diff --git a/.travis.yml b/.travis.yml
index 9f44a43f0aca86..9b326e8bf7e143 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,38 +1,33 @@
 language: cpp
 sudo: false
+dist: trusty
 matrix:
   include:
     - os: linux
       env: ARCH="i686"
-      compiler: "g++-5 -m32"
+      compiler: "g++ -m32"
       addons:
         apt:
-          sources:
-            - ubuntu-toolchain-r-test
           packages:
+            - libssl1.0.0
             - bar
             - time
-            - binutils
-            - gcc-5
-            - g++-5
-            - gcc-5-multilib
-            - g++-5-multilib
+            - gcc-multilib
+            - g++-multilib
             - make:i386
             - libssl-dev:i386
-            - gfortran-5
-            - gfortran-5-multilib
+            - gfortran
+            - gfortran-multilib
     - os: linux
       env: ARCH="x86_64"
-      compiler: "g++-5 -m64"
+      compiler: "g++ -m64"
       addons:
         apt:
-          sources:
-            - ubuntu-toolchain-r-test
           packages:
+            - libssl1.0.0
             - bar
             - time
-            - g++-5
-            - gfortran-5
+            - gfortran
     - os: osx
       env: ARCH="x86_64"
       osx_image: xcode8
@@ -44,7 +39,8 @@ cache:
 branches:
   only:
     - master
-    - /release-.*/
+    - /^release-.*/
+    - /^v\d+\.\d+\.\d+$/
 notifications:
     email: false
     irc:
@@ -60,12 +56,6 @@ before_install:
     - make check-whitespace
     - if [ `uname` = "Linux" ]; then
         contrib/travis_fastfail.sh || exit 1;
-        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;
         BAR="bar -i 30";
         BUILDOPTS="-j3 VERBOSE=1 FORCE_ASSERTIONS=1 LLVM_ASSERTIONS=1";
@@ -83,7 +73,7 @@ before_install:
         BUILDOPTS="-j3 USECLANG=1 LLVM_CONFIG=$(brew --prefix llvm39-julia)/bin/llvm-config LLVM_SIZE=$(brew --prefix llvm39-julia)/bin/llvm-size";
         BUILDOPTS="$BUILDOPTS VERBOSE=1 USE_BLAS64=0 SUITESPARSE_INC=-I$(brew --prefix suite-sparse-julia)/include FORCE_ASSERTIONS=1";
         BUILDOPTS="$BUILDOPTS LIBBLAS=-lopenblas LIBBLASNAME=libopenblas LIBLAPACK=-lopenblas LIBLAPACKNAME=libopenblas";
-        for lib in LLVM SUITESPARSE ARPACK BLAS FFTW LAPACK GMP MPFR PCRE LIBUNWIND; do
+        for lib in LLVM SUITESPARSE ARPACK BLAS LAPACK GMP MPFR PCRE LIBUNWIND; do
             BUILDOPTS="$BUILDOPTS USE_SYSTEM_$lib=1";
         done;
         export LDFLAGS="-L$(brew --prefix openblas-julia)/lib -L$(brew --prefix suite-sparse-julia)/lib";
@@ -96,6 +86,7 @@ before_install:
 script:
     - echo BUILDOPTS=$BUILDOPTS
     - export BUILDOPTS
+    # compile / install dependencies
     - contrib/download_cmake.sh
     - make -C moreutils mispipe
     - make $BUILDOPTS -C base version_git.jl.phony
@@ -113,6 +104,7 @@ script:
           cat deps.log;
           echo "-- end of deps build log -----------------------------------------------";
           false; }
+    # compile / install Julia
     - make $BUILDOPTS NO_GIT=1 prefix=/tmp/julia install | moreutils/ts -s "%.s"
     - make $BUILDOPTS NO_GIT=1 build-stats
     - du -sk /tmp/julia/*
@@ -122,14 +114,25 @@ script:
         done;
       fi
     - cd .. && mv julia julia2
+    # run tests
     - /tmp/julia/bin/julia --precompiled=no -e 'true' &&
         /tmp/julia/bin/julia-debug --precompiled=no -e 'true'
     - /tmp/julia/bin/julia -e 'versioninfo()'
+    - pushd /tmp/julia/share/julia/test
     - export JULIA_CPU_CORES=2 && export JULIA_TEST_MAXRSS_MB=600 &&
-        cd /tmp/julia/share/julia/test &&
         /tmp/julia/bin/julia --check-bounds=yes runtests.jl $TESTSTORUN &&
-        /tmp/julia/bin/julia --check-bounds=yes runtests.jl libgit2-online pkg
-    - cd `dirname $TRAVIS_BUILD_DIR` && mv julia2 julia &&
+        /tmp/julia/bin/julia --check-bounds=yes runtests.jl libgit2-online download pkg
+    - popd
+    # test that the embedding code works on our installation
+    - mkdir /tmp/embedding-test &&
+        make check -C /tmp/julia/share/doc/julia/examples/embedding \
+             JULIA="DYLD_FALLBACK_LIBRARY_PATH='$DYLD_FALLBACK_LIBRARY_PATH' /tmp/julia/bin/julia" \
+             BIN=/tmp/embedding-test \
+             "$(cd julia2 && make print-CC)"
+    # restore initial state and prepare for travis caching
+    - mv julia2 julia &&
         rm -f julia/deps/scratch/libgit2-*/CMakeFiles/CMakeOutput.log
 # uncomment the following if failures are suspected to be due to the out-of-memory killer
 #    - dmesg
+after_success:
+    - cd julia && make -C doc deploy
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 4a050793693b88..ff4654ebf21a10 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,10 +1,10 @@
 # Notes for Julia Contributors
 
-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.
+Hi! If you are new to the Julia community: welcome, and thanks for trying Julia. Please be sure to respect our [community standards](https://julialang.org/community/standards) in all interactions.
 
 ## 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).
+[The learning page](https://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](https://docs.julialang.org/en/latest) covers the language and core library features, and is searchable.
 
 ## Before filing an issue
 
@@ -12,7 +12,7 @@ Hi! If you are new to the Julia community: welcome, and thanks for trying Julia.
 
 - 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). Discuss ideas for libraries at the [Julia Discourse forum](https://discourse.julialang.org/). Doing so will often lead to pointers to existing projects and bring together collaborators with common interests.
+- Library feature requests are generally not accepted on this issue tracker. New libraries should be developed as [packages](https://docs.julialang.org/en/latest/manual/packages#Package-Development-1). Discuss ideas for libraries at the [Julia Discourse forum](https://discourse.julialang.org). Doing so will often lead to pointers to existing projects and bring together collaborators with common interests.
 
 ## Contributor Checklist
 
@@ -26,7 +26,7 @@ Hi! If you are new to the Julia community: welcome, and thanks for trying Julia.
 
 * 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).
 
-* Review discussions on the [Julia Discourse forum](https://discourse.julialang.org/).
+* Review discussions on the [Julia Discourse forum](https://discourse.julialang.org).
 
 * For more detailed tips, read the [submission guide](https://github.com/JuliaLang/julia/blob/master/CONTRIBUTING.md#submitting-contributions) below.
 
@@ -37,26 +37,26 @@ Hi! If you are new to the Julia community: welcome, and thanks for trying Julia.
 A useful bug report filed as a GitHub issue provides information about how to reproduce the error.
 
 1. Before opening a new [GitHub issue](https://github.com/JuliaLang/julia/issues):
-  - Try searching the existing issues or the [Julia Discourse forum](https://discourse.julialang.org/) to see if someone else has already noticed the same problem.
+  - Try searching the existing issues or the [Julia Discourse forum](https://discourse.julialang.org) to see if someone else has already noticed the same problem.
   - Try some simple debugging techniques to help isolate the problem.
     - Try running the code with the debug build of Julia with `make debug`, which produces the `usr/bin/julia-debug`.
     - Consider running `julia-debug` with a debugger such as `gdb` or `lldb`. Obtaining even a simple [backtrace](http://www.unknownroad.com/rtfm/gdbtut/gdbsegfault.html) is very useful.
-    - If Julia segfaults, try following [these debugging tips](http://julia.readthedocs.org/en/latest/devdocs/backtraces/#segfaults-during-bootstrap-sysimg-jl) to help track down the specific origin of the bug.
+    - If Julia segfaults, try following [these debugging tips](https://docs.julialang.org/en/latest/devdocs/backtraces.html#Reporting-and-analyzing-crashes-(segfaults)-1) to help track down the specific origin of the bug.
 
 2. If the problem is caused by a Julia package rather than core Julia, file a bug report with the relevant package author rather than here.
 
 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 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(verbose = 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. 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.
+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 contributions
 
 ### Contributing a Julia package
 
-Julia has a built-in [package manager](https://github.com/JuliaLang/METADATA.jl) based on `git`. A number of [packages](http://pkg.julialang.org/) across many domains are already available for Julia. Developers are encouraged to provide their libraries as a Julia package. The Julia manual provides instructions on [creating Julia packages](http://docs.julialang.org/en/latest/manual/packages/).
+Julia has a built-in [package manager](https://github.com/JuliaLang/METADATA.jl) based on `git`. A number of [packages](http://pkg.julialang.org) across many domains are already available for Julia. Developers are encouraged to provide their libraries as a Julia package. The Julia manual provides instructions on [creating Julia packages](https://docs.julialang.org/en/latest/manual/packages).
 
 For developers who need to wrap C libraries so that they can be called from Julia, the [Clang.jl](https://github.com/ihnorton/Clang.jl) package can help generate the wrappers automatically from the C header files.
 
@@ -71,7 +71,7 @@ to port your package to latest Julia release.
 
 However, porting a package to the latest release may cause the package to break on
 earlier Julia releases. To maintain compatibility across releases, use
-[`Compat.jl`](https://github.com/JuliaLang/Compat.jl/). Find the fix for your package
+[`Compat.jl`](https://github.com/JuliaLang/Compat.jl). Find the fix for your package
 from the README, and specify the minimum version of Compat that provides the fix
 in your REQUIRE file. To find the correct minimum version, refer to
 [this guide](https://github.com/JuliaLang/Compat.jl/#tagging-the-correct-minimum-version-of-compat).
@@ -84,7 +84,7 @@ There are never enough tests. Track [code coverage at Coveralls](https://coveral
 
 2. Browse through the source files and find some untested functionality (highlighted in red) that you think you might be able to write a test for.
 
-3. Write a test that exercises this functionality---you can add your test to one of the existing files, or start a new one, whichever seems most appropriate to you. If you're adding a new test file, make sure you include it in the list of tests in `test/choosetests.jl`. http://julia.readthedocs.org/en/latest/stdlib/test/ may be helpful in explaining how the testing infrastructure works.
+3. Write a test that exercises this functionality---you can add your test to one of the existing files, or start a new one, whichever seems most appropriate to you. If you're adding a new test file, make sure you include it in the list of tests in `test/choosetests.jl`. https://docs.julialang.org/en/latest/stdlib/test may be helpful in explaining how the testing infrastructure works.
 
 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.
 
@@ -112,7 +112,7 @@ from Julia's root directory. This will rebuild the Julia system image, then inst
 >
 > When making changes to any of Julia's documentation it is recommended that you run `make docs` to check the your changes are valid and do not produce any errors before opening a pull request.
 
-Below are outlined the three most common types of documentation changes and the steps required to perform them. Please note that the following instructions do not cover the full range of features provided by Documenter.jl. Refer to [Documenter's documentation](https://juliadocs.github.io/Documenter.jl/stable/) if you encounter anything that is not covered by the sections below.
+Below are outlined the three most common types of documentation changes and the steps required to perform them. Please note that the following instructions do not cover the full range of features provided by Documenter.jl. Refer to [Documenter's documentation](https://juliadocs.github.io/Documenter.jl/stable) if you encounter anything that is not covered by the sections below.
 
 #### Modifying files in `doc/src/`
 
@@ -182,7 +182,7 @@ Examples written within docstrings can be used as testcases known as "doctests"
     "DOCSTRING TEST"
     ```
 
-A doctest needs to match an interactive REPL including the `julia>` prompt. To run doctests you need to run `make -C doc check` from the root directory.
+A doctest needs to match an interactive REPL including the `julia>` prompt. To run doctests you need to run `make -C doc check` from the root directory. It is recommended to add the header `# Examples` above the doctests.
 
 #### News-worthy changes
 
@@ -194,7 +194,7 @@ For new functionality and other substantial changes, add a brief summary to `NEW
 
 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 [Julia Discourse forum](https://discourse.julialang.org/) 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.
+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 [Julia Discourse forum](https://discourse.julialang.org) 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.
 
 Add new code to Julia's base libraries as follows:
 
@@ -216,7 +216,7 @@ or with the `runtests.jl` script, e.g. to run `test/bitarray.jl` and `test/math.
 
     ./usr/bin/julia test/runtests.jl bitarray math
 
-Make sure that [Travis](http://www.travis-ci.org) greenlights the pull request with a [`Good to merge` message](http://blog.travis-ci.com/2012-09-04-pull-requests-just-got-even-more-awesome/).
+Make sure that [Travis](http://www.travis-ci.org) greenlights the pull request with a [`Good to merge` message](http://blog.travis-ci.com/2012-09-04-pull-requests-just-got-even-more-awesome).
 
 ### Code Formatting Guidelines
 
@@ -262,22 +262,22 @@ Make sure that [Travis](http://www.travis-ci.org) greenlights the pull request w
 ## Resources
 
 * Julia
-  - **Homepage:** <http://julialang.org>
-  - **Community:** <http://julialang.org/community/>
+  - **Homepage:** <https://julialang.org>
+  - **Community:** <https://julialang.org/community/>
   - **IRC:** <http://webchat.freenode.net/?channels=Julia>
   - **Source code:** <https://github.com/JuliaLang/julia>
   - **Git clone URL:** <git://github.com/JuliaLang/julia.git>
-  - **Documentation:** <http://julialang.org/manual/>
+  - **Documentation:** <https://julialang.org/manual/>
   - **Status:** <http://status.julialang.org/>
   - **Code coverage:** <https://coveralls.io/r/JuliaLang/julia>
 
 * Design of Julia
   - [Julia: A Fresh Approach to Numerical Computing](http://arxiv.org/pdf/1411.1607v3.pdf)
-  - [Julia: A Fast Dynamic Language for Technical Computing](http://julialang.org/images/julia-dynamic-2012-tr.pdf)
-  - [All Julia Publications](http://julialang.org/publications/)
+  - [Julia: A Fast Dynamic Language for Technical Computing](https://julialang.org/images/julia-dynamic-2012-tr.pdf)
+  - [All Julia Publications](https://julialang.org/publications)
 
 * Using GitHub
   - [Using Julia with GitHub (video)](http://www.youtube.com/watch?v=wnFYV3ZKtOg&feature=youtu.be)
   - [Using Julia on GitHub (notes for video)](https://gist.github.com/2712118#file_Julia_git_pull_request.md)
-  - [General GitHub documentation](http://help.github.com/)
-  - [GitHub pull request documentation](http://help.github.com/send-pull-requests/)
+  - [General GitHub documentation](http://help.github.com)
+  - [GitHub pull request documentation](http://help.github.com/send-pull-requests)
diff --git a/DISTRIBUTING.md b/DISTRIBUTING.md
index cdceecb728e30b..2d0e6916e2037f 100644
--- a/DISTRIBUTING.md
+++ b/DISTRIBUTING.md
@@ -12,9 +12,8 @@ separated most of the notes by OS.
 Note that while the code for Julia is
 [MIT-licensed, with a few exceptions](https://github.com/JuliaLang/julia/blob/master/LICENSE.md),
 the distribution created by the techniques described herein will be
-GPL licensed, as various dependent libraries such as `FFTW` and
-`SuiteSparse` are GPL licensed. We do hope to have a
-non-GPL distribution of Julia in the future.
+GPL licensed, as various dependent libraries such as `SuiteSparse` are
+GPL licensed. We do hope to have a non-GPL distribution of Julia in the future.
 
 Versioning and Git
 ------------------
diff --git a/HISTORY.md b/HISTORY.md
index 03c5a849cd5c20..64383dcfaa848c 100644
--- a/HISTORY.md
+++ b/HISTORY.md
@@ -51,7 +51,7 @@ Experimental language features
 ------------------------------
 
   * Support for
-    [multi-threading](http://docs.julialang.org/en/latest/manual/parallel-computing/#multi-threading-experimental).
+    [multi-threading](https://docs.julialang.org/en/latest/manual/parallel-computing/#multi-threading-experimental).
     Loops with independent iterations can be easily parallelized with the
     `Threads.@threads` macro.
 
@@ -453,7 +453,7 @@ Deprecated or removed
     * `@unix_only` is deprecated in favor of `if is_unix()`
     * `@osx_only` is deprecated in favor of `if is_apple()`
     * `@linux_only` is deprecated in favor of `if is_linux()`
-    * NOTE: Using `@static` could be useful/necessary when used in a function's local scope. See details at the section entitled [Handling Operating System Variation](http://docs.julialang.org/en/latest/manual/handling-operating-system-variation/#man-handling-operating-system-variation) in the manual.
+    * NOTE: Using `@static` could be useful/necessary when used in a function's local scope. See details at the section entitled [Handling Operating System Variation](https://docs.julialang.org/en/latest/manual/handling-operating-system-variation/#man-handling-operating-system-variation) in the manual.
 
 Command-line option changes
 ---------------------------
@@ -510,7 +510,7 @@ New language features
     types instead of to their values. The function then returns an expression forming the
     body of the function to be called at run time ([#7311]).
 
-  * [Documentation system](http://docs.julialang.org/en/latest/manual/documentation/)
+  * [Documentation system](https://docs.julialang.org/en/latest/manual/documentation/)
     for functions, methods, types and macros in packages and user code ([#8791]).
 
   * The syntax `function foo end` can be used to introduce a generic function without
@@ -540,11 +540,11 @@ New language features
   * `++` is now parsed as an infix operator, but does not yet have a default definition ([#11030], [#11686]).
 
   * Support for inter-task communication using `Channels` ([#12264]).
-    See http://docs.julialang.org/en/latest/manual/parallel-computing/#channels for details.
+    See https://docs.julialang.org/en/latest/manual/parallel-computing/#channels for details.
 
   * `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.
+    See https://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]).
 
@@ -1745,8 +1745,8 @@ Bugfixes and performance updates
 
 Too numerous to mention.
 
-[packages chapter]: http://docs.julialang.org/en/latest/manual/packages/
-[sorting functions]: http://docs.julialang.org/en/latest/stdlib/sort/
+[packages chapter]: https://docs.julialang.org/en/latest/manual/packages/
+[sorting functions]: https://docs.julialang.org/en/latest/stdlib/sort/
 [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
diff --git a/LICENSE.md b/LICENSE.md
index c81b1ef7ea7f4a..b906f655a58173 100644
--- a/LICENSE.md
+++ b/LICENSE.md
@@ -35,6 +35,7 @@ Julia includes code from the following projects, which have their own licenses:
 - [MUSL](http://git.musl-libc.org/cgit/musl/tree/COPYRIGHT) (for getopt implementation on Windows) [MIT]
 - [MINGW](https://sourceforge.net/p/mingw/mingw-org-wsl/ci/legacy/tree/mingwrt/mingwex/dirname.c) (for dirname implementation on Windows) [MIT]
 - [NetBSD](http://www.netbsd.org/about/redistribution.html) (for setjmp, longjmp, and strptime implementations on Windows) [BSD-3]
+- [Python](https://docs.python.org/2/license.html) (for strtod implementation on Windows) [BSD-3, effectively]
 - [randmtzig.c](https://github.com/JuliaLang/julia/blob/master/test/perf/micro/randmtzig.c) for Gaussian random number generation (for C benchmarks only) [BSD-3]
 
 The Julia language links to the following external libraries, which have their
@@ -55,7 +56,6 @@ their own licenses:
 - [OPENLIBM](https://github.com/JuliaLang/openlibm/blob/master/LICENSE.md) [MIT, BSD-2, ISC]
 - [OPENSPECFUN](https://github.com/JuliaLang/openspecfun) [MIT, public domain]
 - [FADDEEVA](http://ab-initio.mit.edu/Faddeeva) [MIT]
-- [FFTW](http://fftw.org/doc/License-and-Copyright.html) [GPL2+]
 - [GMP](http://gmplib.org/manual/Copying.html#Copying) [LGPL3+ or GPL2+]
 - [LIBGIT2](https://github.com/libgit2/libgit2/blob/development/COPYING) [GPL2+ with unlimited linking exception]
 - [CURL](https://curl.haxx.se/docs/copyright.html) [MIT/X derivative]
@@ -70,10 +70,11 @@ their own licenses:
 
 The following components of Julia's standard library have separate licenses:
 
-- base/fftw.jl (see [FFTW](http://fftw.org/doc/License-and-Copyright.html))
-- base/linalg/umfpack.jl (see [SUITESPARSE](http://faculty.cse.tamu.edu/davis/suitesparse.html))
-- base/linalg/cholmod.jl (see [SUITESPARSE](http://faculty.cse.tamu.edu/davis/suitesparse.html))
-- base/special/exp.jl (see [FREEBSD MSUN](https://github.com/freebsd/freebsd) [FreeBSD/2-clause BSD/Simplified BSD License])
+- base/grisu/* (see [double-conversion](https://github.com/google/double-conversion/blob/master/LICENSE))
+- base/sparse/umfpack.jl (see [SUITESPARSE](http://faculty.cse.tamu.edu/davis/suitesparse.html))
+- base/sparse/cholmod.jl (see [SUITESPARSE](http://faculty.cse.tamu.edu/davis/suitesparse.html))
+- base/special/exp.jl (see [FDLIBM](http://www.netlib.org/fdlibm/e_exp.c) [Freely distributable with preserved copyright notice])
+- base/special/rem_pio2.jl (see [FDLIBM](http://www.netlib.org/fdlibm/e_rem_pio2.c) [Freely distributable with preserved copyright notice])
 
 
 Julia's build process uses the following external tools:
diff --git a/Make.inc b/Make.inc
index abad5fe879cce6..cf80fc05746fd9 100644
--- a/Make.inc
+++ b/Make.inc
@@ -1,4 +1,5 @@
 # -*- mode: makefile-gmake -*-
+# vi:syntax=make
 
 ## Note:
 ##   It is generally preferable to change these options, for
@@ -25,6 +26,7 @@ OPENBLAS_USE_THREAD:=1
 # Use libraries available on the system instead of building them
 USE_SYSTEM_LLVM:=0
 USE_SYSTEM_LIBUNWIND:=0
+DISABLE_LIBUNWIND:=0
 USE_SYSTEM_PCRE:=0
 USE_SYSTEM_LIBM:=0
 USE_SYSTEM_OPENLIBM:=0
@@ -33,7 +35,6 @@ 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
@@ -52,8 +53,6 @@ USE_LLVM_SHLIB := 1
 ## Settings for various Intel tools
 # Set to 1 to use MKL
 USE_INTEL_MKL ?= 0
-# Set to 1 to use MKL FFT
-USE_INTEL_MKL_FFT ?= 0
 # Set to 1 to use Intel LIBM
 USE_INTEL_LIBM ?= 0
 # Set to 1 to enable profiling with Intel VTune Amplifier
@@ -177,7 +176,7 @@ endif
 USE_GPL_LIBS ?= 1
 
 # Directories where said libraries get installed to
-prefix ?= $(abspath julia-$(JULIA_COMMIT))
+prefix ?= $(BUILDROOT)/julia-$(JULIA_COMMIT)
 bindir := $(prefix)/bin
 libdir := $(prefix)/lib
 libexecdir := $(prefix)/libexec
@@ -230,14 +229,16 @@ INSTALL_M := $(JULIAHOME)/contrib/install.sh 755
 LLVMROOT := $(build_prefix)
 LLVM_ASSERTIONS := 0
 LLVM_DEBUG := 0
-#LLVM_USE_CMAKE: defined in deps/llvm-ver.mk as it depends on LLVM_VER_SHORT
 # set to 1 to get clang and compiler-rt
 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
+
+# Options to enable Polly and its code-generation options
 USE_POLLY := 0
-USE_POLLY_OPENMP := 0
+USE_POLLY_OPENMP := 0  # Enable OpenMP code-generation
+USE_POLLY_ACC := 0     # Enable GPU code-generation
 
 # Cross-compile
 #XC_HOST := i686-w64-mingw32
@@ -316,9 +317,13 @@ JULIACODEGEN := LLVM
 
 # flag for disabling assertions
 ifeq ($(FORCE_ASSERTIONS), 1)
+# C++ code needs to include LLVM header with the same assertion flag as LLVM
+# Use this flag to re-enable assertion in our code after all the LLVM headers are included
+CXX_DISABLE_ASSERTION :=
 DISABLE_ASSERTIONS :=
 else
-DISABLE_ASSERTIONS := -DNDEBUG
+CXX_DISABLE_ASSERTION := -DJL_NDEBUG
+DISABLE_ASSERTIONS := -DNDEBUG -DJL_NDEBUG
 endif
 
 # Compiler specific stuff
@@ -515,6 +520,33 @@ ifeq (exists, $(shell [ -e $(BUILDROOT)/Make.user ] && echo exists ))
 include $(BUILDROOT)/Make.user
 endif
 
+# A bit of a kludge to work around libraries linking to FreeBSD's outdated system libgcc_s
+# Instead, let's link to the libgcc_s corresponding to the installation of gfortran
+ifeq ($(OS),FreeBSD)
+ifneq (,$(findstring gfortran,$(FC)))
+
+# First let's figure out what version of GCC we're dealing with
+_GCCMAJOR := $(shell $(FC) -dumpversion | cut -d'.' -f1)
+_GCCMINOR := $(shell $(FC) -dumpversion | cut -d'.' -f2)
+
+# The ports system uses major and minor for GCC < 5 (e.g. gcc49 for GCC 4.9), otherwise major only
+ifeq ($(_GCCMAJOR),4)
+  _GCCVER := $(_GCCMAJOR)$(_GCCMINOR)
+else
+  _GCCVER := $(_GCCMAJOR)
+endif
+
+# Allow the user to specify this in Make.user
+GCCPATH ?= $(LOCALBASE)/lib/gcc$(_GCCVER)
+
+LDFLAGS += -L$(build_libdir) -L$(GCCPATH) -Wl,-rpath,$(build_libdir) -Wl,-rpath,$(GCCPATH)
+
+# This ensures we get the right RPATH even if we're missing FFLAGS somewhere
+FC += -Wl,-rpath=$(GCCPATH)
+
+endif # gfortran
+endif # FreeBSD
+
 ifneq ($(CC_BASE)$(CXX_BASE),$(shell echo $(CC) | cut -d' ' -f1)$(shell echo $(CXX) | cut -d' ' -f1))
     $(error Forgot override directive on CC or CXX in Make.user? Cowardly refusing to build)
 endif
@@ -529,12 +561,7 @@ SANITIZE_LDFLAGS := -fsanitize=address
 endif
 JCXXFLAGS += $(SANITIZE_OPTS)
 JCFLAGS += $(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)
+JLDFLAGS += $(SANITIZE_LDFLAGS)
 endif
 
 TAR := $(shell which gtar 2>/dev/null || which tar 2>/dev/null)
@@ -656,6 +683,7 @@ ifneq (,$(filter $(ARCH), powerpc64le ppc64le))
 JCFLAGS += -fsigned-char
 OPENBLAS_DYNAMIC_ARCH:=0
 OPENBLAS_TARGET_ARCH:=POWER8
+BINARY:=64
 # GCC doesn't do -march= on ppc64le
 MARCH=
 endif
@@ -732,6 +760,8 @@ endif
 
 ifeq ($(OS),WINNT)
 LIBUNWIND:=
+else ifneq ($(DISABLE_LIBUNWIND), 0)
+LIBUNWIND:=
 else
 ifeq ($(USE_SYSTEM_LIBUNWIND), 1)
 ifneq ($(OS),Darwin)
@@ -827,14 +857,6 @@ LIBLAPACKNAME := liblapack
 endif
 endif
 
-ifeq ($(OS), WINNT)
-LIBFFTWNAME := libfftw3
-LIBFFTWFNAME := libfftw3f
-else
-LIBFFTWNAME := libfftw3_threads
-LIBFFTWFNAME := libfftw3f_threads
-endif
-
 ifeq ($(USE_SYSTEM_LIBM), 1)
 LIBM := -lm
 LIBMNAME := libm
@@ -934,7 +956,16 @@ endif
 
 ifeq ($(OS), FreeBSD)
 JLDFLAGS := -Wl,-Bdynamic
-OSLIBS += -lelf -lkvm -lrt -Wl,--export-dynamic -Wl,--version-script=$(JULIAHOME)/src/julia.expmap $(NO_WHOLE_ARCHIVE) $(LIBUNWIND)
+OSLIBS += -lelf -lkvm -lrt
+
+# Tweak order of libgcc_s in DT_NEEDED,
+# make it loaded first to
+# prevent from linking to outdated system libs.
+# See #21788
+OSLIBS += -lgcc_s
+
+OSLIBS += -Wl,--export-dynamic -Wl,--version-script=$(JULIAHOME)/src/julia.expmap \
+	$(NO_WHOLE_ARCHIVE) $(LIBUNWIND)
 endif
 
 ifeq ($(OS), Darwin)
@@ -980,6 +1011,10 @@ ifeq ($(USE_OPROFILE_JITEVENTS), 1)
 JCPPFLAGS += -DJL_USE_OPROFILE_JITEVENTS
 endif
 
+ifeq ($(DISABLE_LIBUNWIND), 1)
+JCPPFLAGS += -DJL_DISABLE_LIBUNWIND
+endif
+
 # Intel libraries
 
 ifeq ($(USE_INTEL_LIBM), 1)
@@ -997,9 +1032,16 @@ MKLLIB := $(MKLROOT)/lib/ia32
 endif
 USE_SYSTEM_BLAS:=1
 USE_SYSTEM_LAPACK:=1
+ifeq ($(OS), WINNT)
+LIBBLASNAME := mkl_rt
+LIBLAPACKNAME := mkl_rt
+# work around libtool issue with arpack
+MKL_LDFLAGS := -L$(MKLLIB) -Wl,-lmkl_rt
+else
 LIBBLASNAME := libmkl_rt
 LIBLAPACKNAME := libmkl_rt
 MKL_LDFLAGS := -L$(MKLLIB) -lmkl_rt
+endif
 ifneq ($(strip $(MKLLIB)),)
   ifeq ($(OS), Linux)
     RPATH_MKL := -Wl,-rpath,$(MKLLIB)
@@ -1011,12 +1053,6 @@ LIBBLAS   := $(MKL_LDFLAGS)
 LIBLAPACK := $(MKL_LDFLAGS)
 endif
 
-ifeq ($(USE_INTEL_MKL_FFT), 1)
-USE_SYSTEM_FFTW := 1
-LIBFFTWNAME := libmkl_rt
-LIBFFTWFNAME := libmkl_rt
-endif
-
 ifeq ($(HAVE_SSP),1)
 JCPPFLAGS += -DHAVE_SSP=1
 ifeq ($(USEGCC),1)
@@ -1057,8 +1093,14 @@ endif
 # Custom libcxx
 ifeq ($(BUILD_CUSTOM_LIBCXX),1)
 LDFLAGS += -L$(build_libdir)
-CXXLDFLAGS += -L$(build_libdir) -lc++abi -stdlib=libc++ -lc++
-CPPFLAGS += -I$(build_includedir)/c++/v1
+CXXLDFLAGS += -L$(build_libdir) -lc++abi -lc++
+ifeq ($(USECLANG),1)
+CXXLDFLAGS += -stdlib=libc++
+else
+ifeq ($(USEGCC),1)
+$(error BUILD_CUSTOM_LIBCXX is currently only supported with Clang. Try setting BUILD_CUSTOM_LIBCXX=0)
+endif
+endif # Clang
 CUSTOM_LD_LIBRARY_PATH := LD_LIBRARY_PATH="$(build_libdir)"
 ifeq ($(USEICC),1)
 CXXFLAGS += -cxxlib-nostd -static-intel
diff --git a/Makefile b/Makefile
index 0e28cc87b7628e..05b08bed94a49b 100644
--- a/Makefile
+++ b/Makefile
@@ -21,7 +21,7 @@ all: debug release
 # sort is used to remove potential duplicates
 DIRS := $(sort $(build_bindir) $(build_depsbindir) $(build_libdir) $(build_private_libdir) $(build_libexecdir) $(build_includedir) $(build_includedir)/julia $(build_sysconfdir)/julia $(build_datarootdir)/julia $(build_man1dir))
 ifneq ($(BUILDROOT),$(JULIAHOME))
-BUILDDIRS := $(BUILDROOT) $(addprefix $(BUILDROOT)/,base src ui doc deps test test/perf)
+BUILDDIRS := $(BUILDROOT) $(addprefix $(BUILDROOT)/,base src ui doc deps test test/perf examples examples/embedding)
 BUILDDIRMAKE := $(addsuffix /Makefile,$(BUILDDIRS))
 DIRS := $(DIRS) $(BUILDDIRS)
 $(BUILDDIRMAKE): | $(BUILDDIRS)
@@ -62,12 +62,16 @@ $(BUILDROOT)/doc/_build/html/en/index.html: $(shell find $(BUILDROOT)/base $(BUI
 CLEAN_TARGETS += clean-docdir
 clean-docdir:
 	@-rm -fr $(abspath $(build_docdir))
-$(build_prefix)/.examples: $(wildcard $(JULIAHOME)/examples/*.jl) $(shell find $(JULIAHOME)/examples/clustermanager)
+
+$(build_prefix)/.examples: $(wildcard $(JULIAHOME)/examples/*.jl) \
+                           $(shell find $(JULIAHOME)/examples/clustermanager) \
+                           $(shell find $(JULIAHOME)/examples/embedding)
 	@echo Copying in usr/share/doc/julia/examples
 	@-rm -fr $(build_docdir)/examples
 	@mkdir -p $(build_docdir)/examples
 	@cp -R $(JULIAHOME)/examples/*.jl $(build_docdir)/examples/
 	@cp -R $(JULIAHOME)/examples/clustermanager $(build_docdir)/examples/
+	@cp -R $(JULIAHOME)/examples/embedding $(build_docdir)/examples
 	@echo 1 > $@
 
 julia-symlink: julia-ui-$(JULIA_BUILD_MODE)
@@ -151,7 +155,7 @@ release-candidate: release testall
 	@echo 6. Clean out old .tar.gz files living in deps/, "\`git clean -fdx\`" seems to work	#"`
 	@echo 7. Replace github release tarball with tarballs created from make light-source-dist and make full-source-dist
 	@echo 8. Follow packaging instructions in DISTRIBUTING.md to create binary packages for all platforms
-	@echo 9. Upload to AWS, update http://julialang.org/downloads and http://status.julialang.org/stable links
+	@echo 9. Upload to AWS, update https://julialang.org/downloads and http://status.julialang.org/stable links
 	@echo 10. Update checksums on AWS for tarball and packaged binaries
 	@echo 11. Announce on mailing lists
 	@echo 12. Change master to release-0.X in base/version.jl and base/version_git.sh as in 4cb1e20
@@ -182,6 +186,7 @@ $(build_private_libdir)/%.$(SHLIB_EXT): $(build_private_libdir)/%.o
 
 CORE_SRCS := $(addprefix $(JULIAHOME)/, \
 		base/boot.jl base/coreimg.jl \
+		base/docs/core.jl \
 		base/abstractarray.jl \
 		base/array.jl \
 		base/bool.jl \
@@ -241,11 +246,6 @@ JL_PRIVATE_LIBS := ccalltest
 ifeq ($(USE_GPL_LIBS), 1)
 JL_PRIVATE_LIBS += suitesparse_wrapper
 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
@@ -323,6 +323,7 @@ $(eval $(call std_dll,gcc_s_seh-1))
 endif
 $(eval $(call std_dll,ssp-0))
 $(eval $(call std_dll,winpthread-1))
+$(eval $(call std_dll,atomic-1))
 endif
 define stringreplace
 	$(build_depsbindir)/stringreplace $$(strings -t x - $1 | grep '$2' | awk '{print $$1;}') '$3' 255 "$(call cygpath_w,$1)"
@@ -330,7 +331,7 @@ endef
 
 install: $(build_depsbindir)/stringreplace $(BUILDROOT)/doc/_build/html/en/index.html
 	@$(MAKE) $(QUIET_MAKE) all
-	@for subdir in $(bindir) $(libexecdir) $(datarootdir)/julia/site/$(VERSDIR) $(docdir) $(man1dir) $(includedir)/julia $(libdir) $(private_libdir) $(sysconfdir); do \
+	@for subdir in $(bindir) $(datarootdir)/julia/site/$(VERSDIR) $(docdir) $(man1dir) $(includedir)/julia $(libdir) $(private_libdir) $(sysconfdir); do \
 		mkdir -p $(DESTDIR)$$subdir; \
 	done
 
@@ -341,10 +342,8 @@ ifeq ($(OS),WINNT)
 	-$(INSTALL_M) $(build_libdir)/libjulia-debug.dll.a $(DESTDIR)$(libdir)/
 	-$(INSTALL_M) $(build_bindir)/libopenlibm.dll.a $(DESTDIR)$(libdir)/
 else
-	-cp -a $(build_libexecdir) $(DESTDIR)$(prefix)
-
-	# Copy over .dSYM directories directly
 ifeq ($(OS),Darwin)
+	# Copy over .dSYM directories directly
 	-cp -a $(build_libdir)/*.dSYM $(DESTDIR)$(libdir)
 	-cp -a $(build_private_libdir)/*.dSYM $(DESTDIR)$(private_libdir)
 endif
@@ -401,9 +400,9 @@ ifneq ($(private_libdir_rel),$(build_private_libdir_rel))
 ifeq ($(OS), Darwin)
 	for julia in $(DESTDIR)$(bindir)/julia* ; do \
 		install_name_tool -rpath @executable_path/$(build_private_libdir_rel) @executable_path/$(private_libdir_rel) $$julia; \
-		install_name_tool -rpath @executable_path/$(build_libdir_rel) @executable_path/$(libdir_rel) $$julia; \
+		install_name_tool -add_rpath @executable_path/$(build_libdir_rel) @executable_path/$(libdir_rel) $$julia; \
 	done
-else ifeq ($(OS), Linux)
+else ifneq (,$(findstring $(OS),Linux FreeBSD))
 	for julia in $(DESTDIR)$(bindir)/julia* ; do \
 		patchelf --set-rpath '$$ORIGIN/$(private_libdir_rel):$$ORIGIN/$(libdir_rel)' $$julia; \
 	done
@@ -458,7 +457,7 @@ endif
 
 ifeq ($(OS), WINNT)
 	[ ! -d $(JULIAHOME)/dist-extras ] || ( cd $(JULIAHOME)/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 libwinpthread-1.dll $(BUILDROOT)/julia-$(JULIA_COMMIT)/bin )
+		cp 7z.exe 7z.dll libexpat-1.dll zlib1.dll $(BUILDROOT)/julia-$(JULIA_COMMIT)/bin )
 ifeq ($(USE_GPL_LIBS), 1)
 	[ ! -d $(JULIAHOME)/dist-extras ] || ( cd $(JULIAHOME)/dist-extras && \
 		cp busybox.exe $(BUILDROOT)/julia-$(JULIA_COMMIT)/bin )
@@ -480,8 +479,10 @@ else
 endif
 	rm -fr $(BUILDROOT)/julia-$(JULIA_COMMIT)
 
-# this target does not accept BUILDROOT
-light-source-dist.tmp: $(JULIAHOME)/doc/_build/html
+light-source-dist.tmp: $(BUILDROOT)/doc/_build/html/en/index.html
+ifneq ($(BUILDROOT),$(JULIAHOME))
+	$(error make light-source-dist does not work in out-of-tree builds)
+endif
 	# Save git information
 	-@$(MAKE) -C $(JULIAHOME)/base version_git.jl.phony
 
@@ -491,18 +492,16 @@ light-source-dist.tmp: $(JULIAHOME)/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)); \
 	sed -e "s_.*_$$DIRNAME/&_" light-source-dist.tmp > light-source-dist.tmp1; \
-	cd ../ && tar -cz -T $$DIRNAME/light-source-dist.tmp1 --no-recursion -f $$DIRNAME/julia-$(JULIA_VERSION)_$(JULIA_COMMIT).tar.gz
+	cd ../ && tar -cz --no-recursion -T $$DIRNAME/light-source-dist.tmp1 -f $$DIRNAME/julia-$(JULIA_VERSION)_$(JULIA_COMMIT).tar.gz
 
 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
@@ -514,7 +513,7 @@ full-source-dist: light-source-dist.tmp
 	# Prefix everything with the current directory name (usually "julia"), then create tarball
 	DIRNAME=$$(basename $$(pwd)); \
 	sed -e "s_.*_$$DIRNAME/&_" full-source-dist.tmp > full-source-dist.tmp1; \
-	cd ../ && tar -cz -T $$DIRNAME/full-source-dist.tmp1 --no-recursion -f $$DIRNAME/julia-$(JULIA_VERSION)_$(JULIA_COMMIT)-full.tar.gz
+	cd ../ && tar -cz --no-recursion -T $$DIRNAME/full-source-dist.tmp1 -f $$DIRNAME/julia-$(JULIA_VERSION)_$(JULIA_COMMIT)-full.tar.gz
 
 clean: | $(CLEAN_TARGETS)
 	@-$(MAKE) -C $(BUILDROOT)/base clean
@@ -522,6 +521,7 @@ clean: | $(CLEAN_TARGETS)
 	@-$(MAKE) -C $(BUILDROOT)/src clean
 	@-$(MAKE) -C $(BUILDROOT)/ui clean
 	@-$(MAKE) -C $(BUILDROOT)/test clean
+	@-$(MAKE) -C $(BUILDROOT)/examples clean
 	-rm -f $(BUILDROOT)/julia
 	-rm -f $(BUILDROOT)/*.tar.gz
 	-rm -f $(build_depsbindir)/stringreplace \
@@ -548,13 +548,18 @@ distcleanall: cleanall
 	test testall testall1 test clean distcleanall cleanall clean-* \
 	run-julia run-julia-debug run-julia-release run \
 	install binary-dist light-source-dist.tmp light-source-dist \
-	dist full-source-dist source-dist
+	dist full-source-dist source-dist examples
 
 test: check-whitespace $(JULIA_BUILD_MODE)
 	@$(MAKE) $(QUIET_MAKE) -C $(BUILDROOT)/test default JULIA_BUILD_MODE=$(JULIA_BUILD_MODE)
 
+ifeq ($(JULIA_BUILD_MODE),release)
+JULIA_SYSIMG=$(build_private_libdir)/sys$(JULIA_LIBSUFFIX).$(SHLIB_EXT)
+else
+JULIA_SYSIMG=$(build_private_libdir)/sys-$(JULIA_BUILD_MODE)$(JULIA_LIBSUFFIX).$(SHLIB_EXT)
+endif
 testall: check-whitespace $(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)
+	cp $(JULIA_SYSIMG) $(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)
@@ -582,8 +587,8 @@ ifneq (,$(filter $(ARCH), i386 i486 i586 i686))
 	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_42.2 \
-		"mingw32-libgfortran3 mingw32-libquadmath0 mingw32-libstdc++6 mingw32-libgcc_s_sjlj1 mingw32-libssp0 mingw32-libwinpthread1 mingw32-libexpat1 mingw32-zlib1" && \
+	../contrib/windows/winrpm.sh http://download.opensuse.org/repositories/windows:/mingw:/win32/openSUSE_Leap_42.2 \
+		"mingw32-libexpat1 mingw32-zlib1" && \
 	cp usr/i686-w64-mingw32/sys-root/mingw/bin/*.dll .
 else ifeq ($(ARCH),x86_64)
 	cd $(JULIAHOME)/dist-extras && \
@@ -591,15 +596,15 @@ else ifeq ($(ARCH),x86_64)
 	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_42.2 \
-		"mingw64-libgfortran3 mingw64-libquadmath0 mingw64-libstdc++6 mingw64-libgcc_s_seh1 mingw64-libssp0 mingw64-libwinpthread1 mingw64-libexpat1 mingw64-zlib1" && \
+	../contrib/windows/winrpm.sh http://download.opensuse.org/repositories/windows:/mingw:/win64/openSUSE_Leap_42.2 \
+		"mingw64-libexpat1 mingw64-zlib1" && \
 	cp usr/x86_64-w64-mingw32/sys-root/mingw/bin/*.dll .
 else
 	$(error no win-extras target for ARCH=$(ARCH))
 endif
 	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) https://storage.googleapis.com/google-code-archive-downloads/v2/code.google.com/unsis/nsis-2.46.5-Unicode-setup.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 && \
@@ -618,7 +623,9 @@ LLVM_SIZE := $(build_depsbindir)/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))
+	$(call spawn,$(LLVM_SIZE) -A $(call cygpath_w,$(build_private_libdir)/sys.$(SHLIB_EXT)) \
+		$(call cygpath_w,$(build_shlibdir)/libjulia.$(SHLIB_EXT)) \
+		$(call cygpath_w,$(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 '')
diff --git a/NEWS.md b/NEWS.md
index 0ec5525ed9f2bd..7e461a30be6a32 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -1,3 +1,245 @@
+Julia v0.7.0 Release Notes
+==========================
+
+New language features
+---------------------
+
+  * Local variables can be tested for being defined
+    using the new `@isdefined variable` macro ([#22281]).
+
+Language changes
+----------------
+
+  * The syntax for parametric methods, `function f{T}(x::T)`, has been
+    changed to `function f(x::T) where {T}` ([#11310]).
+
+  * The syntax `1.+2` is deprecated, since it is ambiguous: it could mean either
+    `1 .+ 2` (the current meaning) or `1. + 2` ([#19089]).
+
+  * In string and character literals, backslash `\` may no longer
+    precede unrecognized escape characters ([#22800]).
+
+  * Declaring arguments as `x::ANY` to avoid specialization has been replaced
+    by `@nospecialize x`. ([#22666]).
+
+  * Keyword argument default values are now evaluated in successive scopes ---
+    the scope for each expression includes only previous keyword arguments, in
+    left-to-right order ([#17240]).
+
+  * The parsing of `1<<2*3` as `1<<(2*3)` is deprecated, and will change to
+    `(1<<2)*3` in a future version ([#13079]).
+
+  * `{ }` expressions now use `braces` and `bracescat` as expression heads instead
+    of `cell1d` and `cell2d`, and parse similarly to `vect` and `vcat` ([#8470]).
+
+Breaking changes
+----------------
+
+This section lists changes that do not have deprecation warnings.
+
+  * `ntuple(f, n::Integer)` throws `ArgumentError` if `n` is negative.
+    Previously an empty tuple was returned ([#21697]).
+
+  * Juxtaposing string literals (e.g. `"x"y`) is now a syntax error ([#20575]).
+
+  * `@__DIR__` returns the current working directory rather than `nothing` when not run
+    from a file ([#21759]).
+
+  * `@__FILE__` and `@__DIR__` return information relative to the file that it was parsed from,
+    rather than from the task-local `SOURCE_PATH` global when it was expanded.
+
+  * All macros receive an extra argument `__source__::LineNumberNode` which describes the
+    parser location in the source file for the `@` of the macro call.
+    It can be accessed as a normal argument variable in the body of the macro.
+    This is implemented by inserting an extra leading argument into the
+    `Expr(:macrocall, :@name, LineNumberNode(...), args...)`
+    surface syntax. ([#21746])
+
+  * Passing the same keyword argument multiple times is now a syntax error ([#16937]).
+
+  * `getsockname` on a `TCPSocket` now returns the locally bound address and port
+    of the socket. Previously the address of the remote endpoint was being
+    returned ([#21825]).
+
+  * Using `ARGS` within the ~/.juliarc.jl or within a .jl file loaded with `--load` will no
+    longer contain the script name as the first argument. Instead the script name will be
+    assigned to `PROGRAM_FILE`. ([#22092])
+
+  * The format for a `ClusterManager` specifying the cookie on the command line is now
+    `--worker=<cookie>`. `--worker <cookie>` will not work as it is now an optional argument.
+
+  * The representation of `CartesianRange` has changed to a
+    tuple-of-AbstractUnitRanges; the `start` and `stop` fields are no
+    longer present. Use `first(R)` and `last(R)` to obtain
+    start/stop. ([#20974])
+
+  * The `Diagonal` type definition has changed from `Diagonal{T}` to
+    `Diagonal{T,V<:AbstractVector{T}}` ([#22718]).
+
+  * Spaces are no longer allowed between `@` and the name of a macro in a macro call ([#22868]).
+
+  * Juxtaposition of a non-literal with a macro call (`x@macro`) is no longer valid syntax ([#22868]).
+
+  * On a cluster, all files are now loaded from the local file system rather than node 1 ([#22588]).
+    To load the same file everywhere from node 1, one possible alternative is to broadcast a call to `include_string`:
+    `@everywhere include_string(Main, $(read("filename", String)), "filename")`.
+    Improving upon this API is left as an opportunity for packages.
+
+  * `randperm(n)` and `randcycle(n)` now always return a `Vector{Int}` (independent of
+    the type of `n`). Use the corresponding mutating functions `randperm!` and `randcycle!`
+    to control the array type ([#22723]).
+
+  * Worker-worker connections are setup lazily for an `:all_to_all` topology. Use keyword
+    arg `lazy=false` to force all connections to be setup during a `addprocs` call. ([#22814])
+
+Library improvements
+--------------------
+
+  * The functions `strip`, `lstrip` and `rstrip` now return `SubString` ([#22496]).
+
+  * The functions `base` and `digits` digits now accept a negative
+    base (like `ndigits` did) ([#21692]).
+
+  * The function `randn` now accepts complex arguments (`Complex{T <: AbstractFloat}`)
+    ([#21973]).
+
+  * The function `rand` can now pick up random elements from strings, associatives
+    and sets ([#22228], [#21960], [#18155], [#22224]).
+
+  * Method lists are now printed as a numbered list. In addition, the source code of a
+    method can be opened in an editor by entering the corresponding number in the REPL
+    and pressing `^Q` ([#22007]).
+
+  * `getpeername` on a `TCPSocket` returns the address and port of the remote
+    endpoint of the TCP connection ([#21825]).
+
+  * `resize!` and `sizehint!` methods no longer over-reserve memory when the
+    requested array size is more than double of its current size ([#22038]).
+
+  * The `crc32c` function for CRC-32c checksums is now exported ([#22274]).
+
+  * The output of `versioninfo()` is now controlled with keyword arguments ([#21974]).
+
+  * The function `LibGit2.set_remote_url` now always sets both the fetch and push URLs for a
+    git repo. Additionally, the argument order was changed to be consistent with the git
+    command line tool ([#22062]).
+
+  * `logspace` now accepts a `base` keyword argument to specify the base of the logarithmic
+    range. The base defaults to 10 ([#22310]).
+
+  * Added `unique!` which is an inplace version of `unique` ([#20549]).
+
+  * `@test isequal(x, y)` and `@test isapprox(x, y)` now prints an evaluated expression when
+    the test fails ([#22296]).
+
+  * Uses of `Val{c}` in `Base` has been replaced with `Val{c}()`, which is now easily
+    accessible via the `@pure` constructor `Val(c)`. Functions are defined as
+    `f(::Val{c}) = ...` and called by `f(Val(c))`. Notable affected functions include:
+    `ntuple`, `Base.literal_pow`, `sqrtm`, `lufact`, `lufact!`, `qrfact`, `qrfact!`,
+    `cholfact`, `cholfact!`, `_broadcast!`, `reshape`, `cat` and `cat_t`.
+
+  * A new `@macroexpand1` macro for non recursive macro expansion ([#21662]).
+
+  * `Char`s can now be concatenated with `String`s and/or other `Char`s using `*` ([#22532]).
+
+  * `Diagonal` is now parameterized on the type of the wrapped vector. This allows
+    for `Diagonal` matrices with arbitrary `AbstractVector`s ([#22718]).
+
+  * Mutating versions of `randperm` and `randcycle` have been added:
+    `randperm!` and `randcycle!` ([#22723]).
+
+Compiler/Runtime improvements
+-----------------------------
+
+  * The inlining heuristic now models the approximate runtime cost of
+    a method (using some strongly-simplifying assumptions). Functions
+    are inlined unless their estimated runtime cost substantially
+    exceeds the cost of setting up and issuing a subroutine
+    call. ([#22210], [#22732])
+
+Deprecated or removed
+---------------------
+
+  * The keyword `immutable` is fully deprecated to `struct`, and
+    `type` is fully deprecated to `mutable struct` ([#19157], [#20418]).
+
+  * The method `srand(rng, filename, n=4)` has been deprecated ([#21359]).
+
+  * The `cholfact`/`cholfact!` methods that accepted an `uplo` symbol have been deprecated
+    in favor of using `Hermitian` (or `Symmetric`) views ([#22187], [#22188]).
+
+  * `isposdef(A::AbstractMatrix, UL::Symbol)` and `isposdef!(A::AbstractMatrix, UL::Symbol)`
+    have been deprecated in favor of `isposdef(Hermitian(A, UL))` and `isposdef!(Hermitian(A, UL))`
+    respectively ([#22245]).
+
+  * The `bkfact`/`bkfact!` methods that accepted `uplo` and `issymmetric` symbols have been deprecated
+    in favor of using `Hermitian` (or `Symmetric`) views ([#22605]).
+
+  * The function `current_module` is deprecated and replaced with `@__MODULE__` ([#22064]).
+    This caused the deprecation of some reflection methods (such as `macroexpand` and `isconst`),
+    which now require a module argument.
+    And it caused the bugfix of other default arguments to use the Main module (including `whos`, `which`).
+
+  * The `Operators` module is deprecated. Instead, import required operators explicitly
+    from `Base`, e.g. `import Base: +, -, *, /` ([#22251]).
+
+  * Bindings to the FFTW library have been removed from Base. The DFT framework for building FFT
+    implementations is now in AbstractFFTs.jl, the bindings to the FFTW library are in FFTW.jl,
+    and the Base signal processing functions which used FFTs are now in DSP.jl ([#21956]).
+
+  * The `corrected` positional argument to `cov` has been deprecated in favor of
+    a keyword argument with the same name ([#21709]).
+
+  * Omitting spaces around the `?` and the `:` tokens in a ternary expression has been deprecated.
+    Ternaries must now include some amount of whitespace, e.g. `x ? a : b` rather than
+    `x?a:b` ([#22523] and [#22712]).
+
+  * `?` can no longer be used as an identifier name ([#22712])
+
+  * The method `replace(s::AbstractString, pat, r, count)` with `count <= 0` is deprecated
+    in favor of `replace(s::AbstractString, pat, r, typemax(Int))` ([#22325]).
+
+  * `read(io, type, dims)` is deprecated to `read!(io, Array{type}(dims))` ([#21450]).
+
+  * `read(::IO, ::Ref)` is now a method of `read!`, since it mutates its `Ref` argument ([#21592]).
+
+  * `Bidiagonal` constructors now use a `Symbol` (`:U` or `:L`) for the upper/lower
+    argument, instead of a `Bool` or a `Char` ([#22703]).
+
+  * Calling `nfields` on a type to find out how many fields its instances have is deprecated.
+    Use `fieldcount` instead. Use `nfields` only to get the number of fields in a specific object ([#22350]).
+
+  * `fieldnames` now operates only on types. To get the names of fields in an object, use
+    `fieldnames(typeof(x))` ([#22350]).
+
+  * `InexactError` and `DomainError` now take
+    arguments. `InexactError(func::Symbol, type, -3)` now prints as
+    `ERROR: InexactError: func(type, -3)`, and `DomainError(val,
+    [msg])` prints as `ERROR: DomainError with val:\nmsg`. ([#20005],
+    [#22751])
+
+  * The operating system identification functions: `is_linux`, `is_bsd`, `is_apple`, `is_unix`,
+    and `is_windows`, have been deprecated in favor of `Sys.islinux`, `Sys.isbsd`, `Sys.isapple`,
+    `Sys.isunix`, and `Sys.iswindows`, respectively ([#22182]).
+
+  * The forms of `read`, `readstring`, and `eachline` that accepted both a `Cmd` object and an
+    input stream are deprecated. Use e.g. `read(pipeline(stdin, cmd))` instead ([#22762]).
+
+  * The unexported type `AbstractIOBuffer` has been renamed to `GenericIOBuffer` ([#17360] [#22796]).
+
+  * The method `String(io::IOBuffer)` is deprecated to `String(take!(copy(io)))` ([#21438]).
+
+  * The function `readstring` is deprecated in favor of `read(io, String)` ([#22793])
+
+  * The function `showall` is deprecated. Showing entire values is the default, unless an
+    `IOContext` specifying `:limit=>true` is in use ([#22847]).
+
+  * `issubtype` has been deprecated in favor of `<:` (which used to be an alias for `issubtype`).
+
+  * Calling `write` on non-isbits arrays is deprecated in favor of explicit loops or
+    `serialize` ([#6466]).
+
+
 Julia v0.6.0 Release Notes
 ==========================
 
@@ -5,18 +247,22 @@ New language features
 ---------------------
 
   * New type system capabilities ([#8974], [#18457])
-    * Type parameter constraints can refer to previous parameters, e.g.
+
+    + Type parameter constraints can refer to previous parameters, e.g.
       `type Foo{R<:Real, A<:AbstractArray{R}}`. Can also be used in method definitions.
-    * New syntax `Array{T} where T<:Integer`, indicating a union of types over all
+
+    + New syntax `Array{T} where T<:Integer`, indicating a union of types over all
       specified values of `T` (represented by a `UnionAll` type). This provides behavior
       similar to parametric methods or `typealias`, but can be used anywhere a type is
       accepted. This syntax can also be used in method definitions, e.g.
       `function inv(M::Matrix{T}) where T<:AbstractFloat`.
       Anonymous functions can have type parameters via the syntax
       `((x::Array{T}) where T<:Real) -> 2x`.
-    * Implicit type parameters, e.g. `Vector{<:Real}` is equivalent to
+
+    + Implicit type parameters, e.g. `Vector{<:Real}` is equivalent to
       `Vector{T} where T<:Real`, and similarly for `Vector{>:Int}` ([#20414]).
-    * Much more accurate subtype and type intersection algorithms. Method sorting and
+
+    + Much more accurate subtype and type intersection algorithms. Method sorting and
       identification of equivalent and ambiguous methods are improved as a result.
 
 Language changes
@@ -32,13 +278,19 @@ Language changes
     ```
     the syntax `Foo(x) = new(x)` actually defined a constructor for `Foo{T,S}`,
     i.e. the case where the type parameters are specified. For clarity, this
-    definition now must be written as `Foo{T,S}(x) where {T,S<:Real} = new(x)`. ([#11310])
+    definition now must be written as `Foo{T,S}(x) where {T,S<:Real} = new(x)`
+    ([#11310], [#20308]).
 
   * The keywords used to define types have changed ([#19157], [#20418]).
+
     + `immutable` changes to `struct`
+
     + `type` changes to `mutable struct`
+
     + `abstract` changes to `abstract type ... end`
+
     + `bitstype 32 Char` changes to `primitive type Char 32 end`
+
     In 0.6, `immutable` and `type` are still allowed as synonyms without a deprecation
     warning.
 
@@ -46,16 +298,16 @@ Language changes
     nonstandard command literal is like a nonstandard string literal, but the
     syntax uses backquotes (``` ` ```) instead of double quotes, and the
     resulting macro called is suffixed with `_cmd`. For instance, the syntax
-    ``` q`xyz` ``` is equivalent to `@q_cmd "xyz"`. ([#18644])
+    ``` q`xyz` ``` is equivalent to `@q_cmd "xyz"` ([#18644]).
 
   * Nonstandard string and command literals can now be qualified with their
     module. For instance, `Base.r"x"` is now parsed as `Base.@r_str "x"`.
-    Previously, this syntax parsed as an implicit multiplication. ([#18690])
+    Previously, this syntax parsed as an implicit multiplication ([#18690]).
 
   * For every binary operator `⨳`, `a .⨳ b` is now automatically equivalent to
     the `broadcast` call `(⨳).(a, b)`.  Hence, one no longer defines methods
     for `.*` etcetera.  This also means that "dot operations" automatically
-    fuse into a single loop, along with other dot calls `f.(x)`. ([#17623])
+    fuse into a single loop, along with other dot calls `f.(x)` ([#17623]).
     Similarly for unary operators ([#20249]).
 
   * Newly defined methods are no longer callable from the same dynamic runtime
@@ -68,16 +320,15 @@ Language changes
     every function call, operator, and assignment in an expression ([#20321]).
 
   * The identifier `_` can be assigned, but accessing its value is deprecated,
-    allowing this syntax to be used in the future for discarding values ([#9343], [#18251]).
+    allowing this syntax to be used in the future for discarding values ([#9343],
+    [#18251], [#20328]).
 
   * The `typealias` keyword is deprecated, and should be replaced with
-    `Vector{T} = Array{T,1}` or a `const` assignment.
+    `Vector{T} = Array{T,1}` or a `const` assignment ([#20500]).
 
   * Experimental feature: `x^n` for integer literals `n` (e.g. `x^3`
-    or `x^-3`) is now lowered to `x^Val{n}`, to enable compile-time
-    specialization for literal integer exponents ([#20530]).
-    `x^p` for `x::Number` and a literal `p=0,1,2,3` is now lowered to
-    `one(x)`, `x`, `x*x`, and `x*x*x`, respectively ([#20648]).
+    or `x^-3`) is now lowered to `Base.literal_pow(^, x, Val{n})`, to enable
+    compile-time specialization for literal integer exponents ([#20530], [#20889]).
 
 Breaking changes
 ----------------
@@ -86,16 +337,16 @@ This section lists changes that do not have deprecation warnings.
 
   * `readline`, `readlines` and `eachline` return lines without line endings by default.
     You *must* use `readline(s, chomp=false)`, etc. to get the old behavior where
-    returned lines include trailing end-of-line character(s). ([#19944])
+    returned lines include trailing end-of-line character(s) ([#19944]).
 
   * `String`s no longer have a `.data` field (as part of a significant performance
     improvement). Use `Vector{UInt8}(str)` to access a string as a byte array.
     However, allocating the `Vector` object has overhead. You can also use
     `codeunit(str, i)` to access the `i`th byte of a `String`.
     Use `sizeof(str)` instead of `length(str.data)`, and `pointer(str)` instead of
-    `pointer(str.data)`. ([#19449])
+    `pointer(str.data)` ([#19449]).
 
-  * Operations between `Float16` and `Integers` now return `Float16` instead of `Float32`. ([#17261])
+  * Operations between `Float16` and `Integers` now return `Float16` instead of `Float32` ([#17261]).
 
   * Keyword arguments are processed left-to-right: if the same keyword is specified more than
     once, the rightmost occurrence takes precedence ([#17785]).
@@ -112,22 +363,23 @@ This section lists changes that do not have deprecation warnings.
     `broadcast!` or `.=` ([#17623]).
 
   * Operations like `.+` and `.*` on `Range` objects are now generic
-    `broadcast` calls (see above) and produce an `Array`.  If you want
-    a `Range` result, use `+` and `*`, etcetera ([#17623]).
+    `broadcast` calls (see [above](#language-changes)) and produce an `Array`.
+    If you want a `Range` result, use `+` and `*`, etcetera ([#17623]).
 
   * `broadcast` now treats `Ref` (except for `Ptr`) arguments as 0-dimensional
     arrays ([#18965]).
 
   * `broadcast` now handles missing data (`Nullable`s) allowing operations to
     be lifted over mixtures of `Nullable`s and scalars, as if the `Nullable`
-    were like an array with zero or one element. ([#16961], [#19787]).
+    were like an array with zero or one element ([#16961], [#19787]).
 
   * The runtime now enforces when new method definitions can take effect ([#17057]).
     The flip-side of this is that new method definitions should now reliably actually
     take effect, and be called when evaluating new code ([#265]).
 
-  * The array-scalar operations `div`, `mod`, `rem`, `&`, `|`, `xor`, `/`, `\`, `*`, `+`, and `-`
-    now follow broadcast promotion rules ([#19692]).
+  * The array-scalar methods of `/`, `\`, `*`, `+`, and `-` now follow broadcast promotion
+    rules. (Likewise for the now-deprecated array-scalar methods of `div`, `mod`, `rem`,
+    `&`, `|`, and `xor`; see "Deprecated or removed" below.) ([#19692]).
 
   * `broadcast!(f, A)` now calls `f()` for each element of `A`, rather than doing `fill!(A, f())` ([#19722]).
 
@@ -135,19 +387,19 @@ This section lists changes that do not have deprecation warnings.
     removed before `waitfor` seconds. With a `waitfor=0`, `rmprocs` returns immediately
     without waiting for worker exits.
 
-  * `quadgk` has been moved from Base into a separate package. ([#19741])
+  * `quadgk` has been moved from Base into a separate package ([#19741]).
 
   * The `Collections` module has been removed, and all functions defined therein have been
-    moved to the `DataStructures` package. ([#19800])
+    moved to the `DataStructures` package ([#19800]).
 
   * The `RepString` type has been moved to the
     [LegacyStrings.jl package](https://github.com/JuliaArchive/LegacyStrings.jl).
 
   * In macro calls with parentheses, e.g. `@m(a=1)`, assignments are now parsed as
-    `=` expressions, instead of as `kw` expressions. ([#7669])
+    `=` expressions, instead of as `kw` expressions ([#7669]).
 
   * When used as an infix operator, `~` is now parsed as a call to an ordinary operator
-    with assignment precedence, instead of as a macro call. ([#20406])
+    with assignment precedence, instead of as a macro call ([#20406]).
 
   * (µ "micro" and ɛ "latin epsilon") are considered equivalent to
     the corresponding Greek characters in identifiers.  `\varepsilon`
@@ -155,17 +407,17 @@ This section lists changes that do not have deprecation warnings.
 
   * `retry` now inputs the keyword arguments `delays` and `check` instead of
     `n` and `max_delay`.  The previous functionality can be achieved setting
-    `delays` to `ExponentialBackOff`. ([#19331])
+    `delays` to `ExponentialBackOff` ([#19331]).
 
   * `transpose(::AbstractVector)` now always returns a `RowVector` view of the input (which is a
      special 1×n-sized `AbstractMatrix`), not a `Matrix`, etc. In particular, for
-     `v::AbstractVector` we now have `(v.').' === v` and `v.' * v` is a scalar. ([#19670])
+     `v::AbstractVector` we now have `(v.').' === v` and `v.' * v` is a scalar ([#19670]).
 
   * Parametric types with "unspecified" parameters, such as `Array`, are now represented
     as `UnionAll` types instead of `DataType`s ([#18457]).
 
   * `Union` types have two fields, `a` and `b`, instead of a single `types` field.
-    The empty type `Union{}` is represented by a singleton of type `BottomType` ([#18457]).
+    The empty type `Union{}` is represented by a singleton of type `TypeofBottom` ([#18457]).
 
   * The type `NTuple{N}` now refers to tuples where every element has the same type
     (since it is shorthand for `NTuple{N,T} where T`). To get the old behavior of matching
@@ -203,30 +455,70 @@ This section lists changes that do not have deprecation warnings.
 
   * The `count` function no longer sums non-boolean values ([#20404])
 
+  * The generic `getindex(::AbstractString, ::AbstractVector)` method's signature has been
+    tightened to `getindex(::AbstractString, ::AbstractVector{<:Integer})`. Consequently,
+    indexing into `AbstractString`s with non-`AbstractVector{<:Integer}` `AbstractVector`s
+    now throws a `MethodError` in the absence of an appropriate specialization.
+    (Previously such cases failed less explicitly with the exception of
+    `AbstractVector{Bool}`, which now throws an `ArgumentError` noting that
+    logical indexing into strings is not supported.)  ([#20248])
+
   * Bessel, Hankel, Airy, error, Dawson, eta, zeta, digamma, inverse digamma,
     trigamma, and polygamma special functions have been moved from Base to
     the
     [SpecialFunctions.jl package](https://github.com/JuliaMath/SpecialFunctions.jl)
-    ([#20427]).
+    ([#20427]).  Note that `airy`, `airyx` and `airyprime` have been deprecated
+    in favor of more specific functions (`airyai`, `airybi`, `airyaiprime`,
+    `airybiprimex`, `airyaix`, `airybix`, `airyaiprimex`, `airybiprimex`)
+    ([#18050]).
+
+  * When a macro is called in the module in which that macro is defined, global variables
+    in the macro are now correctly resolved in the macro definition environment. Breakage
+    from this change commonly manifests as undefined variable errors that do not occur
+    under 0.5. Fixing such breakage typically requires sprinkling additional `esc`s in
+    the offending macro ([#15850]).
 
   * `write` on an `IOBuffer` now returns a signed integer in order to be
     consistent with other buffers ([#20609]).
 
+  * The `<:Integer` division fallback `/(::Integer, ::Integer)`, which formerly
+    inappropriately took precedence over other division methods for some
+    mixed-integer-type division calls, has been removed ([#19779]).
+
+  * `@async`, `@spawn`, `@spawnat`, `@fetch` and `@fetchfrom` no longer implicitly
+    localize variables. Previously, the expression would be wrapped in an implicit
+    `let` block  ([#19594]).
+
+  * `parse` no longer accepts IPv4 addresses including leading zeros, octal, or hexadecimal.
+    Convert IPv4 addresses including octal or hexadecimal to decimal, and remove leading
+    zeros in decimal addresses ([#19811]).
+
+  * Closures shipped for remote execution via `@spawn` or `remotecall` now automatically
+    serialize globals defined under Main. For details, please refer to the paragraph
+    on "Global variables" under the "Parallel computing" chapter in the manual ([#19594]).
+
+  * `homedir` now determines the user's home directory via `libuv`'s `uv_os_homedir`,
+    rather than from environment variables ([#19636]).
+
+  * Workers now listen on an ephemeral port assigned by the OS. Previously workers would
+    listen on the first free port available from 9009 ([#21818]).
+
+
 Library improvements
 --------------------
 
-  * `@views` macro to convert a whole expression or block of code to
+  * A new `@views` macro was added to convert a whole expression or block of code to
     use views for all slices ([#20164]).
 
-  * `max`, `min`, and related functions (`minmax`, `maximum`, `minimum`,
-    `extrema`) now return `NaN` for `NaN` arguments ([#12563]).
+  * `max`, `min`, and related functions (`minmax`, `maximum`, `minimum`, `extrema`)
+     now return `NaN` for `NaN` arguments ([#12563]).
 
-  * `oneunit(x)` function to return a dimensionful version of `one(x)` (which
-    is clarified to mean a dimensionless quantity if `x` is dimensionful) ([#20268]).
+  * `oneunit(x)` function to return a dimensionful version of `one(x)`
+    (which is clarified to mean a dimensionless quantity if `x` is dimensionful) ([#20268]).
 
   * The `chop` and `chomp` functions now return a `SubString` ([#18339]).
 
-  * Numbered stackframes printed in stacktraces can be opened in an editor by
+  * Numbered stackframes printed in stacktraces can now be opened in an editor by
     entering the corresponding number in the REPL and pressing `^Q` ([#19680]).
 
   * The REPL now supports something called *prompt pasting* ([#17599]).
@@ -236,22 +528,28 @@ Library improvements
     without having to scrub away prompts and outputs.
     This can be disabled or enabled at will with `Base.REPL.enable_promptpaste(::Bool)`.
 
-  * The function `print_with_color` can now take a color represented by an integer between 0 and 255 inclusive as its first argument ([#18473]).
-    For a number to color mapping please refer to [this chart](https://upload.wikimedia.org/wikipedia/en/1/15/Xterm_256color_chart.svg).
+  * The function `print_with_color` can now take a color
+    represented by an integer between 0 and 255 inclusive
+    as its first argument ([#18473]). For a number-to-color mapping, please refer to
+    [this chart](https://upload.wikimedia.org/wikipedia/commons/1/15/Xterm_256color_chart.svg).
     It is also possible to use numbers as colors in environment variables that customizes colors in the REPL.
     For example, to get orange warning messages, simply set `ENV["JULIA_WARN_COLOR"] = 208`.
     Please note that not all terminals support 256 colors.
 
   * The function `print_with_color` no longer prints text in bold by default ([#18628]).
-    Instead, the function now take a keyword argument `bold::Bool` which determines whether to print in bold or not.
-    On some terminals, printing a color in non bold results in slightly darker colors being printed than when printing in bold.
+    Instead, the function now take a keyword argument `bold::Bool`
+    which determines whether to print in bold or not. On some terminals, printing a color in non bold
+    results in slightly darker colors being printed than when printing in bold.
     Therefore, light versions of the colors are now supported.
     For the available colors see the help entry on `print_with_color`.
 
   * The default text style for REPL input and answers has been changed from bold to normal ([#11250]).
-    They can be changed back to bold by setting the environment variables `JULIA_INPUT_COLOR` and `JULIA_ANSWER_COLOR` to `"bold"`.
-    For example, one way of doing this is adding `ENV["JULIA_INPUT_COLOR"] = :bold` and `ENV["JULIA_ANSWER_COLOR"] = :bold` to the `.juliarc.jl` file.
-    See the [manual section on customizing colors](http://docs.julialang.org/en/latest/manual/interacting-with-julia#Customizing-Colors-1) for more information.
+    They can be changed back to bold by setting the environment variables
+    `JULIA_INPUT_COLOR` and `JULIA_ANSWER_COLOR` to `"bold"`.
+    For example, one way of doing this is adding `ENV["JULIA_INPUT_COLOR"] = :bold`
+    and `ENV["JULIA_ANSWER_COLOR"] = :bold` to the `.juliarc.jl` file. See the
+    [manual section on customizing colors](https://docs.julialang.org/en/latest/manual/interacting-with-julia#Customizing-Colors-1)
+    for more information.
 
   * The default color for info messages has been changed from blue to cyan
     ([#18442]), and for warning messages from red to yellow ([#18453]).  This
@@ -269,61 +567,122 @@ Library improvements
     you can now do e.g. `[A I]` and it will concatenate an appropriately sized
     identity matrix ([#19305]).
 
-  * New `accumulate` and `accumulate!` functions, which generalize `cumsum` and
-  `cumprod`. Also known as a [scan](https://en.wikipedia.org/wiki/Prefix_sum)
-  operation ([#18931]).
+  * New `accumulate` and `accumulate!` functions were added, which generalize `cumsum` and `cumprod`.
+    Also known as a [scan](https://en.wikipedia.org/wiki/Prefix_sum) operation ([#18931]).
 
   * `reshape` now allows specifying one dimension with a `Colon()` (`:`) for the new shape, in which case
     that dimension's length will be computed such that its product with all the other dimensions is equal
     to the length of the original array ([#19919]).
 
-  * New `titlecase` function, which capitalizes the first character of each word within a string ([#19469]).
+  * The new `to_indices` function provides a uniform interface for index conversions,
+    taking an array and a tuple of indices as arguments and returning a tuple of
+    integers and/or arrays of supported scalar indices. It will throw an `ArgumentError`
+    for any unsupported indices, and the returned arrays should be iterated over (and
+    not indexed into) to support more efficient logical indexing ([#19730]).
+
+    + Using colons (`:`) to represent a collection of indices is deprecated. They now must be
+      explicitly converted to a specialized array of integers with the `to_indices` function.
+      As a result, the type of `SubArray`s that represent views over colon indices has changed.
+
+    + Logical indexing is now more efficient. Logical arrays are converted by `to_indices` to
+      a lazy, iterable collection of indices that doesn't support indexing. A deprecation
+      provides indexing support with O(n) lookup.
+
+    + The performance of indexing with `CartesianIndex`es is also improved in many situations.
+
+  * A new `titlecase` function was added, to capitalize the first character of each word within a string ([#19469]).
 
   * `any` and `all` now always short-circuit, and `mapreduce` never short-circuits ([#19543]).
     That is, not every member of the input iterable will be visited if a `true` (in the case of `any`) or
     `false` (in the case of `all`) value is found, and `mapreduce` will visit all members of the iterable.
 
-  * Additional methods for `ones` and `zeros` functions to support the same signature as the `similar` function ([#19635]).
+  * Additional methods for `ones` and `zeros` functions were added
+    to support the same signature as the `similar` function ([#19635]).
 
   * `count` now has a `count(itr)` method equivalent to `count(identity, itr)` ([#20403]).
 
-  * Methods for `map` and `filter` with `Nullable` arguments have been
-    implemented; the semantics are as if the `Nullable` were a container with
-    zero or one elements ([#16961]).
+  * Methods for `map` and `filter` with `Nullable` arguments have been implemented;
+    the semantics are as if the `Nullable` were a container with zero or one elements ([#16961]).
 
-  * New `@test_warn` and `@test_nowarn` macros in the `Base.Test` module to
+  * New `@test_warn` and `@test_nowarn` macros were added in the `Base.Test` module to
     test for the presence or absence of warning messages ([#19903]).
 
-  * `logging` can be used to redirect `info`, `warn`, and `error` messages
+  * `logging` can now be used to redirect `info`, `warn`, and `error` messages
     either universally or on a per-module/function basis ([#16213]).
 
-  * New `iszero(x)` function to quickly check whether `x` is zero (or is all zeros, for an array) ([#19950]).
+  * New function `Base.invokelatest(f, args...)` to call the latest version
+    of a function in circumstances where an older version may be called
+    instead (e.g. in a function calling `eval`) ([#19784]).
+
+  * A new `iszero(x)` function was added, to quickly check whether `x` is zero
+    (or is all zeros, for an array) ([#19950]).
 
   * `notify` now returns a count of tasks woken up ([#19841]).
 
-  * New nonstandard string literal `raw"..."` for creating strings
-    with no interpolation or unescaping ([#19900]).
+  * A new nonstandard string literal `raw"..."` was added,
+    for creating strings with no interpolation or unescaping ([#19900]).
+
+  * A new `Dates.Time` type was added that supports representing the time of day
+    with up to nanosecond resolution ([#12274]).
+
+  * Raising one or negative one to a negative integer power formerly threw a `DomainError`.
+    One raised to any negative integer power now yields one, negative one raised to any
+    negative even integer power now yields one, and negative one raised to any negative
+    odd integer power now yields negative one. Similarly, raising `true` to any negative
+    integer power now yields `true` rather than throwing a `DomainError` ([#18342]).
 
-  * A new `Dates.Time` type was added that supports representing the time of day with up to nanosecond resolution ([#12274]).
+  * A new `@macroexpand` macro was added as a convenient alternative to the `macroexpand` function ([#18660]).
 
-  * New `@macroexpand` macro as a convenient alternative to the `macroexpand` function ([#18660]).
+  * `invoke` now supports keyword arguments ([#20345]).
 
-  * Introduced a wrapper type for lazy complex conjugation of arrays, `ConjArray`.
+  * A new `ConjArray` type was added, as a wrapper type for lazy complex conjugation of arrays.
     Currently, it is used by default for the new `RowVector` type only, and
     enforces that both `transpose(vec)` and `ctranspose(vec)` are views not copies ([#20047]).
 
+  * `rem` now accepts a `RoundingMode` argument via `rem(x, y, r::RoundingMode)`, yielding
+    `x - y*round(x/y, r)` without intermediate rounding. In particular, `rem(x, y, RoundNearest)`
+    yields a value in the interval `[-abs(y)/2, abs(y)/2]`), which corresponds to the IEE754
+    `remainder` function. Similarly, `rem2pi(x, r::RoundingMode)` now exists as well, yielding
+    `rem(x, 2pi, r::RoundingMode)` but with greater accuracy ([#10946]).
+
+  * `map[!]` and `broadcast[!]` now have dedicated methods for sparse/structured
+    vectors/matrices. Specifically, `map[!]` and `broadcast[!]` over combinations including
+    one or more `SparseVector`, `SparseMatrixCSC`, `Diagonal`, `Bidiagonal`, `Tridiagonal`,
+    or `SymTridiagonal`, and any number of `broadcast` scalars, `Vector`s, or `Matrix`s,
+    now efficiently yield `SparseVector`s or `SparseMatrix`s as appropriate ([#19239],
+    [#19371], [#19518], [#19438], [#19690], [#19724], [#19926], [#19934], [#20009]).
+
+  * The operators `!` and `∘` (`\circ<tab>` at the REPL and in most code editors) now
+    respectively perform predicate function negation and function composition. For example,
+    `map(!iszero, (0, 1))` is now equivalent to `map(x -> !iszero(x), (0, 1))` and
+    `map(uppercase ∘ hex, 250:255)` is now equivalent to
+    `map(x -> uppercase(hex(x)), 250:255)` ([#17155]).
+
+  * `enumerate` now supports the two-argument form `enumerate(::IndexStyle, iterable)`.
+    This form allows specification of the returned indices' style. For example,
+    `enumerate(IndexLinear, iterable)` yields linear indices and
+    `enumerate(IndexCartesian, iterable)` yields cartesian indices ([#16378]).
+
+  * Jump to first/last history entries in the REPL via "Alt-<" and "Alt->" ([#22829]).
+
 Compiler/Runtime improvements
 -----------------------------
 
-* `ccall` is now implemented as a macro, removing the need for special code-generator support for Intrinsics.
+  * `ccall` is now implemented as a macro,
+    removing the need for special code-generator support for `Intrinsics` ([#18754]).
 
-* `ccall` gained limited support for a `llvmcall` calling-convention. This can replace many uses of `llvmcall` with a simpler, shorter declaration.
+  * `ccall` gained limited support for a `llvmcall` calling-convention.
+    This can replace many uses of `llvmcall` with a simpler, shorter declaration ([#18754]).
 
-* All Intrinsics are now Builtin functions instead and have proper error checking and fall-back static compilation support.
+  * All `Intrinsics` are now `Builtin` functions instead and have proper error checking
+    and fall-back static compilation support ([#18754]).
 
 Deprecated or removed
 ---------------------
 
+  * `ipermutedims(A::AbstractArray, p)` has been deprecated in favor of
+    `permutedims(A, invperm(p))` ([#18891]).
+
   * Linear indexing is now only supported when there is exactly one
     non-cartesian index provided. Allowing a trailing index at dimension `d` to
     linearly access the higher dimensions from array `A` (beyond `size(A, d)`)
@@ -331,103 +690,362 @@ Deprecated or removed
     Instead, `reshape` the array such that its dimensionality matches the
     number of indices ([#20079]).
 
+  * `Multimedia.@textmime "mime"` has been deprecated. Instead define
+    `Multimedia.istextmime(::MIME"mime") = true` ([#18441]).
+
   * `isdefined(a::Array, i::Int)` has been deprecated in favor of `isassigned` ([#18346]).
 
+  * The three-argument `SubArray` constructor (which accepts `dims::Tuple` as its third
+    argument) has been deprecated in favor of the two-argument equivalent (the
+    `dims::Tuple` argument being superfluous) ([#19259]).
+
   * `is` has been deprecated in favor of `===` (which used to be an alias for `is`) ([#17758]).
 
-  * `num` and `den` have been deprecated in favor of `numerator` and `denominator` respectively ([#19233]).
+  * Ambiguous methods for addition and subtraction between `UniformScaling`s and `Number`s,
+    for example `(+)(J::UniformScaling, x::Number)`, have been deprecated in favor of
+    unambiguous, explicit equivalents, for example `J.λ + x` ([#17607]).
+
+  * `num` and `den` have been deprecated in favor of `numerator` and `denominator` respectively ([#19233],[#19246]).
+
+  * `delete!(ENV::EnvHash, k::AbstractString, def)` has been deprecated in favor of
+    `pop!(ENV, k, def)`. Be aware that `pop!` returns `k` or `def`, whereas `delete!`
+    returns `ENV` or `def` ([#18012]).
 
   * infix operator `$` has been deprecated in favor of infix `⊻` or function `xor()` ([#18977]).
 
+  * The single-argument form of `write` (`write(x)`, with implicit `STDOUT` output stream),
+    has been deprecated in favor of the explicit equivalent `write(STDOUT, x)` ([#17654]).
+
   * `Dates.recur` has been deprecated in favor of `filter` ([#19288])
 
-  * `cummin` and `cummax` have been deprecated in favor of `accumulate`.
+  * A number of ambiguous `convert` operations between `Number`s (especially `Real`s)
+    and `Date`, `DateTime`, and `Period` types have been deprecated in favor of
+    unambiguous `convert` and explicit constructor calls. Additionally, ambiguous colon
+    construction of `<:Period` ranges without step specification, for example
+    `Dates.Hour(1):Dates.Hour(2)`, has been deprecated in favor of such construction
+    including step specification, for example `Dates.Hour(1):Dates.Hour(1):Dates.Hour(2)`
+    ([#19920]).
+
+  * `cummin` and `cummax` have been deprecated in favor of `accumulate` ([#18931]).
+
+  * The `Array` constructor syntax `Array(T, dims...)` has been deprecated
+    in favor of the forms `Array{T,N}(dims...)` (where `N` is known, or
+    particularly `Vector{T}(dims...)` for `N = 1` and `Matrix{T}(dims...)` for `N = 2`),
+    and `Array{T}(dims...)` (where `N` is not known). Likewise for `SharedArray`s ([#19989]).
 
   * `sumabs` and `sumabs2` have been deprecated in favor of `sum(abs, x)` and `sum(abs2, x)`, respectively.
     `maxabs` and `minabs` have similarly been deprecated in favor of `maximum(abs, x)` and `minimum(abs, x)`.
     Likewise for the in-place counterparts of these functions ([#19598]).
 
-  * `airy`, `airyx` and `airyprime` have been deprecated in favor of more specific
-    functions (`airyai`, `airybi`, `airyaiprime`, `airybiprimex`, `airyaix`, `airybix`,
-    `airyaiprimex`, `airybiprimex`) ([#18050]).
+  * The array-reducing form of `isinteger` (`isinteger(x::AbstractArray)`) has been
+    deprecated in favor of `all(isinteger, x)` ([#19925]).
 
   * `produce`, `consume` and iteration over a Task object have been deprecated in favor of
     using Channels for inter-task communication  ([#19841]).
 
+  * The `negate` keyword has been deprecated from all functions in the `Dates` adjuster
+    API (`adjust`, `tonext`, `toprev`, `Date`, `Time`, and `DateTime`). Instead use
+    predicate function negation via the `!` operator
+    (see [Library Improvements](#library-improvements)) ([#20213]).
+
   * `@test_approx_eq x y` has been deprecated in favor of `@test isapprox(x,y)` or `@test x ≈ y` ([#4615]).
 
+  * `Matrix()` and `Matrix{T}()` have been deprecated in favor of the explicit forms
+    `Matrix(0, 0)` and `Matrix{T}(0, 0)` ([#20330]).
+
+  * Vectorized functions have been deprecated in favor of dot syntax ([#17302], [#17265],
+    [#18558], [#19711], [#19712], [#19791], [#19802], [#19931], [#20543], [#20228]).
+
+  *  All methods of character predicates (`isalnum`, `isalpha`, `iscntrl`, `isdigit`,
+     `isnumber`, `isgraph`, `islower`, `isprint`, `ispunct`, `isspace`, `isupper`,
+     `isxdigit`) that accept `AbstractStrings` have been deprecated in favor of `all`.
+     For example, `isnumber("123")` should now be expressed `all(isnumber, "123")`
+     ([#20342]).
+
+  * A few names related to indexing traits have been changed: `LinearIndexing` and
+    `linearindexing` have been deprecated in favor of `IndexStyle`. `LinearFast` has
+    been deprecated in favor of `IndexLinear`, and `LinearSlow` has been deprecated in
+    favor of `IndexCartesian` ([#16378]).
+
+  * The two-argument forms of `map` (`map!(f, A)`) and `asyncmap!` (`asyncmap!(f, A)`)
+    have been deprecated in anticipation of future semantic changes ([#19721]).
+
+  * `unsafe_wrap(String, ...)` has been deprecated in favor of `unsafe_string` ([#19449]).
+
+  * `zeros` and `ones` methods accepting an element type as the first argument and an
+    array as the second argument, for example `zeros(Float64, [1, 2, 3])`, have been
+    deprecated in favor of equivalent methods with the second argument instead the
+    size of the array, for example `zeros(Float64, size([1, 2, 3]))` ([#21183]).
+
+  * `Base.promote_eltype_op` has been deprecated ([#19669], [#19814], [#19937]).
+
+  * `isimag` has been deprecated ([#19949]).
+
+  * The tuple-of-types form of `invoke`, `invoke(f, (types...), ...)`, has been deprecated
+    in favor of the tuple-type form `invoke(f, Tuple{types...}, ...)` ([#18444]).
+
+  * `Base._promote_array_type` has been deprecated ([#19766]).
+
+  * `broadcast_zpreserving` has been deprecated ([#19533], [#19720]).
+
+  * Methods allowing indexing of tuples by `AbstractArray`s with more than one dimension
+    have been deprecated. (Indexing a tuple by such a higher-dimensional `AbstractArray`
+    should yield a tuple with more than one dimension, but tuples are one-dimensional.)
+    ([#19737]).
+
+  * `@test_approx_eq a b` has been deprecated in favor of `@test a ≈ b` (or,
+    equivalently, `@test ≈(a, b)` or `@test isapprox(a, b)`).
+    `@test_approx_eq_eps` has been deprecated in favor of new `@test` syntax:
+    `@test` now supports the syntax `@test f(args...) key=val ...` for
+    `@test f(args..., key=val...)`. This syntax allows, for example, writing
+    `@test a ≈ b atol=c` in place of `@test ≈(a, b, atol=c)` (and hence
+    `@test_approx_eq_eps a b c`) ([#19901]).
+
+  * `takebuf_array` has been deprecated in favor of `take!`, and `takebuf_string(x)`
+    has been deprecated in favor of `String(take!(x))` ([#19088]).
+
+  * `convert` methods from `Diagonal` and `Bidiagonal` to subtypes of
+    `AbstractTriangular` have been deprecated ([#17723]).
+
+  * `Base.LinAlg.arithtype` has been deprecated. If you were using `arithtype` within a
+    `promote_op` call, instead use `promote_op(Base.LinAlg.matprod, Ts...)`. Otherwise,
+    consider defining equivalent functionality locally ([#18218]).
+
+  * Special characters (`#{}()[]<>|&*?~;`) should now be quoted in commands. For example,
+    ``` `export FOO=1\;` ``` should replace ``` `export FOO=1;` ``` and
+    ``` `cd $dir '&&' $thingie` ``` should replace ``` `cd $dir && $thingie` ``` ([#19786]).
+
+  * Zero-argument `Channel` constructors (`Channel()`, `Channel{T}()`) have been deprecated
+    in favor of equivalents accepting an explicit `Channel` size
+    (`Channel(2)`, `Channel{T}(2)`) ([#18832]).
+
+  * The zero-argument constructor `MersenneTwister()` has been
+    deprecated in favor of the explicit `MersenneTwister(0)` ([#16984]).
+
+  * `Base.promote_type(op::Type, Ts::Type...)` has been removed as part of an overhaul
+    of `broadcast`'s promotion mechanism. If you need the functionality of that
+    `Base.promote_type` method, consider defining it locally via
+    `Core.Inference.return_type(op, Tuple{Ts...})` ([#18642]).
+
+  * `bitbroadcast` has been deprecated in favor of `broadcast`, which now produces a
+    `BitArray` instead of `Array{Bool}` for functions yielding a boolean result ([#19771]).
+
+  * To complete the deprecation of histogram-related functions, `midpoints` has been
+    deprecated. Instead use the
+    [StatsBase.jl package](https://github.com/JuliaStats/StatsBase.jl)'s
+    `midpoints` function ([#20058]).
+
+  * Passing a type argument to `LibGit2.cat` has been deprecated in favor of a simpler,
+    two-argument method for `LibGit2.cat` ([#20435]).
+
+  * The `LibGit2.owner` function for finding the repository which owns a given Git object
+    has been deprecated in favor of `LibGit2.repository` ([#20135]).
+
+  * The `LibGit2.GitAnyObject` type has been renamed to `LibGit2.GitUnknownObject` to
+    clarify its intent ([#19935]).
+
+  * The `LibGit2.GitOid` type has been renamed to `LibGit2.GitHash` for clarity ([#19878]).
+
+  * Finalizing `LibGit2` objects with `finalize` has been deprecated in favor of using `close`
+    ([#19660]).
+
+  * Parsing string dates from a `Dates.DateFormat` object has been deprecated as part of a
+    larger effort toward faster, more extensible date parsing ([#20952]).
+
+Command-line option changes
+---------------------------
+
+  * In `polly` builds (`USE_POLLY := 1`), the new flag `--polly={yes|no}` controls whether
+    `@polly` declarations are respected. (With `--polly=no`, `@polly` declarations are
+    ignored.) This flag is also available in non-`polly` builds (`USE_POLLY := 0`),
+    but has no effect ([#18159]).
+
 <!--- generated by NEWS-update.jl: -->
 [#265]: https://github.com/JuliaLang/julia/issues/265
 [#4615]: https://github.com/JuliaLang/julia/issues/4615
 [#7669]: https://github.com/JuliaLang/julia/issues/7669
 [#8974]: https://github.com/JuliaLang/julia/issues/8974
 [#9343]: https://github.com/JuliaLang/julia/issues/9343
+[#10946]: https://github.com/JuliaLang/julia/issues/10946
 [#11250]: https://github.com/JuliaLang/julia/issues/11250
 [#11310]: https://github.com/JuliaLang/julia/issues/11310
 [#12274]: https://github.com/JuliaLang/julia/issues/12274
 [#12563]: https://github.com/JuliaLang/julia/issues/12563
+[#15850]: https://github.com/JuliaLang/julia/issues/15850
 [#16213]: https://github.com/JuliaLang/julia/issues/16213
+[#16378]: https://github.com/JuliaLang/julia/issues/16378
+[#16937]: https://github.com/JuliaLang/julia/issues/16937
 [#16961]: https://github.com/JuliaLang/julia/issues/16961
+[#16984]: https://github.com/JuliaLang/julia/issues/16984
 [#16986]: https://github.com/JuliaLang/julia/issues/16986
 [#17057]: https://github.com/JuliaLang/julia/issues/17057
+[#17155]: https://github.com/JuliaLang/julia/issues/17155
 [#17261]: https://github.com/JuliaLang/julia/issues/17261
+[#17265]: https://github.com/JuliaLang/julia/issues/17265
+[#17302]: https://github.com/JuliaLang/julia/issues/17302
 [#17599]: https://github.com/JuliaLang/julia/issues/17599
+[#17607]: https://github.com/JuliaLang/julia/issues/17607
 [#17623]: https://github.com/JuliaLang/julia/issues/17623
+[#17654]: https://github.com/JuliaLang/julia/issues/17654
+[#17723]: https://github.com/JuliaLang/julia/issues/17723
 [#17758]: https://github.com/JuliaLang/julia/issues/17758
 [#17785]: https://github.com/JuliaLang/julia/issues/17785
+[#18012]: https://github.com/JuliaLang/julia/issues/18012
 [#18050]: https://github.com/JuliaLang/julia/issues/18050
+[#18155]: https://github.com/JuliaLang/julia/issues/18155
+[#18159]: https://github.com/JuliaLang/julia/issues/18159
+[#18218]: https://github.com/JuliaLang/julia/issues/18218
 [#18251]: https://github.com/JuliaLang/julia/issues/18251
 [#18330]: https://github.com/JuliaLang/julia/issues/18330
 [#18339]: https://github.com/JuliaLang/julia/issues/18339
+[#18342]: https://github.com/JuliaLang/julia/issues/18342
 [#18346]: https://github.com/JuliaLang/julia/issues/18346
+[#18441]: https://github.com/JuliaLang/julia/issues/18441
 [#18442]: https://github.com/JuliaLang/julia/issues/18442
+[#18444]: https://github.com/JuliaLang/julia/issues/18444
 [#18453]: https://github.com/JuliaLang/julia/issues/18453
 [#18457]: https://github.com/JuliaLang/julia/issues/18457
 [#18473]: https://github.com/JuliaLang/julia/issues/18473
+[#18558]: https://github.com/JuliaLang/julia/issues/18558
 [#18628]: https://github.com/JuliaLang/julia/issues/18628
+[#18642]: https://github.com/JuliaLang/julia/issues/18642
 [#18644]: https://github.com/JuliaLang/julia/issues/18644
 [#18660]: https://github.com/JuliaLang/julia/issues/18660
 [#18690]: https://github.com/JuliaLang/julia/issues/18690
+[#18754]: https://github.com/JuliaLang/julia/issues/18754
 [#18777]: https://github.com/JuliaLang/julia/issues/18777
+[#18832]: https://github.com/JuliaLang/julia/issues/18832
 [#18839]: https://github.com/JuliaLang/julia/issues/18839
+[#18891]: https://github.com/JuliaLang/julia/issues/18891
 [#18931]: https://github.com/JuliaLang/julia/issues/18931
 [#18965]: https://github.com/JuliaLang/julia/issues/18965
 [#18977]: https://github.com/JuliaLang/julia/issues/18977
 [#19018]: https://github.com/JuliaLang/julia/issues/19018
+[#19088]: https://github.com/JuliaLang/julia/issues/19088
 [#19157]: https://github.com/JuliaLang/julia/issues/19157
 [#19233]: https://github.com/JuliaLang/julia/issues/19233
+[#19239]: https://github.com/JuliaLang/julia/issues/19239
+[#19246]: https://github.com/JuliaLang/julia/issues/19246
+[#19259]: https://github.com/JuliaLang/julia/issues/19259
 [#19288]: https://github.com/JuliaLang/julia/issues/19288
 [#19305]: https://github.com/JuliaLang/julia/issues/19305
 [#19331]: https://github.com/JuliaLang/julia/issues/19331
+[#19371]: https://github.com/JuliaLang/julia/issues/19371
+[#19438]: https://github.com/JuliaLang/julia/issues/19438
 [#19449]: https://github.com/JuliaLang/julia/issues/19449
 [#19464]: https://github.com/JuliaLang/julia/issues/19464
 [#19469]: https://github.com/JuliaLang/julia/issues/19469
+[#19518]: https://github.com/JuliaLang/julia/issues/19518
+[#19533]: https://github.com/JuliaLang/julia/issues/19533
 [#19543]: https://github.com/JuliaLang/julia/issues/19543
+[#19594]: https://github.com/JuliaLang/julia/issues/19594
 [#19598]: https://github.com/JuliaLang/julia/issues/19598
 [#19635]: https://github.com/JuliaLang/julia/issues/19635
+[#19636]: https://github.com/JuliaLang/julia/issues/19636
+[#19660]: https://github.com/JuliaLang/julia/issues/19660
+[#19669]: https://github.com/JuliaLang/julia/issues/19669
 [#19670]: https://github.com/JuliaLang/julia/issues/19670
 [#19677]: https://github.com/JuliaLang/julia/issues/19677
 [#19680]: https://github.com/JuliaLang/julia/issues/19680
+[#19690]: https://github.com/JuliaLang/julia/issues/19690
 [#19692]: https://github.com/JuliaLang/julia/issues/19692
+[#19711]: https://github.com/JuliaLang/julia/issues/19711
+[#19712]: https://github.com/JuliaLang/julia/issues/19712
+[#19720]: https://github.com/JuliaLang/julia/issues/19720
+[#19721]: https://github.com/JuliaLang/julia/issues/19721
 [#19722]: https://github.com/JuliaLang/julia/issues/19722
+[#19724]: https://github.com/JuliaLang/julia/issues/19724
+[#19730]: https://github.com/JuliaLang/julia/issues/19730
+[#19737]: https://github.com/JuliaLang/julia/issues/19737
 [#19741]: https://github.com/JuliaLang/julia/issues/19741
+[#19766]: https://github.com/JuliaLang/julia/issues/19766
+[#19771]: https://github.com/JuliaLang/julia/issues/19771
+[#19779]: https://github.com/JuliaLang/julia/issues/19779
+[#19784]: https://github.com/JuliaLang/julia/issues/19784
+[#19786]: https://github.com/JuliaLang/julia/issues/19786
 [#19787]: https://github.com/JuliaLang/julia/issues/19787
+[#19791]: https://github.com/JuliaLang/julia/issues/19791
 [#19800]: https://github.com/JuliaLang/julia/issues/19800
+[#19802]: https://github.com/JuliaLang/julia/issues/19802
+[#19811]: https://github.com/JuliaLang/julia/issues/19811
+[#19814]: https://github.com/JuliaLang/julia/issues/19814
 [#19841]: https://github.com/JuliaLang/julia/issues/19841
+[#19878]: https://github.com/JuliaLang/julia/issues/19878
 [#19900]: https://github.com/JuliaLang/julia/issues/19900
+[#19901]: https://github.com/JuliaLang/julia/issues/19901
 [#19903]: https://github.com/JuliaLang/julia/issues/19903
 [#19919]: https://github.com/JuliaLang/julia/issues/19919
+[#19920]: https://github.com/JuliaLang/julia/issues/19920
+[#19925]: https://github.com/JuliaLang/julia/issues/19925
+[#19926]: https://github.com/JuliaLang/julia/issues/19926
+[#19931]: https://github.com/JuliaLang/julia/issues/19931
+[#19934]: https://github.com/JuliaLang/julia/issues/19934
+[#19935]: https://github.com/JuliaLang/julia/issues/19935
+[#19937]: https://github.com/JuliaLang/julia/issues/19937
 [#19944]: https://github.com/JuliaLang/julia/issues/19944
+[#19949]: https://github.com/JuliaLang/julia/issues/19949
 [#19950]: https://github.com/JuliaLang/julia/issues/19950
+[#19989]: https://github.com/JuliaLang/julia/issues/19989
+[#20005]: https://github.com/JuliaLang/julia/issues/20005
+[#20009]: https://github.com/JuliaLang/julia/issues/20009
 [#20047]: https://github.com/JuliaLang/julia/issues/20047
+[#20058]: https://github.com/JuliaLang/julia/issues/20058
 [#20079]: https://github.com/JuliaLang/julia/issues/20079
+[#20135]: https://github.com/JuliaLang/julia/issues/20135
 [#20164]: https://github.com/JuliaLang/julia/issues/20164
+[#20213]: https://github.com/JuliaLang/julia/issues/20213
+[#20228]: https://github.com/JuliaLang/julia/issues/20228
+[#20248]: https://github.com/JuliaLang/julia/issues/20248
 [#20249]: https://github.com/JuliaLang/julia/issues/20249
 [#20268]: https://github.com/JuliaLang/julia/issues/20268
+[#20308]: https://github.com/JuliaLang/julia/issues/20308
 [#20321]: https://github.com/JuliaLang/julia/issues/20321
 [#20327]: https://github.com/JuliaLang/julia/issues/20327
+[#20328]: https://github.com/JuliaLang/julia/issues/20328
+[#20330]: https://github.com/JuliaLang/julia/issues/20330
+[#20342]: https://github.com/JuliaLang/julia/issues/20342
+[#20345]: https://github.com/JuliaLang/julia/issues/20345
 [#20403]: https://github.com/JuliaLang/julia/issues/20403
 [#20404]: https://github.com/JuliaLang/julia/issues/20404
 [#20406]: https://github.com/JuliaLang/julia/issues/20406
 [#20414]: https://github.com/JuliaLang/julia/issues/20414
 [#20418]: https://github.com/JuliaLang/julia/issues/20418
+[#20427]: https://github.com/JuliaLang/julia/issues/20427
+[#20435]: https://github.com/JuliaLang/julia/issues/20435
+[#20500]: https://github.com/JuliaLang/julia/issues/20500
+[#20530]: https://github.com/JuliaLang/julia/issues/20530
+[#20543]: https://github.com/JuliaLang/julia/issues/20543
+[#20575]: https://github.com/JuliaLang/julia/issues/20575
+[#20609]: https://github.com/JuliaLang/julia/issues/20609
+[#20889]: https://github.com/JuliaLang/julia/issues/20889
+[#20952]: https://github.com/JuliaLang/julia/issues/20952
+[#20974]: https://github.com/JuliaLang/julia/issues/20974
+[#21183]: https://github.com/JuliaLang/julia/issues/21183
+[#21359]: https://github.com/JuliaLang/julia/issues/21359
+[#21692]: https://github.com/JuliaLang/julia/issues/21692
+[#21697]: https://github.com/JuliaLang/julia/issues/21697
+[#21746]: https://github.com/JuliaLang/julia/issues/21746
+[#21759]: https://github.com/JuliaLang/julia/issues/21759
+[#21818]: https://github.com/JuliaLang/julia/issues/21818
+[#21825]: https://github.com/JuliaLang/julia/issues/21825
+[#21956]: https://github.com/JuliaLang/julia/issues/21956
+[#21960]: https://github.com/JuliaLang/julia/issues/21960
+[#21973]: https://github.com/JuliaLang/julia/issues/21973
+[#21974]: https://github.com/JuliaLang/julia/issues/21974
+[#22007]: https://github.com/JuliaLang/julia/issues/22007
+[#22038]: https://github.com/JuliaLang/julia/issues/22038
+[#22062]: https://github.com/JuliaLang/julia/issues/22062
+[#22064]: https://github.com/JuliaLang/julia/issues/22064
+[#22182]: https://github.com/JuliaLang/julia/issues/22182
+[#22187]: https://github.com/JuliaLang/julia/issues/22187
+[#22188]: https://github.com/JuliaLang/julia/issues/22188
+[#22210]: https://github.com/JuliaLang/julia/issues/22210
+[#22224]: https://github.com/JuliaLang/julia/issues/22224
+[#22228]: https://github.com/JuliaLang/julia/issues/22228
+[#22245]: https://github.com/JuliaLang/julia/issues/22245
+[#22310]: https://github.com/JuliaLang/julia/issues/22310
+[#22523]: https://github.com/JuliaLang/julia/issues/22523
+[#22532]: https://github.com/JuliaLang/julia/issues/22532
+[#22709]: https://github.com/JuliaLang/julia/issues/22709
+[#22712]: https://github.com/JuliaLang/julia/issues/22712
+[#22732]: https://github.com/JuliaLang/julia/issues/22732
diff --git a/README.arm.md b/README.arm.md
index f31eed9d51ef3a..9de38fdeee94ec 100644
--- a/README.arm.md
+++ b/README.arm.md
@@ -1,32 +1,20 @@
-# Julia binaries for ARM
+# Julia on ARM (Linux)
 
-[Nightly builds](https://status.julialang.org/download/linux-arm) are
-available for ARMv7-A.
-
-# Hardware requirements
-
-Julia requires at least `armv6` and `vfpv2` instruction sets. It's recommended
-to use at least `armv7-a`. `armv5` or soft float are not supported.
+Julia fully supports ARMv8 (AArch64) processors, and supports ARMv7 and ARMv6
+(AArch32) with some caveats. This file provides general guidelines for compilation,
+in addition to instructions for specific devices.
 
-# Building Julia on ARM
+A list of [known issues](https://github.com/JuliaLang/julia/labels/arm) for ARM is
+available. If you encounter difficulties, please create an issue including the output
+from `cat /proc/cpuinfo`.
 
-Julia has been compiled on several ARMv7 / Cortex A15 Samsung
-Chromebooks running Ubuntu Linux under Crouton, Raspberry Pi systems
-and Odroid boards. This is a work in progress - several tests are
-known to fail, and backtraces are not available.
 
-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.
+## Building Julia
 
-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.
+In most cases, Julia can be successfully built by following the platform independent
+[build instructions](https://github.com/JuliaLang/julia/blob/master/README.md).
 
-This is the list of known issues on ARM:
- [https://github.com/JuliaLang/julia/labels/arm](https://github.com/JuliaLang/julia/labels/arm)
-
-# Build dependencies
+### Build dependencies
 
 We recommend using at least Ubuntu 14.04 and gcc 4.8, which is part of the
 standard `build-essentials`.
@@ -39,62 +27,73 @@ adding the following lines in `Make.user`:
 override USE_SYSTEM_BLAS=1
 override USE_SYSTEM_LAPACK=1
 override USE_SYSTEM_LIBM=1
-override USE_SYSTEM_FFTW=1
 override USE_SYSTEM_GMP=1
 override USE_SYSTEM_MPFR=1
 override USE_SYSTEM_ARPACK=1
 ````
 
-The following command will install all the necessary libraries on Ubuntu.
+The following command will install all the necessary libraries on Ubuntu:
 
 ````
-sudo apt-get install libblas3gf liblapack3gf libarpack2 libfftw3-dev libgmp3-dev \
+sudo apt-get install libblas3gf liblapack3gf libarpack2 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
-may be the simplest thing to do.
+If you run into issues building LLVM, see [these notes](http://llvm.org/docs/HowToBuildOnARM.html).
+
+
+## 32-bit (ARMv6, ARMv7)
 
-# ARM specific build problems
+Julia has been successfully compiled on several variants of the following ARMv6 & ARMv7 devices:
 
-If you run into issues building LLVM, see these notes:
-[http://llvm.org/docs/HowToBuildOnARM.html](http://llvm.org/docs/HowToBuildOnARM.html)
+* ARMv7 / Cortex A15 Samsung Chromebooks running Ubuntu Linux under Crouton;
+* [Raspberry Pi](https://www.raspberrypi.org).
+* [Odroid](http://www.hardkernel.com/main/main.php).
+
+
+Julia requires at least the `armv6` and `vfpv2` instruction sets. It's recommended to use  `armv7-a`.
+`armv5` or soft float are not supported.
+
+### Binaries
+
+[Nightly builds](https://status.julialang.org/download/linux-arm) are
+available for ARMv7-A.
 
-## Raspberry Pi 1 / Raspberry Pi Zero
+### Device specific instructions
 
-Note: These chips use ARMv6, which is not well supported at the moment. However it is
-possible to get a working Julia build.
+#### Raspberry Pi 1 / Raspberry Pi Zero
 
-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`:
+The type of ARM CPU used in the Raspberry Pi is not detected by LLVM. 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).
+It is 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
+To complete the build, you may need to increase the swap file size. To do so, edit
+`/etc/dphys-swapfile`, changing the line:
 
     CONF_SWAPSIZE=100
 
-to
+to:
 
     CONF_SWAPSIZE=512
 
-Then restart the swapfile service:
+before restarting the swapfile service:
 
     sudo /etc/init.d/dphys-swapfile stop
     sudo /etc/init.d/dphys-swapfile start
 
-## Raspberry Pi 2
+#### 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`.
+The type of ARM CPU used in the Raspberry Pi 2 is not detected by LLVM. Explicitly set the
+CPU target by adding the following to `Make.user`:
+
+```JULIA_CPU_TARGET=cortex-a7```
 
 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
@@ -102,7 +101,7 @@ due to unsupported inline assembly. In that case, add `MARCH=armv7-a` to
 
 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.
+1.  Download the [LLVM 3.9.0 binaries for ARMv7a] (http://llvm.org/releases/3.9.0/clang+llvm-3.9.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):
 
     ```
@@ -112,9 +111,9 @@ If building LLVM fails, you can download binaries from the LLVM website:
 
 Please do let us know if you had to download a pre-built LLVM in [#10235](https://github.com/JuliaLang/julia/issues/10235).
 
-## Chromebook
+#### Chromebook
 
-On Chromebooks, you have to first install Crouton.  If you do not have
+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
 so by following these tutorials.
 
@@ -125,7 +124,42 @@ 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
+#### Scaleway cloud hosted ARM servers
 
 On the current [Scaleway](http://scaleway.com) ARM servers, the Julia
 build works out of the box.
+
+## AArch64 (ARMv8)
+
+Julia has been successfully built on the following ARMv8 devices:
+
+* [nVidia Jetson TX1 & TX2](http://www.nvidia.com/object/embedded-systems-dev-kits-modules.html);
+* [X-Gene 1](https://www.apm.com/products/data-center/x-gene-family/x-gene/);
+* [Overdrive 3000](https://softiron.com/products/overdrive-3000/);
+* [Cavium ThunderX](http://www.cavium.com/ThunderX_ARM_Processors.html) on [packet.net](https://www.packet.net).
+
+Compilation on `ARMv8-A` requires that `Make.user` is configured as follows:
+
+```
+MARCH=armv8-a
+```
+
+### Device specific instructions
+
+#### nVidia Jetson TX2
+
+Julia builds and runs on the [nVidia Jetson TX2](http://www.nvidia.com/object/embedded-systems-dev-kits-modules.html)
+platform with minimal configuration changes.
+
+After configuring `Make.user` as per the `AArch64` instructions in this document,
+follow the general [build instructions](https://github.com/JuliaLang/julia/blob/master/README.md).
+The majority of the build dependencies specified in the instructions are installed by
+the default configuration flashed by [Jetpack 3.0](https://developer.nvidia.com/embedded/jetpack). The remaining tools can be installed by issuing the following command:
+
+```
+sudo apt-get install gfortran wget cmake
+```
+
+A full parallel build, including LLVM,
+will complete in around two hours. All tests pass and CUDA functionality is available
+through, e.g., [CUDAdrv](https://github.com/JuliaGPU/CUDAdrv.jl).
diff --git a/README.md b/README.md
index 43e19ece0f37ef..d6b9b28893ded3 100644
--- a/README.md
+++ b/README.md
@@ -1,7 +1,7 @@
 <a name="logo"/>
 <div align="center">
-<a href="http://julialang.org/" target="_blank">
-<img src="http://julialang.org/images/logo_hires.png" alt="Julia Logo" width="210" height="142"></img>
+<a href="https://julialang.org/" target="_blank">
+<img src="https://julialang.org/images/logo_hires.png" alt="Julia Logo" width="210" height="142"></img>
 </a>
 </div>
 
@@ -11,24 +11,23 @@ Windows: [![Build status](https://ci.appveyor.com/api/projects/status/dvial98s5v
 
 Code Coverage: [![Coverage Status](https://coveralls.io/repos/JuliaLang/julia/badge.svg?branch=master)](https://coveralls.io/r/JuliaLang/julia?branch=master) [![codecov.io](http://codecov.io/github/JuliaLang/julia/coverage.svg?branch=master)](http://codecov.io/github/JuliaLang/julia?branch=master)
 
-<a name="The-Julia-Language"/>
 ## The Julia Language
 
 Julia is a high-level, high-performance dynamic language for technical computing.
-The main homepage for Julia can be found at [julialang.org](http://julialang.org/).
+The main homepage for Julia can be found at [julialang.org](https://julialang.org/).
 This is the GitHub repository of Julia source code, including instructions for compiling and installing Julia, below.
 
-<a name="Resources"/>
 ## Resources
 
-- **Homepage:** <http://julialang.org>
-- **Binaries:** <http://julialang.org/downloads/>
-- **Documentation:** <http://docs.julialang.org/>
+- **Homepage:** <https://julialang.org>
+- **Binaries:** <https://julialang.org/downloads/>
+- **Documentation:** <https://docs.julialang.org/>
 - **Packages:** <http://pkg.julialang.org/>
 - **Source code:** <https://github.com/JuliaLang/julia>
 - **Git clone URL:** <git://github.com/JuliaLang/julia.git>
 - **Discussion forum:** <https://discourse.julialang.org>
-- **Mailing lists:** <http://julialang.org/community/>
+- **Mailing lists:** <https://julialang.org/community/>
+- **Slack:** <https://julialang.slack.com> (get an invite from <https://slackinvite.julialang.org>)
 - **Gitter:** <https://gitter.im/JuliaLang/julia>
 - **IRC:** <http://webchat.freenode.net/?channels=julia>
 - **Code coverage:** <https://coveralls.io/r/JuliaLang/julia>
@@ -36,27 +35,37 @@ This is the GitHub repository of Julia source code, including instructions for c
 New developers may find the notes in [CONTRIBUTING](https://github.com/JuliaLang/julia/blob/master/CONTRIBUTING.md) helpful to start contributing to the Julia codebase.
 
 ### External Resources
-<a name="External-Resources"/>
 
 - [**StackOverflow**](https://stackoverflow.com/questions/tagged/julia-lang)
 - [**Youtube**](https://www.youtube.com/channel/UC9IuUwwE2xdjQUT_LMLONoA)
 - [**Twitter**](https://twitter.com/JuliaLanguage)
 - [**Meetup**](http://julia.meetup.com/)
 
-<a name="Currently-Supported-Platforms"/>
 ## Currently Supported Platforms
 
-- **Linux**
-- **MacOS**
-- **FreeBSD**
-- **Windows**
+Julia is built and tested regularly on the following platforms:
+
+| Operating System | Architecture     | CI | Binaries | Support Level |
+|:----------------:|:----------------:|:--:|:--------:|:-------------:|
+| Linux 2.6.18+    | x86-64 (64-bit)  | ✓  | ✓        | Official      |
+|                  | i686 (32-bit)    | ✓  | ✓        | Official      |
+|                  | ARM v7 (32-bit)  |    | ✓        | Official      |
+|                  | ARM v8 (64-bit)  |    | ✓        | Official      |
+|                  | PowerPC (64-bit) |    |          | Community     |
+| macOS 10.8+      | x86-64 (64-bit)  | ✓  | ✓        | Official      |
+| Windows 7+       | x86-64 (64-bit)  | ✓  | ✓        | Official      |
+|                  | i686 (32-bit)    | ✓  | ✓        | Official      |
+| FreeBSD 11.0+    | x86-64 (64-bit)  | ✓  |          | Community     |
+
+All systems marked with ✓ for CI are tested using continuous integration for every commit.
+Systems with ✓ for binaries have official binaries available on the [downloads](https://julialang.org/downloads) page and are tested regularly.
+The systems listed here with neither CI nor official binaries are known to build and work, but ongoing support for those platforms is dependent on community efforts.
+It's possible that Julia will build and work on other platforms too, and we're always looking to better our platform coverage.
+If you're using Julia on a platform not listed here, let us know!
 
-All systems are supported with both x86/64 (64-bit) and x86 (32-bit, except MacOS) architectures. Support for [ARM](https://github.com/JuliaLang/julia/blob/master/README.arm.md), AARCH64, and POWER8 (little-endian) has been added recently.
-
-<a name="Source-Download-and-Compilation"/>
 ## Source Download and Compilation
 
-First, make sure you have all the [required dependencies](#Required-Build-Tools-External-Libraries) installed.
+First, make sure you have all the [required dependencies](#required-build-tools-and-external-libraries) installed.
 Then, acquire the source code by cloning the git repository:
 
     git clone git://github.com/JuliaLang/julia.git
@@ -67,12 +76,12 @@ Then, 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.5` 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.6` series of releases. You can get this version by changing to the Julia directory and running
 
-    git checkout release-0.5
+    git checkout v0.6.0
 
 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. (See [Platform Specific Build Notes](https://github.com/JuliaLang/julia#platform-specific-build-notes) for details.)
-When compiled the first time, it will automatically download and build its [external dependencies](#Required-Build-Tools-External-Libraries).
+When compiled the first time, it will automatically download and build its [external dependencies](#required-build-tools-and-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.
 
@@ -80,7 +89,7 @@ For builds of julia starting with 0.5.0-dev, you can create out-of-tree builds o
 
 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 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).
+**Note:** the build process will 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
 - add an alias (in `bash`: `echo "alias julia='/path/to/install/folder/bin/julia'" >> ~/.bashrc && source ~/.bashrc`), or
@@ -105,7 +114,7 @@ the `julia` source directory, type `make testall`. You should see output
 that lists a series of tests being run; if they complete without
 error, you should be in good shape to start using Julia.
 
-You can read about [getting started](http://docs.julialang.org/en/stable/manual/getting-started/) in the manual.
+You can read about [getting started](https://docs.julialang.org/en/stable/manual/getting-started/) in the manual.
 
 If you are building a Julia package for distribution on Linux, OS X,
 or Windows, take a look at the detailed notes in
@@ -171,12 +180,10 @@ latest version.
 
 
 
-<a name="Uninstalling-Julia"/>
 ## Uninstalling Julia
 
 Julia does not install anything outside the directory it was cloned into. Julia can be completely uninstalled by deleting this directory. Julia packages are installed in `~/.julia` by default, and can be uninstalled by deleting `~/.julia`.
 
-<a name="Platform-Specific-Notes"/>
 ## Platform-Specific Build Notes
 
 ### Linux
@@ -186,20 +193,20 @@ Julia does not install anything outside the directory it was cloned into. Julia
 * GCC version 4.7 or later is required to build Julia.
 * To use external shared libraries not in the system library search path, set `USE_SYSTEM_XXX=1` and `LDFLAGS=-Wl,-rpath,/path/to/dir/contains/libXXX.so` in `Make.user`.
   * Instead of setting `LDFLAGS`, putting the library directory into the environment variable `LD_LIBRARY_PATH` (at both compile and run time) also works.
-* See also the [external dependencies](#Required-Build-Tools-External-Libraries).
+* See also the [external dependencies](#required-build-tools-and-external-libraries).
 
 #### Architecture Customization
 
 Julia can be built for a non-generic architecture by configuring the `ARCH` Makefile variable. See the appropriate section of `Make.inc` for additional customization options, such as `MARCH` and `JULIA_CPU_TARGET`.
 
-For example, to build for Pentium 4, set `MARCH=pentium4` and install the necessary system libraries for linking. On Ubuntu, these may include lib32gfortran3 (also manually call `ln -s /usr/lib32/libgfortran3.so.0 /usr/lib32/libgfortran3.so`) and lib32gcc1, lib32stdc++6, among others.
+For example, to build for Pentium 4, set `MARCH=pentium4` and install the necessary system libraries for linking. On Ubuntu, these may include lib32gfortran-6-dev, lib32gcc1, and lib32stdc++6, among others.
 
 You can also set `MARCH=native` for a maximum-performance build customized for the current machine CPU.
 
 
 #### Ubuntu
 
-The [julia-deps PPA](https://launchpad.net/~staticfloat/+archive/julia-deps/) contains updated packages for Julia dependencies if you want to use system libraries instead of having them downloaded and built during the build process.  See [System Provided Libraries](#System-Provided-Libraries).
+The [julia-deps PPA](https://launchpad.net/~staticfloat/+archive/julia-deps/) contains updated packages for Julia dependencies if you want to use system libraries instead of having them downloaded and built during the build process.  See [System Provided Libraries](#system-provided-libraries).
 
 #### RHEL/CentOS 6
 
@@ -232,20 +239,24 @@ When building Julia, or its dependencies, libraries installed by third party pac
 
 ### FreeBSD
 
-On *FreeBSD Release 11.0*, install the gfortran, git, cmake, and gmake packages/ports (`pkg install gcc6 gmake git cmake`), and compile Julia with the command:
-
-    $ echo 'FC=gfortran6' >> Make.user
-    $ gmake
-
-You must use the `gmake` command on FreeBSD instead of `make`.
+Clang is the default compiler on FreeBSD 11.0-RELEASE and above.
+The remaining build tools are available from the Ports Collection, and can be installed using `pkg install git gcc gmake cmake`.
+To build Julia, simply run `gmake`.
+(Note that `gmake` must be used rather than `make`, since `make` on FreeBSD corresponds to the incompatible BSD Make rather than GNU Make.)
 
-Note that Julia is community-supported and we have little control over our upstream dependencies, you may still run into issues with dependencies and YMMV. Current known issues include:
+It's important to note that the `USE_SYSTEM_*` flags should be used with caution on FreeBSD.
+This is because many system libraries, and even libraries from the Ports Collection, link to the system's `libgcc_s.so.1`,
+or to another library which links to the system `libgcc_s`.
+This library declares its GCC version to be 4.6, which is too old to build Julia, and conflicts with other libraries when linking.
+Thus it is highly recommended to simply allow Julia to build all of its dependencies.
+If you do choose to use the `USE_SYSTEM_*` flags, note that `/usr/local` is not on the compiler path by default, so you may need
+to add `LDFLAGS=-L/usr/local/lib` and `CPPFLAGS=-I/usr/local/include` to your `Make.user`, though doing so may interfere with
+other dependencies.
 
- - The x86 arch doesn't support threading due to lack of compiler runtime library support (set `JULIA_THREADS=0`).
- - OpenBLAS patches in pkg haven't been upstreamed.
- - gfortran can't link binaries. Set `FFLAGS=-Wl,-rpath,/usr/local/lib/gcc6` to work around this (upstream bug submitted to FreeBSD pkg maintainers).
- - System libraries installed by pkg are not on the compiler path by default. You may need to add `LDFLAGS=-L/usr/local/lib` and `CPPFLAGS=-I/usr/local/include` to your environment or `Make.user` file to build successfully.
+Some known issues on FreeBSD are:
 
+* The x86 architecture does not support threading due to lack of compiler runtime library support, so you may need to
+  set `JULIA_THREADS=0` in your `Make.user` if you're on a 32-bit system.
 
 ### Windows
 
@@ -255,7 +266,6 @@ In order to build Julia on Windows, see [README.windows](https://github.com/Juli
 
 Julia can be developed in an isolated Vagrant environment. See [the Vagrant README](https://github.com/JuliaLang/julia/blob/master/contrib/vagrant/README.md) for details.
 
-<a name="Required-Build-Tools-External-Libraries"/>
 ## Required Build Tools and External Libraries
 
 Building Julia requires that the following software be installed:
@@ -285,7 +295,6 @@ Julia uses the following external libraries, which are automatically downloaded
 - **[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]** (>= 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.
@@ -317,23 +326,20 @@ Julia uses the following external libraries, which are automatically downloaded
 [SuiteSparse]:  http://faculty.cse.tamu.edu/davis/suitesparse.html
 [AMOS]:         http://netlib.org/amos
 [ARPACK]:       http://forge.scilab.org/index.php/p/arpack-ng
-[FFTW]:         http://www.fftw.org
 [PCRE]:         http://www.pcre.org
 [LLVM]:         http://www.llvm.org
 [FemtoLisp]:    https://github.com/JeffBezanson/femtolisp
 [GMP]:          http://gmplib.org
 [MPFR]:         http://www.mpfr.org
-[double-conversion]: http://double-conversion.googlecode.com
 [libuv]:        https://github.com/JuliaLang/libuv
 [libgit2]:      https://libgit2.github.com/
-[utf8proc]:     http://julialang.org/utf8proc/
+[utf8proc]:     https://julialang.org/utf8proc/
 [libosxunwind]: https://github.com/JuliaLang/libosxunwind
 [libunwind]:    http://www.nongnu.org/libunwind
 [libssh2]:      https://www.libssh2.org
 [mbedtls]:      https://tls.mbed.org/
 [pkg-config]:   https://www.freedesktop.org/wiki/Software/pkg-config/
 
-<a name="System-Provided-Libraries">
 ### System Provided Libraries
 
 If you already have one or more of these packages installed on your system, you can prevent Julia from compiling duplicates of these libraries by passing `USE_SYSTEM_...=1` to `make` or adding the line to `Make.user`. The complete list of possible flags can be found in `Make.inc`.
@@ -360,12 +366,10 @@ Add the following to the `Make.user` file:
     USEICC = 1
     USEIFC = 1
     USE_INTEL_MKL = 1
-    USE_INTEL_MKL_FFT = 1
     USE_INTEL_LIBM = 1
 
 It is highly recommended to start with a fresh clone of the Julia repository.
 
-<a name="Source-Code-Organization"/>
 ## Source Code Organization
 
 The Julia source code is organized as follows:
@@ -382,10 +386,9 @@ The Julia source code is organized as follows:
     ui/            source for various front ends
     usr/           binaries and shared libraries loaded by Julia's standard libraries
 
-<a name="Binary-Installation"/>
 ## Binary Installation
 
-If you would rather not compile the latest Julia from source, platform-specific tarballs with pre-compiled binaries are also [available for download](http://julialang.org/downloads/).
+If you would rather not compile the latest Julia from source, platform-specific tarballs with pre-compiled binaries are also [available for download](https://julialang.org/downloads/).
 
 You can either run the `julia` executable using its full path in the directory created above, or add that directory to your executable path so that you can run the Julia program from anywhere (in the current shell session):
 
@@ -398,7 +401,7 @@ Now you should be able to run Julia like this:
 On Windows, double-click `usr/bin/julia.exe`.
 
 If everything works correctly, you will see a Julia banner and an interactive prompt into which you can enter expressions for evaluation.
-You can read about [getting started](http://julialang.org/manual/getting-started) in the manual.
+You can read about [getting started](https://julialang.org/manual/getting-started) in the manual.
 
 The following distributions include julia, but the versions may be out of date due to rapid development:
 
@@ -419,8 +422,8 @@ The following distributions include julia, but the versions may be out of date d
   * [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/)
+* [FreeBSD Ports](https://www.freshports.org/lang/julia/)
 
-<a name="Editor-Terminal-Setup"/>
 ## Editor and Terminal Setup
 
 Currently, Julia editing mode support is available for a number of
@@ -440,4 +443,4 @@ is available through
 [Sublime-IJulia](https://github.com/quinnj/Sublime-IJulia) plugin
 enables interaction between IJulia and Sublime Text.
 
-In the terminal, Julia makes great use of both control-key and meta-key bindings. To make the meta-key bindings more accessible, many terminal emulator programs (e.g., `Terminal`, `iTerm`, `xterm`, etc.) allow you to use the alt or option key as meta.  See the section in the manual on [interacting with Julia](http://docs.julialang.org/en/latest/manual/interacting-with-julia/) for more details.
+In the terminal, Julia makes great use of both control-key and meta-key bindings. To make the meta-key bindings more accessible, many terminal emulator programs (e.g., `Terminal`, `iTerm`, `xterm`, etc.) allow you to use the alt or option key as meta.  See the section in the manual on [interacting with Julia](https://docs.julialang.org/en/latest/manual/interacting-with-julia) for more details.
diff --git a/README.windows.md b/README.windows.md
index 91655d5e18da92..05a31ee1f31044 100644
--- a/README.windows.md
+++ b/README.windows.md
@@ -1,198 +1,182 @@
-# General Information for Windows
+# Julia on Windows
 
 This file describes how to install, or build, and use Julia on Windows.
-For more general information about Julia, please see the [main README](https://github.com/JuliaLang/julia/blob/master/README.md) or the [documentation](http://docs.julialang.org/).
 
-# Unicode font support
+For more general information about Julia, please see the
+[main README](https://github.com/JuliaLang/julia/blob/master/README.md)
+or the [documentation](https://docs.julialang.org/).
 
-The built-in Windows fonts have rather poor coverage of the Unicode character space.
-The free [`DejaVu Sans Mono`](http://dejavu-fonts.org/) font can be used as a replacement font in the Windows console.
-Since Windows 2000, simply downloading the font and installing it is insufficient, since Windows keeps a list of approved fonts in the registry.
 
-Instructions for adding fonts to the terminal are available at:
-[http://support.microsoft.com/default.aspx?scid=kb;EN-US;Q247815](http://support.microsoft.com/default.aspx?scid=kb;EN-US;Q247815)
+## General Information for Windows
 
 
-Additionally, rather than sticking with the default command prompt, you may want to use a different terminal emulator program, such as [`Conemu`](https://code.google.com/p/conemu-maximus5/) or [`Mintty`](https://code.google.com/p/mintty/)
-(note that running Julia on Mintty needs a copy of `stty.exe` in your `%PATH%` to work properly).
-Alternatively, you may prefer the features of a more full-function IDE, such as [`Juno`](http://junolab.org), [`LightTable`](https://github.com/one-more-minute/Jupiter-LT), [`Sublime-IJulia`](https://github.com/quinnj/Sublime-IJulia), or [`IJulia`](https://github.com/JuliaLang/IJulia.jl).
+### Unicode font support
 
+The built-in Windows fonts have rather poor coverage of the Unicode character
+space.  The free [`DejaVu Sans Mono`](http://dejavu-fonts.org/) font can be used
+as a replacement font in the Windows console.  Since Windows 2000, simply
+downloading the font and installing it is insufficient, since Windows keeps a
+list of approved fonts in the registry.
 
-# Binary distribution
-
-Julia runs on Windows 7 and later.
-Both the 32-bit and 64-bit versions are supported.
-The 32-bit (i686) binary will run on either a 32-bit and 64-bit operating system.
-The 64-bit (x86_64) binary will only run on 64-bit Windows and will otherwise refuse to launch.
-
-1. [Download](http://julialang.org/downloads) the latest version of Julia. Extract the binary to a reasonable destination folder, e.g. `C:\julia`.
-
-2. Double-click the `julia` shortcut to launch Julia.
-
-3. Julia's home directory is the location pointed to by the Windows environment variable `HOME`: this directory is for instance where the startup file `.juliarc.jl` resides. `HOMEDRIVE`\\`HOMEPATH` is used as a fallback if `HOME` is not defined.
+Instructions for adding fonts to the terminal are available at
+[this answer on superuser.com](https://superuser.com/a/5079)
 
+Additionally, rather than sticking with the default command prompt, you may want
+to use a different terminal emulator program, such as
+[Conemu](https://code.google.com/p/conemu-maximus5/) or [Mintty](
+https://github.com/mintty/mintty) (note that running Julia on Mintty needs a
+copy of `stty.exe` in your `%PATH%` to work properly).  Alternatively, you may
+prefer the features of a more full-function IDE, such as [Juno](http://junolab.org),
+[Sublime-IJulia](https://github.com/quinnj/Sublime-IJulia), or
+[IJulia](https://github.com/JuliaLang/IJulia.jl).
 
-# Line endings
 
-Julia uses binary-mode files exclusively. Unlike many other Windows programs, if you write '\n' to a file, you get a '\n' in the file, not some other bit pattern. This matches the behavior exhibited by other operating systems. If you have installed msysGit, it is suggested, but not required, that you configure your system msysGit to use the same convention:
-
-    git config --global core.eol lf
-    git config --global core.autocrlf input
+### Line endings
 
+Julia uses binary-mode files exclusively.  Unlike many other Windows programs,
+if you write `\n` to a file, you get a `\n` in the file, not some other bit
+pattern.  This matches the behavior exhibited by other operating systems.  If
+you have installed Git for Windows, it is suggested, but not required, that you
+configure your system Git to use the same convention:
+```sh
+git config --global core.eol lf
+git config --global core.autocrlf input
+```
 or edit `%USERPROFILE%\.gitconfig` and add/edit the lines:
-
-    [core] eol = lf
-           autocrlf = input
-
-
-# Source distribution
-
-## Supported build platforms
-- Windows 10: supported (32 and 64 bits)
-- Windows 8: supported (32 and 64 bits)
-- Windows 7: supported (32 and 64 bits)
-- Windows Vista: not officially supported (but probably works anyways)
-- Windows XP: not supported (but may work anyways, if you can get around the lack of junction points)
-
-## Compiling with MinGW/MSYS2
-
-### MSYS2 provides a robust MSYS experience.
-
-1. Install [Python 2.x](http://www.python.org/downloads/). Do **not** install Python 3.
-
-2. Install [CMake](http://www.cmake.org/download/).
-
-3. Install and configure [MSYS2](https://msys2.github.io), a minimal POSIX-like environment for Windows.
-
-  1. Download and run the latest installer for the [32-bit](http://sourceforge.net/projects/msys2/files/Base/i686/) or [64-bit](http://sourceforge.net/projects/msys2/files/Base/x86_64/) distribution. The installer will have a name like `msys2-i686-yyyymmdd.exe` or `msys2-x86_64-yyyymmdd.exe`.
-
-  2. Double-click `msys2_shell.bat` in the installed msys directory. Initialize the MSYS2 base system using the `pacman` package manager included in MSYS2:
-
-     ```
-    update-core
-    pacman --needed -Sy bash pacman pacman-mirrors msys2-runtime # if update-core is not available
-    pacman -Syu           #Update package database and full system upgrade
 ```
-
-  3. Exit and restart MSYS2, then install packages required to build julia:
-
-     ```
-    pacman -S diffutils git m4 make patch tar p7zip msys/openssh ca-certificates
+[core]
+    eol = lf
+    autocrlf = input
 ```
 
-  4. Configure your MSYS2 shell so Python is visible on the path:
+## Binary distribution
 
-     ```
-    echo "export PATH=/usr/local/bin:/usr/bin:/opt/bin:/C/Python27" >> ~/.bashrc
-```
+Julia runs on Windows 7 and later.
+Both the 32-bit and 64-bit versions are supported.
+The 32-bit (i686) binary will run on either a 32-bit and 64-bit operating system.
+The 64-bit (x86_64) binary will only run on 64-bit Windows and will otherwise refuse to launch.
 
-     *N.B.* The `export` clobbers whatever `$PATH` is already defined. This is suggested to avoid path-masking. If you use MSYS2 for purposes other than building Julia, you may prefer to append rather than clobber.
+ 1. [Download](https://julialang.org/downloads) the latest version of Julia.
+    Extract the binary to a reasonable destination folder, e.g. `C:\julia`.
 
-     *N.B.* All of the path separators are unix-style. In MSYS2, `/C/` means the root of your `C:\` drive. Replace `/C/Python27` with the location where you installed Python.
+ 2. Double-click the `julia` shortcut to launch Julia.
 
+ 3. Julia's home directory is the location pointed to by the Windows environment
+    variable `%HOME%`: this directory is for instance where the startup file
+    `.juliarc.jl` resides. `%HOMEDRIVE%\%HOMEPATH%` is used as a fallback if
+    `%HOME%` is not defined.
 
-  5. Configuration of MSYS2 is complete. Now `exit` the MSYS2 shell.
+## Source distribution
 
-4. Build Julia and its dependencies from source.
-  1. Open a new MSYS2 shell and clone the Julia sources
-     ```
-    git clone https://github.com/JuliaLang/julia.git
-    cd julia
-```
+### Supported build platforms
 
-  2. Run the following script to download the correct versions of the MinGW-w64 compilers
-     ```
-    contrib/windows/get_toolchain.sh 32  # for 32 bit Julia
-    # or
-    contrib/windows/get_toolchain.sh 64  # for 64 bit Julia
-```
-     Then follow the printed instructions by running either
-     ```
-    export PATH=$PWD/usr/i686-w64-mingw32/sys-root/mingw/bin:$PATH  # for 32 bit Julia
-    # or
-    export PATH=$PWD/usr/x86_64-w64-mingw32/sys-root/mingw/bin:$PATH  # for 64 bit Julia
-```
-     to add the downloaded MinGW-w64 compilers to your path (temporarily, only needed during the shell session when you build Julia).
+ -  Windows 10: supported (32 and 64 bits)
+ -  Windows 8: supported (32 and 64 bits)
+ -  Windows 7: supported (32 and 64 bits)
 
-  3. Specify the location where you installed CMake
+### Cygwin-to-MinGW cross-compiling
 
-     ```
-    echo 'override CMAKE=/C/path/to/CMake/bin/cmake.exe' > Make.user
-```
+The recommended way of compiling Julia from source on Windows is by cross
+compiling from [Cygwin](http://www.cygwin.com), using versions of the
+MinGW-w64 compilers available through Cygwin's package manager.
 
-  4. Start the build
-     ```
-    make -j 4   # Adjust the number of cores (4) to match your build environment.
-```
+ 1. Download and run Cygwin setup for [32 bit](http://cygwin.com/setup-x86.exe)
+    or [64 bit](http://cygwin.com/setup-x86_64.exe). Note, that you can compile
+    either 32 or 64 bit Julia from either 32 or 64 bit Cygwin. 64 bit Cygwin
+    has a slightly smaller but often more up-to-date selection of packages.
 
-5. Setup Package Development Environment
-  1. The `Pkg` module in Base provides many convenient tools for [developing and publishing packages](http://docs.julialang.org/en/latest/manual/packages/).
-  One of the packages added through pacman above was `openssh`, which will allow secure access to GitHub APIs.
-  Follow GitHub's [guide](https://help.github.com/articles/generating-ssh-keys) to setting up SSH keys to ensure your local machine can communicate with GitHub effectively.
+    Advanced: you may skip steps 2-4 by running:
 
-  2. In case of the issues with building packages (i.e. ICU fails to build with the following error message ```error compiling xp_parse: error compiling xp_make_parser: could not load module libexpat-1: %```) run ```make win-extras``` and then copy everything from the ```dist-extras``` folder into ```usr/bin```.
+        setup-x86_64.exe -s <url> -q -P cmake,gcc-g++,git,make,patch,curl,m4,python,p7zip,mingw64-i686-gcc-g++,mingw64-i686-gcc-fortran,mingw64-x86_64-gcc-g++,mingw64-x86_64-gcc-fortran
+        :: replace <url> with a site from https://cygwin.com/mirrors.html
+        :: or run setup manually first and select a mirror
 
-## Cygwin-to-MinGW cross compiling
+ 2. Select installation location and download mirror.
 
-Julia can be also compiled from source in [Cygwin](http://www.cygwin.com), using versions of the MinGW-w64 compilers available through Cygwin's package manager.
+ 3. At the '*Select Packages'* step, select the following:
 
-1. Download and run Cygwin setup for [32 bit](http://cygwin.com/setup-x86.exe) or [64 bit](http://cygwin.com/setup-x86_64.exe). Note that you can compile either 32 or 64 bit Julia from either 32 or 64 bit Cygwin. 64 bit Cygwin has a slightly smaller but often more up-to-date selection of packages.
+    1.  From the *Devel* category: `cmake`, `gcc-g++`, `git`, `make`, `patch`
+    2.  From the *Net* category: `curl`
+    3.  From *Interpreters* (or *Python*) category: `m4`, `python`
+    4.  From the *Archive* category: `p7zip`
+    5.  For 32 bit Julia, and also from the *Devel* category:
+        `mingw64-i686-gcc-g++` and `mingw64-i686-gcc-fortran`
+    6.  For 64 bit Julia, and also from the *Devel* category:
+        `mingw64-x86_64-gcc-g++` and `mingw64-x86_64-gcc-fortran`
 
-2. Select installation location and download mirror.
+ 4. At the *'Resolving Dependencies'* step, be sure to leave *'Select required
+    packages (RECOMMENDED)'* enabled.
 
-3. At the "Select Packages" step, select the following:
-  1. `git` (under `Devel` category)
-  2. `make` (under `Devel` category)
-  3. `curl` (under `Net` category)
-  4. `patch` (under `Devel` category)
-  5. `python` (under `Interpreters` or `Python` category)
-  6. `gcc-g++` (under `Devel` category)
-  7. `m4` (under `Interpreters` category)
-  8. `cmake` (under `Devel` category)
-  9. `p7zip` (under `Archive` category)
-  10. `mingw64-i686-gcc-g++` and `mingw64-i686-gcc-fortran` (for 32 bit Julia, under `Devel` category)
-  11. `mingw64-x86_64-gcc-g++` and `mingw64-x86_64-gcc-fortran` (for 64 bit Julia, under `Devel` category)
+ 5. Allow Cygwin installation to finish, then start from the installed shortcut
+    a *'Cygwin Terminal'*, or *'Cygwin64 Terminal'*, respectively.
 
-4. At the "Resolving Dependencies" step, be sure to leave "Select required packages (RECOMMENDED)" enabled.
+ 6. Build Julia and its dependencies from source:
 
-5. Allow Cygwin installation to finish, then start a "Cygwin Terminal" (or "Cygwin64 Terminal") from the installed shortcut.
+    1. Get the Julia sources
+       ```sh
+       git clone https://github.com/JuliaLang/julia.git
+       cd julia
+       ```
+       Tip: If you get an `error: cannot fork() for fetch-pack: Resource
+       temporarily unavailable` from git, add `alias git="env PATH=/usr/bin git"`
+       to `~/.bashrc` and restart Cygwin.
 
-6. Build Julia and its dependencies from source.
-  1. Get the Julia sources
-     ```
-    git clone --recursive https://github.com/JuliaLang/julia.git
-    cd julia
-```
-     *Tips:*
-     - If you get an `error: cannot fork() for fetch-pack: Resource temporarily unavailable` from git, add `alias git="env PATH=/usr/bin git"` to `~/.bashrc` and restart Cygwin.
+    2. Set the `XC_HOST` variable in `Make.user` to indicate MinGW-w64 cross
+       compilation
+       ```sh
+       echo 'XC_HOST = i686-w64-mingw32' > Make.user     # for 32 bit Julia
+       # or
+       echo 'XC_HOST = x86_64-w64-mingw32' > Make.user   # for 64 bit Julia
+       ```
 
-  2. Set the `XC_HOST` variable in `Make.user` to indicate MinGW-w64 cross compilation
+    3. Start the build
+       ```sh
+       make -j 4   # Adjust the number of cores (4) to match your build environment.
+       ```
 
-     For 32 bit Julia
-     ```
-    echo 'XC_HOST = i686-w64-mingw32' > Make.user
-```
-     For 64 bit Julia
-     ```
-    echo 'XC_HOST = x86_64-w64-mingw32' > Make.user
-```
 
-  3. Start the build
-    ```
-    make -j 4   # Adjust the number of cores (4) to match your build environment.
-```
+    > Protip: build both!
+    > ```sh
+    > make O=julia-win32 configure
+    > make O=julia-win64 configure
+    > echo 'XC_HOST = i686-w64-mingw32' > julia-win32/Make.user
+    > echo 'XC_HOST = x86_64-w64-mingw32' > julia-win64/Make.user
+    > echo 'ifeq ($(BUILDROOT),$(JULIAHOME))
+    >         $(error "in-tree build disabled")
+    >       endif' >> Make.user
+    > make -C julia-win32  # build for Windows x86 in julia-win32 folder
+    > make -C julia-win64  # build for Windows x86-64 in julia-win64 folder
+    > ```
 
-7. Run Julia using the Julia executables directly
-    ```
+ 7. Run Julia using the Julia executables directly
+    ```sh
     usr/bin/julia.exe
     usr/bin/julia-debug.exe
-```
+    ```
+
+### Compiling with MinGW/MSYS2
+
+Compiling Julia from source using [MSYS2](https://msys2.github.io) has worked
+in the past but is not actively supported. Pull requests to restore support
+would be welcome. See a [past version of this file](
+https://github.com/JuliaLang/julia/blob/v0.6.0/README.windows.md)
+for the former instructions for compiling using MSYS2.
 
-## Cross-compiling from Unix
 
-If you prefer to cross-compile, the following steps should get you started.
+### Cross-compiling from Unix
+
+You can also use MinGW-w64 cross compilers to build a Windows version of Julia from
+Linux, Mac, or the Windows Subsystem for Linux (WSL). Note that when compiling in
+WSL, you should use the Linux file system environment, not the `/mnt/` emulated Windows
+paths, since time stamps in `/mnt/` do not work properly as required by configure
+scripts and makefiles (see https://github.com/Microsoft/BashOnWindows/issues/1939).
+
+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 42.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`:
 
-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,10 +185,10 @@ $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.2/windows:mingw:win$BITS.repo
+zypper addrepo http://download.opensuse.org/repositories/windows:mingw:win$BITS/openSUSE_Leap_42.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
+    python python-xml patch gcc-c++ m4 p7zip.i586 libxml2-tools winbind
 zypper -n install mingw$BITS-cross-gcc-c++ mingw$BITS-cross-gcc-fortran \
     mingw$BITS-libstdc++6 mingw$BITS-libgfortran3 mingw$BITS-libssp0
 # opensuse packages the mingw runtime dlls under sys-root/mingw/bin, not /usr/lib64/gcc
@@ -218,7 +202,7 @@ make -j4 binary-dist
 SCRIPT
 
 Vagrant.configure("2") do |config|
-  config.vm.box = "bento/opensuse-13.2"
+  config.vm.box = "bento/opensuse-leap-42.2"
   config.vm.provider :virtualbox do |vb|
     # Use VBoxManage to customize the VM. For example to change memory:
     vb.memory = 2048
@@ -227,85 +211,57 @@ Vagrant.configure("2") do |config|
 end
 ```
 
-### Cross-building Julia without Vagrant
-
-If you don't care that the build is potentially incompatible with the WinRPM ecosystem (or happen to be on opensuse), use the following steps to cross-compile julia:
 
-First, you will need to ensure your system has the required dependencies. We need wine (>=1.7.5),
-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 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/)),
-and [MacPorts](http://www.macports.org/install.php) or [Homebrew](http://mxcl.github.io/homebrew/).
-Then run ```port install wine wget``` or ```brew install wine wget```, as appropriate.
-
-On Both:
-
-Unfortunately, the version of gcc installed by Ubuntu targets pthreads.
-On Mac, the situation is similar: the version in MacPorts is very old and Homebrew does not have it.
-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://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
-  b. add `fortran` to the end of `--enable-languages=c,c++,objc,obj-c++`
-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.
+### Cross-building Julia without Vagrant
 
-Then we can essentially just repeat these steps for the 32-bit compiler, reusing some of the work:
+If you don't care that the build is potentially incompatible with the WinRPM
+ecosystem (or happen to be on opensuse), use the following steps to cross-
+compile julia:
 
-7. `cd ..`
-8. `cp -a mingw-w64-dgn mingw-w32-dgn`
-9. `cd mingw-w32-dgn`
-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.
+First, you will need to ensure your system has the required dependencies.  We
+need wine (>=1.7.5), a system compiler, and some downloaders.
 
-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).
+**On Ubuntu** (on other linux systems, the dependency names are likely to be similar):
+```sh
+apt-get install wine subversion cvs gcc wget p7zip-full winbind mingw-w64
+```
 
-@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 (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)
+**On Mac**: Install XCode, XCode command line tools, X11 (now [XQuartz](
+http://xquartz.macosforge.org/)), and [MacPorts](http://www.macports.org/install.php)
+or [Homebrew](https://brew.sh/).  Then run `port install wine wget mingw-w64`,
+or `brew install wine wget mingw-w64`, as appropriate.
 
 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`)
-5. `make binary-dist`
-6. move the julia-*.exe installer to the target machine
+ 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`)
+ 5. `make binary-dist`
+ 6. move the `julia-*.exe` installer to the target machine
+
+If you are building for 64-bit windows, the steps are essentially the same.
+Just replace `i686` in `XC_HOST` with `x86_64`. (note: on Mac, wine only runs
+in 32-bit mode).
 
-If you are building for 64-bit windows, the steps are essentially the same. Just replace i686 in XC_HOST with x86_64. (note: on Mac, wine only runs in 32-bit mode).
 
 ## Debugging a cross-compiled build under wine
 
-The most effective way to debug a cross-compiled version of julia on the cross-compilation
-host is to install a windows version of gdb and run it under wine as usual. The pre-built packages
-available [as part of the MSYS2 project](https://sourceforge.net/projects/msys2/files/REPOS/MINGW/)
-are known to work. Apart from the GDB package you may also need the python and termcap packages.
-Finally, GDB's prompt may not work when launch from the command line. This can be worked around
-by prepending `wineconsole` to the regular GDB invocation.
+The most effective way to debug a cross-compiled version of julia on the cross-
+compilation host is to install a windows version of gdb and run it under wine as
+usual. The pre-built packages available [as part of the MSYS2 project](
+https://sourceforge.net/projects/msys2/files/REPOS/MINGW/) are known to work.
+Apart from the GDB package you may also need the python and termcap packages.
+Finally, GDB's prompt may not work when launch from the command line. This can
+be worked around by prepending `wineconsole` to the regular GDB invocation.
+
 
 ## Using a Windows VM
 
 [Vagrant](http://www.vagrantup.com/downloads) can also be used with a Windows
 guest VM via the `Vagrantfile` in [contrib/windows](contrib/windows/Vagrantfile),
-just run `vagrant up` from that folder. To build with Cygwin instead of MSYS2,
-replace `config.vm.provision :shell, privileged: false, :inline => $script_msys2`
-(near the end of the file) with `config.vm.provision :shell, privileged: false, :inline => $script_cygwin`.
+just run `vagrant up` from that folder.
+
 
 ## After compiling
 
@@ -315,33 +271,48 @@ If you need these components, the easiest way to get them is to build the instal
 yourself using ```make win-extras``` followed by ```make binary-dist```, and then
 running the resulting installer.
 
+
 ## Windows Build Debugging
 
+
 ### GDB hangs with cygwin mintty
 
-- Run gdb under the windows console (cmd) instead. gdb [may not function properly](https://www.cygwin.com/ml/cygwin/2009-02/msg00531.html) under mintty with non-cygwin applications. You can use `cmd /c start` to start the windows console from mintty if necessary.
+- Run gdb under the windows console (cmd) instead. gdb [may not function properly](
+  https://www.cygwin.com/ml/cygwin/2009-02/msg00531.html) under mintty with non-
+  cygwin applications. You can use `cmd /c start` to start the windows console
+  from mintty if necessary.
 
 ### GDB not attaching to the right process
 
-- Use the PID from the windows task manager or `WINPID` from the `ps` command instead of the PID from unix style command line tools (e.g. `pgrep`). You may need to add the PID column if it is not shown by default in the windows task manager.
+ - Use the PID from the windows task manager or `WINPID` from the `ps` command
+   instead of the PID from unix style command line tools (e.g. `pgrep`).  You
+   may need to add the PID column if it is not shown by default in the windows
+   task manager.
 
 ### GDB not showing the right backtrace
 
-- When attaching to the julia process, GDB may not be attaching to the right thread. Use `info threads` command to show all the threads and `thread <threadno>` to switch threads.
-- Be sure to use a 32 bit version of GDB to debug a 32 bit build of Julia, or a 64 bit version of GDB to debug a 64 bit build of Julia.
+ - When attaching to the julia process, GDB may not be attaching to the right
+   thread.  Use `info threads` command to show all the threads and
+   `thread <threadno>` to switch threads.
+ - Be sure to use a 32 bit version of GDB to debug a 32 bit build of Julia, or
+   a 64 bit version of GDB to debug a 64 bit build of Julia.
 
 ### Build process is slow/eats memory/hangs my computer
 
-- Disable the Windows [Superfetch](https://en.wikipedia.org/wiki/Windows_Vista_I/O_technologies#SuperFetch) and
-  [Program Compatibility Assistant](http://blogs.msdn.com/b/cjacks/archive/2011/11/22/managing-the-windows-7-program-compatibility-assistant-pca.aspx) services, as they are known to have
-  [spurious interactions]((https://cygwin.com/ml/cygwin/2011-12/msg00058.html)) with MinGW/Cygwin.
-
-  As mentioned in the link above: excessive memory use by `svchost` specifically may be investigated in the Task
-  Manager by clicking on the high-memory `svchost.exe` process and selecting `Go to Services`. Disable child services
-  one-by-one until a culprit is found.
-
-- Beware of [BLODA](https://cygwin.com/faq/faq.html#faq.using.bloda)
-
-  The [vmmap](http://technet.microsoft.com/en-us/sysinternals/dd535533.aspx) tool is indispensable for identifying
-  such software conflicts. Use vmmap to inspect the list of loaded DLLs for bash, mintty, or another persistent
-  process used to drive the build. Essentially *any* DLL outside of the Windows System directory is potential BLODA.
+ - Disable the Windows [Superfetch](https://en.wikipedia.org/wiki/Windows_Vista_I/O_technologies#SuperFetch)
+   and [Program Compatibility Assistant](
+   http://blogs.msdn.com/b/cjacks/archive/2011/11/22/managing-the-windows-7-program-compatibility-assistant-pca.aspx)
+   services, as they are known to have [spurious interactions](
+   https://cygwin.com/ml/cygwin/2011-12/msg00058.html) with MinGW/Cygwin.
+
+   As mentioned in the link above: excessive memory use by `svchost` specifically
+   may be investigated in the Task Manager by clicking on the high-memory
+   `svchost.exe` process and selecting `Go to Services`. Disable child services
+   one-by-one until a culprit is found.
+
+ - Beware of [BLODA](https://cygwin.com/faq/faq.html#faq.using.bloda).
+   The [vmmap](http://technet.microsoft.com/en-us/sysinternals/dd535533.aspx)
+   tool is indispensable for identifying such software conflicts. Use vmmap to
+   inspect the list of loaded DLLs for bash, mintty, or another persistent
+   process used to drive the build. Essentially *any* DLL outside of the Windows
+   System directory is potential BLODA.
diff --git a/VERSION b/VERSION
index fb0b754233e493..9e9aa6f93f9c51 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.6.0-dev
+0.7.0-DEV
diff --git a/appveyor.yml b/appveyor.yml
index 312c8da24cdef7..aa4dd3ed70c146 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -11,7 +11,7 @@ environment:
 branches:
   only:
     - master
-    - /release-.*/
+    - /^release-.*/
 
 skip_commits:
 # Add [av skip] to commit messages for docfixes, etc to reduce load on queue
@@ -31,10 +31,9 @@ init:
 
 cache:
 # Cache large downloads to avoid network unreliability
-  - 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.9.1-i686-w64-mingw32-juliadeps-r04.7z
-  - llvm-3.9.1-x86_64-w64-mingw32-juliadeps-r04.7z
+  - C:\cygdownloads
+  - llvm-3.9.1-i686-w64-mingw32-juliadeps-r07.7z
+  - llvm-3.9.1-x86_64-w64-mingw32-juliadeps-r07.7z
   - usr/bin/busybox.exe
 
 build_script:
@@ -46,14 +45,16 @@ build_script:
 # 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;=%
-# Remove C:\Perl\bin from the path, otherwise it breaks shasum with an error
-# Unable to find Digest::SHA or Digest::SHA::PurePerl
-  - set PATH=%PATH:C:\Perl\bin;=%
+# Remove git's msys2 from path, since it conflicts with cygwin1.dll
+  - set PATH=%PATH:C:\Program Files\Git\usr\bin;=%
+  - ps: contrib/windows/install-cygwin.ps1
 #  - '"%VS120COMNTOOLS%\..\..\VC\vcvarsall.bat" x86_amd64'
-  - C:\msys64\usr\bin\sh.exe --login /c/projects/julia/contrib/windows/msys_build.sh
+  - C:\cygwin-%ARCH%\bin\sh.exe --login /cygdrive/c/projects/julia/contrib/windows/appveyor_build.sh
 
 test_script:
   - usr\bin\julia -e "versioninfo()"
   - usr\bin\julia --precompiled=no -e "true"
-  - cd test && ..\usr\bin\julia --check-bounds=yes runtests.jl all &&
-      ..\usr\bin\julia --check-bounds=yes runtests.jl libgit2-online pkg
+  - cd julia-* && .\bin\julia.exe --check-bounds=yes share\julia\test\runtests.jl all &&
+      .\bin\julia.exe --check-bounds=yes share\julia\test\runtests.jl libgit2-online download pkg
+  - cd ..
+  - usr\bin\julia usr\share\doc\julia\examples\embedding\embedding-test.jl examples\embedding\embedding.exe
diff --git a/base/Enums.jl b/base/Enums.jl
index 48e9e63ecda605..a0ce5dc5692a33 100644
--- a/base/Enums.jl
+++ b/base/Enums.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module Enums
 
@@ -9,10 +9,10 @@ function basetype end
 
 abstract type Enum{T<:Integer} end
 
-Base.convert{T<:Integer}(::Type{Integer}, x::Enum{T}) = bitcast(T, x)
-Base.convert{T<:Integer,T2<:Integer}(::Type{T}, x::Enum{T2}) = convert(T, bitcast(T2, x))
-Base.write{T<:Integer}(io::IO, x::Enum{T}) = write(io, T(x))
-Base.read{T<:Enum}(io::IO, ::Type{T}) = T(read(io, Enums.basetype(T)))
+Base.convert(::Type{Integer}, x::Enum{T}) where {T<:Integer} = bitcast(T, x)
+Base.convert(::Type{T}, x::Enum{T2}) where {T<:Integer,T2<:Integer} = convert(T, bitcast(T2, x))
+Base.write(io::IO, x::Enum{T}) where {T<:Integer} = write(io, T(x))
+Base.read(io::IO, ::Type{T}) where {T<:Enum} = T(read(io, Enums.basetype(T)))
 
 # generate code to test whether expr is in the given set of values
 function membershiptest(expr, values)
@@ -35,6 +35,7 @@ Create an `Enum{BaseType}` subtype with name `EnumName` and enum member values o
 `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
 
+# Examples
 ```jldoctest
 julia> @enum Fruit apple=1 orange=2 kiwi=3
 
@@ -45,37 +46,38 @@ julia> f(apple)
 "I'm a Fruit with value: 1"
 ```
 
-`BaseType`, which defaults to `Int32`, must be a primitive subtype of Integer. Member values can be converted between
-the enum type and `BaseType`. `read` and `write` perform these conversions automatically.
+`BaseType`, which defaults to [`Int32`](@ref), must be a primitive subtype of `Integer`.
+Member values can be converted between the enum type and `BaseType`. `read` and `write`
+perform these conversions automatically.
 """
-macro enum(T,syms...)
+macro enum(T, syms...)
     if isempty(syms)
         throw(ArgumentError("no arguments given for Enum $T"))
     end
     basetype = Int32
     typename = T
-    if isa(T,Expr) && T.head == :(::) && length(T.args) == 2 && isa(T.args[1], Symbol)
+    if isa(T, Expr) && T.head == :(::) && length(T.args) == 2 && isa(T.args[1], Symbol)
         typename = T.args[1]
-        basetype = eval(current_module(),T.args[2])
+        basetype = eval(__module__, T.args[2])
         if !isa(basetype, DataType) || !(basetype <: Integer) || !isbits(basetype)
             throw(ArgumentError("invalid base type for Enum $typename, $T=::$basetype; base type must be an integer primitive type"))
         end
-    elseif !isa(T,Symbol)
+    elseif !isa(T, Symbol)
         throw(ArgumentError("invalid type expression for enum $T"))
     end
-    vals = Array{Tuple{Symbol,Integer}}(0)
+    vals = Vector{Tuple{Symbol,Integer}}(0)
     lo = hi = 0
     i = zero(basetype)
     hasexpr = false
     for s in syms
-        if isa(s,Symbol)
+        if isa(s, Symbol)
             if i == typemin(basetype) && !isempty(vals)
                 throw(ArgumentError("overflow in value \"$s\" of Enum $typename"))
             end
-        elseif isa(s,Expr) &&
+        elseif isa(s, Expr) &&
                (s.head == :(=) || s.head == :kw) &&
-               length(s.args) == 2 && isa(s.args[1],Symbol)
-            i = eval(current_module(),s.args[2]) # allow exprs, e.g. uint128"1"
+               length(s.args) == 2 && isa(s.args[1], Symbol)
+            i = eval(__module__, s.args[2]) # allow exprs, e.g. uint128"1"
             if !isa(i, Integer)
                 throw(ArgumentError("invalid value for Enum $typename, $s=$i; values must be integers"))
             end
@@ -143,7 +145,7 @@ macro enum(T,syms...)
             end
         end
     end
-    if isa(typename,Symbol)
+    if isa(typename, Symbol)
         for (sym,i) in vals
             push!(blk.args, :(const $(esc(sym)) = $(esc(typename))($i)))
         end
diff --git a/base/Makefile b/base/Makefile
index 9edca7ec8f4177..5c82514288c100 100644
--- a/base/Makefile
+++ b/base/Makefile
@@ -53,16 +53,24 @@ ifeq ($(USE_GPL_LIBS), 1)
 else
 	@echo "const USE_GPL_LIBS = false" >> $@
 endif
-	@echo "const libfftw_name = \"$(LIBFFTWNAME)\"" >> $@
-	@echo "const libfftwf_name = \"$(LIBFFTWFNAME)\"" >> $@
-	@echo "const libllvm_version = \"$$($(LLVM_CONFIG_HOST) --version)\"" >> $@
+	@echo "const libllvm_version_string = \"$$($(LLVM_CONFIG_HOST) --version)\"" >> $@
 	@echo "const VERSION_STRING = \"$(JULIA_VERSION)\"" >> $@
 	@echo "const TAGGED_RELEASE_BANNER = \"$(TAGGED_RELEASE_BANNER)\"" >> $@
+ifeq ($(OS),WINNT)
+	@echo 'const SYSCONFDIR = "$(subst /,\\,$(sysconfdir_rel))"' >> $@
+	@echo 'const DATAROOTDIR = "$(subst /,\\,$(datarootdir_rel))"' >> $@
+	@echo 'const DOCDIR = "$(subst /,\\,$(docdir_rel))"' >> $@
+	@echo 'const LIBDIR = "$(subst /,\\,$(libdir_rel))"' >> $@
+	@echo 'const PRIVATE_LIBDIR = "$(subst /,\\,$(private_libdir_rel))"' >> $@
+	@echo 'const INCLUDEDIR = "$(subst /,\\,$(includedir_rel))"' >> $@
+else
 	@echo "const SYSCONFDIR = \"$(sysconfdir_rel)\"" >> $@
 	@echo "const DATAROOTDIR = \"$(datarootdir_rel)\"" >> $@
 	@echo "const DOCDIR = \"$(docdir_rel)\"" >> $@
 	@echo "const LIBDIR = \"$(libdir_rel)\"" >> $@
+	@echo "const PRIVATE_LIBDIR = \"$(private_libdir_rel)\"" >> $@
 	@echo "const INCLUDEDIR = \"$(includedir_rel)\"" >> $@
+endif
 
 	@# This to ensure that we always rebuild this file, but only when it is modified do we touch build_h.jl,
 	@# ensuring we rebuild the system image as infrequently as possible
diff --git a/base/abstractarray.jl b/base/abstractarray.jl
index 5ec677a2db340f..a74127c3c770f7 100644
--- a/base/abstractarray.jl
+++ b/base/abstractarray.jl
@@ -1,7 +1,16 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## Basic functions ##
 
+"""
+    AbstractArray{T,N}
+
+Supertype for `N`-dimensional arrays (or array-like types) with elements of type `T`.
+[`Array`](@ref) and other types are subtypes of this. See the manual section on the
+[`AbstractArray` interface](@ref man-interface-array).
+"""
+AbstractArray
+
 """
     size(A::AbstractArray, [dim...])
 
@@ -9,6 +18,7 @@ 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.
 
+# Examples
 ```jldoctest
 julia> A = ones(2,3,4);
 
@@ -19,14 +29,16 @@ julia> size(A,3,2)
 (4, 3)
 ```
 """
-size{T,N}(t::AbstractArray{T,N}, d) = d <= N ? size(t)[d] : 1
-size{N}(x, d1::Integer, d2::Integer, dx::Vararg{Integer, N}) = (size(x, d1), size(x, d2), ntuple(k->size(x, dx[k]), Val{N})...)
+size(t::AbstractArray{T,N}, d) where {T,N} = d <= N ? size(t)[d] : 1
+size(x, d1::Integer, d2::Integer, dx::Vararg{Integer, N}) where {N} =
+    (size(x, d1), size(x, d2), ntuple(k->size(x, dx[k]), Val(N))...)
 
 """
     indices(A, d)
 
 Returns the valid range of indices for array `A` along dimension `d`.
 
+# Examples
 ```jldoctest
 julia> A = ones(5,6,7);
 
@@ -34,7 +46,7 @@ julia> indices(A,2)
 Base.OneTo(6)
 ```
 """
-function indices{T,N}(A::AbstractArray{T,N}, d)
+function indices(A::AbstractArray{T,N}, d) where {T,N}
     @_inline_meta
     d <= N ? indices(A)[d] : OneTo(1)
 end
@@ -44,6 +56,7 @@ end
 
 Returns the tuple of valid indices for array `A`.
 
+# Examples
 ```jldoctest
 julia> A = ones(5,6,7);
 
@@ -59,8 +72,8 @@ end
 # Performance optimization: get rid of a branch on `d` in `indices(A,
 # d)` for d=1. 1d arrays are heavily used, and the first dimension
 # comes up in other applications.
-indices1{T}(A::AbstractArray{T,0}) = OneTo(1)
-indices1(A::AbstractArray)         = (@_inline_meta; indices(A)[1])
+indices1(A::AbstractArray{<:Any,0}) = OneTo(1)
+indices1(A::AbstractArray) = (@_inline_meta; indices(A)[1])
 indices1(iter) = OneTo(length(iter))
 
 unsafe_indices(A) = indices(A)
@@ -78,6 +91,7 @@ is `indices(A, 1)`.
 Calling this function is the "safe" way to write algorithms that
 exploit linear indexing.
 
+# Examples
 ```jldoctest
 julia> A = ones(5,6,7);
 
@@ -87,16 +101,17 @@ julia> extrema(b)
 (1, 210)
 ```
 """
-linearindices(A)                 = (@_inline_meta; OneTo(_length(A)))
+linearindices(A) = (@_inline_meta; OneTo(_length(A)))
 linearindices(A::AbstractVector) = (@_inline_meta; indices1(A))
 eltype(::Type{<:AbstractArray{E}}) where {E} = E
-elsize{T}(::AbstractArray{T}) = sizeof(T)
+elsize(::AbstractArray{T}) where {T} = sizeof(T)
 
 """
     ndims(A::AbstractArray) -> Integer
 
 Returns the number of dimensions of `A`.
 
+# Examples
 ```jldoctest
 julia> A = ones(3,4,5);
 
@@ -104,26 +119,14 @@ julia> ndims(A)
 3
 ```
 """
-ndims{T,N}(::AbstractArray{T,N}) = N
-ndims{T,N}(::Type{AbstractArray{T,N}}) = N
-ndims{T<:AbstractArray}(::Type{T}) = ndims(supertype(T))
-
-"""
-    length(A::AbstractArray) -> Integer
-
-Returns the number of elements in `A`.
-
-```jldoctest
-julia> A = ones(3,4,5);
+ndims(::AbstractArray{T,N}) where {T,N} = N
+ndims(::Type{AbstractArray{T,N}}) where {T,N} = N
+ndims(::Type{T}) where {T<:AbstractArray} = ndims(supertype(T))
 
-julia> length(A)
-60
-```
-"""
 length(t::AbstractArray) = (@_inline_meta; prod(size(t)))
 _length(A::AbstractArray) = (@_inline_meta; prod(map(unsafe_length, indices(A)))) # circumvent missing size
 _length(A) = (@_inline_meta; length(A))
-endof(a::AbstractArray) = (@_inline_meta; length(a))
+endof(a::AbstractArray) = (@_inline_meta; last(linearindices(a)))
 first(a::AbstractArray) = a[first(eachindex(a))]
 
 """
@@ -132,6 +135,7 @@ first(a::AbstractArray) = a[first(eachindex(a))]
 Get the first element of an iterable collection. Returns the start point of a
 `Range` even if it is empty.
 
+# Examples
 ```jldoctest
 julia> first(2:2:10)
 2
@@ -153,6 +157,7 @@ Get the last element of an ordered collection, if it can be computed in O(1) tim
 accomplished by calling [`endof`](@ref) to get the last index. Returns the end
 point of a `Range` even if it is empty.
 
+# Examples
 ```jldoctest
 julia> last(1:2:10)
 9
@@ -168,6 +173,7 @@ last(a) = a[end]
 
 Returns the distance in memory (in number of elements) between adjacent elements in dimension `k`.
 
+# Examples
 ```jldoctest
 julia> A = ones(3,4,5);
 
@@ -183,18 +189,18 @@ function stride(a::AbstractArray, i::Integer)
         return length(a)
     end
     s = 1
-    for n=1:(i-1)
+    for n = 1:(i-1)
         s *= size(a, n)
     end
     return s
 end
 
-strides(A::AbstractArray{<:Any,0}) = ()
 """
     strides(A)
 
 Returns a tuple of the memory strides in each dimension.
 
+# Examples
 ```jldoctest
 julia> A = ones(3,4,5);
 
@@ -202,12 +208,11 @@ julia> strides(A)
 (1, 3, 12)
 ```
 """
-strides(A::AbstractArray) = _strides((1,), A)
-_strides{T,N}(out::NTuple{N,Any}, A::AbstractArray{T,N}) = out
-function _strides{M}(out::NTuple{M,Any}, A::AbstractArray)
-    @_inline_meta
-    _strides((out..., out[M]*size(A, M)), A)
-end
+strides(A::AbstractArray) = size_to_strides(1, size(A)...)
+@inline size_to_strides(s, d, sz...) = (s, size_to_strides(s * d, sz...)...)
+size_to_strides(s, d) = (s,)
+size_to_strides(s) = ()
+
 
 function isassigned(a::AbstractArray, i::Int...)
     try
@@ -313,6 +318,7 @@ many cases one can rely on `A`'s indices and [`checkindex`](@ref).
 
 See also [`checkindex`](@ref).
 
+# Examples
 ```jldoctest
 julia> A = rand(3, 3);
 
@@ -339,7 +345,7 @@ function checkbounds(::Type{Bool}, A::AbstractArray, i)
     checkindex(Bool, linearindices(A), i)
 end
 # As a special extension, allow using logical arrays that match the source array exactly
-function checkbounds{_,N}(::Type{Bool}, A::AbstractArray{_,N}, I::AbstractArray{Bool,N})
+function checkbounds(::Type{Bool}, A::AbstractArray{<:Any,N}, I::AbstractArray{Bool,N}) where N
     @_inline_meta
     indices(A) == indices(I)
 end
@@ -381,7 +387,10 @@ function checkbounds_indices(::Type{Bool}, IA::Tuple, I::Tuple)
     checkindex(Bool, IA[1], I[1]) & checkbounds_indices(Bool, tail(IA), tail(I))
 end
 checkbounds_indices(::Type{Bool}, ::Tuple{},  ::Tuple{})    = true
-checkbounds_indices(::Type{Bool}, ::Tuple{}, I::Tuple{Any}) = (@_inline_meta; checkindex(Bool, 1:1, I[1]))
+function checkbounds_indices(::Type{Bool}, ::Tuple{}, I::Tuple{Any})
+    @_inline_meta
+    checkindex(Bool, 1:1, I[1])
+end
 function checkbounds_indices(::Type{Bool}, ::Tuple{}, I::Tuple)
     @_inline_meta
     checkindex(Bool, 1:1, I[1]) & checkbounds_indices(Bool, (), tail(I))
@@ -412,7 +421,8 @@ function checkbounds_linear_indices(::Type{Bool}, IA::Tuple{Vararg{OneTo}}, i::U
     partial_linear_indexing_warning_lookup(length(IA))
     true
 end
-function checkbounds_linear_indices(::Type{Bool}, IA::Tuple{AbstractUnitRange,Vararg{AbstractUnitRange}}, i::Union{Slice,Colon})
+function checkbounds_linear_indices(::Type{Bool},
+        IA::Tuple{AbstractUnitRange,Vararg{AbstractUnitRange}}, i::Union{Slice,Colon})
     partial_linear_indexing_warning_lookup(length(IA))
     true
 end
@@ -429,15 +439,17 @@ Return `true` if the given `index` is within the bounds of
 arrays can extend this method in order to provide a specialized bounds
 checking implementation.
 
+# Examples
 ```jldoctest
-julia> checkindex(Bool,1:20,8)
+julia> checkindex(Bool, 1:20, 8)
 true
 
-julia> checkindex(Bool,1:20,21)
+julia> checkindex(Bool, 1:20, 21)
 false
 ```
 """
-checkindex(::Type{Bool}, inds::AbstractUnitRange, i) = throw(ArgumentError("unable to check bounds for indices of type $(typeof(i))"))
+checkindex(::Type{Bool}, inds::AbstractUnitRange, i) =
+    throw(ArgumentError("unable to check bounds for indices of type $(typeof(i))"))
 checkindex(::Type{Bool}, inds::AbstractUnitRange, i::Real) = (first(inds) <= i) & (i <= last(inds))
 checkindex(::Type{Bool}, inds::AbstractUnitRange, ::Colon) = true
 checkindex(::Type{Bool}, inds::AbstractUnitRange, ::Slice) = true
@@ -476,7 +488,7 @@ 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
+```julia-repl
 julia> similar(1:10, 1, 4)
 1×4 Array{Int64,2}:
  4419743872  4374413872  4419743888  0
@@ -485,17 +497,17 @@ julia> similar(1:10, 1, 4)
 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
+```julia-repl
 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
+Since `BitArray`s can only store elements of type [`Bool`](@ref), however, if you request a
 different element type it will create a regular `Array` instead:
 
-```julia
+```julia-repl
 julia> similar(falses(10), Float64, 2, 4)
 2×4 Array{Float64,2}:
  2.18425e-314  2.18425e-314  2.18425e-314  2.18425e-314
@@ -503,14 +515,14 @@ julia> similar(falses(10), Float64, 2, 4)
 ```
 
 """
-similar{T}(a::AbstractArray{T})                             = similar(a, T)
-similar{T}(a::AbstractArray, ::Type{T})                     = similar(a, T, to_shape(indices(a)))
-similar{T}(a::AbstractArray{T}, dims::Tuple)                = similar(a, T, to_shape(dims))
-similar{T}(a::AbstractArray{T}, dims::DimOrInd...)          = similar(a, T, to_shape(dims))
-similar{T}(a::AbstractArray, ::Type{T}, dims::DimOrInd...)  = similar(a, T, to_shape(dims))
-similar{T}(a::AbstractArray, ::Type{T}, dims::NeedsShaping) = similar(a, T, to_shape(dims))
+similar(a::AbstractArray{T}) where {T}                             = similar(a, T)
+similar(a::AbstractArray, ::Type{T}) where {T}                     = similar(a, T, to_shape(indices(a)))
+similar(a::AbstractArray{T}, dims::Tuple) where {T}                = similar(a, T, to_shape(dims))
+similar(a::AbstractArray{T}, dims::DimOrInd...) where {T}          = similar(a, T, to_shape(dims))
+similar(a::AbstractArray, ::Type{T}, dims::DimOrInd...) where {T}  = similar(a, T, to_shape(dims))
+similar(a::AbstractArray, ::Type{T}, dims::NeedsShaping) where {T} = similar(a, T, to_shape(dims))
 # similar creates an Array by default
-similar{T,N}(a::AbstractArray, ::Type{T}, dims::Dims{N})    = Array{T,N}(dims)
+similar(a::AbstractArray, ::Type{T}, dims::Dims{N}) where {T,N}    = Array{T,N}(dims)
 
 to_shape(::Tuple{}) = ()
 to_shape(dims::Dims) = dims
@@ -636,7 +648,8 @@ copy!(dest::AbstractArray, src::AbstractArray) =
 
 function copy!(::IndexStyle, dest::AbstractArray, ::IndexStyle, src::AbstractArray)
     destinds, srcinds = linearindices(dest), linearindices(src)
-    isempty(srcinds) || (first(srcinds) ∈ destinds && last(srcinds) ∈ destinds) || throw(BoundsError(dest, srcinds))
+    isempty(srcinds) || (first(srcinds) ∈ destinds && last(srcinds) ∈ destinds) ||
+        throw(BoundsError(dest, srcinds))
     @inbounds for i in srcinds
         dest[i] = src[i]
     end
@@ -645,7 +658,8 @@ end
 
 function copy!(::IndexStyle, dest::AbstractArray, ::IndexCartesian, src::AbstractArray)
     destinds, srcinds = linearindices(dest), linearindices(src)
-    isempty(srcinds) || (first(srcinds) ∈ destinds && last(srcinds) ∈ destinds) || throw(BoundsError(dest, srcinds))
+    isempty(srcinds) || (first(srcinds) ∈ destinds && last(srcinds) ∈ destinds) ||
+        throw(BoundsError(dest, srcinds))
     i = 0
     @inbounds for a in src
         dest[i+=1] = a
@@ -682,8 +696,8 @@ function copy(a::AbstractArray)
     copymutable(a)
 end
 
-function copy!{R,S}(B::AbstractVecOrMat{R}, ir_dest::Range{Int}, jr_dest::Range{Int},
-                    A::AbstractVecOrMat{S}, ir_src::Range{Int}, jr_src::Range{Int})
+function copy!(B::AbstractVecOrMat{R}, ir_dest::Range{Int}, jr_dest::Range{Int},
+               A::AbstractVecOrMat{S}, ir_src::Range{Int}, jr_src::Range{Int}) where {R,S}
     if length(ir_dest) != length(ir_src)
         throw(ArgumentError(string("source and destination must have same size (got ",
                                    length(ir_src)," and ",length(ir_dest),")")))
@@ -715,6 +729,7 @@ this is equivalent to `copy(a)`, but for other array types it may
 differ depending on the type of `similar(a)`.  For generic iterables
 this is equivalent to `collect(a)`.
 
+# Examples
 ```jldoctest
 julia> tup = (1, 2, 3)
 (1, 2, 3)
@@ -732,7 +747,7 @@ function copymutable(a::AbstractArray)
 end
 copymutable(itr) = collect(itr)
 
-zero{T}(x::AbstractArray{T}) = fill!(similar(x), zero(T))
+zero(x::AbstractArray{T}) where {T} = fill!(similar(x), zero(T))
 
 ## iteration support for arrays by iterating over `eachindex` in the array ##
 # Allows fast iteration by default for both IndexLinear and IndexCartesian arrays
@@ -741,11 +756,11 @@ zero{T}(x::AbstractArray{T}) = fill!(similar(x), zero(T))
 # own, IndexCartesian's CartesianRange is more complicated and requires explicit
 # inlining.
 start(A::AbstractArray) = (@_inline_meta; itr = eachindex(A); (itr, start(itr)))
-next(A::AbstractArray,i) = (@_propagate_inbounds_meta; (idx, s) = next(i[1], i[2]); (A[idx], (i[1], s)))
-done(A::AbstractArray,i) = (@_propagate_inbounds_meta; done(i[1], i[2]))
+next(A::AbstractArray, i) = (@_propagate_inbounds_meta; (idx, s) = next(i[1], i[2]); (A[idx], (i[1], s)))
+done(A::AbstractArray, i) = (@_propagate_inbounds_meta; done(i[1], i[2]))
 
 # eachindex iterates over all indices. IndexCartesian definitions are later.
-eachindex(A::AbstractVector) = (@_inline_meta(); indices1(A))
+eachindex(A::Union{Number,AbstractVector}) = (@_inline_meta(); indices1(A))
 
 """
     eachindex(A...)
@@ -786,7 +801,7 @@ 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`
+if all inputs have fast linear indexing, a [`CartesianRange`](@ref)
 otherwise).
 If the arrays have different sizes and/or dimensionalities, `eachindex` returns an
 iterable that spans the largest range along each dimension.
@@ -816,11 +831,11 @@ isempty(a::AbstractArray) = (_length(a) == 0)
 
 ## Conversions ##
 
-convert{T,N  }(::Type{AbstractArray{T,N}}, A::AbstractArray{T,N}) = A
-convert{T,S,N}(::Type{AbstractArray{T,N}}, A::AbstractArray{S,N}) = copy!(similar(A,T), A)
-convert{T,S,N}(::Type{AbstractArray{T  }}, A::AbstractArray{S,N}) = convert(AbstractArray{T,N}, A)
+convert(::Type{AbstractArray{T,N}}, A::AbstractArray{T,N}) where {T,N  } = A
+convert(::Type{AbstractArray{T,N}}, A::AbstractArray{S,N}) where {T,S,N} = copy!(similar(A,T), A)
+convert(::Type{AbstractArray{T}},   A::AbstractArray{S,N}) where {T,S,N} = convert(AbstractArray{T,N}, A)
 
-convert{T,N}(::Type{Array}, A::AbstractArray{T,N}) = convert(Array{T,N}, A)
+convert(::Type{Array}, A::AbstractArray{T,N}) where {T,N} = convert(Array{T,N}, A)
 
 """
    of_indices(x, y)
@@ -829,14 +844,20 @@ Represents the array `y` as an array having the same indices type as `x`.
 """
 of_indices(x, y) = similar(dims->y, oftype(indices(x), indices(y)))
 
+
+"""
+    full(F)
+
+Reconstruct the matrix `A` from the factorization `F=factorize(A)`.
+"""
 full(x::AbstractArray) = x
 
 ## range conversions ##
 
-map{T<:Real}(::Type{T}, r::StepRange) = T(r.start):T(r.step):T(last(r))
-map{T<:Real}(::Type{T}, r::UnitRange) = T(r.start):T(last(r))
-map{T<:AbstractFloat}(::Type{T}, r::StepRangeLen) = convert(StepRangeLen{T}, r)
-function map{T<:AbstractFloat}(::Type{T}, r::LinSpace)
+map(::Type{T}, r::StepRange) where {T<:Real} = T(r.start):T(r.step):T(last(r))
+map(::Type{T}, r::UnitRange) where {T<:Real} = T(r.start):T(last(r))
+map(::Type{T}, r::StepRangeLen) where {T<:AbstractFloat} = convert(StepRangeLen{T}, r)
+function map(::Type{T}, r::LinSpace) where T<:AbstractFloat
     LinSpace(T(r.start), T(r.stop), length(r))
 end
 
@@ -845,8 +866,11 @@ end
 # note: the following type definitions don't mean any AbstractArray is convertible to
 # a data Ref. they just map the array element type to the pointer type for
 # convenience in cases that work.
-pointer{T}(x::AbstractArray{T}) = unsafe_convert(Ptr{T}, x)
-pointer{T}(x::AbstractArray{T}, i::Integer) = (@_inline_meta; unsafe_convert(Ptr{T},x) + (i-first(linearindices(x)))*elsize(x))
+pointer(x::AbstractArray{T}) where {T} = unsafe_convert(Ptr{T}, x)
+function pointer(x::AbstractArray{T}, i::Integer) where T
+    @_inline_meta
+    unsafe_convert(Ptr{T}, x) + (i - first(linearindices(x)))*elsize(x)
+end
 
 ## Approach:
 # We only define one fallback method on getindex for all argument types.
@@ -854,10 +878,38 @@ pointer{T}(x::AbstractArray{T}, i::Integer) = (@_inline_meta; unsafe_convert(Ptr
 # to transform the indices such that we can call the only getindex method that
 # we require the type A{T,N} <: AbstractArray{T,N} to define; either:
 #       getindex(::A, ::Int) # if IndexStyle(A) == IndexLinear() OR
-#       getindex{T,N}(::A{T,N}, ::Vararg{Int, N}) # if IndexCartesian()
+#       getindex(::A{T,N}, ::Vararg{Int, N}) where {T,N} # if IndexCartesian()
 # If the subtype hasn't defined the required method, it falls back to the
 # _getindex function again where an error is thrown to prevent stack overflows.
+"""
+    getindex(A, inds...)
+
+Return a subset of array `A` as specified by `inds`, where each `ind` may be an
+`Int`, a `Range`, or a [`Vector`](@ref). See the manual section on
+[array indexing](@ref man-array-indexing) for details.
+
+# Examples
+```jldoctest
+julia> A = [1 2; 3 4]
+2×2 Array{Int64,2}:
+ 1  2
+ 3  4
 
+julia> getindex(A, 1)
+1
+
+julia> getindex(A, [2, 1])
+2-element Array{Int64,1}:
+ 3
+ 1
+
+julia> getindex(A, 2:4)
+3-element Array{Int64,1}:
+ 3
+ 2
+ 4
+```
+"""
 function getindex(A::AbstractArray, I...)
     @_propagate_inbounds_meta
     error_if_canonical_indexing(IndexStyle(A), A, I...)
@@ -869,17 +921,20 @@ function unsafe_getindex(A::AbstractArray, I...)
     r
 end
 
-error_if_canonical_indexing(::IndexLinear, A::AbstractArray, ::Int) = error("indexing not defined for ", typeof(A))
-error_if_canonical_indexing{T,N}(::IndexCartesian, A::AbstractArray{T,N}, ::Vararg{Int, N}) = error("indexing not defined for ", typeof(A))
+error_if_canonical_indexing(::IndexLinear, A::AbstractArray, ::Int) =
+    error("indexing not defined for ", typeof(A))
+error_if_canonical_indexing(::IndexCartesian, A::AbstractArray{T,N}, ::Vararg{Int,N}) where {T,N} =
+    error("indexing not defined for ", typeof(A))
 error_if_canonical_indexing(::IndexStyle, ::AbstractArray, ::Any...) = nothing
 
 ## Internal definitions
-_getindex(::IndexStyle, A::AbstractArray, I...) = error("indexing $(typeof(A)) with types $(typeof(I)) is not supported")
+_getindex(::IndexStyle, A::AbstractArray, I...) =
+    error("indexing $(typeof(A)) with types $(typeof(I)) is not supported")
 
 ## IndexLinear Scalar indexing: canonical method is one Int
 _getindex(::IndexLinear, A::AbstractArray, i::Int) = (@_propagate_inbounds_meta; getindex(A, i))
 _getindex(::IndexLinear, A::AbstractArray) = (@_propagate_inbounds_meta; getindex(A, _to_linear_index(A)))
-function _getindex(::IndexLinear, A::AbstractArray, I::Int...)
+function _getindex(::IndexLinear, A::AbstractArray, I::Vararg{Int,M}) where M
     @_inline_meta
     @boundscheck checkbounds(A, I...) # generally _to_linear_index requires bounds checking
     @inbounds r = getindex(A, _to_linear_index(A, I...))
@@ -887,27 +942,33 @@ function _getindex(::IndexLinear, A::AbstractArray, I::Int...)
 end
 _to_linear_index(A::AbstractArray, i::Int) = i
 _to_linear_index(A::AbstractVector, i::Int, I::Int...) = i # TODO: DEPRECATE FOR #14770
-_to_linear_index{T,N}(A::AbstractArray{T,N}, I::Vararg{Int,N}) = (@_inline_meta; sub2ind(A, I...))
+_to_linear_index(A::AbstractArray{T,N}, I::Vararg{Int,N}) where {T,N} = (@_inline_meta; sub2ind(A, I...))
 _to_linear_index(A::AbstractArray) = 1 # TODO: DEPRECATE FOR #14770
 _to_linear_index(A::AbstractArray, I::Int...) = (@_inline_meta; sub2ind(A, I...)) # TODO: DEPRECATE FOR #14770
 
 ## IndexCartesian Scalar indexing: Canonical method is full dimensionality of Ints
-_getindex(::IndexCartesian, A::AbstractArray) = (@_propagate_inbounds_meta; getindex(A, _to_subscript_indices(A)...))
-function _getindex(::IndexCartesian, A::AbstractArray, I::Int...)
+function _getindex(::IndexCartesian, A::AbstractArray)
+    @_propagate_inbounds_meta
+    getindex(A, _to_subscript_indices(A)...)
+end
+function _getindex(::IndexCartesian, A::AbstractArray, I::Vararg{Int,M}) where M
     @_inline_meta
     @boundscheck checkbounds(A, I...) # generally _to_subscript_indices requires bounds checking
     @inbounds r = getindex(A, _to_subscript_indices(A, I...)...)
     r
 end
-_getindex{T,N}(::IndexCartesian, A::AbstractArray{T,N}, I::Vararg{Int, N}) = (@_propagate_inbounds_meta; getindex(A, I...))
+function _getindex(::IndexCartesian, A::AbstractArray{T,N}, I::Vararg{Int, N}) where {T,N}
+    @_propagate_inbounds_meta
+    getindex(A, I...)
+end
 _to_subscript_indices(A::AbstractArray, i::Int) = (@_inline_meta; _unsafe_ind2sub(A, i))
-_to_subscript_indices{T,N}(A::AbstractArray{T,N}) = (@_inline_meta; fill_to_length((), 1, Val{N})) # TODO: DEPRECATE FOR #14770
-_to_subscript_indices{T}(A::AbstractArray{T,0}) = () # TODO: REMOVE FOR #14770
-_to_subscript_indices{T}(A::AbstractArray{T,0}, i::Int) = () # TODO: REMOVE FOR #14770
-_to_subscript_indices{T}(A::AbstractArray{T,0}, I::Int...) = () # TODO: DEPRECATE FOR #14770
-function _to_subscript_indices{T,N}(A::AbstractArray{T,N}, I::Int...) # TODO: DEPRECATE FOR #14770
+_to_subscript_indices(A::AbstractArray{T,N}) where {T,N} = (@_inline_meta; fill_to_length((), 1, Val(N))) # TODO: DEPRECATE FOR #14770
+_to_subscript_indices(A::AbstractArray{T,0}) where {T} = () # TODO: REMOVE FOR #14770
+_to_subscript_indices(A::AbstractArray{T,0}, i::Int) where {T} = () # TODO: REMOVE FOR #14770
+_to_subscript_indices(A::AbstractArray{T,0}, I::Int...) where {T} = () # TODO: DEPRECATE FOR #14770
+function _to_subscript_indices(A::AbstractArray{T,N}, I::Int...) where {T,N} # TODO: DEPRECATE FOR #14770
     @_inline_meta
-    J, Jrem = IteratorsMD.split(I, Val{N})
+    J, Jrem = IteratorsMD.split(I, Val(N))
     _to_subscript_indices(A, J, Jrem)
 end
 _to_subscript_indices(A::AbstractArray, J::Tuple, Jrem::Tuple{}) =
@@ -920,12 +981,13 @@ function __to_subscript_indices(A::AbstractArray, ::Tuple{Vararg{OneTo}}, J::Tup
 end
 # After the partial linear indexing deprecation is removed, this next method can
 # become the new normal. For now, it's limited to non-OneTo arrays.
-function __to_subscript_indices(A::AbstractArray, ::Tuple{AbstractUnitRange,Vararg{AbstractUnitRange}}, J::Tuple, Jrem::Tuple{})
+function __to_subscript_indices(A::AbstractArray,
+        ::Tuple{AbstractUnitRange,Vararg{AbstractUnitRange}}, J::Tuple, Jrem::Tuple{})
     @_inline_meta
     (J..., map(first, tail(_remaining_size(J, indices(A))))...)
 end
 _to_subscript_indices(A, J::Tuple, Jrem::Tuple) = J # already bounds-checked, safe to drop
-_to_subscript_indices{T,N}(A::AbstractArray{T,N}, I::Vararg{Int,N}) = I
+_to_subscript_indices(A::AbstractArray{T,N}, I::Vararg{Int,N}) where {T,N} = I
 _remaining_size(::Tuple{Any}, t::Tuple) = t
 _remaining_size(h::Tuple, t::Tuple) = (@_inline_meta; _remaining_size(tail(h), tail(t)))
 _unsafe_ind2sub(::Tuple{}, i) = () # ind2sub may throw(BoundsError()) in this case
@@ -933,6 +995,12 @@ _unsafe_ind2sub(sz, i) = (@_inline_meta; ind2sub(sz, i))
 
 ## Setindex! is defined similarly. We first dispatch to an internal _setindex!
 # function that allows dispatch on array storage
+
+"""
+    setindex!(A, X, inds...)
+
+Store values from array `X` within some subset of `A` as specified by `inds`.
+"""
 function setindex!(A::AbstractArray, v, I...)
     @_propagate_inbounds_meta
     error_if_canonical_indexing(IndexStyle(A), A, I...)
@@ -944,12 +1012,13 @@ function unsafe_setindex!(A::AbstractArray, v, I...)
     r
 end
 ## Internal defitions
-_setindex!(::IndexStyle, A::AbstractArray, v, I...) = error("indexing $(typeof(A)) with types $(typeof(I)) is not supported")
+_setindex!(::IndexStyle, A::AbstractArray, v, I...) =
+    error("indexing $(typeof(A)) with types $(typeof(I)) is not supported")
 
 ## IndexLinear Scalar indexing
 _setindex!(::IndexLinear, A::AbstractArray, v, i::Int) = (@_propagate_inbounds_meta; setindex!(A, v, i))
 _setindex!(::IndexLinear, A::AbstractArray, v) = (@_propagate_inbounds_meta; setindex!(A, v, _to_linear_index(A)))
-function _setindex!(::IndexLinear, A::AbstractArray, v, I::Int...)
+function _setindex!(::IndexLinear, A::AbstractArray, v, I::Vararg{Int,M}) where M
     @_inline_meta
     @boundscheck checkbounds(A, I...)
     @inbounds r = setindex!(A, v, _to_linear_index(A, I...))
@@ -957,9 +1026,15 @@ function _setindex!(::IndexLinear, A::AbstractArray, v, I::Int...)
 end
 
 # IndexCartesian Scalar indexing
-_setindex!{T,N}(::IndexCartesian, A::AbstractArray{T,N}, v, I::Vararg{Int, N}) = (@_propagate_inbounds_meta; setindex!(A, v, I...))
-_setindex!(::IndexCartesian, A::AbstractArray, v) = (@_propagate_inbounds_meta; setindex!(A, v, _to_subscript_indices(A)...))
-function _setindex!(::IndexCartesian, A::AbstractArray, v, I::Int...)
+function _setindex!(::IndexCartesian, A::AbstractArray{T,N}, v, I::Vararg{Int, N}) where {T,N}
+    @_propagate_inbounds_meta
+    setindex!(A, v, I...)
+end
+function _setindex!(::IndexCartesian, A::AbstractArray, v)
+    @_propagate_inbounds_meta
+    setindex!(A, v, _to_subscript_indices(A)...)
+end
+function _setindex!(::IndexCartesian, A::AbstractArray, v, I::Vararg{Int,M}) where M
     @_inline_meta
     @boundscheck checkbounds(A, I...)
     @inbounds r = setindex!(A, v, _to_subscript_indices(A, I...)...)
@@ -968,13 +1043,14 @@ end
 
 ## get (getindex with a default value) ##
 
-RangeVecIntList{A<:AbstractVector{Int}} = Union{Tuple{Vararg{Union{Range, AbstractVector{Int}}}}, AbstractVector{UnitRange{Int}}, AbstractVector{Range{Int}}, AbstractVector{A}}
+RangeVecIntList{A<:AbstractVector{Int}} = Union{Tuple{Vararg{Union{Range, AbstractVector{Int}}}},
+    AbstractVector{UnitRange{Int}}, AbstractVector{Range{Int}}, AbstractVector{A}}
 
 get(A::AbstractArray, i::Integer, default) = checkbounds(Bool, A, i) ? A[i] : default
 get(A::AbstractArray, I::Tuple{}, default) = similar(A, typeof(default), 0)
 get(A::AbstractArray, I::Dims, default) = checkbounds(Bool, A, I...) ? A[I...] : default
 
-function get!{T}(X::AbstractVector{T}, A::AbstractVector, I::Union{Range, AbstractVector{Int}}, default::T)
+function get!(X::AbstractVector{T}, A::AbstractVector, I::Union{Range,AbstractVector{Int}}, default::T) where T
     # 1d is not linear indexing
     ind = findin(I, indices1(A))
     X[ind] = A[I[ind]]
@@ -983,7 +1059,7 @@ function get!{T}(X::AbstractVector{T}, A::AbstractVector, I::Union{Range, Abstra
     X[last(ind)+1:last(Xind)] = default
     X
 end
-function get!{T}(X::AbstractArray{T}, A::AbstractArray, I::Union{Range, AbstractVector{Int}}, default::T)
+function get!(X::AbstractArray{T}, A::AbstractArray, I::Union{Range,AbstractVector{Int}}, default::T) where T
     # Linear indexing
     ind = findin(I, 1:length(A))
     X[ind] = A[I[ind]]
@@ -995,14 +1071,15 @@ end
 get(A::AbstractArray, I::Range, default) = get!(similar(A, typeof(default), index_shape(I)), A, I, default)
 
 # TODO: DEPRECATE FOR #14770 (just the partial linear indexing part)
-function get!{T}(X::AbstractArray{T}, A::AbstractArray, I::RangeVecIntList, default::T)
+function get!(X::AbstractArray{T}, A::AbstractArray, I::RangeVecIntList, default::T) where T
     fill!(X, default)
     dst, src = indcopy(size(A), I)
     X[dst...] = A[src...]
     X
 end
 
-get(A::AbstractArray, I::RangeVecIntList, default) = get!(similar(A, typeof(default), index_shape(I...)), A, I, default)
+get(A::AbstractArray, I::RangeVecIntList, default) =
+    get!(similar(A, typeof(default), index_shape(I...)), A, I, default)
 
 ## structured matrix methods ##
 replace_in_print_matrix(A::AbstractMatrix,i::Integer,j::Integer,s::AbstractString) = s
@@ -1021,24 +1098,24 @@ promote_eltype(v1, vs...) = promote_type(eltype(v1), promote_eltype(vs...))
 #TODO: ERROR CHECK
 cat(catdim::Integer) = Array{Any,1}(0)
 
-typed_vcat{T}(::Type{T}) = Array{T,1}(0)
-typed_hcat{T}(::Type{T}) = Array{T,1}(0)
+typed_vcat(::Type{T}) where {T} = Array{T,1}(0)
+typed_hcat(::Type{T}) where {T} = Array{T,1}(0)
 
 ## cat: special cases
-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:1, j=1:length(X) ]
-hcat{T<:Number}(X::T...) = T[ X[j] for i=1:1, j=1:length(X) ]
+vcat(X::T...) where {T}         = T[ X[i] for i=1:length(X) ]
+vcat(X::T...) where {T<:Number} = T[ X[i] for i=1:length(X) ]
+hcat(X::T...) where {T}         = T[ X[j] for i=1:1, j=1:length(X) ]
+hcat(X::T...) where {T<:Number} = T[ X[j] for i=1:1, j=1:length(X) ]
 
 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{T}, X::Number...) = hvcat_fill(Array{T,1}(length(X)), X)
-typed_hcat{T}(::Type{T}, X::Number...) = hvcat_fill(Array{T,2}(1,length(X)), X)
+typed_vcat(::Type{T}, X::Number...) where {T} = hvcat_fill(Array{T,1}(length(X)), X)
+typed_hcat(::Type{T}, X::Number...) where {T} = hvcat_fill(Array{T,2}(1,length(X)), X)
 
 vcat(V::AbstractVector...) = typed_vcat(promote_eltype(V...), V...)
-vcat{T}(V::AbstractVector{T}...) = typed_vcat(T, V...)
+vcat(V::AbstractVector{T}...) where {T} = typed_vcat(T, V...)
 
-function typed_vcat{T}(::Type{T}, V::AbstractVector...)
+function typed_vcat(::Type{T}, V::AbstractVector...) where T
     n::Int = 0
     for Vk in V
         n += length(Vk)
@@ -1055,9 +1132,9 @@ function typed_vcat{T}(::Type{T}, V::AbstractVector...)
 end
 
 hcat(A::AbstractVecOrMat...) = typed_hcat(promote_eltype(A...), A...)
-hcat{T}(A::AbstractVecOrMat{T}...) = typed_hcat(T, A...)
+hcat(A::AbstractVecOrMat{T}...) where {T} = typed_hcat(T, A...)
 
-function typed_hcat{T}(::Type{T}, A::AbstractVecOrMat...)
+function typed_hcat(::Type{T}, A::AbstractVecOrMat...) where T
     nargs = length(A)
     nrows = size(A[1], 1)
     ncols = 0
@@ -1092,9 +1169,9 @@ function typed_hcat{T}(::Type{T}, A::AbstractVecOrMat...)
 end
 
 vcat(A::AbstractMatrix...) = typed_vcat(promote_eltype(A...), A...)
-vcat{T}(A::AbstractMatrix{T}...) = typed_vcat(T, A...)
+vcat(A::AbstractMatrix{T}...) where {T} = typed_vcat(T, A...)
 
-function typed_vcat{T}(::Type{T}, A::AbstractMatrix...)
+function typed_vcat(::Type{T}, A::AbstractMatrix...) where T
     nargs = length(A)
     nrows = sum(a->size(a, 1), A)::Int
     ncols = size(A[1], 2)
@@ -1130,31 +1207,34 @@ cat_similar(A::AbstractArray, T, shape) = similar(A, T, shape)
 
 cat_shape(dims, shape::Tuple) = shape
 @inline cat_shape(dims, shape::Tuple, nshape::Tuple, shapes::Tuple...) =
-    cat_shape(dims, _cshp(dims, (), shape, nshape), shapes...)
-
-_cshp(::Tuple{}, out, ::Tuple{}, ::Tuple{}) = out
-_cshp(::Tuple{}, out, ::Tuple{}, nshape) = (out..., nshape...)
-_cshp(dims, out, ::Tuple{}, ::Tuple{}) = (out..., map(b -> 1, dims)...)
-@inline _cshp(dims, out, shape, ::Tuple{}) =
-    _cshp(tail(dims), (out..., shape[1] + dims[1]), tail(shape), ())
-@inline _cshp(dims, out, ::Tuple{}, nshape) =
-    _cshp(tail(dims), (out..., nshape[1]), (), tail(nshape))
-@inline function _cshp(::Tuple{}, out, shape, ::Tuple{})
-    _cs(length(out) + 1, false, shape[1], 1)
-    _cshp((), (out..., 1), tail(shape), ())
-end
-@inline function _cshp(::Tuple{}, out, shape, nshape)
-    next = _cs(length(out) + 1, false, shape[1], nshape[1])
-    _cshp((), (out..., next), tail(shape), tail(nshape))
-end
-@inline function _cshp(dims, out, shape, nshape)
-    next = _cs(length(out) + 1, dims[1], shape[1], nshape[1])
-    _cshp(tail(dims), (out..., next), tail(shape), tail(nshape))
-end
-
-_cs(d, concat, a, b) = concat ? (a + b) : (a == b ? a : throw(DimensionMismatch(string("mismatch in dimension ", d, " (expected ", a, " got ", b, ")"))))
-
-dims2cat{n}(::Type{Val{n}}) = ntuple(i -> (i == n), Val{n})
+    cat_shape(dims, _cshp(1, dims, shape, nshape), shapes...)
+
+_cshp(ndim::Int, ::Tuple{}, ::Tuple{}, ::Tuple{}) = ()
+_cshp(ndim::Int, ::Tuple{}, ::Tuple{}, nshape) = nshape
+_cshp(ndim::Int, dims, ::Tuple{}, ::Tuple{}) = ntuple(b -> 1, Val(length(dims)))
+@inline _cshp(ndim::Int, dims, shape, ::Tuple{}) =
+    (shape[1] + dims[1], _cshp(ndim + 1, tail(dims), tail(shape), ())...)
+@inline _cshp(ndim::Int, dims, ::Tuple{}, nshape) =
+    (nshape[1], _cshp(ndim + 1, tail(dims), (), tail(nshape))...)
+@inline function _cshp(ndim::Int, ::Tuple{}, shape, ::Tuple{})
+    _cs(ndim, shape[1], 1)
+    (1, _cshp(ndim + 1, (), tail(shape), ())...)
+end
+@inline function _cshp(ndim::Int, ::Tuple{}, shape, nshape)
+    next = _cs(ndim, shape[1], nshape[1])
+    (next, _cshp(ndim + 1, (), tail(shape), tail(nshape))...)
+end
+@inline function _cshp(ndim::Int, dims, shape, nshape)
+    a = shape[1]
+    b = nshape[1]
+    next = dims[1] ? a + b : _cs(ndim, a, b)
+    (next, _cshp(ndim + 1, tail(dims), tail(shape), tail(nshape))...)
+end
+
+_cs(d, a, b) = (a == b ? a : throw(DimensionMismatch(
+    "mismatch in dimension $d (expected $a got $b)")))
+
+dims2cat(::Val{n}) where {n} = ntuple(i -> (i == n), Val(n))
 dims2cat(dims) = ntuple(i -> (i in dims), maximum(dims))
 
 cat(dims, X...) = cat_t(dims, promote_eltypeof(X...), X...)
@@ -1169,7 +1249,7 @@ function cat_t(dims, T::Type, X...)
     return _cat(A, shape, catdims, X...)
 end
 
-function _cat{N}(A, shape::NTuple{N}, catdims, X...)
+function _cat(A, shape::NTuple{N}, catdims, X...) where N
     offsets = zeros(Int, N)
     inds = Vector{UnitRange{Int}}(N)
     concat = copy!(zeros(Bool, N), catdims)
@@ -1193,6 +1273,7 @@ end
 
 Concatenate along dimension 1.
 
+# Examples
 ```jldoctest
 julia> a = [1 2 3 4 5]
 1×5 Array{Int64,2}:
@@ -1218,12 +1299,13 @@ julia> vcat(c...)
  4  5  6
 ```
 """
-vcat(X...) = cat(Val{1}, X...)
+vcat(X...) = cat(Val(1), X...)
 """
     hcat(A...)
 
 Concatenate along dimension 2.
 
+# Examples
 ```jldoctest
 julia> a = [1; 2; 3; 4; 5]
 5-element Array{Int64,1}:
@@ -1259,28 +1341,28 @@ julia> hcat(c...)
  3  6
 ```
 """
-hcat(X...) = cat(Val{2}, X...)
+hcat(X...) = cat(Val(2), X...)
 
-typed_vcat(T::Type, X...) = cat_t(Val{1}, T, X...)
-typed_hcat(T::Type, X...) = cat_t(Val{2}, T, X...)
+typed_vcat(T::Type, X...) = cat_t(Val(1), T, X...)
+typed_hcat(T::Type, X...) = cat_t(Val(2), T, X...)
 
-cat{T}(catdims, A::AbstractArray{T}...) = cat_t(catdims, T, A...)
+cat(catdims, A::AbstractArray{T}...) where {T} = cat_t(catdims, T, A...)
 
 # The specializations for 1 and 2 inputs are important
 # especially when running with --inline=no, see #11158
-vcat(A::AbstractArray) = cat(Val{1}, A)
-vcat(A::AbstractArray, B::AbstractArray) = cat(Val{1}, A, B)
-vcat(A::AbstractArray...) = cat(Val{1}, A...)
-hcat(A::AbstractArray) = cat(Val{2}, A)
-hcat(A::AbstractArray, B::AbstractArray) = cat(Val{2}, A, B)
-hcat(A::AbstractArray...) = cat(Val{2}, A...)
-
-typed_vcat(T::Type, A::AbstractArray) = cat_t(Val{1}, T, A)
-typed_vcat(T::Type, A::AbstractArray, B::AbstractArray) = cat_t(Val{1}, T, A, B)
-typed_vcat(T::Type, A::AbstractArray...) = cat_t(Val{1}, T, A...)
-typed_hcat(T::Type, A::AbstractArray) = cat_t(Val{2}, T, A)
-typed_hcat(T::Type, A::AbstractArray, B::AbstractArray) = cat_t(Val{2}, T, A, B)
-typed_hcat(T::Type, A::AbstractArray...) = cat_t(Val{2}, T, A...)
+vcat(A::AbstractArray) = cat(Val(1), A)
+vcat(A::AbstractArray, B::AbstractArray) = cat(Val(1), A, B)
+vcat(A::AbstractArray...) = cat(Val(1), A...)
+hcat(A::AbstractArray) = cat(Val(2), A)
+hcat(A::AbstractArray, B::AbstractArray) = cat(Val(2), A, B)
+hcat(A::AbstractArray...) = cat(Val(2), A...)
+
+typed_vcat(T::Type, A::AbstractArray) = cat_t(Val(1), T, A)
+typed_vcat(T::Type, A::AbstractArray, B::AbstractArray) = cat_t(Val(1), T, A, B)
+typed_vcat(T::Type, A::AbstractArray...) = cat_t(Val(1), T, A...)
+typed_hcat(T::Type, A::AbstractArray) = cat_t(Val(2), T, A)
+typed_hcat(T::Type, A::AbstractArray, B::AbstractArray) = cat_t(Val(2), T, A, B)
+typed_hcat(T::Type, A::AbstractArray...) = cat_t(Val(2), T, A...)
 
 # 2d horizontal and vertical concatenation
 
@@ -1300,6 +1382,7 @@ Horizontal and vertical concatenation in one call. This function is called for b
 syntax. The first argument specifies the number of arguments to concatenate in each block
 row.
 
+# Examples
 ```jldoctest
 julia> a, b, c, d, e, f = 1, 2, 3, 4, 5, 6
 (1, 2, 3, 4, 5, 6)
@@ -1331,9 +1414,9 @@ If the first argument is a single integer `n`, then all block rows are assumed t
 block columns.
 """
 hvcat(rows::Tuple{Vararg{Int}}, xs::AbstractVecOrMat...) = typed_hvcat(promote_eltype(xs...), rows, xs...)
-hvcat{T}(rows::Tuple{Vararg{Int}}, xs::AbstractVecOrMat{T}...) = typed_hvcat(T, rows, xs...)
+hvcat(rows::Tuple{Vararg{Int}}, xs::AbstractVecOrMat{T}...) where {T} = typed_hvcat(T, rows, xs...)
 
-function typed_hvcat{T}(::Type{T}, rows::Tuple{Vararg{Int}}, as::AbstractVecOrMat...)
+function typed_hvcat(::Type{T}, rows::Tuple{Vararg{Int}}, as::AbstractVecOrMat...) where T
     nbr = length(rows)  # number of block rows
 
     nc = 0
@@ -1377,9 +1460,9 @@ function typed_hvcat{T}(::Type{T}, rows::Tuple{Vararg{Int}}, as::AbstractVecOrMa
 end
 
 hvcat(rows::Tuple{Vararg{Int}}) = []
-typed_hvcat{T}(::Type{T}, rows::Tuple{Vararg{Int}}) = Array{T,1}(0)
+typed_hvcat(::Type{T}, rows::Tuple{Vararg{Int}}) where {T} = Array{T,1}(0)
 
-function hvcat{T<:Number}(rows::Tuple{Vararg{Int}}, xs::T...)
+function hvcat(rows::Tuple{Vararg{Int}}, xs::T...) where T<:Number
     nr = length(rows)
     nc = rows[1]
 
@@ -1414,7 +1497,7 @@ end
 
 hvcat(rows::Tuple{Vararg{Int}}, xs::Number...) = typed_hvcat(promote_typeof(xs...), rows, xs...)
 
-function typed_hvcat{T}(::Type{T}, rows::Tuple{Vararg{Int}}, xs::Number...)
+function typed_hvcat(::Type{T}, rows::Tuple{Vararg{Int}}, xs::Number...) where T
     nr = length(rows)
     nc = rows[1]
     for i = 2:nr
@@ -1441,7 +1524,7 @@ function hvcat(rows::Tuple{Vararg{Int}}, as...)
     vcat(rs...)
 end
 
-function typed_hvcat{T}(::Type{T}, rows::Tuple{Vararg{Int}}, as...)
+function typed_hvcat(::Type{T}, rows::Tuple{Vararg{Int}}, as...) where T
     nbr = length(rows)  # number of block rows
     rs = Array{Any,1}(nbr)
     a = 1
@@ -1505,6 +1588,7 @@ end
 
 Returns a tuple of subscripts into array `a` corresponding to the linear index `index`.
 
+# Examples
 ```jldoctest
 julia> A = ones(5,6,7);
 
@@ -1532,6 +1616,7 @@ sub2ind(::Tuple{}, I::Integer...) = (@_inline_meta; _sub2ind((), 1, 1, I...))
 
 The inverse of [`ind2sub`](@ref), returns the linear index corresponding to the provided subscripts.
 
+# Examples
 ```jldoctest
 julia> sub2ind((5,6,7),1,2,3)
 66
@@ -1544,7 +1629,8 @@ sub2ind(dims::DimsInteger, I::Integer...) = (@_inline_meta; _sub2ind(dims, 1, 1,
 sub2ind(inds::Indices, I::Integer...) = (@_inline_meta; _sub2ind(inds, 1, 1, I...))
 # In 1d, there's a question of whether we're doing cartesian indexing
 # or linear indexing. Support only the former.
-sub2ind(inds::Indices{1}, I::Integer...) = throw(ArgumentError("Linear indexing is not defined for one-dimensional arrays"))
+sub2ind(inds::Indices{1}, I::Integer...) =
+    throw(ArgumentError("Linear indexing is not defined for one-dimensional arrays"))
 sub2ind(inds::Tuple{OneTo}, I::Integer...) = (@_inline_meta; _sub2ind(inds, 1, 1, I...)) # only OneTo is safe
 sub2ind(inds::Tuple{OneTo}, i::Integer)    = i
 
@@ -1572,14 +1658,14 @@ ind2sub(::Tuple{}, ind::Integer) = (@_inline_meta; ind == 1 ? () : throw(BoundsE
 Returns a tuple of subscripts into an array with dimensions `dims`,
 corresponding to the linear index `index`.
 
-**Example**:
-
+# Examples
 ```
 i, j, ... = ind2sub(size(A), indmax(A))
 ```
 
 provides the indices of the maximum element.
 
+# Examples
 ```jldoctest
 julia> ind2sub((3,4),2)
 (2, 1)
@@ -1593,7 +1679,8 @@ julia> ind2sub((3,4),4)
 """
 ind2sub(dims::DimsInteger, ind::Integer) = (@_inline_meta; _ind2sub(dims, ind-1))
 ind2sub(inds::Indices, ind::Integer)     = (@_inline_meta; _ind2sub(inds, ind-1))
-ind2sub(inds::Indices{1}, ind::Integer) = throw(ArgumentError("Linear indexing is not defined for one-dimensional arrays"))
+ind2sub(inds::Indices{1}, ind::Integer) =
+    throw(ArgumentError("Linear indexing is not defined for one-dimensional arrays"))
 ind2sub(inds::Tuple{OneTo}, ind::Integer) = (ind,)
 
 _ind2sub(::Tuple{}, ind) = (ind+1,)
@@ -1614,11 +1701,13 @@ _div(ind, d::Integer) = div(ind, d), 1, d
 _div(ind, r::AbstractUnitRange) = (d = unsafe_length(r); (div(ind, d), first(r), d))
 
 # Vectorized forms
-function sub2ind{T<:Integer}(inds::Indices{1}, I1::AbstractVector{T}, I::AbstractVector{T}...)
+function sub2ind(inds::Indices{1}, I1::AbstractVector{T}, I::AbstractVector{T}...) where T<:Integer
     throw(ArgumentError("Linear indexing is not defined for one-dimensional arrays"))
 end
-sub2ind{T<:Integer}(inds::Tuple{OneTo}, I1::AbstractVector{T}, I::AbstractVector{T}...) = _sub2ind_vecs(inds, I1, I...)
-sub2ind{T<:Integer}(inds::Union{DimsInteger,Indices}, I1::AbstractVector{T}, I::AbstractVector{T}...) = _sub2ind_vecs(inds, I1, I...)
+sub2ind(inds::Tuple{OneTo}, I1::AbstractVector{T}, I::AbstractVector{T}...) where {T<:Integer} =
+    _sub2ind_vecs(inds, I1, I...)
+sub2ind(inds::Union{DimsInteger,Indices}, I1::AbstractVector{T}, I::AbstractVector{T}...) where {T<:Integer} =
+    _sub2ind_vecs(inds, I1, I...)
 function _sub2ind_vecs(inds, I::AbstractVector...)
     I1 = I[1]
     Iinds = indices1(I1)
@@ -1633,19 +1722,19 @@ end
 function _sub2ind!(Iout, inds, Iinds, I)
     @_noinline_meta
     for i in Iinds
-        # Iout[i] = sub2ind(inds, map(Ij->Ij[i], I)...)
+        # Iout[i] = sub2ind(inds, map(Ij -> Ij[i], I)...)
         Iout[i] = sub2ind_vec(inds, i, I)
     end
     Iout
 end
 
-sub2ind_vec(inds, i, I) = (@_inline_meta; _sub2ind_vec(inds, (), i, I...))
-_sub2ind_vec(inds, out, i, I1, I...) = (@_inline_meta; _sub2ind_vec(inds, (out..., I1[i]), i, I...))
-_sub2ind_vec(inds, out, i) = (@_inline_meta; sub2ind(inds, out...))
+sub2ind_vec(inds, i, I) = (@_inline_meta; sub2ind(inds, _sub2ind_vec(i, I...)...))
+_sub2ind_vec(i, I1, I...) = (@_inline_meta; (I1[i], _sub2ind_vec(i, I...)...))
+_sub2ind_vec(i) = ()
 
-function ind2sub{N}(inds::Union{DimsInteger{N},Indices{N}}, ind::AbstractVector{<:Integer})
+function ind2sub(inds::Union{DimsInteger{N},Indices{N}}, ind::AbstractVector{<:Integer}) where N
     M = length(ind)
-    t = ntuple(n->similar(ind),Val{N})
+    t = ntuple(n->similar(ind),Val(N))
     for (i,idx) in enumerate(IndexLinear(), ind)
         sub = ind2sub(inds, idx)
         for j = 1:N
@@ -1655,7 +1744,7 @@ function ind2sub{N}(inds::Union{DimsInteger{N},Indices{N}}, ind::AbstractVector{
     t
 end
 
-function ind2sub!{T<:Integer}(sub::Array{T}, dims::Tuple{Vararg{T}}, ind::T)
+function ind2sub!(sub::Array{T}, dims::Tuple{Vararg{T}}, ind::T) where T<:Integer
     ndims = length(dims)
     for i=1:ndims-1
         ind2 = div(ind-1,dims[i])+1
@@ -1676,6 +1765,7 @@ 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)`.
 
+# Examples
 ```jldoctest
 julia> a = 1:3:7;
 
@@ -1703,6 +1793,7 @@ colons go in this expression. The results are concatenated along the remaining d
 For example, if `dims` is `[1,2]` and `A` is 4-dimensional, `f` is called on `A[:,:,i,j]`
 for all `i` and `j`.
 
+# Examples
 ```jldoctest
 julia> a = reshape(collect(1:16),(2,2,2,2))
 2×2×2×2 Array{Int64,4}:
@@ -1755,9 +1846,15 @@ function mapslices(f, A::AbstractArray, dims::AbstractVector)
         idx[d] = Slice(indices(A, d))
     end
 
+    # Apply the function to the first slice in order to determine the next steps
     Aslice = A[idx...]
     r1 = f(Aslice)
-    safe_for_reuse = isa(r1, Number) || (isa(r1, AbstractArray) && eltype(r1) <: Number)
+    # In some cases, we can re-use the first slice for a dramatic performance
+    # increase. The slice itself must be mutable and the result cannot contain
+    # any mutable containers. The following errs on the side of being overly
+    # strict (#18570 & #21123).
+    safe_for_reuse = isa(Aslice, StridedArray) &&
+                     (isa(r1, Number) || (isa(r1, AbstractArray) && eltype(r1) <: Number))
 
     # determine result size and allocate
     Rsize = copy(dimsA)
@@ -1765,7 +1862,7 @@ function mapslices(f, A::AbstractArray, dims::AbstractVector)
     if !isa(r1, AbstractArray) || ndims(r1) == 0
         r1 = [r1]
     end
-    nextra = max(0,length(dims)-ndims(r1))
+    nextra = max(0, length(dims)-ndims(r1))
     if eltype(Rsize) == Int
         Rsize[dims] = [size(r1)..., ntuple(d->1, nextra)...]
     else
@@ -1780,42 +1877,41 @@ function mapslices(f, A::AbstractArray, dims::AbstractVector)
 
     R[ridx...] = r1
 
-    isfirst = true
     nidx = length(otherdims)
+    indexes = Iterators.drop(CartesianRange(itershape), 1)
+    inner_mapslices!(safe_for_reuse, indexes, nidx, idx, otherdims, ridx, Aslice, A, f, R)
+end
+
+@noinline function inner_mapslices!(safe_for_reuse, indexes, nidx, idx, otherdims, ridx, Aslice, A, f, R)
     if safe_for_reuse
         # when f returns an array, R[ridx...] = f(Aslice) line copies elements,
         # so we can reuse Aslice
-        for I in CartesianRange(itershape)
-            if isfirst
-                isfirst = false  # skip the first element, we already handled it
-            else
-                for i in 1:nidx
-                    idx[otherdims[i]] = ridx[otherdims[i]] = I.I[i]
-                end
-                _unsafe_getindex!(Aslice, A, idx...)
-                R[ridx...] = f(Aslice)
-            end
+        for I in indexes # skip the first element, we already handled it
+            replace_tuples!(nidx, idx, ridx, otherdims, I)
+            _unsafe_getindex!(Aslice, A, idx...)
+            R[ridx...] = f(Aslice)
         end
     else
         # we can't guarantee safety (#18524), so allocate new storage for each slice
-        for I in CartesianRange(itershape)
-            if isfirst
-                isfirst = false
-            else
-                for i in 1:nidx
-                    idx[otherdims[i]] = ridx[otherdims[i]] = I.I[i]
-                end
-                R[ridx...] = f(A[idx...])
-            end
+        for I in indexes
+            replace_tuples!(nidx, idx, ridx, otherdims, I)
+            R[ridx...] = f(A[idx...])
         end
     end
 
     return R
 end
 
+function replace_tuples!(nidx, idx, ridx, otherdims, I)
+    for i in 1:nidx
+        idx[otherdims[i]] = ridx[otherdims[i]] = I.I[i]
+    end
+end
+
+
 ## 1 argument
 
-function map!{F}(f::F, dest::AbstractArray, A::AbstractArray)
+function map!(f::F, dest::AbstractArray, A::AbstractArray) where F
     for (i,j) in zip(eachindex(dest),eachindex(A))
         dest[i] = f(A[j])
     end
@@ -1832,6 +1928,7 @@ map(f, A::Union{AbstractArray,AbstractSet,Associative}) = collect_similar(A, Gen
 Transform collection `c` by applying `f` to each element. For multiple collection arguments,
 apply `f` elementwise.
 
+# Examples
 ```jldoctest
 julia> map(x -> x * 2, [1, 2, 3])
 3-element Array{Int64,1}:
@@ -1849,7 +1946,7 @@ julia> map(+, [1, 2, 3], [10, 20, 30])
 map(f, A) = collect(Generator(f,A))
 
 ## 2 argument
-function map!{F}(f::F, dest::AbstractArray, A::AbstractArray, B::AbstractArray)
+function map!(f::F, dest::AbstractArray, A::AbstractArray, B::AbstractArray) where F
     for (i, j, k) in zip(eachindex(dest), eachindex(A), eachindex(B))
         dest[i] = f(A[j], B[k])
     end
@@ -1861,7 +1958,7 @@ end
 @inline ith_all(i, ::Tuple{}) = ()
 @inline ith_all(i, as) = (as[1][i], ith_all(i, tail(as))...)
 
-function map_n!{F}(f::F, dest::AbstractArray, As)
+function map_n!(f::F, dest::AbstractArray, As) where F
     for i = linearindices(As[1])
         dest[i] = f(ith_all(i, As)...)
     end
@@ -1874,6 +1971,7 @@ end
 Like [`map`](@ref), but stores the result in `destination` rather than a new
 collection. `destination` must be at least as large as the first collection.
 
+# Examples
 ```jldoctest
 julia> x = zeros(3);
 
@@ -1886,7 +1984,7 @@ julia> x
  6.0
 ```
 """
-map!{F}(f::F, dest::AbstractArray, As::AbstractArray...) = map_n!(f, dest, As)
+map!(f::F, dest::AbstractArray, As::AbstractArray...) where {F} = map_n!(f, dest, As)
 
 map(f) = f()
 map(f, iters...) = collect(Generator(f, iters...))
@@ -1901,7 +1999,7 @@ unshift!(A, a, b, c...) = unshift!(unshift!(A, c...), a, b)
 ## hashing collections ##
 
 const hashaa_seed = UInt === UInt64 ? 0x7f53e68ceb575e76 : 0xeb575e76
-const hashrle_seed = UInt == UInt64 ? 0x2aab8909bfea414c : 0xbfea414c
+const hashrle_seed = UInt === UInt64 ? 0x2aab8909bfea414c : 0xbfea414c
 function hash(a::AbstractArray, h::UInt)
     h += hashaa_seed
     h += hash(size(a))
diff --git a/base/abstractarraymath.jl b/base/abstractarraymath.jl
index 14fb13a94a3f71..437fa54204943d 100644
--- a/base/abstractarraymath.jl
+++ b/base/abstractarraymath.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
  ## Basic functions ##
 
@@ -12,8 +12,11 @@ all(::typeof(isinteger), ::AbstractArray{<:Integer}) = true
 """
     vec(a::AbstractArray) -> Vector
 
-Reshape array `a` as a one-dimensional column vector.
+Reshape the array `a` as a one-dimensional column vector. The resulting array
+shares the same underlying data as `a`, so modifying one will also modify the
+other.
 
+# Examples
 ```jldoctest
 julia> a = [1 2 3; 4 5 6]
 2×3 Array{Int64,2}:
@@ -29,6 +32,8 @@ julia> vec(a)
  3
  6
 ```
+
+See also [`reshape`](@ref).
 """
 vec(a::AbstractArray) = reshape(a,_length(a))
 vec(a::AbstractVector) = a
@@ -44,6 +49,7 @@ Remove the dimensions specified by `dims` from array `A`.
 Elements of `dims` must be unique and within the range `1:ndims(A)`.
 `size(A,i)` must equal 1 for all `i` in `dims`.
 
+# Examples
 ```jldoctest
 julia> a = reshape(collect(1:4),(2,2,1,1))
 2×2×1×1 Array{Int64,4}:
@@ -97,6 +103,7 @@ imag(x::AbstractArray{<:Real}) = zero(x)
 Return all the data of `A` where the index for dimension `d` equals `i`. Equivalent to
 `A[:,:,...,i,:,:,...]` where `i` is in position `d`.
 
+# Examples
 ```jldoctest
 julia> A = [1 2 3 4; 5 6 7 8]
 2×4 Array{Int64,2}:
@@ -116,16 +123,12 @@ function slicedim(A::AbstractArray, d::Integer, i)
     A[setindex(indices(A), i, d)...]
 end
 
-function flipdim(A::AbstractVector, d::Integer)
-    d == 1 || throw(ArgumentError("dimension to flip must be 1"))
-    reverse(A)
-end
-
 """
     flipdim(A, d::Integer)
 
 Reverse `A` in dimension `d`.
 
+# Examples
 ```jldoctest
 julia> b = [1 2; 3 4]
 2×2 Array{Int64,2}:
@@ -143,6 +146,8 @@ function flipdim(A::AbstractArray, d::Integer)
     1 ≤ d ≤ nd || throw(ArgumentError("dimension $d is not 1 ≤ $d ≤ $nd"))
     if isempty(A)
         return copy(A)
+    elseif nd == 1
+        return reverse(A)
     end
     inds = indices(A)
     B = similar(A)
@@ -176,6 +181,7 @@ circshift(a::AbstractArray, shiftamt::DimsInteger) = circshift!(similar(a), a, s
 Circularly shift the data in an array. The second argument is a vector giving the amount to
 shift in each dimension.
 
+# Examples
 ```jldoctest
 julia> b = reshape(collect(1:16), (4,4))
 4×4 Array{Int64,2}:
@@ -206,7 +212,7 @@ function circshift(a::AbstractArray, shiftamt)
 end
 
 # Uses K-B-N summation
-function cumsum_kbn{T<:AbstractFloat}(v::AbstractVector{T})
+function cumsum_kbn(v::AbstractVector{T}) where T<:AbstractFloat
     r = similar(v)
     if isempty(v); return r; end
 
@@ -237,7 +243,7 @@ end
 Cumulative sum along a dimension, using the Kahan-Babuska-Neumaier compensated summation
 algorithm for additional accuracy. The dimension defaults to 1.
 """
-function cumsum_kbn{T<:AbstractFloat}(A::AbstractArray{T}, axis::Integer=1)
+function cumsum_kbn(A::AbstractArray{T}, axis::Integer=1) where T<:AbstractFloat
     dimsA = size(A)
     ndimsA = ndims(A)
     axis_size = dimsA[axis]
@@ -280,6 +286,7 @@ end
 Construct a matrix by repeating the given matrix (or vector) `m` times in dimension 1 and `n` times in
 dimension 2.
 
+# Examples
 ```jldoctest
 julia> repmat([1, 2, 3], 2)
 6-element Array{Int64,1}:
@@ -336,6 +343,7 @@ repeated. The i-th element of `outer` specifies the number of times that a slice
 i-th dimension of `A` should be repeated. If `inner` or `outer` are omitted, no repetition
 is performed.
 
+# Examples
 ```jldoctest
 julia> repeat(1:2, inner=2)
 4-element Array{Int64,1}:
@@ -360,8 +368,8 @@ julia> repeat([1 2; 3 4], inner=(2, 1), outer=(1, 3))
 ```
 """
 function repeat(A::AbstractArray;
-                inner=ntuple(n->1, Val{ndims(A)}),
-                outer=ntuple(n->1, Val{ndims(A)}))
+                inner=ntuple(n->1, Val(ndims(A))),
+                outer=ntuple(n->1, Val(ndims(A))))
     return _repeat(A, rep_kw2tup(inner), rep_kw2tup(outer))
 end
 
@@ -389,7 +397,7 @@ _rshps(shp, shp_i, sz, i, ::Tuple{}) =
 _reperr(s, n, N) = throw(ArgumentError("number of " * s * " repetitions " *
     "($n) cannot be less than number of dimensions of input ($N)"))
 
-@propagate_inbounds function _repeat(A::AbstractArray, inner, outer)
+@noinline function _repeat(A::AbstractArray, inner, outer)
     shape, inner_shape = rep_shapes(A, inner, outer)
 
     R = similar(A, shape)
@@ -407,7 +415,7 @@ _reperr(s, n, N) = throw(ArgumentError("number of " * s * " repetitions " *
                 n = inner[i]
                 inner_indices[i] = (1:n) + ((c[i] - 1) * n)
             end
-            R[inner_indices...] = A[c]
+            fill!(view(R, inner_indices...), A[c])
         end
     end
 
diff --git a/base/array.jl b/base/array.jl
index 153f7cbf942c8a..d88aac162d9f1c 100644
--- a/base/array.jl
+++ b/base/array.jl
@@ -1,10 +1,22 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## array.jl: Dense arrays
 
 ## Type aliases for convenience ##
+"""
+    AbstractVector{T}
 
+Supertype for one-dimensional arrays (or array-like types) with
+elements of type `T`. Alias for [`AbstractArray{T,1}`](@ref).
+"""
 const AbstractVector{T} = AbstractArray{T,1}
+
+"""
+    AbstractMatrix{T}
+
+Supertype for two-dimensional arrays (or array-like types) with
+elements of type `T`. Alias for [`AbstractArray{T,2}`](@ref).
+"""
 const AbstractMatrix{T} = AbstractArray{T,2}
 const AbstractVecOrMat{T} = Union{AbstractVector{T}, AbstractMatrix{T}}
 const RangeIndex = Union{Int, Range{Int}, AbstractUnitRange{Int}}
@@ -13,7 +25,27 @@ const IntOrInd = Union{Int, AbstractUnitRange}
 const DimsOrInds{N} = NTuple{N,DimOrInd}
 const NeedsShaping = Union{Tuple{Integer,Vararg{Integer}}, Tuple{OneTo,Vararg{OneTo}}}
 
+"""
+    Array{T,N} <: AbstractArray{T,N}
+
+`N`-dimensional dense array with elements of type `T`.
+"""
+Array
+
+"""
+    Vector{T} <: AbstractVector{T}
+
+One-dimensional dense array with elements of type `T`, often used to represent
+a mathematical vector. Alias for [`Array{T,1}`](@ref).
+"""
 const Vector{T} = Array{T,1}
+
+"""
+    Matrix{T} <: AbstractMatrix{T}
+
+Two-dimensional dense array with elements of type `T`, often used to represent
+a mathematical matrix. Alias for [`Array{T,2}`](@ref).
+"""
 const Matrix{T} = Array{T,2}
 const VecOrMat{T} = Union{Vector{T}, Matrix{T}}
 
@@ -32,6 +64,7 @@ For associative collection types, this will be a `Pair{KeyType,ValType}`. The de
 instead of types. However the form that accepts a type argument should be defined for new
 types.
 
+# Examples
 ```jldoctest
 julia> eltype(ones(Float32,2,2))
 Float32
@@ -48,20 +81,8 @@ eltype(x) = eltype(typeof(x))
 
 import Core: arraysize, arrayset, arrayref
 
-"""
-    Array{T}(dims)
-    Array{T,N}(dims)
-
-Construct an uninitialized `N`-dimensional dense array with element type `T`,
-where `N` is determined from the length or number of `dims`.  `dims` may
-be a tuple or a series of integer arguments corresponding to the lengths in each dimension.
-If the rank `N` is supplied explicitly as in `Array{T,N}(dims)`, then it must
-match the length or number of `dims`.
-"""
-Array
-
 vect() = Array{Any,1}(0)
-vect{T}(X::T...) = T[ X[i] for i=1:length(X) ]
+vect(X::T...) where {T} = T[ X[i] for i = 1:length(X) ]
 
 function vect(X...)
     T = promote_typeof(X...)
@@ -73,28 +94,24 @@ end
 size(a::Array, d) = arraysize(a, d)
 size(a::Vector) = (arraysize(a,1),)
 size(a::Matrix) = (arraysize(a,1), arraysize(a,2))
-size(a::Array) = (@_inline_meta; _size((), a))
-_size{_,N}(out::NTuple{N}, A::Array{_,N}) = out
-function _size{_,M,N}(out::NTuple{M}, A::Array{_,N})
-    @_inline_meta
-    _size((out..., size(A,M+1)), A)
-end
+size(a::Array{<:Any,N}) where {N} = (@_inline_meta; ntuple(M -> size(a, M), Val(N)))
 
 asize_from(a::Array, n) = n > ndims(a) ? () : (arraysize(a,n), asize_from(a, n+1)...)
 
 length(a::Array) = arraylen(a)
-elsize{T}(a::Array{T}) = isbits(T) ? sizeof(T) : sizeof(Ptr)
-sizeof(a::Array) = elsize(a) * length(a)
+elsize(a::Array{T}) where {T} = isbits(T) ? sizeof(T) : sizeof(Ptr)
+sizeof(a::Array) = Core.sizeof(a)
 
 function isassigned(a::Array, i::Int...)
-    ii = sub2ind(size(a), i...)
-    1 <= ii <= length(a) || return false
-    ccall(:jl_array_isassigned, Cint, (Any, UInt), a, ii-1) == 1
+    @_inline_meta
+    ii = (sub2ind(size(a), i...) % UInt) - 1
+    @boundscheck ii < length(a) % UInt || return false
+    ccall(:jl_array_isassigned, Cint, (Any, UInt), a, ii) == 1
 end
 
 ## copy ##
 
-function unsafe_copy!{T}(dest::Ptr{T}, src::Ptr{T}, n)
+function unsafe_copy!(dest::Ptr{T}, src::Ptr{T}, n) where T
     # Do not use this to copy data between pointer arrays.
     # It can't be made safe no matter how carefully you checked.
     ccall(:memmove, Ptr{Void}, (Ptr{Void}, Ptr{Void}, UInt),
@@ -102,7 +119,7 @@ function unsafe_copy!{T}(dest::Ptr{T}, src::Ptr{T}, n)
     return dest
 end
 
-function unsafe_copy!{T}(dest::Array{T}, doffs, src::Array{T}, soffs, n)
+function unsafe_copy!(dest::Array{T}, doffs, src::Array{T}, soffs, n) where T
     if isbits(T)
         unsafe_copy!(pointer(dest, doffs), pointer(src, soffs), n)
     else
@@ -112,7 +129,7 @@ function unsafe_copy!{T}(dest::Array{T}, doffs, src::Array{T}, soffs, n)
     return dest
 end
 
-function copy!{T}(dest::Array{T}, doffs::Integer, src::Array{T}, soffs::Integer, n::Integer)
+function copy!(dest::Array{T}, doffs::Integer, src::Array{T}, soffs::Integer, n::Integer) where T
     n == 0 && return dest
     n > 0 || throw(ArgumentError(string("tried to copy n=", n, " elements, but n should be nonnegative")))
     if soffs < 1 || doffs < 1 || soffs+n-1 > length(src) || doffs+n-1 > length(dest)
@@ -121,41 +138,41 @@ function copy!{T}(dest::Array{T}, doffs::Integer, src::Array{T}, soffs::Integer,
     unsafe_copy!(dest, doffs, src, soffs, n)
 end
 
-copy!{T}(dest::Array{T}, src::Array{T}) = copy!(dest, 1, src, 1, length(src))
+copy!(dest::Array{T}, src::Array{T}) where {T} = copy!(dest, 1, src, 1, length(src))
 
-copy{T<:Array}(a::T) = ccall(:jl_array_copy, Ref{T}, (Any,), a)
+copy(a::T) where {T<:Array} = ccall(:jl_array_copy, Ref{T}, (Any,), a)
 
-function reinterpret{T,S}(::Type{T}, a::Array{S,1})
+function reinterpret(::Type{T}, a::Array{S,1}) where T where S
     nel = Int(div(length(a)*sizeof(S),sizeof(T)))
     # TODO: maybe check that remainder is zero?
     return reinterpret(T, a, (nel,))
 end
 
-function reinterpret{T,S}(::Type{T}, a::Array{S})
+function reinterpret(::Type{T}, a::Array{S}) where T where S
     if sizeof(S) != sizeof(T)
         throw(ArgumentError("result shape not specified"))
     end
     reinterpret(T, a, size(a))
 end
 
-function reinterpret{T,S,N}(::Type{T}, a::Array{S}, dims::NTuple{N,Int})
-    if !isbits(T)
-        throw(ArgumentError("cannot reinterpret Array{$(S)} to ::Type{Array{$(T)}}, type $(T) is not a bits type"))
-    end
-    if !isbits(S)
-        throw(ArgumentError("cannot reinterpret Array{$(S)} to ::Type{Array{$(T)}}, type $(S) is not a bits type"))
+function reinterpret(::Type{T}, a::Array{S}, dims::NTuple{N,Int}) where T where S where N
+    function throwbits(::Type{S}, ::Type{T}, ::Type{U}) where {S,T,U}
+        @_noinline_meta
+        throw(ArgumentError("cannot reinterpret Array{$(S)} to ::Type{Array{$(T)}}, type $(U) is not a bits type"))
     end
+    isbits(T) || throwbits(S, T, T)
+    isbits(S) || throwbits(S, T, S)
     nel = div(length(a)*sizeof(S),sizeof(T))
     if prod(dims) != nel
-        throw(DimensionMismatch("new dimensions $(dims) must be consistent with array size $(nel)"))
+        _throw_dmrsa(dims, nel)
     end
     ccall(:jl_reshape_array, Array{T,N}, (Any, Any, Any), Array{T,N}, a, dims)
 end
 
 # reshaping to same # of dimensions
-function reshape{T,N}(a::Array{T,N}, dims::NTuple{N,Int})
+function reshape(a::Array{T,N}, dims::NTuple{N,Int}) where T where N
     if prod(dims) != length(a)
-        throw(DimensionMismatch("new dimensions $(dims) must be consistent with array size $(length(a))"))
+        _throw_dmrsa(dims, length(a))
     end
     if dims == size(a)
         return a
@@ -164,25 +181,51 @@ function reshape{T,N}(a::Array{T,N}, dims::NTuple{N,Int})
 end
 
 # reshaping to different # of dimensions
-function reshape{T,N}(a::Array{T}, dims::NTuple{N,Int})
+function reshape(a::Array{T}, dims::NTuple{N,Int}) where T where N
     if prod(dims) != length(a)
-        throw(DimensionMismatch("new dimensions $(dims) must be consistent with array size $(length(a))"))
+        _throw_dmrsa(dims, length(a))
     end
     ccall(:jl_reshape_array, Array{T,N}, (Any, Any, Any), Array{T,N}, a, dims)
 end
 
+function _throw_dmrsa(dims, len)
+    @_noinline_meta
+    throw(DimensionMismatch("new dimensions $(dims) must be consistent with array size $len"))
+end
+
 ## Constructors ##
 
-similar{T}(a::Array{T,1})                    = Array{T,1}(size(a,1))
-similar{T}(a::Array{T,2})                    = Array{T,2}(size(a,1), size(a,2))
-similar{T}(a::Array{T,1}, S::Type)           = Array{S,1}(size(a,1))
-similar{T}(a::Array{T,2}, S::Type)           = Array{S,2}(size(a,1), size(a,2))
-similar{T}(a::Array{T}, m::Int)              = Array{T,1}(m)
-similar{N}(a::Array, T::Type, dims::Dims{N}) = Array{T,N}(dims)
-similar{T,N}(a::Array{T}, dims::Dims{N})     = Array{T,N}(dims)
+similar(a::Array{T,1}) where {T}                    = Array{T,1}(size(a,1))
+similar(a::Array{T,2}) where {T}                    = Array{T,2}(size(a,1), size(a,2))
+similar(a::Array{T,1}, S::Type) where {T}           = Array{S,1}(size(a,1))
+similar(a::Array{T,2}, S::Type) where {T}           = Array{S,2}(size(a,1), size(a,2))
+similar(a::Array{T}, m::Int) where {T}              = Array{T,1}(m)
+similar(a::Array, T::Type, dims::Dims{N}) where {N} = Array{T,N}(dims)
+similar(a::Array{T}, dims::Dims{N}) where {T,N}     = Array{T,N}(dims)
 
 # T[x...] constructs Array{T,1}
-function getindex{T}(::Type{T}, vals...)
+"""
+    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,...]`.
+
+# Examples
+```jldoctest
+julia> Int8[1, 2, 3]
+3-element Array{Int8,1}:
+ 1
+ 2
+ 3
+
+julia> getindex(Int8, 1, 2, 3)
+3-element Array{Int8,1}:
+ 1
+ 2
+ 3
+```
+"""
+function getindex(::Type{T}, vals...) where T
     a = Array{T,1}(length(vals))
     @inbounds for i = 1:length(vals)
         a[i] = vals[i]
@@ -190,12 +233,12 @@ function getindex{T}(::Type{T}, vals...)
     return a
 end
 
-getindex{T}(::Type{T}) = (@_inline_meta; Array{T,1}(0))
-getindex{T}(::Type{T}, x) = (@_inline_meta; a = Array{T,1}(1); @inbounds a[1] = x; a)
-getindex{T}(::Type{T}, x, y) = (@_inline_meta; a = Array{T,1}(2); @inbounds (a[1] = x; a[2] = y); a)
-getindex{T}(::Type{T}, x, y, z) = (@_inline_meta; a = Array{T,1}(3); @inbounds (a[1] = x; a[2] = y; a[3] = z); a)
+getindex(::Type{T}) where {T} = (@_inline_meta; Array{T,1}(0))
+getindex(::Type{T}, x) where {T} = (@_inline_meta; a = Array{T,1}(1); @inbounds a[1] = x; a)
+getindex(::Type{T}, x, y) where {T} = (@_inline_meta; a = Array{T,1}(2); @inbounds (a[1] = x; a[2] = y); a)
+getindex(::Type{T}, x, y, z) where {T} = (@_inline_meta; a = Array{T,1}(3); @inbounds (a[1] = x; a[2] = y; a[3] = z); a)
 
-function getindex(::Type{Any}, vals::ANY...)
+function getindex(::Type{Any}, @nospecialize vals...)
     a = Array{Any,1}(length(vals))
     @inbounds for i = 1:length(vals)
         a[i] = vals[i]
@@ -209,7 +252,7 @@ function fill!(a::Union{Array{UInt8}, Array{Int8}}, x::Integer)
     return a
 end
 
-function fill!{T<:Union{Integer,AbstractFloat}}(a::Array{T}, x)
+function fill!(a::Array{T}, x) where T<:Union{Integer,AbstractFloat}
     xT = convert(T, x)
     for i in eachindex(a)
         @inbounds a[i] = xT
@@ -224,6 +267,7 @@ end
 Create an array filled with the value `x`. For example, `fill(1.0, (5,5))` returns a 5×5
 array of floats, with each element initialized to `1.0`.
 
+# Examples
 ```jldoctest
 julia> fill(1.0, (5,5))
 5×5 Array{Float64,2}:
@@ -258,9 +302,28 @@ end
     eye([T::Type=Float64,] m::Integer, n::Integer)
 
 `m`-by-`n` identity matrix.
-The default element type is `Float64`.
+The default element type is [`Float64`](@ref).
+
+# Examples
+```jldoctest
+julia> eye(3, 4)
+3×4 Array{Float64,2}:
+ 1.0  0.0  0.0  0.0
+ 0.0  1.0  0.0  0.0
+ 0.0  0.0  1.0  0.0
+
+julia> eye(2, 2)
+2×2 Array{Float64,2}:
+ 1.0  0.0
+ 0.0  1.0
+
+julia> eye(Int, 2, 2)
+2×2 Array{Int64,2}:
+ 1  0
+ 0  1
+```
 """
-function eye{T}(::Type{T}, m::Integer, n::Integer)
+function eye(::Type{T}, m::Integer, n::Integer) where T
     a = zeros(T,m,n)
     for i = 1:min(m,n)
         a[i,i] = oneunit(T)
@@ -274,12 +337,25 @@ end
 `m`-by-`n` identity matrix.
 """
 eye(m::Integer, n::Integer) = eye(Float64, m, n)
-eye{T}(::Type{T}, n::Integer) = eye(T, n, n)
+eye(::Type{T}, n::Integer) where {T} = eye(T, n, n)
 """
     eye([T::Type=Float64,] n::Integer)
 
 `n`-by-`n` identity matrix.
-The default element type is `Float64`.
+The default element type is [`Float64`](@ref).
+
+# Examples
+```jldoctest
+julia> eye(Int, 2)
+2×2 Array{Int64,2}:
+ 1  0
+ 0  1
+
+julia> eye(2)
+2×2 Array{Float64,2}:
+ 1.0  0.0
+ 0.0  1.0
+```
 """
 eye(n::Integer) = eye(Float64, n)
 
@@ -288,6 +364,7 @@ eye(n::Integer) = eye(Float64, n)
 
 Constructs an identity matrix of the same dimensions and type as `A`.
 
+# Examples
 ```jldoctest
 julia> A = [1 2 3; 4 5 6; 7 8 9]
 3×3 Array{Int64,2}:
@@ -304,29 +381,29 @@ julia> eye(A)
 
 Note the difference from [`ones`](@ref).
 """
-eye{T}(x::AbstractMatrix{T}) = eye(typeof(one(T)), size(x, 1), size(x, 2))
+eye(x::AbstractMatrix{T}) where {T} = eye(typeof(one(T)), size(x, 1), size(x, 2))
 
-function _one{T}(unit::T, x::AbstractMatrix)
+function _one(unit::T, x::AbstractMatrix) where T
     m,n = size(x)
     m==n || throw(DimensionMismatch("multiplicative identity defined only for square matrices"))
     eye(T, m)
 end
 
-one{T}(x::AbstractMatrix{T}) = _one(one(T), x)
-oneunit{T}(x::AbstractMatrix{T}) = _one(oneunit(T), x)
+one(x::AbstractMatrix{T}) where {T} = _one(one(T), x)
+oneunit(x::AbstractMatrix{T}) where {T} = _one(oneunit(T), x)
 
 ## Conversions ##
 
-convert{T}(::Type{Vector}, x::AbstractVector{T}) = convert(Vector{T}, x)
-convert{T}(::Type{Matrix}, x::AbstractMatrix{T}) = convert(Matrix{T}, x)
+convert(::Type{Vector}, x::AbstractVector{T}) where {T} = convert(Vector{T}, x)
+convert(::Type{Matrix}, x::AbstractMatrix{T}) where {T} = convert(Matrix{T}, x)
 
-convert{T,n}(::Type{Array{T}}, x::Array{T,n}) = x
-convert{T,n}(::Type{Array{T,n}}, x::Array{T,n}) = x
+convert(::Type{Array{T}}, x::Array{T,n}) where {T,n} = x
+convert(::Type{Array{T,n}}, x::Array{T,n}) where {T,n} = 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,n}(size(x)), x)
+convert(::Type{Array{T}}, x::AbstractArray{S,n}) where {T,n,S} = convert(Array{T,n}, x)
+convert(::Type{Array{T,n}}, x::AbstractArray{S,n}) where {T,n,S} = copy!(Array{T,n}(size(x)), x)
 
-promote_rule{T,n,S}(::Type{Array{T,n}}, ::Type{Array{S,n}}) = Array{promote_type(T,S),n}
+promote_rule(a::Type{Array{T,n}}, b::Type{Array{S,n}}) where {T,n,S} = el_same(promote_type(T,S), a, b)
 
 ## copying iterators to containers
 
@@ -336,6 +413,7 @@ promote_rule{T,n,S}(::Type{Array{T,n}}, ::Type{Array{S,n}}) = Array{promote_type
 Return an `Array` with the given element type of all items in a collection or iterable.
 The result has the same shape and number of dimensions as `collection`.
 
+# Examples
 ```jldoctest
 julia> collect(Float64, 1:2:5)
 3-element Array{Float64,1}:
@@ -344,11 +422,11 @@ julia> collect(Float64, 1:2:5)
  5.0
 ```
 """
-collect{T}(::Type{T}, itr) = _collect(T, itr, iteratorsize(itr))
+collect(::Type{T}, itr) where {T} = _collect(T, itr, iteratorsize(itr))
 
-_collect{T}(::Type{T}, itr, isz::HasLength) = copy!(Array{T,1}(Int(length(itr)::Integer)), itr)
-_collect{T}(::Type{T}, itr, isz::HasShape)  = copy!(similar(Array{T}, indices(itr)), itr)
-function _collect{T}(::Type{T}, itr, isz::SizeUnknown)
+_collect(::Type{T}, itr, isz::HasLength) where {T} = copy!(Array{T,1}(Int(length(itr)::Integer)), itr)
+_collect(::Type{T}, itr, isz::HasShape) where {T}  = copy!(similar(Array{T}, indices(itr)), itr)
+function _collect(::Type{T}, itr, isz::SizeUnknown) where T
     a = Array{T,1}(0)
     for x in itr
         push!(a,x)
@@ -369,6 +447,7 @@ Return an `Array` of all items in a collection or iterator. For associative coll
 `Pair{KeyType, ValType}`. If the argument is array-like or is an iterator with the `HasShape()`
 trait, the result will have the same shape and number of dimensions as the argument.
 
+# Examples
 ```jldoctest
 julia> collect(1:2:13)
 7-element Array{Int64,1}:
@@ -383,6 +462,8 @@ julia> collect(1:2:13)
 """
 collect(itr) = _collect(1:1 #= Array =#, itr, iteratoreltype(itr), iteratorsize(itr))
 
+collect(A::AbstractArray) = _collect_indices(indices(A), A)
+
 collect_similar(cont, itr) = _collect(cont, itr, iteratoreltype(itr), iteratorsize(itr))
 
 _collect(cont, itr, ::HasEltype, isz::Union{HasLength,HasShape}) =
@@ -396,14 +477,22 @@ function _collect(cont, itr, ::HasEltype, isz::SizeUnknown)
     return a
 end
 
+_collect_indices(::Tuple{}, A) = copy!(Vector{eltype(A)}(), A)
+_collect_indices(indsA::Tuple{Vararg{OneTo}}, A) =
+    copy!(Array{eltype(A)}(length.(indsA)), A)
+function _collect_indices(indsA, A)
+    B = Array{eltype(A)}(length.(indsA))
+    copy!(B, CartesianRange(indices(B)), A, CartesianRange(indsA))
+end
+
 if isdefined(Core, :Inference)
-    _default_eltype(itrt::ANY) = Core.Inference.return_type(first, Tuple{itrt})
+    _default_eltype(@nospecialize itrt) = Core.Inference.return_type(first, Tuple{itrt})
 else
-    _default_eltype(itr::ANY) = Any
+    _default_eltype(@nospecialize itr) = Any
 end
 
-_array_for{T}(::Type{T}, itr, ::HasLength) = Array{T,1}(Int(length(itr)::Integer))
-_array_for{T}(::Type{T}, itr, ::HasShape) = similar(Array{T}, indices(itr))
+_array_for(::Type{T}, itr, ::HasLength) where {T} = Array{T,1}(Int(length(itr)::Integer))
+_array_for(::Type{T}, itr, ::HasShape) where {T} = similar(Array{T}, indices(itr))
 
 function collect(itr::Generator)
     isz = iteratorsize(itr.iter)
@@ -443,7 +532,7 @@ function collect_to_with_first!(dest, v1, itr, st)
     return grow_to!(dest, itr, st)
 end
 
-function collect_to!{T}(dest::AbstractArray{T}, itr, offs, st)
+function collect_to!(dest::AbstractArray{T}, itr, offs, st) where T
     # collect to dest array, checking the type of each result. if a result does not
     # match, widen the result type and re-dispatch.
     i = offs
@@ -518,16 +607,17 @@ function getindex(A::Array, c::Colon)
 end
 
 # This is redundant with the abstract fallbacks, but needed for bootstrap
-function getindex{S}(A::Array{S}, I::Range{Int})
+function getindex(A::Array{S}, I::Range{Int}) where S
     return S[ A[i] for i in I ]
 end
 
 ## Indexing: setindex! ##
-setindex!{T}(A::Array{T}, x, i1::Int) = arrayset(A, convert(T,x)::T, i1)
-setindex!{T}(A::Array{T}, x, i1::Int, i2::Int, I::Int...) = (@_inline_meta; arrayset(A, convert(T,x)::T, i1, i2, I...)) # TODO: REMOVE FOR #14770
+setindex!(A::Array{T}, x, i1::Int) where {T} = arrayset(A, convert(T,x)::T, i1)
+setindex!(A::Array{T}, x, i1::Int, i2::Int, I::Int...) where {T} = (@_inline_meta; arrayset(A, convert(T,x)::T, i1, i2, I...)) # TODO: REMOVE FOR #14770
 
 # These are redundant with the abstract fallbacks but needed for bootstrap
 function setindex!(A::Array, x, I::AbstractVector{Int})
+    @_propagate_inbounds_meta
     A === I && (I = copy(I))
     for i in I
         A[i] = x
@@ -535,7 +625,8 @@ function setindex!(A::Array, x, I::AbstractVector{Int})
     return A
 end
 function setindex!(A::Array, X::AbstractArray, I::AbstractVector{Int})
-    setindex_shape_check(X, length(I))
+    @_propagate_inbounds_meta
+    @boundscheck setindex_shape_check(X, length(I))
     count = 1
     if X === A
         X = copy(X)
@@ -544,26 +635,28 @@ function setindex!(A::Array, X::AbstractArray, I::AbstractVector{Int})
         I = copy(I)
     end
     for i in I
-        A[i] = X[count]
+        @inbounds x = X[count]
+        A[i] = x
         count += 1
     end
     return A
 end
 
 # Faster contiguous setindex! with copy!
-function setindex!{T}(A::Array{T}, X::Array{T}, I::UnitRange{Int})
+function setindex!(A::Array{T}, X::Array{T}, I::UnitRange{Int}) where T
     @_inline_meta
     @boundscheck checkbounds(A, I)
     lI = length(I)
-    setindex_shape_check(X, lI)
+    @boundscheck setindex_shape_check(X, lI)
     if lI > 0
         unsafe_copy!(A, first(I), X, 1, lI)
     end
     return A
 end
-function setindex!{T}(A::Array{T}, X::Array{T}, c::Colon)
+function setindex!(A::Array{T}, X::Array{T}, c::Colon) where T
+    @_inline_meta
     lI = length(A)
-    setindex_shape_check(X, lI)
+    @boundscheck setindex_shape_check(X, lI)
     if lI > 0
         unsafe_copy!(A, 1, X, 1, lI)
     end
@@ -571,30 +664,38 @@ function setindex!{T}(A::Array{T}, X::Array{T}, c::Colon)
 end
 
 setindex!(A::Array, x::Number, ::Colon) = fill!(A, x)
-setindex!{T, N}(A::Array{T, N}, x::Number, ::Vararg{Colon, N}) = fill!(A, x)
+setindex!(A::Array{T, N}, x::Number, ::Vararg{Colon, N}) where {T, N} = fill!(A, x)
 
 # efficiently grow an array
 
+_growbeg!(a::Vector, delta::Integer) =
+    ccall(:jl_array_grow_beg, Void, (Any, UInt), a, delta)
+_growend!(a::Vector, delta::Integer) =
+    ccall(:jl_array_grow_end, Void, (Any, UInt), a, delta)
 _growat!(a::Vector, i::Integer, delta::Integer) =
     ccall(:jl_array_grow_at, Void, (Any, Int, UInt), a, i - 1, delta)
 
 # efficiently delete part of an array
 
+_deletebeg!(a::Vector, delta::Integer) =
+    ccall(:jl_array_del_beg, Void, (Any, UInt), a, delta)
+_deleteend!(a::Vector, delta::Integer) =
+    ccall(:jl_array_del_end, Void, (Any, UInt), a, delta)
 _deleteat!(a::Vector, i::Integer, delta::Integer) =
     ccall(:jl_array_del_at, Void, (Any, Int, UInt), a, i - 1, delta)
 
 ## Dequeue functionality ##
 
-function push!{T}(a::Array{T,1}, item)
+function push!(a::Array{T,1}, item) where T
     # convert first so we don't grow the array if the assignment won't work
     itemT = convert(T, item)
-    ccall(:jl_array_grow_end, Void, (Any, UInt), a, 1)
+    _growend!(a, 1)
     a[end] = itemT
     return a
 end
 
-function push!(a::Array{Any,1}, item::ANY)
-    ccall(:jl_array_grow_end, Void, (Any, UInt), a, 1)
+function push!(a::Array{Any,1}, @nospecialize item)
+    _growend!(a, 1)
     arrayset(a, item, length(a))
     return a
 end
@@ -602,7 +703,7 @@ end
 function append!(a::Array{<:Any,1}, items::AbstractVector)
     itemindices = eachindex(items)
     n = length(itemindices)
-    ccall(:jl_array_grow_end, Void, (Any, UInt), a, n)
+    _growend!(a, n)
     copy!(a, length(a)-n+1, items, first(itemindices), n)
     return a
 end
@@ -631,6 +732,7 @@ end
 
 Insert the elements of `items` to the beginning of `a`.
 
+# Examples
 ```jldoctest
 julia> prepend!([3],[1,2])
 3-element Array{Int64,1}:
@@ -644,7 +746,7 @@ function prepend! end
 function prepend!(a::Array{<:Any,1}, items::AbstractVector)
     itemindices = eachindex(items)
     n = length(itemindices)
-    ccall(:jl_array_grow_beg, Void, (Any, UInt), a, n)
+    _growbeg!(a, n)
     if a === items
         copy!(a, 1, items, n+1, n)
     else
@@ -658,7 +760,7 @@ unshift!(a::Vector, iter...) = prepend!(a, iter)
 
 function _prepend!(a, ::Union{HasLength,HasShape}, iter)
     n = length(iter)
-    ccall(:jl_array_grow_beg, Void, (Any, UInt), a, n)
+    _growbeg!(a, n)
     i = 0
     for item in iter
         @inbounds a[i += 1] = item
@@ -683,25 +785,27 @@ Resize `a` to contain `n` elements. If `n` is smaller than the current collectio
 length, the first `n` elements will be retained. If `n` is larger, the new elements are not
 guaranteed to be initialized.
 
+# Examples
 ```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}:
+julia> a = resize!([6, 5, 4, 3, 2, 1], 8);
+
+julia> length(a)
+8
+
+julia> a[1:6]
+6-element Array{Int64,1}:
  6
  5
  4
  3
  2
  1
- 0
- 0
 ```
 """
 function resize!(a::Vector, nl::Integer)
@@ -712,7 +816,7 @@ function resize!(a::Vector, nl::Integer)
         if nl < 0
             throw(ArgumentError("new length must be ≥ 0"))
         end
-        ccall(:jl_array_del_end, Void, (Any, UInt), a, l-nl)
+        _deleteend!(a, l-nl)
     end
     return a
 end
@@ -727,7 +831,7 @@ function pop!(a::Vector)
         throw(ArgumentError("array must be non-empty"))
     end
     item = a[end]
-    ccall(:jl_array_del_end, Void, (Any, UInt), a, 1)
+    _deleteend!(a, 1)
     return item
 end
 
@@ -736,6 +840,7 @@ end
 
 Insert one or more `items` at the beginning of `collection`.
 
+# Examples
 ```jldoctest
 julia> unshift!([1, 2, 3, 4], 5, 6)
 6-element Array{Int64,1}:
@@ -747,9 +852,9 @@ julia> unshift!([1, 2, 3, 4], 5, 6)
  4
 ```
 """
-function unshift!{T}(a::Array{T,1}, item)
+function unshift!(a::Array{T,1}, item) where T
     item = convert(T, item)
-    ccall(:jl_array_grow_beg, Void, (Any, UInt), a, 1)
+    _growbeg!(a, 1)
     a[1] = item
     return a
 end
@@ -759,7 +864,7 @@ function shift!(a::Vector)
         throw(ArgumentError("array must be non-empty"))
     end
     item = a[1]
-    ccall(:jl_array_del_beg, Void, (Any, UInt), a, 1)
+    _deletebeg!(a, 1)
     return item
 end
 
@@ -769,6 +874,7 @@ end
 Insert an `item` into `a` at the given `index`. `index` is the index of `item` in
 the resulting `a`.
 
+# Examples
 ```jldoctest
 julia> insert!([6, 5, 4, 2, 1], 4, 3)
 6-element Array{Int64,1}:
@@ -780,7 +886,7 @@ julia> insert!([6, 5, 4, 2, 1], 4, 3)
  1
 ```
 """
-function insert!{T}(a::Array{T,1}, i::Integer, item)
+function insert!(a::Array{T,1}, i::Integer, item) where T
     # Throw convert error before changing the shape of the array
     _item = convert(T, item)
     _growat!(a, i, 1)
@@ -795,6 +901,7 @@ end
 Remove the item at the given `i` and return the modified `a`. Subsequent items
 are shifted to fill the resulting gap.
 
+# Examples
 ```jldoctest
 julia> deleteat!([6, 5, 4, 3, 2, 1], 2)
 5-element Array{Int64,1}:
@@ -822,6 +929,7 @@ Subsequent items are shifted to fill the resulting gap.
 `inds` can be either an iterator or a collection of sorted and unique integer indices,
 or a boolean vector of the same length as `a` with `true` indicating entries to delete.
 
+# Examples
 ```jldoctest
 julia> deleteat!([6, 5, 4, 3, 2, 1], 1:2:5)
 3-element Array{Int64,1}:
@@ -838,8 +946,8 @@ julia> deleteat!([6, 5, 4, 3, 2, 1], [true, false, true, false, true, false])
 julia> deleteat!([6, 5, 4, 3, 2, 1], (2, 2))
 ERROR: ArgumentError: indices must be unique and sorted
 Stacktrace:
- [1] _deleteat!(::Array{Int64,1}, ::Tuple{Int64,Int64}) at ./array.jl:858
- [2] deleteat!(::Array{Int64,1}, ::Tuple{Int64,Int64}) at ./array.jl:845
+ [1] _deleteat!(::Array{Int64,1}, ::Tuple{Int64,Int64}) at ./array.jl:926
+ [2] deleteat!(::Array{Int64,1}, ::Tuple{Int64,Int64}) at ./array.jl:913
 ```
 """
 deleteat!(a::Vector, inds) = _deleteat!(a, inds)
@@ -870,7 +978,7 @@ function _deleteat!(a::Vector, inds)
         @inbounds a[p] = a[q]
         p += 1; q += 1
     end
-    ccall(:jl_array_del_end, Void, (Any, UInt), a, n-p+1)
+    _deleteend!(a, n-p+1)
     return a
 end
 
@@ -883,7 +991,7 @@ function deleteat!(a::Vector, inds::AbstractVector{Bool})
         @inbounds a[p] = a[q]
         p += !i
     end
-    ccall(:jl_array_del_end, Void, (Any, UInt), a, n-p+1)
+    _deleteend!(a, n-p+1)
     return a
 end
 
@@ -897,6 +1005,7 @@ Subsequent items are shifted left to fill the resulting gap.
 If specified, replacement values from an ordered
 collection will be spliced in place of the removed item.
 
+# Examples
 ```jldoctest splice!
 julia> A = [6, 5, 4, 3, 2, 1]; splice!(A, 5)
 2
@@ -967,6 +1076,7 @@ place of the removed items.
 To insert `replacement` before an index `n` without removing any items, use
 `splice!(collection, n:n-1, replacement)`.
 
+# Examples
 ```jldoctest splice!
 julia> splice!(A, 4:3, 2)
 0-element Array{Int64,1}
@@ -1012,7 +1122,7 @@ function splice!(a::Vector, r::UnitRange{<:Integer}, ins=_default_splice)
 end
 
 function empty!(a::Vector)
-    ccall(:jl_array_del_end, Void, (Any, UInt), a, length(a))
+    _deleteend!(a, length(a))
     return a
 end
 
@@ -1023,39 +1133,44 @@ function lexcmp(a::Array{UInt8,1}, b::Array{UInt8,1})
     return c < 0 ? -1 : c > 0 ? +1 : cmp(length(a),length(b))
 end
 
+const BitIntegerArray{N} = Union{map(T->Array{T,N}, BitInteger_types)...} where N
 # use memcmp for == on bit integer types
-function =={T<:BitInteger,N}(a::Array{T,N}, b::Array{T,N})
+function ==(a::Arr, b::Arr) where Arr <: BitIntegerArray
     size(a) == size(b) && 0 == ccall(
-        :memcmp, Int32, (Ptr{T}, Ptr{T}, UInt), a, b, sizeof(T) * length(a))
+        :memcmp, Int32, (Ptr{Void}, Ptr{Void}, UInt), a, b, sizeof(eltype(Arr)) * length(a))
 end
 
 # this is ~20% faster than the generic implementation above for very small arrays
-function =={T<:BitInteger}(a::Array{T,1}, b::Array{T,1})
+function ==(a::Arr, b::Arr) where Arr <: BitIntegerArray{1}
     len = length(a)
     len == length(b) && 0 == ccall(
-        :memcmp, Int32, (Ptr{T}, Ptr{T}, UInt), a, b, sizeof(T) * len)
+        :memcmp, Int32, (Ptr{Void}, Ptr{Void}, UInt), a, b, sizeof(eltype(Arr)) * len)
 end
 
-function reverse(A::AbstractVector, s=1, n=length(A))
+function reverse(A::AbstractVector, s=first(linearindices(A)), n=last(linearindices(A)))
     B = similar(A)
-    for i = 1:s-1
+    for i = first(linearindices(A)):s-1
         B[i] = A[i]
     end
     for i = s:n
         B[i] = A[n+s-i]
     end
-    for i = n+1:length(A)
+    for i = n+1:last(linearindices(A))
         B[i] = A[i]
     end
     return B
 end
-reverseind(a::AbstractVector, i::Integer) = length(a) + 1 - i
+function reverseind(a::AbstractVector, i::Integer)
+    li = linearindices(a)
+    first(li) + last(li) - i
+end
 
-function reverse!(v::AbstractVector, s=1, n=length(v))
+function reverse!(v::AbstractVector, s=first(linearindices(v)), n=last(linearindices(v)))
+    liv = linearindices(v)
     if n <= s  # empty case; ok
-    elseif !(1 ≤ s ≤ endof(v))
+    elseif !(first(liv) ≤ s ≤ last(liv))
         throw(BoundsError(v, s))
-    elseif !(1 ≤ n ≤ endof(v))
+    elseif !(first(liv) ≤ n ≤ last(liv))
         throw(BoundsError(v, n))
     end
     r = n
@@ -1072,7 +1187,7 @@ end
 vcat() = Array{Any,1}(0)
 hcat() = Array{Any,1}(0)
 
-function hcat{T}(V::Vector{T}...)
+function hcat(V::Vector{T}...) where T
     height = length(V[1])
     for j = 2:length(V)
         if length(V[j]) != height
@@ -1082,7 +1197,7 @@ function hcat{T}(V::Vector{T}...)
     return [ V[j][i]::T for i=1:length(V[1]), j=1:length(V) ]
 end
 
-function vcat{T}(arrays::Vector{T}...)
+function vcat(arrays::Vector{T}...) where T
     n = 0
     for a in arrays
         n += length(a)
@@ -1119,6 +1234,7 @@ cat(n::Integer, x::Integer...) = reshape([x...], (ntuple(x->1, n-1)..., length(x
 
 Find the next linear index >= `i` of a non-zero element of `A`, or `0` if not found.
 
+# Examples
 ```jldoctest
 julia> A = [0 0; 1 0]
 2×2 Array{Int64,2}:
@@ -1147,6 +1263,7 @@ end
 Return the linear index of the first non-zero value in `A` (determined by `A[i]!=0`).
 Returns `0` if no such value is found.
 
+# Examples
 ```jldoctest
 julia> A = [0 0; 1 0]
 2×2 Array{Int64,2}:
@@ -1155,6 +1272,9 @@ julia> A = [0 0; 1 0]
 
 julia> findfirst(A)
 2
+
+julia> findfirst(zeros(3))
+0
 ```
 """
 findfirst(A) = findnext(A, 1)
@@ -1164,6 +1284,7 @@ findfirst(A) = findnext(A, 1)
 
 Find the next linear index >= `i` of an element of `A` equal to `v` (using `==`), or `0` if not found.
 
+# Examples
 ```jldoctest
 julia> A = [1 4; 2 2]
 2×2 Array{Int64,2}:
@@ -1191,6 +1312,7 @@ end
 Return the linear index of the first element equal to `v` in `A`.
 Returns `0` if `v` is not found.
 
+# Examples
 ```jldoctest
 julia> A = [4 6; 2 2]
 2×2 Array{Int64,2}:
@@ -1211,6 +1333,7 @@ findfirst(A, v) = findnext(A, v, 1)
 
 Find the next linear index >= `i` of an element of `A` for which `predicate` returns `true`, or `0` if not found.
 
+# Examples
 ```jldoctest
 julia> A = [1 4; 2 2]
 2×2 Array{Int64,2}:
@@ -1239,6 +1362,7 @@ end
 Return the linear index of the first element of `A` for which `predicate` returns `true`.
 Returns `0` if there is no such element.
 
+# Examples
 ```jldoctest
 julia> A = [1 4; 2 2]
 2×2 Array{Int64,2}:
@@ -1259,6 +1383,7 @@ findfirst(testf::Function, A) = findnext(testf, A, 1)
 
 Find the previous linear index <= `i` of a non-zero element of `A`, or `0` if not found.
 
+# Examples
 ```jldoctest
 julia> A = [0 0; 1 2]
 2×2 Array{Int64,2}:
@@ -1285,6 +1410,7 @@ end
 Return the linear index of the last non-zero value in `A` (determined by `A[i]!=0`).
 Returns `0` if there is no non-zero value in `A`.
 
+# Examples
 ```jldoctest
 julia> A = [1 0; 1 0]
 2×2 Array{Int64,2}:
@@ -1310,6 +1436,7 @@ findlast(A) = findprev(A, length(A))
 
 Find the previous linear index <= `i` of an element of `A` equal to `v` (using `==`), or `0` if not found.
 
+# Examples
 ```jldoctest
 julia> A = [0 0; 1 2]
 2×2 Array{Int64,2}:
@@ -1336,6 +1463,7 @@ end
 Return the linear index of the last element equal to `v` in `A`.
 Returns `0` if there is no element of `A` equal to `v`.
 
+# Examples
 ```jldoctest
 julia> A = [1 2; 2 1]
 2×2 Array{Int64,2}:
@@ -1360,6 +1488,7 @@ findlast(A, v) = findprev(A, v, length(A))
 Find the previous linear index <= `i` of an element of `A` for which `predicate` returns `true`, or
 `0` if not found.
 
+# Examples
 ```jldoctest
 julia> A = [4 6; 1 2]
 2×2 Array{Int64,2}:
@@ -1386,6 +1515,7 @@ end
 Return the linear index of the last element of `A` for which `predicate` returns `true`.
 Returns `0` if there is no such element.
 
+# Examples
 ```jldoctest
 julia> A = [1 2; 3 4]
 2×2 Array{Int64,2}:
@@ -1407,6 +1537,7 @@ findlast(testf::Function, A) = findprev(testf, A, length(A))
 Return a vector `I` of the linear indexes of `A` where `f(A[I])` returns `true`.
 If there are no such elements of `A`, find returns an empty array.
 
+# Examples
 ```jldoctest
 julia> A = [1 2; 3 4]
 2×2 Array{Int64,2}:
@@ -1417,6 +1548,9 @@ julia> find(isodd,A)
 2-element Array{Int64,1}:
  1
  2
+
+julia> find(isodd, [2, 4])
+0-element Array{Int64,1}
 ```
 """
 function find(testf::Function, A)
@@ -1443,6 +1577,7 @@ Return a vector of the linear indexes of the non-zeros in `A` (determined by `A[
 common use of this is to convert a boolean array to an array of indexes of the `true`
 elements. If there are no non-zero elements of `A`, `find` returns an empty array.
 
+# Examples
 ```jldoctest
 julia> A = [true false; false true]
 2×2 Array{Bool,2}:
@@ -1453,6 +1588,9 @@ julia> find(A)
 2-element Array{Int64,1}:
  1
  4
+
+julia> find(zeros(3))
+0-element Array{Int64,1}
 ```
 """
 function find(A)
@@ -1481,6 +1619,7 @@ Return a vector of indexes for each dimension giving the locations of the non-ze
 (determined by `A[i]!=0`).
 If there are no non-zero elements of `A`, `findn` returns a 2-tuple of empty arrays.
 
+# Examples
 ```jldoctest
 julia> A = [1 2 0; 0 0 3; 0 4 0]
 3×3 Array{Int64,2}:
@@ -1521,6 +1660,7 @@ end
 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.
 
+# Examples
 ```jldoctest
 julia> A = [1 2 0; 0 0 3; 0 4 0]
 3×3 Array{Int64,2}:
@@ -1532,7 +1672,7 @@ julia> findnz(A)
 ([1, 1, 3, 2], [1, 2, 2, 3], [1, 2, 4, 3])
 ```
 """
-function findnz{T}(A::AbstractMatrix{T})
+function findnz(A::AbstractMatrix{T}) where T
     nnzA = countnz(A)
     I = zeros(Int, nnzA)
     J = zeros(Int, nnzA)
@@ -1561,6 +1701,7 @@ all elements are `NaN`.
 
 The collection must not be empty.
 
+# Examples
 ```jldoctest
 julia> findmax([8,0.1,-9,pi])
 (8.0, 1)
@@ -1599,6 +1740,7 @@ all elements are `NaN`.
 
 The collection must not be empty.
 
+# Examples
 ```jldoctest
 julia> findmin([8,0.1,-9,pi])
 (-9.0, 3)
@@ -1637,6 +1779,7 @@ elements are `NaN`.
 
 The collection must not be empty.
 
+# Examples
 ```jldoctest
 julia> indmax([8,0.1,-9,pi])
 1
@@ -1659,6 +1802,7 @@ elements are `NaN`.
 
 The collection must not be empty.
 
+# Examples
 ```jldoctest
 julia> indmin([8,0.1,-9,pi])
 3
@@ -1680,6 +1824,7 @@ 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`.
 
+# Examples
 ```jldoctest
 julia> a = ['a', 'b', 'c', 'b', 'd', 'a'];
 
@@ -1706,11 +1851,63 @@ function indexin(a::AbstractArray, b::AbstractArray)
     [get(bdict, i, 0) for i in a]
 end
 
+function _findin(a, b)
+    ind  = Int[]
+    bset = Set(b)
+    @inbounds for (i,ai) in enumerate(a)
+        ai in bset && push!(ind, i)
+    end
+    ind
+end
+
+# If two collections are already sorted, findin can be computed with
+# a single traversal of the two collections. This is much faster than
+# using a hash table (although it has the same complexity).
+function _sortedfindin(v, w)
+    viter, witer = eachindex(v), eachindex(w)
+    out  = eltype(viter)[]
+    i, j = start(viter), start(witer)
+    if done(viter, i) || done(witer, j)
+        return out
+    end
+    viteri, i = next(viter, i)
+    witerj, j = next(witer, j)
+    @inbounds begin
+        vi, wj = v[viteri], w[witerj]
+        while true
+            if isless(vi, wj)
+                if done(viter, i)
+                    break
+                end
+                viteri, i = next(viter, i)
+                vi        = v[viteri]
+            elseif isless(wj, vi)
+                if done(witer, j)
+                    break
+                end
+                witerj, j = next(witer, j)
+                wj        = w[witerj]
+            else
+                push!(out, viteri)
+                if done(viter, i)
+                    break
+                end
+                # We only increment the v iterator because v can have
+                # repeated matches to a single value in w
+                viteri, i = next(viter, i)
+                vi        = v[viteri]
+            end
+        end
+    end
+    return out
+end
+
 """
     findin(a, b)
 
 Returns the indices of elements in collection `a` that appear in collection `b`.
 
+# Examples
 ```jldoctest
 julia> a = collect(1:3:15)
 5-element Array{Int64,1}:
@@ -1731,14 +1928,16 @@ julia> findin(a,b) # 10 is the only common element
  4
 ```
 """
-function findin(a, b)
-    ind = Array{Int,1}(0)
-    bset = Set(b)
-    @inbounds for (i,ai) in enumerate(a)
-        ai in bset && push!(ind, i)
+function findin(a::Array{<:Real}, b::Union{Array{<:Real},Real})
+    if issorted(a, Sort.Forward) && issorted(b, Sort.Forward)
+        return _sortedfindin(a, b)
+    else
+        return _findin(a, b)
     end
-    ind
 end
+# issorted fails for some element types so the method above has to be restricted
+# to element with isless/< defined.
+findin(a, b) = _findin(a, b)
 
 # Copying subregions
 # TODO: DEPRECATE FOR #14770
@@ -1767,12 +1966,13 @@ end
 ## Filter ##
 
 """
-    filter(function, collection)
+    filter(f, a::AbstractArray)
 
-Return a copy of `collection`, removing elements for which `function` is `false`. For
-associative collections, the function is passed two arguments (key and value).
+Return a copy of `a`, removing elements for which `f` is `false`.
+The function `f` is passed one argument.
 
-```jldocttest
+# Examples
+```jldoctest
 julia> a = 1:10
 1:10
 
@@ -1787,20 +1987,44 @@ julia> filter(isodd, a)
 """
 filter(f, As::AbstractArray) = As[map(f, As)::AbstractArray{Bool}]
 
-function filter!(f, a::Vector)
-    insrt = 1
+"""
+    filter!(f, a::AbstractVector)
+
+Update `a`, removing elements for which `f` is `false`.
+The function `f` is passed one argument.
+
+# Examples
+```jldoctest
+julia> filter!(isodd, collect(1:10))
+5-element Array{Int64,1}:
+ 1
+ 3
+ 5
+ 7
+ 9
+```
+"""
+function filter!(f, a::AbstractVector)
+    isempty(a) && return a
+
+    idx = eachindex(a)
+    state = start(idx)
+    i, state = next(idx, state)
+
     for acurr in a
         if f(acurr)
-            a[insrt] = acurr
-            insrt += 1
+            a[i] = acurr
+            i, state = next(idx, state)
         end
     end
-    deleteat!(a, insrt:length(a))
+
+    deleteat!(a, i:last(idx))
+
     return a
 end
 
 function filter(f, a::Vector)
-    r = Array{eltype(a)}(0)
+    r = Vector{eltype(a)}(0)
     for ai in a
         if f(ai)
             push!(r, ai)
@@ -1813,7 +2037,7 @@ end
 # These are moderately efficient, preserve order, and remove dupes.
 
 function intersect(v1, vs...)
-    ret = Array{promote_eltype(v1, vs...)}(0)
+    ret = Vector{promote_eltype(v1, vs...)}(0)
     for v_elem in v1
         inall = true
         for vsi in vs
@@ -1829,7 +2053,7 @@ function intersect(v1, vs...)
 end
 
 function union(vs...)
-    ret = Array{promote_eltype(vs...)}(0)
+    ret = Vector{promote_eltype(vs...)}(0)
     seen = Set()
     for v in vs
         for v_elem in v
@@ -1851,6 +2075,7 @@ both arguments must be collections, and both will be iterated over. In particula
 `setdiff(set,element)` where `element` is a potential member of `set`, will not work in
 general.
 
+# Examples
 ```jldoctest
 julia> setdiff([1,2,3],[3,4,5])
 2-element Array{Int64,1}:
@@ -1884,6 +2109,7 @@ symdiff(a, b) = union(setdiff(a,b), setdiff(b,a))
 Construct the symmetric difference of elements in the passed in sets or arrays.
 Maintains order with arrays.
 
+# Examples
 ```jldoctest
 julia> symdiff([1,2,3],[3,4,5],[4,5,6])
 3-element Array{Int64,1}:
diff --git a/base/arraymath.jl b/base/arraymath.jl
index 762a582b537918..e71cd63faa89e0 100644
--- a/base/arraymath.jl
+++ b/base/arraymath.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## Unary operators ##
 
@@ -9,6 +9,7 @@ Transform an array to its complex conjugate in-place.
 
 See also [`conj`](@ref).
 
+# Examples
 ```jldoctest
 julia> A = [1+im 2-im; 2+2im 3+im]
 2×2 Array{Complex{Int64},2}:
@@ -50,7 +51,7 @@ end
 
 ## data movement ##
 
-function flipdim{T}(A::Array{T}, d::Integer)
+function flipdim(A::Array{T}, d::Integer) where T
     nd = ndims(A)
     1 ≤ d ≤ nd || throw(ArgumentError("dimension $d is not 1 ≤ $d ≤ $nd"))
     sd = size(A, d)
@@ -116,6 +117,7 @@ end
 
 Rotate matrix `A` left 90 degrees.
 
+# Examples
 ```jldoctest
 julia> a = [1 2; 3 4]
 2×2 Array{Int64,2}:
@@ -143,6 +145,7 @@ end
 
 Rotate matrix `A` right 90 degrees.
 
+# Examples
 ```jldoctest
 julia> a = [1 2; 3 4]
 2×2 Array{Int64,2}:
@@ -169,6 +172,7 @@ end
 
 Rotate matrix `A` 180 degrees.
 
+# Examples
 ```jldoctest
 julia> a = [1 2; 3 4]
 2×2 Array{Int64,2}:
@@ -196,6 +200,7 @@ end
 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`.
 
+# Examples
 ```jldoctest
 julia> a = [1 2; 3 4]
 2×2 Array{Int64,2}:
@@ -235,6 +240,7 @@ end
 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`.
 
+# Examples
 ```jldoctest
 julia> a = [1 2; 3 4]
 2×2 Array{Int64,2}:
@@ -269,6 +275,7 @@ rotr90(A::AbstractMatrix, k::Integer) = rotl90(A,-k)
 Rotate matrix `A` 180 degrees an integer `k` number of times.
 If `k` is even, this is equivalent to a `copy`.
 
+# Examples
 ```jldoctest
 julia> a = [1 2; 3 4]
 2×2 Array{Int64,2}:
diff --git a/base/associative.jl b/base/associative.jl
index 0c27814c6b4612..1d4f48bda6aa53 100644
--- a/base/associative.jl
+++ b/base/associative.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # generic operations on associative collections
 
@@ -32,17 +32,17 @@ struct ValueIterator{T<:Associative}
     dict::T
 end
 
-summary{T<:Union{KeyIterator,ValueIterator}}(iter::T) =
+summary(iter::T) where {T<:Union{KeyIterator,ValueIterator}} =
     string(T.name, " for a ", summary(iter.dict))
 
 show(io::IO, iter::Union{KeyIterator,ValueIterator}) = show(io, collect(iter))
 
 length(v::Union{KeyIterator,ValueIterator}) = length(v.dict)
 isempty(v::Union{KeyIterator,ValueIterator}) = isempty(v.dict)
-_tt1{A,B}(::Type{Pair{A,B}}) = A
-_tt2{A,B}(::Type{Pair{A,B}}) = B
-eltype{D}(::Type{KeyIterator{D}}) = _tt1(eltype(D))
-eltype{D}(::Type{ValueIterator{D}}) = _tt2(eltype(D))
+_tt1(::Type{Pair{A,B}}) where {A,B} = A
+_tt2(::Type{Pair{A,B}}) where {A,B} = B
+eltype(::Type{KeyIterator{D}}) where {D} = _tt1(eltype(D))
+eltype(::Type{ValueIterator{D}}) where {D} = _tt2(eltype(D))
 
 start(v::Union{KeyIterator,ValueIterator}) = start(v.dict)
 done(v::Union{KeyIterator,ValueIterator}, state) = done(v.dict, state)
@@ -70,6 +70,7 @@ the order in which they are returned may vary.
 But `keys(a)` and `values(a)` both iterate `a` and
 return the elements in the same order.
 
+# Examples
 ```jldoctest
 julia> a = Dict('a'=>2, 'b'=>3)
 Dict{Char,Int64} with 2 entries:
@@ -95,6 +96,7 @@ the order in which they are returned may vary.
 But `keys(a)` and `values(a)` both iterate `a` and
 return the elements in the same order.
 
+# Examples
 ```jldoctest
 julia> a = Dict('a'=>2, 'b'=>3)
 Dict{Char,Int64} with 2 entries:
@@ -123,6 +125,7 @@ end
 Update collection with pairs from the other collections.
 See also [`merge`](@ref).
 
+# Examples
 ```jldoctest
 julia> d1 = Dict(1 => 2, 3 => 4);
 
@@ -146,6 +149,45 @@ function merge!(d::Associative, others::Associative...)
     return d
 end
 
+"""
+    merge!(combine, d::Associative, others::Associative...)
+
+Update collection with pairs from the other collections.
+Values with the same key will be combined using the
+combiner function.
+
+# Examples
+```jldoctest
+julia> d1 = Dict(1 => 2, 3 => 4);
+
+julia> d2 = Dict(1 => 4, 4 => 5);
+
+julia> merge!(+, d1, d2);
+
+julia> d1
+Dict{Int64,Int64} with 3 entries:
+  4 => 5
+  3 => 4
+  1 => 6
+
+julia> merge!(-, d1, d1);
+
+julia> d1
+Dict{Int64,Int64} with 3 entries:
+  4 => 0
+  3 => 0
+  1 => 0
+```
+"""
+function merge!(combine::Function, d::Associative, others::Associative...)
+    for other in others
+        for (k,v) in other
+            d[k] = haskey(d, k) ? combine(d[k], v) : v
+        end
+    end
+    return d
+end
+
 # very similar to `merge!`, but accepts any iterable and extends code
 # that would otherwise only use `copy!` with arrays.
 function copy!(dest::Union{Associative,AbstractSet}, src)
@@ -160,27 +202,29 @@ end
 
 Get the key type of an associative collection type. Behaves similarly to [`eltype`](@ref).
 
+# Examples
 ```jldoctest
 julia> keytype(Dict(Int32(1) => "foo"))
 Int32
 ```
 """
-keytype{K,V}(::Type{Associative{K,V}}) = K
+keytype(::Type{Associative{K,V}}) where {K,V} = K
 keytype(a::Associative) = keytype(typeof(a))
-keytype{A<:Associative}(::Type{A}) = keytype(supertype(A))
+keytype(::Type{A}) where {A<:Associative} = keytype(supertype(A))
 
 """
     valtype(type)
 
 Get the value type of an associative collection type. Behaves similarly to [`eltype`](@ref).
 
+# Examples
 ```jldoctest
 julia> valtype(Dict(Int32(1) => "foo"))
 String
 ```
 """
-valtype{K,V}(::Type{Associative{K,V}}) = V
-valtype{A<:Associative}(::Type{A}) = valtype(supertype(A))
+valtype(::Type{Associative{K,V}}) where {K,V} = V
+valtype(::Type{A}) where {A<:Associative} = valtype(supertype(A))
 valtype(a::Associative) = valtype(typeof(a))
 
 """
@@ -191,6 +235,7 @@ 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.
 
+# Examples
 ```jldoctest
 julia> a = Dict("foo" => 0.0, "bar" => 42.0)
 Dict{String,Float64} with 2 entries:
@@ -215,17 +260,71 @@ Dict{String,Float64} with 3 entries:
   "foo" => 0.0
 ```
 """
-function merge(d::Associative, others::Associative...)
-    K, V = keytype(d), valtype(d)
-    for other in others
-        K = promote_type(K, keytype(other))
-        V = promote_type(V, valtype(other))
-    end
-    merge!(Dict{K,V}(), d, others...)
+merge(d::Associative, others::Associative...) =
+    merge!(emptymergedict(d, others...), d, others...)
+
+"""
+    merge(combine, d::Associative, others::Associative...)
+
+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. Values with the same key will be combined using the
+combiner function.
+
+# Examples
+```jldoctest
+julia> a = Dict("foo" => 0.0, "bar" => 42.0)
+Dict{String,Float64} with 2 entries:
+  "bar" => 42.0
+  "foo" => 0.0
+
+julia> b = Dict("baz" => 17, "bar" => 4711)
+Dict{String,Int64} with 2 entries:
+  "bar" => 4711
+  "baz" => 17
+
+julia> merge(+, a, b)
+Dict{String,Float64} with 3 entries:
+  "bar" => 4753.0
+  "baz" => 17.0
+  "foo" => 0.0
+```
+"""
+merge(combine::Function, d::Associative, others::Associative...) =
+    merge!(combine, emptymergedict(d, others...), d, others...)
+
+promoteK(K) = K
+promoteV(V) = V
+promoteK(K, d, ds...) = promoteK(promote_type(K, keytype(d)), ds...)
+promoteV(V, d, ds...) = promoteV(promote_type(V, valtype(d)), ds...)
+function emptymergedict(d::Associative, others::Associative...)
+    K = promoteK(keytype(d), others...)
+    V = promoteV(valtype(d), others...)
+    Dict{K,V}()
 end
 
+"""
+    filter!(f, d::Associative)
+
+Update `d`, removing elements for which `f` is `false`.
+The function `f` is passed two arguments (key and value).
+
+# Example
+```jldoctest
+julia> d = Dict(1=>"a", 2=>"b", 3=>"c")
+Dict{Int64,String} with 3 entries:
+  2 => "b"
+  3 => "c"
+  1 => "a"
+
+julia> filter!((x,y)->isodd(x), d)
+Dict{Int64,String} with 2 entries:
+  3 => "c"
+  1 => "a"
+```
+"""
 function filter!(f, d::Associative)
-    badkeys = Array{keytype(d)}(0)
+    badkeys = Vector{keytype(d)}(0)
     for (k,v) in d
         # don't delete!(d, k) here, since associative types
         # may not support mutation during iteration
@@ -236,6 +335,25 @@ function filter!(f, d::Associative)
     end
     return d
 end
+
+"""
+    filter(f, d::Associative)
+
+Return a copy of `d`, removing elements for which `f` is `false`.
+The function `f` is passed two arguments (key and value).
+
+# Examples
+```jldoctest
+julia> d = Dict(1=>"a", 2=>"b")
+Dict{Int64,String} with 2 entries:
+  2 => "b"
+  1 => "a"
+
+julia> filter((x,y)->isodd(x), d)
+Dict{Int64,String} with 1 entry:
+  1 => "a"
+```
+"""
 function filter(f, d::Associative)
     # don't just do filter!(f, copy(d)): avoid making a whole copy of d
     df = similar(d)
@@ -247,7 +365,7 @@ function filter(f, d::Associative)
     return df
 end
 
-eltype{K,V}(::Type{Associative{K,V}}) = Pair{K,V}
+eltype(::Type{Associative{K,V}}) where {K,V} = Pair{K,V}
 
 function isequal(l::Associative, r::Associative)
     l === r && return true
@@ -341,7 +459,17 @@ function rehash!(t::ObjectIdDict, newsz = length(t.ht))
     t
 end
 
-function setindex!(t::ObjectIdDict, v::ANY, k::ANY)
+function sizehint!(t::ObjectIdDict, newsz)
+    newsz = _tablesz(newsz*2)  # *2 for keys and values in same array
+    oldsz = length(t.ht)
+    # grow at least 25%
+    if newsz < (oldsz*5)>>2
+        return t
+    end
+    rehash!(t, newsz)
+end
+
+function setindex!(t::ObjectIdDict, @nospecialize(v), @nospecialize(k))
     if t.ndel >= ((3*length(t.ht))>>2)
         rehash!(t, max(length(t.ht)>>1, 32))
         t.ndel = 0
@@ -350,27 +478,32 @@ function setindex!(t::ObjectIdDict, v::ANY, k::ANY)
     return t
 end
 
-get(t::ObjectIdDict, key::ANY, default::ANY) =
+get(t::ObjectIdDict, @nospecialize(key), @nospecialize(default)) =
     ccall(:jl_eqtable_get, Any, (Any, Any, Any), t.ht, key, default)
 
-function pop!(t::ObjectIdDict, key::ANY, default::ANY)
+function pop!(t::ObjectIdDict, @nospecialize(key), @nospecialize(default))
     val = ccall(:jl_eqtable_pop, Any, (Any, Any, Any), t.ht, key, default)
     # TODO: this can underestimate `ndel`
     val === default || (t.ndel += 1)
     return val
 end
 
-function pop!(t::ObjectIdDict, key::ANY)
+function pop!(t::ObjectIdDict, @nospecialize(key))
     val = pop!(t, key, secret_table_token)
     val !== secret_table_token ? val : throw(KeyError(key))
 end
 
-function delete!(t::ObjectIdDict, key::ANY)
+function delete!(t::ObjectIdDict, @nospecialize(key))
     pop!(t, key, secret_table_token)
     t
 end
 
-empty!(t::ObjectIdDict) = (t.ht = Vector{Any}(length(t.ht)); t.ndel = 0; t)
+function empty!(t::ObjectIdDict)
+    resize!(t.ht, 32)
+    ccall(:memset, Ptr{Void}, (Ptr{Void}, Cint, Csize_t), t.ht, 0, sizeof(t.ht))
+    t.ndel = 0
+    return t
+end
 
 _oidd_nextind(a, i) = reinterpret(Int,ccall(:jl_eqtable_nextind, Csize_t, (Any, Csize_t), a, i))
 
diff --git a/base/asyncmap.jl b/base/asyncmap.jl
index f8a789a653fae7..19846ab7a0cede 100644
--- a/base/asyncmap.jl
+++ b/base/asyncmap.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base.Iterators.Enumerate
 
@@ -206,7 +206,7 @@ function setup_chnl_and_tasks(exec_func, ntasks, batch_size=nothing)
     chnl = Channel(0)
     worker_tasks = []
     foreach(_ -> start_worker_task!(worker_tasks, exec_func, chnl, batch_size), 1:nt)
-
+    yield()
     return (chnl, worker_tasks)
 end
 
diff --git a/base/atomics.jl b/base/atomics.jl
index 743bb0501e3d3e..38f8a0e2431782 100644
--- a/base/atomics.jl
+++ b/base/atomics.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Core.Intrinsics: llvmcall
 
@@ -17,7 +17,7 @@ export
 # Disable 128-bit types on 32-bit Intel sytems due to LLVM problems;
 # see <https://github.com/JuliaLang/julia/issues/14818> (fixed on LLVM 3.9)
 # 128-bit atomics do not exist on AArch32.
-if (VersionNumber(Base.libllvm_version) < v"3.9-" && ARCH === :i686) ||
+if (Base.libllvm_version < v"3.9-" && ARCH === :i686) ||
         startswith(string(ARCH), "arm")
     const inttypes = (Int8, Int16, Int32, Int64,
                       UInt8, UInt16, UInt32, UInt64)
@@ -47,6 +47,7 @@ specified, the atomic object is initialized with zero.
 
 Atomic objects can be accessed using the `[]` notation:
 
+# Examples
 ```jldoctest
 julia> x = Threads.Atomic{Int}(3)
 Base.Threads.Atomic{Int64}(3)
@@ -63,14 +64,14 @@ Atomic operations use an `atomic_` prefix, such as `atomic_add!`,
 """
 mutable struct Atomic{T<:AtomicTypes}
     value::T
-    Atomic{T}() where T<:AtomicTypes = new(zero(T))
-    Atomic{T}(value) where T<:AtomicTypes = new(value)
+    Atomic{T}() where {T<:AtomicTypes} = new(zero(T))
+    Atomic{T}(value) where {T<:AtomicTypes} = new(value)
 end
 
 Atomic() = Atomic{Int}()
 
 """
-    Threads.atomic_cas!{T}(x::Atomic{T}, cmp::T, newval::T)
+    Threads.atomic_cas!(x::Atomic{T}, cmp::T, newval::T) where T
 
 Atomically compare-and-set `x`
 
@@ -86,6 +87,7 @@ the transaction, one records the value in `x`. After the transaction,
 the new value is stored only if `x` has not been modified in the mean
 time.
 
+# Examples
 ```jldoctest
 julia> x = Threads.Atomic{Int}(3)
 Base.Threads.Atomic{Int64}(3)
@@ -104,7 +106,7 @@ Base.Threads.Atomic{Int64}(2)
 function atomic_cas! end
 
 """
-    Threads.atomic_xchg!{T}(x::Atomic{T}, newval::T)
+    Threads.atomic_xchg!(x::Atomic{T}, newval::T) where T
 
 Atomically exchange the value in `x`
 
@@ -113,6 +115,7 @@ value.
 
 For further details, see LLVM's `atomicrmw xchg` instruction.
 
+# Examples
 ```jldoctest
 julia> x = Threads.Atomic{Int}(3)
 Base.Threads.Atomic{Int64}(3)
@@ -127,7 +130,7 @@ julia> x[]
 function atomic_xchg! end
 
 """
-    Threads.atomic_add!{T}(x::Atomic{T}, val::T)
+    Threads.atomic_add!(x::Atomic{T}, val::T) where T
 
 Atomically add `val` to `x`
 
@@ -135,6 +138,7 @@ Performs `x[] += val` atomically. Returns the **old** value.
 
 For further details, see LLVM's `atomicrmw add` instruction.
 
+# Examples
 ```jldoctest
 julia> x = Threads.Atomic{Int}(3)
 Base.Threads.Atomic{Int64}(3)
@@ -149,7 +153,7 @@ julia> x[]
 function atomic_add! end
 
 """
-    Threads.atomic_sub!{T}(x::Atomic{T}, val::T)
+    Threads.atomic_sub!(x::Atomic{T}, val::T) where T
 
 Atomically subtract `val` from `x`
 
@@ -157,6 +161,7 @@ Performs `x[] -= val` atomically. Returns the **old** value.
 
 For further details, see LLVM's `atomicrmw sub` instruction.
 
+# Examples
 ```jldoctest
 julia> x = Threads.Atomic{Int}(3)
 Base.Threads.Atomic{Int64}(3)
@@ -171,7 +176,7 @@ julia> x[]
 function atomic_sub! end
 
 """
-    Threads.atomic_and!{T}(x::Atomic{T}, val::T)
+    Threads.atomic_and!(x::Atomic{T}, val::T) where T
 
 Atomically bitwise-and `x` with `val`
 
@@ -179,6 +184,7 @@ Performs `x[] &= val` atomically. Returns the **old** value.
 
 For further details, see LLVM's `atomicrmw and` instruction.
 
+# Examples
 ```jldoctest
 julia> x = Threads.Atomic{Int}(3)
 Base.Threads.Atomic{Int64}(3)
@@ -193,7 +199,7 @@ julia> x[]
 function atomic_and! end
 
 """
-    Threads.atomic_nand!{T}(x::Atomic{T}, val::T)
+    Threads.atomic_nand!(x::Atomic{T}, val::T) where T
 
 Atomically bitwise-nand (not-and) `x` with `val`
 
@@ -201,6 +207,7 @@ Performs `x[] = ~(x[] & val)` atomically. Returns the **old** value.
 
 For further details, see LLVM's `atomicrmw nand` instruction.
 
+# Examples
 ```jldoctest
 julia> x = Threads.Atomic{Int}(3)
 Base.Threads.Atomic{Int64}(3)
@@ -215,7 +222,7 @@ julia> x[]
 function atomic_nand! end
 
 """
-    Threads.atomic_or!{T}(x::Atomic{T}, val::T)
+    Threads.atomic_or!(x::Atomic{T}, val::T) where T
 
 Atomically bitwise-or `x` with `val`
 
@@ -223,6 +230,7 @@ Performs `x[] |= val` atomically. Returns the **old** value.
 
 For further details, see LLVM's `atomicrmw or` instruction.
 
+# Examples
 ```jldoctest
 julia> x = Threads.Atomic{Int}(5)
 Base.Threads.Atomic{Int64}(5)
@@ -237,7 +245,7 @@ julia> x[]
 function atomic_or! end
 
 """
-    Threads.atomic_xor!{T}(x::Atomic{T}, val::T)
+    Threads.atomic_xor!(x::Atomic{T}, val::T) where T
 
 Atomically bitwise-xor (exclusive-or) `x` with `val`
 
@@ -245,6 +253,7 @@ Performs `x[] \$= val` atomically. Returns the **old** value.
 
 For further details, see LLVM's `atomicrmw xor` instruction.
 
+# Examples
 ```jldoctest
 julia> x = Threads.Atomic{Int}(5)
 Base.Threads.Atomic{Int64}(5)
@@ -259,7 +268,7 @@ julia> x[]
 function atomic_xor! end
 
 """
-    Threads.atomic_max!{T}(x::Atomic{T}, val::T)
+    Threads.atomic_max!(x::Atomic{T}, val::T) where T
 
 Atomically store the maximum of `x` and `val` in `x`
 
@@ -267,6 +276,7 @@ Performs `x[] = max(x[], val)` atomically. Returns the **old** value.
 
 For further details, see LLVM's `atomicrmw max` instruction.
 
+# Examples
 ```jldoctest
 julia> x = Threads.Atomic{Int}(5)
 Base.Threads.Atomic{Int64}(5)
@@ -281,7 +291,7 @@ julia> x[]
 function atomic_max! end
 
 """
-    Threads.atomic_min!{T}(x::Atomic{T}, val::T)
+    Threads.atomic_min!(x::Atomic{T}, val::T) where T
 
 Atomically store the minimum of `x` and `val` in `x`
 
@@ -289,6 +299,7 @@ Performs `x[] = min(x[], val)` atomically. Returns the **old** value.
 
 For further details, see LLVM's `atomicrmw min` instruction.
 
+# Examples
 ```jldoctest
 julia> x = Threads.Atomic{Int}(7)
 Base.Threads.Atomic{Int64}(7)
@@ -302,8 +313,8 @@ julia> x[]
 """
 function atomic_min! end
 
-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))
+unsafe_convert(::Type{Ptr{T}}, x::Atomic{T}) where {T} = convert(Ptr{T}, pointer_from_objref(x))
+setindex!(x::Atomic{T}, v) where {T} = setindex!(x, convert(T, v))
 
 const llvmtypes = Dict(
     Bool => "i1",
@@ -316,13 +327,13 @@ const llvmtypes = Dict(
     Float32 => "float",
     Float64 => "double",
 )
-inttype{T<:Integer}(::Type{T}) = T
+inttype(::Type{T}) where {T<:Integer} = T
 inttype(::Type{Float16}) = Int16
 inttype(::Type{Float32}) = Int32
 inttype(::Type{Float64}) = Int64
 
 
-alignment{T}(::Type{T}) = ccall(:jl_alignment, Cint, (Csize_t,), sizeof(T))
+alignment(::Type{T}) where {T} = ccall(:jl_alignment, Cint, (Csize_t,), sizeof(T))
 
 # 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
@@ -330,92 +341,42 @@ alignment{T}(::Type{T}) = ccall(:jl_alignment, Cint, (Csize_t,), sizeof(T))
 for typ in atomictypes
     lt = llvmtypes[typ]
     ilt = llvmtypes[inttype(typ)]
-    rt = VersionNumber(Base.libllvm_version) >= v"3.6" ? "$lt, $lt*" : "$lt*"
-    irt = VersionNumber(Base.libllvm_version) >= v"3.6" ? "$ilt, $ilt*" : "$ilt*"
-    if VersionNumber(Base.libllvm_version) >= v"3.8"
-        @eval getindex(x::Atomic{$typ}) =
+    rt = Base.libllvm_version >= v"3.6" ? "$lt, $lt*" : "$lt*"
+    irt = Base.libllvm_version >= v"3.6" ? "$ilt, $ilt*" : "$ilt*"
+    @eval getindex(x::Atomic{$typ}) =
+        llvmcall($"""
+                 %rv = load atomic $rt %0 acquire, align $(alignment(typ))
+                 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 $(alignment(typ))
+                 ret void
+                 """, Void, Tuple{Ptr{$typ},$typ}, unsafe_convert(Ptr{$typ}, x), v)
+
+    # Note: atomic_cas! succeeded (i.e. it stored "new") if and only if the result is "cmp"
+    if typ <: Integer
+        @eval atomic_cas!(x::Atomic{$typ}, cmp::$typ, new::$typ) =
             llvmcall($"""
-                     %rv = load atomic $rt %0 acquire, align $(alignment(typ))
+                     %rs = cmpxchg $lt* %0, $lt %1, $lt %2 acq_rel acquire
+                     %rv = extractvalue { $lt, i1 } %rs, 0
                      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 $(alignment(typ))
-                     ret void
-                     """, Void, Tuple{Ptr{$typ},$typ}, unsafe_convert(Ptr{$typ}, x), v)
-    else
-        if typ <: Integer
-            @eval getindex(x::Atomic{$typ}) =
-                llvmcall($"""
-                         %rv = load atomic $rt %0 acquire, align $(alignment(typ))
-                         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 $(alignment(typ))
-                         ret void
-                         """, Void, Tuple{Ptr{$typ},$typ}, unsafe_convert(Ptr{$typ}, x), v)
-        else
-            @eval getindex(x::Atomic{$typ}) =
-                llvmcall($"""
-                         %iptr = bitcast $lt* %0 to $ilt*
-                         %irv = load atomic $irt %iptr acquire, align $(alignment(typ))
-                         %rv = bitcast $ilt %irv to $lt
-                         ret $lt %rv
-                         """, $typ, Tuple{Ptr{$typ}}, unsafe_convert(Ptr{$typ}, x))
-            @eval setindex!(x::Atomic{$typ}, v::$typ) =
-                llvmcall($"""
-                         %iptr = bitcast $lt* %0 to $ilt*
-                         %ival = bitcast $lt %1 to $ilt
-                         store atomic $ilt %ival, $ilt* %iptr release, align $(alignment(typ))
-                         ret void
-                         """, Void, Tuple{Ptr{$typ},$typ}, unsafe_convert(Ptr{$typ}, x), v)
-        end
-    end
-    # Note: atomic_cas! succeeded (i.e. it stored "new") if and only if the result is "cmp"
-    if VersionNumber(Base.libllvm_version) >= v"3.5"
-        if typ <: Integer
-            @eval atomic_cas!(x::Atomic{$typ}, cmp::$typ, new::$typ) =
-                llvmcall($"""
-                         %rs = cmpxchg $lt* %0, $lt %1, $lt %2 acq_rel acquire
-                         %rv = extractvalue { $lt, i1 } %rs, 0
-                         ret $lt %rv
-                         """, $typ, Tuple{Ptr{$typ},$typ,$typ},
-                         unsafe_convert(Ptr{$typ}, x), cmp, new)
-        else
-            @eval atomic_cas!(x::Atomic{$typ}, cmp::$typ, new::$typ) =
-                llvmcall($"""
-                         %iptr = bitcast $lt* %0 to $ilt*
-                         %icmp = bitcast $lt %1 to $ilt
-                         %inew = bitcast $lt %2 to $ilt
-                         %irs = cmpxchg $ilt* %iptr, $ilt %icmp, $ilt %inew acq_rel acquire
-                         %irv = extractvalue { $ilt, i1 } %irs, 0
-                         %rv = bitcast $ilt %irv to $lt
-                         ret $lt %rv
-                         """, $typ, Tuple{Ptr{$typ},$typ,$typ},
-                         unsafe_convert(Ptr{$typ}, x), cmp, new)
-        end
+                     """, $typ, Tuple{Ptr{$typ},$typ,$typ},
+                     unsafe_convert(Ptr{$typ}, x), cmp, new)
     else
-        if typ <: Integer
-            @eval atomic_cas!(x::Atomic{$typ}, cmp::$typ, new::$typ) =
-                llvmcall($"""
-                         %rv = cmpxchg $lt* %0, $lt %1, $lt %2 acq_rel
-                         ret $lt %rv
-                         """, $typ, Tuple{Ptr{$typ},$typ,$typ},
-                         unsafe_convert(Ptr{$typ}, x), cmp, new)
-        else
-            @eval atomic_cas!(x::Atomic{$typ}, cmp::$typ, new::$typ) =
-                llvmcall($"""
-                         %iptr = bitcast $lt* %0 to $ilt*
-                         %icmp = bitcast $lt %1 to $ilt
-                         %inew = bitcast $lt %2 to $ilt
-                         %irv = cmpxchg $ilt* %iptr, $ilt %icmp, $ilt %inew acq_rel
-                         %rv = bitcast $ilt %irv to $lt
-                         ret $lt %rv
-                         """, $typ, Tuple{Ptr{$typ},$typ,$typ},
-                         unsafe_convert(Ptr{$typ}, x), cmp, new)
-        end
+        @eval atomic_cas!(x::Atomic{$typ}, cmp::$typ, new::$typ) =
+            llvmcall($"""
+                     %iptr = bitcast $lt* %0 to $ilt*
+                     %icmp = bitcast $lt %1 to $ilt
+                     %inew = bitcast $lt %2 to $ilt
+                     %irs = cmpxchg $ilt* %iptr, $ilt %icmp, $ilt %inew acq_rel acquire
+                     %irv = extractvalue { $ilt, i1 } %irs, 0
+                     %rv = bitcast $ilt %irv to $lt
+                     ret $lt %rv
+                     """, $typ, 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, "!")
@@ -447,7 +408,7 @@ end
 const opnames = Dict{Symbol, Symbol}(:+ => :add, :- => :sub)
 for op in [:+, :-, :max, :min]
     opname = get(opnames, op, op)
-    @eval function $(Symbol("atomic_", opname, "!")){T<:FloatTypes}(var::Atomic{T}, val::T)
+    @eval function $(Symbol("atomic_", opname, "!"))(var::Atomic{T}, val::T) where T<:FloatTypes
         IT = inttype(T)
         old = var[]
         while true
diff --git a/base/base.jl b/base/base.jl
index 652b9106a18c16..11307307374765 100644
--- a/base/base.jl
+++ b/base/base.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 """
     SystemError(prefix::AbstractString, [errno::Int32])
@@ -54,9 +54,9 @@ mutable struct MethodError <: Exception
     f
     args
     world::UInt
-    MethodError(f::ANY, args::ANY, world::UInt) = new(f, args, world)
+    MethodError(@nospecialize(f), @nospecialize(args), world::UInt) = new(f, args, world)
 end
-MethodError(f::ANY, args::ANY) = MethodError(f, args, typemax(UInt))
+MethodError(@nospecialize(f), @nospecialize(args)) = MethodError(f, args, typemax(UInt))
 
 """
     EOFError()
@@ -122,14 +122,14 @@ 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::ANY)
+function finalizer(@nospecialize(o), @nospecialize(f))
     if isimmutable(o)
         error("objects of type ", typeof(o), " cannot be finalized")
     end
     ccall(:jl_gc_add_finalizer_th, Void, (Ptr{Void}, Any, Any),
           Core.getptls(), o, f)
 end
-function finalizer{T}(o::T, f::Ptr{Void})
+function finalizer(o::T, f::Ptr{Void}) where T
     @_inline_meta
     if isimmutable(T)
         error("objects of type ", T, " cannot be finalized")
@@ -138,8 +138,8 @@ function finalizer{T}(o::T, f::Ptr{Void})
           Core.getptls(), o, f)
 end
 
-finalize(o::ANY) = ccall(:jl_finalize_th, Void, (Ptr{Void}, Any,),
-                         Core.getptls(), o)
+finalize(@nospecialize(o)) = ccall(:jl_finalize_th, Void, (Ptr{Void}, Any,),
+                                   Core.getptls(), o)
 
 gc(full::Bool=true) = ccall(:jl_gc_collect, Void, (Int32,), full)
 gc_enable(on::Bool) = ccall(:jl_gc_enable, Int32, (Int32,), on) != 0
diff --git a/base/base64.jl b/base/base64.jl
index 743f055ca9f114..b06c2fbd7a9391 100644
--- a/base/base64.jl
+++ b/base/base64.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module Base64
 import Base: read, write, close, eof, empty!
@@ -22,6 +22,7 @@ base64-encoded ASCII bytes written to `ostream`.
 Calling [`close`](@ref) on the `Base64EncodePipe` stream
 is necessary to complete the encoding (but does not close `ostream`).
 
+# Examples
 ```jldoctest
 julia> io = IOBuffer();
 
@@ -207,6 +208,7 @@ base64encode(x...) = base64encode(write, x...)
 
 Returns a new read-only I/O stream, which decodes base64-encoded data read from `istream`.
 
+# Examples
 ```jldoctest
 julia> io = IOBuffer();
 
@@ -261,6 +263,7 @@ Decodes the base64-encoded `string` and returns a `Vector{UInt8}` of the decoded
 
 See also [`base64encode`](@ref)
 
+# Examples
 ```jldoctest
 julia> b = base64decode("SGVsbG8h")
 6-element Array{UInt8,1}:
diff --git a/base/bitarray.jl b/base/bitarray.jl
index 5f24ae708c43fd..7d69bcd7e3a636 100644
--- a/base/bitarray.jl
+++ b/base/bitarray.jl
@@ -1,9 +1,14 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## BitArray
 
 # notes: bits are stored in contiguous chunks
 #        unused bits must always be set to 0
+"""
+    BitArray{N} <: DenseArray{Bool, N}
+
+Space-efficient `N`-dimensional boolean array, which stores one bit per boolean value.
+"""
 mutable struct BitArray{N} <: DenseArray{Bool, N}
     chunks::Vector{UInt64}
     len::Int
@@ -17,7 +22,7 @@ mutable struct BitArray{N} <: DenseArray{Bool, N}
             i += 1
         end
         nc = num_bit_chunks(n)
-        chunks = Array{UInt64}(nc)
+        chunks = Vector{UInt64}(nc)
         nc > 0 && (chunks[end] = UInt64(0))
         b = new(chunks, n)
         N != 1 && (b.dims = dims)
@@ -32,10 +37,11 @@ end
     BitArray(dims::Integer...)
     BitArray{N}(dims::NTuple{N,Int})
 
-Construct an uninitialized `BitArray` with the given dimensions.
+Construct an uninitialized [`BitArray`](@ref) with the given dimensions.
 Behaves identically to the [`Array`](@ref) constructor.
 
-```julia
+# Examples
+```julia-repl
 julia> BitArray(2, 2)
 2×2 BitArray{2}:
  false  false
@@ -80,7 +86,7 @@ const _msk64 = ~UInt64(0)
 @inline _msk_end(B::BitArray) = _msk_end(length(B))
 num_bit_chunks(n::Int) = _div64(n+63)
 
-function _check_bitarray_consistency{N}(B::BitArray{N})
+function _check_bitarray_consistency(B::BitArray{N}) where N
     n = length(B)
     if N ≠ 1
         all(d ≥ 0 for d in B.dims) || (warn("negative d in dims: $(B.dims)"); return false)
@@ -238,7 +244,7 @@ function fill_chunks!(Bc::Array{UInt64}, x::Bool, pos::Integer, numbits::Integer
     end
 end
 
-copy_to_bitarray_chunks!(dest::Vector{UInt64}, pos_d::Integer, src::BitArray, pos_s::Integer, numbits::Integer) =
+copy_to_bitarray_chunks!(dest::Vector{UInt64}, pos_d::Int, src::BitArray, pos_s::Int, numbits::Int) =
     copy_chunks!(dest, pos_d, src.chunks, pos_s, numbits)
 
 # pack 8 Bools encoded as one contiguous UIn64 into a single byte, e.g.:
@@ -283,11 +289,12 @@ function copy_to_bitarray_chunks!(Bc::Vector{UInt64}, pos_d::Int, C::Array{Bool}
     nc8 = (nc >>> 3) << 3
     if nc8 > 0
         ind8 = 1
-        C8 = reinterpret(UInt64, unsafe_wrap(Array, pointer(C, ind), nc8 << 6))
+        P8 = Ptr{UInt64}(pointer(C, ind)) # unaligned i64 pointer
         @inbounds for i = 1:nc8
             c = UInt64(0)
             for j = 0:7
-                c |= (pack8bools(C8[ind8]) << (j<<3))
+                # unaligned load
+                c |= (pack8bools(unsafe_load(P8, ind8)) << (j<<3))
                 ind8 += 1
             end
             Bc[bind] = c
@@ -315,79 +322,7 @@ function copy_to_bitarray_chunks!(Bc::Vector{UInt64}, pos_d::Int, C::Array{Bool}
     end
 end
 
-function copy_to_bitarray_chunks!(Bc::Vector{UInt64}, pos_d::Int, C::Array, pos_s::Int, numbits::Int)
-    bind = pos_d
-    cind = pos_s
-    lastind = pos_d + numbits - 1
-    @inbounds while bind ≤ lastind
-        unsafe_bitsetindex!(Bc, Bool(C[cind]), bind)
-        bind += 1
-        cind += 1
-    end
-end
-
-# Note: the next two functions rely on the following definition of the conversion to Bool:
-#   convert(::Type{Bool}, x::Real) = x==0 ? false : x==1 ? true : throw(InexactError())
-# they're used to pre-emptively check in bulk when possible, which is much faster.
-# Also, the functions can be overloaded for custom types T<:Real :
-#  a) in the unlikely eventuality that they use a different logic for Bool conversion
-#  b) to skip the check if not necessary
-@inline try_bool_conversion(x::Real) = x == 0 || x == 1 || throw(InexactError())
-@inline unchecked_bool_convert(x::Real) = x == 1
-
-function copy_to_bitarray_chunks!(Bc::Vector{UInt64}, pos_d::Int, C::Array{<:Real}, pos_s::Int, numbits::Int)
-    @inbounds for i = (1:numbits) + pos_s - 1
-        try_bool_conversion(C[i])
-    end
-
-    kd0, ld0 = get_chunks_id(pos_d)
-    kd1, ld1 = get_chunks_id(pos_d + numbits - 1)
-
-    delta_kd = kd1 - kd0
-
-    u = _msk64
-    if delta_kd == 0
-        msk_d0 = msk_d1 = ~(u << ld0) | (u << (ld1+1))
-        lt0 = ld1
-    else
-        msk_d0 = ~(u << ld0)
-        msk_d1 = (u << (ld1+1))
-        lt0 = 63
-    end
-
-    bind = kd0
-    ind = pos_s
-    @inbounds if ld0 > 0
-        c = UInt64(0)
-        for j = ld0:lt0
-            c |= (UInt64(unchecked_bool_convert(C[ind])) << j)
-            ind += 1
-        end
-        Bc[kd0] = (Bc[kd0] & msk_d0) | (c & ~msk_d0)
-        bind += 1
-    end
-
-    nc = _div64(numbits - ind + pos_s)
-    @inbounds for i = 1:nc
-        c = UInt64(0)
-        for j = 0:63
-            c |= (UInt64(unchecked_bool_convert(C[ind])) << j)
-            ind += 1
-        end
-        Bc[bind] = c
-        bind += 1
-    end
-
-    @inbounds if bind ≤ kd1
-        @assert bind == kd1
-        c = UInt64(0)
-        for j = 0:ld1
-            c |= (UInt64(unchecked_bool_convert(C[ind])) << j)
-            ind += 1
-        end
-        Bc[kd1] = (Bc[kd1] & msk_d1) | (c & ~msk_d1)
-    end
-end
+## More definitions in multidimensional.jl
 
 # auxiliary definitions used when filling a BitArray via a Vector{Bool} cache
 # (e.g. when constructing from an iterable, or in broadcast!)
@@ -433,6 +368,7 @@ end
 
 Create a `BitArray` with all values set to `false`.
 
+# Examples
 ```jldoctest
 julia> falses(2,3)
 2×3 BitArray{2}:
@@ -447,6 +383,7 @@ falses(dims::Integer...) = falses(map(Int,dims))
 
 Create a `BitArray` with all values set to `false` of the same shape as `A`.
 
+# Examples
 ```jldoctest
 julia> A = [1 2; 3 4]
 2×2 Array{Int64,2}:
@@ -466,6 +403,7 @@ falses(A::AbstractArray) = falses(size(A))
 
 Create a `BitArray` with all values set to `true`.
 
+# Examples
 ```jldoctest
 julia> trues(2,3)
 2×3 BitArray{2}:
@@ -480,6 +418,7 @@ trues(dims::Integer...) = trues(map(Int,dims))
 
 Create a `BitArray` with all values set to `true` of the same shape as `A`.
 
+# Examples
 ```jldoctest
 julia> A = [1 2; 3 4]
 2×2 Array{Int64,2}:
@@ -544,11 +483,14 @@ function copy!(dest::BitArray, src::Array)
     return unsafe_copy!(dest, 1, src, 1, length(src))
 end
 
-function reshape{N}(B::BitArray, dims::NTuple{N,Int})
+function reshape(B::BitArray{N}, dims::NTuple{N,Int}) where N
+    return dims == size(B) ? B : _bitreshape(B, dims)
+end
+reshape(B::BitArray, dims::Tuple{Vararg{Int}}) = _bitreshape(B, dims)
+function _bitreshape(B::BitArray, dims::NTuple{N,Int}) where N
     prod(dims) == length(B) ||
         throw(DimensionMismatch("new dimensions $(dims) must be consistent with array size $(length(B))"))
-    dims == size(B) && return B
-    Br = BitArray{N}(ntuple(i->0,N)...)
+    Br = BitArray{N}(ntuple(i->0,Val(N))...)
     Br.chunks = B.chunks
     Br.len = prod(dims)
     N != 1 && (Br.dims = dims)
@@ -557,9 +499,9 @@ end
 
 ## Conversions ##
 
-convert{T,N}(::Type{Array{T}}, B::BitArray{N}) = convert(Array{T,N}, B)
-convert{T,N}(::Type{Array{T,N}}, B::BitArray{N}) = _convert(Array{T,N}, B) # see #15801
-function _convert{T,N}(::Type{Array{T,N}}, B::BitArray{N})
+convert(::Type{Array{T}}, B::BitArray{N}) where {T,N} = convert(Array{T,N}, B)
+convert(::Type{Array{T,N}}, B::BitArray{N}) where {T,N} = _convert(Array{T,N}, B) # see #15801
+function _convert(::Type{Array{T,N}}, B::BitArray{N}) where {T,N}
     A = Array{T}(size(B))
     Bc = B.chunks
     @inbounds for i = 1:length(A)
@@ -568,8 +510,8 @@ function _convert{T,N}(::Type{Array{T,N}}, B::BitArray{N})
     return A
 end
 
-convert{T,N}(::Type{BitArray}, A::AbstractArray{T,N}) = convert(BitArray{N}, A)
-function convert{T,N}(::Type{BitArray{N}}, A::AbstractArray{T,N})
+convert(::Type{BitArray}, A::AbstractArray{T,N}) where {T,N} = convert(BitArray{N}, A)
+function convert(::Type{BitArray{N}}, A::AbstractArray{T,N}) where N where T
     B = BitArray(size(A))
     Bc = B.chunks
     l = length(B)
@@ -594,7 +536,7 @@ function convert{T,N}(::Type{BitArray{N}}, A::AbstractArray{T,N})
     return B
 end
 
-function convert{N}(::Type{BitArray{N}}, A::Array{Bool,N})
+function convert(::Type{BitArray{N}}, A::Array{Bool,N}) where N
     B = BitArray(size(A))
     Bc = B.chunks
     l = length(B)
@@ -603,22 +545,23 @@ function convert{N}(::Type{BitArray{N}}, A::Array{Bool,N})
     return B
 end
 
-convert{N}(::Type{BitArray{N}}, B::BitArray{N}) = B
-convert{T,N}(::Type{AbstractArray{T,N}}, B::BitArray{N}) = convert(Array{T,N}, B)
+convert(::Type{BitArray{N}}, B::BitArray{N}) where {N} = B
+convert(::Type{AbstractArray{T,N}}, B::BitArray{N}) where {T,N} = convert(Array{T,N}, B)
 
-reinterpret{N}(::Type{Bool}, B::BitArray, dims::NTuple{N,Int}) = reinterpret(B, dims)
-reinterpret{N}(B::BitArray, dims::NTuple{N,Int}) = reshape(B, dims)
+reinterpret(::Type{Bool}, B::BitArray, dims::NTuple{N,Int}) where {N} = reinterpret(B, dims)
+reinterpret(B::BitArray, dims::NTuple{N,Int}) where {N} = reshape(B, dims)
 
 ## Constructors from generic iterables ##
 
-BitArray{T,N}(A::AbstractArray{T,N}) = convert(BitArray{N}, A)
+BitArray(A::AbstractArray{<:Any,N}) where {N} = convert(BitArray{N}, A)
 
 """
     BitArray(itr)
 
-Construct a `BitArray` generated by the given iterable object. The shape is inferred from
-the `itr` object.
+Construct a [`BitArray`](@ref) generated by the given iterable object.
+The shape is inferred from the `itr` object.
 
+# Examples
 ```jldoctest
 julia> BitArray([1 0; 0 1])
 2×2 BitArray{2}:
@@ -1213,6 +1156,7 @@ end
 
 Performs a bitwise not operation on `B`. See [`~`](@ref).
 
+# Examples
 ```jldoctest
 julia> A = trues(2,2)
 2×2 BitArray{2}:
@@ -1257,7 +1201,7 @@ end
 
 for f in (:/, :\)
     @eval begin
-        ($f)(A::BitArray, B::BitArray) = ($f)(Array(A), Array(B))
+        ($f)(A::Union{BitMatrix,BitVector}, B::Union{BitMatrix,BitVector}) = ($f)(Array(A), Array(B))
     end
 end
 (/)(B::BitArray, x::Number) = (/)(Array(B), x)
@@ -1447,10 +1391,87 @@ function (>>>)(B::BitVector, i::UInt)
     return A
 end
 
+"""
+    >>(B::BitVector, n) -> BitVector
+
+Right bit shift operator, `B >> n`. For `n >= 0`, the result is `B`
+with elements shifted `n` positions forward, filling with `false`
+values. If `n < 0`, elements are shifted backwards. Equivalent to
+`B << -n`.
+
+# Examples
+```jldoctest
+julia> B = BitVector([true, false, true, false, false])
+5-element BitArray{1}:
+  true
+ false
+  true
+ false
+ false
+
+julia> B >> 1
+5-element BitArray{1}:
+ false
+  true
+ false
+  true
+ false
+
+julia> B >> -1
+5-element BitArray{1}:
+ false
+  true
+ false
+ false
+ false
+```
+"""
 (>>)(B::BitVector, i::Union{Int, UInt}) = B >>> i
 
 # signed integer version of shift operators with handling of negative values
+"""
+    <<(B::BitVector, n) -> BitVector
+
+Left bit shift operator, `B << n`. For `n >= 0`, the result is `B`
+with elements shifted `n` positions backwards, filling with `false`
+values. If `n < 0`, elements are shifted forwards. Equivalent to
+`B >> -n`.
+
+# Examples
+```jldoctest
+julia> B = BitVector([true, false, true, false, false])
+5-element BitArray{1}:
+  true
+ false
+  true
+ false
+ false
+
+julia> B << 1
+5-element BitArray{1}:
+ false
+  true
+ false
+ false
+ false
+
+julia> B << -1
+5-element BitArray{1}:
+ false
+  true
+ false
+  true
+ false
+```
+"""
 (<<)(B::BitVector, i::Int) = (i >=0 ? B << unsigned(i) : B >> unsigned(-i))
+
+"""
+    >>>(B::BitVector, n) -> BitVector
+
+Unsigned right bitshift operator, `B >>> n`. Equivalent to `B >> n`. See [`>>`](@ref) for
+details and examples.
+"""
 (>>>)(B::BitVector, i::Int) = (i >=0 ? B >> unsigned(i) : B << unsigned(-i))
 
 """
@@ -1486,6 +1507,7 @@ Performs a left rotation operation, returning a new `BitVector`.
 `i` controls how far to rotate the bits.
 See also [`rol!`](@ref).
 
+# Examples
 ```jldoctest
 julia> A = BitArray([true, true, false, false, true])
 5-element BitArray{1}:
@@ -1555,6 +1577,7 @@ Performs a right rotation operation on `B`, returning a new `BitVector`.
 `i` controls how far to rotate the bits.
 See also [`ror!`](@ref).
 
+# Examples
 ```jldoctest
 julia> A = BitArray([true, true, false, false, true])
 5-element BitArray{1}:
@@ -1756,7 +1779,7 @@ end
 function find(B::BitArray)
     l = length(B)
     nnzB = countnz(B)
-    I = Array{Int}(nnzB)
+    I = Vector{Int}(nnzB)
     nnzB == 0 && return I
     Bc = B.chunks
     Bcount = 1
@@ -1790,8 +1813,8 @@ findn(B::BitVector) = find(B)
 
 function findn(B::BitMatrix)
     nnzB = countnz(B)
-    I = Array{Int}(nnzB)
-    J = Array{Int}(nnzB)
+    I = Vector{Int}(nnzB)
+    J = Vector{Int}(nnzB)
     count = 1
     for j = 1:size(B,2), i = 1:size(B,1)
         if B[i,j]
@@ -1870,7 +1893,7 @@ end
 # If we were able to specialize the function to a known bitwise operation,
 # map across the chunks. Otherwise, fall-back to the AbstractArray method that
 # iterates bit-by-bit.
-function bit_map!{F}(f::F, dest::BitArray, A::BitArray)
+function bit_map!(f::F, dest::BitArray, A::BitArray) where F
     size(A) == size(dest) || throw(DimensionMismatch("sizes of dest and A must match"))
     isempty(A) && return dest
     destc = dest.chunks
@@ -1881,7 +1904,7 @@ function bit_map!{F}(f::F, dest::BitArray, A::BitArray)
     destc[end] = f(Ac[end]) & _msk_end(A)
     dest
 end
-function bit_map!{F}(f::F, dest::BitArray, A::BitArray, B::BitArray)
+function bit_map!(f::F, dest::BitArray, A::BitArray, B::BitArray) where F
     size(A) == size(B) == size(dest) || throw(DimensionMismatch("sizes of dest, A, and B must all match"))
     isempty(A) && return dest
     destc = dest.chunks
diff --git a/base/bool.jl b/base/bool.jl
index a874de0ca6becd..2e78c2f824fcb1 100644
--- a/base/bool.jl
+++ b/base/bool.jl
@@ -1,13 +1,13 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## boolean conversions ##
 
 convert(::Type{Bool}, x::Bool) = x
-convert(::Type{Bool}, x::Float16) = x==0 ? false : x==1 ? true : throw(InexactError())
-convert(::Type{Bool}, x::Real) = x==0 ? false : x==1 ? true : throw(InexactError())
+convert(::Type{Bool}, x::Float16) = x==0 ? false : x==1 ? true : throw(InexactError(:convert, Bool, x))
+convert(::Type{Bool}, x::Real) = x==0 ? false : x==1 ? true : throw(InexactError(:convert, Bool, x))
 
 # promote Bool to any other numeric type
-promote_rule{T<:Number}(::Type{Bool}, ::Type{T}) = T
+promote_rule(::Type{Bool}, ::Type{T}) where {T<:Number} = T
 
 typemin(::Type{Bool}) = false
 typemax(::Type{Bool}) = true
@@ -19,6 +19,7 @@ typemax(::Type{Bool}) = true
 
 Boolean not.
 
+# Examples
 ```jldoctest
 julia> !true
 false
@@ -50,6 +51,7 @@ Bitwise exclusive or of `x` and `y`.  The infix operation
 `⊻` can be typed by tab-completing `\\xor`
 or `\\veebar` in the Julia REPL.
 
+# Examples
 ```jldoctest
 julia> [true; true; false] .⊻ [true; false; false]
 3-element BitArray{1}:
@@ -77,6 +79,7 @@ sign(x::Bool) = x
 abs(x::Bool) = x
 abs2(x::Bool) = x
 iszero(x::Bool) = !x
+isone(x::Bool) = x
 
 <(x::Bool, y::Bool) = y&!x
 <=(x::Bool, y::Bool) = y|!x
@@ -92,15 +95,15 @@ iszero(x::Bool) = !x
 ^(x::Bool, y::Bool) = x | !y
 ^(x::Integer, y::Bool) = ifelse(y, x, one(x))
 
-function +{T<:AbstractFloat}(x::Bool, y::T)::promote_type(Bool,T)
+function +(x::Bool, y::T)::promote_type(Bool,T) where T<:AbstractFloat
     return ifelse(x, oneunit(y) + y, y)
 end
 +(y::AbstractFloat, x::Bool) = x + y
 
-function *{T<:Number}(x::Bool, y::T)::promote_type(Bool,T)
+function *(x::Bool, y::T)::promote_type(Bool,T) where T<:Number
     return ifelse(x, y, copysign(zero(y), y))
 end
-function *{T<:Unsigned}(x::Bool, y::T)::promote_type(Bool,T)
+function *(x::Bool, y::T)::promote_type(Bool,T) where T<:Unsigned
     return ifelse(x, y, zero(y))
 end
 *(y::Number, x::Bool) = x * y
diff --git a/base/boot.jl b/base/boot.jl
index 1933e511210c55..fd714d4c9addf7 100644
--- a/base/boot.jl
+++ b/base/boot.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # commented-out definitions are implemented in C
 
@@ -87,6 +87,7 @@
 
 #struct LineNumberNode
 #    line::Int
+#    file::Any # nominally Union{Symbol,Void}
 #end
 
 #struct LabelNode
@@ -131,9 +132,10 @@ export
     # string types
     Char, DirectIndexString, AbstractString, String, IO,
     # errors
-    ErrorException, BoundsError, DivideError, DomainError, Exception, InexactError,
-    InterruptException, OutOfMemoryError, ReadOnlyMemoryError, OverflowError,
-    StackOverflowError, SegmentationFault, UndefRefError, UndefVarError, TypeError,
+    ErrorException, BoundsError, DivideError, DomainError, Exception,
+    InterruptException, InexactError, OutOfMemoryError, ReadOnlyMemoryError,
+    OverflowError, StackOverflowError, SegmentationFault, UndefRefError, UndefVarError,
+    TypeError,
     # AST representation
     Expr, GotoNode, LabelNode, LineNumberNode, QuoteNode,
     GlobalRef, NewvarNode, SSAValue, Slot, SlotNumber, TypedSlot,
@@ -141,7 +143,7 @@ export
     fieldtype, getfield, setfield!, nfields, throw, tuple, ===, isdefined, eval,
     # sizeof    # not exported, to avoid conflicting with Base.sizeof
     # type reflection
-    issubtype, typeof, isa, typeassert,
+    <:, typeof, isa, typeassert,
     # method reflection
     applicable, invoke,
     # constants
@@ -160,16 +162,16 @@ primitive type Float16 <: AbstractFloat 16 end
 primitive type Float32 <: AbstractFloat 32 end
 primitive type Float64 <: AbstractFloat 64 end
 
-primitive type Bool <: Integer 8 end
+#primitive type Bool <: Integer 8 end
 primitive type Char 32 end
 
 primitive type Int8    <: Signed   8 end
-primitive type UInt8   <: Unsigned 8 end
+#primitive type UInt8   <: Unsigned 8 end
 primitive type Int16   <: Signed   16 end
 primitive type UInt16  <: Unsigned 16 end
-primitive type Int32   <: Signed   32 end
+#primitive type Int32   <: Signed   32 end
 primitive type UInt32  <: Unsigned 32 end
-primitive type Int64   <: Signed   64 end
+#primitive type Int64   <: Signed   64 end
 primitive type UInt64  <: Unsigned 64 end
 primitive type Int128  <: Signed   128 end
 primitive type UInt128 <: Unsigned 128 end
@@ -181,7 +183,16 @@ else
 end
 
 function Typeof end
-(f::typeof(Typeof))(x::ANY) = isa(x,Type) ? Type{x} : typeof(x)
+ccall(:jl_toplevel_eval_in, Any, (Any, Any),
+      Core, quote
+      (f::typeof(Typeof))(x) = ($(_expr(:meta,:nospecialize,:x)); isa(x,Type) ? Type{x} : typeof(x))
+      end)
+
+macro nospecialize(x)
+    _expr(:meta, :nospecialize, x)
+end
+
+Expr(@nospecialize args...) = _expr(args...)
 
 abstract type Exception end
 mutable struct ErrorException <: Exception
@@ -189,8 +200,6 @@ mutable struct ErrorException <: Exception
     ErrorException(msg::AbstractString) = new(msg)
 end
 
-Expr(args::ANY...) = _expr(args...)
-
 macro _noinline_meta()
     Expr(:meta, :noinline)
 end
@@ -199,13 +208,11 @@ struct BoundsError        <: Exception
     a::Any
     i::Any
     BoundsError() = new()
-    BoundsError(a::ANY) = (@_noinline_meta; new(a))
-    BoundsError(a::ANY, i) = (@_noinline_meta; new(a,i))
+    BoundsError(@nospecialize(a)) = (@_noinline_meta; new(a))
+    BoundsError(@nospecialize(a), i) = (@_noinline_meta; new(a,i))
 end
 struct DivideError        <: Exception end
-struct DomainError        <: Exception end
 struct OverflowError      <: Exception end
-struct InexactError       <: Exception end
 struct OutOfMemoryError   <: Exception end
 struct ReadOnlyMemoryError<: Exception end
 struct SegmentationFault  <: Exception end
@@ -215,12 +222,25 @@ struct UndefVarError      <: Exception
     var::Symbol
 end
 struct InterruptException <: Exception end
+struct DomainError <: Exception
+    val
+    msg
+    DomainError(@nospecialize(val)) = (@_noinline_meta; new(val))
+    DomainError(@nospecialize(val), @nospecialize(msg)) = (@_noinline_meta; new(val, msg))
+end
 mutable struct TypeError <: Exception
     func::Symbol
     context::AbstractString
     expected::Type
     got
 end
+struct InexactError <: Exception
+    func::Symbol
+    T::Type
+    val
+
+    InexactError(f::Symbol, @nospecialize(T), @nospecialize(val)) = (@_noinline_meta; new(f, T, val))
+end
 
 abstract type DirectIndexString <: AbstractString end
 
@@ -229,18 +249,18 @@ String(s::String) = s  # no constructor yet
 # This should always be inlined
 getptls() = ccall(:jl_get_ptls_states, Ptr{Void}, ())
 
-include(fname::String) = ccall(:jl_load_, Any, (Any,), fname)
+include(m::Module, fname::String) = ccall(:jl_load_, Any, (Any, Any), m, fname)
 
-eval(e::ANY) = eval(Main, e)
-eval(m::Module, e::ANY) = ccall(:jl_toplevel_eval_in, Any, (Any, Any), m, e)
+eval(@nospecialize(e)) = eval(Main, e)
+eval(m::Module, @nospecialize(e)) = ccall(:jl_toplevel_eval_in, Any, (Any, Any), m, e)
 
-kwfunc(f::ANY) = ccall(:jl_get_keyword_sorter, Any, (Any,), f)
+kwfunc(@nospecialize(f)) = ccall(:jl_get_keyword_sorter, Any, (Any,), f)
 
-kwftype(t::ANY) = typeof(ccall(:jl_get_kwsorter, Any, (Any,), t.name))
+kwftype(@nospecialize(t)) = typeof(ccall(:jl_get_kwsorter, Any, (Any,), t))
 
 mutable struct Box
     contents::Any
-    Box(x::ANY) = new(x)
+    Box(@nospecialize(x)) = new(x)
     Box() = new()
 end
 
@@ -249,22 +269,22 @@ end
 mutable struct WeakRef
     value
     WeakRef() = WeakRef(nothing)
-    WeakRef(v::ANY) = ccall(:jl_gc_new_weakref_th, Ref{WeakRef},
-                            (Ptr{Void}, Any), getptls(), v)
+    WeakRef(@nospecialize(v)) = ccall(:jl_gc_new_weakref_th, Ref{WeakRef},
+                                      (Ptr{Void}, Any), getptls(), v)
 end
 
 TypeVar(n::Symbol) =
     ccall(:jl_new_typevar, Ref{TypeVar}, (Any, Any, Any), n, Union{}, Any)
-TypeVar(n::Symbol, ub::ANY) =
+TypeVar(n::Symbol, @nospecialize(ub)) =
     ccall(:jl_new_typevar, Ref{TypeVar}, (Any, Any, Any), n, Union{}, ub)
-TypeVar(n::Symbol, lb::ANY, ub::ANY) =
+TypeVar(n::Symbol, @nospecialize(lb), @nospecialize(ub)) =
     ccall(:jl_new_typevar, Ref{TypeVar}, (Any, Any, Any), n, lb, ub)
 
-UnionAll(v::TypeVar, t::ANY) = ccall(:jl_type_unionall, Any, (Any, Any), v, t)
+UnionAll(v::TypeVar, @nospecialize(t)) = ccall(:jl_type_unionall, Any, (Any, Any), v, t)
 
 Void() = nothing
 
-(::Type{Tuple{}})() = ()
+(::Type{Tuple{}})() = () # Tuple{}()
 
 struct VecElement{T}
     value::T
@@ -275,52 +295,52 @@ VecElement(arg::T) where {T} = VecElement{T}(arg)
 # used by lowering of splicing unquote
 splicedexpr(hd::Symbol, args::Array{Any,1}) = (e=Expr(hd); e.args=args; e)
 
-_new(typ::Symbol, argty::Symbol) = eval(:((::Type{$typ})(n::$argty) = $(Expr(:new, typ, :n))))
+_new(typ::Symbol, argty::Symbol) = eval(Core, :((::Type{$typ})(@nospecialize n::$argty) = $(Expr(:new, typ, :n))))
 _new(:LabelNode, :Int)
 _new(:GotoNode, :Int)
 _new(:NewvarNode, :SlotNumber)
-_new(:QuoteNode, :ANY)
+_new(:QuoteNode, :Any)
 _new(:SSAValue, :Int)
-eval(:((::Type{LineNumberNode})(l::Int) = $(Expr(:new, :LineNumberNode, :l))))
-eval(:((::Type{GlobalRef})(m::Module, s::Symbol) = $(Expr(:new, :GlobalRef, :m, :s))))
-eval(:((::Type{SlotNumber})(n::Int) = $(Expr(:new, :SlotNumber, :n))))
-eval(:((::Type{TypedSlot})(n::Int, t::ANY) = $(Expr(:new, :TypedSlot, :n, :t))))
+eval(Core, :((::Type{LineNumberNode})(l::Int) = $(Expr(:new, :LineNumberNode, :l, nothing))))
+eval(Core, :((::Type{LineNumberNode})(l::Int, @nospecialize(f)) = $(Expr(:new, :LineNumberNode, :l, :f))))
+eval(Core, :((::Type{GlobalRef})(m::Module, s::Symbol) = $(Expr(:new, :GlobalRef, :m, :s))))
+eval(Core, :((::Type{SlotNumber})(n::Int) = $(Expr(:new, :SlotNumber, :n))))
+eval(Core, :((::Type{TypedSlot})(n::Int, @nospecialize(t)) = $(Expr(:new, :TypedSlot, :n, :t))))
 
 Module(name::Symbol=:anonymous, std_imports::Bool=true) = ccall(:jl_f_new_module, Ref{Module}, (Any, Bool), name, std_imports)
 
-Task(f::ANY) = ccall(:jl_new_task, Ref{Task}, (Any, Int), f, 0)
+Task(@nospecialize(f)) = ccall(:jl_new_task, Ref{Task}, (Any, Int), f, 0)
 
 # simple convert for use by constructors of types in Core
 # note that there is no actual conversion defined here,
 # so the methods and ccall's in Core aren't permitted to use convert
-convert(::Type{Any}, x::ANY) = x
-convert{T}(::Type{T}, x::T) = x
-cconvert{T}(::Type{T}, x) = convert(T, x)
-unsafe_convert{T}(::Type{T}, x::T) = x
+convert(::Type{Any}, @nospecialize(x)) = x
+convert(::Type{T}, x::T) where {T} = x
+cconvert(::Type{T}, x) where {T} = convert(T, x)
+unsafe_convert(::Type{T}, x::T) where {T} = x
 
-NTuple{N,T} = Tuple{Vararg{T,N}}
+const NTuple{N,T} = Tuple{Vararg{T,N}}
 
 
 # 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}(d::NTuple{1,Int}) = Array{T,1}(getfield(d,1))
-(::Type{Array{T,2}}){T}(d::NTuple{2,Int}) = Array{T,2}(getfield(d,1), getfield(d,2))
-(::Type{Array{T,3}}){T}(d::NTuple{3,Int}) = Array{T,3}(getfield(d,1), getfield(d,2), getfield(d,3))
-(::Type{Array{T,N}}){T,N}(d::Vararg{Int, N}) = 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)
-
-(::Type{Array{T,1}}){T}() = Array{T,1}(0)
+Array{T,N}(d::NTuple{N,Int}) where {T,N} =
+    ccall(:jl_new_array, Array{T,N}, (Any, Any), Array{T,N}, d)
+Array{T,1}(d::NTuple{1,Int}) where {T} = Array{T,1}(getfield(d,1))
+Array{T,2}(d::NTuple{2,Int}) where {T} = Array{T,2}(getfield(d,1), getfield(d,2))
+Array{T,3}(d::NTuple{3,Int}) where {T} = Array{T,3}(getfield(d,1), getfield(d,2), getfield(d,3))
+Array{T,N}(d::Vararg{Int,N}) where {T,N} = ccall(:jl_new_array, Array{T,N}, (Any, Any), Array{T,N}, d)
+Array{T,1}(m::Int) where {T} = ccall(:jl_alloc_array_1d, Array{T,1}, (Any, Int), Array{T,1}, m)
+Array{T,2}(m::Int, n::Int) where {T} =
+    ccall(:jl_alloc_array_2d, Array{T,2}, (Any, Int, Int), Array{T,2}, m, n)
+Array{T,3}(m::Int, n::Int, o::Int) where {T} =
+    ccall(:jl_alloc_array_3d, Array{T,3}, (Any, Int, Int, Int), Array{T,3}, m, n, o)
+
+Array{T}(d::NTuple{N,Int}) where {T,N} = Array{T,N}(d)
+Array{T}(m::Int) where {T} = Array{T,1}(m)
+Array{T}(m::Int, n::Int) where {T} = Array{T,2}(m, n)
+Array{T}(m::Int, n::Int, o::Int) where {T} = Array{T,3}(m, n, o)
+
+Array{T,1}() where {T} = Array{T,1}(0)
 
 # primitive Symbol constructors
 function Symbol(s::String)
@@ -336,7 +356,7 @@ end
 
 # docsystem basics
 macro doc(x...)
-    atdoc(x...)
+    atdoc(__source__, __module__, x...)
 end
 macro __doc__(x)
     Expr(:escape, Expr(:block, Expr(:meta, :doc), x))
@@ -344,7 +364,7 @@ end
 macro doc_str(s)
     Expr(:escape, s)
 end
-atdoc     = (str, expr) -> Expr(:escape, expr)
+atdoc     = (source, mod, str, expr) -> Expr(:escape, expr)
 atdoc!(λ) = global atdoc = λ
 
 
@@ -369,16 +389,16 @@ function write(io::IO, x::String)
     return nb
 end
 
-show(io::IO, x::ANY) = ccall(:jl_static_show, Void, (Ptr{Void}, Any), io_pointer(io), x)
+show(io::IO, @nospecialize x) = ccall(:jl_static_show, Void, (Ptr{Void}, Any), io_pointer(io), x)
 print(io::IO, x::Char) = ccall(:jl_uv_putc, Void, (Ptr{Void}, Char), io_pointer(io), x)
-print(io::IO, x::String) = write(io, x)
-print(io::IO, x::ANY) = show(io, x)
-print(io::IO, x::ANY, a::ANY...) = (print(io, x); print(io, a...))
-println(io::IO) = write(io, 0x0a) # 0x0a = '\n'
-println(io::IO, x::ANY...) = (print(io, x...); println(io))
+print(io::IO, x::String) = (write(io, x); nothing)
+print(io::IO, @nospecialize x) = show(io, x)
+print(io::IO, @nospecialize(x), @nospecialize a...) = (print(io, x); print(io, a...))
+println(io::IO) = (write(io, 0x0a); nothing) # 0x0a = '\n'
+println(io::IO, @nospecialize x...) = (print(io, x...); println(io))
 
-show(a::ANY) = show(STDOUT, a)
-print(a::ANY...) = print(STDOUT, a...)
-println(a::ANY...) = println(STDOUT, a...)
+show(@nospecialize a) = show(STDOUT, a)
+print(@nospecialize a...) = print(STDOUT, a...)
+println(@nospecialize a...) = println(STDOUT, a...)
 
-ccall(:jl_set_istopmod, Void, (Bool,), true)
+ccall(:jl_set_istopmod, Void, (Any, Bool), Core, true)
diff --git a/base/broadcast.jl b/base/broadcast.jl
index 02e8f41a42141d..18c07b0193003a 100644
--- a/base/broadcast.jl
+++ b/base/broadcast.jl
@@ -1,11 +1,11 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module Broadcast
 
 using Base.Cartesian
 using Base: linearindices, tail, OneTo, to_shape,
             _msk_end, unsafe_bitgetindex, bitcache_chunks, bitcache_size, dumpbitcache,
-            nullable_returntype, null_safe_eltype_op, hasvalue, isoperator
+            nullable_returntype, null_safe_op, hasvalue, isoperator
 import Base: broadcast, broadcast!
 export broadcast_getindex, broadcast_setindex!, dotview, @__dot__
 
@@ -14,8 +14,8 @@ const ScalarType = Union{Type{Any}, Type{Nullable}}
 ## Broadcasting utilities ##
 # fallbacks for some special cases
 @inline broadcast(f, x::Number...) = f(x...)
-@inline broadcast{N}(f, t::NTuple{N,Any}, ts::Vararg{NTuple{N,Any}}) = map(f, t, ts...)
-broadcast!{T,S,N}(::typeof(identity), x::Array{T,N}, y::Array{S,N}) =
+@inline broadcast(f, t::NTuple{N,Any}, ts::Vararg{NTuple{N,Any}}) where {N} = map(f, t, ts...)
+broadcast!(::typeof(identity), x::Array{T,N}, y::Array{S,N}) where {T,S,N} =
     size(x) == size(y) ? copy!(x, y) : broadcast_c!(identity, Array, Array, x, y)
 
 # special cases for "X .= ..." (broadcast!) assignments
@@ -40,27 +40,27 @@ promote_containertype(::Type{Tuple}, ::ScalarType) = Tuple
 promote_containertype(::ScalarType, ::Type{Tuple}) = Tuple
 promote_containertype(::Type{Any}, ::Type{Nullable}) = Nullable
 promote_containertype(::Type{Nullable}, ::Type{Any}) = Nullable
-promote_containertype{T}(::Type{T}, ::Type{T}) = T
+promote_containertype(::Type{T}, ::Type{T}) where {T} = T
 
 ## Calculate the broadcast indices of the arguments, or error if incompatible
 # array inputs
 broadcast_indices() = ()
 broadcast_indices(A) = broadcast_indices(containertype(A), A)
+@inline broadcast_indices(A, B...) = broadcast_shape(broadcast_indices(A), broadcast_indices(B...))
 broadcast_indices(::ScalarType, A) = ()
 broadcast_indices(::Type{Tuple}, A) = (OneTo(length(A)),)
 broadcast_indices(::Type{Array}, A::Ref) = ()
 broadcast_indices(::Type{Array}, A) = indices(A)
-@inline broadcast_indices(A, B...) = broadcast_shape((), broadcast_indices(A), map(broadcast_indices, B)...)
+
 # shape (i.e., tuple-of-indices) inputs
 broadcast_shape(shape::Tuple) = shape
-@inline broadcast_shape(shape::Tuple, shape1::Tuple, shapes::Tuple...) = broadcast_shape(_bcs((), shape, shape1), shapes...)
+@inline broadcast_shape(shape::Tuple, shape1::Tuple, shapes::Tuple...) = broadcast_shape(_bcs(shape, shape1), shapes...)
 # _bcs consolidates two shapes into a single output shape
-_bcs(out, ::Tuple{}, ::Tuple{}) = out
-@inline _bcs(out, ::Tuple{}, newshape) = _bcs((out..., newshape[1]), (), tail(newshape))
-@inline _bcs(out, shape, ::Tuple{}) = _bcs((out..., shape[1]), tail(shape), ())
-@inline function _bcs(out, shape, newshape)
-    newout = _bcs1(shape[1], newshape[1])
-    _bcs((out..., newout), tail(shape), tail(newshape))
+_bcs(::Tuple{}, ::Tuple{}) = ()
+@inline _bcs(::Tuple{}, newshape::Tuple) = (newshape[1], _bcs((), tail(newshape))...)
+@inline _bcs(shape::Tuple, ::Tuple{}) = (shape[1], _bcs(tail(shape), ())...)
+@inline function _bcs(shape::Tuple, newshape::Tuple)
+    return (_bcs1(shape[1], newshape[1]), _bcs(tail(shape), tail(newshape))...)
 end
 # _bcs1 handles the logic for a single dimension
 _bcs1(a::Integer, b::Integer) = a == 1 ? b : (b == 1 ? a : (a == b ? a : throw(DimensionMismatch("arrays could not be broadcast to a common size"))))
@@ -134,7 +134,7 @@ Base.@propagate_inbounds _broadcast_getindex(::Any, A, I) = A[I]
 ## Broadcasting core
 # nargs encodes the number of As arguments (which matches the number
 # of keeps). The first two type parameters are to ensure specialization.
-@generated function _broadcast!{K,ID,AT,BT,N}(f, B::AbstractArray, keeps::K, Idefaults::ID, A::AT, Bs::BT, ::Type{Val{N}}, iter)
+@generated function _broadcast!(f, B::AbstractArray, keeps::K, Idefaults::ID, A::AT, Bs::BT, ::Val{N}, iter) where {K,ID,AT,BT,N}
     nargs = N + 1
     quote
         $(Expr(:meta, :inline))
@@ -157,7 +157,7 @@ end
 
 # For BitArray outputs, we cache the result in a "small" Vector{Bool},
 # and then copy in chunks into the output
-@generated function _broadcast!{K,ID,AT,BT,N}(f, B::BitArray, keeps::K, Idefaults::ID, A::AT, Bs::BT, ::Type{Val{N}}, iter)
+@generated function _broadcast!(f, B::BitArray, keeps::K, Idefaults::ID, A::AT, Bs::BT, ::Val{N}, iter) where {K,ID,AT,BT,N}
     nargs = N + 1
     quote
         $(Expr(:meta, :inline))
@@ -200,19 +200,19 @@ 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)`.
 """
-@inline broadcast!{N}(f, C::AbstractArray, A, Bs::Vararg{Any,N}) =
+@inline broadcast!(f, C::AbstractArray, A, Bs::Vararg{Any,N}) where {N} =
     broadcast_c!(f, containertype(C), containertype(A, Bs...), C, A, Bs...)
-@inline function broadcast_c!{N}(f, ::Type, ::Type, C, A, Bs::Vararg{Any,N})
+@inline function broadcast_c!(f, ::Type, ::Type, C, A, Bs::Vararg{Any,N}) where N
     shape = indices(C)
     @boundscheck check_broadcast_indices(shape, A, Bs...)
     keeps, Idefaults = map_newindexer(shape, A, Bs)
     iter = CartesianRange(shape)
-    _broadcast!(f, C, keeps, Idefaults, A, Bs, Val{N}, iter)
+    _broadcast!(f, C, keeps, Idefaults, A, Bs, Val(N), iter)
     return C
 end
 
 # broadcast with computed element type
-@generated function _broadcast!{K,ID,AT,nargs}(f, B::AbstractArray, keeps::K, Idefaults::ID, As::AT, ::Type{Val{nargs}}, iter, st, count)
+@generated function _broadcast!(f, B::AbstractArray, keeps::K, Idefaults::ID, As::AT, ::Val{nargs}, iter, st, count) where {K,ID,AT,nargs}
     quote
         $(Expr(:meta, :noinline))
         # destructure the keeps and As tuples
@@ -238,7 +238,7 @@ end
                     new[II] = B[II]
                 end
                 new[I] = V
-                return _broadcast!(f, new, keeps, Idefaults, As, Val{nargs}, iter, st, count+1)
+                return _broadcast!(f, new, keeps, Idefaults, As, Val(nargs), iter, st, count+1)
             end
             count += 1
         end
@@ -259,12 +259,12 @@ function broadcast_t(f, ::Type{Any}, shape, iter, As...)
         B = similar(Array{typeof(val)}, shape)
     end
     B[I] = val
-    return _broadcast!(f, B, keeps, Idefaults, As, Val{nargs}, iter, st, 1)
+    return _broadcast!(f, B, keeps, Idefaults, As, Val(nargs), iter, st, 1)
 end
-@inline function broadcast_t{N}(f, T, shape, iter, A, Bs::Vararg{Any,N})
+@inline function broadcast_t(f, T, shape, iter, A, Bs::Vararg{Any,N}) where N
     C = similar(Array{T}, shape)
     keeps, Idefaults = map_newindexer(shape, A, Bs)
-    _broadcast!(f, C, keeps, Idefaults, A, Bs, Val{N}, iter)
+    _broadcast!(f, C, keeps, Idefaults, A, Bs, Val(N), iter)
     return C
 end
 
@@ -272,17 +272,37 @@ end
 # in the common case where this is used for logical array indexing; in
 # performance-critical cases where Array{Bool} is desired, one can always
 # use broadcast! instead.
-@inline function broadcast_t{N}(f, ::Type{Bool}, shape, iter, A, Bs::Vararg{Any,N})
+@inline function broadcast_t(f, ::Type{Bool}, shape, iter, A, Bs::Vararg{Any,N}) where N
     C = similar(BitArray, shape)
     keeps, Idefaults = map_newindexer(shape, A, Bs)
-    _broadcast!(f, C, keeps, Idefaults, A, Bs, Val{N}, iter)
+    _broadcast!(f, C, keeps, Idefaults, A, Bs, Val(N), iter)
     return C
 end
 
-eltypestuple(a) = (Base.@_pure_meta; Tuple{eltype(a)})
-eltypestuple(T::Type) = (Base.@_pure_meta; Tuple{Type{T}})
-eltypestuple(a, b...) = (Base.@_pure_meta; Tuple{eltypestuple(a).types..., eltypestuple(b...).types...})
-_broadcast_eltype(f, A, Bs...) = Base._return_type(f, eltypestuple(A, Bs...))
+maptoTuple(f) = Tuple{}
+maptoTuple(f, a, b...) = Tuple{f(a), maptoTuple(f, b...).types...}
+
+# An element type satisfying for all A:
+# broadcast_getindex(
+#     containertype(A),
+#     A, broadcast_indices(A)
+# )::_broadcast_getindex_eltype(A)
+_broadcast_getindex_eltype(A) = _broadcast_getindex_eltype(containertype(A), A)
+_broadcast_getindex_eltype(::ScalarType, T::Type) = Type{T}
+_broadcast_getindex_eltype(::ScalarType, A) = typeof(A)
+_broadcast_getindex_eltype(::Any, A) = eltype(A)  # Tuple, Array, etc.
+
+# An element type satisfying for all A:
+# unsafe_get(A)::unsafe_get_eltype(A)
+_unsafe_get_eltype(x::Nullable) = eltype(x)
+_unsafe_get_eltype(T::Type) = Type{T}
+_unsafe_get_eltype(x) = typeof(x)
+
+# Inferred eltype of result of broadcast(f, xs...)
+_broadcast_eltype(f, A, As...) =
+    Base._return_type(f, maptoTuple(_broadcast_getindex_eltype, A, As...))
+_nullable_eltype(f, A, As...) =
+    Base._return_type(f, maptoTuple(_unsafe_get_eltype, A, As...))
 
 # broadcast methods that dispatch on the type of the final container
 @inline function broadcast_c(f, ::Type{Array}, A, Bs...)
@@ -297,15 +317,11 @@ _broadcast_eltype(f, A, Bs...) = Base._return_type(f, eltypestuple(A, Bs...))
     end
     return broadcast_t(f, Any, shape, iter, A, Bs...)
 end
-function broadcast_c(f, ::Type{Tuple}, As...)
-    shape = broadcast_indices(As...)
-    n = length(shape[1])
-    return ntuple(k->f((_broadcast_getindex(A, k) for A in As)...), n)
-end
 @inline function broadcast_c(f, ::Type{Nullable}, a...)
     nonnull = all(hasvalue, a)
-    S = _broadcast_eltype(f, a...)
-    if isconcrete(S) && null_safe_eltype_op(f, a...)
+    S = _nullable_eltype(f, a...)
+    if isconcrete(S) && null_safe_op(f, maptoTuple(_unsafe_get_eltype,
+                                     a...).types...)
         Nullable{S}(f(map(unsafe_get, a)...), nonnull)
     else
         if nonnull
@@ -316,6 +332,17 @@ end
     end
 end
 @inline broadcast_c(f, ::Type{Any}, a...) = f(a...)
+@inline broadcast_c(f, ::Type{Tuple}, A, Bs...) =
+    tuplebroadcast(f, first_tuple(A, Bs...), A, Bs...)
+@inline tuplebroadcast(f, ::NTuple{N,Any}, As...) where {N} =
+    ntuple(k -> f(tuplebroadcast_getargs(As, k)...), Val(N))
+@inline tuplebroadcast(f, ::NTuple{N,Any}, ::Type{T}, As...) where {N,T} =
+    ntuple(k -> f(T, tuplebroadcast_getargs(As, k)...), Val(N))
+first_tuple(A::Tuple, Bs...) = A
+@inline first_tuple(A, Bs...) = first_tuple(Bs...)
+tuplebroadcast_getargs(::Tuple{}, k) = ()
+@inline tuplebroadcast_getargs(As, k) =
+    (_broadcast_getindex(first(As), k), tuplebroadcast_getargs(tail(As), k)...)
 
 """
     broadcast(f, As...)
@@ -340,6 +367,7 @@ A special syntax exists for broadcasting: `f.(args...)` is equivalent to
 `broadcast(f, args...)`, and nested `f.(g.(args...))` calls are fused into a
 single broadcast loop.
 
+# Examples
 ```jldoctest
 julia> A = [1, 2, 3, 4, 5]
 5-element Array{Int64,1}:
@@ -412,6 +440,7 @@ Broadcasts the `inds` arrays to a common size like [`broadcast`](@ref)
 and returns an array of the results `A[ks...]`,
 where `ks` goes over the positions in the broadcast result `A`.
 
+# Examples
 ```jldoctest
 julia> A = [1, 2, 3, 4, 5]
 5-element Array{Int64,1}:
@@ -564,6 +593,17 @@ If you want to *avoid* adding dots for selected function calls in
 (no dot for `sort`).
 
 (`@.` is equivalent to a call to `@__dot__`.)
+
+# Examples
+```jldoctest
+julia> x = 1.0:3.0; y = similar(x);
+
+julia> @. y = x + 3 * sin(x)
+3-element Array{Float64,1}:
+ 3.52441
+ 4.72789
+ 3.42336
+```
 """
 macro __dot__(x)
     esc(__dot__(x))
diff --git a/base/c.jl b/base/c.jl
index 1e9764e1c12aa7..2723519247e391 100644
--- a/base/c.jl
+++ b/base/c.jl
@@ -1,10 +1,27 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # definitions related to C interface
 
 import Core.Intrinsics: cglobal, bitcast
 
-cfunction(f::Function, r, a) = ccall(:jl_function_ptr, Ptr{Void}, (Any, Any, Any), f, r, a)
+"""
+    cfunction(function::Function, ReturnType::Type, ArgumentTypes::Type)
+
+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.
+
+# Examples
+```julia-repl
+julia> function foo(x::Int, y::Int)
+           return x + y
+       end
+
+julia> cfunction(foo, Int, Tuple{Int,Int})
+Ptr{Void} @0x000000001b82fcd0
+```
+"""
+cfunction(f, r, a) = ccall(:jl_function_ptr, Ptr{Void}, (Any, Any, Any), f, r, a)
 
 if ccall(:jl_is_char_signed, Ref{Bool}, ())
     const Cchar = Int8
@@ -18,7 +35,8 @@ Equivalent to the native `char` c-type.
 """
 Cchar
 
-if is_windows()
+# The ccall here is equivalent to Sys.iswindows(), but that's not defined yet
+@static if ccall(:jl_get_UNAME, Any, ()) === :NT
     const Clong = Int32
     const Culong = UInt32
     const Cwchar_t = UInt16
@@ -45,11 +63,11 @@ Culong
 """
     Cwchar_t
 
-Equivalent to the native `wchar_t` c-type (`Int32`).
+Equivalent to the native `wchar_t` c-type ([`Int32`](@ref)).
 """
 Cwchar_t
 
-if !is_windows()
+@static if ccall(:jl_get_UNAME, Any, ()) !== :NT
     const sizeof_mode_t = ccall(:jl_sizeof_mode_t, Cint, ())
     if sizeof_mode_t == 2
         const Cmode_t = Int16
@@ -63,11 +81,11 @@ end
 # construction from typed pointers
 convert(::Type{Cstring}, p::Ptr{<:Union{Int8,UInt8}}) = bitcast(Cstring, p)
 convert(::Type{Cwstring}, p::Ptr{Cwchar_t}) = bitcast(Cwstring, p)
-convert{T<:Union{Int8,UInt8}}(::Type{Ptr{T}}, p::Cstring) = bitcast(Ptr{T}, p)
+convert(::Type{Ptr{T}}, p::Cstring) where {T<:Union{Int8,UInt8}} = bitcast(Ptr{T}, p)
 convert(::Type{Ptr{Cwchar_t}}, p::Cwstring) = bitcast(Ptr{Cwchar_t}, p)
 
 # construction from untyped pointers
-convert{T<:Union{Cstring,Cwstring}}(::Type{T}, p::Ptr{Void}) = bitcast(T, p)
+convert(::Type{T}, p::Ptr{Void}) where {T<:Union{Cstring,Cwstring}} = bitcast(T, p)
 
 pointer(p::Cstring) = convert(Ptr{UInt8}, p)
 pointer(p::Cwstring) = convert(Ptr{Cwchar_t}, p)
@@ -118,7 +136,7 @@ end
 # symbols are guaranteed not to contain embedded NUL
 convert(::Type{Cstring}, s::Symbol) = Cstring(unsafe_convert(Ptr{Cchar}, s))
 
-if is_windows()
+@static if ccall(:jl_get_UNAME, Any, ()) === :NT
 """
     Base.cwstring(s)
 
@@ -158,9 +176,9 @@ Only conversion to/from UTF-8 is currently supported.
 """
 function transcode end
 
-transcode{T<:Union{UInt8,UInt16,UInt32,Int32}}(::Type{T}, src::Vector{T}) = src
-transcode{T<:Union{Int32,UInt32}}(::Type{T}, src::String) = T[T(c) for c in src]
-transcode{T<:Union{Int32,UInt32}}(::Type{T}, src::Vector{UInt8}) = transcode(T, String(src))
+transcode(::Type{T}, src::Vector{T}) where {T<:Union{UInt8,UInt16,UInt32,Int32}} = src
+transcode(::Type{T}, src::String) where {T<:Union{Int32,UInt32}} = T[T(c) for c in src]
+transcode(::Type{T}, src::Vector{UInt8}) where {T<:Union{Int32,UInt32}} = transcode(T, String(src))
 function transcode(::Type{UInt8}, src::Vector{<:Union{Int32,UInt32}})
     buf = IOBuffer()
     for c in src; print(buf, Char(c)); end
@@ -344,9 +362,18 @@ function ccallable(f::Function, rt::Type, argt::Type, name::Union{AbstractString
     ccall(:jl_extern_c, Void, (Any, Any, Any, Cstring), f, rt, argt, name)
 end
 
-macro ccallable(rt, def)
+function expand_ccallable(rt, def)
     if isa(def,Expr) && (def.head === :(=) || def.head === :function)
         sig = def.args[1]
+        if sig.head === :(::)
+            if rt === nothing
+                rt = sig.args[2]
+            end
+            sig = sig.args[1]
+        end
+        if rt === nothing
+            error("@ccallable requires a return type")
+        end
         if sig.head === :call
             name = sig.args[1]
             at = map(sig.args[2:end]) do a
@@ -364,3 +391,10 @@ macro ccallable(rt, def)
     end
     error("expected method definition in @ccallable")
 end
+
+macro ccallable(def)
+    expand_ccallable(nothing, def)
+end
+macro ccallable(rt, def)
+    expand_ccallable(rt, def)
+end
diff --git a/base/cartesian.jl b/base/cartesian.jl
index 18e31f0f161f92..6762b4db15461c 100644
--- a/base/cartesian.jl
+++ b/base/cartesian.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module Cartesian
 
@@ -75,6 +75,7 @@ end
 Generate expressions like `A[i_1, i_2, ...]`. `indexexpr` can either be an iteration-symbol
 prefix, or an anonymous-function expression.
 
+# Examples
 ```jldoctest
 julia> @macroexpand Base.Cartesian.@nref 3 A i
 :(A[i_1, i_2, i_3])
@@ -120,6 +121,7 @@ end
 
 Generate `N` expressions. `expr` should be an anonymous-function expression.
 
+# Examples
 ```jldoctest
 julia> @macroexpand Base.Cartesian.@nexprs 4 i -> y[i] = A[i+j]
 quote
@@ -417,7 +419,7 @@ function exprresolve(ex::Expr)
     if ex.head == :if
         can_eval, tf = exprresolve_conditional(ex.args[1])
         if can_eval
-            ex = tf?ex.args[2]:ex.args[3]
+            ex = tf ? ex.args[2] : ex.args[3]
         end
     end
     ex
diff --git a/base/channels.jl b/base/channels.jl
index 9f6850c84f9d59..5c73db99e5be2c 100644
--- a/base/channels.jl
+++ b/base/channels.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 abstract type AbstractChannel end
 
@@ -23,11 +23,13 @@ mutable struct Channel{T} <: AbstractChannel
     state::Symbol
     excp::Nullable{Exception} # Exception to be thrown when state != :open
 
-    data::Array{T,1}
+    data::Vector{T}
     sz_max::Int            # maximum size of channel
 
     # Used when sz_max == 0, i.e., an unbuffered channel.
-    takers::Array{Condition}
+    waiters::Int
+    takers::Vector{Task}
+    putters::Vector{Task}
 
     function Channel{T}(sz::Float64) where T
         if sz == Inf
@@ -40,7 +42,12 @@ mutable struct Channel{T} <: AbstractChannel
         if sz < 0
             throw(ArgumentError("Channel size must be either 0, a positive integer or Inf"))
         end
-        new(Condition(), Condition(), :open, Nullable{Exception}(), Array{T}(0), sz, Array{Condition}(0))
+        ch = new(Condition(), Condition(), :open, Nullable{Exception}(), Vector{T}(0), sz, 0)
+        if sz == 0
+            ch.takers = Vector{Task}(0)
+            ch.putters = Vector{Task}(0)
+        end
+        return ch
     end
 
     # deprecated empty constructor
@@ -68,6 +75,7 @@ keyword argument `taskref`.
 
 Returns a Channel.
 
+# Examples
 ```jldoctest
 julia> chnl = Channel(c->foreach(i->put!(c,i), 1:4));
 
@@ -83,7 +91,7 @@ i = 3
 i = 4
 ```
 
-An example of referencing the created task:
+Referencing the created task:
 
 ```jldoctest
 julia> taskref = Ref{Task}();
@@ -102,10 +110,9 @@ true
 """
 function Channel(func::Function; ctype=Any, csize=0, taskref=nothing)
     chnl = Channel{ctype}(csize)
-    task = Task(()->func(chnl))
-    bind(chnl,task)
-    schedule(task)
-    yield()
+    task = Task(() -> func(chnl))
+    bind(chnl, task)
+    yield(task) # immediately start it
 
     isa(taskref, Ref{Task}) && (taskref[] = task)
     return chnl
@@ -156,6 +163,7 @@ When a channel is bound to multiple tasks, the first task to terminate will
 close the channel. When multiple channels are bound to the same task,
 termination of the task will close all of the bound channels.
 
+# Examples
 ```jldoctest
 julia> c = Channel(0);
 
@@ -188,8 +196,8 @@ julia> take!(c)
 julia> put!(c,1);
 ERROR: foo
 Stacktrace:
- [1] check_channel_state(::Channel{Any}) at ./channels.jl:125
- [2] put!(::Channel{Any}, ::Int64) at ./channels.jl:256
+ [1] check_channel_state(::Channel{Any}) at ./channels.jl:131
+ [2] put!(::Channel{Any}, ::Int64) at ./channels.jl:261
 ```
 """
 function bind(c::Channel, task::Task)
@@ -213,14 +221,13 @@ function channeled_tasks(n::Int, funcs...; ctypes=fill(Any,n), csizes=fill(0,n))
     @assert length(csizes) == n
     @assert length(ctypes) == n
 
-    chnls = map(i->Channel{ctypes[i]}(csizes[i]), 1:n)
-    tasks=Task[Task(()->f(chnls...)) for f in funcs]
+    chnls = map(i -> Channel{ctypes[i]}(csizes[i]), 1:n)
+    tasks = Task[ Task(() -> f(chnls...)) for f in funcs ]
 
     # bind all tasks to all channels and schedule them
-    foreach(t -> foreach(c -> bind(c,t), chnls), tasks)
+    foreach(t -> foreach(c -> bind(c, t), chnls), tasks)
     foreach(schedule, tasks)
-
-    yield()  # Allow scheduled tasks to run
+    yield() # Allow scheduled tasks to run
 
     return (chnls, tasks)
 end
@@ -269,13 +276,20 @@ function put_buffered(c::Channel, v)
 end
 
 function put_unbuffered(c::Channel, v)
-    while length(c.takers) == 0
-        notify(c.cond_take, nothing, true, false)  # Required to handle wait() on 0-sized channels
-        wait(c.cond_put)
+    if length(c.takers) == 0
+        push!(c.putters, current_task())
+        c.waiters > 0 && notify(c.cond_take, nothing, false, false)
+
+        try
+            wait()
+        catch ex
+            filter!(x->x!=current_task(), c.putters)
+            rethrow(ex)
+        end
     end
-    cond_taker = shift!(c.takers)
-    notify(cond_taker, v, false, false) > 0 && yield()
-    v
+    taker = shift!(c.takers)
+    yield(taker, v) # immediately give taker a chance to run, but don't block the current task
+    return v
 end
 
 push!(c::Channel, v) = put!(c, v)
@@ -313,20 +327,23 @@ end
 shift!(c::Channel) = take!(c)
 
 # 0-size channel
-function take_unbuffered(c::Channel)
+function take_unbuffered(c::Channel{T}) where T
     check_channel_state(c)
-    cond_taker = Condition()
-    push!(c.takers, cond_taker)
-    notify(c.cond_put, nothing, false, false)
+    push!(c.takers, current_task())
     try
-        return wait(cond_taker)
-    catch e
-        if isa(e, InterruptException)
-            # remove self from the list of takers
-            filter!(x -> x != cond_taker, c.takers)
+        if length(c.putters) > 0
+            let refputter = Ref(shift!(c.putters))
+                return Base.try_yieldto(refputter) do putter
+                    # if we fail to start putter, put it back in the queue
+                    putter === current_task || unshift!(c.putters, putter)
+                end::T
+            end
         else
-            rethrow(e)
+            return wait()::T
         end
+    catch ex
+        filter!(x->x!=current_task(), c.takers)
+        rethrow(ex)
     end
 end
 
@@ -340,9 +357,10 @@ For unbuffered channels returns `true` if there are tasks waiting
 on a [`put!`](@ref).
 """
 isready(c::Channel) = n_avail(c) > 0
-n_avail(c::Channel) = isbuffered(c) ? length(c.data) : n_waiters(c.cond_put)
+n_avail(c::Channel) = isbuffered(c) ? length(c.data) : length(c.putters)
 
-function wait(c::Channel)
+wait(c::Channel) = isbuffered(c) ? wait_impl(c) : wait_unbuffered(c)
+function wait_impl(c::Channel)
     while !isready(c)
         check_channel_state(c)
         wait(c.cond_take)
@@ -350,14 +368,29 @@ function wait(c::Channel)
     nothing
 end
 
+function wait_unbuffered(c::Channel)
+    c.waiters += 1
+    try
+        wait_impl(c)
+    finally
+        c.waiters -= 1
+    end
+    nothing
+end
+
 function notify_error(c::Channel, err)
     notify_error(c.cond_take, err)
     notify_error(c.cond_put, err)
-    foreach(x->notify_error(x, err), c.takers)
+
+    # release tasks on a `wait()/yieldto()` call (on unbuffered channels)
+    if !isbuffered(c)
+        waiters = filter!(t->(t.state == :runnable), vcat(c.takers, c.putters))
+        foreach(t->schedule(t, err; error=true), waiters)
+    end
 end
 notify_error(c::Channel) = notify_error(c, get(c.excp))
 
-eltype{T}(::Type{Channel{T}}) = T
+eltype(::Type{Channel{T}}) where {T} = T
 
 show(io::IO, c::Channel) = print(io, "$(typeof(c))(sz_max:$(c.sz_max),sz_curr:$(n_avail(c)))")
 
@@ -367,7 +400,7 @@ mutable struct ChannelIterState{T}
     ChannelIterState{T}(has::Bool) where {T} = new(has)
 end
 
-start{T}(c::Channel{T}) = ChannelIterState{T}(false)
+start(c::Channel{T}) where {T} = ChannelIterState{T}(false)
 function done(c::Channel, state::ChannelIterState)
     try
         # we are waiting either for more data or channel to be closed
diff --git a/base/char.jl b/base/char.jl
index f3c3b83abab56c..ea7334eb0679e3 100644
--- a/base/char.jl
+++ b/base/char.jl
@@ -1,11 +1,11 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 convert(::Type{Char}, x::UInt32) = reinterpret(Char, x)
 convert(::Type{Char}, x::Number) = Char(UInt32(x))
 convert(::Type{UInt32}, x::Char) = reinterpret(UInt32, x)
-convert{T<:Number}(::Type{T}, x::Char) = convert(T, UInt32(x))
+convert(::Type{T}, x::Char) where {T<:Number} = convert(T, UInt32(x))
 
-rem{T<:Number}(x::Char, ::Type{T}) = rem(UInt32(x), T)
+rem(x::Char, ::Type{T}) where {T<:Number} = rem(UInt32(x), T)
 
 typemax(::Type{Char}) = reinterpret(Char, typemax(UInt32))
 typemin(::Type{Char}) = reinterpret(Char, typemin(UInt32))
diff --git a/base/checked.jl b/base/checked.jl
index 37310d0a35e90e..215f12a62b52ea 100644
--- a/base/checked.jl
+++ b/base/checked.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Support for checked integer arithmetic
 
@@ -27,7 +27,7 @@ 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_abs{T<:Integer}(x::T) = no_op_err("checked_abs", T)
+checked_abs(x::T) where {T<:Integer} = no_op_err("checked_abs", T)
 
 const SignedInt = Union{Int8,Int16,Int32,Int64,Int128}
 const UnsignedInt = Union{UInt8,UInt16,UInt32,UInt64,UInt128}
@@ -87,7 +87,7 @@ represent `-typemin(Int)`, thus leading to an overflow.
 
 The overflow protection may impose a perceptible performance penalty.
 """
-function checked_neg{T<:Integer}(x::T)
+function checked_neg(x::T) where T<:Integer
     checked_sub(T(0), x)
 end
 if BrokenSignedInt != Union{}
@@ -98,7 +98,7 @@ function checked_neg(x::BrokenSignedInt)
 end
 end
 if BrokenUnsignedInt != Union{}
-function checked_neg{T<:BrokenUnsignedInt}(x::T)
+function checked_neg(x::T) where T<:BrokenUnsignedInt
     x != 0 && throw(OverflowError())
     T(0)
 end
@@ -131,12 +131,12 @@ checked_abs(x::Bool) = x
 Calculates `r = x+y`, with the flag `f` indicating whether overflow has occurred.
 """
 function add_with_overflow end
-add_with_overflow{T<:SignedInt}(x::T, y::T)   = checked_sadd_int(x, y)
-add_with_overflow{T<:UnsignedInt}(x::T, y::T) = checked_uadd_int(x, y)
-add_with_overflow(x::Bool, y::Bool)           = x+y, false
+add_with_overflow(x::T, y::T) where {T<:SignedInt}   = checked_sadd_int(x, y)
+add_with_overflow(x::T, y::T) where {T<:UnsignedInt} = checked_uadd_int(x, y)
+add_with_overflow(x::Bool, y::Bool) = (x+y, false)
 
 if BrokenSignedInt != Union{}
-function add_with_overflow{T<:BrokenSignedInt}(x::T, y::T)
+function add_with_overflow(x::T, y::T) where T<:BrokenSignedInt
     r = x + y
     # x and y have the same sign, and the result has a different sign
     f = (x<0) == (y<0) != (r<0)
@@ -144,7 +144,7 @@ function add_with_overflow{T<:BrokenSignedInt}(x::T, y::T)
 end
 end
 if BrokenUnsignedInt != Union{}
-function add_with_overflow{T<:BrokenUnsignedInt}(x::T, y::T)
+function add_with_overflow(x::T, y::T) where T<:BrokenUnsignedInt
     # x + y > typemax(T)
     # Note: ~y == -y-1
     x + y, x > ~y
@@ -159,7 +159,7 @@ Calculates `x+y`, checking for overflow errors where applicable.
 
 The overflow protection may impose a perceptible performance penalty.
 """
-function checked_add{T<:Integer}(x::T, y::T)
+function checked_add(x::T, y::T) where T<:Integer
     @_inline_meta
     z, b = add_with_overflow(x, y)
     b && throw(OverflowError())
@@ -170,17 +170,17 @@ end
 checked_add(x) = x
 checked_add(x::Bool) = +x
 
-checked_add{T}(x1::T, x2::T, x3::T) =
+checked_add(x1::T, x2::T, x3::T) where {T} =
     checked_add(checked_add(x1, x2), x3)
-checked_add{T}(x1::T, x2::T, x3::T, x4::T) =
+checked_add(x1::T, x2::T, x3::T, x4::T) where {T} =
     checked_add(checked_add(x1, x2), x3, x4)
-checked_add{T}(x1::T, x2::T, x3::T, x4::T, x5::T) =
+checked_add(x1::T, x2::T, x3::T, x4::T, x5::T) where {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(x1::T, x2::T, x3::T, x4::T, x5::T, x6::T) where {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(x1::T, x2::T, x3::T, x4::T, x5::T, x6::T, x7::T) where {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(x1::T, x2::T, x3::T, x4::T, x5::T, x6::T, x7::T, x8::T) where {T} =
     checked_add(checked_add(x1, x2), x3, x4, x5, x6, x7, x8)
 
 
@@ -190,12 +190,12 @@ checked_add{T}(x1::T, x2::T, x3::T, x4::T, x5::T, x6::T, x7::T, x8::T) =
 Calculates `r = x-y`, with the flag `f` indicating whether overflow has occurred.
 """
 function sub_with_overflow end
-sub_with_overflow{T<:SignedInt}(x::T, y::T)   = checked_ssub_int(x, y)
-sub_with_overflow{T<:UnsignedInt}(x::T, y::T) = checked_usub_int(x, y)
-sub_with_overflow(x::Bool, y::Bool)           = x-y, false
+sub_with_overflow(x::T, y::T) where {T<:SignedInt}   = checked_ssub_int(x, y)
+sub_with_overflow(x::T, y::T) where {T<:UnsignedInt} = checked_usub_int(x, y)
+sub_with_overflow(x::Bool, y::Bool) = (x-y, false)
 
 if BrokenSignedInt != Union{}
-function sub_with_overflow{T<:BrokenSignedInt}(x::T, y::T)
+function sub_with_overflow(x::T, y::T) where T<:BrokenSignedInt
     r = x - y
     # x and y have different signs, and the result has a different sign than x
     f = (x<0) != (y<0) == (r<0)
@@ -203,7 +203,7 @@ function sub_with_overflow{T<:BrokenSignedInt}(x::T, y::T)
 end
 end
 if BrokenUnsignedInt != Union{}
-function sub_with_overflow{T<:BrokenUnsignedInt}(x::T, y::T)
+function sub_with_overflow(x::T, y::T) where T<:BrokenUnsignedInt
     # x - y < 0
     x - y, x < y
 end
@@ -216,7 +216,7 @@ Calculates `x-y`, checking for overflow errors where applicable.
 
 The overflow protection may impose a perceptible performance penalty.
 """
-function checked_sub{T<:Integer}(x::T, y::T)
+function checked_sub(x::T, y::T) where T<:Integer
     @_inline_meta
     z, b = sub_with_overflow(x, y)
     b && throw(OverflowError())
@@ -230,19 +230,19 @@ end
 Calculates `r = x*y`, with the flag `f` indicating whether overflow has occurred.
 """
 function mul_with_overflow end
-mul_with_overflow{T<:SignedInt}(x::T, y::T)   = checked_smul_int(x, y)
-mul_with_overflow{T<:UnsignedInt}(x::T, y::T) = checked_umul_int(x, y)
-mul_with_overflow(x::Bool, y::Bool)           = x*y, false
+mul_with_overflow(x::T, y::T) where {T<:SignedInt}   = checked_smul_int(x, y)
+mul_with_overflow(x::T, y::T) where {T<:UnsignedInt} = checked_umul_int(x, y)
+mul_with_overflow(x::Bool, y::Bool) = (x*y, false)
 
 if BrokenSignedIntMul != Union{} && BrokenSignedIntMul != Int128
-function mul_with_overflow{T<:BrokenSignedIntMul}(x::T, y::T)
+function mul_with_overflow(x::T, y::T) where T<:BrokenSignedIntMul
     r = widemul(x, y)
     f = r % T != r
     r % T, f
 end
 end
 if BrokenUnsignedIntMul != Union{} && BrokenUnsignedIntMul != UInt128
-function mul_with_overflow{T<:BrokenUnsignedIntMul}(x::T, y::T)
+function mul_with_overflow(x::T, y::T) where T<:BrokenUnsignedIntMul
     r = widemul(x, y)
     f = r % T != r
     r % T, f
@@ -250,7 +250,7 @@ end
 end
 if Int128 <: BrokenSignedIntMul
     # Avoid BigInt
-    function mul_with_overflow{T<:Int128}(x::T, y::T)
+    function mul_with_overflow(x::T, y::T) where T<:Int128
         f = if y > 0
             # x * y > typemax(T)
             # x * y < typemin(T)
@@ -268,7 +268,7 @@ if Int128 <: BrokenSignedIntMul
 end
 if UInt128 <: BrokenUnsignedIntMul
     # Avoid BigInt
-    function mul_with_overflow{T<:UInt128}(x::T, y::T)
+    function mul_with_overflow(x::T, y::T) where T<:UInt128
         # x * y > typemax(T)
         x * y, y > 0 && x > fld(typemax(T), y)
     end
@@ -281,7 +281,7 @@ Calculates `x*y`, checking for overflow errors where applicable.
 
 The overflow protection may impose a perceptible performance penalty.
 """
-function checked_mul{T<:Integer}(x::T, y::T)
+function checked_mul(x::T, y::T) where T<:Integer
     @_inline_meta
     z, b = mul_with_overflow(x, y)
     b && throw(OverflowError())
@@ -290,17 +290,17 @@ end
 
 # Handle multiple arguments
 checked_mul(x) = x
-checked_mul{T}(x1::T, x2::T, x3::T) =
+checked_mul(x1::T, x2::T, x3::T) where {T} =
     checked_mul(checked_mul(x1, x2), x3)
-checked_mul{T}(x1::T, x2::T, x3::T, x4::T) =
+checked_mul(x1::T, x2::T, x3::T, x4::T) where {T} =
     checked_mul(checked_mul(x1, x2), x3, x4)
-checked_mul{T}(x1::T, x2::T, x3::T, x4::T, x5::T) =
+checked_mul(x1::T, x2::T, x3::T, x4::T, x5::T) where {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(x1::T, x2::T, x3::T, x4::T, x5::T, x6::T) where {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(x1::T, x2::T, x3::T, x4::T, x5::T, x6::T, x7::T) where {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(x1::T, x2::T, x3::T, x4::T, x5::T, x6::T, x7::T, x8::T) where {T} =
     checked_mul(checked_mul(x1, x2), x3, x4, x5, x6, x7, x8)
 
 """
@@ -310,7 +310,7 @@ Calculates `div(x,y)`, checking for overflow errors where applicable.
 
 The overflow protection may impose a perceptible performance penalty.
 """
-checked_div{T<:Integer}(x::T, y::T) = div(x, y) # Base.div already checks
+checked_div(x::T, y::T) where {T<:Integer} = div(x, y) # Base.div already checks
 
 """
     Base.checked_rem(x, y)
@@ -319,7 +319,7 @@ Calculates `x%y`, checking for overflow errors where applicable.
 
 The overflow protection may impose a perceptible performance penalty.
 """
-checked_rem{T<:Integer}(x::T, y::T) = rem(x, y) # Base.rem already checks
+checked_rem(x::T, y::T) where {T<:Integer} = rem(x, y) # Base.rem already checks
 
 """
     Base.checked_fld(x, y)
@@ -328,7 +328,7 @@ Calculates `fld(x,y)`, checking for overflow errors where applicable.
 
 The overflow protection may impose a perceptible performance penalty.
 """
-checked_fld{T<:Integer}(x::T, y::T) = fld(x, y) # Base.fld already checks
+checked_fld(x::T, y::T) where {T<:Integer} = fld(x, y) # Base.fld already checks
 
 """
     Base.checked_mod(x, y)
@@ -337,7 +337,7 @@ Calculates `mod(x,y)`, checking for overflow errors where applicable.
 
 The overflow protection may impose a perceptible performance penalty.
 """
-checked_mod{T<:Integer}(x::T, y::T) = mod(x, y) # Base.mod already checks
+checked_mod(x::T, y::T) where {T<:Integer} = mod(x, y) # Base.mod already checks
 
 """
     Base.checked_cld(x, y)
@@ -346,6 +346,6 @@ Calculates `cld(x,y)`, checking for overflow errors where applicable.
 
 The overflow protection may impose a perceptible performance penalty.
 """
-checked_cld{T<:Integer}(x::T, y::T) = cld(x, y) # Base.cld already checks
+checked_cld(x::T, y::T) where {T<:Integer} = cld(x, y) # Base.cld already checks
 
 end
diff --git a/base/client.jl b/base/client.jl
index 268a24d6923730..c46d5acccc95c4 100644
--- a/base/client.jl
+++ b/base/client.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## client.jl - frontend handling command line options, environment setup,
 ##             and REPL
@@ -22,6 +22,7 @@ const text_colors = AnyDict(
     :normal        => "\033[0m",
     :default       => "\033[39m",
     :bold          => "\033[1m",
+    :underline     => "\033[4m",
     :nothing       => "",
 )
 
@@ -31,6 +32,7 @@ end
 
 const disable_text_style = AnyDict(
     :bold => "\033[22m",
+    :underline => "\033[24m",
     :normal => "",
     :default => "",
 )
@@ -100,7 +102,7 @@ function repl_cmd(cmd, out)
                 end
                 cd(ENV["OLDPWD"])
             else
-                cd(@static is_windows() ? dir : readchomp(`$shell -c "echo $(shell_escape(dir))"`))
+                cd(@static Sys.iswindows() ? dir : readchomp(`$shell -c "echo $(shell_escape(dir))"`))
             end
         else
             cd()
@@ -108,7 +110,7 @@ function repl_cmd(cmd, out)
         ENV["OLDPWD"] = new_oldpwd
         println(out, pwd())
     else
-        run(ignorestatus(@static is_windows() ? cmd : (isa(STDIN, TTY) ? `$shell -i -c "$(shell_wrap_true(shell_name, cmd))"` : `$shell -c "$(shell_wrap_true(shell_name, cmd))"`)))
+        run(ignorestatus(@static Sys.iswindows() ? cmd : (isa(STDIN, TTY) ? `$shell -i -c "$(shell_wrap_true(shell_name, cmd))"` : `$shell -c "$(shell_wrap_true(shell_name, cmd))"`)))
     end
     nothing
 end
@@ -140,7 +142,7 @@ end
 display_error(er, bt) = display_error(STDERR, er, bt)
 display_error(er) = display_error(er, [])
 
-function eval_user_input(ast::ANY, show_value)
+function eval_user_input(@nospecialize(ast), show_value)
     errcount, lasterr, bt = 0, (), nothing
     while true
         try
@@ -151,7 +153,7 @@ function eval_user_input(ast::ANY, show_value)
                 display_error(lasterr,bt)
                 errcount, lasterr = 0, ()
             else
-                ast = expand(ast)
+                ast = expand(Main, ast)
                 value = eval(Main, ast)
                 eval(Main, Expr(:body, Expr(:(=), :ans, QuoteNode(value)), Expr(:return, nothing)))
                 if !(value === nothing) && show_value
@@ -208,7 +210,7 @@ function parse_input_line(s::String; filename::String="none")
                s, sizeof(s), filename, sizeof(filename))
     if ex === :_
         # remove with 0.6 deprecation
-        expand(ex)  # to get possible warning about using _ as an rvalue
+        expand(Main, ex)  # to get possible warning about using _ as an rvalue
     end
     return ex
 end
@@ -241,7 +243,7 @@ function incomplete_tag(ex::Expr)
 end
 
 # try to include() a file, ignoring if not found
-try_include(path::AbstractString) = isfile(path) && include(path)
+try_include(mod::Module, path::AbstractString) = isfile(path) && include(mod, path)
 
 function process_options(opts::JLOptions)
     if !isempty(ARGS)
@@ -255,11 +257,21 @@ function process_options(opts::JLOptions)
     color_set             = (opts.color != 0)
     global have_color     = (opts.color == 1)
     global is_interactive = (opts.isinteractive != 0)
+
+    # remove filename from ARGS
+    arg_is_program = opts.eval == C_NULL && opts.print == C_NULL && !isempty(ARGS)
+    global PROGRAM_FILE = arg_is_program ? shift!(ARGS) : ""
+
     while true
         # startup worker.
         # opts.startupfile, opts.load, etc should should not be processed for workers.
-        if opts.worker != C_NULL
-            start_worker(unsafe_string(opts.worker)) # does not return
+        if opts.worker == 1
+            # does not return
+            if opts.cookie != C_NULL
+                start_worker(unsafe_string(opts.cookie))
+            else
+                start_worker()
+            end
         end
 
         # add processors
@@ -277,7 +289,7 @@ function process_options(opts::JLOptions)
         # load file immediately on all processors
         if opts.load != C_NULL
             @sync for p in procs()
-                @async remotecall_fetch(include, p, unsafe_string(opts.load))
+                @async remotecall_fetch(include, p, Main, unsafe_string(opts.load))
             end
         end
         # eval expression
@@ -294,15 +306,13 @@ function process_options(opts::JLOptions)
             break
         end
         # load file
-        if !isempty(ARGS) && !isempty(ARGS[1])
+        if !isempty(PROGRAM_FILE)
             # program
             repl = false
-            # remove filename from ARGS
-            global PROGRAM_FILE = shift!(ARGS)
             if !is_interactive
                 ccall(:jl_exit_on_sigint, Void, (Cint,), 1)
             end
-            include(PROGRAM_FILE)
+            include(Main, PROGRAM_FILE)
         end
         break
     end
@@ -313,17 +323,18 @@ end
 function load_juliarc()
     # If the user built us with a specific Base.SYSCONFDIR, check that location first for a juliarc.jl file
     #   If it is not found, then continue on to the relative path based on JULIA_HOME
-    if !isempty(Base.SYSCONFDIR) && isfile(joinpath(JULIA_HOME,Base.SYSCONFDIR,"julia","juliarc.jl"))
-        include(abspath(JULIA_HOME,Base.SYSCONFDIR,"julia","juliarc.jl"))
+    if !isempty(Base.SYSCONFDIR) && isfile(joinpath(JULIA_HOME, Base.SYSCONFDIR, "julia", "juliarc.jl"))
+        include(Main, abspath(JULIA_HOME, Base.SYSCONFDIR, "julia", "juliarc.jl"))
     else
-        try_include(abspath(JULIA_HOME,"..","etc","julia","juliarc.jl"))
+        try_include(Main, abspath(JULIA_HOME, "..", "etc", "julia", "juliarc.jl"))
     end
-    try_include(abspath(homedir(),".juliarc.jl"))
+    try_include(Main, abspath(homedir(), ".juliarc.jl"))
+    nothing
 end
 
 function load_machine_file(path::AbstractString)
     machines = []
-    for line in split(readstring(path),'\n'; keep=false)
+    for line in split(read(path, String),'\n'; keep=false)
         s = split(line, '*'; keep = false)
         map!(strip, s, s)
         if length(s) > 1
@@ -361,12 +372,13 @@ function __atreplinit(repl)
         end
     end
 end
-_atreplinit(repl) = @eval Main $__atreplinit($repl)
+_atreplinit(repl) = invokelatest(__atreplinit, repl)
 
 function _start()
     empty!(ARGS)
     append!(ARGS, Core.ARGS)
     opts = JLOptions()
+    @eval Main include(x) = $include(Main, x)
     try
         (quiet,repl,startup,color_set,history_file) = process_options(opts)
 
@@ -378,7 +390,7 @@ function _start()
                 global is_interactive |= !isa(STDIN, Union{File, IOStream})
                 color_set || (global have_color = false)
             else
-                term = Terminals.TTYTerminal(get(ENV, "TERM", @static is_windows() ? "" : "dumb"), STDIN, STDOUT, STDERR)
+                term = Terminals.TTYTerminal(get(ENV, "TERM", @static Sys.iswindows() ? "" : "dumb"), STDIN, STDOUT, STDERR)
                 global is_interactive = true
                 color_set || (global have_color = Terminals.hascolor(term))
                 quiet || REPL.banner(term,term)
@@ -401,7 +413,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(readstring(STDIN)))
+                    eval(Main,parse_input_line(read(STDIN, String)))
                 else
                     # otherwise behave repl-like
                     while !eof(STDIN)
diff --git a/base/combinatorics.jl b/base/combinatorics.jl
index 7388e7ecd1b56f..51f7cb1d579576 100644
--- a/base/combinatorics.jl
+++ b/base/combinatorics.jl
@@ -1,33 +1,21 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://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,
-          121645100408832000,2432902008176640000]
-
-const _fact_table128 =
-    UInt128[0x00000000000000000000000000000001, 0x00000000000000000000000000000002,
-            0x00000000000000000000000000000006, 0x00000000000000000000000000000018,
-            0x00000000000000000000000000000078, 0x000000000000000000000000000002d0,
-            0x000000000000000000000000000013b0, 0x00000000000000000000000000009d80,
-            0x00000000000000000000000000058980, 0x00000000000000000000000000375f00,
-            0x00000000000000000000000002611500, 0x0000000000000000000000001c8cfc00,
-            0x0000000000000000000000017328cc00, 0x0000000000000000000000144c3b2800,
-            0x00000000000000000000013077775800, 0x00000000000000000000130777758000,
-            0x00000000000000000001437eeecd8000, 0x00000000000000000016beecca730000,
-            0x000000000000000001b02b9306890000, 0x000000000000000021c3677c82b40000,
-            0x0000000000000002c5077d36b8c40000, 0x000000000000003ceea4c2b3e0d80000,
-            0x000000000000057970cd7e2933680000, 0x00000000000083629343d3dcd1c00000,
-            0x00000000000cd4a0619fb0907bc00000, 0x00000000014d9849ea37eeac91800000,
-            0x00000000232f0fcbb3e62c3358800000, 0x00000003d925ba47ad2cd59dae000000,
-            0x0000006f99461a1e9e1432dcb6000000, 0x00000d13f6370f96865df5dd54000000,
-            0x0001956ad0aae33a4560c5cd2c000000, 0x0032ad5a155c6748ac18b9a580000000,
-            0x0688589cc0e9505e2f2fee5580000000, 0xde1bc4d19efcac82445da75b00000000]
+const _fact_table64 = Vector{Int64}(20)
+_fact_table64[1] = 1
+for n in 2:20
+    _fact_table64[n] = _fact_table64[n-1] * n
+end
+
+const _fact_table128 = Vector{UInt128}(34)
+_fact_table128[1] = 1
+for n in 2:34
+    _fact_table128[n] = _fact_table128[n-1] * n
+end
 
 function factorial_lookup(n::Integer, table, lim)
-    n < 0 && throw(DomainError())
+    n < 0 && throw(DomainError(n, "`n` must not be negative."))
     n > lim && throw(OverflowError())
     n == 0 && return one(n)
     @inbounds f = table[n]
@@ -46,7 +34,7 @@ else
 end
 
 function gamma(n::Union{Int8,UInt8,Int16,UInt16,Int32,UInt32,Int64,UInt64})
-    n < 0 && throw(DomainError())
+    n < 0 && throw(DomainError(n, "`n` must not be negative."))
     n == 0 && return Inf
     n <= 2 && return 1.0
     n > 20 && return gamma(Float64(n))
@@ -61,6 +49,7 @@ end
 
 Returns `true` if `v` is a valid permutation.
 
+# Examples
 ```jldoctest
 julia> isperm([1; 2])
 true
@@ -112,8 +101,9 @@ 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.
 
-See also [`ipermute!`](@ref)
+See also [`ipermute!`](@ref).
 
+# Examples
 ```jldoctest
 julia> A = [1, 1, 3, 4];
 
@@ -157,8 +147,9 @@ end
 """
     ipermute!(v, p)
 
-Like `permute!`, but the inverse of the given permutation is applied.
+Like [`permute!`](@ref), but the inverse of the given permutation is applied.
 
+# Examples
 ```jldoctest
 julia> A = [1, 1, 3, 4];
 
@@ -182,6 +173,7 @@ ipermute!(a, p::AbstractVector) = ipermute!!(a, copymutable(p))
 Return the inverse permutation of `v`.
 If `B = A[v]`, then `A == B[invperm(v)]`.
 
+# Examples
 ```jldoctest
 julia> v = [2; 4; 3; 1];
 
@@ -233,6 +225,7 @@ invperm(a::Tuple) = (invperm([a...])...,)
 Next integer greater than or equal to `n` that can be written as ``\\prod k_i^{p_i}`` for integers
 ``p_1``, ``p_2``, etc.
 
+# Examples
 ```jldoctest
 julia> nextprod([2, 3], 105)
 108
diff --git a/base/complex.jl b/base/complex.jl
index ba4fdfb65628dd..65db3392a3dd2c 100644
--- a/base/complex.jl
+++ b/base/complex.jl
@@ -1,5 +1,13 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
+"""
+    Complex{T<:Real} <: Number
+
+Complex number type with real and imaginary part of type `T`.
+
+`Complex32`, `Complex64` and `Complex128` are aliases for
+`Complex{Float16}`, `Complex{Float32}` and `Complex{Float64}` respectively.
+"""
 struct Complex{T<:Real} <: Number
     re::T
     im::T
@@ -11,33 +19,43 @@ Complex(x::Real) = Complex(x, zero(x))
     im
 
 The imaginary unit.
+
+# Examples
+```jldoctest
+julia> im * im
+-1 + 0im
+```
 """
-const im = Complex(false,true)
+const im = Complex(false, true)
 
 const Complex128 = Complex{Float64}
 const Complex64  = Complex{Float32}
 const Complex32  = Complex{Float16}
 
-convert{T<:Real}(::Type{Complex{T}}, x::Real) = Complex{T}(x,0)
-convert{T<:Real}(::Type{Complex{T}}, z::Complex) = Complex{T}(real(z),imag(z))
-convert{T<:Real}(::Type{T}, z::Complex) =
-    isreal(z) ? convert(T,real(z)) : throw(InexactError())
+convert(::Type{Complex{T}}, x::Real) where {T<:Real} = Complex{T}(x,0)
+convert(::Type{Complex{T}}, z::Complex) where {T<:Real} = Complex{T}(real(z),imag(z))
+convert(::Type{T}, z::Complex) where {T<:Real} =
+    isreal(z) ? convert(T,real(z)) : throw(InexactError(:convert, T, z))
 
 convert(::Type{Complex}, z::Complex) = z
 convert(::Type{Complex}, x::Real) = Complex(x)
 
-promote_rule{T<:Real,S<:Real}(::Type{Complex{T}}, ::Type{S}) =
+promote_rule(::Type{Complex{T}}, ::Type{S}) where {T<:Real,S<:Real} =
     Complex{promote_type(T,S)}
-promote_rule{T<:Real,S<:Real}(::Type{Complex{T}}, ::Type{Complex{S}}) =
+promote_rule(::Type{Complex{T}}, ::Type{Complex{S}}) where {T<:Real,S<:Real} =
     Complex{promote_type(T,S)}
 
-widen{T}(::Type{Complex{T}}) = Complex{widen(T)}
+widen(::Type{Complex{T}}) where {T} = Complex{widen(T)}
+
+float(::Type{Complex{T}}) where {T<:AbstractFloat} = Complex{T}
+float(::Type{Complex{T}}) where {T} = Complex{float(T)}
 
 """
     real(z)
 
 Return the real part of the complex number `z`.
 
+# Examples
 ```jldoctest
 julia> real(1 + 3im)
 1
@@ -50,6 +68,7 @@ real(z::Complex) = z.re
 
 Return the imaginary part of the complex number `z`.
 
+# Examples
 ```jldoctest
 julia> imag(1 + 3im)
 3
@@ -64,6 +83,7 @@ imag(x::Real) = zero(x)
 
 Return both the real and imaginary parts of the complex number `z`.
 
+# Examples
 ```jldoctest
 julia> reim(1 + 3im)
 (1, 3)
@@ -87,14 +107,15 @@ Float64
 ```
 """
 real(T::Type) = typeof(real(zero(T)))
-real{T<:Real}(::Type{T}) = T
-real{T<:Real}(::Type{Complex{T}}) = T
+real(::Type{T}) where {T<:Real} = T
+real(::Type{Complex{T}}) where {T<:Real} = T
 
 """
     isreal(x) -> Bool
 
 Test whether `x` or all its elements are numerically equal to some real number.
 
+# Examples
 ```jldoctest
 julia> isreal(5.)
 true
@@ -110,6 +131,7 @@ isfinite(z::Complex) = isfinite(real(z)) & isfinite(imag(z))
 isnan(z::Complex) = isnan(real(z)) | isnan(imag(z))
 isinf(z::Complex) = isinf(real(z)) | isinf(imag(z))
 iszero(z::Complex) = iszero(real(z)) & iszero(imag(z))
+isone(z::Complex) = isone(real(z)) & iszero(imag(z))
 
 """
     complex(r, [i])
@@ -126,6 +148,7 @@ complex(x::Real, y::Real) = Complex(x, y)
 Returns an appropriate type which can represent a value of type `T` as a complex number.
 Equivalent to `typeof(complex(zero(T)))`.
 
+# Examples
 ```jldoctest
 julia> complex(Complex{Int})
 Complex{Int64}
@@ -134,8 +157,8 @@ julia> complex(Int)
 Complex{Int64}
 ```
 """
-complex{T<:Real}(::Type{T}) = Complex{T}
-complex{T<:Real}(::Type{Complex{T}}) = Complex{T}
+complex(::Type{T}) where {T<:Real} = Complex{T}
+complex(::Type{Complex{T}}) where {T<:Real} = Complex{T}
 
 flipsign(x::Complex, y::Real) = ifelse(signbit(y), -x, x)
 
@@ -158,7 +181,17 @@ end
 show(io::IO, z::Complex{Bool}) =
     print(io, z == im ? "im" : "Complex($(z.re),$(z.im))")
 
-function read{T<:Real}(s::IO, ::Type{Complex{T}})
+function show_unquoted(io::IO, z::Complex, ::Int, prec::Int)
+    if operator_precedence(:+) <= prec
+        print(io, "(")
+        show(io, z)
+        print(io, ")")
+    else
+        show(io, z)
+    end
+end
+
+function read(s::IO, ::Type{Complex{T}}) where T<:Real
     r = read(s,T)
     i = read(s,T)
     Complex{T}(r,i)
@@ -167,6 +200,9 @@ function write(s::IO, z::Complex)
     write(s,real(z),imag(z))
 end
 
+## byte order swaps: real and imaginary part are swapped individually
+bswap(z::Complex) = Complex(bswap(real(z)), bswap(imag(z)))
+
 ## equality and hashing of complex numbers ##
 
 ==(z::Complex, w::Complex) = (real(z) == real(w)) & (imag(z) == imag(w))
@@ -175,6 +211,8 @@ end
 
 isequal(z::Complex, w::Complex) = isequal(real(z),real(w)) & isequal(imag(z),imag(w))
 
+in(x::Complex, r::Range{<:Real}) = isreal(x) && real(x) in r
+
 if UInt === UInt64
     const h_imag = 0x32a7a07f3e7cd1f9
 else
@@ -195,6 +233,7 @@ end
 
 Compute the complex conjugate of a complex number `z`.
 
+# Examples
 ```jldoctest
 julia> conj(1 + 3im)
 1 - 3im
@@ -264,10 +303,10 @@ muladd(z::Complex, w::Complex, x::Real) =
     Complex(muladd(real(z), real(w), x) - imag(z)*imag(w), # TODO: use mulsub given #15985
             muladd(real(z), imag(w), imag(z) * real(w)))
 
-/{R<:Real,S<:Complex}(a::R, z::S) = (T = promote_type(R,S); a*inv(T(z)))
+/(a::R, z::S) where {R<:Real,S<:Complex} = (T = promote_type(R,S); a*inv(T(z)))
 /(z::Complex, x::Real) = Complex(real(z)/x, imag(z)/x)
 
-function /{T<:Real}(a::Complex{T}, b::Complex{T})
+function /(a::Complex{T}, b::Complex{T}) where T<:Real
     are = real(a); aim = imag(a); bre = real(b); bim = imag(b)
     if abs(bre) <= abs(bim)
         if isinf(bre) && isinf(bim)
@@ -291,7 +330,7 @@ end
 inv(z::Complex{<:Union{Float16,Float32}}) =
     oftype(z, conj(widen(z))/abs2(widen(z)))
 
-/{T<:Union{Float16,Float32}}(z::Complex{T}, w::Complex{T}) =
+/(z::Complex{T}, w::Complex{T}) where {T<:Union{Float16,Float32}} =
     oftype(z, widen(z)*inv(widen(w)))
 
 # robust complex division for double precision
@@ -363,7 +402,7 @@ function inv(w::Complex128)
     return Complex128(p*s,q*s) # undo scaling
 end
 
-function ssqs{T<:AbstractFloat}(x::T, y::T)
+function ssqs(x::T, y::T) where T<:AbstractFloat
     k::Int = 0
     ρ = x*x + y*y
     if !isfinite(ρ) && (isinf(x) || isinf(y))
@@ -418,26 +457,48 @@ sqrt(z::Complex) = sqrt(float(z))
 # end
 
 # compute exp(im*theta)
-cis(theta::Real) = Complex(cos(theta),sin(theta))
+function cis(theta::Real)
+    s, c = sincos(theta)
+    Complex(c, s)
+end
 
 """
     cis(z)
 
 Return ``\\exp(iz)``.
+
+# Examples
+```jldoctest
+julia> cis(π) ≈ -1
+true
+```
 """
 function cis(z::Complex)
     v = exp(-imag(z))
-    Complex(v*cos(real(z)), v*sin(real(z)))
+    s, c = sincos(real(z))
+    Complex(v * c, v * s)
 end
 
 """
     angle(z)
 
 Compute the phase angle in radians of a complex number `z`.
+
+# Examples
+```jldoctest
+julia> rad2deg(angle(1 + im))
+45.0
+
+julia> rad2deg(angle(1 - im))
+-45.0
+
+julia> rad2deg(angle(-1 - im))
+-135.0
+```
 """
 angle(z::Complex) = atan2(imag(z), real(z))
 
-function log{T<:AbstractFloat}(z::Complex{T})
+function log(z::Complex{T}) where T<:AbstractFloat
     const T1::T  = 1.25
     const T2::T  = 3
     const ln2::T = log(convert(T,2))  #0.6931471805599453
@@ -501,15 +562,17 @@ function exp(z::Complex)
         end
     else
         er = exp(zr)
-        if zi == zero(zi)
+        if iszero(zi)
             Complex(er, zi)
         else
-            Complex(er*cos(zi), er*sin(zi))
+            s, c = sincos(zi)
+            Complex(er * c, er * s)
         end
     end
 end
 
-function expm1(z::Complex)
+function expm1(z::Complex{T}) where T<:Real
+    Tf = float(T)
     zr,zi = reim(z)
     if isnan(zr)
         Complex(zr, zi==0 ? zi : zr)
@@ -527,20 +590,25 @@ function expm1(z::Complex)
             Complex(erm1, zi)
         else
             er = erm1+one(erm1)
-            wr = isfinite(er) ? erm1 - 2.0*er*(sin(0.5*zi))^2 : er*cos(zi)
-            Complex(wr, er*sin(zi))
+            if isfinite(er)
+                wr = erm1 - 2 * er * (sin(convert(Tf, 0.5) * zi))^2
+                return Complex(wr, er * sin(zi))
+            else
+                s, c = sincos(zi)
+                return Complex(er * c, er * s)
+            end
         end
     end
 end
 
-function log1p{T}(z::Complex{T})
+function log1p(z::Complex{T}) where T
     zr,zi = reim(z)
     if isfinite(zr)
         isinf(zi) && return log(z)
         # This is based on a well-known trick for log1p of real z,
         # allegedly due to Kahan, only modified to handle real(u) <= 0
         # differently to avoid inaccuracy near z==-2 and for correct branch cut
-        u = float(one(T)) + z
+        u = one(float(T)) + z
         u == 1 ? convert(typeof(u), z) : real(u) <= 0 ? log(u) : log(u)*z/(u-1)
     elseif isnan(zr)
         Complex(zr, zr)
@@ -551,7 +619,7 @@ function log1p{T}(z::Complex{T})
     end
 end
 
-function ^{T<:AbstractFloat}(z::Complex{T}, p::Complex{T})::Complex{T}
+function ^(z::Complex{T}, p::Complex{T})::Complex{T} where T<:AbstractFloat
     if p == 2 #square
         zr, zi = reim(z)
         x = (zr-zi)*(zr+zi)
@@ -586,19 +654,23 @@ function ^{T<:AbstractFloat}(z::Complex{T}, p::Complex{T})::Complex{T}
     end
 end
 
-function exp2{T}(z::Complex{T})
+function exp2(z::Complex{T}) where T<:AbstractFloat
     er = exp2(real(z))
     theta = imag(z) * log(convert(T, 2))
-    Complex(er*cos(theta), er*sin(theta))
+    s, c = sincos(theta)
+    Complex(er * c, er * s)
 end
+exp2(z::Complex) = exp2(float(z))
 
-function exp10{T}(z::Complex{T})
+function exp10(z::Complex{T}) where T<:AbstractFloat
     er = exp10(real(z))
     theta = imag(z) * log(convert(T, 10))
-    Complex(er*cos(theta), er*sin(theta))
+    s, c = sincos(theta)
+    Complex(er * c, er * s)
 end
+exp10(z::Complex) = exp10(float(z))
 
-function ^{T<:Complex}(z::T, p::T)
+function ^(z::T, p::T) where T<:Complex
     if isinteger(p)
         rp = real(p)
         if rp < 0
@@ -617,8 +689,7 @@ function ^{T<:Complex}(z::T, p::T)
         rp = rp*exp(-pim*theta)
         ntheta = ntheta + pim*log(r)
     end
-    cosntheta = cos(ntheta)
-    sinntheta = sin(ntheta)
+    sinntheta, cosntheta = sincos(ntheta)
     re, im = rp*cosntheta, rp*sinntheta
     if isinf(rp)
         if isnan(re)
@@ -666,7 +737,7 @@ end
     n>=0 ? power_by_squaring(z,n) : power_by_squaring(inv(z),-n)
 ^(z::Complex{<:Integer}, n::Integer) = power_by_squaring(z,n) # DomainError for n<0
 
-function sin{T}(z::Complex{T})
+function sin(z::Complex{T}) where T
     F = float(T)
     zr, zi = reim(z)
     if zr == 0
@@ -678,12 +749,13 @@ function sin{T}(z::Complex{T})
             Complex(F(NaN), F(NaN))
         end
     else
-        Complex(sin(zr)*cosh(zi), cos(zr)*sinh(zi))
+        s, c = sincos(zr)
+        Complex(s * cosh(zi), c * sinh(zi))
     end
 end
 
 
-function cos{T}(z::Complex{T})
+function cos(z::Complex{T}) where T
     F = float(T)
     zr, zi = reim(z)
     if zr == 0
@@ -697,7 +769,8 @@ function cos{T}(z::Complex{T})
             Complex(F(NaN), F(NaN))
         end
     else
-        Complex(cos(zr)*cosh(zi), -sin(zr)*sinh(zi))
+        s, c = sincos(zr)
+        Complex(c * cosh(zi), -s * sinh(zi))
     end
 end
 
@@ -761,7 +834,7 @@ function cosh(z::Complex)
     cos(Complex(zi,-zr))
 end
 
-function tanh{T<:AbstractFloat}(z::Complex{T})
+function tanh(z::Complex{T}) where T<:AbstractFloat
     const Ω = prevfloat(typemax(T))
     ξ, η = reim(z)
     if isnan(ξ) && η==0 return Complex(ξ, η) end
@@ -806,7 +879,7 @@ function acosh(z::Complex)
     Complex(ξ, η)
 end
 
-function atanh{T<:AbstractFloat}(z::Complex{T})
+function atanh(z::Complex{T}) where T<:AbstractFloat
     const Ω = prevfloat(typemax(T))
     const θ = sqrt(Ω)/4
     const ρ = 1/θ
@@ -863,7 +936,7 @@ breaking ties using the specified [`RoundingMode`](@ref)s. The first
 [`RoundingMode`](@ref) is used for rounding the real components while the
 second is used for rounding the imaginary components.
 """
-function round{MR, MI}(z::Complex{<:AbstractFloat}, ::RoundingMode{MR}, ::RoundingMode{MI})
+function round(z::Complex{<:AbstractFloat}, ::RoundingMode{MR}, ::RoundingMode{MI}) where {MR,MI}
     Complex(round(real(z), RoundingMode{MR}()),
             round(imag(z), RoundingMode{MI}()))
 end
@@ -877,14 +950,14 @@ end
 float(z::Complex{<:AbstractFloat}) = z
 float(z::Complex) = Complex(float(real(z)), float(imag(z)))
 
-big(z::Complex{<:AbstractFloat}) = Complex{BigFloat}(z)
-big(z::Complex{<:Integer}) = Complex{BigInt}(z)
+big(::Type{Complex{T}}) where {T<:Real} = Complex{big(T)}
+big(z::Complex{T}) where {T<:Real} = Complex{big(T)}(z)
 
 ## Array operations on complex numbers ##
 
 complex(A::AbstractArray{<:Complex}) = A
 
-function complex{T}(A::AbstractArray{T})
+function complex(A::AbstractArray{T}) where T
     if !isconcrete(T)
         error("`complex` not defined on abstractly-typed arrays; please convert to a more specific type")
     end
diff --git a/base/coreimg.jl b/base/coreimg.jl
index 0d2ee886141c34..5739e8136084ff 100644
--- a/base/coreimg.jl
+++ b/base/coreimg.jl
@@ -1,17 +1,21 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 Main.Core.eval(Main.Core, :(baremodule Inference
 using Core.Intrinsics
 import Core: print, println, show, write, unsafe_write, STDOUT, STDERR
 
-ccall(:jl_set_istopmod, Void, (Bool,), false)
+ccall(:jl_set_istopmod, Void, (Any, Bool), Inference, false)
 
 eval(x) = Core.eval(Inference, x)
 eval(m, x) = Core.eval(m, x)
 
-const include = Core.include
+include(x) = Core.include(Inference, x)
+include(mod, x) = Core.include(mod, x)
+
 # conditional to allow redefining Core.Inference after base exists
-isdefined(Main, :Base) || ((::Type{T}){T}(arg) = convert(T, arg)::T)
+isdefined(Main, :Base) || ((::Type{T})(arg) where {T} = convert(T, arg)::T)
+
+function return_type end
 
 ## Load essential files and libraries
 include("essentials.jl")
diff --git a/base/coreio.jl b/base/coreio.jl
index 2035aae97abe90..b15fca1ea1003c 100644
--- a/base/coreio.jl
+++ b/base/coreio.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 show(x) = show(STDOUT::IO, x)
 print(xs...)   = print(STDOUT::IO, xs...)
@@ -12,6 +12,7 @@ iswritable(::DevNullStream) = true
 isopen(::DevNullStream) = true
 read(::DevNullStream, ::Type{UInt8}) = throw(EOFError())
 write(::DevNullStream, ::UInt8) = 1
+unsafe_write(::DevNullStream, ::Ptr{UInt8}, n::UInt)::Int = n
 close(::DevNullStream) = nothing
 flush(::DevNullStream) = nothing
 wait_connected(::DevNullStream) = nothing
diff --git a/base/ctypes.jl b/base/ctypes.jl
index 6dccd586459ca5..26640ed82bef50 100644
--- a/base/ctypes.jl
+++ b/base/ctypes.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # essential type definitions for interacting with C code
 # (platform- or OS-dependent types are defined in c.jl)
@@ -6,7 +6,7 @@
 """
     Cuchar
 
-Equivalent to the native `unsigned char` c-type (`UInt8`).
+Equivalent to the native `unsigned char` c-type ([`UInt8`](@ref)).
 """
 const Cuchar = UInt8
 
@@ -14,7 +14,7 @@ const Cuchar = UInt8
 """
     Cshort
 
-Equivalent to the native `signed short` c-type (`Int16`).
+Equivalent to the native `signed short` c-type ([`Int16`](@ref)).
 """
 const Cshort = Int16
 
@@ -22,7 +22,7 @@ const Cshort = Int16
 """
     Cushort
 
-Equivalent to the native `unsigned short` c-type (`UInt16`).
+Equivalent to the native `unsigned short` c-type ([`UInt16`](@ref)).
 """
 const Cushort = UInt16
 
@@ -30,7 +30,7 @@ const Cushort = UInt16
 """
     Cint
 
-Equivalent to the native `signed int` c-type (`Int32`).
+Equivalent to the native `signed int` c-type ([`Int32`](@ref)).
 """
 const Cint = Int32
 
@@ -38,7 +38,7 @@ const Cint = Int32
 """
     Cuint
 
-Equivalent to the native `unsigned int` c-type (`UInt32`).
+Equivalent to the native `unsigned int` c-type ([`UInt32`](@ref)).
 """
 const Cuint = UInt32
 
@@ -70,7 +70,7 @@ const Cssize_t = Int
 """
     Cintmax_t
 
-Equivalent to the native `intmax_t` c-type (`Int64`).
+Equivalent to the native `intmax_t` c-type ([`Int64`](@ref)).
 """
 const Cintmax_t = Int64
 
@@ -78,7 +78,7 @@ const Cintmax_t = Int64
 """
     Cuintmax_t
 
-Equivalent to the native `uintmax_t` c-type (`UInt64`).
+Equivalent to the native `uintmax_t` c-type ([`UInt64`](@ref)).
 """
 const Cuintmax_t = UInt64
 
@@ -86,7 +86,7 @@ const Cuintmax_t = UInt64
 """
     Clonglong
 
-Equivalent to the native `signed long long` c-type (`Int64`).
+Equivalent to the native `signed long long` c-type ([`Int64`](@ref)).
 """
 const Clonglong = Int64
 
@@ -94,7 +94,7 @@ const Clonglong = Int64
 """
     Culonglong
 
-Equivalent to the native `unsigned long long` c-type (`UInt64`).
+Equivalent to the native `unsigned long long` c-type ([`UInt64`](@ref)).
 """
 const Culonglong = UInt64
 
@@ -102,7 +102,7 @@ const Culonglong = UInt64
 """
     Cfloat
 
-Equivalent to the native `float` c-type (`Float32`).
+Equivalent to the native `float` c-type ([`Float32`](@ref)).
 """
 const Cfloat = Float32
 
@@ -110,6 +110,6 @@ const Cfloat = Float32
 """
     Cdouble
 
-Equivalent to the native `double` c-type (`Float64`).
+Equivalent to the native `double` c-type ([`Float64`](@ref)).
 """
 const Cdouble = Float64
diff --git a/base/dSFMT.jl b/base/dSFMT.jl
index bf58595fd4a2ba..11dbf0a079f4da 100644
--- a/base/dSFMT.jl
+++ b/base/dSFMT.jl
@@ -1,8 +1,8 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module dSFMT
 
-import Base: copy, copy!, ==
+import Base: copy, copy!, ==, hash
 
 export DSFMT_state, dsfmt_get_min_array_size, dsfmt_get_idstring,
        dsfmt_init_gen_rand, dsfmt_init_by_array, dsfmt_gv_init_by_array,
@@ -25,7 +25,7 @@ mutable struct DSFMT_state
     val::Vector{Int32}
 
     DSFMT_state(val::Vector{Int32} = zeros(Int32, JN32)) =
-        new(length(val) == JN32 ? val : throw(DomainError()))
+        new(length(val) == JN32 ? val : throw(DomainError(length(val), string("Expected length ", JN32, '.'))))
 end
 
 copy!(dst::DSFMT_state, src::DSFMT_state) = (copy!(dst.val, src.val); dst)
@@ -33,6 +33,8 @@ copy(src::DSFMT_state) = DSFMT_state(copy(src.val))
 
 ==(s1::DSFMT_state, s2::DSFMT_state) = s1.val == s2.val
 
+hash(s::DSFMT_state, h::UInt) = hash(s.val, h)
+
 function dsfmt_get_idstring()
     idstring = ccall((:dsfmt_get_idstring,:libdSFMT),
                      Ptr{UInt8},
@@ -89,9 +91,13 @@ end
 
 # dSFMT jump
 function dsfmt_jump(s::DSFMT_state, jp::AbstractString)
-    index = s.val[end-1]
-    work = zeros(UInt64, JN32>>1)
-    dsfmt = reinterpret(UInt64, copy(s.val))
+    val = s.val
+    nval = length(val)
+    index = val[nval - 1]
+    work = zeros(UInt64, JN32 >> 1)
+    dsfmt = Vector{UInt64}(nval >> 1)
+    ccall(:memcpy, Ptr{Void}, (Ptr{UInt64}, Ptr{Int32}, Csize_t),
+          dsfmt, val, (nval - 1) * sizeof(Int32))
     dsfmt[end] = UInt64(N*2)
 
     for c in jp
@@ -159,7 +165,7 @@ end
 
 ## Windows entropy
 
-if is_windows()
+if Sys.iswindows()
     function win32_SystemFunction036!(a::Array)
         ccall((:SystemFunction036, :Advapi32), stdcall, UInt8, (Ptr{Void}, UInt32), a, sizeof(a))
     end
diff --git a/base/datafmt.jl b/base/datafmt.jl
index 541ec089488d26..ea46841076efed 100644
--- a/base/datafmt.jl
+++ b/base/datafmt.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## file formats ##
 
@@ -27,7 +27,7 @@ passing them as the second argument.
 function countlines(io::IO, eol::Char='\n')
     isascii(eol) || throw(ArgumentError("only ASCII line terminators are supported"))
     aeol = UInt8(eol)
-    a = Array{UInt8}(8192)
+    a = Vector{UInt8}(8192)
     nl = 0
     while !eof(io)
         nb = readbytes!(io, a)
@@ -117,10 +117,10 @@ readdlm(input, dlm::Char, T::Type, eol::Char; opts...) =
 readdlm_auto(input::Vector{UInt8}, dlm::Char, T::Type, eol::Char, auto::Bool; opts...) =
     readdlm_string(String(input), dlm, T, eol, auto, val_opts(opts))
 readdlm_auto(input::IO, dlm::Char, T::Type, eol::Char, auto::Bool; opts...) =
-    readdlm_string(readstring(input), dlm, T, eol, auto, val_opts(opts))
+    readdlm_string(read(input, String), dlm, T, eol, auto, val_opts(opts))
 function readdlm_auto(input::AbstractString, dlm::Char, T::Type, eol::Char, auto::Bool; opts...)
     optsd = val_opts(opts)
-    use_mmap = get(optsd, :use_mmap, is_windows() ? false : true)
+    use_mmap = get(optsd, :use_mmap, Sys.iswindows() ? false : true)
     fsz = filesize(input)
     if use_mmap && fsz > 0 && fsz < typemax(Int)
         a = open(input, "r") do f
@@ -131,7 +131,7 @@ function readdlm_auto(input::AbstractString, dlm::Char, T::Type, eol::Char, auto
         # jl_try_substrtod to segfault below.
         return readdlm_string(unsafe_string(pointer(a),length(a)), dlm, T, eol, auto, optsd)
     else
-        return readdlm_string(readstring(input), dlm, T, eol, auto, optsd)
+        return readdlm_string(read(input, String), dlm, T, eol, auto, optsd)
     end
 end
 
@@ -150,8 +150,8 @@ mutable struct DLMOffsets <: DLMHandler
     bufflen::Int
 
     function DLMOffsets(sbuff::String)
-        offsets = Array{Array{Int,1}}(1)
-        offsets[1] = Array{Int}(offs_chunk_size)
+        offsets = Vector{Vector{Int}}(1)
+        offsets[1] = Vector{Int}(offs_chunk_size)
         thresh = ceil(min(typemax(UInt), Base.Sys.total_memory()) / sizeof(Int) / 5)
         new(offsets, 1, thresh, sizeof(sbuff))
     end
@@ -175,7 +175,7 @@ function store_cell(dlmoffsets::DLMOffsets, row::Int, col::Int,
                 return
             end
         end
-        offsets = Array{Int}(offs_chunk_size)
+        offsets = Vector{Int}(offs_chunk_size)
         push!(oarr, offsets)
         offidx = 1
     end
@@ -208,13 +208,13 @@ mutable struct DLMStore{T} <: DLMHandler
     eol::Char
 end
 
-function DLMStore{T}(::Type{T}, dims::NTuple{2,Integer},
-        has_header::Bool, sbuff::String, auto::Bool, eol::Char)
+function DLMStore(::Type{T}, dims::NTuple{2,Integer},
+                  has_header::Bool, sbuff::String, auto::Bool, eol::Char) where T
     (nrows,ncols) = dims
     nrows <= 0 && throw(ArgumentError("number of rows in dims must be > 0, got $nrows"))
     ncols <= 0 && throw(ArgumentError("number of columns in dims must be > 0, got $ncols"))
     hdr_offset = has_header ? 1 : 0
-    DLMStore{T}(fill(SubString(sbuff,1,0), 1, ncols), Array{T}(nrows-hdr_offset, ncols),
+    DLMStore{T}(fill(SubString(sbuff,1,0), 1, ncols), Matrix{T}(nrows-hdr_offset, ncols),
         nrows, ncols, 0, 0, hdr_offset, sbuff, auto, eol)
 end
 
@@ -222,14 +222,14 @@ _chrinstr(sbuff::String, chr::UInt8, startpos::Int, endpos::Int) =
     (endpos >= startpos) && (C_NULL != ccall(:memchr, Ptr{UInt8},
     (Ptr{UInt8}, Int32, Csize_t), pointer(sbuff)+startpos-1, chr, endpos-startpos+1))
 
-function store_cell{T}(dlmstore::DLMStore{T}, row::Int, col::Int,
-        quoted::Bool, startpos::Int, endpos::Int)
+function store_cell(dlmstore::DLMStore{T}, row::Int, col::Int,
+                    quoted::Bool, startpos::Int, endpos::Int) where T
     drow = row - dlmstore.hdr_offset
 
     ncols = dlmstore.ncols
     lastcol = dlmstore.lastcol
     lastrow = dlmstore.lastrow
-    cells::Array{T,2} = dlmstore.data
+    cells::Matrix{T} = dlmstore.data
     sbuff = dlmstore.sbuff
 
     endpos = prevind(sbuff, nextind(sbuff,endpos))
@@ -238,7 +238,7 @@ function store_cell{T}(dlmstore::DLMStore{T}, row::Int, col::Int,
     end
     if quoted
         startpos += 1
-        endpos -= 1
+        endpos = prevind(sbuff, endpos)
     end
 
     if drow > 0
@@ -263,7 +263,7 @@ function store_cell{T}(dlmstore::DLMStore{T}, row::Int, col::Int,
         # fill data
         if quoted && _chrinstr(sbuff, UInt8('"'), startpos, endpos)
             unescaped = replace(SubString(sbuff, startpos, endpos), r"\"\"", "\"")
-            fail = colval(unescaped, 1, length(unescaped), cells, drow, col)
+            fail = colval(unescaped, 1, endof(unescaped), cells, drow, col)
         else
             fail = colval(sbuff, startpos, endpos, cells, drow, col)
         end
@@ -282,7 +282,7 @@ function store_cell{T}(dlmstore::DLMStore{T}, row::Int, col::Int,
         # fill header
         if quoted && _chrinstr(sbuff, UInt8('"'), startpos, endpos)
             unescaped = replace(SubString(sbuff, startpos, endpos), r"\"\"", "\"")
-            colval(unescaped, 1, length(unescaped), dlmstore.hdr, 1, col)
+            colval(unescaped, 1, endof(unescaped), dlmstore.hdr, 1, col)
         else
             colval(sbuff, startpos, endpos, dlmstore.hdr, 1, col)
         end
@@ -291,7 +291,7 @@ function store_cell{T}(dlmstore::DLMStore{T}, row::Int, col::Int,
     nothing
 end
 
-function result{T}(dlmstore::DLMStore{T})
+function result(dlmstore::DLMStore{T}) where T
     nrows = dlmstore.nrows - dlmstore.hdr_offset
     ncols = dlmstore.ncols
     lastcol = dlmstore.lastcol
@@ -408,7 +408,7 @@ function colval(sbuff::String, startpos::Int, endpos::Int, cells::Array{Bool,2},
     isnull(n) || (cells[row, col] = get(n))
     isnull(n)
 end
-function colval{T<:Integer}(sbuff::String, startpos::Int, endpos::Int, cells::Array{T,2}, row::Int, col::Int)
+function colval(sbuff::String, startpos::Int, endpos::Int, cells::Array{T,2}, row::Int, col::Int) where T<:Integer
     n = tryparse_internal(T, sbuff, startpos, endpos, 0, false)
     isnull(n) || (cells[row, col] = get(n))
     isnull(n)
@@ -456,9 +456,9 @@ function colval(sbuff::String, startpos::Int, endpos::Int, cells::Array{<:Char,2
 end
 colval(sbuff::String, startpos::Int, endpos::Int, cells::Array, row::Int, col::Int) = true
 
-function dlm_parse{D}(dbuff::String, eol::D, dlm::D, qchar::D, cchar::D,
-                      ign_adj_dlm::Bool, allow_quote::Bool, allow_comments::Bool,
-                      skipstart::Int, skipblanks::Bool, dh::DLMHandler)
+function dlm_parse(dbuff::String, eol::D, dlm::D, qchar::D, cchar::D,
+                   ign_adj_dlm::Bool, allow_quote::Bool, allow_comments::Bool,
+                   skipstart::Int, skipblanks::Bool, dh::DLMHandler) where D
     ncols = nrows = col = 0
     is_default_dlm = (dlm == invalid_dlm(D))
     error_str = ""
@@ -620,7 +620,7 @@ readcsv(io, T::Type; opts...) = readdlm(io, ',', T; opts...)
 
 # todo: keyword argument for # of digits to print
 writedlm_cell(io::IO, elt::AbstractFloat, dlm, quotes) = print_shortest(io, elt)
-function writedlm_cell{T}(io::IO, elt::AbstractString, dlm::T, quotes::Bool)
+function writedlm_cell(io::IO, elt::AbstractString, dlm::T, quotes::Bool) where T
     if quotes && !isempty(elt) && (('"' in elt) || ('\n' in elt) || ((T <: Char) ? (dlm in elt) : contains(elt, dlm)))
         print(io, '"', replace(elt, r"\"", "\"\""), '"')
     else
diff --git a/base/dates/Dates.jl b/base/dates/Dates.jl
index 355ef1760b51e9..44ed2aefa79721 100644
--- a/base/dates/Dates.jl
+++ b/base/dates/Dates.jl
@@ -1,8 +1,38 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
+"""
+    Dates
+
+The `Dates` module provides `Date`, `DateTime`, `Time` types, and related functions.
+
+The types are not aware of time zones, based on UT seconds
+(86400 seconds a day, avoiding leap seconds), and
+use the proleptic Gregorian calendar, as specified in [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601).
+For time zone functionality, see the TimeZones.jl package.
+
+```jldoctest
+julia> dt = DateTime(2017,12,31,23,59,59,999)
+2017-12-31T23:59:59.999
+
+julia> d1 = Date(Dates.Month(12), Dates.Year(2017))
+2017-12-01
+
+julia> d2 = Date("2017-12-31", Dates.DateFormat("y-m-d"))
+2017-12-31
+
+julia> Dates.yearmonthday(d2)
+(2017, 12, 31)
+
+julia> d2-d1
+30 days
+```
+
+Please see the manual section on [`Date`](@ref) and [`DateTime`](@ref)
+for more information.
+"""
 module Dates
 
-importall ..Base.Operators
+import ..Base: ==, div, fld, mod, rem, gcd, lcm, +, -, *, /, %
 import ..Base.broadcast
 
 using Base.Iterators
@@ -48,6 +78,6 @@ export Period, DatePeriod, TimePeriod,
        firstdayofquarter, lastdayofquarter,
        adjust, tonext, toprev, tofirst, tolast,
        # io.jl
-       ISODateTimeFormat, ISODateFormat, DateFormat, RFC1123Format, @dateformat_str
+       ISODateTimeFormat, ISODateFormat, ISOTimeFormat, DateFormat, RFC1123Format, @dateformat_str
 
 end # module
diff --git a/base/dates/accessors.jl b/base/dates/accessors.jl
index 4022f4172beb37..bcc710220ac583 100644
--- a/base/dates/accessors.jl
+++ b/base/dates/accessors.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Convert # of Rata Die days to proleptic Gregorian calendar y,m,d,w
 # Reference: http://mysite.verizon.net/aesir_research/date/date0.htm
@@ -74,7 +74,7 @@ for func in (:year, :month)
         @doc """
             $($name)(dt::TimeType) -> Int64
 
-        The $($name) of a `Date` or `DateTime` as an `Int64`.
+        The $($name) of a `Date` or `DateTime` as an [`Int64`](@ref).
         """ $func(dt::TimeType)
     end
 end
@@ -83,9 +83,22 @@ end
     week(dt::TimeType) -> Int64
 
 Return the [ISO week date](https://en.wikipedia.org/wiki/ISO_week_date) of a `Date` or
-`DateTime` as an `Int64`. Note that the first week of a year is the week that contains the
-first Thursday of the year which can result in dates prior to January 4th being in the last
-week of the previous year. For example `week(Date(2005,1,1))` is the 53rd week of 2004.
+`DateTime` as an [`Int64`](@ref). Note that the first week of a year is the week that
+contains the first Thursday of the year, which can result in dates prior to January 4th
+being in the last week of the previous year. For example, `week(Date(2005, 1, 1))` is the 53rd
+week of 2004.
+
+# Examples
+```jldoctest
+julia> Dates.week(Date(1989, 6, 22))
+25
+
+julia> Dates.week(Date(2005, 1, 1))
+53
+
+julia> Dates.week(Date(2004, 12, 31))
+53
+```
 """
 week(dt::TimeType)
 
@@ -95,7 +108,7 @@ for func in (:day, :dayofmonth)
         @doc """
             $($name)(dt::TimeType) -> Int64
 
-        The day of month of a `Date` or `DateTime` as an `Int64`.
+        The day of month of a `Date` or `DateTime` as an [`Int64`](@ref).
         """ $func(dt::TimeType)
     end
 end
@@ -103,7 +116,7 @@ end
 """
     hour(dt::DateTime) -> Int64
 
-The hour of day of a `DateTime` as an `Int64`.
+The hour of day of a `DateTime` as an [`Int64`](@ref).
 """
 hour(dt::DateTime)
 
@@ -113,7 +126,7 @@ for func in (:minute, :second, :millisecond)
         @doc """
             $($name)(dt::DateTime) -> Int64
 
-        The $($name) of a `DateTime` as an `Int64`.
+        The $($name) of a `DateTime` as an [`Int64`](@ref).
         """ $func(dt::DateTime)
     end
 end
@@ -137,7 +150,7 @@ for func in (:hour, :minute, :second, :millisecond, :microsecond, :nanosecond)
         @doc """
             $($name)(t::Time) -> Int64
 
-        The $($name) of a `Time` as an `Int64`.
+        The $($name) of a `Time` as an [`Int64`](@ref).
         """ $func(t::Time)
     end
 end
diff --git a/base/dates/adjusters.jl b/base/dates/adjusters.jl
index eebc68b59b5ad3..44c66ac6959940 100644
--- a/base/dates/adjusters.jl
+++ b/base/dates/adjusters.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ### truncation
 Base.trunc(dt::Date, p::Type{Year}) = Date(UTD(totaldays(year(dt), 1, 1)))
@@ -23,8 +23,13 @@ Base.trunc(t::Time, p::Type{Nanosecond})  = t
 """
     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`.
+Truncates the value of `dt` according to the provided `Period` type.
+
+# Examples
+```jldoctest
+julia> trunc(Dates.DateTime("1996-01-01T12:30:00"), Dates.Day)
+1996-01-01T00:00:00
+```
 """
 Dates.trunc(::Dates.TimeType, ::Type{Dates.Period})
 
@@ -33,6 +38,12 @@ Dates.trunc(::Dates.TimeType, ::Type{Dates.Period})
     firstdayofweek(dt::TimeType) -> TimeType
 
 Adjusts `dt` to the Monday of its week.
+
+# Examples
+```jldoctest
+julia> Dates.firstdayofweek(DateTime("1996-01-05T12:30:00"))
+1996-01-01T00:00:00
+```
 """
 function firstdayofweek end
 
@@ -43,6 +54,12 @@ firstdayofweek(dt::DateTime) = DateTime(firstdayofweek(Date(dt)))
     lastdayofweek(dt::TimeType) -> TimeType
 
 Adjusts `dt` to the Sunday of its week.
+
+# Examples
+```jldoctest
+julia> Dates.lastdayofweek(DateTime("1996-01-05T12:30:00"))
+1996-01-07T00:00:00
+```
 """
 function lastdayofweek end
 
@@ -53,6 +70,12 @@ lastdayofweek(dt::DateTime) = DateTime(lastdayofweek(Date(dt)))
     firstdayofmonth(dt::TimeType) -> TimeType
 
 Adjusts `dt` to the first day of its month.
+
+# Examples
+```jldoctest
+julia> Dates.firstdayofmonth(DateTime("1996-05-20"))
+1996-05-01T00:00:00
+```
 """
 function firstdayofmonth end
 
@@ -63,6 +86,12 @@ firstdayofmonth(dt::DateTime) = DateTime(firstdayofmonth(Date(dt)))
     lastdayofmonth(dt::TimeType) -> TimeType
 
 Adjusts `dt` to the last day of its month.
+
+# Examples
+```jldoctest
+julia> Dates.lastdayofmonth(DateTime("1996-05-20"))
+1996-05-31T00:00:00
+```
 """
 function lastdayofmonth end
 
@@ -76,6 +105,12 @@ lastdayofmonth(dt::DateTime) = DateTime(lastdayofmonth(Date(dt)))
     firstdayofyear(dt::TimeType) -> TimeType
 
 Adjusts `dt` to the first day of its year.
+
+# Examples
+```jldoctest
+julia> Dates.firstdayofyear(DateTime("1996-05-20"))
+1996-01-01T00:00:00
+```
 """
 function firstdayofyear end
 
@@ -86,6 +121,12 @@ firstdayofyear(dt::DateTime) = DateTime(firstdayofyear(Date(dt)))
     lastdayofyear(dt::TimeType) -> TimeType
 
 Adjusts `dt` to the last day of its year.
+
+# Examples
+```jldoctest
+julia> Dates.lastdayofyear(DateTime("1996-05-20"))
+1996-12-31T00:00:00
+```
 """
 function lastdayofyear end
 
@@ -99,6 +140,15 @@ lastdayofyear(dt::DateTime) = DateTime(lastdayofyear(Date(dt)))
     firstdayofquarter(dt::TimeType) -> TimeType
 
 Adjusts `dt` to the first day of its quarter.
+
+# Examples
+```jldoctest
+julia> Dates.firstdayofquarter(DateTime("1996-05-20"))
+1996-04-01T00:00:00
+
+julia> Dates.firstdayofquarter(DateTime("1996-08-20"))
+1996-07-01T00:00:00
+```
 """
 function firstdayofquarter end
 
@@ -113,6 +163,15 @@ firstdayofquarter(dt::DateTime) = DateTime(firstdayofquarter(Date(dt)))
     lastdayofquarter(dt::TimeType) -> TimeType
 
 Adjusts `dt` to the last day of its quarter.
+
+# Examples
+```jldoctest
+julia> Dates.lastdayofquarter(DateTime("1996-05-20"))
+1996-06-30T00:00:00
+
+julia> Dates.lastdayofquarter(DateTime("1996-08-20"))
+1996-09-30T00:00:00
+```
 """
 function lastdayofquarter end
 
@@ -127,7 +186,7 @@ lastdayofquarter(dt::DateTime) = DateTime(lastdayofquarter(Date(dt)))
 struct DateFunction
     f::Function
     # validate boolean, single-arg inner constructor
-    function DateFunction(f::ANY, dt::TimeType)
+    function DateFunction(@nospecialize(f), dt::TimeType)
         isa(f(dt), Bool) || throw(ArgumentError("Provided function must take a single TimeType argument and return true or false"))
         return new(f)
     end
@@ -158,6 +217,20 @@ provided `y, m, d` arguments, and will be adjusted until `f::Function` returns `
 The step size in adjusting can be provided manually through the `step` keyword.
 `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).
+
+# Examples
+```jldoctest
+julia> Date(date -> Dates.week(date) == 20, 2010, 01, 01)
+2010-05-17
+
+julia> Date(date -> Dates.year(date) == 2010, 2000, 01, 01)
+2010-01-01
+
+julia> Date(date -> Dates.month(date) == 10, 2000, 01, 01; limit = 5)
+ERROR: ArgumentError: Adjustment limit reached: 5 iterations
+Stacktrace:
+[...]
+```
 """
 function Date(func::Function, y, m=1, d=1; step::Period=Day(1), negate=nothing, limit::Int=10000)
     func = deprecate_negate(:Date, func, "func,y,m,d", negate)
@@ -172,6 +245,17 @@ the provided `y, m, d...` arguments, and will be adjusted until `f::Function` re
 `true`. The step size in adjusting can be provided manually through the `step` keyword.
 `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).
+
+# Examples
+```jldoctest
+julia> DateTime(dt -> Dates.second(dt) == 40, 2010, 10, 20, 10; step = Dates.Second(1))
+2010-10-20T10:00:40
+
+julia> DateTime(dt -> Dates.hour(dt) == 20, 2010, 10, 20, 10; step = Dates.Hour(1), limit = 5)
+ERROR: ArgumentError: Adjustment limit reached: 5 iterations
+Stacktrace:
+[...]
+```
 """
 DateTime(::Function, args...)
 
@@ -209,6 +293,20 @@ provides a limit to the max number of iterations the adjustment API will pursue
 throwing an error (in the case that `f::Function` is never satisfied). Note that the default step
 will adjust to allow for greater precision for the given arguments; i.e. if hour, minute, and second
 arguments are provided, the default step will be `Millisecond(1)` instead of `Second(1)`.
+
+# Examples
+```jldoctest
+julia> Dates.Time(t -> Dates.minute(t) == 30, 20)
+20:30:00
+
+julia> Dates.Time(t -> Dates.minute(t) == 0, 20)
+20:00:00
+
+julia> Dates.Time(t -> Dates.hour(t) == 10, 3; limit = 5)
+ERROR: ArgumentError: Adjustment limit reached: 5 iterations
+Stacktrace:
+[...]
+```
 """
 Time(::Function, args...)
 
@@ -253,8 +351,8 @@ tonext(dt::TimeType, dow::Int; same::Bool=false) = adjust(ISDAYOFWEEK[dow], same
     tonext(func::Function, dt::TimeType; step=Day(1), 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`.
+returns `true`. `func` must take a single `TimeType` argument and return a [`Bool`](@ref).
+`same` allows `dt` to be considered in satisfying `func`.
 """
 function tonext(func::Function, dt::TimeType; step::Period=Day(1), negate=nothing, limit::Int=10000, same::Bool=false)
     func = deprecate_negate(:tonext, func, "func,dt", negate)
@@ -274,8 +372,8 @@ toprev(dt::TimeType, dow::Int; same::Bool=false) = adjust(ISDAYOFWEEK[dow], same
     toprev(func::Function, dt::TimeType; step=Day(-1), 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`.
+returns `true`. `func` must take a single `TimeType` argument and return a [`Bool`](@ref).
+`same` allows `dt` to be considered in satisfying `func`.
 """
 function toprev(func::Function, dt::TimeType; step::Period=Day(-1), negate=nothing, limit::Int=10000, same::Bool=false)
     func = deprecate_negate(:toprev, func, "func,dt", negate)
diff --git a/base/dates/arithmetic.jl b/base/dates/arithmetic.jl
index ac59b4971e3ab8..93d22c5f721195 100644
--- a/base/dates/arithmetic.jl
+++ b/base/dates/arithmetic.jl
@@ -1,12 +1,12 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Instant arithmetic
 (+)(x::Instant) = x
-(-){T<:Instant}(x::T, y::T) = x.periods - y.periods
+(-)(x::T, y::T) where {T<:Instant} = x.periods - y.periods
 
 # TimeType arithmetic
 (+)(x::TimeType) = x
-(-){T<:TimeType}(x::T, y::T) = x.instant - y.instant
+(-)(x::T, y::T) where {T<:TimeType} = x.instant - y.instant
 
 # Date-Time arithmetic
 """
@@ -17,7 +17,7 @@ the `Time` are used along with the year, month, and day of the `Date` to create
 Non-zero microseconds or nanoseconds in the `Time` type will result in an `InexactError` being thrown.
 """
 function (+)(dt::Date, t::Time)
-    (microsecond(t) > 0 || nanosecond(t) > 0) && throw(InexactError())
+    (microsecond(t) > 0 || nanosecond(t) > 0) && throw(InexactError(:+, DateTime, t))
     y, m, d = yearmonthday(dt)
     return DateTime(y, m, d, hour(t), minute(t), second(t), millisecond(t))
 end
@@ -90,9 +90,9 @@ end
 (-)(x::StridedArray{<:GeneralPeriod}, y::TimeType) = x .- y
 
 # TimeType, AbstractArray{TimeType}
-(-){T<:TimeType}(x::AbstractArray{T}, y::T) = x .- y
-(-){T<:TimeType}(y::T, x::AbstractArray{T}) = y .- x
+(-)(x::AbstractArray{T}, y::T) where {T<:TimeType} = x .- y
+(-)(y::T, x::AbstractArray{T}) where {T<:TimeType} = y .- x
 
 # AbstractArray{TimeType}, AbstractArray{TimeType}
-(-){T<:TimeType}(x::OrdinalRange{T}, y::OrdinalRange{T}) = collect(x) - collect(y)
-(-){T<:TimeType}(x::Range{T}, y::Range{T}) = collect(x) - collect(y)
+(-)(x::OrdinalRange{T}, y::OrdinalRange{T}) where {T<:TimeType} = collect(x) - collect(y)
+(-)(x::Range{T}, y::Range{T}) where {T<:TimeType} = collect(x) - collect(y)
diff --git a/base/dates/conversions.jl b/base/dates/conversions.jl
index b406d1d47b78c9..853f20b01cc771 100644
--- a/base/dates/conversions.jl
+++ b/base/dates/conversions.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Conversion/Promotion
 
@@ -53,7 +53,7 @@ end
     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`.
+since the unix epoch `1970-01-01T00:00:00` as a [`Float64`](@ref).
 """
 datetime2unix(dt::DateTime) = (value(dt) - UNIXEPOCH) / 1000.0
 
@@ -116,6 +116,6 @@ end
     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`.
+epoch `-4713-11-24T12:00:00` as a [`Float64`](@ref).
 """
 datetime2julian(dt::DateTime) = (value(dt) - JULIANEPOCH) / 86400000.0
diff --git a/base/dates/io.jl b/base/dates/io.jl
index 778e7e99641bca..2005b941effab7 100644
--- a/base/dates/io.jl
+++ b/base/dates/io.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 """
     AbstractDateToken
@@ -74,13 +74,13 @@ end
 @inline min_width(d::DatePart) = d.fixed ? d.width : 1
 @inline max_width(d::DatePart) = d.fixed ? d.width : 0
 
-function _show_content{c}(io::IO, d::DatePart{c})
+function _show_content(io::IO, d::DatePart{c}) where c
     for i = 1:d.width
         write(io, c)
     end
 end
 
-function Base.show{c}(io::IO, d::DatePart{c})
+function Base.show(io::IO, d::DatePart{c}) where c
     write(io, "DatePart(")
     _show_content(io, d)
     write(io, ")")
@@ -108,10 +108,21 @@ for (tok, fn) in zip("uUeE", [monthabbr_to_value, monthname_to_value, dayabbr_to
     end
 end
 
+# 3-digit (base 10) number following a decimal point. For InexactError below.
+struct Decimal3 end
+
 @inline function tryparsenext(d::DatePart{'s'}, str, i, len)
     ms, ii = tryparsenext_base10(str, i, len, min_width(d), max_width(d))
     if !isnull(ms)
-        ms = Nullable{Int64}(get(ms) * 10 ^ (3 - (ii - i)))
+        val0 = val = get(ms)
+        len = ii - i
+        if len > 3
+            val, r = divrem(val, Int64(10) ^ (len - 3))
+            r == 0 || throw(InexactError(:convert, Decimal3, val0))
+        else
+            val *= Int64(10) ^ (3 - len)
+        end
+        ms = Nullable{Int64}(val)
     end
     return ms, ii
 end
@@ -154,15 +165,15 @@ end
 
 function format(io, d::DatePart{'s'}, dt)
     ms = millisecond(dt)
-    if ms == 0
-        write(io, '0')
-    elseif ms % 100 == 0
-        write(io, dec(div(ms, 100), 1))
+    if ms % 100 == 0
+        str = dec(div(ms, 100), 1)
     elseif ms % 10 == 0
-        write(io, dec(div(ms, 10), 2))
+        str = dec(div(ms, 10), 2)
     else
-        write(io, dec(ms, 3))
+        str = dec(ms, 3)
     end
+
+    write(io, rpad(str, d.width, '0'))
 end
 
 ### Delimiters
@@ -174,18 +185,18 @@ end
 Delim(d::Char) = Delim{Char, 1}(d)
 Delim(d::String) = Delim{String, length(d)}(d)
 
-@inline function tryparsenext{N}(d::Delim{Char, N}, str, i::Int, len)
-    R = Nullable{Int64}
+@inline function tryparsenext(d::Delim{Char, N}, str, i::Int, len) where N
+    R = Nullable{Bool}
     for j=1:N
         i > len && return (R(), i)
         c, i = next(str, i)
         c != d.d && return (R(), i)
     end
-    return R(0), i
+    return R(true), i
 end
 
-@inline function tryparsenext{N}(d::Delim{String, N}, str, i::Int, len)
-    R = Nullable{Int64}
+@inline function tryparsenext(d::Delim{String, N}, str, i::Int, len) where N
+    R = Nullable{Bool}
     i1 = i
     i2 = start(d.d)
     for j = 1:N
@@ -198,15 +209,15 @@ end
             return R(), i1
         end
     end
-    return R(0), i1
+    return R(true), i1
 end
 
 @inline function format(io, d::Delim, dt, locale)
     write(io, d.d)
 end
 
-function _show_content{N}(io::IO, d::Delim{Char, N})
-    if d.d in keys(SLOT_RULE)
+function _show_content(io::IO, d::Delim{Char, N}) where N
+    if d.d in keys(CONVERSION_SPECIFIERS)
         for i = 1:N
             write(io, '\\', d.d)
         end
@@ -219,7 +230,7 @@ end
 
 function _show_content(io::IO, d::Delim)
     for c in d.d
-        if c in keys(SLOT_RULE)
+        if c in keys(CONVERSION_SPECIFIERS)
             write(io, '\\')
         end
         write(io, c)
@@ -236,8 +247,9 @@ end
 
 abstract type DayOfWeekToken end # special addition to Period types
 
-# mapping format specifiers to period types
-const SLOT_RULE = Dict{Char, Type}(
+# Map conversion specifiers or character codes to tokens.
+# Note: Allow addition of new character codes added by packages
+const CONVERSION_SPECIFIERS = Dict{Char, Type}(
     'y' => Year,
     'Y' => Year,
     'm' => Month,
@@ -252,13 +264,29 @@ const SLOT_RULE = Dict{Char, Type}(
     's' => Millisecond,
 )
 
-slot_order(::Type{Date}) = (Year, Month, Day)
-slot_order(::Type{DateTime}) = (Year, Month, Day, Hour, Minute, Second, Millisecond)
-
-slot_defaults(::Type{Date}) = map(Int64, (1, 1, 1))
-slot_defaults(::Type{DateTime}) = map(Int64, (1, 1, 1, 0, 0, 0, 0))
+# Default values are needed when a conversion specifier is used in a DateFormat for parsing
+# and we have reached the end of the input string.
+# Note: Allow `Any` value as a default to support extensibility
+const CONVERSION_DEFAULTS = Dict{Type, Any}(
+    Year => Int64(1),
+    Month => Int64(1),
+    DayOfWeekToken => Int64(0),
+    Day => Int64(1),
+    Hour => Int64(0),
+    Minute => Int64(0),
+    Second => Int64(0),
+    Millisecond => Int64(0),
+    Microsecond => Int64(0),
+    Nanosecond => Int64(0),
+)
 
-slot_types{T<:TimeType}(::Type{T}) = typeof(slot_defaults(T))
+# Specifies the required fields in order to parse a TimeType
+# Note: Allows for addition of new TimeTypes
+const CONVERSION_TRANSLATIONS = Dict{Type{<:TimeType}, Tuple}(
+    Date => (Year, Month, Day),
+    DateTime => (Year, Month, Day, Hour, Minute, Second, Millisecond),
+    Time => (Hour, Minute, Second, Millisecond, Microsecond, Nanosecond),
+)
 
 """
     DateFormat(format::AbstractString, locale="english") -> DateFormat
@@ -300,13 +328,13 @@ function DateFormat(f::AbstractString, locale::DateLocale=ENGLISH)
     prev = ()
     prev_offset = 1
 
-    letters = String(collect(keys(Base.Dates.SLOT_RULE)))
+    letters = String(collect(keys(CONVERSION_SPECIFIERS)))
     for m in eachmatch(Regex("(?<!\\\\)([\\Q$letters\\E])\\1*"), f)
         tran = replace(f[prev_offset:m.offset - 1], r"\\(.)", s"\1")
 
         if !isempty(prev)
             letter, width = prev
-            typ = SLOT_RULE[letter]
+            typ = CONVERSION_SPECIFIERS[letter]
 
             push!(tokens, DatePart{letter}(width, isempty(tran)))
         end
@@ -326,7 +354,7 @@ function DateFormat(f::AbstractString, locale::DateLocale=ENGLISH)
 
     if !isempty(prev)
         letter, width = prev
-        typ = SLOT_RULE[letter]
+        typ = CONVERSION_SPECIFIERS[letter]
 
         push!(tokens, DatePart{letter}(width, false))
     end
@@ -366,51 +394,86 @@ end
 # Standard formats
 const ISODateTimeFormat = DateFormat("yyyy-mm-dd\\THH:MM:SS.s")
 const ISODateFormat = DateFormat("yyyy-mm-dd")
+const ISOTimeFormat = DateFormat("HH:MM:SS.s")
 const RFC1123Format = DateFormat("e, dd u yyyy HH:MM:SS")
 
+default_format(::Type{DateTime}) = ISODateTimeFormat
+default_format(::Type{Date}) = ISODateFormat
+default_format(::Type{Time}) = ISOTimeFormat
+
 ### API
+
+const Locale = Union{DateLocale, String}
+
 """
     DateTime(dt::AbstractString, format::AbstractString; locale="english") -> DateTime
 
-Construct a `DateTime` by parsing the `dt` date string following the pattern given in
-the `format` string.
+Construct a `DateTime` by parsing the `dt` date time string following the
+pattern given in the `format` string.
 
-This method creates a `DateFormat` object each time it is called. If you are parsing many
-date strings of the same format, consider creating a [`DateFormat`](@ref) object once and using
-that as the second argument instead.
+This method creates a `DateFormat` object each time it is called. If you are
+parsing many date time strings of the same format, consider creating a
+[`DateFormat`](@ref) object once and using that as the second argument instead.
 """
-DateTime(dt::AbstractString, format::AbstractString;
-    locale::Union{DateLocale, String}=ENGLISH) = parse(DateTime, dt, DateFormat(format, locale))
+function DateTime(dt::AbstractString, format::AbstractString; locale::Locale=ENGLISH)
+    parse(DateTime, dt, DateFormat(format, locale))
+end
 
 """
     DateTime(dt::AbstractString, df::DateFormat) -> DateTime
 
-Construct a `DateTime` by parsing the `dt` date string following the pattern given in
-the [`DateFormat`](@ref) object. Similar to
-`DateTime(::AbstractString, ::AbstractString)` but more efficient when repeatedly parsing
-similarly formatted date strings with a pre-created `DateFormat` object.
+Construct a `DateTime` by parsing the `dt` date time string following the
+pattern given in the [`DateFormat`](@ref) object. Similar to
+`DateTime(::AbstractString, ::AbstractString)` but more efficient when
+repeatedly parsing similarly formatted date time strings with a pre-created
+`DateFormat` object.
 """
 DateTime(dt::AbstractString, df::DateFormat=ISODateTimeFormat) = parse(DateTime, dt, df)
 
 """
-    Date(dt::AbstractString, format::AbstractString; locale="english") -> Date
+    Date(d::AbstractString, format::AbstractString; locale="english") -> Date
 
-Construct a `Date` object by parsing a `dt` date string following the pattern given in the
-`format` string. Follows the same conventions as
-`DateTime(::AbstractString, ::AbstractString)`.
+Construct a `Date` by parsing the `d` date string following the pattern given
+in the `format` string.
+
+This method creates a `DateFormat` object each time it is called. If you are
+parsing many date strings of the same format, consider creating a
+[`DateFormat`](@ref) object once and using that as the second argument instead.
 """
-Date(dt::AbstractString, format::AbstractString;
-    locale::Union{DateLocale, String}=ENGLISH) = parse(Date, dt, DateFormat(format, locale))
+function Date(d::AbstractString, format::AbstractString; locale::Locale=ENGLISH)
+    parse(Date, d, DateFormat(format, locale))
+end
 
 """
-    Date(dt::AbstractString, df::DateFormat) -> Date
+    Date(d::AbstractString, df::DateFormat) -> Date
 
-Parse a date from a date string `dt` using a `DateFormat` object `df`.
+Parse a date from a date string `d` using a `DateFormat` object `df`.
 """
-Date(dt::AbstractString,df::DateFormat=ISODateFormat) = parse(Date, dt, df)
+Date(d::AbstractString, df::DateFormat=ISODateFormat) = parse(Date, d, df)
 
-@generated function format{S, T}(io::IO, dt::TimeType, fmt::DateFormat{S, T})
-    N = nfields(T)
+"""
+    Time(t::AbstractString, format::AbstractString; locale="english") -> Time
+
+Construct a `Time` by parsing the `t` time string following the pattern given
+in the `format` string.
+
+This method creates a `DateFormat` object each time it is called. If you are
+parsing many time strings of the same format, consider creating a
+[`DateFormat`](@ref) object once and using that as the second argument instead.
+"""
+function Time(t::AbstractString, format::AbstractString; locale::Locale=ENGLISH)
+    parse(Time, t, DateFormat(format, locale))
+end
+
+"""
+    Time(t::AbstractString, df::DateFormat) -> Time
+
+Parse a time from a time string `t` using a `DateFormat` object `df`.
+"""
+Time(t::AbstractString, df::DateFormat=ISOTimeFormat) = parse(Time, t, df)
+
+@generated function format(io::IO, dt::TimeType, fmt::DateFormat{<:Any,T}) where T
+    N = fieldcount(T)
     quote
         ts = fmt.tokens
         loc = fmt.locale
@@ -459,8 +522,9 @@ generate the string "1996-01-15T00:00:00" you could use `format`: "yyyy-mm-ddTHH
 Note that if you need to use a code character as a literal you can use the escape character
 backslash. The string "1996y01m" can be produced with the format "yyyy\\ymm\\m".
 """
-format(dt::TimeType, f::AbstractString;
-    locale::Union{DateLocale, String}=ENGLISH) = format(dt, DateFormat(f, locale))
+function format(dt::TimeType, f::AbstractString; locale::Locale=ENGLISH)
+    format(dt, DateFormat(f, locale))
+end
 
 # show
 
@@ -495,22 +559,22 @@ function Base.string(dt::Date)
 end
 
 # vectorized
-DateTime(Y::AbstractArray{<:AbstractString}, format::AbstractString;
-    locale::Union{DateLocale, String}=ENGLISH) = DateTime(Y, DateFormat(format, locale))
+function DateTime(Y::AbstractArray{<:AbstractString}, f::AbstractString; locale::Locale=ENGLISH)
+    DateTime(Y, DateFormat(f, locale))
+end
 function DateTime(Y::AbstractArray{<:AbstractString}, df::DateFormat=ISODateTimeFormat)
     return reshape(DateTime[parse(DateTime, y, df) for y in Y], size(Y))
 end
-Date(Y::AbstractArray{<:AbstractString}, format::AbstractString;
-    locale::Union{DateLocale, String}=ENGLISH) = Date(Y, DateFormat(format, locale))
+function Date(Y::AbstractArray{<:AbstractString}, f::AbstractString; locale::Locale=ENGLISH)
+    Date(Y, DateFormat(f, locale))
+end
 function Date(Y::AbstractArray{<:AbstractString}, df::DateFormat=ISODateFormat)
     return reshape(Date[Date(parse(Date, y, df)) for y in Y], size(Y))
 end
 
-format(Y::AbstractArray{<:TimeType}, fmt::AbstractString;
-    locale::Union{DateLocale, String}=ENGLISH) = format(Y, DateFormat(fmt, locale))
-function format(Y::AbstractArray{Date}, df::DateFormat=ISODateFormat)
-    return reshape([format(y, df) for y in Y], size(Y))
+function format(Y::AbstractArray{<:TimeType}, f::AbstractString; locale::Locale=ENGLISH)
+    format(Y, DateFormat(f, locale))
 end
-function format(Y::AbstractArray{DateTime}, df::DateFormat=ISODateTimeFormat)
+function format(Y::AbstractArray{T}, df::DateFormat=default_format(T)) where T<:TimeType
     return reshape([format(y, df) for y in Y], size(Y))
 end
diff --git a/base/dates/parse.jl b/base/dates/parse.jl
index e638319f10b09f..07a04ac2257d6c 100644
--- a/base/dates/parse.jl
+++ b/base/dates/parse.jl
@@ -1,97 +1,161 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
 ### Parsing utilities
 
-@generated function tryparse_internal{T<:TimeType, S, F}(::Type{T}, str::AbstractString, df::DateFormat{S, F}, raise::Bool=false)
-    token_types = Type[dp <: DatePart ? SLOT_RULE[first(dp.parameters)] : Void for dp in F.parameters]
-    N = length(F.parameters)
+_directives(::Type{DateFormat{S,T}}) where {S,T} = T.parameters
 
-    types = slot_order(T)
-    num_types = length(types)
-    order = Vector{Int}(num_types)
-    for i = 1:num_types
-        order[i] = findfirst(token_types, types[i])
+character_codes(df::Type{DateFormat{S,T}}) where {S,T} = character_codes(_directives(df))
+function character_codes(directives::SimpleVector)
+    letters = sizehint!(Char[], length(directives))
+    for (i, directive) in enumerate(directives)
+        if directive <: DatePart
+            letter = first(directive.parameters)
+            push!(letters, letter)
+        end
     end
+    return letters
+end
 
-    field_defaults = slot_defaults(T)
-    field_order = tuple(order...)
-    tuple_type = slot_types(T)
-
-    # `slot_order`, `slot_defaults`, and `slot_types` return tuples of the same length
-    assert(num_types == length(field_order) == length(field_defaults))
+genvar(t::DataType) = Symbol(lowercase(string(Base.datatype_name(t))))
+
+"""
+    tryparsenext_core(str::AbstractString, pos::Int, len::Int, df::DateFormat, raise=false)
+
+Parses the string according to the directives within the DateFormat. Parsing will start at
+character index `pos` and will stop when all directives are used or we have parsed up to
+the end of the string, `len`. When a directive cannot be parsed the returned value tuple
+will be null if `raise` is false otherwise an exception will be thrown.
+
+Returns a 3-element tuple `(values, pos, num_parsed)`:
+* `values::Nullable{Tuple}`: A tuple which contains a value for each `DatePart` within the
+  `DateFormat` in the order in which they occur. If the string ends before we finish parsing
+  all the directives the missing values will be filled in with default values.
+* `pos::Int`: The character index at which parsing stopped.
+* `num_parsed::Int`: The number of values which were parsed and stored within `values`.
+  Useful for distinguishing parsed values from default values.
+"""
+@generated function tryparsenext_core(str::AbstractString, pos::Int, len::Int,
+                                      df::DateFormat, raise::Bool=false)
+    directives = _directives(df)
+    letters = character_codes(directives)
+
+    tokens = Type[CONVERSION_SPECIFIERS[letter] for letter in letters]
+    value_names = Symbol[genvar(t) for t in tokens]
+    value_defaults = Tuple(CONVERSION_DEFAULTS[t] for t in tokens)
+    R = typeof(value_defaults)
+
+    # Pre-assign variables to defaults. Allows us to use `@goto done` without worrying about
+    # unassigned variables.
+    assign_defaults = Expr[
+        quote
+            $name = $default
+        end
+        for (name, default) in zip(value_names, value_defaults)
+    ]
+
+    vi = 1
+    parsers = Expr[
+        begin
+            if directives[i] <: DatePart
+                name = value_names[vi]
+                nullable = Symbol(:nullable_, name)
+                vi += 1
+                quote
+                    pos > len && @goto done
+                    $nullable, next_pos = tryparsenext(directives[$i], str, pos, len, locale)
+                    isnull($nullable) && @goto error
+                    $name = unsafe_get($nullable)
+                    pos = next_pos
+                    num_parsed += 1
+                    directive_index += 1
+                end
+            else
+                quote
+                    pos > len && @goto done
+                    nullable_delim, next_pos = tryparsenext(directives[$i], str, pos, len, locale)
+                    isnull(nullable_delim) && @goto error
+                    pos = next_pos
+                    directive_index += 1
+                end
+            end
+        end
+        for i in 1:length(directives)
+    ]
 
     quote
-        R = Nullable{$tuple_type}
-        t = df.tokens
-        l = df.locale
-        pos, len = start(str), endof(str)
+        directives = df.tokens
+        locale::DateLocale = df.locale
 
-        err_idx = 1
-        Base.@nexprs $N i->val_i = 0
-        Base.@nexprs $N i->(begin
-            pos > len && @goto done
-            nv, next_pos = tryparsenext(t[i], str, pos, len, l)
-            isnull(nv) && @goto error
-            val_i, pos = unsafe_get(nv), next_pos
-            err_idx += 1
-        end)
-        pos <= len && @goto error
+        num_parsed = 0
+        directive_index = 1
 
-        @label done
-        parts = Base.@ntuple $N val
-        return R(reorder_args(parts, $field_order, $field_defaults, err_idx)::$tuple_type)
+        $(assign_defaults...)
+        $(parsers...)
 
-        @label error
-        # Note: Keeping exception generation in separate function helps with performance
-        raise && throw(gen_exception(t, err_idx, pos))
-        return R()
-    end
-end
+        pos > len || @goto error
 
-function gen_exception(tokens, err_idx, pos)
-    if err_idx > length(tokens)
-        ArgumentError("Found extra characters at the end of date time string")
-    else
-        ArgumentError("Unable to parse date time. Expected token $(tokens[err_idx]) at char $pos")
-    end
-end
+        @label done
+        return Nullable{$R}($(Expr(:tuple, value_names...))), pos, num_parsed
 
-#    reorder_args(val, idx, default, default_from)
-#
-# reorder elements of `val` tuple according to `idx` tuple. Use `default[i]`
-# when `idx[i] == 0` or i >= default_from
-#
-# returns a tuple `xs` of the same length as `idx` where `xs[i]` is
-# `val[idx[i]]` if `idx[i]` is non zero, `default[i]` if `idx[i]` is zero.
-#
-# `xs[i]` is `default[i]` for all i >= `default_from`.
-#
-#
-function reorder_args{N}(val::Tuple, idx::NTuple{N}, default::Tuple, default_from::Integer)
-    ntuple(Val{N}) do i
-        if idx[i] == 0 || idx[i] >= default_from
-            default[i]
-        else
-            val[idx[i]]
+        @label error
+        if raise
+            if directive_index > length(directives)
+                throw(ArgumentError("Found extra characters at the end of date time string"))
+            else
+                d = directives[directive_index]
+                throw(ArgumentError("Unable to parse date time. Expected directive $d at char $pos"))
+            end
         end
+        return Nullable{$R}(), pos, 0
     end
 end
 
-function Base.tryparse{T<:TimeType}(::Type{T}, str::AbstractString, df::DateFormat)
-    nt = tryparse_internal(T, str, df, false)
-    if isnull(nt)
-        return Nullable{T}()
-    else
-        return Nullable{T}(T(unsafe_get(nt)...))
-    end
-end
+"""
+    tryparsenext_internal(::Type{<:TimeType}, str, pos, len, df::DateFormat, raise=false)
+
+Parses the string according to the directives within the DateFormat. The specified TimeType
+type determines the type of and order of tokens returned. If the given DateFormat or string
+does not provide a required token a default value will be used. When the string cannot be
+parsed the returned value tuple will be null if `raise` is false otherwise an exception will
+be thrown.
+
+Returns a 2-element tuple `(values, pos)`:
+* `values::Nullable{Tuple}`: A tuple which contains a value for each token as specified by
+  the passed in type.
+* `pos::Int`: The character index at which parsing stopped.
+"""
+@generated function tryparsenext_internal(::Type{T}, str::AbstractString, pos::Int, len::Int,
+                                          df::DateFormat, raise::Bool=false) where T<:TimeType
+    letters = character_codes(df)
+
+    tokens = Type[CONVERSION_SPECIFIERS[letter] for letter in letters]
+    value_names = Symbol[genvar(t) for t in tokens]
+
+    output_tokens = CONVERSION_TRANSLATIONS[T]
+    output_names = Symbol[genvar(t) for t in output_tokens]
+    output_defaults = Tuple(CONVERSION_DEFAULTS[t] for t in output_tokens)
+    R = typeof(output_defaults)
+
+    # Pre-assign output variables to defaults. Ensures that all output variables are
+    # assigned as the value tuple returned from `tryparsenext_core` may not include all
+    # of the required variables.
+    assign_defaults = Expr[
+        quote
+            $name = $default
+        end
+        for (name, default) in zip(output_names, output_defaults)
+    ]
 
-default_format(::Type{Date}) = ISODateFormat
-default_format(::Type{DateTime}) = ISODateTimeFormat
+    # Unpacks the value tuple returned by `tryparsenext_core` into separate variables.
+    value_tuple = Expr(:tuple, value_names...)
 
-function Base.parse{T<:TimeType}(::Type{T},
-                                 str::AbstractString,
-                                 df::DateFormat=default_format(T))
-    nt = tryparse_internal(T, str, df, true)
-    T(unsafe_get(nt)...)
+    quote
+        values, pos, num_parsed = tryparsenext_core(str, pos, len, df, raise)
+        isnull(values) && return Nullable{$R}(), pos
+        $(assign_defaults...)
+        $value_tuple = unsafe_get(values)
+        return Nullable{$R}($(Expr(:tuple, output_names...))), pos
+    end
 end
 
 @inline function tryparsenext_base10(str::AbstractString, i::Int, len::Int, min_width::Int=1, max_width::Int=0)
@@ -200,3 +264,48 @@ function Base.parse(::Type{DateTime}, s::AbstractString, df::typeof(ISODateTimeF
     @label error
     throw(ArgumentError("Invalid DateTime string"))
 end
+
+function Base.parse(::Type{T}, str::AbstractString, df::DateFormat=default_format(T)) where T<:TimeType
+    pos, len = start(str), endof(str)
+    values, pos = tryparsenext_internal(T, str, pos, len, df, true)
+    T(unsafe_get(values)...)
+end
+
+function Base.tryparse(::Type{T}, str::AbstractString, df::DateFormat=default_format(T)) where T<:TimeType
+    pos, len = start(str), endof(str)
+    values, pos = tryparsenext_internal(T, str, pos, len, df, false)
+    if isnull(values)
+        Nullable{T}()
+    elseif isnull(validargs(T, unsafe_get(values)...))
+        # TODO: validargs gets called twice, since it's called again in the T constructor
+        Nullable{T}(T(unsafe_get(values)...))
+    else
+        Nullable{T}()
+    end
+end
+
+"""
+    parse_components(str::AbstractString, df::DateFormat) -> Array{Any}
+
+Parse the string into its components according to the directives in the DateFormat.
+Each component will be a distinct type, typically a subtype of Period. The order of the
+components will match the order of the `DatePart` directives within the DateFormat. The
+number of components may be less than the total number of `DatePart`.
+"""
+@generated function parse_components(str::AbstractString, df::DateFormat)
+    letters = character_codes(df)
+    tokens = Type[CONVERSION_SPECIFIERS[letter] for letter in letters]
+
+    quote
+        pos, len = start(str), endof(str)
+        values, pos, num_parsed = tryparsenext_core(str, pos, len, df, true)
+        t = unsafe_get(values)
+        types = $(Expr(:tuple, tokens...))
+        result = Vector{Any}(num_parsed)
+        for (i, typ) in enumerate(types)
+            i > num_parsed && break
+            result[i] = typ(t[i])  # Constructing types takes most of the time
+        end
+        return result
+    end
+end
diff --git a/base/dates/periods.jl b/base/dates/periods.jl
index 0779d8446fed64..91391421c9b191 100644
--- a/base/dates/periods.jl
+++ b/base/dates/periods.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #Period types
 value(x::Period) = x.value
@@ -33,7 +33,7 @@ for period in (:Year, :Month, :Week, :Day, :Hour, :Minute, :Second, :Millisecond
             $($period_str)(v)
 
         Construct a `$($period_str)` object with the given `v` value. Input must be
-        losslessly convertible to an `Int64`.
+        losslessly convertible to an [`Int64`](@ref).
         """ $period(v)
     end
 end
@@ -41,10 +41,10 @@ end
 #Print/show/traits
 Base.string(x::Period) = string(value(x), _units(x))
 Base.show(io::IO,x::Period) = print(io, string(x))
-Base.zero{P<:Period}(::Union{Type{P},P}) = P(0)
-Base.one{P<:Period}(::Union{Type{P},P}) = 1  # see #16116
-Base.typemin{P<:Period}(::Type{P}) = P(typemin(Int64))
-Base.typemax{P<:Period}(::Type{P}) = P(typemax(Int64))
+Base.zero(::Union{Type{P},P}) where {P<:Period} = P(0)
+Base.one(::Union{Type{P},P}) where {P<:Period} = 1  # see #16116
+Base.typemin(::Type{P}) where {P<:Period} = P(typemin(Int64))
+Base.typemax(::Type{P}) where {P<:Period} = P(typemax(Int64))
 
 # Default values (as used by TimeTypes)
 """
@@ -55,39 +55,40 @@ Month, and Day, and `T(0)` for Hour, Minute, Second, and Millisecond.
 """
 function default end
 
-default{T<:DatePeriod}(p::Union{T,Type{T}}) = T(1)
-default{T<:TimePeriod}(p::Union{T,Type{T}}) = T(0)
+default(p::Union{T,Type{T}}) where {T<:DatePeriod} = T(1)
+default(p::Union{T,Type{T}}) where {T<:TimePeriod} = T(0)
 
-(-){P<:Period}(x::P) = P(-value(x))
-Base.isless{P<:Period}(x::P, y::P) = isless(value(x), value(y))
-=={P<:Period}(x::P, y::P) = value(x) == value(y)
+(-)(x::P) where {P<:Period} = P(-value(x))
+==(x::P, y::P) where {P<:Period} = value(x) == value(y)
+==(x::Period, y::Period) = (==)(promote(x, y)...)
+Base.isless(x::P, y::P) where {P<:Period} = isless(value(x), value(y))
+Base.isless(x::Period, y::Period) = isless(promote(x, y)...)
 
 # Period Arithmetic, grouped by dimensionality:
-import Base: div, fld, mod, rem, gcd, lcm, +, -, *, /, %
 for op in (:+, :-, :lcm, :gcd)
-    @eval ($op){P<:Period}(x::P, y::P) = P(($op)(value(x), value(y)))
+    @eval ($op)(x::P, y::P) where {P<:Period} = P(($op)(value(x), value(y)))
 end
 
 for op in (:/, :div, :fld)
     @eval begin
-        ($op){P<:Period}(x::P, y::P) = ($op)(value(x), value(y))
-        ($op){P<:Period}(x::P, y::Real) = P(($op)(value(x), Int64(y)))
+        ($op)(x::P, y::P) where {P<:Period} = ($op)(value(x), value(y))
+        ($op)(x::P, y::Real) where {P<:Period} = P(($op)(value(x), Int64(y)))
     end
 end
 
 for op in (:rem, :mod)
     @eval begin
-        ($op){P<:Period}(x::P, y::P) = P(($op)(value(x), value(y)))
-        ($op){P<:Period}(x::P, y::Real) = P(($op)(value(x), Int64(y)))
+        ($op)(x::P, y::P) where {P<:Period} = P(($op)(value(x), value(y)))
+        ($op)(x::P, y::Real) where {P<:Period} = P(($op)(value(x), Int64(y)))
     end
 end
 
-*{P<:Period}(x::P, y::Real) = P(value(x) * Int64(y))
-*(y::Real, x::Period) = x * y
+(*)(x::P, y::Real) where {P<:Period} = P(value(x) * Int64(y))
+(*)(y::Real, x::Period) = x * y
 for (op, Ty, Tz) in ((:*, Real, :P),
                    (:/, :P, Float64), (:/, Real, :P))
     @eval begin
-        function ($op){P<:Period}(X::StridedArray{P}, y::$Ty)
+        function ($op)(X::StridedArray{P}, y::$Ty) where P<:Period
             Z = similar(X, $Tz)
             for (Idst, Isrc) in zip(eachindex(Z), eachindex(X))
                 @inbounds Z[Idst] = ($op)(X[Isrc], y)
@@ -98,8 +99,8 @@ for (op, Ty, Tz) in ((:*, Real, :P),
 end
 
 # intfuncs
-Base.gcdx{T<:Period}(a::T, b::T) = ((g, x, y) = gcdx(value(a), value(b)); return T(g), x, y)
-Base.abs{T<:Period}(a::T) = T(abs(value(a)))
+Base.gcdx(a::T, b::T) where {T<:Period} = ((g, x, y) = gcdx(value(a), value(b)); return T(g), x, y)
+Base.abs(a::T) where {T<:Period} = T(abs(value(a)))
 
 periodisless(::Period,::Year)        = true
 periodisless(::Period,::Month)       = true
@@ -134,7 +135,7 @@ periodisless(::Nanosecond,::Microsecond)  = true
 periodisless(::Period,::Nanosecond)       = false
 
 # return (next coarser period, conversion factor):
-coarserperiod{P<:Period}(::Type{P}) = (P, 1)
+coarserperiod(::Type{P}) where {P<:Period} = (P, 1)
 coarserperiod(::Type{Nanosecond})  = (Microsecond, 1000)
 coarserperiod(::Type{Microsecond}) = (Millisecond, 1000)
 coarserperiod(::Type{Millisecond}) = (Second, 1000)
@@ -197,7 +198,7 @@ Construct a `CompoundPeriod` from a `Vector` of `Period`s. All `Period`s of the
 will be added together.
 
 # Examples
-```julia
+```jldoctest
 julia> Dates.CompoundPeriod(Dates.Hour(12), Dates.Hour(13))
 25 hours
 
@@ -211,7 +212,7 @@ julia> Dates.CompoundPeriod(Dates.Minute(50000))
 50000 minutes
 ```
 """
-CompoundPeriod(p::Vector{<:Period}) = CompoundPeriod(Array{Period}(p))
+CompoundPeriod(p::Vector{<:Period}) = CompoundPeriod(Vector{Period}(p))
 
 CompoundPeriod(t::Time) = CompoundPeriod(Period[Hour(t), Minute(t), Second(t), Millisecond(t),
                                                 Microsecond(t), Nanosecond(t)])
@@ -230,7 +231,7 @@ Reduces the `CompoundPeriod` into its canonical form by applying the following r
   (eg. `Hour(1) - Day(1)` becomes `-Hour(23)`)
 
 # Examples
-```julia
+```jldoctest
 julia> Dates.canonicalize(Dates.CompoundPeriod(Dates.Hour(12), Dates.Hour(13)))
 1 day, 1 hour
 
@@ -398,7 +399,7 @@ const FixedPeriod = Union{Week, Day, Hour, Minute, Second, Millisecond, Microsec
 # like div but throw an error if remainder is nonzero
 function divexact(x, y)
     q, r = divrem(x, y)
-    r == 0 || throw(InexactError())
+    r == 0 || throw(InexactError(:divexact, Int, x/y))
     return q
 end
 
@@ -413,7 +414,7 @@ for i = 1:length(fixedperiod_conversions)
         vmax = typemax(Int64) ÷ N
         vmin = typemin(Int64) ÷ N
         @eval function Base.convert(::Type{$T}, x::$Tc)
-            $vmin ≤ value(x) ≤ $vmax || throw(InexactError())
+            $vmin ≤ value(x) ≤ $vmax || throw(InexactError(:convert, $T, x))
             return $T(value(x) * $N)
         end
     end
@@ -425,24 +426,36 @@ for i = 1:length(fixedperiod_conversions)
         N *= nc
     end
 end
-# have to declare thusly so that diagonal dispatch above takes precedence:
-(==){T<:FixedPeriod, S<:FixedPeriod}(x::T, y::S) = (==)(promote(x, y)...)
-Base.isless{T<:FixedPeriod, S<:FixedPeriod}(x::T, y::S) = isless(promote(x, y)...)
 
 # other periods with fixed conversions but which aren't fixed time periods
 const OtherPeriod = Union{Month, Year}
 let vmax = typemax(Int64) ÷ 12, vmin = typemin(Int64) ÷ 12
     @eval function Base.convert(::Type{Month}, x::Year)
-        $vmin ≤ value(x) ≤ $vmax || throw(InexactError())
+        $vmin ≤ value(x) ≤ $vmax || throw(InexactError(:convert, Month, x))
         Month(value(x) * 12)
     end
 end
 Base.convert(::Type{Year}, x::Month) = Year(divexact(value(x), 12))
 Base.promote_rule(::Type{Year}, ::Type{Month}) = Month
-(==){T<:OtherPeriod, S<:OtherPeriod}(x::T, y::S) = (==)(promote(x, y)...)
-Base.isless{T<:OtherPeriod, S<:OtherPeriod}(x::T, y::S) = isless(promote(x, y)...)
 
-# truncating conversions to milliseconds and days:
+# disallow comparing fixed to other periods
+(==)(x::FixedPeriod, y::OtherPeriod) = throw(MethodError(==, (x, y)))
+(==)(x::OtherPeriod, y::FixedPeriod) = throw(MethodError(==, (x, y)))
+
+const fixedperiod_seed = UInt === UInt64 ? 0x5b7fc751bba97516 : 0xeae0fdcb
+const otherperiod_seed = UInt === UInt64 ? 0xe1837356ff2d2ac9 : 0x170d1b00
+# tons() will overflow for periods longer than ~300,000 years, implying a hash collision
+# which is relatively harmless given how infrequent such periods should appear
+Base.hash(x::FixedPeriod, h::UInt) = hash(tons(x), h + fixedperiod_seed)
+# Overflow can also happen here for really long periods (~8e17 years)
+Base.hash(x::Year, h::UInt) = hash(12 * value(x), h + otherperiod_seed)
+Base.hash(x::Month, h::UInt) = hash(value(x), h + otherperiod_seed)
+
+Base.isless(x::FixedPeriod, y::OtherPeriod) = throw(MethodError(isless, (x, y)))
+Base.isless(x::OtherPeriod, y::FixedPeriod) = throw(MethodError(isless, (x, y)))
+
+# truncating conversions to milliseconds, nanoseconds and days:
+# overflow can happen for periods longer than ~300,000 years
 toms(c::Nanosecond)  = div(value(c), 1000000)
 toms(c::Microsecond) = div(value(c), 1000)
 toms(c::Millisecond) = value(c)
diff --git a/base/dates/query.jl b/base/dates/query.jl
index 5862196583f3ab..48392ab9e03122 100644
--- a/base/dates/query.jl
+++ b/base/dates/query.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Date Locales
 
@@ -90,6 +90,15 @@ dayofweek(days) = mod1(days, 7)
     daysinyear(dt::TimeType) -> Int
 
 Returns 366 if the year of `dt` is a leap year, otherwise returns 365.
+
+# Examples
+```jldoctest
+julia> Dates.daysinyear(1999)
+365
+
+julia> Dates.daysinyear(2000)
+366
+```
 """
 daysinyear(y) = 365 + isleapyear(y)
 
@@ -101,7 +110,13 @@ dayofyear(y, m, d) = MONTHDAYS[m] + d + (m > 2 && isleapyear(y))
 """
     dayofweek(dt::TimeType) -> Int64
 
-Returns the day of the week as an `Int64` with `1 = Monday, 2 = Tuesday, etc.`.
+Returns the day of the week as an [`Int64`](@ref) with `1 = Monday, 2 = Tuesday, etc.`.
+
+# Examples
+```jldoctest
+julia> Dates.dayofweek(Date("2000-01-01"))
+6
+```
 """
 dayofweek(dt::TimeType) = dayofweek(days(dt))
 
@@ -114,20 +129,32 @@ dayname(day::Integer; locale::AbstractString="english") = dayname(day, LOCALES[l
 dayabbr(day::Integer; locale::AbstractString="english") = dayabbr(day, LOCALES[locale])
 
 """
-    dayname(dt::TimeType; locale="english") -> AbstractString
+    dayname(dt::TimeType; locale="english") -> String
 
 Return the full day name corresponding to the day of the week of the `Date` or `DateTime` in
 the given `locale`.
+
+# Examples
+```jldoctest
+julia> Dates.dayname(Date("2000-01-01"))
+"Saturday"
+```
 """
 function dayname(dt::TimeType;locale::AbstractString="english")
     dayname(dayofweek(dt); locale=locale)
 end
 
 """
-    dayabbr(dt::TimeType; locale="english") -> AbstractString
+    dayabbr(dt::TimeType; locale="english") -> String
 
 Return the abbreviated name corresponding to the day of the week of the `Date` or `DateTime`
 in the given `locale`.
+
+# Examples
+```jldoctest
+julia> Dates.dayabbr(Date("2000-01-01"))
+"Sat"
+```
 """
 function dayabbr(dt::TimeType;locale::AbstractString="english")
     dayabbr(dayofweek(dt); locale=locale)
@@ -149,6 +176,18 @@ issunday(dt::TimeType) = dayofweek(dt) == Sun
 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.
+
+# Examples
+```jldoctest
+julia> Dates.dayofweekofmonth(Date("2000-02-01"))
+1
+
+julia> Dates.dayofweekofmonth(Date("2000-02-08"))
+2
+
+julia> Dates.dayofweekofmonth(Date("2000-02-15"))
+3
+````
 """
 function dayofweekofmonth(dt::TimeType)
     d = day(dt)
@@ -168,6 +207,15 @@ For the day of week of `dt`, returns the total number of that day of the week in
 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.
+
+# Examples
+```jldoctest
+julia> Dates.daysofweekinmonth(Date("2005-01-01"))
+5
+
+julia> Dates.daysofweekinmonth(Date("2005-01-04"))
+4
+```
 """
 function daysofweekinmonth(dt::TimeType)
     y, m, d = yearmonthday(dt)
@@ -188,18 +236,30 @@ monthname(month::Integer; locale::AbstractString="english") = monthname(month, L
 monthabbr(month::Integer; locale::AbstractString="english") = monthabbr(month, LOCALES[locale])
 
 """
-    monthname(dt::TimeType; locale="english") -> AbstractString
+    monthname(dt::TimeType; locale="english") -> String
 
 Return the full name of the month of the `Date` or `DateTime` in the given `locale`.
+
+# Examples
+```jldoctest
+julia> Dates.monthname(Date("2005-01-04"))
+"January"
+```
 """
 function monthname(dt::TimeType; locale::AbstractString="english")
     monthname(month(dt); locale=locale)
 end
 
 """
-    monthabbr(dt::TimeType; locale="english") -> AbstractString
+    monthabbr(dt::TimeType; locale="english") -> String
 
 Return the abbreviated month name of the `Date` or `DateTime` in the given `locale`.
+
+# Examples
+```jldoctest
+julia> Dates.monthabbr(Date("2005-01-04"))
+"Jan"
+```
 """
 function monthabbr(dt::TimeType; locale::AbstractString="english")
     monthabbr(month(dt); locale=locale)
@@ -209,6 +269,18 @@ end
     daysinmonth(dt::TimeType) -> Int
 
 Returns the number of days in the month of `dt`. Value will be 28, 29, 30, or 31.
+
+# Examples
+```jldoctest
+julia> Dates.daysinmonth(Date("2000-01"))
+31
+
+julia> Dates.daysinmonth(Date("2001-02"))
+28
+
+julia> Dates.daysinmonth(Date("2000-02"))
+29
+```
 """
 daysinmonth(dt::TimeType) = ((y, m) = yearmonth(dt); return daysinmonth(y, m))
 
@@ -217,6 +289,15 @@ daysinmonth(dt::TimeType) = ((y, m) = yearmonth(dt); return daysinmonth(y, m))
     isleapyear(dt::TimeType) -> Bool
 
 Returns `true` if the year of `dt` is a leap year.
+
+# Examples
+```jldoctest
+julia> Dates.isleapyear(Date("2004"))
+true
+
+julia> Dates.isleapyear(Date("2005"))
+false
+```
 """
 isleapyear(dt::TimeType) = isleapyear(year(dt))
 
diff --git a/base/dates/ranges.jl b/base/dates/ranges.jl
index bd853f68e5b061..21b646bd062fe4 100644
--- a/base/dates/ranges.jl
+++ b/base/dates/ranges.jl
@@ -1,11 +1,11 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Date/DateTime Ranges
 
 # Override default step; otherwise it would be Millisecond(1)
-Base.colon{T<:DateTime}(start::T, stop::T) = StepRange(start, Day(1), stop)
-Base.colon{T<:Date}(start::T, stop::T)     = StepRange(start, Day(1), stop)
-Base.colon{T<:Time}(start::T, stop::T)     = StepRange(start, Second(1), stop)
+Base.colon(start::T, stop::T) where {T<:DateTime} = StepRange(start, Day(1), stop)
+Base.colon(start::T, stop::T) where {T<:Date}     = StepRange(start, Day(1), stop)
+Base.colon(start::T, stop::T) where {T<:Time}     = StepRange(start, Second(1), stop)
 
 Base.range(start::DateTime, len::Integer)  = range(start, Day(1), len)
 Base.range(start::Date, len::Integer)      = range(start, Day(1), len)
@@ -25,16 +25,16 @@ function len(a, b, c)
     end
     return i - 1
 end
-Base.length(r::StepRange{<:TimeType}) = isempty(r) ? 0 : len(r.start, r.stop, r.step) + 1
+Base.length(r::StepRange{<:TimeType}) = isempty(r) ? Int64(0) : len(r.start, r.stop, r.step) + 1
 # Period ranges hook into Int64 overflow detection
 Base.length(r::StepRange{<:Period}) = length(StepRange(value(r.start), value(r.step), value(r.stop)))
 
 # Used to calculate the last valid date in the range given the start, stop, and step
 # last = stop - steprem(start, stop, step)
-Base.steprem{T<:TimeType}(a::T, b::T, c) = b - (a + c * len(a, b, c))
+Base.steprem(a::T, b::T, c) where {T<:TimeType} = b - (a + c * len(a, b, c))
 
 import Base.in
-function in{T<:TimeType}(x::T, r::StepRange{T})
+function in(x::T, r::StepRange{T}) where T<:TimeType
     n = len(first(r), x, step(r)) + 1
     n >= 1 && n <= length(r) && r[n] == x
 end
diff --git a/base/dates/rounding.jl b/base/dates/rounding.jl
index 0f10cf5ca93b1f..6a4a40d38ae13a 100644
--- a/base/dates/rounding.jl
+++ b/base/dates/rounding.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # The epochs used for date rounding are based ISO 8601's "year zero" notation
 const DATEEPOCH = value(Date(0))
@@ -27,7 +27,7 @@ epochms2datetime(i) = DateTime(UTM(DATETIMEEPOCH + Int64(i)))
     date2epochdays(dt::Date) -> Int64
 
 Takes the given `Date` and returns the number of days since the rounding epoch
-(`0000-01-01T00:00:00`) as an `Int64`.
+(`0000-01-01T00:00:00`) as an [`Int64`](@ref).
 """
 date2epochdays(dt::Date) = value(dt) - DATEEPOCH
 
@@ -35,18 +35,18 @@ date2epochdays(dt::Date) = value(dt) - DATEEPOCH
     datetime2epochms(dt::DateTime) -> Int64
 
 Takes the given `DateTime` and returns the number of milliseconds since the rounding epoch
-(`0000-01-01T00:00:00`) as an `Int64`.
+(`0000-01-01T00:00:00`) as an [`Int64`](@ref).
 """
 datetime2epochms(dt::DateTime) = value(dt) - DATETIMEEPOCH
 
 function Base.floor(dt::Date, p::Year)
-    value(p) < 1 && throw(DomainError())
+    value(p) < 1 && throw(DomainError(p))
     years = year(dt)
     return Date(years - mod(years, value(p)))
 end
 
 function Base.floor(dt::Date, p::Month)
-    value(p) < 1 && throw(DomainError())
+    value(p) < 1 && throw(DomainError(p))
     y, m = yearmonth(dt)
     months_since_epoch = y * 12 + m - 1
     month_offset = months_since_epoch - mod(months_since_epoch, value(p))
@@ -56,14 +56,14 @@ function Base.floor(dt::Date, p::Month)
 end
 
 function Base.floor(dt::Date, p::Week)
-    value(p) < 1 && throw(DomainError())
+    value(p) < 1 && throw(DomainError(p))
     days = value(dt) - WEEKEPOCH
     days = days - mod(days, value(Day(p)))
     return Date(UTD(WEEKEPOCH + Int64(days)))
 end
 
 function Base.floor(dt::Date, p::Day)
-    value(p) < 1 && throw(DomainError())
+    value(p) < 1 && throw(DomainError(p))
     days = date2epochdays(dt)
     return epochdays2date(days - mod(days, value(p)))
 end
@@ -71,7 +71,7 @@ end
 Base.floor(dt::DateTime, p::DatePeriod) = DateTime(Base.floor(Date(dt), p))
 
 function Base.floor(dt::DateTime, p::TimePeriod)
-    value(p) < 1 && throw(DomainError())
+    value(p) < 1 && throw(DomainError(p))
     milliseconds = datetime2epochms(dt)
     return epochms2datetime(milliseconds - mod(milliseconds, value(Millisecond(p))))
 end
@@ -166,7 +166,7 @@ Base.round(dt::TimeType, p::Period, r::RoundingMode{:Up}) = Base.ceil(dt, p)
 # No implementation of other `RoundingMode`s: rounding to nearest "even" is skipped because
 # "even" is not defined for Period; rounding toward/away from zero is skipped because ISO
 # 8601's year 0000 is not really "zero".
-Base.round(::TimeType, ::Period, ::RoundingMode) = throw(DomainError())
+Base.round(::TimeType, p::Period, ::RoundingMode) = throw(DomainError(p))
 
 # Default to RoundNearestTiesUp.
 Base.round(dt::TimeType, p::Period) = Base.round(dt, p, RoundNearestTiesUp)
diff --git a/base/dates/types.jl b/base/dates/types.jl
index b1ef80aeb4ee41..12e3e62bf25f22 100644
--- a/base/dates/types.jl
+++ b/base/dates/types.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 abstract type AbstractTime end
 
@@ -47,7 +47,7 @@ end
     Nanosecond(v)
 
 Construct a `Period` type with the given `v` value. Input must be losslessly convertible
-to an `Int64`.
+to an [`Int64`](@ref).
 """
 Period(v)
 
@@ -90,7 +90,7 @@ struct UTC <: TimeZone end
     TimeType
 
 `TimeType` types wrap `Instant` machine instances to provide human representations of the
-machine instant. Both `DateTime` and `Date` are subtypes of `TimeType`.
+machine instant. `Time`, `DateTime` and `Date` are subtypes of `TimeType`.
 """
 abstract type TimeType <: AbstractTime end
 
@@ -144,51 +144,94 @@ isleapyear(y) = ((y % 4 == 0) && (y % 100 != 0)) || (y % 400 == 0)
 const DAYSINMONTH = (31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
 daysinmonth(y,m) = DAYSINMONTH[m] + (m == 2 && isleapyear(y))
 
+### UTILITIES ###
+
+# These are necessary because the type constructors for TimeType subtypes can
+# throw, and we want to be able to use tryparse without requiring a try/catch.
+# This is made easier by providing a helper function that checks arguments, so
+# we can validate arguments in tryparse.
+
+"""
+    validargs(::Type{<:TimeType}, args...) -> Nullable{ArgumentError}
+
+Determine whether the given arguments consitute valid inputs for the given type.
+Returns a `Nullable{ArgumentError}` where null signifies success.
+"""
+function validargs end
+
+"""
+    argerror([msg]) -> Nullable{ArgumentError}
+
+Construct a `Nullable{ArgumentError}` with the given message, or null if no message
+is provided. For use by `validargs`.
+"""
+argerror(msg::String) = Nullable(ArgumentError(msg))
+argerror() = Nullable{ArgumentError}()
+
 ### CONSTRUCTORS ###
 # Core constructors
 """
     DateTime(y, [m, d, h, mi, s, ms]) -> DateTime
 
-Construct a `DateTime` type by parts. Arguments must be convertible to `Int64`.
+Construct a `DateTime` type by parts. Arguments must be convertible to [`Int64`](@ref).
 """
 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 (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)"))
+    err = validargs(DateTime, y, m, d, h, mi, s, ms)
+    isnull(err) || throw(unsafe_get(err))
     rata = ms + 1000 * (s + 60mi + 3600h + 86400 * totaldays(y, m, d))
     return DateTime(UTM(rata))
 end
 
+function validargs(::Type{DateTime}, y::Int64, m::Int64, d::Int64,
+                   h::Int64, mi::Int64, s::Int64, ms::Int64)
+    0 < m < 13 || return argerror("Month: $m out of range (1:12)")
+    0 < d < daysinmonth(y, m) + 1 || return argerror("Day: $d out of range (1:$(daysinmonth(y, m)))")
+    -1 < h < 24 || return argerror("Hour: $h out of range (0:23)")
+    -1 < mi < 60 || return argerror("Minute: $mi out of range (0:59)")
+    -1 < s < 60 || return argerror("Second: $s out of range (0:59)")
+    -1 < ms < 1000 || return argerror("Millisecond: $ms out of range (0:999)")
+    return argerror()
+end
+
 """
     Date(y, [m, d]) -> Date
 
-Construct a `Date` type by parts. Arguments must be convertible to `Int64`.
+Construct a `Date` type by parts. Arguments must be convertible to [`Int64`](@ref).
 """
 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)))"))
+    err = validargs(Date, y, m, d)
+    isnull(err) || throw(unsafe_get(err))
     return Date(UTD(totaldays(y, m, d)))
 end
 
+function validargs(::Type{Date}, y::Int64, m::Int64, d::Int64)
+    0 < m < 13 || return argerror("Month: $m out of range (1:12)")
+    0 < d < daysinmonth(y, m) + 1 || return argerror("Day: $d out of range (1:$(daysinmonth(y, m)))")
+    return argerror()
+end
+
 """
     Time(h, [mi, s, ms, us, ns]) -> Time
 
-Construct a `Time` type by parts. Arguments must be convertible to `Int64`.
+Construct a `Time` type by parts. Arguments must be convertible to [`Int64`](@ref).
 """
 function Time(h::Int64, mi::Int64=0, s::Int64=0, ms::Int64=0, us::Int64=0, ns::Int64=0)
-    -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)"))
-    -1 < us < 1000 || throw(ArgumentError("Microsecond: $us out of range (0:999)"))
-    -1 < ns < 1000 || throw(ArgumentError("Nanosecond: $ns out of range (0:999)"))
+    err = validargs(Time, h, mi, s, ms, us, ns)
+    isnull(err) || throw(unsafe_get(err))
     return Time(Nanosecond(ns + 1000us + 1000000ms + 1000000000s + 60000000000mi + 3600000000000h))
 end
 
+function validargs(::Type{Time}, h::Int64, mi::Int64, s::Int64, ms::Int64, us::Int64, ns::Int64)
+    -1 < h < 24 || return argerror("Hour: $h out of range (0:23)")
+    -1 < mi < 60 || return argerror("Minute: $mi out of range (0:59)")
+    -1 < s < 60 || return argerror("Second: $s out of range (0:59)")
+    -1 < ms < 1000 || return argerror("Millisecond: $ms out of range (0:999)")
+    -1 < us < 1000 || return argerror("Microsecond: $us out of range (0:999)")
+    -1 < ns < 1000 || return argerror("Nanosecond: $ns out of range (0:999)")
+    return argerror()
+end
+
 # Convenience constructors from Periods
 function DateTime(y::Year, m::Month=Month(1), d::Day=Day(1),
                   h::Hour=Hour(0), mi::Minute=Minute(0),
@@ -270,7 +313,7 @@ Date(y, m=1, d=1) = Date(Int64(y), Int64(m), Int64(d))
 Time(h, mi=0, s=0, ms=0, us=0, ns=0) = Time(Int64(h), Int64(mi), Int64(s), Int64(ms), Int64(us), Int64(ns))
 
 # Traits, Equality
-Base.isfinite{T<:TimeType}(::Union{Type{T}, T}) = true
+Base.isfinite(::Union{Type{T}, T}) where {T<:TimeType} = true
 calendar(dt::DateTime) = ISOCalendar
 calendar(dt::Date) = ISOCalendar
 
@@ -294,22 +337,22 @@ Base.typemin(::Union{Date, Type{Date}}) = Date(-252522163911150, 1, 1)
 Base.typemax(::Union{Time, Type{Time}}) = Time(23, 59, 59, 999, 999, 999)
 Base.typemin(::Union{Time, Type{Time}}) = Time(0)
 # Date-DateTime promotion, isless, ==
-Base.eltype{T<:Period}(::Type{T}) = T
+Base.eltype(::Type{T}) where {T<:Period} = T
 Base.promote_rule(::Type{Date}, x::Type{DateTime}) = DateTime
-Base.isless{T<:TimeType}(x::T, y::T) = isless(value(x), value(y))
+Base.isless(x::T, y::T) where {T<:TimeType} = isless(value(x), value(y))
 Base.isless(x::TimeType, y::TimeType) = isless(Base.promote_noncircular(x, y)...)
-=={T<:TimeType}(x::T, y::T) = ==(value(x), value(y))
+(==)(x::T, y::T) where {T<:TimeType} = (==)(value(x), value(y))
 function ==(a::Time, b::Time)
     return hour(a) == hour(b) && minute(a) == minute(b) &&
         second(a) == second(b) && millisecond(a) == millisecond(b) &&
         microsecond(a) == microsecond(b) && nanosecond(a) == nanosecond(b)
 end
-==(x::TimeType, y::TimeType) = ===(promote(x, y)...)
+(==)(x::TimeType, y::TimeType) = (===)(promote(x, y)...)
 
 import Base: sleep, Timer, timedwait
 sleep(time::Period) = sleep(toms(time) / 1000)
 Timer(time::Period, repeat::Period=Second(0)) = Timer(toms(time) / 1000, toms(repeat) / 1000)
 timedwait(testcb::Function, time::Period) = timedwait(testcb, toms(time) / 1000)
 
-(::Type{Base.TypeOrder})(::Type{<:AbstractTime}) = Base.HasOrder()
-(::Type{Base.TypeArithmetic})(::Type{<:AbstractTime}) = Base.ArithmeticOverflows()
+Base.TypeOrder(::Type{<:AbstractTime}) = Base.HasOrder()
+Base.TypeArithmetic(::Type{<:AbstractTime}) = Base.ArithmeticOverflows()
diff --git a/base/deepcopy.jl b/base/deepcopy.jl
index 42d169be30a575..e4c0947d809359 100644
--- a/base/deepcopy.jl
+++ b/base/deepcopy.jl
@@ -1,10 +1,30 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # deep copying
 
 # Note: deepcopy_internal(::Any, ::ObjectIdDict) is
 #       only exposed for specialization by libraries
 
+"""
+    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(x) = deepcopy_internal(x, ObjectIdDict())::typeof(x)
 
 deepcopy_internal(x::Union{Symbol,Core.MethodInstance,Method,GlobalRef,DataType,Union,Task},
@@ -31,9 +51,9 @@ function deepcopy_internal(x::String, stackdict::ObjectIdDict)
     return y
 end
 
-function deepcopy_internal(x::ANY, stackdict::ObjectIdDict)
+function deepcopy_internal(@nospecialize(x), stackdict::ObjectIdDict)
     T = typeof(x)::DataType
-    nf = nfields(T)
+    nf = nfields(x)
     (isbits(T) || nf == 0) && return x
     if haskey(stackdict, x)
         return stackdict[x]
@@ -58,7 +78,7 @@ function deepcopy_internal(x::Array, stackdict::ObjectIdDict)
     _deepcopy_array_t(x, eltype(x), stackdict)
 end
 
-function _deepcopy_array_t(x::ANY, T, stackdict::ObjectIdDict)
+function _deepcopy_array_t(@nospecialize(x), T, stackdict::ObjectIdDict)
     if isbits(T)
         return (stackdict[x]=copy(x))
     end
diff --git a/base/deprecated.jl b/base/deprecated.jl
index aff54d7b8c2ad7..07a395a7a19185 100644
--- a/base/deprecated.jl
+++ b/base/deprecated.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Deprecated functions and objects
 #
@@ -18,37 +18,43 @@
 # the name of the function, which is used to ensure that the deprecation warning
 # is only printed the first time for each call place.
 
-macro deprecate(old,new,ex=true)
+macro deprecate(old, new, ex=true)
     meta = Expr(:meta, :noinline)
     @gensym oldmtname
-    if isa(old,Symbol)
-        oldname = Expr(:quote,old)
-        newname = Expr(:quote,new)
+    if isa(old, Symbol)
+        oldname = Expr(:quote, old)
+        newname = Expr(:quote, new)
         Expr(:toplevel,
-            ex ? Expr(:export,esc(old)) : nothing,
+            ex ? Expr(:export, esc(old)) : nothing,
             :(function $(esc(old))(args...)
                   $meta
-                  depwarn(string($oldname," is deprecated, use ",$newname," instead."),
+                  depwarn(string($oldname, " is deprecated, use ", $newname, " instead."),
                           $oldmtname)
                   $(esc(new))(args...)
               end),
             :(const $oldmtname = Core.Typeof($(esc(old))).name.mt.name))
-    elseif isa(old,Expr) && old.head == :call
+    elseif isa(old, Expr) && (old.head == :call || old.head == :where)
         remove_linenums!(new)
         oldcall = sprint(show_unquoted, old)
         newcall = sprint(show_unquoted, new)
-        oldsym = if isa(old.args[1],Symbol)
-            old.args[1]::Symbol
-        elseif isa(old.args[1],Expr) && old.args[1].head == :curly
-            old.args[1].args[1]::Symbol
+        # if old.head is a :where, step down one level to the :call to avoid code duplication below
+        callexpr = old.head == :call ? old : old.args[1]
+        if callexpr.head == :call
+            if isa(callexpr.args[1], Symbol)
+                oldsym = callexpr.args[1]::Symbol
+            elseif isa(callexpr.args[1], Expr) && callexpr.args[1].head == :curly
+                oldsym = callexpr.args[1].args[1]::Symbol
+            else
+                error("invalid usage of @deprecate")
+            end
         else
             error("invalid usage of @deprecate")
         end
         Expr(:toplevel,
-            ex ? Expr(:export,esc(oldsym)) : nothing,
+            ex ? Expr(:export, esc(oldsym)) : nothing,
             :($(esc(old)) = begin
                   $meta
-                  depwarn(string($oldcall," is deprecated, use ",$newcall," instead."),
+                  depwarn(string($oldcall, " is deprecated, use ", $newcall, " instead."),
                           $oldmtname)
                   $(esc(new))
               end),
@@ -85,11 +91,20 @@ function firstcaller(bt::Array{Ptr{Void},1}, funcsyms)
     for frame in bt
         lkups = StackTraces.lookup(frame)
         for lkup in lkups
-            if lkup === StackTraces.UNKNOWN
+            if lkup == StackTraces.UNKNOWN
                 continue
             end
             found && @goto found
             found = lkup.func in funcsyms
+            # look for constructor type name
+            if !found && !isnull(lkup.linfo)
+                li = get(lkup.linfo)
+                ft = ccall(:jl_first_argument_datatype, Any, (Any,), li.def.sig)
+                if isa(ft,DataType) && ft.name === Type.body.name
+                    ft = unwrap_unionall(ft.parameters[1])
+                    found = (isa(ft,DataType) && ft.name.name in funcsyms)
+                end
+            end
         end
     end
     return StackTraces.UNKNOWN
@@ -97,16 +112,34 @@ function firstcaller(bt::Array{Ptr{Void},1}, funcsyms)
     return lkup
 end
 
-deprecate(s::Symbol) = deprecate(current_module(), s)
-deprecate(m::Module, s::Symbol) = ccall(:jl_deprecate_binding, Void, (Any, Any), m, s)
+deprecate(m::Module, s::Symbol, flag=1) = ccall(:jl_deprecate_binding, Void, (Any, Any, Cint), m, s, flag)
 
 macro deprecate_binding(old, new, export_old=true)
-    Expr(:toplevel,
+    return Expr(:toplevel,
          export_old ? Expr(:export, esc(old)) : nothing,
          Expr(:const, Expr(:(=), esc(old), esc(new))),
-         Expr(:call, :deprecate, Expr(:quote, old)))
+         Expr(:call, :deprecate, __module__, Expr(:quote, old)))
 end
 
+macro deprecate_moved(old, new, export_old=true)
+    eold = esc(old)
+    return Expr(:toplevel,
+         :(function $eold(args...; kwargs...)
+               error($eold, " has been moved to the package ", $new, ".jl.\n",
+                     "Run `Pkg.add(\"", $new, "\")` to install it, restart Julia,\n",
+                     "and then run `using ", $new, "` to load it.")
+           end),
+         export_old ? Expr(:export, eold) : nothing,
+         Expr(:call, :deprecate, __module__, Expr(:quote, old), 2))
+end
+
+# BEGIN 0.6-alpha deprecations (delete when 0.6 is released)
+
+@deprecate isambiguous(m1::Method, m2::Method, b::Bool) isambiguous(m1, m2, ambiguous_bottom=b) false
+# TODO: delete allow_bottom keyword code in Base.Test.detect_ambiguities
+
+# END 0.6-alpha deprecations
+
 # BEGIN 0.6 deprecations
 
 const _oldstyle_array_vcat_ = false
@@ -187,7 +220,7 @@ end
 # Deprecate vectorized unary functions over sparse matrices in favor of compact broadcast syntax (#17265).
 for f in (:sin, :sinh, :sind, :asin, :asinh, :asind,
         :tan, :tanh, :tand, :atan, :atanh, :atand,
-        :sinpi, :cosc, :ceil, :floor, :trunc, :round, :real, :imag,
+        :sinpi, :cosc, :ceil, :floor, :trunc, :round,
         :log1p, :expm1, :abs, :abs2,
         :log, :log2, :log10, :exp, :exp2, :exp10, :sinc, :cospi,
         :cos, :cosh, :cosd, :acos, :acosd,
@@ -199,25 +232,19 @@ end
 
 # For deprecating vectorized functions in favor of compact broadcast syntax
 macro dep_vectorize_1arg(S, f)
-    S = esc(S)
-    f = esc(f)
-    T = esc(:T)
-    x = esc(:x)
-    AbsArr = esc(:AbstractArray)
-    :( @deprecate $f{$T<:$S}($x::$AbsArr{$T}) $f.($x) )
+    x = esc(:x) # work around macro hygiene bug
+    T = esc(:T) # work around macro hygiene bug
+    return :( @deprecate $f($x::AbstractArray{$T}) where {$T<:$S} $f.($x) )
 end
 macro dep_vectorize_2arg(S, f)
-    S = esc(S)
-    f = esc(f)
-    T1 = esc(:T1)
-    T2 = esc(:T2)
-    x = esc(:x)
-    y = esc(:y)
-    AbsArr = esc(:AbstractArray)
-    quote
-        @deprecate $f{$T1<:$S}($x::$S, $y::$AbsArr{$T1}) $f.($x,$y)
-        @deprecate $f{$T1<:$S}($x::$AbsArr{$T1}, $y::$S) $f.($x,$y)
-        @deprecate $f{$T1<:$S,$T2<:$S}($x::$AbsArr{$T1}, $y::$AbsArr{$T2}) $f.($x,$y)
+    x = esc(:x) # work around macro hygiene bug
+    y = esc(:y) # work around macro hygiene bug
+    T1 = esc(:T1) # work around macro hygiene bug
+    T2 = esc(:T2) # work around macro hygiene bug
+    return quote
+        @deprecate $f($x::$S, $y::AbstractArray{$T1}) where {$T1<:$S} $f.($x, $y)
+        @deprecate $f($x::AbstractArray{$T1}, $y::$S) where {$T1<:$S} $f.($x, $y)
+        @deprecate $f($x::AbstractArray{$T1}, $y::AbstractArray{$T2}) where {$T1<:$S, $T2<:$S} $f.($x, $y)
     end
 end
 
@@ -305,20 +332,20 @@ for f in (
 end
 
 # Deprecate @vectorize_1arg and @vectorize_2arg themselves
-macro vectorize_1arg(S,f)
+macro vectorize_1arg(S, f)
     depwarn(string("`@vectorize_1arg` is deprecated in favor of compact broadcast syntax. ",
         "Instead of `@vectorize_1arg`'ing function `f` and calling `f(arg)`, call `f.(arg)`."),
         :vectorize_1arg)
     quote
-        @dep_vectorize_1arg($(esc(S)),$(esc(f)))
+        @dep_vectorize_1arg($S, $f)
     end
 end
-macro vectorize_2arg(S,f)
+macro vectorize_2arg(S, f)
     depwarn(string("`@vectorize_2arg` is deprecated in favor of compact broadcast syntax. ",
         "Instead of `@vectorize_2arg`'ing function `f` and calling `f(arg1, arg2)`, call ",
-        "`f.(arg1,arg2)`. "), :vectorize_2arg)
+        "`f.(arg1, arg2)`. "), :vectorize_2arg)
     quote
-        @dep_vectorize_2arg($(esc(S)),$(esc(f)))
+        @dep_vectorize_2arg($S, $f)
     end
 end
 export @vectorize_1arg, @vectorize_2arg
@@ -468,7 +495,7 @@ Filesystem.stop_watching(stream::Filesystem._FDWatcher) = depwarn("stop_watching
             filter(fun, dr)
         end
      end
-     recur{T<:TimeType}(fun::Function, start::T, stop::T; step::Period=Day(1), negate::Bool=false, limit::Int=10000) = recur(fun, start:step:stop; negate=negate)
+     recur(fun::Function, start::T, stop::T; step::Period=Day(1), negate::Bool=false, limit::Int=10000) where {T<:TimeType} = recur(fun, start:step:stop; negate=negate)
 end
 
 # Index conversions revamp; #19730
@@ -478,7 +505,8 @@ function getindex(A::LogicalIndex, i::Int)
     first(Iterators.drop(A, i-1))
 end
 function to_indexes(I...)
-    depwarn("to_indexes is deprecated; pass both the source array `A` and indices as `to_indices(A, $(I...))` instead.", :to_indexes)
+    Istr = join(I, ", ")
+    depwarn("to_indexes is deprecated; pass both the source array `A` and indices as `to_indices(A, $Istr)` instead.", :to_indexes)
     map(_to_index, I)
 end
 _to_index(i) = to_index(I)
@@ -616,7 +644,7 @@ for (Bsig, A1sig, A2sig, gbb, funcname) in
             func       = @get! cache  f  gen_broadcast_function_sparse($gbb, f, ($A1sig) <: SparseMatrixCSC)
             # need eval because func was just created by gen_broadcast_function_sparse
             # TODO: convert this to a generated function
-            eval(current_module(), Expr(:body, Expr(:return, Expr(:call, QuoteNode(func), QuoteNode(B), QuoteNode(A1), QuoteNode(A2)))))
+            eval(_current_module(), Expr(:body, Expr(:return, Expr(:call, QuoteNode(func), QuoteNode(B), QuoteNode(A1), QuoteNode(A2)))))
             return B
         end
     end  # let broadcast_cache
@@ -625,11 +653,11 @@ _broadcast_zpreserving!(args...) = broadcast!(args...)
 # note: promote_eltype_op also deprecated, defined later in this file
 _broadcast_zpreserving(f, As...) =
     broadcast!(f, similar(Array{_promote_eltype_op(f, As...)}, Base.Broadcast.broadcast_indices(As...)), As...)
-_broadcast_zpreserving{Tv1,Ti1,Tv2,Ti2}(f::Function, A_1::SparseMatrixCSC{Tv1,Ti1}, A_2::SparseMatrixCSC{Tv2,Ti2}) =
+_broadcast_zpreserving(f::Function, A_1::SparseMatrixCSC{Tv1,Ti1}, A_2::SparseMatrixCSC{Tv2,Ti2}) where {Tv1,Ti1,Tv2,Ti2} =
     _broadcast_zpreserving!(f, spzeros(promote_type(Tv1, Tv2), promote_type(Ti1, Ti2), Base.to_shape(Base.Broadcast.broadcast_indices(A_1, A_2))), A_1, A_2)
-_broadcast_zpreserving{Ti}(f::Function, A_1::SparseMatrixCSC{<:Any,Ti}, A_2::Union{Array,BitArray,Number}) =
+_broadcast_zpreserving(f::Function, A_1::SparseMatrixCSC{<:Any,Ti}, A_2::Union{Array,BitArray,Number}) where {Ti} =
     _broadcast_zpreserving!(f, spzeros(promote_eltype(A_1, A_2), Ti, Base.to_shape(Base.Broadcast.broadcast_indices(A_1, A_2))), A_1, A_2)
-_broadcast_zpreserving{Ti}(f::Function, A_1::Union{Array,BitArray,Number}, A_2::SparseMatrixCSC{<:Any,Ti}) =
+_broadcast_zpreserving(f::Function, A_1::Union{Array,BitArray,Number}, A_2::SparseMatrixCSC{<:Any,Ti}) where {Ti} =
     _broadcast_zpreserving!(f, spzeros(promote_eltype(A_1, A_2), Ti, Base.to_shape(Base.Broadcast.broadcast_indices(A_1, A_2))), A_1, A_2)
 
 function _depstring_bczpres()
@@ -671,21 +699,12 @@ end
 @deprecate xor(A::AbstractArray, B::AbstractArray)  xor.(A, B)
 
 # QuadGK moved to a package (#19741)
-function quadgk(args...; kwargs...)
-    error(string(quadgk, args, " has been moved to the package QuadGK.jl.\n",
-                 "Run Pkg.add(\"QuadGK\") to install QuadGK on Julia v0.6 and later, and then run `using QuadGK`."))
-end
-export quadgk
+@deprecate_moved quadgk "QuadGK"
 
 # Collections functions moved to a package (#19800)
 module Collections
-    export PriorityQueue, enqueue!, dequeue!, heapify!, heapify, heappop!, heappush!, isheap, peek
     for f in (:PriorityQueue, :enqueue!, :dequeue!, :heapify!, :heapify, :heappop!, :heappush!, :isheap, :peek)
-        @eval function ($f)(args...; kwargs...)
-            error(string($f, args, " has been moved to the package DataStructures.jl.\n",
-                         "Run Pkg.add(\"DataStructures\") to install DataStructures on Julia v0.6 and later, ",
-                         "and then run `using DataStructures`."))
-        end
+        @eval Base.@deprecate_moved $f "DataStructures"
     end
 end
 export Collections
@@ -694,19 +713,19 @@ export Collections
 @deprecate bitbroadcast broadcast
 
 # Deprecate two-argument map! (map!(f, A)) for a cycle in anticipation of semantic change
-@deprecate map!{F}(f::F, A::AbstractArray) map!(f, A, A)
+@deprecate map!(f::F, A::AbstractArray) where {F} map!(f, A, A)
 @deprecate asyncmap!(f, c; ntasks=0, batch_size=nothing) asyncmap!(f, c, c; ntasks=ntasks, batch_size=batch_size)
 
 # Not exported, but used outside Base
 _promote_array_type(F, ::Type, ::Type, T::Type) = T
-_promote_array_type{A<:AbstractFloat}(F, ::Type{<:Real}, ::Type{A}, ::Type) = A
-_promote_array_type{A<:Integer}(F, ::Type{<:Integer}, ::Type{A}, ::Type) = A
+_promote_array_type(F, ::Type{<:Real}, ::Type{A}, ::Type) where {A<:AbstractFloat} = A
+_promote_array_type(F, ::Type{<:Integer}, ::Type{A}, ::Type) where {A<:Integer} = A
 _promote_array_type(::typeof(/), ::Type{<:Integer}, ::Type{<:Integer}, T::Type) = T
 _promote_array_type(::typeof(\), ::Type{<:Integer}, ::Type{<:Integer}, T::Type) = T
 _promote_array_type(::typeof(/), ::Type{<:Integer}, ::Type{Bool}, T::Type) = T
 _promote_array_type(::typeof(\), ::Type{<:Integer}, ::Type{Bool}, T::Type) = T
 _promote_array_type(F, ::Type{<:Integer}, ::Type{Bool}, T::Type) = T
-_promote_array_type{T<:AbstractFloat}(F, ::Type{<:Union{Complex, Real}}, ::Type{Complex{T}}, ::Type) = Complex{T}
+_promote_array_type(F, ::Type{<:Union{Complex, Real}}, ::Type{Complex{T}}, ::Type) where {T<:AbstractFloat} = Complex{T}
 function promote_array_type(F, R, S, T)
     Base.depwarn("`promote_array_type` is deprecated as it is no longer needed " *
                  "in Base. See https://github.com/JuliaLang/julia/issues/19669 " *
@@ -739,8 +758,8 @@ end
 @deprecate round(M::Bidiagonal) round.(M)
 @deprecate round(M::Tridiagonal) round.(M)
 @deprecate round(M::SymTridiagonal) round.(M)
-@deprecate round{T}(::Type{T}, x::AbstractArray) round.(T, x)
-@deprecate round{T}(::Type{T}, x::AbstractArray, r::RoundingMode) round.(T, x, r)
+@deprecate round(::Type{T}, x::AbstractArray) where {T} round.(T, x)
+@deprecate round(::Type{T}, x::AbstractArray, r::RoundingMode) where {T} round.(T, x, r)
 @deprecate round(x::AbstractArray, r::RoundingMode) round.(x, r)
 @deprecate round(x::AbstractArray, digits::Integer, base::Integer = 10) round.(x, digits, base)
 
@@ -748,21 +767,21 @@ end
 @deprecate trunc(M::Bidiagonal) trunc.(M)
 @deprecate trunc(M::Tridiagonal) trunc.(M)
 @deprecate trunc(M::SymTridiagonal) trunc.(M)
-@deprecate trunc{T}(::Type{T}, x::AbstractArray) trunc.(T, x)
+@deprecate trunc(::Type{T}, x::AbstractArray) where {T} trunc.(T, x)
 @deprecate trunc(x::AbstractArray, digits::Integer, base::Integer = 10) trunc.(x, digits, base)
 
 # Deprecate manually vectorized floor methods in favor of compact broadcast syntax
 @deprecate floor(M::Bidiagonal) floor.(M)
 @deprecate floor(M::Tridiagonal) floor.(M)
 @deprecate floor(M::SymTridiagonal) floor.(M)
-@deprecate floor{T}(::Type{T}, A::AbstractArray) floor.(T, A)
+@deprecate floor(::Type{T}, A::AbstractArray) where {T} floor.(T, A)
 @deprecate floor(A::AbstractArray, digits::Integer, base::Integer = 10) floor.(A, digits, base)
 
 # Deprecate manually vectorized ceil methods in favor of compact broadcast syntax
 @deprecate ceil(M::Bidiagonal) ceil.(M)
 @deprecate ceil(M::Tridiagonal) ceil.(M)
 @deprecate ceil(M::SymTridiagonal) ceil.(M)
-@deprecate ceil{T}(::Type{T}, x::AbstractArray) ceil.(T, x)
+@deprecate ceil(::Type{T}, x::AbstractArray) where {T} ceil.(T, x)
 @deprecate ceil(x::AbstractArray, digits::Integer, base::Integer = 10) ceil.(x, digits, base)
 
 # Deprecate manually vectorized `big` methods in favor of compact broadcast syntax
@@ -791,10 +810,10 @@ end
 @deprecate rem(A::AbstractArray, B::Number) rem.(A, B)
 
 # Deprecate manually vectorized div, mod, and % methods for dates
-@deprecate div{P<:Dates.Period}(X::StridedArray{P}, y::P)         div.(X, y)
+@deprecate div(X::StridedArray{P}, y::P) where {P<:Dates.Period}  div.(X, y)
 @deprecate div(X::StridedArray{<:Dates.Period}, y::Integer)       div.(X, y)
-@deprecate (%){P<:Dates.Period}(X::StridedArray{P}, y::P)         X .% y
-@deprecate mod{P<:Dates.Period}(X::StridedArray{P}, y::P)         mod.(X, y)
+@deprecate (%)(X::StridedArray{P}, y::P) where {P<:Dates.Period}  X .% y
+@deprecate mod(X::StridedArray{P}, y::P) where {P<:Dates.Period}  mod.(X, y)
 
 # Deprecate manually vectorized mod methods in favor of compact broadcast syntax
 @deprecate mod(B::BitArray, x::Bool) mod.(B, x)
@@ -826,13 +845,16 @@ end
 # Deprecate vectorized !
 @deprecate(!(A::AbstractArray{Bool}), .!A) # parens for #20541
 @deprecate(!(B::BitArray), .!B) # parens for #20541
+!(::typeof(()->())) = () # make sure ! has at least 4 methods so that for-loops don't end up getting a back-edge to depwarn
 
 # Deprecate vectorized ~
 @deprecate ~(A::AbstractArray) .~A
 @deprecate ~(B::BitArray) .~B
 
 function frexp(A::Array{<:AbstractFloat})
-    depwarn("`frexp(x::Array)` is discontinued.", :frexp)
+    depwarn(string("`frexp(x::Array)` is discontinued. Though not a direct replacement, ",
+                   "consider using dot-syntax to `broadcast` scalar `frexp` over `Array`s ",
+                   "instead, for example `frexp.(rand(4))`."), :frexp)
     F = similar(A)
     E = Array{Int}(size(A))
     for (iF, iE, iA) in zip(eachindex(F), eachindex(E), eachindex(A))
@@ -1006,7 +1028,7 @@ isempty(::Task) = error("isempty not defined for Tasks")
         end
     end
 
-    array_eps{T}(a::AbstractArray{Complex{T}}) = eps(float(maximum(x->(isfinite(x) ? abs(x) : T(NaN)), a)))
+    array_eps(a::AbstractArray{Complex{T}}) where {T} = eps(float(maximum(x->(isfinite(x) ? abs(x) : T(NaN)), a)))
     array_eps(a) = eps(float(maximum(x->(isfinite(x) ? abs(x) : oftype(x,NaN)), a)))
 
     test_approx_eq(va, vb, astr, bstr) =
@@ -1052,7 +1074,7 @@ function partial_linear_indexing_warning_lookup(nidxs_remaining)
         for frame in bt
             lkups = StackTraces.lookup(frame)
             for caller in lkups
-                if caller === StackTraces.UNKNOWN
+                if caller == StackTraces.UNKNOWN
                     continue
                 end
                 found && @goto found
@@ -1080,25 +1102,25 @@ function partial_linear_indexing_warning(n)
 end
 
 # Deprecate Array(T, dims...) in favor of proper type constructors
-@deprecate Array{T,N}(::Type{T}, d::NTuple{N,Int})               Array{T}(d)
-@deprecate Array{T}(::Type{T}, d::Int...)                        Array{T}(d...)
-@deprecate Array{T}(::Type{T}, m::Int)                           Array{T}(m)
-@deprecate Array{T}(::Type{T}, m::Int,n::Int)                    Array{T}(m,n)
-@deprecate Array{T}(::Type{T}, m::Int,n::Int,o::Int)             Array{T}(m,n,o)
-@deprecate Array{T}(::Type{T}, d::Integer...)                    Array{T}(convert(Tuple{Vararg{Int}}, d))
-@deprecate Array{T}(::Type{T}, m::Integer)                       Array{T}(Int(m))
-@deprecate Array{T}(::Type{T}, m::Integer,n::Integer)            Array{T}(Int(m),Int(n))
-@deprecate Array{T}(::Type{T}, m::Integer,n::Integer,o::Integer) Array{T}(Int(m),Int(n),Int(o))
+@deprecate Array(::Type{T}, d::NTuple{N,Int}) where {T,N}               Array{T}(d)
+@deprecate Array(::Type{T}, d::Int...) where {T}                        Array{T}(d...)
+@deprecate Array(::Type{T}, m::Int) where {T}                           Array{T}(m)
+@deprecate Array(::Type{T}, m::Int,n::Int) where {T}                    Array{T}(m,n)
+@deprecate Array(::Type{T}, m::Int,n::Int,o::Int) where {T}             Array{T}(m,n,o)
+@deprecate Array(::Type{T}, d::Integer...) where {T}                    Array{T}(convert(Tuple{Vararg{Int}}, d))
+@deprecate Array(::Type{T}, m::Integer) where {T}                       Array{T}(Int(m))
+@deprecate Array(::Type{T}, m::Integer,n::Integer) where {T}            Array{T}(Int(m),Int(n))
+@deprecate Array(::Type{T}, m::Integer,n::Integer,o::Integer) where {T} Array{T}(Int(m),Int(n),Int(o))
 
 # Likewise for SharedArrays
-@deprecate SharedArray{T,N}(::Type{T}, dims::Dims{N}; kwargs...) SharedArray{T}(dims; kwargs...)
-@deprecate SharedArray{T}(::Type{T}, dims::Int...; kwargs...)    SharedArray{T}(dims...; kwargs...)
-@deprecate(SharedArray{T,N}(filename::AbstractString, ::Type{T}, dims::NTuple{N,Int}, offset; kwargs...),
+@deprecate SharedArray(::Type{T}, dims::Dims{N}; kwargs...) where {T,N} SharedArray{T}(dims; kwargs...)
+@deprecate SharedArray(::Type{T}, dims::Int...; kwargs...) where {T}    SharedArray{T}(dims...; kwargs...)
+@deprecate(SharedArray(filename::AbstractString, ::Type{T}, dims::NTuple{N,Int}, offset; kwargs...) where {T,N},
            SharedArray{T}(filename, dims, offset; kwargs...))
-@deprecate(SharedArray{T}(filename::AbstractString, ::Type{T}, dims::NTuple, offset; kwargs...),
+@deprecate(SharedArray(filename::AbstractString, ::Type{T}, dims::NTuple, offset; kwargs...) where {T},
            SharedArray{T}(filename, dims, offset; kwargs...))
 
-@noinline function is_intrinsic_expr(x::ANY)
+@noinline function is_intrinsic_expr(@nospecialize(x))
     Base.depwarn("is_intrinsic_expr is deprecated. There are no intrinsic functions anymore.", :is_intrinsic_expr)
     return false
 end
@@ -1106,14 +1128,14 @@ end
 @deprecate EachLine(stream, ondone) EachLine(stream, ondone=ondone)
 
 # These conversions should not be defined, see #19896
-@deprecate convert{T<:Number}(::Type{T}, x::Dates.Period) convert(T, Dates.value(x))
-@deprecate convert{T<:Dates.Period}(::Type{T}, x::Real)   T(x)
-@deprecate convert{R<:Real}(::Type{R}, x::Dates.DateTime) R(Dates.value(x))
-@deprecate convert{R<:Real}(::Type{R}, x::Dates.Date)     R(Dates.value(x))
-@deprecate convert(::Type{Dates.DateTime}, x::Real)       Dates.DateTime(Dates.Millisecond(x))
-@deprecate convert(::Type{Dates.Date}, x::Real)           Dates.Date(Dates.Day(x))
-
-function colon{T<:Dates.Period}(start::T, stop::T)
+@deprecate convert(::Type{T}, x::Dates.Period) where {T<:Number} convert(T, Dates.value(x))
+@deprecate convert(::Type{T}, x::Real) where {T<:Dates.Period}   T(x)
+@deprecate convert(::Type{R}, x::Dates.DateTime) where {R<:Real} R(Dates.value(x))
+@deprecate convert(::Type{R}, x::Dates.Date) where {R<:Real}     R(Dates.value(x))
+@deprecate convert(::Type{Dates.DateTime}, x::Real)              Dates.DateTime(Dates.Millisecond(x))
+@deprecate convert(::Type{Dates.Date}, x::Real)                  Dates.Date(Dates.Day(x))
+
+function colon(start::T, stop::T) where T<:Dates.Period
     depwarn("$start:$stop is deprecated, use $start:$T(1):$stop instead.", :colon)
     colon(start, T(1), stop)
 end
@@ -1124,13 +1146,22 @@ end
      Base.@deprecate_binding GitAnyObject GitUnknownObject
 
      @deprecate owner(x) repository(x) false
-     @deprecate get{T<:GitObject}(::Type{T}, repo::GitRepo, x) T(repo, x) false
-     @deprecate get{T<:GitObject}(::Type{T}, repo::GitRepo, oid::GitHash, oid_size::Int) T(repo, GitShortHash(oid, oid_size)) false
+     @deprecate get(::Type{T}, repo::GitRepo, x) where {T<:GitObject} T(repo, x) false
+     @deprecate get(::Type{T}, repo::GitRepo, oid::GitHash, oid_size::Int) where {T<:GitObject} T(repo, GitShortHash(oid, oid_size)) false
      @deprecate revparse(repo::GitRepo, objname::AbstractString) GitObject(repo, objname) false
      @deprecate object(repo::GitRepo, te::GitTreeEntry) GitObject(repo, te) false
      @deprecate commit(ann::GitAnnotated) GitHash(ann) false
-     @deprecate cat{T<:GitObject}(repo::GitRepo, ::Type{T}, object::AbstractString) cat(repo, object)
      @deprecate lookup(repo::GitRepo, oid::GitHash) GitBlob(repo, oid) false
+    function Base.cat(repo::GitRepo, ::Type{T}, spec::Union{AbstractString,AbstractGitHash}) where T<:GitObject
+        Base.depwarn("cat(repo::GitRepo, T, spec) is deprecated, use content(T(repo, spec))", :cat)
+        try
+            return content(GitBlob(repo, spec))
+        catch e
+            isa(e, LibGit2.GitError) && return nothing
+            rethrow(e)
+        end
+    end
+    Base.cat(repo::GitRepo, spec::Union{AbstractString,AbstractGitHash}) = cat(repo, GitBlob, spec)
 end
 
 # when this deprecation is deleted, remove all calls to it, and all
@@ -1156,7 +1187,7 @@ end
 ## the replacement StepRangeLen also has 4 real-valued fields, which
 ## makes deprecation tricky. See #20506.
 
-immutable Use_StepRangeLen_Instead{T<:AbstractFloat} <: Range{T}
+struct Use_StepRangeLen_Instead{T<:AbstractFloat} <: Range{T}
     start::T
     step::T
     len::T
@@ -1172,16 +1203,16 @@ step(r::Use_StepRangeLen_Instead) = r.step/r.divisor
 
 length(r::Use_StepRangeLen_Instead) = Integer(r.len)
 
-first{T}(r::Use_StepRangeLen_Instead{T}) = convert(T, r.start/r.divisor)
+first(r::Use_StepRangeLen_Instead{T}) where {T} = convert(T, r.start/r.divisor)
 
-last{T}(r::Use_StepRangeLen_Instead{T}) = convert(T, (r.start + (r.len-1)*r.step)/r.divisor)
+last(r::Use_StepRangeLen_Instead{T}) where {T} = convert(T, (r.start + (r.len-1)*r.step)/r.divisor)
 
 start(r::Use_StepRangeLen_Instead) = 0
 done(r::Use_StepRangeLen_Instead, i::Int) = length(r) <= i
-next{T}(r::Use_StepRangeLen_Instead{T}, i::Int) =
+next(r::Use_StepRangeLen_Instead{T}, i::Int) where {T} =
     (convert(T, (r.start + i*r.step)/r.divisor), i+1)
 
-function getindex{T}(r::Use_StepRangeLen_Instead{T}, i::Integer)
+function getindex(r::Use_StepRangeLen_Instead{T}, i::Integer) where T
     @_inline_meta
     @boundscheck checkbounds(r, i)
     convert(T, (r.start + (i-1)*r.step)/r.divisor)
@@ -1200,24 +1231,24 @@ end
 *(x::Real, r::Use_StepRangeLen_Instead)   = Use_StepRangeLen_Instead(x*r.start, x*r.step, r.len, r.divisor)
 *(r::Use_StepRangeLen_Instead, x::Real)   = x * r
 /(r::Use_StepRangeLen_Instead, x::Real)   = Use_StepRangeLen_Instead(r.start/x, r.step/x, r.len, r.divisor)
-promote_rule{T1,T2}(::Type{Use_StepRangeLen_Instead{T1}},::Type{Use_StepRangeLen_Instead{T2}}) =
+promote_rule(::Type{Use_StepRangeLen_Instead{T1}},::Type{Use_StepRangeLen_Instead{T2}}) where {T1,T2} =
     Use_StepRangeLen_Instead{promote_type(T1,T2)}
-convert{T<:AbstractFloat}(::Type{Use_StepRangeLen_Instead{T}}, r::Use_StepRangeLen_Instead{T}) = r
-convert{T<:AbstractFloat}(::Type{Use_StepRangeLen_Instead{T}}, r::Use_StepRangeLen_Instead) =
+convert(::Type{Use_StepRangeLen_Instead{T}}, r::Use_StepRangeLen_Instead{T}) where {T<:AbstractFloat} = r
+convert(::Type{Use_StepRangeLen_Instead{T}}, r::Use_StepRangeLen_Instead) where {T<:AbstractFloat} =
     Use_StepRangeLen_Instead{T}(r.start,r.step,r.len,r.divisor)
 
-promote_rule{F,OR<:OrdinalRange}(::Type{Use_StepRangeLen_Instead{F}}, ::Type{OR}) =
+promote_rule(::Type{Use_StepRangeLen_Instead{F}}, ::Type{OR}) where {F,OR<:OrdinalRange} =
     Use_StepRangeLen_Instead{promote_type(F,eltype(OR))}
-convert{T<:AbstractFloat}(::Type{Use_StepRangeLen_Instead{T}}, r::OrdinalRange) =
+convert(::Type{Use_StepRangeLen_Instead{T}}, r::OrdinalRange) where {T<:AbstractFloat} =
     Use_StepRangeLen_Instead{T}(first(r), step(r), length(r), one(T))
-convert{T}(::Type{Use_StepRangeLen_Instead}, r::OrdinalRange{T}) =
+convert(::Type{Use_StepRangeLen_Instead}, r::OrdinalRange{T}) where {T} =
     Use_StepRangeLen_Instead{typeof(float(first(r)))}(first(r), step(r), length(r), one(T))
 
-promote_rule{F,OR<:Use_StepRangeLen_Instead}(::Type{LinSpace{F}}, ::Type{OR}) =
+promote_rule(::Type{LinSpace{F}}, ::Type{OR}) where {F,OR<:Use_StepRangeLen_Instead} =
     LinSpace{promote_type(F,eltype(OR))}
-convert{T<:AbstractFloat}(::Type{LinSpace{T}}, r::Use_StepRangeLen_Instead) =
+convert(::Type{LinSpace{T}}, r::Use_StepRangeLen_Instead) where {T<:AbstractFloat} =
     linspace(convert(T, first(r)), convert(T, last(r)), convert(T, length(r)))
-convert{T<:AbstractFloat}(::Type{LinSpace}, r::Use_StepRangeLen_Instead{T}) =
+convert(::Type{LinSpace}, r::Use_StepRangeLen_Instead{T}) where {T<:AbstractFloat} =
     convert(LinSpace{T}, r)
 
 reverse(r::Use_StepRangeLen_Instead)   = Use_StepRangeLen_Instead(r.start + (r.len-1)*r.step, -r.step, r.len, r.divisor)
@@ -1238,7 +1269,7 @@ end
 
 @noinline zero_arg_matrix_constructor(prefix::String) =
     depwarn("$prefix() is deprecated, use $prefix(0, 0) instead.", :zero_arg_matrix_constructor)
-function (::Type{Matrix{T}}){T}()
+function (::Type{Matrix{T}})() where T
     zero_arg_matrix_constructor("Matrix{T}")
     return Matrix{T}(0, 0)
 end
@@ -1263,14 +1294,7 @@ for f in (:airyai, :airyaiprime, :airybi, :airybiprime, :airyaix, :airyaiprimex,
           :eta, :zeta, :digamma, :invdigamma, :polygamma, :trigamma,
           :hankelh1, :hankelh1x, :hankelh2, :hankelh2x,
           :airy, :airyx, :airyprime)
-    @eval begin
-        function $f(args...; kwargs...)
-            error(string($f, args, " has been moved to the package SpecialFunctions.jl.\n",
-                         "Run Pkg.add(\"SpecialFunctions\") to install SpecialFunctions on Julia v0.6 and later,\n",
-                         "and then run `using SpecialFunctions`."))
-        end
-        export $f
-    end
+    @eval @deprecate_moved $f "SpecialFunctions"
 end
 
 @deprecate_binding LinearIndexing IndexStyle false
@@ -1278,9 +1302,303 @@ end
 @deprecate_binding LinearSlow IndexCartesian false
 @deprecate_binding linearindexing IndexStyle false
 
-@deprecate isleaftype isconcrete
+# #20876
+@eval Base.Dates begin
+    function Base.Dates.parse(x::AbstractString, df::DateFormat)
+        Base.depwarn(string(
+            "`Dates.parse(x::AbstractString, df::DateFormat)` is deprecated, use ",
+            "`sort!(filter!(el -> isa(el, Dates.Period), Dates.parse_components(x, df), rev=true, lt=Dates.periodisless)` ",
+            " instead."), :parse)
+        sort!(filter!(el -> isa(el, Period), parse_components(x, df)), rev=true, lt=periodisless)
+     end
+end
+
+# PR #16984
+@deprecate MersenneTwister() MersenneTwister(0)
+
+# #19635
+for fname in (:ones, :zeros)
+    @eval @deprecate ($fname)(T::Type, arr) ($fname)(T, size(arr))
+    @eval ($fname)(T::Type, i::Integer) = ($fname)(T, (i,))
+    @eval function ($fname)(::Type{T}, arr::Array{T}) where T
+        msg = string("`", $fname, "{T}(::Type{T}, arr::Array{T})` is deprecated, use ",
+                            "`", $fname , "(T, size(arr))` instead. ",
+                           )
+        error(msg)
+    end
+end
 
 # END 0.6 deprecations
 
+# BEGIN 0.7 deprecations
+
+@deprecate issubtype (<:)
+
+# 12807
+start(::Union{Process, ProcessChain}) = 1
+done(::Union{Process, ProcessChain}, i::Int) = (i == 3)
+next(p::Union{Process, ProcessChain}, i::Int) = (getindex(p, i), i + 1)
+@noinline function getindex(p::Union{Process, ProcessChain}, i::Int)
+    depwarn("open(cmd) now returns only a Process<:IO object", :getindex)
+    return i == 1 ? getfield(p, p.openstream) : p
+end
+
+@deprecate cond(F::LinAlg.LU, p::Integer) cond(full(F), p)
+
+# PR #21359
+@deprecate srand(r::MersenneTwister, filename::AbstractString, n::Integer=4) srand(r, read!(filename, Array{UInt32}(Int(n))))
+@deprecate srand(filename::AbstractString, n::Integer=4) srand(read!(filename, Array{UInt32}(Int(n))))
+@deprecate MersenneTwister(filename::AbstractString)  srand(MersenneTwister(0), read!(filename, Array{UInt32}(Int(4))))
+
+# PR #21974
+@deprecate versioninfo(verbose::Bool) versioninfo(verbose=verbose)
+@deprecate versioninfo(io::IO, verbose::Bool) versioninfo(io, verbose=verbose)
+
+# PR #22188
+@deprecate cholfact!(A::StridedMatrix, uplo::Symbol, ::Type{Val{false}}) cholfact!(Hermitian(A, uplo), Val(false))
+@deprecate cholfact!(A::StridedMatrix, uplo::Symbol) cholfact!(Hermitian(A, uplo))
+@deprecate cholfact(A::StridedMatrix, uplo::Symbol, ::Type{Val{false}}) cholfact(Hermitian(A, uplo), Val(false))
+@deprecate cholfact(A::StridedMatrix, uplo::Symbol) cholfact(Hermitian(A, uplo))
+@deprecate cholfact!(A::StridedMatrix, uplo::Symbol, ::Type{Val{true}}; tol = 0.0) cholfact!(Hermitian(A, uplo), Val(true), tol = tol)
+@deprecate cholfact(A::StridedMatrix, uplo::Symbol, ::Type{Val{true}}; tol = 0.0) cholfact(Hermitian(A, uplo), Val(true), tol = tol)
+
+# PR #22245
+@deprecate isposdef(A::AbstractMatrix, UL::Symbol) isposdef(Hermitian(A, UL))
+@deprecate isposdef!(A::StridedMatrix, UL::Symbol) isposdef!(Hermitian(A, UL))
+
+# also remove all support machinery in src for current_module when removing this deprecation
+# and make Base.include an error
+_current_module() = ccall(:jl_get_current_module, Ref{Module}, ())
+@noinline function binding_module(s::Symbol)
+    depwarn("binding_module(symbol) is deprecated, use `binding_module(module, symbol)` instead.", :binding_module)
+    return binding_module(_current_module(), s)
+end
+@noinline function expand(@nospecialize(x))
+    depwarn("expand(x) is deprecated, use `expand(module, x)` instead.", :expand)
+    return expand(_current_module(), x)
+end
+@noinline function macroexpand(@nospecialize(x))
+    depwarn("macroexpand(x) is deprecated, use `macroexpand(module, x)` instead.", :macroexpand)
+    return macroexpand(_current_module(), x)
+end
+@noinline function isconst(s::Symbol)
+    depwarn("isconst(symbol) is deprecated, use `isconst(module, symbol)` instead.", :isconst)
+    return isconst(_current_module(), s)
+end
+@noinline function include_string(txt::AbstractString, fname::AbstractString)
+    depwarn("include_string(string, fname) is deprecated, use `include_string(module, string, fname)` instead.", :include_string)
+    return include_string(_current_module(), txt, fname)
+end
+@noinline function include_string(txt::AbstractString)
+    depwarn("include_string(string) is deprecated, use `include_string(module, string)` instead.", :include_string)
+    return include_string(_current_module(), txt, "string")
+end
+
+"""
+    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.
+
+DEPRECATED: use @__MODULE__ instead
+"""
+@noinline function current_module()
+    depwarn("current_module() is deprecated, use `@__MODULE__` instead.", :current_module)
+    return _current_module()
+end
+export current_module
+
+# PR #22062
+function LibGit2.set_remote_url(repo::LibGit2.GitRepo, url::AbstractString; remote::AbstractString="origin")
+    Base.depwarn(string(
+        "`LibGit2.set_remote_url(repo, url; remote=remote)` is deprecated, use ",
+        "`LibGit2.set_remote_url(repo, remote, url)` instead."), :set_remote_url)
+    LibGit2.set_remote_url(repo, remote, url)
+end
+function LibGit2.set_remote_url(path::AbstractString, url::AbstractString; remote::AbstractString="origin")
+    Base.depwarn(string(
+        "`LibGit2.set_remote_url(path, url; remote=remote)` is deprecated, use ",
+        "`LibGit2.set_remote_url(path, remote, url)` instead."), :set_remote_url)
+    LibGit2.set_remote_url(path, remote, url)
+end
+
+module Operators
+    for op in [:!, :(!=), :(!==), :%, :&, :*, :+, :-, :/, ://, :<, :<:, :<<, :(<=),
+               :<|, :(==), :(===), :>, :>:, :(>=), :>>, :>>>, :\, :^, :colon,
+               :ctranspose, :getindex, :hcat, :hvcat, :setindex!, :transpose, :vcat,
+               :xor, :|, :|>, :~, :×, :÷, :∈, :∉, :∋, :∌, :∘, :√, :∛, :∩, :∪, :≠, :≤,
+               :≥, :⊆, :⊈, :⊊, :⊻, :⋅]
+        if isdefined(Base, op)
+            @eval Base.@deprecate_binding $op Base.$op
+        end
+    end
+end
+export Operators
+
+# PR #21956
+# This mimics the structure as it was defined in Base to avoid directly breaking code
+# that assumes this structure
+module DFT
+    for f in [:bfft, :bfft!, :brfft, :dct, :dct!, :fft, :fft!, :fftshift, :idct, :idct!,
+              :ifft, :ifft!, :ifftshift, :irfft, :plan_bfft, :plan_bfft!, :plan_brfft,
+              :plan_dct, :plan_dct!, :plan_fft, :plan_fft!, :plan_idct, :plan_idct!,
+              :plan_ifft, :plan_ifft!, :plan_irfft, :plan_rfft, :rfft]
+        pkg = endswith(String(f), "shift") ? "AbstractFFTs" : "FFTW"
+        @eval Base.@deprecate_moved $f $pkg
+    end
+    module FFTW
+        for f in [:r2r, :r2r!, :plan_r2r, :plan_r2r!]
+            @eval Base.@deprecate_moved $f "FFTW"
+        end
+    end
+    export FFTW
+end
+using .DFT
+for f in filter(s -> isexported(DFT, s), names(DFT, true))
+    @eval export $f
+end
+module DSP
+    for f in [:conv, :conv2, :deconv, :filt, :filt!, :xcorr]
+        @eval Base.@deprecate_moved $f "DSP"
+    end
+end
+using .DSP
+export conv, conv2, deconv, filt, filt!, xcorr
+
+# PR #21709
+@deprecate cov(x::AbstractVector, corrected::Bool) cov(x, corrected=corrected)
+@deprecate cov(x::AbstractMatrix, vardim::Int, corrected::Bool) cov(x, vardim, corrected=corrected)
+@deprecate cov(X::AbstractVector, Y::AbstractVector, corrected::Bool) cov(X, Y, corrected=corrected)
+@deprecate cov(X::AbstractVecOrMat, Y::AbstractVecOrMat, vardim::Int, corrected::Bool) cov(X, Y, vardim, corrected=corrected)
+
+# bkfact
+function bkfact(A::StridedMatrix, uplo::Symbol, symmetric::Bool = issymmetric(A), rook::Bool = false)
+    depwarn("bkfact with uplo and symmetric arguments deprecated. Please use bkfact($(symmetric ? "Symmetric(" : "Hermitian(")A, :$uplo))",
+        :bkfact)
+    return bkfact(symmetric ? Symmetric(A, uplo) : Hermitian(A, uplo), rook)
+end
+function bkfact!(A::StridedMatrix, uplo::Symbol, symmetric::Bool = issymmetric(A), rook::Bool = false)
+    depwarn("bkfact! with uplo and symmetric arguments deprecated. Please use bkfact!($(symmetric ? "Symmetric(" : "Hermitian(")A, :$uplo))",
+        :bkfact!)
+    return bkfact!(symmetric ? Symmetric(A, uplo) : Hermitian(A, uplo), rook)
+end
+
+# PR #22325
+# TODO: when this replace is removed from deprecated.jl:
+# 1) rename the function replace_new from strings/util.jl to replace
+# 2) update the replace(s::AbstractString, pat, f) method, below replace_new
+#    (see instructions there)
+function replace(s::AbstractString, pat, f, n::Integer)
+    if n <= 0
+        depwarn(string("`replace(s, pat, r, count)` with `count <= 0` is deprecated, use ",
+                       "`replace(s, pat, r, typemax(Int))` or `replace(s, pat, r)` instead"),
+                :replace)
+        replace(s, pat, f)
+    else
+        replace_new(String(s), pat, f, n)
+    end
+end
+
+# PR #22475
+@deprecate ntuple(f, ::Type{Val{N}}) where {N}  ntuple(f, Val(N))
+@deprecate fill_to_length(t, val, ::Type{Val{N}}) where {N} fill_to_length(t, val, Val(N)) false
+@deprecate literal_pow(a, b, ::Type{Val{N}}) where {N} literal_pow(a, b, Val(N)) false
+@eval IteratorsMD @deprecate split(t, V::Type{Val{n}}) where {n} split(t, Val(n)) false
+@deprecate sqrtm(A::UpperTriangular{T},::Type{Val{realmatrix}}) where {T,realmatrix} sqrtm(A, Val(realmatrix))
+@deprecate lufact(A::AbstractMatrix, ::Type{Val{false}}) lufact(A, Val(false))
+@deprecate lufact(A::AbstractMatrix, ::Type{Val{true}}) lufact(A, Val(true))
+@deprecate lufact!(A::AbstractMatrix, ::Type{Val{false}}) lufact!(A, Val(false))
+@deprecate lufact!(A::AbstractMatrix, ::Type{Val{true}}) lufact!(A, Val(true))
+@deprecate qrfact(A::AbstractMatrix, ::Type{Val{false}}) qrfact(A, Val(false))
+@deprecate qrfact(A::AbstractMatrix, ::Type{Val{true}}) qrfact(A, Val(true))
+@deprecate qrfact!(A::AbstractMatrix, ::Type{Val{false}}) qrfact!(A, Val(false))
+@deprecate qrfact!(A::AbstractMatrix, ::Type{Val{true}}) qrfact!(A, Val(true))
+@deprecate cholfact(A::AbstractMatrix, ::Type{Val{false}}) cholfact(A, Val(false))
+@deprecate cholfact(A::AbstractMatrix, ::Type{Val{true}}; tol = 0.0) cholfact(A, Val(true); tol = tol)
+@deprecate cholfact!(A::AbstractMatrix, ::Type{Val{false}}) cholfact!(A, Val(false))
+@deprecate cholfact!(A::AbstractMatrix, ::Type{Val{true}}; tol = 0.0) cholfact!(A, Val(true); tol = tol)
+@deprecate cat(::Type{Val{N}}, A::AbstractArray...) where {N} cat(Val(N), A...)
+@deprecate cat(::Type{Val{N}}, A::SparseArrays._SparseConcatGroup...) where {N} cat(Val(N), A...)
+@deprecate cat(::Type{Val{N}}, A::SparseArrays._DenseConcatGroup...) where {N} cat(Val(N), A...)
+@deprecate cat_t(::Type{Val{N}}, ::Type{T}, A, B) where {N,T} cat_t(Val(N), T, A, B) false
+@deprecate reshape(A::AbstractArray, ::Type{Val{N}}) where {N} reshape(A, Val(N))
+
+@deprecate read(s::IO, x::Ref) read!(s, x)
+
+@deprecate read(s::IO, t::Type, d1::Int, dims::Int...) read!(s, Array{t}(tuple(d1,dims...)))
+@deprecate read(s::IO, t::Type, d1::Integer, dims::Integer...) read!(s, Array{t}(convert(Tuple{Vararg{Int}},tuple(d1,dims...))))
+@deprecate read(s::IO, t::Type, dims::Dims) read!(s, Array{t}(dims))
+
+function CartesianRange(start::CartesianIndex{N}, stop::CartesianIndex{N}) where N
+    inds = map((f,l)->f:l, start.I, stop.I)
+    depwarn("the internal representation of CartesianRange has changed, use CartesianRange($inds) (or other more approriate AbstractUnitRange type) instead.", :CartesianRange)
+    CartesianRange(inds)
+end
+
+# PR #20005
+function InexactError()
+    depwarn("InexactError now supports arguments, use `InexactError(funcname::Symbol, ::Type, value)` instead.", :InexactError)
+    InexactError(:none, Any, nothing)
+end
+
+# PR #22751
+function DomainError()
+    depwarn("DomainError now supports arguments, use `DomainError(value)` or `DomainError(value, msg)` instead.", :DomainError)
+    DomainError(nothing)
+end
+
+# PR #22703
+@deprecate Bidiagonal(dv::AbstractVector, ev::AbstractVector, isupper::Bool) Bidiagonal(dv, ev, ifelse(isupper, :U, :L))
+@deprecate Bidiagonal(dv::AbstractVector, ev::AbstractVector, uplo::Char) Bidiagonal(dv, ev, ifelse(uplo == 'U', :U, :L))
+@deprecate Bidiagonal(A::AbstractMatrix, isupper::Bool) Bidiagonal(A, ifelse(isupper, :U, :L))
+
+@deprecate fieldnames(v) fieldnames(typeof(v))
+# nfields(::Type) deprecation in builtins.c: update nfields tfunc in inference.jl when it is removed.
+# also replace `_nfields` with `nfields` in summarysize.c when this is removed.
+
+# ::ANY is deprecated in src/method.c
+# also remove all instances of `jl_ANY_flag` in src/
+
+# issue #13079
+# in julia-parser.scm:
+#     move prec-bitshift after prec-rational
+#     remove parse-with-chains-warn and bitshift-warn
+# update precedence table in doc/src/manual/mathematical-operations.md
+
+# PR #22182
+@deprecate is_apple   Sys.isapple
+@deprecate is_bsd     Sys.isbsd
+@deprecate is_linux   Sys.islinux
+@deprecate is_unix    Sys.isunix
+@deprecate is_windows Sys.iswindows
+
+@deprecate read(cmd::AbstractCmd, stdin::Redirectable) read(pipeline(stdin, cmd))
+@deprecate readstring(cmd::AbstractCmd, stdin::Redirectable) readstring(pipeline(stdin, cmd))
+@deprecate eachline(cmd::AbstractCmd, stdin; chomp::Bool=true) eachline(pipeline(stdin, cmd), chomp=chomp)
+
+@deprecate showall(x)     show(x)
+@deprecate showall(io, x) show(IOContext(io, :limit => false), x)
+
+@deprecate_binding AbstractIOBuffer GenericIOBuffer false
+
+@deprecate String(io::GenericIOBuffer) String(take!(copy(io)))
+
+@deprecate readstring(s::IO) read(s, String)
+@deprecate readstring(filename::AbstractString) read(filename, String)
+@deprecate readstring(cmd::AbstractCmd) read(cmd, String)
+
+# issue #11310
+# remove "parametric method syntax" deprecation in julia-syntax.scm
+
+@deprecate momenttype(::Type{T}) where {T} typeof((zero(T)*zero(T) + zero(T)*zero(T))/2) false
+
+# issue #6466
+# `write` on non-isbits arrays is deprecated in io.jl.
+        
+@deprecate isleaftype isconcrete
+
+# END 0.7 deprecations
+
 # BEGIN 1.0 deprecations
+
 # END 1.0 deprecations
diff --git a/base/dft.jl b/base/dft.jl
deleted file mode 100644
index bbef1f433e550b..00000000000000
--- a/base/dft.jl
+++ /dev/null
@@ -1,442 +0,0 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
-
-module DFT
-
-# DFT plan where the inputs are an array of eltype T
-abstract type Plan{T} end
-
-import Base: show, summary, size, ndims, length, eltype,
-             *, A_mul_B!, inv, \, A_ldiv_B!
-
-eltype{T}(::Type{Plan{T}}) = T
-
-# size(p) should return the size of the input array for p
-size(p::Plan, d) = size(p)[d]
-ndims(p::Plan) = length(size(p))
-length(p::Plan) = prod(size(p))::Int
-
-##############################################################################
-export fft, ifft, bfft, fft!, ifft!, bfft!,
-       plan_fft, plan_ifft, plan_bfft, plan_fft!, plan_ifft!, plan_bfft!,
-       rfft, irfft, brfft, plan_rfft, plan_irfft, plan_brfft
-
-const FFTWFloat = Union{Float32,Float64}
-fftwfloat(x) = _fftwfloat(float(x))
-_fftwfloat{T<:FFTWFloat}(::Type{T}) = T
-_fftwfloat(::Type{Float16}) = Float32
-_fftwfloat{T}(::Type{Complex{T}}) = Complex{_fftwfloat(T)}
-_fftwfloat{T}(::Type{T}) = error("type $T not supported")
-_fftwfloat{T}(x::T) = _fftwfloat(T)(x)
-
-complexfloat(x::StridedArray{Complex{<:FFTWFloat}}) = x
-realfloat(x::StridedArray{<:FFTWFloat}) = x
-
-# return an Array, rather than similar(x), to avoid an extra copy for FFTW
-# (which only works on StridedArray types).
-complexfloat{T<:Complex}(x::AbstractArray{T}) = copy1(typeof(fftwfloat(zero(T))), x)
-complexfloat{T<:Real}(x::AbstractArray{T}) = copy1(typeof(complex(fftwfloat(zero(T)))), x)
-
-realfloat{T<:Real}(x::AbstractArray{T}) = copy1(typeof(fftwfloat(zero(T))), x)
-
-# copy to a 1-based array, using circular permutation
-function copy1{T}(::Type{T}, x)
-    y = Array{T}(map(length, indices(x)))
-    Base.circcopy!(y, x)
-end
-
-to1(x::AbstractArray) = _to1(indices(x), x)
-_to1(::Tuple{Base.OneTo,Vararg{Base.OneTo}}, x) = x
-_to1(::Tuple, x) = copy1(eltype(x), x)
-
-# implementations only need to provide plan_X(x, region)
-# for X in (:fft, :bfft, ...):
-for f in (:fft, :bfft, :ifft, :fft!, :bfft!, :ifft!, :rfft)
-    pf = Symbol("plan_", f)
-    @eval begin
-        $f(x::AbstractArray) = (y = to1(x); $pf(y) * y)
-        $f(x::AbstractArray, region) = (y = to1(x); $pf(y, region) * y)
-        $pf(x::AbstractArray; kws...) = (y = to1(x); $pf(y, 1:ndims(y); kws...))
-    end
-end
-
-"""
-    plan_ifft(A [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
-
-Same as [`plan_fft`](@ref), but produces a plan that performs inverse transforms
-[`ifft`](@ref).
-"""
-plan_ifft
-
-"""
-    plan_ifft!(A [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
-
-Same as [`plan_ifft`](@ref), but operates in-place on `A`.
-"""
-plan_ifft!
-
-"""
-    plan_bfft!(A [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
-
-Same as [`plan_bfft`](@ref), but operates in-place on `A`.
-"""
-plan_bfft!
-
-"""
-    plan_bfft(A [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
-
-Same as [`plan_fft`](@ref), but produces a plan that performs an unnormalized
-backwards transform [`bfft`](@ref).
-"""
-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`](@ref).)
-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)`.  (For `A_mul_B!`, however, the input array `A` must
-be a complex floating-point array like the output `Â`.) 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!`](@ref) is the same as [`plan_fft`](@ref) but creates a
-plan that operates in-place on its argument (which must be an array of complex
-floating-point numbers). [`plan_ifft`](@ref) and so on are similar but produce
-plans that perform the equivalent of the inverse transforms [`ifft`](@ref) and so on.
-"""
-plan_fft
-
-"""
-    plan_fft!(A [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
-
-Same as [`plan_fft`](@ref), 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`](@ref). 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`](@ref). 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`](@ref), 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`](@ref), but operates in-place on `A`, which must be an array of
-complex floating-point numbers.
-"""
-fft!
-
-"""
-    bfft(A [, dims])
-
-Similar to [`ifft`](@ref), 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`](@ref)
-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`](@ref), 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)
-    pf = Symbol("plan_", f)
-    @eval begin
-        $f(x::AbstractArray{<:Real}, region=1:ndims(x)) = $f(complexfloat(x), region)
-        $pf(x::AbstractArray{<:Real}, region; kws...) = $pf(complexfloat(x), region; kws...)
-        $f(x::AbstractArray{<:Complex{<:Union{Integer,Rational}}}, region=1:ndims(x)) = $f(complexfloat(x), region)
-        $pf(x::AbstractArray{<:Complex{<:Union{Integer,Rational}}}, region; kws...) = $pf(complexfloat(x), region; kws...)
-    end
-end
-rfft(x::AbstractArray{<:Union{Integer,Rational}}, region=1:ndims(x)) = rfft(realfloat(x), region)
-plan_rfft(x::AbstractArray, region; kws...) = plan_rfft(realfloat(x), region; kws...)
-
-# only require implementation to provide *(::Plan{T}, ::Array{T})
-*{T}(p::Plan{T}, x::AbstractArray) = p * copy1(T, x)
-
-# Implementations should also implement A_mul_B!(Y, plan, X) so as to support
-# pre-allocated output arrays.  We don't define * in terms of A_mul_B!
-# generically here, however, because of subtleties for in-place and rfft plans.
-
-##############################################################################
-# To support inv, \, and A_ldiv_B!(y, p, x), we require Plan subtypes
-# to have a pinv::Plan field, which caches the inverse plan, and which
-# should be initially undefined.  They should also implement
-# plan_inv(p) to construct the inverse of a plan p.
-
-# hack from @simonster (in #6193) to compute the return type of plan_inv
-# without actually calling it or even constructing the empty arrays.
-_pinv_type(p::Plan) = typeof([plan_inv(x) for x in typeof(p)[]])
-pinv_type(p::Plan) = eltype(_pinv_type(p))
-
-inv(p::Plan) =
-    isdefined(p, :pinv) ? p.pinv::pinv_type(p) : (p.pinv = plan_inv(p))
-\(p::Plan, x::AbstractArray) = inv(p) * x
-A_ldiv_B!(y::AbstractArray, p::Plan, x::AbstractArray) = A_mul_B!(y, inv(p), x)
-
-##############################################################################
-# implementations only need to provide the unnormalized backwards FFT,
-# similar to FFTW, and we do the scaling generically to get the ifft:
-
-mutable struct ScaledPlan{T,P,N} <: Plan{T}
-    p::P
-    scale::N # not T, to avoid unnecessary promotion to Complex
-    pinv::Plan
-    ScaledPlan{T,P,N}(p, scale) where {T,P,N} = new(p, scale)
-end
-ScaledPlan{T}(p::P, scale::N) where {T,P,N} = ScaledPlan{T,P,N}(p, scale)
-ScaledPlan(p::Plan{T}, scale::Number) where {T} = ScaledPlan{T}(p, scale)
-ScaledPlan(p::ScaledPlan, α::Number) = ScaledPlan(p.p, p.scale * α)
-
-size(p::ScaledPlan) = size(p.p)
-
-show(io::IO, p::ScaledPlan) = print(io, p.scale, " * ", p.p)
-summary(p::ScaledPlan) = string(p.scale, " * ", summary(p.p))
-
-*(p::ScaledPlan, x::AbstractArray) = scale!(p.p * x, p.scale)
-
-*(α::Number, p::Plan) = ScaledPlan(p, α)
-*(p::Plan, α::Number) = ScaledPlan(p, α)
-*(I::UniformScaling, p::ScaledPlan) = ScaledPlan(p, I.λ)
-*(p::ScaledPlan, I::UniformScaling) = ScaledPlan(p, I.λ)
-*(I::UniformScaling, p::Plan) = ScaledPlan(p, I.λ)
-*(p::Plan, I::UniformScaling) = ScaledPlan(p, I.λ)
-
-# Normalization for ifft, given unscaled bfft, is 1/prod(dimensions)
-normalization(T, sz, region) = one(T) / Int(prod([sz...][[region...]]))
-normalization(X, region) = normalization(real(eltype(X)), size(X), region)
-
-plan_ifft(x::AbstractArray, region; kws...) =
-    ScaledPlan(plan_bfft(x, region; kws...), normalization(x, region))
-plan_ifft!(x::AbstractArray, region; kws...) =
-    ScaledPlan(plan_bfft!(x, region; kws...), normalization(x, region))
-
-plan_inv(p::ScaledPlan) = ScaledPlan(plan_inv(p.p), inv(p.scale))
-
-A_mul_B!(y::AbstractArray, p::ScaledPlan, x::AbstractArray) =
-    scale!(p.scale, A_mul_B!(y, p.p, x))
-
-##############################################################################
-# Real-input DFTs are annoying because the output has a different size
-# than the input if we want to gain the full factor-of-two(ish) savings
-# For backward real-data transforms, we must specify the original length
-# of the first dimension, since there is no reliable way to detect this
-# from the data (we can't detect whether the dimension was originally even
-# or odd).
-
-for f in (:brfft, :irfft)
-    pf = Symbol("plan_", f)
-    @eval begin
-        $f(x::AbstractArray, d::Integer) = $pf(x, d) * x
-        $f(x::AbstractArray, d::Integer, region) = $pf(x, d, region) * x
-        $pf(x::AbstractArray, d::Integer;kws...) = $pf(x, d, 1:ndims(x);kws...)
-    end
-end
-
-for f in (:brfft, :irfft)
-    @eval begin
-        $f(x::AbstractArray{<:Real}, d::Integer, region=1:ndims(x)) = $f(complexfloat(x), d, region)
-        $f(x::AbstractArray{<:Complex{<:Union{Integer,Rational}}}, d::Integer, region=1:ndims(x)) = $f(complexfloat(x), d, region)
-    end
-end
-
-"""
-    irfft(A, d [, dims])
-
-Inverse of [`rfft`](@ref): for a complex array `A`, gives the corresponding real
-array whose FFT yields `A` in the first half. As for [`rfft`](@ref), `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`](@ref) but computes an unnormalized inverse transform (similar
-to [`bfft`](@ref)), 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)...]
-    osize[d1] = osize[d1]>>1 + 1
-    return osize
-end
-
-function brfft_output_size(x::AbstractArray, d::Integer, region)
-    d1 = first(region)
-    osize = [size(x)...]
-    @assert osize[d1] == d>>1 + 1
-    osize[d1] = d
-    return osize
-end
-
-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`](@ref)
-except for [`irfft`](@ref) and [`brfft`](@ref), respectively. The first
-three arguments have the same meaning as for [`irfft`](@ref).
-"""
-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))
-    for i in dim
-        s[i] = div(size(x,i),2)
-    end
-    circshift(x, s)
-end
-
-"""
-    fftshift(x,dim)
-
-Swap the first and second halves of the given dimension or iterable of dimensions 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))
-    for i in dim
-        s[i] = -div(size(x,i),2)
-    end
-    circshift(x, s)
-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`.
-
-    !!! note
-        * Julia starts FFTW up with 1 thread by default. Higher performance is usually possible by
-          increasing number of threads. Use `FFTW.set_num_threads(Sys.CPU_CORES)` to use as many
-          threads as cores on your system.
-
-        * This performs a multidimensional FFT by default. FFT libraries in other languages such as
-          Python and Octave perform a one-dimensional FFT along the first non-singleton dimension
-          of the array. This is worth noting while performing comparisons. For more details,
-          refer to the [Noteworthy Differences from other Languages](@ref)
-          section of the manual.
-    """ ->
-    fft
-
-    include("fft/FFTW.jl")
-    importall .FFTW
-    export FFTW, dct, idct, dct!, idct!, plan_dct, plan_idct, plan_dct!, plan_idct!
-end
-
-##############################################################################
-
-end
diff --git a/base/dict.jl b/base/dict.jl
index 90dedd9bf4e006..ced9824a6daac2 100644
--- a/base/dict.jl
+++ b/base/dict.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 function _truncate_at_width_or_chars(str, width, chars="", truncmark="…")
     truncwidth = strwidth(truncmark)
@@ -23,7 +23,7 @@ function _truncate_at_width_or_chars(str, width, chars="", truncmark="…")
     end
 end
 
-function show{K,V}(io::IO, t::Associative{K,V})
+function show(io::IO, t::Associative{K,V}) where V where K
     recur_io = IOContext(io, :SHOWN_SET => t)
     limit::Bool = get(io, :limit, false)
     if !haskey(io, :compact)
@@ -135,10 +135,10 @@ copy(d::Dict) = Dict(d)
 
 const AnyDict = Dict{Any,Any}
 
-Dict(ps::Pair{K,V}...) where {K,V}        = Dict{K,V}(ps)
-Dict(ps::Pair{K}...,) where K             = Dict{K,Any}(ps)
-Dict(ps::(Pair{K,V} where K)...,) where V = Dict{Any,V}(ps)
-Dict(ps::Pair...)                         = Dict{Any,Any}(ps)
+Dict(ps::Pair{K,V}...)           where {K,V} = Dict{K,V}(ps)
+Dict(ps::Pair{K}...)             where {K}   = Dict{K,Any}(ps)
+Dict(ps::(Pair{K,V} where K)...) where {V}   = Dict{Any,V}(ps)
+Dict(ps::Pair...)                            = Dict{Any,Any}(ps)
 
 function Dict(kv)
     try
@@ -154,12 +154,12 @@ end
 
 TP{K,V} = Union{Type{Tuple{K,V}},Type{Pair{K,V}}}
 
-associative_with_eltype{K,V}(DT_apply, kv, ::TP{K,V}) = DT_apply(K, V)(kv)
-associative_with_eltype{K,V}(DT_apply, kv::Generator, ::TP{K,V}) = DT_apply(K, V)(kv)
-associative_with_eltype{K,V}(DT_apply, ::Type{Pair{K,V}}) = DT_apply(K, V)()
+associative_with_eltype(DT_apply, kv, ::TP{K,V}) where {K,V} = DT_apply(K, V)(kv)
+associative_with_eltype(DT_apply, kv::Generator, ::TP{K,V}) where {K,V} = DT_apply(K, V)(kv)
+associative_with_eltype(DT_apply, ::Type{Pair{K,V}}) where {K,V} = DT_apply(K, V)()
 associative_with_eltype(DT_apply, ::Type) = DT_apply(Any, Any)()
-associative_with_eltype{F}(DT_apply::F, kv, t) = grow_to!(associative_with_eltype(DT_apply, _default_eltype(typeof(kv))), kv)
-function associative_with_eltype{F}(DT_apply::F, kv::Generator, t)
+associative_with_eltype(DT_apply::F, kv, t) where {F} = grow_to!(associative_with_eltype(DT_apply, _default_eltype(typeof(kv))), kv)
+function associative_with_eltype(DT_apply::F, kv::Generator, t) where F
     T = _default_eltype(typeof(kv))
     if T <: Union{Pair, Tuple{Any, Any}} && isconcrete(T)
         return associative_with_eltype(DT_apply, kv, T)
@@ -174,7 +174,7 @@ function grow_to!(dest::Associative, itr)
     return isempty(out) ? dest : out
 end
 
-function grow_to!{K,V}(dest::Associative{K,V}, itr, st)
+function grow_to!(dest::Associative{K,V}, itr, st) where V where K
     while !done(itr, st)
         (k,v), st = next(itr, st)
         if isa(k,K) && isa(v,V)
@@ -189,11 +189,11 @@ function grow_to!{K,V}(dest::Associative{K,V}, itr, st)
     return dest
 end
 
-similar{K,V}(d::Dict{K,V}) = Dict{K,V}()
-similar{K,V}(d::Dict, ::Type{Pair{K,V}}) = Dict{K,V}()
+similar(d::Dict{K,V}) where {K,V} = Dict{K,V}()
+similar(d::Dict, ::Type{Pair{K,V}}) where {K,V} = Dict{K,V}()
 
 # conversion between Dict types
-function convert{K,V}(::Type{Dict{K,V}},d::Associative)
+function convert(::Type{Dict{K,V}},d::Associative) where V where K
     h = Dict{K,V}()
     for (k,v) in d
         ck = convert(K,k)
@@ -205,7 +205,7 @@ function convert{K,V}(::Type{Dict{K,V}},d::Associative)
     end
     return h
 end
-convert{K,V}(::Type{Dict{K,V}},d::Dict{K,V}) = d
+convert(::Type{Dict{K,V}},d::Dict{K,V}) where {K,V} = d
 
 hashindex(key, sz) = (((hash(key)%Int) & (sz-1)) + 1)::Int
 
@@ -213,7 +213,7 @@ isslotempty(h::Dict, i::Int) = h.slots[i] == 0x0
 isslotfilled(h::Dict, i::Int) = h.slots[i] == 0x1
 isslotmissing(h::Dict, i::Int) = h.slots[i] == 0x2
 
-function rehash!{K,V}(h::Dict{K,V}, newsz = length(h.keys))
+function rehash!(h::Dict{K,V}, newsz = length(h.keys)) where V where K
     olds = h.slots
     oldk = h.keys
     oldv = h.vals
@@ -270,7 +270,12 @@ function rehash!{K,V}(h::Dict{K,V}, newsz = length(h.keys))
     return h
 end
 
-function sizehint!(d::Dict, newsz)
+max_values(::Type) = typemax(Int)
+max_values(T::Type{<:Union{Void,BitIntegerSmall}}) = 1 << (8*sizeof(T))
+max_values(T::Union) = max(max_values(T.a), max_values(T.b))
+max_values(::Type{Bool}) = 2
+
+function sizehint!(d::Dict{T}, newsz) where T
     oldsz = length(d.slots)
     if newsz <= oldsz
         # todo: shrink
@@ -279,7 +284,8 @@ function sizehint!(d::Dict, newsz)
         return d
     end
     # grow at least 25%
-    newsz = max(newsz, (oldsz*5)>>2)
+    newsz = min(max(newsz, (oldsz*5)>>2),
+                max_values(T))
     rehash!(d, newsz)
 end
 
@@ -300,7 +306,7 @@ julia> A
 Dict{String,Int64} with 0 entries
 ```
 """
-function empty!{K,V}(h::Dict{K,V})
+function empty!(h::Dict{K,V}) where V where K
     fill!(h.slots, 0x0)
     sz = length(h.slots)
     empty!(h.keys)
@@ -315,7 +321,7 @@ function empty!{K,V}(h::Dict{K,V})
 end
 
 # get the index where a key is stored, or -1 if not present
-function ht_keyindex{K,V}(h::Dict{K,V}, key)
+function ht_keyindex(h::Dict{K,V}, key) where V where K
     sz = length(h.keys)
     iter = 0
     maxprobe = h.maxprobe
@@ -340,7 +346,7 @@ end
 # get the index where a key is stored, or -pos if not present
 # and the key would be inserted at pos
 # This version is for use by setindex! and get!
-function ht_keyindex2{K,V}(h::Dict{K,V}, key)
+function ht_keyindex2(h::Dict{K,V}, key) where V where K
     age0 = h.age
     sz = length(h.keys)
     iter = 0
@@ -408,7 +414,7 @@ function _setindex!(h::Dict, v, key, index)
     end
 end
 
-function setindex!{K,V}(h::Dict{K,V}, v0, key0)
+function setindex!(h::Dict{K,V}, v0, key0) where V where K
     key = convert(K, key0)
     if !isequal(key, key0)
         throw(ArgumentError("$key0 is not a valid key for type $K"))
@@ -416,7 +422,7 @@ function setindex!{K,V}(h::Dict{K,V}, v0, key0)
     setindex!(h, v0, key)
 end
 
-function setindex!{K,V}(h::Dict{K,V}, v0, key::K)
+function setindex!(h::Dict{K,V}, v0, key::K) where V where K
     v = convert(V, v0)
     index = ht_keyindex2(h, key)
 
@@ -431,8 +437,8 @@ function setindex!{K,V}(h::Dict{K,V}, v0, key::K)
     return h
 end
 
-get!{K,V}(h::Dict{K,V}, key0, default) = get!(()->default, h, key0)
-function get!{K,V}(default::Callable, h::Dict{K,V}, key0)
+get!(h::Dict{K,V}, key0, default) where {K,V} = get!(()->default, h, key0)
+function get!(default::Callable, h::Dict{K,V}, key0) where V where K
     key = convert(K, key0)
     if !isequal(key, key0)
         throw(ArgumentError("$key0 is not a valid key for type $K"))
@@ -440,7 +446,7 @@ function get!{K,V}(default::Callable, h::Dict{K,V}, key0)
     return get!(default, h, key)
 end
 
-function get!{K,V}(default::Callable, h::Dict{K,V}, key::K)
+function get!(default::Callable, h::Dict{K,V}, key::K) where V where K
     index = ht_keyindex2(h, key)
 
     index > 0 && return h.vals[index]
@@ -469,17 +475,17 @@ macro get!(h, key0, default)
 end
 
 
-function getindex{K,V}(h::Dict{K,V}, key)
+function getindex(h::Dict{K,V}, key) where V where K
     index = ht_keyindex(h, key)
     return (index < 0) ? throw(KeyError(key)) : h.vals[index]::V
 end
 
-function get{K,V}(h::Dict{K,V}, key, default)
+function get(h::Dict{K,V}, key, default) where V where K
     index = ht_keyindex(h, key)
     return (index < 0) ? default : h.vals[index]::V
 end
 
-function get{K,V}(default::Callable, h::Dict{K,V}, key)
+function get(default::Callable, h::Dict{K,V}, key) where V where K
     index = ht_keyindex(h, key)
     return (index < 0) ? default() : h.vals[index]::V
 end
@@ -523,7 +529,7 @@ julia> getkey(a,'d','a')
 'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)
 ```
 """
-function getkey{K,V}(h::Dict{K,V}, key, default)
+function getkey(h::Dict{K,V}, key, default) where V where K
     index = ht_keyindex(h, key)
     return (index<0) ? default : h.keys[index]::K
 end
@@ -544,6 +550,15 @@ function pop!(h::Dict, key, default)
     return index > 0 ? _pop!(h, index) : default
 end
 
+function pop!(h::Dict)
+    isempty(h) && throw(ArgumentError("dict must be non-empty"))
+    idx = start(h)
+    key = h.keys[idx]
+    val = h.vals[idx]
+    _delete!(h, idx)
+    key => val
+end
+
 function _delete!(h::Dict, index)
     h.slots[index] = 0x2
     ccall(:jl_arrayunset, Void, (Any, UInt), h.keys, index-1)
@@ -576,7 +591,7 @@ function start(t::Dict)
     return i
 end
 done(t::Dict, i) = i > length(t.vals)
-next{K,V}(t::Dict{K,V}, i) = (Pair{K,V}(t.keys[i],t.vals[i]), skip_deleted(t,i+1))
+next(t::Dict{K,V}, i) where {K,V} = (Pair{K,V}(t.keys[i],t.vals[i]), skip_deleted(t,i+1))
 
 isempty(t::Dict) = (t.count == 0)
 length(t::Dict) = t.count
@@ -595,8 +610,8 @@ function filter!(f, d::Union{ObjectIdDict,Dict})
     return d
 end
 
-struct ImmutableDict{K, V} <: Associative{K,V}
-    parent::ImmutableDict{K, V}
+struct ImmutableDict{K,V} <: Associative{K,V}
+    parent::ImmutableDict{K,V}
     key::K
     value::V
     ImmutableDict{K,V}() where {K,V} = new() # represents an empty dictionary
@@ -660,7 +675,7 @@ 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)
+next(::ImmutableDict{K,V}, t) where {K,V} = (Pair{K,V}(t.key, t.value), t.parent)
 done(::ImmutableDict, t) = !isdefined(t, :parent)
 length(t::ImmutableDict) = count(x->true, t)
 isempty(t::ImmutableDict) = done(t, start(t))
@@ -671,5 +686,5 @@ function similar(t::ImmutableDict)
     return t
 end
 
-_similar_for{P<:Pair}(c::Dict, ::Type{P}, itr, isz) = similar(c, P)
+_similar_for(c::Dict, ::Type{P}, itr, isz) where {P<:Pair} = similar(c, P)
 _similar_for(c::Associative, T, itr, isz) = throw(ArgumentError("for Associatives, similar requires an element type of Pair;\n  if calling map, consider a comprehension instead"))
diff --git a/base/distributed/Distributed.jl b/base/distributed/Distributed.jl
index 17f680e0c5a7da..73270b0672b3b5 100644
--- a/base/distributed/Distributed.jl
+++ b/base/distributed/Distributed.jl
@@ -1,16 +1,16 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module Distributed
 
 # imports for extension
 import Base: getindex, wait, put!, take!, fetch, isready, push!, length,
-             hash, ==, connect, kill, serialize, deserialize, close
+             hash, ==, connect, kill, serialize, deserialize, close, showerror
 
 # imports for use
 using Base: Process, Semaphore, JLOptions, AnyDict, buffer_writes, wait_connected,
             VERSION_STRING, sync_begin, sync_add, sync_end, async_run_thunk,
             binding_module, notify_error, atexit, julia_exename, julia_cmd,
-            AsyncGenerator, display_error
+            AsyncGenerator, display_error, acquire, release, invokelatest
 
 # NOTE: clusterserialize.jl imports additional symbols from Base.Serializer for use
 
diff --git a/base/distributed/cluster.jl b/base/distributed/cluster.jl
index 6dfd36e99786bb..ed4b87762a3012 100644
--- a/base/distributed/cluster.jl
+++ b/base/distributed/cluster.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 abstract type ClusterManager end
 
@@ -10,7 +10,7 @@ mutable struct WorkerConfig
 
     # Used when launching additional workers at a host
     count::Nullable{Union{Int, Symbol}}
-    exename::Nullable{AbstractString}
+    exename::Nullable{Union{AbstractString, Cmd}}
     exeflags::Nullable{Cmd}
 
     # External cluster managers can use this to store information at a per-worker level
@@ -59,6 +59,7 @@ mutable struct Worker
     state::WorkerState
     c_state::Condition      # wait for state changes
     ct_time::Float64        # creation time
+    conn_func::Nullable{Function}     # Used to setup connections lazily
 
     r_stream::IO
     w_stream::IO
@@ -82,12 +83,13 @@ mutable struct Worker
         w
     end
 
-    function Worker(id::Int)
+    Worker(id::Int) = Worker(id, Nullable{Function}())
+    function Worker(id::Int, conn_func)
         @assert id > 0
         if haskey(map_pid_wrkr, id)
             return map_pid_wrkr[id]
         end
-        w=new(id, [], [], false, W_CREATED, Condition(), time())
+        w=new(id, [], [], false, W_CREATED, Condition(), time(), conn_func)
         register_worker(w)
         w
     end
@@ -102,21 +104,56 @@ end
 
 function check_worker_state(w::Worker)
     if w.state == W_CREATED
-        if PGRP.topology == :all_to_all
-            # Since higher pids connect with lower pids, the remote worker
-            # may not have connected to us yet. Wait for some time.
-            timeout =  worker_timeout() - (time() - w.ct_time)
-            timeout <= 0 && error("peer $(w.id) has not connected to $(myid())")
-
-            @schedule (sleep(timeout); notify(w.c_state; all=true))
-            wait(w.c_state)
-            w.state == W_CREATED && error("peer $(w.id) didn't connect to $(myid()) within $timeout seconds")
+        if !isclusterlazy()
+            if PGRP.topology == :all_to_all
+                # Since higher pids connect with lower pids, the remote worker
+                # may not have connected to us yet. Wait for some time.
+                wait_for_conn(w)
+            else
+                error("peer $(w.id) is not connected to $(myid()). Topology : " * string(PGRP.topology))
+            end
         else
-            error("peer $(w.id) is not connected to $(myid()). Topology : " * string(PGRP.topology))
+            w.ct_time = time()
+            if myid() > w.id
+                @schedule exec_conn_func(w)
+            else
+                # route request via node 1
+                @schedule remotecall_fetch((p,to_id) -> remotecall_fetch(exec_conn_func, p, to_id), 1, w.id, myid())
+            end
+            wait_for_conn(w)
         end
     end
 end
 
+exec_conn_func(id::Int) = exec_conn_func(worker_from_id(id))
+function exec_conn_func(w::Worker)
+    if isnull(w.conn_func)
+        return wait_for_conn(w) # Some other task may be trying to connect at the same time.
+    end
+
+    try
+        f = get(w.conn_func)
+        w.conn_func = Nullable{Function}()
+        f()
+    catch e
+        w.conn_func = () -> throw(e)
+        rethrow(e)
+    end
+    nothing
+end
+
+function wait_for_conn(w)
+    if w.state == W_CREATED
+        timeout =  worker_timeout() - (time() - w.ct_time)
+        timeout <= 0 && error("peer $(w.id) has not connected to $(myid())")
+
+        @schedule (sleep(timeout); notify(w.c_state; all=true))
+        wait(w.c_state)
+        w.state == W_CREATED && error("peer $(w.id) didn't connect to $(myid()) within $timeout seconds")
+    end
+    nothing
+end
+
 ## process group creation ##
 
 mutable struct LocalProcess
@@ -136,25 +173,42 @@ worker_timeout() = parse(Float64, get(ENV, "JULIA_WORKER_TIMEOUT", "60.0"))
 
 
 ## worker creation and setup ##
+"""
+    start_worker(out::IO=STDOUT)
+    start_worker(cookie::AbstractString)
+    start_worker(out::IO, cookie::AbstractString)
+
+`Base.start_worker` is an internal function which is the default entry point for
+worker processes connecting via TCP/IP. It sets up the process as a Julia cluster
+worker.
 
-# The entry point for julia worker processes. does not return. Used for TCP transport.
-# Cluster managers implementing their own transport will provide their own.
-# Argument is descriptor to write listening port # to.
-start_worker(cookie::AbstractString) = start_worker(STDOUT, cookie)
-function start_worker(out::IO, cookie::AbstractString)
-    # we only explicitly monitor worker STDOUT on the console, so redirect
-    # stderr to stdout so we can see the output.
-    # at some point we might want some or all worker output to go to log
-    # files instead.
-    # Currently disabled since this caused processes to spin instead of
-    # exit when process 1 shut down. Don't yet know why.
-    #redirect_stderr(STDOUT)
+If the cookie is unspecified, the worker tries to read it from its STDIN.
+
+host:port information is written to stream `out` (defaults to STDOUT).
+
+The function closes STDIN (after reading the cookie if required), redirects STDERR to STDOUT,
+listens on a free port (or if specified, the port in the `--bind-to` command
+line option) and schedules tasks to process incoming TCP connections and requests.
+
+It does not return.
+"""
+start_worker(out::IO=STDOUT) = start_worker(out, Nullable{AbstractString}())
+start_worker(cookie::AbstractString) = start_worker(STDOUT, Nullable{AbstractString}(cookie))
+start_worker(out::IO, cookie::AbstractString) = start_worker(out, Nullable{AbstractString}(cookie))
+function start_worker(out::IO, cookie_in::Nullable{AbstractString})
+    if isnull(cookie_in)
+        cookie = readline(STDIN)
+    else
+        cookie = get(cookie_in)
+    end
+    close(STDIN) # workers will not use it
+    redirect_stderr(STDOUT)
 
     init_worker(cookie)
     interface = IPv4(LPROC.bind_addr)
     if LPROC.bind_port == 0
-        (actual_port,sock) = listenany(interface, UInt16(9009))
-        LPROC.bind_port = actual_port
+        (port, sock) = listenany(interface, UInt16(0))
+        LPROC.bind_port = port
     else
         sock = listen(interface, LPROC.bind_port)
     end
@@ -167,8 +221,6 @@ function start_worker(out::IO, cookie::AbstractString)
     print(out, LPROC.bind_addr)
     print(out, '\n')
     flush(out)
-    # close STDIN; workers will not use it
-    #close(STDIN)
 
     disable_nagle(sock)
 
@@ -179,7 +231,6 @@ function start_worker(out::IO, cookie::AbstractString)
     try
         # To prevent hanging processes on remote machines, newly launched workers exit if the
         # master process does not connect in time.
-        # TODO : Make timeout configurable.
         check_master_connect()
         while true; wait(); end
     catch err
@@ -210,21 +261,55 @@ end
 # The master process uses this to connect to the worker and subsequently
 # setup a all-to-all network.
 function read_worker_host_port(io::IO)
-    while true
-        conninfo = readline(io)
+    t0 = time()
+
+    # Wait at most for JULIA_WORKER_TIMEOUT seconds to read host:port
+    # info from the worker
+    timeout = worker_timeout()
+
+    # We expect the first line to contain the host:port string. However, as
+    # the worker may be launched via ssh or a cluster manager like SLURM,
+    # ignore any informational / warning lines printed by the launch command.
+    # If we do not find the host:port string in the first 1000 lines, treat it
+    # as an error.
+
+    ntries = 1000
+    while ntries > 0
+        readtask = @schedule readline(io)
+        yield()
+        while !istaskdone(readtask) && ((time() - t0) < timeout)
+            sleep(0.05)
+        end
+        !istaskdone(readtask) && break
+
+        conninfo = wait(readtask)
+        if isempty(conninfo) && !isopen(io)
+            error("Unable to read host:port string from worker. Launch command exited with error?")
+        end
+
+        ntries -= 1
         bind_addr, port = parse_connection_info(conninfo)
-        if bind_addr != ""
+        if !isempty(bind_addr)
             return bind_addr, port
         end
+
+        # TODO: Identify root cause and report a better actionable error.
+        # Also print unmatched lines?
+    end
+    close(io)
+    if ntries > 0
+        error("Timed out waiting to read host:port string from worker.")
+    else
+        error("Unexpected output from worker launch command. Host:port string not found.")
     end
 end
 
 function parse_connection_info(str)
     m = match(r"^julia_worker:(\d+)#(.*)", str)
     if m !== nothing
-        (m.captures[2], parse(Int16, m.captures[1]))
+        (m.captures[2], parse(UInt16, m.captures[1]))
     else
-        ("", Int16(-1))
+        ("", UInt16(0))
     end
 end
 
@@ -232,7 +317,7 @@ end
     init_worker(cookie::AbstractString, manager::ClusterManager=DefaultClusterManager())
 
 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. Command line argument `--worker[=<cookie>]` has the effect of initializing a
 process as a worker using TCP/IP sockets for transport.
 `cookie` is a [`cluster_cookie`](@ref).
 """
@@ -278,6 +363,8 @@ master can be specified via variable `JULIA_WORKER_TIMEOUT` in the worker proces
 environment. Relevant only when using TCP/IP as transport.
 """
 function addprocs(manager::ClusterManager; kwargs...)
+    cluster_mgmt_from_master_check()
+
     lock(worker_lock)
     try
         addprocs_locked(manager::ClusterManager; kwargs...)
@@ -290,6 +377,17 @@ function addprocs_locked(manager::ClusterManager; kwargs...)
     params = merge(default_addprocs_params(), AnyDict(kwargs))
     topology(Symbol(params[:topology]))
 
+    if PGRP.topology != :all_to_all
+        params[:lazy] = false
+    end
+
+    if isnull(PGRP.lazy) || nprocs() == 1
+        PGRP.lazy = Nullable{Bool}(params[:lazy])
+    elseif isclusterlazy() != params[:lazy]
+        throw(ArgumentError(string("Active workers with lazy=", isclusterlazy(),
+                                    ". Cannot set lazy=", params[:lazy])))
+    end
+
     # References to launched workers, filled when each worker is fully initialized and
     # has connected to all nodes.
     launched_q = Int[]   # Asynchronously filled by the launch method
@@ -346,7 +444,8 @@ default_addprocs_params() = AnyDict(
     :dir      => pwd(),
     :exename  => joinpath(JULIA_HOME, julia_exename()),
     :exeflags => ``,
-    :enable_threaded_blas => false)
+    :enable_threaded_blas => false,
+    :lazy => true)
 
 
 function setup_launched_worker(manager, wconfig, launched_q)
@@ -402,8 +501,14 @@ function create_worker(manager, wconfig)
 
     # initiate a connect. Does not wait for connection completion in case of TCP.
     w = Worker()
+    local r_s, w_s
+    try
+        (r_s, w_s) = connect(manager, w.id, wconfig)
+    catch e
+        deregister_worker(w.id)
+        rethrow(e)
+    end
 
-    (r_s, w_s) = connect(manager, w.id, wconfig)
     w = Worker(w.id, r_s, w_s, manager; config=wconfig)
     # install a finalizer to perform cleanup if necessary
     finalizer(w, (w)->if myid() == 1 manage(w.manager, w.id, w.config, :finalize) end)
@@ -461,7 +566,7 @@ function create_worker(manager, wconfig)
 
     all_locs = map(x -> isa(x, Worker) ? (get(x.config.connect_at, ()), x.id) : ((), x.id, true), join_list)
     send_connection_hdr(w, true)
-    join_message = JoinPGRPMsg(w.id, all_locs, PGRP.topology, get(wconfig.enable_threaded_blas, false))
+    join_message = JoinPGRPMsg(w.id, all_locs, PGRP.topology, get(wconfig.enable_threaded_blas, false), isclusterlazy())
     send_msg_now(w, MsgHeader(RRID(0,0), ntfy_oid), join_message)
 
     @schedule manage(w.manager, w.id, w.config, :register)
@@ -483,8 +588,9 @@ function launch_additional(np::Integer, cmd::Cmd)
     addresses = Vector{Any}(np)
 
     for i in 1:np
-        io, pobj = open(pipeline(detach(cmd), stderr=STDERR), "r")
-        io_objs[i] = io
+        io = open(detach(cmd), "r+")
+        write_cookie(io)
+        io_objs[i] = io.out
     end
 
     for (i,io) in enumerate(io_objs)
@@ -562,8 +668,9 @@ mutable struct ProcessGroup
     workers::Array{Any,1}
     refs::Dict                  # global references
     topology::Symbol
+    lazy::Nullable{Bool}
 
-    ProcessGroup(w::Array{Any,1}) = new("pg-default", w, Dict(), :all_to_all)
+    ProcessGroup(w::Array{Any,1}) = new("pg-default", w, Dict(), :all_to_all, Nullable{Bool}())
 end
 const PGRP = ProcessGroup([])
 
@@ -577,6 +684,14 @@ function topology(t)
     t
 end
 
+function isclusterlazy()
+    if isnull(PGRP.lazy)
+        return false
+    else
+        return get(PGRP.lazy)
+    end
+end
+
 get_bind_addr(pid::Integer) = get_bind_addr(worker_from_id(pid))
 get_bind_addr(w::LocalProcess) = LPROC.bind_addr
 function get_bind_addr(w::Worker)
@@ -609,7 +724,20 @@ myid() = LPROC.id
 
 Get the number of available processes.
 """
-nprocs() = length(PGRP.workers)
+function nprocs()
+    if myid() == 1 || (PGRP.topology == :all_to_all && !isclusterlazy())
+        n = length(PGRP.workers)
+        # filter out workers in the process of being setup/shutdown.
+        for jw in PGRP.workers
+            if !isa(jw, LocalProcess) && (jw.state != W_CONNECTED)
+                n = n - 1
+            end
+        end
+        return n
+    else
+        return length(PGRP.workers)
+    end
+end
 
 """
     nworkers()
@@ -627,7 +755,31 @@ end
 
 Returns a list of all process identifiers.
 """
-procs() = Int[x.id for x in PGRP.workers]
+function procs()
+    if myid() == 1 || (PGRP.topology == :all_to_all  && !isclusterlazy())
+        # filter out workers in the process of being setup/shutdown.
+        return Int[x.id for x in PGRP.workers if isa(x, LocalProcess) || (x.state == W_CONNECTED)]
+    else
+        return Int[x.id for x in PGRP.workers]
+    end
+end
+
+function id_in_procs(id)  # faster version of `id in procs()`
+    if myid() == 1 || (PGRP.topology == :all_to_all  && !isclusterlazy())
+        for x in PGRP.workers
+            if (x.id::Int) == id && (isa(x, LocalProcess) || (x::Worker).state == W_CONNECTED)
+                return true
+            end
+        end
+    else
+        for x in PGRP.workers
+            if (x.id::Int) == id
+                return true
+            end
+        end
+    end
+    return false
+end
 
 """
     procs(pid::Integer)
@@ -637,11 +789,12 @@ Specifically all workers bound to the same ip-address as `pid` are returned.
 """
 function procs(pid::Integer)
     if myid() == 1
+        all_workers = [x for x in PGRP.workers if isa(x, LocalProcess) || (x.state == W_CONNECTED)]
         if (pid == 1) || (isa(map_pid_wrkr[pid].manager, LocalManager))
-            Int[x.id for x in filter(w -> (w.id==1) || (isa(w.manager, LocalManager)), PGRP.workers)]
+            Int[x.id for x in filter(w -> (w.id==1) || (isa(w.manager, LocalManager)), all_workers)]
         else
             ipatpid = get_bind_addr(pid)
-            Int[x.id for x in filter(w -> get_bind_addr(w) == ipatpid, PGRP.workers)]
+            Int[x.id for x in filter(w -> get_bind_addr(w) == ipatpid, all_workers)]
         end
     else
         remotecall_fetch(procs, 1, pid)
@@ -655,13 +808,19 @@ Returns a list of all worker process identifiers.
 """
 function workers()
     allp = procs()
-    if nprocs() == 1
+    if length(allp) == 1
        allp
     else
        filter(x -> x != 1, allp)
     end
 end
 
+function cluster_mgmt_from_master_check()
+    if myid() != 1
+        throw(ErrorException("Only process 1 can add and remove workers"))
+    end
+end
+
 """
     rmprocs(pids...; waitfor=typemax(Int))
 
@@ -678,10 +837,7 @@ Argument `waitfor` specifies how long to wait for the workers to shut down:
       parallel calls.
 """
 function rmprocs(pids...; waitfor=typemax(Int))
-    # Only pid 1 can add and remove processes
-    if myid() != 1
-        throw(ErrorException("only process 1 can add and remove processes"))
-    end
+    cluster_mgmt_from_master_check()
 
     pids = vcat(pids...)
     if waitfor == 0
@@ -740,17 +896,18 @@ mutable struct ProcessExitedException <: Exception end
 
 worker_from_id(i) = worker_from_id(PGRP, i)
 function worker_from_id(pg::ProcessGroup, i)
-    if in(i, map_del_wrkr)
+    if !isempty(map_del_wrkr) && in(i, map_del_wrkr)
         throw(ProcessExitedException())
     end
-    if !haskey(map_pid_wrkr,i)
+    w = get(map_pid_wrkr, i, nothing)
+    if w === nothing
         if myid() == 1
             error("no process with id $i exists")
         end
         w = Worker(i)
         map_pid_wrkr[i] = w
     else
-        w = map_pid_wrkr[i]
+        w = w::Union{Worker, LocalProcess}
     end
     w
 end
@@ -801,10 +958,10 @@ function deregister_worker(pg, pid)
             end
         end
 
-        if myid() == 1
+        if myid() == 1 && isdefined(w, :config)
             # Notify the cluster manager of this workers death
             manage(w.manager, w.id, w.config, :deregister)
-            if PGRP.topology != :all_to_all
+            if PGRP.topology != :all_to_all || isclusterlazy()
                 for rpid in workers()
                     try
                         remote_do(deregister_worker, rpid, pid)
@@ -876,7 +1033,7 @@ end
 function disable_nagle(sock)
     # disable nagle on all OSes
     ccall(:uv_tcp_nodelay, Cint, (Ptr{Void}, Cint), sock.handle, 1)
-    @static if is_linux()
+    @static if Sys.islinux()
         # tcp_quickack is a linux only option
         if ccall(:jl_tcp_quickack, Cint, (Ptr{Void}, Cint), sock.handle, 1) < 0
             warn_once("Networking unoptimized ( Error enabling TCP_QUICKACK : ", Libc.strerror(Libc.errno()), " )")
@@ -959,3 +1116,5 @@ function init_parallel()
     assert(isempty(PGRP.workers))
     register_worker(LPROC)
 end
+
+write_cookie(io::IO) = write(io.in, string(cluster_cookie(), "\n"))
diff --git a/base/distributed/clusterserialize.jl b/base/distributed/clusterserialize.jl
index 043ca57abf5769..2a42f35a7f572c 100644
--- a/base/distributed/clusterserialize.jl
+++ b/base/distributed/clusterserialize.jl
@@ -1,13 +1,16 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
-using Base.Serializer: known_object_data, object_number, serialize_cycle, deserialize_cycle, writetag,
+using Base.Serializer: object_number, serialize_cycle, deserialize_cycle, writetag,
                       __deserialized_types__, serialize_typename, deserialize_typename,
                       TYPENAME_TAG, object_numbers, reset_state, serialize_type
 
+import Base.Serializer: lookup_object_number, remember_object
+
 mutable struct ClusterSerializer{I<:IO} <: AbstractSerializer
     io::I
     counter::Int
     table::ObjectIdDict
+    pending_refs::Vector{Int}
 
     pid::Int                                     # Worker we are connected to.
     tn_obj_sent::Set{UInt64}                     # TypeName objects sent
@@ -17,21 +20,33 @@ mutable struct ClusterSerializer{I<:IO} <: AbstractSerializer
     anonfunc_id::UInt64
 
     function ClusterSerializer{I}(io::I) where I<:IO
-        new(io, 0, ObjectIdDict(), Base.worker_id_from_socket(io),
+        new(io, 0, ObjectIdDict(), Int[], Base.worker_id_from_socket(io),
             Set{UInt64}(), Dict{UInt64, UInt64}(), Dict{UInt64, Vector{Symbol}}(), 0)
     end
 end
 ClusterSerializer(io::IO) = ClusterSerializer{typeof(io)}(io)
 
+const known_object_data = Dict{UInt64,Any}()
+
+function lookup_object_number(s::ClusterSerializer, n::UInt64)
+    return get(known_object_data, n, nothing)
+end
+
+function remember_object(s::ClusterSerializer, @nospecialize(o), n::UInt64)
+    known_object_data[n] = o
+    if isa(o, TypeName) && !haskey(object_numbers, o)
+        # set up reverse mapping for serialize
+        object_numbers[o] = n
+    end
+    return nothing
+end
+
 function deserialize(s::ClusterSerializer, ::Type{TypeName})
     full_body_sent = deserialize(s)
     number = read(s.io, UInt64)
     if !full_body_sent
-        tn = get(known_object_data, number, nothing)::TypeName
-        if !haskey(object_numbers, tn)
-            # set up reverse mapping for serialize
-            object_numbers[tn] = number
-        end
+        tn = lookup_object_number(s, number)::TypeName
+        remember_object(s, tn, number)
         deserialize_cycle(s, tn)
     else
         tn = deserialize_typename(s, number)
@@ -73,9 +88,9 @@ function serialize(s::ClusterSerializer, g::GlobalRef)
     # Record if required and then invoke the default GlobalRef serializer.
     sym = g.name
     if g.mod === Main && isdefined(g.mod, sym)
-        v = getfield(Main, sym)
-        if  !isa(v, DataType) && !isa(v, Module) &&
-            (binding_module(Main, sym) === Main) && (s.anonfunc_id != 0)
+        if (binding_module(Main, sym) === Main) && (s.anonfunc_id != 0) &&
+            !startswith(string(sym), "#") # Anonymous functions are handled via FULL_GLOBALREF_TAG
+
             push!(get!(s.glbs_in_tnobj, s.anonfunc_id, []), sym)
         end
     end
@@ -99,7 +114,7 @@ function syms_2b_sent(s::ClusterSerializer, identifier)
             oid = object_id(v)
             if haskey(s.glbs_sent, oid)
                 # We have sent this object before, see if it has changed.
-                s.glbs_sent[oid] != hash(v) && push!(lst, sym)
+                s.glbs_sent[oid] != hash(sym, hash(v)) && push!(lst, sym)
             else
                 push!(lst, sym)
             end
@@ -128,7 +143,7 @@ function serialize_global_from_main(s::ClusterSerializer, sym)
             end
         end
     end
-    record_v && (s.glbs_sent[oid] = hash(v))
+    record_v && (s.glbs_sent[oid] = hash(sym, hash(v)))
 
     serialize(s, isconst(Main, sym))
     serialize(s, v)
diff --git a/base/distributed/macros.jl b/base/distributed/macros.jl
index 51e5405c0f09a8..0dc79e86b95b68 100644
--- a/base/distributed/macros.jl
+++ b/base/distributed/macros.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 let nextidx = 0
     global nextproc
@@ -16,11 +16,52 @@ spawnat(p, thunk) = sync_add(remotecall(thunk, p))
 
 spawn_somewhere(thunk) = spawnat(nextproc(),thunk)
 
+"""
+    @spawn
+
+Create a closure around an expression and run it on an automatically-chosen process,
+returning a [`Future`](@ref) to the result.
+
+# Examples
+```julia-repl
+julia> addprocs(3);
+
+julia> f = @spawn myid()
+Future(2, 1, 5, Nullable{Any}())
+
+julia> fetch(f)
+2
+
+julia> f = @spawn myid()
+Future(3, 1, 7, Nullable{Any}())
+
+julia> fetch(f)
+3
+```
+"""
 macro spawn(expr)
     thunk = esc(:(()->($expr)))
     :(spawn_somewhere($thunk))
 end
 
+"""
+    @spawnat
+
+Create a closure around an expression and run the closure
+asynchronously on process `p`. Returns a [`Future`](@ref) to the result.
+Accepts two arguments, `p` and an expression.
+
+# Examples
+```julia-repl
+julia> addprocs(1);
+
+julia> f = @spawnat 2 myid()
+Future(2, 1, 3, Nullable{Any}())
+
+julia> fetch(f)
+2
+```
+"""
 macro spawnat(p, expr)
     thunk = esc(:(()->($expr)))
     :(spawnat($(esc(p)), $thunk))
@@ -31,6 +72,23 @@ end
 
 Equivalent to `fetch(@spawn expr)`.
 See [`fetch`](@ref) and [`@spawn`](@ref).
+
+# Examples
+```julia-repl
+julia> addprocs(3);
+
+julia> @fetch myid()
+2
+
+julia> @fetch myid()
+3
+
+julia> @fetch myid()
+4
+
+julia> @fetch myid()
+2
+```
 """
 macro fetch(expr)
     thunk = esc(:(()->($expr)))
@@ -42,67 +100,120 @@ end
 
 Equivalent to `fetch(@spawnat p expr)`.
 See [`fetch`](@ref) and [`@spawnat`](@ref).
+
+# Examples
+```julia-repl
+julia> addprocs(3);
+
+julia> @fetchfrom 2 myid()
+2
+
+julia> @fetchfrom 4 myid()
+4
+```
 """
 macro fetchfrom(p, expr)
     thunk = esc(:(()->($expr)))
     :(remotecall_fetch($thunk, $(esc(p))))
 end
 
+# extract a list of modules to import from an expression
+extract_imports!(imports, x) = imports
+function extract_imports!(imports, ex::Expr)
+    if Meta.isexpr(ex, (:import, :using))
+        return push!(imports, ex.args[1])
+    elseif Meta.isexpr(ex, :let)
+        return extract_imports!(imports, ex.args[1])
+    elseif Meta.isexpr(ex, (:toplevel, :block))
+        for i in eachindex(ex.args)
+            extract_imports!(imports, ex.args[i])
+        end
+    end
+    return imports
+end
+extract_imports(x) = extract_imports!(Symbol[], x)
+
 """
-    @everywhere expr
+    @everywhere [procs()] expr
 
-Execute an expression under `Main` everywhere. Equivalent to calling
-`eval(Main, expr)` on all processes. Errors on any of the processes are collected into a
-`CompositeException` and thrown. For example :
+Execute an expression under `Main` on all `procs`.
+Errors on any of the processes are collected into a
+`CompositeException` and thrown. For example:
 
-    @everywhere bar=1
+    @everywhere bar = 1
 
 will define `Main.bar` on all processes.
 
 Unlike [`@spawn`](@ref) and [`@spawnat`](@ref),
-`@everywhere` does not capture any local variables. Prefixing
-`@everywhere` with [`@eval`](@ref) allows us to broadcast
-local variables using interpolation :
+`@everywhere` does not capture any local variables.
+Instead, local variables can be broadcast using interpolation:
 
     foo = 1
-    @eval @everywhere bar=\$foo
+    @everywhere bar = \$foo
 
-The expression is evaluated under `Main` irrespective of where `@everywhere` is called from.
-For example :
+The optional argument `procs` allows specifying a subset of all
+processes to have execute the expression.
 
-    module FooBar
-        foo() = @everywhere bar()=myid()
+Equivalent to calling `remotecall_eval(Main, procs, expr)`.
+"""
+macro everywhere(ex)
+    return :(@everywhere procs() $ex)
+end
+
+macro everywhere(procs, ex)
+    imps = [Expr(:import, m) for m in extract_imports(ex)]
+    return quote
+        $(isempty(imps) ? nothing : Expr(:toplevel, imps...)) # run imports locally first
+        let ex = $(Expr(:quote, ex)), procs = $(esc(procs))
+            remotecall_eval(Main, procs, ex)
+        end
     end
-    FooBar.foo()
+end
 
-will result in `Main.bar` being defined on all processes and not `FooBar.bar`.
 """
-macro everywhere(ex)
-    quote
-        sync_begin()
-        for pid in workers()
-            async_run_thunk(()->remotecall_fetch(eval_ew_expr, pid, $(Expr(:quote,ex))))
-            yield() # ensure that the remotecall_fetch has been started
+    remotecall_eval(m::Module, procs, expression)
+
+Execute an expression under module `m` on the processes
+specified in `procs`.
+Errors on any of the processes are collected into a
+`CompositeException` and thrown.
+
+See also `@everywhere`.
+"""
+function remotecall_eval(m::Module, procs, ex)
+    @sync begin
+        run_locally = 0
+        for pid in procs
+            if pid == myid()
+                run_locally += 1
+            else
+                @async remotecall_wait(Core.eval, pid, m, ex)
+            end
         end
+        yield() # ensure that the remotecall_fetch have had a chance to start
 
         # execute locally last as we do not want local execution to block serialization
         # of the request to remote nodes.
-        if nprocs() > 1
-            async_run_thunk(()->eval_ew_expr($(Expr(:quote,ex))))
+        for _ in 1:run_locally
+            @async Core.eval(m, ex)
         end
-
-        sync_end()
     end
+    nothing
+end
+
+# optimized version of remotecall_eval for a single pid
+# and which also fetches the return value
+function remotecall_eval(m::Module, pid::Int, ex)
+    return remotecall_fetch(Core.eval, pid, m, ex)
 end
 
-eval_ew_expr(ex) = (eval(Main, ex); nothing)
 
 # Statically split range [1,N] into equal sized chunks for np processors
 function splitrange(N::Int, np::Int)
     each = div(N,np)
     extras = rem(N,np)
     nchunks = each > 0 ? np : extras
-    chunks = Array{UnitRange{Int}}(nchunks)
+    chunks = Vector{UnitRange{Int}}(nchunks)
     lo = 1
     for i in 1:nchunks
         hi = lo + each - 1
@@ -203,4 +314,3 @@ macro parallel(args...)
     end
     thecall
 end
-
diff --git a/base/distributed/managers.jl b/base/distributed/managers.jl
index be3ddd337b34a2..8a09063dceef4d 100644
--- a/base/distributed/managers.jl
+++ b/base/distributed/managers.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Built-in SSH and Local Managers
 
@@ -58,48 +58,51 @@ location on each node, or to be available via a shared file system.
 
 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`.
+`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.
+`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`.
+  master process. Default is `false`.
 
-* `sshflags`: specifies additional ssh options, e.g.
-  ```sshflags=\`-i /home/foo/bar.pem\` ```
+* `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.
+* `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()`)
+  directory (as found by `pwd()`)
 
- * `enable_threaded_blas`: if `true` then  BLAS will run on multiple threads in added
-                           processes. Default is `false`.
+* `enable_threaded_blas`: if `true` then  BLAS will run on multiple threads in added
+  processes. Default is `false`.
 
 * `exename`: name of the `julia` executable. Defaults to `"\$JULIA_HOME/julia"` or
-             `"\$JULIA_HOME/julia-debug"` as the case may be.
+  `"\$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`: 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=:all_to_all`: All processes are connected to each other. 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=: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 specifies 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`.
+    + `topology=:custom`: The `launch` method of the cluster manager specifies 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`.
+
+* `lazy`: Applicable only with `topology=:all_to_all`. If `true`, worker-worker connections
+  are setup lazily, i.e. they are setup at the first instance of a remote call between
+  workers. Default is true.
 
 
 Environment variables :
@@ -156,7 +159,7 @@ function launch_on_machine(manager::SSHManager, machine, cnt, params, launched,
     if length(machine_bind) > 1
         exeflags = `--bind-to $(machine_bind[2]) $exeflags`
     end
-    exeflags = `$exeflags --worker $(cluster_cookie())`
+    exeflags = `$exeflags --worker`
 
     machine_def = split(machine_bind[1], ':')
     # if this machine def has a port number, add the port information to the ssh flags
@@ -167,7 +170,7 @@ function launch_on_machine(manager::SSHManager, machine, cnt, params, launched,
     portopt = ``
     if length(machine_def) == 2
         portstr = machine_def[2]
-        if !isinteger(portstr) || (p = parse(Int,portstr); p < 1 || p > 65535)
+        if !all(isdigit, portstr) || (p = parse(Int,portstr); p < 1 || p > 65535)
             msg = "invalid machine definition format string: invalid port format \"$machine_def\""
             throw(ArgumentError(msg))
         end
@@ -193,19 +196,18 @@ function launch_on_machine(manager::SSHManager, machine, cnt, params, launched,
     # -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 $(Base.shell_escape(cmd))`
+    cmd = `ssh -T -a -x -o ClearAllForwardings=yes $sshflags $host $(Base.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")
+    # for the launched processes.
+    io = open(detach(cmd), "r+")
+    write_cookie(io)
 
     wconfig = WorkerConfig()
-    wconfig.io = io
+    wconfig.io = io.out
     wconfig.host = host
     wconfig.tunnel = params[:tunnel]
     wconfig.sshflags = sshflags
@@ -259,8 +261,7 @@ Returns a port number `localport` such that `localhost:localport` connects to `h
 """
 function ssh_tunnel(user, host, bind_addr, port, sshflags)
     port = Int(port)
-    cnt  = 100
-    localport = next_tunnel_port()
+    cnt = ntries = 100
     # 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
@@ -269,15 +270,16 @@ function ssh_tunnel(user, host, bind_addr, port, sshflags)
     # 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
+    while cnt > 0
         localport = next_tunnel_port()
+        if success(detach(`$ssh -f $sshflags $user@$host -L $localport:$bind_addr:$port sleep 60`))
+            return localport
+        end
         cnt -= 1
     end
-    if cnt == 0
-        throw(ErrorException(
-            "unable to create SSH tunnel after $cnt tries. No free port?"))
-    end
-    return localport
+
+    throw(ErrorException(
+        string("unable to create SSH tunnel after ", ntries, " tries. No free port?")))
 end
 
 
@@ -304,7 +306,7 @@ addprocs(; kwargs...) = addprocs(Sys.CPU_CORES; kwargs...)
 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. If `restrict` is `true`, binding is restricted to
-`127.0.0.1`. Keyword args `dir`, `exename`, `exeflags`, `topology`, and
+`127.0.0.1`. Keyword args `dir`, `exename`, `exeflags`, `topology`, `lazy` and
 `enable_threaded_blas` have the same effect as documented for `addprocs(machines)`.
 """
 function addprocs(np::Integer; restrict=true, kwargs...)
@@ -321,12 +323,13 @@ function launch(manager::LocalManager, params::Dict, launched::Array, c::Conditi
     bind_to = manager.restrict ? `127.0.0.1` : `$(LPROC.bind_addr)`
 
     for i in 1:manager.np
-        io, pobj = open(pipeline(detach(
-                setenv(`$(julia_cmd(exename)) $exeflags --bind-to $bind_to --worker $(cluster_cookie())`, dir=dir)),
-            stderr=STDERR), "r")
+        cmd = `$(julia_cmd(exename)) $exeflags --bind-to $bind_to --worker`
+        io = open(detach(setenv(cmd, dir=dir)), "r+")
+        write_cookie(io)
+
         wconfig = WorkerConfig()
-        wconfig.process = pobj
-        wconfig.io = io
+        wconfig.process = io
+        wconfig.io = io.out
         wconfig.enable_threaded_blas = params[:enable_threaded_blas]
         push!(launched, wconfig)
     end
@@ -457,31 +460,35 @@ end
 const client_port = Ref{Cushort}(0)
 
 function socket_reuse_port()
-    s = TCPSocket()
-    client_host = Ref{Cuint}(0)
-    ccall(:jl_tcp_bind, Int32,
-            (Ptr{Void}, UInt16, UInt32, Cuint),
-            s.handle, hton(client_port.x), hton(UInt32(0)), 0) < 0 && throw(SystemError("bind() : "))
+    if ccall(:jl_has_so_reuseport, Int32, ()) == 1
+        s = TCPSocket(delay = false)
 
-    # TODO: Support OSX and change the above code to call setsockopt before bind once libuv provides
-    # early access to a socket fd, i.e., before a bind call.
+        # Some systems (e.g. Linux) require the port to be bound before setting REUSEPORT
+        bind_early = Sys.islinux()
 
-    @static if is_linux()
-        try
-            rc = ccall(:jl_tcp_reuseport, Int32, (Ptr{Void}, ), s.handle)
-            if rc > 0  # SO_REUSEPORT is unsupported, just return the ephemerally bound socket
-                return s
-            elseif rc < 0
-                throw(SystemError("setsockopt() SO_REUSEPORT : "))
-            end
-            getsockname(s)
-        catch e
+        bind_early && bind_client_port(s)
+        rc = ccall(:jl_tcp_reuseport, Int32, (Ptr{Void},), s.handle)
+        if rc < 0
             # 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)
+            nworkers() > 128 && warn_once("Error trying to reuse client port number, falling back to regular socket.")
+
             # provide a clean new socket
             return TCPSocket()
         end
+        bind_early || bind_client_port(s)
+        return s
+    else
+        return TCPSocket()
     end
+end
+
+function bind_client_port(s)
+    err = ccall(:jl_tcp_bind, Int32, (Ptr{Void}, UInt16, UInt32, Cuint),
+                            s.handle, hton(client_port[]), hton(UInt32(0)), 0)
+    Base.uv_error("bind() failed", err)
+
+    _addr, port = getsockname(s)
+    client_port[] = port
     return s
 end
 
diff --git a/base/distributed/messages.jl b/base/distributed/messages.jl
index dc95b032e2efa0..12f347fa493f0f 100644
--- a/base/distributed/messages.jl
+++ b/base/distributed/messages.jl
@@ -1,11 +1,9 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 abstract type AbstractMsg end
 
-let REF_ID::Int = 1
-    global next_ref_id
-    next_ref_id() = (id = REF_ID; REF_ID += 1; id)
-end
+const REF_ID = Ref(1)
+next_ref_id() = (id = REF_ID[]; REF_ID[] = id+1; id)
 
 struct RRID
     whence::Int
@@ -70,6 +68,7 @@ struct JoinPGRPMsg <: AbstractMsg
     other_workers::Array
     topology::Symbol
     enable_threaded_blas::Bool
+    lazy::Bool
 end
 struct JoinCompleteMsg <: AbstractMsg
     cpu_cores::Int
@@ -80,34 +79,32 @@ end
 # of approximately 10%. Can be removed once module Serializer
 # has been suitably improved.
 
-# replace  CallMsg{Mode} with specific invocations
-const msgtypes = filter!(x->x!=CallMsg, subtypes(AbstractMsg))
-push!(msgtypes, CallMsg{:call}, CallMsg{:call_fetch})
+const msgtypes = Any[CallWaitMsg, IdentifySocketAckMsg, IdentifySocketMsg,
+                     JoinCompleteMsg, JoinPGRPMsg, RemoteDoMsg, ResultMsg,
+                     CallMsg{:call}, CallMsg{:call_fetch}]
 
 for (idx, tname) in enumerate(msgtypes)
-    nflds = length(fieldnames(tname))
-    @eval begin
-        function serialize(s::AbstractSerializer, o::$tname)
-            write(s.io, UInt8($idx))
-            for fld in fieldnames($tname)
-                serialize(s, getfield(o, fld))
-            end
-        end
-
-        function deserialize_msg(s::AbstractSerializer, ::Type{$tname})
-            data=Array{Any,1}($nflds)
-            for i in 1:$nflds
-                data[i] = deserialize(s)
-            end
-            return $tname(data...)
-        end
+    exprs = Any[ :(serialize(s, o.$fld)) for fld in fieldnames(tname) ]
+    @eval function serialize_msg(s::AbstractSerializer, o::$tname)
+        write(s.io, UInt8($idx))
+        $(exprs...)
+        return nothing
     end
 end
 
-function deserialize_msg(s::AbstractSerializer)
-    idx = read(s.io, UInt8)
-    t = msgtypes[idx]
-    return eval(current_module(), Expr(:body, Expr(:return, Expr(:call, deserialize_msg, QuoteNode(s), QuoteNode(t)))))
+let msg_cases = :(assert(false))
+    for i = length(msgtypes):-1:1
+        mti = msgtypes[i]
+        msg_cases = :(if idx == $i
+                          return $(Expr(:call, QuoteNode(mti), fill(:(deserialize(s)), fieldcount(mti))...))
+                      else
+                          $msg_cases
+                      end)
+    end
+    @eval function deserialize_msg(s::AbstractSerializer)
+        idx = read(s.io, UInt8)
+        $msg_cases
+    end
 end
 
 function send_msg_unknown(s::IO, header, msg)
@@ -171,8 +168,7 @@ function serialize_hdr_raw(io, hdr)
 end
 
 function deserialize_hdr_raw(io)
-    data = Array{Int,1}(4)
-    read!(io, data)
+    data = read!(io, Ref{NTuple{4,Int}}())[]
     return MsgHeader(RRID(data[1], data[2]), RRID(data[3], data[4]))
 end
 
@@ -183,7 +179,7 @@ function send_msg_(w::Worker, header, msg, now::Bool)
     try
         reset_state(w.w_serializer)
         serialize_hdr_raw(io, header)
-        eval(current_module(), Expr(:body, Expr(:return, Expr(:call, serialize, QuoteNode(w.w_serializer), QuoteNode(msg)))))  # io is wrapped in w_serializer
+        invokelatest(serialize_msg, w.w_serializer, msg)  # io is wrapped in w_serializer
         write(io, MSG_BOUNDARY)
 
         if !now && w.gcflag
diff --git a/base/distributed/pmap.jl b/base/distributed/pmap.jl
index 9e8c6530796f14..3cf4c895d3db3e 100644
--- a/base/distributed/pmap.jl
+++ b/base/distributed/pmap.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 mutable struct BatchProcessingError <: Exception
     data
@@ -60,7 +60,7 @@ which is then returned inline with the results to the caller.
 
 Consider the following two examples. The first one returns the exception object inline,
 the second a 0 in place of any exception:
-```julia
+```julia-repl
 julia> pmap(x->iseven(x) ? error("foo") : x, 1:4; on_error=identity)
 4-element Array{Any,1}:
  1
diff --git a/base/distributed/process_messages.jl b/base/distributed/process_messages.jl
index d9bac73f9545e9..8debaa255c34e7 100644
--- a/base/distributed/process_messages.jl
+++ b/base/distributed/process_messages.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # data stored by the owner of a remote reference
 def_rv_channel() = Channel(1)
@@ -158,7 +158,7 @@ function message_handler_loop(r_stream::IO, w_stream::IO, incoming::Bool)
             # println("header: ", header)
 
             try
-                msg = deserialize_msg(serializer)
+                msg = invokelatest(deserialize_msg, serializer)
             catch e
                 # Deserialization error; discard bytes in stream until boundary found
                 boundary_idx = 1
@@ -196,11 +196,14 @@ function message_handler_loop(r_stream::IO, w_stream::IO, incoming::Bool)
         end
     catch e
         # Check again as it may have been set in a message handler but not propagated to the calling block above
-        wpid = worker_id_from_socket(r_stream)
-        if (wpid < 1)
+        if wpid < 1
+            wpid = worker_id_from_socket(r_stream)
+        end
+
+        if wpid < 1
             println(STDERR, e, CapturedException(e, catch_backtrace()))
             println(STDERR, "Process($(myid())) - Unknown remote, closing connection.")
-        else
+        elseif !(wpid in map_del_wrkr)
             werr = worker_from_id(wpid)
             oldstate = werr.state
             set_worker_state(werr, W_TERMINATED)
@@ -307,14 +310,22 @@ function handle_msg(msg::JoinPGRPMsg, header, r_stream, w_stream, version)
         disable_threaded_libs()
     end
 
+    lazy = msg.lazy
+    PGRP.lazy = Nullable{Bool}(lazy)
+
     wait_tasks = Task[]
     for (connect_at, rpid) in msg.other_workers
         wconfig = WorkerConfig()
         wconfig.connect_at = connect_at
 
         let rpid=rpid, wconfig=wconfig
-            t = @async connect_to_peer(cluster_manager, rpid, wconfig)
-            push!(wait_tasks, t)
+            if lazy
+                # The constructor registers the object with a global registry.
+                Worker(rpid, Nullable{Function}(()->connect_to_peer(cluster_manager, rpid, wconfig)))
+            else
+                t = @async connect_to_peer(cluster_manager, rpid, wconfig)
+                push!(wait_tasks, t)
+            end
         end
     end
 
diff --git a/base/distributed/remotecall.jl b/base/distributed/remotecall.jl
index d740d9720c6f24..e39a59e77e49e6 100644
--- a/base/distributed/remotecall.jl
+++ b/base/distributed/remotecall.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 """
     client_refs
@@ -20,6 +20,8 @@ mutable struct Future <: AbstractRemoteRef
 
     Future(w::Int, rrid::RRID) = Future(w, rrid, Nullable{Any}())
     Future(w::Int, rrid::RRID, v) = (r = new(w,rrid.whence,rrid.id,v); return test_existing_ref(r))
+
+    Future(t::Tuple) = new(t[1],t[2],t[3],t[4])  # Useful for creating dummy, zeroed-out instances
 end
 
 mutable struct RemoteChannel{T<:AbstractChannel} <: AbstractRemoteRef
@@ -31,6 +33,10 @@ mutable struct RemoteChannel{T<:AbstractChannel} <: AbstractRemoteRef
         r = new(w, rrid.whence, rrid.id)
         return test_existing_ref(r)
     end
+
+    function RemoteChannel{T}(t::Tuple) where T<:AbstractChannel
+        return new(t[1],t[2],t[3])
+    end
 end
 
 function test_existing_ref(r::AbstractRemoteRef)
@@ -152,7 +158,7 @@ function lookup_ref(pg, rrid, f)
         rv = get(pg.refs, rrid, false)
         if rv === false
             # first we've heard of this ref
-            rv = RemoteValue(eval(Main, Expr(:body, Expr(:return, Expr(:call, f)))))
+            rv = RemoteValue(invokelatest(f))
             pg.refs[rrid] = rv
             push!(rv.clientset, rrid.whence)
         end
@@ -235,7 +241,7 @@ end
 function send_del_client(rr)
     if rr.where == myid()
         del_client(rr)
-    elseif rr.where in procs() # process only if a valid worker
+    elseif id_in_procs(rr.where) # process only if a valid worker
         w = worker_from_id(rr.where)
         push!(w.del_msgs, (remoteref_id(rr), myid()))
         w.gcflag = true
@@ -260,7 +266,7 @@ end
 function send_add_client(rr::AbstractRemoteRef, i)
     if rr.where == myid()
         add_client(remoteref_id(rr), i)
-    elseif (i != rr.where) && (rr.where in procs())
+    elseif (i != rr.where) && id_in_procs(rr.where)
         # 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().
@@ -271,31 +277,31 @@ function send_add_client(rr::AbstractRemoteRef, i)
     end
 end
 
-channel_type{T}(rr::RemoteChannel{T}) = T
+channel_type(rr::RemoteChannel{T}) where {T} = T
 
-serialize(s::AbstractSerializer, f::Future) = serialize(s, f, isnull(f.v))
-serialize(s::AbstractSerializer, rr::RemoteChannel) = serialize(s, rr, true)
-function serialize(s::AbstractSerializer, rr::AbstractRemoteRef, addclient)
+serialize(s::ClusterSerializer, f::Future) = serialize(s, f, isnull(f.v))
+serialize(s::ClusterSerializer, rr::RemoteChannel) = serialize(s, rr, true)
+function serialize(s::ClusterSerializer, rr::AbstractRemoteRef, addclient)
     if addclient
         p = worker_id_from_socket(s.io)
         (p !== rr.where) && send_add_client(rr, p)
     end
-    invoke(serialize, Tuple{AbstractSerializer, Any}, s, rr)
+    invoke(serialize, Tuple{ClusterSerializer, Any}, s, rr)
 end
 
-function deserialize(s::AbstractSerializer, t::Type{<:Future})
+function deserialize(s::ClusterSerializer, t::Type{<:Future})
     f = deserialize_rr(s,t)
     Future(f.where, RRID(f.whence, f.id), f.v) # ctor adds to client_refs table
 end
 
-function deserialize(s::AbstractSerializer, t::Type{<:RemoteChannel})
+function deserialize(s::ClusterSerializer, t::Type{<:RemoteChannel})
     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, RRID(rr.whence, rr.id))
 end
 
 function deserialize_rr(s, t)
-    rr = invoke(deserialize, Tuple{AbstractSerializer, DataType}, s, t)
+    rr = invoke(deserialize, Tuple{ClusterSerializer, DataType}, s, t)
     if rr.where == myid()
         # send_add_client() is not executed when the ref is being
         # serialized to where it exists
@@ -304,6 +310,18 @@ function deserialize_rr(s, t)
     rr
 end
 
+# Future and RemoteChannel are serializable only in a running cluster.
+# Serialize zeroed-out values to non ClusterSerializer objects
+function serialize(s::AbstractSerializer, ::Future)
+    zero_fut = Future((0,0,0,Nullable{Any}()))
+    invoke(serialize, Tuple{AbstractSerializer, Any}, s, zero_fut)
+end
+
+function serialize(s::AbstractSerializer, ::RemoteChannel)
+    zero_rc = RemoteChannel{Channel{Any}}((0,0,0))
+    invoke(serialize, Tuple{AbstractSerializer, Any}, s, zero_rc)
+end
+
 
 # make a thunk to call f on args in a way that simulates what would happen if
 # the function were sent elsewhere
@@ -484,7 +502,7 @@ Waits and fetches a value from `x` depending on the type of `x`:
 
 Does not remove the item fetched.
 """
-fetch(x::ANY) = x
+fetch(@nospecialize x) = x
 
 isready(rv::RemoteValue, args...) = isready(rv.c, args...)
 
diff --git a/base/distributed/workerpool.jl b/base/distributed/workerpool.jl
index 2c5f772f706a0a..0406f80bbe3b4c 100644
--- a/base/distributed/workerpool.jl
+++ b/base/distributed/workerpool.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 abstract type AbstractWorkerPool end
 
@@ -25,7 +25,7 @@ end
 
 function WorkerPool()
     wp = WorkerPool(Channel{Int}(typemax(Int)), RemoteChannel())
-    put!(wp.ref, wp)
+    put!(wp.ref, WeakRef(wp))
     wp
 end
 
@@ -52,7 +52,7 @@ function serialize(S::AbstractSerializer, pool::WorkerPool)
     serialize(S, pool.ref)
 end
 
-deserialize{T<:WorkerPool}(S::AbstractSerializer, t::Type{T}) = T(deserialize(S))
+deserialize(S::AbstractSerializer, t::Type{T}) where {T<:WorkerPool} = T(deserialize(S))
 
 wp_local_push!(pool::AbstractWorkerPool, w::Int) = (push!(pool.workers, w); put!(pool.channel, w); pool)
 wp_local_length(pool::AbstractWorkerPool) = length(pool.workers)
@@ -97,7 +97,7 @@ function wp_local_take!(pool::AbstractWorkerPool)
         end
 
         worker = take!(pool.channel)
-        if worker in procs()
+        if id_in_procs(worker)
             break
         else
             delete!(pool.workers, worker) # Remove invalid worker from pool
@@ -124,7 +124,7 @@ for func = (:length, :isready, :workers, :nworkers, :take!)
     @eval begin
         function ($func)(pool::WorkerPool)
             if pool.ref.where != myid()
-                return remotecall_fetch(ref->($func_local)(fetch(ref)), pool.ref.where, pool.ref)
+                return remotecall_fetch(ref->($func_local)(fetch(ref).value), pool.ref.where, pool.ref)
             else
                 return ($func_local)(pool)
             end
@@ -140,7 +140,7 @@ for func = (:push!, :put!)
     @eval begin
         function ($func)(pool::WorkerPool, w::Int)
             if pool.ref.where != myid()
-                return remotecall_fetch((ref, w)->($func_local)(fetch(ref), w), pool.ref.where, pool.ref, w)
+                return remotecall_fetch((ref, w)->($func_local)(fetch(ref).value, w), pool.ref.where, pool.ref, w)
             else
                 return ($func_local)(pool, w)
             end
@@ -245,12 +245,12 @@ To clear the cache earlier, use `clear!(pool)`.
 For global variables, only the bindings are captured in a closure, not the data.
 `let` blocks can be used to capture global data.
 
-For example:
-```
-const foo=rand(10^8);
-wp=CachingPool(workers())
-let foo=foo
-    pmap(wp, i->sum(foo)+i, 1:100);
+# Examples
+```julia
+const foo = rand(10^8);
+wp = CachingPool(workers())
+let foo = foo
+    pmap(wp, i -> sum(foo) + i, 1:100);
 end
 ```
 
diff --git a/base/docs/Docs.jl b/base/docs/Docs.jl
index 5c112ea32f698f..ef69e30962ff45 100644
--- a/base/docs/Docs.jl
+++ b/base/docs/Docs.jl
@@ -1,8 +1,12 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 """
-The Docs module provides the `@doc` macro which can be used to set and retrieve
-documentation metadata for Julia objects. Please see docs for the `@doc` macro for more
+    Docs
+
+The `Docs` module provides the `@doc` macro which can be used to set and retrieve
+documentation metadata for Julia objects.
+
+Please see the manual section on documentation for more
 information.
 """
 module Docs
@@ -68,9 +72,9 @@ export doc
 const modules = Module[]
 const META    = gensym(:meta)
 
-meta(m::Module = current_module()) = isdefined(m, META) ? getfield(m, META) : ObjectIdDict()
+meta(m::Module) = isdefined(m, META) ? getfield(m, META) : ObjectIdDict()
 
-function initmeta(m::Module = current_module())
+function initmeta(m::Module)
     if !isdefined(m, META)
         eval(m, :(const $META = $(ObjectIdDict())))
         push!(modules, m)
@@ -78,26 +82,38 @@ function initmeta(m::Module = current_module())
     nothing
 end
 
-function signature(expr::Expr)
-    if isexpr(expr, [:call, :macrocall])
+function signature!(tv, expr::Expr)
+    is_macrocall = isexpr(expr, :macrocall)
+    if is_macrocall || isexpr(expr, :call)
         sig = :(Union{Tuple{}})
-        for arg in expr.args[2:end]
+        first_arg = is_macrocall ? 3 : 2 # skip function arguments
+        for arg in expr.args[first_arg:end]
             isexpr(arg, :parameters) && continue
             if isexpr(arg, :kw) # optional arg
                 push!(sig.args, :(Tuple{$(sig.args[end].args[2:end]...)}))
             end
             push!(sig.args[end].args, argtype(arg))
         end
-        tv = typevars(expr)
+        if isexpr(expr.args[1], :curly) && isempty(tv)
+            append!(tv, tvar.(expr.args[1].args[2:end]))
+        end
+        for i = length(tv):-1:1
+            push!(sig.args, :(Tuple{$(tv[i].args[1])}))
+        end
         for i = length(tv):-1:1
             sig = Expr(:where, sig, tv[i])
         end
         sig
+    elseif isexpr(expr, :where)
+        append!(tv, tvar.(expr.args[2:end]))
+        signature!(tv, expr.args[1])
     else
-        signature(expr.args[1])
+        signature!(tv, expr.args[1])
     end
 end
-signature(other) = :(Union{})
+signature!(tv, other) = :(Union{})
+signature(expr::Expr) = signature!([], expr)
+signature(other) = signature!([], other)
 
 function argtype(expr::Expr)
     isexpr(expr, :(::))  && return expr.args[end]
@@ -106,11 +122,8 @@ function argtype(expr::Expr)
 end
 argtype(other) = :Any
 
-function typevars(expr::Expr)
-    isexpr(expr, :curly) && return expr.args[2:end]
-    typevars(expr.args[1])
-end
-typevars(::Symbol) = []
+tvar(x::Expr)   = x
+tvar(s::Symbol) = :($s <: Any)
 
 # Docsystem types.
 # ================
@@ -133,7 +146,7 @@ mutable struct DocStr
     data   :: Dict{Symbol, Any}
 end
 
-function docstr(binding::Binding, typesig::ANY = Union{})
+function docstr(binding::Binding, @nospecialize typesig = Union{})
     for m in modules
         dict = meta(m)
         if haskey(dict, binding)
@@ -156,10 +169,10 @@ _docstr(doc::DocStr, data) = (doc.data = merge(data, doc.data); doc)
 macro ref(x)
     binding = bindingexpr(namify(x))
     typesig = signature(x)
-    esc(docexpr(binding, typesig))
+    esc(docexpr(__source__, __module__, binding, typesig))
 end
 
-docexpr(args...) = Expr(:call, docstr, args...)
+docexpr(__source__, __module__, args...) = Expr(:call, docstr, args...)
 
 function formatdoc(d::DocStr)
     buffer = IOBuffer()
@@ -193,9 +206,9 @@ by a `Union` of `Tuple` types. For example the following `Method` definition
 
 is stored as `Tuple{Any, Any}` in the `MultiDoc` while
 
-    f{T}(x::T, y = ?) = ...
+    f(x::T, y = ?) where {T} = ...
 
-is stored as `Union{Tuple{T}, Tuple{T, Any}}`.
+is stored as `Union{Tuple{T, Any}, Tuple{T}} where T`.
 
 Note: The `Function`/`DataType` object's signature is always `Union{}`.
 """
@@ -212,18 +225,18 @@ end
 # =======================
 
 """
-    Docs.doc!(binding, str, sig)
+    Docs.doc!(__module__, binding, str, sig)
 
-Adds a new docstring `str` to the docsystem for `binding` and signature `sig`.
+Adds a new docstring `str` to the docsystem of `__module__` for `binding` and signature `sig`.
 """
-function doc!(b::Binding, str::DocStr, sig::ANY = Union{})
-    initmeta()
-    m = get!(meta(), b, MultiDoc())
+function doc!(__module__::Module, b::Binding, str::DocStr, @nospecialize sig = Union{})
+    initmeta(__module__)
+    m = get!(meta(__module__), 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.
-        s = "replacing docs for '$b :: $sig' in module '$(current_module())'."
-        isdefined(Base, :STDERR) ? warn(s) : ccall(:jl_, Void, (Any,), "WARNING: $s")
+        # that over-writing a docstring *may* have been accidental.  The warning
+        # is suppressed for symbols in Main, for interactive use (#23011).
+        __module__ == Main || warn("replacing docs for '$b :: $sig' in module '$(__module__)'.")
     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.
@@ -367,7 +380,7 @@ function summarize(io::IO, λ::Function, binding)
 end
 
 function summarize(io::IO, T::DataType, binding)
-    println(io, "**Summary:**")
+    println(io, "# Summary")
     println(io, "```")
     println(io,
             T.abstract ? "abstract type" :
@@ -376,8 +389,8 @@ function summarize(io::IO, T::DataType, binding)
             " ", T, " <: ", supertype(T)
             )
     println(io, "```")
-    if !isempty(fieldnames(T))
-        println(io, "**Fields:**")
+    if !T.abstract && T.name !== Tuple.name && !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)
@@ -386,13 +399,20 @@ function summarize(io::IO, T::DataType, binding)
         println(io, "```")
     end
     if !isempty(subtypes(T))
-        println(io, "**Subtypes:**")
+        println(io, "# Subtypes")
         println(io, "```")
         for t in subtypes(T)
             println(io, t)
         end
         println(io, "```")
     end
+    if supertype(T) != Any
+        println(io, "# Supertype Hierarchy")
+        println(io, "```")
+        Base.show_supertypes(io, T)
+        println(io)
+        println(io, "```")
+    end
 end
 
 function summarize(io::IO, m::Module, binding)
@@ -400,13 +420,13 @@ function summarize(io::IO, m::Module, binding)
     if isfile(readme)
         println(io, "Displaying the `README.md` for the module instead.\n")
         println(io, "---\n")
-        println(io, readstring(readme))
+        println(io, read(readme, String))
     else
-        println(io, "No `README.md` found for module `", m, "`.\n")
+        println(io, "No docstring or `README.md` found for module `", m, "`.\n")
     end
 end
 
-function summarize{T}(io::IO, ::T, binding)
+function summarize(io::IO, ::T, binding) where T
     println(io, "`", binding, "` is of type `", T, "`.\n")
     summarize(io, T, binding)
 end
@@ -443,7 +463,7 @@ function nameof(x::Expr, ismacro)
     if isexpr(x, :.)
         ismacro ? macroname(x) : x
     else
-        n = isexpr(x, [:module, :type, :bitstype]) ? 2 : 1
+        n = isexpr(x, (:module, :type, :bitstype)) ? 2 : 1
         nameof(x.args[n], ismacro)
     end
 end
@@ -462,26 +482,31 @@ isfield(x) = isexpr(x, :.) &&
 # =========================
 
 """
-    Docs.metadata(expr)
+    Docs.metadata(source, module, expr, ismodule)
 
 Build a `Dict` expression containing metadata captured from the expression `expr`.
 
 Fields that may be included in the returned `Dict`:
 
-- `:path`:       String representing the file where `expr` is defined.
+- `:path`:       Symbol 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)
+function metadata(__source__, __module__, expr, ismodule)
     args = []
     # Filename and linenumber of the docstring.
-    push!(args, :($(Pair)(:path, $(Base).@__FILE__)))
-    push!(args, :($(Pair)(:linenumber, $(unsafe_load(cglobal(:jl_lineno, Cint))))))
+    __file__ = isa(__source__.file, Symbol) ? String(__source__.file) : ""
+    push!(args, Pair(:path, __file__))
+    push!(args, Pair(:linenumber, __source__.line))
     # Module in which the docstring is defined.
-    push!(args, :($(Pair)(:module, $(current_module)())))
-    # Field docs for concrete types.
+    if ismodule # Module docs go inside the module with name `expr`
+        push!(args, :($Pair(:module, $expr)))
+    else
+        push!(args, Pair(:module, __module__))
+    end
     if isexpr(expr, :type)
+        # Field docs for concrete types.
         fields = []
         tmp = nothing
         for each in expr.args[3].args
@@ -498,37 +523,36 @@ function metadata(expr)
     :($(Dict)($(args...)))
 end
 
-function keyworddoc(str, def)
-    docstr = esc(docexpr(lazy_iterpolate(str), metadata(def)))
-    :($(keywords)[$(esc(quot(def.name)))] = $docstr)
+function keyworddoc(__source__, __module__, str, def)
+    docstr = esc(docexpr(__source__, __module__, lazy_iterpolate(str), metadata(__source__, __module__, def, false)))
+    return :($(keywords)[$(esc(quot(def.name)))] = $docstr)
 end
 
-function objectdoc(str, def, expr, sig = :(Union{}))
+function objectdoc(__source__, __module__, str, def, expr, sig = :(Union{}))
     binding = esc(bindingexpr(namify(expr)))
-    docstr  = esc(docexpr(lazy_iterpolate(str), metadata(expr)))
+    docstr  = esc(docexpr(__source__, __module__, lazy_iterpolate(str), metadata(__source__, __module__, expr, false)))
     quote
         $(esc(def))
-        $(doc!)($binding, $docstr, $(esc(sig)))
+        $(doc!)($__module__, $binding, $docstr, $(esc(sig)))
     end
 end
 
-function calldoc(str, def)
+function calldoc(__source__, __module__, str, def)
     args = def.args[2:end]
     if isempty(args) || all(validcall, args)
-        objectdoc(str, nothing, def, signature(def))
+        objectdoc(__source__, __module__, str, nothing, def, signature(def))
     else
         docerror(def)
     end
 end
-validcall(x) = isa(x, Symbol) || isexpr(x, [:(::), :..., :kw, :parameters])
+validcall(x) = isa(x, Symbol) || isexpr(x, (:(::), :..., :kw, :parameters))
 
-function moduledoc(meta, def, def′)
+function moduledoc(__source__, __module__, meta, def, def′)
     name  = namify(def′)
-    docex = Expr(:call, doc!, bindingexpr(name),
-        docexpr(lazy_iterpolate(meta), metadata(name))
-    )
+    docex = Expr(:call, doc!, name, bindingexpr(name),
+        docexpr(__source__, name, lazy_iterpolate(meta), metadata(__source__, __module__, name, true)))
     if def === nothing
-        esc(:(eval($name, $(quot(docex)))))
+        esc(:($eval($name, $(quot(docex)))))
     else
         def = unblock(def)
         block = def.args[3].args
@@ -542,18 +566,18 @@ function moduledoc(meta, def, def′)
 end
 
 # Shares a single doc, `meta`, between several expressions from the tuple expression `ex`.
-function multidoc(meta, ex, define)
+function multidoc(__source__, __module__, meta, ex, define)
     out = Expr(:toplevel)
-    str = docexpr(lazy_iterpolate(meta), metadata(ex))
+    str = docexpr(__source__, __module__, lazy_iterpolate(meta), metadata(__source__, __module__, ex, false))
     ref = Ref{DocStr}()
     for (n, arg) in enumerate(ex.args)
         # The first `arg` to be documented needs to also create the docstring for the group.
         # Subsequent `arg`s just need `ref` to be able to find the docstring without having
         # to create an entirely new one each.
         docstr = n === 1 ? :($(ref)[] = $str) : :($(ref)[])
-        push!(out.args, :(@doc($docstr, $arg, $define)))
+        push!(out.args, docm(__source__, __module__, docstr, arg, define))
     end
-    esc(out)
+    return out
 end
 
 """
@@ -581,7 +605,7 @@ function __doc__!(meta, def, define)
         # 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]
+            each.args = [Symbol("@doc"), nothing, meta, each.args[end], define] # TODO: forward line number info
         end
     else
         # `def` has already been defined during Base image gen so we just need to find and
@@ -624,19 +648,19 @@ const BINDING_HEADS = [:typealias, :const, :global, :(=)]  # deprecation: remove
 isquotedmacrocall(x) =
     isexpr(x, :copyast, 1) &&
     isa(x.args[1], QuoteNode) &&
-    isexpr(x.args[1].value, :macrocall, 1)
+    isexpr(x.args[1].value, :macrocall, 2)
 # Simple expressions / atoms the may be documented.
 isbasicdoc(x) = isexpr(x, :.) || isa(x, Union{QuoteNode, Symbol})
-is_signature(x) = isexpr(x, :call) || (isexpr(x, :(::), 2) && isexpr(x.args[1], :call))
+is_signature(x) = isexpr(x, :call) || (isexpr(x, :(::), 2) && isexpr(x.args[1], :call)) || isexpr(x, :where)
 
-function docm(meta, ex, define = true)
+function docm(source::LineNumberNode, mod::Module, 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))
+    x = unblock(macroexpand(mod, 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
-    if isa(x, GlobalRef) && (x::GlobalRef).mod == current_module()
+    if isa(x, GlobalRef) && (x::GlobalRef).mod == mod
         x = (x::GlobalRef).name
     end
 
@@ -645,7 +669,7 @@ function docm(meta, ex, define = true)
     #   "..."
     #   kw"if", kw"else"
     #
-    isa(x, Base.BaseDocs.Keyword) ? keyworddoc(meta, x) :
+    isa(x, Base.BaseDocs.Keyword) ? keyworddoc(source, mod, meta, x) :
 
     # Method / macro definitions and "call" syntax.
     #
@@ -655,9 +679,9 @@ function docm(meta, ex, define = true)
     #   function f end
     #   f(...)
     #
-    isexpr(x, FUNC_HEADS) && is_signature(x.args[1])   ? objectdoc(meta, def, x, signature(x)) :
-    isexpr(x, :function)  && !isexpr(x.args[1], :call) ? objectdoc(meta, def, x) :
-    isexpr(x, :call)                                   ? calldoc(meta, x) :
+    isexpr(x, FUNC_HEADS) && is_signature(x.args[1])   ? objectdoc(source, mod, meta, def, x, signature(x)) :
+    isexpr(x, :function)  && !isexpr(x.args[1], :call) ? objectdoc(source, mod, meta, def, x) :
+    isexpr(x, :call)                                   ? calldoc(source, mod, meta, x) :
 
     # Type definitions.
     #
@@ -665,7 +689,7 @@ function docm(meta, ex, define = true)
     #   abstract T
     #   bitstype N T
     #
-    isexpr(x, [:type, :abstract, :bitstype]) ? objectdoc(meta, def, x) :
+    isexpr(x, [:type, :abstract, :bitstype]) ? objectdoc(source, mod, meta, def, x) :
 
     # "Bindings". Names that resolve to objects with different names, ie.
     #
@@ -673,20 +697,20 @@ function docm(meta, ex, define = true)
     #   T = S
     #   global T = S
     #
-    isexpr(x, BINDING_HEADS) && !isexpr(x.args[1], :call) ? objectdoc(meta, def, x) :
+    isexpr(x, BINDING_HEADS) && !isexpr(x.args[1], :call) ? objectdoc(source, mod, meta, def, x) :
 
     # Quoted macrocall syntax. `:@time` / `:(Base.@time)`.
-    isquotedmacrocall(x) ? objectdoc(meta, def, x) :
+    isquotedmacrocall(x) ? objectdoc(source, mod, meta, def, x) :
     # Modules and baremodules.
-    isexpr(x, :module) ? moduledoc(meta, def, x) :
+    isexpr(x, :module) ? moduledoc(source, mod, meta, def, x) :
     # Document several expressions with the same docstring. `a, b, c`.
-    isexpr(x, :tuple) ? multidoc(meta, x, define) :
+    isexpr(x, :tuple) ? multidoc(source, mod, 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) :
+    isbasicdoc(x) ? objectdoc(source, mod, 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
@@ -705,14 +729,14 @@ function docerror(ex)
     :($(error)($txt, "\n"))
 end
 
-function docm(ex)
+function docm(source::LineNumberNode, mod::Module, ex)
     if isexpr(ex, :->)
-        docm(ex.args...)
+        docm(source, mod, 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])
+        if isexpr(ex, :call) || isexpr(ex, :macrocall)
             sig = esc(signature(ex))
             :($(doc)($binding, $sig))
         else
@@ -731,11 +755,21 @@ include("utils.jl")
 # Swap out the bootstrap macro with the real one.
 Core.atdoc!(docm)
 
+macro local_hygiene(expr)
+    # removes `esc` Exprs relative to the module argument to expand
+    # and resolves everything else relative to this (Doc) module
+    # this allows us to get good errors and backtraces
+    # from calling docm (by not using macros),
+    # while also getting macro-expansion correct (by using the macro-expander)
+    return expr
+end
 function loaddocs(docs)
+    unescape = GlobalRef(Docs, Symbol("@local_hygiene"))
     for (mod, ex, str, file, line) in docs
         data = Dict(:path => string(file), :linenumber => line)
         doc = docstr(str, data)
-        eval(mod, :(@doc($doc, $ex, false)))
+        docstring = docm(LineNumberNode(line, file), mod, doc, ex, false) # expand the real @doc macro now
+        eval(mod, Expr(:macrocall, unescape, nothing, docstring))
     end
     empty!(docs)
 end
diff --git a/base/docs/basedocs.jl b/base/docs/basedocs.jl
index 2e90a0a73161f1..e675042c4373f6 100644
--- a/base/docs/basedocs.jl
+++ b/base/docs/basedocs.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module BaseDocs
 
@@ -7,20 +7,17 @@ struct Keyword
 end
 macro kw_str(text) Keyword(Symbol(text)) end
 
-"Hello, Human."
-kw"hello", kw"hi"
-
 """
 **Welcome to Julia $(string(VERSION)).** The full manual is available at
 
-    http://docs.julialang.org/
+    https://docs.julialang.org/
 
 as well many great tutorials and learning resources:
 
-    http://julialang.org/learning/
+    https://julialang.org/learning/
 
 For help on a specific function or macro, type `?` followed
-by its name, e.g. `?fft`, or `?@time`, and press enter.
+by its name, e.g. `?cos`, or `?@time`, and press enter.
 """
 kw"help", kw"?", kw"julia"
 
@@ -84,7 +81,7 @@ Julia’s type system more than just a collection of object implementations. For
     abstract type Number end
     abstract type Real <: Number end
 
-`Number` has no supertype, whereas `Real` is an abstract subtype of `Number`.
+[`Number`](@ref) has no supertype, whereas [`Real`](@ref) is an abstract subtype of `Number`.
 """
 kw"abstract type"
 
@@ -127,7 +124,7 @@ primitive type declarations:
 
 The number after the name indicates how many bits of storage the type requires. Currently,
 only sizes that are multiples of 8 bits are supported.
-The `Bool` declaration shows how a primitive type can be optionally
+The [`Bool`](@ref) declaration shows how a primitive type can be optionally
 declared to be a subtype of some supertype.
 """
 kw"primitive type"
@@ -648,11 +645,34 @@ to be set after construction. See `struct` and the manual for more information.
 kw"mutable struct"
 
 """
-    @__LINE__ -> Int
+The `where` keyword creates a type that is an iterated union of other types, over all
+values of some variable. For example `Vector{T} where T<:Real` includes all `Vector`s
+where the element type is some kind of `Real` number.
+
+The variable bound defaults to `Any` if it is omitted:
+
+    Vector{T} where T    # short for `where T<:Any`
+
+Variables can also have lower bounds:
+
+    Vector{T} where T>:Int
+    Vector{T} where Int<:T<:Real
+
+There is also a concise syntax for nested `where` expressions. For example, this:
+
+    Pair{T, S} where S<:Array{T} where T<:Number
+
+can be shortened to:
+
+    Pair{T, S} where {T<:Number, S<:Array{T}}
 
-`@__LINE__` expands to the line number of the call-site.
+This form is often found on method signatures.
+
+Note that in this form, the variables are listed outermost-first. This matches the
+order in which variables are substituted when a type is "applied" to parameter values
+using the syntax `T{p1, p2, ...}`.
 """
-kw"@__LINE__"
+kw"where"
 
 """
     ans
@@ -670,12 +690,11 @@ The singleton instance of type `Void`, used by convention when there is no value
 nothing
 
 """
-    ANY
+    Core.TypeofBottom
 
-Equivalent to `Any` for dispatch purposes, but signals the compiler to skip code
-generation specialization for that field.
+The singleton type containing only the value `Union{}`.
 """
-ANY
+Core.TypeofBottom
 
 """
     DevNull
@@ -689,4 +708,22 @@ run(pipeline(`cat test.txt`, DevNull))
 """
 DevNull
 
+"""
+    Function
+
+Abstract type of all functions.
+
+```jldoctest
+julia> isa(+, Function)
+true
+
+julia> typeof(sin)
+Base.#sin
+
+julia> ans <: Function
+true
+```
+"""
+Function
+
 end
diff --git a/base/docs/bindings.jl b/base/docs/bindings.jl
index 40ca52cd09e0a6..f0c73997c7b635 100644
--- a/base/docs/bindings.jl
+++ b/base/docs/bindings.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 export @var
 
@@ -24,7 +24,7 @@ function splitexpr(x::Expr)
     isexpr(x, :.)         ? (x.args[1], x.args[2]) :
     error("Invalid @var syntax `$x`.")
 end
-splitexpr(s::Symbol) = Expr(:call, current_module), quot(s)
+splitexpr(s::Symbol) = Expr(:macrocall, getfield(Base, Symbol("@__MODULE__")), nothing), quot(s)
 splitexpr(other)     = error("Invalid @var syntax `$other`.")
 
 macro var(x)
diff --git a/base/docs/core.jl b/base/docs/core.jl
index 81993ae2ef2c36..b096bf13173aae 100644
--- a/base/docs/core.jl
+++ b/base/docs/core.jl
@@ -1,15 +1,11 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module CoreDocs
 
-import ..esc, ..push!, ..getindex, ..current_module, ..unsafe_load, ..Csize_t
+import ..esc, ..push!, ..getindex, ..unsafe_load, ..Csize_t
 
-function doc!(str, ex)
-    ptr  = unsafe_load(Core.Intrinsics.cglobal(:jl_filename, Ptr{UInt8}))
-    len  = ccall(:strlen, Csize_t, (Ptr{UInt8},), ptr)
-    file = ccall(:jl_symbol_n, Any, (Ptr{UInt8}, Csize_t), ptr, len)
-    line = unsafe_load(Core.Intrinsics.cglobal(:jl_lineno, Int32)) # Cint
-    push!(DOCS, (current_module(), ex, str, file, line))
+function doc!(source::LineNumberNode, mod::Module, str, ex)
+    push!(DOCS, (mod, ex, str, source.file, source.line))
 end
 const DOCS = Array{Any, 1}()
 
@@ -18,11 +14,12 @@ isexpr(x, h) = isa(x, Expr) && x.head === h
 lazy_iterpolate(s::AbstractString) = Expr(:call, Core.svec, s)
 lazy_iterpolate(x) = isexpr(x, :string) ? Expr(:call, Core.svec, x.args...) : x
 
-function docm(str, x)
-    out = esc(Expr(:call, doc!, lazy_iterpolate(str), Expr(:quote, x)))
+function docm(source::LineNumberNode, mod::Module, str, x)
+    out = esc(Expr(:call, doc!, QuoteNode(source), mod, lazy_iterpolate(str), Expr(:quote, x)))
     isexpr(x, :module) ? Expr(:toplevel, out, esc(x)) :
     isexpr(x, :call) ? out : Expr(:block, esc(x), out)
 end
-docm(x) = isexpr(x, :->) ? docm(x.args[1], x.args[2].args[2]) : error("invalid '@doc'.")
+docm(source::LineNumberNode, mod::Module, x) =
+    isexpr(x, :->) ? docm(source, mod, x.args[1], x.args[2].args[2]) : error("invalid '@doc'.")
 
 end
diff --git a/base/docs/helpdb.jl b/base/docs/helpdb.jl
index 713de51e6b985a..5e2a4fe44b28a8 100644
--- a/base/docs/helpdb.jl
+++ b/base/docs/helpdb.jl
@@ -1,3 +1,3 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
-include("helpdb/Base.jl")
+include(joinpath("helpdb", "Base.jl"))
diff --git a/base/docs/helpdb/Base.jl b/base/docs/helpdb/Base.jl
index d725d54390b6da..494242bf2e3363 100644
--- a/base/docs/helpdb/Base.jl
+++ b/base/docs/helpdb/Base.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Base
 
@@ -9,6 +9,7 @@ Fill array `A` with the value `x`. If `x` is an object reference, all elements w
 the same object. `fill!(A, Foo())` will return `A` filled with the result of evaluating
 `Foo()` once.
 
+# Examples
 ```jldoctest
 julia> A = zeros(2,3)
 2×3 Array{Float64,2}:
@@ -81,6 +82,7 @@ Subtraction operator.
 
 A string giving the literal bit representation of a number.
 
+# Examples
 ```jldoctest
 julia> bits(4)
 "0000000000000000000000000000000000000000000000000000000000000100"
@@ -91,64 +93,13 @@ julia> bits(2.2)
 """
 bits
 
-"""
-    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,...]`.
-
-```jldoctest
-julia> Int8[1, 2, 3]
-3-element Array{Int8,1}:
- 1
- 2
- 3
-
-julia> getindex(Int8, 1, 2, 3)
-3-element Array{Int8,1}:
- 1
- 2
- 3
-```
-"""
-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 man-array-indexing) for details.
-
-```jldoctest
-julia> A = [1 2; 3 4]
-2×2 Array{Int64,2}:
- 1  2
- 3  4
-
-julia> getindex(A, 1)
-1
-
-julia> getindex(A, [2, 1])
-2-element Array{Int64,1}:
- 3
- 1
-
-julia> getindex(A, 2:4)
-3-element Array{Int64,1}:
- 3
- 2
- 4
-```
-"""
-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, ...)`.
 
+# Examples
 ```jldoctest
 julia> A = Dict("a" => 1, "b" => 2)
 Dict{String,Int64} with 2 entries:
@@ -164,31 +115,19 @@ getindex(collection, key...)
 """
     cconvert(T,x)
 
-Convert `x` to a value of type `T`, typically by calling `convert(T,x)`
+Convert `x` to a value to be passed to C code as type `T`, typically by calling `convert(T, x)`.
 
 In cases where `x` cannot be safely converted to `T`, unlike [`convert`](@ref), `cconvert` may
 return an object of a type different from `T`, which however is suitable for
-[`unsafe_convert`](@ref) to handle.
+[`unsafe_convert`](@ref) to handle. The result of this function should be kept valid (for the GC)
+until the result of [`unsafe_convert`](@ref) is not needed anymore.
+This can be used to allocate memory that will be accessed by the `ccall`.
+If multiple objects need to be allocated, a tuple of the objects can be used as return value.
 
 Neither `convert` nor `cconvert` should take a Julia object and turn it into a `Ptr`.
 """
 cconvert
 
-"""
-    assert(cond)
-
-Throw an [`AssertionError`](@ref) if `cond` is `false`.
-Also available as the macro `@assert expr`.
-"""
-assert
-
-"""
-    sech(x)
-
-Compute the hyperbolic secant of `x`
-"""
-sech
-
 """
     unsafe_copy!(dest::Ptr{T}, src::Ptr{T}, N)
 
@@ -219,6 +158,7 @@ unsafe_copy!(dest::Array, d, src::Array, so, N)
 Create a Float32 from `x`. If `x` is not exactly representable then `mode` determines how
 `x` is rounded.
 
+# Examples
 ```jldoctest
 julia> Float32(1/3, RoundDown)
 0.3333333f0
@@ -229,7 +169,7 @@ julia> Float32(1/3, RoundUp)
 
 See [`RoundingMode`](@ref) for available rounding modes.
 """
-Float32
+Float32(x)
 
 """
     Mmap.mmap(io::Union{IOStream,AbstractString,Mmap.AnonymousMmap}[, type::Type{Array{T,N}}, dims, offset]; grow::Bool=true, shared::Bool=true)
@@ -243,7 +183,7 @@ determines how the bytes of the array are interpreted. Note that the file must b
 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.
+`dims` is a tuple or single [`Integer`](@ref) 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
@@ -302,31 +242,14 @@ the byte representation is different.
 
 This would create a 25-by-30000 `BitArray`, linked to the file associated with stream `s`.
 """
-Mmap.mmap(io, ::BitArray, dims = ?, offset = ?)
-
-"""
-    filter!(function, collection)
-
-Update `collection`, removing elements for which `function` is `false`.
-For associative collections, the function is passed two arguments (key and value).
-
-```jldoctest
-julia> filter!(isodd, collect(1:10))
-5-element Array{Int64,1}:
- 1
- 3
- 5
- 7
- 9
-```
-"""
-filter!
+Mmap.mmap(io, ::BitArray, dims, offset)
 
 """
     sizeof(T)
 
 Size, in bytes, of the canonical binary representation of the given DataType `T`, if any.
 
+# Examples
 ```jldoctest
 julia> sizeof(Float32)
 4
@@ -341,7 +264,7 @@ If `T` does not have a specific size, an error is thrown.
 julia> sizeof(Base.LinAlg.LU)
 ERROR: argument is an abstract type; size is indeterminate
 Stacktrace:
- [1] sizeof(::Type{T} where T) at ./essentials.jl:160
+ [1] sizeof(::Type{T} where T) at ./essentials.jl:150
 ```
 """
 sizeof(::Type)
@@ -378,6 +301,7 @@ oftype
 
 Insert one or more `items` at the end of `collection`.
 
+# Examples
 ```jldoctest
 julia> push!([1, 2, 3], 4, 5, 6)
 6-element Array{Int64,1}:
@@ -399,6 +323,12 @@ push!
     promote(xs...)
 
 Convert all arguments to their common promotion type (if any), and return them all (as a tuple).
+
+# Examples
+```jldoctest
+julia> promote(Int8(1), Float16(4.5), Float32(4.1))
+(1.0f0, 4.5f0, 4.1f0)
+```
 """
 promote
 
@@ -410,7 +340,6 @@ to synchronous `File`'s and `IOStream`'s not to any of the asynchronous streams.
 """
 fd
 
-
 """
     ones([A::AbstractArray,] [T=eltype(A)::Type,] [dims=size(A)::Tuple])
 
@@ -418,6 +347,7 @@ Create an array of all ones with the same layout as `A`, element type `T` and si
 The `A` argument can be skipped, which behaves like `Array{Float64,0}()` was passed.
 For convenience `dims` may also be passed in variadic form.
 
+# Examples
 ```jldoctest
 julia> ones(Complex128, 2, 3)
 2×3 Array{Complex{Float64},2}:
@@ -461,31 +391,6 @@ Like [`randsubseq`](@ref), but the results are stored in `S`
 """
 randsubseq!
 
-"""
-    redisplay(x)
-    redisplay(d::Display, x)
-    redisplay(mime, x)
-    redisplay(d::Display, mime, x)
-
-By default, the `redisplay` functions simply call [`display`](@ref).
-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
-
-"""
-    searchsorted(a, x, [by=<transform>,] [lt=<comparison>,] [rev=false])
-
-Returns the range of indices of `a` which compare as equal to `x` (using binary search)
-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)
 
@@ -501,54 +406,12 @@ Show every part of the representation of a value.
 """
 dump
 
-"""
-    isinteractive() -> Bool
-
-Determine whether Julia is running an interactive session.
-"""
-isinteractive
-
-"""
-    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`](@ref) 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`](@ref) 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
-
 """
     tuple(xs...)
 
 Construct a tuple of the given objects.
 
+# Examples
 ```jldoctest
 julia> tuple(1, 'a', pi)
 (1, 'a', π = 3.1415926535897...)
@@ -570,6 +433,7 @@ eachmatch
 
 Get a hexadecimal string of the binary representation of a floating point number.
 
+# Examples
 ```jldoctest
 julia> num2hex(2.2)
 "400199999999999a"
@@ -590,6 +454,7 @@ truncate
 
 Compute ``10^x``.
 
+# Examples
 ```jldoctest
 julia> exp10(2)
 100.0
@@ -600,25 +465,10 @@ julia> exp10(0.2)
 """
 exp10
 
-"""
-    &(x, y)
-
-Bitwise and.
-
-```jldoctest
-julia> 4 & 10
-0
-
-julia> 4 & 12
-4
-```
-"""
-&
-
 """
     select(v, k, [by=<transform>,] [lt=<comparison>,] [rev=false])
 
-Variant of `select!` which copies `v` before partially sorting it, thereby returning the
+Variant of [`select!`](@ref) which copies `v` before partially sorting it, thereby returning the
 same thing as `select!` but leaving `v` unmodified.
 """
 select
@@ -664,6 +514,41 @@ ErrorException
     reverse(v [, start=1 [, stop=length(v) ]] )
 
 Return a copy of `v` reversed from start to stop.
+
+# Examples
+```jldoctest
+julia> A = collect(1:5)
+5-element Array{Int64,1}:
+ 1
+ 2
+ 3
+ 4
+ 5
+
+julia> reverse(A)
+5-element Array{Int64,1}:
+ 5
+ 4
+ 3
+ 2
+ 1
+
+julia> reverse(A, 1, 4)
+5-element Array{Int64,1}:
+ 4
+ 3
+ 2
+ 1
+ 5
+
+julia> reverse(A, 3, 5)
+5-element Array{Int64,1}:
+ 1
+ 2
+ 5
+ 4
+ 3
+```
 """
 reverse
 
@@ -686,15 +571,14 @@ UndefRefError
 
 Add the elements of `collection2` to the end of `collection`.
 
+# Examples
 ```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
@@ -718,18 +602,12 @@ Seek a stream relative to the current position.
 """
 skip
 
-"""
-    setdiff!(s, iterable)
-
-Remove each element of `iterable` from set `s` in-place.
-"""
-setdiff!
-
 """
     copysign(x, y) -> z
 
 Return `z` which has the magnitude of `x` and the same sign as `y`.
 
+# Examples
 ```jldoctest
 julia> copysign(1, -2)
 -1
@@ -740,33 +618,13 @@ julia> copysign(-1, 2)
 """
 copysign
 
-"""
-    @show
-
-Show an expression and result, returning the result.
-"""
-:@show
-
-"""
-    showcompact(x)
-
-Show a compact representation of a value.
-
-This is used for printing array elements without repeating type information (which would
-be redundant with that printed once for the whole array), and without line breaks inside
-the representation of an element.
-
-To offer a compact representation different from its standard one, a custom type should
-test `get(io, :compact, false)` in its normal `show` method.
-"""
-showcompact
-
 """
     getfield(value, name::Symbol)
 
 Extract a named field from a `value` of composite type. The syntax `a.b` calls
 `getfield(a, :b)`.
 
+# Examples
 ```jldoctest
 julia> a = 1//2
 1//2
@@ -786,17 +644,49 @@ at the position where it would appear if the array were fully sorted via a non-s
 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!
 
-"""
-    randstring([rng,] len=8)
+# Examples
+```jldoctest
+julia> a = [1, 2, 4, 3, 4]
+5-element Array{Int64,1}:
+ 1
+ 2
+ 4
+ 3
+ 4
+
+julia> select!(a, 4)
+4
+
+julia> a
+5-element Array{Int64,1}:
+ 1
+ 2
+ 3
+ 4
+ 4
+
+julia> a = [1, 2, 4, 3, 4]
+5-element Array{Int64,1}:
+ 1
+ 2
+ 4
+ 3
+ 4
+
+julia> select!(a, 4, rev=true)
+2
 
-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).
+julia> a
+5-element Array{Int64,1}:
+ 4
+ 4
+ 3
+ 2
+ 1
+```
 """
-randstring
+select!
 
 """
     Float64(x [, mode::RoundingMode])
@@ -804,6 +694,7 @@ randstring
 Create a Float64 from `x`. If `x` is not exactly representable then `mode` determines how
 `x` is rounded.
 
+# Examples
 ```jldoctest
 julia> Float64(pi, RoundDown)
 3.141592653589793
@@ -814,13 +705,35 @@ julia> Float64(pi, RoundUp)
 
 See [`RoundingMode`](@ref) for available rounding modes.
 """
-Float64
+Float64(x)
 
 """
     union(s1,s2...)
     ∪(s1,s2...)
 
 Construct the union of two or more sets. Maintains order with arrays.
+
+# Examples
+```jldoctest
+julia> union([1, 2], [3, 4])
+4-element Array{Int64,1}:
+ 1
+ 2
+ 3
+ 4
+
+julia> union([1, 2], [2, 4])
+3-element Array{Int64,1}:
+ 1
+ 2
+ 4
+
+julia> union([4, 2], [1, 2])
+3-element Array{Int64,1}:
+ 4
+ 2
+ 1
+```
 """
 union
 
@@ -829,6 +742,7 @@ union
 
 The highest finite value representable by the given floating-point DataType `T`.
 
+# Examples
 ```jldoctest
 julia> realmax(Float16)
 Float16(6.55e4)
@@ -855,6 +769,7 @@ serialize
 
 The lowest value representable by the given (real) numeric DataType `T`.
 
+# Examples
 ```jldoctest
 julia> typemin(Float16)
 -Inf16
@@ -888,7 +803,8 @@ trunc
 """
     unsafe_convert(T,x)
 
-Convert `x` to a value of type `T`
+Convert `x` to a C argument of type `T`
+where the input `x` must be the return value of `cconvert(T, ...)`.
 
 In cases where [`convert`](@ref) would need to take a Julia object
 and turn it into a `Ptr`, this function should be used to define and perform
@@ -902,6 +818,8 @@ 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.
+
+See also [`cconvert`](@ref)
 """
 unsafe_convert
 
@@ -912,15 +830,6 @@ Seek a stream to the given position.
 """
 seek
 
-"""
-    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
-
 """
     cglobal((symbol, library) [, type=Void])
 
@@ -938,6 +847,7 @@ cglobal
 
 Returns the last index of the collection.
 
+# Examples
 ```jldoctest
 julia> endof([1,2,4])
 3
@@ -950,6 +860,7 @@ endof
 
 For a given iterable object and iteration state, return the current item and the next iteration state.
 
+# Examples
 ```jldoctest
 julia> next(1:5, 3)
 (3, 4)
@@ -985,7 +896,29 @@ finalize
 """
     BoundsError([a],[i])
 
-An indexing operation into an array, `a`, tried to access an out-of-bounds element, `i`.
+An indexing operation into an array, `a`, tried to access an out-of-bounds element at index `i`.
+
+# Examples
+```jldoctest
+julia> A = ones(7);
+
+julia> A[8]
+ERROR: BoundsError: attempt to access 7-element Array{Float64,1} at index [8]
+Stacktrace:
+ [1] getindex(::Array{Float64,1}, ::Int64) at ./array.jl:586
+
+julia> B = ones(2, 3);
+
+julia> B[2, 4]
+ERROR: BoundsError: attempt to access 2×3 Array{Float64,2} at index [2, 4]
+Stacktrace:
+ [1] getindex(::Array{Float64,2}, ::Int64, ::Int64) at ./array.jl:587
+
+julia> B[9]
+ERROR: BoundsError: attempt to access 2×3 Array{Float64,2} at index [9]
+Stacktrace:
+ [1] getindex(::Array{Float64,2}, ::Int64) at ./array.jl:586
+```
 """
 BoundsError
 
@@ -1010,6 +943,14 @@ stop as soon as it has parsed a valid expression. Incomplete but otherwise synta
 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.
+
+```jldoctest
+julia> parse("x = 3, y = 5", 7)
+(:(y = 5), 13)
+
+julia> parse("x = 3, y = 5", 5)
+(:((3, y) = 5), 13)
+```
 """
 parse(str, start)
 
@@ -1020,6 +961,22 @@ Parse the expression string greedily, returning a single expression. An error is
 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.
+
+```jldoctest
+julia> parse("x = 3")
+:(x = 3)
+
+julia> parse("x = ")
+:($(Expr(:incomplete, "incomplete: premature end of input")))
+
+julia> parse("1.0.2")
+ERROR: ParseError("invalid numeric constant \\\"1.0.\\\"")
+Stacktrace:
+[...]
+
+julia> parse("1.0.2"; raise = false)
+:($(Expr(:error, "invalid numeric constant \"1.0.\"")))
+```
 """
 parse(str)
 
@@ -1029,6 +986,20 @@ parse(str)
 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.
+
+```jldoctest
+julia> parse(Int, "1234")
+1234
+
+julia> parse(Int, "1234", 5)
+194
+
+julia> parse(Int, "afc", 16)
+2812
+
+julia> parse(Float64, "1.2e-3")
+0.0012
+```
 """
 parse(T::Type, str, base=Int)
 
@@ -1047,9 +1018,9 @@ Return a partial permutation of the vector `v`, according to the order specified
 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
+from [`select`](@ref) 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]`
+`sortperm(...)[k]`.
 """
 selectperm
 
@@ -1061,8 +1032,17 @@ For arrays, this constructs an array with the same binary data as the given
 array, but with the specified element type.
 For example,
 `reinterpret(Float32, UInt32(7))` interprets the 4 bytes corresponding to `UInt32(7)` as a
-`Float32`.
+[`Float32`](@ref).
+
+!!! warning
 
+    It is not allowed to `reinterpret` an array to an element type with a larger alignment then
+    the alignment of the array. For a normal `Array`, this is the alignment of its element type.
+    For a reinterpreted array, this is the alignment of the `Array` it was reinterpreted from.
+    For example, `reinterpret(UInt32, UInt8[0, 0, 0, 0])` is not allowed but
+    `reinterpret(UInt32, reinterpret(UInt8, Float32[1.0]))` is allowed.
+
+# Examples
 ```jldoctest
 julia> reinterpret(Float32, UInt32(7))
 1.0f-44
@@ -1074,29 +1054,12 @@ julia> reinterpret(Float32, UInt32[1 2 3 4 5])
 """
 reinterpret
 
-"""
-    ~(x)
-
-Bitwise not.
-
-```jldoctest
-julia> ~4
--5
-
-julia> ~10
--11
-
-julia> ~true
-false
-```
-"""
-~
-
 """
     bswap(n)
 
 Byte-swap an integer. Flip the bits of its binary representation.
 
+# Examples
 ```jldoctest
 julia> a = bswap(4)
 288230376151711744
@@ -1113,45 +1076,33 @@ julia> bin(bswap(1))
 """
 bswap
 
-"""
-    maxintfloat(T)
-
-The largest integer losslessly representable by the given floating-point DataType `T`.
-"""
-maxintfloat
-
 """
     delete!(collection, key)
 
 Delete the mapping for the given key in a collection, and return the collection.
-"""
-delete!
-
 
-"""
-    searchsortedfirst(a, x, [by=<transform>,] [lt=<comparison>,] [rev=false])
+# Examples
+```jldoctest
+julia> d = Dict("a"=>1, "b"=>2)
+Dict{String,Int64} with 2 entries:
+  "b" => 2
+  "a" => 1
 
-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`.
+julia> delete!(d, "b")
+Dict{String,Int64} with 1 entry:
+  "a" => 1
+```
 """
-searchsortedfirst
+delete!
 
 """
     big(x)
 
-Convert a number to a maximum precision representation (typically `BigInt` or `BigFloat`).
-See [`BigFloat`](@ref) for information about some pitfalls with floating-point numbers.
+Convert a number to a maximum precision representation (typically [`BigInt`](@ref) or
+`BigFloat`). See [`BigFloat`](@ref) for information about some pitfalls with floating-point numbers.
 """
 big
 
-"""
-    quit()
-
-Quit the program indicating that the processes completed successfully. This function calls
-`exit(0)` (see [`exit`](@ref)).
-"""
-quit
-
 """
     typejoin(T, S)
 
@@ -1162,7 +1113,7 @@ typejoin
 """
     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`
+Like [`selectperm`](@ref), but accepts a preallocated index vector `ix`. If `initialized` is `false`
 (the default), ix is initialized to contain the values `1:length(ix)`.
 """
 selectperm!
@@ -1175,17 +1126,21 @@ Compile the given function `f` for the argument tuple (of types) `args`, but do
 precompile
 
 """
-    cot(x)
-
-Compute the cotangent of `x`, where `x` is in radians.
-"""
-cot
-
-"""
-    get(collection, key, default)
+    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.
+
+# Examples
+```jldoctest
+julia> d = Dict("a"=>1, "b"=>2);
+
+julia> get(d, "a", 3)
+1
+
+julia> get(d, "c", 3)
+3
+```
 """
 get(collection,key,default)
 
@@ -1214,13 +1169,6 @@ Forces synchronization between the in-memory version of a memory-mapped `Array`
 """
 Mmap.sync!
 
-"""
-    csc(x)
-
-Compute the cosecant of `x`, where `x` is in radians.
-"""
-csc
-
 """
     hash(x[, h::UInt])
 
@@ -1238,6 +1186,10 @@ hash
     read(stream::IO, T)
 
 Read a single value of type `T` from `stream`, in canonical binary representation.
+
+    read(stream::IO, String)
+
+Read the entirety of `stream`, as a String.
 """
 read(stream, t)
 
@@ -1246,6 +1198,7 @@ read(stream, t)
 
 Remove the first `item` from `collection`.
 
+# Examples
 ```jldoctest
 julia> A = [1, 2, 3, 4, 5, 6]
 6-element Array{Int64,1}:
@@ -1278,53 +1231,40 @@ Run a command object asynchronously, returning the resulting `Process` object.
 spawn
 
 """
-    isdefined([m::Module,] s::Symbol)
+    isdefined(m::Module, s::Symbol)
     isdefined(object, s::Symbol)
     isdefined(object, index::Int)
 
 Tests whether an assignable location is defined. The arguments can be a module and a symbol
-or a composite object and field name (as a symbol) or index. With a single symbol argument,
-tests whether a global variable with that name is defined in [`current_module()`](@ref).
+or a composite object and field name (as a symbol) or index.
 """
 isdefined
 
-"""
-    cotd(x)
-
-Compute the cotangent of `x`, where `x` is in degrees.
-"""
-cotd
-
 """
     wait([x])
 
 Block the current task until some event occurs, depending on the type of the argument:
 
-* [`RemoteChannel`](@ref) : Wait for a value to become available on the specified remote channel.
+* [`RemoteChannel`](@ref) : Wait for a value to become available on the specified remote
+  channel.
 * [`Future`](@ref) : Wait for a value to become available for the specified future.
 * [`Channel`](@ref): Wait for a value to be appended to the channel.
 * [`Condition`](@ref): Wait for [`notify`](@ref) 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`](@ref): 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`](@ref) for keyword arguments and return code)
+* [`Task`](@ref): 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`](@ref) 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`](@ref) or [`yieldto`](@ref).
 
-Often `wait` is called within a `while` loop to ensure a waited-for condition is met before proceeding.
+Often `wait` is called within a `while` loop to ensure a waited-for condition is met before
+proceeding.
 """
 wait
 
-"""
-    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
-
 """
     copy(x)
 
@@ -1339,6 +1279,7 @@ copy
 
 Determine whether a collection is empty (has no elements).
 
+# Examples
 ```jldoctest
 julia> isempty([])
 true
@@ -1357,9 +1298,17 @@ Convert a hexadecimal string to the floating point number it represents.
 hex2num
 
 """
-    InexactError()
+    InexactError(name::Symbol, T, val)
+
+Cannot exactly convert `val` to type `T` in a method of function `name`.
 
-Type conversion cannot be done exactly.
+# Examples
+```jldoctest
+julia> convert(Float64, 1+2im)
+ERROR: InexactError: convert(Float64, 1 + 2im)
+Stacktrace:
+ [1] convert(::Type{Float64}, ::Complex{Int64}) at ./complex.jl:37
+```
 """
 InexactError
 
@@ -1371,21 +1320,23 @@ The highest value representable by the given (real) numeric `DataType`.
 typemax
 
 """
-    DomainError()
+    DomainError(val)
+    DomainError(val, msg)
 
-The arguments to a function or constructor are outside the valid domain.
-"""
-DomainError
-
-"""
-    IntSet([itr])
+The argument `val` to a function or constructor is outside the valid domain.
 
-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`](@ref) instead.
+# Examples
+```jldoctest
+julia> sqrt(-1)
+ERROR: DomainError with -1.0:
+sqrt will only return a complex result if called with a complex argument. Try sqrt(Complex(x)).
+Stacktrace:
+ [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
+ [2] sqrt at ./math.jl:462 [inlined]
+ [3] sqrt(::Int64) at ./math.jl:472
+```
 """
-IntSet
+DomainError
 
 """
     Task(func)
@@ -1393,6 +1344,7 @@ IntSet
 Create a `Task` (i.e. coroutine) to execute the given function (which must be
 callable with no arguments). The task exits when this function returns.
 
+# Examples
 ```jldoctest
 julia> a() = det(rand(1000, 1000));
 
@@ -1403,15 +1355,6 @@ In this example, `b` is a runnable `Task` that hasn't started yet.
 """
 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
-
 """
     StackOverflowError()
 
@@ -1420,25 +1363,13 @@ recurses infinitely.
 """
 StackOverflowError
 
-"""
-    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`](@ref), or using the `big`
-string literal.
-"""
-BigInt
-
 """
     ==(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.
+Generic equality operator, giving a single [`Bool`](@ref) 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.
 
@@ -1457,16 +1388,16 @@ Seek a stream to its beginning.
 seekstart
 
 """
-    nfields(x::DataType) -> Int
+    nfields(x) -> Int
 
-Get the number of fields of a `DataType`.
+Get the number of fields in the given object.
 """
 nfields
 
 """
     show(stream, mime, x)
 
-The `display` functions ultimately call `show` in order to write an object `x` as a
+The [`display`](@ref) functions ultimately call `show` 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 `show` method for `T`, via: `show(stream, ::MIME"mime", x::T) = ...`,
@@ -1494,31 +1425,17 @@ See [`IOContext`](@ref) for details.
 """
 show(stream, mime, x)
 
-"""
-    mean!(r, v)
-
-Compute the mean of `v` over the singleton dimensions of `r`, and write results to `r`.
-"""
-mean!
-
 """
     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
+is the default comparison used by [`sort`](@ref). 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
 
-"""
-    showerror(io, e)
-
-Show a descriptive representation of an exception object.
-"""
-showerror
-
 """
     error(message::AbstractString)
 
@@ -1561,6 +1478,24 @@ unsafe_trunc
 
 Returns the "parent array" of an array view type (e.g., `SubArray`), or the array itself if
 it is not a view.
+
+# Examples
+```jldoctest
+julia> a = [1 2; 3 4]
+2×2 Array{Int64,2}:
+ 1  2
+ 3  4
+
+julia> s_a = Symmetric(a)
+2×2 Symmetric{Int64,Array{Int64,2}}:
+ 1  2
+ 2  4
+
+julia> parent(s_a)
+2×2 Array{Int64,2}:
+ 1  2
+ 3  4
+```
 """
 parent
 
@@ -1573,13 +1508,6 @@ used only with extreme caution, as it can cause memory use to grow without bound
 """
 gc_enable
 
-"""
-    secd(x)
-
-Compute the secant of `x`, where `x` is in degrees.
-"""
-secd
-
 """
     OverflowError()
 
@@ -1621,43 +1549,14 @@ by `show` generally includes Julia-specific formatting and type information.
 show(x)
 
 """
-    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`.
-
-```jldoctest
-julia> issubtype(Int8, Int32)
-false
-
-julia> Int8 <: Integer
-true
-```
-"""
-issubtype(type1, type2)
-
-"""
-    finalizer(x, function)
+    finalizer(x, f)
 
 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.
+`x`. The type of `x` must be a `mutable struct`, otherwise the behavior of this function is
+unpredictable.
 """
 finalizer
 
-"""
-    csch(x)
-
-Compute the hyperbolic cosecant of `x`.
-"""
-csch
-
-"""
-    sec(x)
-
-Compute the secant of `x`, where `x` is in radians.
-"""
-sec
-
 """
     TypeError(func::Symbol, context::AbstractString, expected::Type, got)
 
@@ -1709,6 +1608,7 @@ matchall
 Return the value stored for the given key, or if no mapping for the key is present, store
 `key => default`, and return `default`.
 
+# Examples
 ```jldoctest
 julia> d = Dict("a"=>1, "b"=>2, "c"=>3);
 
@@ -1735,20 +1635,14 @@ Return the value stored for the given key, or if no mapping for the key is prese
 `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
+```julia
+get!(dict, key) do
+    # default value calculated here
+    time()
+end
+```
 """
 get!(f::Function,collection,key)
-
-"""
-    @assert cond [text]
-
-Throw an `AssertionError` if `cond` is `false`. Preferred syntax for writing assertions.
-Message `text` is optionally displayed upon assertion failure.
-"""
 :@assert
 
 """
@@ -1765,28 +1659,24 @@ deserialize
 """
     length(collection) -> Integer
 
-For ordered, indexable collections, returns the maximum index `i` for which `getindex(collection, i)`
-is valid.
-For unordered collections, returns the number of elements.
+Return the number of elements in the collection.
+
+Use [`endof`](@ref) to get the last valid index of an indexable collection.
 
+# Examples
 ```jldoctest
 julia> length(1:5)
 5
 
-julia> length([1; 2; 3; 4])
+julia> length([1, 2, 3, 4])
+4
+
+julia> length([1 2; 3 4])
 4
 ```
 """
 length(collection)
 
-"""
-    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()
 
@@ -1805,27 +1695,19 @@ issubnormal
     NullException()
 
 An attempted access to a [`Nullable`](@ref) with no defined value.
-"""
-NullException
-
-"""
-    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
+# Examples
+```jldoctest
+julia> a = Nullable{Int}()
+Nullable{Int64}()
 
-    bar = cfunction(foo, Float64, ())
+julia> get(a)
+ERROR: NullException()
+Stacktrace:
+ [1] get(::Nullable{Int64}) at ./nullable.jl:92
+```
 """
-cfunction
+NullException
 
 """
     intersect(s1,s2...)
@@ -1833,16 +1715,21 @@ cfunction
 
 Construct the intersection of two or more sets.
 Maintains order and multiplicity of the first argument for arrays and ranges.
-"""
-intersect
 
-"""
-    @spawn
+# Examples
+```jldoctest
+julia> intersect([1, 2, 3], [3, 4, 5])
+1-element Array{Int64,1}:
+ 3
 
-Creates a closure around an expression and runs it on an automatically-chosen process,
-returning a [`Future`](@ref) to the result.
+julia> intersect([1, 4, 4, 5, 6], [4, 6, 6, 7, 8])
+3-element Array{Int64,1}:
+ 4
+ 4
+ 6
+```
 """
-:@spawn
+intersect
 
 """
     promote_rule(type1, type2)
@@ -1853,13 +1740,6 @@ it for new types as appropriate.
 """
 promote_rule
 
-"""
-    showall(x)
-
-Similar to [`show`](@ref), except shows all elements of arrays.
-"""
-showall
-
 """
     match(r::Regex, s::AbstractString[, idx::Integer[, addopts]])
 
@@ -1870,18 +1750,12 @@ retrieved by accessing `m.match` and the captured sequences can be retrieved by
 """
 match
 
-"""
-    coth(x)
-
-Compute the hyperbolic cotangent of `x`.
-"""
-coth
-
 """
     start(iter) -> state
 
 Get initial iteration state for an iterable object.
 
+# Examples
 ```jldoctest
 julia> start(1:5)
 1
@@ -1895,14 +1769,6 @@ julia> start([4;2;3])
 """
 start
 
-"""
-    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
-
 """
     isa(x, type) -> Bool
 
@@ -1916,6 +1782,7 @@ isa
 
 Test whether we are done iterating.
 
+# Examples
 ```jldoctest
 julia> done(1:5, 3)
 false
@@ -1934,21 +1801,22 @@ done
 
 Convert `x` to a value of type `T`.
 
-If `T` is an `Integer` type, an [`InexactError`](@ref) will be raised if `x`
+If `T` is an [`Integer`](@ref) type, an [`InexactError`](@ref) 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`.
 
+# Examples
 ```jldoctest
 julia> convert(Int, 3.0)
 3
 
 julia> convert(Int, 3.5)
-ERROR: InexactError()
+ERROR: InexactError: convert(Int64, 3.5)
 Stacktrace:
- [1] convert(::Type{Int64}, ::Float64) at ./float.jl:675
+ [1] convert(::Type{Int64}, ::Float64) at ./float.jl:680
 ```
 
-If `T` is a `AbstractFloat` or `Rational` type,
+If `T` is a [`AbstractFloat`](@ref) or [`Rational`](@ref) type,
 then it will return the closest value to `x` representable by `T`.
 
 ```jldoctest
@@ -2004,6 +1872,7 @@ convert
 
 Determine whether the given generic function has a method applicable to the given arguments.
 
+# Examples
 ```jldoctest
 julia> function f(x, y)
            x + y
@@ -2027,13 +1896,6 @@ algorithms. See [`muladd`](@ref).
 """
 fma
 
-"""
-    copy!(dest, src)
-
-Copy all elements from collection `src` to array `dest`. Returns `dest`.
-"""
-copy!(dest,src)
-
 """
     copy!(dest, do, src, so, N)
 
@@ -2049,13 +1911,6 @@ Addition operator. `x+y+z+...` calls this function with all arguments, i.e. `+(x
 """
 +
 
-"""
-    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...)
 
@@ -2064,47 +1919,6 @@ 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`](@ref)) `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
-
-"""
-    full(F)
-
-Reconstruct the matrix `A` from the factorization `F=factorize(A)`.
-"""
-full(F)
-
-"""
-    throw(e)
-
-Throw an object as an exception.
-"""
-throw
-
-"""
-    issubset(a, b)
-    ⊆(a,b) -> Bool
-    ⊈(a,b) -> Bool
-    ⊊(a,b) -> Bool
-
-Determine whether every element of `a` is also in `b`, using [`in`](@ref).
-"""
-issubset(a,b)
-
-"""
-    issubset(A, S) -> Bool
-    ⊆(A,S) -> Bool
-
-Return `true` if `A` is a subset of or equal to `S`.
-"""
-issubset
-
 """
     zeros([A::AbstractArray,] [T=eltype(A)::Type,] [dims=size(A)::Tuple])
 
@@ -2112,7 +1926,7 @@ Create an array of all zeros with the same layout as `A`, element type `T` and s
 The `A` argument can be skipped, which behaves like `Array{Float64,0}()` was passed.
 For convenience `dims` may also be passed in variadic form.
 
-
+# Examples
 ```jldoctest
 julia> zeros(1)
 1-element Array{Float64,1}:
@@ -2167,238 +1981,238 @@ isvalid(value)
     isvalid(T, value) -> Bool
 
 Returns `true` if the given value is valid for that type. Types currently can
-be either `Char` or `String`. Values for `Char` can be of type `Char` or `UInt32`.
+be either `Char` or `String`. Values for `Char` can be of type `Char` or [`UInt32`](@ref).
 Values for `String` can be of that type, or `Vector{UInt8}`.
 """
 isvalid(T,value)
 
 """
-    unsigned(x) -> Unsigned
+    skipchars(stream, predicate; linecomment::Char)
 
-Convert a number to an unsigned integer. If the argument is signed, it is reinterpreted as
-unsigned without checking for negative values.
+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.
 """
-unsigned
+skipchars
 
 """
-    reverseind(v, i)
+    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.
 
-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.)
+# Examples
+```jldoctest
+julia> d = Dict("a"=>1, "b"=>2, "c"=>3);
+
+julia> pop!(d, "a")
+1
+
+julia> pop!(d, "d")
+ERROR: KeyError: key "d" not found
+Stacktrace:
+ [1] pop!(::Dict{String,Int64}, ::String) at ./dict.jl:539
+
+julia> pop!(d, "e", 4)
+4
+```
 """
-reverseind
+pop!(collection,key,default)
 
 """
-    signbit(x)
+    pop!(collection) -> item
 
-Returns `true` if the value of the sign of `x` is negative, otherwise `false`.
+Remove an item in `collection` and return it. If `collection` is an
+ordered container, the last item is returned.
 
+# Examples
 ```jldoctest
-julia> signbit(-4)
-true
+julia> A=[1, 2, 3]
+3-element Array{Int64,1}:
+ 1
+ 2
+ 3
 
-julia> signbit(5)
-false
+julia> pop!(A)
+3
 
-julia> signbit(5.5)
-false
+julia> A
+2-element Array{Int64,1}:
+ 1
+ 2
 
-julia> signbit(-4.1)
-true
-```
-"""
-signbit
+julia> S = Set([1, 2])
+Set([2, 1])
 
-"""
-    cscd(x)
+julia> pop!(S)
+2
 
-Compute the cosecant of `x`, where `x` is in degrees.
-"""
-cscd
+julia> S
+Set([1])
 
+julia> pop!(Dict(1=>2))
+1 => 2
+```
 """
-    tryparse(type, str, [base])
+pop!(collection)
 
-Like [`parse`](@ref), but returns a [`Nullable`](@ref) of the requested type. The result will be null if the
-string does not contain a valid number.
 """
-tryparse
+    seekend(s)
 
+Seek a stream to its end.
 """
-    exit([code])
+seekend
 
-Quit (or control-D at the prompt). The default exit code is zero, indicating that the
-processes completed successfully.
 """
-exit
+    DivideError()
 
-"""
-    skipchars(stream, predicate; linecomment::Char)
+Integer division was attempted with a denominator value of 0.
 
-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
+# Examples
+```jldoctest
+julia> 2/0
+Inf
 
+julia> div(2, 0)
+ERROR: DivideError: integer division error
+Stacktrace:
+ [1] div(::Int64, ::Int64) at ./int.jl:183
+```
 """
-    realmin(T)
+DivideError
 
-The smallest in absolute value non-subnormal value representable by the given floating-point DataType `T`.
 """
-realmin
+    Number
 
+Abstract supertype for all number types.
 """
-    union!(s, iterable)
+Number
 
-Union each element of `iterable` into set `s` in-place.
 """
-union!
+    Real <: Number
 
+Abstract supertype for all real numbers.
 """
-    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.
+Real
 
-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
+    AbstractFloat <: Real
 
+Abstract supertype for all floating point numbers.
 """
-    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))`.
+AbstractFloat
 
-```jldoctest
-julia> widen(Int32)
-Int64
-
-julia> widen(1.5f0)
-1.5
-```
 """
-widen
+    Integer <: Real
 
+Abstract supertype for all integers.
 """
-    Set([itr])
+Integer
 
-Construct a [`Set`](@ref) of the values generated by the given iterable object, or an
-empty set. Should be used instead of [`IntSet`](@ref) for sparse integer sets, or
-for sets of arbitrary objects.
 """
-Set
+    Signed <: Integer
 
+Abstract supertype for all signed integers.
 """
-    signed(x)
+Signed
 
-Convert a number to a signed integer. If the argument is unsigned, it is reinterpreted as
-signed without checking for overflow.
 """
-signed
+    Unsigned <: Integer
 
+Abstract supertype for all unsigned integers.
 """
-    Val{c}
+Unsigned
 
-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
+    Bool <: Integer
 
+Boolean type.
 """
-    |(x, y)
+Bool
 
-Bitwise or.
+for bit in (16, 32, 64)
+    @eval begin
+        """
+            Float$($bit) <: AbstractFloat
 
-```jldoctest
-julia> 4 | 10
-14
+        $($bit)-bit floating point number type.
+        """
+        $(Symbol("Float", bit))
+    end
+end
 
-julia> 4 | 1
-5
-```
-"""
-Base.:(|)
+for bit in (8, 16, 32, 64, 128)
+    @eval begin
+        """
+            Int$($bit) <: Signed
 
-"""
-    pop!(collection, key[, default])
+        $($bit)-bit signed integer type.
+        """
+        $(Symbol("Int", bit))
 
-Delete and return the mapping for `key` if it exists in `collection`, otherwise return
-`default`, or throw an error if `default` is not specified.
+        """
+            UInt$($bit) <: Unsigned
 
-```jldoctest
-julia> d = Dict("a"=>1, "b"=>2, "c"=>3);
+        $($bit)-bit unsigned integer type.
+        """
+        $(Symbol("UInt", bit))
+    end
+end
 
-julia> pop!(d, "a")
-1
+"""
+    Vector{T}(n)
 
-julia> pop!(d, "d")
-ERROR: KeyError: key "d" not found
-Stacktrace:
- [1] pop!(::Dict{String,Int64}, ::String) at ./dict.jl:539
+Construct an uninitialized [`Vector{T}`](@ref) of length `n`.
 
-julia> pop!(d, "e", 4)
-4
+# Examples
+```julia-repl
+julia> Vector{Float64}(3)
+3-element Array{Float64,1}:
+ 6.90966e-310
+ 6.90966e-310
+ 6.90966e-310
 ```
 """
-pop!(collection,key,?)
+Vector{T}(n)
 
 """
-    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
+    Matrix{T}(m, n)
 
-julia> pop!(A)
-6
+Construct an uninitialized [`Matrix{T}`](@ref) of size `m`×`n`.
 
-julia> A
-5-element Array{Int64,1}:
- 1
- 2
- 3
- 4
- 5
+# Examples
+```julia-repl
+julia> Matrix{Float64}(2, 3)
+2×3 Array{Float64,2}:
+ 6.93517e-310  6.93517e-310  6.93517e-310
+ 6.93517e-310  6.93517e-310  1.29396e-320
 ```
 """
-pop!(collection)
+Matrix{T}(m, n)
 
 """
-    seekend(s)
+    Array{T}(dims)
+    Array{T,N}(dims)
 
-Seek a stream to its end.
-"""
-seekend
+Construct an uninitialized `N`-dimensional [`Array`](@ref)
+containing elements of type `T`. `N` can either be supplied explicitly,
+as in `Array{T,N}(dims)`, or be determined by the length or number of `dims`.
+`dims` may be a tuple or a series of integer arguments corresponding to the lengths
+in each dimension. If the rank `N` is supplied explicitly, then it must
+match the length or number of `dims`.
 
-"""
-    DivideError()
+# Examples
+```julia-repl
+julia> A = Array{Float64,2}(2, 3) # N given explicitly
+2×3 Array{Float64,2}:
+ 6.90198e-310  6.90198e-310  6.90198e-310
+ 6.90198e-310  6.90198e-310  0.0
 
-Integer division was attempted with a denominator value of 0.
+julia> B = Array{Float64}(2) # N determined by the input
+2-element Array{Float64,1}:
+ 1.87103e-320
+ 0.0
+```
 """
-DivideError
+Array{T,N}(dims)
diff --git a/base/docs/utils.jl b/base/docs/utils.jl
index 973c49eb2ee060..37fa56432b33a3 100644
--- a/base/docs/utils.jl
+++ b/base/docs/utils.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Text / HTML objects
 
@@ -72,8 +72,8 @@ print(io::IO, t::Text) = print(io, t.content)
 print(io::IO, t::Text{<:Function}) = t.content(io)
 show(io::IO, t::Text) = print(io, t)
 
-=={T<:Union{HTML, Text}}(t1::T, t2::T) = t1.content == t2.content
-hash{T<:Union{HTML, Text}}(t::T, h::UInt) = hash(T, hash(t.content, h))
+==(t1::T, t2::T) where {T<:Union{HTML,Text}} = t1.content == t2.content
+hash(t::T, h::UInt) where {T<:Union{HTML,Text}} = hash(T, hash(t.content, h))
 
 """
     @text_str -> Docs.Text
@@ -186,14 +186,16 @@ function repl(io::IO, s::Symbol)
     quote
         repl_latex($io, $str)
         repl_search($io, $str)
-        ($(isdefined(s) || haskey(keywords, s))) || repl_corrections($io, $str)
+        $(if !isdefined(Main, s) && !haskey(keywords, s)
+               :(repl_corrections($io, $str))
+          end)
         $(_repl(s))
     end
 end
-isregex(x) = isexpr(x, :macrocall, 2) && x.args[1] === Symbol("@r_str") && !isempty(x.args[2])
+isregex(x) = isexpr(x, :macrocall, 3) && x.args[1] === Symbol("@r_str") && !isempty(x.args[3])
 repl(io::IO, ex::Expr) = isregex(ex) ? :(apropos($io, $ex)) : _repl(ex)
 repl(io::IO, str::AbstractString) = :(apropos($io, $str))
-repl(io::IO, other) = :(@doc $(esc(other)))
+repl(io::IO, other) = :(@doc $other)
 
 repl(x) = repl(STDOUT, x)
 
@@ -201,7 +203,7 @@ function _repl(x)
     if (isexpr(x, :call) && !any(isexpr(x, :(::)) for x in x.args))
         x.args[2:end] = [:(::typeof($arg)) for arg in x.args[2:end]]
     end
-    docs = :(@doc $(esc(x)))
+    docs = :(@doc $x)
     if isfield(x)
         quote
             if isa($(esc(x.args[1])), DataType)
@@ -251,7 +253,7 @@ avgdistance(xs) =
 function fuzzyscore(needle, haystack)
     score = 0.
     is, acro = bestmatch(needle, haystack)
-    score += (acro?2:1)*length(is) # Matched characters
+    score += (acro ? 2 : 1)*length(is) # Matched characters
     score -= 2(length(needle)-length(is)) # Missing characters
     !acro && (score -= avgdistance(is)/10) # Contiguous
     !isempty(is) && (score -= mean(is)/100) # Closer to beginning
@@ -269,7 +271,7 @@ function levenshtein(s1, s2)
     a, b = collect(s1), collect(s2)
     m = length(a)
     n = length(b)
-    d = Array{Int}(m+1, n+1)
+    d = Matrix{Int}(m+1, n+1)
 
     d[1:m+1, 1] = 0:m
     d[1, 1:n+1] = 0:n
@@ -328,7 +330,7 @@ function print_joined_cols(io::IO, ss, delim = "", last = delim; cols = displays
     total = 0
     for i = 1:length(ss)
         total += length(ss[i])
-        total + max(i-2,0)*length(delim) + (i>1?1:0)*length(last) > cols && (i-=1; break)
+        total + max(i-2,0)*length(delim) + (i>1 ? 1 : 0)*length(last) > cols && (i-=1; break)
     end
     join(io, ss[1:i], delim, last)
 end
@@ -336,7 +338,7 @@ end
 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()))
+    cors = levsort(word, accessible(Main))
     pre = "Perhaps you meant "
     print(io, pre)
     print_joined_cols(io, cors, ", ", " or "; cols = displaysize(io)[2] - length(pre))
@@ -364,7 +366,7 @@ accessible(mod::Module) =
      map(names, moduleusings(mod))...;
      builtins] |> unique |> filtervalid
 
-completions(name) = fuzzysort(name, accessible(current_module()))
+completions(name) = fuzzysort(name, accessible(Main))
 completions(name::Symbol) = completions(string(name))
 
 
@@ -414,6 +416,7 @@ 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(@nospecialize x) = string(x) # for random objects interpolated into the docstring
 stripmd(x::AbstractString) = x  # base case
 stripmd(x::Void) = " "
 stripmd(x::Vector) = string(map(stripmd, x)...)
diff --git a/base/dsp.jl b/base/dsp.jl
deleted file mode 100644
index f7d32406dcc382..00000000000000
--- a/base/dsp.jl
+++ /dev/null
@@ -1,205 +0,0 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
-
-module DSP
-
-import Base.trailingsize
-
-export filt, filt!, deconv, conv, conv2, xcorr
-
-_zerosi(b,a,T) = zeros(promote_type(eltype(b), eltype(a), T), max(length(a), length(b))-1)
-
-"""
-    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).
-"""
-function filt{T,S}(b::Union{AbstractVector, Number}, a::Union{AbstractVector, Number},
-                   x::AbstractArray{T}, si::AbstractArray{S}=_zerosi(b,a,T))
-    filt!(Array{promote_type(eltype(b), eltype(a), T, S)}(size(x)), b, a, x, si)
-end
-
-# in-place filtering: returns results in the out argument, which may shadow x
-# (and does so by default)
-
-"""
-    filt!(out, b, a, x, [si])
-
-Same as [`filt`](@ref) but writes the result into the `out` argument, which may
-alias the input `x` to modify it in-place.
-"""
-function filt!{T,S,N}(out::AbstractArray, b::Union{AbstractVector, Number}, a::Union{AbstractVector, Number},
-                      x::AbstractArray{T}, si::AbstractArray{S,N}=_zerosi(b,a,T))
-    isempty(b) && throw(ArgumentError("filter vector b must be non-empty"))
-    isempty(a) && throw(ArgumentError("filter vector a must be non-empty"))
-    a[1] == 0  && throw(ArgumentError("filter vector a[1] must be nonzero"))
-    if size(x) != size(out)
-        throw(ArgumentError("output size $(size(out)) must match input size $(size(x))"))
-    end
-
-    as = length(a)
-    bs = length(b)
-    sz = max(as, bs)
-    silen = sz - 1
-    ncols = trailingsize(x,2)
-
-    if size(si, 1) != silen
-        throw(ArgumentError("initial state vector si must have max(length(a),length(b))-1 rows"))
-    end
-    if N > 1 && trailingsize(si,2) != ncols
-        throw(ArgumentError("initial state vector si must be a vector or have the same number of columns as x"))
-    end
-
-    size(x,1) == 0 && return out
-    sz == 1 && return scale!(out, x, b[1]/a[1]) # Simple scaling without memory
-
-    # Filter coefficient normalization
-    if a[1] != 1
-        norml = a[1]
-        a ./= norml
-        b ./= norml
-    end
-    # Pad the coefficients with zeros if needed
-    bs<sz   && (b = copy!(zeros(eltype(b), sz), b))
-    1<as<sz && (a = copy!(zeros(eltype(a), sz), a))
-
-    initial_si = si
-    for col = 1:ncols
-        # Reset the filter state
-        si = initial_si[:, N > 1 ? col : 1]
-        if as > 1
-            _filt_iir!(out, b, a, x, si, col)
-        else
-            _filt_fir!(out, b, x, si, col)
-        end
-    end
-    return out
-end
-
-function _filt_iir!(out, b, a, x, si, col)
-    silen = length(si)
-    @inbounds for i=1:size(x, 1)
-        xi = x[i,col]
-        val = si[1] + b[1]*xi
-        for j=1:(silen-1)
-            si[j] = si[j+1] + b[j+1]*xi - a[j+1]*val
-        end
-        si[silen] = b[silen+1]*xi - a[silen+1]*val
-        out[i,col] = val
-    end
-end
-
-function _filt_fir!(out, b, x, si, col)
-    silen = length(si)
-    @inbounds for i=1:size(x, 1)
-        xi = x[i,col]
-        val = si[1] + b[1]*xi
-        for j=1:(silen-1)
-            si[j] = si[j+1] + b[j+1]*xi
-        end
-        si[silen] = b[silen+1]*xi
-        out[i,col] = val
-    end
-end
-
-"""
-    deconv(b,a) -> c
-
-Construct vector `c` such that `b = conv(a,c) + r`.
-Equivalent to polynomial division.
-"""
-function deconv{T}(b::StridedVector{T}, a::StridedVector{T})
-    lb = size(b,1)
-    la = size(a,1)
-    if lb < la
-        return [zero(T)]
-    end
-    lx = lb-la+1
-    x = zeros(T, lx)
-    x[1] = 1
-    filt(b, a, x)
-end
-
-"""
-    conv(u,v)
-
-Convolution of two vectors. Uses FFT algorithm.
-"""
-function conv{T<:Base.LinAlg.BlasFloat}(u::StridedVector{T}, v::StridedVector{T})
-    nu = length(u)
-    nv = length(v)
-    n = nu + nv - 1
-    np2 = n > 1024 ? nextprod([2,3,5], n) : nextpow2(n)
-    upad = [u; zeros(T, np2 - nu)]
-    vpad = [v; zeros(T, np2 - nv)]
-    if T <: Real
-        p = plan_rfft(upad)
-        y = irfft((p*upad).*(p*vpad), np2)
-    else
-        p = plan_fft!(upad)
-        y = ifft!((p*upad).*(p*vpad))
-    end
-    return y[1:n]
-end
-conv{T<:Integer}(u::StridedVector{T}, v::StridedVector{T}) = round.(Int,conv(float(u), float(v)))
-conv(u::StridedVector{<:Integer}, v::StridedVector{<:Base.LinAlg.BlasFloat}) = conv(float(u), v)
-conv(u::StridedVector{<:Base.LinAlg.BlasFloat}, v::StridedVector{<:Integer}) = conv(u, float(v))
-
-"""
-    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.
-"""
-function conv2{T}(u::StridedVector{T}, v::StridedVector{T}, A::StridedMatrix{T})
-    m = length(u)+size(A,1)-1
-    n = length(v)+size(A,2)-1
-    B = zeros(T, m, n)
-    B[1:size(A,1),1:size(A,2)] = A
-    u = fft([u;zeros(T,m-length(u))])
-    v = fft([v;zeros(T,n-length(v))])
-    C = ifft(fft(B) .* (u * v.'))
-    if T <: Real
-        return real(C)
-    end
-    return C
-end
-
-"""
-    conv2(B,A)
-
-2-D convolution of the matrix `B` with the matrix `A`. Uses 2-D FFT algorithm.
-"""
-function conv2{T}(A::StridedMatrix{T}, B::StridedMatrix{T})
-    sa, sb = size(A), size(B)
-    At = zeros(T, sa[1]+sb[1]-1, sa[2]+sb[2]-1)
-    Bt = zeros(T, sa[1]+sb[1]-1, sa[2]+sb[2]-1)
-    At[1:sa[1], 1:sa[2]] = A
-    Bt[1:sb[1], 1:sb[2]] = B
-    p = plan_fft(At)
-    C = ifft((p*At).*(p*Bt))
-    if T <: Real
-        return real(C)
-    end
-    return C
-end
-conv2{T<:Integer}(A::StridedMatrix{T}, B::StridedMatrix{T}) = round.(Int,conv2(float(A), float(B)))
-conv2{T<:Integer}(u::StridedVector{T}, v::StridedVector{T}, A::StridedMatrix{T}) = round.(Int,conv2(float(u), float(v), float(A)))
-
-"""
-    xcorr(u,v)
-
-Compute the cross-correlation of two vectors.
-"""
-function xcorr(u, v)
-    su = size(u,1); sv = size(v,1)
-    if su < sv
-        u = [u;zeros(eltype(u),sv-su)]
-    elseif sv < su
-        v = [v;zeros(eltype(v),su-sv)]
-    end
-    flipdim(conv(flipdim(u, 1), v), 1)
-end
-
-end # module
diff --git a/base/env.jl b/base/env.jl
index e4bc18e39df8ec..c6010c193cc6d0 100644
--- a/base/env.jl
+++ b/base/env.jl
@@ -1,6 +1,6 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
-if is_windows()
+if Sys.iswindows()
     const ERROR_ENVVAR_NOT_FOUND = UInt32(203)
 
     _getenvlen(var::Vector{UInt16}) = ccall(:GetEnvironmentVariableW,stdcall,UInt32,(Ptr{UInt16},Ptr{UInt16},UInt32),var,C_NULL,0)
@@ -84,7 +84,7 @@ delete!(::EnvHash, k::AbstractString) = (_unsetenv(k); ENV)
 setindex!(::EnvHash, v, k::AbstractString) = _setenv(k,string(v))
 push!(::EnvHash, k::AbstractString, v) = setindex!(ENV, v, k)
 
-if is_windows()
+if Sys.iswindows()
     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
@@ -97,7 +97,7 @@ if is_windows()
         pos = block[1]
         blk = block[2]
         len = ccall(:wcslen, UInt, (Ptr{UInt16},), pos)
-        buf = Array{UInt16}(len)
+        buf = Vector{UInt16}(len)
         unsafe_copy!(pointer(buf), pos, len)
         env = transcode(String, buf)
         m = match(r"^(=?[^=]+)=(.*)$"s, env)
@@ -148,7 +148,7 @@ by zero or more `"var"=>val` arguments `kv`. `withenv` is generally used via the
 environment variable (if it is set). When `withenv` returns, the original environment has
 been restored.
 """
-function withenv{T<:AbstractString}(f::Function, keyvals::Pair{T}...)
+function withenv(f::Function, keyvals::Pair{T}...) where T<:AbstractString
     old = Dict{T,Any}()
     for (key,val) in keyvals
         old[key] = get(ENV,key,nothing)
diff --git a/base/errno.jl b/base/errno.jl
index 99986995832c71..19da1239109a60 100644
--- a/base/errno.jl
+++ b/base/errno.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 include("errno_h.jl")
 export
diff --git a/base/error.jl b/base/error.jl
index e5d1cb36a7f59d..60f37eb6c14679 100644
--- a/base/error.jl
+++ b/base/error.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # pseudo-definitions to show how everything behaves
 #
@@ -16,6 +16,13 @@
 #     rethrow(val)
 # end
 
+"""
+    throw(e)
+
+Throw an object as an exception.
+"""
+throw
+
 ## native julia error handling ##
 
 error(s::AbstractString) = throw(ErrorException(s))
@@ -27,7 +34,10 @@ Raise an `ErrorException` with the given message.
 
 See also [`logging`](@ref).
 """
-error(s...) = throw(ErrorException(Main.Base.string(s...)))
+function error(s::Vararg{Any,N}) where {N}
+    @_noinline_meta
+    throw(ErrorException(Main.Base.string(s...)))
+end
 
 """
     rethrow([e])
@@ -53,7 +63,10 @@ Get the backtrace of the current exception, for use within `catch` blocks.
 catch_backtrace() = ccall(:jl_get_backtrace, Array{Ptr{Void},1}, ())
 
 ## keyword arg lowering generates calls to this ##
-kwerr(kw, args...) = throw(MethodError(typeof(args[1]).name.mt.kwsorter, (kw,args...)))
+function kwerr(kw, args::Vararg{Any,N}) where {N}
+    @_noinline_meta
+    throw(MethodError(typeof(args[1]).name.mt.kwsorter, (kw,args...)))
+end
 
 ## system error handling ##
 """
@@ -65,7 +78,29 @@ systemerror(p, b::Bool; extrainfo=nothing) = b ? throw(Main.Base.SystemError(str
 
 ## assertion functions and macros ##
 
+
+"""
+    assert(cond)
+
+Throw an [`AssertionError`](@ref) if `cond` is `false`.
+Also available as the macro [`@assert`](@ref).
+"""
 assert(x) = x ? nothing : throw(Main.Base.AssertionError())
+
+"""
+    @assert cond [text]
+
+Throw an [`AssertionError`](@ref) if `cond` is `false`. Preferred syntax for writing assertions.
+Message `text` is optionally displayed upon assertion failure.
+
+# Examples
+```jldoctest
+julia> @assert iseven(3) "3 is an odd number!"
+ERROR: AssertionError: 3 is an odd number!
+
+julia> @assert isodd(3) "What even are numbers?"
+```
+"""
 macro assert(ex, msgs...)
     msg = isempty(msgs) ? ex : msgs[1]
     if isa(msg, AbstractString)
@@ -98,7 +133,7 @@ end
 """
     ExponentialBackOff(; n=1, first_delay=0.05, max_delay=10.0, factor=5.0, jitter=0.1)
 
-A `Float64` iterator of length `n` whose elements exponentially increase at a
+A [`Float64`](@ref) iterator of length `n` whose elements exponentially increase at a
 rate in the interval `factor` * (1 ± `jitter`).  The first element is
 `first_delay` and all elements are clamped to `max_delay`.
 """
@@ -128,15 +163,15 @@ retry(f, delays=fill(5.0, 3))
 retry(f, delays=rand(5:10, 2))
 retry(f, delays=Base.ExponentialBackOff(n=3, first_delay=5, max_delay=1000))
 retry(http_get, check=(s,e)->e.status == "503")(url)
-retry(read, check=(s,e)->isa(e, UVError))(io)
+retry(read, check=(s,e)->isa(e, UVError))(io, 128; all=false)
 ```
 """
 function retry(f::Function;  delays=ExponentialBackOff(), check=nothing)
-    (args...) -> begin
+    (args...; kwargs...) -> begin
         state = start(delays)
         while true
             try
-                return f(args...)
+                return f(args...; kwargs...)
             catch e
                 done(delays, state) && rethrow(e)
                 if check !== nothing
diff --git a/base/essentials.jl b/base/essentials.jl
index 469e865bb2f1b3..23cb3ebd6228d2 100644
--- a/base/essentials.jl
+++ b/base/essentials.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Core: CodeInfo
 
@@ -17,6 +17,42 @@ end
 macro _noinline_meta()
     Expr(:meta, :noinline)
 end
+
+"""
+    @nospecialize
+
+Applied to a function argument name, hints to the compiler that the method
+should not be specialized for different types of that argument.
+This is only a hint for avoiding excess code generation.
+Can be applied to an argument within a formal argument list, or in the
+function body.
+When applied to an argument, the macro must wrap the entire argument
+expression.
+When used in a function body, the macro must occur in statement position and
+before any code.
+
+```julia
+function example_function(@nospecialize x)
+    ...
+end
+
+function example_function(@nospecialize(x = 1), y)
+    ...
+end
+
+function example_function(x, y, z)
+    @nospecialize x y
+    ...
+end
+```
+"""
+macro nospecialize(var, vars...)
+    if isa(var, Expr) && var.head === :(=)
+        var.head = :kw
+    end
+    Expr(:meta, :nospecialize, var, vars...)
+end
+
 macro _pure_meta()
     Expr(:meta, :pure)
 end
@@ -25,25 +61,15 @@ macro _propagate_inbounds_meta()
     Expr(:meta, :inline, :propagate_inbounds)
 end
 
-convert(::Type{Any}, x::ANY) = x
-convert{T}(::Type{T}, x::T) = x
+convert(::Type{Any}, @nospecialize(x)) = x
+convert(::Type{T}, x::T) where {T} = x
 
 convert(::Type{Tuple{}}, ::Tuple{}) = ()
 convert(::Type{Tuple}, x::Tuple) = x
-convert{T}(::Type{Tuple{Vararg{T}}}, x::Tuple) = cnvt_all(T, x...)
+convert(::Type{Tuple{Vararg{T}}}, x::Tuple) where {T} = cnvt_all(T, x...)
 cnvt_all(T) = ()
 cnvt_all(T, x, rest...) = tuple(convert(T,x), cnvt_all(T, rest...)...)
 
-macro generated(f)
-    isa(f, Expr) || error("invalid syntax; @generated must be used with a function definition")
-    if f.head === :function || (isdefined(:length) && f.head === :(=) && length(f.args) == 2 && f.args[1].head == :call)
-        f.head = :stagedfunction
-        return Expr(:escape, f)
-    else
-        error("invalid syntax; @generated must be used with a function definition")
-    end
-end
-
 """
     @eval [mod,] ex
 
@@ -51,7 +77,7 @@ Evaluate an expression with values interpolated into it using `eval`.
 If two arguments are provided, the first is the module to evaluate in.
 """
 macro eval(ex)
-    :(eval($(current_module()), $(Expr(:quote,ex))))
+    :(eval($__module__, $(Expr(:quote,ex))))
 end
 macro eval(mod, ex)
     :(eval($(esc(mod)), $(Expr(:quote,ex))))
@@ -60,13 +86,13 @@ end
 argtail(x, rest...) = rest
 tail(x::Tuple) = argtail(x...)
 
-tuple_type_head(T::UnionAll) = tuple_type_head(T.body)
+tuple_type_head(T::UnionAll) = (@_pure_meta; UnionAll(T.var, tuple_type_head(T.body)))
 function tuple_type_head(T::DataType)
     @_pure_meta
     T.name === Tuple.name || throw(MethodError(tuple_type_head, (T,)))
     return unwrapva(T.parameters[1])
 end
-tuple_type_tail(T::UnionAll) = tuple_type_tail(T.body)
+tuple_type_tail(T::UnionAll) = (@_pure_meta; UnionAll(T.var, tuple_type_tail(T.body)))
 function tuple_type_tail(T::DataType)
     @_pure_meta
     T.name === Tuple.name || throw(MethodError(tuple_type_tail, (T,)))
@@ -77,19 +103,19 @@ function tuple_type_tail(T::DataType)
 end
 
 tuple_type_cons(::Type, ::Type{Union{}}) = Union{}
-function tuple_type_cons{S,T<:Tuple}(::Type{S}, ::Type{T})
+function tuple_type_cons(::Type{S}, ::Type{T}) where T<:Tuple where S
     @_pure_meta
     Tuple{S, T.parameters...}
 end
 
-function unwrap_unionall(a::ANY)
+function unwrap_unionall(@nospecialize(a))
     while isa(a,UnionAll)
         a = a.body
     end
     return a
 end
 
-function rewrap_unionall(t::ANY, u::ANY)
+function rewrap_unionall(@nospecialize(t), @nospecialize(u))
     if !isa(u, UnionAll)
         return t
     end
@@ -97,7 +123,7 @@ function rewrap_unionall(t::ANY, u::ANY)
 end
 
 # replace TypeVars in all enclosing UnionAlls with fresh TypeVars
-function rename_unionall(u::ANY)
+function rename_unionall(@nospecialize(u))
     if !isa(u,UnionAll)
         return u
     end
@@ -113,13 +139,13 @@ function rename_unionall(u::ANY)
 end
 
 const _va_typename = Vararg.body.body.name
-function isvarargtype(t::ANY)
+function isvarargtype(@nospecialize(t))
     t = unwrap_unionall(t)
     isa(t, DataType) && (t::DataType).name === _va_typename
 end
 
 isvatuple(t::DataType) = (n = length(t.parameters); n > 0 && isvarargtype(t.parameters[n]))
-function unwrapva(t::ANY)
+function unwrapva(@nospecialize(t))
     t2 = unwrap_unionall(t)
     isvarargtype(t2) ? t2.parameters[1] : t
 end
@@ -133,9 +159,9 @@ function typename(a::Union)
 end
 typename(union::UnionAll) = typename(union.body)
 
-convert{T<:Tuple{Any,Vararg{Any}}}(::Type{T}, x::Tuple{Any, Vararg{Any}}) =
+convert(::Type{T}, x::Tuple{Any,Vararg{Any}}) where {T<:Tuple{Any,Vararg{Any}}} =
     tuple(convert(tuple_type_head(T),x[1]), convert(tuple_type_tail(T), tail(x))...)
-convert{T<:Tuple{Any,Vararg{Any}}}(::Type{T}, x::T) = x
+convert(::Type{T}, x::T) where {T<:Tuple{Any,Vararg{Any}}} = x
 
 oftype(x,c) = convert(typeof(x),c)
 
@@ -143,17 +169,17 @@ unsigned(x::Int) = reinterpret(UInt, x)
 signed(x::UInt) = reinterpret(Int, x)
 
 # conversions used by ccall
-ptr_arg_cconvert{T}(::Type{Ptr{T}}, x) = cconvert(T, x)
-ptr_arg_unsafe_convert{T}(::Type{Ptr{T}}, x) = unsafe_convert(T, x)
+ptr_arg_cconvert(::Type{Ptr{T}}, x) where {T} = cconvert(T, x)
+ptr_arg_unsafe_convert(::Type{Ptr{T}}, x) where {T} = unsafe_convert(T, x)
 ptr_arg_unsafe_convert(::Type{Ptr{Void}}, x) = x
 
 cconvert(T::Type, x) = convert(T, x) # do the conversion eagerly in most cases
 cconvert(::Type{<:Ptr}, x) = x # but defer the conversion to Ptr to unsafe_convert
-unsafe_convert{T}(::Type{T}, x::T) = x # unsafe_convert (like convert) defaults to assuming the convert occurred
-unsafe_convert{T<:Ptr}(::Type{T}, x::T) = x  # to resolve ambiguity with the next method
-unsafe_convert{P<:Ptr}(::Type{P}, x::Ptr) = convert(P, x)
+unsafe_convert(::Type{T}, x::T) where {T} = x # unsafe_convert (like convert) defaults to assuming the convert occurred
+unsafe_convert(::Type{T}, x::T) where {T<:Ptr} = x  # to resolve ambiguity with the next method
+unsafe_convert(::Type{P}, x::Ptr) where {P<:Ptr} = convert(P, x)
 
-reinterpret{T}(::Type{T}, x) = bitcast(T, x)
+reinterpret(::Type{T}, x) where {T} = bitcast(T, x)
 reinterpret(::Type{Unsigned}, x::Float16) = reinterpret(UInt16,x)
 reinterpret(::Type{Signed}, x::Float16) = reinterpret(Int16,x)
 
@@ -163,7 +189,7 @@ function append_any(xs...)
     # used by apply() and quote
     # must be a separate function from append(), since apply() needs this
     # exact function.
-    out = Array{Any}(4)
+    out = Vector{Any}(4)
     l = 4
     i = 1
     for x in xs
@@ -181,11 +207,9 @@ function append_any(xs...)
 end
 
 # simple Array{Any} operations needed for bootstrap
-setindex!(A::Array{Any}, x::ANY, i::Int) = Core.arrayset(A, x, i)
+setindex!(A::Array{Any}, @nospecialize(x), i::Int) = Core.arrayset(A, x, i)
 
-map(f::Function, a::Array{Any,1}) = Any[ f(a[i]) for i=1:length(a) ]
-
-function precompile(f::ANY, args::Tuple)
+function precompile(@nospecialize(f), args::Tuple)
     ccall(:jl_compile_hint, Int32, (Any,), Tuple{Core.Typeof(f), args...}) != 0
 end
 
@@ -194,13 +218,13 @@ function precompile(argt::Type)
 end
 
 """
-    esc(e::ANY)
+    esc(e)
 
 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 [Macros](@ref man-macros)
 section of the Metaprogramming chapter of the manual for more details and examples.
 """
-esc(e::ANY) = Expr(:escape, e)
+esc(@nospecialize(e)) = Expr(:escape, e)
 
 macro boundscheck(blk)
     # hack: use this syntax since it avoids introducing line numbers
@@ -226,7 +250,7 @@ function sum(A::AbstractArray)
 end
 ```
 
-!!! Warning
+!!! warning
 
     Using `@inbounds` may return incorrect results/crashes/corruption
     for out-of-bounds indices. The user is responsible for checking it manually.
@@ -256,12 +280,13 @@ function getindex(v::SimpleVector, i::Int)
     return unsafe_pointer_to_objref(x)
 end
 
-length(v::SimpleVector) = v.length
-endof(v::SimpleVector) = v.length
+# TODO: add gc use intrinsic call instead of noinline
+length(v::SimpleVector) = (@_noinline_meta; unsafe_load(convert(Ptr{Int},data_pointer_from_objref(v))))
+endof(v::SimpleVector) = length(v)
 start(v::SimpleVector) = 1
 next(v::SimpleVector,i) = (v[i],i+1)
-done(v::SimpleVector,i) = (i > v.length)
-isempty(v::SimpleVector) = (v.length == 0)
+done(v::SimpleVector,i) = (i > length(v))
+isempty(v::SimpleVector) = (length(v) == 0)
 indices(v::SimpleVector) = (OneTo(length(v)),)
 linearindices(v::SimpleVector) = indices(v, 1)
 indices(v::SimpleVector, d) = d <= 1 ? indices(v)[d] : OneTo(1)
@@ -306,7 +331,7 @@ false
 function isassigned end
 
 function isassigned(v::SimpleVector, i::Int)
-    1 <= i <= length(v) || return false
+    @boundscheck 1 <= i <= length(v) || return false
     x = unsafe_load(convert(Ptr{Ptr{Void}},data_pointer_from_objref(v)) + i*sizeof(Ptr))
     return x != C_NULL
 end
@@ -317,25 +342,82 @@ end
 Colons (:) are used to signify indexing entire objects or dimensions at once.
 
 Very few operations are defined on Colons directly; instead they are converted
-by `to_indices` to an internal vector type (`Base.Slice`) to represent the
+by [`to_indices`](@ref) to an internal vector type (`Base.Slice`) to represent the
 collection of indices they span before being used.
 """
 struct Colon
 end
 const (:) = Colon()
 
-# For passing constants through type inference
-struct Val{T}
+"""
+    Val(c)
+
+Return `Val{c}()`, which contains no run-time data. Types like this can be used to
+pass the information between functions through the value `c`, which must be an `isbits`
+value. The intent of this construct is to be able to dispatch on constants directly (at
+compile time) without having to test the value of the constant at run time.
+
+# Examples
+```jldoctest
+julia> f(::Val{true}) = "Good"
+f (generic function with 1 method)
+
+julia> f(::Val{false}) = "Bad"
+f (generic function with 2 methods)
+
+julia> f(Val(true))
+"Good"
+```
+"""
+struct Val{x}
 end
 
+Val(x) = (@_pure_meta; Val{x}())
+
 # used by interpolating quote and some other things in the front end
-function vector_any(xs::ANY...)
+function vector_any(@nospecialize xs...)
     n = length(xs)
-    a = Array{Any}(n)
+    a = Vector{Any}(n)
     @inbounds for i = 1:n
         Core.arrayset(a,xs[i],i)
     end
     a
 end
 
+function as_kwargs(xs::Union{AbstractArray,Associative})
+    n = length(xs)
+    to = Vector{Any}(n*2)
+    i = 1
+    for (k, v) in xs
+        to[i]   = k::Symbol
+        to[i+1] = v
+        i += 2
+    end
+    return to
+end
+
+function as_kwargs(xs)
+    to = Vector{Any}(0)
+    for (k, v) in xs
+        ccall(:jl_array_ptr_1d_push2, Void, (Any, Any, Any), to, k::Symbol, v)
+    end
+    return to
+end
+
 isempty(itr) = done(itr, start(itr))
+
+"""
+    invokelatest(f, args...; kwargs...)
+
+Calls `f(args...; kwargs...)`, but guarantees that the most recent method of `f`
+will be executed.   This is useful in specialized circumstances,
+e.g. long-running event loops or callback functions that may
+call obsolete versions of a function `f`.
+(The drawback is that `invokelatest` is somewhat slower than calling
+`f` directly, and the type of the result cannot be inferred by the compiler.)
+"""
+function invokelatest(f, args...; kwargs...)
+    # We use a closure (`inner`) to handle kwargs.
+    inner() = f(args...; kwargs...)
+    Core._apply_latest(inner)
+end
diff --git a/base/event.jl b/base/event.jl
index 0d455ebf18195e..6dfbe2a8fc1760 100644
--- a/base/event.jl
+++ b/base/event.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## condition variables
 
@@ -40,7 +40,7 @@ is raised as an exception in the woken tasks.
 
 Returns the count of tasks woken up. Returns 0 if no tasks are waiting on `condition`.
 """
-notify(c::Condition, arg::ANY=nothing; all=true, error=false) = notify(c, arg, all, error)
+notify(c::Condition, @nospecialize(arg = nothing); all=true, error=false) = notify(c, arg, all, error)
 function notify(c::Condition, arg, all, error)
     cnt = 0
     if all
@@ -76,7 +76,7 @@ end
 
 ## scheduler and work queue
 
-global const Workqueue = Any[]
+global const Workqueue = Task[]
 
 function enq_work(t::Task)
     t.state == :runnable || error("schedule: Task not runnable")
@@ -127,13 +127,13 @@ function schedule(t::Task, arg; error=false)
     return enq_work(t)
 end
 
-# fast version of schedule(t,v);wait()
-function schedule_and_wait(t::Task, v=nothing)
+# fast version of `schedule(t, arg); wait()`
+function schedule_and_wait(t::Task, arg=nothing)
     t.state == :runnable || error("schedule: Task not runnable")
     if isempty(Workqueue)
-        return yieldto(t, v)
+        return yieldto(t, arg)
     else
-        t.result = v
+        t.result = arg
         push!(Workqueue, t)
         t.state = :queued
     end
@@ -149,6 +149,19 @@ tasks.
 """
 yield() = (enq_work(current_task()); wait())
 
+"""
+    yield(t::Task, arg = nothing)
+
+A fast, unfair-scheduling version of `schedule(t, arg); yield()` which
+immediately yields to `t` before calling the scheduler.
+"""
+function yield(t::Task, @nospecialize x = nothing)
+    t.state == :runnable || error("schedule: Task not runnable")
+    t.result = x
+    enq_work(current_task())
+    return try_yieldto(ensure_rescheduled, Ref(t))
+end
+
 """
     yieldto(t::Task, arg = nothing)
 
@@ -157,67 +170,92 @@ called with no arguments. On subsequent switches, `arg` is returned from the tas
 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(t::Task, x::ANY = nothing) = ccall(:jl_switchto, Any, (Any, Any), t, x)
+function yieldto(t::Task, @nospecialize x = nothing)
+    t.result = x
+    return try_yieldto(identity, Ref(t))
+end
+
+function try_yieldto(undo, reftask::Ref{Task})
+    try
+        ccall(:jl_switchto, Void, (Any,), reftask)
+    catch e
+        undo(reftask[])
+        rethrow(e)
+    end
+    ct = current_task()
+    exc = ct.exception
+    if exc !== nothing
+        ct.exception = nothing
+        throw(exc)
+    end
+    result = ct.result
+    ct.result = nothing
+    return result
+end
 
 # yield to a task, throwing an exception in it
-function throwto(t::Task, exc)
+function throwto(t::Task, @nospecialize exc)
     t.exception = exc
-    yieldto(t)
+    return yieldto(t)
+end
+
+function ensure_rescheduled(othertask::Task)
+    ct = current_task()
+    if ct !== othertask && othertask.state == :runnable
+        # we failed to yield to othertask
+        # return it to the head of the queue to be scheduled later
+        unshift!(Workqueue, othertask)
+        othertask.state = :queued
+    end
+    if ct.state == :queued
+        # if the current task was queued,
+        # also need to return it to the runnable state
+        # before throwing an error
+        i = findfirst(Workqueue, ct)
+        i == 0 || deleteat!(Workqueue, i)
+        ct.state = :runnable
+    end
+    nothing
+end
+
+@noinline function poptask()
+    t = shift!(Workqueue)
+    if t.state != :queued
+        # assume this somehow got queued twice,
+        # probably broken now, but try discarding this switch and keep going
+        # can't throw here, because it's probably not the fault of the caller to wait
+        # and don't want to use print() here, because that may try to incur a task switch
+        ccall(:jl_safe_printf, Void, (Ptr{UInt8}, Int32...),
+            "\nWARNING: Workqueue inconsistency detected: shift!(Workqueue).state != :queued\n")
+        return
+    end
+    t.state = :runnable
+    return Ref(t)
 end
 
 function wait()
     while true
         if isempty(Workqueue)
             c = process_events(true)
-            if c==0 && eventloop()!=C_NULL && isempty(Workqueue)
+            if c == 0 && eventloop() != C_NULL && isempty(Workqueue)
                 # if there are no active handles and no runnable tasks, just
                 # wait for signals.
                 pause()
             end
         else
-            t = shift!(Workqueue)
-            if t.state != :queued
-                # assume this somehow got queued twice,
-                # probably broken now, but try discarding this switch and keep going
-                # can't throw here, because it's probably not the fault of the caller to wait
-                # and don't want to use print() here, because that may try to incur a task switch
-                ccall(:jl_safe_printf, Void, (Ptr{UInt8}, Vararg{Int32}),
-                    "\nWARNING: Workqueue inconsistency detected: shift!(Workqueue).state != :queued\n")
-                continue
+            reftask = poptask()
+            if reftask !== nothing
+                result = try_yieldto(ensure_rescheduled, reftask)
+                process_events(false)
+                # return when we come out of the queue
+                return result
             end
-            arg = t.result
-            t.result = nothing
-            t.state = :runnable
-            local result
-            try
-                result = yieldto(t, arg)
-                current_task().state == :runnable || throw(AssertionError("current_task().state == :runnable"))
-            catch e
-                ct = current_task()
-                if ct.state == :queued
-                    if t.state == :runnable
-                        # assume we failed to queue t
-                        # return it to the queue to be scheduled later
-                        t.result = arg
-                        t.state = :queued
-                        push!(Workqueue, t)
-                    end
-                    # return ourself to the runnable state
-                    i = findfirst(Workqueue, ct)
-                    i == 0 || deleteat!(Workqueue, i)
-                    ct.state = :runnable
-                end
-                rethrow(e)
-            end
-            process_events(false)
-            # return when we come out of the queue
-            return result
         end
     end
-    assert(false)
+    # unreachable
 end
 
-if is_windows()
+if Sys.iswindows()
     pause() = ccall(:Sleep, stdcall, Void, (UInt32,), 0xffffffff)
 else
     pause() = ccall(:pause, Void, ())
@@ -238,41 +276,24 @@ Use [`isopen`](@ref) to check whether it is still active.
 mutable struct AsyncCondition
     handle::Ptr{Void}
     cond::Condition
+    isopen::Bool
 
     function AsyncCondition()
-        this = new(Libc.malloc(_sizeof_uv_async), Condition())
+        this = new(Libc.malloc(_sizeof_uv_async), Condition(), true)
         associate_julia_struct(this.handle, this)
-        preserve_handle_new(this)
+        finalizer(this, uvfinalize)
         err = ccall(:uv_async_init, Cint, (Ptr{Void}, Ptr{Void}, Ptr{Void}),
             eventloop(), this, uv_jl_asynccb::Ptr{Void})
-        this
+        if err != 0
+            #TODO: this codepath is currently not tested
+            Libc.free(this.handle)
+            this.handle = C_NULL
+            throw(UVError("uv_async_init", err))
+        end
+        return this
     end
 end
 
-unsafe_convert(::Type{Ptr{Void}}, async::AsyncCondition) = async.handle
-
-function wait(async::AsyncCondition)
-    isopen(async) || throw(EOFError())
-    wait(async.cond)
-end
-
-isopen(t::AsyncCondition) = (t.handle != C_NULL)
-
-close(t::AsyncCondition) = ccall(:jl_close_uv, Void, (Ptr{Void},), t)
-
-function _uv_hook_close(async::AsyncCondition)
-    async.handle = C_NULL
-    unpreserve_handle(async)
-    notify_error(async.cond, EOFError())
-    nothing
-end
-
-function uv_asynccb(handle::Ptr{Void})
-    async = @handle_as handle AsyncCondition
-    notify(async.cond)
-    nothing
-end
-
 """
     AsyncCondition(callback::Function)
 
@@ -286,16 +307,15 @@ function AsyncCondition(cb::Function)
             success = try
                 wait(async)
                 true
-            catch # ignore possible exception on close()
-                false
+            catch exc # ignore possible exception on close()
+                isa(exc, EOFError) || rethrow(exc)
             end
             success && cb(async)
         end
     end)
     # must start the task right away so that it can wait for the AsyncCondition before
     # we re-enter the event loop. this avoids a race condition. see issue #12719
-    enq_work(current_task())
-    yieldto(waiter)
+    yield(waiter)
     return async
 end
 
@@ -323,11 +343,11 @@ mutable struct Timer
             #TODO: this codepath is currently not tested
             Libc.free(this.handle)
             this.handle = C_NULL
-            throw(UVError("uv_make_timer",err))
+            throw(UVError("uv_timer_init", err))
         end
 
         associate_julia_struct(this.handle, this)
-        preserve_handle_new(this)
+        finalizer(this, uvfinalize)
 
         ccall(:uv_update_time, Void, (Ptr{Void},), eventloop())
         ccall(:uv_timer_start,  Cint,  (Ptr{Void}, Ptr{Void}, UInt64, UInt64),
@@ -338,32 +358,46 @@ mutable struct Timer
 end
 
 unsafe_convert(::Type{Ptr{Void}}, t::Timer) = t.handle
+unsafe_convert(::Type{Ptr{Void}}, async::AsyncCondition) = async.handle
 
-function wait(t::Timer)
+function wait(t::Union{Timer, AsyncCondition})
     isopen(t) || throw(EOFError())
-    wait(t.cond)
+    stream_wait(t, t.cond)
 end
 
-isopen(t::Timer) = t.isopen
+isopen(t::Union{Timer, AsyncCondition}) = t.isopen
 
-function close(t::Timer)
-    if t.handle != C_NULL
+function close(t::Union{Timer, AsyncCondition})
+    if t.handle != C_NULL && isopen(t)
         t.isopen = false
-        ccall(:uv_timer_stop, Cint, (Ptr{Void},), t)
+        isa(t, Timer) && ccall(:uv_timer_stop, Cint, (Ptr{Void},), t)
         ccall(:jl_close_uv, Void, (Ptr{Void},), t)
     end
     nothing
 end
 
-function _uv_hook_close(t::Timer)
-    unpreserve_handle(t)
-    disassociate_julia_struct(t)
-    t.handle = C_NULL
+function uvfinalize(t::Union{Timer, AsyncCondition})
+    if t.handle != C_NULL
+        disassociate_julia_struct(t.handle) # not going to call the usual close hooks
+        close(t)
+        t.handle = C_NULL
+    end
     t.isopen = false
+    nothing
+end
+
+function _uv_hook_close(t::Union{Timer, AsyncCondition})
+    uvfinalize(t)
     notify_error(t.cond, EOFError())
     nothing
 end
 
+function uv_asynccb(handle::Ptr{Void})
+    async = @handle_as handle AsyncCondition
+    notify(async.cond)
+    nothing
+end
+
 function uv_timercb(handle::Ptr{Void})
     t = @handle_as handle Timer
     if ccall(:uv_timer_get_repeat, UInt64, (Ptr{Void},), t) == 0
@@ -403,7 +437,8 @@ function Timer(cb::Function, timeout::Real, repeat::Real=0.0)
             success = try
                 wait(t)
                 true
-            catch # ignore possible exception on close()
+            catch exc # ignore possible exception on close()
+                isa(exc, EOFError) || rethrow(exc)
                 false
             end
             success && cb(t)
@@ -411,7 +446,6 @@ function Timer(cb::Function, timeout::Real, repeat::Real=0.0)
     end)
     # must start the task right away so that it can wait for the Timer before
     # we re-enter the event loop. this avoids a race condition. see issue #12719
-    enq_work(current_task())
-    yieldto(waiter)
+    yield(waiter)
     return t
 end
diff --git a/base/exports.jl b/base/exports.jl
index e4f8f970f6d8bd..e9f514d5441721 100644
--- a/base/exports.jl
+++ b/base/exports.jl
@@ -1,10 +1,8 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 export
 # Modules
-    FFTW,
     Meta,
-    Operators,
     Pkg,
     LibGit2,
     StackTraces,
@@ -23,7 +21,7 @@ export
     Markdown,
     Threads,
     Iterators,
-    Parallel,
+    Distributed,
 
 # Types
     AbstractChannel,
@@ -357,6 +355,7 @@ export
     isreal,
     issubnormal,
     iszero,
+    isone,
     lcm,
     ldexp,
     leading_ones,
@@ -405,6 +404,7 @@ export
     significand,
     sin,
     sinc,
+    sincos,
     sind,
     sinh,
     sinpi,
@@ -509,7 +509,9 @@ export
     prod,
     promote_shape,
     randcycle,
+    randcycle!,
     randperm,
+    randperm!,
     randsubseq!,
     randsubseq,
     range,
@@ -719,6 +721,7 @@ export
     symdiff,
     union!,
     union,
+    unique!,
     unique,
     values,
     valtype,
@@ -729,6 +732,9 @@ export
     ⊆,
     ⊈,
     ⊊,
+    ⊇,
+    ⊉,
+    ⊋,
     ∩,
     ∪,
 
@@ -806,7 +812,6 @@ export
     search,
     searchindex,
     show,
-    showall,
     showcompact,
     showerror,
     split,
@@ -859,42 +864,6 @@ export
     var,
     varm,
 
-# signal processing
-    bfft!,
-    bfft,
-    brfft,
-    conv,
-    conv2,
-    dct!,
-    dct,
-    deconv,
-    fft!,
-    fft,
-    fftshift,
-    filt,
-    filt!,
-    idct!,
-    idct,
-    ifft!,
-    ifft,
-    ifftshift,
-    irfft,
-    plan_bfft!,
-    plan_bfft,
-    plan_brfft,
-    plan_dct!,
-    plan_dct,
-    plan_fft!,
-    plan_fft,
-    plan_idct!,
-    plan_idct,
-    plan_ifft!,
-    plan_ifft,
-    plan_irfft,
-    plan_rfft,
-    rfft,
-    xcorr,
-
 # iteration
     done,
     next,
@@ -979,6 +948,7 @@ export
     fieldoffset,
     fieldname,
     fieldnames,
+    fieldcount,
     isconcrete,
     oftype,
     promote,
@@ -996,12 +966,12 @@ export
     expand,
     gensym,
     macroexpand,
+    @macroexpand1,
     @macroexpand,
     parse,
 
 # help and reflection
     apropos,
-    current_module,
     edit,
     code_typed,
     code_warntype,
@@ -1023,11 +993,11 @@ export
     which,
     whos,
     workspace,
+    @isdefined,
 
 # loading source files
     __precompile__,
     evalfile,
-    include,
     include_string,
     include_dependency,
     reload,
@@ -1043,6 +1013,7 @@ export
     atexit,
     atreplinit,
     clipboard,
+    crc32c,
     exit,
     ntuple,
     quit,
@@ -1068,6 +1039,7 @@ export
     getaddrinfo,
     gethostname,
     getipaddr,
+    getpeername,
     getsockname,
     htol,
     hton,
@@ -1100,7 +1072,6 @@ export
     readdlm,
     readline,
     readlines,
-    readstring,
     readuntil,
     redirect_stderr,
     redirect_stdin,
@@ -1244,6 +1215,8 @@ export
     # parser internal
     @__FILE__,
     @__DIR__,
+    @__LINE__,
+    @__MODULE__,
     @int128_str,
     @uint128_str,
     @big_str,
@@ -1286,14 +1259,6 @@ export
     @code_llvm,
     @code_native,
 
-    # platform-conditional code
-    @static,
-    is_windows,
-    is_linux,
-    is_apple,
-    is_bsd,
-    is_unix,
-
     # tasks
     @schedule,
     @sync,
@@ -1314,6 +1279,7 @@ export
     @simd,
     @inline,
     @noinline,
+    @nospecialize,
     @polly,
 
     @assert,
@@ -1323,6 +1289,7 @@ export
     @goto,
     @view,
     @views,
+    @static,
 
 # SparseArrays module re-exports
     SparseArrays,
@@ -1344,7 +1311,7 @@ export
     nzrange,
     nnz,
 
-# Parallel module re-exports
+# Distributed module re-exports
     @spawn,
     @spawnat,
     @fetch,
diff --git a/base/expr.jl b/base/expr.jl
index 55b9e23359c881..d3138e1a0ac23e 100644
--- a/base/expr.jl
+++ b/base/expr.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## symbols ##
 
@@ -39,42 +39,77 @@ copy(e::Expr) = (n = Expr(e.head);
 
 # copy parts of an AST that the compiler mutates
 copy_exprs(x::Expr) = copy(x)
-copy_exprs(x::ANY) = x
+copy_exprs(@nospecialize(x)) = x
 copy_exprargs(x::Array{Any,1}) = Any[copy_exprs(a) for a in x]
 
 ==(x::Expr, y::Expr) = x.head === y.head && isequal(x.args, y.args)
 ==(x::QuoteNode, y::QuoteNode) = isequal(x.value, y.value)
 
 """
-    expand(x)
+    expand(m, x)
 
-Takes the expression `x` and returns an equivalent expression in lowered form.
+Takes the expression `x` and returns an equivalent expression in lowered form
+for executing in module `m`.
 See also [`code_lowered`](@ref).
 """
-expand(x::ANY) = ccall(:jl_expand, Any, (Any,), x)
+expand(m::Module, @nospecialize(x)) = ccall(:jl_expand, Any, (Any, Any), x, m)
 
 """
-    macroexpand(x)
+    macroexpand(m::Module, x; recursive=true)
 
-Takes the expression `x` and returns an equivalent expression with all macros removed (expanded).
+Takes the expression `x` and returns an equivalent expression with all macros removed (expanded)
+for executing in module `m`.
+The `recursive` keyword controls whether deeper levels of nested macros are also expanded.
+This is demonstrated in the example below:
+```julia-repl
+julia> module M
+           macro m1()
+               42
+           end
+           macro m2()
+               :(@m1())
+           end
+       end
+M
+
+julia> macroexpand(M, :(@m2()), recursive=true)
+42
+
+julia> macroexpand(M, :(@m2()), recursive=false)
+:(#= REPL[16]:6 =# M.@m1)
+```
 """
-macroexpand(x::ANY) = ccall(:jl_macroexpand, Any, (Any,), x)
+function macroexpand(m::Module, @nospecialize(x); recursive=true)
+    if recursive
+        ccall(:jl_macroexpand, Any, (Any, Any), x, m)
+    else
+        ccall(:jl_macroexpand1, Any, (Any, Any), x, m)
+    end
+end
 
 """
     @macroexpand
 
 Return equivalent expression with all macros removed (expanded).
 
-There is a subtle difference between `@macroexpand` and `macroexpand` in that expansion takes place in
-different contexts. This is best seen in the following example:
+There are differences between `@macroexpand` and [`macroexpand`](@ref).
+
+* While [`macroexpand`](@ref) takes a keyword argument `recursive`, `@macroexpand`
+is always recursive. For a non recursive macro version, see [`@macroexpand1`](@ref).
 
-```jldoctest
+* While [`macroexpand`](@ref) has an explicit `module` argument, `@macroexpand` always
+expands with respect to the module in which it is called.
+This is best seen in the following example:
+```julia-repl
 julia> module M
            macro m()
                1
            end
            function f()
-               (@macroexpand(@m), macroexpand(:(@m)))
+               (@macroexpand(@m),
+                macroexpand(M, :(@m)),
+                macroexpand(Main, :(@m))
+               )
            end
        end
 M
@@ -85,16 +120,23 @@ julia> macro m()
 @m (macro with 1 method)
 
 julia> M.f()
-(1, 2)
+(1, 1, 2)
 ```
-With `@macroexpand` the expression expands where `@macroexpand` appears in the code (module
-`M` in the example). With `macroexpand` the expression expands in the current module where
-the code was finally called (REPL in the example).
-Note that when calling `macroexpand` or `@macroexpand` directly from the REPL, both of these contexts coincide, hence there is no difference.
+With `@macroexpand` the expression expands where `@macroexpand` appears in the code (module `M` in the example).
+With `macroexpand` the expression expands in the module given as the first argument.
 """
 macro macroexpand(code)
-    code_expanded = macroexpand(code)
-    QuoteNode(code_expanded)
+    return :(macroexpand($__module__, $(QuoteNode(code)), recursive=true))
+end
+
+
+"""
+    @macroexpand1
+
+Non recursive version of [`@macroexpand`](@ref).
+"""
+macro macroexpand1(code)
+    return :(macroexpand($__module__, $(QuoteNode(code)), recursive=false))
 end
 
 ## misc syntax ##
@@ -240,7 +282,7 @@ function is_short_function_def(ex)
     ex.head == :(=) || return false
     while length(ex.args) >= 1 && isa(ex.args[1], Expr)
         (ex.args[1].head == :call) && return true
-        (ex.args[1].head == :where) || return false
+        (ex.args[1].head == :where || ex.args[1].head == :(::)) || return false
         ex = ex.args[1]
     end
     return false
@@ -276,9 +318,25 @@ end
 
 remove_linenums!(ex) = ex
 function remove_linenums!(ex::Expr)
-    filter!(x->!((isa(x,Expr) && x.head === :line) || isa(x,LineNumberNode)), ex.args)
+    if ex.head === :body || ex.head === :block || ex.head === :quote
+        # remove line number expressions from metadata (not argument literal or inert) position
+        filter!(ex.args) do x
+            isa(x, Expr) && x.head === :line && return false
+            isa(x, LineNumberNode) && return false
+            return true
+        end
+    end
     for subex in ex.args
         remove_linenums!(subex)
     end
-    ex
+    return ex
+end
+
+macro generated(f)
+     if isa(f, Expr) && (f.head === :function || is_short_function_def(f))
+        f.head = :stagedfunction
+        return Expr(:escape, f)
+    else
+        error("invalid syntax; @generated must be used with a function definition")
+    end
 end
diff --git a/base/fastmath.jl b/base/fastmath.jl
index f99e44b0f50e1a..7fff15810f590b 100644
--- a/base/fastmath.jl
+++ b/base/fastmath.jl
@@ -1,11 +1,12 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Support for @fastmath
 
 # This module provides versions of math functions that may violate
 # strict IEEE semantics.
 
-# This allows the following transformations:
+# This allows the following transformations. For more information see
+# http://llvm.org/docs/LangRef.html#fast-math-flags:
 # nnan: No NaNs - Allow optimizations to assume the arguments and
 #       result are not NaN. Such optimizations are required to retain
 #       defined behavior over NaNs, but the value of the result is
@@ -23,7 +24,7 @@ module FastMath
 
 export @fastmath
 
-import Core.Intrinsics: powi_llvm, sqrt_llvm_fast, neg_float_fast,
+import Core.Intrinsics: sqrt_llvm, neg_float_fast,
     add_float_fast, sub_float_fast, mul_float_fast, div_float_fast, rem_float_fast,
     eq_float_fast, ne_float_fast, lt_float_fast, le_float_fast
 
@@ -42,7 +43,6 @@ const fast_op =
          :cmp => :cmp_fast,
          :conj => :conj_fast,
          :inv => :inv_fast,
-         :mod => :mod_fast,
          :rem => :rem_fast,
          :sign => :sign_fast,
          :isfinite => :isfinite_fast,
@@ -77,6 +77,7 @@ const fast_op =
          :min => :min_fast,
          :minmax => :minmax_fast,
          :sin => :sin_fast,
+         :sincos => :sincos_fast,
          :sinh => :sinh_fast,
          :sqrt => :sqrt_fast,
          :tan => :tan_fast,
@@ -124,6 +125,27 @@ function make_fastmath(symb::Symbol)
 end
 make_fastmath(expr) = expr
 
+"""
+    @fastmath expr
+
+Execute a transformed version of the expression, which calls functions that
+may violate strict IEEE semantics. This allows the fastest possible operation,
+but results are undefined -- be careful when doing this, as it may change numerical
+results.
+
+This sets the [LLVM Fast-Math flags](http://llvm.org/docs/LangRef.html#fast-math-flags),
+and corresponds to the `-ffast-math` option in clang. See [the notes on performance
+annotations](@ref man-performance-annotations) for more details.
+
+# Examples
+```jldoctest
+julia> @fastmath 1+2
+3
+
+julia> @fastmath(sin(3))
+0.1411200080598672
+```
+"""
 macro fastmath(expr)
     make_fastmath(esc(expr))
 end
@@ -135,29 +157,25 @@ FloatTypes = Union{Float32, Float64}
 
 sub_fast(x::FloatTypes) = neg_float_fast(x)
 
-add_fast{T<:FloatTypes}(x::T, y::T) = add_float_fast(x, y)
-sub_fast{T<:FloatTypes}(x::T, y::T) = sub_float_fast(x, y)
-mul_fast{T<:FloatTypes}(x::T, y::T) = mul_float_fast(x, y)
-div_fast{T<:FloatTypes}(x::T, y::T) = div_float_fast(x, y)
-rem_fast{T<:FloatTypes}(x::T, y::T) = rem_float_fast(x, y)
+add_fast(x::T, y::T) where {T<:FloatTypes} = add_float_fast(x, y)
+sub_fast(x::T, y::T) where {T<:FloatTypes} = sub_float_fast(x, y)
+mul_fast(x::T, y::T) where {T<:FloatTypes} = mul_float_fast(x, y)
+div_fast(x::T, y::T) where {T<:FloatTypes} = div_float_fast(x, y)
+rem_fast(x::T, y::T) where {T<:FloatTypes} = rem_float_fast(x, y)
 
-add_fast{T<:FloatTypes}(x::T, y::T, zs::T...) =
+add_fast(x::T, y::T, zs::T...) where {T<:FloatTypes} =
     add_fast(add_fast(x, y), zs...)
-mul_fast{T<:FloatTypes}(x::T, y::T, zs::T...) =
+mul_fast(x::T, y::T, zs::T...) where {T<:FloatTypes} =
     mul_fast(mul_fast(x, y), zs...)
 
 @fastmath begin
-    cmp_fast{T<:FloatTypes}(x::T, y::T) = ifelse(x==y, 0, ifelse(x<y, -1, +1))
-    function mod_fast{T<:FloatTypes}(x::T, y::T)
-        r = rem(x,y)
-        ifelse((r > 0) ⊻ (y > 0), r+y, r)
-    end
+    cmp_fast(x::T, y::T) where {T<:FloatTypes} = ifelse(x==y, 0, ifelse(x<y, -1, +1))
 end
 
-eq_fast{T<:FloatTypes}(x::T, y::T) = eq_float_fast(x, y)
-ne_fast{T<:FloatTypes}(x::T, y::T) = ne_float_fast(x, y)
-lt_fast{T<:FloatTypes}(x::T, y::T) = lt_float_fast(x, y)
-le_fast{T<:FloatTypes}(x::T, y::T) = le_float_fast(x, y)
+eq_fast(x::T, y::T) where {T<:FloatTypes} = eq_float_fast(x, y)
+ne_fast(x::T, y::T) where {T<:FloatTypes} = ne_float_fast(x, y)
+lt_fast(x::T, y::T) where {T<:FloatTypes} = lt_float_fast(x, y)
+le_fast(x::T, y::T) where {T<:FloatTypes} = le_float_fast(x, y)
 
 isinf_fast(x) = false
 isfinite_fast(x) = true
@@ -171,48 +189,48 @@ ComplexTypes = Union{Complex64, Complex128}
 @fastmath begin
     abs_fast(x::ComplexTypes) = hypot(real(x), imag(x))
     abs2_fast(x::ComplexTypes) = real(x)*real(x) + imag(x)*imag(x)
-    conj_fast{T<:ComplexTypes}(x::T) = T(real(x), -imag(x))
+    conj_fast(x::T) where {T<:ComplexTypes} = T(real(x), -imag(x))
     inv_fast(x::ComplexTypes) = conj(x) / abs2(x)
     sign_fast(x::ComplexTypes) = x == 0 ? float(zero(x)) : x/abs(x)
 
-    add_fast{T<:ComplexTypes}(x::T, y::T) =
+    add_fast(x::T, y::T) where {T<:ComplexTypes} =
         T(real(x)+real(y), imag(x)+imag(y))
-    add_fast{T<:FloatTypes}(x::Complex{T}, b::T) =
+    add_fast(x::Complex{T}, b::T) where {T<:FloatTypes} =
         Complex{T}(real(x)+b, imag(x))
-    add_fast{T<:FloatTypes}(a::T, y::Complex{T}) =
+    add_fast(a::T, y::Complex{T}) where {T<:FloatTypes} =
         Complex{T}(a+real(y), imag(y))
 
-    sub_fast{T<:ComplexTypes}(x::T, y::T) =
+    sub_fast(x::T, y::T) where {T<:ComplexTypes} =
         T(real(x)-real(y), imag(x)-imag(y))
-    sub_fast{T<:FloatTypes}(x::Complex{T}, b::T) =
+    sub_fast(x::Complex{T}, b::T) where {T<:FloatTypes} =
         Complex{T}(real(x)-b, imag(x))
-    sub_fast{T<:FloatTypes}(a::T, y::Complex{T}) =
+    sub_fast(a::T, y::Complex{T}) where {T<:FloatTypes} =
         Complex{T}(a-real(y), -imag(y))
 
-    mul_fast{T<:ComplexTypes}(x::T, y::T) =
+    mul_fast(x::T, y::T) where {T<:ComplexTypes} =
         T(real(x)*real(y) - imag(x)*imag(y),
           real(x)*imag(y) + imag(x)*real(y))
-    mul_fast{T<:FloatTypes}(x::Complex{T}, b::T) =
+    mul_fast(x::Complex{T}, b::T) where {T<:FloatTypes} =
         Complex{T}(real(x)*b, imag(x)*b)
-    mul_fast{T<:FloatTypes}(a::T, y::Complex{T}) =
+    mul_fast(a::T, y::Complex{T}) where {T<:FloatTypes} =
         Complex{T}(a*real(y), a*imag(y))
 
-    @inline div_fast{T<:ComplexTypes}(x::T, y::T) =
+    @inline div_fast(x::T, y::T) where {T<:ComplexTypes} =
         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) =
+    div_fast(x::Complex{T}, b::T) where {T<:FloatTypes} =
         Complex{T}(real(x)/b, imag(x)/b)
-    div_fast{T<:FloatTypes}(a::T, y::Complex{T}) =
+    div_fast(a::T, y::Complex{T}) where {T<:FloatTypes} =
         Complex{T}(a*real(y), -a*imag(y)) / abs2(y)
 
-    eq_fast{T<:ComplexTypes}(x::T, y::T) =
+    eq_fast(x::T, y::T) where {T<:ComplexTypes} =
         (real(x)==real(y)) & (imag(x)==imag(y))
-    eq_fast{T<:FloatTypes}(x::Complex{T}, b::T) =
+    eq_fast(x::Complex{T}, b::T) where {T<:FloatTypes} =
         (real(x)==b) & (imag(x)==T(0))
-    eq_fast{T<:FloatTypes}(a::T, y::Complex{T}) =
+    eq_fast(a::T, y::Complex{T}) where {T<:FloatTypes} =
         (a==real(y)) & (T(0)==imag(y))
 
-    ne_fast{T<:ComplexTypes}(x::T, y::T) = !(x==y)
+    ne_fast(x::T, y::T) where {T<:ComplexTypes} = !(x==y)
 end
 
 # fall-back implementations and type promotion
@@ -225,7 +243,7 @@ for op in (:abs, :abs2, :conj, :inv, :sign)
     end
 end
 
-for op in (:+, :-, :*, :/, :(==), :!=, :<, :<=, :cmp, :mod, :rem)
+for op in (:+, :-, :*, :/, :(==), :!=, :<, :<=, :cmp, :rem)
     op_fast = fast_op[op]
     @eval begin
         # fall-back implementation for non-numeric types
@@ -234,7 +252,7 @@ for op in (:+, :-, :*, :/, :(==), :!=, :<, :<=, :cmp, :mod, :rem)
         $op_fast(x::Number, y::Number, zs::Number...) =
             $op_fast(promote(x,y,zs...)...)
         # fall-back implementation that applies after promotion
-        $op_fast{T<:Number}(x::T,ys::T...) = $op(x,ys...)
+        $op_fast(x::T,ys::T...) where {T<:Number} = $op(x,ys...)
     end
 end
 
@@ -243,19 +261,17 @@ end
 
 # builtins
 
-pow_fast(x::FloatTypes, y::Integer) = pow_fast(x, Int32(y))
-pow_fast(x::FloatTypes, y::Int32) = Base.powi_llvm(x, y)
+pow_fast(x::Float32, y::Integer) = ccall("llvm.powi.f32", llvmcall, Float32, (Float32, Int32), x, y)
+pow_fast(x::Float64, y::Integer) = ccall("llvm.powi.f64", llvmcall, Float64, (Float64, Int32), x, y)
 
-# TODO: Change sqrt_llvm intrinsic to avoid nan checking; add nan
-# checking to sqrt in math.jl; remove sqrt_llvm_fast intrinsic
-sqrt_fast(x::FloatTypes) = sqrt_llvm_fast(x)
+sqrt_fast(x::FloatTypes) = sqrt_llvm(x)
 
 # libm
 
 const libm = Base.libm_name
 
 for f in (:acos, :acosh, :asin, :asinh, :atan, :atanh, :cbrt, :cos,
-          :cosh, :exp2, :exp, :expm1, :lgamma, :log10, :log1p, :log2,
+          :cosh, :exp2, :expm1, :lgamma, :log10, :log1p, :log2,
           :log, :sin, :sinh, :tan, :tanh)
     f_fast = fast_op[f]
     @eval begin
@@ -278,49 +294,88 @@ atan2_fast(x::Float64, y::Float64) =
 
 # explicit implementations
 
-@fastmath begin
-    exp10_fast{T<:FloatTypes}(x::T) = exp2(log2(T(10))*x)
-    exp10_fast(x::Integer) = exp10(float(x))
+# FIXME: Change to `ccall((:sincos, libm))` when `Ref` calling convention can be
+#        stack allocated.
+@inline function sincos_fast(v::Float64)
+    return Base.llvmcall("""
+    %f = bitcast i8 *%1 to void (double, double *, double *)*
+    %ps = alloca double
+    %pc = alloca double
+    call void %f(double %0, double *%ps, double *%pc)
+    %s = load double, double* %ps
+    %c = load double, double* %pc
+    %res0 = insertvalue [2 x double] undef, double %s, 0
+    %res = insertvalue [2 x double] %res0, double %c, 1
+    ret [2 x double] %res
+    """, Tuple{Float64,Float64}, Tuple{Float64,Ptr{Void}}, v, cglobal((:sincos, libm)))
+end
 
-    hypot_fast{T<:FloatTypes}(x::T, y::T) = sqrt(x*x + y*y)
+@inline function sincos_fast(v::Float32)
+    return Base.llvmcall("""
+    %f = bitcast i8 *%1 to void (float, float *, float *)*
+    %ps = alloca float
+    %pc = alloca float
+    call void %f(float %0, float *%ps, float *%pc)
+    %s = load float, float* %ps
+    %c = load float, float* %pc
+    %res0 = insertvalue [2 x float] undef, float %s, 0
+    %res = insertvalue [2 x float] %res0, float %c, 1
+    ret [2 x float] %res
+    """, Tuple{Float32,Float32}, Tuple{Float32,Ptr{Void}}, v, cglobal((:sincosf, libm)))
+end
+
+@inline function sincos_fast(v::Float16)
+    s, c = sincos_fast(Float32(v))
+    return Float16(s), Float16(c)
+end
+
+sincos_fast(v::AbstractFloat) = (sin_fast(v), cos_fast(v))
+sincos_fast(v::Real) = sincos_fast(float(v)::AbstractFloat)
+sincos_fast(v) = (sin_fast(v), cos_fast(v))
+
+@fastmath begin
+    hypot_fast(x::T, y::T) where {T<:FloatTypes} = sqrt(x*x + y*y)
 
     # Note: we use the same comparison for min, max, and minmax, so
     # that the compiler can convert between them
-    max_fast{T<:FloatTypes}(x::T, y::T) = ifelse(y > x, y, x)
-    min_fast{T<:FloatTypes}(x::T, y::T) = ifelse(y > x, x, y)
-    minmax_fast{T<:FloatTypes}(x::T, y::T) = ifelse(y > x, (x,y), (y,x))
+    max_fast(x::T, y::T) where {T<:FloatTypes} = ifelse(y > x, y, x)
+    min_fast(x::T, y::T) where {T<:FloatTypes} = ifelse(y > x, x, y)
+    minmax_fast(x::T, y::T) where {T<:FloatTypes} = ifelse(y > x, (x,y), (y,x))
 
     # complex numbers
 
-    cis_fast{T<:FloatTypes}(x::T) = Complex{T}(cos(x), sin(x))
+    function cis_fast(x::T) where {T<:FloatTypes}
+        s, c = sincos_fast(x)
+        Complex{T}(c, s)
+    end
 
     # See <http://en.cppreference.com/w/cpp/numeric/complex>
-    pow_fast{T<:ComplexTypes}(x::T, y::T) = exp(y*log(x))
-    pow_fast{T<:FloatTypes}(x::T, y::Complex{T}) = exp(y*log(x))
-    pow_fast{T<:FloatTypes}(x::Complex{T}, y::T) = exp(y*log(x))
-    acos_fast{T<:ComplexTypes}(x::T) =
+    pow_fast(x::T, y::T) where {T<:ComplexTypes} = exp(y*log(x))
+    pow_fast(x::T, y::Complex{T}) where {T<:FloatTypes} = exp(y*log(x))
+    pow_fast(x::Complex{T}, y::T) where {T<:FloatTypes} = exp(y*log(x))
+    acos_fast(x::T) where {T<:ComplexTypes} =
         convert(T,π)/2 + im*log(im*x + sqrt(1-x*x))
     acosh_fast(x::ComplexTypes) = log(x + sqrt(x+1) * sqrt(x-1))
     angle_fast(x::ComplexTypes) = atan2(imag(x), real(x))
     asin_fast(x::ComplexTypes) = -im*asinh(im*x)
     asinh_fast(x::ComplexTypes) = log(x + sqrt(1+x*x))
     atan_fast(x::ComplexTypes) = -im*atanh(im*x)
-    atanh_fast{T<:ComplexTypes}(x::T) = convert(T,1)/2*(log(1+x) - log(1-x))
+    atanh_fast(x::T) where {T<:ComplexTypes} = convert(T,1)/2*(log(1+x) - log(1-x))
     cis_fast(x::ComplexTypes) = exp(-imag(x)) * cis(real(x))
     cos_fast(x::ComplexTypes) = cosh(im*x)
-    cosh_fast{T<:ComplexTypes}(x::T) = convert(T,1)/2*(exp(x) + exp(-x))
-    exp10_fast{T<:ComplexTypes}(x::T) =
+    cosh_fast(x::T) where {T<:ComplexTypes} = convert(T,1)/2*(exp(x) + exp(-x))
+    exp10_fast(x::T) where {T<:ComplexTypes} =
         exp10(real(x)) * cis(imag(x)*log(convert(T,10)))
-    exp2_fast{T<:ComplexTypes}(x::T) =
+    exp2_fast(x::T) where {T<:ComplexTypes} =
         exp2(real(x)) * cis(imag(x)*log(convert(T,2)))
     exp_fast(x::ComplexTypes) = exp(real(x)) * cis(imag(x))
     expm1_fast(x::ComplexTypes) = exp(x)-1
-    log10_fast{T<:ComplexTypes}(x::T) = log(x) / log(convert(T,10))
+    log10_fast(x::T) where {T<:ComplexTypes} = log(x) / log(convert(T,10))
     log1p_fast(x::ComplexTypes) = log(1+x)
-    log2_fast{T<:ComplexTypes}(x::T) = log(x) / log(convert(T,2))
-    log_fast{T<:ComplexTypes}(x::T) = T(log(abs2(x))/2, angle(x))
+    log2_fast(x::T) where {T<:ComplexTypes} = log(x) / log(convert(T,2))
+    log_fast(x::T) where {T<:ComplexTypes} = T(log(abs2(x))/2, angle(x))
     sin_fast(x::ComplexTypes) = -im*sinh(im*x)
-    sinh_fast{T<:ComplexTypes}(x::T) = convert(T,1)/2*(exp(x) - exp(-x))
+    sinh_fast(x::T) where {T<:ComplexTypes} = convert(T,1)/2*(exp(x) - exp(-x))
     sqrt_fast(x::ComplexTypes) = sqrt(abs(x)) * cis(angle(x)/2)
     tan_fast(x::ComplexTypes) = -im*tanh(im*x)
     tanh_fast(x::ComplexTypes) = (a=exp(x); b=exp(-x); (a-b)/(a+b))
@@ -346,7 +401,7 @@ for f in (:^, :atan2, :hypot, :max, :min, :minmax)
         # type promotion
         $f_fast(x::Number, y::Number) = $f_fast(promote(x, y)...)
         # fall-back implementation that applies after promotion
-        $f_fast{T<:Number}(x::T, y::T) = $f(x, y)
+        $f_fast(x::T, y::T) where {T<:Number} = $f(x, y)
     end
 end
 
diff --git a/base/fft/FFTW.jl b/base/fft/FFTW.jl
deleted file mode 100644
index d68e302c98a8e8..00000000000000
--- a/base/fft/FFTW.jl
+++ /dev/null
@@ -1,863 +0,0 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
-
-module FFTW
-
-import ..DFT: fft, bfft, ifft, rfft, brfft, irfft, plan_fft, plan_bfft, plan_ifft, plan_rfft, plan_brfft, plan_irfft, fft!, bfft!, ifft!, plan_fft!, plan_bfft!, plan_ifft!, Plan, rfft_output_size, brfft_output_size, plan_inv, normalization, ScaledPlan
-
-import Base: show, *, convert, unsafe_convert, size, strides, ndims, pointer, A_mul_B!
-
-export r2r, r2r!, plan_r2r, plan_r2r!
-
-export export_wisdom, import_wisdom, import_system_wisdom, forget_wisdom,
-       MEASURE, DESTROY_INPUT, UNALIGNED, CONSERVE_MEMORY, EXHAUSTIVE,
-       PRESERVE_INPUT, PATIENT, ESTIMATE, WISDOM_ONLY, NO_TIMELIMIT,
-       R2HC, HC2R, DHT, REDFT00, REDFT01, REDFT10, REDFT11,
-       RODFT00, RODFT01, RODFT10, RODFT11,
-       fftwNumber, fftwReal, fftwComplex, flops
-
-## FFT: Implement fft by calling fftw.
-
-const libfftw = Base.libfftw_name
-const libfftwf = Base.libfftwf_name
-
-const version = convert(VersionNumber, split(unsafe_string(cglobal((:fftw_version,Base.DFT.FFTW.libfftw), UInt8)), ['-', ' '])[2])
-
-## Direction of FFT
-
-const FORWARD = -1
-const BACKWARD = 1
-
-## FFTW Flags from fftw3.h
-
-const MEASURE         = UInt32(0)
-const DESTROY_INPUT   = UInt32(1 << 0)
-const UNALIGNED       = UInt32(1 << 1)
-const CONSERVE_MEMORY = UInt32(1 << 2)
-const EXHAUSTIVE      = UInt32(1 << 3)   # NO_EXHAUSTIVE is default
-const PRESERVE_INPUT  = UInt32(1 << 4)   # cancels DESTROY_INPUT
-const PATIENT         = UInt32(1 << 5)   # IMPATIENT is default
-const ESTIMATE        = UInt32(1 << 6)
-const WISDOM_ONLY     = UInt32(1 << 21)
-const NO_SIMD = UInt32(1 << 17) # disable SIMD, useful for benchmarking
-
-## R2R transform kinds
-
-const R2HC    = 0
-const HC2R    = 1
-const DHT     = 2
-const REDFT00 = 3
-const REDFT01 = 4
-const REDFT10 = 5
-const REDFT11 = 6
-const RODFT00 = 7
-const RODFT01 = 8
-const RODFT10 = 9
-const RODFT11 = 10
-
-let k2s = Dict(R2HC => "R2HC", HC2R => "HC2R", DHT => "DHT", REDFT00 => "REDFT00", REDFT01 => "REDFT01", REDFT10 => "REDFT10", REDFT11 => "REDFT11", RODFT00 => "RODFT00", RODFT01 => "RODFT01", RODFT10 => "RODFT10", RODFT11 => "RODFT11")
-    global kind2string
-    kind2string(k::Integer) = k2s[Int(k)]
-end
-
-# FFTW floating-point types:
-
-const fftwNumber = Union{Float64,Float32,Complex128,Complex64}
-const fftwReal = Union{Float64,Float32}
-const fftwComplex = Union{Complex128,Complex64}
-const fftwDouble = Union{Float64,Complex128}
-const fftwSingle = Union{Float32,Complex64}
-const fftwTypeDouble = Union{Type{Float64},Type{Complex128}}
-const fftwTypeSingle = Union{Type{Float32},Type{Complex64}}
-
-# For ESTIMATE plans, FFTW allows one to pass NULL for the array pointer,
-# since it is not written to.  Hence, it is convenient to create an
-# array-like type that carries a size and a stride like a "real" array
-# but which is converted to C_NULL as a pointer.
-struct FakeArray{T, N} <: DenseArray{T, N}
-    sz::NTuple{N, Int}
-    st::NTuple{N, Int}
-end
-size(a::FakeArray) = a.sz
-strides(a::FakeArray) = a.st
-unsafe_convert{T}(::Type{Ptr{T}}, a::FakeArray{T}) = convert(Ptr{T}, C_NULL)
-pointer{T}(a::FakeArray{T}) = convert(Ptr{T}, C_NULL)
-FakeArray{T, N}(::Type{T}, sz::NTuple{N, Int}) =
-    FakeArray{T, N}(sz, colmajorstrides(sz))
-FakeArray{T}(::Type{T}, sz::Int...) = FakeArray(T, sz)
-fakesimilar(flags, X, T) = flags & ESTIMATE != 0 ? FakeArray(T, size(X)) : Array{T}(size(X))
-alignment_of(A::FakeArray) = Int32(0)
-
-## Julia wrappers around FFTW functions
-
-# Wisdom
-
-# Import and export wisdom to/from a single file for all precisions,
-# which is more user-friendly than requiring the user to call a
-# separate routine depending on the fp precision of the plans.  This
-# requires a bit of trickness since we have to (a) use the libc file
-# I/O routines with fftw_export_wisdom_to_file/import_wisdom_from_file
-# (b) we need 256 bytes of space padding between the wisdoms to work
-# around FFTW's internal file i/o buffering [see the BUFSZ constant in
-# FFTW's api/import-wisdom-from-file.c file].
-
-function export_wisdom(fname::AbstractString)
-    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) # 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,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
-        error("failed to import wisdom from $fname")
-    end
-    ccall(:fclose, Void, (Ptr{Void},), f)
-end
-
-function import_system_wisdom()
-    if ccall((:fftw_import_system_wisdom,libfftw), Int32, ()) == 0 ||
-       ccall((:fftwf_import_system_wisdom,libfftwf), Int32, ()) == 0
-        error("failed to import system wisdom")
-    end
-end
-
-function forget_wisdom()
-    ccall((:fftw_forget_wisdom,libfftw), Void, ())
-    ccall((:fftwf_forget_wisdom,libfftwf), Void, ())
-end
-
-# Threads
-
-let initialized = false
-    global set_num_threads
-    function set_num_threads(nthreads::Integer)
-        if !initialized
-            # must re-initialize FFTW if any FFTW routines have been called
-            ccall((:fftw_cleanup,libfftw), Void, ())
-            ccall((:fftwf_cleanup,libfftwf), Void, ())
-            stat = ccall((:fftw_init_threads,libfftw), Int32, ())
-            statf = ccall((:fftwf_init_threads,libfftwf), Int32, ())
-            if stat == 0 || statf == 0
-                error("could not initialize FFTW threads")
-            end
-            initialized = true
-        end
-        ccall((:fftw_plan_with_nthreads,libfftw), Void, (Int32,), nthreads)
-        ccall((:fftwf_plan_with_nthreads,libfftwf), Void, (Int32,), nthreads)
-    end
-end
-
-# pointer type for fftw_plan (opaque pointer)
-
-struct fftw_plan_struct end
-const PlanPtr = Ptr{fftw_plan_struct}
-
-# Planner timelimits
-
-const NO_TIMELIMIT = -1.0 # from fftw3.h
-
-set_timelimit(precision::fftwTypeDouble,seconds) =
-    ccall((:fftw_set_timelimit,libfftw), Void, (Float64,), seconds)
-
-set_timelimit(precision::fftwTypeSingle,seconds) =
-    ccall((:fftwf_set_timelimit,libfftwf), Void, (Float64,), seconds)
-
-# Array alignment mod 16:
-#   FFTW plans may depend on the alignment of the array mod 16 bytes,
-#   i.e. the address mod 16 of the first element of the array, in order
-#   to exploit SIMD operations.  Julia arrays are, by default, aligned
-#   to 16-byte boundaries (address mod 16 == 0), but this may not be
-#   true for data imported from external C code, or for SubArrays.
-#   Use the undocumented routine fftw_alignment_of to determine the
-#   alignment of a given pointer modulo whatever FFTW needs; this
-#   function will be documented in FFTW 3.3.4.
-
-
-if Base.libfftw_name == "libmkl_rt"
-    alignment_of(A::StridedArray{<:fftwDouble}) =
-        convert(Int32, convert(Int64, pointer(A)) % 16)
-    alignment_of(A::StridedArray{<:fftwSingle}) =
-        convert(Int32, convert(Int64, pointer(A)) % 16)
-else
-    alignment_of{T<:fftwDouble}(A::StridedArray{T}) =
-        ccall((:fftw_alignment_of, libfftw), Int32, (Ptr{T},), A)
-    alignment_of{T<:fftwSingle}(A::StridedArray{T}) =
-        ccall((:fftwf_alignment_of, libfftwf), Int32, (Ptr{T},), A)
-end
-
-# FFTWPlan (low-level)
-
-# low-level storage of the FFTW plan, along with the information
-# needed to determine whether it is applicable.   We need to put
-# this into a type to support a finalizer on the fftw_plan.
-# K is FORWARD/BACKWARD for forward/backward or r2c/c2r plans, respectively.
-# For r2r plans, K is a tuple of the transform kinds along each dimension.
-abstract type FFTWPlan{T<:fftwNumber,K,inplace} <: Plan{T} end
-for P in (:cFFTWPlan, :rFFTWPlan, :r2rFFTWPlan) # complex, r2c/c2r, and r2r
-    @eval begin
-        mutable struct $P{T<:fftwNumber,K,inplace,N} <: FFTWPlan{T,K,inplace}
-            plan::PlanPtr
-            sz::NTuple{N, Int} # size of array on which plan operates (Int tuple)
-            osz::NTuple{N, Int} # size of output array (Int tuple)
-            istride::NTuple{N, Int} # strides of input
-            ostride::NTuple{N, Int} # strides of output
-            ialign::Int32 # alignment mod 16 of input
-            oalign::Int32 # alignment mod 16 of input
-            flags::UInt32 # planner flags
-            region::Any # region (iterable) of dims that are transormed
-            pinv::ScaledPlan
-            function $P{T,K,inplace,N}(plan::PlanPtr, flags::Integer, R::Any,
-                                       X::StridedArray{T, N}, Y::StridedArray) where {T<:fftwNumber,K,inplace,N}
-                p = new(plan, size(X), size(Y), strides(X), strides(Y),
-                        alignment_of(X), alignment_of(Y), flags, R)
-                finalizer(p, destroy_plan)
-                p
-            end
-        end
-    end
-end
-
-size(p::FFTWPlan) = p.sz
-
-unsafe_convert(::Type{PlanPtr}, p::FFTWPlan) = p.plan
-
-destroy_plan(plan::FFTWPlan{<:fftwDouble}) =
-    ccall((:fftw_destroy_plan,libfftw), Void, (PlanPtr,), plan)
-
-destroy_plan(plan::FFTWPlan{<:fftwSingle}) =
-    ccall((:fftwf_destroy_plan,libfftwf), Void, (PlanPtr,), plan)
-
-cost(plan::FFTWPlan{<:fftwDouble}) =
-    ccall((:fftw_cost,libfftw), Float64, (PlanPtr,), plan)
-cost(plan::FFTWPlan{<:fftwSingle}) =
-    ccall((:fftwf_cost,libfftwf), Float64, (PlanPtr,), plan)
-
-function arithmetic_ops(plan::FFTWPlan{<:fftwDouble})
-    # Change to individual Ref after we can allocate them on stack
-    ref = Ref{NTuple{3, Float64}}()
-    ptr = Ptr{Float64}(Base.unsafe_convert(Ptr{NTuple{3, Float64}}, ref))
-    ccall((:fftw_flops,libfftw), Void,
-          (PlanPtr,Ptr{Float64},Ptr{Float64},Ptr{Float64}),
-          plan, ptr, ptr + 8, ptr + 16)
-    (round(Int64, ref[][1]), round(Int64, ref[][2]), round(Int64, ref[][3]))
-end
-function arithmetic_ops(plan::FFTWPlan{<:fftwSingle})
-    # Change to individual Ref after we can allocate them on stack
-    ref = Ref{NTuple{3, Float64}}()
-    ptr = Ptr{Float64}(Base.unsafe_convert(Ptr{NTuple{3, Float64}}, ref))
-    ccall((:fftwf_flops,libfftwf), Void,
-          (PlanPtr,Ptr{Float64},Ptr{Float64},Ptr{Float64}),
-          plan, ptr, ptr + 8, ptr + 16)
-    (round(Int64, ref[][1]), round(Int64, ref[][2]), round(Int64, ref[][3]))
-end
-flops(plan::FFTWPlan) = let ops = arithmetic_ops(plan)
-    ops[1] + ops[2] + 2 * ops[3] # add + mul + 2*fma
-end
-
-# Pretty-printing plans
-
-function showfftdims(io, sz::Dims, istride::Dims, T)
-    if isempty(sz)
-        print(io, "0-dimensional")
-    elseif length(sz) == 1
-        print(io, sz[1], "-element")
-    else
-        print(io, join(sz, "×"))
-    end
-    if istride == colmajorstrides(sz)
-        print(io, " array of ", T)
-    else
-        print(io, " $istride-strided array of ", T)
-    end
-end
-
-# The sprint_plan function was released in FFTW 3.3.4
-sprint_plan_(plan::FFTWPlan{<:fftwDouble}) =
-    ccall((:fftw_sprint_plan,libfftw), Ptr{UInt8}, (PlanPtr,), plan)
-sprint_plan_(plan::FFTWPlan{<:fftwSingle}) =
-    ccall((:fftwf_sprint_plan,libfftwf), Ptr{UInt8}, (PlanPtr,), plan)
-function sprint_plan(plan::FFTWPlan)
-    p = sprint_plan_(plan)
-    str = unsafe_string(p)
-    Libc.free(p)
-    return str
-end
-
-function show{T,K,inplace}(io::IO, p::cFFTWPlan{T,K,inplace})
-    print(io, inplace ? "FFTW in-place " : "FFTW ",
-          K < 0 ? "forward" : "backward", " plan for ")
-    showfftdims(io, p.sz, p.istride, T)
-    version >= v"3.3.4" && print(io, "\n", sprint_plan(p))
-end
-
-function show{T,K,inplace}(io::IO, p::rFFTWPlan{T,K,inplace})
-    print(io, inplace ? "FFTW in-place " : "FFTW ",
-          K < 0 ? "real-to-complex" : "complex-to-real",
-          " plan for ")
-    showfftdims(io, p.sz, p.istride, T)
-    version >= v"3.3.4" && print(io, "\n", sprint_plan(p))
-end
-
-function show{T,K,inplace}(io::IO, p::r2rFFTWPlan{T,K,inplace})
-    print(io, inplace ? "FFTW in-place r2r " : "FFTW r2r ")
-    if isempty(K)
-        print(io, "0-dimensional")
-    elseif K == ntuple(i -> K[1], length(K))
-        print(io, kind2string(K[1]))
-        if length(K) > 1
-            print(io, "^", length(K))
-        end
-    else
-        print(io, join(map(kind2string, K), "×"))
-    end
-    print(io, " plan for ")
-    showfftdims(io, p.sz, p.istride, T)
-    version >= v"3.3.4" && print(io, "\n", sprint_plan(p))
-end
-
-# Check whether a FFTWPlan is applicable to a given input array, and
-# throw an informative error if not:
-function assert_applicable{T}(p::FFTWPlan{T}, X::StridedArray{T})
-    if size(X) != p.sz
-        throw(ArgumentError("FFTW plan applied to wrong-size array"))
-    elseif strides(X) != p.istride
-        throw(ArgumentError("FFTW plan applied to wrong-strides array"))
-    elseif alignment_of(X) != p.ialign || p.flags & UNALIGNED != 0
-        throw(ArgumentError("FFTW plan applied to array with wrong memory alignment"))
-    end
-end
-
-function assert_applicable{T,K,inplace}(p::FFTWPlan{T,K,inplace}, X::StridedArray{T}, Y::StridedArray)
-    assert_applicable(p, X)
-    if size(Y) != p.osz
-        throw(ArgumentError("FFTW plan applied to wrong-size output"))
-    elseif strides(Y) != p.ostride
-        throw(ArgumentError("FFTW plan applied to wrong-strides output"))
-    elseif alignment_of(Y) != p.oalign || p.flags & UNALIGNED != 0
-        throw(ArgumentError("FFTW plan applied to output with wrong memory alignment"))
-    elseif inplace != (pointer(X) == pointer(Y))
-        throw(ArgumentError(string("FFTW ",
-                                   inplace ? "in-place" : "out-of-place",
-                                   " plan applied to ",
-                                   inplace ? "out-of-place" : "in-place",
-                                   " data")))
-    end
-end
-
-# strides for a column-major (Julia-style) array of size == sz
-colmajorstrides(sz) = isempty(sz) ? () : (1,cumprod(Int[sz[1:end-1]...])...)
-
-# Execute
-
-unsafe_execute!(plan::FFTWPlan{<:fftwDouble}) =
-    ccall((:fftw_execute,libfftw), Void, (PlanPtr,), plan)
-
-unsafe_execute!(plan::FFTWPlan{<:fftwSingle}) =
-    ccall((:fftwf_execute,libfftwf), Void, (PlanPtr,), plan)
-
-unsafe_execute!{T<:fftwDouble}(plan::cFFTWPlan{T},
-                               X::StridedArray{T}, Y::StridedArray{T}) =
-    ccall((:fftw_execute_dft,libfftw), Void,
-          (PlanPtr,Ptr{T},Ptr{T}), plan, X, Y)
-
-unsafe_execute!{T<:fftwSingle}(plan::cFFTWPlan{T},
-                               X::StridedArray{T}, Y::StridedArray{T}) =
-    ccall((:fftwf_execute_dft,libfftwf), Void,
-          (PlanPtr,Ptr{T},Ptr{T}), plan, X, Y)
-
-unsafe_execute!(plan::rFFTWPlan{Float64,FORWARD},
-                X::StridedArray{Float64}, Y::StridedArray{Complex128}) =
-    ccall((:fftw_execute_dft_r2c,libfftw), Void,
-          (PlanPtr,Ptr{Float64},Ptr{Complex128}), plan, X, Y)
-
-unsafe_execute!(plan::rFFTWPlan{Float32,FORWARD},
-                X::StridedArray{Float32}, Y::StridedArray{Complex64}) =
-    ccall((:fftwf_execute_dft_r2c,libfftwf), Void,
-          (PlanPtr,Ptr{Float32},Ptr{Complex64}), plan, X, Y)
-
-unsafe_execute!(plan::rFFTWPlan{Complex128,BACKWARD},
-                X::StridedArray{Complex128}, Y::StridedArray{Float64}) =
-    ccall((:fftw_execute_dft_c2r,libfftw), Void,
-          (PlanPtr,Ptr{Complex128},Ptr{Float64}), plan, X, Y)
-
-unsafe_execute!(plan::rFFTWPlan{Complex64,BACKWARD},
-                X::StridedArray{Complex64}, Y::StridedArray{Float32}) =
-    ccall((:fftwf_execute_dft_c2r,libfftwf), Void,
-          (PlanPtr,Ptr{Complex64},Ptr{Float32}), plan, X, Y)
-
-unsafe_execute!{T<:fftwDouble}(plan::r2rFFTWPlan{T},
-                               X::StridedArray{T}, Y::StridedArray{T}) =
-    ccall((:fftw_execute_r2r,libfftw), Void,
-          (PlanPtr,Ptr{T},Ptr{T}), plan, X, Y)
-
-unsafe_execute!{T<:fftwSingle}(plan::r2rFFTWPlan{T},
-                               X::StridedArray{T}, Y::StridedArray{T}) =
-    ccall((:fftwf_execute_r2r,libfftwf), Void,
-          (PlanPtr,Ptr{T},Ptr{T}), plan, X, Y)
-
-# NOTE ON GC (garbage collection):
-#    The FFTWPlan has a finalizer so that gc will destroy the plan,
-#    which is necessary for gc to work with plan_fft.  However,
-#    even when we are creating a single-use FFTWPlan [e.g. for fftn(x)],
-#    we intentionally do NOT call destroy_plan explicitly, and instead
-#    wait for garbage collection.  The reason is that, in the common
-#    case where the user calls fft(x) a second time soon afterwards,
-#    if destroy_plan has not yet been called then FFTW will internally
-#    re-use the table of trigonometric constants from the first plan.
-
-# Compute dims and howmany for FFTW guru planner
-function dims_howmany(X::StridedArray, Y::StridedArray,
-                      sz::Array{Int,1}, region)
-    reg = [region...]
-    if length(unique(reg)) < length(reg)
-        throw(ArgumentError("each dimension can be transformed at most once"))
-    end
-    ist = [strides(X)...]
-    ost = [strides(Y)...]
-    dims = [sz[reg] ist[reg] ost[reg]]'
-    oreg = [1:ndims(X);]
-    oreg[reg] = 0
-    oreg = filter(d -> d > 0, oreg)
-    howmany = [sz[oreg] ist[oreg] ost[oreg]]'
-    return (dims, howmany)
-end
-
-# check & convert kinds into int32 array with same length as region
-function fix_kinds(region, kinds)
-    if length(kinds) != length(region)
-        if length(kinds) > length(region)
-            throw(ArgumentError("too many transform kinds"))
-        else
-            if isempty(kinds)
-                throw(ArgumentError("must supply a transform kind"))
-            end
-            k = Array{Int32}(length(region))
-            k[1:length(kinds)] = [kinds...]
-            k[length(kinds)+1:end] = kinds[end]
-            kinds = k
-        end
-    else
-        kinds = Int32[kinds...]
-    end
-    for i = 1:length(kinds)
-        if kinds[i] < 0 || kinds[i] > 10
-            throw(ArgumentError("invalid transform kind"))
-        end
-    end
-    return kinds
-end
-
-# low-level FFTWPlan creation (for internal use in FFTW module)
-
-for (Tr,Tc,fftw,lib) in ((:Float64,:Complex128,"fftw",libfftw),
-                         (:Float32,:Complex64,"fftwf",libfftwf))
-    @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 = isa(region, Tuple) ? region : copy(region)
-        dims, howmany = dims_howmany(X, Y, [size(X)...], R)
-        plan = ccall(($(string(fftw,"_plan_guru64_dft")),$lib),
-                     PlanPtr,
-                     (Int32, Ptr{Int}, Int32, Ptr{Int},
-                      Ptr{$Tc}, Ptr{$Tc}, Int32, UInt32),
-                     size(dims,2), dims, size(howmany,2), howmany,
-                     X, Y, direction, flags)
-        set_timelimit($Tr, NO_TIMELIMIT)
-        if plan == C_NULL
-            error("FFTW could not create plan") # shouldn't normally happen
-        end
-        return cFFTWPlan{$Tc,K,inplace,N}(plan, flags, R, X, Y)
-    end
-
-    @eval function (::Type{rFFTWPlan{$Tr,$FORWARD,inplace,N}}){inplace,N}(X::StridedArray{$Tr,N},
-                                                                          Y::StridedArray{$Tc,N},
-                                                                          region, flags::Integer, timelimit::Real)
-        R = isa(region, Tuple) ? region : copy(region)
-        region = circshift([region...],-1) # FFTW halves last dim
-        set_timelimit($Tr, timelimit)
-        dims, howmany = dims_howmany(X, Y, [size(X)...], region)
-        plan = ccall(($(string(fftw,"_plan_guru64_dft_r2c")),$lib),
-                     PlanPtr,
-                     (Int32, Ptr{Int}, Int32, Ptr{Int},
-                      Ptr{$Tr}, Ptr{$Tc}, UInt32),
-                     size(dims,2), dims, size(howmany,2), howmany,
-                     X, Y, flags)
-        set_timelimit($Tr, NO_TIMELIMIT)
-        if plan == C_NULL
-            error("FFTW could not create plan") # shouldn't normally happen
-        end
-        return rFFTWPlan{$Tr,$FORWARD,inplace,N}(plan, flags, R, X, Y)
-    end
-
-    @eval function (::Type{rFFTWPlan{$Tc,$BACKWARD,inplace,N}}){inplace,N}(X::StridedArray{$Tc,N},
-                                                                           Y::StridedArray{$Tr,N},
-                                                                           region, flags::Integer, timelimit::Real)
-        R = isa(region, Tuple) ? region : copy(region)
-        region = circshift([region...],-1) # FFTW halves last dim
-        set_timelimit($Tr, timelimit)
-        dims, howmany = dims_howmany(X, Y, [size(Y)...], region)
-        plan = ccall(($(string(fftw,"_plan_guru64_dft_c2r")),$lib),
-                     PlanPtr,
-                     (Int32, Ptr{Int}, Int32, Ptr{Int},
-                      Ptr{$Tc}, Ptr{$Tr}, UInt32),
-                     size(dims,2), dims, size(howmany,2), howmany,
-                     X, Y, flags)
-        set_timelimit($Tr, NO_TIMELIMIT)
-        if plan == C_NULL
-            error("FFTW could not create plan") # shouldn't normally happen
-        end
-        return rFFTWPlan{$Tc,$BACKWARD,inplace,N}(plan, flags, R, X, Y)
-    end
-
-    @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 = isa(region, Tuple) ? region : copy(region)
-        knd = fix_kinds(region, kinds)
-        set_timelimit($Tr, timelimit)
-        dims, howmany = dims_howmany(X, Y, [size(X)...], region)
-        plan = ccall(($(string(fftw,"_plan_guru64_r2r")),$lib),
-                     PlanPtr,
-                     (Int32, Ptr{Int}, Int32, Ptr{Int},
-                      Ptr{$Tr}, Ptr{$Tr}, Ptr{Int32}, UInt32),
-                     size(dims,2), dims, size(howmany,2), howmany,
-                     X, Y, knd, flags)
-        set_timelimit($Tr, NO_TIMELIMIT)
-        if plan == C_NULL
-            error("FFTW could not create plan") # shouldn't normally happen
-        end
-        r2rFFTWPlan{$Tr,(map(Int,knd)...),inplace,N}(plan, flags, R, X, Y)
-    end
-
-    # support r2r transforms of complex = transforms of real & imag parts
-    @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 = isa(region, Tuple) ? region : copy(region)
-        knd = fix_kinds(region, kinds)
-        set_timelimit($Tr, timelimit)
-        dims, howmany = dims_howmany(X, Y, [size(X)...], region)
-        dims[2:3, 1:size(dims,2)] *= 2
-        howmany[2:3, 1:size(howmany,2)] *= 2
-        howmany = [howmany [2,1,1]] # append loop over real/imag parts
-        plan = ccall(($(string(fftw,"_plan_guru64_r2r")),$lib),
-                     PlanPtr,
-                     (Int32, Ptr{Int}, Int32, Ptr{Int},
-                      Ptr{$Tc}, Ptr{$Tc}, Ptr{Int32}, UInt32),
-                     size(dims,2), dims, size(howmany,2), howmany,
-                     X, Y, knd, flags)
-        set_timelimit($Tr, NO_TIMELIMIT)
-        if plan == C_NULL
-            error("FFTW could not create plan") # shouldn't normally happen
-        end
-        r2rFFTWPlan{$Tc,(map(Int,knd)...),inplace,N}(plan, flags, R, X, Y)
-    end
-
-end
-
-# Convert arrays of numeric types to FFTW-supported packed complex-float types
-# (FIXME: is there a way to use the Julia promotion rules more cleverly here?)
-fftwcomplex(X::StridedArray{<:fftwComplex}) = X
-fftwcomplex{T<:fftwReal}(X::AbstractArray{T}) =
-    copy!(Array{typeof(complex(zero(T)))}(size(X)), X)
-fftwcomplex(X::AbstractArray{<:Real}) = copy!(Array{Complex128}(size(X)),X)
-fftwcomplex(X::AbstractArray{<:Complex}) = copy!(Array{Complex128}(size(X)), X)
-fftwfloat(X::StridedArray{<:fftwReal}) = X
-fftwfloat(X::AbstractArray{<:Real}) = copy!(Array{Float64}(size(X)), X)
-fftwfloat(X::AbstractArray{<:Complex}) = fftwcomplex(X)
-
-for (f,direction) in ((:fft,FORWARD), (:bfft,BACKWARD))
-    plan_f = Symbol("plan_",f)
-    plan_f! = Symbol("plan_",f,"!")
-    idirection = -direction
-    @eval begin
-        function $plan_f{T<:fftwComplex,N}(X::StridedArray{T,N}, region;
-                                           flags::Integer=ESTIMATE,
-                                           timelimit::Real=NO_TIMELIMIT)
-            cFFTWPlan{T,$direction,false,N}(X, fakesimilar(flags, X, T),
-                                            region, flags, timelimit)
-        end
-
-        function $plan_f!{T<:fftwComplex,N}(X::StridedArray{T,N}, region;
-                                            flags::Integer=ESTIMATE,
-                                            timelimit::Real=NO_TIMELIMIT)
-            cFFTWPlan{T,$direction,true,N}(X, X, region, flags, timelimit)
-        end
-        $plan_f(X::StridedArray{<:fftwComplex}; kws...) =
-            $plan_f(X, 1:ndims(X); kws...)
-        $plan_f!(X::StridedArray{<:fftwComplex}; kws...) =
-            $plan_f!(X, 1:ndims(X); kws...)
-
-        function plan_inv{T<:fftwComplex,N,inplace}(p::cFFTWPlan{T,$direction,inplace,N})
-            X = Array{T}(p.sz)
-            Y = inplace ? X : fakesimilar(p.flags, X, T)
-            ScaledPlan(cFFTWPlan{T,$idirection,inplace,N}(X, Y, p.region,
-                                                          p.flags, NO_TIMELIMIT),
-                       normalization(X, p.region))
-        end
-    end
-end
-
-function A_mul_B!{T}(y::StridedArray{T}, p::cFFTWPlan{T}, x::StridedArray{T})
-    assert_applicable(p, x, y)
-    unsafe_execute!(p, x, y)
-    return y
-end
-
-function *{T,K,N}(p::cFFTWPlan{T,K,false}, x::StridedArray{T,N})
-    assert_applicable(p, x)
-    y = Array{T}(p.osz)::Array{T,N}
-    unsafe_execute!(p, x, y)
-    return y
-end
-
-function *{T,K}(p::cFFTWPlan{T,K,true}, x::StridedArray{T})
-    assert_applicable(p, x)
-    unsafe_execute!(p, x, x)
-    return x
-end
-
-# rfft/brfft and planned variants.  No in-place version for now.
-
-for (Tr,Tc) in ((:Float32,:Complex64),(:Float64,:Complex128))
-    # Note: use $FORWARD and $BACKWARD below because of issue #9775
-    @eval begin
-        function plan_rfft{N}(X::StridedArray{$Tr,N}, region;
-                              flags::Integer=ESTIMATE,
-                              timelimit::Real=NO_TIMELIMIT)
-            osize = rfft_output_size(X, region)
-            Y = flags&ESTIMATE != 0 ? FakeArray($Tc,osize...) : Array{$Tc}(osize...)
-            rFFTWPlan{$Tr,$FORWARD,false,N}(X, Y, region, flags, timelimit)
-        end
-
-        function plan_brfft{N}(X::StridedArray{$Tc,N}, d::Integer, region;
-                               flags::Integer=ESTIMATE,
-                               timelimit::Real=NO_TIMELIMIT)
-            osize = brfft_output_size(X, d, region)
-            Y = flags&ESTIMATE != 0 ? FakeArray($Tr,osize...) : Array{$Tr}(osize...)
-
-            # FFTW currently doesn't support PRESERVE_INPUT for
-            # multidimensional out-of-place c2r transforms, so
-            # we have to handle 1d and >1d cases separately with a copy.  Ugh.
-            if length(region) <= 1
-                rFFTWPlan{$Tc,$BACKWARD,false,N}(X, Y, region,
-                                                 flags | PRESERVE_INPUT,
-                                                 timelimit)
-            else
-                rFFTWPlan{$Tc,$BACKWARD,false,N}(copy(X), Y, region, flags,
-                                                 timelimit)
-            end
-        end
-
-        plan_rfft(X::StridedArray{$Tr};kws...)=plan_rfft(X,1:ndims(X);kws...)
-        plan_brfft(X::StridedArray{$Tr};kws...)=plan_brfft(X,1:ndims(X);kws...)
-
-        function plan_inv{N}(p::rFFTWPlan{$Tr,$FORWARD,false,N})
-            X = Array{$Tr}(p.sz)
-            Y = p.flags&ESTIMATE != 0 ? FakeArray($Tc,p.osz) : Array{$Tc}(p.osz)
-            ScaledPlan(rFFTWPlan{$Tc,$BACKWARD,false,N}(Y, X, p.region,
-                                                        length(p.region) <= 1 ?
-                                                        p.flags | PRESERVE_INPUT :
-                                                        p.flags, NO_TIMELIMIT),
-                       normalization(X, p.region))
-        end
-
-        function plan_inv{N}(p::rFFTWPlan{$Tc,$BACKWARD,false,N})
-            X = Arra{$Tc}(p.sz)
-            Y = p.flags&ESTIMATE != 0 ? FakeArray($Tr,p.osz) : Array{$Tr}(p.osz)
-            ScaledPlan(rFFTWPlan{$Tr,$FORWARD,false,N}(Y, X, p.region,
-                                                       p.flags, NO_TIMELIMIT),
-                       normalization(Y, p.region))
-        end
-
-        function A_mul_B!(y::StridedArray{$Tc}, p::rFFTWPlan{$Tr,$FORWARD}, x::StridedArray{$Tr})
-            assert_applicable(p, x, y)
-            unsafe_execute!(p, x, y)
-            return y
-        end
-        function A_mul_B!(y::StridedArray{$Tr}, p::rFFTWPlan{$Tc,$BACKWARD}, x::StridedArray{$Tc})
-            assert_applicable(p, x, y)
-            unsafe_execute!(p, x, y) # note: may overwrite x as well as y!
-            return y
-        end
-
-        function *{N}(p::rFFTWPlan{$Tr,$FORWARD,false}, x::StridedArray{$Tr,N})
-            assert_applicable(p, x)
-            y = Array{$Tc}(p.osz)::Array{$Tc,N}
-            unsafe_execute!(p, x, y)
-            return y
-        end
-
-        function *{N}(p::rFFTWPlan{$Tc,$BACKWARD,false}, x::StridedArray{$Tc,N})
-            if p.flags & PRESERVE_INPUT != 0
-                assert_applicable(p, x)
-                y = Array{$Tr}(p.osz)::Array{$Tr,N}
-                unsafe_execute!(p, x, y)
-            else # need to make a copy to avoid overwriting x
-                xc = copy(x)
-                assert_applicable(p, xc)
-                y = Array{$Tr}(p.osz)::Array{$Tr,N}
-                unsafe_execute!(p, xc, y)
-            end
-            return y
-        end
-    end
-end
-
-"""
-    plan_rfft(A [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
-
-Pre-plan an optimized real-input FFT, similar to [`plan_fft`](@ref) except for
-[`rfft`](@ref) instead of [`fft`](@ref). The first two arguments, and the
-size of the transformed result, are the same as for [`rfft`](@ref).
-"""
-plan_rfft
-
-"""
-    plan_brfft(A, d [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
-
-Pre-plan an optimized real-input unnormalized transform, similar to
-[`plan_rfft`](@ref) except for [`brfft`](@ref) instead of
-[`rfft`](@ref). The first two arguments and the size of the transformed result, are
-the same as for [`brfft`](@ref).
-"""
-plan_brfft
-
-# FFTW r2r transforms (low-level interface)
-
-for f in (:r2r, :r2r!)
-    pf = Symbol("plan_", f)
-    @eval begin
-        $f(x::AbstractArray{<:fftwNumber}, kinds) = $pf(x, kinds) * x
-        $f(x::AbstractArray{<:fftwNumber}, kinds, region) = $pf(x, kinds, region) * x
-        $pf(x::AbstractArray, kinds; kws...) = $pf(x, kinds, 1:ndims(x); kws...)
-        $f(x::AbstractArray{<:Real}, kinds, region=1:ndims(x)) = $f(fftwfloat(x), kinds, region)
-        $pf(x::AbstractArray{<:Real}, kinds, region; kws...) = $pf(fftwfloat(x), kinds, region; kws...)
-        $f(x::AbstractArray{<:Complex}, kinds, region=1:ndims(x)) = $f(fftwcomplex(x), kinds, region)
-        $pf(x::AbstractArray{<:Complex}, kinds, region; kws...) = $pf(fftwcomplex(x), kinds, region; kws...)
-    end
-end
-
-function plan_r2r{T<:fftwNumber,N}(X::StridedArray{T,N}, kinds, region;
-                                   flags::Integer=ESTIMATE,
-                                   timelimit::Real=NO_TIMELIMIT)
-    r2rFFTWPlan{T,ANY,false,N}(X, fakesimilar(flags, X, T), region, kinds,
-                               flags, timelimit)
-end
-
-function plan_r2r!{T<:fftwNumber,N}(X::StridedArray{T,N}, kinds, region;
-                                    flags::Integer=ESTIMATE,
-                                    timelimit::Real=NO_TIMELIMIT)
-    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`](@ref) to pre-plan optimized r2r transforms.
-"""
-FFTW.r2r
-
-"""
-    r2r!(A, kind [, dims])
-
-Same as [`r2r`](@ref), 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`](@ref), but corresponds to [`r2r!`](@ref).
-"""
-FFTW.plan_r2r!
-
-"""
-    plan_r2r(A, kind [, dims [, flags [, timelimit]]])
-
-Pre-plan an optimized r2r transform, similar to [`plan_fft`](@ref)
-except that the transforms (and the first three arguments)
-correspond to [`r2r`](@ref) and [`r2r!`](@ref), 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,
-                               REDFT01 => REDFT10, REDFT10 => REDFT01,
-                               REDFT11 => REDFT11,
-                               RODFT00 => RODFT00,
-                               RODFT01 => RODFT10, RODFT10 => RODFT01,
-                               RODFT11 => RODFT11)
-
-# r2r inverses are normalized to 1/N, where N is a "logical" size
-# the transform with length n and kind k:
-function logical_size(n::Integer, k::Integer)
-    k <= DHT && return n
-    k == REDFT00 && return 2(n-1)
-    k == RODFT00 && return 2(n+1)
-    return 2n
-end
-
-function plan_inv{T<:fftwNumber,K,inplace,N}(p::r2rFFTWPlan{T,K,inplace,N})
-    X = Array{T}(p.sz)
-    iK = fix_kinds(p.region, [inv_kind[k] for k in K])
-    Y = inplace ? X : fakesimilar(p.flags, X, T)
-    ScaledPlan(r2rFFTWPlan{T,ANY,inplace,N}(X, Y, p.region, iK,
-                                            p.flags, NO_TIMELIMIT),
-               normalization(real(T),
-                             map(logical_size, [p.sz...][[p.region...]], iK),
-                             1:length(iK)))
-end
-
-function A_mul_B!{T}(y::StridedArray{T}, p::r2rFFTWPlan{T}, x::StridedArray{T})
-    assert_applicable(p, x, y)
-    unsafe_execute!(p, x, y)
-    return y
-end
-
-function *{T,K,N}(p::r2rFFTWPlan{T,K,false}, x::StridedArray{T,N})
-    assert_applicable(p, x)
-    y = Array{T}(p.osz)::Array{T,N}
-    unsafe_execute!(p, x, y)
-    return y
-end
-
-function *{T,K}(p::r2rFFTWPlan{T,K,true}, x::StridedArray{T})
-    assert_applicable(p, x)
-    unsafe_execute!(p, x, x)
-    return x
-end
-
-include("dct.jl")
-
-end # module
diff --git a/base/fft/dct.jl b/base/fft/dct.jl
deleted file mode 100644
index c5590c9623d0e7..00000000000000
--- a/base/fft/dct.jl
+++ /dev/null
@@ -1,176 +0,0 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
-
-# (This is part of the FFTW module.)
-
-export dct, idct, dct!, idct!, plan_dct, plan_idct, plan_dct!, plan_idct!
-
-# Discrete cosine transforms (type II/III) via FFTW's r2r transforms;
-# we follow the Matlab convention and adopt a unitary normalization here.
-# Unlike Matlab we compute the multidimensional transform by default,
-# similar to the Julia fft functions.
-
-mutable struct DCTPlan{T<:fftwNumber,K,inplace} <: Plan{T}
-    plan::r2rFFTWPlan{T}
-    r::Array{UnitRange{Int}} # array of indices for rescaling
-    nrm::Float64 # normalization factor
-    region::Dims # dimensions being transformed
-    pinv::DCTPlan{T}
-    DCTPlan{T,K,inplace}(plan,r,nrm,region) where {T<:fftwNumber,K,inplace} = new(plan,r,nrm,region)
-end
-
-size(p::DCTPlan) = size(p.plan)
-
-function show{T,K,inplace}(io::IO, p::DCTPlan{T,K,inplace})
-    print(io, inplace ? "FFTW in-place " : "FFTW ",
-          K == REDFT10 ? "DCT (DCT-II)" : "IDCT (DCT-III)", " plan for ")
-    showfftdims(io, p.plan.sz, p.plan.istride, eltype(p))
-end
-
-for (pf, pfr, K, inplace) in ((:plan_dct, :plan_r2r, REDFT10, false),
-                              (:plan_dct!, :plan_r2r!, REDFT10, true),
-                              (:plan_idct, :plan_r2r, REDFT01, false),
-                              (:plan_idct!, :plan_r2r!, REDFT01, true))
-    @eval function $pf{T<:fftwNumber}(X::StridedArray{T}, region; kws...)
-        r = [1:n for n in size(X)]
-        nrm = sqrt(0.5^length(region) * normalization(X,region))
-        DCTPlan{T,$K,$inplace}($pfr(X, $K, region; kws...), r, nrm,
-                               ntuple(i -> Int(region[i]), length(region)))
-    end
-end
-
-"""
-    plan_dct!(A [, dims [, flags [, timelimit]]])
-
-Same as [`plan_dct`](@ref), 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`](@ref) except producing a function that computes
-[`idct`](@ref). The first two arguments have the same meaning as for
-[`idct`](@ref).
-"""
-plan_idct
-
-"""
-    plan_dct(A [, dims [, flags [, timelimit]]])
-
-Pre-plan an optimized discrete cosine transform (DCT), similar to
-[`plan_fft`](@ref) except producing a function that computes
-[`dct`](@ref). The first two arguments have the same meaning as for
-[`dct`](@ref).
-"""
-plan_dct
-
-"""
-    plan_idct!(A [, dims [, flags [, timelimit]]])
-
-Same as [`plan_idct`](@ref), 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]
-    DCTPlan{T,iK,inplace}(inplace ?
-                          plan_r2r!(X, iK, p.region, flags=p.plan.flags) :
-                          plan_r2r(X, iK, p.region, flags=p.plan.flags),
-                          p.r, p.nrm, p.region)
-end
-
-for f in (:dct, :dct!, :idct, :idct!)
-    pf = Symbol("plan_", f)
-    @eval begin
-        $f(x::AbstractArray{<:fftwNumber}) = $pf(x) * x
-        $f(x::AbstractArray{<:fftwNumber}, region) = $pf(x, region) * x
-        $pf(x::AbstractArray; kws...) = $pf(x, 1:ndims(x); kws...)
-        $f(x::AbstractArray{<:Real}, region=1:ndims(x)) = $f(fftwfloat(x), region)
-        $pf(x::AbstractArray{<:Real}, region; kws...) = $pf(fftwfloat(x), region; kws...)
-        $pf(x::AbstractArray{<:Complex}, region; kws...) = $pf(fftwcomplex(x), region; kws...)
-    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`](@ref). See also [`plan_dct`](@ref) 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`](@ref).  See also
-[`plan_idct`](@ref) for even greater efficiency.
-"""
-idct
-
-"""
-    dct!(A [, dims])
-
-Same as [`dct!`](@ref), 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!`](@ref), but operates in-place on `A`.
-"""
-idct!
-
-const sqrthalf = sqrt(0.5)
-const sqrt2 = sqrt(2.0)
-const onerange = 1:1
-
-function A_mul_B!{T}(y::StridedArray{T}, p::DCTPlan{T,REDFT10},
-                     x::StridedArray{T})
-    assert_applicable(p.plan, x, y)
-    unsafe_execute!(p.plan, x, y)
-    scale!(y, p.nrm)
-    r = p.r
-    for d in p.region
-        oldr = r[d]
-        r[d] = onerange
-        y[r...] *= sqrthalf
-        r[d] = oldr
-    end
-    return y
-end
-
-# note: idct changes input data
-function A_mul_B!{T}(y::StridedArray{T}, p::DCTPlan{T,REDFT01},
-                     x::StridedArray{T})
-    assert_applicable(p.plan, x, y)
-    scale!(x, p.nrm)
-    r = p.r
-    for d in p.region
-        oldr = r[d]
-        r[d] = onerange
-        x[r...] *= sqrt2
-        r[d] = oldr
-    end
-    unsafe_execute!(p.plan, x, y)
-    return y
-end
-
-*{T}(p::DCTPlan{T,REDFT10,false}, x::StridedArray{T}) =
-    A_mul_B!(Array{T}(p.plan.osz), p, x)
-
-*{T}(p::DCTPlan{T,REDFT01,false}, x::StridedArray{T}) =
-    A_mul_B!(Array{T}(p.plan.osz), p, copy(x)) # need copy to preserve input
-
-*{T,K}(p::DCTPlan{T,K,true}, x::StridedArray{T}) = A_mul_B!(x, p, x)
diff --git a/base/file.jl b/base/file.jl
index 30eb9696de249a..9876aeb5ac89a1 100644
--- a/base/file.jl
+++ b/base/file.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Operations with the file system (paths) ##
 
@@ -24,6 +24,7 @@ export
     tempdir,
     tempname,
     touch,
+    unlink,
     walkdir
 
 # get and set current directory
@@ -34,7 +35,7 @@ export
 Get the current working directory.
 """
 function pwd()
-    b = Array{UInt8}(1024)
+    b = Vector{UInt8}(1024)
     len = Ref{Csize_t}(length(b))
     uv_error(:getcwd, ccall(:uv_cwd, Cint, (Ptr{UInt8}, Ptr{Csize_t}), b, len))
     String(b[1:len[]])
@@ -50,7 +51,7 @@ function cd(dir::AbstractString)
 end
 cd() = cd(homedir())
 
-if is_windows()
+if Sys.iswindows()
     function cd(f::Function, dir::AbstractString)
         old = pwd()
         try
@@ -84,10 +85,13 @@ cd(f::Function) = cd(f, homedir())
     mkdir(path::AbstractString, mode::Unsigned=0o777)
 
 Make a new directory with name `path` and permissions `mode`. `mode` defaults to `0o777`,
-modified by the current file creation mask.
+modified by the current file creation mask. This function never creates more than one
+directory. If the directory already exists, or some intermediate directories do not exist,
+this function throws an error. See [`mkpath`](@ref) for a function which creates all
+required intermediate directories.
 """
 function mkdir(path::AbstractString, mode::Unsigned=0o777)
-    @static if is_windows()
+    @static if Sys.iswindows()
         ret = ccall(:_wmkdir, Int32, (Cwstring,), path)
     else
         ret = ccall(:mkdir, Int32, (Cstring, UInt32), path, mode)
@@ -132,7 +136,7 @@ directory, then all contents are removed recursively.
 function rm(path::AbstractString; force::Bool=false, recursive::Bool=false)
     if islink(path) || !isdir(path)
         try
-            @static if is_windows()
+            @static if Sys.iswindows()
                 # is writable on windows actually means "is deletable"
                 if (filemode(path) & 0o222) == 0
                     chmod(path, 0o777)
@@ -151,7 +155,7 @@ function rm(path::AbstractString; force::Bool=false, recursive::Bool=false)
                 rm(joinpath(path, p), force=force, recursive=true)
             end
         end
-        @static if is_windows()
+        @static if Sys.iswindows()
             ret = ccall(:_wrmdir, Int32, (Cwstring,), path)
         else
             ret = ccall(:rmdir, Int32, (Cstring,), path)
@@ -250,10 +254,10 @@ function touch(path::AbstractString)
     end
 end
 
-if is_windows()
+if Sys.iswindows()
 
 function tempdir()
-    temppath = Array{UInt16}(32767)
+    temppath = Vector{UInt16}(32767)
     lentemppath = ccall(:GetTempPathW,stdcall,UInt32,(UInt32,Ptr{UInt16}),length(temppath),temppath)
     if lentemppath >= length(temppath) || lentemppath == 0
         error("GetTempPath failed: $(Libc.FormatMessage())")
@@ -265,7 +269,7 @@ 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)
+    tname = Vector{UInt16}(32767)
     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
@@ -355,6 +359,7 @@ mktemp(parent)
     mktempdir(parent=tempdir())
 
 Create a temporary directory in the `parent` directory and return its path.
+If `parent` does not exist, throw an error.
 """
 mktempdir(parent)
 
@@ -362,7 +367,8 @@ mktempdir(parent)
 """
     mktemp(f::Function, parent=tempdir())
 
-Apply the function `f` to the result of `mktemp(parent)` and remove the temporary file upon completion.
+Apply the function `f` to the result of [`mktemp(parent)`](@ref) and remove the
+temporary file upon completion.
 """
 function mktemp(fn::Function, parent=tempdir())
     (tmp_path, tmp_io) = mktemp(parent)
@@ -377,8 +383,8 @@ end
 """
     mktempdir(f::Function, parent=tempdir())
 
-Apply the function `f` to the result of `mktempdir(parent)` and remove the temporary
-directory upon completion.
+Apply the function `f` to the result of [`mktempdir(parent)`](@ref) and remove the
+temporary directory upon completion.
 """
 function mktempdir(fn::Function, parent=tempdir())
     tmpdir = mktempdir(parent)
@@ -459,8 +465,8 @@ function walkdir(root; topdown=true, follow_symlinks=false, onerror=throw)
         close(chnl)
         return chnl
     end
-    dirs = Array{eltype(content)}(0)
-    files = Array{eltype(content)}(0)
+    dirs = Vector{eltype(content)}(0)
+    files = Vector{eltype(content)}(0)
     for name in content
         if isdir(joinpath(root, name))
             push!(dirs, name)
@@ -530,7 +536,7 @@ function sendfile(src::AbstractString, dst::AbstractString)
     end
 end
 
-if is_windows()
+if Sys.iswindows()
     const UV_FS_SYMLINK_JUNCTION = 0x0002
 end
 
@@ -544,20 +550,20 @@ Creates a symbolic link to `target` with the name `link`.
     soft symbolic links, such as Windows XP.
 """
 function symlink(p::AbstractString, np::AbstractString)
-    @static if is_windows()
+    @static if Sys.iswindows()
         if Sys.windows_version() < Sys.WINDOWS_VISTA_VER
             error("Windows XP does not support soft symlinks")
         end
     end
     flags = 0
-    @static if is_windows()
+    @static if Sys.iswindows()
         if isdir(p)
             flags |= UV_FS_SYMLINK_JUNCTION
             p = abspath(p)
         end
     end
     err = ccall(:jl_fs_symlink, Int32, (Cstring, Cstring, Cint), p, np, flags)
-    @static if is_windows()
+    @static if Sys.iswindows()
         if err < 0 && !isdir(p)
             Base.warn_once("Note: on Windows, creating file symlinks requires Administrator privileges.")
         end
@@ -577,12 +583,12 @@ function readlink(path::AbstractString)
             (Ptr{Void}, Ptr{Void}, Cstring, Ptr{Void}),
             eventloop(), req, path, C_NULL)
         if ret < 0
-            ccall(:uv_fs_req_cleanup, Void, (Ptr{Void}, ), req)
+            ccall(:uv_fs_req_cleanup, Void, (Ptr{Void},), req)
             uv_error("readlink", ret)
             assert(false)
         end
-        tgt = unsafe_string(ccall(:jl_uv_fs_t_ptr, Ptr{Cchar}, (Ptr{Void}, ), req))
-        ccall(:uv_fs_req_cleanup, Void, (Ptr{Void}, ), req)
+        tgt = unsafe_string(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)
diff --git a/base/filesystem.jl b/base/filesystem.jl
index f66bbfd5a0df59..48e136d86f924c 100644
--- a/base/filesystem.jl
+++ b/base/filesystem.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## File Operations (Libuv-based) ##
 
@@ -21,7 +21,6 @@ export File,
        StatStruct,
        # open,
        futime,
-       unlink,
        write,
        JL_O_WRONLY,
        JL_O_RDONLY,
@@ -45,7 +44,7 @@ import Base:
     skip, stat, unsafe_read, unsafe_write, transcode, uv_error, uvhandle,
     uvtype, write
 
-if is_windows()
+if Sys.iswindows()
     import Base: cwstring
 end
 
@@ -53,7 +52,7 @@ 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)
+include(string(length(Core.ARGS) >= 2 ? Core.ARGS[2] : "", "file_constants.jl"))  # include($BUILDROOT/base/file_constants.jl)
 
 ## Operations with File (fd) objects ##
 
diff --git a/base/float.jl b/base/float.jl
index a2715231a8a486..d7a2724f2f3df4 100644
--- a/base/float.jl
+++ b/base/float.jl
@@ -1,29 +1,29 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## floating point traits ##
 
 """
     Inf16
 
-Positive infinity of type `Float16`.
+Positive infinity of type [`Float16`](@ref).
 """
 const Inf16 = bitcast(Float16, 0x7c00)
 """
     NaN16
 
-A not-a-number value of type `Float16`.
+A not-a-number value of type [`Float16`](@ref).
 """
 const NaN16 = bitcast(Float16, 0x7e00)
 """
     Inf32
 
-Positive infinity of type `Float32`.
+Positive infinity of type [`Float32`](@ref).
 """
 const Inf32 = bitcast(Float32, 0x7f800000)
 """
     NaN32
 
-A not-a-number value of type `Float32`.
+A not-a-number value of type [`Float32`](@ref).
 """
 const NaN32 = bitcast(Float32, 0x7fc00000)
 const Inf64 = bitcast(Float64, 0x7ff0000000000000)
@@ -32,13 +32,13 @@ const NaN64 = bitcast(Float64, 0x7ff8000000000000)
 """
     Inf
 
-Positive infinity of type `Float64`.
+Positive infinity of type [`Float64`](@ref).
 """
 const Inf = Inf64
 """
     NaN
 
-A not-a-number value of type `Float64`.
+A not-a-number value of type [`Float64`](@ref).
 """
 const NaN = NaN64
 
@@ -64,7 +64,7 @@ for t1 in (Float32, Float64)
     end
 end
 convert(::Type{Integer}, x::Float16) = convert(Integer, Float32(x))
-convert{T<:Integer}(::Type{T}, x::Float16) = convert(T, Float32(x))
+convert(::Type{T}, x::Float16) where {T<:Integer} = convert(T, Float32(x))
 
 
 promote_rule(::Type{Float64}, ::Type{UInt128}) = Float64
@@ -197,8 +197,8 @@ end
 #   "Fast Half Float Conversion" by Jeroen van der Zijp
 #   ftp://ftp.fox-toolkit.org/pub/fasthalffloatconversion.pdf
 
-const basetable = Array{UInt16}(512)
-const shifttable = Array{UInt8}(512)
+const basetable = Vector{UInt16}(512)
+const shifttable = Vector{UInt8}(512)
 
 for i = 0:255
     e = i - 127
@@ -271,16 +271,19 @@ julia> float(Int)
 Float64
 ```
 """
-float{T<:Number}(::Type{T}) = typeof(float(zero(T)))
+float(::Type{T}) where {T<:Number} = typeof(float(zero(T)))
+float(::Type{T}) where {T<:AbstractFloat} = T
 
 for Ti in (Int8, Int16, Int32, Int64)
     @eval begin
+        unsafe_trunc(::Type{$Ti}, x::Float16) = unsafe_trunc($Ti, Float32(x))
         unsafe_trunc(::Type{$Ti}, x::Float32) = fptosi($Ti, x)
         unsafe_trunc(::Type{$Ti}, x::Float64) = fptosi($Ti, x)
     end
 end
 for Ti in (UInt8, UInt16, UInt32, UInt64)
     @eval begin
+        unsafe_trunc(::Type{$Ti}, x::Float16) = unsafe_trunc($Ti, Float32(x))
         unsafe_trunc(::Type{$Ti}, x::Float32) = fptoui($Ti, x)
         unsafe_trunc(::Type{$Ti}, x::Float64) = fptoui($Ti, x)
     end
@@ -314,6 +317,8 @@ function unsafe_trunc(::Type{Int128}, x::Float32)
     copysign(unsafe_trunc(UInt128,x) % Int128, x)
 end
 
+unsafe_trunc(::Type{UInt128}, x::Float16) = unsafe_trunc(UInt128, Float32(x))
+unsafe_trunc(::Type{Int128}, x::Float16) = unsafe_trunc(Int128, Float32(x))
 
 # matches convert methods
 # also determines floor, ceil, round
@@ -323,15 +328,15 @@ trunc(::Type{Unsigned}, x::Float32) = trunc(UInt,x)
 trunc(::Type{Unsigned}, x::Float64) = trunc(UInt,x)
 trunc(::Type{Integer}, x::Float32) = trunc(Int,x)
 trunc(::Type{Integer}, x::Float64) = trunc(Int,x)
-trunc{T<:Integer}(::Type{T}, x::Float16) = trunc(T, Float32(x))
+trunc(::Type{T}, x::Float16) where {T<:Integer} = trunc(T, Float32(x))
 
 # fallbacks
-floor{T<:Integer}(::Type{T}, x::AbstractFloat) = trunc(T,floor(x))
-floor{T<:Integer}(::Type{T}, x::Float16) = floor(T, Float32(x))
-ceil{ T<:Integer}(::Type{T}, x::AbstractFloat) = trunc(T,ceil(x))
-ceil{ T<:Integer}(::Type{T}, x::Float16) = ceil(T, Float32(x))
-round{T<:Integer}(::Type{T}, x::AbstractFloat) = trunc(T,round(x))
-round{T<:Integer}(::Type{T}, x::Float16) = round(T, Float32(x))
+floor(::Type{T}, x::AbstractFloat) where {T<:Integer} = trunc(T,floor(x))
+floor(::Type{T}, x::Float16) where {T<:Integer} = floor(T, Float32(x))
+ceil(::Type{T}, x::AbstractFloat) where {T<:Integer} = trunc(T,ceil(x))
+ceil(::Type{T}, x::Float16) where {T<:Integer} = ceil(T, Float32(x))
+round(::Type{T}, x::AbstractFloat) where {T<:Integer} = trunc(T,round(x))
+round(::Type{T}, x::Float16) where {T<:Integer} = round(T, Float32(x))
 
 trunc(x::Float64) = trunc_llvm(x)
 trunc(x::Float32) = trunc_llvm(x)
@@ -395,9 +400,9 @@ end
 rem(x::Float32, y::Float32) = rem_float(x, y)
 rem(x::Float64, y::Float64) = rem_float(x, y)
 
-cld{T<:AbstractFloat}(x::T, y::T) = -fld(-x,y)
+cld(x::T, y::T) where {T<:AbstractFloat} = -fld(-x,y)
 
-function mod{T<:AbstractFloat}(x::T, y::T)
+function mod(x::T, y::T) where T<:AbstractFloat
     r = rem(x,y)
     if r == 0
         copysign(r,y)
@@ -438,17 +443,18 @@ for op in (:<, :<=, :isless)
 end
 
 function cmp(x::AbstractFloat, y::AbstractFloat)
-    (isnan(x) || isnan(y)) && throw(DomainError())
+    isnan(x) && throw(DomainError(x, "`x` cannot be NaN."))
+    isnan(y) && throw(DomainError(y, "`y` cannot be NaN."))
     ifelse(x<y, -1, ifelse(x>y, 1, 0))
 end
 
 function cmp(x::Real, y::AbstractFloat)
-    isnan(y) && throw(DomainError())
+    isnan(y) && throw(DomainError(y, "`y` cannot be NaN."))
     ifelse(x<y, -1, ifelse(x>y, 1, 0))
 end
 
 function cmp(x::AbstractFloat, y::Real)
-    isnan(x) && throw(DomainError())
+    isnan(x) && throw(DomainError(x, "`x` cannot be NaN."))
     ifelse(x<y, -1, ifelse(x>y, 1, 0))
 end
 
@@ -515,7 +521,7 @@ abs(x::Float64) = abs_float(x)
 Test whether a floating point number is not a number (NaN).
 """
 isnan(x::AbstractFloat) = x != x
-isnan(x::Float16)    = reinterpret(UInt16,x)&0x7fff  > 0x7c00
+isnan(x::Float16) = reinterpret(UInt16,x)&0x7fff > 0x7c00
 isnan(x::Real) = false
 
 """
@@ -559,7 +565,7 @@ hash(x::Float32, h::UInt) = hash(Float64(x), h)
 precision(::Type{Float16}) = 11
 precision(::Type{Float32}) = 24
 precision(::Type{Float64}) = 53
-precision{T<:AbstractFloat}(::T) = precision(T)
+precision(::T) where {T<:AbstractFloat} = precision(T)
 
 """
     uabs(x::Integer)
@@ -644,14 +650,14 @@ for Ti in (Int8, Int16, Int32, Int64, Int128, UInt8, UInt16, UInt32, UInt64, UIn
                     if $(Tf(typemin(Ti))-one(Tf)) < x < $(Tf(typemax(Ti))+one(Tf))
                         return unsafe_trunc($Ti,x)
                     else
-                        throw(InexactError())
+                        throw(InexactError(:trunc, $Ti, x))
                     end
                 end
                 function convert(::Type{$Ti}, x::$Tf)
                     if ($(Tf(typemin(Ti))) <= x <= $(Tf(typemax(Ti)))) && (trunc(x) == x)
                         return unsafe_trunc($Ti,x)
                     else
-                        throw(InexactError())
+                        throw(InexactError(:convert, $Ti, x))
                     end
                 end
             end
@@ -665,14 +671,14 @@ for Ti in (Int8, Int16, Int32, Int64, Int128, UInt8, UInt16, UInt32, UInt64, UIn
                     if $(Tf(typemin(Ti))) <= x < $(Tf(typemax(Ti)))
                         return unsafe_trunc($Ti,x)
                     else
-                        throw(InexactError())
+                        throw(InexactError(:trunc, $Ti, x))
                     end
                 end
                 function convert(::Type{$Ti}, x::$Tf)
                     if ($(Tf(typemin(Ti))) <= x < $(Tf(typemax(Ti)))) && (trunc(x) == x)
                         return unsafe_trunc($Ti,x)
                     else
-                        throw(InexactError())
+                        throw(InexactError(:convert, $Ti, x))
                     end
                 end
             end
@@ -690,8 +696,8 @@ end
     typemax(::Type{Float32}) = $(Inf32)
     typemin(::Type{Float64}) = $(-Inf64)
     typemax(::Type{Float64}) = $(Inf64)
-    typemin{T<:Real}(x::T) = typemin(T)
-    typemax{T<:Real}(x::T) = typemax(T)
+    typemin(x::T) where {T<:Real} = typemin(T)
+    typemax(x::T) where {T<:Real} = typemax(T)
 
     realmin(::Type{Float16}) = $(bitcast(Float16, 0x0400))
     realmin(::Type{Float32}) = $(bitcast(Float32, 0x00800000))
@@ -699,8 +705,15 @@ end
     realmax(::Type{Float16}) = $(bitcast(Float16, 0x7bff))
     realmax(::Type{Float32}) = $(bitcast(Float32, 0x7f7fffff))
     realmax(::Type{Float64}) = $(bitcast(Float64, 0x7fefffffffffffff))
-    realmin{T<:AbstractFloat}(x::T) = realmin(T)
-    realmax{T<:AbstractFloat}(x::T) = realmax(T)
+
+    """
+        realmin(T)
+
+    The smallest in absolute value non-subnormal value representable by the given
+    floating-point DataType `T`.
+    """
+    realmin(x::T) where {T<:AbstractFloat} = realmin(T)
+    realmax(x::T) where {T<:AbstractFloat} = realmax(T)
     realmin() = realmin(Float64)
     realmax() = realmax(Float64)
 
@@ -745,8 +758,8 @@ of `x` is different, then the larger of the two is taken, that is
     eps(x) == max(x-prevfloat(x), nextfloat(x)-x)
 
 The exceptions to this rule are the smallest and largest finite values
-(e.g. `nextfloat(-Inf)` and `prevfloat(Inf)` for `Float64`), which round to the smaller of
-the values.
+(e.g. `nextfloat(-Inf)` and `prevfloat(Inf)` for [`Float64`](@ref)), which round to the
+smaller of the values.
 
 The rationale for this behavior is that `eps` bounds the floating point rounding
 error. Under the default `RoundNearest` rounding mode, if ``y`` is a real number and ``x``
@@ -812,14 +825,6 @@ fpinttype(::Type{Float64}) = UInt64
 fpinttype(::Type{Float32}) = UInt32
 fpinttype(::Type{Float16}) = UInt16
 
-@pure significand_bits{T<:AbstractFloat}(::Type{T}) = trailing_ones(significand_mask(T))
-@pure exponent_bits{T<:AbstractFloat}(::Type{T}) = sizeof(T)*8 - significand_bits(T) - 1
-@pure exponent_bias{T<:AbstractFloat}(::Type{T}) = Int(exponent_one(T) >> significand_bits(T))
-# maximum float exponent
-@pure exponent_max{T<:AbstractFloat}(::Type{T}) = Int(exponent_mask(T) >> significand_bits(T)) - exponent_bias(T)
-# maximum float exponent without bias
-@pure exponent_raw_max{T<:AbstractFloat}(::Type{T}) = Int(exponent_mask(T) >> significand_bits(T))
-
 ## TwicePrecision utilities
 # The numeric constants are half the number of bits in the mantissa
 for (F, T, n) in ((Float16, UInt16, 5), (Float32, UInt32, 12), (Float64, UInt64, 26))
@@ -847,7 +852,7 @@ truncmask(x, mask) = x
 
 float(A::AbstractArray{<:AbstractFloat}) = A
 
-function float{T}(A::AbstractArray{T})
+function float(A::AbstractArray{T}) where T
     if !isconcrete(T)
         error("`float` not defined on abstractly-typed arrays; please convert to a more specific type")
     end
diff --git a/base/floatfuncs.jl b/base/floatfuncs.jl
index 44761882c39772..840c05f5e6ba60 100644
--- a/base/floatfuncs.jl
+++ b/base/floatfuncs.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## floating-point functions ##
 
@@ -16,10 +16,23 @@ signbit(x::Float64) = signbit(bitcast(Int64, x))
 signbit(x::Float32) = signbit(bitcast(Int32, x))
 signbit(x::Float16) = signbit(bitcast(Int16, x))
 
+"""
+    maxintfloat(T)
+
+The largest integer losslessly representable by the given floating-point DataType `T`.
+"""
 maxintfloat(::Type{Float64}) = 9007199254740992.
 maxintfloat(::Type{Float32}) = Float32(16777216.)
 maxintfloat(::Type{Float16}) = Float16(2048f0)
-maxintfloat{T<:AbstractFloat}(x::T)  = maxintfloat(T)
+maxintfloat(x::T) where {T<:AbstractFloat} = maxintfloat(T)
+
+"""
+    maxintfloat(T, S)
+
+The largest integer losslessly representable by the given floating-point DataType `T` that
+also does not exceed the maximum integer representable by the integer DataType `S`.
+"""
+maxintfloat(::Type{S}, ::Type{T}) where {S<:AbstractFloat, T<:Integer} = min(maxintfloat(S), S(typemax(T)))
 maxintfloat() = maxintfloat(Float64)
 
 isinteger(x::AbstractFloat) = (x - trunc(x) == 0)
@@ -48,6 +61,7 @@ specifying a rounding mode the global mode will be used
 ([`RoundNearest`](@ref) mode), with ties (fractional values of 0.5) being
 rounded to the nearest even integer.
 
+# Examples
 ```jldoctest
 julia> round(1.7)
 2.0
@@ -68,6 +82,7 @@ rounded.
 `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.
 
+# Examples
 ```jldoctest
 julia> round(pi, 2)
 3.14
@@ -78,10 +93,11 @@ julia> round(pi, 3, 2)
 
 !!! note
     Rounding to specified digits in bases other than 2 can be inexact when
-    operating on binary floating point numbers. For example, the `Float64`
+    operating on binary floating point numbers. For example, the [`Float64`](@ref)
     value represented by `1.15` is actually *less* than 1.15, yet will be
     rounded to 1.2.
 
+    # Examples
     ```jldoctest
     julia> x = 1.15
     1.15
@@ -110,7 +126,7 @@ function round(x::AbstractFloat, ::RoundingMode{:NearestTiesUp})
     y = floor(x)
     ifelse(x==y,y,copysign(floor(2*x-y),x))
 end
-round{T<:Integer}(::Type{T}, x::AbstractFloat, r::RoundingMode) = trunc(T,round(x,r))
+round(::Type{T}, x::AbstractFloat, r::RoundingMode) where {T<:Integer} = trunc(T,round(x,r))
 
 # adapted from Matlab File Exchange roundsd: http://www.mathworks.com/matlabcentral/fileexchange/26212
 # for round, og is the power of 10 relative to the decimal point
@@ -131,8 +147,23 @@ function _signif_og(x, digits, base)
     return og, e
 end
 
+"""
+    signif(x, digits, [base])
+
+Rounds (in the sense of [`round`](@ref)) `x` so that there are `digits` significant digits, under a
+base `base` representation, default 10.
+
+# Examples
+```jldoctest
+julia> signif(123.456, 2)
+120.0
+
+julia> signif(357.913, 4, 2)
+352.0
+```
+"""
 function signif(x::Real, digits::Integer, base::Integer=10)
-    digits < 1 && throw(DomainError())
+    digits < 1 && throw(DomainError(digits, "`digits` cannot be less than 1."))
 
     x = float(x)
     (x == 0 || !isfinite(x)) && return x
@@ -189,6 +220,7 @@ approximately equal component-wise.
 The binary operator `≈` is equivalent to `isapprox` with the default arguments, and `x ≉ y`
 is equivalent to `!isapprox(x,y)`.
 
+# Examples
 ```jldoctest
 julia> 0.1 ≈ (0.1 - 1e-10)
 true
@@ -208,9 +240,9 @@ const ≈ = isapprox
 ≉(args...; kws...) = !≈(args...; kws...)
 
 # default tolerance arguments
-rtoldefault{T<:AbstractFloat}(::Type{T}) = sqrt(eps(T))
+rtoldefault(::Type{T}) where {T<:AbstractFloat} = sqrt(eps(T))
 rtoldefault(::Type{<:Real}) = 0
-rtoldefault{T<:Number,S<:Number}(x::Union{T,Type{T}}, y::Union{S,Type{S}}) = max(rtoldefault(real(T)),rtoldefault(real(S)))
+rtoldefault(x::Union{T,Type{T}}, y::Union{S,Type{S}}) where {T<:Number,S<:Number} = max(rtoldefault(real(T)),rtoldefault(real(S)))
 
 # fused multiply-add
 fma_libm(x::Float32, y::Float32, z::Float32) =
diff --git a/base/generator.jl b/base/generator.jl
index 53d69e9adde54e..d95c2650577dd4 100644
--- a/base/generator.jl
+++ b/base/generator.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 """
     Generator(f, iter)
@@ -35,7 +35,7 @@ end
 
 Generator(f, I1, I2, Is...) = Generator(a->f(a...), zip(I1, I2, Is...))
 
-Generator{T,I}(::Type{T}, iter::I) = Generator{I,Type{T}}(T, iter)
+Generator(::Type{T}, iter::I) where {T,I} = Generator{I,Type{T}}(T, iter)
 
 start(g::Generator) = (@_inline_meta; start(g.iter))
 done(g::Generator, s) = (@_inline_meta; done(g.iter, s))
@@ -109,10 +109,12 @@ iteratoreltype(x) = iteratoreltype(typeof(x))
 iteratoreltype(::Type) = HasEltype()  # HasEltype is the default
 
 iteratorsize(::Type{<:AbstractArray}) = HasShape()
-iteratorsize{I,F}(::Type{Generator{I,F}}) = iteratorsize(I)
+iteratorsize(::Type{Generator{I,F}}) where {I,F} = iteratorsize(I)
 length(g::Generator) = length(g.iter)
 size(g::Generator) = size(g.iter)
 indices(g::Generator) = indices(g.iter)
 ndims(g::Generator) = ndims(g.iter)
 
-iteratoreltype{I,T}(::Type{Generator{I,T}}) = EltypeUnknown()
+iteratoreltype(::Type{Generator{I,T}}) where {I,T} = EltypeUnknown()
+
+haslength(iter) = iteratorsize(iter) isa Union{HasShape, HasLength}
diff --git a/base/gmp.jl b/base/gmp.jl
index c01b491e85083e..f5cfa8c75e08b3 100644
--- a/base/gmp.jl
+++ b/base/gmp.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module GMP
 
@@ -8,8 +8,9 @@ import Base: *, +, -, /, <, <<, >>, >>>, <=, ==, >, >=, ^, (~), (&), (|), xor,
              binomial, cmp, convert, div, divrem, factorial, fld, gcd, gcdx, lcm, mod,
              ndigits, promote_rule, rem, show, isqrt, string, powermod,
              sum, trailing_zeros, trailing_ones, count_ones, base, tryparse_internal,
-             bin, oct, dec, hex, isequal, invmod, prevpow2, nextpow2, ndigits0z, widen, signed, unsafe_trunc, trunc,
-             iszero
+             bin, oct, dec, hex, isequal, invmod, prevpow2, nextpow2, ndigits0zpb,
+             widen, signed, unsafe_trunc, trunc, iszero, isone, big, flipsign, signbit,
+             hastypemax
 
 if Clong == Int32
     const ClongMax = Union{Int8, Int16, Int32}
@@ -31,44 +32,199 @@ const GMP_BITS_PER_LIMB = gmp_bits_per_limb()
 # be used whenever mp_limb_t is in the signature of ccall'ed GMP functions.
 if GMP_BITS_PER_LIMB == 32
     const Limb = UInt32
+    const SLimbMax = Union{Int8, Int16, Int32}
+    const ULimbMax = Union{UInt8, UInt16, UInt32}
 elseif GMP_BITS_PER_LIMB == 64
     const Limb = UInt64
+    const SLimbMax = Union{Int8, Int16, Int32, Int64}
+    const ULimbMax = Union{UInt8, UInt16, UInt32, UInt64}
 else
     error("GMP: cannot determine the type mp_limb_t (__gmp_bits_per_limb == $GMP_BITS_PER_LIMB)")
 end
 
+"""
+    BigInt <: Integer
 
+Arbitrary precision integer type.
+"""
 mutable struct BigInt <: Integer
     alloc::Cint
     size::Cint
     d::Ptr{Limb}
+
     function BigInt()
         b = new(zero(Cint), zero(Cint), C_NULL)
-        ccall((:__gmpz_init,:libgmp), Void, (Ptr{BigInt},), &b)
+        MPZ.init!(b)
         finalizer(b, cglobal((:__gmpz_clear, :libgmp)))
         return b
     end
 end
 
+"""
+    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`](@ref).
+
+Instances can be constructed from strings via [`parse`](@ref), or using the `big`
+string literal.
+
+```jldoctest
+julia> parse(BigInt, "42")
+42
+
+julia> big"313"
+313
+```
+"""
+BigInt(x)
+
 function __init__()
     try
         if gmp_version().major != GMP_VERSION.major || gmp_bits_per_limb() != GMP_BITS_PER_LIMB
-            error(string("The dynamically loaded GMP library (version $(gmp_version()) with __gmp_bits_per_limb == $(gmp_bits_per_limb()))\n",
-                         "does not correspond to the compile time version (version $GMP_VERSION with __gmp_bits_per_limb == $GMP_BITS_PER_LIMB).\n",
-                         "Please rebuild Julia."))
+            msg = gmp_bits_per_limb() != GMP_BITS_PER_LIMB ? error : warn
+            msg(string("The dynamically loaded GMP library (version $(gmp_version()) with __gmp_bits_per_limb == $(gmp_bits_per_limb()))\n",
+                       "does not correspond to the compile time version (version $GMP_VERSION with __gmp_bits_per_limb == $GMP_BITS_PER_LIMB).\n",
+                       "Please rebuild Julia."))
         end
 
         ccall((:__gmp_set_memory_functions, :libgmp), Void,
               (Ptr{Void},Ptr{Void},Ptr{Void}),
               cglobal(:jl_gc_counted_malloc),
               cglobal(:jl_gc_counted_realloc_with_old_size),
-              cglobal(:jl_gc_counted_free))
+              cglobal(:jl_gc_counted_free_with_size))
+
+        ZERO.alloc, ZERO.size, ZERO.d = 0, 0, C_NULL
+        ONE.alloc, ONE.size, ONE.d = 1, 1, pointer(_ONE)
     catch ex
         Base.showerror_nostdio(ex,
             "WARNING: Error during initialization of module GMP")
     end
 end
 
+
+module MPZ
+# wrapping of libgmp functions
+# - "output parameters" are labeled x, y, z, and are returned when appropriate
+# - constant input parameters are labeled a, b, c
+# - a method modifying its input has a "!" appendend to its name, according to Julia's conventions
+# - some convenient methods are added (in addition to the pure MPZ ones), e.g. `add(a, b) = add!(BigInt(), a, b)`
+#   and `add!(x, a) = add!(x, x, a)`.
+using Base.GMP: BigInt, Limb
+
+const mpz_t = Ptr{BigInt}
+const bitcnt_t = Culong
+
+gmpz(op::Symbol) = (Symbol(:__gmpz_, op), :libgmp)
+
+init!(x::BigInt) = (ccall((:__gmpz_init, :libgmp), Void, (mpz_t,), &x); x)
+init2!(x::BigInt, a) = (ccall((:__gmpz_init2, :libgmp), Void, (mpz_t, bitcnt_t), &x, a); x)
+
+realloc2!(x, a) = (ccall((:__gmpz_realloc2, :libgmp), Void, (mpz_t, bitcnt_t), &x, a); x)
+realloc2(a) = realloc2!(BigInt(), a)
+
+sizeinbase(a::BigInt, b) = Int(ccall((:__gmpz_sizeinbase, :libgmp), Csize_t, (mpz_t, Cint), &a, b))
+
+for op in (:add, :sub, :mul, :fdiv_q, :tdiv_q, :fdiv_r, :tdiv_r, :gcd, :lcm, :and, :ior, :xor)
+    op! = Symbol(op, :!)
+    @eval begin
+        $op!(x::BigInt, a::BigInt, b::BigInt) = (ccall($(gmpz(op)), Void, (mpz_t, mpz_t, mpz_t), &x, &a, &b); x)
+        $op(a::BigInt, b::BigInt) = $op!(BigInt(), a, b)
+        $op!(x::BigInt, b::BigInt) = $op!(x, x, b)
+    end
+end
+
+invert!(x::BigInt, a::BigInt, b::BigInt) =
+    ccall((:__gmpz_invert, :libgmp), Cint, (mpz_t, mpz_t, mpz_t), &x, &a, &b)
+invert(a::BigInt, b::BigInt) = invert!(BigInt(), a, b)
+invert!(x::BigInt, b::BigInt) = invert!(x, x, b)
+
+for op in (:add_ui, :sub_ui, :mul_ui, :mul_2exp, :fdiv_q_2exp, :pow_ui, :bin_ui)
+    op! = Symbol(op, :!)
+    @eval begin
+        $op!(x::BigInt, a::BigInt, b) = (ccall($(gmpz(op)), Void, (mpz_t, mpz_t, Culong), &x, &a, b); x)
+        $op(a::BigInt, b) = $op!(BigInt(), a, b)
+        $op!(x::BigInt, b) = $op!(x, x, b)
+    end
+end
+
+ui_sub!(x::BigInt, a, b::BigInt) = (ccall((:__gmpz_ui_sub, :libgmp), Void, (mpz_t, Culong, mpz_t), &x, a, &b); x)
+ui_sub(a, b::BigInt) = ui_sub!(BigInt(), a, b)
+
+for op in (:scan1, :scan0)
+    @eval $op(a::BigInt, b) = Int(ccall($(gmpz(op)), Culong, (mpz_t, Culong), &a, b))
+end
+
+mul_si!(x::BigInt, a::BigInt, b) = (ccall((:__gmpz_mul_si, :libgmp), Void, (mpz_t, mpz_t, Clong), &x, &a, b); x)
+mul_si(a::BigInt, b) = mul_si!(BigInt(), a, b)
+mul_si!(x::BigInt, b) = mul_si!(x, x, b)
+
+for op in (:neg, :com, :sqrt, :set)
+    op! = Symbol(op, :!)
+    @eval begin
+        $op!(x::BigInt, a::BigInt) = (ccall($(gmpz(op)), Void, (mpz_t, mpz_t), &x, &a); x)
+        $op(a::BigInt) = $op!(BigInt(), a)
+    end
+    op == :set && continue # MPZ.set!(x) would make no sense
+    @eval $op!(x::BigInt) = $op!(x, x)
+end
+
+for (op, T) in ((:fac_ui, Culong), (:set_ui, Culong), (:set_si, Clong), (:set_d, Cdouble))
+    op! = Symbol(op, :!)
+    @eval begin
+        $op!(x::BigInt, a) = (ccall($(gmpz(op)), Void, (mpz_t, $T), &x, a); x)
+        $op(a) = $op!(BigInt(), a)
+    end
+end
+
+popcount(a::BigInt) = ccall((:__gmpz_popcount, :libgmp), Culong, (mpz_t,), &a) % Int
+
+mpn_popcount(d::Ptr{Limb}, s::Integer) = ccall((:__gmpn_popcount, :libgmp), Culong, (Ptr{Limb}, Csize_t), d, s) % Int
+mpn_popcount(a::BigInt) = mpn_popcount(a.d, abs(a.size))
+
+function tdiv_qr!(x::BigInt, y::BigInt, a::BigInt, b::BigInt)
+    ccall((:__gmpz_tdiv_qr, :libgmp), Void, (mpz_t, mpz_t, mpz_t, mpz_t), &x, &y, &a, &b)
+    x, y
+end
+tdiv_qr(a::BigInt, b::BigInt) = tdiv_qr!(BigInt(), BigInt(), a, b)
+
+powm!(x::BigInt, a::BigInt, b::BigInt, c::BigInt) =
+    (ccall((:__gmpz_powm, :libgmp), Void, (mpz_t, mpz_t, mpz_t, mpz_t), &x, &a, &b, &c); x)
+powm(a::BigInt, b::BigInt, c::BigInt) = powm!(BigInt(), a, b, c)
+powm!(x::BigInt, b::BigInt, c::BigInt) = powm!(x, x, b, c)
+
+function gcdext!(x::BigInt, y::BigInt, z::BigInt, a::BigInt, b::BigInt)
+    ccall((:__gmpz_gcdext, :libgmp), Void, (mpz_t, mpz_t, mpz_t, mpz_t, mpz_t),
+          &x, &y, &z, &a, &b)
+    x, y, z
+end
+gcdext(a::BigInt, b::BigInt) = gcdext!(BigInt(), BigInt(), BigInt(), a, b)
+
+cmp(a::BigInt, b::BigInt) = ccall((:__gmpz_cmp, :libgmp), Cint, (mpz_t, mpz_t), &a, &b) % Int
+cmp_si(a::BigInt, b) = ccall((:__gmpz_cmp_si, :libgmp), Cint, (mpz_t, Clong), &a, b) % Int
+cmp_ui(a::BigInt, b) = ccall((:__gmpz_cmp_ui, :libgmp), Cint, (mpz_t, Culong), &a, b) % Int
+cmp_d(a::BigInt, b) = ccall((:__gmpz_cmp_d, :libgmp), Cint, (mpz_t, Cdouble), &a, b) % Int
+
+mpn_cmp(a::Ptr{Limb}, b::Ptr{Limb}, c) = ccall((:__gmpn_cmp, :libgmp), Cint, (Ptr{Limb}, Ptr{Limb}, Clong), a, b, c)
+mpn_cmp(a::BigInt, b::BigInt, c) = mpn_cmp(a.d, b.d, c)
+
+get_str!(x, a, b::BigInt) = (ccall((:__gmpz_get_str,:libgmp), Ptr{Cchar}, (Ptr{Cchar}, Cint, mpz_t), x, a, &b); x)
+set_str!(x::BigInt, a, b) = ccall((:__gmpz_set_str, :libgmp), Cint, (mpz_t, Ptr{UInt8}, Cint), &x, a, b) % Int
+get_d(a::BigInt) = ccall((:__gmpz_get_d, :libgmp), Cdouble, (mpz_t,), &a)
+
+limbs_write!(x::BigInt, a) = ccall((:__gmpz_limbs_write, :libgmp), Ptr{Limb}, (mpz_t, Clong), &x, a)
+limbs_finish!(x::BigInt, a) = ccall((:__gmpz_limbs_finish, :libgmp), Void, (mpz_t, Clong), &x, a)
+import!(x::BigInt, a, b, c, d, e, f) =
+    ccall((:__gmpz_import, :libgmp), Void, (mpz_t, Csize_t, Cint, Csize_t, Cint, Csize_t, Ptr{Void}),
+          &x, a, b, c, d, e, f)
+
+end # module MPZ
+
+const ZERO = BigInt()
+const ONE  = BigInt()
+const _ONE = Limb[1]
+
 widen(::Type{Int128})  = BigInt
 widen(::Type{UInt128}) = BigInt
 widen(::Type{BigInt})  = BigInt
@@ -77,6 +233,8 @@ signed(x::BigInt) = x
 
 convert(::Type{BigInt}, x::BigInt) = x
 
+hastypemax(::Type{BigInt}) = false
+
 function tryparse_internal(::Type{BigInt}, s::AbstractString, startpos::Int, endpos::Int, base_::Integer, raise::Bool)
     _n = Nullable{BigInt}()
 
@@ -96,44 +254,28 @@ function tryparse_internal(::Type{BigInt}, s::AbstractString, startpos::Int, end
     if Base.containsnul(bstr)
         err = -1 # embedded NUL char (not handled correctly by GMP)
     else
-        err = ccall((:__gmpz_set_str, :libgmp),
-                    Int32, (Ptr{BigInt}, Ptr{UInt8}, Int32),
-                    &z, pointer(bstr)+(i-start(bstr)), base)
+        err = MPZ.set_str!(z, pointer(bstr)+(i-start(bstr)), base)
     end
     if err != 0
         raise && throw(ArgumentError("invalid BigInt: $(repr(bstr))"))
         return _n
     end
-    Nullable(sgn < 0 ? -z : z)
-end
-
-function convert(::Type{BigInt}, x::Union{Clong,Int32})
-    z = BigInt()
-    ccall((:__gmpz_set_si, :libgmp), Void, (Ptr{BigInt}, Clong), &z, x)
-    return z
-end
-function convert(::Type{BigInt}, x::Union{Culong,UInt32})
-    z = BigInt()
-    ccall((:__gmpz_set_ui, :libgmp), Void, (Ptr{BigInt}, Culong), &z, x)
-    return z
+    Nullable(flipsign!(z, sgn))
 end
 
+convert(::Type{BigInt}, x::Union{Clong,Int32}) = MPZ.set_si(x)
+convert(::Type{BigInt}, x::Union{Culong,UInt32}) = MPZ.set_ui(x)
 convert(::Type{BigInt}, x::Bool) = BigInt(UInt(x))
 
-
-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
+unsafe_trunc(::Type{BigInt}, x::Union{Float32,Float64}) = MPZ.set_d(x)
 
 function convert(::Type{BigInt}, x::Union{Float32,Float64})
-    isinteger(x) || throw(InexactError())
+    isinteger(x) || throw(InexactError(:convert, BigInt, x))
     unsafe_trunc(BigInt,x)
 end
 
 function trunc(::Type{BigInt}, x::Union{Float32,Float64})
-    isfinite(x) || throw(InexactError())
+    isfinite(x) || throw(InexactError(:trunc, BigInt, x))
     unsafe_trunc(BigInt,x)
 end
 
@@ -169,56 +311,60 @@ function convert(::Type{BigInt}, x::Integer)
 end
 
 
-rem(x::BigInt, ::Type{Bool}) = ((x&1)!=0)
-function rem{T<:Union{Unsigned,Signed}}(x::BigInt, ::Type{T})
+rem(x::BigInt, ::Type{Bool}) = !iszero(x) & unsafe_load(x.d) % Bool # never unsafe here
+
+rem(x::BigInt, ::Type{T}) where T<:Union{SLimbMax,ULimbMax} =
+    iszero(x) ? zero(T) : flipsign(unsafe_load(x.d) % T, x.size)
+
+function rem(x::BigInt, ::Type{T}) where T<:Union{Unsigned,Signed}
     u = zero(T)
-    for l = 1:min(abs(x.size), cld(sizeof(T),sizeof(Limb)))
-        u += (unsafe_load(x.d,l)%T) << ((sizeof(Limb)<<3)*(l-1))
+    for l = 1:min(abs(x.size), cld(sizeof(T), sizeof(Limb)))
+        u += (unsafe_load(x.d, l) % T) << ((sizeof(Limb)<<3)*(l-1))
     end
-    x.size < 0 ? -u : u
+    flipsign(u, x.size)
 end
 
-function convert{T<:Unsigned}(::Type{T}, x::BigInt)
+rem(x::Integer, ::Type{BigInt}) = convert(BigInt, x)
+
+function convert(::Type{T}, x::BigInt) where T<:Unsigned
     if sizeof(T) < sizeof(Limb)
         convert(T, convert(Limb,x))
     else
-        0 <= x.size <= cld(sizeof(T),sizeof(Limb)) || throw(InexactError())
+        0 <= x.size <= cld(sizeof(T),sizeof(Limb)) || throw(InexactError(:convert, T, x))
         x % T
     end
 end
 
-function convert{T<:Signed}(::Type{T}, x::BigInt)
+function convert(::Type{T}, x::BigInt) where T<:Signed
     n = abs(x.size)
     if sizeof(T) < sizeof(Limb)
         SLimb = typeof(Signed(one(Limb)))
         convert(T, convert(SLimb, x))
     else
-        0 <= n <= cld(sizeof(T),sizeof(Limb)) || throw(InexactError())
+        0 <= n <= cld(sizeof(T),sizeof(Limb)) || throw(InexactError(:convert, T, x))
         y = x % T
-        (x.size > 0) ⊻ (y > 0) && throw(InexactError()) # catch overflow
+        ispos(x) ⊻ (y > 0) && throw(InexactError(:convert, T, x)) # catch overflow
         y
     end
 end
 
 
-function (::Type{Float64})(n::BigInt, ::RoundingMode{:ToZero})
-    ccall((:__gmpz_get_d, :libgmp), Float64, (Ptr{BigInt},), &n)
-end
+(::Type{Float64})(n::BigInt, ::RoundingMode{:ToZero}) = MPZ.get_d(n)
 
-function (::Type{T}){T<:Union{Float16,Float32}}(n::BigInt, ::RoundingMode{:ToZero})
+function (::Type{T})(n::BigInt, ::RoundingMode{:ToZero}) where T<:Union{Float16,Float32}
     T(Float64(n,RoundToZero),RoundToZero)
 end
 
-function (::Type{T}){T<:CdoubleMax}(n::BigInt, ::RoundingMode{:Down})
+function (::Type{T})(n::BigInt, ::RoundingMode{:Down}) where T<:CdoubleMax
     x = T(n,RoundToZero)
     x > n ? prevfloat(x) : x
 end
-function (::Type{T}){T<:CdoubleMax}(n::BigInt, ::RoundingMode{:Up})
+function (::Type{T})(n::BigInt, ::RoundingMode{:Up}) where T<:CdoubleMax
     x = T(n,RoundToZero)
     x < n ? nextfloat(x) : x
 end
 
-function (::Type{T}){T<:CdoubleMax}(n::BigInt, ::RoundingMode{:Nearest})
+function (::Type{T})(n::BigInt, ::RoundingMode{:Nearest}) where T<:CdoubleMax
     x = T(n,RoundToZero)
     if maxintfloat(T) <= abs(x) < T(Inf)
         r = n-BigInt(x)
@@ -246,17 +392,16 @@ convert(::Type{Float16}, n::BigInt) = Float16(n,RoundNearest)
 
 promote_rule(::Type{BigInt}, ::Type{<:Integer}) = BigInt
 
+big(::Type{<:Integer})  = BigInt
+big(::Type{<:Rational}) = Rational{BigInt}
+
 # Binary ops
 for (fJ, fC) in ((:+, :add), (:-,:sub), (:*, :mul),
                  (:fld, :fdiv_q), (:div, :tdiv_q), (:mod, :fdiv_r), (:rem, :tdiv_r),
                  (:gcd, :gcd), (:lcm, :lcm),
                  (:&, :and), (:|, :ior), (:xor, :xor))
     @eval begin
-        function ($fJ)(x::BigInt, y::BigInt)
-            z = BigInt()
-            ccall(($(string(:__gmpz_,fC)), :libgmp), Void, (Ptr{BigInt}, Ptr{BigInt}, Ptr{BigInt}), &z, &x, &y)
-            return z
-        end
+        ($fJ)(x::BigInt, y::BigInt) = MPZ.$fC(x, y)
     end
 end
 
@@ -268,14 +413,14 @@ function invmod(x::BigInt, y::BigInt)
     if ya == 1
         return z
     end
-    if (y==0 || ccall((:__gmpz_invert, :libgmp), Cint, (Ptr{BigInt}, Ptr{BigInt}, Ptr{BigInt}), &z, &x, &ya) == 0)
-        throw(DomainError())
+    if (y==0 || MPZ.invert!(z, x, ya) == 0)
+        throw(DomainError(y))
     end
     # GMP always returns a positive inverse; we instead want to
     # normalize such that div(z, y) == 0, i.e. we want a negative z
     # when y is negative.
     if y < 0
-        z = z + y
+        MPZ.add!(z, y)
     end
     # The postcondition is: mod(z * x, y) == mod(big(1), m) && div(z, y) == 0
     return z
@@ -283,142 +428,72 @@ end
 
 # More efficient commutative operations
 for (fJ, fC) in ((:+, :add), (:*, :mul), (:&, :and), (:|, :ior), (:xor, :xor))
+    fC! = Symbol(fC, :!)
     @eval begin
-        function ($fJ)(a::BigInt, b::BigInt, c::BigInt)
-            z = BigInt()
-            ccall(($(string(:__gmpz_,fC)), :libgmp), Void, (Ptr{BigInt}, Ptr{BigInt}, Ptr{BigInt}), &z, &a, &b)
-            ccall(($(string(:__gmpz_,fC)), :libgmp), Void, (Ptr{BigInt}, Ptr{BigInt}, Ptr{BigInt}), &z, &z, &c)
-            return z
-        end
-        function ($fJ)(a::BigInt, b::BigInt, c::BigInt, d::BigInt)
-            z = BigInt()
-            ccall(($(string(:__gmpz_,fC)), :libgmp), Void, (Ptr{BigInt}, Ptr{BigInt}, Ptr{BigInt}), &z, &a, &b)
-            ccall(($(string(:__gmpz_,fC)), :libgmp), Void, (Ptr{BigInt}, Ptr{BigInt}, Ptr{BigInt}), &z, &z, &c)
-            ccall(($(string(:__gmpz_,fC)), :libgmp), Void, (Ptr{BigInt}, Ptr{BigInt}, Ptr{BigInt}), &z, &z, &d)
-            return z
-        end
-        function ($fJ)(a::BigInt, b::BigInt, c::BigInt, d::BigInt, e::BigInt)
-            z = BigInt()
-            ccall(($(string(:__gmpz_,fC)), :libgmp), Void, (Ptr{BigInt}, Ptr{BigInt}, Ptr{BigInt}), &z, &a, &b)
-            ccall(($(string(:__gmpz_,fC)), :libgmp), Void, (Ptr{BigInt}, Ptr{BigInt}, Ptr{BigInt}), &z, &z, &c)
-            ccall(($(string(:__gmpz_,fC)), :libgmp), Void, (Ptr{BigInt}, Ptr{BigInt}, Ptr{BigInt}), &z, &z, &d)
-            ccall(($(string(:__gmpz_,fC)), :libgmp), Void, (Ptr{BigInt}, Ptr{BigInt}, Ptr{BigInt}), &z, &z, &e)
-            return z
-        end
+        ($fJ)(a::BigInt, b::BigInt, c::BigInt) = MPZ.$fC!(MPZ.$fC(a, b), c)
+        ($fJ)(a::BigInt, b::BigInt, c::BigInt, d::BigInt) = MPZ.$fC!(MPZ.$fC!(MPZ.$fC(a, b), c), d)
+        ($fJ)(a::BigInt, b::BigInt, c::BigInt, d::BigInt, e::BigInt) =
+            MPZ.$fC!(MPZ.$fC!(MPZ.$fC!(MPZ.$fC(a, b), c), d), e)
     end
 end
 
 # Basic arithmetic without promotion
-function +(x::BigInt, c::CulongMax)
-    z = BigInt()
-    ccall((:__gmpz_add_ui, :libgmp), Void, (Ptr{BigInt}, Ptr{BigInt}, Culong), &z, &x, c)
-    return z
-end
++(x::BigInt, c::CulongMax) = MPZ.add_ui(x, c)
 +(c::CulongMax, x::BigInt) = x + c
 
-function -(x::BigInt, c::CulongMax)
-    z = BigInt()
-    ccall((:__gmpz_sub_ui, :libgmp), Void, (Ptr{BigInt}, Ptr{BigInt}, Culong), &z, &x, c)
-    return z
-end
-function -(c::CulongMax, x::BigInt)
-    z = BigInt()
-    ccall((:__gmpz_ui_sub, :libgmp), Void, (Ptr{BigInt}, Culong, Ptr{BigInt}), &z, c, &x)
-    return z
-end
+-(x::BigInt, c::CulongMax) = MPZ.sub_ui(x, c)
+-(c::CulongMax, x::BigInt) = MPZ.ui_sub(c, x)
+
 +(x::BigInt, c::ClongMax) = c < 0 ? -(x, -(c % Culong)) : x + convert(Culong, c)
 +(c::ClongMax, x::BigInt) = c < 0 ? -(x, -(c % Culong)) : x + convert(Culong, c)
 -(x::BigInt, c::ClongMax) = c < 0 ? +(x, -(c % Culong)) : -(x, convert(Culong, c))
 -(c::ClongMax, x::BigInt) = c < 0 ? -(x + -(c % Culong)) : -(convert(Culong, c), x)
 
-function *(x::BigInt, c::CulongMax)
-    z = BigInt()
-    ccall((:__gmpz_mul_ui, :libgmp), Void, (Ptr{BigInt}, Ptr{BigInt}, Culong), &z, &x, c)
-    return z
-end
+*(x::BigInt, c::CulongMax) = MPZ.mul_ui(x, c)
 *(c::CulongMax, x::BigInt) = x * c
-function *(x::BigInt, c::ClongMax)
-    z = BigInt()
-    ccall((:__gmpz_mul_si, :libgmp), Void, (Ptr{BigInt}, Ptr{BigInt}, Clong), &z, &x, c)
-    return z
-end
+*(x::BigInt, c::ClongMax) = MPZ.mul_si(x, c)
 *(c::ClongMax, x::BigInt) = x * c
 
 /(x::BigInt, y::Union{ClongMax,CulongMax}) = float(x)/y
 /(x::Union{ClongMax,CulongMax}, y::BigInt) = x/float(y)
 
 # unary ops
-for (fJ, fC) in ((:-, :neg), (:~, :com))
-    @eval begin
-        function ($fJ)(x::BigInt)
-            z = BigInt()
-            ccall(($(string(:__gmpz_,fC)), :libgmp), Void, (Ptr{BigInt}, Ptr{BigInt}), &z, &x)
-            return z
-        end
-    end
-end
-
-function <<(x::BigInt, c::UInt)
-    c == 0 && return x
-    z = BigInt()
-    ccall((:__gmpz_mul_2exp, :libgmp), Void, (Ptr{BigInt}, Ptr{BigInt}, Culong), &z, &x, c)
-    return z
-end
-
-function >>(x::BigInt, c::UInt)
-    c == 0 && return x
-    z = BigInt()
-    ccall((:__gmpz_fdiv_q_2exp, :libgmp), Void, (Ptr{BigInt}, Ptr{BigInt}, Culong), &z, &x, c)
-    return z
-end
+(-)(x::BigInt) = MPZ.neg(x)
+(~)(x::BigInt) = MPZ.com(x)
 
+<<(x::BigInt, c::UInt) = c == 0 ? x : MPZ.mul_2exp(x, c)
+>>(x::BigInt, c::UInt) = c == 0 ? x : MPZ.fdiv_q_2exp(x, c)
 >>>(x::BigInt, c::UInt) = x >> c
 
+trailing_zeros(x::BigInt) = MPZ.scan1(x, 0)
+trailing_ones(x::BigInt) = MPZ.scan0(x, 0)
 
-trailing_zeros(x::BigInt) = Int(ccall((:__gmpz_scan1, :libgmp), Culong, (Ptr{BigInt}, Culong), &x, 0))
-trailing_ones(x::BigInt) = Int(ccall((:__gmpz_scan0, :libgmp), Culong, (Ptr{BigInt}, Culong), &x, 0))
+count_ones(x::BigInt) = MPZ.popcount(x)
 
-count_ones(x::BigInt) = Int(ccall((:__gmpz_popcount, :libgmp), Culong, (Ptr{BigInt},), &x))
+"""
+    count_ones_abs(x::BigInt)
 
-function divrem(x::BigInt, y::BigInt)
-    z1 = BigInt()
-    z2 = BigInt()
-    ccall((:__gmpz_tdiv_qr, :libgmp), Void, (Ptr{BigInt}, Ptr{BigInt}, Ptr{BigInt}, Ptr{BigInt}), &z1, &z2, &x, &y)
-    z1, z2
-end
+Number of ones in the binary representation of abs(x).
+"""
+count_ones_abs(x::BigInt) = iszero(x) ? 0 : MPZ.mpn_popcount(x)
 
-function cmp(x::BigInt, y::BigInt)
-    ccall((:__gmpz_cmp, :libgmp), Int32, (Ptr{BigInt}, Ptr{BigInt}), &x, &y)
-end
-function cmp(x::BigInt, y::ClongMax)
-    ccall((:__gmpz_cmp_si, :libgmp), Int32, (Ptr{BigInt}, Clong), &x, y)
-end
-function cmp(x::BigInt, y::CulongMax)
-    ccall((:__gmpz_cmp_ui, :libgmp), Int32, (Ptr{BigInt}, Culong), &x, y)
-end
-cmp(x::BigInt, y::Integer) = cmp(x,big(y))
-cmp(x::Integer, y::BigInt) = -cmp(y,x)
+divrem(x::BigInt, y::BigInt) = MPZ.tdiv_qr(x, y)
 
-function cmp(x::BigInt, y::CdoubleMax)
-    isnan(y) && throw(DomainError())
-    ccall((:__gmpz_cmp_d, :libgmp), Int32, (Ptr{BigInt}, Cdouble), &x, y)
-end
-cmp(x::CdoubleMax, y::BigInt) = -cmp(y,x)
+cmp(x::BigInt, y::BigInt) = MPZ.cmp(x, y)
+cmp(x::BigInt, y::ClongMax) = MPZ.cmp_si(x, y)
+cmp(x::BigInt, y::CulongMax) = MPZ.cmp_ui(x, y)
+cmp(x::BigInt, y::Integer) = cmp(x, big(y))
+cmp(x::Integer, y::BigInt) = -cmp(y, x)
 
-function isqrt(x::BigInt)
-    z = BigInt()
-    ccall((:__gmpz_sqrt, :libgmp), Void, (Ptr{BigInt}, Ptr{BigInt}), &z, &x)
-    return z
-end
+cmp(x::BigInt, y::CdoubleMax) = isnan(y) ? throw(DomainError(y, "`y` cannot be NaN.")) : MPZ.cmp_d(x, y)
+cmp(x::CdoubleMax, y::BigInt) = -cmp(y, x)
 
-function ^(x::BigInt, y::Culong)
-    z = BigInt()
-    ccall((:__gmpz_pow_ui, :libgmp), Void, (Ptr{BigInt}, Ptr{BigInt}, Culong), &z, &x, y)
-    return z
-end
+isqrt(x::BigInt) = MPZ.sqrt(x)
+
+^(x::BigInt, y::Culong) = MPZ.pow_ui(x, y)
 
 function bigint_pow(x::BigInt, y::Integer)
-    if y<0; throw(DomainError()); end
+    if y<0; throw(DomainError(y, "`y` cannot be negative.")); end
     if x== 1; return x; end
     if x==-1; return isodd(y) ? x : -x; end
     if y>typemax(Culong)
@@ -443,29 +518,20 @@ end
 ^(x::Integer, y::BigInt ) = bigint_pow(BigInt(x), y)
 ^(x::Bool   , y::BigInt ) = Base.power_by_squaring(x, y)
 
-# override default inlining of x^2 and x^3 etc.
-^{p}(x::BigInt, ::Type{Val{p}}) = x^Culong(p)
-
 function powermod(x::BigInt, p::BigInt, m::BigInt)
-    r = BigInt()
-    ccall((:__gmpz_powm, :libgmp), Void,
-          (Ptr{BigInt}, Ptr{BigInt}, Ptr{BigInt}, Ptr{BigInt}),
-          &r, &x, &p, &m)
-    return m < 0 && r > 0 ? r + m : r # choose sign conistent with mod(x^p, m)
+    r = MPZ.powm(x, p, m)
+    return m < 0 && r > 0 ? MPZ.add!(r, m) : r # choose sign consistent with mod(x^p, m)
 end
 
 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)
-        return a < 0 ? (-a,-one(BigInt),zero(BigInt)) : (a,one(BigInt),zero(BigInt))
+    if iszero(b) # shortcut this to ensure consistent results with gcdx(a,b)
+        return a < 0 ? (-a,-ONE,b) : (a,one(BigInt),b)
+        # we don't return the globals ONE and ZERO in case the user wants to
+        # mutate the result
     end
-    g = BigInt()
-    s = BigInt()
-    t = BigInt()
-    ccall((:__gmpz_gcdext, :libgmp), Void,
-        (Ptr{BigInt}, Ptr{BigInt}, Ptr{BigInt}, Ptr{BigInt}, Ptr{BigInt}),
-        &g, &s, &t, &a, &b)
+    g, s, t = MPZ.gcdext(a, b)
     if t == 0
         # work around a difference in some versions of GMP
         if a == b
@@ -477,28 +543,17 @@ function gcdx(a::BigInt, b::BigInt)
     g, s, t
 end
 
-function sum(arr::AbstractArray{BigInt})
-    n = BigInt(0)
-    for i in arr
-        ccall((:__gmpz_add, :libgmp), Void,
-            (Ptr{BigInt}, Ptr{BigInt}, Ptr{BigInt}),
-            &n, &n, &i)
-    end
-    return n
-end
+sum(arr::AbstractArray{BigInt}) = foldl(MPZ.add!, BigInt(0), arr)
+# note: a similar implementation for `prod` won't be efficient:
+# 1) the time complexity of the allocations is negligible compared to the multiplications
+# 2) assuming arr contains similarly sized BigInts, the multiplications are much more
+# performant when doing e.g. ((a1*a2)*(a2*a3))*(...) rather than a1*(a2*(a3*(...))),
+# which is exactly what the default implementation of `prod` does, via mapreduce
+# (which maybe could be slightly optimized for BigInt)
 
-function factorial(x::BigInt)
-    x.size < 0 && return BigInt(0)
-    z = BigInt()
-    ccall((:__gmpz_fac_ui, :libgmp), Void, (Ptr{BigInt}, Culong), &z, x)
-    return z
-end
+factorial(x::BigInt) = isneg(x) ? BigInt(0) : MPZ.fac_ui(x)
 
-function binomial(n::BigInt, k::UInt)
-    z = BigInt()
-    ccall((:__gmpz_bin_ui, :libgmp), Void, (Ptr{BigInt}, Ptr{BigInt}, Culong), &z, &n, k)
-    return z
-end
+binomial(n::BigInt, k::UInt) = MPZ.bin_ui(n, k)
 binomial(n::BigInt, k::Integer) = k < 0 ? BigInt(0) : binomial(n, UInt(k))
 
 ==(x::BigInt, y::BigInt) = cmp(x,y) == 0
@@ -506,7 +561,8 @@ binomial(n::BigInt, k::Integer) = k < 0 ? BigInt(0) : binomial(n, UInt(k))
 ==(i::Integer, x::BigInt) = cmp(x,i) == 0
 ==(x::BigInt, f::CdoubleMax) = isnan(f) ? false : cmp(x,f) == 0
 ==(f::CdoubleMax, x::BigInt) = isnan(f) ? false : cmp(x,f) == 0
-iszero(x::BigInt) = x == Clong(0)
+iszero(x::BigInt) = x.size == 0
+isone(x::BigInt) = x == Culong(1)
 
 <=(x::BigInt, y::BigInt) = cmp(x,y) <= 0
 <=(x::BigInt, i::Integer) = cmp(x,i) <= 0
@@ -519,6 +575,12 @@ iszero(x::BigInt) = x == Clong(0)
 <(i::Integer, x::BigInt) = cmp(x,i) > 0
 <(x::BigInt, f::CdoubleMax) = isnan(f) ? false : cmp(x,f) < 0
 <(f::CdoubleMax, x::BigInt) = isnan(f) ? false : cmp(x,f) > 0
+isneg(x::BigInt) = x.size < 0
+ispos(x::BigInt) = x.size > 0
+
+signbit(x::BigInt) = isneg(x)
+flipsign!(x::BigInt, y::Integer) = (signbit(y) && (x.size = -x.size); x)
+flipsign( x::BigInt, y::Integer) = signbit(y) ? -x : x
 
 string(x::BigInt) = dec(x)
 show(io::IO, x::BigInt) = print(io, string(x))
@@ -533,36 +595,30 @@ oct(n::BigInt, pad::Int) = base( 8, n, pad)
 dec(n::BigInt, pad::Int) = base(10, n, pad)
 hex(n::BigInt, pad::Int) = base(16, n, pad)
 
-function base(b::Integer, n::BigInt)
+function base(b::Integer, n::BigInt, pad::Integer=1)
+    b < 0 && return base(Int(b), n, pad, (b>0) & (n.size<0))
     2 <= b <= 62 || throw(ArgumentError("base must be 2 ≤ base ≤ 62, got $b"))
-    nd = ndigits(n, b)
-    str = Base._string_n(n < 0 ? nd+1 : nd)
-    ccall((:__gmpz_get_str,:libgmp), Ptr{UInt8}, (Ptr{UInt8}, Cint, Ptr{BigInt}), str, b, &n)
-    return str
-end
-
-function base(b::Integer, n::BigInt, pad::Integer)
-    s = base(b, n)
-    buf = IOBuffer()
-    if n < 0
-        s = s[2:end]
-        write(buf, '-')
-    end
-    for i in 1:pad-sizeof(s) # `s` is known to be ASCII, and `length` is slower
-        write(buf, '0')
+    iszero(n) && pad < 1 && return ""
+    nd1 = ndigits(n, b)
+    nd  = max(nd1, pad)
+    sv  = Base.StringVector(nd + isneg(n))
+    MPZ.get_str!(pointer(sv) + nd - nd1, b, n)
+    @inbounds for i = (1:nd-nd1) + isneg(n)
+        sv[i] = '0' % UInt8
     end
-    write(buf, s)
-    String(buf)
+    isneg(n) && (sv[1] = '-' % UInt8)
+    String(sv)
 end
 
-function ndigits0z(x::BigInt, b::Integer=10)
-    b < 2 && throw(DomainError())
+function ndigits0zpb(x::BigInt, b::Integer)
+    b < 2 && throw(DomainError(b, "`b` cannot be less than 2."))
+    x.size == 0 && return 0 # for consistency with other ndigits0z methods
     if ispow2(b) && 2 <= b <= 62 # GMP assumes b is in this range
-        Int(ccall((:__gmpz_sizeinbase,:libgmp), Csize_t, (Ptr{BigInt}, Cint), &x, b))
+        MPZ.sizeinbase(x, b)
     else
         # non-base 2 mpz_sizeinbase might return an answer 1 too big
         # use property that log(b, x) < ndigits(x, b) <= log(b, x) + 1
-        n = Int(ccall((:__gmpz_sizeinbase,:libgmp), Csize_t, (Ptr{BigInt}, Cint), &x, 2))
+        n = MPZ.sizeinbase(x, 2)
         lb = log2(b) # assumed accurate to <1ulp (true for openlibm)
         q,r = divrem(n,lb)
         iq = Int(q)
@@ -576,10 +632,11 @@ function ndigits0z(x::BigInt, b::Integer=10)
         end
     end
 end
-ndigits(x::BigInt, b::Integer=10) = x.size == 0 ? 1 : ndigits0z(x,b)
 
-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))
+# below, ONE is always left-shifted by at least one digit, so a new BigInt is
+# allocated, which can be safely mutated
+prevpow2(x::BigInt) = -2 <= x <= 2 ? x : flipsign!(ONE << (ndigits(x, 2) - 1), x)
+nextpow2(x::BigInt) = count_ones_abs(x) <= 1 ? x : flipsign!(ONE << ndigits(x, 2), x)
 
 Base.checked_abs(x::BigInt) = abs(x)
 Base.checked_neg(x::BigInt) = -x
@@ -599,8 +656,7 @@ function Base.deepcopy_internal(x::BigInt, stackdict::ObjectIdDict)
     if haskey(stackdict, x)
         return stackdict[x]
     end
-    y = BigInt()
-    ccall((:__gmpz_set,:libgmp), Void, (Ptr{BigInt}, Ptr{BigInt}), &y, &x)
+    y = MPZ.set(x)
     stackdict[x] = y
     return y
 end
diff --git a/base/grisu/bignum.jl b/base/grisu/bignum.jl
index 2182602163537b..2f1d67ce292ed4 100644
--- a/base/grisu/bignum.jl
+++ b/base/grisu/bignum.jl
@@ -1,5 +1,5 @@
 # This file is a part of Julia, but is derived from
-# https://github.com/floitsch/double-conversion which has the following license
+# https://github.com/google/double-conversion which has the following license
 #
 # Copyright 2006-2014, the V8 project authors. All rights reserved.
 # Redistribution and use in source and binary forms, with or without
@@ -79,7 +79,7 @@ function generateshortestdigits!(num,den,minus,plus,is_even,buffer)
         in_delta_room_minus = is_even ?
             Bignums.lessequal(num,minus) : Bignums.less(num,minus)
         in_delta_room_plus = is_even ?
-            Bignums.pluscompare(num,plus,den) >= 0: Bignums.pluscompare(num,plus,den) > 0
+            Bignums.pluscompare(num,plus,den) >= 0 : Bignums.pluscompare(num,plus,den) > 0
         if !in_delta_room_minus && !in_delta_room_plus
             Bignums.times10!(num)
             Bignums.times10!(minus)
diff --git a/base/grisu/bignums.jl b/base/grisu/bignums.jl
index fe50bf35a12ef1..7398028b812024 100644
--- a/base/grisu/bignums.jl
+++ b/base/grisu/bignums.jl
@@ -1,5 +1,5 @@
 # This file is a part of Julia, but is derived from
-# https://github.com/floitsch/double-conversion which has the following license
+# https://github.com/google/double-conversion which has the following license
 #
 # Copyright 2006-2014, the V8 project authors. All rights reserved.
 # Redistribution and use in source and binary forms, with or without
@@ -47,14 +47,14 @@ const kBigitSize = 28
 const kBigitMask = Chunk((1 << kBigitSize) - 1)
 # Every instance allocates kBigitLength chunks on the stack. Bignums cannot
 # grow. There are no checks if the stack-allocated space is sufficient.
-const kBigitCapacity = div(kMaxSignificantBits,kBigitSize)
+const kBigitCapacity = div(kMaxSignificantBits, kBigitSize)
 
 mutable struct Bignum
-    bigits::Array{UInt32,1}
+    bigits::Vector{UInt32}
     used_digits::Int32
     exponent::Int32
     function Bignum()
-        bigits = Array{UInt32}(kBigitCapacity)
+        bigits = Vector{UInt32}(kBigitCapacity)
         @inbounds for i = 1:kBigitCapacity
             bigits[i] = 0
         end
diff --git a/base/grisu/fastfixed.jl b/base/grisu/fastfixed.jl
index f1eda5058ad5a0..014806b6531ea5 100644
--- a/base/grisu/fastfixed.jl
+++ b/base/grisu/fastfixed.jl
@@ -1,5 +1,5 @@
 # This file is a part of Julia, but is derived from
-# https://github.com/floitsch/double-conversion which has the following license
+# https://github.com/google/double-conversion which has the following license
 #
 # Copyright 2006-2014, the V8 project authors. All rights reserved.
 # Redistribution and use in source and binary forms, with or without
diff --git a/base/grisu/fastprecision.jl b/base/grisu/fastprecision.jl
index 4167557f034fc0..3d737b1d13eb6f 100644
--- a/base/grisu/fastprecision.jl
+++ b/base/grisu/fastprecision.jl
@@ -1,5 +1,5 @@
 # This file is a part of Julia, but is derived from
-# https://github.com/floitsch/double-conversion which has the following license
+# https://github.com/google/double-conversion which has the following license
 #
 # Copyright 2006-2014, the V8 project authors. All rights reserved.
 # Redistribution and use in source and binary forms, with or without
@@ -87,7 +87,7 @@ function digitgen(w,buffer,requested_digits=1000)
     return r, kappa, len
 end
 
-function fastprecision(v, requested_digits, buffer = Array{UInt8}(100))
+function fastprecision(v, requested_digits, buffer = Vector{UInt8}(100))
     f = normalize(Float64(v))
     ten_mk_min_exp = kMinExp - (f.e + FloatSignificandSize)
     ten_mk_max_exp = kMaxExp - (f.e + FloatSignificandSize)
diff --git a/base/grisu/fastshortest.jl b/base/grisu/fastshortest.jl
index 519850e009abc8..c7b70dea84acc0 100644
--- a/base/grisu/fastshortest.jl
+++ b/base/grisu/fastshortest.jl
@@ -1,5 +1,5 @@
 # This file is a part of Julia, but is derived from
-# https://github.com/floitsch/double-conversion which has the following license
+# https://github.com/google/double-conversion which has the following license
 #
 # Copyright 2006-2014, the V8 project authors. All rights reserved.
 # Redistribution and use in source and binary forms, with or without
@@ -55,7 +55,7 @@ const SmallPowersOfTen = [
         1000000, 10000000, 100000000, 1000000000]
 
 function bigpowten(n,n_bits)
-    guess = (n_bits + 1) * 1233 >> 12
+    guess = ((n_bits + 1) * 1233) >> 12
     guess += 1
     i = SmallPowersOfTen[guess+1]
     return n < i ? (SmallPowersOfTen[guess], guess-1) : (i,guess)
@@ -102,7 +102,7 @@ function digitgen(low,w,high,buffer)
     end
 end
 
-function fastshortest(v, buffer = Array{UInt8}(17))
+function fastshortest(v, buffer = Vector{UInt8}(17))
     f = normalize(Float64(v))
     bound_minus, bound_plus = normalizedbound(v)
     ten_mk_min_exp = kMinExp - (f.e + FloatSignificandSize)
diff --git a/base/grisu/float.jl b/base/grisu/float.jl
index c545b8c10d216a..a92b94ccd4b51b 100644
--- a/base/grisu/float.jl
+++ b/base/grisu/float.jl
@@ -1,5 +1,5 @@
 # This file is a part of Julia, but is derived from
-# https://github.com/floitsch/double-conversion which has the following license
+# https://github.com/google/double-conversion which has the following license
 #
 # Copyright 2006-2014, the V8 project authors. All rights reserved.
 # Redistribution and use in source and binary forms, with or without
@@ -28,6 +28,8 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+import Base: -, *
+
 struct Float
     s::UInt64
     e::Int32
@@ -104,16 +106,16 @@ SignificandMask(::Type{Float16}) = 0x03ff
 HiddenBit(::Type{Float16}) = 0x0400
 uint_t(d::Float16) = reinterpret(UInt16,d)
 
-function _exponent{T<:AbstractFloat}(d::T)
+function _exponent(d::T) where T<:AbstractFloat
   isdenormal(d) && return DenormalExponent(T)
   biased_e::Int32 = Int32((uint_t(d) & ExponentMask(T)) >> PhysicalSignificandSize(T))
   return Int32(biased_e - ExponentBias(T))
 end
-function _significand{T<:AbstractFloat}(d::T)
+function _significand(d::T) where T<:AbstractFloat
   s = uint_t(d) & SignificandMask(T)
   return !isdenormal(d) ? s + HiddenBit(T) : s
 end
-isdenormal{T<:AbstractFloat}(d::T) = (uint_t(d) & ExponentMask(T)) == 0
+isdenormal(d::T) where {T<:AbstractFloat} = (uint_t(d) & ExponentMask(T)) == 0
 
 function normalizedbound(f::AbstractFloat)
     v = Float(_significand(f),_exponent(f))
@@ -125,7 +127,7 @@ function normalizedbound(f::AbstractFloat)
     end
     return Float(m_minus.s << (m_minus.e - m_plus.e), m_plus.e), m_plus
 end
-function lowerboundaryiscloser{T<:AbstractFloat}(f::T)
+function lowerboundaryiscloser(f::T) where T<:AbstractFloat
     physical_significand_is_zero = (uint_t(f) & SignificandMask(T)) == 0
     return physical_significand_is_zero && (_exponent(f) != DenormalExponent(T))
 end
diff --git a/base/grisu/grisu.jl b/base/grisu/grisu.jl
index 9a806f1300a725..04743722335165 100644
--- a/base/grisu/grisu.jl
+++ b/base/grisu/grisu.jl
@@ -1,9 +1,7 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module Grisu
 
-importall ..Base.Operators
-
 export print_shortest
 export DIGITS, grisu
 
@@ -11,14 +9,14 @@ const SHORTEST = 1
 const FIXED = 2
 const PRECISION = 3
 
-const DIGITS = Array{UInt8}(309+17)
+const DIGITS = Vector{UInt8}(309+17)
 
-include("grisu/float.jl")
-include("grisu/fastshortest.jl")
-include("grisu/fastprecision.jl")
-include("grisu/fastfixed.jl")
-include("grisu/bignums.jl")
-include("grisu/bignum.jl")
+include(joinpath("grisu", "float.jl"))
+include(joinpath("grisu", "fastshortest.jl"))
+include(joinpath("grisu", "fastprecision.jl"))
+include(joinpath("grisu", "fastfixed.jl"))
+include(joinpath("grisu", "bignums.jl"))
+include(joinpath("grisu", "bignum.jl"))
 
 const BIGNUMS = [Bignums.Bignum(),Bignums.Bignum(),Bignums.Bignum(),Bignums.Bignum()]
 
@@ -184,6 +182,12 @@ function _print_shortest(io::IO, x::AbstractFloat, dot::Bool, mode, n::Int)
     nothing
 end
 
+"""
+    print_shortest(io::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(io::IO, x::AbstractFloat, dot::Bool) = _print_shortest(io, x, dot, SHORTEST, 0)
 print_shortest(io::IO, x::Union{AbstractFloat,Integer}) = print_shortest(io, float(x), false)
 
diff --git a/base/hashing.jl b/base/hashing.jl
index 8e83b21d8ecf36..331d6c214ea3e8 100644
--- a/base/hashing.jl
+++ b/base/hashing.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## hashing a single value ##
 
@@ -7,7 +7,7 @@ hash(w::WeakRef, h::UInt) = hash(w.value, h)
 
 ## hashing general objects ##
 
-hash(x::ANY, h::UInt) = 3*object_id(x) - h
+hash(@nospecialize(x), h::UInt) = hash_uint(3h - object_id(x))
 
 ## core data hashing functions ##
 
@@ -55,7 +55,6 @@ end
 
 ## symbol & expression hashing ##
 
-hash(x::Symbol, h::UInt) = 3*object_id(x) - h
 if UInt === UInt64
     hash(x::Expr, h::UInt) = hash(x.args, hash(x.head, h + 0x83c7900696d26dc6))
 else
diff --git a/base/hashing2.jl b/base/hashing2.jl
index 96bd4ed55e56ba..37a401ac974f0f 100644
--- a/base/hashing2.jl
+++ b/base/hashing2.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## efficient value-based hashing of integers ##
 
diff --git a/base/i18n.jl b/base/i18n.jl
index 66f650b90d8083..d4488cc1ce832e 100644
--- a/base/i18n.jl
+++ b/base/i18n.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module I18n
 
diff --git a/base/indices.jl b/base/indices.jl
index e01b6699592b0a..e55a64dd385973 100644
--- a/base/indices.jl
+++ b/base/indices.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 Dims{N} = NTuple{N,Int}
 DimsInteger{N} = NTuple{N,Integer}
@@ -237,7 +237,7 @@ unsafe_indices(S::Slice) = (S.indices,)
 indices1(S::Slice) = S.indices
 first(S::Slice) = first(S.indices)
 last(S::Slice) = last(S.indices)
-errmsg(A) = error("size not supported for arrays with indices $(indices(A)); see http://docs.julialang.org/en/latest/devdocs/offset-arrays/")
+errmsg(A) = error("size not supported for arrays with indices $(indices(A)); see https://docs.julialang.org/en/latest/devdocs/offset-arrays/")
 size(S::Slice) = first(S.indices) == 1 ? (length(S.indices),) : errmsg(S)
 length(S::Slice) = first(S.indices) == 1 ? length(S.indices) : errmsg(S)
 unsafe_length(S::Slice) = first(S.indices) == 1 ? unsafe_length(S.indices) : errmsg(S)
diff --git a/base/inference.jl b/base/inference.jl
index 724e6777158084..9aa2c69c81e9fc 100644
--- a/base/inference.jl
+++ b/base/inference.jl
@@ -1,18 +1,25 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 import Core: _apply, svec, apply_type, Builtin, IntrinsicFunction, MethodInstance
 
 #### parameters limiting potentially-infinite types ####
 const MAX_TYPEUNION_LEN = 3
 const MAX_TYPE_DEPTH = 8
+const TUPLE_COMPLEXITY_LIMIT_DEPTH = 3
+
+const MAX_INLINE_CONST_SIZE = 256
 
 struct InferenceParams
     world::UInt
 
     # optimization
     inlining::Bool
+    inline_cost_threshold::Int  # number of CPU cycles beyond which it's not worth inlining
+    inline_nonconcrete_penalty::Int # penalty for dynamic dispatch
+    inline_tupleret_bonus::Int  # extra willingness for non-isbits tuple return types
 
     # parameters limiting potentially-infinite types (configurable)
+    MAX_METHODS::Int
     MAX_TUPLETYPE_LEN::Int
     MAX_TUPLE_DEPTH::Int
     MAX_TUPLE_SPLAT::Int
@@ -22,18 +29,21 @@ struct InferenceParams
     # reasonable defaults
     function InferenceParams(world::UInt;
                     inlining::Bool = inlining_enabled(),
+                    inline_cost_threshold::Int = 100,
+                    inline_nonconcrete_penalty::Int = 1000,
+                    inline_tupleret_bonus::Int = 400,
+                    max_methods::Int = 4,
                     tupletype_len::Int = 15,
                     tuple_depth::Int = 4,
                     tuple_splat::Int = 16,
                     union_splitting::Int = 4,
                     apply_union_enum::Int = 8)
-        return new(world, inlining, tupletype_len,
-            tuple_depth, tuple_splat, union_splitting, apply_union_enum)
+        return new(world, inlining, inline_cost_threshold, inline_nonconcrete_penalty,
+                   inline_tupleret_bonus, max_methods, tupletype_len,
+                   tuple_depth, tuple_splat, union_splitting, apply_union_enum)
     end
 end
 
-const UNION_SPLIT_MISMATCH_ERROR = false
-
 # alloc_elim_pass! relies on `Slot_AssignedOnce | Slot_UsedUndef` being
 # SSA. This should be true now but can break if we start to track conditional
 # constants. e.g.
@@ -58,13 +68,15 @@ const VarTable = Array{Any,1}
 mutable struct VarState
     typ
     undef::Bool
-    VarState(typ::ANY, undef::Bool) = new(typ, undef)
+    VarState(@nospecialize(typ), undef::Bool) = new(typ, undef)
 end
 
 # The type of a value might be constant
 struct Const
     val
-    Const(v::ANY) = new(v)
+    actual::Bool  # if true, we obtained `val` by actually calling a @pure function
+    Const(@nospecialize(v)) = new(v, false)
+    Const(@nospecialize(v), a::Bool) = new(v, a)
 end
 
 # The type of a value might be Bool,
@@ -77,9 +89,9 @@ mutable struct Conditional
     vtype
     elsetype
     function Conditional(
-                var::ANY,
-                vtype::ANY,
-                nottype::ANY)
+                @nospecialize(var),
+                @nospecialize(vtype),
+                @nospecialize(nottype))
         return new(var, vtype, nottype)
     end
 end
@@ -93,7 +105,7 @@ struct PartialTypeVar
     PartialTypeVar(tv::TypeVar, lb_certain::Bool, ub_certain::Bool) = new(tv, lb_certain, ub_certain)
 end
 
-function rewrap(t::ANY, u::ANY)
+function rewrap(@nospecialize(t), @nospecialize(u))
     isa(t, Const) && return t
     isa(t, Conditional) && return t
     return rewrap_unionall(t, u)
@@ -118,7 +130,7 @@ mutable struct InferenceState
     bestguess #::Type
     # current active instruction pointers
     ip::IntSet
-    pc´´::Int
+    pc´´::LineNum
     nstmts::Int
     # current exception handler info
     cur_hand #::Tuple{LineNum, Tuple{LineNum, ...}}
@@ -126,15 +138,13 @@ mutable struct InferenceState
     n_handlers::Int
     # ssavalue sparsity and restart info
     ssavalue_uses::Vector{IntSet}
-    ssavalue_init::Vector{Any}
-    # call-graph edges connecting from a caller to a callee (and back)
-    # we shouldn't need to iterate edges very often, so we use it to optimize the lookup from edge -> linenum
-    # whereas backedges is optimized for iteration
-    edges::ObjectIdDict # a Dict{InferenceState, Vector{LineNum}}
-    backedges::Vector{Tuple{InferenceState, Vector{LineNum}}}
-    # iteration fixed-point detection
-    fixedpoint::Bool
-    inworkq::Bool
+    ssavalue_defs::Vector{LineNum}
+    vararg_type_container #::Type
+
+    backedges::Vector{Tuple{InferenceState, LineNum}} # call-graph backedges connecting from callee to caller
+    callers_in_cycle::Vector{InferenceState}
+    parent::Union{Void, InferenceState}
+
     const_api::Bool
     const_ret::Bool
 
@@ -144,12 +154,14 @@ mutable struct InferenceState
 
     inferred::Bool
 
+    dont_work_on_me::Bool
+
     # src is assumed to be a newly-allocated CodeInfo, that can be modified in-place to contain intermediate results
     function InferenceState(linfo::MethodInstance, src::CodeInfo,
                             optimize::Bool, cached::Bool, params::InferenceParams)
         code = src.code::Array{Any,1}
         nl = label_counter(code) + 1
-        toplevel = !isdefined(linfo, :def)
+        toplevel = !isa(linfo.def, Method)
 
         if !toplevel && isempty(linfo.sparam_vals) && !isempty(linfo.def.sparam_syms)
             # linfo is unspecialized
@@ -164,7 +176,8 @@ mutable struct InferenceState
             sp = linfo.sparam_vals
         end
 
-        src.ssavaluetypes = Any[ NF for i = 1:(src.ssavaluetypes::Int) ]
+        nssavalues = src.ssavaluetypes::Int
+        src.ssavaluetypes = Any[ NF for i = 1:nssavalues ]
 
         n = length(code)
         s_edges = Any[ () for i = 1:n ]
@@ -178,6 +191,7 @@ mutable struct InferenceState
         atypes = unwrap_unionall(linfo.specTypes)
         nargs::Int = toplevel ? 0 : linfo.def.nargs
         la = nargs
+        vararg_type_container = nothing
         if la > 0
             if linfo.def.isva
                 if atypes == Tuple
@@ -186,12 +200,12 @@ mutable struct InferenceState
                     end
                     vararg_type = Tuple
                 else
-                    vararg_type = limit_tuple_depth(params, tupletype_tail(atypes, la))
-                    vararg_type = tuple_tfunc(vararg_type) # returns a Const object, if applicable
+                    vararg_type_container = limit_tuple_depth(params, tupletype_tail(atypes, la))
+                    vararg_type = tuple_tfunc(vararg_type_container) # returns a Const object, if applicable
                     vararg_type = rewrap(vararg_type, linfo.specTypes)
                 end
                 s_types[1][la] = VarState(vararg_type, false)
-                src.slottypes[la] = widenconst(vararg_type)
+                src.slottypes[la] = vararg_type
                 la -= 1
             end
         end
@@ -215,23 +229,25 @@ mutable struct InferenceState
                 if isa(atyp, DataType) && isdefined(atyp, :instance)
                     # replace singleton types with their equivalent Const object
                     atyp = Const(atyp.instance)
+                elseif isconstType(atyp)
+                    atype = Const(atyp.parameters[1])
                 else
                     atyp = rewrap_unionall(atyp, linfo.specTypes)
                 end
                 i == laty && (lastatype = atyp)
                 s_types[1][i] = VarState(atyp, false)
-                src.slottypes[i] = widenconst(atyp)
+                src.slottypes[i] = atyp
             end
             for i = (atail + 1):la
                 s_types[1][i] = VarState(lastatype, false)
-                src.slottypes[i] = widenconst(lastatype)
+                src.slottypes[i] = lastatype
             end
         else
             @assert la == 0 # wrong number of arguments
         end
 
-        ssavalue_uses = find_ssavalue_uses(code)
-        ssavalue_init = copy(src.ssavaluetypes::Vector{Any})
+        ssavalue_uses = find_ssavalue_uses(code, nssavalues)
+        ssavalue_defs = find_ssavalue_defs(code, nssavalues)
 
         # exception handlers
         cur_hand = ()
@@ -245,7 +261,7 @@ mutable struct InferenceState
             meth = linfo.def
             inmodule = meth.module
         else
-            inmodule = current_module() # toplevel thunks are inferred in the current module
+            inmodule = linfo.def::Module
         end
 
         if cached && !toplevel
@@ -261,59 +277,72 @@ mutable struct InferenceState
             nargs, s_types, s_edges,
             Union{}, W, 1, n,
             cur_hand, handler_at, n_handlers,
-            ssavalue_uses, ssavalue_init,
-            ObjectIdDict(), # Dict{InferenceState, Vector{LineNum}}(),
-            Vector{Tuple{InferenceState, Vector{LineNum}}}(),
-            false, false, false, false, optimize, cached, false)
-        push!(active, frame)
-        nactive[] += 1
+            ssavalue_uses, ssavalue_defs, vararg_type_container,
+            Vector{Tuple{InferenceState,LineNum}}(), # backedges
+            Vector{InferenceState}(), # callers_in_cycle
+            #=parent=#nothing,
+            false, false, optimize, cached, false, false)
         return frame
     end
 end
 
-# create copies of the CodeInfo definition, and any fields that type-inference might modify
-# TODO: post-inference see if we can swap back to the original arrays
-function get_source(li::MethodInstance)
-    src = ccall(:jl_copy_code_info, Ref{CodeInfo}, (Any,), li.def.source)
-    if isa(src.code, Array{UInt8,1})
-        src.code = ccall(:jl_uncompress_ast, Any, (Any, Any), li.def, src.code)
+function InferenceState(linfo::MethodInstance,
+                        optimize::Bool, cached::Bool, params::InferenceParams)
+    # prepare an InferenceState object for inferring lambda
+    # create copies of the CodeInfo definition, and any fields that type-inference might modify
+    m = linfo.def::Method
+    if isdefined(m, :generator)
+        try
+            # user code might throw errors – ignore them
+            src = get_staged(linfo)
+        catch
+            return nothing
+        end
     else
-        src.code = copy_exprargs(src.code)
+        # TODO: post-inference see if we can swap back to the original arrays?
+        if isa(m.source, Array{UInt8,1})
+            src = ccall(:jl_uncompress_ast, Any, (Any, Any), m, m.source)
+        else
+            src = ccall(:jl_copy_code_info, Ref{CodeInfo}, (Any,), m.source)
+            src.code = copy_exprargs(src.code)
+            src.slotnames = copy(src.slotnames)
+            src.slotflags = copy(src.slotflags)
+        end
     end
-    src.slotnames = copy(src.slotnames)
-    src.slotflags = copy(src.slotflags)
-    return src
+    return InferenceState(linfo, src, optimize, cached, params)
 end
 
 function get_staged(li::MethodInstance)
-    src = ccall(:jl_code_for_staged, Any, (Any,), li)::CodeInfo
-    if isa(src.code, Array{UInt8,1})
-        src.code = ccall(:jl_uncompress_ast, Any, (Any, Any), li.def, src.code)
-    end
-    return src
+    return ccall(:jl_code_for_staged, Any, (Any,), li)::CodeInfo
 end
 
 
-#### current global inference state ####
+#### debugging utilities ####
+
+function print_callstack(sv::InferenceState)
+    while sv !== nothing
+        println(sv.linfo)
+        for cycle in sv.callers_in_cycle
+            println(' ', cycle.linfo)
+        end
+        sv = sv.parent
+    end
+end
 
-const active = Vector{Any}() # set of all InferenceState objects being processed
-const nactive = Array{Int}(())
-nactive[] = 0
-const workq = Vector{InferenceState}() # set of InferenceState objects that can make immediate progress
 
 #### helper functions ####
 
 @inline slot_id(s) = isa(s, SlotNumber) ? (s::SlotNumber).id : (s::TypedSlot).id # using a function to ensure we can infer this
 
 # avoid cycle due to over-specializing `any` when used by inference
-function _any(f::ANY, a)
+function _any(@nospecialize(f), a)
     for x in a
         f(x) && return true
     end
     return false
 end
 
-function contains_is(itr, x::ANY)
+function contains_is(itr, @nospecialize(x))
     for y in itr
         if y === x
             return true
@@ -322,13 +351,15 @@ function contains_is(itr, x::ANY)
     return false
 end
 
+anymap(f::Function, a::Array{Any,1}) = Any[ f(a[i]) for i=1:length(a) ]
+
 _topmod(sv::InferenceState) = _topmod(sv.mod)
 _topmod(m::Module) = ccall(:jl_base_relative_to, Any, (Any,), m)::Module
 
-function istopfunction(topmod, f::ANY, sym)
-    if isdefined(Main, :Base) && isdefined(Main.Base, sym) && f === getfield(Main.Base, sym)
+function istopfunction(topmod, @nospecialize(f), sym)
+    if isdefined(Main, :Base) && isdefined(Main.Base, sym) && isconst(Main.Base, sym) && f === getfield(Main.Base, sym)
         return true
-    elseif isdefined(topmod, sym) && f === getfield(topmod, sym)
+    elseif isdefined(topmod, sym) && isconst(topmod, sym) && f === getfield(topmod, sym)
         return true
     end
     return false
@@ -338,65 +369,83 @@ isknownlength(t::DataType) = !isvatuple(t) ||
     (length(t.parameters) > 0 && isa(unwrap_unionall(t.parameters[end]).parameters[2],Int))
 
 # t[n:end]
-tupletype_tail(t::ANY, n) = Tuple{t.parameters[n:end]...}
+tupletype_tail(@nospecialize(t), n) = Tuple{t.parameters[n:end]...}
+
+function is_specializable_vararg_slot(arg, sv::InferenceState)
+    return (isa(arg, Slot) && slot_id(arg) == sv.nargs &&
+            isa(sv.vararg_type_container, DataType))
+end
 
 
 #### type-functions for builtins / intrinsics ####
 
 const _Type_name = Type.body.name
-isType(t::ANY) = isa(t, DataType) && (t::DataType).name === _Type_name
+isType(@nospecialize t) = isa(t, DataType) && (t::DataType).name === _Type_name
 
 # true if Type is inlineable as constant (is a singleton)
-isconstType(t::ANY) = isType(t) && (isconcrete(t.parameters[1]) || t.parameters[1] === Union{})
+isconstType(@nospecialize t) = isType(t) && (isconcrete(t.parameters[1]) || t.parameters[1] === Union{})
+
+iskindtype(@nospecialize t) = (t === DataType || t === UnionAll || t === Union || t === typeof(Bottom))
 
 const IInf = typemax(Int) # integer infinity
-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,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::ANY)
+const n_ifunc = reinterpret(Int32, arraylen) + 1
+const t_ifunc = Array{Tuple{Int, Int, Any}, 1}(n_ifunc)
+const t_ifunc_cost = Array{Int, 1}(n_ifunc)
+const t_ffunc_key = Array{Any, 1}(0)
+const t_ffunc_val = Array{Tuple{Int, Int, Any}, 1}(0)
+const t_ffunc_cost = Array{Int, 1}(0)
+function add_tfunc(f::IntrinsicFunction, minarg::Int, maxarg::Int, @nospecialize(tfunc), cost::Int)
+    idx = reinterpret(Int32, f) + 1
+    t_ifunc[idx] = (minarg, maxarg, tfunc)
+    t_ifunc_cost[idx] = cost
+end
+# TODO: add @nospecialize on `f` and declare its type as `Builtin` when that's supported
+function add_tfunc(f::Function, minarg::Int, maxarg::Int, @nospecialize(tfunc), cost::Int)
     push!(t_ffunc_key, f)
     push!(t_ffunc_val, (minarg, maxarg, tfunc))
+    push!(t_ffunc_cost, cost)
 end
 
-add_tfunc(throw, 1, 1, (x::ANY) -> Bottom)
+add_tfunc(throw, 1, 1, (@nospecialize(x)) -> Bottom, 0)
 
 # the inverse of typeof_tfunc
-function instanceof_tfunc(t::ANY)
-    # TODO improve
-    if t === Bottom
-        return t
+# returns (type, isexact)
+# if isexact is false, the actual runtime type may (will) be a subtype of t
+function instanceof_tfunc(@nospecialize(t))
+    if t === Bottom || t === typeof(Bottom)
+        return Bottom, true
     elseif isa(t, Const)
         if isa(t.val, Type)
-            return t.val
+            return t.val, true
         end
     elseif isType(t)
-        return t.parameters[1]
-    elseif isa(t,UnionAll)
+        tp = t.parameters[1]
+        return tp, !has_free_typevars(tp)
+    elseif isa(t, UnionAll)
         t′ = unwrap_unionall(t)
-        return rewrap_unionall(instanceof_tfunc(t′), t)
-    elseif isa(t,Union)
-        return Union{instanceof_tfunc(t.a), instanceof_tfunc(t.b)}
-    end
-    return Any
-end
-bitcast_tfunc(t::ANY, x::ANY) = instanceof_tfunc(t)
-math_tfunc(x::ANY) = widenconst(x)
-math_tfunc(x::ANY, y::ANY) = widenconst(x)
-math_tfunc(x::ANY, y::ANY, z::ANY) = widenconst(x)
-fptoui_tfunc(t::ANY, x::ANY) = bitcast_tfunc(t, x)
-fptosi_tfunc(t::ANY, x::ANY) = bitcast_tfunc(t, x)
-function fptoui_tfunc(x::ANY)
+        t′′, isexact = instanceof_tfunc(t′)
+        return rewrap_unionall(t′′, t), isexact
+    elseif isa(t, Union)
+        ta, isexact_a = instanceof_tfunc(t.a)
+        tb, isexact_b = instanceof_tfunc(t.b)
+        return Union{ta, tb}, false # at runtime, will be exactly one of these
+    end
+    return Any, false
+end
+bitcast_tfunc(@nospecialize(t), @nospecialize(x)) = instanceof_tfunc(t)[1]
+math_tfunc(@nospecialize(x)) = widenconst(x)
+math_tfunc(@nospecialize(x), @nospecialize(y)) = widenconst(x)
+math_tfunc(@nospecialize(x), @nospecialize(y), @nospecialize(z)) = widenconst(x)
+fptoui_tfunc(@nospecialize(t), @nospecialize(x)) = bitcast_tfunc(t, x)
+fptosi_tfunc(@nospecialize(t), @nospecialize(x)) = bitcast_tfunc(t, x)
+function fptoui_tfunc(@nospecialize(x))
     T = widenconst(x)
     T === Float64 && return UInt64
     T === Float32 && return UInt32
     T === Float16 && return UInt16
     return Any
 end
-function fptosi_tfunc(x::ANY)
+function fptosi_tfunc(@nospecialize(x))
     T = widenconst(x)
     T === Float64 && return Int64
     T === Float32 && return Int32
@@ -405,107 +454,101 @@ function fptosi_tfunc(x::ANY)
 end
 
     ## conversion ##
-add_tfunc(bitcast, 2, 2, bitcast_tfunc)
-add_tfunc(sext_int, 2, 2, bitcast_tfunc)
-add_tfunc(zext_int, 2, 2, bitcast_tfunc)
-add_tfunc(trunc_int, 2, 2, bitcast_tfunc)
-add_tfunc(fptoui, 1, 2, fptoui_tfunc)
-add_tfunc(fptosi, 1, 2, fptosi_tfunc)
-add_tfunc(uitofp, 2, 2, bitcast_tfunc)
-add_tfunc(sitofp, 2, 2, bitcast_tfunc)
-add_tfunc(fptrunc, 2, 2, bitcast_tfunc)
-add_tfunc(fpext, 2, 2, bitcast_tfunc)
-    ## checked conversion ##
-add_tfunc(checked_trunc_sint, 2, 2, bitcast_tfunc)
-add_tfunc(checked_trunc_uint, 2, 2, bitcast_tfunc)
-add_tfunc(check_top_bit, 1, 1, math_tfunc)
+add_tfunc(bitcast, 2, 2, bitcast_tfunc, 1)
+add_tfunc(sext_int, 2, 2, bitcast_tfunc, 1)
+add_tfunc(zext_int, 2, 2, bitcast_tfunc, 1)
+add_tfunc(trunc_int, 2, 2, bitcast_tfunc, 1)
+add_tfunc(fptoui, 1, 2, fptoui_tfunc, 1)
+add_tfunc(fptosi, 1, 2, fptosi_tfunc, 1)
+add_tfunc(uitofp, 2, 2, bitcast_tfunc, 1)
+add_tfunc(sitofp, 2, 2, bitcast_tfunc, 1)
+add_tfunc(fptrunc, 2, 2, bitcast_tfunc, 1)
+add_tfunc(fpext, 2, 2, bitcast_tfunc, 1)
     ## arithmetic ##
-add_tfunc(neg_int, 1, 1, math_tfunc)
-add_tfunc(add_int, 2, 2, math_tfunc)
-add_tfunc(sub_int, 2, 2, math_tfunc)
-add_tfunc(mul_int, 2, 2, math_tfunc)
-add_tfunc(sdiv_int, 2, 2, math_tfunc)
-add_tfunc(udiv_int, 2, 2, math_tfunc)
-add_tfunc(srem_int, 2, 2, math_tfunc)
-add_tfunc(urem_int, 2, 2, math_tfunc)
-add_tfunc(neg_float, 1, 1, math_tfunc)
-add_tfunc(add_float, 2, 2, math_tfunc)
-add_tfunc(sub_float, 2, 2, math_tfunc)
-add_tfunc(mul_float, 2, 2, math_tfunc)
-add_tfunc(div_float, 2, 2, math_tfunc)
-add_tfunc(rem_float, 2, 2, math_tfunc)
-add_tfunc(fma_float, 3, 3, math_tfunc)
-add_tfunc(muladd_float, 3, 3, math_tfunc)
+add_tfunc(neg_int, 1, 1, math_tfunc, 1)
+add_tfunc(add_int, 2, 2, math_tfunc, 1)
+add_tfunc(sub_int, 2, 2, math_tfunc, 1)
+add_tfunc(mul_int, 2, 2, math_tfunc, 4)
+add_tfunc(sdiv_int, 2, 2, math_tfunc, 30)
+add_tfunc(udiv_int, 2, 2, math_tfunc, 30)
+add_tfunc(srem_int, 2, 2, math_tfunc, 30)
+add_tfunc(urem_int, 2, 2, math_tfunc, 30)
+add_tfunc(neg_float, 1, 1, math_tfunc, 1)
+add_tfunc(add_float, 2, 2, math_tfunc, 1)
+add_tfunc(sub_float, 2, 2, math_tfunc, 1)
+add_tfunc(mul_float, 2, 2, math_tfunc, 4)
+add_tfunc(div_float, 2, 2, math_tfunc, 20)
+add_tfunc(rem_float, 2, 2, math_tfunc, 20)
+add_tfunc(fma_float, 3, 3, math_tfunc, 5)
+add_tfunc(muladd_float, 3, 3, math_tfunc, 5)
     ## fast arithmetic ##
-add_tfunc(neg_float_fast, 1, 1, math_tfunc)
-add_tfunc(add_float_fast, 2, 2, math_tfunc)
-add_tfunc(sub_float_fast, 2, 2, math_tfunc)
-add_tfunc(mul_float_fast, 2, 2, math_tfunc)
-add_tfunc(div_float_fast, 2, 2, math_tfunc)
-add_tfunc(rem_float_fast, 2, 2, math_tfunc)
+add_tfunc(neg_float_fast, 1, 1, math_tfunc, 1)
+add_tfunc(add_float_fast, 2, 2, math_tfunc, 1)
+add_tfunc(sub_float_fast, 2, 2, math_tfunc, 1)
+add_tfunc(mul_float_fast, 2, 2, math_tfunc, 2)
+add_tfunc(div_float_fast, 2, 2, math_tfunc, 10)
+add_tfunc(rem_float_fast, 2, 2, math_tfunc, 10)
     ## bitwise operators ##
-add_tfunc(and_int, 2, 2, math_tfunc)
-add_tfunc(or_int, 2, 2, math_tfunc)
-add_tfunc(xor_int, 2, 2, math_tfunc)
-add_tfunc(not_int, 1, 1, math_tfunc)
-add_tfunc(shl_int, 2, 2, math_tfunc)
-add_tfunc(lshr_int, 2, 2, math_tfunc)
-add_tfunc(ashr_int, 2, 2, math_tfunc)
-add_tfunc(bswap_int, 1, 1, math_tfunc)
-add_tfunc(ctpop_int, 1, 1, math_tfunc)
-add_tfunc(ctlz_int, 1, 1, math_tfunc)
-add_tfunc(cttz_int, 1, 1, math_tfunc)
-add_tfunc(checked_sdiv_int, 2, 2, math_tfunc)
-add_tfunc(checked_udiv_int, 2, 2, math_tfunc)
-add_tfunc(checked_srem_int, 2, 2, math_tfunc)
-add_tfunc(checked_urem_int, 2, 2, math_tfunc)
+add_tfunc(and_int, 2, 2, math_tfunc, 1)
+add_tfunc(or_int, 2, 2, math_tfunc, 1)
+add_tfunc(xor_int, 2, 2, math_tfunc, 1)
+add_tfunc(not_int, 1, 1, math_tfunc, 1)
+add_tfunc(shl_int, 2, 2, math_tfunc, 1)
+add_tfunc(lshr_int, 2, 2, math_tfunc, 1)
+add_tfunc(ashr_int, 2, 2, math_tfunc, 1)
+add_tfunc(bswap_int, 1, 1, math_tfunc, 1)
+add_tfunc(ctpop_int, 1, 1, math_tfunc, 1)
+add_tfunc(ctlz_int, 1, 1, math_tfunc, 1)
+add_tfunc(cttz_int, 1, 1, math_tfunc, 1)
+add_tfunc(checked_sdiv_int, 2, 2, math_tfunc, 40)
+add_tfunc(checked_udiv_int, 2, 2, math_tfunc, 40)
+add_tfunc(checked_srem_int, 2, 2, math_tfunc, 40)
+add_tfunc(checked_urem_int, 2, 2, math_tfunc, 40)
     ## functions ##
-add_tfunc(abs_float, 1, 1, math_tfunc)
-add_tfunc(copysign_float, 2, 2, math_tfunc)
-add_tfunc(flipsign_int, 2, 2, math_tfunc)
-add_tfunc(ceil_llvm, 1, 1, math_tfunc)
-add_tfunc(floor_llvm, 1, 1, math_tfunc)
-add_tfunc(trunc_llvm, 1, 1, math_tfunc)
-add_tfunc(rint_llvm, 1, 1, math_tfunc)
-add_tfunc(sqrt_llvm, 1, 1, math_tfunc)
-add_tfunc(powi_llvm, 2, 2, math_tfunc)
-add_tfunc(sqrt_llvm_fast, 1, 1, math_tfunc)
+add_tfunc(abs_float, 1, 1, math_tfunc, 2)
+add_tfunc(copysign_float, 2, 2, math_tfunc, 2)
+add_tfunc(flipsign_int, 2, 2, math_tfunc, 1)
+add_tfunc(ceil_llvm, 1, 1, math_tfunc, 10)
+add_tfunc(floor_llvm, 1, 1, math_tfunc, 10)
+add_tfunc(trunc_llvm, 1, 1, math_tfunc, 10)
+add_tfunc(rint_llvm, 1, 1, math_tfunc, 10)
+add_tfunc(sqrt_llvm, 1, 1, math_tfunc, 20)
     ## same-type comparisons ##
-cmp_tfunc(x::ANY, y::ANY) = Bool
-add_tfunc(eq_int, 2, 2, cmp_tfunc)
-add_tfunc(ne_int, 2, 2, cmp_tfunc)
-add_tfunc(slt_int, 2, 2, cmp_tfunc)
-add_tfunc(ult_int, 2, 2, cmp_tfunc)
-add_tfunc(sle_int, 2, 2, cmp_tfunc)
-add_tfunc(ule_int, 2, 2, cmp_tfunc)
-add_tfunc(eq_float, 2, 2, cmp_tfunc)
-add_tfunc(ne_float, 2, 2, cmp_tfunc)
-add_tfunc(lt_float, 2, 2, cmp_tfunc)
-add_tfunc(le_float, 2, 2, cmp_tfunc)
-add_tfunc(fpiseq, 2, 2, cmp_tfunc)
-add_tfunc(fpislt, 2, 2, cmp_tfunc)
-add_tfunc(eq_float_fast, 2, 2, cmp_tfunc)
-add_tfunc(ne_float_fast, 2, 2, cmp_tfunc)
-add_tfunc(lt_float_fast, 2, 2, cmp_tfunc)
-add_tfunc(le_float_fast, 2, 2, cmp_tfunc)
+cmp_tfunc(@nospecialize(x), @nospecialize(y)) = Bool
+add_tfunc(eq_int, 2, 2, cmp_tfunc, 1)
+add_tfunc(ne_int, 2, 2, cmp_tfunc, 1)
+add_tfunc(slt_int, 2, 2, cmp_tfunc, 1)
+add_tfunc(ult_int, 2, 2, cmp_tfunc, 1)
+add_tfunc(sle_int, 2, 2, cmp_tfunc, 1)
+add_tfunc(ule_int, 2, 2, cmp_tfunc, 1)
+add_tfunc(eq_float, 2, 2, cmp_tfunc, 2)
+add_tfunc(ne_float, 2, 2, cmp_tfunc, 2)
+add_tfunc(lt_float, 2, 2, cmp_tfunc, 2)
+add_tfunc(le_float, 2, 2, cmp_tfunc, 2)
+add_tfunc(fpiseq, 2, 2, cmp_tfunc, 1)
+add_tfunc(fpislt, 2, 2, cmp_tfunc, 1)
+add_tfunc(eq_float_fast, 2, 2, cmp_tfunc, 1)
+add_tfunc(ne_float_fast, 2, 2, cmp_tfunc, 1)
+add_tfunc(lt_float_fast, 2, 2, cmp_tfunc, 1)
+add_tfunc(le_float_fast, 2, 2, cmp_tfunc, 1)
 
     ## checked arithmetic ##
-chk_tfunc(x::ANY, y::ANY) = Tuple{widenconst(x), Bool}
-add_tfunc(checked_sadd_int, 2, 2, chk_tfunc)
-add_tfunc(checked_uadd_int, 2, 2, chk_tfunc)
-add_tfunc(checked_ssub_int, 2, 2, chk_tfunc)
-add_tfunc(checked_usub_int, 2, 2, chk_tfunc)
-add_tfunc(checked_smul_int, 2, 2, chk_tfunc)
-add_tfunc(checked_umul_int, 2, 2, chk_tfunc)
+chk_tfunc(@nospecialize(x), @nospecialize(y)) = Tuple{widenconst(x), Bool}
+add_tfunc(checked_sadd_int, 2, 2, chk_tfunc, 10)
+add_tfunc(checked_uadd_int, 2, 2, chk_tfunc, 10)
+add_tfunc(checked_ssub_int, 2, 2, chk_tfunc, 10)
+add_tfunc(checked_usub_int, 2, 2, chk_tfunc, 10)
+add_tfunc(checked_smul_int, 2, 2, chk_tfunc, 10)
+add_tfunc(checked_umul_int, 2, 2, chk_tfunc, 10)
     ## other, misc intrinsics ##
 add_tfunc(Core.Intrinsics.llvmcall, 3, IInf,
-    (fptr::ANY, rt::ANY, at::ANY, a...) -> instanceof_tfunc(rt))
-cglobal_tfunc(fptr::ANY) = Ptr{Void}
-cglobal_tfunc(fptr::ANY, t::ANY) = (isType(t) ? Ptr{t.parameters[1]} : Ptr)
-cglobal_tfunc(fptr::ANY, t::Const) = (isa(t.val, Type) ? Ptr{t.val} : Ptr)
-add_tfunc(Core.Intrinsics.cglobal, 1, 2, cglobal_tfunc)
+          (@nospecialize(fptr), @nospecialize(rt), @nospecialize(at), a...) -> instanceof_tfunc(rt)[1], 10)
+cglobal_tfunc(@nospecialize(fptr)) = Ptr{Void}
+cglobal_tfunc(@nospecialize(fptr), @nospecialize(t)) = (isType(t) ? Ptr{t.parameters[1]} : Ptr)
+cglobal_tfunc(@nospecialize(fptr), t::Const) = (isa(t.val, Type) ? Ptr{t.val} : Ptr)
+add_tfunc(Core.Intrinsics.cglobal, 1, 2, cglobal_tfunc, 5)
 add_tfunc(Core.Intrinsics.select_value, 3, 3,
-    function (cnd::ANY, x::ANY, y::ANY)
+    function (@nospecialize(cnd), @nospecialize(x), @nospecialize(y))
         if isa(cnd, Const)
             if cnd.val === true
                 return x
@@ -517,9 +560,9 @@ add_tfunc(Core.Intrinsics.select_value, 3, 3,
         end
         (Bool ⊑ cnd) || return Bottom
         return tmerge(x, y)
-    end)
+    end, 1)
 add_tfunc(===, 2, 2,
-    function (x::ANY, y::ANY)
+    function (@nospecialize(x), @nospecialize(y))
         if isa(x, Const) && isa(y, Const)
             return Const(x.val === y.val)
         elseif typeintersect(widenconst(x), widenconst(y)) === Bottom
@@ -536,26 +579,86 @@ add_tfunc(===, 2, 2,
             x.val === true && return y
         end
         return Bool
-    end)
-add_tfunc(isdefined, 1, IInf, (args...)->Bool)
-add_tfunc(Core.sizeof, 1, 1, x->Int)
+    end, 1)
+function isdefined_tfunc(args...)
+    arg1 = args[1]
+    if isa(arg1, Const)
+        a1 = typeof(arg1.val)
+    else
+        a1 = widenconst(arg1)
+    end
+    if isType(a1)
+        return Bool
+    end
+    a1 = unwrap_unionall(a1)
+    if isa(a1, DataType) && !a1.abstract
+        if a1 <: Array # TODO update when deprecation is removed
+        elseif a1 === Module
+            length(args) == 2 || return Bottom
+            sym = args[2]
+            Symbol <: widenconst(sym) || return Bottom
+            if isa(sym, Const) && isa(sym.val, Symbol) && isa(arg1, Const) && isdefined(arg1.val, sym.val)
+                return Const(true)
+            end
+        elseif length(args) == 2 && isa(args[2], Const)
+            val = args[2].val
+            idx::Int = 0
+            if isa(val, Symbol)
+                idx = fieldindex(a1, val, false)
+            elseif isa(val, Int)
+                idx = val
+            else
+                return Bottom
+            end
+            if 1 <= idx <= a1.ninitialized
+                return Const(true)
+            elseif idx <= 0 || (!isvatuple(a1) && idx > fieldcount(a1))
+                return Const(false)
+            elseif !isvatuple(a1) && isbits(fieldtype(a1, idx))
+                return Const(true)
+            elseif isa(arg1, Const) && isimmutable((arg1::Const).val)
+                return Const(isdefined((arg1::Const).val, idx))
+            end
+        end
+    end
+    Bool
+end
+# TODO change IInf to 2 when deprecation is removed
+add_tfunc(isdefined, 1, IInf, isdefined_tfunc, 1)
+_const_sizeof(@nospecialize(x)) = try
+    # Constant Vector does not have constant size
+    isa(x, Vector) && return Int
+    return Const(Core.sizeof(x))
+catch
+    return Int
+end
+add_tfunc(Core.sizeof, 1, 1,
+          function (@nospecialize(x),)
+              isa(x, Const) && return _const_sizeof(x.val)
+              isa(x, Conditional) && return _const_sizeof(Bool)
+              isconstType(x) && return _const_sizeof(x.parameters[1])
+              x !== DataType && isconcrete(x) && return _const_sizeof(x)
+              return Int
+          end, 0)
+old_nfields(@nospecialize x) = length((isa(x,DataType) ? x : typeof(x)).types)
 add_tfunc(nfields, 1, 1,
-    function (x::ANY)
-        isa(x,Const) && return Const(nfields(x.val))
-        isa(x,Conditional) && return Const(nfields(Bool))
+    function (@nospecialize(x),)
+        isa(x,Const) && return Const(old_nfields(x.val))
+        isa(x,Conditional) && return Const(old_nfields(Bool))
         if isType(x)
-            isconcrete(x.parameters[1]) && return Const(nfields(x.parameters[1]))
-        elseif isa(x,DataType) && !x.abstract && !(x.name === Tuple.name && isvatuple(x))
+            # TODO: remove with deprecation in builtins.c for nfields(::Type)
+            isconcrete(x.parameters[1]) && return Const(old_nfields(x.parameters[1]))
+        elseif isa(x,DataType) && !x.abstract && !(x.name === Tuple.name && isvatuple(x)) && x !== DataType
             return Const(length(x.types))
         end
         return Int
-    end)
-add_tfunc(Core._expr, 1, IInf, (args...)->Expr)
-add_tfunc(applicable, 1, IInf, (f::ANY, args...)->Bool)
-add_tfunc(Core.Intrinsics.arraylen, 1, 1, x->Int)
-add_tfunc(arraysize, 2, 2, (a::ANY, d::ANY)->Int)
+    end, 0)
+add_tfunc(Core._expr, 1, IInf, (args...)->Expr, 100)
+add_tfunc(applicable, 1, IInf, (@nospecialize(f), args...)->Bool, 100)
+add_tfunc(Core.Intrinsics.arraylen, 1, 1, x->Int, 4)
+add_tfunc(arraysize, 2, 2, (@nospecialize(a), @nospecialize(d))->Int, 4)
 add_tfunc(pointerref, 3, 3,
-          function (a::ANY, i::ANY, align::ANY)
+          function (@nospecialize(a), @nospecialize(i), @nospecialize(align))
               a = widenconst(a)
               if a <: Ptr
                   if isa(a,DataType) && isa(a.parameters[1],Type)
@@ -568,10 +671,10 @@ add_tfunc(pointerref, 3, 3,
                   end
               end
               return Any
-          end)
-add_tfunc(pointerset, 4, 4, (a::ANY, v::ANY, i::ANY, align::ANY) -> a)
+          end, 4)
+add_tfunc(pointerset, 4, 4, (@nospecialize(a), @nospecialize(v), @nospecialize(i), @nospecialize(align)) -> a, 5)
 
-function typeof_tfunc(t::ANY)
+function typeof_tfunc(@nospecialize(t))
     if isa(t, Const)
         return Const(typeof(t.val))
     elseif isa(t, Conditional)
@@ -597,14 +700,16 @@ function typeof_tfunc(t::ANY)
         return Union{a, b}
     elseif isa(t, TypeVar) && !(Any <: t.ub)
         return typeof_tfunc(t.ub)
+    elseif isa(t, UnionAll)
+        return rewrap_unionall(widenconst(typeof_tfunc(unwrap_unionall(t))), t)
     else
         return DataType # typeof(anything)::DataType
     end
 end
-add_tfunc(typeof, 1, 1, typeof_tfunc)
+add_tfunc(typeof, 1, 1, typeof_tfunc, 0)
 add_tfunc(typeassert, 2, 2,
-          function (v::ANY, t::ANY)
-              t = instanceof_tfunc(t)
+          function (@nospecialize(v), @nospecialize(t))
+              t, isexact = instanceof_tfunc(t)
               t === Any && return v
               if isa(v, Const)
                   if !has_free_typevars(t) && !isa(v.val, t)
@@ -618,33 +723,47 @@ add_tfunc(typeassert, 2, 2,
                   return v
               end
               return typeintersect(v, t)
-          end)
+          end, 4)
 add_tfunc(isa, 2, 2,
-          function (v::ANY, t::ANY)
-              t = instanceof_tfunc(t)
-              if t !== Any && !has_free_typevars(t)
-                  if v ⊑ t
-                      return Const(true)
-                  elseif isa(v, Const) || isa(v, Conditional) || isconcrete(v)
+          function (@nospecialize(v), @nospecialize(t))
+              t, isexact = instanceof_tfunc(t)
+              if !has_free_typevars(t)
+                  if t === Bottom
+                      return Const(false)
+                  elseif v ⊑ t
+                      if isexact
+                          return Const(true)
+                      end
+                  elseif isa(v, Const) || isa(v, Conditional) || (isconcrete(v) && !iskindtype(v))
                       return Const(false)
+                  elseif isexact && typeintersect(v, t) === Bottom
+                      if !iskindtype(v) #= subtyping currently intentionally answers this query incorrectly for kinds =#
+                          return Const(false)
+                      end
                   end
               end
               # TODO: handle non-concrete t by testing against lower and upper bounds
               return Bool
-          end)
-add_tfunc(issubtype, 2, 2,
-          function (a::ANY, b::ANY)
-              if (isa(a,Const) || isType(a)) && (isa(b,Const) || isType(b))
-                  a = instanceof_tfunc(a)
-                  b = instanceof_tfunc(b)
-                  if !has_free_typevars(a) && !has_free_typevars(b)
-                      return Const(issubtype(a, b))
+          end, 0)
+add_tfunc(<:, 2, 2,
+          function (@nospecialize(a), @nospecialize(b))
+              a, isexact_a = instanceof_tfunc(a)
+              b, isexact_b = instanceof_tfunc(b)
+              if !has_free_typevars(a) && !has_free_typevars(b)
+                  if a <: b
+                      if isexact_b || a === Bottom
+                          return Const(true)
+                      end
+                  else
+                      if isexact_a || (b !== Bottom && typeintersect(a, b) === Union{})
+                          return Const(false)
+                      end
                   end
               end
               return Bool
-          end)
+          end, 0)
 
-function type_depth(t::ANY)
+function type_depth(@nospecialize(t))
     if t === Bottom
         return 0
     elseif isa(t, Union)
@@ -655,24 +774,31 @@ function type_depth(t::ANY)
         if t.var.ub === Any && t.var.lb === Bottom
             return type_depth(t.body)
         end
-        return max(type_depth(t.var.ub)+1, type_depth(t.var.lb)+1, type_depth(t.body))
+        return max(type_depth(t.var.ub) + 1, type_depth(t.var.lb) + 1, type_depth(t.body))
     end
     return 0
 end
 
-function limit_type_depth(t::ANY, d::Int)
+function limit_type_depth(@nospecialize(t), d::Int)
     r = limit_type_depth(t, d, true, TypeVar[])
     @assert !isa(t, Type) || t <: r
     return r
 end
 
-function limit_type_depth(t::ANY, d::Int, cov::Bool, vars::Vector{TypeVar}=TypeVar[])
-    if isa(t,Union)
-        if d > MAX_TYPE_DEPTH
-            return Any
+function limit_type_depth(@nospecialize(t), d::Int, cov::Bool, vars::Vector{TypeVar}=TypeVar[])
+    if isa(t, Union)
+        if d < 0
+            if cov
+                return Any
+            else
+                var = TypeVar(:_)
+                push!(vars, var)
+                return var
+            end
         end
-        return Union{map(x->limit_type_depth(x, d+1, cov, vars), (t.a,t.b))...}
-    elseif isa(t,UnionAll)
+        return Union{limit_type_depth(t.a, d - 1, cov, vars),
+                     limit_type_depth(t.b, d - 1, cov, vars)}
+    elseif isa(t, UnionAll)
         v = t.var
         if v.ub === Any
             if v.lb === Bottom
@@ -680,9 +806,9 @@ function limit_type_depth(t::ANY, d::Int, cov::Bool, vars::Vector{TypeVar}=TypeV
             end
             ub = Any
         else
-            ub = limit_type_depth(v.ub, d+1, true)
+            ub = limit_type_depth(v.ub, d - 1, true)
         end
-        if v.lb === Bottom || type_depth(v.lb) > MAX_TYPE_DEPTH
+        if v.lb === Bottom || type_depth(v.lb) > d
             # note: lower bounds need to be widened by making them lower
             lb = Bottom
         else
@@ -695,14 +821,25 @@ function limit_type_depth(t::ANY, d::Int, cov::Bool, vars::Vector{TypeVar}=TypeV
     end
     P = t.parameters
     isempty(P) && return t
-    if d > MAX_TYPE_DEPTH
-        cov && return t.name.wrapper
-        var = TypeVar(:_, t.name.wrapper)
+    if d < 0
+        if isvarargtype(t)
+            # never replace Vararg with non-Vararg
+            return Vararg{limit_type_depth(P[1], d, cov, vars), P[2]}
+        end
+        widert = t.name.wrapper
+        if !(t <: widert)
+            # This can happen when a typevar has bounds too wide for its context, e.g.
+            # `Complex{T} where T` is not a subtype of `Complex`. In that case widen even
+            # faster to something safe to ensure the result is a supertype of the input.
+            widert = Any
+        end
+        cov && return widert
+        var = TypeVar(:_, widert)
         push!(vars, var)
         return var
     end
     stillcov = cov && (t.name === Tuple.name)
-    Q = map(x->limit_type_depth(x, d+1, stillcov, vars), P)
+    Q = map(x -> limit_type_depth(x, d - 1, stillcov, vars), P)
     R = t.name.wrapper{Q...}
     if cov && !stillcov
         for var in vars
@@ -712,6 +849,253 @@ function limit_type_depth(t::ANY, d::Int, cov::Bool, vars::Vector{TypeVar}=TypeV
     return R
 end
 
+# limit the complexity of type `t` to be simpler than the comparison type `compare`
+# no new values may be introduced, so the parameter `source` encodes the set of all values already present
+function limit_type_size(@nospecialize(t), @nospecialize(compare), @nospecialize(source))
+    source = svec(unwrap_unionall(compare), unwrap_unionall(source))
+    source[1] === source[2] && (source = svec(source[1]))
+    type_more_complex(t, compare, source, TUPLE_COMPLEXITY_LIMIT_DEPTH) || return t
+    r = _limit_type_size(t, compare, source)
+    @assert t <: r
+    #@assert r === _limit_type_size(r, t, source) # this monotonicity constraint is slightly stronger than actually required,
+      # since we only actually need to demonstrate that repeated application would reaches a fixed point,
+      #not that it is already at the fixed point
+    return r
+end
+
+sym_isless(a::Symbol, b::Symbol) = ccall(:strcmp, Int32, (Ptr{UInt8}, Ptr{UInt8}), a, b) < 0
+
+function type_more_complex(@nospecialize(t), @nospecialize(c), sources::SimpleVector, tupledepth::Int)
+    # detect cases where the comparison is trivial
+    if t === c
+        return false
+    elseif t === Union{}
+        return false # Bottom is as simple as they come
+    elseif isa(t, DataType) && isempty(t.parameters)
+        return false # fastpath: unparameterized types are always finite
+    elseif tupledepth > 0 && isa(unwrap_unionall(t), DataType) && isa(c, Type) && c !== Union{} && c <: t
+        return false # t is already wider than the comparison in the type lattice
+    elseif tupledepth > 0 && is_derived_type_from_any(unwrap_unionall(t), sources)
+        return false # t isn't something new
+    end
+    # peel off wrappers
+    if isa(c, UnionAll)
+        # allow wrapping type with fewer UnionAlls than comparison if in a covariant context
+        if !isa(t, UnionAll) && tupledepth == 0
+            return true
+        end
+        t = unwrap_unionall(t)
+        c = unwrap_unionall(c)
+    end
+    # rules for various comparison types
+    if isa(c, TypeVar)
+        if isa(t, TypeVar)
+            return !(t.lb === Union{} || t.lb === c.lb) || # simplify lb towards Union{}
+                   type_more_complex(t.ub, c.ub, sources, tupledepth)
+        end
+        c.lb === Union{} || return true
+        return type_more_complex(t, c.ub, sources, max(tupledepth, 1)) # allow replacing a TypeVar with a concrete value
+    elseif isa(c, Union)
+        if isa(t, Union)
+            return type_more_complex(t.a, c.a, sources, tupledepth) ||
+                   type_more_complex(t.b, c.b, sources, tupledepth)
+        end
+        return type_more_complex(t, c.a, sources, tupledepth) &&
+               type_more_complex(t, c.b, sources, tupledepth)
+    elseif isa(t, Int) && isa(c, Int)
+        return t !== 1 # alternatively, could use !(0 <= t < c)
+    end
+    # base case for data types
+    if isa(t, DataType)
+        tP = t.parameters
+        if isa(c, DataType) && t.name === c.name
+            cP = c.parameters
+            length(cP) < length(tP) && return true
+            ntail = length(cP) - length(tP) # assume parameters were dropped from the tuple head
+            # allow creating variation within a nested tuple, but only so deep
+            if t.name === Tuple.name && tupledepth > 0
+                tupledepth -= 1
+            elseif !isvarargtype(t)
+                tupledepth = 0
+            end
+            isgenerator = (t.name.name === :Generator && t.name.module === _topmod(t.name.module))
+            for i = 1:length(tP)
+                tPi = tP[i]
+                cPi = cP[i + ntail]
+                if isgenerator
+                    let tPi = unwrap_unionall(tPi),
+                        cPi = unwrap_unionall(cPi)
+                        if isa(tPi, DataType) && isa(cPi, DataType) &&
+                                !tPi.abstract && !cPi.abstract &&
+                                sym_isless(cPi.name.name, tPi.name.name)
+                            # allow collect on (anonymous) Generators to nest, provided that their functions are appropriately ordered
+                            # TODO: is there a better way?
+                            continue
+                        end
+                    end
+                end
+                type_more_complex(tPi, cPi, sources, tupledepth) && return true
+            end
+            return false
+        end
+        if isType(t) # allow taking typeof any source type anywhere as Type{...}, as long as it isn't nesting Type{Type{...}}
+            tt = unwrap_unionall(t.parameters[1])
+            if isa(tt, DataType) && !isType(tt)
+                is_derived_type_from_any(tt, sources) || return true
+                return false
+            end
+        end
+    end
+    return true
+end
+
+function is_derived_type(@nospecialize(t), @nospecialize(c)) # try to find `type` somewhere in `comparison` type
+    t === c && return true
+    if isa(c, TypeVar)
+        # see if it is replacing a TypeVar upper bound with something simpler
+        return is_derived_type(t, c.ub)
+    elseif isa(c, Union)
+        # see if it is one of the elements of the union
+        return is_derived_type(t, c.a) || is_derived_type(t, c.b)
+    elseif isa(c, UnionAll)
+        # see if it is derived from the body
+        return is_derived_type(t, c.body)
+    elseif isa(c, DataType)
+        if isa(t, DataType)
+            # see if it is one of the supertypes of a parameter
+            super = supertype(c)
+            while super !== Any
+                t === super && return true
+                super = supertype(super)
+            end
+        end
+        # see if it was extracted from a type parameter
+        cP = c.parameters
+        for p in cP
+            is_derived_type(t, p) && return true
+        end
+        if isconcrete(c) && isbits(c)
+            # see if it was extracted from a fieldtype
+            # however, only look through types that can be inlined
+            # to ensure monotonicity of derivation
+            # since we know that for immutable types,
+            # the field types must have been constructed prior to the type,
+            # it cannot have a reference cycle in the type graph
+            cF = c.types
+            for f in cF
+                is_derived_type(t, f) && return true
+            end
+        end
+    end
+    return false
+end
+
+function is_derived_type_from_any(@nospecialize(t), sources::SimpleVector)
+    for s in sources
+        is_derived_type(t, s) && return true
+    end
+    return false
+end
+
+function _limit_type_size(@nospecialize(t), @nospecialize(c), sources::SimpleVector) # type vs. comparison which was derived from source
+    if t === c
+        return t # quick egal test
+    elseif t === Union{}
+        return t # easy case
+    elseif isa(t, DataType) && isempty(t.parameters)
+        return t # fast path: unparameterized are always simple
+    elseif isa(unwrap_unionall(t), DataType) && isa(c, Type) && c !== Union{} && c <: t
+        return t # t is already wider than the comparison in the type lattice
+    elseif is_derived_type_from_any(unwrap_unionall(t), sources)
+        return t # t isn't something new
+    end
+    if isa(t, TypeVar)
+        if isa(c, TypeVar)
+            if t.ub === c.ub && t.lb === c.lb
+                return t
+            end
+        end
+    elseif isa(t, Union)
+        if isa(c, Union)
+            a = _limit_type_size(t.a, c.a, sources)
+            b = _limit_type_size(t.b, c.b, sources)
+            return Union{a, b}
+        end
+    elseif isa(t, UnionAll)
+        if isa(c, UnionAll)
+            tv = t.var
+            cv = c.var
+            if tv.ub === cv.ub
+                if tv.lb === cv.lb
+                    return UnionAll(tv, _limit_type_size(t.body, c.body, sources))
+                end
+                ub = tv.ub
+            else
+                ub = _limit_type_size(tv.ub, cv.ub, sources)
+            end
+            if tv.lb === cv.lb
+                lb = tv.lb
+            else
+                # note: lower bounds need to be widened by making them lower
+                lb = Bottom
+            end
+            v2 = TypeVar(tv.name, lb, ub)
+            return UnionAll(v2, _limit_type_size(t{v2}, c{v2}, sources))
+        end
+        tbody = _limit_type_size(t.body, c, sources)
+        tbody === t.body && return t
+        return UnionAll(t.var, tbody)
+    elseif isa(t, DataType)
+        if isa(c, DataType)
+            tP = t.parameters
+            cP = c.parameters
+            if t.name === c.name && !isempty(cP)
+                if isvarargtype(t)
+                    VaT = _limit_type_size(tP[1], cP[1], sources)
+                    N = tP[2]
+                    if isa(N, TypeVar) || N === cP[2]
+                        return Vararg{VaT, N}
+                    end
+                    return Vararg{VaT}
+                elseif t.name === Tuple.name
+                    # for covariant datatypes (aka Tuple),
+                    # apply type-size limit elementwise
+                    np = min(length(tP), length(cP))
+                    Q = Any[ tP[i] for i in 1:np ]
+                    if length(tP) > np # implies Tuple
+                        # combine tp[np:end] into tP[np] using Vararg
+                        Q[np] = tuple_tail_elem(Bottom, Any[ tP[i] for i in np:length(tP) ])
+                    end
+                    for i = 1:np
+                        Q[i] = _limit_type_size(Q[i], cP[i], sources)
+                    end
+                    return Tuple{Q...}
+                end
+            end
+        end
+        if isType(t) # allow taking typeof as Type{...}, but ensure it doesn't start nesting
+            tt = unwrap_unionall(t.parameters[1])
+            if isa(tt, DataType) && !isType(tt)
+                is_derived_type_from_any(tt, sources) && return t
+            end
+        end
+        if isvarargtype(t)
+            # never replace Vararg with non-Vararg
+            return Vararg
+        end
+        widert = t.name.wrapper
+        if !(t <: widert)
+            # This can happen when a typevar has bounds too wide for its context, e.g.
+            # `Complex{T} where T` is not a subtype of `Complex`. In that case widen even
+            # faster to something safe to ensure the result is a supertype of the input.
+            return Any
+        end
+        return widert
+    end
+    return Any
+end
+
+
 const DataType_name_fieldindex = fieldindex(DataType, :name)
 const DataType_parameters_fieldindex = fieldindex(DataType, :parameters)
 const DataType_types_fieldindex = fieldindex(DataType, :types)
@@ -731,25 +1115,26 @@ function const_datatype_getfield_tfunc(sv, fld)
     return nothing
 end
 
-# returns (type, isexact)
-function getfield_tfunc(s00::ANY, name)
+function getfield_tfunc(@nospecialize(s00), name)
     if isa(s00, TypeVar)
         s00 = s00.ub
     end
     s = unwrap_unionall(s00)
-    if isType(s)
-        p1 = s.parameters[1]
-        if !isconcrete(p1)
-            return Any
-        end
-        s = DataType # typeof(p1)
-    elseif isa(s, Union)
+    if isa(s, Union)
         return tmerge(rewrap(getfield_tfunc(s.a, name),s00),
                       rewrap(getfield_tfunc(s.b, name),s00))
     elseif isa(s, Conditional)
         return Bottom # Bool has no fields
-    elseif isa(s, Const)
-        sv = s.val
+    elseif isa(s, Const) || isType(s)
+        if !isa(s, Const)
+            p1 = s.parameters[1]
+            if !isconcrete(p1)
+                return Any
+            end
+            sv = p1
+        else
+            sv = s.val
+        end
         if isa(name, Const)
             nv = name.val
             if isa(sv, UnionAll)
@@ -773,6 +1158,9 @@ function getfield_tfunc(s00::ANY, name)
             if isa(sv, Module) && isa(nv, Symbol)
                 return abstract_eval_global(sv, nv)
             end
+            if !(isa(nv,Symbol) || isa(nv,Int))
+                return Bottom
+            end
             if (isa(sv, SimpleVector) || isimmutable(sv)) && isdefined(sv, nv)
                 return abstract_eval_constant(getfield(sv, nv))
             end
@@ -810,7 +1198,7 @@ function getfield_tfunc(s00::ANY, name)
         if isempty(s.parameters)
             return R
         end
-        return limit_type_depth(R, 0)
+        return limit_type_depth(R, MAX_TYPE_DEPTH)
     end
     fld = name.val
     if isa(fld,Symbol)
@@ -845,11 +1233,11 @@ function getfield_tfunc(s00::ANY, name)
     # conservatively limit the type depth here,
     # since the UnionAll type bound is otherwise incorrect
     # in the current type system
-    return rewrap_unionall(limit_type_depth(R, 0), s00)
+    return rewrap_unionall(limit_type_depth(R, MAX_TYPE_DEPTH), s00)
 end
-add_tfunc(getfield, 2, 2, (s::ANY, name::ANY) -> getfield_tfunc(s, name))
-add_tfunc(setfield!, 3, 3, (o::ANY, f::ANY, v::ANY) -> v)
-function fieldtype_tfunc(s0::ANY, name::ANY)
+add_tfunc(getfield, 2, 2, (@nospecialize(s), @nospecialize(name)) -> getfield_tfunc(s, name), 1)
+add_tfunc(setfield!, 3, 3, (@nospecialize(o), @nospecialize(f), @nospecialize(v)) -> v, 3)
+function fieldtype_tfunc(@nospecialize(s0), @nospecialize(name))
     if s0 === Any || s0 === Type || DataType ⊑ s0 || UnionAll ⊑ s0
         return Type
     end
@@ -861,7 +1249,7 @@ function fieldtype_tfunc(s0::ANY, name::ANY)
         return Bottom
     end
 
-    s = instanceof_tfunc(s0)
+    s = instanceof_tfunc(s0)[1]
     u = unwrap_unionall(s)
 
     if isa(u,Union)
@@ -908,9 +1296,9 @@ function fieldtype_tfunc(s0::ANY, name::ANY)
     end
     return Type{<:ft}
 end
-add_tfunc(fieldtype, 2, 2, fieldtype_tfunc)
+add_tfunc(fieldtype, 2, 2, fieldtype_tfunc, 0)
 
-function valid_tparam(x::ANY)
+function valid_tparam(@nospecialize(x))
     if isa(x,Tuple)
         for t in x
             !valid_tparam(t) && return false
@@ -920,10 +1308,10 @@ function valid_tparam(x::ANY)
     return isa(x,Int) || isa(x,Symbol) || isa(x,Bool) || (!isa(x,Type) && isbits(x))
 end
 
-has_free_typevars(t::ANY) = ccall(:jl_has_free_typevars, Cint, (Any,), t)!=0
+has_free_typevars(@nospecialize(t)) = ccall(:jl_has_free_typevars, Cint, (Any,), t)!=0
 
 # TODO: handle e.g. apply_type(T, R::Union{Type{Int32},Type{Float64}})
-function apply_type_tfunc(headtypetype::ANY, args::ANY...)
+function apply_type_tfunc(@nospecialize(headtypetype), @nospecialize args...)
     if isa(headtypetype, Const)
         headtype = headtypetype.val
     elseif isType(headtypetype) && isconcrete(headtypetype.parameters[1])
@@ -970,7 +1358,7 @@ function apply_type_tfunc(headtypetype::ANY, args::ANY...)
         ai = args[i]
         if isType(ai)
             aip1 = ai.parameters[1]
-            canconst &= isconcrete(aip1)
+            canconst &= !has_free_typevars(aip1)
             push!(tparams, aip1)
         elseif isa(ai, Const) && (isa(ai.val, Type) || isa(ai.val, TypeVar) || valid_tparam(ai.val))
             push!(tparams, ai.val)
@@ -1023,7 +1411,7 @@ function apply_type_tfunc(headtypetype::ANY, args::ANY...)
     if isvarargtype(headtype)
         return Type
     end
-    if uncertain && type_too_complex(appl,0)
+    if uncertain && type_too_complex(appl, MAX_TYPE_DEPTH)
         return Type{<:headtype}
     end
     if istuple
@@ -1035,16 +1423,16 @@ function apply_type_tfunc(headtypetype::ANY, args::ANY...)
     end
     return ans
 end
-add_tfunc(apply_type, 1, IInf, apply_type_tfunc)
+add_tfunc(apply_type, 1, IInf, apply_type_tfunc, 10)
 
-@pure function type_typeof(v::ANY)
+@pure function type_typeof(@nospecialize(v))
     if isa(v, Type)
         return Type{v}
     end
     return typeof(v)
 end
 
-function invoke_tfunc(f::ANY, types::ANY, argtype::ANY, sv::InferenceState)
+function invoke_tfunc(@nospecialize(f), @nospecialize(types), @nospecialize(argtype), sv::InferenceState)
     if !isconcrete(Type{types})
         return Any
     end
@@ -1062,13 +1450,26 @@ function invoke_tfunc(f::ANY, types::ANY, argtype::ANY, sv::InferenceState)
     meth = entry.func
     (ti, env) = ccall(:jl_match_method, Ref{SimpleVector}, (Any, Any),
                       argtype, meth.sig)
-    return typeinf_edge(meth::Method, ti, env, sv)
+    rt, edge = typeinf_edge(meth::Method, ti, env, sv)
+    edge !== nothing && add_backedge!(edge::MethodInstance, sv)
+    return rt
 end
 
-function tuple_tfunc(argtype::ANY)
+function tuple_tfunc(@nospecialize(argtype))
     if isa(argtype, DataType) && argtype.name === Tuple.name
-        p = Any[ isType(x) && !isa(x.parameters[1], TypeVar) ? typeof(x.parameters[1]) : x
-                 for x in argtype.parameters ]
+        p = Vector{Any}()
+        for x in argtype.parameters
+            if isType(x) && !isa(x.parameters[1], TypeVar)
+                xparam = x.parameters[1]
+                if isconcrete(xparam) || xparam === Bottom
+                    push!(p, typeof(xparam))
+                else
+                    push!(p, Type)
+                end
+            else
+                push!(p, x)
+            end
+        end
         t = Tuple{p...}
         # replace a singleton type with its equivalent Const object
         isdefined(t, :instance) && return Const(t.instance)
@@ -1077,15 +1478,16 @@ function tuple_tfunc(argtype::ANY)
     return argtype
 end
 
-function builtin_tfunction(f::ANY, argtypes::Array{Any,1}, sv::InferenceState)
+function builtin_tfunction(@nospecialize(f), argtypes::Array{Any,1},
+                           sv::Union{InferenceState,Void}, params::InferenceParams = sv.params)
     isva = !isempty(argtypes) && isvarargtype(argtypes[end])
     if f === tuple
         for a in argtypes
             if !isa(a, Const)
-                return tuple_tfunc(limit_tuple_depth(sv.params, argtypes_to_type(argtypes)))
+                return tuple_tfunc(limit_tuple_depth(params, argtypes_to_type(argtypes)))
             end
         end
-        return Const(tuple(map(a->a.val, argtypes)...))
+        return Const(tuple(anymap(a->a.val, argtypes)...))
     elseif f === svec
         return SimpleVector
     elseif f === arrayset
@@ -1131,7 +1533,7 @@ function builtin_tfunction(f::ANY, argtypes::Array{Any,1}, sv::InferenceState)
             else
                 sigty = nothing
             end
-            if isa(sigty, Type) && sigty <: Tuple
+            if isa(sigty, Type) && sigty <: Tuple && sv !== nothing
                 return invoke_tfunc(af, sigty, argtypes_to_type(argtypes[3:end]), sv)
             end
         end
@@ -1142,20 +1544,20 @@ function builtin_tfunction(f::ANY, argtypes::Array{Any,1}, sv::InferenceState)
     end
     if isa(f, IntrinsicFunction)
         iidx = Int(reinterpret(Int32, f::IntrinsicFunction)) + 1
-        if !isassigned(t_ifunc, iidx)
-            # unknown/unhandled intrinsic (most fall in this category since most return an unboxed value)
+        if iidx < 0 || iidx > length(t_ifunc)
+            # invalid intrinsic
             return Any
         end
         tf = t_ifunc[iidx]
     else
-        fidx = findfirst(t_ffunc_key, f::Function)
+        fidx = findfirst(t_ffunc_key, f)
         if fidx == 0
-            # unknown/unhandled builtin or anonymous function
+            # unknown/unhandled builtin function
             return Any
         end
         tf = t_ffunc_val[fidx]
     end
-    tf = tf::Tuple{Real, Real, Any}
+    tf = tf::Tuple{Int, Int, Any}
     if !(tf[1] <= length(argtypes) <= tf[2])
         # wrong # of args
         return Bottom
@@ -1163,9 +1565,9 @@ function builtin_tfunction(f::ANY, argtypes::Array{Any,1}, sv::InferenceState)
     return tf[3](argtypes...)
 end
 
-limit_tuple_depth(params::InferenceParams, t::ANY) = limit_tuple_depth_(params,t,0)
+limit_tuple_depth(params::InferenceParams, @nospecialize(t)) = limit_tuple_depth_(params,t,0)
 
-function limit_tuple_depth_(params::InferenceParams, t::ANY, d::Int)
+function limit_tuple_depth_(params::InferenceParams, @nospecialize(t), d::Int)
     if isa(t,Union)
         # also limit within Union types.
         # may have to recur into other stuff in the future too.
@@ -1191,9 +1593,9 @@ function limit_tuple_depth_(params::InferenceParams, t::ANY, d::Int)
     Tuple{p...}
 end
 
-limit_tuple_type = (t::ANY, params::InferenceParams) -> limit_tuple_type_n(t, params.MAX_TUPLETYPE_LEN)
+limit_tuple_type = (@nospecialize(t), params::InferenceParams) -> limit_tuple_type_n(t, params.MAX_TUPLETYPE_LEN)
 
-function limit_tuple_type_n(t::ANY, lim::Int)
+function limit_tuple_type_n(@nospecialize(t), lim::Int)
     if isa(t,UnionAll)
         return UnionAll(t.var, limit_tuple_type_n(t.body, lim))
     end
@@ -1208,7 +1610,7 @@ end
 
 # return an upper-bound on type `a` with type `b` removed
 # such that `return <: a` && `Union{return, b} == Union{a, b}`
-function typesubtract(a::ANY, b::ANY)
+function typesubtract(@nospecialize(a), @nospecialize(b))
     if a <: b
         return Bottom
     end
@@ -1221,8 +1623,34 @@ end
 
 #### recursing into expression ####
 
-function abstract_call_gf_by_type(f::ANY, atype::ANY, sv::InferenceState)
-    tm = _topmod(sv)
+# take a Tuple where one or more parameters are Unions
+# and return an array such that those Unions are removed
+# and `Union{return...} == ty`
+function switchtupleunion(@nospecialize(ty))
+    tparams = (unwrap_unionall(ty)::DataType).parameters
+    return _switchtupleunion(Any[tparams...], length(tparams), [], ty)
+end
+
+function _switchtupleunion(t::Vector{Any}, i::Int, tunion::Vector{Any}, @nospecialize(origt))
+    if i == 0
+        tpl = rewrap_unionall(Tuple{t...}, origt)
+        push!(tunion, tpl)
+    else
+        ti = t[i]
+        if isa(ti, Union)
+            for ty in uniontypes(ti::Union)
+                t[i] = ty
+                _switchtupleunion(t, i - 1, tunion, origt)
+            end
+            t[i] = ti
+        else
+            _switchtupleunion(t, i - 1, tunion, origt)
+        end
+    end
+    return tunion
+end
+
+function abstract_call_gf_by_type(@nospecialize(f), @nospecialize(atype), sv::InferenceState)
     # 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
@@ -1250,147 +1678,168 @@ function abstract_call_gf_by_type(f::ANY, atype::ANY, sv::InferenceState)
     end
     min_valid = UInt[typemin(UInt)]
     max_valid = UInt[typemax(UInt)]
-    applicable = _methods_by_ftype(argtype, 4, sv.params.world, min_valid, max_valid)
-    rettype = Bottom
-    if applicable === false
-        # this means too many methods matched
-        return Any
+    splitunions = 1 < countunionsplit(argtypes) <= sv.params.MAX_UNION_SPLITTING
+    if splitunions
+        splitsigs = switchtupleunion(argtype)
+        applicable = Any[]
+        for sig_n in splitsigs
+            xapplicable = _methods_by_ftype(sig_n, sv.params.MAX_METHODS, sv.params.world, min_valid, max_valid)
+            xapplicable === false && return Any
+            append!(applicable, xapplicable)
+        end
+    else
+        applicable = _methods_by_ftype(argtype, sv.params.MAX_METHODS, sv.params.world, min_valid, max_valid)
+        if applicable === false
+            # this means too many methods matched
+            return Any
+        end
     end
-    x::Array{Any,1} = applicable
+    applicable = applicable::Array{Any,1}
+    napplicable = length(applicable)
     fullmatch = false
-    for (m::SimpleVector) in x
-        sig = m[1]
-        sigtuple = unwrap_unionall(sig)::DataType
-        method = m[3]::Method
-        sparams = m[2]::SimpleVector
-        recomputesvec = false
-        if !fullmatch && typeseq(sig, argtype)
+    rettype = Bottom
+    for i in 1:napplicable
+        match = applicable[i]::SimpleVector
+        method = match[3]::Method
+        if !fullmatch && (argtype <: method.sig)
             fullmatch = true
         end
+        sig = match[1]
+        sigtuple = unwrap_unionall(sig)::DataType
+        splitunions = false
+        # TODO: splitunions = 1 < countunionsplit(sigtuple.parameters) * napplicable <= sv.params.MAX_UNION_SPLITTING
+        # currently this triggers a bug in inference recursion detection
+        if splitunions
+            splitsigs = switchtupleunion(sig)
+            for sig_n in splitsigs
+                rt = abstract_call_method(method, f, sig_n, svec(), sv)
+                rettype = tmerge(rettype, rt)
+                rettype === Any && break
+            end
+            rettype === Any && break
+        else
+            rt = abstract_call_method(method, f, sig, match[2]::SimpleVector, sv)
+            rettype = tmerge(rettype, rt)
+            rettype === Any && break
+        end
+    end
+    if !(fullmatch || rettype === Any)
+        # also need an edge to the method table in case something gets
+        # added that did not intersect with any existing method
+        add_mt_backedge(ftname.mt, argtype, sv)
+        update_valid_age!(min_valid[1], max_valid[1], sv)
+    end
+    #print("=> ", rettype, "\n")
+    return rettype
+end
+
+function abstract_call_method(method::Method, @nospecialize(f), @nospecialize(sig), sparams::SimpleVector, sv::InferenceState)
+    sigtuple = unwrap_unionall(sig)::DataType
 
-        # limit argument type tuple growth
-        msig = unwrap_unionall(m[3].sig)
+    tm = _topmod(sv)
+    if (# promote_typeof signature may be used with many arguments
+          !istopfunction(tm, f, :promote_typeof)
+        # assume getindex methods aren't directly recursive, since wrappers like ReshapedArrays won't look like it here
+        # should still manage to detect recursive growth either via other intermediate methods or actual type-equal signature recursion
+       && !istopfunction(tm, f, :getindex)
+       && !istopfunction(tm, f, :setindex!)
+        # the construct-to-convert method is a bottleneck in inference,
+        # so just assume that recursion will get prevented at some other point
+       && !(method.sig == Tuple{Type, Any}))
+        # otherwise: limit argument type tuple growth of all other functions
+        msig = unwrap_unionall(method.sig)
         lsig = length(msig.parameters)
         ls = length(sigtuple.parameters)
-        td = type_depth(sig)
-        # look at the existing edges to detect growing argument lists
-        mightlimitlength = ls > lsig + 1
-        mightlimitdepth = td > 2
-
-        limitlength = false
-        if mightlimitlength
-            for (callee, _) in sv.edges
-                callee = callee::InferenceState
-                if method === callee.linfo.def && ls > length(unwrap_unionall(callee.linfo.specTypes).parameters)
-                    limitlength = true
+        # look through the parents list to find the topmost
+        # function call to the same method
+        cyclei = 0
+        infstate = sv
+        topmost = nothing
+        while infstate !== nothing
+            infstate = infstate::InferenceState
+            if method === infstate.linfo.def
+                if infstate.linfo.specTypes == sig
+                    # avoid widening when detecting self-recursion
+                    # TODO: merge call cycle and return right away
+                    topmost = nothing
                     break
                 end
+                topmost === nothing && (topmost = infstate)
+            end
+            # iterate through the cycle before walking to the parent
+            if cyclei < length(infstate.callers_in_cycle)
+                cyclei += 1
+                infstate = infstate.callers_in_cycle[cyclei]
+            else
+                cyclei = 0
+                infstate = infstate.parent
             end
         end
 
-        # limit argument type size growth
-        if mightlimitlength || mightlimitdepth
-            # TODO: FIXME: this heuristic depends on non-local state making type-inference unpredictable
-            for infstate in active
-                infstate === nothing && continue
-                infstate = infstate::InferenceState
-                if isdefined(infstate.linfo, :def) && method === infstate.linfo.def
-                    if mightlimitlength && ls > length(unwrap_unionall(infstate.linfo.specTypes).parameters)
-                        limitlength = true
-                    end
-                    if mightlimitdepth && td > type_depth(infstate.linfo.specTypes)
-                        # impose limit if we recur and the argument types grow beyond MAX_TYPE_DEPTH
-                        if td > MAX_TYPE_DEPTH
-                            sig = limit_type_depth(sig, 0)
-                            sigtuple = unwrap_unionall(sig)
-                            recomputesvec = true
+        # TODO: FIXME: this heuristic depends on non-local state making type-inference unpredictable
+        # it also should be integrated into the cycle resolution and iterated to convergence
+        if topmost !== nothing
+            # impose limit if we recur on the same method and the argument type complexity is growing or is beyond MAX_TYPE_DEPTH
+            newsig = sig
+            if !isempty(topmost.callers_in_cycle)
+                # already discovered this method causes dependent self-recursion
+                # widen fully to avoid making the cycle any larger
+                newsig = method.sig
+            else
+                comparison = topmost.linfo.specTypes
+                if ls > lsig + 1 && ls > length(unwrap_unionall(comparison).parameters)
+                    # limit length based on size of definition signature.
+                    # for example, given function f(T, Any...), limit to 3 arguments
+                    # instead of the default (MAX_TUPLETYPE_LEN)
+                    fst = sigtuple.parameters[lsig + 1]
+                    allsame = true
+                    # allow specializing on longer arglists if all the trailing
+                    # arguments are the same, since there is no exponential
+                    # blowup in this case.
+                    for i = (lsig + 2):ls
+                        if sigtuple.parameters[i] != fst
+                            allsame = false
                             break
-                        else
-                            p1, p2 = sigtuple.parameters, unwrap_unionall(infstate.linfo.specTypes).parameters
-                            if length(p2) == ls
-                                limitdepth = false
-                                newsig = Array{Any}(ls)
-                                for i = 1:ls
-                                    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.
-                                        newsig[i] = p1[i].name.wrapper
-                                        limitdepth  = true
-                                    else
-                                        newsig[i] = limit_type_depth(p1[i], 1)
-                                    end
-                                end
-                                if limitdepth
-                                    sigtuple = Tuple{newsig...}
-                                    sig = rewrap_unionall(sigtuple, sig)
-                                    recomputesvec = true
-                                    break
-                                end
-                            end
                         end
                     end
-                end
-            end
-        end
-
-        # limit length based on size of definition signature.
-        # for example, given function f(T, Any...), limit to 3 arguments
-        # instead of the default (MAX_TUPLETYPE_LEN)
-        if limitlength
-            if !istopfunction(tm, f, :promote_typeof)
-                fst = sigtuple.parameters[lsig + 1]
-                allsame = true
-                # allow specializing on longer arglists if all the trailing
-                # arguments are the same, since there is no exponential
-                # blowup in this case.
-                for i = (lsig + 2):ls
-                    if sigtuple.parameters[i] != fst
-                        allsame = false
-                        break
+                    if !allsame
+                        sigtuple = limit_tuple_type_n(sigtuple, lsig + 1)
+                        newsig = rewrap_unionall(sigtuple, newsig)
                     end
                 end
-                if !allsame
-                    sigtuple = limit_tuple_type_n(sigtuple, lsig + 1)
-                    sig = rewrap_unionall(sigtuple, sig)
-                    recomputesvec = true
+                td = type_depth(newsig)
+                max_type_depth = min(MAX_TYPE_DEPTH, type_depth(comparison))
+                if td > max_type_depth
+                    # limit growth in type depth
+                    newsig = limit_type_depth(newsig, max_type_depth)
                 end
+                # see if the type is still too big, and limit it further if required
+                newsig = limit_type_size(newsig, comparison, sv.linfo.specTypes)
             end
-        end
-
-        # if sig changed, may need to recompute the sparams environment
-        if recomputesvec && !isempty(sparams)
-            recomputed = ccall(:jl_env_from_type_intersection, Ref{SimpleVector}, (Any, Any), sig, method.sig)
-            sig = recomputed[1]
-            if !isa(unwrap_unionall(sig), DataType) # probably Union{}
-                rettype = Any
-                break
+            if newsig !== sig
+                sig = newsig
+                sigtuple = unwrap_unionall(sig)
+                sparams = svec()
             end
-            sparams = recomputed[2]::SimpleVector
-        end
-        rt = typeinf_edge(method, sig, sparams, sv)
-        rettype = tmerge(rettype, rt)
-        if rettype === Any
-            break
         end
     end
-    if !(fullmatch || rettype === Any)
-        # also need an edge to the method table in case something gets
-        # added that did not intersect with any existing method
-        add_mt_backedge(ftname.mt, argtype, sv)
-        update_valid_age!(min_valid[1], max_valid[1], sv)
-    end
-    if isempty(x)
-        # TODO: this is needed because type intersection is wrong in some cases
-        return Any
+
+    # if sig changed, may need to recompute the sparams environment
+    if isa(method.sig, UnionAll) && isempty(sparams)
+        recomputed = ccall(:jl_env_from_type_intersection, Ref{SimpleVector}, (Any, Any), sig, method.sig)
+        sig = recomputed[1]
+        if !isa(unwrap_unionall(sig), DataType) # probably Union{}
+            return Any
+        end
+        sparams = recomputed[2]::SimpleVector
     end
-    #print("=> ", rettype, "\n")
-    return rettype
+    rt, edge = typeinf_edge(method, sig, sparams, sv)
+    edge !== nothing && add_backedge!(edge::MethodInstance, sv)
+    return rt
 end
 
 # determine whether `ex` abstractly evals to constant `c`
-function abstract_evals_to_constant(ex, c::ANY, vtypes, sv)
+function abstract_evals_to_constant(@nospecialize(ex), @nospecialize(c), vtypes::VarTable, sv::InferenceState)
     av = abstract_eval(ex, vtypes, sv)
     return isa(av,Const) && av.val === c
 end
@@ -1399,14 +1848,29 @@ end
 # if the expression constructs a container (e.g. `svec(x,y,z)`),
 # refine its type to an array of element types.
 # Union of Tuples of the same length is converted to Tuple of Unions.
-# returns an array of types, or `nothing`.
-function precise_container_type(arg, typ, vtypes::VarTable, sv)
-    tti = widenconst(typ)
-    tti = unwrap_unionall(tti)
-    if isa(typ, Const) && (isa(typ.val, SimpleVector) || isa(typ.val, Tuple))
-        return Any[ abstract_eval_constant(x) for x in typ.val ]
-    elseif isa(arg, Expr) && arg.head === :call && (abstract_evals_to_constant(arg.args[1], svec, vtypes, sv) ||
-                                                    abstract_evals_to_constant(arg.args[1], tuple, vtypes, sv))
+# returns an array of types
+function precise_container_type(@nospecialize(arg), @nospecialize(typ), vtypes::VarTable, sv::InferenceState)
+    if isa(typ, Const)
+        val = typ.val
+        if isa(val, SimpleVector) || isa(val, Tuple)
+            return Any[ Const(val[i]) for i in 1:length(val) ] # avoid making a tuple Generator here!
+        end
+    end
+
+    while isa(arg, SSAValue)
+        def = sv.ssavalue_defs[arg.id + 1]
+        stmt = sv.src.code[def]::Expr
+        arg = stmt.args[2]
+    end
+
+    if is_specializable_vararg_slot(arg, sv)
+        return Any[rewrap_unionall(p, sv.linfo.specTypes) for p in sv.vararg_type_container.parameters]
+    end
+
+    tti0 = widenconst(typ)
+    tti = unwrap_unionall(tti0)
+    if isa(arg, Expr) && arg.head === :call && (abstract_evals_to_constant(arg.args[1], svec, vtypes, sv) ||
+                                                abstract_evals_to_constant(arg.args[1], tuple, vtypes, sv))
         aa = arg.args
         result = Any[ (isa(aa[j],Expr) ? aa[j].typ : abstract_eval(aa[j],vtypes,sv)) for j=2:length(aa) ]
         if _any(isvarargtype, result)
@@ -1418,40 +1882,45 @@ function precise_container_type(arg, typ, vtypes::VarTable, sv)
         if _any(t -> !isa(t,DataType) || !(t <: Tuple) || !isknownlength(t), utis)
             return Any[Vararg{Any}]
         end
-        result = Any[utis[1].parameters...]
+        result = Any[rewrap_unionall(p, tti0) for p in utis[1].parameters]
         for t in utis[2:end]
             if length(t.parameters) != length(result)
                 return Any[Vararg{Any}]
             end
             for j in 1:length(t.parameters)
-                result[j] = tmerge(result[j], t.parameters[j])
+                result[j] = tmerge(result[j], rewrap_unionall(t.parameters[j], tti0))
             end
         end
         return result
-    elseif isa(tti,DataType) && tti <: Tuple
-        if isvatuple(tti) && length(tti.parameters) == 1
-            return Any[Vararg{unwrapva(tti.parameters[1])}]
+    elseif isa(tti0,DataType) && tti0 <: Tuple
+        if isvatuple(tti0) && length(tti0.parameters) == 1
+            return Any[Vararg{unwrapva(tti0.parameters[1])}]
         else
-            return tti.parameters
+            return Any[ p for p in tti0.parameters ]
         end
-    elseif tti <: Array
-        return Any[Vararg{eltype(tti)}]
+    elseif tti0 <: Array
+        return Any[Vararg{eltype(tti0)}]
     else
-        return Any[Vararg{abstract_iteration(tti, vtypes, sv)}]
+        return Any[abstract_iteration(typ, vtypes, sv)]
     end
 end
 
 # simulate iteration protocol on container type up to fixpoint
-function abstract_iteration(itertype, vtypes::VarTable, sv)
-    if !isdefined(Main, :Base) || !isdefined(Main.Base, :start) || !isdefined(Main.Base, :next)
-        return Any
+function abstract_iteration(@nospecialize(itertype), vtypes::VarTable, sv::InferenceState)
+    tm = _topmod(sv)
+    if !isdefined(tm, :start) || !isdefined(tm, :next) || !isconst(tm, :start) || !isconst(tm, :next)
+        return Vararg{Any}
     end
-    statetype = abstract_call(Main.Base.start, (), Any[Const(Main.Base.start), itertype], vtypes, sv)
+    startf = getfield(tm, :start)
+    nextf = getfield(tm, :next)
+    statetype = abstract_call(startf, (), Any[Const(startf), itertype], vtypes, sv)
+    statetype === Bottom && return Bottom
     valtype = Bottom
     while valtype !== Any
-        nt = abstract_call(Main.Base.next, (), Any[Const(Main.Base.next), itertype, statetype], vtypes, sv)
+        nt = abstract_call(nextf, (), Any[Const(nextf), itertype, statetype], vtypes, sv)
+        nt = widenconst(nt)
         if !isa(nt, DataType) || !(nt <: Tuple) || isvatuple(nt) || length(nt.parameters) != 2
-            return Any
+            return Vararg{Any}
         end
         if nt.parameters[1] <: valtype && nt.parameters[2] <: statetype
             break
@@ -1459,32 +1928,34 @@ function abstract_iteration(itertype, vtypes::VarTable, sv)
         valtype = tmerge(valtype, nt.parameters[1])
         statetype = tmerge(statetype, nt.parameters[2])
     end
-    return valtype
+    return Vararg{valtype}
+end
+
+function tuple_tail_elem(@nospecialize(init), ct)
+    return Vararg{widenconst(foldl((a, b) -> tmerge(a, unwrapva(b)), init, ct))}
 end
 
 # do apply(af, fargs...), where af is a function value
-function abstract_apply(af::ANY, fargs, aargtypes::Vector{Any}, vtypes::VarTable, sv)
+function abstract_apply(@nospecialize(aft), fargs::Vector{Any}, aargtypes::Vector{Any}, vtypes::VarTable, sv::InferenceState)
+    if !isa(aft, Const) && !isconstType(aft)
+        if !(isconcrete(aft) || aft <: Type) || (aft <: Builtin) || (aft <: IntrinsicFunction)
+            return Any
+        end
+        # non-constant function, but type is known
+    end
     res = Union{}
     nargs = length(fargs)
     assert(nargs == length(aargtypes))
-    splitunions = countunionsplit(aargtypes) <= sv.params.MAX_APPLY_UNION_ENUM
-    ctypes = Any[Any[]]
+    splitunions = 1 < countunionsplit(aargtypes) <= sv.params.MAX_APPLY_UNION_ENUM
+    ctypes = Any[Any[aft]]
     for i = 1:nargs
-        if aargtypes[i] === Any
-            # bail out completely and infer as f(::Any...)
-            # instead could keep what we got so far and just append a Vararg{Any} (by just
-            # using the normal logic from below), but that makes the time of the subarray
-            # test explode
-            ctypes = Any[Any[Vararg{Any}]]
-            break
-        end
         ctypes´ = []
         for ti in (splitunions ? uniontypes(aargtypes[i]) : Any[aargtypes[i]])
             cti = precise_container_type(fargs[i], ti, vtypes, sv)
             for ct in ctypes
                 if !isempty(ct) && isvarargtype(ct[end])
-                    tail = foldl((a,b)->tmerge(a,unwrapva(b)), unwrapva(ct[end]), cti)
-                    push!(ctypes´, push!(ct[1:end-1], Vararg{widenconst(tail)}))
+                    tail = tuple_tail_elem(unwrapva(ct[end]), cti)
+                    push!(ctypes´, push!(ct[1:(end - 1)], tail))
                 else
                     push!(ctypes´, append_any(ct, cti))
                 end
@@ -1494,12 +1965,19 @@ function abstract_apply(af::ANY, fargs, aargtypes::Vector{Any}, vtypes::VarTable
     end
     for ct in ctypes
         if length(ct) > sv.params.MAX_TUPLETYPE_LEN
-            tail = foldl((a,b)->tmerge(a,unwrapva(b)), Bottom, ct[sv.params.MAX_TUPLETYPE_LEN:end])
+            tail = tuple_tail_elem(Bottom, ct[sv.params.MAX_TUPLETYPE_LEN:end])
             resize!(ct, sv.params.MAX_TUPLETYPE_LEN)
-            ct[end] = Vararg{widenconst(tail)}
+            ct[end] = tail
+        end
+        if isa(aft, Const)
+            rt = abstract_call(aft.val, (), ct, vtypes, sv)
+        elseif isconstType(aft)
+            rt = abstract_call(aft.parameters[1], (), ct, vtypes, sv)
+        else
+            astype = argtypes_to_type(ct)
+            rt = abstract_call_gf_by_type(nothing, astype, sv)
         end
-        at = append_any(Any[Const(af)], ct)
-        res = tmerge(res, abstract_call(af, (), at, vtypes, sv))
+        res = tmerge(res, rt)
         if res === Any
             break
         end
@@ -1507,27 +1985,31 @@ function abstract_apply(af::ANY, fargs, aargtypes::Vector{Any}, vtypes::VarTable
     return res
 end
 
-function return_type_tfunc(argtypes::ANY, vtypes::VarTable, sv::InferenceState)
+# TODO: this function is a very buggy and poor model of the return_type function
+# since abstract_call_gf_by_type is a very inaccurate model of _method and of typeinf_type,
+# while this assumes that it is a precisely accurate and exact model of both
+function return_type_tfunc(@nospecialize(argtypes), vtypes::VarTable, sv::InferenceState)
     if length(argtypes) == 3
         tt = argtypes[3]
         if isa(tt, Const) || (isType(tt) && !has_free_typevars(tt))
             aft = argtypes[2]
             if isa(aft, Const) || (isType(aft) && !has_free_typevars(aft)) ||
-                   (isconcrete(aft) && !(aft <: Builtin) && !(aft <: IntrinsicFunction))
+                   (isconcrete(aft) && !(aft <: Builtin))
                 af_argtype = isa(tt, Const) ? tt.val : tt.parameters[1]
                 if isa(af_argtype, DataType) && af_argtype <: Tuple
                     argtypes_vec = Any[aft, af_argtype.parameters...]
+                    astype = argtypes_to_type(argtypes_vec)
                     if isa(aft, Const)
                         rt = abstract_call(aft.val, (), argtypes_vec, vtypes, sv)
                     elseif isconstType(aft)
                         rt = abstract_call(aft.parameters[1], (), argtypes_vec, vtypes, sv)
                     else
-                        rt = abstract_call_gf_by_type(nothing, argtypes_to_type(argtypes_vec), sv)
+                        rt = abstract_call_gf_by_type(nothing, astype, sv)
                     end
                     if isa(rt, Const)
                         # output was computed to be constant
                         return Const(typeof(rt.val))
-                    elseif isconcrete(rt)
+                    elseif isconcrete(rt) || rt === Bottom
                         # output type was known for certain
                         return Const(rt)
                     elseif (isa(tt, Const) || isconstType(tt)) &&
@@ -1544,7 +2026,7 @@ function return_type_tfunc(argtypes::ANY, vtypes::VarTable, sv::InferenceState)
     return NF
 end
 
-function pure_eval_call(f::ANY, argtypes::ANY, atype::ANY, vtypes::VarTable, sv::InferenceState)
+function pure_eval_call(@nospecialize(f), @nospecialize(argtypes), @nospecialize(atype), sv::InferenceState)
     for i = 2:length(argtypes)
         a = argtypes[i]
         if !(isa(a,Const) || isconstType(a))
@@ -1561,7 +2043,7 @@ function pure_eval_call(f::ANY, argtypes::ANY, atype::ANY, vtypes::VarTable, sv:
     meth = meth[1]::SimpleVector
     method = meth[3]::Method
     # TODO: check pure on the inferred thunk
-    if method.isstaged || !method.source.pure
+    if isdefined(method, :generator) || !method.pure
         return false
     end
 
@@ -1569,13 +2051,13 @@ function pure_eval_call(f::ANY, argtypes::ANY, atype::ANY, vtypes::VarTable, sv:
     try
         value = Core._apply_pure(f, args)
         # TODO: add some sort of edge(s)
-        return abstract_eval_constant(value)
+        return Const(value, true)
     catch
         return false
     end
 end
 
-argtypes_to_type(argtypes::Array{Any,1}) = Tuple{map(widenconst, argtypes)...}
+argtypes_to_type(argtypes::Array{Any,1}) = Tuple{anymap(widenconst, argtypes)...}
 
 _Pair_name = nothing
 function Pair_name()
@@ -1598,35 +2080,19 @@ function _typename(a::Union)
     ta === tb ? tb : (ta === Any || tb === Any) ? Any : Union{}
 end
 _typename(union::UnionAll) = _typename(union.body)
-function typename_static(t)
-    # N.B.: typename maps type equivalence classes to a single value
-    if isa(t, Const) || isType(t)
-        return _typename(isa(t, Const) ? t.val : t.parameters[1])
-    else
-        return Any
-    end
-end
 
-function abstract_call(f::ANY, fargs::Union{Tuple{},Vector{Any}}, argtypes::Vector{Any}, vtypes::VarTable, sv::InferenceState)
+# N.B.: typename maps type equivalence classes to a single value
+typename_static(t::Const) = _typename(t.val)
+typename_static(@nospecialize(t)) = isType(t) ? _typename(t.parameters[1]) : Any
+
+function abstract_call(@nospecialize(f), fargs::Union{Tuple{},Vector{Any}}, argtypes::Vector{Any}, vtypes::VarTable, sv::InferenceState)
     if f === _apply
         length(fargs) > 1 || return Any
-        aft = argtypes[2]
-        if isa(aft, Const)
-            af = aft.val
-        else
-            if isType(aft) && isconcrete(aft.parameters[1])
-                af = aft.parameters[1]
-            elseif isconcrete(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
-        end
-        return abstract_apply(af, fargs[3:end], argtypes[3:end], vtypes, sv)
+        return abstract_apply(argtypes[2], fargs[3:end], argtypes[3:end], vtypes, sv)
     end
 
-    for i = 2:(length(argtypes) - 1)
+    la = length(argtypes)
+    for i = 2:(la - 1)
         if isvarargtype(argtypes[i])
             return Any
         end
@@ -1641,14 +2107,9 @@ function abstract_call(f::ANY, fargs::Union{Tuple{},Vector{Any}}, argtypes::Vect
                 a = fargs[2]
                 if isa(a, fieldtype(Conditional, :var))
                     aty = widenconst(argtypes[2])
-                    tty = instanceof_tfunc(argtypes[3])
-                    if tty !== Any && tty !== Bottom
-                        if isa(tty, TypeVar)
-                            tty_ub = tty.ub
-                            tty_lb = tty.lb
-                        else
-                            tty_ub = tty_lb = tty
-                        end
+                    tty_ub, isexact_tty = instanceof_tfunc(argtypes[3])
+                    if isexact_tty && !isa(tty_ub, TypeVar)
+                        tty_lb = tty_ub # TODO: this would be wrong if !isexact_tty, but instanceof_tfunc doesn't preserve this info
                         if !has_free_typevars(tty_lb) && !has_free_typevars(tty_ub)
                             ifty = typeintersect(aty, tty_ub)
                             elsety = typesubtract(aty, tty_lb)
@@ -1683,7 +2144,7 @@ function abstract_call(f::ANY, fargs::Union{Tuple{},Vector{Any}}, argtypes::Vect
     elseif f === Core.kwfunc
         if length(fargs) == 2
             ft = widenconst(argtypes[2])
-            if isa(ft,DataType) && isdefined(ft.name, :mt) && isdefined(ft.name.mt, :kwsorter)
+            if isa(ft, DataType) && isdefined(ft.name, :mt) && isdefined(ft.name.mt, :kwsorter)
                 return Const(ft.name.mt.kwsorter)
             end
         end
@@ -1731,6 +2192,10 @@ function abstract_call(f::ANY, fargs::Union{Tuple{},Vector{Any}}, argtypes::Vect
             else
                 return Any
             end
+            if !isa(body, Type) && !isa(body, TypeVar)
+                return Any
+            end
+            has_free_typevars(body) || return body
             if isa(argtypes[2], Const)
                 tv = argtypes[2].val
             elseif isa(argtypes[2], PartialTypeVar)
@@ -1741,9 +2206,6 @@ function abstract_call(f::ANY, fargs::Union{Tuple{},Vector{Any}}, argtypes::Vect
                 return Any
             end
             !isa(tv, TypeVar) && return Any
-            if !isa(body, Type) && !isa(body, TypeVar)
-                return Any
-            end
             theunion = UnionAll(tv, body)
             ret = canconst ? abstract_eval_constant(theunion) : Type{theunion}
             return ret
@@ -1769,52 +2231,52 @@ function abstract_call(f::ANY, fargs::Union{Tuple{},Vector{Any}}, argtypes::Vect
         end
         return rty
     elseif length(fargs) == 3 && istopfunction(tm, f, :(>:))
-        # swap T1 and T2 arguments and call issubtype
-        fargs = Any[issubtype, fargs[3], fargs[2]]
-        argtypes = Any[typeof(issubtype), argtypes[3], argtypes[2]]
-        rty = abstract_call(issubtype, fargs, argtypes, vtypes, sv)
+        # swap T1 and T2 arguments and call <:
+        fargs = Any[<:, fargs[3], fargs[2]]
+        argtypes = Any[typeof(<:), argtypes[3], argtypes[2]]
+        rty = abstract_call(<:, fargs, argtypes, vtypes, sv)
         return rty
     end
 
-    if length(argtypes)>2 && argtypes[3] ⊑ Int
+    if la>2 && argtypes[3] ⊑ Int
         at2 = widenconst(argtypes[2])
-        if at2 <: SimpleVector && istopfunction(tm, f, :getindex)
+        if la==3 && at2 <: SimpleVector && istopfunction(tm, f, :getindex)
             if isa(argtypes[2], Const) && isa(argtypes[3], Const)
                 svecval = argtypes[2].val
                 idx = argtypes[3].val
-                if isa(idx, Int) && 1 <= idx <= length(svecval) &
+                if isa(idx, Int) && 1 <= idx <= length(svecval) &&
                       isassigned(svecval, idx)
                     return Const(getindex(svecval, idx))
                 end
             end
         elseif (at2 <: Tuple ||
-            (isa(at2, DataType) && (at2::DataType).name === Pair_name()))
+                (isa(at2, DataType) && (at2::DataType).name === Pair_name()))
             # allow tuple indexing functions to take advantage of constant
             # index arguments.
-            if istopfunction(tm, f, :getindex)
+            if istopfunction(tm, f, :getindex) && la==3
                 return getfield_tfunc(argtypes[2], argtypes[3])
-            elseif istopfunction(tm, f, :next)
+            elseif istopfunction(tm, f, :next) && la==3
                 t1 = widenconst(getfield_tfunc(argtypes[2], argtypes[3]))
                 return t1===Bottom ? Bottom : Tuple{t1, Int}
-            elseif istopfunction(tm, f, :indexed_next)
+            elseif istopfunction(tm, f, :indexed_next) && la==4
                 t1 = widenconst(getfield_tfunc(argtypes[2], argtypes[3]))
                 return t1===Bottom ? Bottom : Tuple{t1, Int}
             end
         end
+    elseif la==2 && argtypes[2] ⊑ SimpleVector && istopfunction(tm, f, :length)
+        if isa(argtypes[2], Const)
+            return Const(length(argtypes[2].val))
+        end
     end
 
     atype = argtypes_to_type(argtypes)
-    t = pure_eval_call(f, argtypes, atype, vtypes, sv)
+    t = pure_eval_call(f, argtypes, atype, sv)
     t !== false && return t
 
-    if istopfunction(tm, f, :promote_type) || istopfunction(tm, f, :typejoin)
-        return Type
+    if istopfunction(tm, f, :typejoin) || f === return_type
+        return Type # don't try to infer these function edges directly -- it won't actually come up with anything useful
     elseif length(argtypes) == 2 && istopfunction(tm, f, :typename)
-        t = argtypes[2]
-        if isa(t, Const) || isType(t)
-            return typename_static(t)
-        end
-        return Any
+        return typename_static(argtypes[2])
     end
 
     if sv.params.inlining
@@ -1869,7 +2331,7 @@ end
 
 const _Ref_name = Ref.body.name
 
-function abstract_eval(e::ANY, vtypes::VarTable, sv::InferenceState)
+function abstract_eval(@nospecialize(e), vtypes::VarTable, sv::InferenceState)
     if isa(e, QuoteNode)
         return abstract_eval_constant((e::QuoteNode).value)
     elseif isa(e, SSAValue)
@@ -1891,7 +2353,7 @@ function abstract_eval(e::ANY, vtypes::VarTable, sv::InferenceState)
     elseif e.head === :null
         t = Void
     elseif e.head === :new
-        t = instanceof_tfunc(abstract_eval(e.args[1], vtypes, sv))
+        t = instanceof_tfunc(abstract_eval(e.args[1], vtypes, sv))[1]
         for i = 2:length(e.args)
             if abstract_eval(e.args[i], vtypes, sv) === Bottom
                 rt = Bottom
@@ -1902,11 +2364,15 @@ function abstract_eval(e::ANY, vtypes::VarTable, sv::InferenceState)
         t = Any
     elseif e.head === :foreigncall
         rt = e.args[2]
-        if isdefined(sv.linfo, :def)
+        if isa(sv.linfo.def, Method)
             spsig = sv.linfo.def.sig
             if isa(spsig, UnionAll)
-                env = data_pointer_from_objref(sv.linfo.sparam_vals) + sizeof(Ptr{Void})
-                rt = ccall(:jl_instantiate_type_in_env, Any, (Any, Any, Ptr{Any}), e.args[2], spsig, env)
+                if !isempty(sv.linfo.sparam_vals)
+                    env = data_pointer_from_objref(sv.linfo.sparam_vals) + sizeof(Ptr{Void})
+                    rt = ccall(:jl_instantiate_type_in_env, Any, (Any, Any, Ptr{Any}), e.args[2], spsig, env)
+                else
+                    rt = rewrap_unionall(e.args[2], spsig)
+                end
             end
         end
         abstract_eval(e.args[1], vtypes, sv)
@@ -1936,14 +2402,17 @@ function abstract_eval(e::ANY, vtypes::VarTable, sv::InferenceState)
     elseif e.head === :static_parameter
         n = e.args[1]
         t = Any
-        if n <= length(sv.sp)
+        if 1 <= n <= length(sv.sp)
             val = sv.sp[n]
-            if isa(val, TypeVar)
+            if isa(val, TypeVar) && Any <: val.ub
                 # static param bound to typevar
-                # if the tvar does not refer to anything more specific than Any,
+                # if the tvar is not known to refer to anything more specific than Any,
                 # the static param might actually be an integer, symbol, etc.
-                if !(Any <: val.ub)
-                    t = UnionAll(val, Type{val})
+            elseif has_free_typevars(val)
+                vs = ccall(:jl_find_free_typevars, Any, (Any,), val)
+                t = Type{val}
+                for v in vs
+                    t = UnionAll(v, t)
                 end
             else
                 t = abstract_eval_constant(val)
@@ -1957,6 +2426,31 @@ function abstract_eval(e::ANY, vtypes::VarTable, sv::InferenceState)
         return abstract_eval_constant(e.args[1])
     elseif e.head === :invoke
         error("type inference data-flow error: tried to double infer a function")
+    elseif e.head === :isdefined
+        sym = e.args[1]
+        t = Bool
+        if isa(sym, Slot)
+            vtyp = vtypes[slot_id(sym)]
+            if vtyp.typ === Bottom
+                t = Const(false) # never assigned previously
+            elseif !vtyp.undef
+                t = Const(true) # definitely assigned previously
+            end
+        elseif isa(sym, Symbol)
+            if isdefined(sv.mod, sym.name)
+                t = Const(true)
+            end
+        elseif isa(sym, GlobalRef)
+            if isdefined(sym.mod, sym.name)
+                t = Const(true)
+            end
+        elseif isa(sym, Expr) && sym.head === :static_parameter
+            n = sym.args[1]
+            if 1 <= n <= length(sv.sp)
+                val = sv.sp[n]
+                t = Const(true)
+            end
+        end
     else
         t = Any
     end
@@ -1976,14 +2470,7 @@ function abstract_eval(e::ANY, vtypes::VarTable, sv::InferenceState)
     return t
 end
 
-const Type_Array = Const(Array)
-
-function abstract_eval_constant(x::ANY)
-    if x === Array
-        return Type_Array
-    end
-    return Const(x)
-end
+const abstract_eval_constant = Const
 
 function abstract_eval_global(M::Module, s::Symbol)
     if isdefined(M,s) && isconst(M,s)
@@ -2009,7 +2496,7 @@ mutable struct StateUpdate
     state::VarTable
 end
 
-function abstract_interpret(e::ANY, vtypes::VarTable, sv::InferenceState)
+function abstract_interpret(@nospecialize(e), vtypes::VarTable, sv::InferenceState)
     !isa(e, Expr) && return vtypes
     # handle assignment
     if e.head === :(=)
@@ -2035,18 +2522,18 @@ function abstract_interpret(e::ANY, vtypes::VarTable, sv::InferenceState)
     return vtypes
 end
 
-function type_too_complex(t::ANY, d)
-    if d > MAX_TYPE_DEPTH
+function type_too_complex(@nospecialize(t), d::Int)
+    if d < 0
         return true
-    elseif isa(t,Union)
-        return type_too_complex(t.a, d+1) || type_too_complex(t.b, d+1)
-    elseif isa(t,TypeVar)
-        return type_too_complex(t.lb,d+1) || type_too_complex(t.ub,d+1)
-    elseif isa(t,UnionAll)
+    elseif isa(t, Union)
+        return type_too_complex(t.a, d - 1) || type_too_complex(t.b, d - 1)
+    elseif isa(t, TypeVar)
+        return type_too_complex(t.lb, d - 1) || type_too_complex(t.ub, d - 1)
+    elseif isa(t, UnionAll)
         return type_too_complex(t.var, d) || type_too_complex(t.body, d)
-    elseif isa(t,DataType)
+    elseif isa(t, DataType)
         for x in (t.parameters)::SimpleVector
-            if type_too_complex(x, d+1)
+            if type_too_complex(x, d - 1)
                 return true
             end
         end
@@ -2070,9 +2557,11 @@ function issubconditional(a::Conditional, b::Conditional)
     return false
 end
 
-function ⊑(a::ANY, b::ANY)
-    a === NF && return true
-    b === NF && return false
+function ⊑(@nospecialize(a), @nospecialize(b))
+    (a === NF || b === Any) && return true
+    (a === Any || b === NF) && return false
+    a === Union{} && return true
+    b === Union{} && return false
     if isa(a, Conditional)
         if isa(b, Conditional)
             return issubconditional(a, b)
@@ -2085,7 +2574,7 @@ function ⊑(a::ANY, b::ANY)
         if isa(b, Const)
             return a.val === b.val
         end
-        return isa(a.val, b)
+        return isa(a.val, widenconst(b))
     elseif isa(b, Const)
         return a === Bottom
     elseif !(isa(a, Type) || isa(a, TypeVar)) ||
@@ -2108,7 +2597,7 @@ function widenconst(c::Const)
     end
 end
 widenconst(c::PartialTypeVar) = TypeVar
-widenconst(t::ANY) = t
+widenconst(@nospecialize(t)) = t
 
 issubstate(a::VarState, b::VarState) = (a.typ ⊑ b.typ && a.undef <= b.undef)
 
@@ -2116,10 +2605,10 @@ issubstate(a::VarState, b::VarState) = (a.typ ⊑ b.typ && a.undef <= b.undef)
 # in a dead branch but can be ignored when analyzing uses/liveness.
 is_meta_expr_head(head::Symbol) =
     (head === :inbounds || head === :boundscheck || head === :meta ||
-     head === :line)
+     head === :line || head === :simdloop)
 is_meta_expr(ex::Expr) = is_meta_expr_head(ex.head)
 
-function tmerge(typea::ANY, typeb::ANY)
+function tmerge(@nospecialize(typea), @nospecialize(typeb))
     typea ⊑ typeb && return typeb
     typeb ⊑ typea && return typea
     if isa(typea, Conditional) && isa(typeb, Conditional)
@@ -2149,7 +2638,7 @@ function tmerge(typea::ANY, typeb::ANY)
         end
     end
     u = Union{typea, typeb}
-    if unionlen(u) > MAX_TYPEUNION_LEN || type_too_complex(u, 0)
+    if unionlen(u) > MAX_TYPEUNION_LEN || type_too_complex(u, MAX_TYPE_DEPTH)
         # don't let type unions get too big
         # TODO: something smarter, like a common supertype
         return Any
@@ -2166,8 +2655,8 @@ function smerge(sa::Union{NotFound,VarState}, sb::Union{NotFound,VarState})
     return VarState(tmerge(sa.typ, sb.typ), sa.undef | sb.undef)
 end
 
-@inline tchanged(n::ANY, o::ANY) = o === NF || (n !== NF && !(n ⊑ o))
-@inline schanged(n::ANY, o::ANY) = (n !== o) && (o === NF || (n !== NF && !issubstate(n, o)))
+@inline tchanged(@nospecialize(n), @nospecialize(o)) = o === NF || (n !== NF && !(n ⊑ o))
+@inline schanged(@nospecialize(n), @nospecialize(o)) = (n !== o) && (o === NF || (n !== NF && !issubstate(n, o)))
 
 function stupdate!(state::Tuple{}, changes::StateUpdate)
     newst = copy(changes.state)
@@ -2232,52 +2721,56 @@ end
 
 #### helper functions for typeinf initialization and looping ####
 
-function label_counter(body)
+function label_counter(body::Vector{Any})
     l = -1
     for b in body
-        if isa(b,LabelNode) && (b::LabelNode).label > l
-            l = (b::LabelNode).label
+        if isa(b, LabelNode) && b.label > l
+            l = b.label
         end
     end
     return l
 end
 genlabel(sv) = LabelNode(sv.label_counter += 1)
 
-function find_ssavalue_uses(body)
-    uses = IntSet[]
-    for line = 1:length(body)
-        find_ssavalue_uses(body[line], uses, line)
+function find_ssavalue_uses(body::Vector{Any}, nvals::Int)
+    uses = IntSet[ IntSet() for i = 1:nvals ]
+    for line in 1:length(body)
+        e = body[line]
+        isa(e, Expr) && find_ssavalue_uses(e, uses, line)
     end
     return uses
 end
-function find_ssavalue_uses(e::ANY, uses, line)
-    if isa(e,SSAValue)
-        id = (e::SSAValue).id + 1
-        while length(uses) < id
-            push!(uses, IntSet())
+
+function find_ssavalue_uses(e::Expr, uses::Vector{IntSet}, line::Int)
+    head = e.head
+    is_meta_expr_head(head) && return
+    skiparg = (head === :(=))
+    for a in e.args
+        if skiparg
+            skiparg = false
+        elseif isa(a, SSAValue)
+            push!(uses[a.id + 1], line)
+        elseif isa(a, Expr)
+            find_ssavalue_uses(a, uses, line)
         end
-        push!(uses[id], line)
-    elseif isa(e,Expr)
-        b = e::Expr
-        head = b.head
-        is_meta_expr_head(head) && return
-        if head === :(=)
-            if isa(b.args[1],SSAValue)
-                id = (b.args[1]::SSAValue).id + 1
-                while length(uses) < id
-                    push!(uses, IntSet())
-                end
+    end
+end
+
+function find_ssavalue_defs(body::Vector{Any}, nvals::Int)
+    defs = zeros(Int, nvals)
+    for line in 1:length(body)
+        e = body[line]
+        if isa(e, Expr) && e.head === :(=)
+            lhs = e.args[1]
+            if isa(lhs, SSAValue)
+                defs[lhs.id + 1] = line
             end
-            find_ssavalue_uses(b.args[2], uses, line)
-            return
-        end
-        for a in b.args
-            find_ssavalue_uses(a, uses, line)
         end
     end
+    return defs
 end
 
-function newvar!(sv::InferenceState, typ::ANY)
+function newvar!(sv::InferenceState, @nospecialize(typ))
     id = length(sv.src.ssavaluetypes)
     push!(sv.src.ssavaluetypes, typ)
     return SSAValue(id)
@@ -2286,44 +2779,19 @@ end
 inlining_enabled() = (JLOptions().can_inline == 1)
 coverage_enabled() = (JLOptions().code_coverage != 0)
 
-# TODO: track the worlds for which this InferenceState
-# is being used, and split it if the WIP requires it?
-function converge_valid_age!(sv::InferenceState)
-    # push the validity range of sv into its fixedpoint callers
-    # recursing as needed to cover the graph
-    for (i, _) in sv.backedges
-        if i.fixedpoint
-            updated = false
-            if i.min_valid < sv.min_valid
-                i.min_valid = sv.min_valid
-                updated = true
-            end
-            if i.max_valid > sv.max_valid
-                i.max_valid = sv.max_valid
-                updated = true
-            end
-            @assert !isdefined(i.linfo, :def) || !i.cached || i.min_valid <= i.params.world <= i.max_valid "invalid age range update"
-            if updated
-                converge_valid_age!(i)
-            end
-        end
-    end
-    nothing
-end
-
 # work towards converging the valid age range for sv
 function update_valid_age!(min_valid::UInt, max_valid::UInt, sv::InferenceState)
     sv.min_valid = max(sv.min_valid, min_valid)
     sv.max_valid = min(sv.max_valid, max_valid)
-    @assert !isdefined(sv.linfo, :def) || !sv.cached || sv.min_valid <= sv.params.world <= sv.max_valid "invalid age range update"
+    @assert !isa(sv.linfo.def, Method) || !sv.cached || sv.min_valid <= sv.params.world <= sv.max_valid "invalid age range update"
     nothing
 end
 update_valid_age!(edge::InferenceState, sv::InferenceState) = update_valid_age!(edge.min_valid, edge.max_valid, sv)
 update_valid_age!(li::MethodInstance, sv::InferenceState) = update_valid_age!(min_world(li), max_world(li), sv)
 
 # temporarily accumulate our edges to later add as backedges in the callee
-function add_backedge(li::MethodInstance, caller::InferenceState)
-    isdefined(caller.linfo, :def) || return # don't add backedges to toplevel exprs
+function add_backedge!(li::MethodInstance, caller::InferenceState)
+    isa(caller.linfo.def, Method) || return # don't add backedges to toplevel exprs
     if caller.stmt_edges[caller.currpc] === ()
         caller.stmt_edges[caller.currpc] = []
     end
@@ -2333,8 +2801,8 @@ function add_backedge(li::MethodInstance, caller::InferenceState)
 end
 
 # temporarily accumulate our no method errors to later add as backedges in the callee method table
-function add_mt_backedge(mt::MethodTable, typ::ANY, caller::InferenceState)
-    isdefined(caller.linfo, :def) || return # don't add backedges to toplevel exprs
+function add_mt_backedge(mt::MethodTable, @nospecialize(typ), caller::InferenceState)
+    isa(caller.linfo.def, Method) || return # don't add backedges to toplevel exprs
     if caller.stmt_edges[caller.currpc] === ()
         caller.stmt_edges[caller.currpc] = []
     end
@@ -2345,7 +2813,7 @@ end
 
 # add the real backedges now
 function finalize_backedges(frame::InferenceState)
-    toplevel = !isdefined(frame.linfo, :def)
+    toplevel = !isa(frame.linfo.def, Method)
     if !toplevel && frame.cached && frame.max_valid == typemax(UInt)
         caller = frame.linfo
         for edges in frame.stmt_edges
@@ -2366,11 +2834,11 @@ function finalize_backedges(frame::InferenceState)
     end
 end
 
-function code_for_method(method::Method, atypes::ANY, sparams::SimpleVector, world::UInt, preexisting::Bool=false)
-    if world < min_world(method) || world > max_world(method)
+function code_for_method(method::Method, @nospecialize(atypes), sparams::SimpleVector, world::UInt, preexisting::Bool=false)
+    if world < min_world(method)
         return nothing
     end
-    if method.isstaged && !isconcrete(atypes)
+    if isdefined(method, :generator) && !isconcrete(atypes)
         # don't call staged functions on abstract types.
         # (see issues #8504, #10230)
         # we can't guarantee that their type behavior is monotonic.
@@ -2388,72 +2856,92 @@ function code_for_method(method::Method, atypes::ANY, sparams::SimpleVector, wor
     return ccall(:jl_specializations_get_linfo, Ref{MethodInstance}, (Any, Any, Any, UInt), method, atypes, sparams, world)
 end
 
-function typeinf_active(linfo::MethodInstance)
-    for infstate in active
-        infstate === nothing && continue
-        infstate = infstate::InferenceState
-        if linfo === infstate.linfo
-            return infstate
-        end
+function typeinf_active(linfo::MethodInstance, sv::InferenceState)
+    for infstate in sv.callers_in_cycle
+        linfo === infstate.linfo && return infstate
     end
     return nothing
 end
 
-function add_backedge(frame::InferenceState, caller::InferenceState, currpc::Int)
+function add_backedge!(frame::InferenceState, caller::InferenceState, currpc::Int)
     update_valid_age!(frame, caller)
-    if haskey(caller.edges, frame)
-        Ws = caller.edges[frame]::Vector{Int}
-        if !(currpc in Ws)
-            push!(Ws, currpc)
+    backedge = (caller, currpc)
+    contains_is(frame.backedges, backedge) || push!(frame.backedges, backedge)
+    return frame
+end
+
+# at the end, all items in b's cycle
+# will now be added to a's cycle
+function union_caller_cycle!(a::InferenceState, b::InferenceState)
+    callers_in_cycle = b.callers_in_cycle
+    b.parent = a.parent
+    b.callers_in_cycle = a.callers_in_cycle
+    contains_is(a.callers_in_cycle, b) || push!(a.callers_in_cycle, b)
+    if callers_in_cycle !== a.callers_in_cycle
+        for caller in callers_in_cycle
+            if caller !== b
+                caller.parent = a.parent
+                caller.callers_in_cycle = a.callers_in_cycle
+                push!(a.callers_in_cycle, caller)
+            end
         end
-    else
-        Ws = Int[currpc]
-        caller.edges[frame] = Ws
-        push!(frame.backedges, (caller, Ws))
     end
+    return
 end
 
-# build (and start inferring) the inference frame for the linfo
-function typeinf_frame(linfo::MethodInstance, caller, optimize::Bool, cached::Bool,
-                       params::InferenceParams)
-    # println(params.world, ' ', linfo)
-    if cached && linfo.inInference
-        # inference on this signature may be in progress,
-        # find the corresponding frame in the active list
-        frame = typeinf_active(linfo)
-        # TODO: this assertion seems iffy
-        assert(frame !== nothing)
-    else
-        # inference not started yet, make a new frame for a new lambda
-        if linfo.def.isstaged
-            try
-                # user code might throw errors – ignore them
-                src = get_staged(linfo)
-            catch
-                return nothing
+function merge_call_chain!(parent::InferenceState, ancestor::InferenceState, child::InferenceState)
+    # add backedge of parent <- child
+    # then add all backedges of parent <- parent.parent
+    # and merge all of the callers into ancestor.callers_in_cycle
+    # and ensure that walking the parent list will get the same result (DAG) from everywhere
+    while true
+        add_backedge!(child, parent, parent.currpc)
+        union_caller_cycle!(ancestor, child)
+        child = parent
+        parent = child.parent
+        child === ancestor && break
+    end
+end
+
+# Walk through `linfo`'s upstream call chain, starting at `parent`. If a parent
+# frame matching `linfo` is encountered, then there is a cycle in the call graph
+# (i.e. `linfo` is a descendant callee of itself). Upon encountering this cycle,
+# we "resolve" it by merging the call chain, which entails unioning each intermediary
+# frame's `callers_in_cycle` field and adding the appropriate backedges. Finally,
+# we return `linfo`'s pre-existing frame. If no cycles are found, `nothing` is
+# returned instead.
+function resolve_call_cycle!(linfo::MethodInstance, parent::InferenceState)
+    frame = parent
+    while isa(frame, InferenceState)
+        if frame.linfo === linfo
+            merge_call_chain!(parent, frame, frame)
+            return frame
+        end
+        for caller in frame.callers_in_cycle
+            if caller.linfo === linfo
+                merge_call_chain!(parent, frame, caller)
+                return caller
             end
-        else
-            src = get_source(linfo)
         end
-        cached && (linfo.inInference = true)
-        frame = InferenceState(linfo, src, optimize, cached, params)
+        frame = frame.parent
     end
-    frame = frame::InferenceState
+    return nothing
+end
 
-    if isa(caller, InferenceState)
-        # if we were called from inside inference, the caller will be the InferenceState object
-        # for which the edge was required
-        @assert caller.currpc > 0
-        add_backedge(frame, caller, caller.currpc)
-    end
-    typeinf_loop(frame)
+# build (and start inferring) the inference frame for the linfo
+function typeinf_frame(linfo::MethodInstance,
+                       optimize::Bool, cached::Bool, params::InferenceParams)
+    frame = InferenceState(linfo, optimize, cached, params)
+    frame === nothing && return nothing
+    cached && (linfo.inInference = true)
+    typeinf(frame)
     return frame
 end
 
 # compute (and cache) an inferred AST and return the current best estimate of the result type
-function typeinf_edge(method::Method, atypes::ANY, sparams::SimpleVector, caller::InferenceState)
+function typeinf_edge(method::Method, @nospecialize(atypes), sparams::SimpleVector, caller::InferenceState)
     code = code_for_method(method, atypes, sparams, caller.params.world)
-    code === nothing && return Any
+    code === nothing && return Any, nothing
     code = code::MethodInstance
     if isdefined(code, :inferred)
         # return rettype if the code is already inferred
@@ -2461,24 +2949,36 @@ function typeinf_edge(method::Method, atypes::ANY, sparams::SimpleVector, caller
         # so need to check whether the code itself is also inferred
         inf = code.inferred
         if !isa(inf, CodeInfo) || (inf::CodeInfo).inferred
-            add_backedge(code, caller)
             if isdefined(code, :inferred_const)
-                return abstract_eval_constant(code.inferred_const)
+                return abstract_eval_constant(code.inferred_const), code
             else
-                return code.rettype
+                return code.rettype, code
             end
         end
     end
-    frame = typeinf_frame(code, caller, true, true, caller.params)
-    frame === nothing && return Any
+    frame = resolve_call_cycle!(code, caller)
+    if frame === nothing
+        code.inInference = true
+        frame = InferenceState(code, #=optimize=#true, #=cached=#true, caller.params) # always optimize and cache edge targets
+        if frame === nothing
+            code.inInference = false
+            return Any, nothing
+        end
+        if caller.cached # don't involve uncached functions in cycle resolution
+            frame.parent = caller
+        end
+        typeinf(frame)
+        return frame.bestguess, frame.inferred ? frame.linfo : nothing
+    end
     frame = frame::InferenceState
-    return frame.bestguess
+    return frame.bestguess, nothing
 end
 
+
 #### entry points for inferring a MethodInstance given a type signature ####
 
 # compute an inferred AST and return type
-function typeinf_code(method::Method, atypes::ANY, sparams::SimpleVector,
+function typeinf_code(method::Method, @nospecialize(atypes), sparams::SimpleVector,
                       optimize::Bool, cached::Bool, params::InferenceParams)
     code = code_for_method(method, atypes, sparams, params.world)
     code === nothing && return (nothing, nothing, Any)
@@ -2492,12 +2992,12 @@ function typeinf_code(linfo::MethodInstance, optimize::Bool, cached::Bool,
             # see if this code already exists in the cache
             # staged functions make this hard since they have two "inferred" conditions,
             # so need to check whether the code itself is also inferred
-            inf = linfo.inferred
             if min_world(linfo) <= params.world <= max_world(linfo)
+                inf = linfo.inferred
                 if linfo.jlcall_api == 2
-                    method = linfo.def
+                    method = linfo.def::Method
                     tree = ccall(:jl_new_code_info_uninit, Ref{CodeInfo}, ())
-                    tree.code = Any[ Expr(:return, QuoteNode(inf)) ]
+                    tree.code = Any[ Expr(:return, QuoteNode(linfo.inferred_const)) ]
                     tree.slotnames = Any[ compiler_temp_sym for i = 1:method.nargs ]
                     tree.slotflags = UInt8[ 0 for i = 1:method.nargs ]
                     tree.slottypes = nothing
@@ -2508,7 +3008,7 @@ function typeinf_code(linfo::MethodInstance, optimize::Bool, cached::Bool,
                     i == 2 && ccall(:jl_typeinf_end, Void, ())
                     return svec(linfo, tree, linfo.rettype)
                 elseif isa(inf, CodeInfo)
-                    if (inf::CodeInfo).inferred
+                    if inf.inferred
                         i == 2 && ccall(:jl_typeinf_end, Void, ())
                         return svec(linfo, inf, linfo.rettype)
                     end
@@ -2516,7 +3016,7 @@ function typeinf_code(linfo::MethodInstance, optimize::Bool, cached::Bool,
             end
         end
     end
-    frame = typeinf_frame(linfo, nothing, optimize, cached, params)
+    frame = typeinf_frame(linfo, optimize, cached, params)
     ccall(:jl_typeinf_end, Void, ())
     frame === nothing && return svec(nothing, nothing, Any)
     frame = frame::InferenceState
@@ -2526,7 +3026,7 @@ function typeinf_code(linfo::MethodInstance, optimize::Bool, cached::Bool,
 end
 
 # compute (and cache) an inferred AST and return the inferred return type
-function typeinf_type(method::Method, atypes::ANY, sparams::SimpleVector,
+function typeinf_type(method::Method, @nospecialize(atypes), sparams::SimpleVector,
                       cached::Bool, params::InferenceParams)
     code = code_for_method(method, atypes, sparams, params.world)
     code === nothing && return nothing
@@ -2544,7 +3044,7 @@ function typeinf_type(method::Method, atypes::ANY, sparams::SimpleVector,
             end
         end
     end
-    frame = typeinf_frame(code, nothing, cached, cached, params)
+    frame = typeinf_frame(code, cached, cached, params)
     ccall(:jl_typeinf_end, Void, ())
     frame === nothing && return nothing
     frame = frame::InferenceState
@@ -2553,16 +3053,15 @@ function typeinf_type(method::Method, atypes::ANY, sparams::SimpleVector,
 end
 
 function typeinf_ext(linfo::MethodInstance, world::UInt)
-    if isdefined(linfo, :def)
+    if isa(linfo.def, Method)
         # method lambda - infer this specialization via the method cache
         return typeinf_code(linfo, true, true, InferenceParams(world))
     else
         # toplevel lambda - infer directly
-        linfo.inInference = true
         ccall(:jl_typeinf_begin, Void, ())
         frame = InferenceState(linfo, linfo.inferred::CodeInfo,
                                true, true, InferenceParams(world))
-        typeinf_loop(frame)
+        typeinf(frame)
         ccall(:jl_typeinf_end, Void, ())
         @assert frame.inferred # TODO: deal with this better
         @assert frame.linfo === linfo
@@ -2572,83 +3071,9 @@ end
 
 #### do the work of inference ####
 
-in_typeinf_loop = false
-function typeinf_loop(frame)
-    global in_typeinf_loop
-    if in_typeinf_loop
-        frame.inworkq || typeinf_frame(frame)
-        return
-    end
-    try
-        in_typeinf_loop = true
-        # the core type-inference algorithm
-        # processes everything in workq,
-        # and returns when there is nothing left
-        while nactive[] > 0
-            while active[end] === nothing
-                pop!(active)
-            end
-            if isempty(workq)
-                frame = active[end]::InferenceState
-            else
-                frame = pop!(workq)
-            end
-            typeinf_frame(frame)
-            if isempty(workq) && nactive[] > 0
-                # nothing in active has an edge that hasn't reached a fixed-point
-                # so all of them can be considered finished now
-                fplist = Any[]
-                for i in active
-                    i === nothing && continue
-                    i = i::InferenceState
-                    if i.fixedpoint
-                        push!(fplist, i)
-                        i.inworkq = true
-                    end
-                end
-                for i in length(fplist):-1:1
-                    # optimize and record the results
-                    # the reverse order makes it more likely to inline a callee into its caller
-                    optimize(fplist[i]::InferenceState) # this may add incomplete work to active
-                end
-                for i in fplist
-                    # push valid ages from each node across the graph cycle
-                    converge_valid_age!(i::InferenceState)
-                end
-                for i in fplist
-                    # record the results
-                    finish(i::InferenceState)
-                end
-                for i in fplist
-                    # update and record all of the back edges for the finished world
-                    finalize_backedges(i::InferenceState)
-                end
-            end
-        end
-        # cleanup the active queue
-        empty!(active)
-    #    while active[end] === nothing
-    #        # this pops everything, but with exaggerated care just in case
-    #        # something managed to add something to the queue at the same time
-    #        # (or someone decides to use an alternative termination condition)
-    #        pop!(active)
-    #    end
-        in_typeinf_loop = false
-    catch ex
-        println("WARNING: An error occurred during inference. Type inference is now partially disabled.")
-        println(ex)
-        ccall(:jlbacktrace, Void, ())
-    end
-    nothing
-end
-
-global_sv = nothing
-function typeinf_frame(frame)
-    global global_sv # TODO: actually pass this to all functions that need it
-    last_global_sv = global_sv
-    global_sv = frame
+function typeinf_work(frame::InferenceState)
     @assert !frame.inferred
-    frame.inworkq = true
+    frame.dont_work_on_me = true # mark that this function is currently on the stack
     W = frame.ip
     s = frame.stmt_types
     n = frame.nstmts
@@ -2734,18 +3159,15 @@ function typeinf_frame(frame)
                     if tchanged(rt, frame.bestguess)
                         # new (wider) return type for frame
                         frame.bestguess = tmerge(frame.bestguess, rt)
-                        for (caller, callerW) in frame.backedges
+                        for (caller, caller_pc) in frame.backedges
                             # notify backedges of updated type information
-                            for caller_pc in callerW
-                                if caller.stmt_types[caller_pc] !== ()
-                                    if caller_pc < caller.pc´´
-                                        caller.pc´´ = caller_pc
-                                    end
-                                    push!(caller.ip, caller_pc)
+                            if caller.stmt_types[caller_pc] !== ()
+                                if caller_pc < caller.pc´´
+                                    caller.pc´´ = caller_pc
                                 end
+                                push!(caller.ip, caller_pc)
                             end
                         end
-                        unmark_fixedpoint(frame)
                     end
                 elseif hd === :enter
                     l = stmt.args[1]::Int
@@ -2793,54 +3215,73 @@ function typeinf_frame(frame)
             end
         end
     end
+    frame.dont_work_on_me = false
+end
 
-    # with no active ip's, type inference on frame is done if there are no outstanding (unfinished) edges
-    #@assert isempty(W)
-    @assert !frame.inferred
-    finished = isempty(frame.edges)
-    if isempty(workq)
-        # oops, there's a cycle somewhere in the `edges` graph
-        # so we've run out off the tree and will need to start work on the loop
-        frame.fixedpoint = true
-    end
-
-    if finished || frame.fixedpoint
-        if finished
-            optimize(frame)
-            finish(frame)
-            finalize_backedges(frame)
-        else # fixedpoint propagation
-            for (i, _) in frame.edges
-                i = i::InferenceState
-                if !i.fixedpoint
-                    update_valid_age!(i, frame) # work towards converging age at the same time
-                    if !i.inworkq
-                        push!(workq, i)
-                        i.inworkq = true
-                    end
-                    i.fixedpoint = true
-                end
+function typeinf(frame::InferenceState)
+
+    typeinf_work(frame)
+
+    # If the current frame is part of a cycle, solve the cycle before finishing
+    no_active_ips_in_callers = false
+    while !no_active_ips_in_callers
+        no_active_ips_in_callers = true
+        for caller in frame.callers_in_cycle
+            caller.dont_work_on_me && return
+            if caller.pc´´ <= caller.nstmts # equivalent to `isempty(caller.ip)`
+                # Note that `typeinf_work(caller)` can potentially modify the other frames
+                # `frame.callers_in_cycle`, which is why making incremental progress requires the
+                # outer while loop.
+                typeinf_work(caller)
+                no_active_ips_in_callers = false
+            end
+            if caller.min_valid < frame.min_valid
+                caller.min_valid = frame.min_valid
+            end
+            if caller.max_valid > frame.max_valid
+                caller.max_valid = frame.max_valid
             end
         end
     end
-    frame.inworkq = false
-    global_sv = last_global_sv
-    nothing
-end
 
-function unmark_fixedpoint(frame::InferenceState)
-    # type information changed for frame, so its edges are no longer stuck
-    # recursively unmark any nodes that had previously been thought to be at a fixedpoint
-    # based upon (recursively) assuming that frame was stuck
-    if frame.fixedpoint
-        frame.fixedpoint = false
-        for (i, _) in frame.backedges
-            unmark_fixedpoint(i)
+    # with no active ip's, type inference on frame is done
+
+    if isempty(frame.callers_in_cycle)
+        @assert !(frame.dont_work_on_me)
+        frame.dont_work_on_me = true
+        optimize(frame)
+        finish(frame)
+        finalize_backedges(frame)
+    else # frame is in frame.callers_in_cycle
+        for caller in frame.callers_in_cycle
+            @assert !(caller.dont_work_on_me)
+            caller.dont_work_on_me = true
+        end
+        for caller in frame.callers_in_cycle
+            optimize(caller)
+            if frame.min_valid < caller.min_valid
+                frame.min_valid = caller.min_valid
+            end
+            if frame.max_valid > caller.max_valid
+                frame.max_valid = caller.max_valid
+            end
+        end
+        for caller in frame.callers_in_cycle
+            caller.min_valid = frame.min_valid
+        end
+        for caller in frame.callers_in_cycle
+            finish(caller)
+        end
+        for caller in frame.callers_in_cycle
+            finalize_backedges(caller)
         end
     end
+
+    nothing
 end
 
-function record_ssa_assign(ssa_id::Int, new::ANY, frame::InferenceState)
+
+function record_ssa_assign(ssa_id::Int, @nospecialize(new), frame::InferenceState)
     old = frame.src.ssavaluetypes[ssa_id]
     if old === NF || !(new ⊑ old)
         frame.src.ssavaluetypes[ssa_id] = tmerge(old, new)
@@ -2861,10 +3302,12 @@ end
 
 #### finalize and record the result of running type inference ####
 
-function isinlineable(m::Method, src::CodeInfo)
+function isinlineable(m::Method, src::CodeInfo, mod::Module, params::InferenceParams, bonus::Int=0)
+    # compute the cost (size) of inlining this code
     inlineable = false
-    cost = 1000
+    cost_threshold = params.inline_cost_threshold
     if m.module === _topmod(m.module)
+        # a few functions get special treatment
         name = m.name
         sig = m.sig
         if ((name === :+ || name === :* || name === :min || name === :max) &&
@@ -2873,13 +3316,11 @@ function isinlineable(m::Method, src::CodeInfo)
             inlineable = true
         elseif (name === :next || name === :done || name === :unsafe_convert ||
                 name === :cconvert)
-            cost ÷= 4
+            cost_threshold *= 4
         end
     end
     if !inlineable
-        body = Expr(:block)
-        body.args = src.code
-        inlineable = inline_worthy(body, cost)
+        inlineable = inline_worthy(src.code, src, mod, params, cost_threshold + bonus)
     end
     return inlineable
 end
@@ -2887,16 +3328,6 @@ end
 # inference completed on `me`
 # now converge the optimization work
 function optimize(me::InferenceState)
-    for (i, _) in me.edges
-        i = i::InferenceState
-        @assert i.fixedpoint
-    end
-    # below may call back into inference and
-    # see this InferenceState is in an incomplete state
-    # set `inworkq` to prevent it from trying to look
-    # at the object in any detail
-    @assert me.inworkq
-
     # annotate fulltree with type information
     type_annotate!(me)
 
@@ -2927,28 +3358,33 @@ function optimize(me::InferenceState)
 
     if isa(me.bestguess, Const) || isconstType(me.bestguess)
         me.const_ret = true
-        ispure = me.src.pure
-        if !ispure && length(me.src.code) < 10
-            ispure = true
+        proven_pure = false
+        # must be proven pure to use const_api; otherwise we might skip throwing errors
+        # (issue #20704)
+        # TODO: Improve this analysis; if a function is marked @pure we should really
+        # only care about certain errors (e.g. method errors and type errors).
+        if length(me.src.code) < 10
+            proven_pure = true
             for stmt in me.src.code
                 if !statement_effect_free(stmt, me.src, me.mod)
-                    ispure = false
+                    proven_pure = false
                     break
                 end
             end
-            if ispure
+            if proven_pure
                 for fl in me.src.slotflags
                     if (fl & Slot_UsedUndef) != 0
-                        ispure = false
+                        proven_pure = false
                         break
                     end
                 end
             end
         end
-        me.src.pure = ispure
+        if proven_pure
+            me.src.pure = true
+        end
 
-        do_coverage = coverage_enabled()
-        if ispure && !do_coverage
+        if proven_pure && !coverage_enabled()
             # use constant calling convention
             # Do not emit `jlcall_api == 2` if coverage is enabled
             # so that we don't need to add coverage support
@@ -2961,8 +3397,31 @@ function optimize(me::InferenceState)
     end
 
     # determine and cache inlineability
-    if !me.src.inlineable && !force_noinline && isdefined(me.linfo, :def)
-        me.src.inlineable = isinlineable(me.linfo.def, me.src)
+    if !force_noinline
+        # don't keep ASTs for functions specialized on a Union argument
+        # TODO: this helps avoid a type-system bug mis-computing sparams during intersection
+        sig = unwrap_unionall(me.linfo.specTypes)
+        if isa(sig, DataType) && sig.name === Tuple.name
+            for P in sig.parameters
+                P = unwrap_unionall(P)
+                if isa(P, Union)
+                    force_noinline = true
+                    break
+                end
+            end
+        else
+            force_noinline = true
+        end
+    end
+    def = me.linfo.def
+    if force_noinline
+        me.src.inlineable = false
+    elseif !me.src.inlineable && isa(def, Method)
+        bonus = 0
+        if me.bestguess ⊑ Tuple && !isbits(widenconst(me.bestguess))
+            bonus = me.params.inline_tupleret_bonus
+        end
+        me.src.inlineable = isinlineable(def, me.src, me.mod, me.params, bonus)
     end
     me.src.inferred = true
     nothing
@@ -2973,7 +3432,7 @@ end
 function finish(me::InferenceState)
     me.currpc = 1 # used by add_backedge
     if me.cached
-        toplevel = !isdefined(me.linfo, :def)
+        toplevel = !isa(me.linfo.def, Method)
         if !toplevel
             min_valid = me.min_valid
             max_valid = me.max_valid
@@ -2984,7 +3443,7 @@ function finish(me::InferenceState)
 
         # check if the existing me.linfo metadata is also sufficient to describe the current inference result
         # to decide if it is worth caching it again (which would also clear any generated code)
-        already_inferred = false
+        already_inferred = !me.linfo.inInference
         if isdefined(me.linfo, :inferred)
             inf = me.linfo.inferred
             if !isa(inf, CodeInfo) || (inf::CodeInfo).inferred
@@ -3008,20 +3467,21 @@ function finish(me::InferenceState)
             end
             if me.const_api
                 # use constant calling convention
-                inferred_result = inferred_const
+                inferred_result = nothing
             else
                 inferred_result = me.src
             end
 
             if !toplevel
                 if !me.const_api
+                    def = me.linfo.def::Method
                     keeptree = me.src.inlineable || ccall(:jl_is_cacheable_sig, Int32, (Any, Any, Any),
-                        me.linfo.specTypes, me.linfo.def.sig, me.linfo.def) != 0
+                        me.linfo.specTypes, def.sig, def) != 0
                     if !keeptree
                         inferred_result = nothing
                     else
                         # compress code for non-toplevel thunks
-                        inferred_result.code = ccall(:jl_compress_ast, Any, (Any, Any), me.linfo.def, inferred_result.code)
+                        inferred_result = ccall(:jl_compress_ast, Any, (Any, Any), def, inferred_result)
                     end
                 end
             end
@@ -3035,20 +3495,9 @@ function finish(me::InferenceState)
         end
     end
 
-    # lazy-delete the item from active for several reasons:
-    # efficiency, correctness, and recursion-safety
-    nactive[] -= 1
-    active[findlast(active, me)] = nothing
-
-    # update all of the callers by traversing the backedges
+    # update all of the callers with real backedges by traversing the temporary list of backedges
     for (i, _) in me.backedges
-        if !me.fixedpoint || !i.fixedpoint
-            # wake up each backedge, unless both me and it already reached a fixed-point (cycle resolution stage)
-            delete!(i.edges, me)
-            i.inworkq || push!(workq, i)
-            i.inworkq = true
-        end
-        add_backedge(me.linfo, i)
+        add_backedge!(me.linfo, i)
     end
 
     # finalize and record the linfo result
@@ -3079,7 +3528,7 @@ function annotate_slot_load!(e::Expr, vtypes::VarTable, sv::InferenceState, unde
                 undefs[id] = true
             end
             #  add type annotations where needed
-            if !(sv.src.slottypes[id] <: vt)
+            if !(sv.src.slottypes[id] ⊑ vt)
                 e.args[i] = TypedSlot(id, vt)
             end
         end
@@ -3221,7 +3670,8 @@ end
 # widen all slots to their optimal storage layout
 # we also need to preserve the type for any untyped load of a DataType
 # since codegen optimizations of functions like `is` will depend on knowing it
-function widen_slot_type(ty::ANY, untypedload::Bool)
+function widen_slot_type(@nospecialize(ty), untypedload::Bool)
+    ty = widenconst(ty)
     if isa(ty, DataType)
         if untypedload || isbits(ty) || isdefined(ty, :instance)
             return ty
@@ -3243,7 +3693,7 @@ end
 
 # replace slots 1:na with argexprs, static params with spvals, and increment
 # other slots by offset.
-function substitute!(e::ANY, na::Int, argexprs::Vector{Any}, spsig::ANY, spvals::Vector{Any}, offset::Int)
+function substitute!(@nospecialize(e), na::Int, argexprs::Vector{Any}, @nospecialize(spsig), spvals::Vector{Any}, offset::Int)
     if isa(e, Slot)
         id = slot_id(e)
         if 1 <= id <= na
@@ -3268,6 +3718,7 @@ function substitute!(e::ANY, na::Int, argexprs::Vector{Any}, spsig::ANY, spvals:
         if head === :static_parameter
             return spvals[e.args[1]]
         elseif head === :foreigncall
+            @assert !isa(spsig,UnionAll) || !isempty(spvals)
             for i = 1:length(e.args)
                 if i == 2
                     e.args[2] = ccall(:jl_instantiate_type_in_env, Any, (Any, Any, Ptr{Any}), e.args[2], spsig, spvals)
@@ -3277,6 +3728,10 @@ function substitute!(e::ANY, na::Int, argexprs::Vector{Any}, spsig::ANY, spvals:
                         for argt
                         in e.args[3] ]
                     e.args[3] = svec(argtuple...)
+                elseif i == 4
+                    @assert isa((e.args[4]::QuoteNode).value, Symbol)
+                elseif i == 5
+                    @assert isa(e.args[5], Int)
                 else
                     e.args[i] = substitute!(e.args[i], na, argexprs, spsig, spvals, offset)
                 end
@@ -3291,7 +3746,7 @@ function substitute!(e::ANY, na::Int, argexprs::Vector{Any}, spsig::ANY, spvals:
 end
 
 # count occurrences up to n+1
-function occurs_more(e::ANY, pred, n)
+function occurs_more(@nospecialize(e), pred, n)
     if isa(e,Expr)
         e = e::Expr
         head = e.head
@@ -3311,7 +3766,7 @@ function occurs_more(e::ANY, pred, n)
     return 0
 end
 
-function exprtype(x::ANY, src::CodeInfo, mod::Module)
+function exprtype(@nospecialize(x), src::CodeInfo, mod::Module)
     if isa(x, Expr)
         return (x::Expr).typ
     elseif isa(x, SlotNumber)
@@ -3332,37 +3787,31 @@ function exprtype(x::ANY, src::CodeInfo, mod::Module)
 end
 
 # known affect-free calls (also effect-free)
-const _pure_builtins = Any[tuple, svec, fieldtype, apply_type, ===, isa, typeof, UnionAll]
+const _pure_builtins = Any[tuple, svec, fieldtype, apply_type, ===, isa, typeof, UnionAll, nfields]
 
 # known effect-free calls (might not be affect-free)
-const _pure_builtins_volatile = Any[getfield, arrayref]
+const _pure_builtins_volatile = Any[getfield, arrayref, isdefined, Core.sizeof]
 
-function is_pure_builtin(f::ANY)
-    if contains_is(_pure_builtins, f)
-        return true
-    end
-    if contains_is(_pure_builtins_volatile, f)
-        return true
-    end
-    if isa(f,IntrinsicFunction)
-        if !(f === Intrinsics.pointerref || # this one is volatile
+function is_pure_intrinsic(f::IntrinsicFunction)
+    return !(f === Intrinsics.pointerref || # this one is volatile
              f === Intrinsics.pointerset || # this one is never effect-free
              f === Intrinsics.llvmcall ||   # this one is never effect-free
-             f === Intrinsics.checked_trunc_sint ||
-             f === Intrinsics.checked_trunc_uint ||
              f === Intrinsics.checked_sdiv_int ||
              f === Intrinsics.checked_udiv_int ||
              f === Intrinsics.checked_srem_int ||
              f === Intrinsics.checked_urem_int ||
-             f === Intrinsics.check_top_bit ||
-             f === Intrinsics.sqrt_llvm)
-            return true
-        end
-    end
-    return false
+             f === Intrinsics.sqrt_llvm ||
+             f === Intrinsics.cglobal)  # cglobal throws an error for symbol-not-found
+end
+
+function is_pure_builtin(@nospecialize(f))
+    return (contains_is(_pure_builtins, f) ||
+            contains_is(_pure_builtins_volatile, f) ||
+            (isa(f,IntrinsicFunction) && is_pure_intrinsic(f)) ||
+            f === return_type)
 end
 
-function statement_effect_free(e::ANY, src::CodeInfo, mod::Module)
+function statement_effect_free(@nospecialize(e), src::CodeInfo, mod::Module)
     if isa(e, Expr)
         if e.head === :(=)
             return !isa(e.args[1], GlobalRef) && effect_free(e.args[2], src, mod, false)
@@ -3378,36 +3827,53 @@ end
 # detect some important side-effect-free calls (allow_volatile=true)
 # and some affect-free calls (allow_volatile=false) -- affect_free means the call
 # cannot be affected by previous calls, except assignment nodes
-function effect_free(e::ANY, src::CodeInfo, mod::Module, allow_volatile::Bool)
+function effect_free(@nospecialize(e), src::CodeInfo, mod::Module, allow_volatile::Bool)
     if isa(e, GlobalRef)
         return (isdefined(e.mod, e.name) && (allow_volatile || isconst(e.mod, e.name)))
     elseif isa(e, Symbol)
         return allow_volatile
+    elseif isa(e, Slot)
+        return src.slotflags[slot_id(e)] & Slot_UsedUndef == 0
     elseif isa(e, Expr)
         e = e::Expr
         head = e.head
         if head === :static_parameter || is_meta_expr_head(head)
             return true
         end
+        if e.typ === Bottom
+            return false
+        end
         ea = e.args
-        if head === :call && !isa(e.args[1], SSAValue) && !isa(e.args[1], Slot)
+        if head === :call
             if is_known_call_p(e, is_pure_builtin, src, mod)
                 if !allow_volatile
                     if is_known_call(e, arrayref, src, mod) || is_known_call(e, arraylen, src, mod)
                         return false
                     elseif is_known_call(e, getfield, src, mod)
+                        length(ea) == 3 || return false
                         et = exprtype(e, src, mod)
                         if !isa(et,Const) && !(isType(et) && isconcrete(et))
                             # first argument must be immutable to ensure e is affect_free
                             a = ea[2]
                             typ = widenconst(exprtype(a, src, mod))
-                            if !isa(typ, DataType) || typ.mutable || typ.abstract
+                            if isconstType(typ)
+                                if Const(:uid) ⊑ exprtype(ea[3], src, mod)
+                                    return false    # DataType uid field can change
+                                end
+                            elseif typ !== SimpleVector && (!isa(typ, DataType) || typ.mutable || typ.abstract)
                                 return false
                             end
                         end
                     end
                 end
                 # fall-through
+            elseif is_known_call(e, _apply, src, mod) && length(ea) > 1
+                ft = exprtype(ea[2], src, mod)
+                if !isa(ft, Const) || (!contains_is(_pure_builtins, ft.val) &&
+                                       ft.val !== Core.sizeof)
+                    return false
+                end
+                # fall-through
             else
                 return false
             end
@@ -3449,8 +3915,7 @@ struct InvokeData
     texpr
 end
 
-function inline_as_constant(val::ANY, argexprs, sv::InferenceState,
-                            invoke_data::ANY)
+function inline_as_constant(@nospecialize(val), argexprs, sv::InferenceState, @nospecialize(invoke_data))
     if invoke_data === nothing
         invoke_fexpr = nothing
         invoke_texpr = nothing
@@ -3470,10 +3935,17 @@ function inline_as_constant(val::ANY, argexprs, sv::InferenceState,
             push!(stmts, invoke_texpr)
         end
     end
-    return (QuoteNode(val), stmts)
+    if !is_self_quoting(val)
+        val = QuoteNode(val)
+    end
+    return (val, stmts)
 end
 
-function countunionsplit(atypes::Vector{Any})
+function is_self_quoting(@nospecialize(x))
+    return isa(x,Number) || isa(x,AbstractString) || isa(x,Tuple) || isa(x,Type)
+end
+
+function countunionsplit(atypes)
     nu = 1
     for ti in atypes
         if isa(ti, Union)
@@ -3483,7 +3955,7 @@ function countunionsplit(atypes::Vector{Any})
     return nu
 end
 
-function get_spec_lambda(atypes::ANY, sv, invoke_data::ANY)
+function get_spec_lambda(@nospecialize(atypes), sv, @nospecialize(invoke_data))
     if invoke_data === nothing
         return ccall(:jl_get_spec_lambda, Any, (Any, UInt), atypes, sv.params.world)
     else
@@ -3494,8 +3966,27 @@ function get_spec_lambda(atypes::ANY, sv, invoke_data::ANY)
     end
 end
 
-function invoke_NF(argexprs, etype::ANY, atypes, sv, atype_unlimited::ANY,
-                   invoke_data::ANY)
+function linearize_args!(args::Vector{Any}, atypes::Vector{Any}, stmts::Vector{Any}, sv::InferenceState)
+    # linearize the IR by moving the arguments to SSA position
+    na = length(args)
+    @assert length(atypes) == na
+    newargs = Vector{Any}(na)
+    for i = na:-1:1
+        aei = args[i]
+        ti = atypes[i]
+        if isa(aei, Expr) || isa(aei, GlobalRef)
+            newvar = newvar!(sv, ti)
+            unshift!(stmts, Expr(:(=), newvar, aei))
+        else
+            newvar = aei
+        end
+        newargs[i] = newvar
+    end
+    return newargs
+end
+
+function invoke_NF(argexprs, @nospecialize(etype), atypes::Vector{Any}, sv::InferenceState,
+                   @nospecialize(atype_unlimited), @nospecialize(invoke_data))
     # converts a :call to :invoke
     nu = countunionsplit(atypes)
     nu > sv.params.MAX_UNION_SPLITTING && return NF
@@ -3509,42 +4000,37 @@ function invoke_NF(argexprs, etype::ANY, atypes, sv, atype_unlimited::ANY,
     end
 
     if nu > 1
-        spec_hit = nothing
+        # linearize the IR by moving the arguments to SSA position
+        stmts = []
+
         spec_miss = nothing
         error_label = nothing
-        linfo_var = add_slot!(sv.src, MethodInstance, false)
         ex = Expr(:call)
-        ex.args = copy(argexprs)
         ex.typ = etype
-        stmts = []
-        arg_hoisted = false
-        for i = length(atypes):-1:1
-            if i == 1 && !(invoke_texpr === nothing)
-                unshift!(stmts, invoke_texpr)
-                arg_hoisted = true
-            end
-            ti = atypes[i]
-            if arg_hoisted || isa(ti, Union)
-                aei = ex.args[i]
-                if !effect_free(aei, sv.src, sv.mod, false)
-                    arg_hoisted = true
-                    newvar = newvar!(sv, ti)
-                    unshift!(stmts, :($newvar = $aei))
-                    ex.args[i] = newvar
-                end
-            end
-        end
+        ex.args = linearize_args!(argexprs, atypes, stmts, sv)
+        invoke_texpr === nothing || insert!(stmts, 2, invoke_texpr)
         invoke_fexpr === nothing || unshift!(stmts, invoke_fexpr)
+
+        local ret_var, merge, invoke_ex, spec_hit
+        ret_var = add_slot!(sv.src, widenconst(etype), false)
+        merge = genlabel(sv)
+        invoke_ex = copy(ex)
+        invoke_ex.head = :invoke
+        unshift!(invoke_ex.args, nothing)
+        spec_hit = false
+
         function splitunion(atypes::Vector{Any}, i::Int)
             if i == 0
                 local sig = argtypes_to_type(atypes)
                 local li = get_spec_lambda(sig, sv, invoke_data)
                 li === nothing && return false
-                add_backedge(li, sv)
+                add_backedge!(li, sv)
                 local stmt = []
-                push!(stmt, Expr(:(=), linfo_var, li))
-                spec_hit === nothing && (spec_hit = genlabel(sv))
-                push!(stmt, GotoNode(spec_hit.label))
+                invoke_ex = copy(invoke_ex)
+                invoke_ex.args[1] = li
+                push!(stmt, Expr(:(=), ret_var, invoke_ex))
+                push!(stmt, GotoNode(merge.label))
+                spec_hit = true
                 return stmt
             else
                 local ti = atypes[i]
@@ -3567,7 +4053,7 @@ function invoke_NF(argexprs, etype::ANY, atypes, sv, atype_unlimited::ANY,
                             all = false
                         end
                     end
-                    if UNION_SPLIT_MISMATCH_ERROR && all
+                    if all
                         error_label === nothing && (error_label = genlabel(sv))
                         push!(stmts, GotoNode(error_label.label))
                     else
@@ -3582,36 +4068,25 @@ function invoke_NF(argexprs, etype::ANY, atypes, sv, atype_unlimited::ANY,
             end
         end
         local match = splitunion(atypes, length(atypes))
-        if match !== false && spec_hit !== nothing
+        if match !== false && spec_hit
             append!(stmts, match)
             if error_label !== nothing
                 push!(stmts, error_label)
                 push!(stmts, Expr(:call, GlobalRef(_topmod(sv.mod), :error), "fatal error in type inference (type bound)"))
             end
-            local ret_var, merge
             if spec_miss !== nothing
-                ret_var = add_slot!(sv.src, widenconst(ex.typ), false)
-                merge = genlabel(sv)
                 push!(stmts, spec_miss)
                 push!(stmts, Expr(:(=), ret_var, ex))
                 push!(stmts, GotoNode(merge.label))
-            else
-                ret_var = newvar!(sv, ex.typ)
-            end
-            push!(stmts, spec_hit)
-            ex = copy(ex)
-            ex.head = :invoke
-            unshift!(ex.args, linfo_var)
-            push!(stmts, Expr(:(=), ret_var, ex))
-            if spec_miss !== nothing
-                push!(stmts, merge)
             end
+            push!(stmts, merge)
             return (ret_var, stmts)
         end
     else
         local cache_linfo = get_spec_lambda(atype_unlimited, sv, invoke_data)
         cache_linfo === nothing && return NF
-        add_backedge(cache_linfo, sv)
+        add_backedge!(cache_linfo, sv)
+        argexprs = copy(argexprs)
         unshift!(argexprs, cache_linfo)
         ex = Expr(:invoke)
         ex.args = argexprs
@@ -3638,13 +4113,17 @@ end
 # static parameters are ok if all the static parameter values are concrete types,
 # meaning they are fully known.
 # `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::InferenceState)
+# `pending_stmts` is an array of statements from functions inlined so far, so
+# we can estimate the total size of the enclosing function after inlining.
+function inlineable(@nospecialize(f), @nospecialize(ft), e::Expr, atypes::Vector{Any}, sv::InferenceState,
+                    pending_stmts)
     argexprs = e.args
 
     if (f === typeassert || ft ⊑ typeof(typeassert)) && length(atypes)==3
         # typeassert(x::S, T) => x, when S<:T
-        if isType(atypes[3]) && isconcrete(atypes[3]) &&
-            atypes[2] ⊑ atypes[3].parameters[1]
+        a3 = atypes[3]
+        if (isType(a3) && isconcrete(a3) && atypes[2] ⊑ a3.parameters[1]) ||
+            (isa(a3,Const) && isa(a3.val,Type) && atypes[2] ⊑ a3.val)
             return (argexprs[2], ())
         end
     end
@@ -3652,12 +4131,18 @@ function inlineable(f::ANY, ft::ANY, e::Expr, atypes::Vector{Any}, sv::Inference
     # special-case inliners for known pure functions that compute types
     if sv.params.inlining
         if isa(e.typ, Const) # || isconstType(e.typ)
-            if (f === apply_type || f === fieldtype || f === typeof ||
+            val = e.typ.val
+            if (f === apply_type || f === fieldtype || f === typeof || f === (===) ||
+                f === Core.sizeof || f === isdefined ||
                 istopfunction(topmod, f, :typejoin) ||
                 istopfunction(topmod, f, :isbits) ||
                 istopfunction(topmod, f, :promote_type) ||
-                (f === Core.kwfunc && length(argexprs) == 2))
-                return inline_as_constant(e.typ.val, argexprs, sv, nothing)
+                (f === Core.kwfunc && length(argexprs) == 2) ||
+                (isbits(val) && Core.sizeof(val) <= MAX_INLINE_CONST_SIZE &&
+                 (contains_is(_pure_builtins, f) ||
+                  (f === getfield && effect_free(e, sv.src, sv.mod, false)) ||
+                  (isa(f,IntrinsicFunction) && is_pure_intrinsic(f)))))
+                return inline_as_constant(val, argexprs, sv, nothing)
             end
         end
     end
@@ -3738,7 +4223,7 @@ function inlineable(f::ANY, ft::ANY, e::Expr, atypes::Vector{Any}, sv::Inference
             issubtype_stmts = Any[ Expr(:(=), issubtype_vnew, arg_T1) ]
             arg_T1 = issubtype_vnew
         end
-        issubtype_expr = Expr(:call, GlobalRef(Core, :issubtype), arg_T2, arg_T1)
+        issubtype_expr = Expr(:call, GlobalRef(Core, :(<:)), arg_T2, arg_T1)
         issubtype_expr.typ = Bool
         return (issubtype_expr, issubtype_stmts)
     end
@@ -3767,16 +4252,6 @@ function inlineable(f::ANY, ft::ANY, e::Expr, atypes::Vector{Any}, sv::Inference
                                   atype_unlimited, method.sig)
         methsp = methsp::SimpleVector
     end
-    # check whether call can be inlined to just a quoted constant value
-    if isa(f, widenconst(ft)) && !method.isstaged && (method.source.pure || f === return_type)
-        if isconstType(e.typ)
-            return inline_as_constant(e.typ.parameters[1], argexprs, sv,
-                                      invoke_data)
-        elseif isa(e.typ,Const)
-            return inline_as_constant(e.typ.val, argexprs, sv,
-                                      invoke_data)
-        end
-    end
 
     methsig = method.sig
     if !(atype <: metharg)
@@ -3784,7 +4259,21 @@ function inlineable(f::ANY, ft::ANY, e::Expr, atypes::Vector{Any}, sv::Inference
                          invoke_data)
     end
 
+    # check whether call can be inlined to just a quoted constant value
+    if isa(f, widenconst(ft)) && !isdefined(method, :generator)
+        if f === return_type
+            if isconstType(e.typ)
+                return inline_as_constant(e.typ.parameters[1], argexprs, sv, invoke_data)
+            elseif isa(e.typ, Const)
+                return inline_as_constant(e.typ.val, argexprs, sv, invoke_data)
+            end
+        elseif method.pure && isa(e.typ, Const) && e.typ.actual
+            return inline_as_constant(e.typ.val, argexprs, sv, invoke_data)
+        end
+    end
+
     argexprs0 = argexprs
+    atypes0 = atypes
     na = Int(method.nargs)
     # check for vararg function
     isva = false
@@ -3793,6 +4282,7 @@ function inlineable(f::ANY, ft::ANY, e::Expr, atypes::Vector{Any}, sv::Inference
         # construct tuple-forming expression for argument tail
         vararg = mk_tuplecall(argexprs[na:end], sv)
         argexprs = Any[argexprs[1:(na - 1)]..., vararg]
+        atypes = Any[atypes[1:(na - 1)]..., vararg.typ]
         isva = true
     elseif na != length(argexprs)
         # we have a method match only because an earlier
@@ -3812,36 +4302,40 @@ function inlineable(f::ANY, ft::ANY, e::Expr, atypes::Vector{Any}, sv::Inference
     # some gf have special tfunc, meaning they wouldn't have been inferred yet
     # check the same conditions from abstract_call to detect this case
     force_infer = false
-    if !method.isstaged
+    if !isdefined(method, :generator)
         if method.module == _topmod(method.module) || (isdefined(Main, :Base) && method.module == Main.Base)
-            if method.name == :getindex || method.name == :next || method.name == :indexed_next
-                if length(atypes) > 2 && atypes[3] ⊑ Int
+            la = length(atypes)
+            if (la==3 && (method.name == :getindex || method.name == :next)) ||
+                (la==4 && method.name == :indexed_next)
+                if atypes[3] ⊑ Int
                     at2 = widenconst(atypes[2])
                     if (at2 <: Tuple || at2 <: SimpleVector ||
                         (isa(at2, DataType) && (at2::DataType).name === Pair_name()))
                         force_infer = true
                     end
                 end
+            elseif la == 2 && method.name == :length && atypes[2] ⊑ SimpleVector
+                force_infer = true
             end
         end
     end
 
     # see if the method has been previously inferred (and cached)
     linfo = code_for_method(method, metharg, methsp, sv.params.world, !force_infer) # Union{Void, MethodInstance}
-    isa(linfo, MethodInstance) || return invoke_NF(argexprs0, e.typ, atypes, sv,
+    isa(linfo, MethodInstance) || return invoke_NF(argexprs0, e.typ, atypes0, sv,
                                                    atype_unlimited, invoke_data)
     linfo = linfo::MethodInstance
     if linfo.jlcall_api == 2
         # in this case function can be inlined to a constant
-        add_backedge(linfo, sv)
-        return inline_as_constant(linfo.inferred, argexprs, sv, invoke_data)
+        add_backedge!(linfo, sv)
+        return inline_as_constant(linfo.inferred_const, argexprs, sv, invoke_data)
     end
 
     # see if the method has a current InferenceState frame
     # or existing inferred code info
     frame = nothing # Union{Void, InferenceState}
-    src = nothing # Union{Void, CodeInfo}
-    if force_infer && isa(atypes[3], Const)
+    inferred = nothing # Union{Void, CodeInfo}
+    if force_infer && la > 2 && isa(atypes[3], Const)
         # Since we inferred this with the information that atypes[3]::Const,
         # must inline with that same information.
         # We do that by overriding the argument type,
@@ -3850,22 +4344,19 @@ function inlineable(f::ANY, ft::ANY, e::Expr, atypes::Vector{Any}, sv::Inference
         # as we'll be able to fix that up at the end of inlinable when we verify the return type.
         # But `next` and `indexed_next` make tuples which would end up burying some of that information in the AST
         # where we can't easily correct it afterwards.
-        frame = InferenceState(linfo, get_source(linfo), #=optimize=#true, #=cache=#false, sv.params)
+        frame = InferenceState(linfo, #=optimize=#true, #=cache=#false, sv.params)
         frame.stmt_types[1][3] = VarState(atypes[3], false)
-        typeinf_loop(frame)
+        typeinf(frame)
     else
-        if isdefined(linfo, :inferred) && isa(linfo.inferred, CodeInfo) && (linfo.inferred::CodeInfo).inferred
+        if isdefined(linfo, :inferred) && linfo.inferred !== nothing
             # use cache
-            src = linfo.inferred
-        elseif linfo.inInference
-            # use WIP
-            frame = typeinf_active(linfo)
+            inferred = linfo.inferred
         elseif force_infer
             # create inferred code on-demand
             # but if we decided in the past not to try to infer this particular signature
             # (due to signature coarsening in abstract_call_gf_by_type)
             # don't infer it now, as attempting to force it now would be a bad idea (non terminating)
-            frame = typeinf_frame(linfo, nothing, #=optimize=#true, #=cache=#true, sv.params)
+            frame = typeinf_frame(linfo, #=optimize=#true, #=cache=#true, sv.params)
         end
     end
 
@@ -3873,12 +4364,12 @@ function inlineable(f::ANY, ft::ANY, e::Expr, atypes::Vector{Any}, sv::Inference
     if isa(frame, InferenceState)
         frame = frame::InferenceState
         linfo = frame.linfo
-        src = frame.src
+        inferred = frame.src
         if frame.const_api # handle like jlcall_api == 2
             if frame.inferred || !frame.cached
-                add_backedge(frame.linfo, sv)
+                add_backedge!(frame.linfo, sv)
             else
-                add_backedge(frame, sv, 0)
+                add_backedge!(frame, sv, 0)
             end
             if isa(frame.bestguess, Const)
                 inferred_const = (frame.bestguess::Const).val
@@ -3894,22 +4385,33 @@ function inlineable(f::ANY, ft::ANY, e::Expr, atypes::Vector{Any}, sv::Inference
     end
 
     # check that the code is inlineable
-    isa(src, CodeInfo) || return invoke_NF(argexprs0, e.typ, atypes, sv,
-                                           atype_unlimited, invoke_data)
-    src = src::CodeInfo
-    ast = src.code
-    if !src.inferred || !src.inlineable
-        return invoke_NF(argexprs0, e.typ, atypes, sv, atype_unlimited,
+    if inferred === nothing
+        src_inferred = src_inlineable = false
+    else
+        src_inferred = ccall(:jl_ast_flag_inferred, Bool, (Any,), inferred)
+        src_inlineable = ccall(:jl_ast_flag_inlineable, Bool, (Any,), inferred)
+    end
+    if !src_inferred || !src_inlineable
+        return invoke_NF(argexprs0, e.typ, atypes0, sv, atype_unlimited,
                          invoke_data)
     end
 
+    if isa(inferred, CodeInfo)
+        src = inferred
+        ast = copy_exprargs(inferred.code)
+    else
+        src = ccall(:jl_uncompress_ast, Any, (Any, Any), method, inferred)::CodeInfo
+        ast = src.code
+    end
+    ast = ast::Array{Any,1}
+
     # create the backedge
     if isa(frame, InferenceState) && !frame.inferred && frame.cached
         # in this case, the actual backedge linfo hasn't been computed
         # yet, but will be when inference on the frame finishes
-        add_backedge(frame, sv, 0)
+        add_backedge!(frame, sv, 0)
     else
-        add_backedge(linfo, sv)
+        add_backedge!(linfo, sv)
     end
 
     spvals = Any[]
@@ -3925,13 +4427,6 @@ function inlineable(f::ANY, ft::ANY, e::Expr, atypes::Vector{Any}, sv::Inference
 
     nm = length(unwrap_unionall(metharg).parameters)
 
-    if !isa(ast, Array{Any,1})
-        ast = ccall(:jl_uncompress_ast, Any, (Any, Any), method, ast)
-    else
-        ast = copy_exprargs(ast)
-    end
-    ast = ast::Array{Any,1}
-
     body = Expr(:block)
     body.args = ast
     propagate_inbounds = src.propagate_inbounds
@@ -3941,6 +4436,7 @@ function inlineable(f::ANY, ft::ANY, e::Expr, atypes::Vector{Any}, sv::Inference
     prelude_stmts = []
     stmts_free = true # true = all entries of stmts are effect_free
 
+    argexprs = copy(argexprs)
     for i = na:-1:1 # stmts_free needs to be calculated in reverse-argument order
         #args_i = args[i]
         aei = argexprs[i]
@@ -3968,7 +4464,7 @@ function inlineable(f::ANY, ft::ANY, e::Expr, atypes::Vector{Any}, sv::Inference
             end
         end
         free = effect_free(aei, sv.src, sv.mod, true)
-        if ((occ==0 && aeitype===Bottom) || (occ > 1 && !inline_worthy(aei, occ*2000)) ||
+        if ((occ==0 && aeitype===Bottom) || (occ > 1 && !inline_worthy(aei, sv.src, sv.mod, sv.params)) ||
                 (affect_free && !free) || (!affect_free && !effect_free(aei, sv.src, sv.mod, false)))
             if occ != 0
                 vnew = newvar!(sv, aeitype)
@@ -4031,19 +4527,18 @@ function inlineable(f::ANY, ft::ANY, e::Expr, atypes::Vector{Any}, sv::Inference
     local retval
     multiret = false
     lastexpr = pop!(body.args)
-    if isa(lastexpr,LabelNode)
+    if isa(lastexpr, LabelNode)
         push!(body.args, lastexpr)
         push!(body.args, Expr(:call, GlobalRef(topmod, :error), "fatal error in type inference (lowering)"))
         lastexpr = nothing
-    elseif !(isa(lastexpr,Expr) && lastexpr.head === :return)
+    elseif !(isa(lastexpr, Expr) && lastexpr.head === :return)
         # code sometimes ends with a meta node, e.g. inbounds pop
         push!(body.args, lastexpr)
         lastexpr = nothing
     end
     for a in body.args
         push!(stmts, a)
-        if isa(a,Expr)
-            a = a::Expr
+        if isa(a, Expr)
             if a.head === :return
                 if !multiret
                     # create slot first time
@@ -4074,7 +4569,7 @@ function inlineable(f::ANY, ft::ANY, e::Expr, atypes::Vector{Any}, sv::Inference
         end
     end
 
-    inlining_ignore = function (stmt::ANY)
+    inlining_ignore = function (@nospecialize(stmt),)
         isa(stmt, Expr) && return is_meta_expr(stmt::Expr)
         isa(stmt, LineNumberNode) && return true
         stmt === nothing && return true
@@ -4082,39 +4577,38 @@ function inlineable(f::ANY, ft::ANY, e::Expr, atypes::Vector{Any}, sv::Inference
     end
 
     do_coverage = coverage_enabled()
-    if do_coverage
-        line = method.line
-        if !isempty(stmts) && isa(stmts[1], LineNumberNode)
-            line = (shift!(stmts)::LineNumberNode).line
+    line::Int = method.line
+    file = method.file
+    if !isempty(stmts)
+        if !do_coverage && all(inlining_ignore, stmts)
+            empty!(stmts)
+        elseif isa(stmts[1], LineNumberNode)
+            linenode = shift!(stmts)::LineNumberNode
+            line = linenode.line
+            isa(linenode.file, Symbol) && (file = linenode.file)
         end
+    end
+    if do_coverage
         # Check if we are switching module, which is necessary to catch user
         # code inlined into `Base` with `--code-coverage=user`.
         # Assume we are inlining directly into `enclosing` instead of another
         # function inlined in it
         mod = method.module
         if mod === sv.mod
-            unshift!(stmts, Expr(:meta, :push_loc, method.file,
+            unshift!(stmts, Expr(:meta, :push_loc, file,
                                  method.name, line))
         else
-            unshift!(stmts, Expr(:meta, :push_loc, method.file,
+            unshift!(stmts, Expr(:meta, :push_loc, file,
                                  method.name, line, mod))
         end
         push!(stmts, Expr(:meta, :pop_loc))
     elseif !isempty(stmts)
-        if all(inlining_ignore, stmts)
-            empty!(stmts)
+        unshift!(stmts, Expr(:meta, :push_loc, file,
+                             method.name, line))
+        if isa(stmts[end], LineNumberNode)
+            stmts[end] = Expr(:meta, :pop_loc)
         else
-            line::Int = method.line
-            if isa(stmts[1], LineNumberNode)
-                line = (shift!(stmts)::LineNumberNode).line
-            end
-            unshift!(stmts, Expr(:meta, :push_loc, method.file,
-                                 method.name, line))
-            if isa(stmts[end], LineNumberNode)
-                stmts[end] = Expr(:meta, :pop_loc)
-            else
-                push!(stmts, Expr(:meta, :pop_loc))
-            end
+            push!(stmts, Expr(:meta, :pop_loc))
         end
     end
     if !isempty(stmts) && !propagate_inbounds
@@ -4134,7 +4628,7 @@ function inlineable(f::ANY, ft::ANY, e::Expr, atypes::Vector{Any}, sv::Inference
         end
     end
 
-    if isa(expr,Expr)
+    if isa(expr, Expr)
         old_t = e.typ
         if old_t ⊑ expr.typ
             # if we had better type information than the content being inlined,
@@ -4148,38 +4642,107 @@ function inlineable(f::ANY, ft::ANY, e::Expr, atypes::Vector{Any}, sv::Inference
     return (expr, stmts)
 end
 
-inline_worthy(body::ANY, cost::Integer) = true
+## Computing the cost of a function body
 
-# should the expression be part of the inline cost model
-function inline_ignore(ex::ANY)
-    if isa(ex, LineNumberNode) || ex === nothing
-        return true
-    end
-    return isa(ex, Expr) && is_meta_expr(ex::Expr)
-end
+# saturating sum (inputs are nonnegative), prevents overflow with typemax(Int) below
+plus_saturate(x, y) = max(x, y, x+y)
+# known return type
+isknowntype(T) = (T == Union{}) || isconcrete(T)
 
-function inline_worthy(body::Expr, cost::Integer=1000) # precondition: 0 < cost; nominal cost = 1000
-    if popmeta!(body, :noinline)[1]
-        return false
+statement_cost(::Any, src::CodeInfo, mod::Module, params::InferenceParams) = 0
+statement_cost(qn::QuoteNode, src::CodeInfo, mod::Module, params::InferenceParams) =
+    statement_cost(qn.value, src, mod, params)
+function statement_cost(ex::Expr, src::CodeInfo, mod::Module, params::InferenceParams)
+    head = ex.head
+    if is_meta_expr(ex) || head == :copyast # not sure if copyast is right
+        return 0
     end
-    symlim = 1000 + 5_000_000 ÷ cost
-    nstmt = 0
-    for stmt in body.args
-        if !(isa(stmt, SSAValue) || inline_ignore(stmt))
-            nstmt += 1
+    argcost = 0
+    for a in ex.args
+        argcost = plus_saturate(argcost, statement_cost(a, src, mod, params))
+    end
+    if head == :return || head == :(=)
+        return argcost
+    end
+    if head == :call
+        extyp = exprtype(ex.args[1], src, mod)
+        if isa(extyp, Type)
+            return argcost
+        end
+        if isa(extyp, Const)
+            f = (extyp::Const).val
+            if isa(f, IntrinsicFunction)
+                iidx = Int(reinterpret(Int32, f::IntrinsicFunction)) + 1
+                if !isassigned(t_ifunc_cost, iidx)
+                    # unknown/unhandled intrinsic
+                    return plus_saturate(argcost, params.inline_nonconcrete_penalty)
+                end
+                return plus_saturate(argcost, t_ifunc_cost[iidx])
+            end
+            if isa(f, Builtin)
+                # The efficiency of operations like a[i] and s.b
+                # depend strongly on whether the result can be
+                # inferred, so check ex.typ
+                if f == Main.Core.getfield || f == Main.Core.tuple
+                    # we might like to penalize non-inferrability, but
+                    # tuple iteration/destructuring makes that
+                    # impossible
+                    # return plus_saturate(argcost, isknowntype(ex.typ) ? 1 : params.inline_nonconcrete_penalty)
+                    return argcost
+                elseif f == Main.Core.arrayref
+                    return plus_saturate(argcost, isknowntype(ex.typ) ? 4 : params.inline_nonconcrete_penalty)
+                end
+                fidx = findfirst(t_ffunc_key, f)
+                if fidx == 0
+                    # unknown/unhandled builtin or anonymous function
+                    # Use the generic cost of a direct function call
+                    return plus_saturate(argcost, 20)
+                end
+                return plus_saturate(argcost, t_ffunc_cost[fidx])
+            end
         end
+        return plus_saturate(argcost, params.inline_nonconcrete_penalty)
+    elseif head == :foreigncall || head == :invoke
+        # Calls whose "return type" is Union{} do not actually return:
+        # they are errors. Since these are not part of the typical
+        # run-time of the function, we omit them from
+        # consideration. This way, non-inlined error branches do not
+        # prevent inlining.
+        return ex.typ == Union{} ? 0 : plus_saturate(20, argcost)
+    elseif head == :llvmcall
+        return plus_saturate(10, argcost) # a wild guess at typical cost
+    elseif (head == :&)
+        return plus_saturate(length(ex.args), argcost)
     end
-    if nstmt < (symlim + 500) ÷ 1000
-        symlim *= 16
-        symlim ÷= 1000
-        if occurs_more(body, e->!inline_ignore(e), symlim) < symlim
-            return true
-        end
+    argcost
+end
+
+function inline_worthy(body::Array{Any,1}, src::CodeInfo, mod::Module,
+                       params::InferenceParams,
+                       cost_threshold::Integer=params.inline_cost_threshold)
+    bodycost = 0
+    for line = 1:length(body)
+        stmt = body[line]
+        thiscost = statement_cost(stmt, src, mod, params)
+        bodycost = plus_saturate(bodycost, thiscost)
     end
-    return false
+    bodycost <= cost_threshold
+end
+
+function inline_worthy(body::Expr, src::CodeInfo, mod::Module, params::InferenceParams,
+                       cost_threshold::Integer=params.inline_cost_threshold)
+    bodycost = statement_cost(body, src, mod, params)
+    bodycost <= cost_threshold
 end
 
-ssavalue_increment(body::ANY, incr) = body
+function inline_worthy(@nospecialize(body), src::CodeInfo, mod::Module, params::InferenceParams,
+                       cost_threshold::Integer=params.inline_cost_threshold)
+    newbody = exprtype(body, src, mod)
+    !isa(newbody, Expr) && return true
+    inline_worthy(newbody, src, mod, params, cost_threshold)
+end
+
+ssavalue_increment(@nospecialize(body), incr) = body
 ssavalue_increment(body::SSAValue, incr) = SSAValue(body.id + incr)
 function ssavalue_increment(body::Expr, incr)
     if is_meta_expr(body)
@@ -4209,17 +4772,15 @@ end
 function inlining_pass!(sv::InferenceState)
     eargs = sv.src.code
     i = 1
+    stmtbuf = []
     while i <= length(eargs)
         ei = eargs[i]
         if isa(ei, Expr)
-            res = inlining_pass(ei, sv)
-            eargs[i] = res[1]
-            if isa(res[2], Array)
-                sts = res[2]::Array{Any,1}
-                for j = 1:length(sts)
-                    insert!(eargs, i, sts[j])
-                    i += 1
-                end
+            eargs[i] = inlining_pass(ei, sv, stmtbuf, 1)
+            if !isempty(stmtbuf)
+                splice!(eargs, i:i-1, stmtbuf)
+                i += length(stmtbuf)
+                empty!(stmtbuf)
             end
         end
         i += 1
@@ -4228,16 +4789,21 @@ end
 
 const corenumtype = Union{Int32, Int64, Float32, Float64}
 
-function inlining_pass(e::Expr, sv::InferenceState)
+# return inlined replacement for `e`, inserting new needed statements
+# at index `ins` in `stmts`.
+function inlining_pass(e::Expr, sv::InferenceState, stmts, ins)
+    if e.head === :isdefined
+        isa(e.typ, Const) && return e.typ.val
+        return e
+    end
     if e.head === :method
         # avoid running the inlining pass on function definitions
-        return (e, ())
+        return e
     end
     eargs = e.args
     if length(eargs) < 1
-        return (e, ())
+        return e
     end
-    stmts = []
     arg1 = eargs[1]
     isccall = false
     i0 = 1
@@ -4245,15 +4811,16 @@ function inlining_pass(e::Expr, sv::InferenceState)
     # by the interpreter and inlining might put in something it can't handle,
     # like another ccall (or try to move the variables out into the function)
     if e.head === :foreigncall
-        # 3 is rewritten to 1 below to handle the callee.
-        i0 = 3
+        # 5 is rewritten to 1 below to handle the callee.
+        i0 = 5
         isccall = true
     elseif is_known_call(e, Core.Intrinsics.llvmcall, sv.src, sv.mod)
         i0 = 5
     end
     has_stmts = false # needed to preserve order-of-execution
+    prev_stmts_length = length(stmts)
     for _i = length(eargs):-1:i0
-        if isccall && _i == 3
+        if isccall && _i == 5
             i = 1
             isccallee = true
         else
@@ -4274,40 +4841,33 @@ function inlining_pass(e::Expr, sv::InferenceState)
             else
                 argloc = eargs
             end
-            res = inlining_pass(ei, sv)
-            res1 = res[1]
-            res2 = res[2]
-            has_new_stmts = isa(res2, Array) && !isempty(res2::Array{Any,1})
+            sl0 = length(stmts)
+            res = inlining_pass(ei, sv, stmts, ins)
+            ns = length(stmts) - sl0  # number of new statements just added
             if isccallee
-                restype = exprtype(res1, sv.src, sv.mod)
+                restype = exprtype(res, sv.src, sv.mod)
                 if isa(restype, Const)
                     argloc[i] = restype.val
-                    if !effect_free(res1, sv.src, sv.mod, false)
-                        insert!(stmts, 1, res1)
-                    end
-                    if has_new_stmts
-                        prepend!(stmts, res2::Array{Any,1})
+                    if !effect_free(res, sv.src, sv.mod, false)
+                        insert!(stmts, ins+ns, res)
                     end
                     # Assume this is the last argument to process
                     break
                 end
             end
-            if has_stmts && !effect_free(res1, sv.src, sv.mod, false)
-                restype = exprtype(res1, sv.src, sv.mod)
+            if has_stmts && !effect_free(res, sv.src, sv.mod, false)
+                restype = exprtype(res, sv.src, sv.mod)
                 vnew = newvar!(sv, restype)
                 argloc[i] = vnew
-                unshift!(stmts, Expr(:(=), vnew, res1))
+                insert!(stmts, ins+ns, Expr(:(=), vnew, res))
             else
-                argloc[i] = res1
-            end
-            if has_new_stmts
-                res2 = res2::Array{Any,1}
-                prepend!(stmts, res2)
-                if !has_stmts && !(_i == i0)
-                    for stmt in res2
-                        if !effect_free(stmt, sv.src, sv.mod, true)
-                            has_stmts = true
-                        end
+                argloc[i] = res
+            end
+            if !has_stmts && ns > 0 && !(_i == i0)
+                for s = ins:ins+ns-1
+                    stmt = stmts[s]
+                    if !effect_free(stmt, sv.src, sv.mod, true)
+                        has_stmts = true; break
                     end
                 end
             end
@@ -4315,14 +4875,25 @@ function inlining_pass(e::Expr, sv::InferenceState)
     end
     if isccall
         le = length(eargs)
-        for i = 4:2:(le - 1)
-            if eargs[i] === eargs[i + 1]
-                eargs[i + 1] = 0
+        nccallargs = eargs[5]::Int
+        ccallargs = ObjectIdDict()
+        for i in 6:(5 + nccallargs)
+            ccallargs[eargs[i]] = nothing
+        end
+        i = 6 + nccallargs
+        while i <= le
+            rootarg = eargs[i]
+            if haskey(ccallargs, rootarg)
+                deleteat!(eargs, i)
+                le -= 1
+            elseif i < le
+                ccallargs[rootarg] = nothing
             end
+            i += 1
         end
     end
     if e.head !== :call
-        return (e, stmts)
+        return e
     end
 
     ft = exprtype(arg1, sv.src, sv.mod)
@@ -4334,10 +4905,12 @@ function inlining_pass(e::Expr, sv::InferenceState)
     else
         f = nothing
         if !( isconcrete(ft) || ft<:Type )
-            return (e, stmts)
+            return e
         end
     end
 
+    ins += (length(stmts) - prev_stmts_length)
+
     if sv.params.inlining
         if isdefined(Main, :Base) &&
             ((isdefined(Main.Base, :^) && f === Main.Base.:^) ||
@@ -4361,19 +4934,13 @@ function inlining_pass(e::Expr, sv::InferenceState)
                                            exprtype(a1, sv.src, sv.mod) ⊑ basenumtype)
                     if square
                         e.args = Any[GlobalRef(Main.Base,:*), a1, a1]
-                        res = inlining_pass(e, sv)
+                        res = inlining_pass(e, sv, stmts, ins)
                     else
                         e.args = Any[GlobalRef(Main.Base,:*), Expr(:call, GlobalRef(Main.Base,:*), a1, a1), a1]
                         e.args[2].typ = e.typ
-                        res = inlining_pass(e, sv)
+                        res = inlining_pass(e, sv, stmts, ins)
                     end
-                    if isa(res, Tuple)
-                        if isa(res[2], Array) && !isempty(res[2])
-                            append!(stmts, res[2])
-                        end
-                        res = res[1]
-                    end
-                    return (res, stmts)
+                    return res
                 end
             end
         end
@@ -4384,13 +4951,14 @@ function inlining_pass(e::Expr, sv::InferenceState)
         ata[1] = ft
         for i = 2:length(e.args)
             a = exprtype(e.args[i], sv.src, sv.mod)
-            (a === Bottom || isvarargtype(a)) && return (e, stmts)
+            (a === Bottom || isvarargtype(a)) && return e
             ata[i] = a
         end
-        res = inlineable(f, ft, e, ata, sv)
+        res = inlineable(f, ft, e, ata, sv, stmts)
         if isa(res,Tuple)
             if isa(res[2],Array) && !isempty(res[2])
-                append!(stmts,res[2])
+                splice!(stmts, ins:ins-1, res[2])
+                ins += length(res[2])
             end
             res = res[1]
         end
@@ -4402,31 +4970,65 @@ function inlining_pass(e::Expr, sv::InferenceState)
                 e = res::Expr
                 f = _apply; ft = abstract_eval_constant(f)
             else
-                return (res,stmts)
+                return res
             end
         end
 
         if f === _apply
             na = length(e.args)
             newargs = Vector{Any}(na-2)
+            newstmts = Any[]
+            effect_free_upto = 0
             for i = 3:na
                 aarg = e.args[i]
-                t = widenconst(exprtype(aarg, sv.src, sv.mod))
+                argt = exprtype(aarg, sv.src, sv.mod)
+                t = widenconst(argt)
                 if isa(aarg,Expr) && (is_known_call(aarg, tuple, sv.src, sv.mod) || is_known_call(aarg, svec, sv.src, sv.mod))
                     # apply(f,tuple(x,y,...)) => f(x,y,...)
                     newargs[i-2] = aarg.args[2:end]
-                elseif isa(aarg, Tuple)
+                elseif isa(argt,Const) && (isa(argt.val, Tuple) || isa(argt.val, SimpleVector)) &&
+                        effect_free(aarg, sv.src, sv.mod, true)
+                    newargs[i-2] = Any[ QuoteNode(x) for x in argt.val ]
+                elseif isa(aarg, Tuple) || (isa(aarg, QuoteNode) && (isa(aarg.value, Tuple) || isa(aarg.value, SimpleVector)))
+                    if isa(aarg, QuoteNode)
+                        aarg = aarg.value
+                    end
                     newargs[i-2] = Any[ QuoteNode(x) for x in aarg ]
                 elseif isa(t, DataType) && t.name === Tuple.name && !isvatuple(t) &&
-                        effect_free(aarg, sv.src, sv.mod, true) && length(t.parameters) <= sv.params.MAX_TUPLE_SPLAT
-                    # apply(f,t::(x,y)) => f(t[1],t[2])
-                    tp = t.parameters
-                    newargs[i-2] = Any[ mk_getfield(aarg,j,tp[j]) for j=1:length(tp) ]
+                         length(t.parameters) <= sv.params.MAX_TUPLE_SPLAT
+                    for k = (effect_free_upto+1):(i-3)
+                        as = newargs[k]
+                        for kk = 1:length(as)
+                            ak = as[kk]
+                            if !effect_free(ak, sv.src, sv.mod, true)
+                                tmpv = newvar!(sv, widenconst(exprtype(ak, sv.src, sv.mod)))
+                                push!(newstmts, Expr(:(=), tmpv, ak))
+                                as[kk] = tmpv
+                            end
+                        end
+                    end
+                    effect_free_upto = i-3
+                    if effect_free(aarg, sv.src, sv.mod, true)
+                        # apply(f,t::(x,y)) => f(t[1],t[2])
+                        tmpv = aarg
+                    else
+                        # apply(f,t::(x,y)) => tmp=t; f(tmp[1],tmp[2])
+                        tmpv = newvar!(sv, t)
+                        push!(newstmts, Expr(:(=), tmpv, aarg))
+                    end
+                    if is_specializable_vararg_slot(aarg, sv)
+                        tp = sv.vararg_type_container.parameters
+                    else
+                        tp = t.parameters
+                    end
+                    newargs[i-2] = Any[ mk_getfield(tmpv,j,tp[j]) for j=1:length(tp) ]
                 else
                     # not all args expandable
-                    return (e,stmts)
+                    return e
                 end
             end
+            splice!(stmts, ins:ins-1, newstmts)
+            ins += length(newstmts)
             e.args = [Any[e.args[2]]; newargs...]
 
             # now try to inline the simplified call
@@ -4439,19 +5041,19 @@ function inlining_pass(e::Expr, sv::InferenceState)
             else
                 f = nothing
                 if !( isconcrete(ft) || ft<:Type )
-                    return (e,stmts)
+                    return e
                 end
             end
         else
-            return (e,stmts)
+            return e
         end
     end
-    return (e,stmts)
+    return e
 end
 
 const compiler_temp_sym = Symbol("#temp#")
 
-function add_slot!(src::CodeInfo, typ::ANY, is_sa::Bool, name::Symbol=compiler_temp_sym)
+function add_slot!(src::CodeInfo, @nospecialize(typ), is_sa::Bool, name::Symbol=compiler_temp_sym)
     @assert !isa(typ, Const) && !isa(typ, Conditional)
     id = length(src.slotnames) + 1
     push!(src.slotnames, name)
@@ -4460,7 +5062,7 @@ function add_slot!(src::CodeInfo, typ::ANY, is_sa::Bool, name::Symbol=compiler_t
     return SlotNumber(id)
 end
 
-function is_known_call(e::Expr, func::ANY, src::CodeInfo, mod::Module)
+function is_known_call(e::Expr, @nospecialize(func), src::CodeInfo, mod::Module)
     if e.head !== :call
         return false
     end
@@ -4468,7 +5070,7 @@ function is_known_call(e::Expr, func::ANY, src::CodeInfo, mod::Module)
     return isa(f, Const) && f.val === func
 end
 
-function is_known_call_p(e::Expr, pred::ANY, src::CodeInfo, mod::Module)
+function is_known_call_p(e::Expr, @nospecialize(pred), src::CodeInfo, mod::Module)
     if e.head !== :call
         return false
     end
@@ -4476,64 +5078,143 @@ function is_known_call_p(e::Expr, pred::ANY, src::CodeInfo, mod::Module)
     return (isa(f, Const) && pred(f.val)) || (isType(f) && pred(f.parameters[1]))
 end
 
-function delete_var!(src::CodeInfo, id, T)
+function record_used(@nospecialize(e), @nospecialize(T), used::Vector{Bool})
+    if isa(e,T)
+        used[e.id+1] = true
+    elseif isa(e,Expr)
+        i0 = e.head === :(=) ? 2 : 1
+        for i = i0:length(e.args)
+            record_used(e.args[i], T, used)
+        end
+    end
+end
+
+function remove_unused_vars!(src::CodeInfo)
+    used = fill(false, length(src.slotnames)+1)
+    used_ssa = fill(false, length(src.ssavaluetypes)+1)
+    for i = 1:length(src.code)
+        record_used(src.code[i], Slot, used)
+        record_used(src.code[i], SSAValue, used_ssa)
+    end
+    for i = 1:length(src.code)
+        e = src.code[i]
+        if isa(e,NewvarNode) && !used[e.slot.id+1]
+            src.code[i] = nothing
+        elseif isa(e,Expr) && e.head === :(=)
+            if (isa(e.args[1],Slot) && !used[e.args[1].id+1]) ||
+                (isa(e.args[1],SSAValue) && !used_ssa[e.args[1].id+1])
+                src.code[i] = e.args[2]
+            end
+        end
+    end
+end
+
+function delete_vars!(src::CodeInfo, r::ObjectIdDict)
     filter!(x->!(isa(x,Expr) && (x.head === :(=) || x.head === :const) &&
-                 isa(x.args[1],T) && x.args[1].id == id),
+                 haskey(r, normvar(x.args[1]))),
             src.code)
     return src
 end
 
-function slot_replace!(src::CodeInfo, id::Int, rhs::ANY, T::ANY)
+function replace_vars!(src::CodeInfo, r::ObjectIdDict)
     for i = 1:length(src.code)
-        src.code[i] = _slot_replace!(src.code[i], id, rhs, T)
+        src.code[i] = _replace_vars!(src.code[i], r)
     end
     return src
 end
 
-function _slot_replace!(e, id::Int, rhs::ANY, T::ANY)
-    if isa(e,T) && e.id == id
-        return rhs
+function _replace_vars!(@nospecialize(e), r::ObjectIdDict)
+    if isa(e, SSAValue) || isa(e, Slot)
+        v = normvar(e)
+        if haskey(r, v)
+            return r[v]
+        end
     end
-    if isa(e,Expr)
+    if isa(e, Expr)
         for i = 1:length(e.args)
-            e.args[i] = _slot_replace!(e.args[i], id, rhs, T)
+            a = e.args[i]
+            if e.head === :isdefined
+                if e.args[i] !== _replace_vars!(a, r)
+                    return true
+                end
+            else
+                e.args[i] = _replace_vars!(a, r)
+            end
         end
     end
     return e
 end
 
-occurs_undef(var::Int, expr, flags) =
-    flags[var] & Slot_UsedUndef != 0 && occurs_more(expr, e -> (isa(e, Slot) && slot_id(e) == var), 0) > 0
-
 is_argument(nargs::Int, v::Slot) = slot_id(v) <= nargs
 
+normslot(s::SlotNumber) = s
+normslot(s::TypedSlot) = SlotNumber(slot_id(s))
+normvar(s::Slot) = normslot(s)
+normvar(s::SSAValue) = s
+normvar(@nospecialize(s)) = s
+
+# given a single-assigned var and its initializer `init`, return what we can
+# replace `var` with, or `var` itself if we shouldn't replace it
+function get_replacement(table, var::Union{SlotNumber, SSAValue}, @nospecialize(init), nargs, slottypes, ssavaluetypes)
+    #if isa(init, QuoteNode)  # this can cause slight code size increases
+    #    return init
+    if (isa(init, Expr) && init.head === :static_parameter) || isa(init, corenumtype) ||
+        init === () || init === nothing
+        return init
+    elseif isa(init, Slot) && is_argument(nargs, init::Slot)
+        # the transformation is not ideal if the assignment
+        # is present for the auto-unbox functionality
+        # (from inlining improved type inference information)
+        # and this transformation would worsen the type information
+        # everywhere later in the function
+        ityp = isa(init, TypedSlot) ? init.typ : slottypes[(init::SlotNumber).id]
+        if ityp ⊑ (isa(var,SSAValue) ? ssavaluetypes[var.id + 1] : slottypes[var.id])
+            return init
+        end
+    elseif isa(init, SSAValue)
+        if isa(var, SlotNumber) && slottypes[var.id] ⊑ Tuple
+            # Here we avoid replacing a Slot with an SSAValue when the type is an
+            # aggregate. That can cause LLVM to generate a bunch of extra memcpys
+            # if the data ever needs to be stack allocated later.
+            return var
+        end
+        if haskey(table, init)
+            return get_replacement(table, init, table[init], nargs, slottypes, ssavaluetypes)
+        end
+        return init
+    elseif isa(init, SlotNumber) && haskey(table, init)
+        return get_replacement(table, init, table[init], nargs, slottypes, ssavaluetypes)
+    elseif isa(init, TypedSlot)
+        sl = normslot(init)
+        if haskey(table, sl)
+            rep = get_replacement(table, sl, table[sl], nargs, slottypes, ssavaluetypes)
+            if isa(rep, SlotNumber)
+                rep = TypedSlot(rep.id, init.typ)
+            end
+            return rep
+        end
+    end
+    return var
+end
+
 # remove all single-assigned vars v in "v = x" where x is an argument.
 # "sa" is the result of find_sa_vars
-# T: Slot or SSAValue
-function remove_redundant_temp_vars(src::CodeInfo, nargs::Int, sa, T)
+function remove_redundant_temp_vars!(src::CodeInfo, nargs::Int, sa::ObjectIdDict)
     flags = src.slotflags
-    ssavalue_types = src.ssavaluetypes
-    bexpr = Expr(:block)
-    bexpr.args = src.code
+    slottypes = src.slottypes
+    ssavaluetypes = src.ssavaluetypes
+    repls = ObjectIdDict()
     for (v, init) in sa
-        if isa(init, Slot) && is_argument(nargs, init::Slot)
-            # this transformation is not valid for vars used before def.
-            # we need to preserve the point of assignment to know where to
-            # throw errors (issue #4645).
-            if T === SSAValue || !occurs_undef(v, bexpr, flags)
-                # the transformation is not ideal if the assignment
-                # is present for the auto-unbox functionality
-                # (from inlining improved type inference information)
-                # and this transformation would worsen the type information
-                # everywhere later in the function
-                ityp = isa(init, TypedSlot) ? init.typ : src.slottypes[(init::SlotNumber).id]
-                if ityp ⊑ (T === SSAValue ? ssavalue_types[v + 1] : src.slottypes[v])
-                    delete_var!(src, v, T)
-                    slot_replace!(src, v, init, T)
-                end
-            end
+        repl = get_replacement(sa, v, init, nargs, slottypes, ssavaluetypes)
+        compare = isa(repl,TypedSlot) ? normslot(repl) : repl
+        if compare !== v
+            repls[v] = repl
         end
     end
+    if !isempty(repls)
+        delete_vars!(src, repls)
+        replace_vars!(src, repls)
+    end
     return src
 end
 
@@ -4542,35 +5223,39 @@ function find_sa_vars(src::CodeInfo, nargs::Int)
     body = src.code
     av = ObjectIdDict()
     av2 = ObjectIdDict()
-    gss = ObjectIdDict()
     for i = 1:length(body)
         e = body[i]
         if isa(e,Expr) && e.head === :(=)
             lhs = e.args[1]
             if isa(lhs, SSAValue)
-                gss[lhs.id] = e.args[2]
+                av[lhs] = e.args[2]
             elseif isa(lhs, Slot)
-                id = slot_id(lhs)
-                if id > nargs  # exclude args
-                    if !haskey(av, id)
-                        av[id] = e.args[2]
+                lhs = normslot(lhs)
+                id = lhs.id
+                # exclude args and used undef vars
+                # this transformation is not valid for vars used before def.
+                # we need to preserve the point of assignment to know where to
+                # throw errors (issue #4645).
+                if id > nargs && (src.slotflags[id] & Slot_UsedUndef == 0)
+                    if !haskey(av, lhs)
+                        av[lhs] = e.args[2]
                     else
-                        av2[id] = true
+                        av2[lhs] = true
                     end
                 end
             end
         end
     end
-    filter!((id, _) -> !haskey(av2, id), av)
-    return (av, gss)
+    filter!((v, _) -> !haskey(av2, v), av)
+    return av
 end
 
 symequal(x::SSAValue, y::SSAValue) = x.id === y.id
 symequal(x::Slot    , y::Slot)     = x.id === y.id
-symequal(x::ANY     , y::ANY)      = x === y
+symequal(@nospecialize(x)     , @nospecialize(y))      = x === y
 
-function occurs_outside_getfield(e::ANY, sym::ANY,
-                                 sv::InferenceState, field_count::Int, field_names::ANY)
+function occurs_outside_getfield(@nospecialize(e), @nospecialize(sym),
+                                 sv::InferenceState, field_count::Int, @nospecialize(field_names))
     if e === sym || (isa(e, Slot) && isa(sym, Slot) && slot_id(e) == slot_id(sym))
         return true
     end
@@ -4591,6 +5276,27 @@ function occurs_outside_getfield(e::ANY, sym::ANY,
         if head === :(=)
             return occurs_outside_getfield(e.args[2], sym, sv,
                                            field_count, field_names)
+        elseif head === :foreigncall
+            args = e.args
+            nccallargs = args[5]::Int
+            # Only arguments escape the structure/layout of the object,
+            # GC root arguments do not.
+            # Also note that only being used in the root slot for this ccall itself
+            # does **not** mean that the object is not needed during the ccall.
+            # However, if its address is never taken
+            # and the object is never used in a way that escapes its layout, we can be sure
+            # that there's no way the user code can rely on the heap allocation of this object.
+            for i in 1:length(args)
+                a = args[i]
+                if i > 5 + nccallargs && symequal(a, sym)
+                    # No need to verify indices, uninitialized members can be
+                    # ignored in root slot.
+                    continue
+                end
+                if occurs_outside_getfield(a, sym, sv, field_count, field_names)
+                    return true
+                end
+            end
         else
             if (head === :block && isa(sym, Slot) &&
                 sv.src.slotflags[slot_id(sym)] & Slot_UsedUndef == 0)
@@ -4614,7 +5320,7 @@ end
 function void_use_elim_pass!(sv::InferenceState)
     # Remove top level SSAValue and slots that is `!usedUndef`.
     # Also remove some `nothing` while we are at it....
-    not_void_use = function (ex::ANY)
+    not_void_use = function (@nospecialize(ex),)
         if isa(ex, SSAValue)
             # Explicitly listed here for clarity
             return false
@@ -4623,9 +5329,15 @@ function void_use_elim_pass!(sv::InferenceState)
         elseif isa(ex, GlobalRef)
             ex = ex::GlobalRef
             return !isdefined(ex.mod, ex.name)
-        elseif (isa(ex, Expr) || isa(ex, GotoNode) || isa(ex, LineNumberNode) ||
+        elseif isa(ex, Expr)
+            h = ex.head
+            if h === :return || h === :(=) || h === :gotoifnot || is_meta_expr_head(h)
+                return true
+            end
+            return !effect_free(ex, sv.src, sv.mod, false)
+        elseif (isa(ex, GotoNode) || isa(ex, LineNumberNode) ||
                 isa(ex, NewvarNode) || isa(ex, Symbol) || isa(ex, LabelNode))
-            # This is a list of special type handled by the compiler
+            # This is a list of special types handled by the compiler
             return true
         end
         return false
@@ -4879,6 +5591,7 @@ function meta_elim_pass!(code::Array{Any,1}, propagate_inbounds::Bool, do_covera
                 code[push_loc] = nothing
                 code[i] = nothing
             else
+                prev_dbg_stack[end] = 0
                 push_loc_pos_stack[end] = 0
             end
         else
@@ -4892,6 +5605,8 @@ end
 # TODO can probably be removed when we switch to a linear IR
 function getfield_elim_pass!(sv::InferenceState)
     body = sv.src.code
+    nssavalues = length(sv.src.ssavaluetypes)
+    sv.ssavalue_defs = find_ssavalue_defs(body, nssavalues)
     for i = 1:length(body)
         body[i] = _getfield_elim_pass!(body[i], sv)
     end
@@ -4905,11 +5620,18 @@ function _getfield_elim_pass!(e::Expr, sv::InferenceState)
         (isa(e.args[3],Int) || isa(e.args[3],QuoteNode))
         e1 = e.args[2]
         j = e.args[3]
-        if isa(e1,Expr)
-            alloc = is_allocation(e1, sv)
+        single_use = true
+        while isa(e1, SSAValue)
+            single_use = false
+            def = sv.ssavalue_defs[e1.id + 1]
+            stmt = sv.src.code[def]::Expr
+            e1 = stmt.args[2]
+        end
+        if isa(e1, Expr)
+            alloc = single_use && is_allocation(e1, sv)
             if alloc !== false
                 flen, fnames = alloc
-                if isa(j,QuoteNode)
+                if isa(j, QuoteNode)
                     j = findfirst(fnames, j.value)
                 end
                 if 1 <= j <= flen
@@ -4925,26 +5647,39 @@ function _getfield_elim_pass!(e::Expr, sv::InferenceState)
                     end
                 end
             end
-        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)
+        elseif isa(e1, GlobalRef) || isa(e1, Symbol) || isa(e1, Slot)
+            # non-self-quoting value
+        else
+            if isa(e1, QuoteNode)
+                e1 = e1.value
+            end
+            if isimmutable(e1) || isa(e1, SimpleVector)
+                # SimpleVector length field is immutable
+                if isa(j, QuoteNode)
+                    j = j.value
+                    if !(isa(j, Int) || isa(j, Symbol))
+                        return e
+                    end
+                end
+                if isdefined(e1, j)
+                    e1j = getfield(e1, j)
+                    if !is_self_quoting(e1j)
+                        e1j = QuoteNode(e1j)
+                    end
+                    return e1j
+                end
             end
-            return e1j
-        elseif isa(e1,QuoteNode) && isa(e1.value,Tuple) && isa(j,Int) && (1 <= j <= length(e1.value))
-            return QuoteNode(e1.value[j])
         end
     end
     return e
 end
 
-_getfield_elim_pass!(e::ANY, sv) = e
+_getfield_elim_pass!(@nospecialize(e), sv) = e
 
 # check if e is a successful allocation of an 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_allocation(e::ANY, sv::InferenceState)
+function is_allocation(@nospecialize(e), sv::InferenceState)
     isa(e, Expr) || return false
     if is_known_call(e, tuple, sv.src, sv.mod)
         return (length(e.args)-1,())
@@ -4953,8 +5688,8 @@ function is_allocation(e::ANY, sv::InferenceState)
         if isa(typ, DataType) && isconcrete(typ)
             nf = length(e.args) - 1
             names = fieldnames(typ)
-            @assert(nf <= nfields(typ))
-            if nf < nfields(typ)
+            @assert(nf <= length(names))
+            if nf < length(names)
                 # some fields were left undef
                 # we could potentially propagate Bottom
                 # for pointer fields
@@ -5000,9 +5735,9 @@ function alloc_elim_pass!(sv::InferenceState)
     body = sv.src.code
     bexpr = Expr(:block)
     bexpr.args = body
-    vs, gs = find_sa_vars(sv.src, sv.nargs)
-    remove_redundant_temp_vars(sv.src, sv.nargs, vs, Slot)
-    remove_redundant_temp_vars(sv.src, sv.nargs, gs, SSAValue)
+    vs = find_sa_vars(sv.src, sv.nargs)
+    remove_redundant_temp_vars!(sv.src, sv.nargs, vs)
+    remove_unused_vars!(sv.src)
     i = 1
     while i < length(body)
         e = body[i]
@@ -5012,7 +5747,7 @@ function alloc_elim_pass!(sv::InferenceState)
         end
         e = e::Expr
         if e.head === :(=) && (isa(e.args[1], SSAValue) ||
-                               (isa(e.args[1], Slot) && haskey(vs, slot_id(e.args[1]))))
+                               (isa(e.args[1], Slot) && haskey(vs, normslot(e.args[1]))))
             var = e.args[1]
             rhs = e.args[2]
             # Need to make sure LLVM can recognize this as LLVM ssa value too
@@ -5145,8 +5880,11 @@ end
 function replace_getfield!(e::Expr, tupname, vals, field_names, sv::InferenceState)
     for i = 1:length(e.args)
         a = e.args[i]
-        if isa(a,Expr) && is_known_call(a, getfield, sv.src, sv.mod) &&
-            symequal(a.args[2],tupname)
+        if !isa(a, Expr)
+            continue
+        end
+        a = a::Expr
+        if is_known_call(a, getfield, sv.src, sv.mod) && symequal(a.args[2], tupname)
             idx = if isa(a.args[3], Int)
                 a.args[3]
             else
@@ -5175,8 +5913,23 @@ function replace_getfield!(e::Expr, tupname, vals, field_names, sv::InferenceSta
                 end
             end
             e.args[i] = val
-        elseif isa(a, Expr)
-            replace_getfield!(a::Expr, tupname, vals, field_names, sv)
+        else
+            if a.head === :foreigncall
+                args = a.args
+                nccallargs = args[5]::Int
+                le = length(args)
+                next_i = 6 + nccallargs
+                while next_i <= le
+                    i = next_i
+                    next_i += 1
+
+                    symequal(args[i], tupname) || continue
+                    # Replace the gc root argument with its fields
+                    splice!(args, i, vals)
+                    next_i += length(vals) - 1
+                end
+            end
+            replace_getfield!(a, tupname, vals, field_names, sv)
         end
     end
 end
@@ -5222,14 +5975,23 @@ function reindex_labels!(sv::InferenceState)
     end
 end
 
-function return_type(f::ANY, t::ANY)
+function return_type(@nospecialize(f), @nospecialize(t))
     params = InferenceParams(ccall(:jl_get_tls_world_age, UInt, ()))
     rt = Union{}
-    for m in _methods(f, t, -1, params.world)
-        ty = typeinf_type(m[3], m[1], m[2], true, params)
-        ty === nothing && return Any
-        rt = tmerge(rt, ty)
-        rt === Any && break
+    if isa(f, Builtin)
+        rt = builtin_tfunction(f, Any[t.parameters...], nothing, params)
+        if isa(rt, TypeVar)
+            rt = rt.ub
+        else
+            rt = widenconst(rt)
+        end
+    else
+        for m in _methods(f, t, -1, params.world)
+            ty = typeinf_type(m[3], m[1], m[2], true, params)
+            ty === nothing && return Any
+            rt = tmerge(rt, ty)
+            rt === Any && break
+        end
     end
     return rt
 end
@@ -5241,7 +6003,8 @@ end
 # especially try to make sure any recursive and leaf functions have concrete signatures,
 # since we won't be able to specialize & infer them at runtime
 
-let fs = Any[typeinf_ext, typeinf_loop, typeinf_edge, occurs_outside_getfield, pure_eval_call]
+let fs = Any[typeinf_ext, typeinf, typeinf_edge, occurs_outside_getfield, pure_eval_call],
+    world = ccall(:jl_get_world_counter, UInt, ())
     for x in t_ffunc_val
         push!(fs, x[3])
     end
@@ -5249,6 +6012,8 @@ let fs = Any[typeinf_ext, typeinf_loop, typeinf_edge, occurs_outside_getfield, p
         if isassigned(t_ifunc, i)
             x = t_ifunc[i]
             push!(fs, x[3])
+        else
+            println(STDERR, "WARNING: tfunc missing for ", reinterpret(IntrinsicFunction, Int32(i)))
         end
     end
     for f in fs
@@ -5260,7 +6025,7 @@ let fs = Any[typeinf_ext, typeinf_loop, typeinf_edge, occurs_outside_getfield, p
                     typ[i] = typ[i].ub
                 end
             end
-            typeinf_type(m[3], Tuple{typ...}, m[2], true, InferenceParams(typemax(UInt)))
+            typeinf_type(m[3], Tuple{typ...}, m[2], true, InferenceParams(world))
         end
     end
 end
diff --git a/base/initdefs.jl b/base/initdefs.jl
index 0259b131de91f9..2cab2349383cd9 100644
--- a/base/initdefs.jl
+++ b/base/initdefs.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## initdefs.jl - initialization and runtime management definitions
 
@@ -9,7 +9,7 @@ A string containing the script name passed to Julia from the command line. Note
 script name remains unchanged from within included files. Alternatively see
 [`@__FILE__`](@ref).
 """
-PROGRAM_FILE = ""
+global PROGRAM_FILE = ""
 
 """
     ARGS
@@ -18,13 +18,32 @@ An array of the command line arguments passed to Julia, as strings.
 """
 const ARGS = String[]
 
+"""
+    exit([code])
+
+Quit (or control-D at the prompt). The default exit code is zero, indicating that the
+processes completed successfully.
+"""
 exit(n) = ccall(:jl_exit, Void, (Int32,), n)
 exit() = exit(0)
+
+"""
+    quit()
+
+Quit the program indicating that the processes completed successfully. This function calls
+`exit(0)` (see [`exit`](@ref)).
+"""
 quit() = exit()
 
 const roottask = current_task()
 
 is_interactive = false
+
+"""
+    isinteractive() -> Bool
+
+Determine whether Julia is running an interactive session.
+"""
 isinteractive() = (is_interactive::Bool)
 
 """
@@ -50,7 +69,7 @@ const LOAD_CACHE_PATH = String[]
 function init_load_path()
     vers = "v$(VERSION.major).$(VERSION.minor)"
     if haskey(ENV, "JULIA_LOAD_PATH")
-        prepend!(LOAD_PATH, split(ENV["JULIA_LOAD_PATH"], @static is_windows() ? ';' : ':'))
+        prepend!(LOAD_PATH, split(ENV["JULIA_LOAD_PATH"], @static Sys.iswindows() ? ';' : ':'))
     end
     push!(LOAD_PATH, abspath(JULIA_HOME, "..", "local", "share", "julia", "site", vers))
     push!(LOAD_PATH, abspath(JULIA_HOME, "..", "share", "julia", "site", vers))
@@ -77,6 +96,12 @@ A string containing the full path to the directory containing the `julia` execut
 
 const atexit_hooks = []
 
+"""
+    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(f::Function) = (unshift!(atexit_hooks, f); nothing)
 
 function _atexit()
diff --git a/base/int.jl b/base/int.jl
index aca8405da700f7..29f206dab146cb 100644
--- a/base/int.jl
+++ b/base/int.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## integer arithmetic ##
 
@@ -7,35 +7,46 @@
 # 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...)
-
-const BitSigned64    = Union{BitSigned64_types...}
-const BitUnsigned64  = Union{BitUnsigned64_types...}
-const BitInteger64   = Union{BitInteger64_types...}
-const BitSigned      = Union{BitSigned_types...}
-const BitUnsigned    = Union{BitUnsigned_types...}
-const BitInteger     = Union{BitInteger_types...}
-const BitSigned64T   = Union{Type{Int8}, Type{Int16}, Type{Int32}, Type{Int64}}
-const BitUnsigned64T = Union{Type{UInt8}, Type{UInt16}, Type{UInt32}, Type{UInt64}}
+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...)
+const BitSignedSmall_types   = Int === Int64 ? ( Int8,  Int16,  Int32) : ( Int8,  Int16)
+const BitUnsignedSmall_types = Int === Int64 ? (UInt8, UInt16, UInt32) : (UInt8, UInt16)
+const BitIntegerSmall_types  = (BitSignedSmall_types..., BitUnsignedSmall_types...)
+
+const BitSigned64      = Union{BitSigned64_types...}
+const BitUnsigned64    = Union{BitUnsigned64_types...}
+const BitInteger64     = Union{BitInteger64_types...}
+const BitSigned        = Union{BitSigned_types...}
+const BitUnsigned      = Union{BitUnsigned_types...}
+const BitInteger       = Union{BitInteger_types...}
+const BitSignedSmall   = Union{BitSignedSmall_types...}
+const BitUnsignedSmall = Union{BitUnsignedSmall_types...}
+const BitIntegerSmall  = Union{BitIntegerSmall_types...}
+const BitSigned64T     = Union{Type{Int8}, Type{Int16}, Type{Int32}, Type{Int64}}
+const BitUnsigned64T   = Union{Type{UInt8}, Type{UInt16}, Type{UInt32}, Type{UInt64}}
+
+const BitIntegerType = Union{map(T->Type{T}, BitInteger_types)...}
+
+throw_inexacterror(f::Symbol, ::Type{T}, val) where T =
+    (@_noinline_meta; throw(InexactError(f, T, val)))
 
 ## integer comparisons ##
 
-<{T<:BitSigned}(x::T, y::T)  = slt_int(x, y)
+(<)(x::T, y::T) where {T<:BitSigned}  = slt_int(x, y)
 
--(x::BitInteger)             = neg_int(x)
--{T<:BitInteger}(x::T, y::T) = sub_int(x, y)
-+{T<:BitInteger}(x::T, y::T) = add_int(x, y)
-*{T<:BitInteger}(x::T, y::T) = mul_int(x, y)
+(-)(x::BitInteger)                    = neg_int(x)
+(-)(x::T, y::T) where {T<:BitInteger} = sub_int(x, y)
+(+)(x::T, y::T) where {T<:BitInteger} = add_int(x, y)
+(*)(x::T, y::T) where {T<:BitInteger} = mul_int(x, y)
 
 inv(x::Integer) = float(one(x)) / float(x)
-/{T<:Integer}(x::T, y::T) = float(x) / float(y)
+(/)(x::T, y::T) where {T<:Integer} = float(x) / float(y)
 # skip promotion for system integer types
-/(x::BitInteger, y::BitInteger) = float(x) / float(y)
+(/)(x::BitInteger, y::BitInteger) = float(x) / float(y)
 
 """
     isodd(x::Integer) -> Bool
@@ -70,7 +81,8 @@ iseven(n::Integer) = !isodd(n)
 signbit(x::Integer) = x < 0
 signbit(x::Unsigned) = false
 
-flipsign{T<:BitSigned}(x::T, y::T) = flipsign_int(x, y)
+flipsign(x::T, y::T) where {T<:BitSigned} = flipsign_int(x, y)
+flipsign(x::BitSigned, y::BitSigned) = flipsign_int(promote(x, y)...) % typeof(x)
 
 flipsign(x::Signed, y::Signed)  = convert(typeof(x), flipsign(promote_noncircular(x, y)...))
 flipsign(x::Signed, y::Float16) = flipsign(x, bitcast(Int16, y))
@@ -115,8 +127,34 @@ abs(x::Signed) = flipsign(x,x)
 
 unsigned(x::Signed) = reinterpret(typeof(convert(Unsigned, zero(x))), x)
 unsigned(x::Bool) = convert(Unsigned, x)
+
+"""
+    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.
+
+# Examples
+```jldoctest
+julia> unsigned(-2)
+0xfffffffffffffffe
+
+julia> unsigned(2)
+0x0000000000000002
+
+julia> signed(unsigned(-2))
+-2
+```
+"""
 unsigned(x) = convert(Unsigned, x)
 signed(x::Unsigned) = reinterpret(typeof(convert(Signed, zero(x))), x)
+
+"""
+    signed(x)
+
+Convert a number to a signed integer. If the argument is unsigned, it is reinterpreted as
+signed without checking for overflow.
+"""
 signed(x) = convert(Signed, x)
 
 div(x::Signed, y::Unsigned) = flipsign(signed(div(unsigned(abs(x)), y)), x)
@@ -131,56 +169,130 @@ fld(x::Unsigned, y::Signed) = div(x, y) - (signbit(y) & (rem(x, y) != 0))
 
 """
     mod(x, y)
+    rem(x, y, RoundDown)
 
-Modulus after flooring division, returning in the range ``[0,y)``, if `y` is positive, or
-``(y,0]`` if `y` is negative.
-
+The reduction of `x` modulo `y`, or equivalently, the remainder of `x` after floored
+division by `y`, i.e.
 ```julia
-x == fld(x,y)*y + mod(x,y)
+x - y*fld(x,y)
+```
+if computed without intermediate rounding.
+
+The result will have the same sign as `y`, and magnitude less than `abs(y)` (with some
+exceptions, see note below).
+
+!!! note
+
+    When used with floating point values, the exact result may not be representable by the
+    type, and so rounding error may occur. In particular, if the exact result is very
+    close to `y`, then it may be rounded to `y`.
+
+```jldoctest
+julia> mod(8, 3)
+2
+
+julia> mod(9, 3)
+0
+
+julia> mod(8.9, 3)
+2.9000000000000004
+
+julia> mod(eps(), 3)
+2.220446049250313e-16
+
+julia> mod(-eps(), 3)
+3.0
 ```
 """
-function mod{T<:Integer}(x::T, y::T)
+function mod(x::T, y::T) where T<:Integer
     y == -1 && return T(0)   # avoid potential overflow in fld
     return x - fld(x, y) * y
 end
 mod(x::Signed, y::Unsigned) = rem(y + unsigned(rem(x, y)), y)
 mod(x::Unsigned, y::Signed) = rem(y + signed(rem(x, y)), y)
-mod{T<:Unsigned}(x::T, y::T) = rem(x, y)
+mod(x::T, y::T) where {T<:Unsigned} = rem(x, 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 is no danger of overflow,
 # while there is a substantial performance penalty to 64-bit promotion.
-div{T<:BitSigned64}(x::T, y::T) = checked_sdiv_int(x, y)
-rem{T<:BitSigned64}(x::T, y::T) = checked_srem_int(x, y)
-div{T<:BitUnsigned64}(x::T, y::T) = checked_udiv_int(x, y)
-rem{T<:BitUnsigned64}(x::T, y::T) = checked_urem_int(x, y)
+div(x::T, y::T) where {T<:BitSigned64} = checked_sdiv_int(x, y)
+rem(x::T, y::T) where {T<:BitSigned64} = checked_srem_int(x, y)
+div(x::T, y::T) where {T<:BitUnsigned64} = checked_udiv_int(x, y)
+rem(x::T, y::T) where {T<:BitUnsigned64} = checked_urem_int(x, y)
 
 
 # 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)
-function fld{T<:Integer}(x::T, y::T)
+fld(x::T, y::T) where {T<:Unsigned} = div(x,y)
+function fld(x::T, y::T) where T<:Integer
     d = div(x, y)
     return d - (signbit(x ⊻ y) & (d * y != x))
 end
 
 # cld(x,y) = div(x,y) + ((x>0) == (y>0) && rem(x,y) != 0 ? 1 : 0)
-function cld{T<:Unsigned}(x::T, y::T)
+function cld(x::T, y::T) where T<:Unsigned
     d = div(x, y)
     return d + (d * y != x)
 end
-function cld{T<:Integer}(x::T, y::T)
+function cld(x::T, y::T) where T<:Integer
     d = div(x, y)
     return d + (((x > 0) == (y > 0)) & (d * y != x))
 end
 
 ## integer bitwise operations ##
 
+"""
+    ~(x)
+
+Bitwise not.
+
+# Examples
+```jldoctest
+julia> ~4
+-5
+
+julia> ~10
+-11
+
+julia> ~true
+false
+```
+"""
 (~)(x::BitInteger)             = not_int(x)
-(&){T<:BitInteger}(x::T, y::T) = and_int(x, y)
-(|){T<:BitInteger}(x::T, y::T) = or_int(x, y)
-xor{T<:BitInteger}(x::T, y::T) = xor_int(x, y)
+
+"""
+    &(x, y)
+
+Bitwise and.
+
+# Examples
+```jldoctest
+julia> 4 & 10
+0
+
+julia> 4 & 12
+4
+```
+"""
+(&)(x::T, y::T) where {T<:BitInteger} = and_int(x, y)
+
+"""
+    |(x, y)
+
+Bitwise or.
+
+# Examples
+```jldoctest
+julia> 4 | 10
+14
+
+julia> 4 | 1
+5
+```
+"""
+(|)(x::T, y::T) where {T<:BitInteger} = or_int(x, y)
+xor(x::T, y::T) where {T<:BitInteger} = xor_int(x, y)
 
 bswap(x::Union{Int8, UInt8}) = x
 bswap(x::Union{Int16, UInt16, Int32, UInt32, Int64, UInt64, Int128, UInt128}) =
@@ -232,7 +344,7 @@ julia> count_zeros(Int32(2 ^ 16 - 1))
 16
 ```
 """
-count_zeros(  x::Integer) = count_ones(~x)
+count_zeros(x::Integer) = count_ones(~x)
 
 """
     leading_ones(x::Integer) -> Integer
@@ -244,7 +356,7 @@ julia> leading_ones(UInt32(2 ^ 32 - 2))
 31
 ```
 """
-leading_ones( x::Integer) = leading_zeros(~x)
+leading_ones(x::Integer) = leading_zeros(~x)
 
 """
     trailing_ones(x::Integer) -> Integer
@@ -260,9 +372,9 @@ trailing_ones(x::Integer) = trailing_zeros(~x)
 
 ## integer comparisons ##
 
-<{T<:BitUnsigned}(x::T, y::T)  = ult_int(x, y)
-<={T<:BitSigned}(x::T, y::T)   = sle_int(x, y)
-<={T<:BitUnsigned}(x::T, y::T) = ule_int(x, y)
+(< )(x::T, y::T) where {T<:BitUnsigned} = ult_int(x, y)
+(<=)(x::T, y::T) where {T<:BitSigned}   = sle_int(x, y)
+(<=)(x::T, y::T) where {T<:BitUnsigned} = ule_int(x, y)
 
 ==(x::Signed,   y::Unsigned) = (x >= 0) & (unsigned(x) == y)
 ==(x::Unsigned, y::Signed  ) = (y >= 0) & (x == unsigned(y))
@@ -288,13 +400,39 @@ trailing_ones(x::Integer) = trailing_zeros(~x)
 >>>(x::BitInteger, y::Int) =
     select_value(0 <= y, x >>> unsigned(y), x << unsigned(-y))
 
+function is_top_bit_set(x::BitInteger)
+    @_inline_meta
+    lshr_int(x, (sizeof(x) << 0x03) - 1) == rem(0x01, typeof(x))
+end
+function check_top_bit(x::BitInteger)
+    @_inline_meta
+    is_top_bit_set(x) && throw_inexacterror(:check_top_bit, typeof(x), x)
+    x
+end
+
 ## integer conversions ##
 
+function checked_trunc_sint(::Type{To}, x::From) where {To,From}
+    @_inline_meta
+    y = trunc_int(To, x)
+    back = sext_int(From, y)
+    x == back || throw_inexacterror(:trunc, To, x)
+    y
+end
+
+function checked_trunc_uint(::Type{To}, x::From) where {To,From}
+    @_inline_meta
+    y = trunc_int(To, x)
+    back = zext_int(From, y)
+    x == back || throw_inexacterror(:trunc, To, x)
+    y
+end
+
 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)
+            if to <: Signed
+                if from <: Unsigned
                     @eval convert(::Type{$to}, x::($from)) =
                         checked_trunc_sint($to, check_top_bit(x))
                 else
@@ -306,9 +444,13 @@ for to in BitInteger_types, from in (BitInteger_types..., Bool)
                     checked_trunc_uint($to, x)
             end
             @eval rem(x::($from), ::Type{$to}) = trunc_int($to, x)
-        elseif from.size < to.size || from === Bool
-            if issubtype(from, Signed)
-                if issubtype(to, Unsigned)
+        elseif from === Bool
+            # Bools use i8 storage and may have garbage in their 7 high bits
+            @eval convert(::Type{$to}, x::($from)) = zext_int($to, x) & $to(1)
+            @eval rem(x::($from), ::Type{$to}) = convert($to, x)
+        elseif from.size < to.size
+            if from <: Signed
+                if to <: Unsigned
                     @eval convert(::Type{$to}, x::($from)) =
                         sext_int($to, check_top_bit(x))
                 else
@@ -321,7 +463,7 @@ for to in BitInteger_types, from in (BitInteger_types..., Bool)
                 @eval rem(x::($from), ::Type{$to}) = convert($to, x)
             end
         else
-            if !(issubtype(from, Signed) === issubtype(to, Signed))
+            if !((from <: Signed) === (to <: Signed))
                 # raise InexactError if x's top bit is set
                 @eval convert(::Type{$to}, x::($from)) = bitcast($to, check_top_bit(x))
             else
@@ -332,11 +474,34 @@ for to in BitInteger_types, from in (BitInteger_types..., Bool)
     end
 end
 
-rem{T<:Integer}(x::T, ::Type{T}) = x
+# @doc isn't available when running in Core at this point.
+# Tuple syntax for documention two function signatures at the same time
+# doesn't work either at this point.
+if module_name(@__MODULE__) === :Base
+    for fname in (:mod, :rem)
+        @eval @doc ("""
+            rem(x::Integer, T::Type{<:Integer}) -> T
+            mod(x::Integer, T::Type{<:Integer}) -> T
+            %(x::Integer, T::Type{<:Integer}) -> T
+
+        Find `y::T` such that `x` ≡ `y` (mod n), where n is the number of integers representable
+        in `T`, and `y` is an integer in `[typemin(T),typemax(T)]`.
+        If `T` can represent any integer (e.g. `T == BigInt`), then this operation corresponds to
+        a conversion to `T`.
+
+        ```jldoctest
+        julia> 129 % Int8
+        -127
+        ```
+        """ -> $fname(x::Integer, T::Type{<:Integer}))
+    end
+end
+
+rem(x::T, ::Type{T}) where {T<:Integer} = x
 rem(x::Integer, ::Type{Bool}) = ((x & 1) != 0)
-mod{T<:Integer}(x::Integer, ::Type{T}) = rem(x, T)
+mod(x::Integer, ::Type{T}) where {T<:Integer} = rem(x, T)
 
-unsafe_trunc{T<:Integer}(::Type{T}, x::Integer) = rem(x, T)
+unsafe_trunc(::Type{T}, x::Integer) where {T<:Integer} = rem(x, T)
 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)
@@ -353,10 +518,10 @@ trunc(x::Integer) = x
 floor(x::Integer) = x
  ceil(x::Integer) = x
 
-round{T<:Integer}(::Type{T}, x::Integer) = convert(T, x)
-trunc{T<:Integer}(::Type{T}, x::Integer) = convert(T, x)
-floor{T<:Integer}(::Type{T}, x::Integer) = convert(T, x)
- ceil{T<:Integer}(::Type{T}, x::Integer) = convert(T, x)
+round(::Type{T}, x::Integer) where {T<:Integer} = convert(T, x)
+trunc(::Type{T}, x::Integer) where {T<:Integer} = convert(T, x)
+floor(::Type{T}, x::Integer) where {T<:Integer} = convert(T, x)
+ ceil(::Type{T}, x::Integer) where {T<:Integer} = convert(T, x)
 
 ## integer construction ##
 
@@ -516,7 +681,7 @@ if Core.sizeof(Int) == 4
         return Int128(mod(BigInt(x), BigInt(y)))
     end
 else
-    *{T<:Union{Int128,UInt128}}(x::T, y::T)  = mul_int(x, y)
+    *(x::T, y::T) where {T<:Union{Int128,UInt128}}  = mul_int(x, y)
 
     div(x::Int128,  y::Int128)  = checked_sdiv_int(x, y)
     div(x::UInt128, y::UInt128) = checked_udiv_int(x, y)
diff --git a/base/interactiveutil.jl b/base/interactiveutil.jl
index 77f8b49959be0d..a7ef16dba368d6 100644
--- a/base/interactiveutil.jl
+++ b/base/interactiveutil.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # editing files
 
@@ -10,7 +10,7 @@ for use within backticks. You can change the editor by setting `JULIA_EDITOR`, `
 `EDITOR` as an environment variable.
 """
 function editor()
-    if is_windows() || is_apple()
+    if Sys.iswindows() || Sys.isapple()
         default_editor = "open"
     elseif isfile("/etc/alternatives/editor")
         default_editor = "/etc/alternatives/editor"
@@ -40,18 +40,23 @@ function edit(path::AbstractString, line::Integer=0)
     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"
+    if startswith(name, "vim.") || name == "vi" || name == "vim" || name == "nvim" ||
+            name == "mvim" || name == "nano" ||
+            name == "emacs" && contains(in, command, ["-nw", "--no-window-system" ]) ||
+            name == "emacsclient" && contains(in, command, ["-nw", "-t", "-tty"])
         cmd = line != 0 ? `$command +$line $path` : `$command $path`
         background = false
+    elseif startswith(name, "emacs") || name == "gedit" || startswith(name, "gvim")
+        cmd = line != 0 ? `$command +$line $path` : `$command $path`
     elseif name == "textmate" || name == "mate" || name == "kate"
         cmd = line != 0 ? `$command $path -l $line` : `$command $path`
     elseif startswith(name, "subl") || startswith(name, "atom")
         cmd = line != 0 ? `$command $path:$line` : `$command $path`
+    elseif name == "code" || (Sys.iswindows() && uppercase(name) == "CODE.EXE")
+        cmd = line != 0 ? `$command -g $path:$line` : `$command -g $path`
     elseif startswith(name, "notepad++")
         cmd = line != 0 ? `$command $path -n$line` : `$command $path`
-    elseif is_apple() && name == "open"
+    elseif Sys.isapple() && name == "open"
         cmd = `open -t $path`
         line_unsupported = true
     else
@@ -60,10 +65,11 @@ function edit(path::AbstractString, line::Integer=0)
         line_unsupported = true
     end
 
-    if is_windows() && name == "open"
-        systemerror(:edit, ccall((:ShellExecuteW,"shell32"), stdcall, Int,
-                                 (Ptr{Void}, Cwstring, Cwstring, Ptr{Void}, Ptr{Void}, Cint),
-                                 C_NULL, "open", path, C_NULL, C_NULL, 10) ≤ 32)
+    if Sys.iswindows() && name == "open"
+        @static Sys.iswindows() && # don't emit this ccall on other platforms
+            systemerror(:edit, ccall((:ShellExecuteW, "shell32"), stdcall, Int,
+                                     (Ptr{Void}, Cwstring, Cwstring, Ptr{Void}, Ptr{Void}, Cint),
+                                     C_NULL, "open", path, C_NULL, C_NULL, 10) ≤ 32)
     elseif background
         spawn(pipeline(cmd, stderr=STDERR))
     else
@@ -81,21 +87,21 @@ Edit the definition of a function, optionally specifying a tuple of types to
 indicate which method to edit. The editor can be changed by setting `JULIA_EDITOR`,
 `VISUAL` or `EDITOR` as an environment variable.
 """
-edit(f)          = edit(functionloc(f)...)
-edit(f, t::ANY)  = edit(functionloc(f,t)...)
+edit(f)                   = edit(functionloc(f)...)
+edit(f, @nospecialize t)  = edit(functionloc(f,t)...)
 edit(file, line::Integer) = error("could not find source file for function")
 
 # terminal pager
 
-if is_windows()
+if Sys.iswindows()
     function less(file::AbstractString, line::Integer)
-        pager = get(ENV, "PAGER", "more")
-        g = pager == "more" ? "" : "g"
+        pager = shell_split(get(ENV, "PAGER", "more"))
+        g = pager[1] == "more" ? "" : "g"
         run(Cmd(`$pager +$(line)$(g) \"$file\"`, windows_verbatim = true))
     end
 else
     function less(file::AbstractString, line::Integer)
-        pager = get(ENV, "PAGER", "less")
+        pager = shell_split(get(ENV, "PAGER", "less"))
         run(`$pager +$(line)g $file`)
     end
 end
@@ -114,21 +120,21 @@ less(file::AbstractString) = less(file, 1)
 Show the definition of a function using the default pager, optionally specifying a tuple of
 types to indicate which method to see.
 """
-less(f)          = less(functionloc(f)...)
-less(f, t::ANY)  = less(functionloc(f,t)...)
+less(f)                   = less(functionloc(f)...)
+less(f, @nospecialize t)  = less(functionloc(f,t)...)
 less(file, line::Integer) = error("could not find source file for function")
 
 # clipboard copy and paste
 
-if is_apple()
+if Sys.isapple()
     function clipboard(x)
         open(pipeline(`pbcopy`, stderr=STDERR), "w") do io
             print(io, x)
         end
     end
-    clipboard() = readstring(`pbpaste`)
+    clipboard() = read(`pbpaste`, String)
 
-elseif is_linux()
+elseif Sys.islinux()
     _clipboardcmd = nothing
     function clipboardcmd()
         global _clipboardcmd
@@ -152,10 +158,10 @@ elseif is_linux()
         cmd = c == :xsel  ? `xsel --nodetach --output --clipboard` :
               c == :xclip ? `xclip -quiet -out -selection clipboard` :
             error("unexpected clipboard command: $c")
-        readstring(pipeline(cmd, stderr=STDERR))
+        read(pipeline(cmd, stderr=STDERR), String)
     end
 
-elseif is_windows()
+elseif Sys.iswindows()
     # TODO: these functions leak memory and memory locks if they throw an error
     function clipboard(x::AbstractString)
         if containsnul(x)
@@ -242,74 +248,94 @@ end
 
 
 """
-    versioninfo(io::IO=STDOUT, verbose::Bool=false)
+    versioninfo(io::IO=STDOUT; verbose::Bool=false, packages::Bool=false)
+
+Print information about the version of Julia in use. The output is
+controlled with boolean keyword arguments:
 
-Print information about the version of Julia in use. If the `verbose` argument is `true`,
-detailed system information is shown as well.
+- `packages`: print information about installed packages
+- `verbose`: print all additional information
 """
-function versioninfo(io::IO=STDOUT, verbose::Bool=false)
-    println(io,             "Julia Version $VERSION")
+function versioninfo(io::IO=STDOUT; verbose::Bool=false, packages::Bool=false)
+    println(io, "Julia Version $VERSION")
     if !isempty(GIT_VERSION_INFO.commit_short)
-        println(io,         "Commit $(GIT_VERSION_INFO.commit_short) ($(GIT_VERSION_INFO.date_string))")
+        println(io, "Commit $(GIT_VERSION_INFO.commit_short) ($(GIT_VERSION_INFO.date_string))")
     end
     if ccall(:jl_is_debugbuild, Cint, ())!=0
         println(io, "DEBUG build")
     end
-    println(io,             "Platform Info:")
-    println(io,             "  OS: ", is_windows() ? "Windows" : is_apple() ?
+    println(io, "Platform Info:")
+    println(io, "  OS: ", Sys.iswindows() ? "Windows" : Sys.isapple() ?
         "macOS" : Sys.KERNEL, " (", Sys.MACHINE, ")")
 
-    cpu = Sys.cpu_info()
-    println(io,             "  CPU: ", cpu[1].model)
-    println(io,             "  WORD_SIZE: ", Sys.WORD_SIZE)
     if verbose
         lsb = ""
-        if is_linux()
+        if Sys.islinux()
             try lsb = readchomp(pipeline(`lsb_release -ds`, stderr=DevNull)) end
         end
-        if is_windows()
-            try lsb = strip(readstring(`$(ENV["COMSPEC"]) /c ver`)) end
+        if Sys.iswindows()
+            try lsb = strip(read(`$(ENV["COMSPEC"]) /c ver`, String)) end
         end
-        if lsb != ""
-            println(io,     "           ", lsb)
+        if !isempty(lsb)
+            println(io, "      ", lsb)
         end
-        if is_unix()
-            println(io,         "  uname: ", readchomp(`uname -mprsv`))
+        if Sys.isunix()
+            println(io, "  uname: ", readchomp(`uname -mprsv`))
         end
-        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: ")
-        print_matrix(io,    Sys.loadavg()')
-        println(io          )
-        Sys.cpu_summary(io)
-        println(io          )
     end
+
+    if verbose
+        cpuio = IOBuffer() # print cpu_summary with correct alignment
+        Sys.cpu_summary(cpuio)
+        for (i, line) in enumerate(split(String(take!(cpuio)), "\n"))
+            prefix = i == 1 ? "  CPU: " : "       "
+            println(io, prefix, line)
+        end
+    else
+        cpu = Sys.cpu_info()
+        println(io, "  CPU: ", cpu[1].model)
+    end
+
+    if verbose
+        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: ")
+        print_matrix(io, Sys.loadavg()')
+        println(io)
+    end
+    println(io, "  WORD_SIZE: ", Sys.WORD_SIZE)
     if Base.libblas_name == "libopenblas" || BLAS.vendor() == :openblas || BLAS.vendor() == :openblas64
         openblas_config = BLAS.openblas_get_config()
-        println(io,         "  BLAS: libopenblas (", openblas_config, ")")
+        println(io, "  BLAS: libopenblas (", openblas_config, ")")
     else
-        println(io,         "  BLAS: ",libblas_name)
+        println(io, "  BLAS: ",libblas_name)
+    end
+    println(io, "  LAPACK: ",liblapack_name)
+    println(io, "  LIBM: ",libm_name)
+    println(io, "  LLVM: libLLVM-",libllvm_version," (", Sys.JIT, ", ", Sys.cpu_name, ")")
+
+    println(io, "Environment:")
+    for (k,v) in ENV
+        if ismatch(r"JULIA", String(k))
+            println(io, "  $(k) = $(v)")
+        end
     end
-    println(io,             "  LAPACK: ",liblapack_name)
-    println(io,             "  LIBM: ",libm_name)
-    println(io,             "  LLVM: libLLVM-",libllvm_version," (", Sys.JIT, ", ", Sys.cpu_name, ")")
     if verbose
-        println(io,         "Environment:")
         for (k,v) in ENV
-            if match(r"JULIA|PATH|FLAG|^TERM$|HOME", String(k)) !== nothing
+            if ismatch(r"PATH|FLAG|^TERM$|HOME", String(k))
                 println(io, "  $(k) = $(v)")
             end
         end
-        println(io          )
-        println(io,         "Package Directory: ", Pkg.dir())
+    end
+    if packages || verbose
+        println(io, "Packages:")
+        println(io, "  Package Directory: ", Pkg.dir())
+        println(io, "  Package Status:")
         Pkg.status(io)
     end
 end
-versioninfo(verbose::Bool) = versioninfo(STDOUT,verbose)
 
 # displaying type-ambiguity warnings
-
-
 """
     code_warntype([io::IO], f, types)
 
@@ -320,7 +346,7 @@ This serves as a warning of potential type instability. Not all non-concrete typ
 problematic for performance, so the results need to be used judiciously.
 See [`@code_warntype`](@ref man-code-warntype) for more information.
 """
-function code_warntype(io::IO, f, t::ANY)
+function code_warntype(io::IO, f, @nospecialize(t))
     emph_io = IOContext(io, :TYPEEMPHASIZE => true)
     for (src, rettype) in code_typed(f, t)
         println(emph_io, "Variables:")
@@ -344,12 +370,11 @@ function code_warntype(io::IO, f, t::ANY)
     end
     nothing
 end
-code_warntype(f, t::ANY) = code_warntype(STDOUT, f, t)
+code_warntype(f, @nospecialize(t)) = code_warntype(STDOUT, f, t)
 
-typesof(args...) = Tuple{map(a->(isa(a,Type) ? Type{a} : typeof(a)), args)...}
+typesof(args...) = Tuple{Any[ Core.Typeof(a) for a in args ]...}
 
-gen_call_with_extracted_types(fcn, ex0::Symbol) = Expr(:call, fcn, Meta.quot(ex0))
-function gen_call_with_extracted_types(fcn, ex0)
+function gen_call_with_extracted_types(__module__, fcn, ex0)
     if isa(ex0, Expr)
         if any(a->(Meta.isexpr(a, :kw) || Meta.isexpr(a, :parameters)), ex0.args)
             # remove keyword args, but call the kwfunc
@@ -367,10 +392,10 @@ function gen_call_with_extracted_types(fcn, ex0)
     end
     exret = Expr(:none)
     is_macro = false
-    ex = expand(ex0)
-    if isa(ex0, Expr) && ex0.head == :macrocall # Make @edit @time 1+2 edit the macro
+    ex = expand(__module__, ex0)
+    if isa(ex0, Expr) && ex0.head == :macrocall # Make @edit @time 1+2 edit the macro by using the types of the *expressions*
         is_macro = true
-        exret = Expr(:call, fcn,  esc(ex0.args[1]), typesof(ex0.args[2:end]...))
+        exret = Expr(:call, fcn, esc(ex0.args[1]), Tuple{#=__source__=#LineNumberNode, #=__module__=#Module, Any[ Core.Typeof(a) for a in ex0.args[3:end] ]...})
     elseif !isa(ex, Expr)
         exret = Expr(:call, :error, "expression is not a function call or symbol")
     elseif ex.head == :call
@@ -407,15 +432,19 @@ for fname in [:which, :less, :edit, :functionloc, :code_warntype,
               :code_llvm, :code_llvm_raw, :code_native]
     @eval begin
         macro ($fname)(ex0)
-            gen_call_with_extracted_types($(Expr(:quote,fname)), ex0)
+            gen_call_with_extracted_types(__module__, $(Expr(:quote, fname)), ex0)
         end
     end
 end
+macro which(ex0::Symbol)
+    ex0 = QuoteNode(ex0)
+    return :(which_module($__module__, $ex0))
+end
 
 for fname in [:code_typed, :code_lowered]
     @eval begin
         macro ($fname)(ex0)
-            thecall = gen_call_with_extracted_types($(Expr(:quote,fname)), ex0)
+            thecall = gen_call_with_extracted_types(__module__, $(Expr(:quote, fname)), ex0)
             quote
                 results = $thecall
                 length(results) == 1 ? results[1] : results
@@ -499,7 +528,7 @@ Evaluates the arguments to the function or macro call, determines their types, a
 """
 :@code_native
 
-function type_close_enough(x::ANY, t::ANY)
+function type_close_enough(@nospecialize(x), @nospecialize(t))
     x == t && return true
     return (isa(x,DataType) && isa(t,DataType) && x.name === t.name &&
             !isconcrete(t) && x <: t) ||
@@ -525,7 +554,7 @@ function methodswith(t::Type, f::Function, showparents::Bool=false, meths = Meth
                        (type_close_enough(x, t) ||
                         (showparents ? (t <: x && (!isa(x,TypeVar) || x.ub != Any)) :
                          (isa(x,TypeVar) && x.ub != Any && t == x.ub)) &&
-                        x != Any && x != ANY)
+                        x != Any)
                    end
                end,
                unwrap_unionall(d.sig).parameters)
@@ -566,7 +595,7 @@ end
 # file downloading
 
 downloadcmd = nothing
-if is_windows()
+if Sys.iswindows()
     function download(url::AbstractString, filename::AbstractString)
         res = ccall((:URLDownloadToFileW,:urlmon),stdcall,Cuint,
                     (Ptr{Void},Cwstring,Cwstring,Cuint,Ptr{Void}),C_NULL,url,filename,0,C_NULL)
@@ -587,9 +616,14 @@ else
             end
         end
         if downloadcmd == :wget
-            run(`wget -O $filename $url`)
+            try
+                run(`wget -O $filename $url`)
+            catch
+                rm(filename)  # wget always creates a file
+                rethrow()
+            end
         elseif downloadcmd == :curl
-            run(`curl -o $filename -L $url`)
+            run(`curl -L -f -o $filename $url`)
         elseif downloadcmd == :fetch
             run(`fetch -f $filename $url`)
         else
@@ -626,17 +660,17 @@ accessed using a statement such as `using LastMain.Package`.
 This function should only be used interactively.
 """
 function workspace()
-    last = Core.Main
-    b = last.Base
-    ccall(:jl_new_main_module, Any, ())
-    m = Core.Main
+    last = Core.Main # ensure to reference the current Main module
+    b = Base # this module
+    ccall(:jl_new_main_module, Any, ()) # make Core.Main a new baremodule
+    m = Core.Main # now grab a handle to the new Main module
     ccall(:jl_add_standard_imports, Void, (Any,), m)
-    eval(m,
-         Expr(:toplevel,
-              :(const Base = $(Expr(:quote, b))),
-              :(const LastMain = $(Expr(:quote, last)))))
+    eval(m, Expr(:toplevel,
+        :(const Base = $b),
+        :(const LastMain = $last),
+        :(include(x) = $include($m, x))))
     empty!(package_locks)
-    nothing
+    return m
 end
 
 # testing
@@ -660,7 +694,7 @@ function runtests(tests = ["all"], numcores = ceil(Int, Sys.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$(readstring(buf))")
+              "including error messages above and the output of versioninfo():\n$(read(buf, String))")
     end
 end
 
@@ -668,13 +702,13 @@ end
 
 
 """
-    whos(io::IO=STDOUT, m::Module=current_module(), pattern::Regex=r"")
+    whos(io::IO=STDOUT, m::Module=Main, pattern::Regex=r"")
 
 Print information about exported global variables in a module, optionally restricted to those matching `pattern`.
 
 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"")
+function whos(io::IO=STDOUT, m::Module=Main, pattern::Regex=r"")
     maxline = displaysize(io)[2]
     line = zeros(UInt8, maxline)
     head = PipeBuffer(maxline + 1)
@@ -718,4 +752,4 @@ function whos(io::IO=STDOUT, m::Module=current_module(), pattern::Regex=r"")
     end
 end
 whos(m::Module, pat::Regex=r"") = whos(STDOUT, m, pat)
-whos(pat::Regex) = whos(STDOUT, current_module(), pat)
+whos(pat::Regex) = whos(STDOUT, Main, pat)
diff --git a/base/intfuncs.jl b/base/intfuncs.jl
index d299a8da279449..875e4f34309fc6 100644
--- a/base/intfuncs.jl
+++ b/base/intfuncs.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## number-theoretic functions ##
 
@@ -7,6 +7,7 @@
 
 Greatest common (positive) divisor (or zero if `x` and `y` are both zero).
 
+# Examples
 ```jldoctest
 julia> gcd(6,9)
 3
@@ -15,7 +16,7 @@ julia> gcd(6,-9)
 3
 ```
 """
-function gcd{T<:Integer}(a::T, b::T)
+function gcd(a::T, b::T) where T<:Integer
     while b != 0
         t = b
         b = rem(a, b)
@@ -26,7 +27,7 @@ end
 
 # binary GCD (aka Stein's) algorithm
 # about 1.7x (2.1x) faster for random Int64s (Int128s)
-function gcd{T<:Union{Int64,UInt64,Int128,UInt128}}(a::T, b::T)
+function gcd(a::T, b::T) where T<:Union{Int64,UInt64,Int128,UInt128}
     a == 0 && return abs(b)
     b == 0 && return abs(a)
     za = trailing_zeros(a)
@@ -51,6 +52,8 @@ end
     lcm(x,y)
 
 Least common (non-negative) multiple.
+
+# Examples
 ```jldoctest
 julia> lcm(2,3)
 6
@@ -59,7 +62,7 @@ julia> lcm(-2,3)
 6
 ```
 """
-function lcm{T<:Integer}(a::T, b::T)
+function lcm(a::T, b::T) where T<:Integer
     # explicit a==0 test is to handle case of lcm(0,0) correctly
     if a == 0
         return a
@@ -86,12 +89,11 @@ 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)``. ``gcdx(x,y)`` returns ``(d,u,v)``.
 
+# Examples
 ```jldoctest
 julia> gcdx(12, 42)
 (6, -3, 1)
-```
 
-```jldoctest
 julia> gcdx(240, 46)
 (2, -9, 47)
 ```
@@ -107,7 +109,7 @@ julia> gcdx(240, 46)
     their `typemax`, and the identity then holds only via the unsigned
     integers' modulo arithmetic.
 """
-function gcdx{T<:Integer}(a::T, b::T)
+function gcdx(a::T, b::T) where T<:Integer
     # a0, b0 = a, b
     s0, s1 = oneunit(T), zero(T)
     t0, t1 = s1, s0
@@ -131,6 +133,7 @@ Take the inverse of `x` modulo `m`: `y` such that ``x y = 1 \\pmod m``,
 with ``div(x,y) = 0``. This is undefined for ``m = 0``, or if
 ``gcd(x,m) \\neq 1``.
 
+# Examples
 ```jldoctest
 julia> invmod(2,5)
 3
@@ -142,9 +145,10 @@ julia> invmod(5,6)
 5
 ```
 """
-function invmod{T<:Integer}(n::T, m::T)
+function invmod(n::T, m::T) where T<:Integer
     g, x, y = gcdx(n, m)
-    (g != 1 || m == 0) && throw(DomainError())
+    g != 1 && throw(DomainError((n, m), "Greatest common divisor is $g."))
+    m == 0 && throw(DomainError(m, "`m` must not be 0."))
     # Note that m might be negative here.
     # For unsigned T, x might be close to typemax; add m to force a wrap-around.
     r = mod(x + m, m)
@@ -156,6 +160,10 @@ invmod(n::Integer, m::Integer) = invmod(promote(n,m)...)
 # ^ for any x supporting *
 to_power_type(x::Number) = oftype(x*x, x)
 to_power_type(x) = x
+@noinline throw_domerr_powbysq(p) = throw(DomainError(p,
+    string("Cannot raise an integer x to a negative power ", p, '.',
+           "\nMake x a float by adding a zero decimal (e.g., 2.0^$p instead ",
+           "of 2^$p), or write 1/x^$(-p), float(x)^$p, or (x//1)^$p")))
 function power_by_squaring(x_, p::Integer)
     x = to_power_type(x_)
     if p == 1
@@ -167,7 +175,7 @@ function power_by_squaring(x_, p::Integer)
     elseif p < 0
         x == 1 && return copy(x)
         x == -1 && return iseven(p) ? one(x) : copy(x)
-        throw(DomainError())
+        throw_domerr_powbysq(p)
     end
     t = trailing_zeros(p) + 1
     p >>= t
@@ -187,28 +195,36 @@ function power_by_squaring(x_, p::Integer)
 end
 power_by_squaring(x::Bool, p::Unsigned) = ((p==0) | x)
 function power_by_squaring(x::Bool, p::Integer)
-    p < 0 && !x && throw(DomainError())
+    p < 0 && !x && throw_domerr_powbysq(p)
     return (p==0) | x
 end
 
-^{T<:Integer}(x::T, p::T) = power_by_squaring(x,p)
+^(x::T, p::T) where {T<:Integer} = power_by_squaring(x,p)
 ^(x::Number, p::Integer)  = power_by_squaring(x,p)
 ^(x, p::Integer)          = power_by_squaring(x,p)
 
-# x^p for any literal integer p is lowered to x^Val{p},
+# x^p for any literal integer p is lowered to Base.literal_pow(^, x, Val(p))
 # to enable compile-time optimizations specialized to p.
-# However, we still need a fallback that calls the general ^.
-# To avoid ambiguities for methods that dispatch on the
-# first argument, we dispatch the fallback via internal_pow:
-^(x, p) = internal_pow(x, p)
-internal_pow{p}(x, ::Type{Val{p}}) = x^p
+# However, we still need a fallback that calls the function ^ which may either
+# mean Base.^ or something else, depending on context.
+# We mark these @inline since if the target is marked @inline,
+# we want to make sure that gets propagated,
+# even if it is over the inlining threshold.
+@inline literal_pow(f, x, ::Val{p}) where {p} = f(x,p)
+
+# Restrict inlining to hardware-supported arithmetic types, which
+# are fast enough to benefit from inlining.
+const HWReal = Union{Int8,Int16,Int32,Int64,UInt8,UInt16,UInt32,UInt64,Float32,Float64}
+const HWNumber = Union{HWReal, Complex{<:HWReal}, Rational{<:HWReal}}
 
 # inference.jl has complicated logic to inline x^2 and x^3 for
-# numeric types.  In terms of Val we can do it much more simply:
-internal_pow(x::Number, ::Type{Val{0}}) = one(x)
-internal_pow(x::Number, ::Type{Val{1}}) = x
-internal_pow(x::Number, ::Type{Val{2}}) = x*x
-internal_pow(x::Number, ::Type{Val{3}}) = x*x*x
+# numeric types.  In terms of Val we can do it much more simply.
+# (The first argument prevents unexpected behavior if a function ^
+# is defined that is not equal to Base.^)
+@inline literal_pow(::typeof(^), x::HWNumber, ::Val{0}) = one(x)
+@inline literal_pow(::typeof(^), x::HWNumber, ::Val{1}) = x
+@inline literal_pow(::typeof(^), x::HWNumber, ::Val{2}) = x*x
+@inline literal_pow(::typeof(^), x::HWNumber, ::Val{3}) = x*x*x
 
 # b^p mod m
 
@@ -216,8 +232,26 @@ internal_pow(x::Number, ::Type{Val{3}}) = x*x*x
     powermod(x::Integer, p::Integer, m)
 
 Compute ``x^p \\pmod m``.
+
+# Examples
+```jldoctest
+julia> powermod(2, 6, 5)
+4
+
+julia> mod(2^6, 5)
+4
+
+julia> powermod(5, 2, 20)
+5
+
+julia> powermod(5, 2, 19)
+6
+
+julia> powermod(5, 3, 19)
+11
+```
 """
-function powermod{T<:Integer}(x::Integer, p::Integer, m::T)
+function powermod(x::Integer, p::Integer, m::T) where T<:Integer
     p < 0 && return powermod(invmod(x, m), -p, m)
     p == 0 && return mod(one(m),m)
     (m == 1 || m == -1) && return zero(m)
@@ -249,6 +283,7 @@ powermod(x::Integer, p::Integer, m::Union{Int128,UInt128}) = oftype(m, powermod(
 The smallest power of two not less than `n`. Returns 0 for `n==0`, and returns
 `-nextpow2(-n)` for negative arguments.
 
+# Examples
 ```jldoctest
 julia> nextpow2(16)
 16
@@ -266,9 +301,13 @@ nextpow2(x::Integer) = reinterpret(typeof(x),x < 0 ? -nextpow2(unsigned(-x)) : n
 The largest power of two not greater than `n`. Returns 0 for `n==0`, and returns
 `-prevpow2(-n)` for negative arguments.
 
+# Examples
 ```jldoctest
 julia> prevpow2(5)
 4
+
+julia> prevpow2(0)
+0
 ```
 """
 prevpow2(x::Unsigned) = one(x) << unsigned((sizeof(x)<<3)-leading_zeros(x)-1)
@@ -279,6 +318,7 @@ prevpow2(x::Integer) = reinterpret(typeof(x),x < 0 ? -prevpow2(unsigned(-x)) : p
 
 Test whether `n` is a power of two.
 
+# Examples
 ```jldoctest
 julia> ispow2(4)
 true
@@ -294,9 +334,27 @@ ispow2(x::Integer) = x > 0 && count_ones(x) == 1
 
 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.
+
+# Examples
+```jldoctest
+julia> nextpow(2, 7)
+8
+
+julia> nextpow(2, 9)
+16
+
+julia> nextpow(5, 20)
+25
+
+julia> nextpow(4, 16)
+16
+```
+
+See also [`prevpow`](@ref).
 """
 function nextpow(a::Real, x::Real)
-    (a <= 1 || x <= 0) && throw(DomainError())
+    a <= 1 && throw(DomainError(a, "`a` must be greater than 1."))
+    x <= 0 && throw(DomainError(x, "`x` must be positive."))
     x <= 1 && return one(a)
     n = ceil(Integer,log(a, x))
     p = a^(n-1)
@@ -309,14 +367,33 @@ end
 
 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.
+
+# Examples
+```jldoctest
+julia> prevpow(2, 7)
+4
+
+julia> prevpow(2, 9)
+8
+
+julia> prevpow(5, 20)
+5
+
+julia> prevpow(4, 16)
+16
+```
+See also [`nextpow`](@ref).
 """
 function prevpow(a::Real, x::Real)
-    (a <= 1 || x < 1) && throw(DomainError())
+    a <= 1 && throw(DomainError(a, "`a` must be greater than 1."))
+    x < 1 && throw(DomainError(x, "`x` must be ≥ 1."))
     n = floor(Integer,log(a, x))
     p = a^(n+1)
     p <= x ? p : a^n
 end
 
+## ndigits (number of digits) in base 10 ##
+
 # decimal digits in an unsigned integer
 const powers_of_ten = [
     0x0000000000000001, 0x000000000000000a, 0x0000000000000064, 0x00000000000003e8,
@@ -325,7 +402,7 @@ const powers_of_ten = [
     0x000000e8d4a51000, 0x000009184e72a000, 0x00005af3107a4000, 0x00038d7ea4c68000,
     0x002386f26fc10000, 0x016345785d8a0000, 0x0de0b6b3a7640000, 0x8ac7230489e80000,
 ]
-function ndigits0z(x::Union{UInt8,UInt16,UInt32,UInt64})
+function ndigits0z(x::Base.BitUnsigned64)
     lz = (sizeof(x)<<3)-leading_zeros(x)
     nd = (1233*lz)>>12+1
     nd -= x < powers_of_ten[nd]
@@ -338,53 +415,120 @@ function ndigits0z(x::UInt128)
     end
     return n + ndigits0z(UInt64(x))
 end
-ndigits0z(x::Integer) = ndigits0z(unsigned(abs(x)))
 
-function ndigits0znb(n::Signed, b::Int)
+ndigits0z(x::Signed) = ndigits0z(unsigned(abs(x)))
+
+ndigits0z(x::Integer) = ndigits0zpb(x, 10)
+
+# TODO (when keywords args are fast): rename to ndigits and make pad a keyword
+ndigits10(x::Integer, pad::Int=1) = max(pad, ndigits0z(x))
+ndigits(x::Integer) = iszero(x) ? 1 : ndigits0z(x)
+
+## ndigits with specified base ##
+
+# The suffix "nb" stands for "negative base"
+function ndigits0znb(x::Integer, b::Integer)
+    # precondition: b < -1 && !(typeof(x) <: Unsigned)
     d = 0
-    while n != 0
-        n = cld(n,b)
+    while x != 0
+        x = cld(x,b)
         d += 1
     end
     return d
 end
 
-function ndigits0z(n::Unsigned, b::Int)
-    b < 0   && return ndigits0znb(signed(n), b)
-    b == 2  && return sizeof(n)<<3 - leading_zeros(n)
-    b == 8  && return (sizeof(n)<<3 - leading_zeros(n) + 2) ÷ 3
-    b == 16 && return sizeof(n)<<1 - leading_zeros(n)>>2
-    b == 10 && return ndigits0z(n)
+ndigits0znb(x::Unsigned, b::Integer) = ndigits0znb(signed(x), b)
+ndigits0znb(x::Bool, b::Integer) = x % Int
+
+# The suffix "pb" stands for "positive base"
+# TODO: allow b::Integer
+function ndigits0zpb(x::Base.BitUnsigned, b::Int)
+    # precondition: b > 1
+    x == 0 && return 0
+    b < 0   && return ndigits0znb(signed(x), b)
+    b == 2  && return sizeof(x)<<3 - leading_zeros(x)
+    b == 8  && return (sizeof(x)<<3 - leading_zeros(x) + 2) ÷ 3
+    b == 16 && return sizeof(x)<<1 - leading_zeros(x)>>2
+    b == 10 && return ndigits0z(x)
 
     d = 0
-    while n > typemax(Int)
-        n = div(n,b)
+    while x > typemax(Int)
+        x = div(x,b)
         d += 1
     end
-    n = div(n,b)
+    x = div(x,b)
     d += 1
 
     m = 1
-    while m <= n
+    while m <= x
         m *= b
         d += 1
     end
     return d
 end
-ndigits0z(x::Integer, b::Integer) = ndigits0z(unsigned(abs(x)),Int(b))
 
-ndigitsnb(x::Integer, b::Integer) = x==0 ? 1 : ndigits0znb(x, b)
+ndigits0zpb(x::Base.BitSigned, b::Integer) = ndigits0zpb(unsigned(abs(x)), Int(b))
+ndigits0zpb(x::Base.BitUnsigned, b::Integer) = ndigits0zpb(x, Int(b))
+ndigits0zpb(x::Bool, b::Integer) = x % Int
+
+# The suffix "0z" means that the output is 0 on input zero (cf. #16841)
+"""
+    ndigits0z(n::Integer, b::Integer=10)
+
+Return 0 if `n == 0`, otherwise compute the number of digits in
+integer `n` written in base `b` (i.e. equal to `ndigits(n, b)`
+in this case).
+The base `b` must not be in `[-1, 0, 1]`.
+
+# Examples
+```jldoctest
+julia> Base.ndigits0z(0, 16)
+0
+
+julia> Base.ndigits(0, 16)
+1
+
+julia> Base.ndigits0z(0)
+0
 
-ndigits(x::Unsigned, b::Integer) = x==0 ? 1 : ndigits0z(x,Int(b))
-ndigits(x::Unsigned)             = x==0 ? 1 : ndigits0z(x)
+julia> Base.ndigits0z(10, 2)
+4
+
+julia> Base.ndigits0z(10)
+2
+```
+
+See also [`ndigits`](@ref).
+"""
+function ndigits0z(x::Integer, b::Integer)
+    if b < -1
+        ndigits0znb(x, b)
+    elseif b > 1
+        ndigits0zpb(x, b)
+    else
+        throw(DomainError(b, "The base `b` must not be in `[-1, 0, 1]`."))
+    end
+end
 
 """
     ndigits(n::Integer, b::Integer=10)
 
 Compute the number of digits in integer `n` written in base `b`.
+The base `b` must not be in `[-1, 0, 1]`.
+
+# Examples
+```jldoctest
+julia> ndigits(12345)
+5
+
+julia> ndigits(1022, 16)
+3
+
+julia> base(16, 1022)
+"3fe"
+```
 """
-ndigits(x::Integer, b::Integer) = b >= 0 ? ndigits(unsigned(abs(x)),Int(b)) : ndigitsnb(x, b)
-ndigits(x::Integer) = ndigits(unsigned(abs(x)))
+ndigits(x::Integer, b::Integer, pad::Int=1) = max(pad, ndigits0z(x, b))
 
 ## integer to string functions ##
 
@@ -415,7 +559,7 @@ function oct(x::Unsigned, pad::Int, neg::Bool)
 end
 
 function dec(x::Unsigned, pad::Int, neg::Bool)
-    i = neg + max(pad,ndigits0z(x))
+    i = neg + ndigits10(x, pad)
     a = StringVector(i)
     while i > neg
         a[i] = '0'+rem(x,10)
@@ -444,14 +588,21 @@ num2hex(n::Integer) = hex(n, sizeof(n)*2)
 const base36digits = ['0':'9';'a':'z']
 const base62digits = ['0':'9';'A':'Z';'a':'z']
 
-function base(b::Int, x::Unsigned, pad::Int, neg::Bool)
-    2 <= b <= 62 || throw(ArgumentError("base must be 2 ≤ base ≤ 62, got $b"))
-    digits = b <= 36 ? base36digits : base62digits
-    i = neg + max(pad,ndigits0z(x,b))
+
+function base(b::Int, x::Integer, pad::Int, neg::Bool)
+    (x >= 0) | (b < 0) || throw(DomainError(x, "For negative `x`, `b` must be negative."))
+    2 <= abs(b) <= 62 || throw(ArgumentError("base must satisfy 2 ≤ abs(base) ≤ 62, got $b"))
+    digits = abs(b) <= 36 ? base36digits : base62digits
+    i = neg + ndigits(x, b, pad)
     a = StringVector(i)
-    while i > neg
-        a[i] = digits[1+rem(x,b)]
-        x = div(x,b)
+    @inbounds while i > neg
+        if b > 0
+            a[i] = digits[1+rem(x,b)]
+            x = div(x,b)
+        else
+            a[i] = digits[1+mod(x,-b)]
+            x = cld(x,b)
+        end
         i -= 1
     end
     if neg; a[1]='-'; end
@@ -472,7 +623,8 @@ julia> base(5,13,4)
 "0023"
 ```
 """
-base(b::Integer, n::Integer, pad::Integer=1) = base(Int(b), unsigned(abs(n)), pad, n<0)
+base(b::Integer, n::Integer, pad::Integer=1) =
+    base(Int(b), b > 0 ? unsigned(abs(n)) : convert(Signed, n), Int(pad), (b>0) & (n<0))
 
 for sym in (:bin, :oct, :dec, :hex)
     @eval begin
@@ -503,21 +655,49 @@ bin
 """
     hex(n, pad::Int=1)
 
-Convert an integer to a hexadecimal string, optionally specifying a number of digits to pad to.
+Convert an integer to a hexadecimal string, optionally specifying a number of
+digits to pad to.
+
+```jldoctest
+julia> hex(20)
+"14"
+
+julia> hex(20, 3)
+"014"
+```
 """
 hex
 
 """
     oct(n, pad::Int=1)
 
-Convert an integer to an octal string, optionally specifying a number of digits to pad to.
+Convert an integer to an octal string, optionally specifying a number of digits
+to pad to.
+
+```jldoctest
+julia> oct(20)
+"24"
+
+julia> oct(20, 3)
+"024"
+```
 """
 oct
 
 """
     dec(n, pad::Int=1)
 
-Convert an integer to a decimal string, optionally specifying a number of digits to pad to.
+Convert an integer to a decimal string, optionally specifying a number of digits
+to pad to.
+
+# Examples
+```jldoctest
+julia> dec(20)
+"20"
+
+julia> dec(20, 3)
+"020"
+```
 """
 dec
 
@@ -533,27 +713,84 @@ bits(x::Union{Int128,UInt128})            = bin(reinterpret(UInt128,x),128)
 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)])`.
+
+# Examples
+```jldoctest
+julia> digits(10, 10)
+2-element Array{Int64,1}:
+ 0
+ 1
+
+julia> digits(10, 2)
+4-element Array{Int64,1}:
+ 0
+ 1
+ 0
+ 1
+
+julia> digits(10, 2, 6)
+6-element Array{Int64,1}:
+ 0
+ 1
+ 0
+ 1
+ 0
+ 0
+```
 """
-digits{T<:Integer}(n::Integer, base::T=10, pad::Integer=1) = digits(T, n, base, pad)
+digits(n::Integer, base::T=10, pad::Integer=1) where {T<:Integer} = 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"))
-    digits!(zeros(T, max(pad, ndigits0z(n,base))), n, base)
+function digits(T::Type{<:Integer}, n::Integer, base::Integer=10, pad::Integer=1)
+    digits!(zeros(T, ndigits(n, base, pad)), n, base)
 end
 
+"""
+    hastypemax(T::Type) -> Bool
+
+Return `true` if and only if `typemax(T)` is defined.
+"""
+hastypemax(::Base.BitIntegerType) = true
+hastypemax(::Type{T}) where {T} = applicable(typemax, T)
+
 """
     digits!(array, n::Integer, base::Integer=10)
 
 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.
+
+# Examples
+```jldoctest
+julia> digits!([2,2,2,2], 10, 2)
+4-element Array{Int64,1}:
+ 0
+ 1
+ 0
+ 1
+
+julia> digits!([2,2,2,2,2,2], 10, 2)
+6-element Array{Int64,1}:
+ 0
+ 1
+ 0
+ 1
+ 0
+ 0
+```
 """
-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"))
+function digits!(a::AbstractVector{T}, n::Integer, base::Integer=10) where T<:Integer
+    base < 0 && isa(n, Unsigned) && return digits!(a, convert(Signed, n), base)
+    2 <= abs(base) || throw(ArgumentError("base must be ≥ 2 or ≤ -2, got $base"))
+    hastypemax(T) && abs(base) - 1 > typemax(T) &&
+        throw(ArgumentError("type $T too small for base $base"))
     for i in eachindex(a)
-        a[i] = rem(n, base)
-        n = div(n, base)
+        if base > 0
+            a[i] = rem(n, base)
+            n = div(n, base)
+        else
+            a[i] = mod(n, -base)
+            n = cld(n, base)
+        end
     end
     return a
 end
@@ -580,7 +817,7 @@ function isqrt(x::Union{Int64,UInt64,Int128,UInt128})
 end
 
 function factorial(n::Integer)
-    n < 0 && throw(DomainError())
+    n < 0 && throw(DomainError(n, "`n` must be nonnegative."))
     local f::typeof(n*n), i::typeof(n*n)
     f = 1
     for i = 2:n
@@ -590,11 +827,20 @@ function factorial(n::Integer)
 end
 
 """
-    binomial(n,k)
+    binomial(n, k)
 
 Number of ways to choose `k` out of `n` items.
+
+# Examples
+```jldoctest
+julia> binomial(5, 3)
+10
+
+julia> factorial(5) ÷ (factorial(5-3) * factorial(3))
+10
+```
 """
-function binomial{T<:Integer}(n::T, k::T)
+function binomial(n::T, k::T) where T<:Integer
     k < 0 && return zero(T)
     sgn = one(T)
     if n < 0
diff --git a/base/intset.jl b/base/intset.jl
index 1bb2016d0a11a7..7785d2dedd072a 100644
--- a/base/intset.jl
+++ b/base/intset.jl
@@ -1,9 +1,18 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 struct IntSet <: AbstractSet{Int}
     bits::BitVector
     IntSet() = new(falses(256))
 end
+
+"""
+    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`](@ref) instead.
+"""
 IntSet(itr) = union!(IntSet(), itr)
 
 eltype(::Type{IntSet}) = Int
@@ -140,7 +149,7 @@ symdiff!(s::IntSet, ns) = (for n in ns; symdiff!(s, n); end; s)
 The set `s` is destructively modified to toggle the inclusion of integer `n`.
 """
 function symdiff!(s::IntSet, n::Integer)
-    0 <= n < typemax(Int) || _throw_intset_bounds_err()
+    0 < n < typemax(Int) || _throw_intset_bounds_err()
     val = !(n in s)
     _setint!(s, n, val)
     s
@@ -169,6 +178,12 @@ done(s::IntSet, i) = i <= 0
 
 
 @noinline _throw_intset_notempty_error() = throw(ArgumentError("collection must be non-empty"))
+
+function first(s::IntSet)
+    idx = findfirst(s.bits)
+    idx == 0 ? _throw_intset_notempty_error() : idx
+end
+
 function last(s::IntSet)
     idx = findprev(s.bits, length(s.bits))
     idx == 0 ? _throw_intset_notempty_error() : idx
@@ -230,3 +245,8 @@ function hash(s::IntSet, h::UInt)
     end
     h
 end
+
+minimum(s::IntSet) = first(s)
+maximum(s::IntSet) = last(s)
+extrema(s::IntSet) = (first(s), last(s))
+issorted(s::IntSet) = true
diff --git a/base/io.jl b/base/io.jl
index 58d443371db4c7..6af638cc97a76d 100644
--- a/base/io.jl
+++ b/base/io.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Generic IO stubs -- all subtypes should implement these (if meaningful)
 
@@ -31,6 +31,13 @@ function wait_readnb end
 function wait_readbyte end
 function wait_close end
 function nb_available end
+
+"""
+    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}`.
+"""
 function readavailable end
 
 """
@@ -156,6 +163,10 @@ write(filename::AbstractString, args...) = open(io->write(io, args...), filename
 
 Open a file and read its contents. `args` is passed to `read`: this is equivalent to
 `open(io->read(io, args...), filename)`.
+
+    read(filename::AbstractString, String)
+
+Read the entire contents of a file as a string.
 """
 read(filename::AbstractString, args...) = open(io->read(io, args...), filename)
 read!(filename::AbstractString, a) = open(io->read!(io, a), filename)
@@ -215,6 +226,25 @@ readlines(s=STDIN; chomp::Bool=true) = collect(eachline(s, chomp=chomp))
 
 ## byte-order mark, ntoh & hton ##
 
+let endian_boms = reinterpret(UInt8, UInt32[0x01020304])
+    global ntoh, hton, ltoh, htol
+    if endian_boms == UInt8[1:4;]
+        ntoh(x) = x
+        hton(x) = x
+        ltoh(x) = bswap(x)
+        htol(x) = bswap(x)
+        const global ENDIAN_BOM = 0x01020304
+    elseif endian_boms == UInt8[4:-1:1;]
+        ntoh(x) = bswap(x)
+        hton(x) = bswap(x)
+        ltoh(x) = x
+        htol(x) = x
+        const global ENDIAN_BOM = 0x04030201
+    else
+        error("seriously? what is this machine?")
+    end
+end
+
 """
     ENDIAN_BOM
 
@@ -222,22 +252,7 @@ The 32-bit byte-order-mark indicates the native byte order of the host machine.
 Little-endian machines will contain the value `0x04030201`. Big-endian machines will contain
 the value `0x01020304`.
 """
-const ENDIAN_BOM = reinterpret(UInt32,UInt8[1:4;])[1]
-
-if ENDIAN_BOM == 0x01020304
-    ntoh(x) = x
-    hton(x) = x
-    ltoh(x) = bswap(x)
-    htol(x) = bswap(x)
-elseif ENDIAN_BOM == 0x04030201
-    ntoh(x) = bswap(x)
-    hton(x) = bswap(x)
-    ltoh(x) = x
-    htol(x) = x
-else
-    error("seriously? what is this machine?")
-end
-
+ENDIAN_BOM
 
 """
     ntoh(x)
@@ -286,9 +301,10 @@ function write(io::IO, xs...)
     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)
+@noinline unsafe_write(s::IO, p::Ref{T}, n::Integer) where {T} =
+    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::Ref{T}) where {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))
@@ -298,6 +314,9 @@ write(s::IO, x::Bool) = write(s, UInt8(x))
 write(to::IO, p::Ptr) = write(to, convert(UInt, p))
 
 function write(s::IO, A::AbstractArray)
+    if !isbits(eltype(A))
+        depwarn("Calling `write` on non-isbits arrays is deprecated. Use a loop or `serialize` instead.", :write)
+    end
     nb = 0
     for a in A
         nb += write(s, a)
@@ -305,14 +324,11 @@ 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)
+@noinline function write(s::IO, a::Array)  # mark noinline to ensure the array is gc-rooted somewhere (by the caller)
+    if isbits(eltype(a))
         return unsafe_write(s, pointer(a), sizeof(a))
     else
+        depwarn("Calling `write` on non-isbits arrays is deprecated. Use a loop or `serialize` instead.", :write)
         nb = 0
         for b in a
             nb += write(s, b)
@@ -321,6 +337,27 @@ end
     end
 end
 
+function write(s::IO, a::SubArray{T,N,<:Array}) where {T,N}
+    if !isbits(T)
+        return invoke(write, Tuple{IO, AbstractArray}, s, a)
+    end
+    elsz = sizeof(T)
+    colsz = size(a,1) * elsz
+    if stride(a,1) != 1
+        for idxs in CartesianRange(size(a))
+            unsafe_write(s, pointer(a, idxs.I), elsz)
+        end
+        return elsz * length(a)
+    elseif N <= 1
+        return unsafe_write(s, pointer(a, 1), colsz)
+    else
+        for idxs in CartesianRange((1, size(a)[2:end]...))
+            unsafe_write(s, pointer(a, idxs.I), colsz)
+        end
+        return colsz * trailingsize(a,2)
+    end
+end
+
 
 function write(s::IO, ch::Char)
     c = reinterpret(UInt32, ch)
@@ -354,37 +391,24 @@ function write(to::IO, from::IO)
     end
 end
 
-@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)
+@noinline unsafe_read(s::IO, p::Ref{T}, n::Integer) where {T} = 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)
+read!(s::IO, x::Ref{T}) where {T} = (unsafe_read(s, x, Core.sizeof(T)); 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
+    return read!(s, Ref{T}(0))[]::T
 end
 
-read(s::IO, ::Type{Bool})    = (read(s,UInt8)!=0)
-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...) =
-    read(s, t, convert(Tuple{Vararg{Int}},tuple(d1,dims...)))
-
-"""
-    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{T}(s::IO, ::Type{T}, dims::Dims) = read!(s, Array{T}(dims))
+read(s::IO, ::Type{Bool}) = (read(s, UInt8) != 0)
+read(s::IO, ::Type{Ptr{T}}) where {T} = convert(Ptr{T}, read(s, UInt))
 
 @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)
+@noinline function read!(s::IO, a::Array{T}) where 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
@@ -433,7 +457,7 @@ function readuntil(s::IO, delim::Char)
     return String(take!(out))
 end
 
-function readuntil{T}(s::IO, delim::T)
+function readuntil(s::IO, delim::T) where T
     out = T[]
     while !eof(s)
         c = read(s, T)
@@ -455,7 +479,7 @@ function readuntil(s::IO, t::AbstractString)
         warn("readuntil(IO,AbstractString) will perform poorly with a long string")
     end
     out = IOBuffer()
-    m = Array{Char}(l)  # last part of stream to match
+    m = Vector{Char}(l)  # last part of stream to match
     t = collect(t)
     i = 0
     while !eof(s)
@@ -482,9 +506,9 @@ end
     readchomp(x)
 
 Read the entirety of `x` as a string and remove a single trailing newline.
-Equivalent to `chomp!(readstring(x))`.
+Equivalent to `chomp!(read(x, String))`.
 """
-readchomp(x) = chomp!(readstring(x))
+readchomp(x) = chomp!(read(x, String))
 
 # read up to nb bytes into nb, returning # bytes read
 
@@ -518,23 +542,15 @@ end
 
 Read at most `nb` bytes from `s`, returning a `Vector{UInt8}` of the bytes read.
 """
-function read(s::IO, nb=typemax(Int))
+function read(s::IO, nb::Integer = 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)
+    b = Vector{UInt8}(nb == typemax(Int) ? 1024 : nb)
     nr = readbytes!(s, b, nb)
     return resize!(b, nr)
 end
 
-"""
-    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(s::IO) = String(read(s))
-readstring(filename::AbstractString) = open(readstring, filename)
+read(s::IO, ::Type{String}) = String(read(s))
 
 ## high-level iterator interfaces ##
 
@@ -614,7 +630,7 @@ previously marked position. Throws an error if the stream is not marked.
 
 See also [`mark`](@ref), [`unmark`](@ref), [`ismarked`](@ref).
 """
-function reset{T<:IO}(io::T)
+function reset(io::T) where T<:IO
     ismarked(io) || throw(ArgumentError("$(T) not marked"))
     m = io.mark
     seek(io, m)
@@ -640,3 +656,34 @@ ismarked(io::IO) = io.mark >= 0
 Commit all currently buffered writes to the given stream.
 """
 flush(io::IO) = nothing
+
+"""
+    skipchars(io::IO, predicate; linecomment=nothing)
+
+Skip forward in `io` until `predicate` returns `false`. If `linecomment`
+is defined, all characters after the `linecomment` character are ignored
+until the next line.
+
+```jldoctext
+julia> buf = IOBuffer("    text")
+IOBuffer(data=UInt8[...], readable=true, writable=false, seekable=true, append=false, size=8, maxsize=Inf, ptr=1, mark=-1)
+
+julia> skipchars(buf, isspace)
+IOBuffer(data=UInt8[...], readable=true, writable=false, seekable=true, append=false, size=8, maxsize=Inf, ptr=5, mark=-1)
+
+julia> String(readavailable(buf))
+"text"
+```
+"""
+function skipchars(io::IO, pred; linecomment=nothing)
+    while !eof(io)
+        c = read(io, Char)
+        if c === linecomment
+            readline(io)
+        elseif !pred(c)
+            skip(io, -codelen(c))
+            break
+        end
+    end
+    return io
+end
diff --git a/base/iobuffer.jl b/base/iobuffer.jl
index 0b2536ad57cdaf..a379adfff0e25a 100644
--- a/base/iobuffer.jl
+++ b/base/iobuffer.jl
@@ -1,10 +1,10 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## work with AbstractVector{UInt8} via I/O primitives ##
 
 # Stateful string
-mutable struct AbstractIOBuffer{T<:AbstractVector{UInt8}} <: IO
-    data::T # T should support: getindex, setindex!, length, copy!, resize!, and T()
+mutable struct GenericIOBuffer{T<:AbstractVector{UInt8}} <: IO
+    data::T # T should support: getindex, setindex!, length, copy!, and resize!
     readable::Bool
     writable::Bool
     seekable::Bool # if not seekable, implementation is free to destroy (compact) past read data
@@ -14,16 +14,16 @@ mutable struct AbstractIOBuffer{T<:AbstractVector{UInt8}} <: IO
     ptr::Int # read (and maybe write) pointer
     mark::Int # reset mark location for ptr (or <0 for no mark)
 
-    function AbstractIOBuffer{T}(data::T, readable::Bool, writable::Bool, seekable::Bool, append::Bool,
+    function GenericIOBuffer{T}(data::T, readable::Bool, writable::Bool, seekable::Bool, append::Bool,
                                  maxsize::Int) where T<:AbstractVector{UInt8}
         new(data,readable,writable,seekable,append,length(data),maxsize,1,-1)
     end
 end
-const IOBuffer = AbstractIOBuffer{Vector{UInt8}}
+const IOBuffer = GenericIOBuffer{Vector{UInt8}}
 
-function AbstractIOBuffer(data::T, readable::Bool, writable::Bool, seekable::Bool, append::Bool,
+function GenericIOBuffer(data::T, readable::Bool, writable::Bool, seekable::Bool, append::Bool,
                           maxsize::Int) where T<:AbstractVector{UInt8}
-    AbstractIOBuffer{T}(data, readable, writable, seekable, append, maxsize)
+    GenericIOBuffer{T}(data, readable, writable, seekable, append, maxsize)
 end
 
 # allocate Vector{UInt8}s for IOBuffer storage that can efficiently become Strings
@@ -40,7 +40,7 @@ from or written to respectively. By default the buffer is readable but not writa
 last argument optionally specifies a size beyond which the buffer may not be grown.
 """
 IOBuffer(data::AbstractVector{UInt8}, readable::Bool=true, writable::Bool=false, maxsize::Int=typemax(Int)) =
-    AbstractIOBuffer(data, readable, writable, true, false, maxsize)
+    GenericIOBuffer(data, readable, writable, true, false, maxsize)
 function IOBuffer(readable::Bool, writable::Bool)
     b = IOBuffer(StringVector(32), readable, writable)
     b.data[:] = 0
@@ -74,10 +74,10 @@ If `data` is given, creates a `PipeBuffer` to operate on a data vector,
 optionally specifying a size beyond which the underlying `Array` may not be grown.
 """
 PipeBuffer(data::Vector{UInt8}=UInt8[], maxsize::Int=typemax(Int)) =
-    AbstractIOBuffer(data,true,true,false,true,maxsize)
-PipeBuffer(maxsize::Int) = (x = PipeBuffer(Vector{UInt8}(maxsize),maxsize); x.size=0; x)
+    GenericIOBuffer(data,true,true,false,true,maxsize)
+PipeBuffer(maxsize::Int) = (x = PipeBuffer(StringVector(maxsize),maxsize); x.size=0; x)
 
-function copy(b::AbstractIOBuffer)
+function copy(b::GenericIOBuffer)
     ret = typeof(b)(b.writable ? copy(b.data) : b.data,
                     b.readable, b.writable, b.seekable, b.append, b.maxsize)
     ret.size = b.size
@@ -85,7 +85,7 @@ function copy(b::AbstractIOBuffer)
     return ret
 end
 
-show(io::IO, b::AbstractIOBuffer) = print(io, "IOBuffer(data=UInt8[...], ",
+show(io::IO, b::GenericIOBuffer) = print(io, "IOBuffer(data=UInt8[...], ",
                                       "readable=", b.readable, ", ",
                                       "writable=", b.writable, ", ",
                                       "seekable=", b.seekable, ", ",
@@ -95,7 +95,7 @@ show(io::IO, b::AbstractIOBuffer) = print(io, "IOBuffer(data=UInt8[...], ",
                                       "ptr=",      b.ptr, ", ",
                                       "mark=",     b.mark, ")")
 
-function unsafe_read(from::AbstractIOBuffer, p::Ptr{UInt8}, nb::UInt)
+function unsafe_read(from::GenericIOBuffer, p::Ptr{UInt8}, nb::UInt)
     from.readable || throw(ArgumentError("read failed, IOBuffer is not readable"))
     avail = nb_available(from)
     adv = min(avail, nb)
@@ -107,7 +107,7 @@ function unsafe_read(from::AbstractIOBuffer, p::Ptr{UInt8}, nb::UInt)
     nothing
 end
 
-function read_sub{T}(from::AbstractIOBuffer, a::AbstractArray{T}, offs, nel)
+function read_sub(from::GenericIOBuffer, a::AbstractArray{T}, offs, nel) where T
     from.readable || throw(ArgumentError("read failed, IOBuffer is not readable"))
     if offs+nel-1 > length(a) || offs < 1 || nel < 0
         throw(BoundsError())
@@ -123,7 +123,7 @@ function read_sub{T}(from::AbstractIOBuffer, a::AbstractArray{T}, offs, nel)
     return a
 end
 
-@inline function read(from::AbstractIOBuffer, ::Type{UInt8})
+@inline function read(from::GenericIOBuffer, ::Type{UInt8})
     from.readable || throw(ArgumentError("read failed, IOBuffer is not readable"))
     ptr = from.ptr
     size = from.size
@@ -135,7 +135,7 @@ end
     return byte
 end
 
-function peek(from::AbstractIOBuffer)
+function peek(from::GenericIOBuffer)
     from.readable || throw(ArgumentError("read failed, IOBuffer is not readable"))
     if from.ptr > from.size
         throw(EOFError())
@@ -143,43 +143,43 @@ function peek(from::AbstractIOBuffer)
     return from.data[from.ptr]
 end
 
-read{T}(from::AbstractIOBuffer, ::Type{Ptr{T}}) = convert(Ptr{T}, read(from, UInt))
+read(from::GenericIOBuffer, ::Type{Ptr{T}}) where {T} = convert(Ptr{T}, read(from, UInt))
 
-isreadable(io::AbstractIOBuffer) = io.readable
-iswritable(io::AbstractIOBuffer) = io.writable
+isreadable(io::GenericIOBuffer) = io.readable
+iswritable(io::GenericIOBuffer) = io.writable
 
-# TODO: AbstractIOBuffer is not iterable, so doesn't really have a length.
+# TODO: GenericIOBuffer is not iterable, so doesn't really have a length.
 # This should maybe be sizeof() instead.
-#length(io::AbstractIOBuffer) = (io.seekable ? io.size : nb_available(io))
-nb_available(io::AbstractIOBuffer) = io.size - io.ptr + 1
-position(io::AbstractIOBuffer) = io.ptr-1
+#length(io::GenericIOBuffer) = (io.seekable ? io.size : nb_available(io))
+nb_available(io::GenericIOBuffer) = io.size - io.ptr + 1
+position(io::GenericIOBuffer) = io.ptr-1
 
-function skip(io::AbstractIOBuffer, n::Integer)
+function skip(io::GenericIOBuffer, n::Integer)
     seekto = io.ptr + n
     n < 0 && return seek(io, seekto-1) # Does error checking
     io.ptr = min(seekto, io.size+1)
     return io
 end
 
-function seek(io::AbstractIOBuffer, n::Integer)
+function seek(io::GenericIOBuffer, n::Integer)
     if !io.seekable
         ismarked(io) || throw(ArgumentError("seek failed, IOBuffer is not seekable and is not marked"))
         n == io.mark || throw(ArgumentError("seek failed, IOBuffer is not seekable and n != mark"))
     end
     # TODO: REPL.jl relies on the fact that this does not throw (by seeking past the beginning or end
-    #       of an AbstractIOBuffer), so that would need to be fixed in order to throw an error here
+    #       of an GenericIOBuffer), so that would need to be fixed in order to throw an error here
     #(n < 0 || n > io.size) && throw(ArgumentError("Attempted to seek outside IOBuffer boundaries."))
     #io.ptr = n+1
     io.ptr = max(min(n+1, io.size+1), 1)
     return io
 end
 
-function seekend(io::AbstractIOBuffer)
+function seekend(io::GenericIOBuffer)
     io.ptr = io.size+1
     return io
 end
 
-function truncate(io::AbstractIOBuffer, n::Integer)
+function truncate(io::GenericIOBuffer, n::Integer)
     io.writable || throw(ArgumentError("truncate failed, IOBuffer is not writeable"))
     io.seekable || throw(ArgumentError("truncate failed, IOBuffer is not seekable"))
     n < 0 && throw(ArgumentError("truncate failed, n bytes must be ≥ 0, got $n"))
@@ -194,7 +194,7 @@ function truncate(io::AbstractIOBuffer, n::Integer)
     return io
 end
 
-function compact(io::AbstractIOBuffer)
+function compact(io::GenericIOBuffer)
     io.writable || throw(ArgumentError("compact failed, IOBuffer is not writeable"))
     io.seekable && throw(ArgumentError("compact failed, IOBuffer is seekable"))
     local ptr::Int, bytes_to_move::Int
@@ -213,8 +213,8 @@ function compact(io::AbstractIOBuffer)
     return io
 end
 
-@inline ensureroom(io::AbstractIOBuffer, nshort::Int) = ensureroom(io, UInt(nshort))
-@inline function ensureroom(io::AbstractIOBuffer, nshort::UInt)
+@inline ensureroom(io::GenericIOBuffer, nshort::Int) = ensureroom(io, UInt(nshort))
+@inline function ensureroom(io::GenericIOBuffer, 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"))
@@ -239,9 +239,9 @@ end
     return io
 end
 
-eof(io::AbstractIOBuffer) = (io.ptr-1 == io.size)
+eof(io::GenericIOBuffer) = (io.ptr-1 == io.size)
 
-@noinline function close{T}(io::AbstractIOBuffer{T})
+@noinline function close(io::GenericIOBuffer{T}) where T
     io.readable = false
     io.writable = false
     io.seekable = false
@@ -251,19 +251,11 @@ eof(io::AbstractIOBuffer) = (io.ptr-1 == io.size)
     io.mark = -1
     if io.writable
         resize!(io.data, 0)
-    else
-        io.data = T()
     end
     nothing
 end
 
-isopen(io::AbstractIOBuffer) = io.readable || io.writable || io.seekable || nb_available(io) > 0
-
-function String(io::AbstractIOBuffer)
-    io.readable || throw(ArgumentError("IOBuffer is not readable"))
-    io.seekable || throw(ArgumentError("IOBuffer is not seekable"))
-    return unsafe_string(pointer(io.data), io.size)
-end
+isopen(io::GenericIOBuffer) = io.readable || io.writable || io.seekable || nb_available(io) > 0
 
 """
     take!(b::IOBuffer)
@@ -271,7 +263,7 @@ end
 Obtain the contents of an `IOBuffer` as an array, without copying. Afterwards, the
 `IOBuffer` is reset to its initial state.
 """
-function take!(io::AbstractIOBuffer)
+function take!(io::GenericIOBuffer)
     ismarked(io) && unmark(io)
     if io.seekable
         nbytes = io.size
@@ -309,7 +301,7 @@ function take!(io::IOBuffer)
     return data
 end
 
-function write(to::AbstractIOBuffer, from::AbstractIOBuffer)
+function write(to::GenericIOBuffer, from::GenericIOBuffer)
     if to === from
         from.ptr = from.size + 1
         return 0
@@ -319,7 +311,7 @@ function write(to::AbstractIOBuffer, from::AbstractIOBuffer)
     return written
 end
 
-function unsafe_write(to::AbstractIOBuffer, p::Ptr{UInt8}, nb::UInt)
+function unsafe_write(to::GenericIOBuffer, p::Ptr{UInt8}, nb::UInt)
     ensureroom(to, nb)
     ptr = (to.append ? to.size+1 : to.ptr)
     written = Int(min(nb, length(to.data) - ptr + 1))
@@ -338,14 +330,14 @@ function unsafe_write(to::AbstractIOBuffer, p::Ptr{UInt8}, nb::UInt)
     return written
 end
 
-function write_sub(to::AbstractIOBuffer, a::AbstractArray{UInt8}, offs, nel)
+function write_sub(to::GenericIOBuffer, a::AbstractArray{UInt8}, offs, nel)
     if offs+nel-1 > length(a) || offs < 1 || nel < 0
         throw(BoundsError())
     end
     unsafe_write(to, pointer(a, offs), UInt(nel))
 end
 
-@inline function write(to::AbstractIOBuffer, a::UInt8)
+@inline function write(to::GenericIOBuffer, a::UInt8)
     ensureroom(to, UInt(1))
     ptr = (to.append ? to.size+1 : to.ptr)
     if ptr > to.maxsize
@@ -360,8 +352,8 @@ end
     return sizeof(UInt8)
 end
 
-readbytes!(io::AbstractIOBuffer, b::Array{UInt8}, nb=length(b)) = readbytes!(io, b, Int(nb))
-function readbytes!(io::AbstractIOBuffer, b::Array{UInt8}, nb::Int)
+readbytes!(io::GenericIOBuffer, b::Array{UInt8}, nb=length(b)) = readbytes!(io, b, Int(nb))
+function readbytes!(io::GenericIOBuffer, b::Array{UInt8}, nb::Int)
     nr = min(nb, nb_available(io))
     if length(b) < nr
         resize!(b, nr)
@@ -369,9 +361,9 @@ function readbytes!(io::AbstractIOBuffer, b::Array{UInt8}, nb::Int)
     read_sub(io, b, 1, nr)
     return nr
 end
-read(io::AbstractIOBuffer) = read!(io,StringVector(nb_available(io)))
-readavailable(io::AbstractIOBuffer) = read(io)
-read(io::AbstractIOBuffer, nb::Integer) = read!(io,StringVector(min(nb, nb_available(io))))
+read(io::GenericIOBuffer) = read!(io,StringVector(nb_available(io)))
+readavailable(io::GenericIOBuffer) = read(io)
+read(io::GenericIOBuffer, nb::Integer) = read!(io,StringVector(min(nb, nb_available(io))))
 
 function search(buf::IOBuffer, delim::UInt8)
     p = pointer(buf.data, buf.ptr)
@@ -380,7 +372,7 @@ function search(buf::IOBuffer, delim::UInt8)
     return nb
 end
 
-function search(buf::AbstractIOBuffer, delim::UInt8)
+function search(buf::GenericIOBuffer, delim::UInt8)
     data = buf.data
     for i = buf.ptr : buf.size
         @inbounds b = data[i]
@@ -391,7 +383,7 @@ function search(buf::AbstractIOBuffer, delim::UInt8)
     return 0
 end
 
-function readuntil(io::AbstractIOBuffer, delim::UInt8)
+function readuntil(io::GenericIOBuffer, delim::UInt8)
     lb = 70
     A = StringVector(lb)
     n = 0
@@ -414,3 +406,15 @@ function readuntil(io::AbstractIOBuffer, delim::UInt8)
     end
     A
 end
+
+# copy-free crc32c of IOBuffer:
+function crc32c(io::IOBuffer, nb::Integer, crc::UInt32=0x00000000)
+    nb < 0 && throw(ArgumentError("number of bytes to checksum must be ≥ 0"))
+    io.readable || throw(ArgumentError("read failed, IOBuffer is not readable"))
+    n = min(nb, nb_available(io))
+    n == 0 && return crc
+    crc = unsafe_crc32c(pointer(io.data, io.ptr), n, crc)
+    io.ptr += n
+    return crc
+end
+crc32c(io::IOBuffer, crc::UInt32=0x00000000) = crc32c(io, nb_available(io), crc)
diff --git a/base/iostream.jl b/base/iostream.jl
index 099e11afc33ff9..3ee3c315d36c39 100644
--- a/base/iostream.jl
+++ b/base/iostream.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## IOStream
 
@@ -144,7 +144,10 @@ end
 Apply the function `f` to the result of `open(args...)` and close the resulting file
 descriptor upon completion.
 
-**Example**: `open(readstring, "file.txt")`
+# Examples
+```julia-repl
+open(f->read(f, String), "file.txt")
+```
 """
 function open(f::Function, args...)
     io = open(args...)
@@ -166,21 +169,6 @@ function unsafe_write(s::IOStream, p::Ptr{UInt8}, nb::UInt)
     return Int(ccall(:ios_write, Csize_t, (Ptr{Void}, Ptr{Void}, Csize_t), s.ios, p, nb))
 end
 
-function write{T,N}(s::IOStream, a::SubArray{T,N,<:Array})
-    if !isbits(T) || stride(a,1)!=1
-        return invoke(write, Tuple{Any, AbstractArray}, s, a)
-    end
-    colsz = size(a,1)*sizeof(T)
-    if N<=1
-        return unsafe_write(s, pointer(a, 1), colsz)
-    else
-        for idxs in CartesianRange((1, size(a)[2:end]...))
-            unsafe_write(s, pointer(a, idxs.I), colsz)
-        end
-        return colsz*trailingsize(a,2)
-    end
-end
-
 # num bytes available without blocking
 nb_available(s::IOStream) = ccall(:jl_nb_available, Int32, (Ptr{Void},), s.ios)
 
@@ -287,7 +275,7 @@ function read(s::IOStream)
             sz -= pos
         end
     end
-    b = Array{UInt8,1}(sz<=0 ? 1024 : sz)
+    b = StringVector(sz<=0 ? 1024 : sz)
     nr = readbytes_all!(s, b, typemax(Int))
     resize!(b, nr)
 end
@@ -309,27 +297,14 @@ function read(s::IOStream, nb::Integer; all::Bool=true)
 end
 
 ## Character streams ##
-const _chtmp = Array{Char}(1)
+const _chtmp = Ref{Char}()
 function peekchar(s::IOStream)
     if ccall(:ios_peekutf8, Cint, (Ptr{Void}, Ptr{Char}), s, _chtmp) < 0
-        return Char(-1)
+        return typemax(Char)
     end
-    return _chtmp[1]
+    return _chtmp[]
 end
 
 function peek(s::IOStream)
     ccall(:ios_peekc, Cint, (Ptr{Void},), s)
 end
-
-function skipchars(s::IOStream, pred; linecomment::Char=Char(0xffffffff))
-    ch = peekchar(s); status = Int(ch)
-    while status >= 0 && (pred(ch) || ch == linecomment)
-        if ch == linecomment
-            readline(s)
-        else
-            read(s, Char)  # advance one character
-        end
-        ch = peekchar(s); status = Int(ch)
-    end
-    return s
-end
diff --git a/base/irrationals.jl b/base/irrationals.jl
index 55390ac1267389..27b94a59689033 100644
--- a/base/irrationals.jl
+++ b/base/irrationals.jl
@@ -1,21 +1,26 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## general machinery for irrational mathematical constants
 
+"""
+    Irrational <: Real
+
+Irrational number type.
+"""
 struct Irrational{sym} <: Real end
 
-show{sym}(io::IO, x::Irrational{sym}) = print(io, "$sym = $(string(float(x))[1:15])...")
+show(io::IO, x::Irrational{sym}) where {sym} = print(io, "$sym = $(string(float(x))[1:15])...")
 
 promote_rule(::Type{<:Irrational}, ::Type{Float16}) = Float16
 promote_rule(::Type{<:Irrational}, ::Type{Float32}) = Float32
 promote_rule(::Type{<:Irrational}, ::Type{<:Irrational}) = Float64
-promote_rule{T<:Number}(::Type{<:Irrational}, ::Type{T}) = promote_type(Float64, T)
+promote_rule(::Type{<:Irrational}, ::Type{T}) where {T<:Number} = promote_type(Float64, T)
 
 convert(::Type{AbstractFloat}, x::Irrational) = Float64(x)
 convert(::Type{Float16}, x::Irrational) = Float16(Float32(x))
-convert{T<:Real}(::Type{Complex{T}}, x::Irrational) = convert(Complex{T}, convert(T,x))
+convert(::Type{Complex{T}}, x::Irrational) where {T<:Real} = convert(Complex{T}, convert(T,x))
 
-@pure function convert{T<:Integer}(::Type{Rational{T}}, x::Irrational)
+@pure function convert(::Type{Rational{T}}, x::Irrational) where T<:Integer
     o = precision(BigFloat)
     p = 256
     while true
@@ -31,13 +36,15 @@ convert{T<:Real}(::Type{Complex{T}}, x::Irrational) = convert(Complex{T}, conver
 end
 convert(::Type{Rational{BigInt}}, x::Irrational) = throw(ArgumentError("Cannot convert an Irrational to a Rational{BigInt}: use rationalize(Rational{BigInt}, x) instead"))
 
-@pure function (t::Type{T}){T<:Union{Float32,Float64}}(x::Irrational, r::RoundingMode)
+@pure function (t::Type{T})(x::Irrational, r::RoundingMode) where T<:Union{Float32,Float64}
     setprecision(BigFloat, 256) do
         T(BigFloat(x), r)
     end
 end
 
-=={s}(::Irrational{s}, ::Irrational{s}) = true
+float(::Type{<:Irrational}) = Float64
+
+==(::Irrational{s}, ::Irrational{s}) where {s} = true
 ==(::Irrational, ::Irrational) = false
 
 # Irrationals, by definition, can't have a finite representation equal them exactly
@@ -62,7 +69,7 @@ end
 <=(x::AbstractFloat, y::Irrational) = x < y
 
 # Irrational vs Rational
-@pure function rationalize{T<:Integer}(::Type{T}, x::Irrational; tol::Real=0)
+@pure function rationalize(::Type{T}, x::Irrational; tol::Real=0) where T
     return rationalize(T, big(x), tol=tol)
 end
 @pure function lessrational(rx::Rational{<:Integer}, x::Irrational)
@@ -70,7 +77,7 @@ end
     # an irrational number required rounding up or down
     return rx < big(x)
 end
-function <{T}(x::Irrational, y::Rational{T})
+function <(x::Irrational, y::Rational{T}) where T
     T <: Unsigned && x < 0.0 && return true
     rx = rationalize(T, x)
     if lessrational(rx, x)
@@ -79,7 +86,7 @@ function <{T}(x::Irrational, y::Rational{T})
         return rx <= y
     end
 end
-function <{T}(x::Rational{T}, y::Irrational)
+function <(x::Rational{T}, y::Irrational) where T
     T <: Unsigned && y < 0.0 && return false
     ry = rationalize(T, y)
     if lessrational(ry, y)
@@ -95,6 +102,9 @@ end
 <=(x::Rational, y::Irrational) = x < y
 
 isfinite(::Irrational) = true
+isinteger(::Irrational) = false
+iszero(::Irrational) = false
+isone(::Irrational) = false
 
 hash(x::Irrational, h::UInt) = 3*object_id(x) - h
 
@@ -130,6 +140,7 @@ macro irrational(sym, val, def)
 end
 
 big(x::Irrational) = convert(BigFloat,x)
+big(::Type{<:Irrational}) = BigFloat
 
 ## specific irrational mathematical constants
 
@@ -151,7 +162,7 @@ julia> pi
 π = 3.1415926535897...
 ```
 """
-const pi = π
+π, const pi = π
 
 """
     e
@@ -164,7 +175,7 @@ julia> e
 e = 2.7182818284590...
 ```
 """
-const eu = e
+e, const eu = e
 
 """
     γ
@@ -177,7 +188,7 @@ julia> eulergamma
 γ = 0.5772156649015...
 ```
 """
-const eulergamma = γ
+γ, const eulergamma = γ
 
 """
     φ
@@ -190,7 +201,7 @@ julia> golden
 φ = 1.6180339887498...
 ```
 """
-const golden = φ
+φ, const golden = φ
 
 """
     catalan
@@ -212,7 +223,6 @@ catalan
 for T in (Irrational, Rational, Integer, Number)
     ^(::Irrational{:e}, x::T) = exp(x)
 end
-^{p}(::Irrational{:e}, ::Type{Val{p}}) = exp(p)
 
 log(::Irrational{:e}) = 1 # use 1 to correctly promote expressions like log(x)/log(e)
 log(::Irrational{:e}, x::Number) = log(x)
diff --git a/base/iterators.jl b/base/iterators.jl
index 6ad54b5cd00cf9..a37960744bc4b4 100644
--- a/base/iterators.jl
+++ b/base/iterators.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module Iterators
 
@@ -18,12 +18,12 @@ _diff_length(a, b, ::IsInfinite, ::IsInfinite) = 0
 _diff_length(a, b, ::IsInfinite, B) = length(a) # inherit behaviour, error
 _diff_length(a, b, A, B) = max(length(a)-length(b), 0)
 
-and_iteratorsize{T}(isz::T, ::T) = isz
+and_iteratorsize(isz::T, ::T) where {T} = isz
 and_iteratorsize(::HasLength, ::HasShape) = HasLength()
 and_iteratorsize(::HasShape, ::HasLength) = HasLength()
 and_iteratorsize(a, b) = SizeUnknown()
 
-and_iteratoreltype{T}(iel::T, ::T) = iel
+and_iteratoreltype(iel::T, ::T) where {T} = iel
 and_iteratoreltype(a, b) = EltypeUnknown()
 
 # enumerate
@@ -43,6 +43,7 @@ for indexing `iter`; it's also possible that `x != iter[i]`, if `iter`
 has indices that do not start at 1. See the `enumerate(IndexLinear(),
 iter)` method if you want to ensure that `i` is an index.
 
+# Examples
 ```jldoctest
 julia> a = ["a", "b", "c"];
 
@@ -65,10 +66,10 @@ size(e::Enumerate) = size(e.itr)
 end
 @inline done(e::Enumerate, state) = done(e.itr, state[2])
 
-eltype{I}(::Type{Enumerate{I}}) = Tuple{Int, eltype(I)}
+eltype(::Type{Enumerate{I}}) where {I} = Tuple{Int, eltype(I)}
 
-iteratorsize{I}(::Type{Enumerate{I}}) = iteratorsize(I)
-iteratoreltype{I}(::Type{Enumerate{I}}) = iteratoreltype(I)
+iteratorsize(::Type{Enumerate{I}}) where {I} = iteratorsize(I)
+iteratoreltype(::Type{Enumerate{I}}) where {I} = iteratoreltype(I)
 
 struct IndexValue{I,A<:AbstractArray}
     data::A
@@ -90,6 +91,7 @@ specifying `IndexCartesian()` ensures that `i` will be a
 `CartesianIndex`; specifying `IndexStyle(A)` chooses whichever has
 been defined as the native indexing style for array `A`.
 
+# Examples
 ```jldoctest
 julia> A = ["a" "d"; "b" "e"; "c" "f"];
 
@@ -135,10 +137,10 @@ size(v::IndexValue)    = size(v.itr)
 end
 @inline done(v::IndexValue, state) = done(v.itr, state)
 
-eltype{I,A}(::Type{IndexValue{I,A}}) = Tuple{eltype(I), eltype(A)}
+eltype(::Type{IndexValue{I,A}}) where {I,A} = Tuple{eltype(I), eltype(A)}
 
-iteratorsize{I}(::Type{IndexValue{I}}) = iteratorsize(I)
-iteratoreltype{I}(::Type{IndexValue{I}}) = iteratoreltype(I)
+iteratorsize(::Type{IndexValue{I}}) where {I} = iteratorsize(I)
+iteratoreltype(::Type{IndexValue{I}}) where {I} = iteratoreltype(I)
 
 # zip
 
@@ -158,7 +160,7 @@ zip(a) = Zip1(a)
 length(z::Zip1) = length(z.a)
 size(z::Zip1) = size(z.a)
 indices(z::Zip1) = indices(z.a)
-eltype{I}(::Type{Zip1{I}}) = Tuple{eltype(I)}
+eltype(::Type{Zip1{I}}) where {I} = Tuple{eltype(I)}
 @inline start(z::Zip1) = start(z.a)
 @inline function next(z::Zip1, st)
     n = next(z.a,st)
@@ -166,8 +168,8 @@ eltype{I}(::Type{Zip1{I}}) = Tuple{eltype(I)}
 end
 @inline done(z::Zip1, st) = done(z.a,st)
 
-iteratorsize{I}(::Type{Zip1{I}}) = iteratorsize(I)
-iteratoreltype{I}(::Type{Zip1{I}}) = iteratoreltype(I)
+iteratorsize(::Type{Zip1{I}}) where {I} = iteratorsize(I)
+iteratoreltype(::Type{Zip1{I}}) where {I} = iteratoreltype(I)
 
 struct Zip2{I1, I2} <: AbstractZipIterator
     a::I1
@@ -177,7 +179,7 @@ zip(a, b) = Zip2(a, b)
 length(z::Zip2) = _min_length(z.a, z.b, iteratorsize(z.a), iteratorsize(z.b))
 size(z::Zip2) = promote_shape(size(z.a), size(z.b))
 indices(z::Zip2) = promote_shape(indices(z.a), indices(z.b))
-eltype{I1,I2}(::Type{Zip2{I1,I2}}) = Tuple{eltype(I1), eltype(I2)}
+eltype(::Type{Zip2{I1,I2}}) where {I1,I2} = Tuple{eltype(I1), eltype(I2)}
 @inline start(z::Zip2) = (start(z.a), start(z.b))
 @inline function next(z::Zip2, st)
     n1 = next(z.a,st[1])
@@ -186,8 +188,8 @@ eltype{I1,I2}(::Type{Zip2{I1,I2}}) = Tuple{eltype(I1), eltype(I2)}
 end
 @inline done(z::Zip2, st) = done(z.a,st[1]) | done(z.b,st[2])
 
-iteratorsize{I1,I2}(::Type{Zip2{I1,I2}}) = zip_iteratorsize(iteratorsize(I1),iteratorsize(I2))
-iteratoreltype{I1,I2}(::Type{Zip2{I1,I2}}) = and_iteratoreltype(iteratoreltype(I1),iteratoreltype(I2))
+iteratorsize(::Type{Zip2{I1,I2}}) where {I1,I2} = zip_iteratorsize(iteratorsize(I1),iteratorsize(I2))
+iteratoreltype(::Type{Zip2{I1,I2}}) where {I1,I2} = and_iteratoreltype(iteratoreltype(I1),iteratoreltype(I2))
 
 struct Zip{I, Z<:AbstractZipIterator} <: AbstractZipIterator
     a::I
@@ -202,6 +204,7 @@ the `i`th component of each input iterable.
 
 Note that [`zip`](@ref) is its own inverse: `collect(zip(zip(a...)...)) == collect(a)`.
 
+# Examples
 ```jldoctest
 julia> a = 1:5
 1:5
@@ -228,7 +231,7 @@ zip(a, b, c...) = Zip(a, zip(b, c...))
 length(z::Zip) = _min_length(z.a, z.z, iteratorsize(z.a), iteratorsize(z.z))
 size(z::Zip) = promote_shape(size(z.a), size(z.z))
 indices(z::Zip) = promote_shape(indices(z.a), indices(z.z))
-eltype{I,Z}(::Type{Zip{I,Z}}) = tuple_type_cons(eltype(I), eltype(Z))
+eltype(::Type{Zip{I,Z}}) where {I,Z} = tuple_type_cons(eltype(I), eltype(Z))
 @inline start(z::Zip) = tuple(start(z.a), start(z.z))
 @inline function next(z::Zip, st)
     n1 = next(z.a, st[1])
@@ -237,8 +240,8 @@ eltype{I,Z}(::Type{Zip{I,Z}}) = tuple_type_cons(eltype(I), eltype(Z))
 end
 @inline done(z::Zip, st) = done(z.a,st[1]) | done(z.z,st[2])
 
-iteratorsize{I1,I2}(::Type{Zip{I1,I2}}) = zip_iteratorsize(iteratorsize(I1),iteratorsize(I2))
-iteratoreltype{I1,I2}(::Type{Zip{I1,I2}}) = and_iteratoreltype(iteratoreltype(I1),iteratoreltype(I2))
+iteratorsize(::Type{Zip{I1,I2}}) where {I1,I2} = zip_iteratorsize(iteratorsize(I1),iteratorsize(I2))
+iteratoreltype(::Type{Zip{I1,I2}}) where {I1,I2} = and_iteratoreltype(iteratoreltype(I1),iteratoreltype(I2))
 
 # filter
 
@@ -247,6 +250,32 @@ struct Filter{F,I}
     itr::I
 end
 
+"""
+    Iterators.filter(flt, itr)
+
+Given a predicate function `flt` and an iterable object `itr`, return an
+iterable object which upon iteration yields the elements `x` of `itr` that
+satisfy `flt(x)`. The order of the original iterator is preserved.
+
+This function is *lazy*; that is, it is guaranteed to return in ``Θ(1)`` time
+and use ``Θ(1)`` additional space, and `flt` will not be called by an
+invocation of `filter`. Calls to `flt` will be made when iterating over the
+returned iterable object. These calls are not cached and repeated calls will be
+made when reiterating.
+
+See [`Base.filter`](@ref) for an eager implementation of filtering for arrays.
+
+# Examples
+```jldoctest
+julia> f = Iterators.filter(isodd, [1, 2, 3, 4, 5])
+Base.Iterators.Filter{Base.#isodd,Array{Int64,1}}(isodd, [1, 2, 3, 4, 5])
+
+julia> foreach(println, f)
+1
+3
+5
+```
+"""
 filter(flt, itr) = Filter(flt, itr)
 
 start(f::Filter) = start_filter(f.flt, f.itr)
@@ -277,8 +306,8 @@ end
 
 done(f::Filter, s) = s[1]
 
-eltype{F,I}(::Type{Filter{F,I}}) = eltype(I)
-iteratoreltype{F,I}(::Type{Filter{F,I}}) = iteratoreltype(I)
+eltype(::Type{Filter{F,I}}) where {F,I} = eltype(I)
+iteratoreltype(::Type{Filter{F,I}}) where {F,I} = iteratoreltype(I)
 iteratorsize(::Type{<:Filter}) = SizeUnknown()
 
 # Rest -- iterate starting at the given state
@@ -292,6 +321,15 @@ end
     rest(iter, state)
 
 An iterator that yields the same elements as `iter`, but starting at the given `state`.
+
+# Examples
+```jldoctest
+julia> collect(Iterators.rest([1,2,3,4], 2))
+3-element Array{Any,1}:
+ 2
+ 3
+ 4
+```
 """
 rest(itr,state) = Rest(itr,state)
 
@@ -299,11 +337,11 @@ start(i::Rest) = i.st
 next(i::Rest, st) = next(i.itr, st)
 done(i::Rest, st) = done(i.itr, st)
 
-eltype{I}(::Type{Rest{I}}) = eltype(I)
-iteratoreltype{I,S}(::Type{Rest{I,S}}) = iteratoreltype(I)
+eltype(::Type{Rest{I}}) where {I} = eltype(I)
+iteratoreltype(::Type{Rest{I,S}}) where {I,S} = iteratoreltype(I)
 rest_iteratorsize(a) = SizeUnknown()
 rest_iteratorsize(::IsInfinite) = IsInfinite()
-iteratorsize{I,S}(::Type{Rest{I,S}}) = rest_iteratorsize(iteratorsize(I))
+iteratorsize(::Type{Rest{I,S}}) where {I,S} = rest_iteratorsize(iteratorsize(I))
 
 
 # Count -- infinite counting
@@ -317,12 +355,23 @@ end
     countfrom(start=1, step=1)
 
 An iterator that counts forever, starting at `start` and incrementing by `step`.
+
+# Examples
+```jldoctest
+julia> for v in Iterators.countfrom(5, 2)
+           v > 10 && break
+           println(v)
+       end
+5
+7
+9
+```
 """
 countfrom(start::Number, step::Number) = Count(promote(start, step)...)
 countfrom(start::Number)               = Count(start, oneunit(start))
 countfrom()                            = Count(1, 1)
 
-eltype{S}(::Type{Count{S}}) = S
+eltype(::Type{Count{S}}) where {S} = S
 
 start(it::Count) = it.start
 next(it::Count, state) = (state, state + it.step)
@@ -342,6 +391,7 @@ end
 
 An iterator that generates at most the first `n` elements of `iter`.
 
+# Examples
 ```jldoctest
 julia> a = 1:2:11
 1:2:11
@@ -365,11 +415,11 @@ julia> collect(Iterators.take(a,3))
 take(xs, n::Integer) = Take(xs, Int(n))
 take(xs::Take, n::Integer) = Take(xs.xs, min(Int(n), xs.n))
 
-eltype{I}(::Type{Take{I}}) = eltype(I)
-iteratoreltype{I}(::Type{Take{I}}) = iteratoreltype(I)
+eltype(::Type{Take{I}}) where {I} = eltype(I)
+iteratoreltype(::Type{Take{I}}) where {I} = iteratoreltype(I)
 take_iteratorsize(a) = HasLength()
 take_iteratorsize(::SizeUnknown) = SizeUnknown()
-iteratorsize{I}(::Type{Take{I}}) = take_iteratorsize(iteratorsize(I))
+iteratorsize(::Type{Take{I}}) where {I} = take_iteratorsize(iteratorsize(I))
 length(t::Take) = _min_length(t.xs, 1:t.n, iteratorsize(t.xs), HasLength())
 
 start(it::Take) = (it.n, start(it.xs))
@@ -397,6 +447,7 @@ end
 
 An iterator that generates all but the first `n` elements of `iter`.
 
+# Examples
 ```jldoctest
 julia> a = 1:2:11
 1:2:11
@@ -420,12 +471,12 @@ drop(xs, n::Integer) = Drop(xs, Int(n))
 drop(xs::Take, n::Integer) = Take(drop(xs.xs, Int(n)), max(0, xs.n - Int(n)))
 drop(xs::Drop, n::Integer) = Drop(xs.xs, Int(n) + xs.n)
 
-eltype{I}(::Type{Drop{I}}) = eltype(I)
-iteratoreltype{I}(::Type{Drop{I}}) = iteratoreltype(I)
+eltype(::Type{Drop{I}}) where {I} = eltype(I)
+iteratoreltype(::Type{Drop{I}}) where {I} = iteratoreltype(I)
 drop_iteratorsize(::SizeUnknown) = SizeUnknown()
 drop_iteratorsize(::Union{HasShape, HasLength}) = HasLength()
 drop_iteratorsize(::IsInfinite) = IsInfinite()
-iteratorsize{I}(::Type{Drop{I}}) = drop_iteratorsize(iteratorsize(I))
+iteratorsize(::Type{Drop{I}}) where {I} = drop_iteratorsize(iteratorsize(I))
 length(d::Drop) = _diff_length(d.xs, 1:d.n, iteratorsize(d.xs), HasLength())
 
 function start(it::Drop)
@@ -453,12 +504,21 @@ end
     cycle(iter)
 
 An iterator that cycles through `iter` forever.
+
+# Examples
+```jldoctest
+julia> for (i, v) in enumerate(Iterators.cycle("hello"))
+           print(v)
+           i > 10 && break
+       end
+hellohelloh
+```
 """
 cycle(xs) = Cycle(xs)
 
-eltype{I}(::Type{Cycle{I}}) = eltype(I)
-iteratoreltype{I}(::Type{Cycle{I}}) = iteratoreltype(I)
-iteratorsize{I}(::Type{Cycle{I}}) = IsInfinite()
+eltype(::Type{Cycle{I}}) where {I} = eltype(I)
+iteratoreltype(::Type{Cycle{I}}) where {I} = iteratoreltype(I)
+iteratorsize(::Type{Cycle{I}}) where {I} = IsInfinite()
 
 function start(it::Cycle)
     s = start(it.xs)
@@ -490,6 +550,7 @@ repeated(x) = Repeated(x)
 An iterator that generates the value `x` forever. If `n` is specified, generates `x` that
 many times (equivalent to `take(repeated(x), n)`).
 
+# Examples
 ```jldoctest
 julia> a = Iterators.repeated([1 2], 4);
 
@@ -503,7 +564,7 @@ julia> collect(a)
 """
 repeated(x, n::Integer) = take(repeated(x), Int(n))
 
-eltype{O}(::Type{Repeated{O}}) = O
+eltype(::Type{Repeated{O}}) where {O} = O
 
 start(it::Repeated) = nothing
 next(it::Repeated, state) = (it.x, nothing)
@@ -525,7 +586,7 @@ ndims(p::AbstractProdIterator) = length(indices(p))
 
 # generic methods to handle size of Prod* types
 _prod_size(a, ::HasShape)  = size(a)
-_prod_size(a, ::HasLength) = (length(a), )
+_prod_size(a, ::HasLength) = (length(a),)
 _prod_size(a, A) =
     throw(ArgumentError("Cannot compute size for object of type $(typeof(a))"))
 _prod_size(a, b, ::HasLength, ::HasLength)  = (length(a),  length(b))
@@ -536,7 +597,7 @@ _prod_size(a, b, A, B) =
     throw(ArgumentError("Cannot construct size for objects of types $(typeof(a)) and $(typeof(b))"))
 
 _prod_indices(a, ::HasShape)  = indices(a)
-_prod_indices(a, ::HasLength) = (OneTo(length(a)), )
+_prod_indices(a, ::HasLength) = (OneTo(length(a)),)
 _prod_indices(a, A) =
     throw(ArgumentError("Cannot compute indices for object of type $(typeof(a))"))
 _prod_indices(a, b, ::HasLength, ::HasLength)  = (OneTo(length(a)),  OneTo(length(b)))
@@ -552,19 +613,19 @@ struct Prod1{I} <: AbstractProdIterator
 end
 product(a) = Prod1(a)
 
-eltype{I}(::Type{Prod1{I}}) = Tuple{eltype(I)}
+eltype(::Type{Prod1{I}}) where {I} = Tuple{eltype(I)}
 size(p::Prod1) = _prod_size(p.a, iteratorsize(p.a))
 indices(p::Prod1) = _prod_indices(p.a, iteratorsize(p.a))
 
 @inline start(p::Prod1) = start(p.a)
 @inline function next(p::Prod1, st)
     n, st = next(p.a, st)
-    (n, ), st
+    (n,), st
 end
 @inline done(p::Prod1, st) = done(p.a, st)
 
-iteratoreltype{I}(::Type{Prod1{I}}) = iteratoreltype(I)
-iteratorsize{I}(::Type{Prod1{I}}) = iteratorsize(I)
+iteratoreltype(::Type{Prod1{I}}) where {I} = iteratoreltype(I)
+iteratorsize(::Type{Prod1{I}}) where {I} = iteratorsize(I)
 
 # two iterators
 struct Prod2{I1, I2} <: AbstractProdIterator
@@ -577,8 +638,9 @@ end
 
 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:
+changes the fastest.
 
+# Examples
 ```jldoctest
 julia> collect(Iterators.product(1:2,3:5))
 2×3 Array{Tuple{Int64,Int64},2}:
@@ -588,10 +650,10 @@ julia> collect(Iterators.product(1:2,3:5))
 """
 product(a, b) = Prod2(a, b)
 
-eltype{I1,I2}(::Type{Prod2{I1,I2}}) = Tuple{eltype(I1), eltype(I2)}
+eltype(::Type{Prod2{I1,I2}}) where {I1,I2} = Tuple{eltype(I1), eltype(I2)}
 
-iteratoreltype{I1,I2}(::Type{Prod2{I1,I2}}) = and_iteratoreltype(iteratoreltype(I1),iteratoreltype(I2))
-iteratorsize{I1,I2}(::Type{Prod2{I1,I2}}) = prod_iteratorsize(iteratorsize(I1),iteratorsize(I2))
+iteratoreltype(::Type{Prod2{I1,I2}}) where {I1,I2} = and_iteratoreltype(iteratoreltype(I1),iteratoreltype(I2))
+iteratorsize(::Type{Prod2{I1,I2}}) where {I1,I2} = prod_iteratorsize(iteratorsize(I1),iteratorsize(I2))
 
 function start(p::AbstractProdIterator)
     s1, s2 = start(p.a), start(p.b)
@@ -625,12 +687,12 @@ struct Prod{I1, I2<:AbstractProdIterator} <: AbstractProdIterator
 end
 product(a, b, c...) = Prod(a, product(b, c...))
 
-eltype{I1,I2}(::Type{Prod{I1,I2}}) = tuple_type_cons(eltype(I1), eltype(I2))
+eltype(::Type{Prod{I1,I2}}) where {I1,I2} = tuple_type_cons(eltype(I1), eltype(I2))
 
-iteratoreltype{I1,I2}(::Type{Prod{I1,I2}}) = and_iteratoreltype(iteratoreltype(I1),iteratoreltype(I2))
-iteratorsize{I1,I2}(::Type{Prod{I1,I2}}) = prod_iteratorsize(iteratorsize(I1),iteratorsize(I2))
+iteratoreltype(::Type{Prod{I1,I2}}) where {I1,I2} = and_iteratoreltype(iteratoreltype(I1),iteratoreltype(I2))
+iteratorsize(::Type{Prod{I1,I2}}) where {I1,I2} = prod_iteratorsize(iteratorsize(I1),iteratorsize(I2))
 
-@inline function next{I1,I2}(p::Prod{I1,I2}, st)
+@inline function next(p::Prod, st)
     x = prod_next(p, st)
     ((x[1][1],x[1][2]...), x[2])
 end
@@ -654,8 +716,9 @@ end
 
 Given an iterator that yields iterators, return an iterator that yields the
 elements of those iterators.
-Put differently, the elements of the argument iterator are concatenated. Example:
+Put differently, the elements of the argument iterator are concatenated.
 
+# Examples
 ```jldoctest
 julia> collect(Iterators.flatten((1:2, 8:9)))
 4-element Array{Int64,1}:
@@ -667,12 +730,29 @@ julia> collect(Iterators.flatten((1:2, 8:9)))
 """
 flatten(itr) = Flatten(itr)
 
-eltype{I}(::Type{Flatten{I}}) = eltype(eltype(I))
-iteratorsize{I}(::Type{Flatten{I}}) = SizeUnknown()
-iteratoreltype{I}(::Type{Flatten{I}}) = _flatteneltype(I, iteratoreltype(I))
+eltype(::Type{Flatten{I}}) where {I} = eltype(eltype(I))
+iteratoreltype(::Type{Flatten{I}}) where {I} = _flatteneltype(I, iteratoreltype(I))
 _flatteneltype(I, ::HasEltype) = iteratoreltype(eltype(I))
 _flatteneltype(I, et) = EltypeUnknown()
 
+flatten_iteratorsize(::Union{HasShape, HasLength}, b::Type{<:Tuple}) = isleaftype(b) ? HasLength() : SizeUnknown()
+flatten_iteratorsize(::Union{HasShape, HasLength}, b::Type{<:Number}) = HasLength()
+flatten_iteratorsize(a, b) = SizeUnknown()
+
+iteratorsize(::Type{Flatten{I}}) where {I} = flatten_iteratorsize(iteratorsize(I), eltype(I))
+
+function flatten_length(f, ::Type{T}) where {T<:Tuple}
+    if !isleaftype(T)
+        throw(ArgumentError(
+            "Cannot compute length of a tuple-type which is not a leaf-type"))
+    end
+    fieldcount(T)*length(f.it)
+end
+flatten_length(f, ::Type{<:Number}) = length(f.it)
+flatten_length(f, T) = throw(ArgumentError(
+    "Iterates of the argument to Flatten are not known to have constant length"))
+length(f::Flatten{I}) where {I} = flatten_length(f, eltype(I))
+
 function start(f::Flatten)
     local inner, s2
     s = start(f.it)
@@ -709,6 +789,7 @@ end
 
 Iterate over a collection `n` elements at a time.
 
+# Examples
 ```jldoctest
 julia> collect(Iterators.partition([1,2,3,4,5], 2))
 3-element Array{Array{Int64,1},1}:
@@ -717,7 +798,7 @@ julia> collect(Iterators.partition([1,2,3,4,5], 2))
  [5]
 ```
 """
-partition{T}(c::T, n::Integer) = PartitionIterator{T}(c, Int(n))
+partition(c::T, n::Integer) where {T} = PartitionIterator{T}(c, Int(n))
 
 
 mutable struct PartitionIterator{T}
@@ -725,7 +806,12 @@ mutable struct PartitionIterator{T}
     n::Int
 end
 
-eltype{T}(::Type{PartitionIterator{T}}) = Vector{eltype(T)}
+eltype(::Type{PartitionIterator{T}}) where {T} = Vector{eltype(T)}
+partition_iteratorsize(::HasShape) = HasLength()
+partition_iteratorsize(isz) = isz
+function iteratorsize(::Type{PartitionIterator{T}}) where {T}
+    partition_iteratorsize(iteratorsize(T))
+end
 
 function length(itr::PartitionIterator)
     l = length(itr.c)
diff --git a/base/libc.jl b/base/libc.jl
index d811c79aae6d9e..fe3f46d446f9cd 100644
--- a/base/libc.jl
+++ b/base/libc.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module Libc
 
@@ -6,11 +6,11 @@ import Base: transcode
 
 export FILE, TmStruct, strftime, strptime, getpid, gethostname, free, malloc, calloc, realloc,
     errno, strerror, flush_cstdio, systemsleep, time, transcode
-if is_windows()
+if Sys.iswindows()
     export GetLastError, FormatMessage
 end
 
-include(string(length(Core.ARGS)>=2?Core.ARGS[2]:"","errno_h.jl"))  # include($BUILDROOT/base/errno_h.jl)
+include(string(length(Core.ARGS) >= 2 ? Core.ARGS[2] : "", "errno_h.jl"))  # include($BUILDROOT/base/errno_h.jl)
 
 ## RawFD ##
 
@@ -23,19 +23,36 @@ end
 
 Base.cconvert(::Type{Int32}, fd::RawFD) = fd.fd
 
-dup(x::RawFD) = RawFD(ccall((@static is_windows() ? :_dup : :dup), Int32, (Int32,), x.fd))
+dup(x::RawFD) = RawFD(ccall((@static Sys.iswindows() ? :_dup : :dup), Int32, (Int32,), x.fd))
 dup(src::RawFD, target::RawFD) = systemerror("dup", -1 ==
-    ccall((@static is_windows() ? :_dup2 : :dup2), Int32,
-    (Int32, Int32), src.fd, target.fd))
+    ccall((@static Sys.iswindows() ? :_dup2 : :dup2), Int32,
+                (Int32, Int32), src.fd, target.fd))
 
 # Wrapper for an OS file descriptor (for Windows)
-if is_windows()
+if Sys.iswindows()
     struct WindowsRawSocket
         handle::Ptr{Void}   # On Windows file descriptors are HANDLE's and 64-bit on 64-bit Windows
     end
     Base.cconvert(::Type{Ptr{Void}}, fd::WindowsRawSocket) = fd.handle
-    _get_osfhandle(fd::RawFD) = WindowsRawSocket(ccall(:_get_osfhandle,Ptr{Void},(Cint,),fd.fd))
+    _get_osfhandle(fd::RawFD) = WindowsRawSocket(ccall(:_get_osfhandle, Ptr{Void}, (Cint,), fd.fd))
     _get_osfhandle(fd::WindowsRawSocket) = fd
+    function dup(src::WindowsRawSocket)
+        new_handle = Ref{Ptr{Void}}(-1)
+        my_process = ccall(:GetCurrentProcess, stdcall, Ptr{Void}, ())
+        const DUPLICATE_SAME_ACCESS = 0x2
+        status = ccall(:DuplicateHandle, stdcall, Int32,
+            (Ptr{Void}, Ptr{Void}, Ptr{Void}, Ptr{Ptr{Void}}, UInt32, Int32, UInt32),
+            my_process, src.handle, my_process, new_handle, 0, false, DUPLICATE_SAME_ACCESS)
+        status == 0 && error("dup failed: $(FormatMessage())")
+        return new_handle[]
+    end
+    function dup(src::WindowsRawSocket, target::RawFD)
+        fd = ccall(:_open_osfhandle, Int32, (Ptr{Void}, Int32), dup(src), 0)
+        dup(RawFD(fd), target)
+        ccall(:_close, Int32, (Int32,), fd)
+        nothing
+    end
+
 else
     _get_osfhandle(fd::RawFD) = fd
 end
@@ -50,7 +67,7 @@ modestr(s::IO) = modestr(isreadable(s), iswritable(s))
 modestr(r::Bool, w::Bool) = r ? (w ? "r+" : "r") : (w ? "w" : throw(ArgumentError("neither readable nor writable")))
 
 function FILE(fd::RawFD, mode)
-    FILEp = ccall((@static is_windows() ? :_fdopen : :fdopen), Ptr{Void}, (Cint, Cstring), fd, mode)
+    FILEp = ccall((@static Sys.iswindows() ? :_fdopen : :fdopen), Ptr{Void}, (Cint, Cstring), fd, mode)
     systemerror("fdopen", FILEp == C_NULL)
     FILE(FILEp)
 end
@@ -85,9 +102,9 @@ flush_cstdio() = ccall(:jl_flush_cstdio, Void, ())
 ## time-related functions ##
 
 # TODO: check for usleep errors?
-if is_unix()
+if Sys.isunix()
     systemsleep(s::Real) = ccall(:usleep, Int32, (UInt32,), round(UInt32, s*1e6))
-elseif is_windows()
+elseif Sys.iswindows()
     function systemsleep(s::Real)
         ccall(:Sleep, stdcall, Void, (UInt32,), round(UInt32, s * 1e3))
         return Int32(0)
@@ -153,7 +170,7 @@ library.
 strftime(t) = strftime("%c", t)
 strftime(fmt::AbstractString, t::Real) = strftime(fmt, TmStruct(t))
 function strftime(fmt::AbstractString, tm::TmStruct)
-    timestr = Array{UInt8}(128)
+    timestr = Vector{UInt8}(128)
     n = ccall(:strftime, Int, (Ptr{UInt8}, Int, Cstring, Ptr{TmStruct}),
               timestr, length(timestr), fmt, &tm)
     if n == 0
@@ -185,7 +202,7 @@ function strptime(fmt::AbstractString, timestr::AbstractString)
         # TODO: better error message
         throw(ArgumentError("invalid arguments"))
     end
-    @static if is_apple()
+    @static if Sys.isapple()
         # if we didn't explicitly parse the weekday or year day, use mktime
         # to fill them in automatically.
         if !ismatch(r"([^%]|^)%(a|A|j|w|Ow)", fmt)
@@ -222,8 +239,8 @@ getpid() = ccall(:jl_getpid, Int32, ())
 Get the local machine's host name.
 """
 function gethostname()
-    hn = Array{UInt8}(256)
-    err = @static if is_windows()
+    hn = Vector{UInt8}(256)
+    err = @static if Sys.iswindows()
         ccall(:gethostname, stdcall, Int32, (Ptr{UInt8}, UInt32), hn, length(hn))
     else
         ccall(:gethostname, Int32, (Ptr{UInt8}, UInt), hn, length(hn))
@@ -269,7 +286,7 @@ Convert a Win32 system call error code to a descriptive string [only available o
 """
 function FormatMessage end
 
-if is_windows()
+if Sys.iswindows()
     GetLastError() = ccall(:GetLastError, stdcall, UInt32, ())
 
     function FormatMessage(e=GetLastError())
@@ -284,7 +301,7 @@ if is_windows()
                     C_NULL, e, 0, lpMsgBuf, 0, C_NULL)
         p = lpMsgBuf[]
         len == 0 && return ""
-        buf = Array{UInt16}(len)
+        buf = Vector{UInt16}(len)
         unsafe_copy!(pointer(buf), p, len)
         ccall(:LocalFree, stdcall, Ptr{Void}, (Ptr{Void},), p)
         return transcode(String, buf)
diff --git a/base/libdl.jl b/base/libdl.jl
index e89c8a5a8dbb90..9c2b8255f77888 100644
--- a/base/libdl.jl
+++ b/base/libdl.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module Libdl
 
@@ -13,7 +13,7 @@ When calling [`dlopen`](@ref), the paths in this list will be searched first, in
 order, before searching the system locations for a valid library handle.
 """
 const DL_LOAD_PATH = String[]
-if is_apple()
+if Sys.isapple()
     push!(DL_LOAD_PATH, "@loader_path/julia")
     push!(DL_LOAD_PATH, "@loader_path")
 end
@@ -152,7 +152,7 @@ find_library(libname::Union{Symbol,AbstractString}, extrapaths=String[]) =
 function dlpath(handle::Ptr{Void})
     p = ccall(:jl_pathname_for_handle, Cstring, (Ptr{Void},), handle)
     s = unsafe_string(p)
-    is_windows() && Libc.free(p)
+    Sys.iswindows() && Libc.free(p)
     return s
 end
 
@@ -163,12 +163,12 @@ function dlpath(libname::Union{AbstractString, Symbol})
     return path
 end
 
-if is_apple()
+if Sys.isapple()
     const dlext = "dylib"
-elseif is_windows()
+elseif Sys.iswindows()
     const dlext = "dll"
 else
-    #assume is_linux, or similar
+    #assume Sys.islinux, or similar
     const dlext = "so"
 end
 
@@ -179,7 +179,7 @@ File extension for dynamic libraries (e.g. dll, dylib, so) on the current platfo
 """
 dlext
 
-if is_linux()
+if Sys.islinux()
     struct dl_phdr_info
         # Base address of object
         addr::Cuint
@@ -205,7 +205,7 @@ if is_linux()
     end
 end # linux-only
 
-if is_bsd() && !is_apple()
+if Sys.isbsd() && !Sys.isapple()
     # DL_ITERATE_PHDR(3) on freebsd
     struct dl_phdr_info
         # Base address of object
@@ -221,7 +221,7 @@ if is_bsd() && !is_apple()
         phnum::Cshort
     end
 
-    function dl_phdr_info_callback(di::dl_phdr_info, size::Csize_t, dy_libs::Array{AbstractString,1})
+    function dl_phdr_info_callback(di::dl_phdr_info, size::Csize_t, dy_libs::Vector{AbstractString})
         name = unsafe_string(di.name)
         if !isempty(name)
             push!(dy_libs, name)
@@ -231,16 +231,16 @@ if is_bsd() && !is_apple()
 end # bsd family
 
 function dllist()
-    dynamic_libraries = Array{AbstractString}(0)
+    dynamic_libraries = Vector{AbstractString}(0)
 
-    @static if is_linux()
+    @static if Sys.islinux()
         const callback = cfunction(dl_phdr_info_callback, Cint,
-                                   (Ref{dl_phdr_info}, Csize_t, Ref{Array{AbstractString,1}} ))
-        ccall(:dl_iterate_phdr, Cint, (Ptr{Void}, Ref{Array{AbstractString,1}}), callback, dynamic_libraries)
+                                   Tuple{Ref{dl_phdr_info}, Csize_t, Ref{Vector{AbstractString}}})
+        ccall(:dl_iterate_phdr, Cint, (Ptr{Void}, Ref{Vector{AbstractString}}), callback, dynamic_libraries)
     end
 
-    @static if is_apple()
-        numImages = ccall(:_dyld_image_count, Cint, (), )
+    @static if Sys.isapple()
+        numImages = ccall(:_dyld_image_count, Cint, ())
 
         # start at 1 instead of 0 to skip self
         for i in 1:numImages-1
@@ -249,14 +249,14 @@ function dllist()
         end
     end
 
-    @static if is_windows()
+    @static if Sys.iswindows()
         ccall(:jl_dllist, Cint, (Any,), dynamic_libraries)
     end
 
-    @static if is_bsd() && !is_apple()
+    @static if Sys.isbsd() && !Sys.isapple()
         const callback = cfunction(dl_phdr_info_callback, Cint,
-                                   (Ref{dl_phdr_info}, Csize_t, Ref{Array{AbstractString,1}} ))
-        ccall(:dl_iterate_phdr, Cint, (Ptr{Void}, Ref{Array{AbstractString,1}}), callback, dynamic_libraries)
+                                   Tuple{Ref{dl_phdr_info}, Csize_t, Ref{Vector{AbstractString}}})
+        ccall(:dl_iterate_phdr, Cint, (Ptr{Void}, Ref{Vector{AbstractString}}), callback, dynamic_libraries)
         shift!(dynamic_libraries)
     end
 
diff --git a/base/libgit2/blame.jl b/base/libgit2/blame.jl
new file mode 100644
index 00000000000000..a0dee7bb25f020
--- /dev/null
+++ b/base/libgit2/blame.jl
@@ -0,0 +1,36 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
+function GitBlame(repo::GitRepo, path::AbstractString; options::BlameOptions=BlameOptions())
+    blame_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
+    @check ccall((:git_blame_file, :libgit2), Cint,
+                  (Ptr{Ptr{Void}}, Ptr{Void}, Cstring, Ptr{BlameOptions}),
+                   blame_ptr_ptr, repo.ptr, path, Ref(options))
+    return GitBlame(repo, blame_ptr_ptr[])
+end
+
+function counthunks(blame::GitBlame)
+    return ccall((:git_blame_get_hunk_count, :libgit2), Int32, (Ptr{Void},), blame.ptr)
+end
+
+function Base.getindex(blame::GitBlame, i::Integer)
+    if !(1 <= i <= counthunks(blame))
+        throw(BoundsError(blame, (i,)))
+    end
+    hunk_ptr = ccall((:git_blame_get_hunk_byindex, :libgit2),
+                      Ptr{BlameHunk},
+                      (Ptr{Void}, Csize_t), blame.ptr, i-1)
+    return unsafe_load(hunk_ptr)
+end
+
+function Base.show(io::IO, blame_hunk::BlameHunk)
+    println(io, "GitBlameHunk:")
+    println(io, "Original path: ", unsafe_string(blame_hunk.orig_path))
+    println(io, "Lines in hunk: ", blame_hunk.lines_in_hunk)
+    println(io, "Final commit oid: ", blame_hunk.final_commit_id)
+    print(io, "Final signature: ")
+    show(io, Signature(blame_hunk.final_signature))
+    println(io)
+    println(io, "Original commit oid: ", blame_hunk.orig_commit_id)
+    print(io, "Original signature: ")
+    show(io, Signature(blame_hunk.orig_signature))
+end
diff --git a/base/libgit2/blob.jl b/base/libgit2/blob.jl
index 207eb9c56b3d9d..5d74c15521cfe8 100644
--- a/base/libgit2/blob.jl
+++ b/base/libgit2/blob.jl
@@ -1,14 +1,35 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 function Base.length(blob::GitBlob)
     return ccall((:git_blob_rawsize, :libgit2), Int64, (Ptr{Void},), blob.ptr)
 end
 
+"""
+    rawcontent(blob::GitBlob) -> Vector{UInt8}
+
+Fetch the *raw* contents of the [`GitBlob`](@ref) `blob`. This is an
+`Array` containing the contents of the blob, which may be binary or may be Unicode.
+If you write to this `Array` the blob on disk will not be updated.
+`rawcontent` will allow the user to load the raw binary data into
+the output `Array` and will not check to ensure it is valid Unicode, so errors
+may occur if the result is passed to functions which expect valid Unicode data.
+
+See also [`content`](@ref), which *will* throw an error if the content of the `blob`
+is binary and not valid Unicode.
+"""
 function rawcontent(blob::GitBlob)
     ptr = ccall((:git_blob_rawcontent, :libgit2), Ptr{UInt8}, (Ptr{Void},), blob.ptr)
     copy(unsafe_wrap(Array, ptr, (length(blob),), false))
 end
 
+"""
+    content(blob::GitBlob) -> String
+
+Fetch the contents of the [`GitBlob`](@ref) `blob`. If the `blob` contains
+binary data (which can be determined using [`isbinary`](@ref)),
+throw an error. Otherwise, return a `String` containing the contents
+of the `blob`.
+"""
 function content(blob::GitBlob)
     s = String(rawcontent(blob))
     isvalid(s) || error("Blob does not contain valid UTF-8 data")
@@ -16,6 +37,8 @@ function content(blob::GitBlob)
 end
 
 """
+    isbinary(blob::GitBlob) -> Bool
+
 Use a heuristic to guess if a file is binary: searching for NULL bytes and
 looking for a reasonable ratio of printable to non-printable characters among
 the first 8000 bytes.
@@ -29,7 +52,14 @@ end
     LibGit2.addblob!(repo::GitRepo, path::AbstractString)
 
 Reads the file at `path` and adds it to the object database of `repo` as a loose blob.
-Returns the `GitHash` of the resulting blob.
+Returns the [`GitHash`](@ref) of the resulting blob.
+
+# Examples
+```julia
+hash_str = hex(commit_oid)
+blob_file = joinpath(repo_path, ".git", "objects", hash_str[1:2], hash_str[3:end])
+id = LibGit2.addblob!(repo, blob_file)
+```
 """
 function addblob!(repo::GitRepo, path::AbstractString)
     id_ref = Ref{GitHash}()
diff --git a/base/libgit2/callbacks.jl b/base/libgit2/callbacks.jl
index a38c31460a3350..9f464bb6de76f9 100644
--- a/base/libgit2/callbacks.jl
+++ b/base/libgit2/callbacks.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 """Mirror callback function
 
@@ -28,6 +28,8 @@ function authenticate_ssh(creds::SSHCredentials, libgit2credptr::Ptr{Ptr{Void}},
         username_ptr, schema, host)
     isusedcreds = checkused!(creds)
 
+    # Note: The same SSHCredentials can be used to authenticate separate requests using the
+    # same credential cache. e.g. using Pkg.update when there are two private packages.
     errcls, errmsg = Error.last_error()
     if errcls != Error.None
         # Check if we used ssh-agent
@@ -37,7 +39,7 @@ function authenticate_ssh(creds::SSHCredentials, libgit2credptr::Ptr{Ptr{Void}},
     end
 
     # first try ssh-agent if credentials support its usage
-    if creds.usesshagent === nothing || creds.usesshagent == "Y" || creds.usesshagent == "U"
+    if creds.usesshagent == "Y" || creds.usesshagent == "U"
         err = ccall((:git_cred_ssh_key_from_agent, :libgit2), Cint,
                      (Ptr{Ptr{Void}}, Cstring), libgit2credptr, username_ptr)
         creds.usesshagent = "U" # used ssh-agent only one time
@@ -59,7 +61,6 @@ function authenticate_ssh(creds::SSHCredentials, libgit2credptr::Ptr{Ptr{Void}},
             ENV["SSH_KEY_PATH"]
         else
             keydefpath = creds.prvkey # check if credentials were already used
-            keydefpath === nothing && (keydefpath = "")
             if isempty(keydefpath) || isusedcreds
                 defaultkeydefpath = joinpath(homedir(),".ssh","id_rsa")
                 if isempty(keydefpath) && isfile(defaultkeydefpath)
@@ -81,7 +82,6 @@ function authenticate_ssh(creds::SSHCredentials, libgit2credptr::Ptr{Ptr{Void}},
             ENV["SSH_PUB_KEY_PATH"]
         else
             keydefpath = creds.pubkey # check if credentials were already used
-            keydefpath === nothing && (keydefpath = "")
             if isempty(keydefpath) || isusedcreds
                 if isempty(keydefpath)
                     keydefpath = privatekey*".pub"
@@ -108,9 +108,8 @@ function authenticate_ssh(creds::SSHCredentials, libgit2credptr::Ptr{Ptr{Void}},
             ENV["SSH_KEY_PASS"]
         else
             passdef = creds.pass # check if credentials were already used
-            passdef === nothing && (passdef = "")
             if passphrase_required && (isempty(passdef) || isusedcreds)
-                if is_windows()
+                if Sys.iswindows()
                     passdef = Base.winprompt(
                         "Your SSH Key requires a password, please enter it now:",
                         "Passphrase required", privatekey; prompt_username = false)
@@ -133,10 +132,9 @@ function authenticate_ssh(creds::SSHCredentials, libgit2credptr::Ptr{Ptr{Void}},
         isusedcreds && return Cint(Error.EAUTH)
     end
 
-    err = ccall((:git_cred_ssh_key_new, :libgit2), Cint,
+    return ccall((:git_cred_ssh_key_new, :libgit2), Cint,
                  (Ptr{Ptr{Void}}, Cstring, Cstring, Cstring, Cstring),
                  libgit2credptr, creds.user, creds.pubkey, creds.prvkey, creds.pass)
-    return err
 end
 
 function authenticate_userpass(creds::UserPasswordCredentials, libgit2credptr::Ptr{Ptr{Void}},
@@ -146,19 +144,16 @@ function authenticate_userpass(creds::UserPasswordCredentials, libgit2credptr::P
     if creds.prompt_if_incorrect
         username = creds.user
         userpass = creds.pass
-        (username === nothing) && (username = "")
-        (userpass === nothing) && (userpass = "")
-        if is_windows()
+        if Sys.iswindows()
             if isempty(username) || isempty(userpass) || isusedcreds
                 res = Base.winprompt("Please enter your credentials for '$schema$host'", "Credentials required",
-                        username === nothing || isempty(username) ?
-                        urlusername : username; prompt_username = true)
+                        isempty(username) ? urlusername : username; prompt_username = true)
                 isnull(res) && return Cint(Error.EAUTH)
                 username, userpass = Base.get(res)
             end
         elseif isusedcreds
-            username = prompt("Username for '$schema$host'", default = isempty(username) ?
-                urlusername : username)
+            username = prompt("Username for '$schema$host'",
+                default=isempty(username) ? urlusername : username)
             userpass = prompt("Password for '$schema$username@$host'", password=true)
         end
         ((creds.user != username) || (creds.pass != userpass)) && reset!(creds)
@@ -170,10 +165,9 @@ function authenticate_userpass(creds::UserPasswordCredentials, libgit2credptr::P
         isusedcreds && return Cint(Error.EAUTH)
     end
 
-    err = ccall((:git_cred_userpass_plaintext_new, :libgit2), Cint,
+    return ccall((:git_cred_userpass_plaintext_new, :libgit2), Cint,
                  (Ptr{Ptr{Void}}, Cstring, Cstring),
                  libgit2credptr, creds.user, creds.pass)
-    err == 0 && return Cint(0)
 end
 
 
@@ -206,7 +200,7 @@ counting strategy that prevents repeated usage of faulty credentials.
 function credentials_callback(libgit2credptr::Ptr{Ptr{Void}}, url_ptr::Cstring,
                               username_ptr::Cstring,
                               allowed_types::Cuint, payload_ptr::Ptr{Void})
-    err = 0
+    err = Cint(0)
     url = unsafe_string(url_ptr)
 
     # parse url for schema and host
@@ -252,19 +246,20 @@ function credentials_callback(libgit2credptr::Ptr{Ptr{Void}}, url_ptr::Cstring,
         end
         err = Cint(Error.EAUTH)
     end
-    return Cint(err)
+    return err
 end
 
 function fetchhead_foreach_callback(ref_name::Cstring, remote_url::Cstring,
-                        oid::Ptr{GitHash}, is_merge::Cuint, payload::Ptr{Void})
+                        oid_ptr::Ptr{GitHash}, is_merge::Cuint, payload::Ptr{Void})
     fhead_vec = unsafe_pointer_to_objref(payload)::Vector{FetchHead}
-    push!(fhead_vec, FetchHead(unsafe_string(ref_name), unsafe_string(remote_url), GitHash(oid), is_merge == 1))
+    push!(fhead_vec, FetchHead(unsafe_string(ref_name), unsafe_string(remote_url),
+        unsafe_load(oid_ptr), 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}))
+mirror_cb() = cfunction(mirror_callback, Cint, Tuple{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}))
+credentials_cb() = cfunction(credentials_callback, Cint, Tuple{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{GitHash}, Cuint, Ptr{Void}))
+fetchhead_foreach_cb() = cfunction(fetchhead_foreach_callback, Cint, Tuple{Cstring, Cstring, Ptr{GitHash}, Cuint, Ptr{Void}})
diff --git a/base/libgit2/commit.jl b/base/libgit2/commit.jl
index 28592fe933c00b..0cf8ca641076d5 100644
--- a/base/libgit2/commit.jl
+++ b/base/libgit2/commit.jl
@@ -1,21 +1,43 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
+"""
+    message(c::GitCommit, raw::Bool=false)
+
+Return the commit message describing the changes made in commit `c`. If
+`raw` is `false`, return a slightly "cleaned up" message (which has any
+leading newlines removed). If `raw` is `true`, the message is not stripped
+of any such newlines.
+"""
 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)
+    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 == C_NULL
         return nothing
     end
     return unsafe_string(msg_ptr)
 end
 
+"""
+    author(c::GitCommit)
+
+Return the `Signature` of the author of the commit `c`. The author is
+the person who made changes to the relevant file(s). See also [`committer`](@ref).
+"""
 function author(c::GitCommit)
     ptr = ccall((:git_commit_author, :libgit2), Ptr{SignatureStruct}, (Ptr{Void},), c.ptr)
     @assert ptr != C_NULL
     return Signature(ptr)
 end
 
+"""
+    committer(c::GitCommit)
+
+Return the `Signature` of the committer of the commit `c`. The committer is
+the person who committed the changes originally authored by the [`author`](@ref), but
+need not be the same as the `author`, for example, if the `author` emailed a patch to
+a `committer` who committed it.
+"""
 function committer(c::GitCommit)
     ptr = ccall((:git_commit_committer, :libgit2), Ptr{SignatureStruct}, (Ptr{Void},), c.ptr)
     @assert ptr != C_NULL
diff --git a/base/libgit2/config.jl b/base/libgit2/config.jl
index 7c01664042cc47..2adf7a82e99b94 100644
--- a/base/libgit2/config.jl
+++ b/base/libgit2/config.jl
@@ -1,5 +1,12 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
+"""
+    GitConfig(path::AbstractString, level::Consts.GIT_CONFIG=Consts.CONFIG_LEVEL_APP, force::Bool=false)
+
+Create a new `GitConfig` by loading configuration information from the file at
+`path`. See [`addfile`](@ref) for more information about the `level` and `force`
+options.
+"""
 function GitConfig(path::AbstractString,
                    level::Consts.GIT_CONFIG = Consts.CONFIG_LEVEL_APP,
                    force::Bool=false)
@@ -16,6 +23,13 @@ function GitConfig(path::AbstractString,
     return cfg
 end
 
+"""
+    GitConfig(repo::GitRepo)
+
+Get the stored configuration for the git repository `repo`. If `repo` does not
+have a specific configuration file set, the default git configuration will be
+used.
+"""
 function GitConfig(repo::GitRepo)
     cfg_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
     @check ccall((:git_repository_config, :libgit2), Cint,
@@ -23,10 +37,17 @@ function GitConfig(repo::GitRepo)
     return GitConfig(repo, cfg_ptr_ptr[])
 end
 
+"""
+    GitConfig(level::Consts.GIT_CONFIG=Consts.CONFIG_LEVEL_DEFAULT)
+
+Get the default git configuration by loading the global and system configuration
+files into a prioritized configuration. This can be used to access default configuration
+options outside a specific git repository.
+"""
 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)
+                  (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)
@@ -43,6 +64,17 @@ function GitConfig(level::Consts.GIT_CONFIG = Consts.CONFIG_LEVEL_DEFAULT)
     return cfg
 end
 
+"""
+    addfile(cfg::GitConfig, path::AbstractString, level::Consts.GIT_CONFIG=Consts.CONFIG_LEVEL_APP, force::Bool=false)
+
+Add an existing git configuration file located at `path` to the current
+[`GitConfig`](@ref) `cfg`. If the file does not exist, it will be created.
+`level` sets the git configuration priority level and is determined by
+[`Consts.GIT_CONFIG`](@ref). If `force` is `false` and a configuration for
+the given priority level already exists, `addfile` will error. If `force` is
+`true`, the existing configuration will be replaced by the one in the file at
+`path`.
+"""
 function addfile(cfg::GitConfig, path::AbstractString,
                  level::Consts.GIT_CONFIG = Consts.CONFIG_LEVEL_APP,
                  force::Bool=false)
@@ -82,7 +114,7 @@ function get(::Type{Int64}, c::GitConfig, name::AbstractString)
     return val_ptr[]
 end
 
-function get{T}(c::GitConfig, name::AbstractString, default::T)
+function get(c::GitConfig, name::AbstractString, default::T) where T
     res = default
     try res = get(T,c,name) end
     return res
@@ -128,3 +160,67 @@ 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
+
+function GitConfigIter(cfg::GitConfig)
+    ci_ptr = Ref{Ptr{Void}}(C_NULL)
+    @check ccall((:git_config_iterator_new, :libgit2), Cint,
+                  (Ptr{Ptr{Void}}, Ptr{Void}), ci_ptr, cfg.ptr)
+    return GitConfigIter(ci_ptr[])
+end
+
+function GitConfigIter(cfg::GitConfig, name::AbstractString)
+    ci_ptr = Ref{Ptr{Void}}(C_NULL)
+    @check ccall((:git_config_multivar_iterator_new, :libgit2), Cint,
+                  (Ptr{Ptr{Void}}, Ptr{Void}, Cstring, Cstring),
+                  ci_ptr, cfg.ptr, name, C_NULL)
+    return GitConfigIter(ci_ptr[])
+end
+
+function GitConfigIter(cfg::GitConfig, name::AbstractString, value::Regex)
+    ci_ptr = Ref{Ptr{Void}}(C_NULL)
+    @check ccall((:git_config_multivar_iterator_new, :libgit2), Cint,
+                  (Ptr{Ptr{Void}}, Ptr{Void}, Cstring, Cstring),
+                  ci_ptr, cfg.ptr, name, value.pattern)
+    return GitConfigIter(ci_ptr[])
+end
+
+function GitConfigIter(cfg::GitConfig, name::Regex)
+    ci_ptr = Ref{Ptr{Void}}(C_NULL)
+    @check ccall((:git_config_iterator_glob_new, :libgit2), Cint,
+                  (Ptr{Ptr{Void}}, Ptr{Void}, Cstring),
+                  ci_ptr, cfg.ptr, name.pattern)
+    return GitConfigIter(ci_ptr[])
+end
+
+function Base.start(ci::GitConfigIter)
+    entry_ptr_ptr = Ref{Ptr{ConfigEntry}}(C_NULL)
+    err = ccall((:git_config_next, :libgit2), Cint,
+                 (Ptr{Ptr{ConfigEntry}}, Ptr{Void}), entry_ptr_ptr, ci.ptr)
+    if err == Cint(Error.GIT_OK)
+        state = Nullable{ConfigEntry}(unsafe_load(entry_ptr_ptr[]))
+    elseif err == Cint(Error.ITEROVER)
+        state = Nullable{ConfigEntry}()
+    else
+        throw(GitError(err))
+    end
+    return state
+end
+
+Base.done(ci::GitConfigIter, state) = isnull(state)
+
+function Base.next(ci::GitConfigIter, state)
+    entry = Base.get(state)
+    entry_ptr_ptr = Ref{Ptr{ConfigEntry}}(C_NULL)
+    err = ccall((:git_config_next, :libgit2), Cint,
+                 (Ptr{Ptr{ConfigEntry}}, Ptr{Void}), entry_ptr_ptr, ci.ptr)
+    if err == Cint(Error.GIT_OK)
+        state = Nullable{ConfigEntry}(unsafe_load(entry_ptr_ptr[]))
+    elseif err == Cint(Error.ITEROVER)
+        state = Nullable{ConfigEntry}()
+    else
+        throw(GitError(err))
+    end
+    return (entry, state)
+end
+
+Base.iteratorsize(::Type{GitConfigIter}) = Base.SizeUnknown()
diff --git a/base/libgit2/consts.jl b/base/libgit2/consts.jl
index 94b535b0dfce5b..0f4ab0989271aa 100644
--- a/base/libgit2/consts.jl
+++ b/base/libgit2/consts.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module Consts
 
@@ -98,15 +98,15 @@ module Consts
     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)
+    @enum(DELTA_STATUS, DELTA_UNMODIFIED = Cint(0),
+                        DELTA_ADDED      = Cint(1),
+                        DELTA_DELETED    = Cint(2),
+                        DELTA_MODIFIED   = Cint(3),
+                        DELTA_RENAMED    = Cint(4),
+                        DELTA_COPIED     = Cint(5),
+                        DELTA_IGNORED    = Cint(6),
+                        DELTA_UNTRACKED  = Cint(7),
+                        DELTA_TYPECHANGE = Cint(8))
 
     # index
     const IDXENTRY_NAMEMASK   = (0x0fff)
@@ -177,12 +177,12 @@ module Consts
     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)
+    @enum(GIT_REBASE_OPERATION, REBASE_OPERATION_PICK   = Cint(0),
+                                REBASE_OPERATION_REWORD = Cint(1),
+                                REBASE_OPERATION_EDIT   = Cint(2),
+                                REBASE_OPERATION_SQUASH = Cint(3),
+                                REBASE_OPERATION_FIXUP  = Cint(4),
+                                REBASE_OPERATION_EXEC   = Cint(5))
 
     # fetch_prune
     const FETCH_PRUNE_UNSPECIFIED = Cint(0)
@@ -201,6 +201,11 @@ module Consts
     const CLONE_NO_LOCAL       = Cint(2)
     const CLONE_LOCAL_NO_LINKS = Cint(3)
 
+    # describe
+    const DESCRIBE_DEFAULT = Cuint(0)
+    const DESCRIBE_TAGS    = Cuint(1 << 0)
+    const DESCRIBE_ALL     = Cuint(1 << 1)
+
     # status
     const STATUS_CURRENT          = Cuint(0)
     const STATUS_INDEX_NEW        = Cuint(1 << 0)
@@ -345,4 +350,16 @@ These are used to select which global option to set or get and are used in `git_
                     SET_TEMPLATE_PATH        = 11,
                     SET_SSL_CERT_LOCATIONS   = 12)
 
+
+    """
+Option flags for `GitProxy`.
+
+* `PROXY_NONE`: do not attempt the connection through a proxy.
+* `PROXY_AUTO`: attempt to figure out the proxy configuration from the git configuration.
+* `PROXY_SPECIFIED`: connect using the URL given in the `url` field of this struct.
+    """
+    @enum(GIT_PROXY, PROXY_NONE,
+                     PROXY_AUTO,
+                     PROXY_SPECIFIED)
+
 end
diff --git a/base/libgit2/diff.jl b/base/libgit2/diff.jl
index c3f202a90cec93..a4a172be9d3022 100644
--- a/base/libgit2/diff.jl
+++ b/base/libgit2/diff.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # TODO: make this a general purpose solution
 function Base.cconvert(::Type{Ptr{DiffOptionsStruct}}, pathspecs::AbstractString)
@@ -11,7 +11,18 @@ function Base.unsafe_convert(::Type{Ptr{DiffOptionsStruct}}, rr::Tuple{Ref{DiffO
     Base.unsafe_convert(Ptr{DiffOptionsStruct}, first(rr))
 end
 
+"""
+    diff_tree(repo::GitRepo, tree::GitTree, pathspecs::AbstractString=""; cached::Bool=false)
 
+Generate a [`GitDiff`](@ref) between `tree` (which will be used for the "old"
+side of the [`DiffDelta`](@ref)) and `repo` (which will be used for the "new" side).
+If `repo` is `cached`, calls [`git_diff_tree_to_index`](https://libgit2.github.com/libgit2/#HEAD/group/diff/git_diff_tree_to_index).
+The `cached` version is generally used to examine the diff for staged changes from one
+commit to the next. If `cached` is `false`, calls
+[`git_diff_tree_to_workdir_with_index`](https://libgit2.github.com/libgit2/#HEAD/group/diff/git_diff_tree_to_workdir_with_index).
+This compares the current working directory against the [`GitIndex`](@ref) and can,
+for example, be used to examine the changes in staged files before a commit.
+"""
 function diff_tree(repo::GitRepo, tree::GitTree, pathspecs::AbstractString=""; cached::Bool=false)
     diff_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
     if cached
@@ -26,6 +37,16 @@ function diff_tree(repo::GitRepo, tree::GitTree, pathspecs::AbstractString=""; c
     return GitDiff(repo, diff_ptr_ptr[])
 end
 
+"""
+    diff_tree(repo::GitRepo, oldtree::GitTree, newtree::GitTree)
+
+Generate a [`GitDiff`](@ref) between `oldtree` (which will be used for the "old"
+side of the [`DiffDelta`](@ref)) and `newtree` (which will be used for the "new"
+side of the `DiffDelta`). Equivalent to [`git_diff_tree_to_tree`](https://libgit2.github.com/libgit2/#HEAD/group/diff/git_diff_tree_to_tree).
+This can be used to generate a diff between two commits. For instance, it could
+be used to compare a commit made 2 months ago with the current latest commit, or
+to compare a commit on another branch with the current latest commit on `master`.
+"""
 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,
@@ -34,14 +55,80 @@ function diff_tree(repo::GitRepo, oldtree::GitTree, newtree::GitTree)
     return GitDiff(repo, diff_ptr_ptr[])
 end
 
+"""
+    GitDiffStats(diff::GitDiff)
+
+Get the diff statistics from the [`GitDiff`](@ref) `diff`. This object records a
+summary of changes made across the `diff`. In particular, it records how many
+files were changed, how many insertions were made, and how many deletions were made.
+"""
+function GitDiffStats(diff::GitDiff)
+    diff_stat_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
+    @check ccall((:git_diff_get_stats, :libgit2), Cint,
+                  (Ptr{Ptr{Void}}, Ptr{Void}),
+                  diff_stat_ptr_ptr, diff.ptr)
+    return GitDiffStats(diff.owner, diff_stat_ptr_ptr[])
+end
+
+"""
+    files_changed(diff_stat::GitDiffStats) -> Csize_t
+
+Return how many files were changed (added/modified/deleted) in the [`GitDiff`](@ref)
+summarized by `diff_stat`. The result may vary depending on the [`DiffOptionsStruct`](@ref)
+used to generate the parent `GitDiff` of `diff_stat` (for instance, whether ignored files
+are to be included or not).
+"""
+function files_changed(diff_stat::GitDiffStats)
+    return ccall((:git_diff_stats_files_changed, :libgit2), Csize_t, (Ptr{Void},), diff_stat.ptr)
+end
+
+"""
+    insertions(diff_stat::GitDiffStats) -> Csize_t
+
+Return the total number of insertions (lines added) in the [`GitDiff`](@ref)
+summarized by `diff_stat`. The result may vary depending on the [`DiffOptionsStruct`](@ref)
+used to generate the parent `GitDiff` of `diff_stat` (for instance, whether ignored files
+are to be included or not).
+"""
+function insertions(diff_stat::GitDiffStats)
+    return ccall((:git_diff_stats_insertions, :libgit2), Csize_t, (Ptr{Void},), diff_stat.ptr)
+end
+
+"""
+    deletions(diff_stat::GitDiffStats) -> Csize_t
+
+Return the total number of deletions (lines removed) in the [`GitDiff`](@ref)
+summarized by `diff_stat`. The result may vary depending on the [`DiffOptionsStruct`](@ref)
+used to generate the parent `GitDiff` of `diff_stat` (for instance, whether ignored files
+are to be included or not).
+"""
+function deletions(diff_stat::GitDiffStats)
+    return ccall((:git_diff_stats_deletions, :libgit2), Csize_t, (Ptr{Void},), diff_stat.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::Integer)
+    if i < 1 || i > count(diff)
+        throw(BoundsError(diff, (i,)))
+    end
     delta_ptr = ccall((:git_diff_get_delta, :libgit2),
                       Ptr{DiffDelta},
                       (Ptr{Void}, Csize_t), diff.ptr, i-1)
-    delta_ptr == C_NULL && throw(BoundsError(diff, (i,)))
     return unsafe_load(delta_ptr)
 end
+
+function Base.show(io::IO, diff_stat::GitDiffStats)
+    println(io, "GitDiffStats:")
+    println(io, "Files changed: $(files_changed(diff_stat))")
+    println(io, "Insertions: $(insertions(diff_stat))")
+    println(io, "Deletions: $(deletions(diff_stat))")
+end
+
+function Base.show(io::IO, diff::GitDiff)
+    println(io, "GitDiff:")
+    println(io, "Number of deltas: $(count(diff))")
+    show(io, GitDiffStats(diff))
+end
diff --git a/base/libgit2/error.jl b/base/libgit2/error.jl
index 8e91bec65821ca..2f5739e0af8798 100644
--- a/base/libgit2/error.jl
+++ b/base/libgit2/error.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module Error
 
diff --git a/base/libgit2/index.jl b/base/libgit2/index.jl
index 8154c70c2c699b..e75ecf7c14185f 100644
--- a/base/libgit2/index.jl
+++ b/base/libgit2/index.jl
@@ -1,5 +1,10 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
+"""
+    GitIndex(repo::GitRepo)
+
+Load the index file for the repository `repo`.
+"""
 function GitIndex(repo::GitRepo)
     idx_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
     @check ccall((:git_repository_index, :libgit2), Cint,
@@ -7,16 +12,39 @@ function GitIndex(repo::GitRepo)
     return GitIndex(repo, idx_ptr_ptr[])
 end
 
+"""
+    read!(idx::GitIndex, force::Bool = false) -> GitIndex
+
+Update the contents of `idx` by reading changes made on disk. For example, `idx`
+might be updated if a file has been added to the repository since it was created.
+If `force` is `true`, any changes in memory (any changes in `idx` since its last
+[`write!`](@ref), or since its creation if no writes have occurred) are discarded.
+If `force` is `false`, the index data is only updated from disk if the data on disk
+has changed since the last time it was loaded into `idx`.
+"""
 function read!(idx::GitIndex, force::Bool = false)
     @check ccall((:git_index_read, :libgit2), Cint, (Ptr{Void}, Cint), idx.ptr, Cint(force))
     return idx
 end
 
+"""
+    write!(idx::GitIndex) -> GitIndex
+
+Write the state of index `idx` to disk using a file lock.
+"""
 function write!(idx::GitIndex)
     @check ccall((:git_index_write, :libgit2), Cint, (Ptr{Void},), idx.ptr)
     return idx
 end
 
+"""
+    write_tree!(idx::GitIndex) -> GitHash
+
+Write the index `idx` as a [`GitTree`](@ref) on disk. Trees will be recursively
+created for each subtree in `idx`. The returned [`GitHash`](@ref) can be used to
+create a [`GitCommit`](@ref). `idx` must have a parent repository and this
+repository cannot be bare. `idx` must not contain any files with conflicts.
+"""
 function write_tree!(idx::GitIndex)
     oid_ptr = Ref(GitHash())
     @check ccall((:git_index_write_tree, :libgit2), Cint,
@@ -25,10 +53,10 @@ function write_tree!(idx::GitIndex)
 end
 
 function repository(idx::GitIndex)
-    if isnull(idx.nrepo)
+    if isnull(idx.owner)
         throw(GitError(Error.Index, Error.ENOTFOUND, "Index does not have an owning repository."))
     else
-        return Base.get(idx.nrepo)
+        return Base.get(idx.owner)
     end
 end
 
@@ -117,6 +145,17 @@ function Base.find(path::String, idx::GitIndex)
     return Nullable(pos_ref[]+1)
 end
 
+"""
+    stage(ie::IndexEntry) -> Cint
+
+Get the stage number of `ie`. The stage number `0` represents the current state
+of the working tree, but other numbers can be used in the case of a merge conflict.
+In such a case, the various stage numbers on an `IndexEntry` describe which side(s)
+of the conflict the current state of the file belongs to. Stage `0` is the state
+before the attempted merge, stage `1` is the changes which have been made locally,
+stages `2` and larger are for changes from other branches (for instance, in the case
+of a multi-branch "octopus" merge, stages `2`, `3`, and `4` might be used).
+"""
 stage(ie::IndexEntry) = ccall((:git_index_entry_stage, :libgit2), Cint, (Ptr{IndexEntry},), Ref(ie))
 
 function Base.show(io::IO, idx::GitIndex)
diff --git a/base/libgit2/libgit2.jl b/base/libgit2/libgit2.jl
index 113946fb3ac02e..c3862f7eb565d8 100644
--- a/base/libgit2/libgit2.jl
+++ b/base/libgit2/libgit2.jl
@@ -1,8 +1,8 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module LibGit2
 
-import Base: merge!, cat, ==
+import Base: merge!, ==
 
 export with, GitRepo, GitConfig
 
@@ -30,6 +30,7 @@ include("tag.jl")
 include("blob.jl")
 include("diff.jl")
 include("rebase.jl")
+include("blame.jl")
 include("status.jl")
 include("tree.jl")
 include("callbacks.jl")
@@ -72,6 +73,18 @@ end
 
 Checks if commit `id` (which is a [`GitHash`](@ref) in string form)
 is in the repository.
+
+# Examples
+```julia-repl
+julia> repo = LibGit2.GitRepo(repo_path);
+
+julia> LibGit2.add!(repo, test_file);
+
+julia> commit_oid = LibGit2.commit(repo, "add test_file");
+
+julia> LibGit2.iscommit(string(commit_oid), repo)
+true
+```
 """
 function iscommit(id::AbstractString, repo::GitRepo)
     res = true
@@ -95,6 +108,17 @@ Checks if there have been any changes to tracked files in the working tree (if
 `cached=false`) or the index (if `cached=true`).
 `pathspecs` are the specifications for options for the diff.
 
+# Examples
+```julia
+repo = LibGit2.GitRepo(repo_path)
+LibGit2.isdirty(repo) # should be false
+open(joinpath(repo_path, new_file), "a") do f
+    println(f, "here's my cool new file")
+end
+LibGit2.isdirty(repo) # now true
+LibGit2.isdirty(repo, new_file) # now true
+```
+
 Equivalent to `git diff-index HEAD [-- <pathspecs>]`.
 """
 isdirty(repo::GitRepo, paths::AbstractString=""; cached::Bool=false) =
@@ -107,6 +131,16 @@ Checks if there are any differences between the tree specified by `treeish` and
 tracked files in the working tree (if `cached=false`) or the index (if `cached=true`).
 `pathspecs` are the specifications for options for the diff.
 
+# Examples
+```julia
+repo = LibGit2.GitRepo(repo_path)
+LibGit2.isdiff(repo, "HEAD") # should be false
+open(joinpath(repo_path, new_file), "a") do f
+    println(f, "here's my cool new file")
+end
+LibGit2.isdiff(repo, "HEAD") # now true
+```
+
 Equivalent to `git diff-index <treeish> [-- <pathspecs>]`.
 """
 function isdiff(repo::GitRepo, treeish::AbstractString, paths::AbstractString=""; cached::Bool=false)
@@ -115,10 +149,10 @@ function isdiff(repo::GitRepo, treeish::AbstractString, paths::AbstractString=""
         diff = diff_tree(repo, tree, paths, cached=cached)
         result = count(diff) > 0
         close(diff)
+        return result
     finally
         close(tree)
     end
-    return result
 end
 
 """
@@ -128,15 +162,33 @@ Show which files have changed in the git repository `repo` between branches `bra
 and `branch2`.
 
 The keyword argument is:
-  * `filter::Set{Cint}=Set([Consts.DELTA_ADDED, Consts.DELTA_MODIFIED, Consts.DELTA_DELETED]))`,
+  * `filter::Set{Consts.DELTA_STATUS}=Set([Consts.DELTA_ADDED, Consts.DELTA_MODIFIED, Consts.DELTA_DELETED]))`,
     and it sets options for the diff. The default is to show files added, modified, or deleted.
 
 Returns only the *names* of the files which have changed, *not* their contents.
 
+# Examples
+```julia
+LibGit2.branch!(repo, "branch/a")
+LibGit2.branch!(repo, "branch/b")
+# add a file to repo
+open(joinpath(LibGit2.path(repo),"file"),"w") do f
+    write(f, "hello repo\n")
+end
+LibGit2.add!(repo, "file")
+LibGit2.commit(repo, "add file")
+# returns ["file"]
+filt = Set([LibGit2.Consts.DELTA_ADDED])
+files = LibGit2.diff_files(repo, "branch/a", "branch/b", filter=filt)
+# returns [] because existing files weren't modified
+filt = Set([LibGit2.Consts.DELTA_MODIFIED])
+files = LibGit2.diff_files(repo, "branch/a", "branch/b", filter=filt)
+```
+
 Equivalent to `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]))
+                    filter::Set{Consts.DELTA_STATUS}=Set([Consts.DELTA_ADDED, Consts.DELTA_MODIFIED, Consts.DELTA_DELETED]))
     b1_id = revparseid(repo, branch1*"^{tree}")
     b2_id = revparseid(repo, branch2*"^{tree}")
     tree1 = GitTree(repo, b1_id)
@@ -147,7 +199,7 @@ function diff_files(repo::GitRepo, branch1::AbstractString, branch2::AbstractStr
         for i in 1:count(diff)
             delta = diff[i]
             delta === nothing && break
-            if delta.status in filter
+            if Consts.DELTA_STATUS(delta.status) in filter
                 push!(files, unsafe_string(delta.new_file.path))
             end
         end
@@ -164,46 +216,26 @@ end
 
 Returns `true` if `a`, a [`GitHash`](@ref) in string form, is an ancestor of
 `b`, a [`GitHash`](@ref) in string form.
-"""
-function is_ancestor_of(a::AbstractString, b::AbstractString, repo::GitRepo)
-    A = revparseid(repo, a)
-    merge_base(repo, a, b) == A
-end
 
-"""
-    set_remote_url(repo::GitRepo, url::AbstractString; remote::AbstractString="origin")
+# Examples
+```julia-repl
+julia> repo = LibGit2.GitRepo(repo_path);
 
-Set the `url` for `remote` for the git repository `repo`.
-The default name of the remote is `"origin"`.
-"""
-function set_remote_url(repo::GitRepo, url::AbstractString; remote::AbstractString="origin")
-    with(GitConfig, repo) do cfg
-        set!(cfg, "remote.$remote.url", url)
+julia> LibGit2.add!(repo, test_file1);
 
-        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
+julia> commit_oid1 = LibGit2.commit(repo, "commit1");
 
-"""
-    set_remote_url(path::AbstractString, url::AbstractString; remote::AbstractString="origin")
+julia> LibGit2.add!(repo, test_file2);
 
-Set the `url` for `remote` for the git repository located at `path`.
-The default name of the remote is `"origin"`.
-"""
-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
+julia> commit_oid2 = LibGit2.commit(repo, "commit2");
 
-function make_payload(payload::Nullable{<:AbstractCredentials})
-    Ref{Nullable{AbstractCredentials}}(payload)
+julia> LibGit2.is_ancestor_of(string(commit_oid1), string(commit_oid2), repo)
+true
+```
+"""
+function is_ancestor_of(a::AbstractString, b::AbstractString, repo::GitRepo)
+    A = revparseid(repo, a)
+    merge_base(repo, a, b) == A
 end
 
 """
@@ -233,7 +265,6 @@ function fetch(repo::GitRepo; remote::AbstractString="origin",
         GitRemoteAnon(repo, remoteurl)
     end
     try
-        payload = make_payload(payload)
         fo = FetchOptions(callbacks=RemoteCallbacks(credentials_cb(), payload))
         fetch(rmt, refspecs, msg="from $(url(rmt))", options = fo)
     finally
@@ -268,7 +299,6 @@ function push(repo::GitRepo; remote::AbstractString="origin",
         GitRemoteAnon(repo, remoteurl)
     end
     try
-        payload = make_payload(payload)
         push_opts=PushOptions(callbacks=RemoteCallbacks(credentials_cb(), payload))
         push(rmt, refspecs, force=force, options=push_opts)
     finally
@@ -296,6 +326,7 @@ end
 
 Checkout a new git branch in the `repo` repository. `commit` is the [`GitHash`](@ref),
 in string form, which will be the start of the new branch.
+If `commit` is an empty string, the current HEAD will be used.
 
 The keyword arguments are:
   * `track::AbstractString=""`: the name of the
@@ -308,6 +339,12 @@ The keyword arguments are:
     finishes the branch head will be set as the HEAD of `repo`.
 
 Equivalent to `git checkout [-b|-B] <branch_name> [<commit>] [--track <track>]`.
+
+# Examples
+```julia
+repo = LibGit2.GitRepo(repo_path)
+LibGit2.branch!(repo, "new_branch", set_head=false)
+```
 """
 function branch!(repo::GitRepo, branch_name::AbstractString,
                  commit::AbstractString = ""; # start point
@@ -382,6 +419,22 @@ Equivalent to `git checkout [-f] --detach <commit>`.
 Checkout the git commit `commit` (a [`GitHash`](@ref) in string form)
 in `repo`. If `force` is `true`, force the checkout and discard any
 current changes. Note that this detaches the current HEAD.
+
+# Examples
+```julia
+repo = LibGit2.init(repo_path)
+open(joinpath(LibGit2.path(repo), "file1"), "w") do f
+    write(f, "111\n")
+end
+LibGit2.add!(repo, "file1")
+commit_oid = LibGit2.commit(repo, "add file1")
+open(joinpath(LibGit2.path(repo), "file1"), "w") do f
+    write(f, "112\n")
+end
+# would fail without the force=true
+# since there are modifications to the file
+LibGit2.checkout!(repo, string(commit_oid), force=true)
+```
 """
 function checkout!(repo::GitRepo, commit::AbstractString = "";
                   force::Bool = true)
@@ -403,15 +456,15 @@ function checkout!(repo::GitRepo, commit::AbstractString = "";
     # search for commit to get a commit object
     obj = GitObject(repo, GitHash(commit))
     peeled = peel(GitCommit, obj)
-
-    opts = force ? CheckoutOptions(checkout_strategy = Consts.CHECKOUT_FORCE) : CheckoutOptions()
-    # detach commit
     obj_oid = GitHash(peeled)
-    ref = GitReference(repo, obj_oid, force=force,
-                       msg="libgit2.checkout: moving from $head_name to $(string(obj_oid))")
 
     # checkout commit
-    checkout_tree(repo, peeled, options = opts)
+    checkout_tree(repo, peeled, options = force ? CheckoutOptions(checkout_strategy = Consts.CHECKOUT_FORCE) : CheckoutOptions())
+
+    GitReference(repo, obj_oid, force=force,
+                 msg="libgit2.checkout: moving from $head_name to $(obj_oid))")
+
+    return nothing
 end
 
 """
@@ -434,6 +487,15 @@ The keyword arguments are:
     repository.
 
 Equivalent to `git clone [-b <branch>] [--bare] <repo_url> <repo_path>`.
+
+# Examples
+```julia
+repo_url = "https://github.com/JuliaLang/Example.jl"
+repo1 = LibGit2.clone(repo_url, "test_path")
+repo2 = LibGit2.clone(repo_url, "test_path", isbare=true)
+julia_url = "https://github.com/JuliaLang/julia"
+julia_repo = LibGit2.clone(julia_url, "julia_path", branch="release-0.6")
+```
 """
 function clone(repo_url::AbstractString, repo_path::AbstractString;
                branch::AbstractString="",
@@ -442,7 +504,6 @@ function clone(repo_url::AbstractString, repo_path::AbstractString;
                payload::Nullable{<:AbstractCredentials}=Nullable{AbstractCredentials}())
     # setup clone options
     lbranch = Base.cconvert(Cstring, branch)
-    payload = make_payload(payload)
     fetch_opts=FetchOptions(callbacks = RemoteCallbacks(credentials_cb(), payload))
     clone_opts = CloneOptions(
                 bare = Cint(isbare),
@@ -470,30 +531,61 @@ set by `mode`:
   3. `Consts.RESET_HARD` - move HEAD to `id`, reset the index to `id`, and discard all working changes.
 
 Equivalent to `git reset [--soft | --mixed | --hard] <id>`.
+
+# Examples
+```julia
+repo = LibGit2.GitRepo(repo_path)
+head_oid = LibGit2.head_oid(repo)
+open(joinpath(repo_path, "file1"), "w") do f
+    write(f, "111\n")
+end
+LibGit2.add!(repo, "file1")
+mode = LibGit2.Consts.RESET_HARD
+# will discard the changes to file1
+# and unstage it
+new_head = LibGit2.reset!(repo, head_oid, mode)
+```
 """
 reset!(repo::GitRepo, id::GitHash, mode::Cint = Consts.RESET_MIXED) =
     reset!(repo, GitObject(repo, id), mode)
 
-""" git cat-file <commit> """
-function cat(repo::GitRepo, spec)
-    obj = GitObject(repo, spec)
-    if isa(obj, GitBlob)
-        content(obj)
-    else
-        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))
+"""
+    LibGit2.revcount(repo::GitRepo, commit1::AbstractString, commit2::AbstractString)
+
+List the number of revisions between `commit1` and `commit2` (committish OIDs in string form).
+Since `commit1` and `commit2` may be on different branches, `revcount` performs a "left-right"
+revision list (and count), returning a tuple of `Int`s - the number of left and right
+commits, respectively. A left (or right) commit refers to which side of a symmetric
+difference in a tree the commit is reachable from.
+
+Equivalent to `git rev-list --left-right --count <commit1> <commit2>`.
+
+# Examples
+```julia
+repo = LibGit2.GitRepo(repo_path)
+repo_file = open(joinpath(repo_path, test_file), "a")
+println(repo_file, "hello world")
+flush(repo_file)
+LibGit2.add!(repo, test_file)
+commit_oid1 = LibGit2.commit(repo, "commit 1")
+println(repo_file, "hello world again")
+flush(repo_file)
+LibGit2.add!(repo, test_file)
+commit_oid2 = LibGit2.commit(repo, "commit 2")
+LibGit2.revcount(repo, string(commit_oid1), string(commit_oid2))
+```
+
+This will return `(-1, 0)`.
+"""
+function revcount(repo::GitRepo, commit1::AbstractString, commit2::AbstractString)
+    commit1_id = revparseid(repo, commit1)
+    commit2_id = revparseid(repo, commit2)
+    base_id = merge_base(repo, string(commit1_id), string(commit2_id))
     fc = with(GitRevWalker(repo)) do walker
-        count((i,r)->i!=base_id, walker, oid=fst_id, by=Consts.SORT_TOPOLOGICAL)
+        count((i,r)->i!=base_id, walker, oid=commit1_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)
+        count((i,r)->i!=base_id, walker, oid=commit2_id, by=Consts.SORT_TOPOLOGICAL)
     end
     return (fc-1, sc-1)
 end
@@ -519,6 +611,12 @@ The keyword arguments are:
     options for the checkout step.
 
 Equivalent to `git merge [--ff-only] [<committish> | <branch>]`.
+
+!!! note
+    If you specify a `branch`, this must be done in reference format, since
+    the string will be turned into a `GitReference`. For example, if you
+    wanted to merge branch `branch_a`, you would call
+    `merge!(repo, branch="refs/heads/branch_a")`.
 """
 function merge!(repo::GitRepo;
                 committish::AbstractString = "",
@@ -667,6 +765,25 @@ end
     authors(repo::GitRepo) -> Vector{Signature}
 
 Returns all authors of commits to the `repo` repository.
+
+# Examples
+```julia
+repo = LibGit2.GitRepo(repo_path)
+repo_file = open(joinpath(repo_path, test_file), "a")
+
+println(repo_file, commit_msg)
+flush(repo_file)
+LibGit2.add!(repo, test_file)
+sig = LibGit2.Signature("TEST", "TEST@TEST.COM", round(time(), 0), 0)
+commit_oid1 = LibGit2.commit(repo, "commit1"; author=sig, committer=sig)
+println(repo_file, randstring(10))
+flush(repo_file)
+LibGit2.add!(repo, test_file)
+commit_oid2 = LibGit2.commit(repo, "commit2"; author=sig, committer=sig)
+
+# will be a Vector of [sig, sig]
+auths = LibGit2.authors(repo)
+```
 """
 function authors(repo::GitRepo)
     return with(GitRevWalker(repo)) do walker
@@ -741,33 +858,13 @@ function set_ssl_cert_locations(cert_loc)
     cert_file = isfile(cert_loc) ? cert_loc : Cstring(C_NULL)
     cert_dir  = isdir(cert_loc) ? cert_loc : Cstring(C_NULL)
     cert_file == C_NULL && cert_dir == C_NULL && return
-    # TODO FIX https://github.com/libgit2/libgit2/pull/3935#issuecomment-253910017
-    #ccall((:git_libgit2_opts, :libgit2), Cint,
-    #      (Cint, Cstring, Cstring),
-    #      Cint(Consts.SET_SSL_CERT_LOCATIONS), cert_file, cert_dir)
-    ENV["SSL_CERT_FILE"] = cert_file
-    ENV["SSL_CERT_DIR"] = cert_dir
+    @check ccall((:git_libgit2_opts, :libgit2), Cint,
+          (Cint, Cstring, Cstring),
+          Cint(Consts.SET_SSL_CERT_LOCATIONS), cert_file, cert_dir)
 end
 
 function __init__()
-    # Look for OpenSSL env variable for CA bundle (linux only)
-    # windows and macOS use the OS native security backends
-    old_ssl_cert_dir = Base.get(ENV, "SSL_CERT_DIR", nothing)
-    old_ssl_cert_file = Base.get(ENV, "SSL_CERT_FILE", nothing)
-    @static if is_linux()
-        cert_loc = if "SSL_CERT_DIR" in keys(ENV)
-            ENV["SSL_CERT_DIR"]
-        elseif "SSL_CERT_FILE" in keys(ENV)
-            ENV["SSL_CERT_FILE"]
-        else
-            # If we have a bundled ca cert file, point libgit2 at that so SSL connections work.
-            abspath(ccall(:jl_get_julia_home, Any, ()),Base.DATAROOTDIR,"julia","cert.pem")
-        end
-        set_ssl_cert_locations(cert_loc)
-    end
-
-    err = ccall((:git_libgit2_init, :libgit2), Cint, ())
-    err > 0 || throw(ErrorException("error initializing LibGit2 module"))
+    @check ccall((:git_libgit2_init, :libgit2), Cint, ())
     REFCOUNT[] = 1
 
     atexit() do
@@ -777,21 +874,18 @@ function __init__()
         end
     end
 
-    @static if is_linux()
-        if old_ssl_cert_dir != Base.get(ENV, "SSL_CERT_DIR", "")
-            if old_ssl_cert_dir === nothing
-                delete!(ENV, "SSL_CERT_DIR")
-            else
-                ENV["SSL_CERT_DIR"] = old_ssl_cert_dir
-            end
-        end
-        if old_ssl_cert_file != Base.get(ENV, "SSL_CERT_FILE", "")
-            if old_ssl_cert_file === nothing
-                delete!(ENV, "SSL_CERT_FILE")
-            else
-                ENV["SSL_CERT_FILE"] = old_ssl_cert_file
-            end
+    # Look for OpenSSL env variable for CA bundle (linux only)
+    # windows and macOS use the OS native security backends
+    @static if Sys.islinux()
+        cert_loc = if "SSL_CERT_DIR" in keys(ENV)
+            ENV["SSL_CERT_DIR"]
+        elseif "SSL_CERT_FILE" in keys(ENV)
+            ENV["SSL_CERT_FILE"]
+        else
+            # If we have a bundled ca cert file, point libgit2 at that so SSL connections work.
+            abspath(ccall(:jl_get_julia_home, Any, ()), Base.DATAROOTDIR, "julia", "cert.pem")
         end
+        set_ssl_cert_locations(cert_loc)
     end
 end
 
diff --git a/base/libgit2/merge.jl b/base/libgit2/merge.jl
index 9031c2bf75fc1d..4a85128e6500d2 100644
--- a/base/libgit2/merge.jl
+++ b/base/libgit2/merge.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 function GitAnnotated(repo::GitRepo, commit_id::GitHash)
     ann_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
@@ -45,7 +45,11 @@ function merge_analysis(repo::GitRepo, anns::Vector{GitAnnotated})
     return analysis[], preference[]
 end
 
-"""Fastforward merge changes into current head """
+"""
+    ffmerge!(repo::GitRepo, ann::GitAnnotated)
+
+Fastforward merge changes into current head
+"""
 function ffmerge!(repo::GitRepo, ann::GitAnnotated)
     cmt = GitCommit(repo, GitHash(ann))
 
@@ -63,7 +67,7 @@ function ffmerge!(repo::GitRepo, ann::GitAnnotated)
     return true
 end
 
-""" Merge changes into current head """
+# Merge changes into current head
 function merge!(repo::GitRepo, anns::Vector{GitAnnotated};
                 merge_opts::MergeOptions = MergeOptions(),
                 checkout_opts::CheckoutOptions = CheckoutOptions())
@@ -71,15 +75,14 @@ function merge!(repo::GitRepo, anns::Vector{GitAnnotated};
     @check ccall((:git_merge, :libgit2), Cint,
                   (Ptr{Void}, Ptr{Ptr{Void}}, Csize_t,
                    Ptr{MergeOptions}, Ptr{CheckoutOptions}),
-                   repo.ptr, anns, anns_size,
+                   repo.ptr, map(x->x.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`
-"""
+# 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())
diff --git a/base/libgit2/oid.jl b/base/libgit2/oid.jl
index 351a4584da26da..3e369a1358349a 100644
--- a/base/libgit2/oid.jl
+++ b/base/libgit2/oid.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 function GitHash(ptr::Ptr{UInt8})
     if ptr == C_NULL
@@ -9,6 +9,11 @@ function GitHash(ptr::Ptr{UInt8})
     return oid_ptr[]
 end
 
+"""
+    GitHash(id::Vector{UInt8})
+
+Construct a `GitHash` from a vector of $OID_RAWSZ bytes.
+"""
 function GitHash(id::Array{UInt8,1})
     if length(id) != OID_RAWSZ
         throw(ArgumentError("invalid raw buffer size"))
@@ -16,6 +21,11 @@ function GitHash(id::Array{UInt8,1})
     return GitHash(pointer(id))
 end
 
+"""
+    GitHash(id::AbstractString)
+
+Construct a `GitHash` from a string of $OID_HEXSZ hexadecimal digits.
+"""
 function GitHash(id::AbstractString)
     bstr = String(id)
     len = sizeof(bstr)
@@ -27,6 +37,19 @@ function GitHash(id::AbstractString)
               (Ptr{GitHash}, Ptr{UInt8}, Csize_t), oid_ptr, bstr, len)
     return oid_ptr[]
 end
+
+function GitShortHash(buf::Buffer)
+    oid_ptr = Ref{GitHash}()
+    @check ccall((:git_oid_fromstrn, :libgit2), Cint,
+              (Ptr{GitHash}, Ptr{UInt8}, Csize_t), oid_ptr, buf.ptr, buf.size)
+    GitShortHash(oid_ptr[], buf.size)
+end
+
+"""
+    GitShortHash(id::AbstractString)
+
+Construct a `GitShortHash` from a string of at most $OID_HEXSZ hexadecimal digits.
+"""
 function GitShortHash(id::AbstractString)
     bstr = String(id)
     len = sizeof(bstr)
@@ -44,6 +67,15 @@ macro githash_str(id)
         GitHash(id)
     end
 end
+
+
+"""
+    GitHash(ref::GitReference)
+
+Get the identifier (`GitHash`) of the object referred to by the direct reference
+`ref`. Note: this does not work for symbolic references; in such cases use
+`GitHash(repo::GitRepo, ref_name::AbstractString)` instead.
+"""
 function GitHash(ref::GitReference)
     isempty(ref) && return GitHash()
     reftype(ref) != Consts.REF_OID && return GitHash()
@@ -52,6 +84,13 @@ function GitHash(ref::GitReference)
     return GitHash(oid_ptr)
 end
 
+
+"""
+    GitHash(repo::GitRepo, ref_name::AbstractString)
+
+Get the identifier (`GitHash`) of the object referred to by reference specified by
+`ref_name`.
+"""
 function GitHash(repo::GitRepo, ref_name::AbstractString)
     isempty(repo) && return GitHash()
     oid_ptr  = Ref(GitHash())
@@ -61,10 +100,31 @@ function GitHash(repo::GitRepo, ref_name::AbstractString)
     return oid_ptr[]
 end
 
+"""
+    GitHash(obj::GitObject)
+
+Get the identifier (`GitHash`) of `obj`.
+"""
 function GitHash(obj::GitObject)
     GitHash(ccall((:git_object_id, :libgit2), Ptr{UInt8}, (Ptr{Void},), obj.ptr))
 end
 
+"""
+    GitShortHash(obj::GitObject)
+
+Get a shortened identifier (`GitShortHash`) of `obj`. The minimum length (in characters)
+is determined by the `core.abbrev` config option, and will be of sufficient length to
+unambiuously identify the object in the repository.
+"""
+function GitShortHash(obj::GitObject)
+    buf_ref = Ref(Buffer())
+    @check ccall((:git_object_short_id, :libgit2), Cint,
+                 (Ptr{Buffer},Ptr{Void}), buf_ref, obj.ptr)
+    sid = GitShortHash(buf_ref[])
+    free(buf_ref)
+    return sid
+end
+
 Base.hex(id::GitHash) = join([hex(i,2) for i in id.val])
 Base.hex(id::GitShortHash) = hex(id.hash)[1:id.len]
 
diff --git a/base/libgit2/rebase.jl b/base/libgit2/rebase.jl
index d89738d89672a8..18441532416cec 100644
--- a/base/libgit2/rebase.jl
+++ b/base/libgit2/rebase.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 function GitRebase(repo::GitRepo, branch::GitAnnotated, upstream::GitAnnotated;
                    onto::Nullable{GitAnnotated}=Nullable{GitAnnotated}(),
@@ -16,15 +16,25 @@ function Base.count(rb::GitRebase)
     return ccall((:git_rebase_operation_entrycount, :libgit2), Csize_t, (Ptr{Void},), rb.ptr)
 end
 
+"""
+    current(rb::GitRebase) -> Csize_t
+
+Return the index of the current [`RebaseOperation`](@ref). If no operation has
+yet been applied (because the [`GitRebase`](@ref) has been constructed but `next`
+has not yet been called or iteration over `rb` has not yet begun), return
+`GIT_REBASE_NO_OPERATION`, which is equal to `typemax(Csize_t)`.
+"""
 function current(rb::GitRebase)
     return ccall((:git_rebase_operation_current, :libgit2), Csize_t, (Ptr{Void},), rb.ptr)
 end
 
 function Base.getindex(rb::GitRebase, i::Integer)
+    if !(1 <= i <= count(rb))
+        throw(BoundsError(rb, (i,)))
+    end
     rb_op_ptr = ccall((:git_rebase_operation_byindex, :libgit2),
                       Ptr{RebaseOperation},
                       (Ptr{Void}, Csize_t), rb.ptr, i-1)
-    rb_op_ptr == C_NULL && return nothing
     return unsafe_load(rb_op_ptr)
 end
 
@@ -41,11 +51,16 @@ function Base.next(rb::GitRebase)
     return unsafe_load(rb_op_ptr_ptr[])
 end
 
+function Base.show(io::IO, rb::GitRebase)
+    println(io, "GitRebase:")
+    println(io, "Number: ", count(rb))
+    println(io, "Currently performing operation: ", current(rb)+1)
+end
 
 """
     LibGit2.commit(rb::GitRebase, sig::GitSignature)
 
-Commits the current patch to the rebase `rb`, using `sig` as the committer. Is silent if
+Commit the current patch to the rebase `rb`, using `sig` as the committer. Is silent if
 the commit has already been applied.
 """
 function commit(rb::GitRebase, sig::GitSignature)
@@ -62,11 +77,27 @@ function commit(rb::GitRebase, sig::GitSignature)
     return oid_ptr[]
 end
 
+"""
+    abort(rb::GitRebase) -> Csize_t
+
+Cancel the in-progress rebase, undoing all changes made so far and returning
+the parent repository of `rb` and its working directory to their state before
+the rebase was initiated. Returns `0` if the abort is successful,
+`LibGit2.Error.ENOTFOUND` if no rebase is in progress (for example, if the
+rebase had completed), and `-1` for other errors.
+"""
 function abort(rb::GitRebase)
     return ccall((:git_rebase_abort, :libgit2), Csize_t,
                       (Ptr{Void},), rb.ptr)
 end
 
+"""
+    finish(rb::GitRebase, sig::GitSignature) -> Csize_t
+
+Complete the rebase described by `rb`. `sig` is a [`GitSignature`](@ref)
+to specify the identity of the user finishing the rebase. Returns `0` if the
+rebase finishes successfully, `-1` if there is an error.
+"""
 function finish(rb::GitRebase, sig::GitSignature)
     return ccall((:git_rebase_finish, :libgit2), Csize_t,
                   (Ptr{Void}, Ptr{SignatureStruct}),
diff --git a/base/libgit2/reference.jl b/base/libgit2/reference.jl
index 5158ca4d339b96..3a8c32929cc336 100644
--- a/base/libgit2/reference.jl
+++ b/base/libgit2/reference.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 function GitReference(repo::GitRepo, refname::AbstractString)
     ref_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
@@ -48,7 +48,7 @@ end
 Returns a shortened version of the name of `ref` that's
 "human-readable".
 
-```julia
+```julia-repl
 julia> repo = LibGit2.GitRepo(path_to_repo);
 
 julia> branch_ref = LibGit2.head(repo);
@@ -162,16 +162,20 @@ end
     peel([T,] ref::GitReference)
 
 Recursively peel `ref` until an object of type `T` is obtained. If no `T` is provided,
-then `ref` will be peeled until an object other than a `GitTag` is obtained.
+then `ref` will be peeled until an object other than a [`GitTag`](@ref) is obtained.
 
 - A `GitTag` will be peeled to the object it references.
-- A `GitCommit` will be peeled to a `GitTree`.
+- A [`GitCommit`](@ref) will be peeled to a [`GitTree`](@ref).
+
+!!! note
+    Only annotated tags can be peeled to `GitTag` objects. Lightweight tags (the default)
+    are references under `refs/tags/` which point directly to `GitCommit` objects.
 """
-function peel{T<:GitObject}(::Type{T}, ref::GitReference)
+function peel(::Type{T}, ref::GitReference) where T<:GitObject
     obj_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
     @check ccall((:git_reference_peel, :libgit2), Cint,
                  (Ptr{Ptr{Void}}, Ptr{Void}, Cint), obj_ptr_ptr, ref.ptr, Consts.OBJECT(T))
-    return T(ref.repo, obj_ptr_ptr[])
+    return T(ref.owner, obj_ptr_ptr[])
 end
 peel(ref::GitReference) = peel(GitObject, ref)
 
@@ -280,21 +284,21 @@ function upstream(ref::GitReference)
             return Nullable{GitReference}()
         end
         if ref_ptr_ptr[] != C_NULL
-            close(GitReference(ref.repo, ref_ptr_ptr[]))
+            close(GitReference(ref.owner, ref_ptr_ptr[]))
         end
         throw(Error.GitError(err))
     end
-    return Nullable{GitReference}(GitReference(ref.repo, ref_ptr_ptr[]))
+    return Nullable{GitReference}(GitReference(ref.owner, ref_ptr_ptr[]))
 end
 
-repository(ref::GitReference) = ref.repo
+repository(ref::GitReference) = ref.owner
 
 function target!(ref::GitReference, new_oid::GitHash; msg::AbstractString="")
     ref_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
     @check ccall((:git_reference_set_target, :libgit2), Cint,
              (Ptr{Ptr{Void}}, Ptr{Void}, Ptr{GitHash}, Cstring),
              ref_ptr_ptr, ref.ptr, Ref(new_oid), isempty(msg) ? C_NULL : msg)
-    return GitReference(ref.repo, ref_ptr_ptr[])
+    return GitReference(ref.owner, ref_ptr_ptr[])
 end
 
 function GitBranchIter(repo::GitRepo, flags::Cint=Cint(Consts.BRANCH_LOCAL))
@@ -311,7 +315,7 @@ function Base.start(bi::GitBranchIter)
                  (Ptr{Ptr{Void}}, Ptr{Cint}, Ptr{Void}),
                   ref_ptr_ptr, btype, bi.ptr)
     err != Int(Error.GIT_OK) && return (nothing, -1, true)
-    return (GitReference(bi.repo, ref_ptr_ptr[]), btype[], false)
+    return (GitReference(bi.owner, ref_ptr_ptr[]), btype[], false)
 end
 
 Base.done(bi::GitBranchIter, state) = Bool(state[3])
@@ -323,7 +327,7 @@ function Base.next(bi::GitBranchIter, state)
                  (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(bi.repo, ref_ptr_ptr[]), btype[], false))
+    return (state[1:2], (GitReference(bi.owner, ref_ptr_ptr[]), btype[], false))
 end
 
 Base.iteratorsize(::Type{GitBranchIter}) = Base.SizeUnknown()
@@ -334,7 +338,7 @@ function Base.map(f::Function, bi::GitBranchIter)
     while !done(bi, s)
         val = f(s[1:2])
         if res === nothing
-            res = Array{typeof(val)}(0)
+            res = Vector{typeof(val)}(0)
         end
         push!(res, val)
         val, s = next(bi, s)
diff --git a/base/libgit2/remote.jl b/base/libgit2/remote.jl
index 4ba586ea862d66..df80810fb02316 100644
--- a/base/libgit2/remote.jl
+++ b/base/libgit2/remote.jl
@@ -1,9 +1,15 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 """
     GitRemote(repo::GitRepo, rmt_name::AbstractString, rmt_url::AbstractString) -> GitRemote
 
 Look up a remote git repository using its name and URL. Uses the default fetch refspec.
+
+# Examples
+```julia
+repo = LibGit2.init(repo_path)
+remote = LibGit2.GitRemote(repo, "upstream", repo_url)
+```
 """
 function GitRemote(repo::GitRepo, rmt_name::AbstractString, rmt_url::AbstractString)
     rmt_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
@@ -19,6 +25,13 @@ end
 Look up a remote git repository using the repository's name and URL,
 as well as specifications for how to fetch from the remote
 (e.g. which remote branch to fetch from).
+
+# Examples
+```julia
+repo = LibGit2.init(repo_path)
+refspec = "+refs/heads/mybranch:refs/remotes/origin/mybranch"
+remote = LibGit2.GitRemote(repo, "upstream", repo_url, refspec)
+```
 """
 function GitRemote(repo::GitRepo, rmt_name::AbstractString, rmt_url::AbstractString, fetch_spec::AbstractString)
     rmt_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
@@ -32,6 +45,12 @@ end
     GitRemoteAnon(repo::GitRepo, url::AbstractString) -> GitRemote
 
 Look up a remote git repository using only its URL, not its name.
+
+# Examples
+```julia
+repo = LibGit2.init(repo_path)
+remote = LibGit2.GitRemoteAnon(repo, repo_url)
+```
 """
 function GitRemoteAnon(repo::GitRepo, url::AbstractString)
     rmt_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
@@ -41,6 +60,34 @@ function GitRemoteAnon(repo::GitRepo, url::AbstractString)
     return GitRemote(repo, rmt_ptr_ptr[])
 end
 
+"""
+    lookup_remote(repo::GitRepo, remote_name::AbstractString) -> Nullable{GitRemote}
+
+Determine if the `remote_name` specified exists within the `repo`. Returns a
+[`Nullable`](@ref), which will be null if the requested remote does not exist. If the remote
+does exist, the `Nullable` contains a [`GitRemote`](@ref) to the remote name.
+
+# Examples
+```julia
+repo = LibGit2.GitRepo(path)
+remote_name = "test"
+isnull(LibGit2.lookup_remote(repo, remote_name)) # will return true
+```
+"""
+function lookup_remote(repo::GitRepo, remote_name::AbstractString)
+    rmt_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
+    err = ccall((:git_remote_lookup, :libgit2), Cint,
+                (Ptr{Ptr{Void}}, Ptr{Void}, Cstring),
+                rmt_ptr_ptr, repo.ptr, remote_name)
+    if err == Int(Error.GIT_OK)
+        return Nullable{GitRemote}(GitRemote(repo, rmt_ptr_ptr[]))
+    elseif err == Int(Error.ENOTFOUND)
+        return Nullable{GitRemote}()
+    else
+        throw(Error.GitError(err))
+    end
+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,
@@ -52,10 +99,45 @@ end
 """
     url(rmt::GitRemote)
 
-Get the URL of a remote git repository.
+Get the fetch URL of a remote git repository.
+
+# Examples
+```julia-repl
+julia> repo_url = "https://github.com/JuliaLang/Example.jl";
+
+julia> repo = LibGit2.init(mktempdir());
+
+julia> remote = LibGit2.GitRemote(repo, "origin", repo_url);
+
+julia> LibGit2.url(remote)
+"https://github.com/JuliaLang/Example.jl"
+```
 """
 function url(rmt::GitRemote)
-    url_ptr = ccall((:git_remote_url, :libgit2), Cstring, (Ptr{Void}, ), rmt.ptr)
+    url_ptr = ccall((:git_remote_url, :libgit2), Cstring, (Ptr{Void},), rmt.ptr)
+    url_ptr == C_NULL && return ""
+    return unsafe_string(url_ptr)
+end
+
+"""
+    push_url(rmt::GitRemote)
+
+Get the push URL of a remote git repository.
+
+# Examples
+```julia-repl
+julia> repo_url = "https://github.com/JuliaLang/Example.jl";
+
+julia> repo = LibGit2.init(mktempdir());
+
+julia> LibGit2.set_remote_push_url(repo, "origin", repo_url);
+
+julia> LibGit2.push_url(LibGit2.get(LibGit2.GitRemote, repo, "origin"))
+"https://github.com/JuliaLang/Example.jl"
+```
+"""
+function push_url(rmt::GitRemote)
+    url_ptr = ccall((:git_remote_pushurl, :libgit2), Cstring, (Ptr{Void},), rmt.ptr)
     url_ptr == C_NULL && return ""
     return unsafe_string(url_ptr)
 end
@@ -66,9 +148,21 @@ end
 Get the name of a remote repository, for instance `"origin"`.
 If the remote is anonymous (see [`GitRemoteAnon`](@ref))
 the name will be an empty string `""`.
+
+# Examples
+```julia-repl
+julia> repo_url = "https://github.com/JuliaLang/Example.jl";
+
+julia> repo = LibGit2.clone(cache_repo, "test_directory");
+
+julia> remote = LibGit2.GitRemote(repo, "origin", repo_url);
+
+julia> name(remote)
+"origin"
+```
 """
 function name(rmt::GitRemote)
-    name_ptr = ccall((:git_remote_name, :libgit2), Cstring, (Ptr{Void}, ), rmt.ptr)
+    name_ptr = ccall((:git_remote_name, :libgit2), Cstring, (Ptr{Void},), rmt.ptr)
     name_ptr == C_NULL && return ""
     return unsafe_string(name_ptr)
 end
@@ -78,6 +172,16 @@ end
 
 Get the *fetch* refspecs for the specified `rmt`. These refspecs contain
 information about which branch(es) to fetch from.
+
+# Examples
+```julia-repl
+julia> remote = LibGit2.get(LibGit2.GitRemote, repo, "upstream");
+
+julia> LibGit2.add_fetch!(repo, remote, "upstream");
+
+julia> LibGit2.fetch_refspecs(remote)
+String["+refs/heads/*:refs/remotes/upstream/*"]
+```
 """
 function fetch_refspecs(rmt::GitRemote)
     sa_ref = Ref(StrArrayStruct())
@@ -93,6 +197,20 @@ end
 
 Get the *push* refspecs for the specified `rmt`. These refspecs contain
 information about which branch(es) to push to.
+
+# Examples
+```julia-repl
+julia> remote = LibGit2.get(LibGit2.GitRemote, repo, "upstream");
+
+julia> LibGit2.add_push!(repo, remote, "refs/heads/master");
+
+julia> close(remote);
+
+julia> remote = LibGit2.get(LibGit2.GitRemote, repo, "upstream");
+
+julia> LibGit2.push_refspecs(remote)
+String["refs/heads/master"]
+```
 """
 function push_refspecs(rmt::GitRemote)
     sa_ref = Ref(StrArrayStruct())
@@ -103,6 +221,54 @@ function push_refspecs(rmt::GitRemote)
     res
 end
 
+"""
+    add_fetch!(repo::GitRepo, rmt::GitRemote, fetch_spec::String)
+
+Add a *fetch* refspec for the specified `rmt`. This refspec will contain
+information about which branch(es) to fetch from.
+
+# Examples
+```julia-repl
+julia> LibGit2.add_fetch!(repo, remote, "upstream");
+
+julia> LibGit2.fetch_refspecs(remote)
+String["+refs/heads/*:refs/remotes/upstream/*"]
+```
+"""
+function add_fetch!(repo::GitRepo, rmt::GitRemote, fetch_spec::String)
+    @check ccall((:git_remote_add_fetch, :libgit2), Cint,
+                 (Ptr{Void}, Cstring, Cstring), repo.ptr,
+                 name(rmt), fetch_spec)
+end
+
+"""
+    add_push!(repo::GitRepo, rmt::GitRemote, push_spec::String)
+
+Add a *push* refspec for the specified `rmt`. This refspec will contain
+information about which branch(es) to push to.
+
+# Examples
+```julia-repl
+julia> LibGit2.add_push!(repo, remote, "refs/heads/master");
+
+julia> remote = LibGit2.get(LibGit2.GitRemote, repo, branch);
+
+julia> LibGit2.push_refspecs(remote)
+String["refs/heads/master"]
+```
+
+!!! note
+    You may need to [`close`](@ref) and reopen the `GitRemote`
+    in question after updating its push refspecs in order for
+    the change to take effect and for calls to [`push`](@ref)
+    to work.
+"""
+function add_push!(repo::GitRepo, rmt::GitRemote, push_spec::String)
+    @check ccall((:git_remote_add_push, :libgit2), Cint,
+                 (Ptr{Void}, Cstring, Cstring), repo.ptr,
+                 name(rmt), push_spec)
+end
+
 """
     fetch(rmt::GitRemote, refspecs; options::FetchOptions=FetchOptions(), msg="")
 
@@ -129,6 +295,13 @@ determine which remote branch(es) to push to.
 The keyword arguments are:
   * `force`: if `true`, a force-push will occur, disregarding conflicts.
   * `options`: determines the options for the push, e.g. which proxy headers to use.
+
+!!! note
+    You can add information about the push refspecs in two other ways: by setting
+    an option in the repository's `GitConfig` (with `push.default` as the key) or
+    by calling [`add_push!`](@ref). Otherwise you will need to explicitly specify
+    a push refspec in the call to `push` for it to have any effect, like so:
+    `LibGit2.push(repo, refspecs=["refs/heads/master"])`.
 """
 function push(rmt::GitRemote, refspecs::Vector{<:AbstractString};
               force::Bool = false, options::PushOptions = PushOptions())
@@ -137,4 +310,88 @@ function push(rmt::GitRemote, refspecs::Vector{<:AbstractString};
                  rmt.ptr, isempty(refspecs) ? C_NULL : refspecs, Ref(options))
 end
 
+"""
+    remote_delete(repo::GitRepo, remote_name::AbstractString) -> Void
+
+Delete the `remote_name` from the git `repo`.
+"""
+function remote_delete(repo::GitRepo, remote_name::AbstractString)
+    @check ccall((:git_remote_delete, :libgit2), Cint,
+                 (Ptr{Void}, Cstring),
+                 repo.ptr, remote_name)
+end
+
 Base.show(io::IO, rmt::GitRemote) = print(io, "GitRemote:\nRemote name: ", name(rmt), " url: ", url(rmt))
+
+
+"""
+    set_remote_fetch_url(repo::GitRepo, remote_name, url)
+    set_remote_fetch_url(path::String, remote_name, url)
+
+Set the fetch `url` for the specified `remote_name` for the GitRepo or the git repository
+located at `path`. Typically git repos use "origin" as the remote name.
+"""
+function set_remote_fetch_url end
+
+function set_remote_fetch_url(repo::GitRepo, remote_name::AbstractString, url::AbstractString)
+    @check ccall((:git_remote_set_url, :libgit2), Cint,
+                 (Ptr{Void}, Cstring, Cstring),
+                 repo.ptr, remote_name, url)
+end
+
+function set_remote_fetch_url(path::AbstractString, remote_name::AbstractString, url::AbstractString)
+    with(GitRepo, path) do repo
+        set_remote_fetch_url(repo, remote_name, url)
+    end
+end
+
+
+"""
+    set_remote_push_url(repo::GitRepo, remote_name, url)
+    set_remote_push_url(path::String, remote_name, url)
+
+Set the push `url` for the specified `remote_name` for the GitRepo or the git repository
+located at `path`. Typically git repos use "origin" as the remote name.
+"""
+function set_remote_push_url end
+
+function set_remote_push_url(repo::GitRepo, remote_name::AbstractString, url::AbstractString)
+    @check ccall((:git_remote_set_pushurl, :libgit2), Cint,
+                 (Ptr{Void}, Cstring, Cstring),
+                 repo.ptr, remote_name, url)
+end
+
+function set_remote_push_url(path::AbstractString, remote_name::AbstractString, url::AbstractString)
+    with(GitRepo, path) do repo
+        set_remote_push_url(repo, remote_name, url)
+    end
+end
+
+
+"""
+    set_remote_url(repo::GitRepo, remote_name, url)
+    set_remote_url(repo::String, remote_name, url)
+
+Set both the fetch and push `url` for `remote_name` for the GitRepo or the git repository
+located at `path`. Typically git repos use "origin" as the remote name.
+
+# Examples
+```julia
+repo_path = joinpath(tempdir(), "Example")
+repo = LibGit2.init(repo_path)
+LibGit2.set_remote_url(repo, "upstream", "https://github.com/JuliaLang/Example.jl")
+LibGit2.set_remote_url(repo_path, "upstream2", "https://github.com/JuliaLang/Example2.jl")
+```
+"""
+function set_remote_url end
+
+function set_remote_url(repo::GitRepo, remote_name::AbstractString, url::AbstractString)
+    set_remote_fetch_url(repo, remote_name, url)
+    set_remote_push_url(repo, remote_name, url)
+end
+
+function set_remote_url(path::AbstractString, remote_name::AbstractString, url::AbstractString)
+    with(GitRepo, path) do repo
+        set_remote_url(repo, remote_name, url)
+    end
+end
diff --git a/base/libgit2/repository.jl b/base/libgit2/repository.jl
index 47ab7046339a27..84e7c70681665b 100644
--- a/base/libgit2/repository.jl
+++ b/base/libgit2/repository.jl
@@ -1,41 +1,29 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 """
     LibGit2.GitRepo(path::AbstractString)
 
-Opens a git repository at `path`.
+Open a git repository at `path`.
 """
 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
-            close(GitRepo(repo_ptr_ptr[]))
-        end
-        throw(Error.GitError(err))
-    end
+    @check ccall((:git_repository_open, :libgit2), Cint,
+                 (Ptr{Ptr{Void}}, Cstring), repo_ptr_ptr, path)
     return GitRepo(repo_ptr_ptr[])
 end
 
 """
     LibGit2.GitRepoExt(path::AbstractString, flags::Cuint = Cuint(Consts.REPOSITORY_OPEN_DEFAULT))
 
-Opens a git repository at `path` with extended controls (for instance, if the current
+Open a git repository at `path` with extended controls (for instance, if the current
 user must be a member of a special access group to read `path`).
 """
 function GitRepoExt(path::AbstractString, flags::Cuint = Cuint(Consts.REPOSITORY_OPEN_DEFAULT))
-    separator = @static is_windows() ? ";" : ":"
+    separator = @static Sys.iswindows() ? ";" : ":"
     repo_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
-    err = ccall((:git_repository_open_ext, :libgit2), Cint,
-                (Ptr{Ptr{Void}}, Cstring, Cuint, Cstring),
+    @check 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
-            close(GitRepo(repo_ptr_ptr[]))
-        end
-        throw(Error.GitError(err))
-    end
     return GitRepo(repo_ptr_ptr[])
 end
 
@@ -48,7 +36,7 @@ end
 """
     LibGit2.init(path::AbstractString, bare::Bool=false) -> GitRepo
 
-Opens a new git repository at `path`. If `bare` is `false`,
+Open a new git repository at `path`. If `bare` is `false`,
 the working tree will be created in `path/.git`. If `bare`
 is `true`, no working directory will be created.
 """
@@ -92,10 +80,26 @@ function headname(repo::GitRepo)
     end
 end
 
+"""
+    isbare(repo::GitRepo) -> Bool
+
+Determine if `repo` is bare. Suppose the top level directory of `repo` is `DIR`.
+A non-bare repository is one in which the git directory (see [`gitdir`](@ref)) is
+`DIR/.git`, and the working tree can be checked out. A bare repository is one in
+which all of git's administrative files are simply in `DIR`, rather than "hidden"
+in the `.git` subdirectory. This means that there is nowhere to check out the working
+tree, and no tracking information for remote branches or configurations is present.
+"""
 function isbare(repo::GitRepo)
     return ccall((:git_repository_is_bare, :libgit2), Cint, (Ptr{Void},), repo.ptr) == 1
 end
 
+"""
+    isattached(repo::GitRepo) -> Bool
+
+Determine if `repo` is detached - that is, whether its HEAD points to a commit
+(detached) or whether HEAD points to a branch tip (attached).
+"""
 function isattached(repo::GitRepo)
     ccall((:git_repository_head_detached, :libgit2), Cint, (Ptr{Void},), repo.ptr) != 1
 end
@@ -104,11 +108,11 @@ end
     GitObject(repo::GitRepo, hash::AbstractGitHash)
     GitObject(repo::GitRepo, spec::AbstractString)
 
-Return the specified object (`GitCommit`, `GitBlob`, `GitTree` or `GitTag`) from `repo`
+Return the specified object ([`GitCommit`](@ref), [`GitBlob`](@ref), [`GitTree`](@ref) or [`GitTag`](@ref)) from `repo`
 specified by `hash`/`spec`.
 
 - `hash` is a full (`GitHash`) or partial (`GitShortHash`) hash.
-- `spec` is a textual specification: see https://git-scm.com/docs/git-rev-parse.html#_specifying_revisions for a full list.
+- `spec` is a textual specification: see [the git docs](https://git-scm.com/docs/git-rev-parse.html#_specifying_revisions) for a full list.
 """ GitObject
 
 for T in (:GitCommit, :GitBlob, :GitTree, :GitTag)
@@ -119,11 +123,11 @@ for T in (:GitCommit, :GitBlob, :GitTree, :GitTag)
 Return a `$T` object from `repo` specified by `hash`/`spec`.
 
 - `hash` is a full (`GitHash`) or partial (`GitShortHash`) hash.
-- `spec` is a textual specification: see https://git-scm.com/docs/git-rev-parse.html#_specifying_revisions for a full list.
+- `spec` is a textual specification: see [the git docs](https://git-scm.com/docs/git-rev-parse.html#_specifying_revisions) for a full list.
 """ $T
 end
 
-function (::Type{T}){T<:GitObject}(repo::GitRepo, spec::AbstractString)
+function (::Type{T})(repo::GitRepo, spec::AbstractString) where T<:GitObject
     obj_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
     @check ccall((:git_revparse_single, :libgit2), Cint,
                  (Ptr{Ptr{Void}}, Ptr{Void}, Cstring), obj_ptr_ptr, repo.ptr, spec)
@@ -135,7 +139,7 @@ function (::Type{T}){T<:GitObject}(repo::GitRepo, spec::AbstractString)
     return T(repo, obj_ptr_ptr[])
 end
 
-function (::Type{T}){T<:GitObject}(repo::GitRepo, oid::GitHash)
+function (::Type{T})(repo::GitRepo, oid::GitHash) where T<:GitObject
     oid_ptr  = Ref(oid)
     obj_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
 
@@ -145,7 +149,7 @@ function (::Type{T}){T<:GitObject}(repo::GitRepo, oid::GitHash)
 
     return T(repo, obj_ptr_ptr[])
 end
-function (::Type{T}){T<:GitObject}(repo::GitRepo, oid::GitShortHash)
+function (::Type{T})(repo::GitRepo, oid::GitShortHash) where T<:GitObject
     oid_ptr  = Ref(oid.hash)
     obj_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
 
@@ -162,12 +166,12 @@ revparseid(repo::GitRepo, spec) = GitHash(GitUnknownObject(repo, spec))
 """
     LibGit2.gitdir(repo::GitRepo)
 
-Returns the location of the "git" files of `repo`:
+Return the location of the "git" files of `repo`:
 
  - for normal repositories, this is the location of the `.git` folder.
  - for bare repositories, this is the location of the repository itself.
 
-See also `workdir`, `path`
+See also [`workdir`](@ref), [`path`](@ref).
 """
 function gitdir(repo::GitRepo)
     return unsafe_string(ccall((:git_repository_path, :libgit2), Cstring,
@@ -177,8 +181,8 @@ end
 """
     LibGit2.workdir(repo::GitRepo)
 
-The location of the working directory of `repo`. This will throw an error for bare
-repositories.
+Return the location of the working directory of `repo`.
+This will throw an error for bare repositories.
 
 !!! note
 
@@ -186,7 +190,7 @@ repositories.
     some cases: e.g. if either the `core.worktree` configuration variable or the
     `GIT_WORK_TREE` environment variable is set.
 
-See also `gitdir`, `path`
+See also [`gitdir`](@ref), [`path`](@ref).
 """
 function workdir(repo::GitRepo)
     sptr = ccall((:git_repository_workdir, :libgit2), Cstring,
@@ -198,14 +202,14 @@ end
 """
     LibGit2.path(repo::GitRepo)
 
-The base file path of the repository `repo`.
+Return the base file path of the repository `repo`.
 
  - for normal repositories, this will typically be the parent directory of the ".git"
    directory (note: this may be different than the working directory, see `workdir` for
    more details).
  - for bare repositories, this is the location of the "git" files.
 
-See also `gitdir`, `workdir`.
+See also [`gitdir`](@ref), [`workdir`](@ref).
 """
 function path(repo::GitRepo)
     d = gitdir(repo)
@@ -229,16 +233,79 @@ then `obj` will be peeled until the type changes.
 - A `GitTag` will be peeled to the object it references.
 - A `GitCommit` will be peeled to a `GitTree`.
 """
-function peel{T<:GitObject}(::Type{T}, obj::GitObject)
+function peel(::Type{T}, obj::GitObject) where T<:GitObject
     new_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
 
     @check ccall((:git_object_peel, :libgit2), Cint,
                 (Ptr{Ptr{Void}}, Ptr{Void}, Cint), new_ptr_ptr, obj.ptr, Consts.OBJECT(T))
 
-    return T(obj.repo, new_ptr_ptr[])
+    return T(obj.owner, new_ptr_ptr[])
 end
 peel(obj::GitObject) = peel(GitObject, obj)
 
+"""
+    LibGit2.GitDescribeResult(commitish::GitObject; kwarg...)
+
+Produce a `GitDescribeResult` of the `commitish` `GitObject`, which
+contains detailed information about it based on the keyword argument:
+
+  * `options::DescribeOptions=DescribeOptions()`
+
+Equivalent to `git describe <commitish>`.
+"""
+function GitDescribeResult(commitish::GitObject;
+                           options::DescribeOptions=DescribeOptions())
+    result_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
+    @check ccall((:git_describe_commit, :libgit2), Cint,
+                 (Ptr{Ptr{Void}}, Ptr{Void}, Ptr{DescribeOptions}),
+                 result_ptr_ptr, commitish.ptr, Ref(options))
+    return GitDescribeResult(commitish.owner, result_ptr_ptr[])
+end
+
+"""
+    LibGit2.GitDescribeResult(repo::GitRepo; kwarg...)
+
+Produce a `GitDescribeResult` of the repository `repo`'s working directory,
+which can include all the commits and tags (or, for instance, HEAD only).
+The `GitDescribeResult` contains detailed information about the workdir based
+on the keyword argument:
+
+  * `options::DescribeOptions=DescribeOptions()`
+
+Equivalent to `git describe`.
+"""
+function GitDescribeResult(repo::GitRepo; options::DescribeOptions=DescribeOptions())
+    result_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
+    @check ccall((:git_describe_workdir, :libgit2), Cint,
+                 (Ptr{Ptr{Void}}, Ptr{Void}, Ptr{DescribeOptions}),
+                 result_ptr_ptr, repo.ptr, Ref(options))
+    return GitDescribeResult(repo, result_ptr_ptr[])
+end
+
+"""
+    LibGit2.format(result::GitDescribeResult; kwarg...) -> String
+
+Produce a formatted string based on a `GitDescribeResult`.
+Formatting options are controlled by the keyword argument:
+
+  * `options::DescribeFormatOptions=DescribeFormatOptions()`
+"""
+function format(result::GitDescribeResult; options::DescribeFormatOptions=DescribeFormatOptions())
+    buf_ref = Ref(Buffer())
+    @check ccall((:git_describe_format, :libgit2), Cint,
+                 (Ptr{Buffer}, Ptr{Void}, Ptr{DescribeFormatOptions}),
+                 buf_ref, result.ptr, Ref(options))
+    buf = buf_ref[]
+    str = unsafe_string(buf.ptr, buf.size)
+    free(buf_ref)
+    return str
+end
+
+function Base.show(io::IO, result::GitDescribeResult)
+    fmt_desc = format(result)
+    println(io, "GitDescribeResult:")
+    println(io, fmt_desc)
+end
 
 function checkout_tree(repo::GitRepo, obj::GitObject;
                        options::CheckoutOptions = CheckoutOptions())
@@ -262,12 +329,29 @@ function checkout_head(repo::GitRepo; options::CheckoutOptions = CheckoutOptions
                  repo.ptr, Ref(options))
 end
 
+"""
+    LibGit2.cherrypick(repo::GitRepo, commit::GitCommit; options::CherrypickOptions = CherrypickOptions())
+
+Cherrypick the commit `commit` and apply the changes in it to the current state of `repo`.
+The keyword argument `options` sets checkout and merge options for the cherrypick.
+
+!!! note
+    `cherrypick` will *apply* the changes in `commit` but not *commit* them, so `repo` will
+    be left in a dirty state. If you want to also commit the changes in `commit` you must
+    call [`commit`](@ref) yourself.
+"""
+function cherrypick(repo::GitRepo, commit::GitCommit; options::CherrypickOptions = CherrypickOptions())
+    @check ccall((:git_cherrypick, :libgit2), Cint,
+                 (Ptr{Void}, Ptr{Void}, Ptr{CherrypickOptions}),
+                 repo.ptr, commit.ptr, Ref(options))
+end
+
 """Updates some entries, determined by the `pathspecs`, in the index from the target commit tree."""
 function reset!(repo::GitRepo, obj::Nullable{<:GitObject}, pathspecs::AbstractString...)
     @check ccall((:git_reset_default, :libgit2), Cint,
                  (Ptr{Void}, Ptr{Void}, Ptr{StrArrayStruct}),
                  repo.ptr,
-                 isnull(obj) ? C_NULL: Base.get(obj).ptr,
+                 isnull(obj) ? C_NULL : Base.get(obj).ptr,
                  collect(pathspecs))
     return head_oid(repo)
 end
@@ -303,7 +387,7 @@ end
 """
     LibGit2.remotes(repo::GitRepo)
 
-Returns a vector of the names of the remotes of `repo`.
+Return a vector of the names of the remotes of `repo`.
 """
 function remotes(repo::GitRepo)
     sa_ref = Ref(StrArrayStruct())
diff --git a/base/libgit2/signature.jl b/base/libgit2/signature.jl
index 8fd7d88a1aa019..fb099efb07d386 100644
--- a/base/libgit2/signature.jl
+++ b/base/libgit2/signature.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 function Signature(ptr::Ptr{SignatureStruct})
     sig   = unsafe_load(ptr)::SignatureStruct
@@ -35,7 +35,12 @@ function Base.convert(::Type{GitSignature}, sig::Signature)
     return GitSignature(sig_ptr_ptr[])
 end
 
-Base.show(io::IO, sig::Signature) = print(io, "Name: $(sig.name), Email: $(sig.email), Time: $(Dates.unix2datetime(sig.time + sig.time_offset))")
+function Base.show(io::IO, sig::Signature)
+    print(io, "Name: ", sig.name, ", ")
+    print(io, "Email: ", sig.email, ", ")
+    print(io, "Time: ", Dates.unix2datetime(sig.time + 60*sig.time_offset))
+    @printf(io, "%+03i:%02i", divrem(sig.time_offset, 60)...)
+end
 
 """Return signature object. Free it after use."""
 function default_signature(repo::GitRepo)
diff --git a/base/libgit2/status.jl b/base/libgit2/status.jl
index c0d547d1c0d903..ccfb4c8e199856 100644
--- a/base/libgit2/status.jl
+++ b/base/libgit2/status.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 """
     LibGit2.GitStatus(repo::GitRepo; status_opts=StatusOptions())
@@ -19,7 +19,7 @@ end
 
 function Base.length(status::GitStatus)
     return Int(ccall((:git_status_list_entrycount, :libgit2), Csize_t,
-                      (Ptr{Ptr{Void}}, ), status.ptr))
+                      (Ptr{Ptr{Void}},), status.ptr))
 end
 
 function Base.getindex(status::GitStatus, i::Integer)
diff --git a/base/libgit2/strarray.jl b/base/libgit2/strarray.jl
index deee54fd8e4ebf..db0803680f72b3 100644
--- a/base/libgit2/strarray.jl
+++ b/base/libgit2/strarray.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 
 function Base.cconvert(::Type{Ptr{StrArrayStruct}}, x::Vector)
diff --git a/base/libgit2/tag.jl b/base/libgit2/tag.jl
index 098bfd03837e98..cde38e326f66f3 100644
--- a/base/libgit2/tag.jl
+++ b/base/libgit2/tag.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 """
     LibGit2.tag_list(repo::GitRepo) -> Vector{String}
@@ -21,7 +21,7 @@ Remove the git tag `tag` from the repository `repo`.
 """
 function tag_delete(repo::GitRepo, tag::AbstractString)
     @check ccall((:git_tag_delete, :libgit2), Cint,
-                  (Ptr{Void}, Cstring, ), repo.ptr, tag)
+                  (Ptr{Void}, Cstring), repo.ptr, tag)
 end
 
 """
@@ -57,7 +57,7 @@ end
 The name of `tag` (e.g. `"v0.5"`).
 """
 function name(tag::GitTag)
-    str_ptr = ccall((:git_tag_name, :libgit2), Cstring, (Ptr{Void}, ), tag.ptr)
+    str_ptr = ccall((:git_tag_name, :libgit2), Cstring, (Ptr{Void},), tag.ptr)
     str_ptr == C_NULL && throw(Error.GitError(Error.ERROR))
     return unsafe_string(str_ptr)
 end
@@ -69,7 +69,7 @@ end
 The `GitHash` of the target object of `tag`.
 """
 function target(tag::GitTag)
-    oid_ptr = ccall((:git_tag_target_id, :libgit2), Ptr{GitHash}, (Ptr{Void}, ), tag.ptr)
+    oid_ptr = ccall((:git_tag_target_id, :libgit2), Ptr{GitHash}, (Ptr{Void},), tag.ptr)
     oid_ptr == C_NULL && throw(Error.GitError(Error.ERROR))
     return unsafe_load(oid_ptr)
 end
diff --git a/base/libgit2/tree.jl b/base/libgit2/tree.jl
index 07cc6f3783f8ba..60da6a821f0be9 100644
--- a/base/libgit2/tree.jl
+++ b/base/libgit2/tree.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 """
 Traverse the entries in a tree and its subtrees in post or pre order.
@@ -8,7 +8,7 @@ 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 = cfunction(f, Cint, Tuple{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}),
@@ -16,11 +16,8 @@ function treewalk(f::Function, tree::GitTree, payload=Any[], post::Bool = false)
     return cbf_payload
 end
 
-function repository(tree::GitTree)
-    repo_ptr = ccall((:git_tree_owner, :libgit2), Ptr{Void},
-                 (Ptr{Void},), tree.ptr)
-    return GitRepo(repo_ptr)
-end
+repository(tree::GitTree) = tree.owner
+repository(te::GitTreeEntry) = repository(te.owner)
 
 function filename(te::GitTreeEntry)
     str = ccall((:git_tree_entry_name, :libgit2), Cstring, (Ptr{Void},), te.ptr)
@@ -53,10 +50,11 @@ function Base.getindex(tree::GitTree, i::Integer)
     te_ptr = ccall((:git_tree_entry_byindex, :libgit2),
                    Ptr{Void},
                    (Ptr{Void}, Csize_t), tree.ptr, i-1)
-    return GitTreeEntry(te_ptr, false)
+    return GitTreeEntry(tree, te_ptr, false)
 end
 
-function (::Type{T}){T<:GitObject}(repo::GitRepo, te::GitTreeEntry)
+function (::Type{T})(te::GitTreeEntry) where T<:GitObject
+    repo = repository(te)
     obj_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
     @check ccall((:git_tree_entry_to_object, :libgit2), Cint,
                   (Ptr{Ptr{Void}}, Ptr{Void}, Ref{Void}),
@@ -70,3 +68,9 @@ function Base.show(io::IO, te::GitTreeEntry)
     println(io, "Entry type: ", entrytype(te))
     println(io, "Entry OID: ", entryid(te))
 end
+
+function Base.show(io::IO, tree::GitTree)
+    println(io, "GitTree:")
+    println(io, "Owner: ", repository(tree))
+    println(io, "Number of entries: ", count(tree))
+end
diff --git a/base/libgit2/types.jl b/base/libgit2/types.jl
index 10423af8e09525..65a6cbc65ff60d 100644
--- a/base/libgit2/types.jl
+++ b/base/libgit2/types.jl
@@ -1,6 +1,7 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
 import Base.@kwdef
-import .Consts: GIT_SUBMODULE_IGNORE, GIT_MERGE_FILE_FAVOR, GIT_MERGE_FILE
+import .Consts: GIT_SUBMODULE_IGNORE, GIT_MERGE_FILE_FAVOR, GIT_MERGE_FILE, GIT_CONFIG
 
 const OID_RAWSZ = 20
 const OID_HEXSZ = OID_RAWSZ * 2
@@ -21,13 +22,11 @@ end
 GitHash() = GitHash(ntuple(i->zero(UInt8), OID_RAWSZ))
 
 """
-    GitShortHash
-
-This is a shortened form of `GitHash`, which can be used to identify a git object when it
-is unique.
+    GitShortHash(hash::GitHash, len::Integer)
 
-Internally it is stored as two fields: a full-size `GitHash` (`hash`) and a length
-(`len`). Only the initial `len` hex digits of `hash` are used.
+A shortened git object identifier, which can be used to identify a git object when it is
+unique, consisting of the initial `len` hexadecimal digits of `hash` (the remaining digits
+are ignored).
 """
 struct GitShortHash <: AbstractGitHash
     hash::GitHash   # underlying hash: unused digits are ignored
@@ -185,7 +184,11 @@ Matches the [`git_remote_callbacks`](https://libgit2.github.com/libgit2/#HEAD/ty
 end
 
 function RemoteCallbacks(credentials::Ptr{Void}, payload::Ref{Nullable{AbstractCredentials}})
-    RemoteCallbacks(credentials=credentials_cb(), payload=pointer_from_objref(payload))
+    RemoteCallbacks(credentials=credentials, payload=pointer_from_objref(payload))
+end
+
+function RemoteCallbacks(credentials::Ptr{Void}, payload::Nullable{<:AbstractCredentials})
+    RemoteCallbacks(credentials, Ref{Nullable{AbstractCredentials}}(payload))
 end
 
 """
@@ -194,10 +197,37 @@ end
 Options for connecting through a proxy.
 
 Matches the [`git_proxy_options`](https://libgit2.github.com/libgit2/#HEAD/type/git_proxy_options) struct.
+
+The fields represent:
+  * `version`: version of the struct in use, in case this changes later. For now, always `1`.
+  * `proxytype`: an `enum` for the type of proxy to use.
+     Defined in [`git_proxy_t`](https://libgit2.github.com/libgit2/#HEAD/type/git_proxy_t).
+     The corresponding Julia enum is `GIT_PROXY` and has values:
+     - `PROXY_NONE`: do not attempt the connection through a proxy.
+     - `PROXY_AUTO`: attempt to figure out the proxy configuration from the git configuration.
+     - `PROXY_SPECIFIED`: connect using the URL given in the `url` field of this struct.
+     Default is to auto-detect the proxy type.
+  * `url`: the URL of the proxy.
+  * `credential_cb`: a pointer to a callback function which will be called if the remote
+    requires authentication to connect.
+  * `certificate_cb`: a pointer to a callback function which will be called if certificate
+    verification fails. This lets the user decide whether or not to keep connecting. If
+    the function returns `1`, connecting will be allowed. If it returns `0`, the connection
+    will not be allowed. A negative value can be used to return errors.
+  * `payload`: the payload to be provided to the two callback functions.
+
+# Examples
+```julia-repl
+julia> fo = LibGit2.FetchOptions();
+
+julia> fo.proxy_opts = LibGit2.ProxyOptions(url=Cstring("https://my_proxy_url.com"))
+
+julia> fetch(remote, "master", options=fo)
+```
 """
 @kwdef struct ProxyOptions
-    version::Cuint             = 1
-    proxytype::Cint
+    version::Cuint               = 1
+    proxytype::Consts.GIT_PROXY  = Consts.PROXY_AUTO
     url::Cstring
     credential_cb::Ptr{Void}
     certificate_cb::Ptr{Void}
@@ -269,11 +299,56 @@ Matches the [`git_diff_options`](https://libgit2.github.com/libgit2/#HEAD/type/g
     new_prefix::Cstring
 end
 
+"""
+    LibGit2.DescribeOptions
+
+Matches the [`git_describe_options`](https://libgit2.github.com/libgit2/#HEAD/type/git_describe_options) struct.
+"""
+@kwdef struct DescribeOptions
+    version::Cuint             = 1
+    max_candidates_tags::Cuint = 10
+    describe_strategy::Cuint   = Consts.DESCRIBE_DEFAULT
+
+    pattern::Cstring
+    only_follow_first_parent::Cint
+    show_commit_oid_as_fallback::Cint
+end
+
+"""
+    LibGit2.DescribeFormatOptions
+
+Matches the [`git_describe_format_options`](https://libgit2.github.com/libgit2/#HEAD/type/git_describe_format_options) struct.
+
+The fields represent:
+  * `version`: version of the struct in use, in case this changes later. For now, always `1`.
+  * `abbreviated_size`: lower bound on the size of the abbreviated `GitHash` to use, defaulting to `7`.
+  * `always_use_long_format`: set to `1` to use the long format for strings even if a short format can be used.
+  * `dirty_suffix`: if set, this will be appended to the end of the description string if the [`workdir`](@ref) is dirty.
+"""
+@kwdef struct DescribeFormatOptions
+    version::Cuint          = 1
+    abbreviated_size::Cuint = 7
+    always_use_long_format::Cint
+    dirty_suffix::Cstring
+end
+
 """
     LibGit2.DiffFile
 
 Description of one side of a delta.
 Matches the [`git_diff_file`](https://libgit2.github.com/libgit2/#HEAD/type/git_diff_file) struct.
+
+The fields represent:
+  * `id`: the [`GitHash`](@ref) of the item in the diff. If the item is empty on this
+     side of the diff (for instance, if the diff is of the removal of a file), this will
+     be `GitHash(0)`.
+  * `path`: a `NULL` terminated path to the item relative to the working directory of the repository.
+  * `size`: the size of the item in bytes.
+  * `flags`: a combination of the [`git_diff_flag_t`](https://libgit2.github.com/libgit2/#HEAD/type/git_diff_flag_t)
+     flags. The `i`th bit of this integer sets the `i`th flag.
+  * `mode`: the [`stat`](@ref) mode for the item.
+  * `id_abbrev`: only present in LibGit2 versions newer than or equal to `0.25.0`.
+     The length of the `id` field when converted using [`hex`](@ref). Usually equal to `OID_HEXSZ` ($OID_HEXSZ).
 """
 struct DiffFile
     id::GitHash
@@ -286,11 +361,29 @@ struct DiffFile
     end
 end
 
+function Base.show(io::IO, df::DiffFile)
+    println(io, "DiffFile:")
+    println(io, "Oid: $(df.id))")
+    println(io, "Path: $(df.path)")
+    println(io, "Size: $(df.size)")
+end
+
 """
     LibGit2.DiffDelta
 
 Description of changes to one entry.
-Matches the [`git_diff_file`](https://libgit2.github.com/libgit2/#HEAD/type/git_diff_file) struct.
+Matches the [`git_diff_delta`](https://libgit2.github.com/libgit2/#HEAD/type/git_diff_delta) struct.
+
+The fields represent:
+  * `status`: One of `Consts.DELTA_STATUS`, indicating whether the file has been added/modified/deleted.
+  * `flags`: Flags for the delta and the objects on each side. Determines whether to treat the file(s)
+     as binary/text, whether they exist on each side of the diff, and whether the object ids are known
+     to be correct.
+  * `similarity`: Used to indicate if a file has been renamed or copied.
+  * `nfiles`: The number of files in the delta (for instance, if the delta
+     was run on a submodule commit id, it may contain more than one file).
+  * `old_file`: A [`DiffFile`](@ref) containing information about the file(s) before the changes.
+  * `new_file`: A [`DiffFile`](@ref) containing information about the file(s) after the changes.
 """
 struct DiffDelta
     status::Cint
@@ -301,6 +394,14 @@ struct DiffDelta
     new_file::DiffFile
 end
 
+function Base.show(io::IO, dd::DiffDelta)
+    println(io, "DiffDelta:")
+    println(io, "Status: $(Consts.DELTA_STATUS(dd.status))")
+    println(io, "Number of files: $(dd.nfiles)")
+    println(io, "Old file:\n$(dd.old_file)")
+    println(io, "New file:\n$(dd.new_file)")
+end
+
 """
     LibGit2.MergeOptions
 
@@ -322,10 +423,37 @@ Matches the [`git_merge_options`](https://libgit2.github.com/libgit2/#HEAD/type/
     file_flags::GIT_MERGE_FILE        = Consts.MERGE_FILE_DEFAULT
 end
 
+"""
+    LibGit2.BlameOptions
+
+Matches the [`git_blame_options`](https://libgit2.github.com/libgit2/#HEAD/type/git_blame_options) struct.
+"""
+@kwdef struct BlameOptions
+    version::Cuint                    = 1
+    flags::UInt32                     = 0
+    min_match_characters::UInt16      = 20
+    newest_commit::GitHash
+    oldest_commit::GitHash
+    min_line::Csize_t                 = 1
+    max_line::Csize_t                 = 0
+end
+
 """
     LibGit2.PushOptions
 
 Matches the [`git_push_options`](https://libgit2.github.com/libgit2/#HEAD/type/git_push_options) struct.
+
+The fields represent:
+  * `version`: version of the struct in use, in case this changes later. For now, always `1`.
+  * `parallelism`: if a pack file must be created, this variable sets the number of worker
+     threads which will be spawned by the packbuilder. If `0`, the packbuilder will auto-set
+     the number of threads to use. The default is `1`.
+  * `callbacks`: the callbacks (e.g. for authentication with the remote) to use for the push.
+  * `proxy_opts`: only relevant if the LibGit2 version is greater than or equal to `0.25.0`.
+     Sets options for using a proxy to communicate with a remote. See [`ProxyOptions`](@ref)
+     for more information.
+  * `custom_headers`: only relevant if the LibGit2 version is greater than or equal to `0.24.0`.
+     Extra headers needed for the push operation.
 """
 @kwdef struct PushOptions
     version::Cuint                     = 1
@@ -339,6 +467,19 @@ Matches the [`git_push_options`](https://libgit2.github.com/libgit2/#HEAD/type/g
     end
 end
 
+"""
+    LibGit2.CherrypickOptions
+
+Matches the [`git_cherrypick_options`](https://libgit2.github.com/libgit2/#HEAD/type/git_cherrypick_options) struct.
+"""
+@kwdef struct CherrypickOptions
+    version::Cuint = 1
+    mainline::Cuint = 0
+    merge_opts::MergeOptions=MergeOptions()
+    checkout_opts::CheckoutOptions=CheckoutOptions()
+end
+
+
 """
     LibGit2.IndexTime
 
@@ -404,7 +545,10 @@ struct RebaseOperation
     id::GitHash
     exec::Cstring
 end
-Base.show(io::IO, rbo::RebaseOperation) = print(io, "RebaseOperation($(string(rbo.id)))")
+function Base.show(io::IO, rbo::RebaseOperation)
+    println(io, "RebaseOperation($(string(rbo.id)))")
+    println(io, "Operation type: $(Consts.GIT_REBASE_OPERATION(rbo.optype))")
+end
 
 """
     LibGit2.StatusOptions
@@ -449,35 +593,67 @@ struct FetchHead
     ismerge::Bool
 end
 
+function Base.show(io::IO, fh::FetchHead)
+    println(io, "FetchHead:")
+    println(io, "Name: $(fh.name)")
+    println(io, "URL: $(fh.url)")
+    print(io, "OID: ")
+    show(io, fh.oid)
+    println(io)
+    println(io, "Merged: $(fh.ismerge)")
+end
+
+"""
+    LibGit2.ConfigEntry
+
+Matches the [`git_config_entry`](https://libgit2.github.com/libgit2/#HEAD/type/git_config_entry) struct.
+"""
+@kwdef struct ConfigEntry
+    name::Cstring
+    value::Cstring
+    level::GIT_CONFIG = Consts.CONFIG_LEVEL_DEFAULT
+    free::Ptr{Void}
+    payload::Ptr{Void}
+end
+
+function Base.show(io::IO, ce::ConfigEntry)
+    print(io, "ConfigEntry(\"", unsafe_string(ce.name), "\", \"", unsafe_string(ce.value), "\")")
+end
+
 # Abstract object types
 abstract type AbstractGitObject end
 Base.isempty(obj::AbstractGitObject) = (obj.ptr == C_NULL)
 
 abstract type GitObject <: AbstractGitObject end
 
-for (typ, reporef, sup, cname) in [
-    (:GitRepo,       nothing,   :AbstractGitObject, :git_repository),
-    (:GitTreeEntry,  nothing,   :AbstractGitObject, :git_tree_entry),
-    (:GitConfig,     :Nullable, :AbstractGitObject, :git_config),
-    (:GitIndex,      :Nullable, :AbstractGitObject, :git_index),
-    (:GitRemote,     :GitRepo,  :AbstractGitObject, :git_remote),
-    (:GitRevWalker,  :GitRepo,  :AbstractGitObject, :git_revwalk),
-    (:GitReference,  :GitRepo,  :AbstractGitObject, :git_reference),
-    (:GitDiff,       :GitRepo,  :AbstractGitObject, :git_diff),
-    (:GitAnnotated,  :GitRepo,  :AbstractGitObject, :git_annotated_commit),
-    (:GitRebase,     :GitRepo,  :AbstractGitObject, :git_rebase),
-    (:GitStatus,     :GitRepo,  :AbstractGitObject, :git_status_list),
-    (:GitBranchIter, :GitRepo,  :AbstractGitObject, :git_branch_iterator),
-    (:GitUnknownObject,  :GitRepo,  :GitObject,         :git_object),
-    (:GitCommit,     :GitRepo,  :GitObject,         :git_commit),
-    (:GitBlob,       :GitRepo,  :GitObject,         :git_blob),
-    (:GitTree,       :GitRepo,  :GitObject,         :git_tree),
-    (:GitTag,        :GitRepo,  :GitObject,         :git_tag)]
-
-    if reporef === nothing
+for (typ, owntyp, sup, cname) in [
+    (:GitRepo,           nothing,               :AbstractGitObject, :git_repository),
+    (:GitConfig,         :(Nullable{GitRepo}),  :AbstractGitObject, :git_config),
+    (:GitIndex,          :(Nullable{GitRepo}),  :AbstractGitObject, :git_index),
+    (:GitRemote,         :GitRepo,              :AbstractGitObject, :git_remote),
+    (:GitRevWalker,      :GitRepo,              :AbstractGitObject, :git_revwalk),
+    (:GitReference,      :GitRepo,              :AbstractGitObject, :git_reference),
+    (:GitDescribeResult, :GitRepo,              :AbstractGitObject, :git_describe_result),
+    (:GitDiff,           :GitRepo,              :AbstractGitObject, :git_diff),
+    (:GitDiffStats,      :GitRepo,              :AbstractGitObject, :git_diff_stats),
+    (:GitAnnotated,      :GitRepo,              :AbstractGitObject, :git_annotated_commit),
+    (:GitRebase,         :GitRepo,              :AbstractGitObject, :git_rebase),
+    (:GitBlame,          :GitRepo,              :AbstractGitObject, :git_blame),
+    (:GitStatus,         :GitRepo,              :AbstractGitObject, :git_status_list),
+    (:GitBranchIter,     :GitRepo,              :AbstractGitObject, :git_branch_iterator),
+    (:GitConfigIter,     nothing,               :AbstractGitObject, :git_config_iterator),
+    (:GitUnknownObject,  :GitRepo,              :GitObject,         :git_object),
+    (:GitCommit,         :GitRepo,              :GitObject,         :git_commit),
+    (:GitBlob,           :GitRepo,              :GitObject,         :git_blob),
+    (:GitTree,           :GitRepo,              :GitObject,         :git_tree),
+    (:GitTag,            :GitRepo,              :GitObject,         :git_tag),
+    (:GitTreeEntry,      :GitTree,              :AbstractGitObject, :git_tree_entry),
+    ]
+
+    if owntyp === nothing
         @eval mutable struct $typ <: $sup
             ptr::Ptr{Void}
-            function $typ(ptr::Ptr{Void},fin=true)
+            function $typ(ptr::Ptr{Void}, fin::Bool=true)
                 # fin=false should only be used when the pointer should not be free'd
                 # e.g. from within callback functions which are passed a pointer
                 @assert ptr != C_NULL
@@ -489,35 +665,25 @@ for (typ, reporef, sup, cname) in [
                 return obj
             end
         end
-    elseif reporef == :Nullable
+    else
         @eval mutable struct $typ <: $sup
-            nrepo::Nullable{GitRepo}
+            owner::$owntyp
             ptr::Ptr{Void}
-            function $typ(repo::GitRepo, ptr::Ptr{Void})
+            function $typ(owner::$owntyp, ptr::Ptr{Void}, fin::Bool=true)
                 @assert ptr != C_NULL
-                obj = new(Nullable(repo), ptr)
-                Threads.atomic_add!(REFCOUNT, UInt(1))
-                finalizer(obj, Base.close)
-                return obj
-            end
-            function $typ(ptr::Ptr{Void})
-                @assert ptr != C_NULL
-                obj = new(Nullable{GitRepo}(), ptr)
-                Threads.atomic_add!(REFCOUNT, UInt(1))
-                finalizer(obj, Base.close)
+                obj = new(owner, ptr)
+                if fin
+                    Threads.atomic_add!(REFCOUNT, UInt(1))
+                    finalizer(obj, Base.close)
+                end
                 return obj
             end
         end
-    elseif reporef == :GitRepo
-        @eval mutable struct $typ <: $sup
-            repo::GitRepo
-            ptr::Ptr{Void}
-            function $typ(repo::GitRepo, ptr::Ptr{Void})
-                @assert ptr != C_NULL
-                obj = new(repo, ptr)
-                Threads.atomic_add!(REFCOUNT, UInt(1))
-                finalizer(obj, Base.close)
-                return obj
+        if isa(owntyp, Expr) && owntyp.args[1] == :Nullable
+            @eval begin
+                $typ(ptr::Ptr{Void}, fin::Bool=true) = $typ($owntyp(), ptr, fin)
+                $typ(owner::$(owntyp.args[2]), ptr::Ptr{Void}, fin::Bool=true) =
+                    $typ($owntyp(owner), ptr, fin)
             end
         end
     end
@@ -569,6 +735,43 @@ mutable struct Signature
     time_offset::Cint
 end
 
+"""
+    LibGit2.BlameHunk
+
+Matches the [`git_blame_hunk`](https://libgit2.github.com/libgit2/#HEAD/type/git_blame_hunk) struct.
+The fields represent:
+    * `lines_in_hunk`: the number of lines in this hunk of the blame.
+    * `final_commit_id`: the [`GitHash`](@ref) of the commit where this section was last changed.
+    * `final_start_line_number`: the *one based* line number in the file where the
+       hunk starts, in the *final* version of the file.
+    * `final_signature`: the signature of the person who last modified this hunk. You will
+       need to pass this to `Signature` to access its fields.
+    * `orig_commit_id`: the [`GitHash`](@ref) of the commit where this hunk was first found.
+    * `orig_path`: the path to the file where the hunk originated. This may be different
+       than the current/final path, for instance if the file has been moved.
+    * `orig_start_line_number`: the *one based* line number in the file where the
+       hunk starts, in the *original* version of the file at `orig_path`.
+    * `orig_signature`: the signature of the person who introduced this hunk. You will
+       need to pass this to `Signature` to access its fields.
+    * `boundary`: `'1'` if the original commit is a "boundary" commit (for instance, if it's
+       equal to an oldest commit set in `options`).
+"""
+@kwdef struct BlameHunk
+    lines_in_hunk::Csize_t
+
+    final_commit_id::GitHash
+    final_start_line_number::Csize_t
+    final_signature::Ptr{SignatureStruct}
+
+    orig_commit_id::GitHash
+    orig_path::Cstring
+    orig_start_line_number::Csize_t
+    orig_signature::Ptr{SignatureStruct}
+
+    boundary::Char
+end
+
+
 """ Resource management helper function
 """
 function with(f::Function, obj)
@@ -579,9 +782,9 @@ function with(f::Function, obj)
     end
 end
 
-with{T}(f::Function, ::Type{T}, args...) = with(f, T(args...))
+with(f::Function, ::Type{T}, args...) where {T} = with(f, T(args...))
 
-function with_warn{T}(f::Function, ::Type{T}, args...)
+function with_warn(f::Function, ::Type{T}, args...) where T
     obj = T(args...)
     try
         with(f, obj)
@@ -591,7 +794,7 @@ function with_warn{T}(f::Function, ::Type{T}, args...)
 end
 
 """
-    LibGit2.Const.OBJECT{T<:GitObject}(::Type{T})
+    LibGit2.Consts.OBJECT(::Type{T}) where T<:GitObject
 
 The `OBJECT` enum value corresponding to type `T`.
 """
@@ -649,32 +852,41 @@ function securezero!(cred::UserPasswordCredentials)
     return cred
 end
 
+function Base.:(==)(a::UserPasswordCredentials, b::UserPasswordCredentials)
+    a.user == b.user && a.pass == b.pass
+end
+
 "SSH credentials type"
 mutable struct SSHCredentials <: AbstractCredentials
     user::String
     pass::String
-    pubkey::String
     prvkey::String
+    pubkey::String
     usesshagent::String  # used for ssh-agent authentication
     prompt_if_incorrect::Bool    # Whether to allow interactive prompting if the credentials are incorrect
     count::Int
-
-    function SSHCredentials(u::AbstractString,p::AbstractString,prompt_if_incorrect::Bool=false)
-        c = new(u,p,"","","Y",prompt_if_incorrect,3)
+    function SSHCredentials(u::AbstractString,p::AbstractString,prvkey::AbstractString,pubkey::AbstractString,prompt_if_incorrect::Bool=false)
+        c = new(u,p,prvkey,pubkey,"Y",prompt_if_incorrect,3)
         finalizer(c, securezero!)
         return c
     end
-    SSHCredentials(prompt_if_incorrect::Bool=false) = SSHCredentials("","",prompt_if_incorrect)
+    SSHCredentials(u::AbstractString,p::AbstractString,prompt_if_incorrect::Bool=false) = SSHCredentials(u,p,"","",prompt_if_incorrect)
+    SSHCredentials(prompt_if_incorrect::Bool=false) = SSHCredentials("","","","",prompt_if_incorrect)
 end
+
 function securezero!(cred::SSHCredentials)
     securezero!(cred.user)
     securezero!(cred.pass)
-    securezero!(cred.pubkey)
     securezero!(cred.prvkey)
+    securezero!(cred.pubkey)
     cred.count = 0
     return cred
 end
 
+function Base.:(==)(a::SSHCredentials, b::SSHCredentials)
+    a.user == b.user && a.pass == b.pass && a.prvkey == b.prvkey && a.pubkey == b.pubkey
+end
+
 "Credentials that support caching"
 mutable struct CachedCredentials <: AbstractCredentials
     cred::Dict{String,AbstractCredentials}
diff --git a/base/libgit2/utils.jl b/base/libgit2/utils.jl
index 31ccfbf6ff93ec..8f3002e7d85ebd 100644
--- a/base/libgit2/utils.jl
+++ b/base/libgit2/utils.jl
@@ -1,10 +1,19 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
+# Parse "GIT URLs" syntax (URLs and a scp-like syntax). For details see:
+# https://git-scm.com/docs/git-clone#_git_urls_a_id_urls_a
 const URL_REGEX = r"""
-^(?:(?<scheme>https?|git|ssh)\:\/\/)?
-(?:(?<user>.*?)(?:\:(?<password>.*?))?@)?
+^(?:(?<scheme>ssh|git|https?)://)?
+(?:
+    (?<user>.*?)
+    (?:\:(?<password>.*?))?@
+)?
 (?<host>[A-Za-z0-9\-\.]+)
-(?:\:(?<port>\d+)?)?
+(?(<scheme>)
+    (?:\:(?<port>\d+))?  # only parse port when not using SCP-like syntax
+    |
+    :?
+)
 (?<path>.*?)$
 """x
 
@@ -23,7 +32,7 @@ reset(val::Integer, flag::Integer) = (val &= ~flag)
 toggle(val::Integer, flag::Integer) = (val |= flag)
 
 function prompt(msg::AbstractString; default::AbstractString="", password::Bool=false)
-    if is_windows() && password
+    if Sys.iswindows() && password
         error("Command line prompt not supported for password entry on windows. Use winprompt instead")
     end
     msg = !isempty(default) ? msg*" [$default]:" : msg*":"
@@ -51,8 +60,8 @@ end
 Standardise the path string `path` to use POSIX separators.
 """
 function posixpath end
-if is_windows()
+if Sys.iswindows()
     posixpath(path) = replace(path,'\\','/')
-else is_unix()
+else Sys.isunix()
     posixpath(path) = path
 end
diff --git a/base/libgit2/walker.jl b/base/libgit2/walker.jl
index 5a15901d3391fd..41b44fcbc14b48 100644
--- a/base/libgit2/walker.jl
+++ b/base/libgit2/walker.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 function GitRevWalker(repo::GitRepo)
     w_ptr = Ref{Ptr{Void}}(C_NULL)
@@ -48,7 +48,7 @@ function Base.sort!(w::GitRevWalker; by::Cint = Consts.SORT_NONE, rev::Bool=fals
     return w
 end
 
-repository(w::GitRevWalker) = w.repo
+repository(w::GitRevWalker) = w.owner
 
 function Base.map(f::Function, walker::GitRevWalker;
                   oid::GitHash=GitHash(),
diff --git a/base/libuv.jl b/base/libuv.jl
index 1037e7ce03d9c3..237e3d22883d07 100644
--- a/base/libuv.jl
+++ b/base/libuv.jl
@@ -1,20 +1,20 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Core definitions for interacting with the libuv library from Julia
 
-include(string(length(Core.ARGS)>=2?Core.ARGS[2]:"","uv_constants.jl"))  # include($BUILDROOT/base/uv_constants.jl)
+include(string(length(Core.ARGS) >= 2 ? Core.ARGS[2] : "", "uv_constants.jl"))  # include($BUILDROOT/base/uv_constants.jl)
 
 # convert UV handle data to julia object, checking for null
 function uv_sizeof_handle(handle)
     if !(UV_UNKNOWN_HANDLE < handle < UV_HANDLE_TYPE_MAX)
-        throw(DomainError())
+        throw(DomainError(handle))
     end
     ccall(:uv_handle_size,Csize_t,(Int32,),handle)
 end
 
 function uv_sizeof_req(req)
     if !(UV_UNKNOWN_REQ < req < UV_REQ_TYPE_MAX)
-        throw(DomainError())
+        throw(DomainError(req))
     end
     ccall(:uv_req_size,Csize_t,(Int32,),req)
 end
@@ -39,7 +39,7 @@ macro handle_as(hand, typ)
     end
 end
 
-associate_julia_struct(handle::Ptr{Void}, jlobj::ANY) =
+associate_julia_struct(handle::Ptr{Void}, @nospecialize(jlobj)) =
     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}) =
@@ -49,7 +49,6 @@ disassociate_julia_struct(handle::Ptr{Void}) =
 # and should thus not be garbage collected
 const uvhandles = ObjectIdDict()
 preserve_handle(x) = uvhandles[x] = get(uvhandles,x,0)::Int+1
-preserve_handle_new(x) = uvhandles[x] = 1
 unpreserve_handle(x) = (v = uvhandles[x]::Int; v == 1 ? pop!(uvhandles,x) : (uvhandles[x] = v-1); nothing)
 
 ## Libuv error handling ##
@@ -87,17 +86,17 @@ function process_events(block::Bool)
 end
 
 function reinit_stdio()
-    global uv_jl_alloc_buf     = cfunction(uv_alloc_buf, Void, (Ptr{Void}, Csize_t, Ptr{Void}))
-    global uv_jl_readcb        = cfunction(uv_readcb, Void, (Ptr{Void}, Cssize_t, Ptr{Void}))
-    global uv_jl_connectioncb  = cfunction(uv_connectioncb, Void, (Ptr{Void}, Cint))
-    global uv_jl_connectcb     = cfunction(uv_connectcb, Void, (Ptr{Void}, Cint))
-    global uv_jl_writecb_task  = cfunction(uv_writecb_task, Void, (Ptr{Void}, Cint))
-    global uv_jl_getaddrinfocb = cfunction(uv_getaddrinfocb, Void, (Ptr{Void},Cint,Ptr{Void}))
-    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_asynccb       = cfunction(uv_asynccb, Void, (Ptr{Void},))
-    global uv_jl_timercb       = cfunction(uv_timercb, Void, (Ptr{Void},))
+    global uv_jl_alloc_buf     = cfunction(uv_alloc_buf, Void, Tuple{Ptr{Void}, Csize_t, Ptr{Void}})
+    global uv_jl_readcb        = cfunction(uv_readcb, Void, Tuple{Ptr{Void}, Cssize_t, Ptr{Void}})
+    global uv_jl_connectioncb  = cfunction(uv_connectioncb, Void, Tuple{Ptr{Void}, Cint})
+    global uv_jl_connectcb     = cfunction(uv_connectcb, Void, Tuple{Ptr{Void}, Cint})
+    global uv_jl_writecb_task  = cfunction(uv_writecb_task, Void, Tuple{Ptr{Void}, Cint})
+    global uv_jl_getaddrinfocb = cfunction(uv_getaddrinfocb, Void, Tuple{Ptr{Void}, Cint, Ptr{Void}})
+    global uv_jl_recvcb        = cfunction(uv_recvcb, Void, Tuple{Ptr{Void}, Cssize_t, Ptr{Void}, Ptr{Void}, Cuint})
+    global uv_jl_sendcb        = cfunction(uv_sendcb, Void, Tuple{Ptr{Void}, Cint})
+    global uv_jl_return_spawn  = cfunction(uv_return_spawn, Void, Tuple{Ptr{Void}, Int64, Int32})
+    global uv_jl_asynccb       = cfunction(uv_asynccb, Void, Tuple{Ptr{Void}})
+    global uv_jl_timercb       = cfunction(uv_timercb, Void, Tuple{Ptr{Void}})
 
     global uv_eventloop = ccall(:jl_global_event_loop, Ptr{Void}, ())
     global STDIN = init_stdio(ccall(:jl_stdin_stream, Ptr{Void}, ()))
diff --git a/base/linalg/arnoldi.jl b/base/linalg/arnoldi.jl
index 935d6fd79ea2ad..ec0b8e03381908 100644
--- a/base/linalg/arnoldi.jl
+++ b/base/linalg/arnoldi.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using .ARPACK
 
@@ -50,8 +50,7 @@ The following keyword arguments are supported:
 iterations `niter` and the number of matrix vector multiplications `nmult`, as well as the
 final residual vector `resid`.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> A = spdiagm(1:4);
 
@@ -90,10 +89,10 @@ julia> λ
 eigs(A; kwargs...) = eigs(A, I; kwargs...)
 eigs(A::AbstractMatrix{<:BlasFloat}, ::UniformScaling; kwargs...) = _eigs(A, I; kwargs...)
 
-eigs{T<:BlasFloat}(A::AbstractMatrix{T}, B::AbstractMatrix{T}; kwargs...) = _eigs(A, B; kwargs...)
+eigs(A::AbstractMatrix{T}, B::AbstractMatrix{T}; kwargs...) where {T<:BlasFloat} = _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...)
+function eigs(A::AbstractMatrix{T}, ::UniformScaling; kwargs...) where T
     Tnew = typeof(zero(T)/sqrt(one(T)))
     eigs(convert(AbstractMatrix{Tnew}, A), I; kwargs...)
 end
@@ -144,8 +143,7 @@ The following keyword arguments are supported:
 iterations `niter` and the number of matrix vector multiplications `nmult`, as well as the
 final residual vector `resid`.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> A = speye(4, 4); B = spdiagm(1:4);
 
@@ -169,17 +167,16 @@ julia> λ
 """
 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)
-
+               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 = checksquare(A)
 
     T = eltype(A)
     iscmplx = T <: Complex
     isgeneral = B !== I
-    sym = issymmetric(A) && issymmetric(B) && !iscmplx
-    nevmax=sym ? n-1 : n-2
+    sym = !iscmplx && issymmetric(A) && issymmetric(B)
+    nevmax = sym ? n-1 : n-2
     if nevmax <= 0
         throw(ArgumentError("input matrix A is too small. Use eigfact instead."))
     end
@@ -300,68 +297,87 @@ end
 
 
 ## svds
-### Restrict operator to BlasFloat because ARPACK only supports that. Loosen restriction
-### when we switch to our own implementation
-mutable struct SVDOperator{T<:BlasFloat,S} <: AbstractArray{T, 2}
+struct SVDAugmented{T,S} <: AbstractArray{T, 2}
     X::S
-    m::Int
-    n::Int
-    SVDOperator{T,S}(X::AbstractMatrix) where {T<:BlasFloat,S} = new(X, size(X, 1), size(X, 2))
+    SVDAugmented{T,S}(X::AbstractMatrix) where {T,S} = new(X)
+end
+
+function SVDAugmented(A::AbstractMatrix{T}) where T
+    Tnew = typeof(zero(T)/sqrt(one(T)))
+    Anew = convert(AbstractMatrix{Tnew}, A)
+    SVDAugmented{Tnew,typeof(Anew)}(Anew)
+end
+
+function A_mul_B!(y::StridedVector{T}, A::SVDAugmented{T}, x::StridedVector{T}) where T
+    m, mn = size(A.X, 1), length(x)
+    A_mul_B!( view(y, 1:m), A.X, view(x, m + 1:mn)) # left singular vector
+    Ac_mul_B!(view(y, m + 1:mn), A.X, view(x, 1:m)) # right singular vector
+    return y
+end
+size(A::SVDAugmented)  = ((+)(size(A.X)...), (+)(size(A.X)...))
+ishermitian(A::SVDAugmented) = true
+
+struct AtA_or_AAt{T,S} <: AbstractArray{T, 2}
+    A::S
+    buffer::Vector{T}
 end
 
-function SVDOperator(A::AbstractMatrix{T}) where T
+function AtA_or_AAt(A::AbstractMatrix{T}) where T
     Tnew = typeof(zero(T)/sqrt(one(T)))
     Anew = convert(AbstractMatrix{Tnew}, A)
-    SVDOperator{Tnew,typeof(Anew)}(Anew)
+    AtA_or_AAt{Tnew,typeof(Anew)}(Anew, Vector{Tnew}(max(size(A)...)))
 end
 
-function A_mul_B!{T}(u::StridedVector{T}, s::SVDOperator{T}, v::StridedVector{T})
-    a, b = s.m, length(v)
-    A_mul_B!(view(u,1:a), s.X, view(v,a+1:b)) # left singular vector
-    Ac_mul_B!(view(u,a+1:b), s.X, view(v,1:a)) # right singular vector
-    u
+function A_mul_B!(y::StridedVector{T}, A::AtA_or_AAt{T}, x::StridedVector{T}) where T
+    if size(A.A, 1) >= size(A.A, 2)
+        A_mul_B!(A.buffer, A.A, x)
+        return Ac_mul_B!(y, A.A, A.buffer)
+    else
+        Ac_mul_B!(A.buffer, A.A, x)
+        return A_mul_B!(y, A.A, A.buffer)
+    end
 end
-size(s::SVDOperator)  = s.m + s.n, s.m + s.n
-issymmetric(s::SVDOperator) = true
+size(A::AtA_or_AAt) = ntuple(i -> min(size(A.A)...), Val(2))
+ishermitian(s::AtA_or_AAt) = true
+
 
 svds(A::AbstractMatrix{<:BlasFloat}; kwargs...) = _svds(A; kwargs...)
 svds(A::AbstractMatrix{BigFloat}; kwargs...) = throw(MethodError(svds, Any[A, kwargs...]))
-function svds{T}(A::AbstractMatrix{T}; kwargs...)
+function svds(A::AbstractMatrix{T}; kwargs...) where T
     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, ncv=2*nsv, u0=zeros((0,)), v0=zeros((0,))) -> (SVD([left_sv,] s, [right_sv,]), nconv, niter, nmult, resid)
+    svds(A; nsv=6, ritzvec=true, tol=0.0, maxiter=1000, ncv=2*nsv, v0=zeros((0,))) -> (SVD([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`](@ref).
 
 **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`.
+* `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. Default: 6.
 * `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`](@ref).
 * `maxiter`: Maximum number of iterations, see [`eigs`](@ref). Default: 1000.
 * `ncv`: Maximum size of the Krylov subspace, see [`eigs`](@ref) (there called `nev`). Default: `2*nsv`.
-* `u0`: Initial guess for the first left Krylov vector. It may have length `m` (the first dimension of `A`), or 0.
-* `v0`: Initial guess for the first right Krylov vector. It may have length `n` (the second dimension of `A`), or 0.
+* `v0`: Initial guess for the first Krylov vector. It may have length `min(size(A)...)`, or 0.
 
 **Outputs**
 
-* `svd`: An `SVD` object containing the left singular vectors, the requested values, and the right singular vectors. If `ritzvec = false`, the left and right singular vectors will be empty.
+* `svd`: An `SVD` object containing the left singular vectors, the requested values, and the
+  right singular vectors. If `ritzvec = false`, the left and right singular vectors will be
+  empty.
 * `nconv`: Number of converged singular values.
 * `niter`: Number of iterations.
 * `nmult`: Number of matrix--vector products used.
 * `resid`: Final residual vector.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> A = spdiagm(1:4);
 
@@ -375,48 +391,45 @@ julia> s[:S]
 
 !!! note "Implementation"
     `svds(A)` is formally equivalent to calling [`eigs`](@ref) 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``.
+    Lanczos tridiagonalization on the Hermitian matrix ``A^\\prime A`` or ``AA^\\prime`` such
+    that the size is smallest.
 """
 svds(A; kwargs...) = _svds(A; kwargs...)
-function _svds(X; nsv::Int = 6, ritzvec::Bool = true, tol::Float64 = 0.0, maxiter::Int = 1000, ncv::Int = 2*nsv, u0::Vector=zeros(eltype(X),(0,)), v0::Vector=zeros(eltype(X),(0,)))
+function _svds(X; nsv::Int = 6, ritzvec::Bool = true, tol::Float64 = 0.0, maxiter::Int = 1000, ncv::Int = 2*nsv, v0::Vector=zeros(eltype(X),(0,)))
     if nsv < 1
         throw(ArgumentError("number of singular values (nsv) must be ≥ 1, got $nsv"))
     end
     if nsv > minimum(size(X))
         throw(ArgumentError("number of singular values (nsv) must be ≤ $(minimum(size(X))), got $nsv"))
     end
-    m,n = size(X)
+    m, n = size(X)
     otype = eltype(X)
-    padv0 = zeros(eltype(X),(0,))
     if length(v0) ∉ [0,n]
         throw(DimensionMismatch("length of v0, the guess for the starting right Krylov vector, must be 0, or $n, got $(length(v0))"))
     end
-    if length(u0) ∉ [0,m]
-        throw(DimensionMismatch("length of u0, the guess for the starting left Krylov vector, must be 0, or $m, got $(length(u0))"))
-    end
-    if length(v0) == n && length(u0) == m
-        padv0 = [u0; v0]
-    elseif length(v0) == n && length(u0) == 0
-        padv0 = [zeros(otype,m); v0]
-    elseif length(v0) == 0 && length(u0) == m
-        padv0 = [u0; zeros(otype,n) ]
-    end
-    ex    = eigs(SVDOperator(X), I; ritzvec = ritzvec, nev = ncv, tol = tol, maxiter = maxiter, v0=padv0)
-    ind   = [1:2:ncv;]
-    sval  = abs.(ex[1][ind])
+    ex    = eigs(AtA_or_AAt(X), I; which = :LM, ritzvec = ritzvec, nev = nsv, tol = tol, maxiter = maxiter, v0=v0)
+    # ind   = [1:2:ncv;]
+    # sval  = abs.(ex[1][ind])
 
+    svals = sqrt.(real.(ex[1]))
     if ritzvec
         # calculating singular vectors
-        left_sv  = sqrt(2) * ex[2][ 1:size(X,1),     ind ] .* sign.(ex[1][ind]')
-        right_sv = sqrt(2) * ex[2][ size(X,1)+1:end, ind ]
-        return (SVD(left_sv, sval, right_sv'), ex[3], ex[4], ex[5], ex[6])
+        # left_sv  = sqrt(2) * ex[2][ 1:size(X,1),     ind ] .* sign.(ex[1][ind]')
+        if size(X, 1) >= size(X, 2)
+            V = ex[2]
+            U = qr(scale!(X*V, inv.(svals)))[1]
+        else
+            U = ex[2]
+            V = qr(scale!(X'U, inv.(svals)))[1]
+        end
+
+        # right_sv = sqrt(2) * ex[2][ size(X,1)+1:end, ind ]
+        return (SVD(U, svals, V'), ex[3], ex[4], ex[5], ex[6])
     else
         #The sort is necessary to work around #10329
-        return (SVD(zeros(eltype(sval), n, 0),
-                    sort!(sval, by=real, rev=true),
-                    zeros(eltype(sval), 0, m)),
+        return (SVD(zeros(eltype(svals), n, 0),
+                    svals,
+                    zeros(eltype(svals), 0, m)),
                     ex[2], ex[3], ex[4], ex[5])
     end
 end
diff --git a/base/linalg/arpack.jl b/base/linalg/arpack.jl
index f03c0f28deeeec..c268920fc3a916 100644
--- a/base/linalg/arpack.jl
+++ b/base/linalg/arpack.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module ARPACK
 
@@ -12,20 +12,20 @@ function aupd_wrapper(T, matvecA!::Function, matvecB::Function, solveSI::Functio
                       tol::Real, maxiter::Integer, mode::Integer, v0::Vector)
     lworkl = cmplx ? ncv * (3*ncv + 5) : (sym ? ncv * (ncv + 8) :  ncv * (3*ncv + 6) )
     TR = cmplx ? T.types[1] : T
-    TOL = Array{TR}(1)
+    TOL = Vector{TR}(1)
     TOL[1] = tol
 
-    v      = Array{T}(n, ncv)
-    workd  = Array{T}(3*n)
-    workl  = Array{T}(lworkl)
-    rwork  = cmplx ? Array{TR}(ncv) : Array{TR}(0)
+    v     = Matrix{T}(n, ncv)
+    workd = Vector{T}(3*n)
+    workl = Vector{T}(lworkl)
+    rwork = cmplx ? Vector{TR}(ncv) : Vector{TR}(0)
 
     if isempty(v0)
-        resid  = Array{T}(n)
-        info   = zeros(BlasInt, 1)
+        resid = Vector{T}(n)
+        info  = zeros(BlasInt, 1)
     else
-        resid  = deepcopy(v0)
-        info   = ones(BlasInt, 1)
+        resid = deepcopy(v0)
+        info  = ones(BlasInt, 1)
     end
     iparam = zeros(BlasInt, 11)
     ipntr  = zeros(BlasInt, (sym && !cmplx) ? 11 : 14)
@@ -109,7 +109,7 @@ function eupd_wrapper(T, n::Integer, sym::Bool, cmplx::Bool, bmat::String,
                       TOL::Array, resid, ncv::Integer, v, ldv, sigma, iparam, ipntr,
                       workd, workl, lworkl, rwork)
     howmny = "A"
-    select = Array{BlasInt}(ncv)
+    select = Vector{BlasInt}(ncv)
     info   = zeros(BlasInt, 1)
 
     dmap = x->abs.(x)
@@ -126,9 +126,9 @@ function eupd_wrapper(T, n::Integer, sym::Bool, cmplx::Bool, bmat::String,
     end
 
     if cmplx
-        d = Array{T}(nev+1)
+        d = Vector{T}(nev+1)
         sigmar = ones(T, 1)*sigma
-        workev = Array{T}(2ncv)
+        workev = Vector{T}(2ncv)
         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)
@@ -139,7 +139,7 @@ function eupd_wrapper(T, n::Integer, sym::Bool, cmplx::Bool, bmat::String,
         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)
     elseif sym
-        d = Array{T}(nev)
+        d = Vector{T}(nev)
         sigmar = ones(T, 1)*sigma
         seupd(ritzvec, howmny, select, d, v, ldv, sigmar,
               bmat, n, which, nev, TOL, resid, ncv, v, ldv,
@@ -149,22 +149,22 @@ function eupd_wrapper(T, n::Integer, sym::Bool, cmplx::Bool, bmat::String,
         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)
+        return ritzvec ? (d[p], v[1:n, p],iparam[5],iparam[3],iparam[9],resid) : (d[p],iparam[5],iparam[3],iparam[9],resid)
     else
-        dr     = Array{T}(nev+1)
-        di     = Array{T}(nev+1)
+        dr     = Vector{T}(nev+1)
+        di     = Vector{T}(nev+1)
         fill!(dr,NaN)
         fill!(di,NaN)
         sigmar = ones(T, 1)*real(sigma)
         sigmai = ones(T, 1)*imag(sigma)
-        workev = Array{T}(3*ncv)
+        workev = Vector{T}(3*ncv)
         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
-        evec = complex.(Array{T}(n, nev+1), Array{T}(n, nev+1))
+        evec = complex.(Matrix{T}(n, nev+1), Matrix{T}(n, nev+1))
 
         j = 1
         while j <= nev
diff --git a/base/linalg/bidiag.jl b/base/linalg/bidiag.jl
index fc3b0910f8fb54..b37ddd03d69c45 100644
--- a/base/linalg/bidiag.jl
+++ b/base/linalg/bidiag.jl
@@ -1,93 +1,53 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Bidiagonal matrices
-mutable struct Bidiagonal{T} <: AbstractMatrix{T}
+struct 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) where T
+    uplo::Char    # upper bidiagonal ('U') or lower ('L')
+    function Bidiagonal{T}(dv::Vector{T}, ev::Vector{T}, uplo::Char) where T
         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)
+        new(dv, ev, uplo)
+    end
+    function Bidiagonal(dv::Vector{T}, ev::Vector{T}, uplo::Char) where T
+        Bidiagonal{T}(dv, ev, uplo)
     end
 end
-"""
-    Bidiagonal(dv, ev, isupper::Bool)
-
-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 [`convert(Array, _)`](@ref) (or `Array(_)` for short). `ev`'s length
-must be one less than the length of `dv`.
-
-# Example
-
-```jldoctest
-julia> dv = [1; 2; 3; 4]
-4-element Array{Int64,1}:
- 1
- 2
- 3
- 4
-
-julia> ev = [7; 8; 9]
-3-element Array{Int64,1}:
- 7
- 8
- 9
-
-julia> Bu = Bidiagonal(dv, ev, true) # ev is on the first superdiagonal
-4×4 Bidiagonal{Int64}:
- 1  7  ⋅  ⋅
- ⋅  2  8  ⋅
- ⋅  ⋅  3  9
- ⋅  ⋅  ⋅  4
-
-julia> Bl = Bidiagonal(dv, ev, false) # ev is on the first subdiagonal
-4×4 Bidiagonal{Int64}:
- 1  ⋅  ⋅  ⋅
- 7  2  ⋅  ⋅
- ⋅  8  3  ⋅
- ⋅  ⋅  9  4
-```
-"""
-Bidiagonal(dv::AbstractVector{T}, ev::AbstractVector{T}, isupper::Bool) where {T} = 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."))
 
 """
-    Bidiagonal(dv, ev, uplo::Char)
+    Bidiagonal(dv, ev, uplo::Symbol)
 
-Constructs an upper (`uplo='U'`) or lower (`uplo='L'`) bidiagonal matrix using the
-given diagonal (`dv`) and off-diagonal (`ev`) vectors.  The result is of type `Bidiagonal`
+Constructs an upper (`uplo=:U`) or lower (`uplo=:L`) 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 [`convert(Array, _)`](@ref) (or `Array(_)` for short). `ev`'s
-length must be one less than the length of `dv`.
-
-# Example
+matrix with [`convert(Array, _)`](@ref) (or `Array(_)` for short). The length of `ev`
+must be one less than the length of `dv`.
 
+# Examples
 ```jldoctest
-julia> dv = [1; 2; 3; 4]
+julia> dv = [1, 2, 3, 4]
 4-element Array{Int64,1}:
  1
  2
  3
  4
 
-julia> ev = [7; 8; 9]
+julia> ev = [7, 8, 9]
 3-element Array{Int64,1}:
  7
  8
  9
 
-julia> Bu = Bidiagonal(dv, ev, 'U') #e is on the first superdiagonal
+julia> Bu = Bidiagonal(dv, ev, :U) # ev is on the first superdiagonal
 4×4 Bidiagonal{Int64}:
  1  7  ⋅  ⋅
  ⋅  2  8  ⋅
  ⋅  ⋅  3  9
  ⋅  ⋅  ⋅  4
 
-julia> Bl = Bidiagonal(dv, ev, 'L') #e is on the first subdiagonal
+julia> Bl = Bidiagonal(dv, ev, :L) # ev is on the first subdiagonal
 4×4 Bidiagonal{Int64}:
  1  ⋅  ⋅  ⋅
  7  2  ⋅  ⋅
@@ -95,30 +55,22 @@ julia> Bl = Bidiagonal(dv, ev, 'L') #e is on the first subdiagonal
  ⋅  ⋅  9  4
 ```
 """
-#Convert from BLAS uplo flag to boolean internal
-Bidiagonal(dv::AbstractVector, ev::AbstractVector, uplo::Char) = begin
-    if uplo === 'U'
-        isupper = true
-    elseif uplo === 'L'
-        isupper = false
-    else
-        throw(ArgumentError("Bidiagonal uplo argument must be upper 'U' or lower 'L', got $(repr(uplo))"))
-    end
-    Bidiagonal(collect(dv), collect(ev), isupper)
+function Bidiagonal(dv::AbstractVector{T}, ev::AbstractVector{T}, uplo::Symbol) where T
+    Bidiagonal{T}(collect(dv), collect(ev), char_uplo(uplo))
 end
-function Bidiagonal(dv::AbstractVector{Td}, ev::AbstractVector{Te}, isupper::Bool) where {Td,Te}
+
+function Bidiagonal(dv::AbstractVector{Td}, ev::AbstractVector{Te}, uplo::Symbol) where {Td,Te}
     T = promote_type(Td,Te)
-    Bidiagonal(convert(Vector{T}, dv), convert(Vector{T}, ev), isupper)
+    Bidiagonal(convert(Vector{T}, dv), convert(Vector{T}, ev), uplo)
 end
 
 """
-    Bidiagonal(A, isupper::Bool)
+    Bidiagonal(A, uplo::Symbol)
 
 Construct a `Bidiagonal` matrix from the main diagonal of `A` and
-its first super- (if `isupper=true`) or sub-diagonal (if `isupper=false`).
-
-# Example
+its first super- (if `uplo=:U`) or sub-diagonal (if `uplo=:L`).
 
+# Examples
 ```jldoctest
 julia> A = [1 1 1 1; 2 2 2 2; 3 3 3 3; 4 4 4 4]
 4×4 Array{Int64,2}:
@@ -127,14 +79,14 @@ julia> A = [1 1 1 1; 2 2 2 2; 3 3 3 3; 4 4 4 4]
  3  3  3  3
  4  4  4  4
 
-julia> Bidiagonal(A, true) #contains the main diagonal and first superdiagonal of A
+julia> Bidiagonal(A, :U) #contains the main diagonal and first superdiagonal of A
 4×4 Bidiagonal{Int64}:
  1  1  ⋅  ⋅
  ⋅  2  2  ⋅
  ⋅  ⋅  3  3
  ⋅  ⋅  ⋅  4
 
-julia> Bidiagonal(A, false) #contains the main diagonal and first subdiagonal of A
+julia> Bidiagonal(A, :L) #contains the main diagonal and first subdiagonal of A
 4×4 Bidiagonal{Int64}:
  1  ⋅  ⋅  ⋅
  2  2  ⋅  ⋅
@@ -142,9 +94,9 @@ julia> Bidiagonal(A, false) #contains the main diagonal and first subdiagonal of
  ⋅  ⋅  4  4
 ```
 """
-Bidiagonal(A::AbstractMatrix, isupper::Bool)=Bidiagonal(diag(A), diag(A, isupper?1:-1), isupper)
+Bidiagonal(A::AbstractMatrix, uplo::Symbol) = Bidiagonal(diag(A), diag(A, uplo == :U ? 1 : -1), uplo)
 
-function getindex{T}(A::Bidiagonal{T}, i::Integer, j::Integer)
+function getindex(A::Bidiagonal{T}, i::Integer, j::Integer) where T
     if !((1 <= i <= size(A,2)) && (1 <= j <= size(A,2)))
         throw(BoundsError(A,(i,j)))
     end
@@ -158,18 +110,23 @@ function getindex{T}(A::Bidiagonal{T}, i::Integer, j::Integer)
 end
 
 function setindex!(A::Bidiagonal, x, i::Integer, j::Integer)
+    @boundscheck checkbounds(A, i, j)
     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."))
+        @inbounds A.dv[i] = x
+    elseif istriu(A) && (i == j - 1)
+        @inbounds A.ev[i] = x
+    elseif istril(A) && (i == j + 1)
+        @inbounds A.ev[j] = x
+    elseif !iszero(x)
+        throw(ArgumentError(string("cannot set entry ($i, $j) off the ",
+            "$(istriu(A) ? "upper" : "lower") bidiagonal band to a nonzero value ($x)")))
     end
+    return x
 end
 
 ## structured matrix methods ##
 function Base.replace_in_print_matrix(A::Bidiagonal,i::Integer,j::Integer,s::AbstractString)
-    if A.isupper
+    if A.uplo == 'U'
         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)
@@ -177,12 +134,12 @@ function Base.replace_in_print_matrix(A::Bidiagonal,i::Integer,j::Integer,s::Abs
 end
 
 #Converting from Bidiagonal to dense Matrix
-function convert{T}(::Type{Matrix{T}}, A::Bidiagonal)
+function convert(::Type{Matrix{T}}, A::Bidiagonal) where T
     n = size(A, 1)
     B = zeros(T, n, n)
     for i = 1:n - 1
         B[i,i] = A.dv[i]
-        if A.isupper
+        if A.uplo == 'U'
             B[i, i + 1] = A.ev[i]
         else
             B[i + 1, i] = A.ev[i]
@@ -191,38 +148,38 @@ function convert{T}(::Type{Matrix{T}}, A::Bidiagonal)
     B[n,n] = A.dv[n]
     return B
 end
-convert{T}(::Type{Matrix}, A::Bidiagonal{T}) = convert(Matrix{T}, A)
+convert(::Type{Matrix}, A::Bidiagonal{T}) where {T} = convert(Matrix{T}, A)
 convert(::Type{Array}, A::Bidiagonal) = convert(Matrix, A)
 full(A::Bidiagonal) = convert(Array, A)
-promote_rule{T,S}(::Type{Matrix{T}}, ::Type{Bidiagonal{S}})=Matrix{promote_type(T,S)}
+promote_rule(::Type{Matrix{T}}, ::Type{Bidiagonal{S}}) where {T,S} = Matrix{promote_type(T,S)}
 
 #Converting from Bidiagonal to Tridiagonal
 Tridiagonal(M::Bidiagonal{T}) where {T} = convert(Tridiagonal{T}, M)
-function convert{T}(::Type{Tridiagonal{T}}, A::Bidiagonal)
+function convert(::Type{Tridiagonal{T}}, A::Bidiagonal) where T
     z = zeros(T, size(A)[1]-1)
-    A.isupper ? Tridiagonal(z, convert(Vector{T},A.dv), convert(Vector{T},A.ev)) : Tridiagonal(convert(Vector{T},A.ev), convert(Vector{T},A.dv), z)
+    A.uplo == 'U' ? Tridiagonal(z, convert(Vector{T},A.dv), convert(Vector{T},A.ev)) : Tridiagonal(convert(Vector{T},A.ev), convert(Vector{T},A.dv), z)
 end
-promote_rule{T,S}(::Type{Tridiagonal{T}}, ::Type{Bidiagonal{S}})=Tridiagonal{promote_type(T,S)}
+promote_rule(::Type{Tridiagonal{T}}, ::Type{Bidiagonal{S}}) where {T,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(::Type{Bidiagonal{T}}, A::Bidiagonal{T}) where {T} = A
 # Convert Bidiagonal to Bidiagonal{T} by constructing a new instance with converted elements
-convert{T}(::Type{Bidiagonal{T}}, A::Bidiagonal) = Bidiagonal(convert(Vector{T}, A.dv), convert(Vector{T}, A.ev), A.isupper)
+convert(::Type{Bidiagonal{T}}, A::Bidiagonal) where {T} = Bidiagonal(convert(Vector{T}, A.dv), convert(Vector{T}, A.ev), A.uplo)
 # When asked to convert Bidiagonal to AbstractMatrix{T}, preserve structure by converting to Bidiagonal{T} <: AbstractMatrix{T}
-convert{T}(::Type{AbstractMatrix{T}}, A::Bidiagonal) = convert(Bidiagonal{T}, A)
+convert(::Type{AbstractMatrix{T}}, A::Bidiagonal) where {T} = convert(Bidiagonal{T}, A)
 
-broadcast(::typeof(big), B::Bidiagonal) = Bidiagonal(big.(B.dv), big.(B.ev), B.isupper)
+broadcast(::typeof(big), B::Bidiagonal) = Bidiagonal(big.(B.dv), big.(B.ev), B.uplo)
 
-similar{T}(B::Bidiagonal, ::Type{T}) = Bidiagonal{T}(similar(B.dv, T), similar(B.ev, T), B.isupper)
+similar(B::Bidiagonal, ::Type{T}) where {T} = Bidiagonal{T}(similar(B.dv, T), similar(B.ev, T), B.uplo)
 
 ###################
 # LAPACK routines #
 ###################
 
 #Singular values
-svdvals!(M::Bidiagonal{<:BlasReal}) = LAPACK.bdsdc!(M.isupper ? 'U' : 'L', 'N', M.dv, M.ev)[1]
+svdvals!(M::Bidiagonal{<:BlasReal}) = LAPACK.bdsdc!(M.uplo, 'N', M.dv, M.ev)[1]
 function svdfact!(M::Bidiagonal{<:BlasReal}; thin::Bool=true)
-    d, e, U, Vt, Q, iQ = LAPACK.bdsdc!(M.isupper ? 'U' : 'L', 'I', M.dv, M.ev)
+    d, e, U, Vt, Q, iQ = LAPACK.bdsdc!(M.uplo, 'I', M.dv, M.ev)
     SVD(U, d, Vt)
 end
 svdfact(M::Bidiagonal; thin::Bool=true) = svdfact!(copy(M),thin=thin)
@@ -236,7 +193,7 @@ function show(io::IO, M::Bidiagonal)
     println(io, summary(M), ":")
     print(io, " diag:")
     print_matrix(io, (M.dv)')
-    print(io, M.isupper?"\n super:":"\n sub:")
+    print(io, M.uplo == 'U' ? "\n super:" : "\n sub:")
     print_matrix(io, (M.ev)')
 end
 
@@ -252,38 +209,38 @@ function size(M::Bidiagonal, d::Integer)
 end
 
 #Elementary operations
-broadcast(::typeof(abs), M::Bidiagonal) = Bidiagonal(abs.(M.dv), abs.(M.ev), abs.(M.isupper))
-broadcast(::typeof(round), M::Bidiagonal) = Bidiagonal(round.(M.dv), round.(M.ev), M.isupper)
-broadcast(::typeof(trunc), M::Bidiagonal) = Bidiagonal(trunc.(M.dv), trunc.(M.ev), M.isupper)
-broadcast(::typeof(floor), M::Bidiagonal) = Bidiagonal(floor.(M.dv), floor.(M.ev), M.isupper)
-broadcast(::typeof(ceil), M::Bidiagonal) = Bidiagonal(ceil.(M.dv), ceil.(M.ev), M.isupper)
+broadcast(::typeof(abs), M::Bidiagonal) = Bidiagonal(abs.(M.dv), abs.(M.ev), M.uplo)
+broadcast(::typeof(round), M::Bidiagonal) = Bidiagonal(round.(M.dv), round.(M.ev), M.uplo)
+broadcast(::typeof(trunc), M::Bidiagonal) = Bidiagonal(trunc.(M.dv), trunc.(M.ev), M.uplo)
+broadcast(::typeof(floor), M::Bidiagonal) = Bidiagonal(floor.(M.dv), floor.(M.ev), M.uplo)
+broadcast(::typeof(ceil), M::Bidiagonal) = Bidiagonal(ceil.(M.dv), ceil.(M.ev), M.uplo)
 for func in (:conj, :copy, :real, :imag)
-    @eval ($func)(M::Bidiagonal) = Bidiagonal(($func)(M.dv), ($func)(M.ev), M.isupper)
+    @eval ($func)(M::Bidiagonal) = Bidiagonal(($func)(M.dv), ($func)(M.ev), M.uplo)
 end
-broadcast{T<:Integer}(::typeof(round), ::Type{T}, M::Bidiagonal) = Bidiagonal(round.(T, M.dv), round.(T, M.ev), M.isupper)
-broadcast{T<:Integer}(::typeof(trunc), ::Type{T}, M::Bidiagonal) = Bidiagonal(trunc.(T, M.dv), trunc.(T, M.ev), M.isupper)
-broadcast{T<:Integer}(::typeof(floor), ::Type{T}, M::Bidiagonal) = Bidiagonal(floor.(T, M.dv), floor.(T, M.ev), M.isupper)
-broadcast{T<:Integer}(::typeof(ceil), ::Type{T}, M::Bidiagonal) = Bidiagonal(ceil.(T, M.dv), ceil.(T, M.ev), M.isupper)
+broadcast(::typeof(round), ::Type{T}, M::Bidiagonal) where {T<:Integer} = Bidiagonal(round.(T, M.dv), round.(T, M.ev), M.uplo)
+broadcast(::typeof(trunc), ::Type{T}, M::Bidiagonal) where {T<:Integer} = Bidiagonal(trunc.(T, M.dv), trunc.(T, M.ev), M.uplo)
+broadcast(::typeof(floor), ::Type{T}, M::Bidiagonal) where {T<:Integer} = Bidiagonal(floor.(T, M.dv), floor.(T, M.ev), M.uplo)
+broadcast(::typeof(ceil), ::Type{T}, M::Bidiagonal) where {T<:Integer} = Bidiagonal(ceil.(T, M.dv), ceil.(T, M.ev), M.uplo)
 
-transpose(M::Bidiagonal) = Bidiagonal(M.dv, M.ev, !M.isupper)
-ctranspose(M::Bidiagonal) = Bidiagonal(conj(M.dv), conj(M.ev), !M.isupper)
+transpose(M::Bidiagonal) = Bidiagonal(M.dv, M.ev, M.uplo == 'U' ? :L : :U)
+ctranspose(M::Bidiagonal) = Bidiagonal(conj(M.dv), conj(M.ev), M.uplo == 'U' ? :L : :U)
 
-istriu(M::Bidiagonal) = M.isupper || iszero(M.ev)
-istril(M::Bidiagonal) = !M.isupper || iszero(M.ev)
+istriu(M::Bidiagonal) = M.uplo == 'U' || iszero(M.ev)
+istril(M::Bidiagonal) = M.uplo == 'L' || iszero(M.ev)
 
 function tril!(M::Bidiagonal, k::Integer=0)
     n = length(M.dv)
     if abs(k) > n
         throw(ArgumentError("requested diagonal, $k, out of bounds in matrix of size ($n,$n)"))
-    elseif M.isupper && k < 0
+    elseif M.uplo == 'U' && k < 0
         fill!(M.dv,0)
         fill!(M.ev,0)
     elseif k < -1
         fill!(M.dv,0)
         fill!(M.ev,0)
-    elseif M.isupper && k == 0
+    elseif M.uplo == 'U' && k == 0
         fill!(M.ev,0)
-    elseif !M.isupper && k == -1
+    elseif M.uplo == 'L' && k == -1
         fill!(M.dv,0)
     end
     return M
@@ -293,27 +250,27 @@ function triu!(M::Bidiagonal, k::Integer=0)
     n = length(M.dv)
     if abs(k) > n
         throw(ArgumentError("requested diagonal, $k, out of bounds in matrix of size ($n,$n)"))
-    elseif !M.isupper && k > 0
+    elseif M.uplo == 'L' && k > 0
         fill!(M.dv,0)
         fill!(M.ev,0)
     elseif k > 1
         fill!(M.dv,0)
         fill!(M.ev,0)
-    elseif !M.isupper && k == 0
+    elseif M.uplo == 'L' && k == 0
         fill!(M.ev,0)
-    elseif M.isupper && k == 1
+    elseif M.uplo == 'U' && k == 1
         fill!(M.dv,0)
     end
     return M
 end
 
-function diag{T}(M::Bidiagonal{T}, n::Integer=0)
+function diag(M::Bidiagonal{T}, n::Integer=0) where T
     if n == 0
         return M.dv
     elseif n == 1
-        return M.isupper ? M.ev : zeros(T, size(M,1)-1)
+        return M.uplo == 'U' ? M.ev : zeros(T, size(M,1)-1)
     elseif n == -1
-        return M.isupper ? zeros(T, size(M,1)-1) : M.ev
+        return M.uplo == 'L' ? M.ev : zeros(T, size(M,1)-1)
     elseif -size(M,1) < n < size(M,1)
         return zeros(T, size(M,1)-abs(n))
     else
@@ -322,29 +279,29 @@ function diag{T}(M::Bidiagonal{T}, n::Integer=0)
 end
 
 function +(A::Bidiagonal, B::Bidiagonal)
-    if A.isupper==B.isupper
-        Bidiagonal(A.dv+B.dv, A.ev+B.ev, A.isupper)
+    if A.uplo == B.uplo
+        Bidiagonal(A.dv+B.dv, A.ev+B.ev, A.uplo)
     else
-        Tridiagonal((A.isupper ? (B.ev,A.dv+B.dv,A.ev) : (A.ev,A.dv+B.dv,B.ev))...)
+        Tridiagonal((A.uplo == 'U' ? (B.ev,A.dv+B.dv,A.ev) : (A.ev,A.dv+B.dv,B.ev))...)
     end
 end
 
 function -(A::Bidiagonal, B::Bidiagonal)
-    if A.isupper==B.isupper
-        Bidiagonal(A.dv-B.dv, A.ev-B.ev, A.isupper)
+    if A.uplo == B.uplo
+        Bidiagonal(A.dv-B.dv, A.ev-B.ev, A.uplo)
     else
-        Tridiagonal((A.isupper ? (-B.ev,A.dv-B.dv,A.ev) : (A.ev,A.dv-B.dv,-B.ev))...)
+        Tridiagonal((A.uplo == 'U' ? (-B.ev,A.dv-B.dv,A.ev) : (A.ev,A.dv-B.dv,-B.ev))...)
     end
 end
 
--(A::Bidiagonal)=Bidiagonal(-A.dv,-A.ev,A.isupper)
-*(A::Bidiagonal, B::Number) = Bidiagonal(A.dv*B, A.ev*B, A.isupper)
+-(A::Bidiagonal)=Bidiagonal(-A.dv,-A.ev,A.uplo)
+*(A::Bidiagonal, B::Number) = Bidiagonal(A.dv*B, A.ev*B, A.uplo)
 *(B::Number, A::Bidiagonal) = A*B
-/(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)
+/(A::Bidiagonal, B::Number) = Bidiagonal(A.dv/B, A.ev/B, A.uplo)
+==(A::Bidiagonal, B::Bidiagonal) = (A.uplo==B.uplo) && (A.dv==B.dv) && (A.ev==B.ev)
 
-BiTriSym = Union{Bidiagonal, Tridiagonal, SymTridiagonal}
-BiTri = Union{Bidiagonal, Tridiagonal}
+const BiTriSym = Union{Bidiagonal,Tridiagonal,SymTridiagonal}
+const BiTri = Union{Bidiagonal,Tridiagonal}
 A_mul_B!(C::AbstractMatrix, A::SymTridiagonal, B::BiTriSym) = A_mul_B_td!(C, A, B)
 A_mul_B!(C::AbstractMatrix, A::BiTri, B::BiTriSym) = A_mul_B_td!(C, A, B)
 A_mul_B!(C::AbstractMatrix, A::BiTriSym, B::BiTriSym) = A_mul_B_td!(C, A, B)
@@ -368,11 +325,11 @@ function check_A_mul_B!_sizes(C, A, B)
     nA, mA = size(A)
     nB, mB = size(B)
     nC, mC = size(C)
-    if !(nA == nC)
+    if nA != nC
         throw(DimensionMismatch("sizes size(A)=$(size(A)) and size(C) = $(size(C)) must match at first entry."))
-    elseif !(mA == nB)
+    elseif mA != nB
         throw(DimensionMismatch("second entry of size(A)=$(size(A)) and first entry of size(B) = $(size(B)) must match."))
-    elseif !(mB == mC)
+    elseif mB != mC
         throw(DimensionMismatch("sizes size(B)=$(size(B)) and size(C) = $(size(C)) must match at first second entry."))
     end
 end
@@ -488,21 +445,21 @@ function A_mul_B_td!(C::AbstractMatrix, A::AbstractMatrix, B::BiTriSym)
     C
 end
 
-SpecialMatrix = Union{Bidiagonal, SymTridiagonal, Tridiagonal}
+const SpecialMatrix = Union{Bidiagonal,SymTridiagonal,Tridiagonal}
 # to avoid ambiguity warning, but shouldn't be necessary
 *(A::AbstractTriangular, B::SpecialMatrix) = Array(A) * Array(B)
 *(A::SpecialMatrix, B::SpecialMatrix) = Array(A) * Array(B)
 
 #Generic multiplication
 for func in (:*, :Ac_mul_B, :A_mul_Bc, :/, :A_rdiv_Bc)
-    @eval ($func){T}(A::Bidiagonal{T}, B::AbstractVector{T}) = ($func)(Array(A), B)
+    @eval ($func)(A::Bidiagonal{T}, B::AbstractVector{T}) where {T} = ($func)(Array(A), B)
 end
 
 #Linear solvers
 A_ldiv_B!(A::Union{Bidiagonal, AbstractTriangular}, b::AbstractVector) = naivesub!(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)
+function A_ldiv_B!(A::Union{Bidiagonal,AbstractTriangular}, B::AbstractMatrix)
     nA,mA = size(A)
     tmp = similar(B,size(B,1))
     n = size(B, 1)
@@ -517,7 +474,7 @@ function A_ldiv_B!(A::Union{Bidiagonal, AbstractTriangular}, B::AbstractMatrix)
     B
 end
 for func in (:Ac_ldiv_B!, :At_ldiv_B!)
-    @eval function ($func)(A::Union{Bidiagonal, AbstractTriangular}, B::AbstractMatrix)
+    @eval function ($func)(A::Union{Bidiagonal,AbstractTriangular}, B::AbstractMatrix)
         nA,mA = size(A)
         tmp = similar(B,size(B,1))
         n = size(B, 1)
@@ -533,12 +490,12 @@ for func in (:Ac_ldiv_B!, :At_ldiv_B!)
     end
 end
 #Generic solver using naive substitution
-function naivesub!{T}(A::Bidiagonal{T}, b::AbstractVector, x::AbstractVector = b)
+function naivesub!(A::Bidiagonal{T}, b::AbstractVector, x::AbstractVector = b) where T
     N = size(A, 2)
     if N != length(b) || N != length(x)
         throw(DimensionMismatch("second dimension of A, $N, does not match one of the lengths of x, $(length(x)), or b, $(length(b))"))
     end
-    if !A.isupper #do forward substitution
+    if A.uplo == 'L' #do forward substitution
         for j = 1:N
             x[j] = b[j]
             j > 1 && (x[j] -= A.ev[j-1] * x[j-1])
@@ -557,7 +514,7 @@ end
 ### 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})
+        function ($f)(A::Bidiagonal{TA}, B::AbstractVecOrMat{TB}) where {TA<:Number,TB<:Number}
             TAB = typeof((zero(TA)*zero(TB) + zero(TA)*zero(TB))/one(TA))
             ($g)(convert(AbstractArray{TAB}, A), copy_oftype(B, TAB))
         end
@@ -569,12 +526,12 @@ factorize(A::Bidiagonal) = A
 
 # Eigensystems
 eigvals(M::Bidiagonal) = M.dv
-function eigvecs{T}(M::Bidiagonal{T})
+function eigvecs(M::Bidiagonal{T}) where T
     n = length(M.dv)
-    Q = Array{T}(n, n)
+    Q = Matrix{T}(n,n)
     blks = [0; find(x -> x == 0, M.ev); n]
     v = zeros(T, n)
-    if M.isupper
+    if M.uplo == 'U'
         for idx_block = 1:length(blks) - 1, i = blks[idx_block] + 1:blks[idx_block + 1] #index of eigenvector
             fill!(v, zero(T))
             v[blks[idx_block] + 1] = one(T)
@@ -610,11 +567,7 @@ _valuefields(::Type{<:Tridiagonal}) = [:dl, :d, :du]
 _valuefields(::Type{<:SymTridiagonal}) = [:dv, :ev]
 _valuefields(::Type{<:AbstractTriangular}) = [:data]
 
-SpecialArrays = Union{Diagonal,
-    Bidiagonal,
-    Tridiagonal,
-    SymTridiagonal,
-    AbstractTriangular}
+const SpecialArrays = Union{Diagonal,Bidiagonal,Tridiagonal,SymTridiagonal,AbstractTriangular}
 
 @generated function fillslots!(A::SpecialArrays, x)
     ex = :(xT = convert(eltype(A), x))
@@ -625,14 +578,14 @@ SpecialArrays = Union{Diagonal,
 end
 
 # for historical reasons:
-fill!(a::AbstractTriangular, x) = fillslots!(a, x);
-fill!(D::Diagonal, x) = fillslots!(D, x);
+fill!(a::AbstractTriangular, x) = fillslots!(a, x)
+fill!(D::Diagonal, x) = fillslots!(D, x)
 
 _small_enough(A::Bidiagonal) = size(A, 1) <= 1
 _small_enough(A::Tridiagonal) = size(A, 1) <= 2
 _small_enough(A::SymTridiagonal) = size(A, 1) <= 2
 
-function fill!(A::Union{Bidiagonal, Tridiagonal, SymTridiagonal} ,x)
+function fill!(A::Union{Bidiagonal,Tridiagonal,SymTridiagonal}, x)
     xT = convert(eltype(A), x)
     (xT == zero(eltype(A)) || _small_enough(A)) && return fillslots!(A, xT)
     throw(ArgumentError("array A of type $(typeof(A)) and size $(size(A)) can
diff --git a/base/linalg/bitarray.jl b/base/linalg/bitarray.jl
index 2b053e52745dea..b591b94d0e358f 100644
--- a/base/linalg/bitarray.jl
+++ b/base/linalg/bitarray.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 function dot(x::BitVector, y::BitVector)
     # simplest way to mimic Array dot behavior
@@ -40,7 +40,7 @@ end
     #C
 #end
 
-#aCb{T, S}(A::BitMatrix{T}, B::BitMatrix{S}) = aTb(A, B)
+#aCb(A::BitMatrix{T}, B::BitMatrix{S}) where {T,S} = aTb(A, B)
 
 function triu(B::BitMatrix, k::Integer=0)
     m,n = size(B)
@@ -295,4 +295,4 @@ function transpose(B::BitMatrix)
     return Bt
 end
 
-ctranspose(B::BitArray) = transpose(B)
+ctranspose(B::Union{BitMatrix,BitVector}) = transpose(B)
diff --git a/base/linalg/blas.jl b/base/linalg/blas.jl
index 3a7a9fb4b676ef..7da0bba72cb4b5 100644
--- a/base/linalg/blas.jl
+++ b/base/linalg/blas.jl
@@ -1,14 +1,16 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module BLAS
 
+import ..axpy!
 import Base: copy!
-import Base.LinAlg: axpy!, dot
 
 export
 # Level 1
     asum,
+    axpy!,
     blascopy!,
+    dot,
     dotc,
     dotu,
     scal!,
@@ -61,17 +63,15 @@ import ..LinAlg: BlasReal, BlasComplex, BlasFloat, BlasInt, DimensionMismatch, c
 
 # utility routines
 function vendor()
-    try
-        cglobal((:openblas_set_num_threads, Base.libblas_name), Void)
-        return :openblas
-    end
-    try
-        cglobal((:openblas_set_num_threads64_, Base.libblas_name), Void)
-        return :openblas64
-    end
-    try
-        cglobal((:MKL_Set_Num_Threads, Base.libblas_name), Void)
-        return :mkl
+    lib = Libdl.dlopen_e(Base.libblas_name)
+    if lib != C_NULL
+        if Libdl.dlsym_e(lib, :openblas_set_num_threads) != C_NULL
+            return :openblas
+        elseif Libdl.dlsym_e(lib, :openblas_set_num_threads64_) != C_NULL
+            return :openblas64
+        elseif Libdl.dlsym_e(lib, :MKL_Set_Num_Threads) != C_NULL
+            return :mkl
+        end
     end
     return :unknown
 end
@@ -105,7 +105,7 @@ function set_num_threads(n::Integer)
     end
 
     # OSX BLAS looks at an environment variable
-    @static if is_apple()
+    @static if Sys.isapple()
         ENV["VECLIB_MAXIMUM_THREADS"] = n
     end
 
@@ -218,7 +218,7 @@ scal(n, DA, DX, incx) = scal!(n, DA, copy(DX), incx)
 Dot product of two vectors consisting of `n` elements of array `X` with stride `incx` and
 `n` elements of array `Y` with stride `incy`.
 
-# Example:
+# Examples
 ```jldoctest
 julia> dot(10, ones(10), 1, ones(20), 2)
 10.0
@@ -233,7 +233,7 @@ Dot function for two complex vectors, consisting of `n` elements of array `X`
 with stride `incx` and `n` elements of array `U` with stride `incy`,
 conjugating the first vector.
 
-# Example:
+# Examples
 ```jldoctest
 julia> Base.BLAS.dotc(10, im*ones(10), 1, complex.(ones(20), ones(20)), 2)
 10.0 - 10.0im
@@ -247,7 +247,7 @@ function dotc end
 Dot function for two complex vectors consisting of `n` elements of array `X`
 with stride `incx` and `n` elements of array `Y` with stride `incy`.
 
-# Example:
+# Examples
 ```jldoctest
 julia> Base.BLAS.dotu(10, im*ones(10), 1, complex.(ones(20), ones(20)), 2)
 -10.0 + 10.0im
@@ -281,11 +281,11 @@ for (fname, elty) in ((:cblas_zdotc_sub,:Complex128),
                 # *     .. Array Arguments ..
                 #       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)
+            result = Ref{$elty}()
             ccall((@blasfunc($fname), libblas), Void,
                 (BlasInt, Ptr{$elty}, BlasInt, Ptr{$elty}, BlasInt, Ptr{$elty}),
                  n, DX, incx, DY, incy, result)
-            result[1]
+            result[]
         end
     end
 end
@@ -299,29 +299,29 @@ for (fname, elty) in ((:cblas_zdotu_sub,:Complex128),
                 # *     .. Array Arguments ..
                 #       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)
+            result = Ref{$elty}()
             ccall((@blasfunc($fname), libblas), Void,
                 (BlasInt, Ptr{$elty}, BlasInt, Ptr{$elty}, BlasInt, Ptr{$elty}),
                  n, DX, incx, DY, incy, result)
-            result[1]
+            result[]
         end
     end
 end
-function dot{T<:BlasReal}(DX::Union{DenseArray{T},StridedVector{T}}, DY::Union{DenseArray{T},StridedVector{T}})
+function dot(DX::Union{DenseArray{T},StridedVector{T}}, DY::Union{DenseArray{T},StridedVector{T}}) where T<:BlasReal
     n = length(DX)
     if n != length(DY)
         throw(DimensionMismatch("dot product arguments have lengths $(length(DX)) and $(length(DY))"))
     end
     dot(n, pointer(DX), stride(DX, 1), pointer(DY), stride(DY, 1))
 end
-function dotc{T<:BlasComplex}(DX::Union{DenseArray{T},StridedVector{T}}, DY::Union{DenseArray{T},StridedVector{T}})
+function dotc(DX::Union{DenseArray{T},StridedVector{T}}, DY::Union{DenseArray{T},StridedVector{T}}) where T<:BlasComplex
     n = length(DX)
     if n != length(DY)
         throw(DimensionMismatch("dot product arguments have lengths $(length(DX)) and $(length(DY))"))
     end
     dotc(n, pointer(DX), stride(DX, 1), pointer(DY), stride(DY, 1))
 end
-function dotu{T<:BlasComplex}(DX::Union{DenseArray{T},StridedVector{T}}, DY::Union{DenseArray{T},StridedVector{T}})
+function dotu(DX::Union{DenseArray{T},StridedVector{T}}, DY::Union{DenseArray{T},StridedVector{T}}) where T<:BlasComplex
     n = length(DX)
     if n != length(DY)
         throw(DimensionMismatch("dot product arguments have lengths $(length(DX)) and $(length(DY))"))
@@ -331,12 +331,15 @@ end
 
 ## nrm2
 
+stride1(x) = stride(x,1)
+stride1(x::Array) = 1
+
 """
     nrm2(n, X, incx)
 
 2-norm of a vector consisting of `n` elements of array `X` with stride `incx`.
 
-# Example:
+# Examples
 ```jldoctest
 julia> Base.BLAS.nrm2(4, ones(8), 2)
 2.0
@@ -360,8 +363,7 @@ for (fname, elty, ret_type) in ((:dnrm2_,:Float64,:Float64),
         end
     end
 end
-nrm2(x::StridedVector) = nrm2(length(x), pointer(x), stride(x,1))
-nrm2(x::Array) = nrm2(length(x), pointer(x), 1)
+nrm2(x::Union{StridedVector,Array}) = nrm2(length(x), pointer(x), stride1(x))
 
 ## asum
 
@@ -370,7 +372,7 @@ nrm2(x::Array) = nrm2(length(x), pointer(x), 1)
 
 Sum of the absolute values of the first `n` elements of array `X` with stride `incx`.
 
-# Example:
+# Examples
 ```jldoctest
 julia> Base.BLAS.asum(5, im*ones(10), 2)
 5.0
@@ -394,8 +396,7 @@ for (fname, elty, ret_type) in ((:dasum_,:Float64,:Float64),
         end
     end
 end
-asum(x::StridedVector) = asum(length(x), pointer(x), stride(x,1))
-asum(x::Array) = asum(length(x), pointer(x), 1)
+asum(x::Union{StridedVector,Array}) = asum(length(x), pointer(x), stride1(x))
 
 ## axpy
 
@@ -404,7 +405,7 @@ asum(x::Array) = asum(length(x), pointer(x), 1)
 
 Overwrite `Y` with `a*X + Y`, where `a` is a scalar. Returns `Y`.
 
-# Example:
+# Examples
 ```jldoctest
 julia> x = [1; 2; 3];
 
@@ -439,7 +440,7 @@ for (fname, elty) in ((:daxpy_,:Float64),
         end
     end
 end
-function axpy!{T<:BlasFloat}(alpha::Number, x::Union{DenseArray{T},StridedVector{T}}, y::Union{DenseArray{T},StridedVector{T}})
+function axpy!(alpha::Number, x::Union{DenseArray{T},StridedVector{T}}, y::Union{DenseArray{T},StridedVector{T}}) where T<:BlasFloat
     if length(x) != length(y)
         throw(DimensionMismatch("x has length $(length(x)), but y has length $(length(y))"))
     end
@@ -447,9 +448,8 @@ function axpy!{T<:BlasFloat}(alpha::Number, x::Union{DenseArray{T},StridedVector
     y
 end
 
-function axpy!{T<:BlasFloat,Ti<:Integer}(alpha::Number, x::Array{T}, rx::Union{UnitRange{Ti},Range{Ti}},
-                                         y::Array{T}, ry::Union{UnitRange{Ti},Range{Ti}})
-
+function axpy!(alpha::Number, x::Array{T}, rx::Union{UnitRange{Ti},Range{Ti}},
+               y::Array{T}, ry::Union{UnitRange{Ti},Range{Ti}}) where {T<:BlasFloat,Ti<:Integer}
     if length(rx) != length(ry)
         throw(DimensionMismatch("ranges of differing lengths"))
     end
@@ -476,8 +476,7 @@ for (fname, elty) in ((:idamax_,:Float64),
         end
     end
 end
-iamax(dx::StridedVector) = iamax(length(dx), pointer(dx), stride(dx,1))
-iamax(dx::Array) = iamax(length(dx), pointer(dx), 1)
+iamax(dx::Union{StridedVector,Array}) = iamax(length(dx), pointer(dx), stride1(dx))
 
 # Level 2
 ## mv
@@ -557,11 +556,11 @@ sub-diagonals and `ku` super-diagonals. `alpha` and `beta` are scalars. Returns
 function gbmv! end
 
 """
-    gbmv(trans, m, kl, ku, alpha, A, x, beta, y)
+    gbmv(trans, m, kl, ku, alpha, A, x)
 
 Returns `alpha*A*x` or `alpha*A'*x` according to [`trans`](@ref stdlib-blas-trans).
 The matrix `A` is a general band matrix of dimension `m` by `size(A,2)` with `kl` sub-diagonals and `ku`
-super-diagonals. `alpha` and `beta` are scalars.
+super-diagonals, and `alpha` is a scalar.
 """
 function gbmv end
 
@@ -893,7 +892,7 @@ for (fname, elty) in ((:dtrsv_,:Float64),
                 (Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt},
                  Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}),
                  &uplo, &trans, &diag, &n,
-                 A, &max(1,stride(A,2)), x, &1)
+                 A, &max(1,stride(A,2)), x, &stride(x, 1))
             x
         end
         function trsv(uplo::Char, trans::Char, diag::Char, A::StridedMatrix{$elty}, x::StridedVector{$elty})
@@ -926,7 +925,7 @@ for (fname, elty) in ((:dger_,:Float64),
                  Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
                  Ptr{BlasInt}),
                  &m, &n, &α, x,
-                 &1, y, &1, A,
+                 &stride(x, 1), y, &stride(y, 1), A,
                  &max(1,stride(A,2)))
             A
         end
@@ -1466,8 +1465,8 @@ end
 
 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}})
+function copy!(dest::Array{T}, rdest::Union{UnitRange{Ti},Range{Ti}},
+               src::Array{T}, rsrc::Union{UnitRange{Ti},Range{Ti}}) where {T<:BlasFloat,Ti<:Integer}
     if minimum(rdest) < 1 || maximum(rdest) > length(dest)
         throw(ArgumentError("range out of bounds for dest, of length $(length(dest))"))
     end
diff --git a/base/linalg/bunchkaufman.jl b/base/linalg/bunchkaufman.jl
index e21acd3727754f..12763756fca5b3 100644
--- a/base/linalg/bunchkaufman.jl
+++ b/base/linalg/bunchkaufman.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## Create an extractor that extracts the modified original matrix, e.g.
 ## LD for BunchKaufman, UL for CholeskyDense, LU for LUDense and
@@ -12,8 +12,8 @@ struct BunchKaufman{T,S<:AbstractMatrix} <: Factorization{T}
     rook::Bool
     info::BlasInt
 end
-BunchKaufman{T}(A::AbstractMatrix{T}, ipiv::Vector{BlasInt}, uplo::Char, symmetric::Bool,
-    rook::Bool, info::BlasInt) =
+BunchKaufman(A::AbstractMatrix{T}, ipiv::Vector{BlasInt}, uplo::Char, symmetric::Bool,
+             rook::Bool, info::BlasInt) where {T} =
         BunchKaufman{T,typeof(A)}(A, ipiv, uplo, symmetric, rook, info)
 
 """
@@ -22,36 +22,22 @@ BunchKaufman{T}(A::AbstractMatrix{T}, ipiv::Vector{BlasInt}, uplo::Char, symmetr
 `bkfact!` is the same as [`bkfact`](@ref), but saves space by overwriting the
 input `A`, instead of creating a copy.
 """
-function bkfact!(A::StridedMatrix{<:BlasReal}, uplo::Symbol = :U,
-    symmetric::Bool = issymmetric(A), rook::Bool = false)
-
-    if !symmetric
-        throw(ArgumentError("Bunch-Kaufman decomposition is only valid for symmetric matrices"))
-    end
-    if rook
-        LD, ipiv, info = LAPACK.sytrf_rook!(char_uplo(uplo), A)
-    else
-        LD, ipiv, info = LAPACK.sytrf!(char_uplo(uplo), A)
-    end
-    BunchKaufman(LD, ipiv, char_uplo(uplo), symmetric, rook, info)
+function bkfact!(A::RealHermSymComplexSym{T,S} where {T<:BlasReal,S<:StridedMatrix}, rook::Bool = false)
+    LD, ipiv, info = rook ? LAPACK.sytrf_rook!(A.uplo, A.data) : LAPACK.sytrf!(A.uplo, A.data)
+    BunchKaufman(LD, ipiv, A.uplo, true, rook, info)
 end
-function bkfact!(A::StridedMatrix{<:BlasComplex}, uplo::Symbol=:U,
-    symmetric::Bool=issymmetric(A), rook::Bool=false)
-
-    if rook
-        if symmetric
-            LD, ipiv, info = LAPACK.sytrf_rook!(char_uplo(uplo), A)
-        else
-            LD, ipiv, info = LAPACK.hetrf_rook!(char_uplo(uplo), A)
-        end
+function bkfact!(A::Hermitian{T,S} where {T<:BlasComplex,S<:StridedMatrix{T}}, rook::Bool = false)
+    LD, ipiv, info = rook ? LAPACK.hetrf_rook!(A.uplo, A.data) : LAPACK.hetrf!(A.uplo, A.data)
+    BunchKaufman(LD, ipiv, A.uplo, false, rook, info)
+end
+function bkfact!(A::StridedMatrix{<:BlasFloat}, rook::Bool = false)
+    if ishermitian(A)
+        return bkfact!(Hermitian(A), rook)
+    elseif issymmetric(A)
+        return bkfact!(Symmetric(A), rook)
     else
-        if symmetric
-            LD, ipiv, info = LAPACK.sytrf!(char_uplo(uplo),  A)
-        else
-            LD, ipiv, info = LAPACK.hetrf!(char_uplo(uplo), A)
-        end
+        throw(ArgumentError("Bunch-Kaufman decomposition is only valid for symmetric or Hermitian matrices"))
     end
-    BunchKaufman(LD, ipiv, char_uplo(uplo), symmetric, rook, info)
 end
 
 """
@@ -66,30 +52,156 @@ If `symmetric` is `true`, `A` is assumed to be symmetric. If `symmetric` is `fal
 The following functions are available for
 `BunchKaufman` objects: [`size`](@ref), `\\`, [`inv`](@ref), [`issymmetric`](@ref), [`ishermitian`](@ref).
 
-[^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/).
 
 """
-bkfact(A::StridedMatrix{<:BlasFloat}, 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{T}) = B
-convert{T}(::Type{BunchKaufman{T}}, B::BunchKaufman) =
+bkfact(A::AbstractMatrix{T}, rook::Bool=false) where {T} =
+    bkfact!(copy_oftype(A, typeof(sqrt(one(T)))), rook)
+
+convert(::Type{BunchKaufman{T}}, B::BunchKaufman{T}) where {T} = B
+convert(::Type{BunchKaufman{T}}, B::BunchKaufman) where {T} =
     BunchKaufman(convert(Matrix{T}, B.LD), B.ipiv, B.uplo, B.symmetric, B.rook, B.info)
-convert{T}(::Type{Factorization{T}}, B::BunchKaufman{T}) = B
-convert{T}(::Type{Factorization{T}}, B::BunchKaufman) = convert(BunchKaufman{T}, B)
+convert(::Type{Factorization{T}}, B::BunchKaufman{T}) where {T} = B
+convert(::Type{Factorization{T}}, B::BunchKaufman) where {T} = convert(BunchKaufman{T}, B)
 
 size(B::BunchKaufman) = size(B.LD)
 size(B::BunchKaufman, d::Integer) = size(B.LD, d)
 issymmetric(B::BunchKaufman) = B.symmetric
 ishermitian(B::BunchKaufman) = !B.symmetric
 
+function _ipiv2perm_bk(v::AbstractVector{T}, maxi::Integer, uplo::Char) where T
+    p = T[1:maxi;]
+    uploL = uplo == 'L'
+    i = uploL ? 1 : maxi
+    # if uplo == 'U' we construct the permutation backwards
+    @inbounds while 1 <= i <= length(v)
+        vi = v[i]
+        if vi > 0 # the 1x1 blocks
+            p[i], p[vi] = p[vi], p[i]
+            i += uploL ? 1 : -1
+        else # the 2x2 blocks
+            if uploL
+                p[i + 1], p[-vi] = p[-vi], p[i + 1]
+                i += 2
+            else # 'U'
+                p[i - 1], p[-vi] = p[-vi], p[i - 1]
+                i -= 2
+            end
+        end
+    end
+    return p
+end
+
+"""
+    getindex(B::BunchKaufman, d::Symbol)
+
+Extract the factors of the Bunch-Kaufman factorization `B`. The factorization can take the
+two forms `L*D*L'` or `U*D*U'` (or `.'` in the complex symmetric case) where `L` is a
+`UnitLowerTriangular` matrix, `U` is a `UnitUpperTriangular`, and `D` is a block diagonal
+symmetric or Hermitian matrix with 1x1 or 2x2 blocks. The argument `d` can be
+- `:D`: the block diagonal matrix
+- `:U`: the upper triangular factor (if factorization is `U*D*U'`)
+- `:L`: the lower triangular factor (if factorization is `L*D*L'`)
+- `:p`: permutation vector
+- `:P`: permutation matrix
+
+# Examples
+```jldoctest
+julia> A = [1 2 3; 2 1 2; 3 2 1]
+3×3 Array{Int64,2}:
+ 1  2  3
+ 2  1  2
+ 3  2  1
+
+julia> F = bkfact(Symmetric(A, :L))
+Base.LinAlg.BunchKaufman{Float64,Array{Float64,2}}
+D factor:
+3×3 Tridiagonal{Float64}:
+ 1.0  3.0    ⋅
+ 3.0  1.0   0.0
+  ⋅   0.0  -1.0
+L factor:
+3×3 Base.LinAlg.UnitLowerTriangular{Float64,Array{Float64,2}}:
+ 1.0  0.0  0.0
+ 0.0  1.0  0.0
+ 0.5  0.5  1.0
+permutation:
+3-element Array{Int64,1}:
+ 1
+ 3
+ 2
+successful: true
+
+julia> F[:L]*F[:D]*F[:L].' - A[F[:p], F[:p]]
+3×3 Array{Float64,2}:
+ 0.0  0.0  0.0
+ 0.0  0.0  0.0
+ 0.0  0.0  0.0
+
+julia> F = bkfact(Symmetric(A));
+
+julia> F[:U]*F[:D]*F[:U].' - F[:P]*A*F[:P]'
+3×3 Array{Float64,2}:
+ 0.0  0.0  0.0
+ 0.0  0.0  0.0
+ 0.0  0.0  0.0
+```
+"""
+function getindex(B::BunchKaufman{T}, d::Symbol) where {T<:BlasFloat}
+    n = size(B, 1)
+    if d == :p
+        return _ipiv2perm_bk(B.ipiv, n, B.uplo)
+    elseif d == :P
+        return eye(T, n)[:,invperm(B[:p])]
+    elseif d == :L || d == :U || d == :D
+        if B.rook
+            # syconvf_rook just added to LAPACK 3.7.0. Uncomment and remove error when we distribute LAPACK 3.7.0
+            # LUD, od = LAPACK.syconvf_rook!(B.uplo, 'C', copy(B.LD), B.ipiv)
+            throw(ArgumentError("reconstruction rook pivoted Bunch-Kaufman factorization not implemented yet"))
+        else
+            LUD, od = LAPACK.syconv!(B.uplo, copy(B.LD), B.ipiv)
+        end
+        if d == :D
+            if B.uplo == 'L'
+                odl = od[1:n - 1]
+                return Tridiagonal(odl, diag(LUD), B.symmetric ? odl : conj.(odl))
+            else # 'U'
+                odu = od[2:n]
+                return Tridiagonal(B.symmetric ? odu : conj.(odu), diag(LUD), odu)
+            end
+        elseif d == :L
+            if B.uplo == 'L'
+                return UnitLowerTriangular(LUD)
+            else
+                throw(ArgumentError("factorization is U*D*U.' but you requested L"))
+            end
+        else # :U
+            if B.uplo == 'U'
+                return UnitUpperTriangular(LUD)
+            else
+                throw(ArgumentError("factorization is L*D*L.' but you requested U"))
+            end
+        end
+    else
+        throw(KeyError(d))
+    end
+end
+
+issuccess(B::BunchKaufman) = B.info == 0
+
+function Base.show(io::IO, mime::MIME{Symbol("text/plain")}, B::BunchKaufman)
+    println(io, summary(B))
+    println(io, "D factor:")
+    show(io, mime, B[:D])
+    println(io, "\n$(B.uplo) factor:")
+    show(io, mime, B[Symbol(B.uplo)])
+    println(io, "\npermutation:")
+    show(io, mime, B[:p])
+    print(io, "\nsuccessful: $(issuccess(B))")
+end
+
 function inv(B::BunchKaufman{<:BlasReal})
-    if B.info > 0
+    if !issuccess(B)
         throw(SingularException(B.info))
     end
 
@@ -101,7 +213,7 @@ function inv(B::BunchKaufman{<:BlasReal})
 end
 
 function inv(B::BunchKaufman{<:BlasComplex})
-    if B.info > 0
+    if !issuccess(B)
         throw(SingularException(B.info))
     end
 
@@ -120,8 +232,8 @@ function inv(B::BunchKaufman{<:BlasComplex})
     end
 end
 
-function A_ldiv_B!{T<:BlasReal}(B::BunchKaufman{T}, R::StridedVecOrMat{T})
-    if B.info > 0
+function A_ldiv_B!(B::BunchKaufman{T}, R::StridedVecOrMat{T}) where T<:BlasReal
+    if !issuccess(B)
         throw(SingularException(B.info))
     end
 
@@ -131,8 +243,8 @@ function A_ldiv_B!{T<:BlasReal}(B::BunchKaufman{T}, R::StridedVecOrMat{T})
         LAPACK.sytrs!(B.uplo, B.LD, B.ipiv, R)
     end
 end
-function A_ldiv_B!{T<:BlasComplex}(B::BunchKaufman{T}, R::StridedVecOrMat{T})
-    if B.info > 0
+function A_ldiv_B!(B::BunchKaufman{T}, R::StridedVecOrMat{T}) where T<:BlasComplex
+    if !issuccess(B)
         throw(SingularException(B.info))
     end
 
@@ -150,13 +262,18 @@ function A_ldiv_B!{T<:BlasComplex}(B::BunchKaufman{T}, R::StridedVecOrMat{T})
         end
     end
 end
+# There is no fallback solver for Bunch-Kaufman so we'll have to promote to same element type
+function A_ldiv_B!(B::BunchKaufman{T}, R::StridedVecOrMat{S}) where {T,S}
+    TS = promote_type(T,S)
+    return A_ldiv_B!(convert(BunchKaufman{TS}, B), convert(AbstractArray{TS}, R))
+end
 
 function logabsdet(F::BunchKaufman)
     M = F.LD
     p = F.ipiv
     n = size(F.LD, 1)
 
-    if F.info > 0
+    if !issuccess(F)
         return eltype(F)(-Inf), zero(eltype(F))
     end
     s = one(real(eltype(F)))
diff --git a/base/linalg/cholesky.jl b/base/linalg/cholesky.jl
index 5e4bdfd199b031..697b98eea7e5ff 100644
--- a/base/linalg/cholesky.jl
+++ b/base/linalg/cholesky.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ##########################
 # Cholesky Factorization #
@@ -10,16 +10,18 @@
 # In the methods below, LAPACK is called when possible, i.e. StridedMatrices with Float32,
 # Float64, Complex{Float32}, and Complex{Float64} element types. For other element or
 # matrix types, the unblocked Julia implementation in _chol! is used. For cholfact
-# and cholfact! pivoting is supported through a Val{Bool} argument. A type argument is
+# and cholfact! pivoting is supported through a Val(Bool) argument. A type argument is
 # necessary for type stability since the output of cholfact and cholfact! is either
 # Cholesky or PivotedCholesky. The latter is only
-# supported for the four LAPACK element types. For other types, e.g. BigFloats Val{true} will
+# supported for the four LAPACK element types. For other types, e.g. BigFloats Val(true) will
 # give an error. It is required that the input is Hermitian (including real symmetric) either
 # through the Hermitian and Symmetric views or exact symmetric or Hermitian elements which
-# is checked for and an error is thrown if the check fails. The dispatch
-# is further complicated by a limitation in the formulation of Unions. The relevant union
-# would be Union{Symmetric{T<:Real,S}, Hermitian} but, right now, it doesn't work in Julia
-# so we'll have to define methods for the two elements of the union separately.
+# is checked for and an error is thrown if the check fails.
+
+# The internal structure is as follows
+# - _chol! returns the factor and info without checking positive definiteness
+# - chol/chol! returns the factor and checks for positive definiteness
+# - cholfact/cholfact! returns Cholesky without checking positive definiteness
 
 # FixMe? The dispatch below seems overly complicated. One simplification could be to
 # merge the two Cholesky types into one. It would remove the need for Val completely but
@@ -30,9 +32,12 @@
 struct Cholesky{T,S<:AbstractMatrix} <: Factorization{T}
     factors::S
     uplo::Char
+    info::BlasInt
 end
-Cholesky{T}(A::AbstractMatrix{T}, uplo::Symbol) = Cholesky{T,typeof(A)}(A, char_uplo(uplo))
-Cholesky{T}(A::AbstractMatrix{T}, uplo::Char) = Cholesky{T,typeof(A)}(A, uplo)
+Cholesky(A::AbstractMatrix{T}, uplo::Symbol, info::BlasInt) where {T} =
+    Cholesky{T,typeof(A)}(A, char_uplo(uplo), info)
+Cholesky(A::AbstractMatrix{T}, uplo::Char, info::BlasInt) where {T} =
+    Cholesky{T,typeof(A)}(A, uplo, info)
 
 struct CholeskyPivoted{T,S<:AbstractMatrix} <: Factorization{T}
     factors::S
@@ -42,8 +47,8 @@ struct CholeskyPivoted{T,S<:AbstractMatrix} <: Factorization{T}
     tol::Real
     info::BlasInt
 end
-function CholeskyPivoted{T}(A::AbstractMatrix{T}, uplo::Char, piv::Vector{BlasInt},
-                            rank::BlasInt, tol::Real, info::BlasInt)
+function CholeskyPivoted(A::AbstractMatrix{T}, uplo::Char, piv::Vector{BlasInt},
+                            rank::BlasInt, tol::Real, info::BlasInt) where T
     CholeskyPivoted{T,typeof(A)}(A, uplo, piv, rank, tol, info)
 end
 
@@ -52,11 +57,11 @@ end
 ## BLAS/LAPACK element types
 function _chol!(A::StridedMatrix{<:BlasFloat}, ::Type{UpperTriangular})
     C, info = LAPACK.potrf!('U', A)
-    return @assertposdef UpperTriangular(C) info
+    return UpperTriangular(C), info
 end
 function _chol!(A::StridedMatrix{<:BlasFloat}, ::Type{LowerTriangular})
     C, info = LAPACK.potrf!('L', A)
-    return @assertposdef LowerTriangular(C) info
+    return LowerTriangular(C), info
 end
 
 ## Non BLAS/LAPACK element types (generic)
@@ -67,7 +72,10 @@ function _chol!(A::AbstractMatrix, ::Type{UpperTriangular})
             for i = 1:k - 1
                 A[k,k] -= A[i,k]'A[i,k]
             end
-            Akk = _chol!(A[k,k], UpperTriangular)
+            Akk, info = _chol!(A[k,k], UpperTriangular)
+            if info != 0
+                return UpperTriangular(A), info
+            end
             A[k,k] = Akk
             AkkInv = inv(Akk')
             for j = k + 1:n
@@ -78,7 +86,7 @@ function _chol!(A::AbstractMatrix, ::Type{UpperTriangular})
             end
         end
     end
-    return UpperTriangular(A)
+    return UpperTriangular(A), convert(BlasInt, 0)
 end
 function _chol!(A::AbstractMatrix, ::Type{LowerTriangular})
     n = checksquare(A)
@@ -87,7 +95,10 @@ function _chol!(A::AbstractMatrix, ::Type{LowerTriangular})
             for i = 1:k - 1
                 A[k,k] -= A[k,i]*A[k,i]'
             end
-            Akk = _chol!(A[k,k], LowerTriangular)
+            Akk, info = _chol!(A[k,k], LowerTriangular)
+            if info != 0
+                return LowerTriangular(A), info
+            end
             A[k,k] = Akk
             AkkInv = inv(Akk)
             for j = 1:k
@@ -102,39 +113,40 @@ function _chol!(A::AbstractMatrix, ::Type{LowerTriangular})
             end
         end
      end
-    return LowerTriangular(A)
+    return LowerTriangular(A), convert(BlasInt, 0)
 end
 
 ## Numbers
 function _chol!(x::Number, uplo)
     rx = real(x)
-    if rx != abs(x)
-        throw(ArgumentError("x must be positive semidefinite"))
-    end
-    rxr = sqrt(rx)
-    convert(promote_type(typeof(x), typeof(rxr)), rxr)
+    rxr = sqrt(abs(rx))
+    rval =  convert(promote_type(typeof(x), typeof(rxr)), rxr)
+    rx == abs(x) ? (rval, convert(BlasInt, 0)) : (rval, convert(BlasInt, 1))
 end
 
+chol!(x::Number, uplo) = ((C, info) = _chol!(x, uplo); @assertposdef C info)
+
 non_hermitian_error(f) = throw(ArgumentError("matrix is not symmetric/" *
     "Hermitian. This error can be avoided by calling $f(Hermitian(A)) " *
     "which will ignore either the upper or lower triangle of the matrix."))
 
 # chol!. Destructive methods for computing Cholesky factor of real symmetric or Hermitian
 # matrix
-chol!(A::Hermitian) =
-    _chol!(A.uplo == 'U' ? A.data : LinAlg.copytri!(A.data, 'L', true), UpperTriangular)
-chol!(A::Symmetric{<:Real,<:StridedMatrix}) =
-    _chol!(A.uplo == 'U' ? A.data : LinAlg.copytri!(A.data, 'L', true), UpperTriangular)
+function chol!(A::RealHermSymComplexHerm{<:Real,<:StridedMatrix})
+    C, info = _chol!(A.uplo == 'U' ? A.data : LinAlg.copytri!(A.data, 'L', true), UpperTriangular)
+    @assertposdef C info
+end
 function chol!(A::StridedMatrix)
     ishermitian(A) || non_hermitian_error("chol!")
-    return _chol!(A, UpperTriangular)
+    C, info = _chol!(A, UpperTriangular)
+    @assertposdef C info
 end
 
 
 
 # chol. Non-destructive methods for computing Cholesky factor of a real symmetric or
 # Hermitian matrix. Promotes elements to a type that is stable under square roots.
-function chol(A::Hermitian)
+function chol(A::RealHermSymComplexHerm)
     T = promote_type(typeof(chol(one(eltype(A)))), Float32)
     AA = similar(A, T, size(A))
     if A.uplo == 'U'
@@ -144,26 +156,15 @@ function chol(A::Hermitian)
     end
     chol!(Hermitian(AA, :U))
 end
-function chol{T<:Real}(A::Symmetric{T,<:AbstractMatrix})
-    TT = promote_type(typeof(chol(one(T))), Float32)
-    AA = similar(A, TT, size(A))
-    if A.uplo == 'U'
-        copy!(AA, A.data)
-    else
-        Base.ctranspose!(AA, A.data)
-    end
-    chol!(Hermitian(AA, :U))
-end
 
 ## for StridedMatrices, check that matrix is symmetric/Hermitian
 """
     chol(A) -> U
 
 Compute the Cholesky factorization of a positive definite matrix `A`
-and return the UpperTriangular matrix `U` such that `A = U'U`.
-
-# Example
+and return the [`UpperTriangular`](@ref) matrix `U` such that `A = U'U`.
 
+# Examples
 ```jldoctest
 julia> A = [1. 2.; 2. 50.]
 2×2 Array{Float64,2}:
@@ -192,46 +193,39 @@ end
 
 Compute the square root of a non-negative number `x`.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> chol(16)
 4.0
 ```
 """
-chol(x::Number, args...) = _chol!(x, nothing)
+chol(x::Number, args...) = ((C, info) = _chol!(x, nothing); @assertposdef C info)
 
 
 
 # cholfact!. Destructive methods for computing Cholesky factorization of real symmetric
 # or Hermitian matrix
-## No pivoting
-function cholfact!(A::Hermitian, ::Type{Val{false}})
+## No pivoting (default)
+function cholfact!(A::RealHermSymComplexHerm, ::Val{false}=Val(false))
     if A.uplo == 'U'
-        Cholesky(_chol!(A.data, UpperTriangular).data, 'U')
+        CU, info = _chol!(A.data, UpperTriangular)
+        Cholesky(CU.data, 'U', info)
     else
-        Cholesky(_chol!(A.data, LowerTriangular).data, 'L')
-    end
-end
-function cholfact!(A::Symmetric{<:Real}, ::Type{Val{false}})
-    if A.uplo == 'U'
-        Cholesky(_chol!(A.data, UpperTriangular).data, 'U')
-    else
-        Cholesky(_chol!(A.data, LowerTriangular).data, 'L')
+        CL, info = _chol!(A.data, LowerTriangular)
+        Cholesky(CL.data, 'L', info)
     end
 end
 
 ### for StridedMatrices, check that matrix is symmetric/Hermitian
 """
-    cholfact!(A, [uplo::Symbol,] Val{false}) -> Cholesky
+    cholfact!(A, Val(false)) -> Cholesky
 
 The same as [`cholfact`](@ref), but saves space by overwriting the input `A`,
 instead of creating a copy. An [`InexactError`](@ref) exception is thrown if
 the factorization produces a number not representable by the element type of
 `A`, e.g. for integer types.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> A = [1 2; 2 50]
 2×2 Array{Int64,2}:
@@ -239,76 +233,61 @@ julia> A = [1 2; 2 50]
  2  50
 
 julia> cholfact!(A)
-ERROR: InexactError()
+ERROR: InexactError: convert(Int64, 6.782329983125268)
 ```
 """
-function cholfact!(A::StridedMatrix, uplo::Symbol, ::Type{Val{false}})
+function cholfact!(A::StridedMatrix, ::Val{false}=Val(false))
     ishermitian(A) || non_hermitian_error("cholfact!")
-    return cholfact!(Hermitian(A, uplo), Val{false})
-end
-
-### Default to no pivoting (and storing of upper factor) when not explicit
-cholfact!(A::Hermitian) = cholfact!(A, Val{false})
-cholfact!(A::Symmetric{<:Real}) = cholfact!(A, Val{false})
-#### for StridedMatrices, check that matrix is symmetric/Hermitian
-function cholfact!(A::StridedMatrix, uplo::Symbol = :U)
-    ishermitian(A) || non_hermitian_error("cholfact!")
-    return cholfact!(Hermitian(A, uplo))
+    return cholfact!(Hermitian(A), Val(false))
 end
 
 
 ## With pivoting
 ### BLAS/LAPACK element types
 function cholfact!(A::RealHermSymComplexHerm{<:BlasReal,<:StridedMatrix},
-        ::Type{Val{true}}; tol = 0.0)
+                   ::Val{true}; tol = 0.0)
     AA, piv, rank, info = LAPACK.pstrf!(A.uplo, A.data, tol)
     return CholeskyPivoted{eltype(AA),typeof(AA)}(AA, A.uplo, piv, rank, tol, info)
 end
 
 ### Non BLAS/LAPACK element types (generic). Since generic fallback for pivoted Cholesky
 ### is not implemented yet we throw an error
-cholfact!(A::RealHermSymComplexHerm{<:Real}, ::Type{Val{true}};
+cholfact!(A::RealHermSymComplexHerm{<:Real}, ::Val{true};
     tol = 0.0) =
         throw(ArgumentError("generic pivoted Cholesky factorization is not implemented yet"))
 
 ### for StridedMatrices, check that matrix is symmetric/Hermitian
 """
-    cholfact!(A, [uplo::Symbol,] Val{true}; tol = 0.0) -> CholeskyPivoted
+    cholfact!(A, Val(true); tol = 0.0) -> CholeskyPivoted
 
 The same as [`cholfact`](@ref), but saves space by overwriting the input `A`,
 instead of creating a copy. An [`InexactError`](@ref) exception is thrown if the
 factorization produces a number not representable by the element type of `A`,
 e.g. for integer types.
 """
-function cholfact!(A::StridedMatrix, uplo::Symbol, ::Type{Val{true}}; tol = 0.0)
+function cholfact!(A::StridedMatrix, ::Val{true}; tol = 0.0)
     ishermitian(A) || non_hermitian_error("cholfact!")
-    return cholfact!(Hermitian(A, uplo), Val{true}; tol = tol)
+    return cholfact!(Hermitian(A), Val(true); tol = tol)
 end
 
 # cholfact. Non-destructive methods for computing Cholesky factorization of real symmetric
 # or Hermitian matrix
-## No pivoting
-cholfact(A::Hermitian, ::Type{Val{false}}) =
-    cholfact!(copy_oftype(A, promote_type(typeof(chol(one(eltype(A)))),Float32)), Val{false})
-cholfact(A::Symmetric{<:Real,<:StridedMatrix}, ::Type{Val{false}}) =
-    cholfact!(copy_oftype(A, promote_type(typeof(chol(one(eltype(A)))),Float32)), Val{false})
+## No pivoting (default)
+cholfact(A::RealHermSymComplexHerm{<:Real,<:StridedMatrix}, ::Val{false}=Val(false)) =
+    cholfact!(copy_oftype(A, promote_type(typeof(chol(one(eltype(A)))),Float32)))
 
 ### for StridedMatrices, check that matrix is symmetric/Hermitian
 """
-    cholfact(A, [uplo::Symbol,] Val{false}) -> Cholesky
+    cholfact(A, Val(false)) -> Cholesky
 
 Compute the Cholesky factorization of a dense symmetric positive definite matrix `A`
 and return a `Cholesky` factorization. The matrix `A` can either be a [`Symmetric`](@ref) or [`Hermitian`](@ref)
-`StridedMatrix` or a *perfectly* symmetric or Hermitian `StridedMatrix`. In the latter case,
-the optional argument `uplo` may be `:L` for using the lower part or `:U` for the upper part of `A`.
-The default is to use `:U`.
+`StridedMatrix` or a *perfectly* symmetric or Hermitian `StridedMatrix`.
 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`](@ref), [`\\`](@ref),
-[`inv`](@ref), and [`det`](@ref).
-A `PosDefException` exception is thrown in case the matrix is not positive definite.
-
-# Example
+[`inv`](@ref), [`det`](@ref), [`logdet`](@ref) and [`isposdef`](@ref).
 
+# Examples
 ```jldoctest
 julia> A = [4. 12. -16.; 12. 37. -43.; -16. -43. 98.]
 3×3 Array{Float64,2}:
@@ -319,6 +298,7 @@ julia> A = [4. 12. -16.; 12. 37. -43.; -16. -43. 98.]
 julia> C = cholfact(A)
 Base.LinAlg.Cholesky{Float64,Array{Float64,2}} with factor:
 [2.0 6.0 -8.0; 0.0 1.0 5.0; 0.0 0.0 3.0]
+successful: true
 
 julia> C[:U]
 3×3 UpperTriangular{Float64,Array{Float64,2}}:
@@ -336,67 +316,54 @@ julia> C[:L] * C[:U] == A
 true
 ```
 """
-function cholfact(A::StridedMatrix, uplo::Symbol, ::Type{Val{false}})
+function cholfact(A::StridedMatrix, ::Val{false}=Val(false))
     ishermitian(A) || non_hermitian_error("cholfact")
-    return cholfact(Hermitian(A, uplo), Val{false})
-end
-
-### Default to no pivoting (and storing of upper factor) when not explicit
-cholfact(A::Hermitian) = cholfact(A, Val{false})
-cholfact(A::Symmetric{<:Real,<:StridedMatrix}) = cholfact(A, Val{false})
-#### for StridedMatrices, check that matrix is symmetric/Hermitian
-function cholfact(A::StridedMatrix, uplo::Symbol = :U)
-    ishermitian(A) || non_hermitian_error("cholfact")
-    return cholfact(Hermitian(A, uplo))
+    return cholfact(Hermitian(A))
 end
 
 
 ## With pivoting
-cholfact(A::Hermitian, ::Type{Val{true}}; tol = 0.0) =
-        cholfact!(copy_oftype(A, promote_type(typeof(chol(one(eltype(A)))),Float32)),
-            Val{true}; tol = tol)
-cholfact(A::RealHermSymComplexHerm{<:Real,<:StridedMatrix}, ::Type{Val{true}}; tol = 0.0) =
+cholfact(A::RealHermSymComplexHerm{<:Real,<:StridedMatrix}, ::Val{true}; tol = 0.0) =
         cholfact!(copy_oftype(A, promote_type(typeof(chol(one(eltype(A)))),Float32)),
-            Val{true}; tol = tol)
+            Val(true); tol = tol)
 
 ### for StridedMatrices, check that matrix is symmetric/Hermitian
 """
-    cholfact(A, [uplo::Symbol,] Val{true}; tol = 0.0) -> CholeskyPivoted
+    cholfact(A, 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 matrix `A` can either be a [`Symmetric`](@ref)
 or [`Hermitian`](@ref) `StridedMatrix` or a *perfectly* symmetric or Hermitian `StridedMatrix`.
-In the latter case, the optional argument `uplo` 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`](@ref), [`\\`](@ref), [`inv`](@ref), [`det`](@ref), and [`rank`](@ref).
 The argument `tol` determines the tolerance for determining the rank.
 For negative values, the tolerance is the machine precision.
 """
-function cholfact(A::StridedMatrix, uplo::Symbol, ::Type{Val{true}}; tol = 0.0)
+function cholfact(A::StridedMatrix, ::Val{true}; tol = 0.0)
     ishermitian(A) || non_hermitian_error("cholfact")
-    return cholfact(Hermitian(A, uplo), Val{true}; tol = tol)
+    return cholfact(Hermitian(A), Val(true); tol = tol)
 end
 
 ## Number
 function cholfact(x::Number, uplo::Symbol=:U)
-    xf = fill(chol(x), 1, 1)
-    Cholesky(xf, uplo)
+    C, info = _chol!(x, uplo)
+    xf = fill(C, 1, 1)
+    Cholesky(xf, uplo, info)
 end
 
 
-function convert{T}(::Type{Cholesky{T}}, C::Cholesky)
+function convert(::Type{Cholesky{T}}, C::Cholesky) where T
     Cnew = convert(AbstractMatrix{T}, C.factors)
-    Cholesky{T, typeof(Cnew)}(Cnew, C.uplo)
+    Cholesky{T, typeof(Cnew)}(Cnew, C.uplo, C.info)
 end
-convert{T}(::Type{Factorization{T}}, C::Cholesky{T}) = C
-convert{T}(::Type{Factorization{T}}, C::Cholesky) = convert(Cholesky{T}, C)
-convert{T}(::Type{CholeskyPivoted{T}},C::CholeskyPivoted{T}) = C
-convert{T}(::Type{CholeskyPivoted{T}},C::CholeskyPivoted) =
+convert(::Type{Factorization{T}}, C::Cholesky{T}) where {T} = C
+convert(::Type{Factorization{T}}, C::Cholesky) where {T} = convert(Cholesky{T}, C)
+convert(::Type{CholeskyPivoted{T}},C::CholeskyPivoted{T}) where {T} = C
+convert(::Type{CholeskyPivoted{T}},C::CholeskyPivoted) where {T} =
     CholeskyPivoted(AbstractMatrix{T}(C.factors),C.uplo,C.piv,C.rank,C.tol,C.info)
-convert{T}(::Type{Factorization{T}}, C::CholeskyPivoted{T}) = C
-convert{T}(::Type{Factorization{T}}, C::CholeskyPivoted) = convert(CholeskyPivoted{T}, C)
+convert(::Type{Factorization{T}}, C::CholeskyPivoted{T}) where {T} = C
+convert(::Type{Factorization{T}}, C::CholeskyPivoted) where {T} = convert(CholeskyPivoted{T}, C)
 
 convert(::Type{AbstractMatrix}, C::Cholesky) = C.uplo == 'U' ? C[:U]'C[:U] : C[:L]*C[:L]'
 convert(::Type{AbstractArray}, C::Cholesky) = convert(AbstractMatrix, C)
@@ -413,7 +380,7 @@ convert(::Type{Matrix}, F::CholeskyPivoted) = convert(Array, convert(AbstractArr
 convert(::Type{Array}, F::CholeskyPivoted) = convert(Matrix, F)
 full(F::CholeskyPivoted) = convert(AbstractArray, F)
 
-copy(C::Cholesky) = Cholesky(copy(C.factors), C.uplo)
+copy(C::Cholesky) = Cholesky(copy(C.factors), C.uplo, C.info)
 copy(C::CholeskyPivoted) = CholeskyPivoted(copy(C.factors), C.uplo, C.piv, C.rank, C.tol, C.info)
 
 size(C::Union{Cholesky, CholeskyPivoted}) = size(C.factors)
@@ -425,7 +392,7 @@ function getindex(C::Cholesky, d::Symbol)
     d == :UL && return Symbol(C.uplo) == :U ? UpperTriangular(C.factors) : LowerTriangular(C.factors)
     throw(KeyError(d))
 end
-function getindex{T<:BlasFloat}(C::CholeskyPivoted{T}, d::Symbol)
+function getindex(C::CholeskyPivoted{T}, d::Symbol) where T<:BlasFloat
     d == :U && return UpperTriangular(Symbol(C.uplo) == d ? C.factors : C.factors')
     d == :L && return LowerTriangular(Symbol(C.uplo) == d ? C.factors : C.factors')
     d == :p && return C.piv
@@ -440,11 +407,16 @@ function getindex{T<:BlasFloat}(C::CholeskyPivoted{T}, d::Symbol)
     throw(KeyError(d))
 end
 
-show(io::IO, C::Cholesky{<:Any,<:AbstractMatrix}) =
-    (println(io, "$(typeof(C)) with factor:");show(io,C[:UL]))
+issuccess(C::Cholesky) = C.info == 0
 
-A_ldiv_B!{T<:BlasFloat}(C::Cholesky{T,<:AbstractMatrix}, B::StridedVecOrMat{T}) =
-    LAPACK.potrs!(C.uplo, C.factors, B)
+function show(io::IO, C::Cholesky{<:Any,<:AbstractMatrix})
+    println(io, "$(typeof(C)) with factor:")
+    show(io, C[:UL])
+    print(io, "\nsuccessful: $(issuccess(C))")
+end
+
+A_ldiv_B!(C::Cholesky{T,<:AbstractMatrix}, B::StridedVecOrMat{T}) where {T<:BlasFloat} =
+    @assertposdef LAPACK.potrs!(C.uplo, C.factors, B) C.info
 
 function A_ldiv_B!(C::Cholesky{<:Any,<:AbstractMatrix}, B::StridedVecOrMat)
     if C.uplo == 'L'
@@ -454,11 +426,11 @@ function A_ldiv_B!(C::Cholesky{<:Any,<:AbstractMatrix}, B::StridedVecOrMat)
     end
 end
 
-function A_ldiv_B!{T<:BlasFloat}(C::CholeskyPivoted{T}, B::StridedVector{T})
+function A_ldiv_B!(C::CholeskyPivoted{T}, B::StridedVector{T}) where T<:BlasFloat
     chkfullrank(C)
     ipermute!(LAPACK.potrs!(C.uplo, C.factors, permute!(B, C.piv)), C.piv)
 end
-function A_ldiv_B!{T<:BlasFloat}(C::CholeskyPivoted{T}, B::StridedMatrix{T})
+function A_ldiv_B!(C::CholeskyPivoted{T}, B::StridedMatrix{T}) where T<:BlasFloat
     chkfullrank(C)
     n = size(C, 1)
     for i=1:size(B, 2)
@@ -491,17 +463,22 @@ function A_ldiv_B!(C::CholeskyPivoted, B::StridedMatrix)
     end
 end
 
+isposdef(C::Cholesky) = C.info == 0
+
 function det(C::Cholesky)
+    isposdef(C) || throw(PosDefException(C.info))
     dd = one(real(eltype(C)))
-    for i in 1:size(C.factors,1)
+    @inbounds for i in 1:size(C.factors,1)
         dd *= real(C.factors[i,i])^2
     end
-    dd
+    return dd
 end
 
 function logdet(C::Cholesky)
+    # need to check first, or log will throw DomainError
+    isposdef(C) || throw(PosDefException(C.info))
     dd = zero(real(eltype(C)))
-    for i in 1:size(C.factors,1)
+    @inbounds for i in 1:size(C.factors,1)
         dd += log(real(C.factors[i,i]))
     end
     dd + dd # instead of 2.0dd which can change the type
@@ -532,10 +509,9 @@ function logdet(C::CholeskyPivoted)
 end
 
 inv!(C::Cholesky{<:BlasFloat,<:StridedMatrix}) =
-    copytri!(LAPACK.potri!(C.uplo, C.factors), C.uplo, true)
+    @assertposdef copytri!(LAPACK.potri!(C.uplo, C.factors), C.uplo, true) C.info
 
-inv(C::Cholesky{<:BlasFloat,<:StridedMatrix}) =
-    inv!(copy(C))
+inv(C::Cholesky{<:BlasFloat,<:StridedMatrix}) = inv!(copy(C))
 
 function inv(C::CholeskyPivoted)
     chkfullrank(C)
diff --git a/base/linalg/conjarray.jl b/base/linalg/conjarray.jl
index 9cad2c8da5be4d..0cd982761157b2 100644
--- a/base/linalg/conjarray.jl
+++ b/base/linalg/conjarray.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 """
     ConjArray(array)
@@ -9,7 +9,6 @@ type is usually constructed (and unwrapped) via the [`conj`](@ref) function (or
 other arrays, the `ConjArray` constructor can be used directly.
 
 # Examples
-
 ```jldoctest
 julia> [1+im, 1-im]'
 1×2 RowVector{Complex{Int64},ConjArray{Complex{Int64},1,Array{Complex{Int64},1}}}:
@@ -21,42 +20,42 @@ julia> ConjArray([1+im 0; 0 1-im])
  0+0im  1+1im
 ```
 """
-immutable ConjArray{T, N, A <: AbstractArray} <: AbstractArray{T, N}
+struct ConjArray{T,N,A<:AbstractArray} <: AbstractArray{T,N}
     parent::A
 end
 
-@inline ConjArray{T,N}(a::AbstractArray{T,N}) = ConjArray{conj_type(T), N, typeof(a)}(a)
+@inline ConjArray(a::AbstractArray{T,N}) where {T,N} = ConjArray{conj_type(T),N,typeof(a)}(a)
 
-ConjVector{T, V <: AbstractVector} = ConjArray{T, 1, V}
-@inline ConjVector{T}(v::AbstractVector{T}) = ConjArray{conj_type(T), 1, typeof(v)}(v)
+const ConjVector{T,V<:AbstractVector} = ConjArray{T,1,V}
+@inline ConjVector(v::AbstractVector{T}) where {T} = ConjArray{conj_type(T),1,typeof(v)}(v)
 
-ConjMatrix{T, M <: AbstractMatrix} = ConjArray{T, 2, M}
-@inline ConjMatrix{T}(m::AbstractMatrix{T}) = ConjArray{conj_type(T), 2, typeof(m)}(m)
+const ConjMatrix{T,M<:AbstractMatrix} = ConjArray{T,2,M}
+@inline ConjMatrix(m::AbstractMatrix{T}) where {T} = ConjArray{conj_type(T),2,typeof(m)}(m)
 
 # This type can cause the element type to change under conjugation - e.g. an array of complex arrays.
 @inline conj_type(x) = conj_type(typeof(x))
-@inline conj_type{T}(::Type{T}) = promote_op(conj, T)
+@inline conj_type(::Type{T}) where {T} = promote_op(conj, T)
 
 @inline parent(c::ConjArray) = c.parent
 @inline parent_type(c::ConjArray) = parent_type(typeof(c))
-@inline parent_type{T,N,A}(::Type{ConjArray{T,N,A}}) = A
+@inline parent_type(::Type{ConjArray{T,N,A}}) where {T,N,A} = A
 
 @inline size(a::ConjArray) = size(a.parent)
-IndexStyle{CA <: ConjArray}(::CA) = IndexStyle(parent_type(CA))
-IndexStyle{CA <: ConjArray}(::Type{CA}) = IndexStyle(parent_type(CA))
+IndexStyle(::CA) where {CA<:ConjArray} = IndexStyle(parent_type(CA))
+IndexStyle(::Type{CA}) where {CA<:ConjArray} = IndexStyle(parent_type(CA))
 
-@propagate_inbounds getindex{T,N}(a::ConjArray{T,N}, i::Int) = conj(getindex(a.parent, i))
-@propagate_inbounds getindex{T,N}(a::ConjArray{T,N}, i::Vararg{Int,N}) = conj(getindex(a.parent, i...))
-@propagate_inbounds setindex!{T,N}(a::ConjArray{T,N}, v, i::Int) = setindex!(a.parent, conj(v), i)
-@propagate_inbounds setindex!{T,N}(a::ConjArray{T,N}, v, i::Vararg{Int,N}) = setindex!(a.parent, conj(v), i...)
+@propagate_inbounds getindex(a::ConjArray{T,N}, i::Int) where {T,N} = conj(getindex(a.parent, i))
+@propagate_inbounds getindex(a::ConjArray{T,N}, i::Vararg{Int,N}) where {T,N} = conj(getindex(a.parent, i...))
+@propagate_inbounds setindex!(a::ConjArray{T,N}, v, i::Int) where {T,N} = setindex!(a.parent, conj(v), i)
+@propagate_inbounds setindex!(a::ConjArray{T,N}, v, i::Vararg{Int,N}) where {T,N} = setindex!(a.parent, conj(v), i...)
 
-@inline similar{T,N}(a::ConjArray, ::Type{T}, dims::Dims{N}) = similar(parent(a), T, dims)
+@inline similar(a::ConjArray, ::Type{T}, dims::Dims{N}) where {T,N} = similar(parent(a), T, dims)
 
 # Currently, this is default behavior for RowVector only
 @inline conj(a::ConjArray) = parent(a)
 
 # Helper functions, currently used by RowVector
 @inline _conj(a::AbstractArray) = ConjArray(a)
-@inline _conj{T<:Real}(a::AbstractArray{T}) = a
+@inline _conj(a::AbstractArray{T}) where {T<:Real} = a
 @inline _conj(a::ConjArray) = parent(a)
-@inline _conj{T<:Real}(a::ConjArray{T}) = parent(a)
+@inline _conj(a::ConjArray{T}) where {T<:Real} = parent(a)
diff --git a/base/linalg/dense.jl b/base/linalg/dense.jl
index aba54fe857f341..fa36b882dc8ed9 100644
--- a/base/linalg/dense.jl
+++ b/base/linalg/dense.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Linear algebra functions for dense matrices in column major format
 
@@ -9,7 +9,12 @@ const DOT_CUTOFF = 128
 const ASUM_CUTOFF = 32
 const NRM2_CUTOFF = 32
 
-function scale!{T<:BlasFloat}(X::Array{T}, s::T)
+# Generic cross-over constant based on benchmarking on a single thread with an i7 CPU @ 2.5GHz
+# L1 cache: 32K, L2 cache: 256K, L3 cache: 6144K
+# This constant should ideally be determined by the actual CPU cache size
+const ISONE_CUTOFF = 2^21 # 2M
+
+function scale!(X::Array{T}, s::T) where T<:BlasFloat
     s == 0 && return fill!(X, zero(T))
     s == 1 && return X
     if length(X) < SCAL_CUTOFF
@@ -20,34 +25,80 @@ function scale!{T<:BlasFloat}(X::Array{T}, s::T)
     X
 end
 
-scale!{T<:BlasFloat}(s::T, X::Array{T}) = scale!(X, s)
+scale!(s::T, X::Array{T}) where {T<:BlasFloat} = scale!(X, s)
 
-scale!{T<:BlasFloat}(X::Array{T}, s::Number) = scale!(X, convert(T, s))
-function scale!{T<:BlasComplex}(X::Array{T}, s::Real)
+scale!(X::Array{T}, s::Number) where {T<:BlasFloat} = scale!(X, convert(T, s))
+function scale!(X::Array{T}, s::Real) where T<:BlasComplex
     R = typeof(real(zero(T)))
     BLAS.scal!(2*length(X), convert(R,s), convert(Ptr{R},pointer(X)), 1)
     X
 end
 
-#Test whether a matrix is positive-definite
-isposdef!(A::StridedMatrix{<:BlasFloat}, UL::Symbol) = LAPACK.potrf!(char_uplo(UL), A)[2] == 0
+
+function isone(A::StridedMatrix)
+    m, n = size(A)
+    m != n && return false # only square matrices can satisfy x == one(x)
+    if sizeof(A) < ISONE_CUTOFF
+        _isone_triacheck(A, m)
+    else
+        _isone_cachefriendly(A, m)
+    end
+end
+
+@inline function _isone_triacheck(A::StridedMatrix, m::Int)
+    @inbounds for i in 1:m, j in i:m
+        if i == j
+            isone(A[i,i]) || return false
+        else
+            iszero(A[i,j]) && iszero(A[j,i]) || return false
+        end
+    end
+    return true
+end
+
+# Inner loop over rows to be friendly to the CPU cache
+@inline function _isone_cachefriendly(A::StridedMatrix, m::Int)
+    @inbounds for i in 1:m, j in 1:m
+        if i == j
+            isone(A[i,i]) || return false
+        else
+            iszero(A[j,i]) || return false
+        end
+    end
+    return true
+end
+
 
 """
     isposdef!(A) -> Bool
 
-Test whether a matrix is positive definite, overwriting `A` in the process.
-"""
-isposdef!(A::StridedMatrix) = ishermitian(A) && isposdef!(A, :U)
+Test whether a matrix is positive definite by trying to perform a
+Cholesky factorization of `A`, overwriting `A` in the process.
+See also [`isposdef`](@ref).
 
-isposdef{T}(A::AbstractMatrix{T}, UL::Symbol) = (S = typeof(sqrt(one(T))); isposdef!(S == T ? copy(A) : convert(AbstractMatrix{S}, A), UL))
+# Examples
+```jldoctest
+julia> A = [1. 2.; 2. 50.];
 
+julia> isposdef!(A)
+true
+
+julia> A
+2×2 Array{Float64,2}:
+ 1.0  2.0
+ 2.0  6.78233
+```
 """
-    isposdef(A) -> Bool
+isposdef!(A::AbstractMatrix) = ishermitian(A) && isposdef(cholfact!(Hermitian(A)))
 
-Test whether a matrix is positive definite.
+"""
+    isposdef(A) -> Bool
 
-# Example
+Test whether a matrix is positive definite by trying to perform a
+Cholesky factorization of `A`.
+See also [`isposdef!`](@ref)
 
+# Examples
 ```jldoctest
 julia> A = [1 2; 2 50]
 2×2 Array{Int64,2}:
@@ -58,23 +109,23 @@ julia> isposdef(A)
 true
 ```
 """
-isposdef{T}(A::AbstractMatrix{T}) = (S = typeof(sqrt(one(T))); isposdef!(S == T ? copy(A) : convert(AbstractMatrix{S}, A)))
+isposdef(A::AbstractMatrix) = ishermitian(A) && isposdef(cholfact(Hermitian(A)))
 isposdef(x::Number) = imag(x)==0 && real(x) > 0
 
 stride1(x::Array) = 1
 stride1(x::StridedVector) = stride(x, 1)::Int
 
-function norm{T<:BlasFloat, TI<:Integer}(x::StridedVector{T}, rx::Union{UnitRange{TI},Range{TI}})
+function norm(x::StridedVector{T}, rx::Union{UnitRange{TI},Range{TI}}) where {T<:BlasFloat,TI<:Integer}
     if minimum(rx) < 1 || maximum(rx) > length(x)
         throw(BoundsError(x, rx))
     end
     BLAS.nrm2(length(rx), pointer(x)+(first(rx)-1)*sizeof(T), step(rx))
 end
 
-vecnorm1{T<:BlasReal}(x::Union{Array{T},StridedVector{T}}) =
+vecnorm1(x::Union{Array{T},StridedVector{T}}) where {T<:BlasReal} =
     length(x) < ASUM_CUTOFF ? generic_vecnorm1(x) : BLAS.asum(x)
 
-vecnorm2{T<:BlasFloat}(x::Union{Array{T},StridedVector{T}}) =
+vecnorm2(x::Union{Array{T},StridedVector{T}}) where {T<:BlasFloat} =
     length(x) < NRM2_CUTOFF ? generic_vecnorm2(x) : BLAS.nrm2(x)
 
 """
@@ -83,7 +134,7 @@ vecnorm2{T<:BlasFloat}(x::Union{Array{T},StridedVector{T}}) =
 Returns the upper triangle of `M` starting from the `k`th superdiagonal,
 overwriting `M` in the process.
 
-# Example
+# Examples
 ```jldoctest
 julia> M = [1 2 3 4 5; 1 2 3 4 5; 1 2 3 4 5; 1 2 3 4 5; 1 2 3 4 5]
 5×5 Array{Int64,2}:
@@ -126,8 +177,7 @@ triu(M::Matrix, k::Integer) = triu!(copy(M), k)
 Returns the lower triangle of `M` starting from the `k`th superdiagonal, overwriting `M` in
 the process.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> M = [1 2 3 4 5; 1 2 3 4 5; 1 2 3 4 5; 1 2 3 4 5; 1 2 3 4 5]
 5×5 Array{Int64,2}:
@@ -192,8 +242,7 @@ end
 
 A `Range` giving the indices of the `k`th diagonal of the matrix `M`.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> A = [1 2 3; 4 5 6; 7 8 9]
 3×3 Array{Int64,2}:
@@ -213,8 +262,7 @@ diagind(A::AbstractMatrix, k::Integer=0) = diagind(size(A,1), size(A,2), k)
 The `k`th diagonal of a matrix, as a vector.
 Use [`diagm`](@ref) to construct a diagonal matrix.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> A = [1 2 3; 4 5 6; 7 8 9]
 3×3 Array{Int64,2}:
@@ -233,10 +281,10 @@ diag(A::AbstractMatrix, k::Integer=0) = A[diagind(A,k)]
 """
     diagm(v, k::Integer=0)
 
-Construct a matrix by placing `v` on the `k`th diagonal.
-
-# Example
+Construct a matrix by placing `v` on the `k`th diagonal. This constructs a full matrix; if
+you want a storage-efficient version with fast arithmetic, use [`Diagonal`](@ref) instead.
 
+# Examples
 ```jldoctest
 julia> diagm([1,2,3],1)
 4×4 Array{Int64,2}:
@@ -246,16 +294,16 @@ julia> diagm([1,2,3],1)
  0  0  0  0
 ```
 """
-function diagm{T}(v::AbstractVector{T}, k::Integer=0)
+function diagm(v::AbstractVector{T}, k::Integer=0) where T
     n = length(v) + abs(k)
     A = zeros(T,n,n)
     A[diagind(A,k)] = v
     A
 end
 
-diagm(x::Number) = (X = Array{typeof(x)}(1,1); X[1,1] = x; X)
+diagm(x::Number) = (X = Matrix{typeof(x)}(1,1); X[1,1] = x; X)
 
-function trace{T}(A::Matrix{T})
+function trace(A::Matrix{T}) where T
     n = checksquare(A)
     t = zero(T)
     for i=1:n
@@ -269,8 +317,7 @@ end
 
 Kronecker tensor product of two vectors or two matrices.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> A = [1 2; 3 4]
 2×2 Array{Int64,2}:
@@ -290,8 +337,8 @@ julia> kron(A, B)
  3+0im  0-3im  4+0im  0-4im
 ```
 """
-function kron{T,S}(a::AbstractMatrix{T}, b::AbstractMatrix{S})
-    R = Array{promote_op(*,T,S)}(size(a,1)*size(b,1), size(a,2)*size(b,2))
+function kron(a::AbstractMatrix{T}, b::AbstractMatrix{S}) where {T,S}
+    R = Matrix{promote_op(*,T,S)}(size(a,1)*size(b,1), size(a,2)*size(b,2))
     m = 1
     for j = 1:size(a,2), l = 1:size(b,2), i = 1:size(a,1)
         aij = a[i,j]
@@ -305,22 +352,75 @@ end
 
 kron(a::Number, b::Union{Number, AbstractVecOrMat}) = a * b
 kron(a::AbstractVecOrMat, b::Number) = a * b
-kron(a::AbstractVector, b::AbstractVector)=vec(kron(reshape(a,length(a),1),reshape(b,length(b),1)))
-kron(a::AbstractMatrix, b::AbstractVector)=kron(a,reshape(b,length(b),1))
-kron(a::AbstractVector, b::AbstractMatrix)=kron(reshape(a,length(a),1),b)
+kron(a::AbstractVector, b::AbstractVector) = vec(kron(reshape(a ,length(a), 1), reshape(b, length(b), 1)))
+kron(a::AbstractMatrix, b::AbstractVector) = kron(a, reshape(b, length(b), 1))
+kron(a::AbstractVector, b::AbstractMatrix) = kron(reshape(a, length(a), 1), b)
+
+# Matrix power
+(^)(A::AbstractMatrix, p::Integer) = p < 0 ? Base.power_by_squaring(inv(A), -p) : Base.power_by_squaring(A, p)
+function integerpow(A::AbstractMatrix{T}, p) where T
+    TT = Base.promote_op(^, T, typeof(p))
+    return (TT == T ? A : copy!(similar(A, TT), A))^Integer(p)
+end
+function schurpow(A::AbstractMatrix, p)
+    if istriu(A)
+        # Integer part
+        retmat = A ^ floor(p)
+        # Real part
+        if p - floor(p) == 0.5
+            # special case: A^0.5 === sqrtm(A)
+            retmat = retmat * sqrtm(A)
+        else
+            retmat = retmat * powm!(UpperTriangular(float.(A)), real(p - floor(p)))
+        end
+    else
+        S,Q,d = schur(complex(A))
+        # Integer part
+        R = S ^ floor(p)
+        # Real part
+        if p - floor(p) == 0.5
+            # special case: A^0.5 === sqrtm(A)
+            R = R * sqrtm(S)
+        else
+            R = R * powm!(UpperTriangular(float.(S)), real(p - floor(p)))
+        end
+        retmat = Q * R * Q'
+    end
+
+    # if A has nonpositive real eigenvalues, retmat is a nonprincipal matrix power.
+    if isreal(retmat)
+        return real(retmat)
+    else
+        return retmat
+    end
+end
+function (^)(A::AbstractMatrix{T}, p::Real) where T
+    n = checksquare(A)
+
+    # For integer powers, use power_by_squaring
+    isinteger(p) && return integerpow(A, p)
 
-^(A::AbstractMatrix, p::Integer) = p < 0 ? inv(A^-p) : Base.power_by_squaring(A,p)
+    # If possible, use diagonalization
+    if issymmetric(A)
+        return (Symmetric(A)^p)
+    end
+    if ishermitian(A)
+        return (Hermitian(A)^p)
+    end
 
-function ^(A::AbstractMatrix, p::Number)
-    if isinteger(p)
-        return A^Integer(real(p))
+    # Quicker return if A is diagonal
+    if isdiag(A)
+        retmat = copy(A)
+        for i in 1:n
+            retmat[i, i] = retmat[i, i] ^ p
+        end
+        return retmat
     end
-    checksquare(A)
-    v, X = eig(A)
-    any(v.<0) && (v = complex(v))
-    Xinv = ishermitian(A) ? X' : inv(X)
-    (X * Diagonal(v.^p)) * Xinv
+
+    # Otherwise, use Schur decomposition
+    return schurpow(A, p)
 end
+(^)(A::AbstractMatrix, p::Number) = expm(p*logm(A))
 
 # Matrix exponential
 
@@ -338,8 +438,7 @@ 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)
 
-# Example
-
+# Examples
 ```jldoctest
 julia> A = eye(2, 2)
 2×2 Array{Float64,2}:
@@ -358,7 +457,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})
+function expm!(A::StridedMatrix{T}) where T<:BlasFloat
     n = checksquare(A)
     if ishermitian(A)
         return full(expm(Hermitian(A)))
@@ -452,7 +551,7 @@ function rcswap!(i::Integer, j::Integer, X::StridedMatrix{<:Number})
 end
 
 """
-    logm(A::StridedMatrix)
+    logm(A{T}::StridedMatrix{T})
 
 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
@@ -469,8 +568,7 @@ triangular factor.
 
 [^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)
 
-# Example
-
+# Examples
 ```jldoctest
 julia> A = 2.7182818 * eye(2)
 2×2 Array{Float64,2}:
@@ -478,41 +576,38 @@ julia> A = 2.7182818 * eye(2)
  0.0      2.71828
 
 julia> logm(A)
-2×2 Array{Float64,2}:
+2×2 Symmetric{Float64,Array{Float64,2}}:
  1.0  0.0
  0.0  1.0
 ```
 """
-function logm(A::StridedMatrix)
+function logm(A::StridedMatrix{T}) where T
     # If possible, use diagonalization
+    if issymmetric(A) && T <: Real
+        return logm(Symmetric(A))
+    end
     if ishermitian(A)
-        return full(logm(Hermitian(A)))
+        return logm(Hermitian(A))
     end
 
     # Use Schur decomposition
     n = checksquare(A)
     if istriu(A)
-        retmat = full(logm(UpperTriangular(complex(A))))
-        d = diag(A)
+        return full(logm(UpperTriangular(complex(A))))
     else
-        S,Q,d = schur(complex(A))
-        R = logm(UpperTriangular(S))
-        retmat = Q * R * Q'
-    end
-
-    # Check whether the matrix has nonpositive real eigs
-    np_real_eigs = false
-    for i = 1:n
-        if imag(d[i]) < eps() && real(d[i]) <= 0
-            np_real_eigs = true
-            break
+        if isreal(A)
+            SchurF = schurfact(real(A))
+        else
+            SchurF = schurfact(A)
+        end
+        if !istriu(SchurF.T)
+            SchurS = schurfact(complex(SchurF.T))
+            logT = SchurS.Z * logm(UpperTriangular(SchurS.T)) * SchurS.Z'
+            return SchurF.Z * logT * SchurF.Z'
+        else
+            R = logm(UpperTriangular(complex(SchurF.T)))
+            return SchurF.Z * R * SchurF.Z'
         end
-    end
-
-    if isreal(A) && !np_real_eigs
-        return real(retmat)
-    else
-        return retmat
     end
 end
 function logm(a::Number)
@@ -539,8 +634,7 @@ and then the complex square root of the triangular factor.
     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)
 
-# Example
-
+# Examples
 ```jldoctest
 julia> A = [4 0; 0 4]
 2×2 Array{Int64,2}:
@@ -582,18 +676,21 @@ end
 sqrtm(a::Number) = (b = sqrt(complex(a)); imag(b) == 0 ? real(b) : b)
 sqrtm(a::Complex) = sqrt(a)
 
-function inv{T}(A::StridedMatrix{T})
+function inv(A::StridedMatrix{T}) where T
     checksquare(A)
     S = typeof((one(T)*zero(T) + one(T)*zero(T))/one(T))
     AA = convert(AbstractArray{S}, A)
     if istriu(AA)
         Ai = inv(UpperTriangular(AA))
+        Ai = convert(typeof(parent(Ai)), Ai)
     elseif istril(AA)
         Ai = inv(LowerTriangular(AA))
+        Ai = convert(typeof(parent(Ai)), Ai)
     else
-        Ai = inv(lufact(AA))
+        Ai = inv!(lufact(AA))
+        Ai = convert(typeof(parent(Ai)), Ai)
     end
-    return convert(typeof(parent(Ai)), Ai)
+    return Ai
 end
 
 """
@@ -622,10 +719,9 @@ systems. For example: `A=factorize(A); x=A\\b; y=A\\C`.
 If `factorize` is called on a Hermitian positive-definite matrix, for instance, then `factorize`
 will return a Cholesky factorization.
 
-# Example
-
+# Examples
 ```jldoctest
-julia> A = Array(Bidiagonal(ones(5, 5), true))
+julia> A = Array(Bidiagonal(ones(5, 5), :U))
 5×5 Array{Float64,2}:
  1.0  1.0  0.0  0.0  0.0
  0.0  1.0  1.0  0.0  0.0
@@ -644,7 +740,7 @@ julia> factorize(A) # factorize will check to see that A is already factorized
 This returns a `5×5 Bidiagonal{Float64}`, which can now be passed to other linear algebra functions
 (e.g. eigensolvers) which will use specialized methods for `Bidiagonal` types.
 """
-function factorize{T}(A::StridedMatrix{T})
+function factorize(A::StridedMatrix{T}) where T
     m, n = size(A)
     if m == n
         if m == 1 return A[1] end
@@ -685,12 +781,12 @@ function factorize{T}(A::StridedMatrix{T})
                     return Diagonal(A)
                 end
                 if utri1
-                    return Bidiagonal(diag(A), diag(A, -1), false)
+                    return Bidiagonal(diag(A), diag(A, -1), :L)
                 end
                 return LowerTriangular(A)
             end
             if utri
-                return Bidiagonal(diag(A), diag(A, 1), true)
+                return Bidiagonal(diag(A), diag(A, 1), :U)
             end
             if utri1
                 if (herm & (T <: Complex)) | sym
@@ -705,17 +801,19 @@ function factorize{T}(A::StridedMatrix{T})
             return UpperTriangular(A)
         end
         if herm
-            try
-                return cholfact(A)
+            cf = cholfact(A)
+            if cf.info == 0
+                return cf
+            else
+                return factorize(Hermitian(A))
             end
-            return factorize(Hermitian(A))
         end
         if sym
             return factorize(Symmetric(A))
         end
         return lufact(A)
     end
-    qrfact(A, Val{true})
+    qrfact(A, Val(true))
 end
 
 ## Moore-Penrose pseudoinverse
@@ -738,8 +836,7 @@ inverting dense ill-conditioned matrices in a least-squares sense,
 
 For more information, see [^issue8859], [^B96], [^S84], [^KY88].
 
-# Example
-
+# Examples
 ```jldoctest
 julia> M = [1.5 1.3; 1.2 1.9]
 2×2 Array{Float64,2}:
@@ -765,11 +862,11 @@ julia> M * N
 
 [^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 pinv{T}(A::StridedMatrix{T}, tol::Real)
+function pinv(A::StridedMatrix{T}, tol::Real) where T
     m, n = size(A)
     Tout = typeof(zero(T)/sqrt(one(T) + one(T)))
     if m == 0 || n == 0
-        return Array{Tout}(n, m)
+        return Matrix{Tout}(n, m)
     end
     if istril(A)
         if istriu(A)
@@ -794,7 +891,7 @@ function pinv{T}(A::StridedMatrix{T}, tol::Real)
     Sinv[find(.!isfinite.(Sinv))] = zero(Stype)
     return SVD.Vt' * (Diagonal(Sinv) * SVD.U')
 end
-function pinv{T}(A::StridedMatrix{T})
+function pinv(A::StridedMatrix{T}) where T
     tol = eps(real(float(one(T))))*maximum(size(A))
     return pinv(A, tol)
 end
@@ -811,8 +908,7 @@ end
 
 Basis for nullspace of `M`.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> M = [1 0 0; 0 1 0; 0 0 0]
 3×3 Array{Int64,2}:
@@ -827,7 +923,7 @@ julia> nullspace(M)
  1.0
 ```
 """
-function nullspace{T}(A::StridedMatrix{T})
+function nullspace(A::StridedMatrix{T}) where T
     m, n = size(A)
     (m == 0 || n == 0) && return eye(T, n)
     SVD = svdfact(A, thin = false)
@@ -849,10 +945,12 @@ function cond(A::AbstractMatrix, p::Real=2)
         return maxv == 0.0 ? oftype(real(A[1,1]),Inf) : maxv / minimum(v)
     elseif p == 1 || p == Inf
         checksquare(A)
-        return cond(lufact(A), p)
+        return _cond1Inf(A, p)
     end
     throw(ArgumentError("p-norm must be 1, 2 or Inf, got $p"))
 end
+_cond1Inf(A::StridedMatrix{<:BlasFloat}, p::Real) = _cond1Inf(lufact(A), p, norm(A, p))
+_cond1Inf(A::AbstractMatrix, p::Real)             = norm(A, p)*norm(inv(A), p)
 
 ## Lyapunov and Sylvester equation
 
@@ -864,7 +962,7 @@ end
 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 sylvester{T<:BlasFloat}(A::StridedMatrix{T},B::StridedMatrix{T},C::StridedMatrix{T})
+function sylvester(A::StridedMatrix{T},B::StridedMatrix{T},C::StridedMatrix{T}) where T<:BlasFloat
     RA, QA = schur(A)
     RB, QB = schur(B)
 
@@ -872,9 +970,9 @@ function sylvester{T<:BlasFloat}(A::StridedMatrix{T},B::StridedMatrix{T},C::Stri
     Y, scale = LAPACK.trsyl!('N','N', RA, RB, D)
     scale!(QA*A_mul_Bc(Y,QB), inv(scale))
 end
-sylvester{T<:Integer}(A::StridedMatrix{T},B::StridedMatrix{T},C::StridedMatrix{T}) = sylvester(float(A), float(B), float(C))
+sylvester(A::StridedMatrix{T}, B::StridedMatrix{T}, C::StridedMatrix{T}) where {T<:Integer} = sylvester(float(A), float(B), float(C))
 
-sylvester(a::Union{Real,Complex},b::Union{Real,Complex},c::Union{Real,Complex}) = -c / (a + b)
+sylvester(a::Union{Real,Complex}, b::Union{Real,Complex}, c::Union{Real,Complex}) = -c / (a + b)
 
 # AX + XA' + C = 0
 
@@ -885,12 +983,12 @@ Computes the solution `X` to the continuous Lyapunov equation `AX + XA' + C = 0`
 eigenvalue of `A` has a zero real part and no two eigenvalues are negative complex
 conjugates of each other.
 """
-function lyap{T<:BlasFloat}(A::StridedMatrix{T},C::StridedMatrix{T})
+function lyap(A::StridedMatrix{T}, C::StridedMatrix{T}) where {T<:BlasFloat}
     R, Q = schur(A)
 
     D = -Ac_mul_B(Q,C*Q)
     Y, scale = LAPACK.trsyl!('N', T <: Complex ? 'C' : 'T', R, R, D)
     scale!(Q*A_mul_Bc(Y,Q), inv(scale))
 end
-lyap{T<:Integer}(A::StridedMatrix{T},C::StridedMatrix{T}) = lyap(float(A), float(C))
-lyap{T<:Number}(a::T, c::T) = -c/(2a)
+lyap(A::StridedMatrix{T}, C::StridedMatrix{T}) where {T<:Integer} = lyap(float(A), float(C))
+lyap(a::T, c::T) where {T<:Number} = -c/(2a)
diff --git a/base/linalg/diagonal.jl b/base/linalg/diagonal.jl
index bb2416d56989f7..f146773d7e9b08 100644
--- a/base/linalg/diagonal.jl
+++ b/base/linalg/diagonal.jl
@@ -1,17 +1,16 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## Diagonal matrices
 
-struct Diagonal{T} <: AbstractMatrix{T}
-    diag::Vector{T}
+struct Diagonal{T,V<:AbstractVector{T}} <: AbstractMatrix{T}
+    diag::V
 end
 """
     Diagonal(A::AbstractMatrix)
 
-Constructs a matrix from the diagonal of `A`.
-
-# Example
+Construct a matrix from the diagonal of `A`.
 
+# Examples
 ```jldoctest
 julia> A = [1 2 3; 4 5 6; 7 8 9]
 3×3 Array{Int64,2}:
@@ -20,42 +19,44 @@ julia> A = [1 2 3; 4 5 6; 7 8 9]
  7  8  9
 
 julia> Diagonal(A)
-3×3 Diagonal{Int64}:
+3×3 Diagonal{Int64,Array{Int64,1}}:
  1  ⋅  ⋅
  ⋅  5  ⋅
  ⋅  ⋅  9
 ```
 """
 Diagonal(A::AbstractMatrix) = Diagonal(diag(A))
+
 """
     Diagonal(V::AbstractVector)
 
-Constructs a matrix with `V` as its diagonal.
-
-# Example
+Construct a matrix with `V` as its diagonal.
 
+# Examples
 ```jldoctest
-julia> V = [1; 2]
+julia> V = [1, 2]
 2-element Array{Int64,1}:
  1
  2
 
 julia> Diagonal(V)
-2×2 Diagonal{Int64}:
+2×2 Diagonal{Int64,Array{Int64,1}}:
  1  ⋅
  ⋅  2
 ```
 """
-Diagonal(V::AbstractVector) = Diagonal(collect(V))
+Diagonal(V::AbstractVector{T}) where {T} = Diagonal{T,typeof(V)}(V)
+Diagonal{T}(V::AbstractVector{T}) where {T} = Diagonal{T,typeof(V)}(V)
+Diagonal{T}(V::AbstractVector) where {T} = Diagonal{T}(convert(AbstractVector{T}, V))
 
-convert{T}(::Type{Diagonal{T}}, D::Diagonal{T}) = D
-convert{T}(::Type{Diagonal{T}}, D::Diagonal) = Diagonal{T}(convert(Vector{T}, D.diag))
-convert{T}(::Type{AbstractMatrix{T}}, D::Diagonal) = convert(Diagonal{T}, D)
+convert(::Type{Diagonal{T}}, D::Diagonal{T}) where {T} = D
+convert(::Type{Diagonal{T}}, D::Diagonal) where {T} = Diagonal{T}(convert(AbstractVector{T}, D.diag))
+convert(::Type{AbstractMatrix{T}}, D::Diagonal) where {T} = convert(Diagonal{T}, D)
 convert(::Type{Matrix}, D::Diagonal) = diagm(D.diag)
 convert(::Type{Array}, D::Diagonal) = convert(Matrix, D)
 full(D::Diagonal) = convert(Array, D)
 
-function similar{T}(D::Diagonal, ::Type{T})
+function similar(D::Diagonal, ::Type{T}) where T
     return Diagonal{T}(similar(D.diag, T))
 end
 
@@ -79,17 +80,17 @@ end
     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))
+diagzero(::Diagonal{T},i,j) where {T} = zero(T)
+diagzero(D::Diagonal{Matrix{T}},i,j) where {T} = zeros(T, size(D.diag[i], 1), size(D.diag[j], 2))
 
 function setindex!(D::Diagonal, v, i::Int, j::Int)
     @boundscheck checkbounds(D, i, j)
     if i == j
         @inbounds D.diag[i] = v
-    elseif v != 0
-        throw(ArgumentError("cannot set an off-diagonal index ($i, $j) to a nonzero value ($v)"))
+    elseif !iszero(v)
+        throw(ArgumentError("cannot set off-diagonal entry ($i, $j) to a nonzero value ($v)"))
     end
-    D
+    return v
 end
 
 
@@ -101,8 +102,10 @@ end
 parent(D::Diagonal) = D.diag
 
 ishermitian(D::Diagonal{<:Real}) = true
-ishermitian(D::Diagonal) = isreal(D.diag)
-issymmetric(D::Diagonal) = true
+ishermitian(D::Diagonal{<:Number}) = isreal(D.diag)
+ishermitian(D::Diagonal) = all(ishermitian, D.diag)
+issymmetric(D::Diagonal{<:Number}) = true
+issymmetric(D::Diagonal) = all(issymmetric, D.diag)
 isposdef(D::Diagonal) = all(x -> x > 0, D.diag)
 
 factorize(D::Diagonal) = D
@@ -133,24 +136,24 @@ function tril!(D::Diagonal,k::Integer=0)
     return D
 end
 
-==(Da::Diagonal, Db::Diagonal) = Da.diag == Db.diag
--(A::Diagonal)=Diagonal(-A.diag)
-+(Da::Diagonal, Db::Diagonal) = Diagonal(Da.diag + Db.diag)
--(Da::Diagonal, Db::Diagonal) = Diagonal(Da.diag - Db.diag)
+(==)(Da::Diagonal, Db::Diagonal) = Da.diag == Db.diag
+(-)(A::Diagonal) = Diagonal(-A.diag)
+(+)(Da::Diagonal, Db::Diagonal) = Diagonal(Da.diag + Db.diag)
+(-)(Da::Diagonal, Db::Diagonal) = Diagonal(Da.diag - Db.diag)
 
-*(x::Number, D::Diagonal) = Diagonal(x * D.diag)
-*(D::Diagonal, x::Number) = Diagonal(D.diag * x)
-/(D::Diagonal, x::Number) = Diagonal(D.diag / x)
-*(Da::Diagonal, Db::Diagonal) = Diagonal(Da.diag .* Db.diag)
-*(D::Diagonal, V::AbstractVector) = D.diag .* V
+(*)(x::Number, D::Diagonal) = Diagonal(x * D.diag)
+(*)(D::Diagonal, x::Number) = Diagonal(D.diag * x)
+(/)(D::Diagonal, x::Number) = Diagonal(D.diag / x)
+(*)(Da::Diagonal, Db::Diagonal) = Diagonal(Da.diag .* Db.diag)
+(*)(D::Diagonal, V::AbstractVector) = D.diag .* V
 
 (*)(A::AbstractTriangular, D::Diagonal) = A_mul_B!(copy(A), D)
 (*)(D::Diagonal, B::AbstractTriangular) = A_mul_B!(D, copy(B))
 
 (*)(A::AbstractMatrix, D::Diagonal) =
-    scale!(similar(A, promote_op(*, eltype(A), eltype(D.diag))), A, D.diag)
+    scale!(similar(A, promote_op(*, eltype(A), eltype(D.diag)), size(A)), A, D.diag)
 (*)(D::Diagonal, A::AbstractMatrix) =
-    scale!(similar(A, promote_op(*, eltype(A), eltype(D.diag))), D.diag, A)
+    scale!(similar(A, promote_op(*, eltype(A), eltype(D.diag)), size(A)), D.diag, A)
 
 A_mul_B!(A::Union{LowerTriangular,UpperTriangular}, D::Diagonal) =
     typeof(A)(A_mul_B!(A.data, D))
@@ -223,45 +226,86 @@ A_mul_B!(A::AbstractMatrix,B::Diagonal)  = scale!(A,B.diag)
 A_mul_Bt!(A::AbstractMatrix,B::Diagonal) = scale!(A,B.diag)
 A_mul_Bc!(A::AbstractMatrix,B::Diagonal) = scale!(A,conj(B.diag))
 
-/(Da::Diagonal, Db::Diagonal) = Diagonal(Da.diag ./ Db.diag)
-function A_ldiv_B!{T}(D::Diagonal{T}, v::AbstractVector{T})
+# Get ambiguous method if try to unify AbstractVector/AbstractMatrix here using AbstractVecOrMat
+A_mul_B!(out::AbstractVector, A::Diagonal, in::AbstractVector) = out .= A.diag .* in
+Ac_mul_B!(out::AbstractVector, A::Diagonal, in::AbstractVector) = out .= ctranspose.(A.diag) .* in
+At_mul_B!(out::AbstractVector, A::Diagonal, in::AbstractVector) = out .= transpose.(A.diag) .* in
+
+A_mul_B!(out::AbstractMatrix, A::Diagonal, in::AbstractMatrix) = out .= A.diag .* in
+Ac_mul_B!(out::AbstractMatrix, A::Diagonal, in::AbstractMatrix) = out .= ctranspose.(A.diag) .* in
+At_mul_B!(out::AbstractMatrix, A::Diagonal, in::AbstractMatrix) = out .= transpose.(A.diag) .* in
+
+# ambiguities with Symmetric/Hermitian
+# RealHermSymComplex[Sym]/[Herm] only include Number; invariant to [c]transpose
+A_mul_Bt(A::Diagonal, B::RealHermSymComplexSym) = A*B
+At_mul_B(A::RealHermSymComplexSym, B::Diagonal) = A*B
+A_mul_Bc(A::Diagonal, B::RealHermSymComplexHerm) = A*B
+Ac_mul_B(A::RealHermSymComplexHerm, B::Diagonal) = A*B
+
+(/)(Da::Diagonal, Db::Diagonal) = Diagonal(Da.diag ./ Db.diag)
+function A_ldiv_B!(D::Diagonal{T}, v::AbstractVector{T}) where {T}
     if length(v) != length(D.diag)
         throw(DimensionMismatch("diagonal matrix is $(length(D.diag)) by $(length(D.diag)) but right hand side has $(length(v)) rows"))
     end
-    for i=1:length(D.diag)
+    for i = 1:length(D.diag)
         d = D.diag[i]
-        if d == zero(T)
+        if iszero(d)
             throw(SingularException(i))
         end
-        v[i] *= inv(d)
+        v[i] = d\v[i]
     end
     v
 end
-function A_ldiv_B!{T}(D::Diagonal{T}, V::AbstractMatrix{T})
+function A_ldiv_B!(D::Diagonal{T}, V::AbstractMatrix{T}) where {T}
     if size(V,1) != length(D.diag)
         throw(DimensionMismatch("diagonal matrix is $(length(D.diag)) by $(length(D.diag)) but right hand side has $(size(V,1)) rows"))
     end
-    for i=1:length(D.diag)
+    for i = 1:length(D.diag)
         d = D.diag[i]
-        if d == zero(T)
+        if iszero(d)
             throw(SingularException(i))
         end
-        d⁻¹ = inv(d)
-        for j=1:size(V,2)
-            @inbounds V[i,j] *= d⁻¹
+        for j = 1:size(V,2)
+            @inbounds V[i,j] = d\V[i,j]
         end
     end
     V
 end
 
+Ac_ldiv_B!(D::Diagonal{T}, B::AbstractVecOrMat{T}) where {T} = A_ldiv_B!(conj(D), B)
+At_ldiv_B!(D::Diagonal{T}, B::AbstractVecOrMat{T}) where {T} = A_ldiv_B!(D, B)
+
+function A_rdiv_B!(A::AbstractMatrix{T}, D::Diagonal{T}) where {T}
+    dd = D.diag
+    m, n = size(A)
+    if (k = length(dd)) ≠ n
+        throw(DimensionMismatch("left hand side has $n columns but D is $k by $k"))
+    end
+    @inbounds for j in 1:n
+        ddj = dd[j]
+        if iszero(ddj)
+            throw(SingularException(j))
+        end
+        for i in 1:m
+            A[i, j] /= ddj
+        end
+    end
+    A
+end
+
+A_rdiv_Bc!(A::AbstractMatrix{T}, D::Diagonal{T}) where {T} = A_rdiv_B!(A, conj(D))
+A_rdiv_Bt!(A::AbstractMatrix{T}, D::Diagonal{T}) where {T} = A_rdiv_B!(A, D)
+
 # Methods to resolve ambiguities with `Diagonal`
 @inline *(rowvec::RowVector, D::Diagonal) = transpose(D * transpose(rowvec))
 @inline A_mul_Bt(D::Diagonal, rowvec::RowVector) = D*transpose(rowvec)
 @inline A_mul_Bc(D::Diagonal, rowvec::RowVector) = D*ctranspose(rowvec)
 
 conj(D::Diagonal) = Diagonal(conj(D.diag))
-transpose(D::Diagonal) = D
-ctranspose(D::Diagonal) = conj(D)
+transpose(D::Diagonal{<:Number}) = D
+transpose(D::Diagonal) = Diagonal(transpose.(D.diag))
+ctranspose(D::Diagonal{<:Number}) = conj(D)
+ctranspose(D::Diagonal) = Diagonal(ctranspose.(D.diag))
 
 diag(D::Diagonal) = D.diag
 trace(D::Diagonal) = sum(D.diag)
@@ -272,11 +316,15 @@ function logdet(D::Diagonal{<:Complex}) # make sure branch cut is correct
     complex(real(z), rem2pi(imag(z), RoundNearest))
 end
 # identity matrices via eye(Diagonal{type},n)
-eye{T}(::Type{Diagonal{T}}, n::Int) = Diagonal(ones(T,n))
+eye(::Type{Diagonal{T}}, n::Int) where {T} = Diagonal(ones(T,n))
 
+# Matrix functions
 expm(D::Diagonal) = Diagonal(exp.(D.diag))
+expm(D::Diagonal{<:AbstractMatrix}) = Diagonal(expm.(D.diag))
 logm(D::Diagonal) = Diagonal(log.(D.diag))
+logm(D::Diagonal{<:AbstractMatrix}) = Diagonal(logm.(D.diag))
 sqrtm(D::Diagonal) = Diagonal(sqrt.(D.diag))
+sqrtm(D::Diagonal{<:AbstractMatrix}) = Diagonal(sqrtm.(D.diag))
 
 #Linear solver
 function A_ldiv_B!(D::Diagonal, B::StridedVecOrMat)
@@ -300,7 +348,7 @@ end
 (\)(D::Diagonal, b::AbstractVector) = D.diag .\ b
 (\)(Da::Diagonal, Db::Diagonal) = Diagonal(Da.diag .\ Db.diag)
 
-function inv{T}(D::Diagonal{T})
+function inv(D::Diagonal{T}) where T
     Di = similar(D.diag, typeof(inv(zero(T))))
     for i = 1:length(D.diag)
         if D.diag[i] == zero(T)
@@ -311,14 +359,14 @@ function inv{T}(D::Diagonal{T})
     Diagonal(Di)
 end
 
-function pinv{T}(D::Diagonal{T})
+function pinv(D::Diagonal{T}) where T
     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)
+function pinv(D::Diagonal{T}, tol::Real) where T
     Di = similar(D.diag, typeof(inv(zero(T))))
     if( !isempty(D.diag) ) maxabsD = maximum(abs.(D.diag)) end
     for i = 1:length(D.diag)
diff --git a/base/linalg/eigen.jl b/base/linalg/eigen.jl
index 6354df70be1507..0e8e8d549bddf7 100644
--- a/base/linalg/eigen.jl
+++ b/base/linalg/eigen.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Eigendecomposition
 struct Eigen{T,V,S<:AbstractMatrix,U<:AbstractVector} <: Factorization{T}
@@ -35,7 +35,7 @@ isposdef(A::Union{Eigen,GeneralizedEigen}) = isreal(A.values) && all(x -> x > 0,
 Same as [`eigfact`](@ref), but saves space by overwriting the input `A` (and
 `B`), instead of creating a copy.
 """
-function eigfact!{T<:BlasReal}(A::StridedMatrix{T}; permute::Bool=true, scale::Bool=true)
+function eigfact!(A::StridedMatrix{T}; permute::Bool=true, scale::Bool=true) where T<:BlasReal
     n = size(A, 2)
     n == 0 && return Eigen(zeros(T, 0), zeros(T, 0, 0))
     issymmetric(A) && return eigfact!(Symmetric(A))
@@ -58,7 +58,7 @@ function eigfact!{T<:BlasReal}(A::StridedMatrix{T}; permute::Bool=true, scale::B
     return Eigen(complex.(WR, WI), evec)
 end
 
-function eigfact!{T<:BlasComplex}(A::StridedMatrix{T}; permute::Bool=true, scale::Bool=true)
+function eigfact!(A::StridedMatrix{T}; permute::Bool=true, scale::Bool=true) where T<:BlasComplex
     n = size(A, 2)
     n == 0 && return Eigen(zeros(T, 0), zeros(T, 0, 0))
     ishermitian(A) && return eigfact!(Hermitian(A))
@@ -79,8 +79,7 @@ before the eigenvector calculation. The option `permute=true` permutes the matri
 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.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> F = eigfact([1.0 0.0 0.0; 0.0 3.0 0.0; 0.0 0.0 18.0])
 Base.LinAlg.Eigen{Float64,Float64,Array{Float64,2},Array{Float64,1}}([1.0, 3.0, 18.0], [1.0 0.0 0.0; 0.0 1.0 0.0; 0.0 0.0 1.0])
@@ -98,7 +97,7 @@ julia> F[:vectors]
  0.0  0.0  1.0
 ```
 """
-function eigfact{T}(A::StridedMatrix{T}; permute::Bool=true, scale::Bool=true)
+function eigfact(A::StridedMatrix{T}; permute::Bool=true, scale::Bool=true) where T
     S = promote_type(Float32, typeof(one(T)/norm(one(T))))
     eigfact!(copy_oftype(A, S), permute = permute, scale = scale)
 end
@@ -117,13 +116,12 @@ end
 Computes eigenvalues (`D`) and eigenvectors (`V`) of `A`.
 See [`eigfact`](@ref) for details on the
 `irange`, `vl`, and `vu` arguments
-(for [`SymTridiagonal`](@ref), `Hermitian`, and
-`Symmetric` matrices)
+(for [`SymTridiagonal`](@ref), [`Hermitian`](@ref), and
+[`Symmetric`](@ref) matrices)
 and the `permute` and `scale` keyword arguments.
 The eigenvectors are returned columnwise.
 
-# Example
-
+# Examples
 ```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], [1.0 0.0 0.0; 0.0 1.0 0.0; 0.0 0.0 1.0])
@@ -144,8 +142,7 @@ Returns a matrix `M` whose columns are the eigenvectors of `A`. (The `k`th eigen
 be obtained from the slice `M[:, k]`.) The `permute` and `scale` keywords are the same as
 for [`eigfact`](@ref).
 
-# Example
-
+# Examples
 ```jldoctest
 julia> eigvecs([1.0 0.0 0.0; 0.0 3.0 0.0; 0.0 0.0 18.0])
 3×3 Array{Float64,2}:
@@ -156,9 +153,9 @@ julia> eigvecs([1.0 0.0 0.0; 0.0 3.0 0.0; 0.0 0.0 18.0])
 """
 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
+eigvecs(F::Union{Eigen{T,V,S,U}, GeneralizedEigen{T,V,S,U}}) where {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(F::Union{Eigen{T,V,S,U}, GeneralizedEigen{T,V,S,U}}) where {T,V,S,U} = F[:values]::U
 
 """
     eigvals!(A; permute::Bool=true, scale::Bool=true) -> values
@@ -189,11 +186,11 @@ become closer to upper triangular, and `scale=true` scales the matrix by its dia
 elements to make rows and columns more equal in norm. The default is `true` for both
 options.
 """
-function eigvals{T}(A::StridedMatrix{T}; permute::Bool=true, scale::Bool=true)
+function eigvals(A::StridedMatrix{T}; permute::Bool=true, scale::Bool=true) where T
     S = promote_type(Float32, typeof(one(T)/norm(one(T))))
     return eigvals!(copy_oftype(A, S), permute = permute, scale = scale)
 end
-function eigvals{T<:Number}(x::T; kwargs...)
+function eigvals(x::T; kwargs...) where T<:Number
     val = convert(promote_type(Float32, typeof(one(T)/norm(one(T)))), x)
     return imag(val) == 0 ? [real(val)] : [val]
 end
@@ -209,8 +206,7 @@ Note that if the eigenvalues of `A` are complex,
 this method will fail, since complex numbers cannot
 be sorted.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> A = [0 im; -im 0]
 2×2 Array{Complex{Int64},2}:
@@ -226,16 +222,17 @@ julia> A = [0 im; -1 0]
  -1+0im  0+0im
 
 julia> eigmax(A)
-ERROR: DomainError:
+ERROR: DomainError with Complex{Int64}[0+0im 0+1im; -1+0im 0+0im]:
+`A` cannot have complex eigenvalues.
 Stacktrace:
- [1] #eigmax#40(::Bool, ::Bool, ::Function, ::Array{Complex{Int64},2}) at ./linalg/eigen.jl:238
+ [1] #eigmax#52(::Bool, ::Bool, ::Function, ::Array{Complex{Int64},2}) at ./linalg/eigen.jl:238
  [2] eigmax(::Array{Complex{Int64},2}) at ./linalg/eigen.jl:236
 ```
 """
 function eigmax(A::Union{Number, StridedMatrix}; permute::Bool=true, scale::Bool=true)
     v = eigvals(A, permute = permute, scale = scale)
     if eltype(v)<:Complex
-        throw(DomainError())
+        throw(DomainError(A, "`A` cannot have complex eigenvalues."))
     end
     maximum(v)
 end
@@ -251,8 +248,7 @@ Note that if the eigenvalues of `A` are complex,
 this method will fail, since complex numbers cannot
 be sorted.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> A = [0 im; -im 0]
 2×2 Array{Complex{Int64},2}:
@@ -268,16 +264,17 @@ julia> A = [0 im; -1 0]
  -1+0im  0+0im
 
 julia> eigmin(A)
-ERROR: DomainError:
+ERROR: DomainError with Complex{Int64}[0+0im 0+1im; -1+0im 0+0im]:
+`A` cannot have complex eigenvalues.
 Stacktrace:
- [1] #eigmin#41(::Bool, ::Bool, ::Function, ::Array{Complex{Int64},2}) at ./linalg/eigen.jl:280
+ [1] #eigmin#53(::Bool, ::Bool, ::Function, ::Array{Complex{Int64},2}) at ./linalg/eigen.jl:280
  [2] eigmin(::Array{Complex{Int64},2}) at ./linalg/eigen.jl:278
 ```
 """
 function eigmin(A::Union{Number, StridedMatrix}; permute::Bool=true, scale::Bool=true)
     v = eigvals(A, permute = permute, scale = scale)
     if eltype(v)<:Complex
-        throw(DomainError())
+        throw(DomainError(A, "`A` cannot have complex eigenvalues."))
     end
     minimum(v)
 end
@@ -286,7 +283,7 @@ inv(A::Eigen) = A.vectors * inv(Diagonal(A.values)) / A.vectors
 det(A::Eigen) = prod(A.values)
 
 # Generalized eigenproblem
-function eigfact!{T<:BlasReal}(A::StridedMatrix{T}, B::StridedMatrix{T})
+function eigfact!(A::StridedMatrix{T}, B::StridedMatrix{T}) where T<:BlasReal
     issymmetric(A) && isposdef(B) && return eigfact!(Symmetric(A), Symmetric(B))
     n = size(A, 1)
     alphar, alphai, beta, _, vr = LAPACK.ggev!('N', 'V', A, B)
@@ -309,7 +306,7 @@ function eigfact!{T<:BlasReal}(A::StridedMatrix{T}, B::StridedMatrix{T})
     return GeneralizedEigen(complex.(alphar, alphai)./beta, vecs)
 end
 
-function eigfact!{T<:BlasComplex}(A::StridedMatrix{T}, B::StridedMatrix{T})
+function eigfact!(A::StridedMatrix{T}, B::StridedMatrix{T}) where T<:BlasComplex
     ishermitian(A) && isposdef(B) && return eigfact!(Hermitian(A), Hermitian(B))
     alpha, beta, _, vr = LAPACK.ggev!('N', 'V', A, B)
     return GeneralizedEigen(alpha./beta, vr)
@@ -323,7 +320,7 @@ Computes the generalized eigenvalue decomposition of `A` and `B`, returning a
 `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{TA,TB}(A::AbstractMatrix{TA}, B::AbstractMatrix{TB})
+function eigfact(A::AbstractMatrix{TA}, B::AbstractMatrix{TB}) where {TA,TB}
     S = promote_type(Float32, typeof(one(TA)/norm(one(TA))),TB)
     return eigfact!(copy_oftype(A, S), copy_oftype(B, S))
 end
@@ -338,8 +335,7 @@ Computes generalized eigenvalues (`D`) and vectors (`V`) of `A` with respect to
 `eig` is a wrapper around [`eigfact`](@ref), extracting all parts of the
 factorization to a tuple; where possible, using [`eigfact`](@ref) is recommended.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> A = [1 0; 0 -1]
 2×2 Array{Int64,2}:
@@ -369,12 +365,12 @@ end
 
 Same as [`eigvals`](@ref), but saves space by overwriting the input `A` (and `B`), instead of creating copies.
 """
-function eigvals!{T<:BlasReal}(A::StridedMatrix{T}, B::StridedMatrix{T})
+function eigvals!(A::StridedMatrix{T}, B::StridedMatrix{T}) where T<:BlasReal
     issymmetric(A) && isposdef(B) && return eigvals!(Symmetric(A), Symmetric(B))
     alphar, alphai, beta, vl, vr = LAPACK.ggev!('N', 'N', A, B)
     return (iszero(alphai) ? alphar : complex.(alphar, alphai))./beta
 end
-function eigvals!{T<:BlasComplex}(A::StridedMatrix{T}, B::StridedMatrix{T})
+function eigvals!(A::StridedMatrix{T}, B::StridedMatrix{T}) where T<:BlasComplex
     ishermitian(A) && isposdef(B) && return eigvals!(Hermitian(A), Hermitian(B))
     alpha, beta, vl, vr = LAPACK.ggev!('N', 'N', A, B)
     alpha./beta
@@ -385,8 +381,7 @@ end
 
 Computes the generalized eigenvalues of `A` and `B`.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> A = [1 0; 0 -1]
 2×2 Array{Int64,2}:
@@ -404,7 +399,7 @@ julia> eigvals(A,B)
  0.0-1.0im
 ```
 """
-function eigvals{TA,TB}(A::AbstractMatrix{TA}, B::AbstractMatrix{TB})
+function eigvals(A::AbstractMatrix{TA}, B::AbstractMatrix{TB}) where {TA,TB}
     S = promote_type(Float32, typeof(one(TA)/norm(one(TA))),TB)
     return eigvals!(copy_oftype(A, S), copy_oftype(B, S))
 end
@@ -415,8 +410,7 @@ end
 Returns a matrix `M` whose columns are the generalized eigenvectors of `A` and `B`. (The `k`th eigenvector can
 be obtained from the slice `M[:, k]`.)
 
-# Example
-
+# Examples
 ```jldoctest
 julia> A = [1 0; 0 -1]
 2×2 Array{Int64,2}:
diff --git a/base/linalg/exceptions.jl b/base/linalg/exceptions.jl
index 40320246f420b4..4b0a72e251950d 100644
--- a/base/linalg/exceptions.jl
+++ b/base/linalg/exceptions.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 export LAPACKException,
        ARPACKException,
@@ -6,11 +6,11 @@ export LAPACKException,
        PosDefException,
        RankDeficientException
 
-mutable struct LAPACKException <: Exception
+struct LAPACKException <: Exception
     info::BlasInt
 end
 
-mutable struct ARPACKException <: Exception
+struct ARPACKException <: Exception
     info::String
 end
 
@@ -25,14 +25,14 @@ function ARPACKException(i::Integer)
     return ARPACKException("unspecified ARPACK error: $i")
 end
 
-mutable struct SingularException <: Exception
+struct SingularException <: Exception
     info::BlasInt
 end
 
-mutable struct PosDefException <: Exception
+struct PosDefException <: Exception
     info::BlasInt
 end
 
-mutable struct RankDeficientException <: Exception
+struct RankDeficientException <: Exception
     info::BlasInt
 end
diff --git a/base/linalg/factorization.jl b/base/linalg/factorization.jl
index 7a3a2d881fc613..e3b10d258857cc 100644
--- a/base/linalg/factorization.jl
+++ b/base/linalg/factorization.jl
@@ -1,10 +1,10 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## Matrix factorizations and decompositions
 
 abstract type Factorization{T} end
 
-eltype{T}(::Type{Factorization{T}}) = T
+eltype(::Type{Factorization{T}}) where {T} = T
 transpose(F::Factorization) = error("transpose not implemented for $(typeof(F))")
 ctranspose(F::Factorization) = error("ctranspose not implemented for $(typeof(F))")
 
@@ -16,6 +16,25 @@ macro assertnonsingular(A, info)
    :($(esc(info)) == 0 ? $(esc(A)) : throw(SingularException($(esc(info)))))
 end
 
+"""
+    issuccess(F::Factorization)
+
+Test that a factorization of a matrix succeeded.
+
+```jldoctest
+julia> cholfact([1 0; 0 1])
+Base.LinAlg.Cholesky{Float64,Array{Float64,2}} with factor:
+[1.0 0.0; 0.0 1.0]
+successful: true
+
+julia> cholfact([1 0; 0 -1])
+Base.LinAlg.Cholesky{Float64,Array{Float64,2}} with factor:
+[1.0 0.0; 0.0 -1.0]
+successful: false
+```
+"""
+issuccess(F::Factorization)
+
 function logdet(F::Factorization)
     d, s = logabsdet(F)
     return d + log(s)
@@ -27,12 +46,16 @@ function det(F::Factorization)
 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)))
+convert(::Type{Factorization{T}}, F::Factorization{T}) where {T} = F
+inv(F::Factorization{T}) where {T} = A_ldiv_B!(F, eye(T, size(F,1)))
+
+Base.hash(F::Factorization, h::UInt) = mapreduce(f -> hash(getfield(F, f)), hash, h, 1:nfields(F))
+Base.:(==)(  F::T, G::T) where {T<:Factorization} = all(f -> getfield(F, f) == getfield(G, f), 1:nfields(F))
+Base.isequal(F::T, G::T) where {T<:Factorization} = all(f -> isequal(getfield(F, f), getfield(G, f)), 1:nfields(F))
 
 # 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::VecOrMat{Complex{T}})
+function (\)(F::Factorization{T}, B::VecOrMat{Complex{T}}) where T<:BlasReal
     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)), _ret_size(F, B))
@@ -45,7 +68,7 @@ for (f1, f2) in ((:\, :A_ldiv_B!),
             TFB = typeof(oneunit(eltype(B)) / oneunit(eltype(F)))
             BB = similar(B, TFB, size(B))
             copy!(BB, B)
-            $f2(convert(Factorization{TFB}, F), BB)
+            $f2(F, BB)
         end
     end
 end
diff --git a/base/linalg/generic.jl b/base/linalg/generic.jl
index da32703c0e9c60..1666b8bf3f3d7a 100644
--- a/base/linalg/generic.jl
+++ b/base/linalg/generic.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## linalg.jl: Some generic Linear Algebra definitions
 
@@ -54,8 +54,7 @@ If `A` is a matrix and `b` is a vector, then `scale!(A,b)` scales each column `i
 thrown if the scaling produces a number not representable by the element type of `A`,
 e.g. for integer types.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> a = [1 2; 3 4]
 2×2 Array{Int64,2}:
@@ -91,8 +90,7 @@ scale!(s::Number, X::AbstractArray) = generic_scale!(s, X)
 
 Compute the cross product of two 3-vectors.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> a = [0;1;0]
 3-element Array{Int64,1}:
@@ -121,8 +119,7 @@ cross(a::AbstractVector, b::AbstractVector) =
 
 Upper triangle of a matrix.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> a = ones(4,4)
 4×4 Array{Float64,2}:
@@ -146,8 +143,7 @@ triu(M::AbstractMatrix) = triu!(copy(M))
 
 Lower triangle of a matrix.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> a = ones(4,4)
 4×4 Array{Float64,2}:
@@ -171,8 +167,7 @@ tril(M::AbstractMatrix) = tril!(copy(M))
 
 Returns the upper triangle of `M` starting from the `k`th superdiagonal.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> a = ones(4,4)
 4×4 Array{Float64,2}:
@@ -203,8 +198,7 @@ triu(M::AbstractMatrix,k::Integer) = triu!(copy(M),k)
 
 Returns the lower triangle of `M` starting from the `k`th superdiagonal.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> a = ones(4,4)
 4×4 Array{Float64,2}:
@@ -254,8 +248,7 @@ diff(a::AbstractVector) = [ a[i+1] - a[i] for i=1:length(a)-1 ]
 Finite difference operator of matrix or vector `A`. If `A` is a matrix,
 compute the finite difference over a dimension `dim` (default `1`).
 
-# Example
-
+# Examples
 ```jldoctest
 julia> a = [2 4; 6 16]
 2×2 Array{Int64,2}:
@@ -287,8 +280,7 @@ gradient(F::AbstractVector) = gradient(F, [1:length(F);])
 Compute differences along vector `F`, using `h` as the spacing between points. The default
 spacing is one.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> a = [2,4,6,8];
 
@@ -304,7 +296,7 @@ gradient(F::AbstractVector, h::Real) = gradient(F, [h*(1:length(F));])
 
 diag(A::AbstractVector) = throw(ArgumentError("use diagm instead of diag to construct a diagonal matrix"))
 
-#diagm{T}(v::AbstractVecOrMat{T})
+#diagm(v::AbstractVecOrMat{T}) where {T}
 
 ###########################################################################################
 # Inner products and norms
@@ -350,7 +342,7 @@ end
 # faster computation of norm(x)^2, avoiding overflow for integers
 norm_sqr(x) = norm(x)^2
 norm_sqr(x::Number) = abs2(x)
-norm_sqr{T<:Integer}(x::Union{T,Complex{T},Rational{T}}) = abs2(float(x))
+norm_sqr(x::Union{T,Complex{T},Rational{T}}) where {T<:Integer} = abs2(float(x))
 
 function generic_vecnorm2(x)
     maxabs = vecnormInf(x)
@@ -412,16 +404,24 @@ vecnorm2(x) = generic_vecnorm2(x)
 vecnormp(x, p) = generic_vecnormp(x, p)
 
 """
-    vecnorm(A, [p::Real=2])
+    vecnorm(A, p::Real=2)
 
 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.
+The `p`-norm is defined as:
+```math
+\\|A\\|_p = \\left( \\sum_{i=1}^n | a_i | ^p \\right)^{1/p}
+```
+with ``a_i`` the entries of ``A`` and ``n`` its length.
 
-# Example
+`p` can assume any numeric value (even though not all values produce a
+mathematically valid vector norm). In particular, `vecnorm(A, Inf)` returns the largest value
+in `abs(A)`, whereas `vecnorm(A, -Inf)` returns the smallest. If `A` is a matrix and `p=2`,
+then this is equivalent to the Frobenius norm.
 
+# Examples
 ```jldoctest
 julia> vecnorm([1 2 3; 4 5 6; 7 8 9])
 16.881943016134134
@@ -447,14 +447,18 @@ function vecnorm(itr, p::Real=2)
         vecnormp(itr,p)
     end
 end
-@inline vecnorm(x::Number, p::Real=2) = p == 0 ? (x==0 ? zero(abs(x)) : oneunit(abs(x))) : abs(x)
 
-norm(x::AbstractVector, p::Real=2) = vecnorm(x, p)
+"""
+    vecnorm(x::Number, p::Real=2)
+
+For numbers, return ``\\left( |x|^p \\right) ^{1/p}``.
+"""
+@inline vecnorm(x::Number, p::Real=2) = p == 0 ? (x==0 ? zero(abs(x)) : oneunit(abs(x))) : abs(x)
 
-function norm1{T}(A::AbstractMatrix{T})
+function norm1(A::AbstractMatrix{T}) where T
     m, n = size(A)
     Tnorm = typeof(float(real(zero(T))))
-    Tsum = promote_type(Float64,Tnorm)
+    Tsum = promote_type(Float64, Tnorm)
     nrm::Tsum = 0
     @inbounds begin
         for j = 1:n
@@ -467,16 +471,16 @@ function norm1{T}(A::AbstractMatrix{T})
     end
     return convert(Tnorm, nrm)
 end
-function norm2{T}(A::AbstractMatrix{T})
+function norm2(A::AbstractMatrix{T}) where T
     m,n = size(A)
     if m == 1 || n == 1 return vecnorm2(A) end
     Tnorm = typeof(float(real(zero(T))))
     (m == 0 || n == 0) ? zero(Tnorm) : convert(Tnorm, svdvals(A)[1])
 end
-function normInf{T}(A::AbstractMatrix{T})
+function normInf(A::AbstractMatrix{T}) where T
     m,n = size(A)
     Tnorm = typeof(float(real(zero(T))))
-    Tsum = promote_type(Float64,Tnorm)
+    Tsum = promote_type(Float64, Tnorm)
     nrm::Tsum = 0
     @inbounds begin
         for i = 1:m
@@ -491,18 +495,26 @@ function normInf{T}(A::AbstractMatrix{T})
 end
 
 """
-    norm(A, [p::Real=2])
+    norm(A::AbstractArray, p::Real=2)
+
+Compute the `p`-norm of a vector or the operator norm of a matrix `A`,
+defaulting to the 2-norm.
+
+    norm(A::AbstractVector, p::Real=2)
 
-Compute the `p`-norm of a vector or the operator norm of a matrix `A`, defaulting to the `p=2`-norm.
+For vectors, this is equivalent to [`vecnorm`](@ref) and equal to:
+```math
+\\|A\\|_p = \\left( \\sum_{i=1}^n | a_i | ^p \\right)^{1/p}
+```
+with ``a_i`` the entries of ``A`` and ``n`` its length.
 
-For vectors, `p` can assume any numeric value (even though not all values produce a
+`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.
 
-# Example
-
+# Examples
 ```jldoctest
-julia> v = [3;-2;6]
+julia> v = [3, -2, 6]
 3-element Array{Int64,1}:
   3
  -2
@@ -514,13 +526,31 @@ julia> norm(v)
 julia> norm(v, Inf)
 6.0
 ```
+"""
+norm(x::AbstractVector, p::Real=2) = vecnorm(x, p)
+
+"""
+    norm(A::AbstractMatrix, p::Real=2)
 
 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`](@ref) to compute the Frobenius norm.
 
-# Example
+When `p=1`, the matrix norm is the maximum absolute column sum of `A`:
+```math
+\\|A\\|_1 = \\max_{1 ≤ j ≤ n} \\sum_{i=1}^m | a_{ij} |
+```
+with ``a_{ij}`` the entries of ``A``, and ``m`` and ``n`` its dimensions.
+
+When `p=2`, the matrix norm is the spectral norm, equal to the largest
+singular value of `A`.
+
+When `p=Inf`, the matrix norm is the maximum absolute row sum of `A`:
+```math
+\\|A\\|_\\infty = \\max_{1 ≤ i ≤ m} \\sum _{j=1}^n | a_{ij} |
+```
 
+# Examples
 ```jldoctest
 julia> A = [1 -2 -3; 2 3 -1]
 2×3 Array{Int64,2}:
@@ -543,14 +573,20 @@ function norm(A::AbstractMatrix, p::Real=2)
     end
 end
 
+"""
+    norm(x::Number, p::Real=2)
+
+For numbers, return ``\\left( |x|^p \\right)^{1/p}``.
+This is equivalent to [`vecnorm`](@ref).
+"""
 @inline norm(x::Number, p::Real=2) = vecnorm(x, p)
 
 @inline norm(tv::RowVector) = norm(transpose(tv))
 
 """
-    norm(rowvector, [q = 2])
+    norm(A::RowVector, q::Real=2)
 
-Takes the q-norm of a `RowVector`, which is equivalent to the p-norm with
+For row vectors, return the ``q``-norm of `A`, which is equivalent to the p-norm with
 value `p = q/(q-1)`. They coincide at `p = q = 2`.
 
 The difference in norm between a vector space and its dual arises to preserve
@@ -631,10 +667,10 @@ dot(x::Number, y::Number) = vecdot(x, y)
     dot(x, y)
     ⋅(x,y)
 
-Compute the dot product. For complex vectors, the first vector is conjugated.
-
-# Example
+Compute the dot product between two vectors. For complex vectors, the first vector is conjugated.
+When the vectors have equal lengths, calling `dot` is semantically equivalent to `sum(vx'vy for (vx,vy) in zip(x, y))`.
 
+# Examples
 ```jldoctest
 julia> dot([1; 1], [2; 3])
 5
@@ -643,7 +679,29 @@ julia> dot([im; im], [1; 1])
 0 - 2im
 ```
 """
-dot(x::AbstractVector, y::AbstractVector) = vecdot(x, y)
+function dot(x::AbstractVector, y::AbstractVector)
+    if length(x) != length(y)
+        throw(DimensionMismatch("dot product arguments have lengths $(length(x)) and $(length(y))"))
+    end
+    ix = start(x)
+    if done(x, ix)
+        # we only need to check the first vector, since equal lengths have been asserted
+        return zero(eltype(x))'zero(eltype(y))
+    end
+    @inbounds (vx, ix) = next(x, ix)
+    @inbounds (vy, iy) = next(y, start(y))
+    s = vx'vy
+    while !done(x, ix)
+        @inbounds (vx, ix) = next(x, ix)
+        @inbounds (vy, iy) = next(y, iy)
+        s += vx'vy
+    end
+    return s
+end
+
+# Call optimized BLAS methods for vectors of numbers
+dot(x::AbstractVector{<:Number}, y::AbstractVector{<:Number}) = vecdot(x, y)
+
 
 ###########################################################################################
 
@@ -655,6 +713,21 @@ values of `M` have magnitude greater than `tol`.
 By default, the value of `tol` is the largest
 dimension of `M` multiplied by the [`eps`](@ref)
 of the [`eltype`](@ref) of `M`.
+
+# Examples
+```jldoctest
+julia> rank(eye(3))
+3
+
+julia> rank(diagm([1, 0, 2]))
+2
+
+julia> rank(diagm([1, 0.001, 2]), 0.1)
+2
+
+julia> rank(diagm([1, 0.001, 2]), 0.00001)
+3
+```
 """
 rank(A::AbstractMatrix, tol::Real) = mapreduce(x -> x > tol, +, 0, svdvals(A))
 function rank(A::AbstractMatrix)
@@ -670,8 +743,7 @@ rank(x::Number) = x==0 ? 0 : 1
 
 Matrix trace. Sums the diagonal elements of `M`.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> A = [1 2; 3 4]
 2×2 Array{Int64,2}:
@@ -689,7 +761,7 @@ end
 trace(x::Number) = x
 
 #kron(a::AbstractVector, b::AbstractVector)
-#kron{T,S}(a::AbstractMatrix{T}, b::AbstractMatrix{S})
+#kron(a::AbstractMatrix{T}, b::AbstractMatrix{S}) where {T,S}
 
 #det(a::AbstractMatrix)
 
@@ -701,8 +773,7 @@ Matrix inverse. Computes matrix `N` such that
 Computed by solving the left-division
 `N = M \\ I`.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> M = [2 5; 1 3]
 2×2 Array{Int64,2}:
@@ -718,7 +789,7 @@ julia> M*N == N*M == eye(2)
 true
 ```
 """
-function inv{T}(A::AbstractMatrix{T})
+function inv(A::AbstractMatrix{T}) where T
     S = typeof(zero(T)/one(T))      # dimensionful
     S0 = typeof(zero(T)/oneunit(T)) # dimensionless
     A_ldiv_B!(factorize(convert(AbstractMatrix{S}, A)), eye(S0, checksquare(A)))
@@ -740,8 +811,7 @@ When `A` is sparse, a similar polyalgorithm is used. For indefinite matrices, th
 factorization does not use pivoting during the numerical factorization and therefore the
 procedure can fail even for invertible matrices.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> A = [1 0; 1 -2]; B = [32; -4];
 
@@ -769,7 +839,7 @@ function (\)(A::AbstractMatrix, B::AbstractVecOrMat)
         end
         return lufact(A) \ B
     end
-    return qrfact(A,Val{true}) \ B
+    return qrfact(A,Val(true)) \ B
 end
 
 (\)(a::AbstractVector, b::AbstractArray) = reshape(a, length(a), 1) \ b
@@ -800,13 +870,14 @@ condition number, or componentwise relative condition number.
 """
 condskeel(A::AbstractMatrix, x::AbstractVector, p::Real=Inf) = norm(abs.(inv(A))*(abs.(A)*abs.(x)), p)
 
+issymmetric(A::AbstractMatrix{<:Real}) = ishermitian(A)
+
 """
     issymmetric(A) -> Bool
 
 Test whether a matrix is symmetric.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> a = [1 2; 2 -1]
 2×2 Array{Int64,2}:
@@ -845,8 +916,7 @@ issymmetric(x::Number) = x == x
 
 Test whether a matrix is Hermitian.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> a = [1 2; 2 -1]
 2×2 Array{Int64,2}:
@@ -885,8 +955,7 @@ ishermitian(x::Number) = (x == conj(x))
 
 Test whether a matrix is upper triangular.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> a = [1 2; 2 -1]
 2×2 Array{Int64,2}:
@@ -908,7 +977,7 @@ true
 function istriu(A::AbstractMatrix)
     m, n = size(A)
     for j = 1:min(n,m-1), i = j+1:m
-        if A[i,j] != 0
+        if !iszero(A[i,j])
             return false
         end
     end
@@ -920,8 +989,7 @@ end
 
 Test whether a matrix is lower triangular.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> a = [1 2; 2 -1]
 2×2 Array{Int64,2}:
@@ -943,7 +1011,7 @@ true
 function istril(A::AbstractMatrix)
     m, n = size(A)
     for j = 2:n, i = 1:min(j-1,m)
-        if A[i,j] != 0
+        if !iszero(A[i,j])
             return false
         end
     end
@@ -955,8 +1023,7 @@ end
 
 Test whether a matrix is diagonal.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> a = [1 2; 2 -1]
 2×2 Array{Int64,2}:
@@ -988,14 +1055,15 @@ Perform simple linear regression using Ordinary Least Squares. Returns `a` and `
 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.
 
-**Examples:**
-
-    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*x)             # Plot line determined by linear regression
+# Examples
+```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*x)             # Plot line determined by linear regression
+```
 
 See also:
 
@@ -1142,8 +1210,7 @@ end
 
 Matrix determinant.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> M = [1 0; 2 2]
 2×2 Array{Int64,2}:
@@ -1154,7 +1221,7 @@ julia> det(M)
 2.0
 ```
 """
-function det{T}(A::AbstractMatrix{T})
+function det(A::AbstractMatrix{T}) where T
     if istriu(A) || istril(A)
         S = typeof((one(T)*zero(T) + zero(T))/one(T))
         return convert(S, det(UpperTriangular(A)))
@@ -1166,7 +1233,7 @@ det(x::Number) = x
 """
     logabsdet(M)
 
-Log of absolute value of determinant of real matrix. Equivalent to
+Log of absolute value of matrix determinant. Equivalent to
 `(log(abs(det(M))), sign(det(M)))`, but may provide increased accuracy and/or speed.
 """
 logabsdet(A::AbstractMatrix) = logabsdet(lufact(A))
@@ -1177,8 +1244,7 @@ logabsdet(A::AbstractMatrix) = logabsdet(lufact(A))
 Log of matrix determinant. Equivalent to `log(det(M))`, but may provide
 increased accuracy and/or speed.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> M = [1 0; 2 2]
 2×2 Array{Int64,2}:
@@ -1197,7 +1263,9 @@ function logdet(A::AbstractMatrix)
     return d + log(s)
 end
 
-NumberArray{T<:Number} = AbstractArray{T}
+logdet(A) = log(det(A))
+
+const NumberArray{T<:Number} = AbstractArray{T}
 
 """
     promote_leaf_eltypes(itr)
@@ -1206,8 +1274,7 @@ For an (possibly nested) iterable object `itr`, promote the types of leaf
 elements.  Equivalent to `promote_type(typeof(leaf1), typeof(leaf2), ...)`.
 Currently supports only numeric leaf elements.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> a = [[1,2, [3,4]], 5.0, [6im, [7.0, 8.0]]]
 3-element Array{Any,1}:
@@ -1219,9 +1286,9 @@ julia> promote_leaf_eltypes(a)
 Complex{Float64}
 ```
 """
-promote_leaf_eltypes{T<:Number}(x::Union{AbstractArray{T},Tuple{Vararg{T}}}) = T
-promote_leaf_eltypes{T<:NumberArray}(x::Union{AbstractArray{T},Tuple{Vararg{T}}}) = eltype(T)
-promote_leaf_eltypes{T}(x::T) = T
+promote_leaf_eltypes(x::Union{AbstractArray{T},Tuple{Vararg{T}}}) where {T<:Number} = T
+promote_leaf_eltypes(x::Union{AbstractArray{T},Tuple{Vararg{T}}}) where {T<:NumberArray} = eltype(T)
+promote_leaf_eltypes(x::T) where {T} = T
 promote_leaf_eltypes(x::Union{AbstractArray,Tuple}) = mapreduce(promote_leaf_eltypes, promote_type, Bool, x)
 
 # isapprox: approximate equality of arrays [like isapprox(Number,Number)]
@@ -1240,10 +1307,11 @@ function isapprox(x::AbstractArray, y::AbstractArray;
 end
 
 """
-    normalize!(v, [p::Real=2])
+    normalize!(v::AbstractVector, p::Real=2)
 
-Normalize the vector `v` in-place with respect to the `p`-norm.
-See also [`vecnorm`](@ref) and [`normalize`](@ref).
+Normalize the vector `v` in-place so that its `p`-norm equals unity,
+i.e. `norm(v, p) == 1`.
+See also [`normalize`](@ref) and [`vecnorm`](@ref).
 """
 function normalize!(v::AbstractVector, p::Real=2)
     nrm = norm(v, p)
@@ -1268,27 +1336,33 @@ end
 end
 
 """
-    normalize(v, [p::Real=2])
+    normalize(v::AbstractVector, p::Real=2)
 
-Normalize the vector `v` with respect to the `p`-norm.
+Normalize the vector `v` so that its `p`-norm equals unity,
+i.e. `norm(v, p) == vecnorm(v, p) == 1`.
 See also [`normalize!`](@ref) and [`vecnorm`](@ref).
 
-# Example
-
+# Examples
 ```jldoctest
 julia> a = [1,2,4];
 
-julia> normalize(a)
+julia> b = normalize(a)
 3-element Array{Float64,1}:
  0.218218
  0.436436
  0.872872
 
-julia> normalize(a,1)
+julia> norm(b)
+1.0
+
+julia> c = normalize(a, 1)
 3-element Array{Float64,1}:
  0.142857
  0.285714
  0.571429
+
+julia> norm(c, 1)
+1.0
 ```
 """
 function normalize(v::AbstractVector, p::Real = 2)
diff --git a/base/linalg/givens.jl b/base/linalg/givens.jl
index 9100331761e5bb..d822499d94c432 100644
--- a/base/linalg/givens.jl
+++ b/base/linalg/givens.jl
@@ -1,15 +1,15 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 # givensAlgorithm functions are derived from LAPACK, see below
 
 abstract type AbstractRotation{T} end
 
 transpose(R::AbstractRotation) = error("transpose not implemented for $(typeof(R)). Consider using conjugate transpose (') instead of transpose (.').")
 
-function *{T,S}(R::AbstractRotation{T}, A::AbstractVecOrMat{S})
+function *(R::AbstractRotation{T}, A::AbstractVecOrMat{S}) where {T,S}
     TS = typeof(zero(T)*zero(S) + zero(T)*zero(S))
     A_mul_B!(convert(AbstractRotation{TS}, R), TS == S ? copy(A) : convert(AbstractArray{TS}, A))
 end
-function A_mul_Bc{T,S}(A::AbstractVecOrMat{T}, R::AbstractRotation{S})
+function A_mul_Bc(A::AbstractVecOrMat{T}, R::AbstractRotation{S}) where {T,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
@@ -34,19 +34,19 @@ mutable struct Rotation{T} <: AbstractRotation{T}
     rotations::Vector{Givens{T}}
 end
 
-convert{T}(::Type{Givens{T}}, G::Givens{T}) = G
-convert{T}(::Type{Givens{T}}, G::Givens) = Givens(G.i1, G.i2, convert(T, G.c), convert(T, G.s))
-convert{T}(::Type{Rotation{T}}, R::Rotation{T}) = R
-convert{T}(::Type{Rotation{T}}, R::Rotation) = Rotation{T}([convert(Givens{T}, g) for g in R.rotations])
-convert{T}(::Type{AbstractRotation{T}}, G::Givens) = convert(Givens{T}, G)
-convert{T}(::Type{AbstractRotation{T}}, R::Rotation) = convert(Rotation{T}, R)
+convert(::Type{Givens{T}}, G::Givens{T}) where {T} = G
+convert(::Type{Givens{T}}, G::Givens) where {T} = Givens(G.i1, G.i2, convert(T, G.c), convert(T, G.s))
+convert(::Type{Rotation{T}}, R::Rotation{T}) where {T} = R
+convert(::Type{Rotation{T}}, R::Rotation) where {T} = Rotation{T}([convert(Givens{T}, g) for g in R.rotations])
+convert(::Type{AbstractRotation{T}}, G::Givens) where {T} = convert(Givens{T}, G)
+convert(::Type{AbstractRotation{T}}, R::Rotation) where {T} = convert(Rotation{T}, R)
 
 ctranspose(G::Givens) = Givens(G.i1, G.i2, conj(G.c), -G.s)
-ctranspose{T}(R::Rotation{T}) = Rotation{T}(reverse!([ctranspose(r) for r in R.rotations]))
+ctranspose(R::Rotation{T}) where {T} = Rotation{T}(reverse!([ctranspose(r) for r in R.rotations]))
 
 realmin2(::Type{Float32}) = reinterpret(Float32, 0x26000000)
 realmin2(::Type{Float64}) = reinterpret(Float64, 0x21a0000000000000)
-realmin2{T}(::Type{T}) = (twopar = 2one(T); twopar^trunc(Integer,log(realmin(T)/eps(T))/log(twopar)/twopar))
+realmin2(::Type{T}) where {T} = (twopar = 2one(T); twopar^trunc(Integer,log(realmin(T)/eps(T))/log(twopar)/twopar))
 
 # derived from LAPACK's dlartg
 # Copyright:
@@ -54,7 +54,7 @@ realmin2{T}(::Type{T}) = (twopar = 2one(T); twopar^trunc(Integer,log(realmin(T)/
 # Univ. of California Berkeley
 # Univ. of Colorado Denver
 # NAG Ltd.
-function givensAlgorithm{T<:AbstractFloat}(f::T, g::T)
+function givensAlgorithm(f::T, g::T) where T<:AbstractFloat
     onepar = one(T)
     twopar = 2one(T)
     T0 = typeof(onepar) # dimensionless
@@ -128,7 +128,7 @@ end
 # Univ. of California Berkeley
 # Univ. of Colorado Denver
 # NAG Ltd.
-function givensAlgorithm{T<:AbstractFloat}(f::Complex{T}, g::Complex{T})
+function givensAlgorithm(f::Complex{T}, g::Complex{T}) where T<:AbstractFloat
     twopar, onepar = 2one(T), one(T)
     T0 = typeof(onepar) # dimensionless
     zeropar = T0(zero(T)) # must be dimensionless
@@ -170,31 +170,29 @@ function givensAlgorithm{T<:AbstractFloat}(f::Complex{T}, g::Complex{T})
     f2 = abs2(fs)
     g2 = abs2(gs)
     if f2 <= max(g2, oneunit(T))*safmin
-
-     # This is a rare case: F is very small.
-
+        # This is a rare case: F is very small.
         if f == 0
             cs = zero(T)
             r = complex(hypot(real(g), imag(g)))
-        # do complex/real division explicitly with two real divisions
+            # do complex/real division explicitly with two real divisions
             d = hypot(real(gs), imag(gs))
             sn = complex(real(gs)/d, -imag(gs)/d)
             return cs, sn, r
         end
         f2s = hypot(real(fs), imag(fs))
-     # g2 and g2s are accurate
-     # g2 is at least safmin, and g2s is at least safmn2
+        # g2 and g2s are accurate
+        # g2 is at least safmin, and g2s is at least safmn2
         g2s = sqrt(g2)
-     # error in cs from underflow in f2s is at most
-     # unfl / safmn2 .lt. sqrt(unfl*eps) .lt. eps
-     # if max(g2,one)=g2, then f2 .lt. g2*safmin,
-     # and so cs .lt. sqrt(safmin)
-     # if max(g2,one)=one, then f2 .lt. safmin
-     # and so cs .lt. sqrt(safmin)/safmn2 = sqrt(eps)
-     # therefore, cs = f2s/g2s / sqrt( 1 + (f2s/g2s)**2 ) = f2s/g2s
+        # error in cs from underflow in f2s is at most
+        # unfl / safmn2 .lt. sqrt(unfl*eps) .lt. eps
+        # if max(g2,one)=g2, then f2 .lt. g2*safmin,
+        # and so cs .lt. sqrt(safmin)
+        # if max(g2,one)=one, then f2 .lt. safmin
+        # and so cs .lt. sqrt(safmin)/safmn2 = sqrt(eps)
+        # therefore, cs = f2s/g2s / sqrt( 1 + (f2s/g2s)**2 ) = f2s/g2s
         cs = f2s/g2s
-     # make sure abs(ff) = 1
-     # do complex/real division explicitly with 2 real divisions
+        # make sure abs(ff) = 1
+        # do complex/real division explicitly with 2 real divisions
         if abs1(f) > 1
             d = hypot(real(f), imag(f))
             ff = complex(real(f)/d, imag(f)/d)
@@ -207,17 +205,15 @@ function givensAlgorithm{T<:AbstractFloat}(f::Complex{T}, g::Complex{T})
         sn = ff*complex(real(gs)/g2s, -imag(gs)/g2s)
         r = cs*f + sn*g
     else
-
-     # This is the most common case.
-     # Neither F2 nor F2/G2 are less than SAFMIN
-     # F2S cannot overflow, and it is accurate
-
+        # This is the most common case.
+        # Neither F2 nor F2/G2 are less than SAFMIN
+        # F2S cannot overflow, and it is accurate
         f2s = sqrt(onepar + g2/f2)
-     # do the f2s(real)*fs(complex) multiply with two real multiplies
+        # do the f2s(real)*fs(complex) multiply with two real multiplies
         r = complex(f2s*real(fs), f2s*imag(fs))
         cs = onepar/f2s
         d = f2 + g2
-     # do complex/real division explicitly with two real divisions
+        # do complex/real division explicitly with two real divisions
         sn = complex(real(r)/d, imag(r)/d)
         sn *= conj(gs)
         if count != 0
@@ -237,7 +233,7 @@ end
 
 """
 
-    givens{T}(f::T, g::T, i1::Integer, i2::Integer) -> (G::Givens, r::T)
+    givens(f::T, g::T, i1::Integer, i2::Integer) where {T} -> (G::Givens, r::T)
 
 Computes the Givens rotation `G` and scalar `r` such that for any vector `x` where
 ```
@@ -256,7 +252,7 @@ y[i2] = 0
 
 See also: [`LinAlg.Givens`](@ref)
 """
-function givens{T}(f::T, g::T, i1::Integer, i2::Integer)
+function givens(f::T, g::T, i1::Integer, i2::Integer) where T
     if i1 == i2
         throw(ArgumentError("Indices must be distinct."))
     end
@@ -364,4 +360,4 @@ function A_mul_Bc!(A::AbstractMatrix, R::Rotation)
     end
     return A
 end
-*{T}(G1::Givens{T}, G2::Givens{T}) = Rotation(push!(push!(Givens{T}[], G2), G1))
+*(G1::Givens{T}, G2::Givens{T}) where {T} = Rotation(push!(push!(Givens{T}[], G2), G1))
diff --git a/base/linalg/hessenberg.jl b/base/linalg/hessenberg.jl
index 87743b87c0230d..ebb7e8ea0f665a 100644
--- a/base/linalg/hessenberg.jl
+++ b/base/linalg/hessenberg.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 struct Hessenberg{T,S<:AbstractMatrix} <: Factorization{T}
     factors::S
@@ -30,8 +30,7 @@ matrix with `F[:H]`. When `Q` is extracted, the resulting type is the `Hessenber
 and may be converted to a regular matrix with [`convert(Array, _)`](@ref)
  (or `Array(_)` for short).
 
-# Example
-
+# Examples
 ```jldoctest
 julia> A = [4. 9. 7.; 4. 4. 1.; 4. 3. 2.]
 3×3 Array{Float64,2}:
@@ -48,7 +47,7 @@ julia> F[:Q] * F[:H] * F[:Q]'
  4.0  3.0  2.0
 ```
 """
-function hessfact{T}(A::StridedMatrix{T})
+function hessfact(A::StridedMatrix{T}) where T
     S = promote_type(Float32, typeof(zero(T)/norm(one(T))))
     return hessfact!(copy_oftype(A, S))
 end
@@ -58,7 +57,7 @@ struct HessenbergQ{T,S<:AbstractMatrix} <: AbstractMatrix{T}
     τ::Vector{T}
     HessenbergQ{T,S}(factors::AbstractMatrix{T}, τ::Vector{T}) where {T,S<:AbstractMatrix} = new(factors, τ)
 end
-HessenbergQ{T}(factors::AbstractMatrix{T}, τ::Vector{T}) = HessenbergQ{T,typeof(factors)}(factors, τ)
+HessenbergQ(factors::AbstractMatrix{T}, τ::Vector{T}) where {T} = HessenbergQ{T,typeof(factors)}(factors, τ)
 HessenbergQ(A::Hessenberg) = HessenbergQ(A.factors, A.τ)
 size(A::HessenbergQ, d) = size(A.factors, d)
 size(A::HessenbergQ) = size(A.factors)
@@ -87,29 +86,29 @@ convert(::Type{Matrix}, F::Hessenberg) = convert(Array, convert(AbstractArray, F
 convert(::Type{Array}, F::Hessenberg) = convert(Matrix, F)
 full(F::Hessenberg) = convert(AbstractArray, F)
 
-A_mul_B!{T<:BlasFloat}(Q::HessenbergQ{T}, X::StridedVecOrMat{T}) =
+A_mul_B!(Q::HessenbergQ{T}, X::StridedVecOrMat{T}) where {T<:BlasFloat} =
     LAPACK.ormhr!('L', 'N', 1, size(Q.factors, 1), Q.factors, Q.τ, X)
-A_mul_B!{T<:BlasFloat}(X::StridedMatrix{T}, Q::HessenbergQ{T}) =
+A_mul_B!(X::StridedMatrix{T}, Q::HessenbergQ{T}) where {T<:BlasFloat} =
     LAPACK.ormhr!('R', 'N', 1, size(Q.factors, 1), Q.factors, Q.τ, X)
-Ac_mul_B!{T<:BlasFloat}(Q::HessenbergQ{T}, X::StridedVecOrMat{T}) =
+Ac_mul_B!(Q::HessenbergQ{T}, X::StridedVecOrMat{T}) where {T<:BlasFloat} =
     LAPACK.ormhr!('L', ifelse(T<:Real, 'T', 'C'), 1, size(Q.factors, 1), Q.factors, Q.τ, X)
-A_mul_Bc!{T<:BlasFloat}(X::StridedMatrix{T}, Q::HessenbergQ{T}) =
+A_mul_Bc!(X::StridedMatrix{T}, Q::HessenbergQ{T}) where {T<:BlasFloat} =
     LAPACK.ormhr!('R', ifelse(T<:Real, 'T', 'C'), 1, size(Q.factors, 1), Q.factors, Q.τ, X)
 
 
-function (*){T,S}(Q::HessenbergQ{T}, X::StridedVecOrMat{S})
+function (*)(Q::HessenbergQ{T}, X::StridedVecOrMat{S}) where {T,S}
     TT = typeof(zero(T)*zero(S) + zero(T)*zero(S))
     return A_mul_B!(Q, copy_oftype(X, TT))
 end
-function (*){T,S}(X::StridedVecOrMat{S}, Q::HessenbergQ{T})
+function (*)(X::StridedVecOrMat{S}, Q::HessenbergQ{T}) where {T,S}
     TT = typeof(zero(T)*zero(S) + zero(T)*zero(S))
     return A_mul_B!(copy_oftype(X, TT), Q)
 end
-function Ac_mul_B{T,S}(Q::HessenbergQ{T}, X::StridedVecOrMat{S})
+function Ac_mul_B(Q::HessenbergQ{T}, X::StridedVecOrMat{S}) where {T,S}
     TT = typeof(zero(T)*zero(S) + zero(T)*zero(S))
     return Ac_mul_B!(Q, copy_oftype(X, TT))
 end
-function A_mul_Bc{T,S}(X::StridedVecOrMat{S}, Q::HessenbergQ{T})
+function A_mul_Bc(X::StridedVecOrMat{S}, Q::HessenbergQ{T}) where {T,S}
     TT = typeof(zero(T)*zero(S) + zero(T)*zero(S))
     return A_mul_Bc!(copy_oftype(X, TT), Q)
 end
diff --git a/base/linalg/lapack.jl b/base/linalg/lapack.jl
index 5282ec8ba22f2c..3a70e5a865d8ad 100644
--- a/base/linalg/lapack.jl
+++ b/base/linalg/lapack.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## The LAPACK module of interfaces to LAPACK subroutines
 module LAPACK
@@ -196,8 +196,8 @@ for (gebal, gebak, elty, relty) in
             chkstride1(A)
             n = checksquare(A)
             chkfinite(A) # balancing routines don't support NaNs and Infs
-            ihi = Array{BlasInt}(1)
-            ilo = Array{BlasInt}(1)
+            ihi = Ref{BlasInt}()
+            ilo = Ref{BlasInt}()
             scale = similar(A, $relty, n)
             info = Ref{BlasInt}()
             ccall((@blasfunc($gebal), liblapack), Void,
@@ -205,7 +205,7 @@ for (gebal, gebak, elty, relty) in
                    Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$relty}, Ptr{BlasInt}),
                   &job, &n, A, &max(1,stride(A,2)), ilo, ihi, scale, info)
             chklapackerror(info[])
-            ilo[1], ihi[1], scale
+            ilo[], ihi[], scale
         end
 
         #     SUBROUTINE DGEBAK( JOB, SIDE, N, ILO, IHI, SCALE, M, V, LDV, INFO )
@@ -282,10 +282,10 @@ for (gebrd, gelqf, geqlf, geqrf, geqp3, geqrt, geqrt3, gerqf, getrf, elty, relty
             e     = similar(A, $relty, k)
             tauq  = similar(A, $elty, k)
             taup  = similar(A, $elty, k)
-            work  = Array{$elty}(1)
+            work  = Vector{$elty}(1)
             lwork = BlasInt(-1)
             info  = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 ccall((@blasfunc($gebrd), liblapack), Void,
                     (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                      Ptr{$relty}, Ptr{$relty}, Ptr{$elty}, Ptr{$elty},
@@ -296,7 +296,7 @@ for (gebrd, gelqf, geqlf, geqrf, geqp3, geqrt, geqrt3, gerqf, getrf, elty, relty
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             A, d, e, tauq, taup
@@ -316,7 +316,7 @@ 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)
+            work  = Vector{$elty}(1)
             info  = Ref{BlasInt}()
             for i = 1:2  # first call returns lwork as work[1]
                 ccall((@blasfunc($gelqf), liblapack), Void,
@@ -326,7 +326,7 @@ for (gebrd, gelqf, geqlf, geqrf, geqp3, geqrt, geqrt3, gerqf, getrf, elty, relty
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             A, tau
@@ -346,7 +346,7 @@ 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)
+            work  = Vector{$elty}(1)
             info  = Ref{BlasInt}()
             for i = 1:2  # first call returns lwork as work[1]
                 ccall((@blasfunc($geqlf), liblapack), Void,
@@ -356,7 +356,7 @@ for (gebrd, gelqf, geqlf, geqrf, geqp3, geqrt, geqrt3, gerqf, getrf, elty, relty
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             A, tau
@@ -381,14 +381,14 @@ for (gebrd, gelqf, geqlf, geqrf, geqp3, geqrt, geqrt3, gerqf, getrf, elty, relty
             if lda == 0
                 return A, tau, jpvt
             end # Early exit
-            work  = Array{$elty}(1)
+            work  = Vector{$elty}(1)
             lwork = BlasInt(-1)
             cmplx = eltype(A)<:Complex
             if cmplx
-                rwork = Array{$relty}(2n)
+                rwork = Vector{$relty}(2n)
             end
             info = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 if cmplx
                     ccall((@blasfunc($geqp3), liblapack), Void,
                           (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
@@ -409,7 +409,7 @@ for (gebrd, gelqf, geqlf, geqrf, geqp3, geqrt, geqrt3, gerqf, getrf, elty, relty
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work  = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             return A, tau, jpvt
@@ -424,7 +424,7 @@ for (gebrd, gelqf, geqlf, geqrf, geqp3, geqrt, geqrt3, gerqf, getrf, elty, relty
                 throw(ArgumentError("block size $nb > $minmn too large"))
             end
             lda = max(1, stride(A,2))
-            work = Array{$elty}(nb*n)
+            work = Vector{$elty}(nb*n)
             if n > 0
                 info = Ref{BlasInt}()
                 ccall((@blasfunc($geqrt), liblapack), Void,
@@ -474,7 +474,7 @@ for (gebrd, gelqf, geqlf, geqrf, geqp3, geqrt, geqrt3, gerqf, getrf, elty, relty
             if length(tau) != min(m,n)
                 throw(DimensionMismatch("tau has length $(length(tau)), but needs length $(min(m,n))"))
             end
-            work  = Array{$elty}(1)
+            work  = Vector{$elty}(1)
             lwork = BlasInt(-1)
             info  = Ref{BlasInt}()
             for i = 1:2                # first call returns lwork as work[1]
@@ -485,7 +485,7 @@ for (gebrd, gelqf, geqlf, geqrf, geqp3, geqrt, geqrt3, gerqf, getrf, elty, relty
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             A, tau
@@ -503,7 +503,7 @@ 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)
+            work  = Vector{$elty}(1)
             info  = Ref{BlasInt}()
             for i = 1:2                # first call returns lwork as work[1]
                 ccall((@blasfunc($gerqf), liblapack), Void,
@@ -513,7 +513,7 @@ for (gebrd, gelqf, geqlf, geqrf, geqp3, geqrt, geqrt3, gerqf, getrf, elty, relty
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             A, tau
@@ -758,10 +758,10 @@ for (tzrzf, ormrz, elty) in
             end
             lda = max(1, m)
             tau = similar(A, $elty, m)
-            work  = Array{$elty}(1)
+            work  = Vector{$elty}(1)
             lwork = BlasInt(-1)
             info  = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 ccall((@blasfunc($tzrzf), liblapack), Void,
                     (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                      Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
@@ -770,7 +770,7 @@ for (tzrzf, ormrz, elty) in
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             A, tau
@@ -795,10 +795,10 @@ 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)
+            work  = Vector{$elty}(1)
             lwork = BlasInt(-1)
             info  = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 ccall((@blasfunc($ormrz), liblapack), Void,
                     (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt},
                      Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
@@ -811,7 +811,7 @@ for (tzrzf, ormrz, elty) in
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             C
@@ -860,24 +860,24 @@ for (gels, gesv, getrs, getri, elty) in
                 throw(DimensionMismatch("matrix A has dimensions ($m,$n), transposed: $btrn, but leading dimension of B is $(size(B,1))"))
             end
             info  = Ref{BlasInt}()
-            work  = Array{$elty}(1)
+            work  = Vector{$elty}(1)
             lwork = BlasInt(-1)
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 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)),
+                      &(btrn ? 'T' : 'N'), &m, &n, &size(B,2), A, &max(1,stride(A,2)),
                       B, &max(1,stride(B,2)), work, &lwork, info)
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             k   = min(m, n)
             F   = m < n ? tril(A[1:k, 1:k]) : triu(A[1:k, 1:k])
-            ssr = Array{$elty}(size(B,2))
+            ssr = Vector{$elty}(size(B, 2))
             for i = 1:size(B,2)
                 x = zero($elty)
                 for j = k+1:size(B,1)
@@ -949,9 +949,9 @@ for (gels, gesv, getrs, getri, elty) in
             end
             lda = max(1,stride(A, 2))
             lwork = BlasInt(-1)
-            work  = Array{$elty}(1)
+            work  = Vector{$elty}(1)
             info  = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 ccall((@blasfunc($getri), liblapack), Void,
                       (Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt},
                        Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
@@ -959,7 +959,7 @@ for (gels, gesv, getrs, getri, elty) in
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work  = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             A
@@ -1040,11 +1040,11 @@ for (gesvx, elty) in
             ldaf = stride(AF,2)
             nrhs = size(B,2)
             ldb  = stride(B,2)
-            rcond = Array{$elty}(1)
+            rcond = Vector{$elty}(1)
             ferr  = similar(A, $elty, nrhs)
             berr  = similar(A, $elty, nrhs)
-            work  = Array{$elty}(4n)
-            iwork = Array{BlasInt}(n)
+            work  = Vector{$elty}(4n)
+            iwork = Vector{BlasInt}(n)
             info  = Ref{BlasInt}()
             X = similar(A, $elty, n, nrhs)
             ccall((@blasfunc($gesvx), liblapack), Void,
@@ -1109,11 +1109,11 @@ for (gesvx, elty, relty) in
             ldaf = stride(AF,2)
             nrhs = size(B,2)
             ldb = stride(B,2)
-            rcond = Array{$relty}(1)
+            rcond = Vector{$relty}(1)
             ferr  = similar(A, $relty, nrhs)
             berr  = similar(A, $relty, nrhs)
-            work  = Array{$elty}(2n)
-            rwork = Array{$relty}(2n)
+            work  = Vector{$elty}(2n)
+            rwork = Vector{$relty}(2n)
             info  = Ref{BlasInt}()
             X = similar(A, $elty, n, nrhs)
             ccall((@blasfunc($gesvx), liblapack), Void,
@@ -1206,12 +1206,12 @@ for (gelsd, gelsy, elty) in
             newB = [B; zeros($elty, max(0, n - size(B, 1)), size(B, 2))]
             s     = similar(A, $elty, min(m, n))
             rcond = convert($elty, rcond)
-            rnk   = Array{BlasInt}(1)
+            rnk   = Vector{BlasInt}(1)
             info  = Ref{BlasInt}()
-            work  = Array{$elty}(1)
+            work  = Vector{$elty}(1)
             lwork = BlasInt(-1)
-            iwork = Array{BlasInt}(1)
-            for i = 1:2
+            iwork = Vector{BlasInt}(1)
+            for i = 1:2  # first call returns lwork as work[1] and iwork length as iwork[1]
                 ccall((@blasfunc($gelsd), liblapack), Void,
                       (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt},
                        Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
@@ -1222,8 +1222,8 @@ for (gelsd, gelsy, elty) in
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
-                    iwork = Array{BlasInt}(iwork[1])
+                    resize!(work, lwork)
+                    resize!(iwork, iwork[1])
                 end
             end
             subsetrows(B, newB, n), rnk[1]
@@ -1251,11 +1251,11 @@ for (gelsd, gelsy, elty) in
             ldb = max(1, m, n)
             jpvt = zeros(BlasInt, n)
             rcond = convert($elty, rcond)
-            rnk = Array{BlasInt}(1)
-            work = Array{$elty}(1)
+            rnk = Vector{BlasInt}(1)
+            work = Vector{$elty}(1)
             lwork = BlasInt(-1)
             info = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 ccall((@blasfunc($gelsy), liblapack), Void,
                     (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty},
                      Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt},
@@ -1268,7 +1268,7 @@ for (gelsd, gelsy, elty) in
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(work[1])
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             subsetrows(B, newB, n), rnk[1]
@@ -1299,13 +1299,13 @@ for (gelsd, gelsy, elty, relty) in
             newB = [B; zeros($elty, max(0, n - size(B, 1)), size(B, 2))]
             s     = similar(A, $relty, min(m, n))
             rcond = convert($relty, rcond)
-            rnk   = Array{BlasInt}(1)
+            rnk   = Vector{BlasInt}(1)
             info  = Ref{BlasInt}()
-            work  = Array{$elty}(1)
+            work  = Vector{$elty}(1)
             lwork = BlasInt(-1)
-            rwork = Array{$relty}(1)
-            iwork = Array{BlasInt}(1)
-            for i = 1:2
+            rwork = Vector{$relty}(1)
+            iwork = Vector{BlasInt}(1)
+            for i = 1:2  # first call returns lwork as work[1], rwork length as rwork[1] and iwork length as iwork[1]
                 ccall((@blasfunc($gelsd), liblapack), Void,
                       (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty},
                        Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$relty},
@@ -1316,9 +1316,9 @@ for (gelsd, gelsy, elty, relty) in
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
-                    rwork = Array{$relty}(BlasInt(rwork[1]))
-                    iwork = Array{BlasInt}(iwork[1])
+                    resize!(work, lwork)
+                    resize!(rwork, BlasInt(rwork[1]))
+                    resize!(iwork, iwork[1])
                 end
             end
             subsetrows(B, newB, n), rnk[1]
@@ -1346,12 +1346,12 @@ for (gelsd, gelsy, elty, relty) in
             ldb = max(1, m, n)
             jpvt = zeros(BlasInt, n)
             rcond = convert($relty, rcond)
-            rnk = Array{BlasInt}(1)
-            work = Array{$elty}(1)
+            rnk = Vector{BlasInt}(1)
+            work = Vector{$elty}(1)
             lwork = BlasInt(-1)
-            rwork = Array{$relty}(2n)
+            rwork = Vector{$relty}(2n)
             info = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 ccall((@blasfunc($gelsy), liblapack), Void,
                     (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty},
                      Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt},
@@ -1364,7 +1364,7 @@ for (gelsd, gelsy, elty, relty) in
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             subsetrows(B, newB, n), rnk[1]
@@ -1423,9 +1423,9 @@ for (gglse, elty) in ((:dgglse_, :Float64),
             end
             X = zeros($elty, n)
             info  = Ref{BlasInt}()
-            work  = Array{$elty}(1)
+            work  = Vector{$elty}(1)
             lwork = BlasInt(-1)
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 ccall((@blasfunc($gglse), liblapack), Void,
                       (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty},
                        Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
@@ -1436,7 +1436,7 @@ for (gglse, elty) in ((:dgglse_, :Float64),
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             X, dot(view(c, n - p + 1:m), view(c, n - p + 1:m))
@@ -1484,10 +1484,10 @@ for (geev, gesvd, gesdd, ggsvd, elty, relty) in
                 WR    = similar(A, $elty, n)
                 WI    = similar(A, $elty, n)
             end
-            work  = Array{$elty}(1)
+            work  = Vector{$elty}(1)
             lwork = BlasInt(-1)
             info  = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 if cmplx
                     ccall((@blasfunc($geev), liblapack), Void,
                           (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty},
@@ -1508,7 +1508,7 @@ for (geev, gesvd, gesdd, ggsvd, elty, relty) in
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             cmplx ? (W, VL, VR) : (WR, WI, VL, VR)
@@ -1541,7 +1541,7 @@ for (geev, gesvd, gesdd, ggsvd, elty, relty) in
                 U  = similar(A, $elty, (m, 0))
                 VT = similar(A, $elty, (n, 0))
             end
-            work   = Array{$elty}(1)
+            work   = Vector{$elty}(1)
             lwork  = BlasInt(-1)
             S      = similar(A, $relty, minmn)
             cmplx  = eltype(A)<:Complex
@@ -1549,9 +1549,9 @@ for (geev, gesvd, gesdd, ggsvd, elty, relty) in
                 rwork = Array{$relty}(job == 'N' ? 7*minmn :
                               minmn*max(5*minmn+7, 2*max(m,n)+2*minmn+1))
             end
-            iwork  = Array{BlasInt}(8*minmn)
+            iwork  = Vector{BlasInt}(8*minmn)
             info   = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 if cmplx
                     ccall((@blasfunc($gesdd), liblapack), Void,
                           (Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty},
@@ -1577,7 +1577,7 @@ for (geev, gesvd, gesdd, ggsvd, elty, relty) in
                     # and
                     # https://github.com/scipy/scipy/issues/5401
                     lwork = round(BlasInt, nextfloat(real(work[1])))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             if job == 'O'
@@ -1610,16 +1610,16 @@ for (geev, gesvd, gesdd, ggsvd, elty, relty) in
             m, n   = size(A)
             minmn  = min(m, n)
             S      = similar(A, $relty, minmn)
-            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)
+            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   = Vector{$elty}(1)
             cmplx  = eltype(A) <: Complex
             if cmplx
-                rwork = Array{$relty}(5minmn)
+                rwork = Vector{$relty}(5minmn)
             end
             lwork  = BlasInt(-1)
             info   = Ref{BlasInt}()
-            for i in 1:2
+            for i in 1:2  # first call returns lwork as work[1]
                 if cmplx
                     ccall((@blasfunc($gesvd), liblapack), Void,
                           (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt},
@@ -1640,7 +1640,7 @@ for (geev, gesvd, gesdd, ggsvd, elty, relty) in
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             if jobu == 'O'
@@ -1680,8 +1680,8 @@ for (geev, gesvd, gesdd, ggsvd, elty, relty) in
                 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)
+            k = Vector{BlasInt}(1)
+            l = Vector{BlasInt}(1)
             lda = max(1,stride(A, 2))
             ldb = max(1,stride(B, 2))
             alpha = similar(A, $relty, n)
@@ -1692,12 +1692,12 @@ for (geev, gesvd, gesdd, ggsvd, elty, relty) in
             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}(max(3n, m, p) + n)
+            work = Vector{$elty}(max(3n, m, p) + n)
             cmplx = eltype(A) <: Complex
             if cmplx
-                rwork = Array{$relty}(2n)
+                rwork = Vector{$relty}(2n)
             end
-            iwork = Array{BlasInt}(n)
+            iwork = Vector{BlasInt}(n)
             info = Ref{BlasInt}()
             if cmplx
                 ccall((@blasfunc($ggsvd), liblapack), Void,
@@ -1814,11 +1814,11 @@ for (f, elty) in ((:dggsvd3_, :Float64),
             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)
+            work = Vector{$elty}(1)
             lwork = BlasInt(-1)
-            iwork = Array{BlasInt}(n)
+            iwork = Vector{BlasInt}(n)
             info = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 ccall((@blasfunc($f), liblapack), Void,
                     (Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt},
                     Ptr{BlasInt}, Ptr{BlasInt}, Ref{BlasInt}, Ref{BlasInt},
@@ -1858,8 +1858,8 @@ for (f, elty, relty) in ((:zggsvd3_, :Complex128, :Float64),
                 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)
+            k = Vector{BlasInt}(1)
+            l = Vector{BlasInt}(1)
             lda = max(1,stride(A, 2))
             ldb = max(1,stride(B, 2))
             alpha = similar(A, $relty, n)
@@ -1870,12 +1870,12 @@ for (f, elty, relty) in ((:zggsvd3_, :Complex128, :Float64),
             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)
+            work = Vector{$elty}(1)
             lwork = BlasInt(-1)
-            rwork = Array{$relty}(2n)
-            iwork = Array{BlasInt}(n)
+            rwork = Vector{$relty}(2n)
+            iwork = Vector{BlasInt}(n)
             info = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 ccall((@blasfunc($f), liblapack), Void,
                     (Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt},
                     Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt},
@@ -1894,7 +1894,7 @@ for (f, elty, relty) in ((:zggsvd3_, :Complex128, :Float64),
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(work[1])
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             if m - k[1] - l[1] >= 0
@@ -1965,13 +1965,13 @@ for (geevx, ggev, elty) in
                 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)
+            ilo = Ref{BlasInt}()
+            ihi = Ref{BlasInt}()
             scale = similar(A, $elty, n)
-            abnrm = Array{$elty}(1)
+            abnrm = Ref{$elty}()
             rconde = similar(A, $elty, n)
             rcondv = similar(A, $elty, n)
-            work = Array{$elty}(1)
+            work = Vector{$elty}(1)
             lwork = BlasInt(-1)
             iworksize = 0
             if sense == 'N' || sense == 'E'
@@ -1981,9 +1981,9 @@ for (geevx, ggev, elty) in
             else
                 throw(ArgumentError("sense must be 'N', 'E', 'V' or 'B', but $sense was passed"))
             end
-            iwork = Array{BlasInt}(iworksize)
+            iwork = Vector{BlasInt}(iworksize)
             info = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 ccall((@blasfunc($geevx), liblapack), Void,
                       (Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8},
                        Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
@@ -2000,10 +2000,10 @@ for (geevx, ggev, elty) in
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(work[1])
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
-            A, wr, wi, VL, VR, ilo[1], ihi[1], scale, abnrm[1], rconde, rcondv
+            A, wr, wi, VL, VR, ilo[], ihi[], scale, abnrm[], rconde, rcondv
         end
 
         #       SUBROUTINE DGGEV( JOBVL, JOBVR, N, A, LDA, B, LDB, ALPHAR, ALPHAI,
@@ -2045,10 +2045,10 @@ for (geevx, ggev, elty) in
                 throw(ArgumentError("jobvr must be 'V' or 'N', but $jobvr was passed"))
             end
             vr = similar(A, $elty, ldvr, n)
-            work = Array{$elty}(1)
+            work = Vector{$elty}(1)
             lwork = BlasInt(-1)
             info = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 ccall((@blasfunc($ggev), liblapack), Void,
                     (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty},
                      Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
@@ -2063,7 +2063,7 @@ for (geevx, ggev, elty) in
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(work[1])
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             alphar, alphai, beta, vl, vr
@@ -2118,17 +2118,17 @@ for (geevx, ggev, elty, relty) in
                 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)
+            ilo = Ref{BlasInt}()
+            ihi = Ref{BlasInt}()
             scale = similar(A, $relty, n)
-            abnrm = Array{$relty}(1)
+            abnrm = Ref{$relty}()
             rconde = similar(A, $relty, n)
             rcondv = similar(A, $relty, n)
-            work = Array{$elty}(1)
+            work = Vector{$elty}(1)
             lwork = BlasInt(-1)
-            rwork = Array{$relty}(2n)
+            rwork = Vector{$relty}(2n)
             info = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 ccall((@blasfunc($geevx), liblapack), Void,
                       (Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8},
                        Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
@@ -2145,10 +2145,10 @@ for (geevx, ggev, elty, relty) in
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(work[1])
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
-            A, w, VL, VR, ilo[1], ihi[1], scale, abnrm[1], rconde, rcondv
+            A, w, VL, VR, ilo[], ihi[], scale, abnrm[], rconde, rcondv
         end
 
         # SUBROUTINE ZGGEV( JOBVL, JOBVR, N, A, LDA, B, LDB, ALPHA, BETA,
@@ -2190,11 +2190,11 @@ for (geevx, ggev, elty, relty) in
                 throw(ArgumentError("jobvr must be 'V' or 'N', but $jobvr was passed"))
             end
             vr = similar(A, $elty, ldvr, n)
-            work = Array{$elty}(1)
+            work = Vector{$elty}(1)
             lwork = BlasInt(-1)
-            rwork = Array{$relty}(8n)
+            rwork = Vector{$relty}(8n)
             info = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 ccall((@blasfunc($ggev), liblapack), Void,
                     (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty},
                      Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
@@ -2209,7 +2209,7 @@ for (geevx, ggev, elty, relty) in
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(work[1])
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             alpha, beta, vl, vr
@@ -2265,9 +2265,9 @@ for (laic1, elty) in
             if j != length(w)
                 throw(DimensionMismatch("vectors must have same length, but length of x is $j and length of w is $(length(w))"))
             end
-            sestpr = Array{$elty}(1)
-            s = Array{$elty}(1)
-            c = Array{$elty}(1)
+            sestpr = Vector{$elty}(1)
+            s = Vector{$elty}(1)
+            c = Vector{$elty}(1)
             ccall((@blasfunc($laic1), liblapack), Void,
                 (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty},
                  Ptr{$elty}, Ptr{$elty}, Ptr{$elty}, Ptr{$elty},
@@ -2298,9 +2298,9 @@ for (laic1, elty, relty) in
             if j != length(w)
                 throw(DimensionMismatch("vectors must have same length, but length of x is $j and length of w is $(length(w))"))
             end
-            sestpr = Array{$relty}(1)
-            s = Array{$elty}(1)
-            c = Array{$elty}(1)
+            sestpr = Vector{$relty}(1)
+            s = Vector{$elty}(1)
+            c = Vector{$elty}(1)
             ccall((@blasfunc($laic1), liblapack), Void,
                 (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{$relty},
                  Ptr{$elty}, Ptr{$elty}, Ptr{$relty}, Ptr{$elty},
@@ -2461,10 +2461,10 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
             if k > m
                 throw(DimensionMismatch("invalid number of reflectors: k = $k should be <= m = $m"))
             end
-            work  = Array{$elty}(1)
+            work  = Vector{$elty}(1)
             lwork = BlasInt(-1)
             info  = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 ccall((@blasfunc($orglq), liblapack), Void,
                       (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty},
                        Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
@@ -2472,7 +2472,7 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             if m < size(A,1)
@@ -2494,10 +2494,10 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
             if k > n
                 throw(DimensionMismatch("invalid number of reflectors: k = $k should be <= n = $n"))
             end
-            work  = Array{$elty}(1)
+            work  = Vector{$elty}(1)
             lwork = BlasInt(-1)
             info  = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 ccall((@blasfunc($orgqr), liblapack), Void,
                       (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty},
                        Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
@@ -2507,7 +2507,7 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             if n < size(A,2)
@@ -2529,10 +2529,10 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
             if k > n
                 throw(DimensionMismatch("invalid number of reflectors: k = $k should be <= n = $n"))
             end
-            work  = Array{$elty}(1)
+            work  = Vector{$elty}(1)
             lwork = BlasInt(-1)
             info  = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 ccall((@blasfunc($orgql), liblapack), Void,
                       (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty},
                        Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
@@ -2542,7 +2542,7 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             if n < size(A,2)
@@ -2564,10 +2564,10 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
             if k > n
                 throw(DimensionMismatch("invalid number of reflectors: k = $k should be <= n = $n"))
             end
-            work  = Array{$elty}(1)
+            work  = Vector{$elty}(1)
             lwork = BlasInt(-1)
             info  = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 ccall((@blasfunc($orgrq), liblapack), Void,
                       (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty},
                        Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
@@ -2577,7 +2577,7 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             if n < size(A,2)
@@ -2614,10 +2614,10 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
             if side == 'R' && k > n
                 throw(DimensionMismatch("invalid number of reflectors: k = $k should be <= n = $n"))
             end
-            work  = Array{$elty}(1)
+            work  = Vector{$elty}(1)
             lwork = BlasInt(-1)
             info  = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 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},
@@ -2627,7 +2627,7 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             C
@@ -2660,10 +2660,10 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
             if side == 'R' && k > n
                 throw(DimensionMismatch("invalid number of reflectors: k = $k should be <= n = $n"))
             end
-            work  = Array{$elty}(1)
+            work  = Vector{$elty}(1)
             lwork = BlasInt(-1)
             info  = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 ccall((@blasfunc($ormqr), liblapack), Void,
                       (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt},
                        Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
@@ -2676,7 +2676,7 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             C
@@ -2709,10 +2709,10 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
             if side == 'R' && k > n
                 throw(DimensionMismatch("invalid number of reflectors: k = $k should be <= n = $n"))
             end
-            work  = Array{$elty}(1)
+            work  = Vector{$elty}(1)
             lwork = BlasInt(-1)
             info  = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 ccall((@blasfunc($ormql), liblapack), Void,
                       (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt},
                        Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
@@ -2725,7 +2725,7 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             C
@@ -2758,10 +2758,10 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
             if side == 'R' && k > n
                 throw(DimensionMismatch("invalid number of reflectors: k = $k should be <= n = $n"))
             end
-            work  = Array{$elty}(1)
+            work  = Vector{$elty}(1)
             lwork = BlasInt(-1)
             info  = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 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},
@@ -2771,7 +2771,7 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             C
@@ -2815,7 +2815,7 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
                 throw(DimensionMismatch("wrong value for nb = $nb, which must be between 1 and $k"))
             end
             ldc = stride(C, 2)
-            work = Array{$elty}(wss)
+            work = Vector{$elty}(wss)
             info = Ref{BlasInt}()
             ccall((@blasfunc($gemqrt), liblapack), Void,
                 (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt},
@@ -2963,10 +2963,10 @@ for (posv, potrf, potri, potrs, pstrf, elty, rtyp) in
                   (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                   &uplo, &size(A,1), A, &lda, info)
             chkargsok(info[])
-            #info[1]>0 means the leading minor of order info[i] is not positive definite
+            #info[] > 0 means the leading minor of order info[] is not positive definite
             #ordinarily, throw Exception here, but return error code here
             #this simplifies isposdef! and factorize
-            return A, info[]
+            return A, info[] # info stored in Cholesky
         end
 
         #       SUBROUTINE DPOTRI( UPLO, N, A, LDA, INFO )
@@ -3029,8 +3029,8 @@ for (posv, potrf, potri, potrs, pstrf, elty, rtyp) in
             n = checksquare(A)
             chkuplo(uplo)
             piv  = similar(A, BlasInt, n)
-            rank = Array{BlasInt}(1)
-            work = Array{$rtyp}(2n)
+            rank = Vector{BlasInt}(1)
+            work = Vector{$rtyp}(2n)
             info = Ref{BlasInt}()
             ccall((@blasfunc($pstrf), liblapack), Void,
                   (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt},
@@ -3334,9 +3334,9 @@ for (trcon, trevc, trrfs, elty) in
             chkdiag(diag)
             n = checksquare(A)
             chkuplo(uplo)
-            rcond = Array{$elty}(1)
-            work  = Array{$elty}(3n)
-            iwork = Array{BlasInt}(n)
+            rcond = Vector{$elty}(1)
+            work  = Vector{$elty}(3n)
+            iwork = Vector{BlasInt}(n)
             info  = Ref{BlasInt}()
             ccall((@blasfunc($trcon), liblapack), Void,
                   (Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt},
@@ -3372,8 +3372,8 @@ for (trcon, trevc, trrfs, elty) in
             chkstride1(T, select)
 
             # Allocate
-            m = Array{BlasInt}(1)
-            work = Array{$elty}(3n)
+            m = Ref{BlasInt}()
+            work = Vector{$elty}(3n)
             info = Ref{BlasInt}()
 
             ccall((@blasfunc($trevc), liblapack), Void,
@@ -3390,19 +3390,19 @@ for (trcon, trevc, trrfs, elty) in
             #Decide what exactly to return
             if howmny == 'S' #compute selected eigenvectors
                 if side == 'L' #left eigenvectors only
-                    return select, VL[:,1:m[1]]
+                    return select, VL[:,1:m[]]
                 elseif side == 'R' #right eigenvectors only
-                    return select, VR[:,1:m[1]]
+                    return select, VR[:,1:m[]]
                 else #side == 'B' #both eigenvectors
-                    return select, VL[:,1:m[1]], VR[:,1:m[1]]
+                    return select, VL[:,1:m[]], VR[:,1:m[]]
                 end
             else #compute all eigenvectors
                 if side == 'L' #left eigenvectors only
-                    return VL[:,1:m[1]]
+                    return VL[:,1:m[]]
                 elseif side == 'R' #right eigenvectors only
-                    return VR[:,1:m[1]]
+                    return VR[:,1:m[]]
                 else #side == 'B' #both eigenvectors
-                    return VL[:,1:m[1]], VR[:,1:m[1]]
+                    return VL[:,1:m[]], VR[:,1:m[]]
                 end
             end
         end
@@ -3428,8 +3428,8 @@ for (trcon, trevc, trrfs, elty) in
             if nrhs != size(X,2)
                 throw(DimensionMismatch("second dimensions of B, $nrhs, and X, $(size(X,2)), must match"))
             end
-            work = Array{$elty}(3n)
-            iwork = Array{BlasInt}(n)
+            work = Vector{$elty}(3n)
+            iwork = Vector{BlasInt}(n)
             info = Ref{BlasInt}()
             ccall((@blasfunc($trrfs), liblapack), Void,
                 (Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt},
@@ -3462,9 +3462,9 @@ for (trcon, trevc, trrfs, elty, relty) in
             n = checksquare(A)
             chkuplo(uplo)
             chkdiag(diag)
-            rcond = Array{$relty}(1)
-            work  = Array{$elty}(2n)
-            rwork = Array{$relty}(n)
+            rcond = Vector{$relty}(1)
+            work  = Vector{$elty}(2n)
+            rwork = Vector{$relty}(n)
             info  = Ref{BlasInt}()
             ccall((@blasfunc($trcon), liblapack), Void,
                   (Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt},
@@ -3501,9 +3501,9 @@ for (trcon, trevc, trrfs, elty, relty) in
             end
 
             # Allocate
-            m = Array{BlasInt}(1)
-            work = Array{$elty}(2n)
-            rwork = Array{$relty}(n)
+            m = Ref{BlasInt}()
+            work = Vector{$elty}(2n)
+            rwork = Vector{$relty}(n)
             info = Ref{BlasInt}()
             ccall((@blasfunc($trevc), liblapack), Void,
                 (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt},
@@ -3519,19 +3519,19 @@ for (trcon, trevc, trrfs, elty, relty) in
             #Decide what exactly to return
             if howmny == 'S' #compute selected eigenvectors
                 if side == 'L' #left eigenvectors only
-                    return select, VL[:,1:m[1]]
+                    return select, VL[:,1:m[]]
                 elseif side == 'R' #right eigenvectors only
-                    return select, VR[:,1:m[1]]
+                    return select, VR[:,1:m[]]
                 else #side=='B' #both eigenvectors
-                    return select, VL[:,1:m[1]], VR[:,1:m[1]]
+                    return select, VL[:,1:m[]], VR[:,1:m[]]
                 end
             else #compute all eigenvectors
                 if side == 'L' #left eigenvectors only
-                    return VL[:,1:m[1]]
+                    return VL[:,1:m[]]
                 elseif side == 'R' #right eigenvectors only
-                    return VR[:,1:m[1]]
+                    return VR[:,1:m[]]
                 else #side=='B' #both eigenvectors
-                    return VL[:,1:m[1]], VR[:,1:m[1]]
+                    return VL[:,1:m[]], VR[:,1:m[]]
                 end
             end
         end
@@ -3557,8 +3557,8 @@ for (trcon, trevc, trrfs, elty, relty) in
             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)
+            work  = Vector{$elty}(2n)
+            rwork = Vector{$relty}(n)
             info  = Ref{BlasInt}()
             ccall((@blasfunc($trrfs), liblapack), Void,
                 (Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt},
@@ -3628,7 +3628,7 @@ for (stev, stebz, stegr, stein, elty) in
                 throw(DimensionMismatch("ev has length $(length(ev)) but needs one less than dv's length, $n)"))
             end
             Zmat = similar(dv, $elty, (n, job != 'N' ? n : 0))
-            work = Array{$elty}(max(1, 2n-2))
+            work = Vector{$elty}(max(1, 2n-2))
             info = Ref{BlasInt}()
             ccall((@blasfunc($stev), liblapack), Void,
                   (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty}, Ptr{$elty},
@@ -3648,14 +3648,14 @@ for (stev, stebz, stegr, stein, elty) in
             if length(ev) != n - 1
                 throw(DimensionMismatch("ev has length $(length(ev)) but needs one less than dv's length, $n)"))
             end
-            m = Array{BlasInt}(1)
-            nsplit = Array{BlasInt}(1)
+            m = Ref{BlasInt}()
+            nsplit = Vector{BlasInt}(1)
             w = similar(dv, $elty, n)
             tmp = 0.0
             iblock = similar(dv, BlasInt,n)
             isplit = similar(dv, BlasInt,n)
-            work = Array{$elty}(4*n)
-            iwork = Array{BlasInt}(3*n)
+            work = Vector{$elty}(4*n)
+            iwork = Vector{BlasInt}(3*n)
             info = Ref{BlasInt}()
             ccall((@blasfunc($stebz), liblapack), Void,
                 (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty},
@@ -3669,7 +3669,7 @@ for (stev, stebz, stegr, stein, elty) in
                 w, iblock, isplit, work,
                 iwork, info)
             chklapackerror(info[])
-            w[1:m[1]], iblock[1:m[1]], isplit[1:nsplit[1]]
+            w[1:m[]], iblock[1:m[]], isplit[1:nsplit[1]]
         end
 
         function stegr!(jobz::Char, range::Char, dv::StridedVector{$elty}, ev::StridedVector{$elty}, vl::Real, vu::Real, il::Integer, iu::Integer)
@@ -3679,18 +3679,18 @@ for (stev, stebz, stegr, stein, elty) in
                 throw(DimensionMismatch("ev has length $(length(ev)) but needs one less than dv's length, $n)"))
             end
             eev = [ev; zero($elty)]
-            abstol = Array{$elty}(1)
-            m = Array{BlasInt}(1)
+            abstol = Vector{$elty}(1)
+            m = Ref{BlasInt}()
             w = similar(dv, $elty, n)
             ldz = jobz == 'N' ? 1 : n
             Z = similar(dv, $elty, ldz, range == 'I' ? iu-il+1 : n)
             isuppz = similar(dv, BlasInt, 2*size(Z, 2))
-            work = Array{$elty}(1)
+            work = Vector{$elty}(1)
             lwork = BlasInt(-1)
-            iwork = Array{BlasInt}(1)
+            iwork = Vector{BlasInt}(1)
             liwork = BlasInt(-1)
             info = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1] and liwork as iwork[1]
                 ccall((@blasfunc($stegr), liblapack), Void,
                     (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty},
                     Ptr{$elty}, Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt},
@@ -3705,12 +3705,12 @@ for (stev, stebz, stegr, stein, elty) in
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(work[1])
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                     liwork = iwork[1]
-                    iwork = Array{BlasInt}(liwork)
+                    resize!(iwork, liwork)
                 end
             end
-            m[1] == length(w) ? w : w[1:m[1]], m[1] == size(Z, 2) ? Z : Z[:,1:m[1]]
+            m[] == length(w) ? w : w[1:m[]], m[] == size(Z, 2) ? Z : Z[:,1:m[]]
         end
 
         function stein!(dv::StridedVector{$elty}, ev_in::StridedVector{$elty}, w_in::StridedVector{$elty}, iblock_in::StridedVector{BlasInt}, isplit_in::StridedVector{BlasInt})
@@ -3744,9 +3744,9 @@ for (stev, stebz, stegr, stein, elty) in
                 isplit[1:length(isplit_in)] = isplit_in
             end
             z = similar(dv, $elty,(n,m))
-            work  = Array{$elty}(5*n)
-            iwork = Array{BlasInt}(n)
-            ifail = Array{BlasInt}(m)
+            work  = Vector{$elty}(5*n)
+            iwork = Vector{BlasInt}(n)
+            ifail = Vector{BlasInt}(m)
             info  = Ref{BlasInt}()
             ccall((@blasfunc($stein), liblapack), Void,
                 (Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt},
@@ -3834,7 +3834,7 @@ for (syconv, sysv, sytrf, sytri, sytrs, elty) in
             chkstride1(A, ipiv)
             n = checksquare(A)
             chkuplo(uplo)
-            work = Array{$elty}(n)
+            work = Vector{$elty}(n)
             info = Ref{BlasInt}()
             ccall((@blasfunc($syconv), liblapack), Void,
                   (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
@@ -3860,10 +3860,10 @@ for (syconv, sysv, sytrf, sytri, sytrs, elty) in
                 throw(DimensionMismatch("B has first dimension $(size(B,1)), but needs $n"))
             end
             ipiv  = similar(A, BlasInt, n)
-            work  = Array{$elty}(1)
+            work  = Vector{$elty}(1)
             lwork = BlasInt(-1)
             info  = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 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}),
@@ -3873,7 +3873,7 @@ for (syconv, sysv, sytrf, sytri, sytrs, elty) in
                 chknonsingular(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             B, A, ipiv
@@ -3894,10 +3894,10 @@ for (syconv, sysv, sytrf, sytri, sytrs, elty) in
             if n == 0
                 return A, ipiv
             end
-            work  = Array{$elty}(1)
+            work  = Vector{$elty}(1)
             lwork = BlasInt(-1)
             info  = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 ccall((@blasfunc($sytrf), liblapack), Void,
                       (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                        Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
@@ -3905,7 +3905,7 @@ for (syconv, sysv, sytrf, sytri, sytrs, elty) in
                 chkargsok(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             return A, ipiv, info[]
@@ -3922,7 +3922,7 @@ for (syconv, sysv, sytrf, sytri, sytrs, elty) in
 #             chkstride1(A)
 #             n = checksquare(A)
 #             chkuplo(uplo)
-#             work  = Array{$elty}(1)
+#             work  = Vector{$elty}(1)
 #             lwork = BlasInt(-1)
 #             info  = Ref{BlasInt}()
 #             for i in 1:2
@@ -3934,7 +3934,7 @@ for (syconv, sysv, sytrf, sytri, sytrs, elty) in
 #                 chknonsingular(info[])
 #                 if lwork < 0
 #                     lwork = BlasInt(real(work[1]))
-#                     work = Array{$elty}(lwork)
+#                     work = Vector{$elty}(lwork)
 #                 end
 #             end
 #             A
@@ -3951,7 +3951,7 @@ for (syconv, sysv, sytrf, sytri, sytrs, elty) in
             chkstride1(A, ipiv)
             n = checksquare(A)
             chkuplo(uplo)
-            work = Array{$elty}(n)
+            work = Vector{$elty}(n)
             info = Ref{BlasInt}()
             ccall((@blasfunc($sytri), liblapack), Void,
                   (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
@@ -3990,9 +3990,9 @@ for (syconv, sysv, sytrf, sytri, sytrs, elty) in
 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))
+for (sysv, sytrf, sytri, sytrs, syconvf, elty) in
+    ((:dsysv_rook_,:dsytrf_rook_,:dsytri_rook_,:dsytrs_rook_,:dsyconvf_rook_,:Float64),
+     (:ssysv_rook_,:ssytrf_rook_,:ssytri_rook_,:ssytrs_rook_,:ssyconvf_rook_,:Float32))
     @eval begin
         #       SUBROUTINE DSYSV_ROOK(UPLO, N, NRHS, A, LDA, IPIV, B, LDB, WORK,
         #                             LWORK, INFO )
@@ -4010,10 +4010,10 @@ for (sysv, sytrf, sytri, sytrs, elty) in
                 throw(DimensionMismatch("B has first dimension $(size(B,1)), but needs $n"))
             end
             ipiv  = similar(A, BlasInt, n)
-            work  = Array{$elty}(1)
+            work  = Vector{$elty}(1)
             lwork = BlasInt(-1)
             info  = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 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}),
@@ -4023,7 +4023,7 @@ for (sysv, sytrf, sytri, sytrs, elty) in
                 chknonsingular(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             B, A, ipiv
@@ -4044,10 +4044,10 @@ for (sysv, sytrf, sytri, sytrs, elty) in
             if n == 0
                 return A, ipiv
             end
-            work  = Array{$elty}(1)
+            work  = Vector{$elty}(1)
             lwork = BlasInt(-1)
             info  = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 ccall((@blasfunc($sytrf), liblapack), Void,
                       (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                        Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
@@ -4055,7 +4055,7 @@ for (sysv, sytrf, sytri, sytrs, elty) in
                 chkargsok(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             return A, ipiv, info[]
@@ -4072,7 +4072,7 @@ for (sysv, sytrf, sytri, sytrs, elty) in
             chkstride1(A, ipiv)
             n = checksquare(A)
             chkuplo(uplo)
-            work = Array{$elty}(n)
+            work = Vector{$elty}(n)
             info = Ref{BlasInt}()
             ccall((@blasfunc($sytri), liblapack), Void,
                   (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
@@ -4107,6 +4107,45 @@ for (sysv, sytrf, sytri, sytrs, elty) in
             chklapackerror(info[])
             B
         end
+
+        # SUBROUTINE DSYCONVF_ROOK( UPLO, WAY, N, A, LDA, IPIV, E, INFO )
+        #
+        # .. Scalar Arguments ..
+        # CHARACTER          UPLO, WAY
+        # INTEGER            INFO, LDA, N
+        # ..
+        # .. Array Arguments ..
+        # INTEGER            IPIV( * )
+        # DOUBLE PRECISION   A( LDA, * ), E( * )
+        function syconvf_rook!(uplo::Char, way::Char, A::StridedMatrix{$elty},
+                               ipiv::StridedVector{BlasInt}, e::StridedVector{$elty})
+            # extract
+            n = checksquare(A)
+
+            # check
+            chkuplo(uplo)
+            if way != :C && way != :R
+                throw(ArgumentError("way must be :C or :R"))
+            end
+            if length(ipiv) != n
+                throw(ArgumentError("length of pivot vector was $(length(ipiv)) but should have been $n"))
+            end
+            if length(e) != n
+                throw(ArgumentError("length of e vector was $(length(ipiv)) but should have been $n"))
+            end
+
+            # allocate
+            info = Ref{BlasInt}()
+
+            ccall((@blasfunc($syconvf), liblapack), Void,
+                (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty},
+                 Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}),
+                &uplo, &way, &n, A,
+                &lda, ipiv, e, info)
+
+            chklapackerror(info[])
+            return A, e
+        end
     end
 end
 
@@ -4129,7 +4168,7 @@ for (syconv, hesv, hetrf, hetri, hetrs, elty, relty) in
             chkstride1(A,ipiv)
             n = checksquare(A)
             chkuplo(uplo)
-            work = Array{$elty}(n)
+            work = Vector{$elty}(n)
             info = Ref{BlasInt}()
             ccall((@blasfunc($syconv), liblapack), Void,
                   (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
@@ -4155,10 +4194,10 @@ for (syconv, hesv, hetrf, hetri, hetrs, elty, relty) in
                 throw(DimensionMismatch("B has first dimension $(size(B,1)), but needs $n"))
             end
             ipiv  = similar(A, BlasInt, n)
-            work  = Array{$elty}(1)
+            work  = Vector{$elty}(1)
             lwork = BlasInt(-1)
             info  = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 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}),
@@ -4167,7 +4206,7 @@ for (syconv, hesv, hetrf, hetri, hetrs, elty, relty) in
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             B, A, ipiv
@@ -4186,10 +4225,10 @@ for (syconv, hesv, hetrf, hetri, hetrs, elty, relty) in
             n = checksquare(A)
             chkuplo(uplo)
             ipiv  = similar(A, BlasInt, n)
-            work  = Array{$elty}(1)
+            work  = Vector{$elty}(1)
             lwork = BlasInt(-1)
             info  = Ref{BlasInt}()
-            for i in 1:2
+            for i in 1:2  # first call returns lwork as work[1]
                 ccall((@blasfunc($hetrf), liblapack), Void,
                       (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                        Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
@@ -4197,7 +4236,7 @@ for (syconv, hesv, hetrf, hetri, hetrs, elty, relty) in
                 chkargsok(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             A, ipiv, info[]
@@ -4215,7 +4254,7 @@ for (syconv, hesv, hetrf, hetri, hetrs, elty, relty) in
 #             chkstride1(A)
 #             n = checksquare(A)
 #             chkuplo(uplo)
-#             work  = Array{$elty}(1)
+#             work  = Vector{$elty}(1)
 #             lwork = BlasInt(-1)
 #             info  = Ref{BlasInt}()
 #             for i in 1:2
@@ -4226,7 +4265,7 @@ for (syconv, hesv, hetrf, hetri, hetrs, elty, relty) in
 #                 chklapackerror(info[])
 #                 if lwork < 0
 #                     lwork = BlasInt(real(work[1]))
-#                     work = Array{$elty}(lwork)
+#                     work = Vector{$elty}(lwork)
 #                 end
 #             end
 #             A
@@ -4245,7 +4284,7 @@ for (syconv, hesv, hetrf, hetri, hetrs, elty, relty) in
             chkstride1(A, ipiv)
             n = checksquare(A)
             chkuplo(uplo)
-            work = Array{$elty}(n)
+            work = Vector{$elty}(n)
             info = Ref{BlasInt}()
             ccall((@blasfunc($hetri), liblapack), Void,
                   (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
@@ -4301,10 +4340,10 @@ for (hesv, hetrf, hetri, hetrs, elty, relty) in
                 throw(DimensionMismatch("B has first dimension $(size(B,1)), but needs $n"))
             end
             ipiv  = similar(A, BlasInt, n)
-            work  = Array{$elty}(1)
+            work  = Vector{$elty}(1)
             lwork = BlasInt(-1)
             info  = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 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}),
@@ -4313,7 +4352,7 @@ for (hesv, hetrf, hetri, hetrs, elty, relty) in
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             B, A, ipiv
@@ -4332,10 +4371,10 @@ for (hesv, hetrf, hetri, hetrs, elty, relty) in
             n = checksquare(A)
             chkuplo(uplo)
             ipiv  = similar(A, BlasInt, n)
-            work  = Array{$elty}(1)
+            work  = Vector{$elty}(1)
             lwork = BlasInt(-1)
             info  = Ref{BlasInt}()
-            for i in 1:2
+            for i in 1:2  # first call returns lwork as work[1]
                 ccall((@blasfunc($hetrf), liblapack), Void,
                       (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                        Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
@@ -4343,7 +4382,7 @@ for (hesv, hetrf, hetri, hetrs, elty, relty) in
                 chkargsok(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             A, ipiv, info[]
@@ -4361,7 +4400,7 @@ for (hesv, hetrf, hetri, hetrs, elty, relty) in
             chkstride1(A,ipiv)
             n = checksquare(A)
             chkuplo(uplo)
-            work = Array{$elty}(n)
+            work = Vector{$elty}(n)
             info = Ref{BlasInt}()
             ccall((@blasfunc($hetri), liblapack), Void,
                   (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
@@ -4418,10 +4457,10 @@ for (sysv, sytrf, sytri, sytrs, elty, relty) in
                 throw(DimensionMismatch("B has first dimension $(size(B,1)), but needs $n"))
             end
             ipiv  = similar(A, BlasInt, n)
-            work  = Array{$elty}(1)
+            work  = Vector{$elty}(1)
             lwork = BlasInt(-1)
             info  = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 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}),
@@ -4431,7 +4470,7 @@ for (sysv, sytrf, sytri, sytrs, elty, relty) in
                 chknonsingular(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             B, A, ipiv
@@ -4453,10 +4492,10 @@ for (sysv, sytrf, sytri, sytrs, elty, relty) in
             if n == 0
                 return A, ipiv
             end
-            work  = Array{$elty}(1)
+            work  = Vector{$elty}(1)
             lwork = BlasInt(-1)
             info  = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 ccall((@blasfunc($sytrf), liblapack), Void,
                       (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                        Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
@@ -4464,7 +4503,7 @@ for (sysv, sytrf, sytri, sytrs, elty, relty) in
                 chkargsok(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             A, ipiv, info[]
@@ -4482,7 +4521,7 @@ for (sysv, sytrf, sytri, sytrs, elty, relty) in
 #             chkstride1(A)
 #             n = checksquare(A)
 #             chkuplo(uplo)
-#             work  = Array{$elty}(1)
+#             work  = Vector{$elty}(1)
 #             lwork = BlasInt(-1)
 #             info  = Ref{BlasInt}()
 #             for i in 1:2
@@ -4493,7 +4532,7 @@ for (sysv, sytrf, sytri, sytrs, elty, relty) in
 #                 chklapackerror(info[])
 #                 if lwork < 0
 #                     lwork = BlasInt(real(work[1]))
-#                     work = Array{$elty}(lwork)
+#                     work = Vector{$elty}(lwork)
 #                 end
 #             end
 #             A
@@ -4511,7 +4550,7 @@ for (sysv, sytrf, sytri, sytrs, elty, relty) in
             chkstride1(A, ipiv)
             n = checksquare(A)
             chkuplo(uplo)
-            work = Array{$elty}(n)
+            work = Vector{$elty}(n)
             info = Ref{BlasInt}()
             ccall((@blasfunc($sytri), liblapack), Void,
                   (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
@@ -4548,9 +4587,9 @@ for (sysv, sytrf, sytri, sytrs, elty, relty) in
     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))
+for (sysv, sytrf, sytri, sytrs, syconvf, elty, relty) in
+    ((:zsysv_rook_,:zsytrf_rook_,:zsytri_rook_,:zsytrs_rook_,:zsyconvf_rook_,:Complex128, :Float64),
+     (:csysv_rook_,:csytrf_rook_,:csytri_rook_,:csytrs_rook_,:csyconvf_rook_,:Complex64, :Float32))
     @eval begin
         #       SUBROUTINE ZSYSV_ROOK(UPLO, N, NRHS, A, LDA, IPIV, B, LDB, WORK,
         #      $                      LWORK, INFO )
@@ -4569,10 +4608,10 @@ for (sysv, sytrf, sytri, sytrs, elty, relty) in
                 throw(DimensionMismatch("B has first dimension $(size(B,1)), but needs $n"))
             end
             ipiv  = similar(A, BlasInt, n)
-            work  = Array{$elty}(1)
+            work  = Vector{$elty}(1)
             lwork = BlasInt(-1)
             info  = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 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}),
@@ -4582,7 +4621,7 @@ for (sysv, sytrf, sytri, sytrs, elty, relty) in
                 chknonsingular(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             B, A, ipiv
@@ -4604,10 +4643,10 @@ for (sysv, sytrf, sytri, sytrs, elty, relty) in
             if n == 0
                 return A, ipiv
             end
-            work  = Array{$elty}(1)
+            work  = Vector{$elty}(1)
             lwork = BlasInt(-1)
             info  = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 ccall((@blasfunc($sytrf), liblapack), Void,
                       (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                        Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
@@ -4615,7 +4654,7 @@ for (sysv, sytrf, sytri, sytrs, elty, relty) in
                 chkargsok(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             A, ipiv, info[]
@@ -4633,7 +4672,7 @@ for (sysv, sytrf, sytri, sytrs, elty, relty) in
             chkstride1(A, ipiv)
             n = checksquare(A)
             chkuplo(uplo)
-            work = Array{$elty}(n)
+            work = Vector{$elty}(n)
             info = Ref{BlasInt}()
             ccall((@blasfunc($sytri), liblapack), Void,
                   (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
@@ -4667,6 +4706,46 @@ for (sysv, sytrf, sytri, sytrs, elty, relty) in
             chklapackerror(info[])
             B
         end
+
+        # SUBROUTINE ZSYCONVF_ROOK( UPLO, WAY, N, A, LDA, IPIV, E, INFO )
+        #
+        # .. Scalar Arguments ..
+        # CHARACTER          UPLO, WAY
+        # INTEGER            INFO, LDA, N
+        # ..
+        # .. Array Arguments ..
+        # INTEGER            IPIV( * )
+        # COMPLEX*16         A( LDA, * ), E( * )
+        function syconvf_rook!(uplo::Char, way::Char, A::StridedMatrix{$elty},
+                               ipiv::StridedVector{BlasInt}, e::StridedVector{$elty} = Vector{$elty}(length(ipiv)))
+            # extract
+            n   = checksquare(A)
+            lda = stride(A, 2)
+
+            # check
+            chkuplo(uplo)
+            if way != 'C' && way != 'R'
+                throw(ArgumentError("way must be 'C' or 'R'"))
+            end
+            if length(ipiv) != n
+                throw(ArgumentError("length of pivot vector was $(length(ipiv)) but should have been $n"))
+            end
+            if length(e) != n
+                throw(ArgumentError("length of e vector was $(length(ipiv)) but should have been $n"))
+            end
+
+            # allocate
+            info = Ref{BlasInt}()
+
+            ccall((@blasfunc($syconvf), liblapack), Void,
+                (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty},
+                 Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}),
+                &uplo, &way, &n, A,
+                &max(1, lda), ipiv, e, info)
+
+            chklapackerror(info[])
+            return A, e
+        end
     end
 end
 
@@ -4785,10 +4864,10 @@ for (syev, syevr, sygvd, elty) in
             chkstride1(A)
             n = checksquare(A)
             W     = similar(A, $elty, n)
-            work  = Array{$elty}(1)
+            work  = Vector{$elty}(1)
             lwork = BlasInt(-1)
             info  = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 ccall((@blasfunc($syev), liblapack), Void,
                       (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                       Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
@@ -4796,7 +4875,7 @@ for (syev, syevr, sygvd, elty) in
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             jobz == 'V' ? (W, A) : W
@@ -4824,7 +4903,7 @@ for (syev, syevr, sygvd, elty) in
                 throw(ArgumentError("lower boundary, $vl, must be less than upper boundary, $vu"))
             end
             lda = stride(A,2)
-            m = Array{BlasInt}(1)
+            m = Ref{BlasInt}()
             w = similar(A, $elty, n)
             ldz = n
             if jobz == 'N'
@@ -4833,12 +4912,12 @@ for (syev, syevr, sygvd, elty) in
                 Z = similar(A, $elty, ldz, n)
             end
             isuppz = similar(A, BlasInt, 2*n)
-            work   = Array{$elty}(1)
+            work   = Vector{$elty}(1)
             lwork  = BlasInt(-1)
-            iwork  = Array{BlasInt}(1)
+            iwork  = Vector{BlasInt}(1)
             liwork = BlasInt(-1)
             info   = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1] and liwork as iwork[1]
                 ccall((@blasfunc($syevr), liblapack), Void,
                     (Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt},
                         Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty},
@@ -4855,12 +4934,12 @@ for (syev, syevr, sygvd, elty) in
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                     liwork = iwork[1]
-                    iwork = Array{BlasInt}(liwork)
+                    resize!(iwork, liwork)
                 end
             end
-            w[1:m[1]], Z[:,1:(jobz == 'V' ? m[1] : 0)]
+            w[1:m[]], Z[:,1:(jobz == 'V' ? m[] : 0)]
         end
         syevr!(jobz::Char, A::StridedMatrix{$elty}) =
             syevr!(jobz, 'A', 'U', A, 0.0, 0.0, 0, 0, -1.0)
@@ -4884,12 +4963,12 @@ for (syev, syevr, sygvd, elty) in
             lda = max(1, stride(A, 2))
             ldb = max(1, stride(B, 2))
             w = similar(A, $elty, n)
-            work = Array{$elty}(1)
+            work = Vector{$elty}(1)
             lwork = BlasInt(-1)
-            iwork = Array{BlasInt}(1)
+            iwork = Vector{BlasInt}(1)
             liwork = BlasInt(-1)
             info = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1] and liwork as iwork[1]
                 ccall((@blasfunc($sygvd), liblapack), Void,
                     (Ptr{BlasInt}, Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt},
                      Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
@@ -4902,9 +4981,9 @@ for (syev, syevr, sygvd, elty) in
                 chkargsok(info[])
                 if i == 1
                     lwork = BlasInt(work[1])
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                     liwork = iwork[1]
-                    iwork = Array{BlasInt}(liwork)
+                    resize!(iwork, liwork)
                 end
             end
             chkposdef(info[])
@@ -4929,11 +5008,11 @@ for (syev, syevr, sygvd, elty, relty) in
             chkstride1(A)
             n = checksquare(A)
             W     = similar(A, $relty, n)
-            work  = Array{$elty}(1)
+            work  = Vector{$elty}(1)
             lwork = BlasInt(-1)
-            rwork = Array{$relty}(max(1, 3n-2))
+            rwork = Vector{$relty}(max(1, 3n-2))
             info  = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 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}),
@@ -4941,7 +5020,7 @@ for (syev, syevr, sygvd, elty, relty) in
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             jobz == 'V' ? (W, A) : W
@@ -4971,7 +5050,7 @@ for (syev, syevr, sygvd, elty, relty) in
                 throw(ArgumentError("lower boundary, $vl, must be less than upper boundary, $vu"))
             end
             lda = max(1,stride(A,2))
-            m = Array{BlasInt}(1)
+            m = Ref{BlasInt}()
             w = similar(A, $relty, n)
             if jobz == 'N'
                 ldz = 1
@@ -4981,14 +5060,14 @@ for (syev, syevr, sygvd, elty, relty) in
                 Z = similar(A, $elty, ldz, n)
             end
             isuppz = similar(A, BlasInt, 2*n)
-            work   = Array{$elty}(1)
+            work   = Vector{$elty}(1)
             lwork  = BlasInt(-1)
-            rwork  = Array{$relty}(1)
+            rwork  = Vector{$relty}(1)
             lrwork = BlasInt(-1)
-            iwork  = Array{BlasInt}(1)
+            iwork  = Vector{BlasInt}(1)
             liwork = BlasInt(-1)
             info   = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1], lrwork as rwork[1] and liwork as iwork[1]
                 ccall((@blasfunc($syevr), liblapack), Void,
                       (Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt},
                        Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty},
@@ -5005,14 +5084,14 @@ for (syev, syevr, sygvd, elty, relty) in
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                     lrwork = BlasInt(rwork[1])
-                    rwork = Array{$relty}(lrwork)
+                    resize!(rwork, lrwork)
                     liwork = iwork[1]
-                    iwork = Array{BlasInt}(liwork)
+                    resize!(iwork, liwork)
                 end
             end
-            w[1:m[1]], Z[:,1:(jobz == 'V' ? m[1] : 0)]
+            w[1:m[]], Z[:,1:(jobz == 'V' ? m[] : 0)]
         end
         syevr!(jobz::Char, A::StridedMatrix{$elty}) =
             syevr!(jobz, 'A', 'U', A, 0.0, 0.0, 0, 0, -1.0)
@@ -5036,14 +5115,14 @@ for (syev, syevr, sygvd, elty, relty) in
             lda = max(1, stride(A, 2))
             ldb = max(1, stride(B, 2))
             w = similar(A, $relty, n)
-            work = Array{$elty}(1)
+            work = Vector{$elty}(1)
             lwork = BlasInt(-1)
-            iwork = Array{BlasInt}(1)
+            iwork = Vector{BlasInt}(1)
             liwork = BlasInt(-1)
-            rwork = Array{$relty}()
+            rwork = Vector{$relty}(1)
             lrwork = BlasInt(-1)
             info = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1], lrwork as rwork[1] and liwork as iwork[1]
                 ccall((@blasfunc($sygvd), liblapack), Void,
                     (Ptr{BlasInt}, Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt},
                      Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
@@ -5056,11 +5135,11 @@ for (syev, syevr, sygvd, elty, relty) in
                 chkargsok(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                     liwork = iwork[1]
-                    iwork = Array{BlasInt}(liwork)
+                    resize!(iwork, liwork)
                     lrwork = BlasInt(rwork[1])
-                    rwork = Array{$relty}(lrwork)
+                    resize!(rwork, lrwork)
                 end
             end
             chkposdef(info[])
@@ -5095,7 +5174,7 @@ 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)
+    sygvd!(itype, jobz, uplo, A, B) -> (w, A, B)
 
 Finds the generalized eigenvalues (`jobz = N`) or eigenvalues and
 eigenvectors (`jobz = V`) of a symmetric matrix `A` and symmetric
@@ -5140,7 +5219,7 @@ for (bdsqr, relty, elty) in
                 throw(DimensionMismatch("leading dimension of C, $ldc, must be at least $n"))
             end
             # Allocate
-            work = Array{$relty}(4n)
+            work = Vector{$relty}(4n)
             info = Ref{BlasInt}()
             ccall((@blasfunc($bdsqr), liblapack), Void,
                 (Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt},
@@ -5209,8 +5288,8 @@ for (bdsdc, elty) in
             vt = similar(d, $elty, (ldvt, n))
             q  = similar(d, $elty, ldq)
             iq = similar(d, BlasInt, ldiq)
-            work  = Array{$elty}(lwork)
-            iwork = Array{BlasInt}(8n)
+            work  = Vector{$elty}(lwork)
+            iwork = Vector{BlasInt}(8n)
             info  = Ref{BlasInt}()
             ccall((@blasfunc($bdsdc), liblapack), Void,
                (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty},
@@ -5258,9 +5337,9 @@ for (gecon, elty) in
             chkstride1(A)
             n = checksquare(A)
             lda = max(1, stride(A, 2))
-            rcond = Array{$elty}(1)
-            work = Array{$elty}(4n)
-            iwork = Array{BlasInt}(n)
+            rcond = Vector{$elty}(1)
+            work = Vector{$elty}(4n)
+            iwork = Vector{BlasInt}(n)
             info = Ref{BlasInt}()
             ccall((@blasfunc($gecon), liblapack), Void,
                   (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
@@ -5292,9 +5371,9 @@ for (gecon, elty, relty) in
             chkstride1(A)
             n = checksquare(A)
             lda = max(1, stride(A, 2))
-            rcond = Array{$relty}(1)
-            work = Array{$elty}(2n)
-            rwork = Array{$relty}(2n)
+            rcond = Vector{$relty}(1)
+            work = Vector{$elty}(2n)
+            rwork = Vector{$relty}(2n)
             info = Ref{BlasInt}()
             ccall((@blasfunc($gecon), liblapack), Void,
                   (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
@@ -5335,10 +5414,10 @@ for (gehrd, elty) in
             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)
+            work = Vector{$elty}(1)
             lwork = BlasInt(-1)
             info = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 ccall((@blasfunc($gehrd), liblapack), Void,
                     (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty},
                      Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt},
@@ -5349,7 +5428,7 @@ for (gehrd, elty) in
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             A, tau
@@ -5385,10 +5464,10 @@ for (orghr, elty) in
             if n - length(tau) != 1
                 throw(DimensionMismatch("tau has length $(length(tau)), needs $(n - 1)"))
             end
-            work = Array{$elty}(1)
+            work = Vector{$elty}(1)
             lwork = BlasInt(-1)
             info = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 ccall((@blasfunc($orghr), liblapack), Void,
                     (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty},
                      Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt},
@@ -5399,7 +5478,7 @@ for (orghr, elty) in
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             A
@@ -5441,10 +5520,10 @@ for (ormhr, elty) in
                 throw(DimensionMismatch("A and C matrices are not conformable"))
             end
 
-            work = Array{$elty}(1)
+            work = Vector{$elty}(1)
             lwork = BlasInt(-1)
             info = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 ccall((@blasfunc($ormhr), liblapack), Void,
                     (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt},
                      Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
@@ -5457,7 +5536,7 @@ for (ormhr, elty) in
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             C
@@ -5480,15 +5559,15 @@ for (gees, gges, elty) in
         function gees!(jobvs::Char, A::StridedMatrix{$elty})
             chkstride1(A)
             n = checksquare(A)
-            sdim = Array{BlasInt}(1)
+            sdim = Vector{BlasInt}(1)
             wr = similar(A, $elty, n)
             wi = similar(A, $elty, n)
             ldvs = jobvs == 'V' ? n : 1
             vs = similar(A, $elty, ldvs, n)
-            work = Array{$elty}(1)
+            work = Vector{$elty}(1)
             lwork = BlasInt(-1)
             info = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 ccall((@blasfunc($gees), liblapack), Void,
                     (Ptr{UInt8}, Ptr{UInt8}, Ptr{Void}, Ptr{BlasInt},
                         Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty},
@@ -5501,7 +5580,7 @@ for (gees, gges, elty) in
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             A, vs, iszero(wi) ? wr : complex.(wr, wi)
@@ -5530,10 +5609,10 @@ for (gees, gges, elty) in
             vsl = similar(A, $elty, ldvsl, n)
             ldvsr = jobvsr == 'V' ? n : 1
             vsr = similar(A, $elty, ldvsr, n)
-            work = Array{$elty}(1)
+            work = Vector{$elty}(1)
             lwork = BlasInt(-1)
             info = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 ccall((@blasfunc($gges), liblapack), Void,
                     (Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8}, Ptr{Void},
                         Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
@@ -5550,7 +5629,7 @@ for (gees, gges, elty) in
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             A, B, complex.(alphar, alphai), beta, vsl[1:(jobvsl == 'V' ? n : 0),:], vsr[1:(jobvsr == 'V' ? n : 0),:]
@@ -5578,11 +5657,11 @@ for (gees, gges, elty, relty) in
             w = similar(A, $elty, n)
             ldvs = jobvs == 'V' ? n : 1
             vs = similar(A, $elty, ldvs, n)
-            work = Array{$elty}(1)
+            work = Vector{$elty}(1)
             lwork = BlasInt(-1)
-            rwork = Array{$relty}(n)
+            rwork = Vector{$relty}(n)
             info = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 ccall((@blasfunc($gees), liblapack), Void,
                     (Ptr{UInt8}, Ptr{UInt8}, Ptr{Void}, Ptr{BlasInt},
                         Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty},
@@ -5595,7 +5674,7 @@ for (gees, gges, elty, relty) in
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             A, vs, w
@@ -5624,11 +5703,11 @@ for (gees, gges, elty, relty) in
             vsl = similar(A, $elty, ldvsl, n)
             ldvsr = jobvsr == 'V' ? n : 1
             vsr = similar(A, $elty, ldvsr, n)
-            work = Array{$elty}(1)
+            work = Vector{$elty}(1)
             lwork = BlasInt(-1)
-            rwork = Array{$relty}(8n)
+            rwork = Vector{$relty}(8n)
             info = Ref{BlasInt}()
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 ccall((@blasfunc($gges), liblapack), Void,
                     (Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8}, Ptr{Void},
                         Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
@@ -5645,7 +5724,7 @@ for (gees, gges, elty, relty) in
                 chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
-                    work = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             A, B, alpha, beta, vsl[1:(jobvsl == 'V' ? n : 0),:], vsr[1:(jobvsr == 'V' ? n : 0),:]
@@ -5692,7 +5771,7 @@ for (trexc, trsen, tgsen, elty) in
             n = checksquare(T)
             ldt = max(1, stride(T, 2))
             ldq = max(1, stride(Q, 2))
-            work = Array{$elty}(n)
+            work = Vector{$elty}(n)
             info = Ref{BlasInt}()
             ccall((@blasfunc($trexc), liblapack), Void,
                   (Ptr{UInt8},  Ptr{BlasInt},
@@ -5727,13 +5806,13 @@ for (trexc, trsen, tgsen, elty) in
             wr = similar(T, $elty, n)
             wi = similar(T, $elty, n)
             m = sum(select)
-            work = Array{$elty}(1)
+            work = Vector{$elty}(1)
             lwork = BlasInt(-1)
-            iwork = Array{BlasInt}(1)
+            iwork = Vector{BlasInt}(1)
             liwork = BlasInt(-1)
             info = Ref{BlasInt}()
             select = convert(Array{BlasInt}, select)
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1] and liwork as iwork[1]
                 ccall((@blasfunc($trsen), liblapack), Void,
                     (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt},
                     Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
@@ -5748,9 +5827,9 @@ for (trexc, trsen, tgsen, elty) in
                 chklapackerror(info[])
                 if i == 1 # only estimated optimal lwork, liwork
                     lwork  = BlasInt(real(work[1]))
+                    resize!(work, lwork)
                     liwork = BlasInt(real(iwork[1]))
-                    work   = Array{$elty}(lwork)
-                    iwork  = Array{BlasInt}(liwork)
+                    resize!(iwork, liwork)
                 end
             end
             T, Q, iszero(wi) ? wr : complex.(wr, wi)
@@ -5793,12 +5872,12 @@ for (trexc, trsen, tgsen, elty) in
             alphar = similar(T, $elty, n)
             beta = similar(T, $elty, n)
             lwork = BlasInt(-1)
-            work = Array{$elty}(1)
+            work = Vector{$elty}(1)
             liwork = BlasInt(-1)
-            iwork = Array{BlasInt}(1)
+            iwork = Vector{BlasInt}(1)
             info = Ref{BlasInt}()
             select = convert(Array{BlasInt}, select)
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1] and liwork as iwork[1]
                 ccall((@blasfunc($tgsen), liblapack), Void,
                        (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt},
                         Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
@@ -5817,9 +5896,9 @@ for (trexc, trsen, tgsen, elty) in
                 chklapackerror(info[])
                 if i == 1 # only estimated optimal lwork, liwork
                     lwork  = BlasInt(real(work[1]))
-                    work   = Array{$elty}(lwork)
+                    resize!(work, lwork)
                     liwork = BlasInt(real(iwork[1]))
-                    iwork = Array{BlasInt}(liwork)
+                    resize!(iwork, liwork)
                 end
             end
             S, T, complex.(alphar, alphai), beta, Q, Z
@@ -5874,11 +5953,11 @@ for (trexc, trsen, tgsen, elty) in
             ldq = max(1, stride(Q, 2))
             w = similar(T, $elty, n)
             m = sum(select)
-            work = Array{$elty}(1)
+            work = Vector{$elty}(1)
             lwork = BlasInt(-1)
             info = Ref{BlasInt}()
             select = convert(Array{BlasInt}, select)
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1]
                 ccall((@blasfunc($trsen), liblapack), Void,
                     (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt},
                     Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
@@ -5893,7 +5972,7 @@ for (trexc, trsen, tgsen, elty) in
                 chklapackerror(info[])
                 if i == 1 # only estimated optimal lwork, liwork
                     lwork  = BlasInt(real(work[1]))
-                    work   = Array{$elty}(lwork)
+                    resize!(work, lwork)
                 end
             end
             T, Q, w
@@ -5935,12 +6014,12 @@ for (trexc, trsen, tgsen, elty) in
             alpha = similar(T, $elty, n)
             beta = similar(T, $elty, n)
             lwork = BlasInt(-1)
-            work = Array{$elty}(1)
+            work = Vector{$elty}(1)
             liwork = BlasInt(-1)
-            iwork = Array{BlasInt}(1)
+            iwork = Vector{BlasInt}(1)
             info = Ref{BlasInt}()
             select = convert(Array{BlasInt}, select)
-            for i = 1:2
+            for i = 1:2  # first call returns lwork as work[1] and liwork as iwork[1]
                 ccall((@blasfunc($tgsen), liblapack), Void,
                        (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt},
                         Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
@@ -5959,9 +6038,9 @@ for (trexc, trsen, tgsen, elty) in
                 chklapackerror(info[])
                 if i == 1 # only estimated optimal lwork, liwork
                     lwork  = BlasInt(real(work[1]))
-                    work   = Array{$elty}(lwork)
+                    resize!(work, lwork)
                     liwork = BlasInt(real(iwork[1]))
-                    iwork = Array{BlasInt}(liwork)
+                    resize!(iwork, liwork)
                 end
             end
             S, T, alpha, beta, Q, Z
@@ -6018,7 +6097,7 @@ 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)
+            scale = Vector{$relty}(1)
             info  = Ref{BlasInt}()
             ccall((@blasfunc($fn), liblapack), Void,
                 (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt},
diff --git a/base/linalg/ldlt.jl b/base/linalg/ldlt.jl
index 55260cc46142ef..53414b08aeee9a 100644
--- a/base/linalg/ldlt.jl
+++ b/base/linalg/ldlt.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 struct LDLt{T,S<:AbstractMatrix} <: Factorization{T}
     data::S
@@ -7,13 +7,13 @@ end
 size(S::LDLt) = size(S.data)
 size(S::LDLt, i::Integer) = size(S.data, i)
 
-convert{T,S}(::Type{LDLt{T,S}}, F::LDLt) = LDLt{T,S}(convert(S, F.data))
+convert(::Type{LDLt{T,S}}, F::LDLt) where {T,S} = LDLt{T,S}(convert(S, F.data))
 # NOTE: the annotaion <:AbstractMatrix shouldn't be necessary, it is introduced
 #       to avoid an ambiguity warning (see issue #6383)
-convert{T,S,U<:AbstractMatrix}(::Type{LDLt{T}}, F::LDLt{S,U}) = convert(LDLt{T,U}, F)
+convert(::Type{LDLt{T}}, F::LDLt{S,U}) where {T,S,U<:AbstractMatrix} = convert(LDLt{T,U}, F)
 
-convert{T}(::Type{Factorization{T}}, F::LDLt{T}) = F
-convert{T,S,U}(::Type{Factorization{T}}, F::LDLt{S,U}) = convert(LDLt{T,U}, F)
+convert(::Type{Factorization{T}}, F::LDLt{T}) where {T} = F
+convert(::Type{Factorization{T}}, F::LDLt{S,U}) where {T,S,U} = convert(LDLt{T,U}, F)
 
 # SymTridiagonal
 """
@@ -21,7 +21,7 @@ convert{T,S,U}(::Type{Factorization{T}}, F::LDLt{S,U}) = convert(LDLt{T,U}, F)
 
 Same as [`ldltfact`](@ref), but saves space by overwriting the input `A`, instead of creating a copy.
 """
-function ldltfact!{T<:Real}(S::SymTridiagonal{T})
+function ldltfact!(S::SymTridiagonal{T}) where T<:Real
     n = size(S,1)
     d = S.dv
     e = S.ev
@@ -39,14 +39,14 @@ Compute an `LDLt` factorization of a real symmetric tridiagonal matrix such that
 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})
+function ldltfact(M::SymTridiagonal{T}) where T
     S = typeof(zero(T)/one(T))
     return S == T ? ldltfact!(copy(M)) : ldltfact!(convert(SymTridiagonal{S}, M))
 end
 
 factorize(S::SymTridiagonal) = ldltfact(S)
 
-function A_ldiv_B!{T}(S::LDLt{T,SymTridiagonal{T}}, B::AbstractVecOrMat{T})
+function A_ldiv_B!(S::LDLt{T,SymTridiagonal{T}}, B::AbstractVecOrMat{T}) where T
     n, nrhs = size(B, 1), size(B, 2)
     if size(S,1) != n
         throw(DimensionMismatch("Matrix has dimensions $(size(S)) but right hand side has first dimension $n"))
diff --git a/base/linalg/linalg.jl b/base/linalg/linalg.jl
index 1f63661d53f096..a510f0efc8b516 100644
--- a/base/linalg/linalg.jl
+++ b/base/linalg/linalg.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module LinAlg
 
@@ -7,11 +7,11 @@ import Base: A_mul_Bt, At_ldiv_Bt, A_rdiv_Bc, At_ldiv_B, Ac_mul_Bc, A_mul_Bc, Ac
     Ac_ldiv_B, Ac_ldiv_Bc, At_mul_Bt, A_rdiv_Bt, At_mul_B
 import Base: USE_BLAS64, abs, big, broadcast, ceil, conj, convert, copy, copy!,
     ctranspose, eltype, eye, findmax, findmin, fill!, floor, full, getindex,
-    hcat, imag, indices, inv, isapprox, kron, length, IndexStyle, map,
+    hcat, imag, indices, inv, isapprox, isone, IndexStyle, kron, length, map,
     ndims, oneunit, parent, power_by_squaring, print_matrix, promote_rule, real, round,
     setindex!, show, similar, size, transpose, trunc, typed_hcat
-using Base: promote_op, _length, iszero, @pure, @propagate_inbounds, IndexLinear,
-    reduce, hvcat_fill, typed_vcat, promote_typeof
+using Base: hvcat_fill, iszero, IndexLinear, _length, promote_op, promote_typeof,
+    @propagate_inbounds, @pure, reduce, typed_vcat
 # We use `_length` because of non-1 indices; releases after julia 0.5
 # can go back to `length`. `_length(A)` is equivalent to `length(linearindices(A))`.
 
@@ -91,6 +91,7 @@ export
     ishermitian,
     isposdef,
     isposdef!,
+    issuccess,
     issymmetric,
     istril,
     istriu,
@@ -201,8 +202,7 @@ end
 Check that a matrix is square, then return its common dimension.
 For multiple arguments, return a vector.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> A = ones(4,4); B = zeros(5,5);
 
@@ -237,8 +237,8 @@ function char_uplo(uplo::Symbol)
     end
 end
 
-copy_oftype{T}(A::AbstractArray{T}, ::Type{T}) = copy(A)
-copy_oftype{T,N,S}(A::AbstractArray{T,N}, ::Type{S}) = convert(AbstractArray{S,N}, A)
+copy_oftype(A::AbstractArray{T}, ::Type{T}) where {T} = copy(A)
+copy_oftype(A::AbstractArray{T,N}, ::Type{S}) where {T,N,S} = convert(AbstractArray{S,N}, A)
 
 include("conjarray.jl")
 include("transpose.jl")
@@ -248,7 +248,6 @@ include("exceptions.jl")
 include("generic.jl")
 
 include("blas.jl")
-import .BLAS: gemv! # consider renaming gemv! in matmul
 include("matmul.jl")
 include("lapack.jl")
 
@@ -262,7 +261,6 @@ include("hessenberg.jl")
 include("lq.jl")
 include("eigen.jl")
 include("svd.jl")
-include("schur.jl")
 include("symmetric.jl")
 include("cholesky.jl")
 include("lu.jl")
@@ -274,6 +272,8 @@ include("givens.jl")
 include("special.jl")
 include("bitarray.jl")
 include("ldlt.jl")
+include("schur.jl")
+
 
 include("arpack.jl")
 include("arnoldi.jl")
diff --git a/base/linalg/lq.jl b/base/linalg/lq.jl
index eca82f2a15a7fb..b6b43289385fbe 100644
--- a/base/linalg/lq.jl
+++ b/base/linalg/lq.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # LQ Factorizations
 
@@ -47,16 +47,16 @@ 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{T}) = A
-convert{T}(::Type{Factorization{T}}, A::LQ) = convert(LQ{T}, A)
+convert(::Type{LQ{T}},A::LQ) where {T} = LQ(convert(AbstractMatrix{T}, A.factors), convert(Vector{T}, A.τ))
+convert(::Type{Factorization{T}}, A::LQ{T}) where {T} = A
+convert(::Type{Factorization{T}}, A::LQ) where {T} = convert(LQ{T}, A)
 convert(::Type{AbstractMatrix}, A::LQ) = A[:L]*A[:Q]
 convert(::Type{AbstractArray}, A::LQ) = convert(AbstractMatrix, A)
 convert(::Type{Matrix}, A::LQ) = convert(Array, convert(AbstractArray, A))
 convert(::Type{Array}, A::LQ) = convert(Matrix, A)
 full(A::LQ) = convert(AbstractArray, A)
 
-ctranspose{T}(A::LQ{T}) = QR{T,typeof(A.factors)}(A.factors', A.τ)
+ctranspose(A::LQ{T}) where {T} = QR{T,typeof(A.factors)}(A.factors', A.τ)
 
 function getindex(A::LQ, d::Symbol)
     m, n = size(A)
@@ -79,11 +79,18 @@ 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)
+function show(io::IO, C::LQ)
+    println(io, "$(typeof(C)) with factors L and Q:")
+    show(io, C[:L])
+    println(io)
+    show(io, C[:Q])
+end
+
+convert(::Type{LQPackedQ{T}}, Q::LQPackedQ) where {T} = LQPackedQ(convert(AbstractMatrix{T}, Q.factors), convert(Vector{T}, Q.τ))
+convert(::Type{AbstractMatrix{T}}, Q::LQPackedQ) where {T} = convert(LQPackedQ{T}, Q)
 convert(::Type{Matrix}, A::LQPackedQ) = LAPACK.orglq!(copy(A.factors),A.τ)
 convert(::Type{Array}, A::LQPackedQ) = convert(Matrix, A)
-function full{T}(A::LQPackedQ{T}; thin::Bool = true)
+function full(A::LQPackedQ{T}; thin::Bool = true) where T
     #= We construct the full eye here, even though it seems inefficient, 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
@@ -112,33 +119,33 @@ end
 size(A::LQPackedQ) = size(A.factors)
 
 ## 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})
+A_mul_B!(A::LQ{T}, B::StridedVecOrMat{T}) where {T<:BlasFloat} = A[:L]*LAPACK.ormlq!('L','N',A.factors,A.τ,B)
+A_mul_B!(A::LQ{T}, B::QR{T}) where {T<:BlasFloat} = A[:L]*LAPACK.ormlq!('L','N',A.factors,A.τ,full(B))
+A_mul_B!(A::QR{T}, B::LQ{T}) where {T<:BlasFloat} = A_mul_B!(zeros(full(A)), full(A), full(B))
+function *(A::LQ{TA}, B::StridedVecOrMat{TB}) where {TA,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})
+function *(A::LQ{TA},B::QR{TB}) where {TA,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})
+function *(A::QR{TA},B::LQ{TB}) where {TA,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 (*)(A::LQPackedQ,B::StridedVecOrMat)
+A_mul_B!(A::LQPackedQ{T}, B::StridedVecOrMat{T}) where {T<:BlasFloat} = LAPACK.ormlq!('L','N',A.factors,A.τ,B)
+function (*)(A::LQPackedQ, B::StridedVecOrMat)
     TAB = promote_type(eltype(A), eltype(B))
     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)
+Ac_mul_B!(A::LQPackedQ{T}, B::StridedVecOrMat{T}) where {T<:BlasReal} = LAPACK.ormlq!('L','T',A.factors,A.τ,B)
+Ac_mul_B!(A::LQPackedQ{T}, B::StridedVecOrMat{T}) where {T<:BlasComplex} = LAPACK.ormlq!('L','C',A.factors,A.τ,B)
 function Ac_mul_B(A::LQPackedQ, B::StridedVecOrMat)
     TAB = promote_type(eltype(A), eltype(B))
     if size(B,1) == size(A.factors,2)
@@ -164,8 +171,8 @@ for (f1, f2) in ((:A_mul_Bc, :A_mul_B!),
 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})
+A_mul_B!(A::StridedMatrix{T}, B::LQPackedQ{T}) where {T<:BlasFloat} = LAPACK.ormlq!('R', 'N', B.factors, B.τ, A)
+function *(A::StridedMatrix{TA}, B::LQPackedQ{TB}) where {TA,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))
@@ -177,9 +184,9 @@ function *{TA,TB}(A::StridedMatrix{TA},B::LQPackedQ{TB})
 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})
+A_mul_Bc!(A::StridedMatrix{T}, B::LQPackedQ{T}) where {T<:BlasReal}    = LAPACK.ormlq!('R','T',B.factors,B.τ,A)
+A_mul_Bc!(A::StridedMatrix{T}, B::LQPackedQ{T}) where {T<:BlasComplex} = LAPACK.ormlq!('R','C',B.factors,B.τ,A)
+function A_mul_Bc(A::StridedVecOrMat{TA}, B::LQPackedQ{TB}) where {TA<:Number,TB<:Number}
     TAB = promote_type(TA,TB)
     A_mul_Bc!(copy_oftype(A, TAB), convert(AbstractMatrix{TAB},(B)))
 end
@@ -197,7 +204,7 @@ for (f1, f2) in ((:Ac_mul_B, :A_mul_B!),
     end
 end
 
-function \{TA,Tb}(A::LQ{TA}, b::StridedVector{Tb})
+function (\)(A::LQ{TA}, b::StridedVector{Tb}) where {TA,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))"))
@@ -205,7 +212,7 @@ function \{TA,Tb}(A::LQ{TA}, b::StridedVector{Tb})
     x = A_ldiv_B!(AA, copy_oftype(b, S))
     return x
 end
-function \{TA,TB}(A::LQ{TA},B::StridedMatrix{TB})
+function (\)(A::LQ{TA},B::StridedMatrix{TB}) where {TA,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"))
@@ -215,7 +222,7 @@ function \{TA,TB}(A::LQ{TA},B::StridedMatrix{TB})
 end
 # 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::LQ{T}, B::VecOrMat{Complex{T}})
+function (\)(F::LQ{T}, B::VecOrMat{Complex{T}}) where T<:BlasReal
     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)),
@@ -223,7 +230,7 @@ function (\){T<:BlasReal}(F::LQ{T}, B::VecOrMat{Complex{T}})
 end
 
 
-function A_ldiv_B!{T}(A::LQ{T}, B::StridedVecOrMat{T})
+function A_ldiv_B!(A::LQ{T}, B::StridedVecOrMat{T}) where 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 854c774160bb16..d25f61a2a406fe 100644
--- a/base/linalg/lu.jl
+++ b/base/linalg/lu.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ####################
 # LU Factorization #
@@ -12,34 +12,38 @@ end
 LU(factors::AbstractMatrix{T}, ipiv::Vector{BlasInt}, info::BlasInt) where {T} = LU{T,typeof(factors)}(factors, ipiv, info)
 
 # StridedMatrix
-function lufact!{T<:BlasFloat}(A::StridedMatrix{T}, pivot::Union{Type{Val{false}}, Type{Val{true}}} = Val{true})
-    if pivot === Val{false}
+function lufact!(A::StridedMatrix{T}, pivot::Union{Val{false}, Val{true}} = Val(true)) where T<:BlasFloat
+    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
+function lufact!(A::HermOrSym, pivot::Union{Val{false}, Val{true}} = Val(true))
+    copytri!(A.data, A.uplo, isa(A, Hermitian))
+    lufact!(A.data, pivot)
+end
 
 """
-    lufact!(A, pivot=Val{true}) -> LU
+    lufact!(A, pivot=Val(true)) -> LU
 
 `lufact!` is the same as [`lufact`](@ref), but saves space by overwriting the
 input `A`, instead of creating a copy. An [`InexactError`](@ref)
 exception is thrown if the factorization produces a number not representable by the
 element type of `A`, e.g. for integer types.
 """
-lufact!(A::StridedMatrix, pivot::Union{Type{Val{false}}, Type{Val{true}}} = Val{true}) = generic_lufact!(A, pivot)
-function generic_lufact!{T,Pivot}(A::StridedMatrix{T}, ::Type{Val{Pivot}} = Val{true})
+lufact!(A::StridedMatrix, pivot::Union{Val{false}, Val{true}} = Val(true)) = generic_lufact!(A, pivot)
+function generic_lufact!(A::StridedMatrix{T}, ::Val{Pivot} = Val(true)) where {T,Pivot}
     m, n = size(A)
     minmn = min(m,n)
     info = 0
-    ipiv = Array{BlasInt}(minmn)
+    ipiv = Vector{BlasInt}(minmn)
     @inbounds begin
         for k = 1:minmn
             # find index max
             kp = k
             if Pivot
-                amax = real(zero(T))
+                amax = abs(zero(T))
                 for i = k:m
                     absi = abs(A[i,k])
                     if absi > amax
@@ -49,7 +53,7 @@ function generic_lufact!{T,Pivot}(A::StridedMatrix{T}, ::Type{Val{Pivot}} = Val{
                 end
             end
             ipiv[k] = kp
-            if A[kp,k] != 0
+            if !iszero(A[kp,k])
                 if k != kp
                     # Interchange
                     for i = 1:n
@@ -78,11 +82,13 @@ function generic_lufact!{T,Pivot}(A::StridedMatrix{T}, ::Type{Val{Pivot}} = Val{
 end
 
 # floating point types doesn't have to be promoted for LU, but should default to pivoting
-lufact{T<:AbstractFloat}(A::Union{AbstractMatrix{T},AbstractMatrix{Complex{T}}}, pivot::Union{Type{Val{false}}, Type{Val{true}}} = Val{true}) = lufact!(copy(A), pivot)
+lufact(A::Union{AbstractMatrix{T}, AbstractMatrix{Complex{T}}},
+    pivot::Union{Val{false}, Val{true}} = Val(true)) where {T<:AbstractFloat} =
+        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
+    lufact(A [,pivot=Val(true)]) -> F::LU
 
 Compute the LU factorization of `A`.
 
@@ -110,14 +116,13 @@ The relationship between `F` and `A` is
 |:---------------------------------|:-----|:-----------------------|
 | [`/`](@ref)                      | ✓    |                        |
 | [`\\`](@ref)                     | ✓    | ✓                      |
-| [`cond`](@ref)                   | ✓    |                        |
+| [`inv`](@ref)                    | ✓    | ✓                      |
 | [`det`](@ref)                    | ✓    | ✓                      |
 | [`logdet`](@ref)                 | ✓    | ✓                      |
 | [`logabsdet`](@ref)              | ✓    | ✓                      |
 | [`size`](@ref)                   | ✓    | ✓                      |
 
-# Example
-
+# Examples
 ```jldoctest
 julia> A = [4 3; 6 3]
 2×2 Array{Int64,2}:
@@ -128,29 +133,30 @@ julia> F = lufact(A)
 Base.LinAlg.LU{Float64,Array{Float64,2}} with factors L and U:
 [1.0 0.0; 1.5 1.0]
 [4.0 3.0; 0.0 -1.5]
+successful: true
 
 julia> F[:L] * F[:U] == A[F[:p], :]
 true
 ```
 """
-function lufact{T}(A::AbstractMatrix{T}, pivot::Union{Type{Val{false}}, Type{Val{true}}})
+function lufact(A::AbstractMatrix{T}, pivot::Union{Val{false}, Val{true}}) where T
     S = typeof(zero(T)/one(T))
     AA = similar(A, S, size(A))
     copy!(AA, A)
     lufact!(AA, pivot)
 end
 # We can't assume an ordered field so we first try without pivoting
-function lufact{T}(A::AbstractMatrix{T})
+function lufact(A::AbstractMatrix{T}) where T
     S = typeof(zero(T)/one(T))
     AA = similar(A, S, size(A))
     copy!(AA, A)
-    F = lufact!(AA, Val{false})
-    if F.info == 0
+    F = lufact!(AA, Val(false))
+    if issuccess(F)
         return F
     else
         AA = similar(A, S, size(A))
         copy!(AA, A)
-        return lufact!(AA, Val{true})
+        return lufact!(AA, Val(true))
     end
 end
 
@@ -160,16 +166,15 @@ lufact(F::LU) = F
 lu(x::Number) = (one(x), x, 1)
 
 """
-    lu(A, pivot=Val{true}) -> L, U, p
+    lu(A, pivot=Val(true)) -> L, U, p
 
 Compute the LU factorization of `A`, such that `A[p,:] = L*U`.
 By default, pivoting is used. This can be overridden by passing
-`Val{false}` for the second argument.
+`Val(false)` for the second argument.
 
 See also [`lufact`](@ref).
 
-# Example
-
+# Examples
 ```jldoctest
 julia> A = [4. 3.; 6. 3.]
 2×2 Array{Float64,2}:
@@ -183,24 +188,25 @@ julia> A[p, :] == L * U
 true
 ```
 """
-function lu(A::AbstractMatrix, pivot::Union{Type{Val{false}}, Type{Val{true}}} = Val{true})
+function lu(A::AbstractMatrix, pivot::Union{Val{false}, Val{true}} = Val(true))
     F = lufact(A, pivot)
     F[:L], F[:U], F[:p]
 end
 
-function convert{T}(::Type{LU{T}}, F::LU)
+function convert(::Type{LU{T}}, F::LU) where T
     M = convert(AbstractMatrix{T}, F.factors)
     LU{T,typeof(M)}(M, F.ipiv, F.info)
 end
-convert{T,S}(::Type{LU{T,S}}, F::LU) = LU{T,S}(convert(S, F.factors), F.ipiv, F.info)
-convert{T}(::Type{Factorization{T}}, F::LU{T}) = F
-convert{T}(::Type{Factorization{T}}, F::LU) = convert(LU{T}, F)
+convert(::Type{LU{T,S}}, F::LU) where {T,S} = LU{T,S}(convert(S, F.factors), F.ipiv, F.info)
+convert(::Type{Factorization{T}}, F::LU{T}) where {T} = F
+convert(::Type{Factorization{T}}, F::LU) where {T} = convert(LU{T}, F)
 
+copy(A::LU{T,S}) where {T,S} = LU{T,S}(copy(A.factors), copy(A.ipiv), A.info)
 
 size(A::LU) = size(A.factors)
 size(A::LU,n) = size(A.factors,n)
 
-function ipiv2perm{T}(v::AbstractVector{T}, maxi::Integer)
+function ipiv2perm(v::AbstractVector{T}, maxi::Integer) where T
     p = T[1:maxi;]
     @inbounds for i in 1:length(v)
         p[i], p[v[i]] = p[v[i]], p[i]
@@ -208,7 +214,7 @@ function ipiv2perm{T}(v::AbstractVector{T}, maxi::Integer)
     return p
 end
 
-function getindex{T}(F::LU{T,<:StridedMatrix}, d::Symbol)
+function getindex(F::LU{T,<:StridedMatrix}, d::Symbol) where T
     m, n = size(F)
     if d == :L
         L = tril!(F.factors[1:m, 1:min(m,n)])
@@ -225,57 +231,78 @@ function getindex{T}(F::LU{T,<:StridedMatrix}, d::Symbol)
     end
 end
 
-function show(io::IO, C::LU)
-    println(io, "$(typeof(C)) with factors L and U:")
-    show(io, C[:L])
+issuccess(F::LU) = F.info == 0
+
+function show(io::IO, F::LU)
+    println(io, "$(typeof(F)) with factors L and U:")
+    show(io, F[:L])
     println(io)
-    show(io, C[:U])
+    show(io, F[:U])
+    print(io, "\nsuccessful: $(issuccess(F))")
 end
 
-A_ldiv_B!{T<:BlasFloat}(A::LU{T,<:StridedMatrix}, B::StridedVecOrMat{T}) = @assertnonsingular LAPACK.getrs!('N', A.factors, A.ipiv, B) A.info
-A_ldiv_B!(A::LU{<:Any,<:StridedMatrix}, b::StridedVector) = A_ldiv_B!(UpperTriangular(A.factors), A_ldiv_B!(UnitLowerTriangular(A.factors), b[ipiv2perm(A.ipiv, length(b))]))
-A_ldiv_B!(A::LU{<:Any,<:StridedMatrix}, B::StridedMatrix) = A_ldiv_B!(UpperTriangular(A.factors), A_ldiv_B!(UnitLowerTriangular(A.factors), B[ipiv2perm(A.ipiv, size(B, 1)),:]))
-
-At_ldiv_B!{T<:BlasFloat}(A::LU{T,<:StridedMatrix}, B::StridedVecOrMat{T}) = @assertnonsingular LAPACK.getrs!('T', A.factors, A.ipiv, B) A.info
-At_ldiv_B!(A::LU{<:Any,<:StridedMatrix}, b::StridedVector) = At_ldiv_B!(UnitLowerTriangular(A.factors), At_ldiv_B!(UpperTriangular(A.factors), b))[invperm(ipiv2perm(A.ipiv, length(b)))]
-At_ldiv_B!(A::LU{<:Any,<:StridedMatrix}, B::StridedMatrix) = At_ldiv_B!(UnitLowerTriangular(A.factors), At_ldiv_B!(UpperTriangular(A.factors), B))[invperm(ipiv2perm(A.ipiv, size(B,1))),:]
-
-Ac_ldiv_B!{T<:Real}(F::LU{T,<:StridedMatrix}, B::StridedVecOrMat{T}) = At_ldiv_B!(F, B)
-Ac_ldiv_B!{T<:BlasComplex}(A::LU{T,<:StridedMatrix}, B::StridedVecOrMat{T}) = @assertnonsingular LAPACK.getrs!('C', A.factors, A.ipiv, B) A.info
-Ac_ldiv_B!(A::LU{<:Any,<:StridedMatrix}, b::StridedVector) = Ac_ldiv_B!(UnitLowerTriangular(A.factors), Ac_ldiv_B!(UpperTriangular(A.factors), b))[invperm(ipiv2perm(A.ipiv, length(b)))]
-Ac_ldiv_B!(A::LU{<:Any,<:StridedMatrix}, B::StridedMatrix) = Ac_ldiv_B!(UnitLowerTriangular(A.factors), Ac_ldiv_B!(UpperTriangular(A.factors), B))[invperm(ipiv2perm(A.ipiv, size(B,1))),:]
-
-At_ldiv_Bt{T<:BlasFloat}(A::LU{T,<:StridedMatrix}, B::StridedVecOrMat{T}) = @assertnonsingular LAPACK.getrs!('T', A.factors, A.ipiv, transpose(B)) A.info
+A_ldiv_B!(A::LU{T,<:StridedMatrix}, B::StridedVecOrMat{T}) where {T<:BlasFloat} =
+    @assertnonsingular LAPACK.getrs!('N', A.factors, A.ipiv, B) A.info
+A_ldiv_B!(A::LU{<:Any,<:StridedMatrix}, b::StridedVector) =
+    A_ldiv_B!(UpperTriangular(A.factors),
+    A_ldiv_B!(UnitLowerTriangular(A.factors), b[ipiv2perm(A.ipiv, length(b))]))
+A_ldiv_B!(A::LU{<:Any,<:StridedMatrix}, B::StridedMatrix) =
+    A_ldiv_B!(UpperTriangular(A.factors),
+    A_ldiv_B!(UnitLowerTriangular(A.factors), B[ipiv2perm(A.ipiv, size(B, 1)),:]))
+
+At_ldiv_B!(A::LU{T,<:StridedMatrix}, B::StridedVecOrMat{T}) where {T<:BlasFloat} =
+    @assertnonsingular LAPACK.getrs!('T', A.factors, A.ipiv, B) A.info
+At_ldiv_B!(A::LU{<:Any,<:StridedMatrix}, b::StridedVector) =
+    At_ldiv_B!(UnitLowerTriangular(A.factors),
+    At_ldiv_B!(UpperTriangular(A.factors), b))[invperm(ipiv2perm(A.ipiv, length(b)))]
+At_ldiv_B!(A::LU{<:Any,<:StridedMatrix}, B::StridedMatrix) =
+    At_ldiv_B!(UnitLowerTriangular(A.factors),
+    At_ldiv_B!(UpperTriangular(A.factors), B))[invperm(ipiv2perm(A.ipiv, size(B,1))),:]
+
+Ac_ldiv_B!(F::LU{T,<:StridedMatrix}, B::StridedVecOrMat{T}) where {T<:Real} =
+    At_ldiv_B!(F, B)
+Ac_ldiv_B!(A::LU{T,<:StridedMatrix}, B::StridedVecOrMat{T}) where {T<:BlasComplex} =
+    @assertnonsingular LAPACK.getrs!('C', A.factors, A.ipiv, B) A.info
+Ac_ldiv_B!(A::LU{<:Any,<:StridedMatrix}, b::StridedVector) =
+    Ac_ldiv_B!(UnitLowerTriangular(A.factors),
+    Ac_ldiv_B!(UpperTriangular(A.factors), b))[invperm(ipiv2perm(A.ipiv, length(b)))]
+Ac_ldiv_B!(A::LU{<:Any,<:StridedMatrix}, B::StridedMatrix) =
+    Ac_ldiv_B!(UnitLowerTriangular(A.factors),
+    Ac_ldiv_B!(UpperTriangular(A.factors), B))[invperm(ipiv2perm(A.ipiv, size(B,1))),:]
+
+At_ldiv_Bt(A::LU{T,<:StridedMatrix}, B::StridedVecOrMat{T}) where {T<:BlasFloat} =
+    @assertnonsingular LAPACK.getrs!('T', A.factors, A.ipiv, transpose(B)) A.info
 At_ldiv_Bt(A::LU, B::StridedVecOrMat) = At_ldiv_B(A, transpose(B))
 
-Ac_ldiv_Bc{T<:BlasComplex}(A::LU{T,<:StridedMatrix}, B::StridedVecOrMat{T}) = @assertnonsingular LAPACK.getrs!('C', A.factors, A.ipiv, ctranspose(B)) A.info
+Ac_ldiv_Bc(A::LU{T,<:StridedMatrix}, B::StridedVecOrMat{T}) where {T<:BlasComplex} =
+    @assertnonsingular LAPACK.getrs!('C', A.factors, A.ipiv, ctranspose(B)) A.info
 Ac_ldiv_Bc(A::LU, B::StridedVecOrMat) = Ac_ldiv_B(A, ctranspose(B))
 
-function det{T}(A::LU{T})
-    n = checksquare(A)
-    A.info > 0 && return zero(T)
+function det(F::LU{T}) where T
+    n = checksquare(F)
+    issuccess(F) || return zero(T)
     P = one(T)
     c = 0
     @inbounds for i = 1:n
-        P *= A.factors[i,i]
-        if A.ipiv[i] != i
-                c += 1
+        P *= F.factors[i,i]
+        if F.ipiv[i] != i
+            c += 1
         end
     end
     s = (isodd(c) ? -one(T) : one(T))
     return P * s
 end
 
-function logabsdet{T}(A::LU{T})  # return log(abs(det)) and sign(det)
-    n = checksquare(A)
-    A.info > 0 && return log(zero(real(T))), log(one(T))
+function logabsdet(F::LU{T}) where T  # return log(abs(det)) and sign(det)
+    n = checksquare(F)
+    issuccess(F) || return log(zero(real(T))), log(one(T))
     c = 0
     P = one(T)
     abs_det = zero(real(T))
     @inbounds for i = 1:n
-        dg_ii = A.factors[i,i]
+        dg_ii = F.factors[i,i]
         P *= sign(dg_ii)
-        if A.ipiv[i] != i
+        if F.ipiv[i] != i
             c += 1
         end
         abs_det += log(abs(dg_ii))
@@ -284,19 +311,26 @@ function logabsdet{T}(A::LU{T})  # return log(abs(det)) and sign(det)
     abs_det, s
 end
 
-inv!(A::LU{<:BlasFloat,<:StridedMatrix}) = @assertnonsingular LAPACK.getri!(A.factors, A.ipiv) A.info
-inv(A::LU{<:BlasFloat,<:StridedMatrix}) = inv!(LU(copy(A.factors), copy(A.ipiv), copy(A.info)))
+inv!(A::LU{<:BlasFloat,<:StridedMatrix}) =
+    @assertnonsingular LAPACK.getri!(A.factors, A.ipiv) A.info
+inv!(A::LU{T,<:StridedMatrix}) where {T} =
+    @assertnonsingular A_ldiv_B!(A.factors, copy(A), eye(T, size(A, 1))) A.info
+inv(A::LU{<:BlasFloat,<:StridedMatrix}) = inv!(copy(A))
 
-cond(A::LU{<:BlasFloat,<:StridedMatrix}, p::Number) = inv(LAPACK.gecon!(p == 1 ? '1' : 'I', A.factors, norm((A[:L]*A[:U])[A[:p],:], p)))
-cond(A::LU, p::Number) = norm(A[:L]*A[:U],p)*norm(inv(A),p)
+function _cond1Inf(A::LU{<:BlasFloat,<:StridedMatrix}, p::Number, normA::Real)
+    if p != 1 && p != Inf
+        throw(ArgumentError("p must be either 1 or Inf"))
+    end
+    return inv(LAPACK.gecon!(p == 1 ? '1' : 'I', A.factors, normA))
+end
 
 # Tridiagonal
 
 # See dgttrf.f
-function lufact!{T}(A::Tridiagonal{T}, pivot::Union{Type{Val{false}}, Type{Val{true}}} = Val{true})
+function lufact!(A::Tridiagonal{T}, pivot::Union{Val{false}, Val{true}} = Val(true)) where T
     n = size(A, 1)
     info = 0
-    ipiv = Array{BlasInt}(n)
+    ipiv = Vector{BlasInt}(n)
     dl = A.dl
     d = A.d
     du = A.du
@@ -308,7 +342,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]
@@ -331,7 +365,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
@@ -360,10 +394,10 @@ end
 
 factorize(A::Tridiagonal) = lufact(A)
 
-function getindex{T}(F::Base.LinAlg.LU{T,Tridiagonal{T}}, d::Symbol)
+function getindex(F::Base.LinAlg.LU{T,Tridiagonal{T}}, d::Symbol) where T
     m, n = size(F)
     if d == :L
-        L = Array(Bidiagonal(ones(T, n), F.factors.dl, false))
+        L = Array(Bidiagonal(ones(T, n), F.factors.dl, d))
         for i = 2:n
             tmp = L[F.ipiv[i], 1:i - 1]
             L[F.ipiv[i], 1:i - 1] = L[i, 1:i - 1]
@@ -371,7 +405,7 @@ function getindex{T}(F::Base.LinAlg.LU{T,Tridiagonal{T}}, d::Symbol)
         end
         return L
     elseif d == :U
-        U = Array(Bidiagonal(F.factors.d, F.factors.du, true))
+        U = Array(Bidiagonal(F.factors.d, F.factors.du, d))
         for i = 1:n - 2
             U[i,i + 2] = F.factors.du2[i]
         end
@@ -385,7 +419,7 @@ function getindex{T}(F::Base.LinAlg.LU{T,Tridiagonal{T}}, d::Symbol)
 end
 
 # See dgtts2.f
-function A_ldiv_B!{T}(A::LU{T,Tridiagonal{T}}, B::AbstractVecOrMat)
+function A_ldiv_B!(A::LU{T,Tridiagonal{T}}, B::AbstractVecOrMat) where T
     n = size(A,1)
     if n != size(B,1)
         throw(DimensionMismatch("matrix has dimensions ($n,$n) but right hand side has $(size(B,1)) rows"))
@@ -416,7 +450,7 @@ function A_ldiv_B!{T}(A::LU{T,Tridiagonal{T}}, B::AbstractVecOrMat)
     return B
 end
 
-function At_ldiv_B!{T}(A::LU{T,Tridiagonal{T}}, B::AbstractVecOrMat)
+function At_ldiv_B!(A::LU{T,Tridiagonal{T}}, B::AbstractVecOrMat) where T
     n = size(A,1)
     if n != size(B,1)
         throw(DimensionMismatch("matrix has dimensions ($n,$n) but right hand side has $(size(B,1)) rows"))
@@ -450,8 +484,8 @@ function At_ldiv_B!{T}(A::LU{T,Tridiagonal{T}}, B::AbstractVecOrMat)
     return B
 end
 
-# Ac_ldiv_B!{T<:Real}(A::LU{T,Tridiagonal{T}}, B::AbstractVecOrMat) = At_ldiv_B!(A,B)
-function Ac_ldiv_B!{T}(A::LU{T,Tridiagonal{T}}, B::AbstractVecOrMat)
+# Ac_ldiv_B!(A::LU{T,Tridiagonal{T}}, B::AbstractVecOrMat) where {T<:Real} = At_ldiv_B!(A,B)
+function Ac_ldiv_B!(A::LU{T,Tridiagonal{T}}, B::AbstractVecOrMat) where T
     n = size(A,1)
     if n != size(B,1)
         throw(DimensionMismatch("matrix has dimensions ($n,$n) but right hand side has $(size(B,1)) rows"))
@@ -494,13 +528,13 @@ convert(::Type{Matrix}, F::LU) = convert(Array, convert(AbstractArray, F))
 convert(::Type{Array}, F::LU) = convert(Matrix, F)
 full(F::LU) = convert(AbstractArray, F)
 
-function convert{T}(::Type{Tridiagonal}, F::Base.LinAlg.LU{T,Tridiagonal{T}})
+function convert(::Type{Tridiagonal}, F::Base.LinAlg.LU{T,Tridiagonal{T}}) where T
     n = size(F, 1)
 
-    dl     = copy(F.factors.dl)
-    d      = copy(F.factors.d)
-    du     = copy(F.factors.du)
-    du2    = copy(F.factors.du2)
+    dl  = copy(F.factors.dl)
+    d   = copy(F.factors.d)
+    du  = copy(F.factors.du)
+    du2 = copy(F.factors.du2)
 
     for i = n - 1:-1:1
         li         = dl[i]
@@ -528,8 +562,12 @@ function convert{T}(::Type{Tridiagonal}, F::Base.LinAlg.LU{T,Tridiagonal{T}})
     end
     return Tridiagonal(dl, d, du)
 end
-convert{T}(::Type{AbstractMatrix}, F::Base.LinAlg.LU{T,Tridiagonal{T}}) = convert(Tridiagonal, F)
-convert{T}(::Type{AbstractArray}, F::Base.LinAlg.LU{T,Tridiagonal{T}}) = convert(AbstractMatrix, F)
-convert{T}(::Type{Matrix}, F::Base.LinAlg.LU{T,Tridiagonal{T}}) = convert(Array, convert(AbstractArray, F))
-convert{T}(::Type{Array}, F::Base.LinAlg.LU{T,Tridiagonal{T}}) = convert(Matrix, F)
-full{T}(F::Base.LinAlg.LU{T,Tridiagonal{T}}) = convert(AbstractArray, F)
+convert(::Type{AbstractMatrix}, F::Base.LinAlg.LU{T,Tridiagonal{T}}) where {T} =
+    convert(Tridiagonal, F)
+convert(::Type{AbstractArray}, F::Base.LinAlg.LU{T,Tridiagonal{T}}) where {T} =
+    convert(AbstractMatrix, F)
+convert(::Type{Matrix}, F::Base.LinAlg.LU{T,Tridiagonal{T}}) where {T} =
+    convert(Array, convert(AbstractArray, F))
+convert(::Type{Array}, F::Base.LinAlg.LU{T,Tridiagonal{T}}) where {T} =
+    convert(Matrix, F)
+full(F::Base.LinAlg.LU{T,Tridiagonal{T}}) where {T} = convert(AbstractArray, F)
diff --git a/base/linalg/matmul.jl b/base/linalg/matmul.jl
index d6888111732456..6112d29be3b54e 100644
--- a/base/linalg/matmul.jl
+++ b/base/linalg/matmul.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # matmul.jl: Everything to do with dense matrix multiplication
 
@@ -7,7 +7,6 @@ matprod(x, y) = x*y + x*y
 # multiply by diagonal matrix as vector
 function scale!(C::AbstractMatrix, A::AbstractMatrix, b::AbstractVector)
     m, n = size(A)
-    p, q = size(C)
     if size(A) != size(C)
         throw(DimensionMismatch("size of A, $(size(A)), does not match size of C, $(size(C))"))
     end
@@ -25,7 +24,6 @@ end
 
 function scale!(C::AbstractMatrix, b::AbstractVector, A::AbstractMatrix)
     m, n = size(A)
-    p, q = size(C)
     if size(A) != size(C)
         throw(DimensionMismatch("size of A, $(size(A)), does not match size of C, $(size(C))"))
     end
@@ -40,10 +38,10 @@ end
 
 # Dot products
 
-vecdot{T<:BlasReal}(x::Union{DenseArray{T},StridedVector{T}}, y::Union{DenseArray{T},StridedVector{T}}) = BLAS.dot(x, y)
-vecdot{T<:BlasComplex}(x::Union{DenseArray{T},StridedVector{T}}, y::Union{DenseArray{T},StridedVector{T}}) = BLAS.dotc(x, y)
+vecdot(x::Union{DenseArray{T},StridedVector{T}}, y::Union{DenseArray{T},StridedVector{T}}) where {T<:BlasReal} = BLAS.dot(x, y)
+vecdot(x::Union{DenseArray{T},StridedVector{T}}, y::Union{DenseArray{T},StridedVector{T}}) where {T<:BlasComplex} = BLAS.dotc(x, y)
 
-function dot{T<:BlasReal, TI<:Integer}(x::Vector{T}, rx::Union{UnitRange{TI},Range{TI}}, y::Vector{T}, ry::Union{UnitRange{TI},Range{TI}})
+function dot(x::Vector{T}, rx::Union{UnitRange{TI},Range{TI}}, y::Vector{T}, ry::Union{UnitRange{TI},Range{TI}}) where {T<:BlasReal,TI<:Integer}
     if length(rx) != length(ry)
         throw(DimensionMismatch("length of rx, $(length(rx)), does not equal length of ry, $(length(ry))"))
     end
@@ -56,7 +54,7 @@ function dot{T<:BlasReal, TI<:Integer}(x::Vector{T}, rx::Union{UnitRange{TI},Ran
     BLAS.dot(length(rx), pointer(x)+(first(rx)-1)*sizeof(T), step(rx), pointer(y)+(first(ry)-1)*sizeof(T), step(ry))
 end
 
-function dot{T<:BlasComplex, TI<:Integer}(x::Vector{T}, rx::Union{UnitRange{TI},Range{TI}}, y::Vector{T}, ry::Union{UnitRange{TI},Range{TI}})
+function dot(x::Vector{T}, rx::Union{UnitRange{TI},Range{TI}}, y::Vector{T}, ry::Union{UnitRange{TI},Range{TI}}) where {T<:BlasComplex,TI<:Integer}
     if length(rx) != length(ry)
         throw(DimensionMismatch("length of rx, $(length(rx)), does not equal length of ry, $(length(ry))"))
     end
@@ -69,14 +67,14 @@ function dot{T<:BlasComplex, TI<:Integer}(x::Vector{T}, rx::Union{UnitRange{TI},
     BLAS.dotc(length(rx), pointer(x)+(first(rx)-1)*sizeof(T), step(rx), pointer(y)+(first(ry)-1)*sizeof(T), step(ry))
 end
 
-At_mul_B{T<:BlasComplex}(x::StridedVector{T}, y::StridedVector{T}) = BLAS.dotu(x, y)
+At_mul_B(x::StridedVector{T}, y::StridedVector{T}) where {T<:BlasComplex} = BLAS.dotu(x, y)
 
 # Matrix-vector multiplication
-function (*){T<:BlasFloat,S}(A::StridedMatrix{T}, x::StridedVector{S})
+function (*)(A::StridedMatrix{T}, x::StridedVector{S}) where {T<:BlasFloat,S}
     TS = promote_op(matprod, T, 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})
+function (*)(A::AbstractMatrix{T}, x::AbstractVector{S}) where {T,S}
     TS = promote_op(matprod, T, S)
     A_mul_B!(similar(x,TS,size(A,1)),A,x)
 end
@@ -88,7 +86,7 @@ A_mul_Bc(a::AbstractVector, B::AbstractMatrix) = A_mul_Bc(reshape(a,length(a),1)
 A_mul_Bc(A::AbstractMatrix, b::AbstractVector) = A_mul_Bc(A,reshape(b,length(b),1))
 (*)(a::AbstractVector, B::AbstractMatrix) = reshape(a,length(a),1)*B
 
-A_mul_B!{T<:BlasFloat}(y::StridedVector{T}, A::StridedVecOrMat{T}, x::StridedVector{T}) = gemv!(y, 'N', A, x)
+A_mul_B!(y::StridedVector{T}, A::StridedVecOrMat{T}, x::StridedVector{T}) where {T<:BlasFloat} = gemv!(y, 'N', A, x)
 for elty in (Float32,Float64)
     @eval begin
         function A_mul_B!(y::StridedVector{Complex{$elty}}, A::StridedVecOrMat{Complex{$elty}}, x::StridedVector{$elty})
@@ -101,28 +99,28 @@ for elty in (Float32,Float64)
 end
 A_mul_B!(y::AbstractVector, A::AbstractVecOrMat, x::AbstractVector) = generic_matvecmul!(y, 'N', A, x)
 
-function At_mul_B{T<:BlasFloat,S}(A::StridedMatrix{T}, x::StridedVector{S})
+function At_mul_B(A::StridedMatrix{T}, x::StridedVector{S}) where {T<:BlasFloat,S}
     TS = promote_op(matprod, T, S)
     At_mul_B!(similar(x,TS,size(A,2)), A, convert(AbstractVector{TS}, x))
 end
-function At_mul_B{T,S}(A::AbstractMatrix{T}, x::AbstractVector{S})
+function At_mul_B(A::AbstractMatrix{T}, x::AbstractVector{S}) where {T,S}
     TS = promote_op(matprod, T, 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{T}, A::StridedVecOrMat{T}, x::StridedVector{T}) where {T<:BlasFloat} = gemv!(y, 'T', A, x)
 At_mul_B!(y::AbstractVector, A::AbstractVecOrMat, x::AbstractVector) = generic_matvecmul!(y, 'T', A, x)
 
-function Ac_mul_B{T<:BlasFloat,S}(A::StridedMatrix{T}, x::StridedVector{S})
+function Ac_mul_B(A::StridedMatrix{T}, x::StridedVector{S}) where {T<:BlasFloat,S}
     TS = promote_op(matprod, T, S)
     Ac_mul_B!(similar(x,TS,size(A,2)),A,convert(AbstractVector{TS},x))
 end
-function Ac_mul_B{T,S}(A::AbstractMatrix{T}, x::AbstractVector{S})
+function Ac_mul_B(A::AbstractMatrix{T}, x::AbstractVector{S}) where {T,S}
     TS = promote_op(matprod, T, S)
     Ac_mul_B!(similar(x,TS,size(A,2)), A, x)
 end
 
-Ac_mul_B!{T<:BlasReal}(y::StridedVector{T}, A::StridedVecOrMat{T}, x::StridedVector{T}) = At_mul_B!(y, A, x)
-Ac_mul_B!{T<:BlasComplex}(y::StridedVector{T}, A::StridedVecOrMat{T}, x::StridedVector{T}) = gemv!(y, 'C', A, x)
+Ac_mul_B!(y::StridedVector{T}, A::StridedVecOrMat{T}, x::StridedVector{T}) where {T<:BlasReal} = At_mul_B!(y, A, x)
+Ac_mul_B!(y::StridedVector{T}, A::StridedVecOrMat{T}, x::StridedVector{T}) where {T<:BlasComplex} = gemv!(y, 'C', A, x)
 Ac_mul_B!(y::AbstractVector, A::AbstractVecOrMat, x::AbstractVector) = generic_matvecmul!(y, 'C', A, x)
 
 # Matrix-matrix multiplication
@@ -134,8 +132,7 @@ Ac_mul_B!(y::AbstractVector, A::AbstractVecOrMat, x::AbstractVector) = generic_m
 
 Matrix multiplication.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> [1 1; 0 1] * [1 0; 1 1]
 2×2 Array{Int64,2}:
@@ -143,11 +140,11 @@ julia> [1 1; 0 1] * [1 0; 1 1]
  1  1
 ```
 """
-function (*){T,S}(A::AbstractMatrix{T}, B::AbstractMatrix{S})
+function (*)(A::AbstractMatrix{T}, B::AbstractMatrix{S}) where {T,S}
     TS = promote_op(matprod, T, 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)
+A_mul_B!(C::StridedMatrix{T}, A::StridedVecOrMat{T}, B::StridedVecOrMat{T}) where {T<:BlasFloat} = gemm_wrapper!(C, 'N', 'N', A, B)
 for elty in (Float32,Float64)
     @eval begin
         function A_mul_B!(C::StridedMatrix{Complex{$elty}}, A::StridedVecOrMat{Complex{$elty}}, B::StridedVecOrMat{$elty})
@@ -166,8 +163,7 @@ Calculates the matrix-matrix or matrix-vector product ``A⋅B`` and stores the r
 overwriting the existing value of `Y`. Note that `Y` must not be aliased with either `A` or
 `B`.
 
-# Example
-
+# Examples
 ```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);
 
@@ -179,18 +175,18 @@ julia> Y
 """
 A_mul_B!(C::AbstractMatrix, A::AbstractVecOrMat, B::AbstractVecOrMat) = generic_matmatmul!(C, 'N', 'N', A, B)
 
-function At_mul_B{T,S}(A::AbstractMatrix{T}, B::AbstractMatrix{S})
+function At_mul_B(A::AbstractMatrix{T}, B::AbstractMatrix{S}) where {T,S}
     TS = promote_op(matprod, T, 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}) = A===B ? syrk_wrapper!(C, 'T', A) : gemm_wrapper!(C, 'T', 'N', A, B)
+At_mul_B!(C::StridedMatrix{T}, A::StridedVecOrMat{T}, B::StridedVecOrMat{T}) where {T<:BlasFloat} = A===B ? syrk_wrapper!(C, 'T', A) : gemm_wrapper!(C, 'T', 'N', A, B)
 At_mul_B!(C::AbstractMatrix, A::AbstractVecOrMat, B::AbstractVecOrMat) = generic_matmatmul!(C, 'T', 'N', A, B)
 
-function A_mul_Bt{T,S}(A::AbstractMatrix{T}, B::AbstractMatrix{S})
+function A_mul_Bt(A::AbstractMatrix{T}, B::AbstractMatrix{S}) where {T,S}
     TS = promote_op(matprod, T, 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}) = A===B ? syrk_wrapper!(C, 'N', A) : gemm_wrapper!(C, 'N', 'T', A, B)
+A_mul_Bt!(C::StridedMatrix{T}, A::StridedVecOrMat{T}, B::StridedVecOrMat{T}) where {T<:BlasFloat} = A===B ? syrk_wrapper!(C, 'N', A) : gemm_wrapper!(C, 'N', 'T', A, B)
 for elty in (Float32,Float64)
     @eval begin
         function A_mul_Bt!(C::StridedMatrix{Complex{$elty}}, A::StridedVecOrMat{Complex{$elty}}, B::StridedVecOrMat{$elty})
@@ -203,34 +199,34 @@ for elty in (Float32,Float64)
 end
 A_mul_Bt!(C::AbstractVecOrMat, A::AbstractVecOrMat, B::AbstractVecOrMat) = generic_matmatmul!(C, 'N', 'T', A, B)
 
-function At_mul_Bt{T,S}(A::AbstractMatrix{T}, B::AbstractVecOrMat{S})
+function At_mul_Bt(A::AbstractMatrix{T}, B::AbstractVecOrMat{S}) where {T,S}
     TS = promote_op(matprod, T, 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)
+At_mul_Bt!(C::StridedMatrix{T}, A::StridedVecOrMat{T}, B::StridedVecOrMat{T}) where {T<:BlasFloat} = gemm_wrapper!(C, 'T', 'T', A, B)
 At_mul_Bt!(C::AbstractMatrix, A::AbstractVecOrMat, B::AbstractVecOrMat) = generic_matmatmul!(C, 'T', 'T', A, B)
 
-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::AbstractMatrix{T}, B::AbstractMatrix{S})
+Ac_mul_B(A::StridedMatrix{T}, B::StridedMatrix{T}) where {T<:BlasReal} = At_mul_B(A, B)
+Ac_mul_B!(C::StridedMatrix{T}, A::StridedVecOrMat{T}, B::StridedVecOrMat{T}) where {T<:BlasReal} = At_mul_B!(C, A, B)
+function Ac_mul_B(A::AbstractMatrix{T}, B::AbstractMatrix{S}) where {T,S}
     TS = promote_op(matprod, T, 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}) = A===B ? herk_wrapper!(C,'C',A) : gemm_wrapper!(C,'C', 'N', A, B)
+Ac_mul_B!(C::StridedMatrix{T}, A::StridedVecOrMat{T}, B::StridedVecOrMat{T}) where {T<:BlasComplex} = A===B ? herk_wrapper!(C,'C',A) : gemm_wrapper!(C,'C', 'N', A, B)
 Ac_mul_B!(C::AbstractMatrix, A::AbstractVecOrMat, B::AbstractVecOrMat) = generic_matmatmul!(C, 'C', 'N', A, B)
 
 A_mul_Bc(A::StridedMatrix{<:BlasFloat}, B::StridedMatrix{<:BlasReal}) = A_mul_Bt(A, B)
-A_mul_Bc!{T<:BlasFloat}(C::StridedMatrix{T}, A::StridedVecOrMat{T}, B::StridedVecOrMat{<:BlasReal}) = A_mul_Bt!(C, A, B)
-function A_mul_Bc{T,S}(A::AbstractMatrix{T}, B::AbstractMatrix{S})
+A_mul_Bc!(C::StridedMatrix{T}, A::StridedVecOrMat{T}, B::StridedVecOrMat{<:BlasReal}) where {T<:BlasFloat} = A_mul_Bt!(C, A, B)
+function A_mul_Bc(A::AbstractMatrix{T}, B::AbstractMatrix{S}) where {T,S}
     TS = promote_op(matprod, T, 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}) = A===B ? herk_wrapper!(C, 'N', A) : gemm_wrapper!(C, 'N', 'C', A, B)
+A_mul_Bc!(C::StridedMatrix{T}, A::StridedVecOrMat{T}, B::StridedVecOrMat{T}) where {T<:BlasComplex} = A===B ? herk_wrapper!(C, 'N', A) : gemm_wrapper!(C, 'N', 'C', A, B)
 A_mul_Bc!(C::AbstractMatrix, A::AbstractVecOrMat, B::AbstractVecOrMat) = generic_matmatmul!(C, 'N', 'C', A, B)
 
-Ac_mul_Bc{T,S}(A::AbstractMatrix{T}, B::AbstractMatrix{S}) =
+Ac_mul_Bc(A::AbstractMatrix{T}, B::AbstractMatrix{S}) where {T,S} =
     Ac_mul_Bc!(similar(B, promote_op(matprod, T, 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{T}, A::StridedVecOrMat{T}, B::StridedVecOrMat{T}) where {T<:BlasFloat} = gemm_wrapper!(C, 'C', 'C', A, B)
 Ac_mul_Bc!(C::AbstractMatrix, A::AbstractVecOrMat, B::AbstractVecOrMat) = generic_matmatmul!(C, 'C', 'C', A, B)
 Ac_mul_Bt!(C::AbstractMatrix, A::AbstractVecOrMat, B::AbstractVecOrMat) = generic_matmatmul!(C, 'C', 'T', A, B)
 # Supporting functions for matrix multiplication
@@ -251,7 +247,7 @@ function copytri!(A::AbstractMatrix, uplo::Char, conjugate::Bool=false)
     A
 end
 
-function gemv!{T<:BlasFloat}(y::StridedVector{T}, tA::Char, A::StridedVecOrMat{T}, x::StridedVector{T})
+function gemv!(y::StridedVector{T}, tA::Char, A::StridedVecOrMat{T}, x::StridedVector{T}) where T<:BlasFloat
     mA, nA = lapack_size(tA, A)
     if nA != length(x)
         throw(DimensionMismatch("second dimension of A, $nA, does not match length of x, $(length(x))"))
@@ -269,7 +265,7 @@ function gemv!{T<:BlasFloat}(y::StridedVector{T}, tA::Char, A::StridedVecOrMat{T
     return generic_matvecmul!(y, tA, A, x)
 end
 
-function syrk_wrapper!{T<:BlasFloat}(C::StridedMatrix{T}, tA::Char, A::StridedVecOrMat{T})
+function syrk_wrapper!(C::StridedMatrix{T}, tA::Char, A::StridedVecOrMat{T}) where T<:BlasFloat
     nC = checksquare(C)
     if tA == 'T'
         (nA, mA) = size(A,1), size(A,2)
@@ -297,7 +293,7 @@ function syrk_wrapper!{T<:BlasFloat}(C::StridedMatrix{T}, tA::Char, A::StridedVe
     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}}})
+function herk_wrapper!(C::Union{StridedMatrix{T}, StridedMatrix{Complex{T}}}, tA::Char, A::Union{StridedVecOrMat{T}, StridedVecOrMat{Complex{T}}}) where T<:BlasReal
     nC = checksquare(C)
     if tA == 'C'
         (nA, mA) = size(A,1), size(A,2)
@@ -320,7 +316,7 @@ function herk_wrapper!{T<:BlasReal}(C::Union{StridedMatrix{T}, StridedMatrix{Com
     end
 
     # Result array does not need to be initialized as long as beta==0
-    #    C = Array{T}(mA, mA)
+    #    C = Matrix{T}(mA, mA)
 
     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)
@@ -328,18 +324,18 @@ function herk_wrapper!{T<:BlasReal}(C::Union{StridedMatrix{T}, StridedMatrix{Com
     return generic_matmatmul!(C,tA, tAt, A, A)
 end
 
-function gemm_wrapper{T<:BlasFloat}(tA::Char, tB::Char,
-                                    A::StridedVecOrMat{T},
-                                    B::StridedVecOrMat{T})
+function gemm_wrapper(tA::Char, tB::Char,
+                      A::StridedVecOrMat{T},
+                      B::StridedVecOrMat{T}) where T<:BlasFloat
     mA, nA = lapack_size(tA, A)
     mB, nB = lapack_size(tB, B)
     C = similar(B, T, mA, nB)
     gemm_wrapper!(C, tA, tB, A, B)
 end
 
-function gemm_wrapper!{T<:BlasFloat}(C::StridedVecOrMat{T}, tA::Char, tB::Char,
-                                     A::StridedVecOrMat{T},
-                                     B::StridedVecOrMat{T})
+function gemm_wrapper!(C::StridedVecOrMat{T}, tA::Char, tB::Char,
+                       A::StridedVecOrMat{T},
+                       B::StridedVecOrMat{T}) where T<:BlasFloat
     mA, nA = lapack_size(tA, A)
     mB, nB = lapack_size(tB, B)
 
@@ -374,7 +370,7 @@ end
 # blas.jl defines matmul for floats; other integer and mixed precision
 # cases are handled here
 
-lapack_size(t::Char, M::AbstractVecOrMat) = (size(M, t=='N' ? 1:2), size(M, t=='N' ? 2:1))
+lapack_size(t::Char, M::AbstractVecOrMat) = (size(M, t=='N' ? 1 : 2), size(M, t=='N' ? 2 : 1))
 
 function copy!(B::AbstractVecOrMat, ir_dest::UnitRange{Int}, jr_dest::UnitRange{Int}, tM::Char, M::AbstractVecOrMat, ir_src::UnitRange{Int}, jr_src::UnitRange{Int})
     if tM == 'N'
@@ -402,7 +398,7 @@ end
 # NOTE: the generic version is also called as fallback for
 #       strides != 1 cases
 
-function generic_matvecmul!{R}(C::AbstractVector{R}, tA, A::AbstractVecOrMat, B::AbstractVector)
+function generic_matvecmul!(C::AbstractVector{R}, tA, A::AbstractVecOrMat, B::AbstractVector) where R
     mB = length(B)
     mA, nA = lapack_size(tA, A)
     if mB != nA
@@ -459,7 +455,7 @@ function generic_matvecmul!{R}(C::AbstractVector{R}, tA, A::AbstractVecOrMat, B:
     C
 end
 
-function generic_matmatmul{T,S}(tA, tB, A::AbstractVecOrMat{T}, B::AbstractMatrix{S})
+function generic_matmatmul(tA, tB, A::AbstractVecOrMat{T}, B::AbstractMatrix{S}) where {T,S}
     mA, nA = lapack_size(tA, A)
     mB, nB = lapack_size(tB, B)
     C = similar(B, promote_op(matprod, T, S), mA, nB)
@@ -467,9 +463,9 @@ function generic_matmatmul{T,S}(tA, tB, A::AbstractVecOrMat{T}, B::AbstractMatri
 end
 
 const tilebufsize = 10800  # Approximately 32k/3
-const Abuf = Array{UInt8}(tilebufsize)
-const Bbuf = Array{UInt8}(tilebufsize)
-const Cbuf = Array{UInt8}(tilebufsize)
+const Abuf = Vector{UInt8}(tilebufsize)
+const Bbuf = Vector{UInt8}(tilebufsize)
+const Cbuf = Vector{UInt8}(tilebufsize)
 
 function generic_matmatmul!(C::AbstractMatrix, tA, tB, A::AbstractMatrix, B::AbstractMatrix)
     mA, nA = lapack_size(tA, A)
@@ -487,7 +483,7 @@ end
 
 generic_matmatmul!(C::AbstractVecOrMat, tA, tB, A::AbstractVecOrMat, B::AbstractVecOrMat) = _generic_matmatmul!(C, tA, tB, A, B)
 
-function _generic_matmatmul!{T,S,R}(C::AbstractVecOrMat{R}, tA, tB, A::AbstractVecOrMat{T}, B::AbstractVecOrMat{S})
+function _generic_matmatmul!(C::AbstractVecOrMat{R}, tA, tB, A::AbstractVecOrMat{T}, B::AbstractVecOrMat{S}) where {T,S,R}
     mA, nA = lapack_size(tA, A)
     mB, nB = lapack_size(tB, B)
     if mB != nA
@@ -502,7 +498,7 @@ function _generic_matmatmul!{T,S,R}(C::AbstractVecOrMat{R}, tA, tB, A::AbstractV
 
     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))))
+        tile_size = floor(Int, sqrt(tilebufsize / max(sizeof(R), sizeof(S), sizeof(T))))
     end
     @inbounds begin
     if tile_size > 0
@@ -655,7 +651,7 @@ end
 
 
 # multiply 2x2 matrices
-function matmul2x2{T,S}(tA, tB, A::AbstractMatrix{T}, B::AbstractMatrix{S})
+function matmul2x2(tA, tB, A::AbstractMatrix{T}, B::AbstractMatrix{S}) where {T,S}
     matmul2x2!(similar(B, promote_op(matprod, T, S), 2, 2), tA, tB, A, B)
 end
 
@@ -687,7 +683,7 @@ function matmul2x2!(C::AbstractMatrix, tA, tB, A::AbstractMatrix, B::AbstractMat
 end
 
 # Multiply 3x3 matrices
-function matmul3x3{T,S}(tA, tB, A::AbstractMatrix{T}, B::AbstractMatrix{S})
+function matmul3x3(tA, tB, A::AbstractMatrix{T}, B::AbstractMatrix{S}) where {T,S}
     matmul3x3!(similar(B, promote_op(matprod, T, S), 3, 3), tA, tB, A, B)
 end
 
diff --git a/base/linalg/qr.jl b/base/linalg/qr.jl
index 191d138e3a2711..a6e1e7522c4296 100644
--- a/base/linalg/qr.jl
+++ b/base/linalg/qr.jl
@@ -1,14 +1,90 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # QR and Hessenberg Factorizations
+"""
+    QR <: Factorization
+
+A QR matrix factorization stored in a packed format, typically obtained from
+[`qrfact`](@ref). If ``A`` is an `m`×`n` matrix, then
+
+```math
+A = Q R
+```
+
+where ``Q`` is an orthogonal/unitary matrix and ``R`` is upper triangular.
+The matrix ``Q`` is stored as a sequence of Householder reflectors ``v_i``
+and coefficients ``\\tau_i`` where:
+
+```math
+Q = \\prod_{i=1}^{\\min(m,n)} (I - \\tau_i v_i v_i^T).
+```
+
+The object has two fields:
+
+* `factors` is an `m`×`n` matrix.
 
+  - The upper triangular part contains the elements of ``R``, that is `R =
+    triu(F.factors)` for a `QR` object `F`.
+
+  - The subdiagonal part contains the reflectors ``v_i`` stored in a packed format where
+    ``v_i`` is the ``i``th column of the matrix `V = eye(m,n) + tril(F.factors,-1)`.
+
+* `τ` is a vector  of length `min(m,n)` containing the coefficients ``\tau_i``.
+
+"""
 struct QR{T,S<:AbstractMatrix} <: Factorization{T}
     factors::S
     τ::Vector{T}
     QR{T,S}(factors::AbstractMatrix{T}, τ::Vector{T}) where {T,S<:AbstractMatrix} = new(factors, τ)
 end
 QR(factors::AbstractMatrix{T}, τ::Vector{T}) where {T} = QR{T,typeof(factors)}(factors, τ)
+
 # Note. For QRCompactWY factorization without pivoting, the WY representation based method introduced in LAPACK 3.4
+"""
+    QRCompactWY <: Factorization
+
+A QR matrix factorization stored in a compact blocked format, typically obtained from
+[`qrfact`](@ref). If ``A`` is an `m`×`n` matrix, then
+
+```math
+A = Q R
+```
+
+where ``Q`` is an orthogonal/unitary matrix and ``R`` is upper triangular. It is similar
+to the [`QR`](@ref) format except that the orthogonal/unitary matrix ``Q`` is stored in
+*Compact WY* format [^Schreiber1989], as a lower trapezoidal matrix ``V`` and an upper
+triangular matrix ``T`` where
+
+```math
+Q = \\prod_{i=1}^{\\min(m,n)} (I - \\tau_i v_i v_i^T) = I - V T V^T
+```
+
+such that ``v_i`` is the ``i``th column of ``V``, and ``\tau_i`` is the ``i``th diagonal
+element of ``T``.
+
+The object has two fields:
+
+* `factors`, as in the [`QR`](@ref) type, is an `m`×`n` matrix.
+
+  - The upper triangular part contains the elements of ``R``, that is `R =
+    triu(F.factors)` for a `QR` object `F`.
+
+  - The subdiagonal part contains the reflectors ``v_i`` stored in a packed format such
+    that `V = eye(m,n) + tril(F.factors,-1)`.
+
+* `T` is a square matrix with `min(m,n)` columns, whose upper triangular part gives the
+  matrix ``T`` above (the subdiagonal elements are ignored).
+
+!!! note
+
+    This format should not to be confused with the older *WY* representation
+    [^Bischof1987].
+
+
+[^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)
+"""
 struct QRCompactWY{S,M<:AbstractMatrix} <: Factorization{S}
     factors::M
     T::Matrix{S}
@@ -16,6 +92,37 @@ struct QRCompactWY{S,M<:AbstractMatrix} <: Factorization{S}
 end
 QRCompactWY(factors::AbstractMatrix{S}, T::AbstractMatrix{S}) where {S} = QRCompactWY{S,typeof(factors)}(factors, T)
 
+"""
+    QRPivoted <: Factorization
+
+A QR matrix factorization with column pivoting in a packed format, typically obtained from
+[`qrfact`](@ref). If ``A`` is an `m`×`n` matrix, then
+
+```math
+A P = Q R
+```
+
+where ``P`` is a permutation matrix, ``Q`` is an orthogonal/unitary matrix and ``R`` is
+upper triangular. The matrix ``Q`` is stored as a sequence of Householder reflectors:
+
+```math
+Q = \\prod_{i=1}^{\\min(m,n)} (I - \\tau_i v_i v_i^T).
+```
+
+The object has three fields:
+
+* `factors` is an `m`×`n` matrix.
+
+  - The upper triangular part contains the elements of ``R``, that is `R =
+    triu(F.factors)` for a `QR` object `F`.
+
+  - The subdiagonal part contains the reflectors ``v_i`` stored in a packed format where
+    ``v_i`` is the ``i``th column of the matrix `V = eye(m,n) + tril(F.factors,-1)`.
+
+* `τ` is a vector of length `min(m,n)` containing the coefficients ``\tau_i``.
+
+* `jpvt` is an integer vector of length `n` corresponding to the permutation ``P``.
+"""
 struct QRPivoted{T,S<:AbstractMatrix} <: Factorization{T}
     factors::S
     τ::Vector{T}
@@ -26,7 +133,7 @@ end
 QRPivoted(factors::AbstractMatrix{T}, τ::Vector{T}, jpvt::Vector{BlasInt}) where {T} =
     QRPivoted{T,typeof(factors)}(factors, τ, jpvt)
 
-function qrfactUnblocked!{T}(A::AbstractMatrix{T})
+function qrfactUnblocked!(A::AbstractMatrix{T}) where {T}
     m, n = size(A)
     τ = zeros(T, min(m,n))
     for k = 1:min(m - 1 + !(T<:Real), n)
@@ -55,7 +162,7 @@ end
 function qrfactPivotedUnblocked!(A::StridedMatrix)
     m, n = size(A)
     piv = collect(UnitRange{BlasInt}(1,n))
-    τ = Array{eltype(A)}(min(m,n))
+    τ = Vector{eltype(A)}(min(m,n))
     for j = 1:min(m,n)
 
         # Find column with maximum norm in trailing submatrix
@@ -87,48 +194,51 @@ function qrfactPivotedUnblocked!(A::StridedMatrix)
 end
 
 # LAPACK version
-qrfact!(A::StridedMatrix{<:BlasFloat}, ::Type{Val{false}}) = QRCompactWY(LAPACK.geqrt!(A, min(minimum(size(A)), 36))...)
-qrfact!(A::StridedMatrix{<:BlasFloat}, ::Type{Val{true}}) = QRPivoted(LAPACK.geqp3!(A)...)
-qrfact!(A::StridedMatrix{<:BlasFloat}) = qrfact!(A, Val{false})
+qrfact!(A::StridedMatrix{<:BlasFloat}, ::Val{false}) = QRCompactWY(LAPACK.geqrt!(A, min(minimum(size(A)), 36))...)
+qrfact!(A::StridedMatrix{<:BlasFloat}, ::Val{true}) = QRPivoted(LAPACK.geqp3!(A)...)
+qrfact!(A::StridedMatrix{<:BlasFloat}) = qrfact!(A, Val(false))
 
 # Generic fallbacks
 
 """
-    qrfact!(A, pivot=Val{false})
+    qrfact!(A, pivot=Val(false))
 
 `qrfact!` is the same as [`qrfact`](@ref) when `A` is a subtype of
 `StridedMatrix`, but saves space by overwriting the input `A`, instead of creating a copy.
 An [`InexactError`](@ref) exception is thrown if the factorization produces a number not
 representable by the element type of `A`, e.g. for integer types.
 """
-qrfact!(A::StridedMatrix, ::Type{Val{false}}) = qrfactUnblocked!(A)
-qrfact!(A::StridedMatrix, ::Type{Val{true}}) = qrfactPivotedUnblocked!(A)
-qrfact!(A::StridedMatrix) = qrfact!(A, Val{false})
+qrfact!(A::StridedMatrix, ::Val{false}) = qrfactUnblocked!(A)
+qrfact!(A::StridedMatrix, ::Val{true}) = qrfactPivotedUnblocked!(A)
+qrfact!(A::StridedMatrix) = qrfact!(A, Val(false))
 
 """
-    qrfact(A, pivot=Val{false}) -> F
+    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}`).
+Compute the QR factorization of the matrix `A`: an orthogonal (or unitary if `A` is
+complex-valued) matrix `Q`, and an upper triangular matrix `R` such that
+
+```math
+A = Q 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]`        |
+The returned object `F` stores the factorization in a packed format:
 
-`BlasFloat` refers to any of: `Float32`, `Float64`, `Complex64` or `Complex128`.
+ - if `pivot == Val(true)` then `F` is a [`QRPivoted`](@ref) object,
 
-The individual components of the factorization `F` can be accessed by indexing:
+ - otherwise if the element type of `A` is a BLAS type ([`Float32`](@ref), [`Float64`](@ref),
+   `Complex64` or `Complex128`), then `F` is a [`QRCompactWY`](@ref) object,
 
-| 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`              |                 |                    | ✓               |
+ - otherwise `F` is a [`QR`](@ref) object.
 
-The following functions are available for the `QR` objects: [`size`](@ref)
+The individual components of the factorization `F` can be accessed by indexing with a symbol:
+
+ - `F[:Q]`: the orthogonal/unitary matrix `Q`
+ - `F[:R]`: the upper triangular matrix `R`
+ - `F[:p]`: the permutation vector of the pivot ([`QRPivoted`](@ref) only)
+ - `F[:P]`: the permutation matrix of the pivot ([`QRPivoted`](@ref) only)
+
+The following functions are available for the `QR` objects: [`inv`](@ref), [`size`](@ref),
 and [`\\`](@ref). When `A` is rectangular, `\\` will return a least squares
 solution and if the solution is not unique, the one with smallest norm is returned.
 
@@ -136,8 +246,7 @@ Multiplication with respect to either thin or full `Q` is allowed, i.e. both `F[
 and `F[:Q]*A` are supported. A `Q` matrix can be converted into a regular matrix with
 [`full`](@ref) which has a named argument `thin`.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> A = [3.0 -6.0; 4.0 -8.0; 0.0 1.0]
 3×2 Array{Float64,2}:
@@ -159,40 +268,13 @@ true
     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)
 """
-function qrfact{T}(A::AbstractMatrix{T}, arg)
+function qrfact(A::AbstractMatrix{T}, arg) where T
     AA = similar(A, typeof(zero(T)/norm(one(T))), size(A))
     copy!(AA, A)
     return qrfact!(AA, arg)
 end
-function qrfact{T}(A::AbstractMatrix{T})
+function qrfact(A::AbstractMatrix{T}) where T
     AA = similar(A, typeof(zero(T)/norm(one(T))), size(A))
     copy!(AA, A)
     return qrfact!(AA)
@@ -200,21 +282,21 @@ end
 qrfact(x::Number) = qrfact(fill(x,1,1))
 
 """
-    qr(A, pivot=Val{false}; thin::Bool=true) -> Q, R, [p]
+    qr(A, pivot=Val(false); thin::Bool=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`](@ref).
 The default is to compute a thin factorization. Note that `R` is not
 extended with zeros when the full `Q` is requested.
 """
-qr(A::Union{Number, AbstractMatrix}, pivot::Union{Type{Val{false}}, Type{Val{true}}}=Val{false}; thin::Bool=true) =
+qr(A::Union{Number, AbstractMatrix}, pivot::Union{Val{false}, Val{true}}=Val(false); thin::Bool=true) =
     _qr(A, pivot, thin=thin)
-function _qr(A::Union{Number, AbstractMatrix}, ::Type{Val{false}}; thin::Bool=true)
-    F = qrfact(A, Val{false})
+function _qr(A::Union{Number, AbstractMatrix}, ::Val{false}; thin::Bool=true)
+    F = qrfact(A, Val(false))
     full(getq(F), thin=thin), F[:R]::Matrix{eltype(F)}
 end
-function _qr(A::Union{Number, AbstractMatrix}, ::Type{Val{true}}; thin::Bool=true)
-    F = qrfact(A, Val{true})
+function _qr(A::Union{Number, AbstractMatrix}, ::Val{true}; thin::Bool=true)
+    F = qrfact(A, Val(true))
     full(getq(F), thin=thin), F[:R]::Matrix{eltype(F)}, F[:p]::Vector{BlasInt}
 end
 
@@ -228,8 +310,7 @@ Returns `w`, a unit vector in the direction of `v`, and
 See also [`normalize`](@ref), [`normalize!`](@ref),
 and [`LinAlg.qr!`](@ref).
 
-# Example
-
+# Examples
 ```jldoctest
 julia> v = [1; 2]
 2-element Array{Int64,1}:
@@ -271,20 +352,20 @@ function qr!(v::AbstractVector)
 end
 
 # Conversions
-convert{T}(::Type{QR{T}}, A::QR) = QR(convert(AbstractMatrix{T}, A.factors), convert(Vector{T}, A.τ))
-convert{T}(::Type{Factorization{T}}, A::QR{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))
-convert{T}(::Type{Factorization{T}}, A::QRCompactWY{T}) = A
-convert{T}(::Type{Factorization{T}}, A::QRCompactWY) = convert(QRCompactWY{T}, A)
+convert(::Type{QR{T}}, A::QR) where {T} = QR(convert(AbstractMatrix{T}, A.factors), convert(Vector{T}, A.τ))
+convert(::Type{Factorization{T}}, A::QR{T}) where {T} = A
+convert(::Type{Factorization{T}}, A::QR) where {T} = convert(QR{T}, A)
+convert(::Type{QRCompactWY{T}}, A::QRCompactWY) where {T} = QRCompactWY(convert(AbstractMatrix{T}, A.factors), convert(AbstractMatrix{T}, A.T))
+convert(::Type{Factorization{T}}, A::QRCompactWY{T}) where {T} = A
+convert(::Type{Factorization{T}}, A::QRCompactWY) where {T} = convert(QRCompactWY{T}, A)
 convert(::Type{AbstractMatrix}, F::Union{QR,QRCompactWY}) = F[:Q] * F[:R]
 convert(::Type{AbstractArray}, F::Union{QR,QRCompactWY}) = convert(AbstractMatrix, F)
 convert(::Type{Matrix}, F::Union{QR,QRCompactWY}) = convert(Array, convert(AbstractArray, F))
 convert(::Type{Array}, F::Union{QR,QRCompactWY}) = convert(Matrix, F)
 full(F::Union{QR,QRCompactWY}) = convert(AbstractArray, F)
-convert{T}(::Type{QRPivoted{T}}, A::QRPivoted) = QRPivoted(convert(AbstractMatrix{T}, A.factors), convert(Vector{T}, A.τ), A.jpvt)
-convert{T}(::Type{Factorization{T}}, A::QRPivoted{T}) = A
-convert{T}(::Type{Factorization{T}}, A::QRPivoted) = convert(QRPivoted{T}, A)
+convert(::Type{QRPivoted{T}}, A::QRPivoted) where {T} = QRPivoted(convert(AbstractMatrix{T}, A.factors), convert(Vector{T}, A.τ), A.jpvt)
+convert(::Type{Factorization{T}}, A::QRPivoted{T}) where {T} = A
+convert(::Type{Factorization{T}}, A::QRPivoted) where {T} = convert(QRPivoted{T}, A)
 convert(::Type{AbstractMatrix}, F::QRPivoted) = (F[:Q] * F[:R])[:,invperm(F[:p])]
 convert(::Type{AbstractArray}, F::QRPivoted) = convert(AbstractMatrix, F)
 convert(::Type{Matrix}, F::QRPivoted) = convert(Array, convert(AbstractArray, F))
@@ -318,7 +399,7 @@ function getindex(A::QRCompactWY, d::Symbol)
         throw(KeyError(d))
     end
 end
-function getindex{T}(A::QRPivoted{T}, d::Symbol)
+function getindex(A::QRPivoted{T}, d::Symbol) where T
     m, n = size(A)
     if d == :R
         return triu!(A.factors[1:min(m,n), 1:n])
@@ -339,35 +420,49 @@ function getindex{T}(A::QRPivoted{T}, d::Symbol)
     end
 end
 
+abstract type AbstractQ{T} <: AbstractMatrix{T} end
+
 # Type-stable interface to get Q
 getq(A::QRCompactWY) = QRCompactWYQ(A.factors,A.T)
 getq(A::Union{QR, QRPivoted}) = QRPackedQ(A.factors,A.τ)
 
-struct QRPackedQ{T,S<:AbstractMatrix} <: AbstractMatrix{T}
+"""
+    QRPackedQ <: AbstractMatrix
+
+The orthogonal/unitary ``Q`` matrix of a QR factorization stored in [`QR`](@ref) or
+[`QRPivoted`](@ref) format.
+"""
+struct QRPackedQ{T,S<:AbstractMatrix} <: AbstractQ{T}
     factors::S
     τ::Vector{T}
     QRPackedQ{T,S}(factors::AbstractMatrix{T}, τ::Vector{T}) where {T,S<:AbstractMatrix} = new(factors, τ)
 end
 QRPackedQ(factors::AbstractMatrix{T}, τ::Vector{T}) where {T} = QRPackedQ{T,typeof(factors)}(factors, τ)
 
-struct QRCompactWYQ{S, M<:AbstractMatrix} <: AbstractMatrix{S}
+"""
+    QRCompactWYQ <: AbstractMatrix
+
+The orthogonal/unitary ``Q`` matrix of a QR factorization stored in [`QRCompactWY`](@ref)
+format.
+"""
+struct QRCompactWYQ{S, M<:AbstractMatrix} <: AbstractQ{S}
     factors::M
     T::Matrix{S}
     QRCompactWYQ{S,M}(factors::AbstractMatrix{S}, T::Matrix{S}) where {S,M<:AbstractMatrix} = new(factors, T)
 end
 QRCompactWYQ(factors::AbstractMatrix{S}, T::Matrix{S}) where {S} = QRCompactWYQ{S,typeof(factors)}(factors, T)
 
-convert{T}(::Type{QRPackedQ{T}}, Q::QRPackedQ) = QRPackedQ(convert(AbstractMatrix{T}, Q.factors), convert(Vector{T}, Q.τ))
-convert{T}(::Type{AbstractMatrix{T}}, Q::QRPackedQ{T}) = Q
-convert{T}(::Type{AbstractMatrix{T}}, Q::QRPackedQ) = convert(QRPackedQ{T}, Q)
-convert{S}(::Type{QRCompactWYQ{S}}, Q::QRCompactWYQ) = QRCompactWYQ(convert(AbstractMatrix{S}, Q.factors), convert(AbstractMatrix{S}, Q.T))
-convert{S}(::Type{AbstractMatrix{S}}, Q::QRCompactWYQ{S}) = Q
-convert{S}(::Type{AbstractMatrix{S}}, Q::QRCompactWYQ) = convert(QRCompactWYQ{S}, Q)
-convert{T}(::Type{Matrix}, A::Union{QRPackedQ{T},QRCompactWYQ{T}}) = A_mul_B!(A, eye(T, size(A.factors, 1), minimum(size(A.factors))))
-convert(::Type{Array}, A::Union{QRPackedQ,QRCompactWYQ}) = convert(Matrix, A)
+convert(::Type{QRPackedQ{T}}, Q::QRPackedQ) where {T} = QRPackedQ(convert(AbstractMatrix{T}, Q.factors), convert(Vector{T}, Q.τ))
+convert(::Type{AbstractMatrix{T}}, Q::QRPackedQ{T}) where {T} = Q
+convert(::Type{AbstractMatrix{T}}, Q::QRPackedQ) where {T} = convert(QRPackedQ{T}, Q)
+convert(::Type{QRCompactWYQ{S}}, Q::QRCompactWYQ) where {S} = QRCompactWYQ(convert(AbstractMatrix{S}, Q.factors), convert(AbstractMatrix{S}, Q.T))
+convert(::Type{AbstractMatrix{S}}, Q::QRCompactWYQ{S}) where {S} = Q
+convert(::Type{AbstractMatrix{S}}, Q::QRCompactWYQ) where {S} = convert(QRCompactWYQ{S}, Q)
+convert(::Type{Matrix}, A::AbstractQ{T}) where {T} = A_mul_B!(A, eye(T, size(A.factors, 1), minimum(size(A.factors))))
+convert(::Type{Array}, A::AbstractQ) = convert(Matrix, A)
 
 """
-    full(A::Union{QRPackedQ,QRCompactWYQ}; thin::Bool=true) -> Matrix
+    full(A::AbstractQ; thin::Bool=true) -> Matrix
 
 Converts an orthogonal or unitary matrix stored as a `QRCompactWYQ` object, i.e. in the
 compact WY format [^Bischof1987], or in the `QRPackedQ` format, to a dense matrix.
@@ -377,7 +472,7 @@ rows of `R` in the QR factorization that are zero. The resulting matrix is the `
 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 full{T}(A::Union{QRPackedQ{T},QRCompactWYQ{T}}; thin::Bool = true)
+function full(A::AbstractQ{T}; thin::Bool = true) where T
     if thin
         convert(Array, A)
     else
@@ -387,11 +482,11 @@ end
 
 size(A::Union{QR,QRCompactWY,QRPivoted}, dim::Integer) = size(A.factors, dim)
 size(A::Union{QR,QRCompactWY,QRPivoted}) = size(A.factors)
-size(A::Union{QRPackedQ,QRCompactWYQ}, dim::Integer) = 0 < dim ? (dim <= 2 ? size(A.factors, 1) : 1) : throw(BoundsError())
-size(A::Union{QRPackedQ,QRCompactWYQ}) = size(A, 1), size(A, 2)
+size(A::AbstractQ, dim::Integer) = 0 < dim ? (dim <= 2 ? size(A.factors, 1) : 1) : throw(BoundsError())
+size(A::AbstractQ) = size(A, 1), size(A, 2)
 
 
-function getindex(A::Union{QRPackedQ,QRCompactWYQ}, i::Integer, j::Integer)
+function getindex(A::AbstractQ, i::Integer, j::Integer)
     x = zeros(eltype(A), size(A, 1))
     x[i] = 1
     y = zeros(eltype(A), size(A, 2))
@@ -401,8 +496,10 @@ end
 
 ## Multiplication by Q
 ### QB
-A_mul_B!{T<:BlasFloat}(A::QRCompactWYQ{T}, B::StridedVecOrMat{T}) = LAPACK.gemqrt!('L','N',A.factors,A.T,B)
-A_mul_B!{T<:BlasFloat}(A::QRPackedQ{T}, B::StridedVecOrMat{T}) = LAPACK.ormqr!('L','N',A.factors,A.τ,B)
+A_mul_B!(A::QRCompactWYQ{T,S}, B::StridedVecOrMat{T}) where {T<:BlasFloat, S<:StridedMatrix} =
+    LAPACK.gemqrt!('L','N',A.factors,A.T,B)
+A_mul_B!(A::QRPackedQ{T,S}, B::StridedVecOrMat{T}) where {T<:BlasFloat, S<:StridedMatrix} =
+    LAPACK.ormqr!('L','N',A.factors,A.τ,B)
 function A_mul_B!(A::QRPackedQ, B::AbstractVecOrMat)
     mA, nA = size(A.factors)
     mB, nB = size(B,1), size(B,2)
@@ -428,7 +525,7 @@ function A_mul_B!(A::QRPackedQ, B::AbstractVecOrMat)
     B
 end
 
-function (*)(A::Union{QRPackedQ,QRCompactWYQ}, b::StridedVector)
+function (*)(A::AbstractQ, b::StridedVector)
     TAb = promote_type(eltype(A), eltype(b))
     Anew = convert(AbstractMatrix{TAb}, A)
     if size(A.factors, 1) == length(b)
@@ -440,7 +537,7 @@ function (*)(A::Union{QRPackedQ,QRCompactWYQ}, b::StridedVector)
     end
     A_mul_B!(Anew, bnew)
 end
-function (*)(A::Union{QRPackedQ,QRCompactWYQ}, B::StridedMatrix)
+function (*)(A::AbstractQ, B::StridedMatrix)
     TAB = promote_type(eltype(A), eltype(B))
     Anew = convert(AbstractMatrix{TAB}, A)
     if size(A.factors, 1) == size(B, 1)
@@ -454,10 +551,14 @@ function (*)(A::Union{QRPackedQ,QRCompactWYQ}, B::StridedMatrix)
 end
 
 ### QcB
-Ac_mul_B!{T<:BlasReal}(A::QRCompactWYQ{T}, B::StridedVecOrMat{T}) = LAPACK.gemqrt!('L','T',A.factors,A.T,B)
-Ac_mul_B!{T<:BlasComplex}(A::QRCompactWYQ{T}, B::StridedVecOrMat{T}) = LAPACK.gemqrt!('L','C',A.factors,A.T,B)
-Ac_mul_B!{T<:BlasReal}(A::QRPackedQ{T}, B::StridedVecOrMat{T}) = LAPACK.ormqr!('L','T',A.factors,A.τ,B)
-Ac_mul_B!{T<:BlasComplex}(A::QRPackedQ{T}, B::StridedVecOrMat{T}) = LAPACK.ormqr!('L','C',A.factors,A.τ,B)
+Ac_mul_B!(A::QRCompactWYQ{T,S}, B::StridedVecOrMat{T}) where {T<:BlasReal,S<:StridedMatrix} =
+    LAPACK.gemqrt!('L','T',A.factors,A.T,B)
+Ac_mul_B!(A::QRCompactWYQ{T,S}, B::StridedVecOrMat{T}) where {T<:BlasComplex,S<:StridedMatrix} =
+    LAPACK.gemqrt!('L','C',A.factors,A.T,B)
+Ac_mul_B!(A::QRPackedQ{T,S}, B::StridedVecOrMat{T}) where {T<:BlasReal,S<:StridedMatrix} =
+    LAPACK.ormqr!('L','T',A.factors,A.τ,B)
+Ac_mul_B!(A::QRPackedQ{T,S}, B::StridedVecOrMat{T}) where {T<:BlasComplex,S<:StridedMatrix} =
+    LAPACK.ormqr!('L','C',A.factors,A.τ,B)
 function Ac_mul_B!(A::QRPackedQ, B::AbstractVecOrMat)
     mA, nA = size(A.factors)
     mB, nB = size(B,1), size(B,2)
@@ -482,7 +583,7 @@ function Ac_mul_B!(A::QRPackedQ, B::AbstractVecOrMat)
     end
     B
 end
-function Ac_mul_B(Q::Union{QRPackedQ,QRCompactWYQ}, B::StridedVecOrMat)
+function Ac_mul_B(Q::AbstractQ, B::StridedVecOrMat)
     TQB = promote_type(eltype(Q), eltype(B))
     return Ac_mul_B!(convert(AbstractMatrix{TQB}, Q), copy_oftype(B, TQB))
 end
@@ -491,7 +592,7 @@ end
 for (f1, f2) in ((:A_mul_Bc, :A_mul_B!),
                  (:Ac_mul_Bc, :Ac_mul_B!))
     @eval begin
-        function ($f1)(Q::Union{QRPackedQ,QRCompactWYQ}, B::StridedVecOrMat)
+        function ($f1)(Q::AbstractQ, B::StridedVecOrMat)
             TQB = promote_type(eltype(Q), eltype(B))
             Bc = similar(B, TQB, (size(B, 2), size(B, 1)))
             ctranspose!(Bc, B)
@@ -501,8 +602,10 @@ for (f1, f2) in ((:A_mul_Bc, :A_mul_B!),
 end
 
 ### AQ
-A_mul_B!{T<:BlasFloat}(A::StridedVecOrMat{T}, B::QRCompactWYQ{T}) = LAPACK.gemqrt!('R','N', B.factors, B.T, A)
-A_mul_B!{T<:BlasFloat}(A::StridedVecOrMat{T}, B::QRPackedQ{T}) = LAPACK.ormqr!('R', 'N', B.factors, B.τ, A)
+A_mul_B!(A::StridedVecOrMat{T}, B::QRCompactWYQ{T,S}) where {T<:BlasFloat,S<:StridedMatrix} =
+    LAPACK.gemqrt!('R','N', B.factors, B.T, A)
+A_mul_B!(A::StridedVecOrMat{T}, B::QRPackedQ{T,S}) where {T<:BlasFloat,S<:StridedMatrix} =
+    LAPACK.ormqr!('R', 'N', B.factors, B.τ, A)
 function A_mul_B!(A::StridedMatrix,Q::QRPackedQ)
     mQ, nQ = size(Q.factors)
     mA, nA = size(A,1), size(A,2)
@@ -528,17 +631,17 @@ function A_mul_B!(A::StridedMatrix,Q::QRPackedQ)
     A
 end
 
-function (*)(A::StridedMatrix, Q::Union{QRPackedQ,QRCompactWYQ})
+function (*)(A::StridedMatrix, Q::AbstractQ)
     TAQ = promote_type(eltype(A), eltype(Q))
     return A_mul_B!(copy_oftype(A, TAQ), convert(AbstractMatrix{TAQ}, Q))
 end
 
 ### AQc
-A_mul_Bc!{T<:BlasReal}(A::StridedVecOrMat{T}, B::QRCompactWYQ{T}) = LAPACK.gemqrt!('R','T',B.factors,B.T,A)
-A_mul_Bc!{T<:BlasComplex}(A::StridedVecOrMat{T}, B::QRCompactWYQ{T}) = LAPACK.gemqrt!('R','C',B.factors,B.T,A)
-A_mul_Bc!{T<:BlasReal}(A::StridedVecOrMat{T}, B::QRPackedQ{T}) = LAPACK.ormqr!('R','T',B.factors,B.τ,A)
-A_mul_Bc!{T<:BlasComplex}(A::StridedVecOrMat{T}, B::QRPackedQ{T}) = LAPACK.ormqr!('R','C',B.factors,B.τ,A)
-function A_mul_Bc!(A::AbstractMatrix,Q::QRPackedQ)
+A_mul_Bc!(A::StridedVecOrMat{T}, B::QRCompactWYQ{T}) where {T<:BlasReal} = LAPACK.gemqrt!('R','T',B.factors,B.T,A)
+A_mul_Bc!(A::StridedVecOrMat{T}, B::QRCompactWYQ{T}) where {T<:BlasComplex} = LAPACK.gemqrt!('R','C',B.factors,B.T,A)
+A_mul_Bc!(A::StridedVecOrMat{T}, B::QRPackedQ{T}) where {T<:BlasReal} = LAPACK.ormqr!('R','T',B.factors,B.τ,A)
+A_mul_Bc!(A::StridedVecOrMat{T}, B::QRPackedQ{T}) where {T<:BlasComplex} = LAPACK.ormqr!('R','C',B.factors,B.τ,A)
+function A_mul_Bc!(A::StridedMatrix,Q::QRPackedQ)
     mQ, nQ = size(Q.factors)
     mA, nA = size(A,1), size(A,2)
     if nA != mQ
@@ -562,7 +665,7 @@ function A_mul_Bc!(A::AbstractMatrix,Q::QRPackedQ)
     end
     A
 end
-function A_mul_Bc(A::AbstractMatrix, B::Union{QRCompactWYQ,QRPackedQ})
+function A_mul_Bc(A::StridedMatrix, B::AbstractQ)
     TAB = promote_type(eltype(A),eltype(B))
     BB = convert(AbstractMatrix{TAB}, B)
     if size(A,2) == size(B.factors, 1)
@@ -575,14 +678,14 @@ function A_mul_Bc(A::AbstractMatrix, B::Union{QRCompactWYQ,QRPackedQ})
         throw(DimensionMismatch("matrix A has dimensions $(size(A)) but matrix B has dimensions $(size(B))"))
     end
 end
-@inline A_mul_Bc(rowvec::RowVector, B::Union{LinAlg.QRCompactWYQ,LinAlg.QRPackedQ}) = ctranspose(B*ctranspose(rowvec))
+@inline A_mul_Bc(rowvec::RowVector, B::AbstractQ) = ctranspose(B*ctranspose(rowvec))
 
 
 ### AcQ/AcQc
 for (f1, f2) in ((:Ac_mul_B, :A_mul_B!),
                  (:Ac_mul_Bc, :A_mul_Bc!))
     @eval begin
-        function ($f1)(A::StridedVecOrMat, Q::Union{QRPackedQ,QRCompactWYQ})
+        function ($f1)(A::StridedVecOrMat, Q::AbstractQ)
             TAQ = promote_type(eltype(A), eltype(Q))
             Ac = similar(A, TAQ, (size(A, 2), size(A, 1)))
             ctranspose!(Ac, A)
@@ -591,17 +694,21 @@ for (f1, f2) in ((:Ac_mul_B, :A_mul_B!),
     end
 end
 
-A_ldiv_B!{T<:BlasFloat}(A::QRCompactWY{T}, b::StridedVector{T}) = (A_ldiv_B!(UpperTriangular(A[:R]), view(Ac_mul_B!(A[:Q], b), 1:size(A, 2))); b)
-A_ldiv_B!{T<:BlasFloat}(A::QRCompactWY{T}, B::StridedMatrix{T}) = (A_ldiv_B!(UpperTriangular(A[:R]), view(Ac_mul_B!(A[:Q], B), 1:size(A, 2), 1:size(B, 2))); B)
+A_ldiv_B!(A::QRCompactWY{T}, b::StridedVector{T}) where {T<:BlasFloat} = (A_ldiv_B!(UpperTriangular(A[:R]), view(Ac_mul_B!(A[:Q], b), 1:size(A, 2))); b)
+A_ldiv_B!(A::QRCompactWY{T}, B::StridedMatrix{T}) where {T<:BlasFloat} = (A_ldiv_B!(UpperTriangular(A[:R]), view(Ac_mul_B!(A[:Q], B), 1:size(A, 2), 1:size(B, 2))); B)
 
 # Julia implementation similarly to xgelsy
-function A_ldiv_B!{T<:BlasFloat}(A::QRPivoted{T}, B::StridedMatrix{T}, rcond::Real)
+function A_ldiv_B!(A::QRPivoted{T}, B::StridedMatrix{T}, rcond::Real) where T<:BlasFloat
     mA, nA = size(A.factors)
     nr = min(mA,nA)
     nrhs = size(B, 2)
-    if nr == 0 return zeros(T, 0, nrhs), 0 end
+    if nr == 0
+        return zeros(T, 0, nrhs), 0
+    end
     ar = abs(A.factors[1])
-    if ar == 0 return zeros(T, nr, nrhs), 0 end
+    if ar == 0
+        return zeros(T, nA, nrhs), 0
+    end
     rnk = 1
     xmin = ones(T, 1)
     xmax = ones(T, 1)
@@ -625,9 +732,9 @@ function A_ldiv_B!{T<:BlasFloat}(A::QRPivoted{T}, B::StridedMatrix{T}, rcond::Re
     B[1:nA,:] = view(B, 1:nA, :)[invperm(A[:p]::Vector{BlasInt}),:]
     return B, rnk
 end
-A_ldiv_B!{T<:BlasFloat}(A::QRPivoted{T}, B::StridedVector{T}) = vec(A_ldiv_B!(A,reshape(B,length(B),1)))
-A_ldiv_B!{T<:BlasFloat}(A::QRPivoted{T}, B::StridedVecOrMat{T}) = A_ldiv_B!(A, B, maximum(size(A))*eps(real(float(one(eltype(B))))))[1]
-function A_ldiv_B!{T}(A::QR{T}, B::StridedMatrix{T})
+A_ldiv_B!(A::QRPivoted{T}, B::StridedVector{T}) where {T<:BlasFloat} = vec(A_ldiv_B!(A,reshape(B,length(B),1)))
+A_ldiv_B!(A::QRPivoted{T}, B::StridedVecOrMat{T}) where {T<:BlasFloat} = A_ldiv_B!(A, B, maximum(size(A))*eps(real(float(one(eltype(B))))))[1]
+function A_ldiv_B!(A::QR{T}, B::StridedMatrix{T}) where T
     m, n = size(A)
     minmn = min(m,n)
     mB, nB = size(B)
@@ -710,7 +817,7 @@ function _append_zeros(B::AbstractMatrix, T::Type, n)
     end
 end
 
-function (\){TA,TB}(A::Union{QR{TA},QRCompactWY{TA},QRPivoted{TA}}, B::AbstractVecOrMat{TB})
+function (\)(A::Union{QR{TA},QRCompactWY{TA},QRPivoted{TA}}, B::AbstractVecOrMat{TB}) where {TA,TB}
     S = promote_type(TA,TB)
     m, n = size(A)
     m == size(B,1) || throw(DimensionMismatch("left hand side has $m rows, but right hand side has $(size(B,1)) rows"))
@@ -729,7 +836,7 @@ end
 _ret_size(A::Factorization, b::AbstractVector) = (max(size(A, 2), length(b)),)
 _ret_size(A::Factorization, B::AbstractMatrix) = (max(size(A, 2), size(B, 1)), size(B, 2))
 
-function (\){T<:BlasReal}(A::Union{QR{T},QRCompactWY{T},QRPivoted{T}}, BIn::VecOrMat{Complex{T}})
+function (\)(A::Union{QR{T},QRCompactWY{T},QRPivoted{T}}, BIn::VecOrMat{Complex{T}}) where T<:BlasReal
     m, n = size(A)
     m == size(BIn, 1) || throw(DimensionMismatch("left hand side has $m rows, but right hand side has $(size(BIn,1)) rows"))
 
diff --git a/base/linalg/rowvector.jl b/base/linalg/rowvector.jl
index 3c4ce60137e222..eb24fa5792517d 100644
--- a/base/linalg/rowvector.jl
+++ b/base/linalg/rowvector.jl
@@ -1,7 +1,9 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
 """
     RowVector(vector)
 
-A lazy-view wrapper of an `AbstractVector`, which turns a length-`n` vector into a `1×n`
+A lazy-view wrapper of an [`AbstractVector`](@ref), which turns a length-`n` vector into a `1×n`
 shaped row vector and represents the transpose of a vector (the elements are also transposed
 recursively). This type is usually constructed (and unwrapped) via the [`transpose`](@ref)
 function or `.'` operator (or related [`ctranspose`](@ref) or `'` operator).
@@ -19,14 +21,14 @@ struct RowVector{T,V<:AbstractVector} <: AbstractMatrix{T}
     end
 end
 
-@inline check_types{T1,T2}(::Type{T1},::AbstractVector{T2}) = check_types(T1, T2)
-@pure check_types{T1,T2}(::Type{T1},::Type{T2}) = T1 === transpose_type(T2) ? nothing :
+@inline check_types(::Type{T1}, ::AbstractVector{T2}) where {T1,T2} = check_types(T1, T2)
+@pure check_types(::Type{T1}, ::Type{T2}) where {T1,T2} = T1 === transpose_type(T2) ? nothing :
     error("Element type mismatch. Tried to create a `RowVector{$T1}` from an `AbstractVector{$T2}`")
 
-ConjRowVector{T, CV <: ConjVector} = RowVector{T, CV}
+const ConjRowVector{T,CV<:ConjVector} = RowVector{T,CV}
 
 # The element type may be transformed as transpose is recursive
-@inline transpose_type{T}(::Type{T}) = promote_op(transpose, T)
+@inline transpose_type(::Type{T}) where {T} = promote_op(transpose, T)
 
 # Constructors that take a vector
 @inline RowVector(vec::AbstractVector{T}) where {T} = RowVector{transpose_type(T),typeof(vec)}(vec)
@@ -43,15 +45,15 @@ ConjRowVector{T, CV <: ConjVector} = RowVector{T, CV}
     error("RowVector expects 1×N size, got $n")
 
 # Conversion of underlying storage
-convert{T,V<:AbstractVector}(::Type{RowVector{T,V}}, rowvec::RowVector) =
+convert(::Type{RowVector{T,V}}, rowvec::RowVector) where {T,V<:AbstractVector} =
     RowVector{T,V}(convert(V,rowvec.vec))
 
 # similar tries to maintain the RowVector wrapper and the parent type
 @inline similar(rowvec::RowVector) = RowVector(similar(parent(rowvec)))
-@inline similar{T}(rowvec::RowVector, ::Type{T}) = RowVector(similar(parent(rowvec), transpose_type(T)))
+@inline similar(rowvec::RowVector, ::Type{T}) where {T} = RowVector(similar(parent(rowvec), transpose_type(T)))
 
 # Resizing similar currently loses its RowVector property.
-@inline similar{T,N}(rowvec::RowVector, ::Type{T}, dims::Dims{N}) = similar(parent(rowvec), T, dims)
+@inline similar(rowvec::RowVector, ::Type{T}, dims::Dims{N}) where {T,N} = similar(parent(rowvec), T, dims)
 
 # Basic methods
 """
@@ -59,8 +61,7 @@ convert{T,V<:AbstractVector}(::Type{RowVector{T,V}}, rowvec::RowVector) =
 
 The transposition operator (`.'`).
 
-# Example
-
+# Examples
 ```jldoctest
 julia> v = [1,2,3]
 3-element Array{Int64,1}:
@@ -75,7 +76,6 @@ julia> transpose(v)
 """
 @inline transpose(vec::AbstractVector) = RowVector(vec)
 @inline ctranspose(vec::AbstractVector) = RowVector(_conj(vec))
-@inline ctranspose(vec::AbstractVector{<:Real}) = RowVector(vec)
 
 @inline transpose(rowvec::RowVector) = rowvec.vec
 @inline transpose(rowvec::ConjRowVector) = copy(rowvec.vec) # remove the ConjArray wrapper from any raw vector
@@ -89,8 +89,7 @@ parent(rowvec::RowVector) = rowvec.vec
 
 Returns a [`ConjArray`](@ref) lazy view of the input, where each element is conjugated.
 
-### Example
-
+# Examples
 ```jldoctest
 julia> v = [1+im, 1-im].'
 1×2 RowVector{Complex{Int64},Array{Complex{Int64},1}}:
@@ -141,31 +140,33 @@ end
 @inline check_tail_indices(i1, i2, i3, is...) = i3 == 1 ? check_tail_indices(i1, i2, is...) : false
 
 # helper function for below
-@inline to_vec(rowvec::RowVector) = transpose(rowvec)
+@inline to_vec(rowvec::RowVector) = map(transpose, transpose(rowvec))
 @inline to_vec(x::Number) = x
 @inline to_vecs(rowvecs...) = (map(to_vec, rowvecs)...)
 
-# map
-@inline map(f, rowvecs::RowVector...) = RowVector(map(f, to_vecs(rowvecs...)...))
+# map: Preserve the RowVector by un-wrapping and re-wrapping, but note that `f`
+# expects to operate within the transposed domain, so to_vec transposes the elements
+@inline map(f, rowvecs::RowVector...) = RowVector(map(transpose∘f, to_vecs(rowvecs...)...))
 
 # broacast (other combinations default to higher-dimensional array)
 @inline broadcast(f, rowvecs::Union{Number,RowVector}...) =
-    RowVector(broadcast(f, to_vecs(rowvecs...)...))
+    RowVector(broadcast(transpose∘f, to_vecs(rowvecs...)...))
 
 # Horizontal concatenation #
 
 @inline hcat(X::RowVector...) = transpose(vcat(map(transpose, X)...))
 @inline hcat(X::Union{RowVector,Number}...) = transpose(vcat(map(transpose, X)...))
 
-@inline typed_hcat{T}(::Type{T}, X::RowVector...) =
+@inline typed_hcat(::Type{T}, X::RowVector...) where {T} =
     transpose(typed_vcat(T, map(transpose, X)...))
-@inline typed_hcat{T}(::Type{T}, X::Union{RowVector,Number}...) =
+@inline typed_hcat(::Type{T}, X::Union{RowVector,Number}...) where {T} =
     transpose(typed_vcat(T, map(transpose, X)...))
 
 # Multiplication #
 
 # inner product -> dot product specializations
-@inline *{T<:Real}(rowvec::RowVector{T}, vec::AbstractVector{T}) = dot(parent(rowvec), vec)
+@inline *(rowvec::RowVector{T}, vec::AbstractVector{T}) where {T<:Real} = dot(parent(rowvec), vec)
+@inline *(rowvec::ConjRowVector{T}, vec::AbstractVector{T}) where {T<:Real} = dot(rowvec', vec)
 @inline *(rowvec::ConjRowVector, vec::AbstractVector) = dot(rowvec', vec)
 
 # Generic behavior
@@ -201,7 +202,7 @@ At_mul_B(::RowVector, ::AbstractVector) = throw(DimensionMismatch("Cannot multip
 @inline At_mul_B(rowvec1::RowVector, rowvec2::RowVector) = transpose(rowvec1) * rowvec2
 At_mul_B(vec::AbstractVector, rowvec::RowVector) = throw(DimensionMismatch(
     "Cannot multiply two transposed vectors"))
-@inline At_mul_B{T<:Real}(vec1::AbstractVector{T}, vec2::AbstractVector{T}) =
+@inline At_mul_B(vec1::AbstractVector{T}, vec2::AbstractVector{T}) where {T<:Real} =
     reduce(+, map(At_mul_B, vec1, vec2)) # Seems to be overloaded...
 @inline At_mul_B(vec1::AbstractVector, vec2::AbstractVector) = transpose(vec1) * vec2
 
diff --git a/base/linalg/schur.jl b/base/linalg/schur.jl
index 209e3488295943..658a2e5addbb8a 100644
--- a/base/linalg/schur.jl
+++ b/base/linalg/schur.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Schur decomposition
 struct Schur{Ty,S<:AbstractMatrix} <: Factorization{Ty}
@@ -7,7 +7,7 @@ struct Schur{Ty,S<:AbstractMatrix} <: Factorization{Ty}
     values::Vector
     Schur{Ty,S}(T::AbstractMatrix{Ty}, Z::AbstractMatrix{Ty}, values::Vector) where {Ty,S} = new(T, Z, values)
 end
-Schur(T::AbstractMatrix{Ty}, Z::AbstractMatrix{Ty}, values::Vector) where Ty = Schur{Ty, typeof(T)}(T, Z, values)
+Schur(T::AbstractMatrix{Ty}, Z::AbstractMatrix{Ty}, values::Vector) where {Ty} = Schur{Ty, typeof(T)}(T, Z, values)
 
 """
     schurfact!(A::StridedMatrix) -> F::Schur
@@ -24,8 +24,7 @@ be obtained from the `Schur` object `F` with either `F[:Schur]` or `F[:T]` and t
 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]`.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> A = [-2. 1. 3.; 2. 1. -1.; -7. 2. 7.]
 3×3 Array{Float64,2}:
@@ -34,7 +33,11 @@ julia> A = [-2. 1. 3.; 2. 1. -1.; -7. 2. 7.]
  -7.0  2.0   7.0
 
 julia> F = schurfact(A)
-Base.LinAlg.Schur{Float64,Array{Float64,2}}([2.0 0.801792 6.63509; -8.55988e-11 2.0 8.08286; 0.0 0.0 1.99999], [0.577351 0.154299 -0.801784; 0.577346 -0.77152 0.267262; 0.577354 0.617211 0.534522], Complex{Float64}[2.0+8.28447e-6im, 2.0-8.28447e-6im, 1.99999+0.0im])
+Base.LinAlg.Schur{Float64,Array{Float64,2}} with factors T and Z:
+[2.0 0.801792 6.63509; -8.55988e-11 2.0 8.08286; 0.0 0.0 1.99999]
+[0.577351 0.154299 -0.801784; 0.577346 -0.77152 0.267262; 0.577354 0.617211 0.534522]
+and values:
+Complex{Float64}[2.0+8.28447e-6im, 2.0-8.28447e-6im, 1.99999+0.0im]
 
 julia> F[:vectors] * F[:Schur] * F[:vectors]'
 3×3 Array{Float64,2}:
@@ -44,7 +47,7 @@ julia> F[:vectors] * F[:Schur] * F[:vectors]'
 ```
 """
 schurfact(A::StridedMatrix{<:BlasFloat}) = schurfact!(copy(A))
-function schurfact{T}(A::StridedMatrix{T})
+function schurfact(A::StridedMatrix{T}) where T
     S = promote_type(Float32, typeof(one(T)/norm(one(T))))
     return schurfact!(copy_oftype(A, S))
 end
@@ -61,6 +64,16 @@ function getindex(F::Schur, d::Symbol)
     end
 end
 
+function show(io::IO, F::Schur)
+    println(io, "$(typeof(F)) with factors T and Z:")
+    show(io, F[:T])
+    println(io)
+    show(io, F[:Z])
+    println(io)
+    println(io, "and values:")
+    show(io, F[:values])
+end
+
 """
     schur(A::StridedMatrix) -> T::Matrix, Z::Matrix, λ::Vector
 
@@ -70,8 +83,7 @@ triangular Schur factor `T` and the orthogonal/unitary Schur vectors `Z` such th
 
 See [`schurfact`](@ref).
 
-# Example
-
+# Examples
 ```jldoctest
 julia> A = [-2. 1. 3.; 2. 1. -1.; -7. 2. 7.]
 3×3 Array{Float64,2}:
@@ -93,6 +105,12 @@ function schur(A::StridedMatrix)
     SchurF = schurfact(A)
     SchurF[:T], SchurF[:Z], SchurF[:values]
 end
+schur(A::Symmetric) = schur(full(A))
+schur(A::Hermitian) = schur(full(A))
+schur(A::UpperTriangular) = schur(full(A))
+schur(A::LowerTriangular) = schur(full(A))
+schur(A::Tridiagonal) = schur(full(A))
+
 
 """
     ordschur!(F::Schur, select::Union{Vector{Bool},BitVector}) -> F::Schur
@@ -123,7 +141,7 @@ ordschur(schur::Schur, select::Union{Vector{Bool},BitVector}) =
 
 Same as [`ordschur`](@ref) but overwrites the input arguments.
 """
-ordschur!{Ty<:BlasFloat}(T::StridedMatrix{Ty}, Z::StridedMatrix{Ty}, select::Union{Vector{Bool},BitVector}) =
+ordschur!(T::StridedMatrix{Ty}, Z::StridedMatrix{Ty}, select::Union{Vector{Bool},BitVector}) where {Ty<:BlasFloat} =
     LinAlg.LAPACK.trsen!(convert(Vector{BlasInt}, select), T, Z)
 
 """
@@ -136,7 +154,7 @@ corresponding leading columns of `Z` form an orthogonal/unitary basis of the cor
 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(T::StridedMatrix{Ty}, Z::StridedMatrix{Ty}, select::Union{Vector{Bool},BitVector}) where {Ty<:BlasFloat} =
     ordschur!(copy(T), copy(Z), select)
 
 struct GeneralizedSchur{Ty,M<:AbstractMatrix} <: Factorization{Ty}
@@ -161,7 +179,7 @@ end
 
 Same as [`schurfact`](@ref) but uses the input matrices `A` and `B` as workspace.
 """
-schurfact!{T<:BlasFloat}(A::StridedMatrix{T}, B::StridedMatrix{T}) =
+schurfact!(A::StridedMatrix{T}, B::StridedMatrix{T}) where {T<:BlasFloat} =
     GeneralizedSchur(LinAlg.LAPACK.gges!('V', 'V', A, B)...)
 
 """
@@ -174,8 +192,8 @@ and `F[:T]`, the left unitary/orthogonal Schur vectors can be obtained with `F[:
 `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})
+schurfact(A::StridedMatrix{T},B::StridedMatrix{T}) where {T<:BlasFloat} = schurfact!(copy(A),copy(B))
+function schurfact(A::StridedMatrix{TA}, B::StridedMatrix{TB}) where {TA,TB}
     S = promote_type(Float32, typeof(one(TA)/norm(one(TA))), TB)
     return schurfact!(copy_oftype(A, S), copy_oftype(B, S))
 end
@@ -210,8 +228,8 @@ ordschur(gschur::GeneralizedSchur, select::Union{Vector{Bool},BitVector}) =
 
 Same as [`ordschur`](@ref) 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}) =
+ordschur!(S::StridedMatrix{Ty}, T::StridedMatrix{Ty}, Q::StridedMatrix{Ty},
+    Z::StridedMatrix{Ty}, select::Union{Vector{Bool},BitVector}) where {Ty<:BlasFloat} =
         LinAlg.LAPACK.tgsen!(convert(Vector{BlasInt}, select), S, T, Q, Z)
 
 """
@@ -224,8 +242,8 @@ and `T`, and the left and right unitary/orthogonal Schur vectors are also reorde
 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(S::StridedMatrix{Ty}, T::StridedMatrix{Ty}, Q::StridedMatrix{Ty},
+    Z::StridedMatrix{Ty}, select::Union{Vector{Bool},BitVector}) where {Ty<:BlasFloat} =
         ordschur!(copy(S), copy(T), copy(Q), copy(Z), select)
 
 function getindex(F::GeneralizedSchur, d::Symbol)
diff --git a/base/linalg/special.jl b/base/linalg/special.jl
index 662637ec1b9f46..e7ba87788d40b5 100644
--- a/base/linalg/special.jl
+++ b/base/linalg/special.jl
@@ -1,13 +1,13 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Methods operating on different special matrix types
 
 # Interconversion between special matrix types
-convert{T}(::Type{Bidiagonal}, A::Diagonal{T}) =
-    Bidiagonal(A.diag, zeros(T, size(A.diag,1)-1), true)
-convert{T}(::Type{SymTridiagonal}, A::Diagonal{T}) =
+convert(::Type{Bidiagonal}, A::Diagonal{T}) where {T} =
+    Bidiagonal(A.diag, zeros(T, size(A.diag,1)-1), :U)
+convert(::Type{SymTridiagonal}, A::Diagonal{T}) where {T} =
     SymTridiagonal(A.diag, zeros(T, size(A.diag,1)-1))
-convert{T}(::Type{Tridiagonal}, A::Diagonal{T}) =
+convert(::Type{Tridiagonal}, A::Diagonal{T}) where {T} =
     Tridiagonal(zeros(T, size(A.diag,1)-1), A.diag, zeros(T, size(A.diag,1)-1))
 
 function convert(::Type{Diagonal}, A::Union{Bidiagonal, SymTridiagonal})
@@ -24,15 +24,15 @@ function convert(::Type{SymTridiagonal}, A::Bidiagonal)
     SymTridiagonal(A.dv, A.ev)
 end
 
-convert{T}(::Type{Tridiagonal}, A::Bidiagonal{T}) =
-    Tridiagonal(A.isupper ? zeros(T, size(A.dv,1)-1) : A.ev, A.dv,
-                A.isupper ? A.ev:zeros(T, size(A.dv,1)-1))
+convert(::Type{Tridiagonal}, A::Bidiagonal{T}) where {T} =
+    Tridiagonal(A.uplo == 'U' ? zeros(T, size(A.dv,1)-1) : A.ev, A.dv,
+                A.uplo == 'U' ? A.ev : zeros(T, size(A.dv,1)-1))
 
 function convert(::Type{Bidiagonal}, A::SymTridiagonal)
     if !iszero(A.ev)
         throw(ArgumentError("matrix cannot be represented as Bidiagonal"))
     end
-    Bidiagonal(A.dv, A.ev, true)
+    Bidiagonal(A.dv, A.ev, :U)
 end
 
 function convert(::Type{Diagonal}, A::Tridiagonal)
@@ -44,9 +44,9 @@ end
 
 function convert(::Type{Bidiagonal}, A::Tridiagonal)
     if iszero(A.dl)
-        return Bidiagonal(A.d, A.du, true)
+        return Bidiagonal(A.d, A.du, :U)
     elseif iszero(A.du)
-        return Bidiagonal(A.d, A.dl, false)
+        return Bidiagonal(A.d, A.dl, :L)
     else
         throw(ArgumentError("matrix cannot be represented as Bidiagonal"))
     end
@@ -73,9 +73,9 @@ end
 function convert(::Type{Bidiagonal}, A::AbstractTriangular)
     fA = full(A)
     if fA == diagm(diag(A)) + diagm(diag(fA, 1), 1)
-        return Bidiagonal(diag(A), diag(fA,1), true)
+        return Bidiagonal(diag(A), diag(fA,1), :U)
     elseif fA == diagm(diag(A)) + diagm(diag(fA, -1), -1)
-        return Bidiagonal(diag(A), diag(fA,-1), false)
+        return Bidiagonal(diag(A), diag(fA,-1), :L)
     else
         throw(ArgumentError("matrix cannot be represented as Bidiagonal"))
     end
@@ -94,9 +94,9 @@ function convert(::Type{Tridiagonal}, A::AbstractTriangular)
 end
 
 # Constructs two method definitions taking into account (assumed) commutativity
-# e.g. @commutative f{S,T}(x::S, y::T) = x+y is the same is defining
-#     f{S,T}(x::S, y::T) = x+y
-#     f{S,T}(y::T, x::S) = f(x, y)
+# e.g. @commutative f(x::S, y::T) where {S,T} = x+y is the same is defining
+#     f(x::S, y::T) where {S,T} = x+y
+#     f(y::T, x::S) where {S,T} = f(x, y)
 macro commutative(myexpr)
     @assert myexpr.head===:(=) || myexpr.head===:function # Make sure it is a function definition
     y = copy(myexpr.args[1].args[2:end])
diff --git a/base/linalg/svd.jl b/base/linalg/svd.jl
index 96df0b82a89fc8..3cb28e9a2bb23a 100644
--- a/base/linalg/svd.jl
+++ b/base/linalg/svd.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Singular Value Decomposition
 struct SVD{T,Tr,M<:AbstractArray} <: Factorization{T}
@@ -15,12 +15,8 @@ SVD(U::AbstractArray{T}, S::Vector{Tr}, Vt::AbstractArray{T}) where {T,Tr} = SVD
 
 `svdfact!` is the same as [`svdfact`](@ref), 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}; thin::Bool=true)
+function svdfact!(A::StridedMatrix{T}; thin::Bool=true) where T<:BlasFloat
     m,n = size(A)
     if m == 0 || n == 0
         u,s,vt = (eye(T, m, thin ? n : m), real(zeros(T,0)), eye(T,n,n))
@@ -31,19 +27,20 @@ function svdfact!{T<:BlasFloat}(A::StridedMatrix{T}; thin::Bool=true)
 end
 
 """
-    svdfact(A, thin::Bool=true) -> SVD
+    svdfact(A; thin::Bool=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`.
+The singular values in `S` are sorted in descending order.
 
 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.
 
-# Example
+# Examples
 ```jldoctest
 julia> A = [1. 0. 0. 0. 2.; 0. 0. 3. 0. 0.; 0. 0. 0. 0. 0.; 0. 2. 0. 0. 0.]
 4×5 Array{Float64,2}:
@@ -63,7 +60,7 @@ julia> F[:U] * diagm(F[:S]) * F[:Vt]
  0.0  2.0  0.0  0.0  0.0
 ```
 """
-function svdfact{T}(A::StridedVecOrMat{T}; thin::Bool = true)
+function svdfact(A::StridedVecOrMat{T}; thin::Bool = true) where T
     S = promote_type(Float32, typeof(one(T)/norm(one(T))))
     svdfact!(copy_oftype(A, S), thin = thin)
 end
@@ -71,10 +68,10 @@ svdfact(x::Number; thin::Bool=true) = SVD(x == 0 ? fill(one(x), 1, 1) : fill(x/a
 svdfact(x::Integer; thin::Bool=true) = svdfact(float(x), thin=thin)
 
 """
-    svd(A, thin::Bool=true) -> U, S, V
+    svd(A; thin::Bool=true) -> U, S, V
 
 Computes the SVD of `A`, returning `U`, vector `S`, and `V` such that
-`A == U*diagm(S)*V'`.
+`A == U*diagm(S)*V'`. The singular values in `S` are sorted in descending order.
 
 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
@@ -84,8 +81,7 @@ If `thin=true` (default), a thin SVD is returned. For a ``M \\times N`` matrix
 of the `SVD` factorization to a tuple. Direct use of `svdfact` is therefore more
 efficient.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> A = [1. 0. 0. 0. 2.; 0. 0. 3. 0. 0.; 0. 0. 0. 0. 0.; 0. 2. 0. 0. 0.]
 4×5 Array{Float64,2}:
@@ -105,10 +101,11 @@ julia> U*diagm(S)*V'
  0.0  2.0  0.0  0.0  0.0
 ```
 """
-function svd(A::Union{Number, AbstractArray}; thin::Bool=true)
+function svd(A::AbstractArray; thin::Bool=true)
     F = svdfact(A, thin=thin)
     F.U, F.S, F.Vt'
 end
+svd(x::Number; thin::Bool=true) = first.(svd(fill(x, 1, 1)))
 
 function getindex(F::SVD, d::Symbol)
     if d == :U
@@ -130,16 +127,15 @@ end
 Returns the singular values of `A`, saving space by overwriting the input.
 See also [`svdvals`](@ref).
 """
-svdvals!{T<:BlasFloat}(A::StridedMatrix{T}) = findfirst(size(A), 0) > 0 ? zeros(T, 0) : LAPACK.gesdd!('N', A)[2]
+svdvals!(A::StridedMatrix{T}) where {T<:BlasFloat} = isempty(A) ? zeros(real(T), 0) : LAPACK.gesdd!('N', A)[2]
 svdvals(A::AbstractMatrix{<:BlasFloat}) = svdvals!(copy(A))
 
 """
     svdvals(A)
 
-Returns the singular values of `A`.
-
-# Example
+Returns the singular values of `A` in descending order.
 
+# Examples
 ```jldoctest
 julia> A = [1. 0. 0. 0. 2.; 0. 0. 3. 0. 0.; 0. 0. 0. 0. 0.; 0. 2. 0. 0. 0.]
 4×5 Array{Float64,2}:
@@ -156,15 +152,15 @@ julia> svdvals(A)
  0.0
 ```
 """
-function svdvals{T}(A::AbstractMatrix{T})
+function svdvals(A::AbstractMatrix{T}) where T
     S = promote_type(Float32, typeof(one(T)/norm(one(T))))
     svdvals!(copy_oftype(A, S))
 end
 svdvals(x::Number) = abs(x)
-svdvals{T}(S::SVD{<:Any,T}) = (S[:S])::Vector{T}
+svdvals(S::SVD{<:Any,T}) where {T} = (S[:S])::Vector{T}
 
 # SVD least squares
-function A_ldiv_B!{T}(A::SVD{T}, B::StridedVecOrMat)
+function A_ldiv_B!(A::SVD{T}, B::StridedVecOrMat) where T
     k = searchsortedlast(A.S, eps(real(T))*A.S[1], rev=true)
     view(A.Vt,1:k,:)' * (view(A.S,1:k) .\ (view(A.U,:,1:k)' * B))
 end
@@ -195,7 +191,7 @@ end
 `svdfact!` is the same as [`svdfact`](@ref), but modifies the arguments
 `A` and `B` in-place, instead of making copies.
 """
-function svdfact!{T<:BlasFloat}(A::StridedMatrix{T}, B::StridedMatrix{T})
+function svdfact!(A::StridedMatrix{T}, B::StridedMatrix{T}) where T<:BlasFloat
     # xggsvd3 replaced xggsvd in LAPACK 3.6.0
     if LAPACK.laver() < (3, 6, 0)
         U, V, Q, a, b, k, l, R = LAPACK.ggsvd!('U', 'V', 'Q', A, B)
@@ -204,7 +200,7 @@ function svdfact!{T<:BlasFloat}(A::StridedMatrix{T}, B::StridedMatrix{T})
     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::StridedMatrix{T}, B::StridedMatrix{T}) where {T<:BlasFloat} = svdfact!(copy(A),copy(B))
 
 """
     svdfact(A, B) -> GeneralizedSVD
@@ -230,10 +226,14 @@ documentation for 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})
+function svdfact(A::StridedMatrix{TA}, B::StridedMatrix{TB}) where {TA,TB}
     S = promote_type(Float32, typeof(one(TA)/norm(one(TA))),TB)
     return svdfact!(copy_oftype(A, S), copy_oftype(B, S))
 end
+# This method can be heavily optimized but it is probably not critical
+# and might introduce bugs or inconsistencies relative to the 1x1 matrix
+# version
+svdfact(x::Number, y::Number) = svdfact(fill(x, 1, 1), fill(y, 1, 1))
 
 """
     svd(A, B) -> U, V, Q, D1, D2, R0
@@ -248,8 +248,9 @@ function svd(A::AbstractMatrix, B::AbstractMatrix)
     F = svdfact(A, B)
     F[:U], F[:V], F[:Q], F[:D1], F[:D2], F[:R0]
 end
+svd(x::Number, y::Number) = first.(svd(fill(x, 1, 1), fill(y, 1, 1)))
 
-function getindex{T}(obj::GeneralizedSVD{T}, d::Symbol)
+function getindex(obj::GeneralizedSVD{T}, d::Symbol) where T
     if d == :U
         return obj.U
     elseif d == :V
@@ -287,7 +288,7 @@ function getindex{T}(obj::GeneralizedSVD{T}, d::Symbol)
     end
 end
 
-function svdvals!{T<:BlasFloat}(A::StridedMatrix{T}, B::StridedMatrix{T})
+function svdvals!(A::StridedMatrix{T}, B::StridedMatrix{T}) where T<:BlasFloat
     # xggsvd3 replaced xggsvd in LAPACK 3.6.0
     if LAPACK.laver() < (3, 6, 0)
         _, _, _, a, b, k, l, _ = LAPACK.ggsvd!('N', 'N', 'N', A, B)
@@ -296,7 +297,7 @@ function svdvals!{T<:BlasFloat}(A::StridedMatrix{T}, B::StridedMatrix{T})
     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::StridedMatrix{T},B::StridedMatrix{T}) where {T<:BlasFloat} = svdvals!(copy(A),copy(B))
 
 """
     svdvals(A, B)
@@ -304,10 +305,11 @@ svdvals{T<:BlasFloat}(A::StridedMatrix{T},B::StridedMatrix{T}) = svdvals!(copy(A
 Return the generalized singular values from the generalized singular value
 decomposition of `A` and `B`. See also [`svdfact`](@ref).
 """
-function svdvals{TA,TB}(A::StridedMatrix{TA}, B::StridedMatrix{TB})
+function svdvals(A::StridedMatrix{TA}, B::StridedMatrix{TB}) where {TA,TB}
     S = promote_type(Float32, typeof(one(TA)/norm(one(TA))), TB)
     return svdvals!(copy_oftype(A, S), copy_oftype(B, S))
 end
+svdvals(x::Number, y::Number) = abs(x/y)
 
 # Conversion
 convert(::Type{AbstractMatrix}, F::SVD) = (F.U * Diagonal(F.S)) * F.Vt
diff --git a/base/linalg/symmetric.jl b/base/linalg/symmetric.jl
index 4664ad505354a5..b61249425bebd8 100644
--- a/base/linalg/symmetric.jl
+++ b/base/linalg/symmetric.jl
@@ -1,6 +1,6 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
-#Symmetric and Hermitian matrices
+# Symmetric and Hermitian matrices
 struct Symmetric{T,S<:AbstractMatrix} <: AbstractMatrix{T}
     data::S
     uplo::Char
@@ -8,10 +8,10 @@ end
 """
     Symmetric(A, uplo=:U)
 
-Construct a `Symmetric` matrix from the upper (if `uplo = :U`) or lower (if `uplo = :L`) triangle of `A`.
-
-# Example
+Construct a `Symmetric` view of the upper (if `uplo = :U`) or lower (if `uplo = :L`)
+triangle of the matrix `A`.
 
+# Examples
 ```jldoctest
 julia> A = [1 0 2 0 3; 0 4 0 5 0; 6 0 7 0 8; 0 9 0 1 0; 2 0 3 0 4]
 5×5 Array{Int64,2}:
@@ -40,7 +40,8 @@ julia> Slower = Symmetric(A, :L)
 
 Note that `Supper` will not be equal to `Slower` unless `A` is itself symmetric (e.g. if `A == A.'`).
 """
-Symmetric(A::AbstractMatrix, uplo::Symbol=:U) = (checksquare(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)))
+
 struct Hermitian{T,S<:AbstractMatrix} <: AbstractMatrix{T}
     data::S
     uplo::Char
@@ -48,10 +49,10 @@ end
 """
     Hermitian(A, uplo=:U)
 
-Construct a `Hermitian` matrix from the upper (if `uplo = :U`) or lower (if `uplo = :L`) triangle of `A`.
-
-# Example
+Construct a `Hermitian` view of the upper (if `uplo = :U`) or lower (if `uplo = :L`)
+triangle of the matrix `A`.
 
+# Examples
 ```jldoctest
 julia> A = [1 0 2+2im 0 3-3im; 0 4 0 5 0; 6-6im 0 7 0 8+8im; 0 9 0 1 0; 2+2im 0 3-3im 0 4];
 
@@ -83,8 +84,30 @@ function Hermitian(A::AbstractMatrix, uplo::Symbol=:U)
     Hermitian{eltype(A),typeof(A)}(A, char_uplo(uplo))
 end
 
-HermOrSym{T,S} = Union{Hermitian{T,S}, Symmetric{T,S}}
-RealHermSymComplexHerm{T<:Real,S} = Union{Hermitian{T,S}, Symmetric{T,S}, Hermitian{Complex{T},S}}
+for (S, H) in ((:Symmetric, :Hermitian), (:Hermitian, :Symmetric))
+    @eval begin
+        $S(A::$S) = A
+        function $S(A::$S, uplo::Symbol)
+            if A.uplo == char_uplo(uplo)
+                return A
+            else
+                throw(ArgumentError("Cannot construct $($S); uplo doesn't match"))
+            end
+        end
+        $S(A::$H) = $S(A.data, Symbol(A.uplo))
+        function $S(A::$H, uplo::Symbol)
+            if A.uplo == char_uplo(uplo)
+                return $S(A.data, Symbol(A.uplo))
+            else
+                throw(ArgumentError("Cannot construct $($S); uplo doesn't match"))
+            end
+        end
+    end
+end
+
+const HermOrSym{T,S} = Union{Hermitian{T,S}, Symmetric{T,S}}
+const RealHermSymComplexHerm{T<:Real,S} = Union{Hermitian{T,S}, Symmetric{T,S}, Hermitian{Complex{T},S}}
+const RealHermSymComplexSym{T<:Real,S} = Union{Hermitian{T,S}, Symmetric{T,S}, Symmetric{Complex{T},S}}
 
 size(A::HermOrSym, d) = size(A.data, d)
 size(A::HermOrSym) = size(A.data)
@@ -114,10 +137,10 @@ function setindex!(A::Hermitian, v, i::Integer, j::Integer)
     end
 end
 
-similar{T}(A::Symmetric, ::Type{T}) = Symmetric(similar(A.data, T))
+similar(A::Symmetric, ::Type{T}) where {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})
+function similar(A::Hermitian, ::Type{T}) where T
     B = similar(A.data, T)
     for i = 1:size(A,1)
         B[i,i] = 0
@@ -131,15 +154,15 @@ convert(::Type{Matrix}, A::Hermitian) = copytri!(convert(Matrix, copy(A.data)),
 convert(::Type{Array}, A::Union{Symmetric,Hermitian}) = convert(Matrix, A)
 full(A::Union{Symmetric,Hermitian}) = convert(Array, A)
 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))
-convert{T,S<:AbstractMatrix}(::Type{Hermitian{T,S}},A::Hermitian{T,S}) = A
-convert{T,S<:AbstractMatrix}(::Type{Hermitian{T,S}},A::Hermitian) = Hermitian{T,S}(convert(S,A.data),A.uplo)
-convert{T}(::Type{AbstractMatrix{T}}, A::Hermitian) = Hermitian(convert(AbstractMatrix{T}, A.data), Symbol(A.uplo))
+convert(::Type{Symmetric{T,S}},A::Symmetric{T,S}) where {T,S<:AbstractMatrix} = A
+convert(::Type{Symmetric{T,S}},A::Symmetric) where {T,S<:AbstractMatrix} = Symmetric{T,S}(convert(S,A.data),A.uplo)
+convert(::Type{AbstractMatrix{T}}, A::Symmetric) where {T} = Symmetric(convert(AbstractMatrix{T}, A.data), Symbol(A.uplo))
+convert(::Type{Hermitian{T,S}},A::Hermitian{T,S}) where {T,S<:AbstractMatrix} = A
+convert(::Type{Hermitian{T,S}},A::Hermitian) where {T,S<:AbstractMatrix} = Hermitian{T,S}(convert(S,A.data),A.uplo)
+convert(::Type{AbstractMatrix{T}}, A::Hermitian) where {T} = Hermitian(convert(AbstractMatrix{T}, A.data), Symbol(A.uplo))
 
-copy{T,S}(A::Symmetric{T,S}) = (B = copy(A.data); Symmetric{T,typeof(B)}(B,A.uplo))
-copy{T,S}(A::Hermitian{T,S}) = (B = copy(A.data); Hermitian{T,typeof(B)}(B,A.uplo))
+copy(A::Symmetric{T,S}) where {T,S} = (B = copy(A.data); Symmetric{T,typeof(B)}(B,A.uplo))
+copy(A::Hermitian{T,S}) where {T,S} = (B = copy(A.data); Hermitian{T,typeof(B)}(B,A.uplo))
 
 function copy!(dest::Symmetric, src::Symmetric)
     if src.uplo == dest.uplo
@@ -159,13 +182,36 @@ function copy!(dest::Hermitian, src::Hermitian)
     return dest
 end
 
+function Base.isreal(A::HermOrSym)
+    n = size(A, 1)
+    @inbounds if A.uplo == 'U'
+        for j in 1:n
+            for i in 1:(j - (A isa Hermitian))
+                if !isreal(A.data[i,j])
+                    return false
+                end
+            end
+        end
+    else
+        for j in 1:n
+            for i in (j + (A isa Hermitian)):n
+                if !isreal(A.data[i,j])
+                    return false
+                end
+            end
+        end
+    end
+    return true
+end
+
 ishermitian(A::Hermitian) = true
 ishermitian(A::Symmetric{<:Real}) = true
-ishermitian(A::Symmetric{<:Complex}) = isreal(A.data)
+ishermitian(A::Symmetric{<:Complex}) = isreal(A)
 issymmetric(A::Hermitian{<:Real}) = true
-issymmetric(A::Hermitian{<:Complex}) = isreal(A.data)
+issymmetric(A::Hermitian{<:Complex}) = isreal(A)
 issymmetric(A::Symmetric) = true
 transpose(A::Symmetric) = A
+transpose(A::Hermitian{<:Real}) = A
 ctranspose(A::Symmetric{<:Real}) = A
 function ctranspose(A::Symmetric)
     AC = ctranspose(A.data)
@@ -181,7 +227,7 @@ trace(A::Hermitian) = real(trace(A.data))
 Base.conj(A::HermOrSym) = typeof(A)(conj(A.data), A.uplo)
 Base.conj!(A::HermOrSym) = typeof(A)(conj!(A.data), A.uplo)
 
-#tril/triu
+# tril/triu
 function tril(A::Hermitian, k::Integer=0)
     if A.uplo == 'U' && k <= 0
         return tril!(A.data',k)
@@ -230,19 +276,50 @@ function triu(A::Symmetric, k::Integer=0)
     end
 end
 
--{Tv,S<:AbstractMatrix}(A::Symmetric{Tv,S}) = Symmetric{Tv,S}(-A.data, A.uplo)
+(-)(A::Symmetric{Tv,S}) where {Tv,S} = Symmetric{Tv,S}(-A.data, A.uplo)
+(-)(A::Hermitian{Tv,S}) where {Tv,S} = Hermitian{Tv,S}(-A.data, A.uplo)
 
 ## Matvec
-A_mul_B!{T<:BlasFloat}(y::StridedVector{T}, A::Symmetric{T,<:StridedMatrix}, x::StridedVector{T}) = BLAS.symv!(A.uplo, one(T), A.data, x, zero(T), y)
-A_mul_B!{T<:BlasComplex}(y::StridedVector{T}, A::Hermitian{T,<:StridedMatrix}, x::StridedVector{T}) = BLAS.hemv!(A.uplo, one(T), A.data, x, zero(T), y)
-##Matmat
-A_mul_B!{T<:BlasFloat}(C::StridedMatrix{T}, A::Symmetric{T,<:StridedMatrix}, B::StridedMatrix{T}) = BLAS.symm!('L', A.uplo, one(T), A.data, B, zero(T), C)
-A_mul_B!{T<:BlasFloat}(C::StridedMatrix{T}, A::StridedMatrix{T}, B::Symmetric{T,<:StridedMatrix}) = BLAS.symm!('R', B.uplo, one(T), B.data, A, zero(T), C)
-A_mul_B!{T<:BlasComplex}(C::StridedMatrix{T}, A::Hermitian{T,<:StridedMatrix}, B::StridedMatrix{T}) = BLAS.hemm!('L', A.uplo, one(T), A.data, B, zero(T), C)
-A_mul_B!{T<:BlasComplex}(C::StridedMatrix{T}, A::StridedMatrix{T}, B::Hermitian{T,<:StridedMatrix}) = BLAS.hemm!('R', B.uplo, one(T), B.data, A, zero(T), C)
-
-*(A::HermOrSym, B::HermOrSym) = full(A)*full(B)
-*(A::StridedMatrix, B::HermOrSym) = A*full(B)
+A_mul_B!(y::StridedVector{T}, A::Symmetric{T,<:StridedMatrix}, x::StridedVector{T}) where {T<:BlasFloat} =
+    BLAS.symv!(A.uplo, one(T), A.data, x, zero(T), y)
+A_mul_B!(y::StridedVector{T}, A::Hermitian{T,<:StridedMatrix}, x::StridedVector{T}) where {T<:BlasReal} =
+    BLAS.symv!(A.uplo, one(T), A.data, x, zero(T), y)
+A_mul_B!(y::StridedVector{T}, A::Hermitian{T,<:StridedMatrix}, x::StridedVector{T}) where {T<:BlasComplex} =
+    BLAS.hemv!(A.uplo, one(T), A.data, x, zero(T), y)
+## Matmat
+A_mul_B!(C::StridedMatrix{T}, A::Symmetric{T,<:StridedMatrix}, B::StridedMatrix{T}) where {T<:BlasFloat} =
+    BLAS.symm!('L', A.uplo, one(T), A.data, B, zero(T), C)
+A_mul_B!(C::StridedMatrix{T}, A::StridedMatrix{T}, B::Symmetric{T,<:StridedMatrix}) where {T<:BlasFloat} =
+    BLAS.symm!('R', B.uplo, one(T), B.data, A, zero(T), C)
+A_mul_B!(C::StridedMatrix{T}, A::Hermitian{T,<:StridedMatrix}, B::StridedMatrix{T}) where {T<:BlasReal} =
+    BLAS.symm!('L', A.uplo, one(T), A.data, B, zero(T), C)
+A_mul_B!(C::StridedMatrix{T}, A::StridedMatrix{T}, B::Hermitian{T,<:StridedMatrix}) where {T<:BlasReal} =
+    BLAS.symm!('R', B.uplo, one(T), B.data, A, zero(T), C)
+A_mul_B!(C::StridedMatrix{T}, A::Hermitian{T,<:StridedMatrix}, B::StridedMatrix{T}) where {T<:BlasComplex} =
+    BLAS.hemm!('L', A.uplo, one(T), A.data, B, zero(T), C)
+A_mul_B!(C::StridedMatrix{T}, A::StridedMatrix{T}, B::Hermitian{T,<:StridedMatrix}) where {T<:BlasComplex} =
+    BLAS.hemm!('R', B.uplo, one(T), B.data, A, zero(T), C)
+
+*(A::HermOrSym, B::HermOrSym) = A*full(B)
+
+# Fallbacks to avoid generic_matvecmul!/generic_matmatmul!
+## Symmetric{<:Number} and Hermitian{<:Real} are invariant to transpose; peel off the t
+At_mul_B(A::RealHermSymComplexSym, B::AbstractVector) = A*B
+At_mul_B(A::RealHermSymComplexSym, B::AbstractMatrix) = A*B
+A_mul_Bt(A::AbstractMatrix, B::RealHermSymComplexSym) = A*B
+## Hermitian{<:Number} and Symmetric{<:Real} are invariant to ctranspose; peel off the c
+Ac_mul_B(A::RealHermSymComplexHerm, B::AbstractVector) = A*B
+Ac_mul_B(A::RealHermSymComplexHerm, B::AbstractMatrix) = A*B
+A_mul_Bc(A::AbstractMatrix, B::RealHermSymComplexHerm) = A*B
+
+# ambiguities with RowVector
+A_mul_Bt(A::RowVector, B::RealHermSymComplexSym) = A*B
+A_mul_Bc(A::RowVector, B::RealHermSymComplexHerm) = A*B
+# ambiguities with AbstractTriangular
+At_mul_B(A::RealHermSymComplexSym, B::AbstractTriangular) = A*B
+A_mul_Bt(A::AbstractTriangular, B::RealHermSymComplexSym) = A*B
+Ac_mul_B(A::RealHermSymComplexHerm, B::AbstractTriangular) = A*B
+A_mul_Bc(A::AbstractTriangular, B::RealHermSymComplexHerm) = A*B
 
 for T in (:Symmetric, :Hermitian), op in (:+, :-, :*, :/)
     # Deal with an ambiguous case
@@ -251,25 +328,54 @@ for T in (:Symmetric, :Hermitian), op in (:+, :-, :*, :/)
     @eval ($op)(A::$T, x::$S) = ($T)(($op)(A.data, x), Symbol(A.uplo))
 end
 
-bkfact(A::HermOrSym) = bkfact(A.data, Symbol(A.uplo), issymmetric(A))
-factorize(A::HermOrSym) = bkfact(A)
+function factorize(A::HermOrSym{T}) where T
+    TT = typeof(sqrt(one(T)))
+    if TT <: BlasFloat
+        return bkfact(A)
+    else # fallback
+        return lufact(A)
+    end
+end
 
-# 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(A::Symmetric{<:Real}) = det(bkfact(A))
-det(A::Symmetric) = det(bkfact(A))
+det(A::RealHermSymComplexHerm) = real(det(factorize(A)))
+det(A::Symmetric{<:Real}) = det(factorize(A))
+det(A::Symmetric) = det(factorize(A))
 
-\(A::HermOrSym{<:Any,<:StridedMatrix}, B::StridedVecOrMat) = \(bkfact(A.data, Symbol(A.uplo), issymmetric(A)), B)
+\(A::HermOrSym{<:Any,<:StridedMatrix}, B::AbstractVector) = \(factorize(A), B)
+# Bunch-Kaufman solves can not utilize BLAS-3 for multiple right hand sides
+# so using LU is faster for AbstractMatrix right hand side
+\(A::HermOrSym{<:Any,<:StridedMatrix}, B::AbstractMatrix) = \(lufact(A), B)
+# ambiguity with RowVector
+\(A::HermOrSym{<:Any,<:StridedMatrix}, B::RowVector) = invoke(\, Tuple{AbstractMatrix, RowVector}, A, B)
 
-inv{T<:BlasFloat,S<:StridedMatrix}(A::Hermitian{T,S}) = Hermitian{T,S}(inv(bkfact(A)), A.uplo)
-inv{T<:BlasFloat,S<:StridedMatrix}(A::Symmetric{T,S}) = Symmetric{T,S}(inv(bkfact(A)), A.uplo)
+function _inv(A::HermOrSym)
+    n = checksquare(A)
+    B = inv!(lufact(A))
+    conjugate = isa(A, Hermitian)
+    # symmetrize
+    if A.uplo == 'U' # add to upper triangle
+        @inbounds for i = 1:n, j = i:n
+            B[i,j] = conjugate ? (B[i,j] + conj(B[j,i])) / 2 : (B[i,j] + B[j,i]) / 2
+        end
+    else # A.uplo == 'L', add to lower triangle
+        @inbounds for i = 1:n, j = i:n
+            B[j,i] = conjugate ? (B[j,i] + conj(B[i,j])) / 2 : (B[j,i] + B[i,j]) / 2
+        end
+    end
+    B
+end
+inv(A::Hermitian{T,S}) where {T<:BlasFloat,S<:StridedMatrix} = Hermitian{T,S}(_inv(A), A.uplo)
+inv(A::Symmetric{T,S}) where {T<:BlasFloat,S<:StridedMatrix} = Symmetric{T,S}(_inv(A), A.uplo)
 
 eigfact!(A::RealHermSymComplexHerm{<:BlasReal,<:StridedMatrix}) = Eigen(LAPACK.syevr!('V', 'A', A.uplo, A.data, 0.0, 0.0, 0, 0, -1.0)...)
-# Because of #6721 it is necessary to specify the parameters explicitly here.
-eigfact(A::RealHermSymComplexHerm{<:Real}) = (T = eltype(A); S = promote_type(Float32, typeof(zero(T)/norm(one(T)))); eigfact!(S != T ? convert(AbstractMatrix{S}, A) : copy(A)))
+
+function eigfact(A::RealHermSymComplexHerm)
+    T = eltype(A)
+    S = promote_type(Float32, typeof(zero(T)/norm(one(T))))
+    eigfact!(S != T ? convert(AbstractMatrix{S}, A) : copy(A))
+end
 
 eigfact!(A::RealHermSymComplexHerm{<:BlasReal,<:StridedMatrix}, irange::UnitRange) = Eigen(LAPACK.syevr!('V', 'I', A.uplo, A.data, 0.0, 0.0, irange.start, irange.stop, -1.0)...)
-# Because of #6721 it is necessary to specify the parameters explicitly here.
 
 """
     eigfact(A::Union{SymTridiagonal, Hermitian, Symmetric}, irange::UnitRange) -> Eigen
@@ -286,10 +392,15 @@ The `UnitRange` `irange` specifies indices of the sorted eigenvalues to search f
     If `irange` is not `1:n`, where `n` is the dimension of `A`, then the returned factorization
     will be a *truncated* factorization.
 """
-eigfact(A::RealHermSymComplexHerm{<:Real}, irange::UnitRange) = (T = eltype(A); S = promote_type(Float32, typeof(zero(T)/norm(one(T)))); eigfact!(S != T ? convert(AbstractMatrix{S}, A) : copy(A), irange))
+function eigfact(A::RealHermSymComplexHerm, irange::UnitRange)
+    T = eltype(A)
+    S = promote_type(Float32, typeof(zero(T)/norm(one(T))))
+    eigfact!(S != T ? convert(AbstractMatrix{S}, A) : copy(A), irange)
+end
+
+eigfact!(A::RealHermSymComplexHerm{T,<:StridedMatrix}, vl::Real, vh::Real) where {T<:BlasReal} =
+    Eigen(LAPACK.syevr!('V', 'V', A.uplo, A.data, convert(T, vl), convert(T, vh), 0, 0, -1.0)...)
 
-eigfact!{T<:BlasReal}(A::RealHermSymComplexHerm{T,<:StridedMatrix}, vl::Real, vh::Real) = Eigen(LAPACK.syevr!('V', 'V', A.uplo, A.data, convert(T, vl), convert(T, vh), 0, 0, -1.0)...)
-# Because of #6721 it is necessary to specify the parameters explicitly here.
 """
     eigfact(A::Union{SymTridiagonal, Hermitian, Symmetric}, vl::Real, vu::Real) -> Eigen
 
@@ -305,11 +416,20 @@ The following functions are available for `Eigen` objects: [`inv`](@ref), [`det`
     If [`vl`, `vu`] does not contain all eigenvalues of `A`, then the returned factorization
     will be a *truncated* factorization.
 """
-eigfact(A::RealHermSymComplexHerm{<:Real}, 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 eigfact(A::RealHermSymComplexHerm, 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)
+end
 
-eigvals!(A::RealHermSymComplexHerm{<:BlasReal,<:StridedMatrix}) = 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(A::RealHermSymComplexHerm{<:Real}) = (T = eltype(A); S = promote_type(Float32, typeof(zero(T)/norm(one(T)))); eigvals!(S != T ? convert(AbstractMatrix{S}, A) : copy(A)))
+eigvals!(A::RealHermSymComplexHerm{<:BlasReal,<:StridedMatrix}) =
+    LAPACK.syevr!('N', 'A', A.uplo, A.data, 0.0, 0.0, 0, 0, -1.0)[1]
+
+function eigvals(A::RealHermSymComplexHerm)
+    T = eltype(A)
+    S = promote_type(Float32, typeof(zero(T)/norm(one(T))))
+    eigvals!(S != T ? convert(AbstractMatrix{S}, A) : copy(A))
+end
 
 """
     eigvals!(A::Union{SymTridiagonal, Hermitian, Symmetric}, irange::UnitRange) -> values
@@ -317,8 +437,9 @@ eigvals(A::RealHermSymComplexHerm{<:Real}) = (T = eltype(A); S = promote_type(Fl
 Same as [`eigvals`](@ref), but saves space by overwriting the input `A`, instead of creating a copy.
 `irange` is a range of eigenvalue *indices* to search for - for instance, the 2nd to 8th eigenvalues.
 """
-eigvals!(A::RealHermSymComplexHerm{<:BlasReal,<:StridedMatrix}, irange::UnitRange) = LAPACK.syevr!('N', 'I', A.uplo, A.data, 0.0, 0.0, irange.start, irange.stop, -1.0)[1]
-# Because of #6721 it is necessary to specify the parameters explicitly here.
+eigvals!(A::RealHermSymComplexHerm{<:BlasReal,<:StridedMatrix}, irange::UnitRange) =
+    LAPACK.syevr!('N', 'I', A.uplo, A.data, 0.0, 0.0, irange.start, irange.stop, -1.0)[1]
+
 """
     eigvals(A::Union{SymTridiagonal, Hermitian, Symmetric}, irange::UnitRange) -> values
 
@@ -344,7 +465,11 @@ julia> eigvals(A)
   5.14005
 ```
 """
-eigvals(A::RealHermSymComplexHerm{<:Real}, irange::UnitRange) = (T = eltype(A); S = promote_type(Float32, typeof(zero(T)/norm(one(T)))); eigvals!(S != T ? convert(AbstractMatrix{S}, A) : copy(A), irange))
+function eigvals(A::RealHermSymComplexHerm, irange::UnitRange)
+    T = eltype(A)
+    S = promote_type(Float32, typeof(zero(T)/norm(one(T))))
+    eigvals!(S != T ? convert(AbstractMatrix{S}, A) : copy(A), irange)
+end
 
 """
     eigvals!(A::Union{SymTridiagonal, Hermitian, Symmetric}, vl::Real, vu::Real) -> values
@@ -352,8 +477,9 @@ eigvals(A::RealHermSymComplexHerm{<:Real}, irange::UnitRange) = (T = eltype(A);
 Same as [`eigvals`](@ref), but saves space by overwriting the input `A`, instead of creating a copy.
 `vl` is the lower bound of the interval to search for eigenvalues, and `vu` is the upper bound.
 """
-eigvals!{T<:BlasReal}(A::RealHermSymComplexHerm{T,<:StridedMatrix}, vl::Real, vh::Real) = LAPACK.syevr!('N', 'V', A.uplo, A.data, convert(T, vl), convert(T, vh), 0, 0, -1.0)[1]
-# Because of #6721 it is necessary to specify the parameters explicitly here.
+eigvals!(A::RealHermSymComplexHerm{T,<:StridedMatrix}, vl::Real, vh::Real) where {T<:BlasReal} =
+    LAPACK.syevr!('N', 'V', A.uplo, A.data, convert(T, vl), convert(T, vh), 0, 0, -1.0)[1]
+
 """
     eigvals(A::Union{SymTridiagonal, Hermitian, Symmetric}, vl::Real, vu::Real) -> values
 
@@ -378,24 +504,32 @@ julia> eigvals(A)
   5.14005
 ```
 """
-eigvals(A::RealHermSymComplexHerm{<:Real}, vl::Real, vh::Real) = (T = eltype(A); S = promote_type(Float32, typeof(zero(T)/norm(one(T)))); eigvals!(S != T ? convert(AbstractMatrix{S}, A) : copy(A), vl, vh))
+function eigvals(A::RealHermSymComplexHerm, vl::Real, vh::Real)
+    T = eltype(A)
+    S = promote_type(Float32, typeof(zero(T)/norm(one(T))))
+    eigvals!(S != T ? convert(AbstractMatrix{S}, A) : copy(A), vl, vh)
+end
 
 eigmax(A::RealHermSymComplexHerm{<:Real,<:StridedMatrix}) = eigvals(A, size(A, 1):size(A, 1))[1]
 eigmin(A::RealHermSymComplexHerm{<:Real,<:StridedMatrix}) = eigvals(A, 1:1)[1]
 
-function eigfact!{T<:BlasReal,S<:StridedMatrix}(A::HermOrSym{T,S}, B::HermOrSym{T,S})
+function eigfact!(A::HermOrSym{T,S}, B::HermOrSym{T,S}) where {T<:BlasReal,S<:StridedMatrix}
     vals, vecs, _ = LAPACK.sygvd!(1, 'V', A.uplo, A.data, B.uplo == A.uplo ? B.data : B.data')
     GeneralizedEigen(vals, vecs)
 end
-function eigfact!{T<:BlasComplex,S<:StridedMatrix}(A::Hermitian{T,S}, B::Hermitian{T,S})
+function eigfact!(A::Hermitian{T,S}, B::Hermitian{T,S}) where {T<:BlasComplex,S<:StridedMatrix}
     vals, vecs, _ = LAPACK.sygvd!(1, 'V', A.uplo, A.data, B.uplo == A.uplo ? B.data : B.data')
     GeneralizedEigen(vals, vecs)
 end
 
-eigvals!{T<:BlasReal,S<:StridedMatrix}(A::HermOrSym{T,S}, B::HermOrSym{T,S}) = LAPACK.sygvd!(1, 'N', A.uplo, A.data, B.uplo == A.uplo ? B.data : B.data')[1]
-eigvals!{T<:BlasComplex,S<:StridedMatrix}(A::Hermitian{T,S}, B::Hermitian{T,S}) = LAPACK.sygvd!(1, 'N', A.uplo, A.data, B.uplo == A.uplo ? B.data : B.data')[1]
+eigvals!(A::HermOrSym{T,S}, B::HermOrSym{T,S}) where {T<:BlasReal,S<:StridedMatrix} =
+    LAPACK.sygvd!(1, 'N', A.uplo, A.data, B.uplo == A.uplo ? B.data : B.data')[1]
+eigvals!(A::Hermitian{T,S}, B::Hermitian{T,S}) where {T<:BlasComplex,S<:StridedMatrix} =
+    LAPACK.sygvd!(1, 'N', A.uplo, A.data, B.uplo == A.uplo ? B.data : B.data')[1]
+
+eigvecs(A::HermOrSym) = eigvecs(eigfact(A))
 
-function svdvals!{T<:Real,S}(A::Union{Hermitian{T,S}, Symmetric{T,S}, Hermitian{Complex{T},S}}) #  the union is the same as RealHermSymComplexHerm, but right now parametric typealiases are broken
+function svdvals!(A::RealHermSymComplexHerm)
     vals = eigvals!(A)
     for i = 1:length(vals)
         vals[i] = abs(vals[i])
@@ -403,12 +537,63 @@ function svdvals!{T<:Real,S}(A::Union{Hermitian{T,S}, Symmetric{T,S}, Hermitian{
     return sort!(vals, rev = true)
 end
 
-#Matrix-valued functions
+# Matrix functions
+^(A::Symmetric{<:Real}, p::Integer) = sympow(A, p)
+^(A::Symmetric{<:Complex}, p::Integer) = sympow(A, p)
+function sympow(A::Symmetric, p::Integer)
+    if p < 0
+        return Symmetric(Base.power_by_squaring(inv(A), -p))
+    else
+        return Symmetric(Base.power_by_squaring(A, p))
+    end
+end
+function ^(A::Symmetric{<:Real}, p::Real)
+    isinteger(p) && return integerpow(A, p)
+    F = eigfact(A)
+    if all(λ -> λ ≥ 0, F.values)
+        return Symmetric((F.vectors * Diagonal((F.values).^p)) * F.vectors')
+    else
+        return Symmetric((F.vectors * Diagonal((complex(F.values)).^p)) * F.vectors')
+    end
+end
+function ^(A::Symmetric{<:Complex}, p::Real)
+    isinteger(p) && return integerpow(A, p)
+    return Symmetric(schurpow(A, p))
+end
+function ^(A::Hermitian, p::Integer)
+    if p < 0
+        retmat = Base.power_by_squaring(inv(A), -p)
+    else
+        retmat = Base.power_by_squaring(A, p)
+    end
+    for i = 1:size(A,1)
+        retmat[i,i] = real(retmat[i,i])
+    end
+    return Hermitian(retmat)
+end
+function ^(A::Hermitian{T}, p::Real) where T
+    isinteger(p) && return integerpow(A, p)
+    F = eigfact(A)
+    if all(λ -> λ ≥ 0, F.values)
+        retmat = (F.vectors * Diagonal((F.values).^p)) * F.vectors'
+        if T <: Real
+            return Hermitian(retmat)
+        else
+            for i = 1:size(A,1)
+                retmat[i,i] = real(retmat[i,i])
+            end
+            return Hermitian(retmat)
+        end
+    else
+        return (F.vectors * Diagonal((complex(F.values).^p))) * F.vectors'
+    end
+end
+
 function expm(A::Symmetric)
     F = eigfact(A)
     return Symmetric((F.vectors * Diagonal(exp.(F.values))) * F.vectors')
 end
-function expm{T}(A::Hermitian{T})
+function expm(A::Hermitian{T}) where T
     n = checksquare(A)
     F = eigfact(A)
     retmat = (F.vectors * Diagonal(exp.(F.values))) * F.vectors'
@@ -423,12 +608,10 @@ function expm{T}(A::Hermitian{T})
 end
 
 for (funm, func) in ([:logm,:log], [:sqrtm,:sqrt])
-
     @eval begin
-
-        function ($funm)(A::Symmetric)
+        function ($funm)(A::Symmetric{T}) where T<:Real
             F = eigfact(A)
-            if isposdef(F)
+            if all(λ -> λ ≥ 0, F.values)
                 retmat = (F.vectors * Diagonal(($func).(F.values))) * F.vectors'
             else
                 retmat = (F.vectors * Diagonal(($func).(complex.(F.values)))) * F.vectors'
@@ -436,10 +619,10 @@ for (funm, func) in ([:logm,:log], [:sqrtm,:sqrt])
             return Symmetric(retmat)
         end
 
-        function ($funm){T}(A::Hermitian{T})
+        function ($funm)(A::Hermitian{T}) where T
             n = checksquare(A)
             F = eigfact(A)
-            if isposdef(F)
+            if all(λ -> λ ≥ 0, F.values)
                 retmat = (F.vectors * Diagonal(($func).(F.values))) * F.vectors'
                 if T <: Real
                     return Hermitian(retmat)
@@ -454,7 +637,5 @@ for (funm, func) in ([:logm,:log], [:sqrtm,:sqrt])
                 return retmat
             end
         end
-
     end
-
 end
diff --git a/base/linalg/transpose.jl b/base/linalg/transpose.jl
index d15c54dab8dc6f..c19730f9f58fce 100644
--- a/base/linalg/transpose.jl
+++ b/base/linalg/transpose.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ctranspose(a::AbstractArray) = error("ctranspose not defined for $(typeof(a)). Consider using `permutedims` for higher-dimensional arrays.")
 transpose(a::AbstractArray) = error("transpose not defined for $(typeof(a)). Consider using `permutedims` for higher-dimensional arrays.")
@@ -42,7 +42,7 @@ function ctranspose!(B::AbstractMatrix, A::AbstractVector)
 end
 
 const transposebaselength=64
-function transpose_f!(f,B::AbstractMatrix,A::AbstractMatrix)
+function transpose_f!(f, B::AbstractMatrix, A::AbstractMatrix)
     inds = indices(A)
     indices(B,1) == inds[2] && indices(B,2) == inds[1] || throw(DimensionMismatch(string(f)))
 
@@ -60,7 +60,7 @@ function transpose_f!(f,B::AbstractMatrix,A::AbstractMatrix)
     end
     return B
 end
-function transposeblock!(f,B::AbstractMatrix,A::AbstractMatrix,m::Int,n::Int,offseti::Int,offsetj::Int)
+function transposeblock!(f, B::AbstractMatrix, A::AbstractMatrix, m::Int, n::Int, offseti::Int, offsetj::Int)
     if m*n<=transposebaselength
         @inbounds begin
             for j = offsetj+(1:n)
@@ -99,8 +99,7 @@ end
 
 The transposition operator (`.'`).
 
-# Example
-
+# Examples
 ```jldoctest
 julia> A = [1 2 3; 4 5 6; 7 8 9]
 3×3 Array{Int64,2}:
diff --git a/base/linalg/triangular.jl b/base/linalg/triangular.jl
index 79c0d426bb226d..79ba4820a7fb19 100644
--- a/base/linalg/triangular.jl
+++ b/base/linalg/triangular.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## Triangular
 
@@ -21,16 +21,16 @@ for t in (:LowerTriangular, :UnitLowerTriangular, :UpperTriangular,
         size(A::$t, d) = size(A.data, d)
         size(A::$t) = size(A.data)
 
-        convert{T}(::Type{$t{T}}, A::$t{T}) = A
-        function convert{T}(::Type{$t{T}}, A::$t)
+        convert(::Type{$t{T}}, A::$t{T}) where {T} = A
+        function convert(::Type{$t{T}}, A::$t) where T
             Anew = convert(AbstractMatrix{T}, A.data)
             $t(Anew)
         end
-        convert{T}(::Type{AbstractMatrix{T}}, A::$t{T}) = A
-        convert{T}(::Type{AbstractMatrix{T}}, A::$t) = convert($t{T}, A)
-        convert{T}(::Type{Matrix}, A::$t{T}) = convert(Matrix{T}, A)
+        convert(::Type{AbstractMatrix{T}}, A::$t{T}) where {T} = A
+        convert(::Type{AbstractMatrix{T}}, A::$t) where {T} = convert($t{T}, A)
+        convert(::Type{Matrix}, A::$t{T}) where {T} = convert(Matrix{T}, A)
 
-        function similar{T}(A::$t, ::Type{T})
+        function similar(A::$t, ::Type{T}) where T
             B = similar(A.data, T)
             return $t(B)
         end
@@ -50,6 +50,49 @@ LowerTriangular(U::UpperTriangular) = throw(ArgumentError(
 UpperTriangular(U::LowerTriangular) = throw(ArgumentError(
     "cannot create an UpperTriangular matrix from a LowerTriangular input"))
 
+"""
+    LowerTriangular(A::AbstractMatrix)
+
+Construct a `LowerTriangular` view of the the matrix `A`.
+
+# Examples
+```jldoctest
+julia> A = [1.0 2.0 3.0; 4.0 5.0 6.0; 7.0 8.0 9.0]
+3×3 Array{Float64,2}:
+ 1.0  2.0  3.0
+ 4.0  5.0  6.0
+ 7.0  8.0  9.0
+
+julia> LowerTriangular(A)
+3×3 LowerTriangular{Float64,Array{Float64,2}}:
+ 1.0   ⋅    ⋅
+ 4.0  5.0   ⋅
+ 7.0  8.0  9.0
+```
+"""
+LowerTriangular
+"""
+    UpperTriangular(A::AbstractMatrix)
+
+Construct an `UpperTriangular` view of the the matrix `A`.
+
+# Examples
+```jldoctest
+julia> A = [1.0 2.0 3.0; 4.0 5.0 6.0; 7.0 8.0 9.0]
+3×3 Array{Float64,2}:
+ 1.0  2.0  3.0
+ 4.0  5.0  6.0
+ 7.0  8.0  9.0
+
+julia> UpperTriangular(A)
+3×3 UpperTriangular{Float64,Array{Float64,2}}:
+ 1.0  2.0  3.0
+  ⋅   5.0  6.0
+  ⋅    ⋅   9.0
+```
+"""
+UpperTriangular
+
 imag(A::UpperTriangular) = UpperTriangular(imag(A.data))
 imag(A::LowerTriangular) = LowerTriangular(imag(A.data))
 imag(A::UnitLowerTriangular) = LowerTriangular(tril!(imag(A.data),-1))
@@ -61,14 +104,14 @@ parent(A::AbstractTriangular) = A.data
 
 # then handle all methods that requires specific handling of upper/lower and unit diagonal
 
-function convert{T}(::Type{Matrix{T}}, A::LowerTriangular)
-    B = Array{T}(size(A, 1), size(A, 1))
+function convert(::Type{Matrix{T}}, A::LowerTriangular) where T
+    B = Matrix{T}(size(A, 1), size(A, 1))
     copy!(B, A.data)
     tril!(B)
     B
 end
-function convert{T}(::Type{Matrix{T}}, A::UnitLowerTriangular)
-    B = Array{T}(size(A, 1), size(A, 1))
+function convert(::Type{Matrix{T}}, A::UnitLowerTriangular) where T
+    B = Matrix{T}(size(A, 1), size(A, 1))
     copy!(B, A.data)
     tril!(B)
     for i = 1:size(B,1)
@@ -76,14 +119,14 @@ function convert{T}(::Type{Matrix{T}}, A::UnitLowerTriangular)
     end
     B
 end
-function convert{T}(::Type{Matrix{T}}, A::UpperTriangular)
-    B = Array{T}(size(A, 1), size(A, 1))
+function convert(::Type{Matrix{T}}, A::UpperTriangular) where T
+    B = Matrix{T}(size(A, 1), size(A, 1))
     copy!(B, A.data)
     triu!(B)
     B
 end
-function convert{T}(::Type{Matrix{T}}, A::UnitUpperTriangular)
-    B = Array{T}(size(A, 1), size(A, 1))
+function convert(::Type{Matrix{T}}, A::UnitUpperTriangular) where T
+    B = Matrix{T}(size(A, 1), size(A, 1))
     copy!(B, A.data)
     triu!(B)
     for i = 1:size(B,1)
@@ -119,11 +162,11 @@ function full!(A::UnitUpperTriangular)
     B
 end
 
-getindex{T}(A::UnitLowerTriangular{T}, i::Integer, j::Integer) =
+getindex(A::UnitLowerTriangular{T}, i::Integer, j::Integer) where {T} =
     i > j ? A.data[i,j] : ifelse(i == j, oneunit(T), zero(T))
 getindex(A::LowerTriangular, i::Integer, j::Integer) =
     i >= j ? A.data[i,j] : zero(A.data[j,i])
-getindex{T}(A::UnitUpperTriangular{T}, i::Integer, j::Integer) =
+getindex(A::UnitUpperTriangular{T}, i::Integer, j::Integer) where {T} =
     i < j ? A.data[i,j] : ifelse(i == j, oneunit(T), zero(T))
 getindex(A::UpperTriangular, i::Integer, j::Integer) =
     i <= j ? A.data[i,j] : zero(A.data[j,i])
@@ -189,7 +232,7 @@ istril(A::UnitLowerTriangular) = true
 istriu(A::UpperTriangular) = true
 istriu(A::UnitUpperTriangular) = true
 
-function tril!(A::UpperTriangular,k::Integer=0)
+function tril!(A::UpperTriangular, k::Integer=0)
     n = size(A,1)
     if abs(k) > n
         throw(ArgumentError("requested diagonal, $k, out of bounds in matrix of size ($n,$n)"))
@@ -205,9 +248,9 @@ function tril!(A::UpperTriangular,k::Integer=0)
         return UpperTriangular(tril!(A.data,k))
     end
 end
-triu!(A::UpperTriangular,k::Integer=0) = UpperTriangular(triu!(A.data,k))
+triu!(A::UpperTriangular, k::Integer=0) = UpperTriangular(triu!(A.data,k))
 
-function tril!{T}(A::UnitUpperTriangular{T},k::Integer=0)
+function tril!(A::UnitUpperTriangular{T}, k::Integer=0) where T
     n = size(A,1)
     if abs(k) > n
         throw(ArgumentError("requested diagonal, $k, out of bounds in matrix of size ($n,$n)"))
@@ -228,14 +271,14 @@ function tril!{T}(A::UnitUpperTriangular{T},k::Integer=0)
     end
 end
 
-function triu!(A::UnitUpperTriangular,k::Integer=0)
+function triu!(A::UnitUpperTriangular, k::Integer=0)
     for i in diagind(A)
         A.data[i] = oneunit(eltype(A))
     end
     return triu!(UpperTriangular(A.data),k)
 end
 
-function triu!(A::LowerTriangular,k::Integer=0)
+function triu!(A::LowerTriangular, k::Integer=0)
     n = size(A,1)
     if abs(k) > n
         throw(ArgumentError("requested diagonal, $k, out of bounds in matrix of size ($n,$n)"))
@@ -252,9 +295,9 @@ function triu!(A::LowerTriangular,k::Integer=0)
     end
 end
 
-tril!(A::LowerTriangular,k::Integer=0) = LowerTriangular(tril!(A.data,k))
+tril!(A::LowerTriangular, k::Integer=0) = LowerTriangular(tril!(A.data,k))
 
-function triu!{T}(A::UnitLowerTriangular{T},k::Integer=0)
+function triu!(A::UnitLowerTriangular{T}, k::Integer=0) where T
     n = size(A,1)
     if abs(k) > n
         throw(ArgumentError("requested diagonal, $k, out of bounds in matrix of size ($n,$n)"))
@@ -275,7 +318,7 @@ function triu!{T}(A::UnitLowerTriangular{T},k::Integer=0)
     end
 end
 
-function tril!(A::UnitLowerTriangular,k::Integer=0)
+function tril!(A::UnitLowerTriangular, k::Integer=0)
     for i in diagind(A)
         A.data[i] = oneunit(eltype(A))
     end
@@ -324,50 +367,50 @@ function -(A::UnitUpperTriangular)
 end
 
 # copy and scale
-function copy!{T<:Union{UpperTriangular, UnitUpperTriangular}}(A::T, B::T)
+function copy!(A::T, B::T) where T<:Union{UpperTriangular,UnitUpperTriangular}
     n = size(B,1)
     for j = 1:n
-        for i = 1:(isa(B, UnitUpperTriangular)?j-1:j)
+        for i = 1:(isa(B, UnitUpperTriangular) ? j-1 : j)
             @inbounds A[i,j] = B[i,j]
         end
     end
     return A
 end
-function copy!{T<:Union{LowerTriangular, UnitLowerTriangular}}(A::T, B::T)
+function copy!(A::T, B::T) where T<:Union{LowerTriangular,UnitLowerTriangular}
     n = size(B,1)
     for j = 1:n
-        for i = (isa(B, UnitLowerTriangular)?j+1:j):n
+        for i = (isa(B, UnitLowerTriangular) ? j+1 : j):n
             @inbounds A[i,j] = B[i,j]
         end
     end
     return A
 end
 
-function scale!(A::UpperTriangular, B::Union{UpperTriangular, UnitUpperTriangular}, c::Number)
+function scale!(A::UpperTriangular, B::Union{UpperTriangular,UnitUpperTriangular}, c::Number)
     n = checksquare(B)
     for j = 1:n
         if isa(B, UnitUpperTriangular)
             @inbounds A[j,j] = c
         end
-        for i = 1:(isa(B, UnitUpperTriangular)?j-1:j)
+        for i = 1:(isa(B, UnitUpperTriangular) ? j-1 : j)
             @inbounds A[i,j] = c * B[i,j]
         end
     end
     return A
 end
-function scale!(A::LowerTriangular, B::Union{LowerTriangular, UnitLowerTriangular}, c::Number)
+function scale!(A::LowerTriangular, B::Union{LowerTriangular,UnitLowerTriangular}, c::Number)
     n = checksquare(B)
     for j = 1:n
         if isa(B, UnitLowerTriangular)
             @inbounds A[j,j] = c
         end
-        for i = (isa(B, UnitLowerTriangular)?j+1:j):n
+        for i = (isa(B, UnitLowerTriangular) ? j+1 : j):n
             @inbounds A[i,j] = c * B[i,j]
         end
     end
     return A
 end
-scale!(A::Union{UpperTriangular,LowerTriangular},c::Number) = scale!(A,A,c)
+scale!(A::Union{UpperTriangular,LowerTriangular}, c::Number) = scale!(A,A,c)
 scale!(c::Number, A::Union{UpperTriangular,LowerTriangular}) = scale!(A,c)
 
 # Binary operations
@@ -411,61 +454,61 @@ for (t, uploc, isunitc) in ((:LowerTriangular, 'L', 'N'),
                             (:UnitUpperTriangular, 'U', 'U'))
     @eval begin
         # Vector multiplication
-        A_mul_B!{T<:BlasFloat}(A::$t{T,<:StridedMatrix}, b::StridedVector{T}) =
+        A_mul_B!(A::$t{T,<:StridedMatrix}, b::StridedVector{T}) where {T<:BlasFloat} =
             BLAS.trmv!($uploc, 'N', $isunitc, A.data, b)
-        At_mul_B!{T<:BlasFloat}(A::$t{T,<:StridedMatrix}, b::StridedVector{T}) =
+        At_mul_B!(A::$t{T,<:StridedMatrix}, b::StridedVector{T}) where {T<:BlasFloat} =
             BLAS.trmv!($uploc, 'T', $isunitc, A.data, b)
-        Ac_mul_B!{T<:BlasReal}(A::$t{T,<:StridedMatrix}, b::StridedVector{T}) =
+        Ac_mul_B!(A::$t{T,<:StridedMatrix}, b::StridedVector{T}) where {T<:BlasReal} =
             BLAS.trmv!($uploc, 'T', $isunitc, A.data, b)
-        Ac_mul_B!{T<:BlasComplex}(A::$t{T,<:StridedMatrix}, b::StridedVector{T}) =
+        Ac_mul_B!(A::$t{T,<:StridedMatrix}, b::StridedVector{T}) where {T<:BlasComplex} =
             BLAS.trmv!($uploc, 'C', $isunitc, A.data, b)
 
         # Matrix multiplication
-        A_mul_B!{T<:BlasFloat}(A::$t{T,<:StridedMatrix}, B::StridedMatrix{T}) =
+        A_mul_B!(A::$t{T,<:StridedMatrix}, B::StridedMatrix{T}) where {T<:BlasFloat} =
             BLAS.trmm!('L', $uploc, 'N', $isunitc, one(T), A.data, B)
-        A_mul_B!{T<:BlasFloat}(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) =
+        A_mul_B!(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) where {T<:BlasFloat} =
             BLAS.trmm!('R', $uploc, 'N', $isunitc, one(T), B.data, A)
 
-        At_mul_B!{T<:BlasFloat}(A::$t{T,<:StridedMatrix}, B::StridedMatrix{T}) =
+        At_mul_B!(A::$t{T,<:StridedMatrix}, B::StridedMatrix{T}) where {T<:BlasFloat} =
             BLAS.trmm!('L', $uploc, 'T', $isunitc, one(T), A.data, B)
-        Ac_mul_B!{T<:BlasComplex}(A::$t{T,<:StridedMatrix}, B::StridedMatrix{T}) =
+        Ac_mul_B!(A::$t{T,<:StridedMatrix}, B::StridedMatrix{T}) where {T<:BlasComplex} =
             BLAS.trmm!('L', $uploc, 'C', $isunitc, one(T), A.data, B)
-        Ac_mul_B!{T<:BlasReal}(A::$t{T,<:StridedMatrix}, B::StridedMatrix{T}) =
+        Ac_mul_B!(A::$t{T,<:StridedMatrix}, B::StridedMatrix{T}) where {T<:BlasReal} =
             BLAS.trmm!('L', $uploc, 'T', $isunitc, one(T), A.data, B)
 
-        A_mul_Bt!{T<:BlasFloat}(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) =
+        A_mul_Bt!(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) where {T<:BlasFloat} =
             BLAS.trmm!('R', $uploc, 'T', $isunitc, one(T), B.data, A)
-        A_mul_Bc!{T<:BlasComplex}(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) =
+        A_mul_Bc!(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) where {T<:BlasComplex} =
             BLAS.trmm!('R', $uploc, 'C', $isunitc, one(T), B.data, A)
-        A_mul_Bc!{T<:BlasReal}(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) =
+        A_mul_Bc!(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) where {T<:BlasReal} =
             BLAS.trmm!('R', $uploc, 'T', $isunitc, one(T), B.data, A)
 
         # Left division
-        A_ldiv_B!{T<:BlasFloat}(A::$t{T,<:StridedMatrix}, B::StridedVecOrMat{T}) =
+        A_ldiv_B!(A::$t{T,<:StridedMatrix}, B::StridedVecOrMat{T}) where {T<:BlasFloat} =
             LAPACK.trtrs!($uploc, 'N', $isunitc, A.data, B)
-        At_ldiv_B!{T<:BlasFloat}(A::$t{T,<:StridedMatrix}, B::StridedVecOrMat{T}) =
+        At_ldiv_B!(A::$t{T,<:StridedMatrix}, B::StridedVecOrMat{T}) where {T<:BlasFloat} =
             LAPACK.trtrs!($uploc, 'T', $isunitc, A.data, B)
-        Ac_ldiv_B!{T<:BlasReal}(A::$t{T,<:StridedMatrix}, B::StridedVecOrMat{T}) =
+        Ac_ldiv_B!(A::$t{T,<:StridedMatrix}, B::StridedVecOrMat{T}) where {T<:BlasReal} =
             LAPACK.trtrs!($uploc, 'T', $isunitc, A.data, B)
-        Ac_ldiv_B!{T<:BlasComplex}(A::$t{T,<:StridedMatrix}, B::StridedVecOrMat{T}) =
+        Ac_ldiv_B!(A::$t{T,<:StridedMatrix}, B::StridedVecOrMat{T}) where {T<:BlasComplex} =
             LAPACK.trtrs!($uploc, 'C', $isunitc, A.data, B)
 
         # Right division
-        A_rdiv_B!{T<:BlasFloat}(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) =
+        A_rdiv_B!(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) where {T<:BlasFloat} =
             BLAS.trsm!('R', $uploc, 'N', $isunitc, one(T), B.data, A)
-        A_rdiv_Bt!{T<:BlasFloat}(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) =
+        A_rdiv_Bt!(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) where {T<:BlasFloat} =
             BLAS.trsm!('R', $uploc, 'T', $isunitc, one(T), B.data, A)
-        A_rdiv_Bc!{T<:BlasReal}(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) =
+        A_rdiv_Bc!(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) where {T<:BlasReal} =
             BLAS.trsm!('R', $uploc, 'T', $isunitc, one(T), B.data, A)
-        A_rdiv_Bc!{T<:BlasComplex}(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) =
+        A_rdiv_Bc!(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) where {T<:BlasComplex} =
             BLAS.trsm!('R', $uploc, 'C', $isunitc, one(T), B.data, A)
 
         # Matrix inverse
-        inv!{T<:BlasFloat,S<:StridedMatrix}(A::$t{T,S}) =
+        inv!(A::$t{T,S}) where {T<:BlasFloat,S<:StridedMatrix} =
             $t{T,S}(LAPACK.trtri!($uploc, $isunitc, A.data))
 
         # Error bounds for triangular solve
-        errorbounds{T<:BlasFloat}(A::$t{T,<:StridedMatrix}, X::StridedVecOrMat{T}, B::StridedVecOrMat{T}) =
+        errorbounds(A::$t{T,<:StridedMatrix}, X::StridedVecOrMat{T}, B::StridedVecOrMat{T}) where {T<:BlasFloat} =
             LAPACK.trrfs!($uploc, 'N', $isunitc, A.data, B, X)
 
         # Condition numbers
@@ -475,27 +518,27 @@ for (t, uploc, isunitc) in ((:LowerTriangular, 'L', 'N'),
                 return inv(LAPACK.trcon!('O', $uploc, $isunitc, A.data))
             elseif p == Inf
                 return inv(LAPACK.trcon!('I', $uploc, $isunitc, A.data))
-            else #use fallback
+            else # use fallback
                 return cond(full(A), p)
             end
         end
     end
 end
 
-function inv{T}(A::LowerTriangular{T})
+function inv(A::LowerTriangular{T}) where T
     S = typeof((zero(T)*one(T) + zero(T))/one(T))
     LowerTriangular(A_ldiv_B!(convert(AbstractArray{S}, A), eye(S, size(A, 1))))
 end
-function inv{T}(A::UpperTriangular{T})
+function inv(A::UpperTriangular{T}) where T
     S = typeof((zero(T)*one(T) + zero(T))/one(T))
     UpperTriangular(A_ldiv_B!(convert(AbstractArray{S}, A), eye(S, size(A, 1))))
 end
-inv{T}(A::UnitUpperTriangular{T}) = UnitUpperTriangular(A_ldiv_B!(A, eye(T, size(A, 1))))
-inv{T}(A::UnitLowerTriangular{T}) = UnitLowerTriangular(A_ldiv_B!(A, eye(T, size(A, 1))))
+inv(A::UnitUpperTriangular{T}) where {T} = UnitUpperTriangular(A_ldiv_B!(A, eye(T, size(A, 1))))
+inv(A::UnitLowerTriangular{T}) where {T} = UnitLowerTriangular(A_ldiv_B!(A, eye(T, size(A, 1))))
 
-errorbounds{T<:Union{BigFloat, Complex{BigFloat}}}(A::AbstractTriangular{T,<:StridedMatrix}, X::StridedVecOrMat{T}, B::StridedVecOrMat{T}) =
+errorbounds(A::AbstractTriangular{T,<:StridedMatrix}, X::StridedVecOrMat{T}, B::StridedVecOrMat{T}) where {T<:Union{BigFloat,Complex{BigFloat}}} =
     error("not implemented yet! Please submit a pull request.")
-function errorbounds{TA<:Number,TX<:Number,TB<:Number}(A::AbstractTriangular{TA,<:StridedMatrix}, X::StridedVecOrMat{TX}, B::StridedVecOrMat{TB})
+function errorbounds(A::AbstractTriangular{TA,<:StridedMatrix}, X::StridedVecOrMat{TX}, B::StridedVecOrMat{TB}) where {TA<:Number,TX<:Number,TB<:Number}
     TAXB = promote_type(TA, TB, TX, Float32)
     errorbounds(convert(AbstractMatrix{TAXB}, A), convert(AbstractArray{TAXB}, X), convert(AbstractArray{TAXB}, B))
 end
@@ -1583,7 +1626,7 @@ for (f, g) in ((:\, :A_ldiv_B!), (:Ac_ldiv_B, :Ac_ldiv_B!), (:At_ldiv_B, :At_ldi
         end
     end
 end
-### Multiplication with triangle to the rigth and hence lhs cannot be transposed.
+### Multiplication with triangle to the right and hence lhs cannot be transposed.
 for (f, g) in ((:*, :A_mul_B!), (:A_mul_Bc, :A_mul_Bc!), (:A_mul_Bt, :A_mul_Bt!))
     mat != :AbstractVector && @eval begin
         function ($f)(A::$mat, B::AbstractTriangular)
@@ -1662,18 +1705,86 @@ At_ldiv_B(::Union{UnitUpperTriangular,UnitLowerTriangular}, ::RowVector) = throw
 Ac_ldiv_B(::Union{UpperTriangular,LowerTriangular}, ::RowVector) = throw(DimensionMismatch("Cannot left-divide matrix by transposed vector"))
 Ac_ldiv_B(::Union{UnitUpperTriangular,UnitLowerTriangular}, ::RowVector) = throw(DimensionMismatch("Cannot left-divide matrix by transposed vector"))
 
+# Complex matrix power for upper triangular factor, see:
+#   Higham and Lin, "A Schur-Padé algorithm for fractional powers of a Matrix",
+#     SIAM J. Matrix Anal. & Appl., 32 (3), (2011) 1056–1078.
+#   Higham and Lin, "An improved Schur-Padé algorithm for fractional powers of
+#     a matrix and their Fréchet derivatives", SIAM. J. Matrix Anal. & Appl.,
+#     34(3), (2013) 1341–1360.
+function powm!(A0::UpperTriangular{<:BlasFloat}, p::Real)
+    if abs(p) >= 1
+        ArgumentError("p must be a real number in (-1,1), got $p")
+    end
+
+    normA0 = norm(A0, 1)
+    scale!(A0, 1/normA0)
+
+    theta = [1.53e-5, 2.25e-3, 1.92e-2, 6.08e-2, 1.25e-1, 2.03e-1, 2.84e-1]
+    n = checksquare(A0)
+
+    A, m, s = invsquaring(A0, theta)
+    A = I - A
+
+    # Compute accurate diagonal of I - T
+    sqrt_diag!(A0, A, s)
+    for i = 1:n
+        A[i, i] = -A[i, i]
+    end
+    # Compute the Padé approximant
+    c = 0.5 * (p - m) / (2 * m - 1)
+    triu!(A)
+    S = c * A
+    Stmp = similar(S)
+    for j = m-1:-1:1
+        j4 = 4 * j
+        c = (-p - j) / (j4 + 2)
+        for i = 1:n
+            @inbounds S[i, i] = S[i, i] + 1
+        end
+        copy!(Stmp, S)
+        scale!(S, A, c)
+        A_ldiv_B!(Stmp, S.data)
+
+        c = (p - j) / (j4 - 2)
+        for i = 1:n
+            @inbounds S[i, i] = S[i, i] + 1
+        end
+        copy!(Stmp, S)
+        scale!(S, A, c)
+        A_ldiv_B!(Stmp, S.data)
+    end
+    for i = 1:n
+        S[i, i] = S[i, i] + 1
+    end
+    copy!(Stmp, S)
+    scale!(S, A, -p)
+    A_ldiv_B!(Stmp, S.data)
+    for i = 1:n
+        @inbounds S[i, i] = S[i, i] + 1
+    end
+
+    blockpower!(A0, S, p/(2^s))
+    for m = 1:s
+        A_mul_B!(Stmp.data, S, S)
+        copy!(S, Stmp)
+        blockpower!(A0, S, p/(2^(s-m)))
+    end
+    scale!(S, normA0^p)
+    return S
+end
+powm(A::LowerTriangular, p::Real) = powm(A.', p::Real).'
 
 # Complex matrix logarithm for the upper triangular factor, see:
 #   Al-Mohy and Higham, "Improved inverse  scaling and squaring algorithms for
-#     the matrix logarithm", SIAM J. Sci. Comput., 34(4), (2012), pp. C153-C169.
+#     the matrix logarithm", SIAM J. Sci. Comput., 34(4), (2012), pp. C153–C169.
 #   Al-Mohy, Higham and Relton, "Computing the Frechet derivative of the matrix
-#     logarithm and estimating the condition number", SIAM J. Sci. Comput., 35(4),
-#     (2013), C394-C410.
+#     logarithm and estimating the condition number", SIAM J. Sci. Comput.,
+#     35(4), (2013), C394–C410.
 #
 # Based on the code available at http://eprints.ma.man.ac.uk/1851/02/logm.zip,
 # Copyright (c) 2011, Awad H. Al-Mohy and Nicholas J. Higham
 # Julia version relicensed with permission from original authors
-function logm{T<:Union{Float64,Complex{Float64}}}(A0::UpperTriangular{T})
+function logm(A0::UpperTriangular{T}) where T<:Union{Float64,Complex{Float64}}
     maxsqrt = 100
     theta = [1.586970738772063e-005,
          2.313807884242979e-003,
@@ -1689,19 +1800,12 @@ function logm{T<:Union{Float64,Complex{Float64}}}(A0::UpperTriangular{T})
     m = 0
 
     # Compute repeated roots
-    d = diag(A)
-    dm1 = Array{T}(n)
+    d = complex(diag(A))
+    dm1 = d .- 1
     s = 0
-    for i = 1:n
-        dm1[i] = d[i] - 1.
-    end
-    while norm(dm1, Inf) > theta[tmax]
-        for i = 1:n
-            d[i] = sqrt(d[i])
-        end
-        for i = 1:n
-            dm1[i] = d[i] - 1
-        end
+    while norm(dm1, Inf) > theta[tmax] && s < maxsqrt
+        d .= sqrt.(d)
+        dm1 .= d .- 1
         s = s + 1
     end
     s0 = s
@@ -1715,7 +1819,7 @@ function logm{T<:Union{Float64,Complex{Float64}}}(A0::UpperTriangular{T})
     alpha2 = max(d2, d3)
     foundm = false
     if alpha2 <= theta[2]
-        m = alpha2<=theta[1]?1:2
+        m = alpha2 <= theta[1] ? 1 : 2
         foundm = true
     end
 
@@ -1809,14 +1913,14 @@ function logm{T<:Union{Float64,Complex{Float64}}}(A0::UpperTriangular{T})
         A[i,i] = z0 / r
     end
 
-    # Compute the Gauss-Legendre quadrature formula
+    # Get the Gauss-Legendre quadrature points and weights
     R = zeros(Float64, m, m)
     for i = 1:m - 1
         R[i,i+1] = i / sqrt((2 * i)^2 - 1)
         R[i+1,i] = R[i,i+1]
     end
     x,V = eig(R)
-    w = Array{Float64}(m)
+    w = Vector{Float64}(m)
     for i = 1:m
         x[i] = (x[i] + 1) / 2
         w[i] = V[1,i]^2
@@ -1850,10 +1954,164 @@ function logm{T<:Union{Float64,Complex{Float64}}}(A0::UpperTriangular{T})
     end
 
     return UpperTriangular(Y)
-
 end
 logm(A::LowerTriangular) = logm(A.').'
 
+# Auxiliary functions for logm and matrix power
+
+# Compute accurate diagonal of A = A0^s - I
+#   Al-Mohy, "A more accurate Briggs method for the logarithm",
+#      Numer. Algorithms, 59, (2012), 393–402.
+function sqrt_diag!(A0::UpperTriangular, A::UpperTriangular, s)
+    n = checksquare(A0)
+    @inbounds for i = 1:n
+        a = complex(A0[i,i])
+        if s == 0
+            A[i,i] = a - 1
+        else
+            s0 = s
+            if imag(a) >= 0 && real(a) <= 0 && a != 0
+                a = sqrt(a)
+                s0 = s - 1
+            end
+            z0 = a - 1
+            a = sqrt(a)
+            r = 1 + a
+            for j = 1:s0-1
+                a = sqrt(a)
+                r = r * (1 + a)
+            end
+            A[i,i] = z0 / r
+        end
+    end
+end
+
+# Used only by powm at the moment
+# Repeatedly compute the square roots of A so that in the end its
+# eigenvalues are close enough to the positive real line
+function invsquaring(A0::UpperTriangular, theta)
+    # assumes theta is in ascending order
+    maxsqrt = 100
+    tmax = size(theta, 1)
+    n = checksquare(A0)
+    A = complex(copy(A0))
+    p = 0
+    m = 0
+
+    # Compute repeated roots
+    d = complex(diag(A))
+    dm1 = d .- 1
+    s = 0
+    while norm(dm1, Inf) > theta[tmax] && s < maxsqrt
+        d .= sqrt.(d)
+        dm1 .= d .- 1
+        s = s + 1
+    end
+    s0 = s
+    for k = 1:min(s, maxsqrt)
+        A = sqrtm(A)
+    end
+
+    AmI = A - I
+    d2 = sqrt(norm(AmI^2, 1))
+    d3 = cbrt(norm(AmI^3, 1))
+    alpha2 = max(d2, d3)
+    foundm = false
+    if alpha2 <= theta[2]
+        m = alpha2 <= theta[1] ? 1 : 2
+        foundm = true
+    end
+
+    while !foundm
+        more = false
+        if s > s0
+            d3 = cbrt(norm(AmI^3, 1))
+        end
+        d4 = norm(AmI^4, 1)^(1/4)
+        alpha3 = max(d3, d4)
+        if alpha3 <= theta[tmax]
+            for j = 3:tmax
+                if alpha3 <= theta[j]
+                    break
+                elseif alpha3 / 2 <= theta[5] && p < 2
+                    more = true
+                    p = p + 1
+                end
+            end
+            if j <= 6
+                m = j
+                foundm = true
+                break
+            elseif alpha3 / 2 <= theta[5] && p < 2
+                more = true
+                p = p + 1
+           end
+        end
+
+        if !more
+            d5 = norm(AmI^5, 1)^(1/5)
+            alpha4 = max(d4, d5)
+            eta = min(alpha3, alpha4)
+            if eta <= theta[tmax]
+                j = 0
+                for j = 6:tmax
+                    if eta <= theta[j]
+                        m = j
+                        break
+                    end
+                    break
+                end
+            end
+            if s == maxsqrt
+                m = tmax
+                break
+            end
+            A = sqrtm(A)
+            AmI = A - I
+            s = s + 1
+        end
+    end
+
+    # Compute accurate superdiagonal of T
+    p = 1 / 2^s
+    A = complex(A)
+    blockpower!(A, A0, p)
+    return A,m,s
+end
+
+# Compute accurate diagonal and superdiagonal of A = A0^p
+function blockpower!(A::UpperTriangular, A0::UpperTriangular, p)
+    n = checksquare(A0)
+    @inbounds for k = 1:n-1
+        Ak = complex(A0[k,k])
+        Akp1 = complex(A0[k+1,k+1])
+
+        Akp = Ak^p
+        Akp1p = Akp1^p
+
+        A[k,k] = Akp
+        A[k+1,k+1] = Akp1p
+
+        if Ak == Akp1
+            A[k,k+1] = p * A0[k,k+1] * Ak^(p-1)
+        elseif 2 * abs(Ak) < abs(Akp1) || 2 * abs(Akp1) < abs(Ak)
+            A[k,k+1] = A0[k,k+1] * (Akp1p - Akp) / (Akp1 - Ak)
+        else
+            logAk = log(Ak)
+            logAkp1 = log(Akp1)
+            w = atanh((Akp1 - Ak)/(Akp1 + Ak)) + im * pi * unw(logAkp1-logAk)
+            dd = 2 * exp(p*(logAk+logAkp1)/2) * sinh(p*w) / (Akp1 - Ak);
+            A[k,k+1] = A0[k,k+1] * dd
+        end
+    end
+end
+
+# Unwinding number
+unw(x::Real) = 0
+unw(x::Number) = ceil((imag(x) - pi) / (2 * pi))
+
+# End of auxiliary functions for logm and matrix power
+
 function sqrtm(A::UpperTriangular)
     realmatrix = false
     if isreal(A)
@@ -1866,9 +2124,9 @@ function sqrtm(A::UpperTriangular)
             end
         end
     end
-    sqrtm(A,Val{realmatrix})
+    sqrtm(A,Val(realmatrix))
 end
-function sqrtm{T,realmatrix}(A::UpperTriangular{T},::Type{Val{realmatrix}})
+function sqrtm(A::UpperTriangular{T},::Val{realmatrix}) where {T,realmatrix}
     B = A.data
     n = checksquare(B)
     t = realmatrix ? typeof(sqrt(zero(T))) : typeof(sqrt(complex(zero(T))))
@@ -1886,7 +2144,7 @@ function sqrtm{T,realmatrix}(A::UpperTriangular{T},::Type{Val{realmatrix}})
     end
     return UpperTriangular(R)
 end
-function sqrtm{T}(A::UnitUpperTriangular{T})
+function sqrtm(A::UnitUpperTriangular{T}) where T
     B = A.data
     n = checksquare(B)
     t = typeof(sqrt(zero(T)))
@@ -1907,9 +2165,9 @@ end
 sqrtm(A::LowerTriangular) = sqrtm(A.').'
 sqrtm(A::UnitLowerTriangular) = sqrtm(A.').'
 
-#Generic eigensystems
+# Generic eigensystems
 eigvals(A::AbstractTriangular) = diag(A)
-function eigvecs{T}(A::AbstractTriangular{T})
+function eigvecs(A::AbstractTriangular{T}) where T
     TT = promote_type(T, Float32)
     if TT <: BlasFloat
         return eigvecs(convert(AbstractMatrix{TT}, A))
@@ -1917,15 +2175,15 @@ 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)
-det{T}(A::UnitLowerTriangular{T}) = one(T)
-logdet{T}(A::UnitUpperTriangular{T}) = zero(T)
-logdet{T}(A::UnitLowerTriangular{T}) = zero(T)
-logabsdet{T}(A::UnitUpperTriangular{T}) = zero(T), one(T)
-logabsdet{T}(A::UnitLowerTriangular{T}) = zero(T), one(T)
+det(A::UnitUpperTriangular{T}) where {T} = one(T)
+det(A::UnitLowerTriangular{T}) where {T} = one(T)
+logdet(A::UnitUpperTriangular{T}) where {T} = zero(T)
+logdet(A::UnitLowerTriangular{T}) where {T} = zero(T)
+logabsdet(A::UnitUpperTriangular{T}) where {T} = zero(T), one(T)
+logabsdet(A::UnitLowerTriangular{T}) where {T} = zero(T), one(T)
 det(A::UpperTriangular) = prod(diag(A.data))
 det(A::LowerTriangular) = prod(diag(A.data))
-function logabsdet{T}(A::Union{UpperTriangular{T},LowerTriangular{T}})
+function logabsdet(A::Union{UpperTriangular{T},LowerTriangular{T}}) where T
     sgn = one(T)
     abs_det = zero(real(T))
     @inbounds for i in 1:size(A,1)
@@ -1938,7 +2196,7 @@ end
 
 eigfact(A::AbstractTriangular) = Eigen(eigvals(A), eigvecs(A))
 
-#Generic singular systems
+# Generic singular systems
 for func in (:svd, :svdfact, :svdfact!, :svdvals)
     @eval begin
         ($func)(A::AbstractTriangular) = ($func)(full(A))
diff --git a/base/linalg/tridiag.jl b/base/linalg/tridiag.jl
index 279e2aca796ad1..4a6599fc6e1345 100644
--- a/base/linalg/tridiag.jl
+++ b/base/linalg/tridiag.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #### Specialized matrix types ####
 
@@ -22,8 +22,7 @@ respectively. The result is of type `SymTridiagonal` and provides efficient spec
 eigensolvers, but may be converted into a regular matrix with
 [`convert(Array, _)`](@ref) (or `Array(_)` for short).
 
-# Example
-
+# Examples
 ```jldoctest
 julia> dv = [1; 2; 3; 4]
 4-element Array{Int64,1}:
@@ -61,11 +60,11 @@ function SymTridiagonal(A::AbstractMatrix)
     end
 end
 
-convert{T}(::Type{SymTridiagonal{T}}, S::SymTridiagonal) =
+convert(::Type{SymTridiagonal{T}}, S::SymTridiagonal) where {T} =
     SymTridiagonal(convert(Vector{T}, S.dv), convert(Vector{T}, S.ev))
-convert{T}(::Type{AbstractMatrix{T}}, S::SymTridiagonal) =
+convert(::Type{AbstractMatrix{T}}, S::SymTridiagonal) where {T} =
     SymTridiagonal(convert(Vector{T}, S.dv), convert(Vector{T}, S.ev))
-function convert{T}(::Type{Matrix{T}}, M::SymTridiagonal{T})
+function convert(::Type{Matrix{T}}, M::SymTridiagonal{T}) where T
     n = size(M, 1)
     Mf = zeros(T, n, n)
     @inbounds begin
@@ -78,7 +77,7 @@ function convert{T}(::Type{Matrix{T}}, M::SymTridiagonal{T})
     end
     return Mf
 end
-convert{T}(::Type{Matrix}, M::SymTridiagonal{T}) = convert(Matrix{T}, M)
+convert(::Type{Matrix}, M::SymTridiagonal{T}) where {T} = convert(Matrix{T}, M)
 convert(::Type{Array}, M::SymTridiagonal) = convert(Matrix, M)
 full(M::SymTridiagonal) = convert(Array, M)
 
@@ -93,7 +92,7 @@ function size(A::SymTridiagonal, d::Integer)
     end
 end
 
-similar{T}(S::SymTridiagonal, ::Type{T}) = SymTridiagonal{T}(similar(S.dv, T), similar(S.ev, T))
+similar(S::SymTridiagonal, ::Type{T}) where {T} = SymTridiagonal{T}(similar(S.dv, T), similar(S.ev, T))
 
 #Elementary operations
 broadcast(::typeof(abs), M::SymTridiagonal) = SymTridiagonal(abs.(M.dv), abs.(M.ev))
@@ -104,15 +103,15 @@ broadcast(::typeof(ceil), M::SymTridiagonal) = SymTridiagonal(ceil.(M.dv), ceil.
 for func in (:conj, :copy, :real, :imag)
     @eval ($func)(M::SymTridiagonal) = SymTridiagonal(($func)(M.dv), ($func)(M.ev))
 end
-broadcast{T<:Integer}(::typeof(round), ::Type{T}, M::SymTridiagonal) = SymTridiagonal(round.(T, M.dv), round.(T, M.ev))
-broadcast{T<:Integer}(::typeof(trunc), ::Type{T}, M::SymTridiagonal) = SymTridiagonal(trunc.(T, M.dv), trunc.(T, M.ev))
-broadcast{T<:Integer}(::typeof(floor), ::Type{T}, M::SymTridiagonal) = SymTridiagonal(floor.(T, M.dv), floor.(T, M.ev))
-broadcast{T<:Integer}(::typeof(ceil), ::Type{T}, M::SymTridiagonal) = SymTridiagonal(ceil.(T, M.dv), ceil.(T, M.ev))
+broadcast(::typeof(round), ::Type{T}, M::SymTridiagonal) where {T<:Integer} = SymTridiagonal(round.(T, M.dv), round.(T, M.ev))
+broadcast(::typeof(trunc), ::Type{T}, M::SymTridiagonal) where {T<:Integer} = SymTridiagonal(trunc.(T, M.dv), trunc.(T, M.ev))
+broadcast(::typeof(floor), ::Type{T}, M::SymTridiagonal) where {T<:Integer} = SymTridiagonal(floor.(T, M.dv), floor.(T, M.ev))
+broadcast(::typeof(ceil), ::Type{T}, M::SymTridiagonal) where {T<:Integer} = SymTridiagonal(ceil.(T, M.dv), ceil.(T, M.ev))
 
 transpose(M::SymTridiagonal) = M #Identity operation
 ctranspose(M::SymTridiagonal) = conj(M)
 
-function diag{T}(M::SymTridiagonal{T}, n::Integer=0)
+function diag(M::SymTridiagonal{T}, n::Integer=0) where T
     absn = abs(n)
     if absn == 0
         return M.dv
@@ -163,41 +162,41 @@ end
 (\)(T::SymTridiagonal, B::StridedVecOrMat) = ldltfact(T)\B
 
 eigfact!(A::SymTridiagonal{<:BlasReal}) = Eigen(LAPACK.stegr!('V', A.dv, A.ev)...)
-function eigfact{T}(A::SymTridiagonal{T})
+function eigfact(A::SymTridiagonal{T}) where T
     S = promote_type(Float32, typeof(zero(T)/norm(one(T))))
     eigfact!(copy_oftype(A, S))
 end
 
 eigfact!(A::SymTridiagonal{<:BlasReal}, 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)
+function eigfact(A::SymTridiagonal{T}, irange::UnitRange) where T
     S = promote_type(Float32, typeof(zero(T)/norm(one(T))))
     return eigfact!(copy_oftype(A, S), irange)
 end
 
 eigfact!(A::SymTridiagonal{<:BlasReal}, 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)
+function eigfact(A::SymTridiagonal{T}, vl::Real, vu::Real) where T
     S = promote_type(Float32, typeof(zero(T)/norm(one(T))))
     return eigfact!(copy_oftype(A, S), vl, vu)
 end
 
 eigvals!(A::SymTridiagonal{<:BlasReal}) = LAPACK.stev!('N', A.dv, A.ev)[1]
-function eigvals{T}(A::SymTridiagonal{T})
+function eigvals(A::SymTridiagonal{T}) where T
     S = promote_type(Float32, typeof(zero(T)/norm(one(T))))
     return eigvals!(copy_oftype(A, S))
 end
 
 eigvals!(A::SymTridiagonal{<:BlasReal}, 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)
+function eigvals(A::SymTridiagonal{T}, irange::UnitRange) where T
     S = promote_type(Float32, typeof(zero(T)/norm(one(T))))
     return eigvals!(copy_oftype(A, S), irange)
 end
 
 eigvals!(A::SymTridiagonal{<:BlasReal}, 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)
+function eigvals(A::SymTridiagonal{T}, vl::Real, vu::Real) where T
     S = promote_type(Float32, typeof(zero(T)/norm(one(T))))
     return eigvals!(copy_oftype(A, S), vl, vu)
 end
@@ -218,8 +217,7 @@ be obtained from the slice `M[:, k]`.)
 If the optional vector of eigenvalues `eigvals` is specified, `eigvecs`
 returns the specific corresponding eigenvectors.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> A = SymTridiagonal([1.; 2.; 1.], [2.; 3.])
 3×3 SymTridiagonal{Float64}:
@@ -297,12 +295,12 @@ end
 mutable struct ZeroOffsetVector
     data::Vector
 end
-getindex( a::ZeroOffsetVector, i) = a.data[i+1]
+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)
+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
 
@@ -313,7 +311,7 @@ end
 #    R. Usmani, "Inversion of a tridiagonal Jacobi matrix",
 #    Linear Algebra and its Applications 212-213 (1994), pp.413-414
 #    doi:10.1016/0024-3795(94)90414-6
-function inv_usmani{T}(a::Vector{T}, b::Vector{T}, c::Vector{T})
+function inv_usmani(a::Vector{T}, b::Vector{T}, c::Vector{T}) where T
     n = length(b)
     θ = ZeroOffsetVector(zeros(T, n+1)) #principal minors of A
     θ[0] = 1
@@ -327,7 +325,7 @@ function inv_usmani{T}(a::Vector{T}, b::Vector{T}, c::Vector{T})
     for i=n-1:-1:1
         φ[i] = b[i]*φ[i+1]-a[i]*c[i]*φ[i+2]
     end
-    α = Array{T}(n, n)
+    α = Matrix{T}(n, n)
     for i=1:n, j=1:n
         sign = (i+j)%2==0 ? (+) : (-)
         if i<j
@@ -343,7 +341,7 @@ end
 
 #Implements the determinant using principal minors
 #Inputs and reference are as above for inv_usmani()
-function det_usmani{T}(a::Vector{T}, b::Vector{T}, c::Vector{T})
+function det_usmani(a::Vector{T}, b::Vector{T}, c::Vector{T}) where T
     n = length(b)
     θa = one(T)
     if n == 0
@@ -359,7 +357,7 @@ end
 inv(A::SymTridiagonal) = inv_usmani(A.ev, A.dv, A.ev)
 det(A::SymTridiagonal) = det_usmani(A.ev, A.dv, A.ev)
 
-function getindex{T}(A::SymTridiagonal{T}, i::Integer, j::Integer)
+function getindex(A::SymTridiagonal{T}, i::Integer, j::Integer) where T
     if !(1 <= i <= size(A,2) && 1 <= j <= size(A,2))
         throw(BoundsError(A, (i,j)))
     end
@@ -375,13 +373,13 @@ function getindex{T}(A::SymTridiagonal{T}, i::Integer, j::Integer)
 end
 
 function setindex!(A::SymTridiagonal, x, i::Integer, j::Integer)
+    @boundscheck checkbounds(A, i, j)
     if i == j
-        A.dv[i] = x
-    elseif abs(i - j) == 1
-        A.ev[min(i,j)] = x
+        @inbounds A.dv[i] = x
     else
-        throw(ArgumentError("cannot set elements outside the sub, main, or super diagonals"))
+        throw(ArgumentError("cannot set off-diagonal entry ($i, $j)"))
     end
+    return x
 end
 
 ## Tridiagonal matrices ##
@@ -401,8 +399,7 @@ solvers, but may be converted into a regular matrix with
 [`convert(Array, _)`](@ref) (or `Array(_)` for short).
 The lengths of `dl` and `du` must be one less than the length of `d`.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> dl = [1; 2; 3]
 3-element Array{Int64,1}:
@@ -432,7 +429,7 @@ julia> Tridiagonal(dl, d, du)
 ```
 """
 # Basic constructor takes in three dense vectors of same type
-function Tridiagonal{T}(dl::Vector{T}, d::Vector{T}, du::Vector{T})
+function Tridiagonal(dl::Vector{T}, d::Vector{T}, du::Vector{T}) where T
     n = length(d)
     if (length(dl) != n-1 || length(du) != n-1)
         throw(ArgumentError("cannot make Tridiagonal from incompatible lengths of subdiagonal, diagonal and superdiagonal: ($(length(dl)), $(length(d)), $(length(du))"))
@@ -441,7 +438,7 @@ function Tridiagonal{T}(dl::Vector{T}, d::Vector{T}, du::Vector{T})
 end
 
 # Construct from diagonals of any abstract vector, any eltype
-function Tridiagonal{Tl, Td, Tu}(dl::AbstractVector{Tl}, d::AbstractVector{Td}, du::AbstractVector{Tu})
+function Tridiagonal(dl::AbstractVector{Tl}, d::AbstractVector{Td}, du::AbstractVector{Tu}) where {Tl,Td,Tu}
     Tridiagonal(map(v->convert(Vector{promote_type(Tl,Td,Tu)}, v), (dl, d, du))...)
 end
 
@@ -452,8 +449,7 @@ end
 returns a `Tridiagonal` array based on (abstract) matrix `A`, using its first lower diagonal,
 main diagonal, and first upper diagonal.
 
-# Example
-
+# Examples
 ```jldoctest
 julia> A = [1 2 3 4; 1 2 3 4; 1 2 3 4; 1 2 3 4]
 4×4 Array{Int64,2}:
@@ -485,7 +481,7 @@ function size(M::Tridiagonal, d::Integer)
     end
 end
 
-function convert{T}(::Type{Matrix{T}}, M::Tridiagonal{T})
+function convert(::Type{Matrix{T}}, M::Tridiagonal{T}) where T
     A = zeros(T, size(M))
     for i = 1:length(M.d)
         A[i,i] = M.d[i]
@@ -496,10 +492,10 @@ function convert{T}(::Type{Matrix{T}}, M::Tridiagonal{T})
     end
     A
 end
-convert{T}(::Type{Matrix}, M::Tridiagonal{T}) = convert(Matrix{T}, M)
+convert(::Type{Matrix}, M::Tridiagonal{T}) where {T} = convert(Matrix{T}, M)
 convert(::Type{Array}, M::Tridiagonal) = convert(Matrix, M)
 full(M::Tridiagonal) = convert(Array, M)
-function similar{T}(M::Tridiagonal, ::Type{T})
+function similar(M::Tridiagonal, ::Type{T}) where T
     Tridiagonal{T}(similar(M.dl, T), similar(M.d, T), similar(M.du, T), similar(M.du2, T))
 end
 
@@ -517,19 +513,19 @@ for func in (:conj, :copy, :real, :imag)
         Tridiagonal(($func)(M.dl), ($func)(M.d), ($func)(M.du), ($func)(M.du2))
     end
 end
-broadcast{T<:Integer}(::typeof(round), ::Type{T}, M::Tridiagonal) =
+broadcast(::typeof(round), ::Type{T}, M::Tridiagonal) where {T<:Integer} =
     Tridiagonal(round.(T, M.dl), round.(T, M.d), round.(T, M.du), round.(T, M.du2))
-broadcast{T<:Integer}(::typeof(trunc), ::Type{T}, M::Tridiagonal) =
+broadcast(::typeof(trunc), ::Type{T}, M::Tridiagonal) where {T<:Integer} =
     Tridiagonal(trunc.(T, M.dl), trunc.(T, M.d), trunc.(T, M.du), trunc.(T, M.du2))
-broadcast{T<:Integer}(::typeof(floor), ::Type{T}, M::Tridiagonal) =
+broadcast(::typeof(floor), ::Type{T}, M::Tridiagonal) where {T<:Integer} =
     Tridiagonal(floor.(T, M.dl), floor.(T, M.d), floor.(T, M.du), floor.(T, M.du2))
-broadcast{T<:Integer}(::typeof(ceil), ::Type{T}, M::Tridiagonal) =
+broadcast(::typeof(ceil), ::Type{T}, M::Tridiagonal) where {T<:Integer} =
     Tridiagonal(ceil.(T, M.dl), ceil.(T, M.d), ceil.(T, M.du), ceil.(T, M.du2))
 
 transpose(M::Tridiagonal) = Tridiagonal(M.du, M.d, M.dl)
 ctranspose(M::Tridiagonal) = conj(transpose(M))
 
-function diag{T}(M::Tridiagonal{T}, n::Integer=0)
+function diag(M::Tridiagonal{T}, n::Integer=0) where T
     if n == 0
         return M.d
     elseif n == -1
@@ -543,7 +539,7 @@ function diag{T}(M::Tridiagonal{T}, n::Integer=0)
     end
 end
 
-function getindex{T}(A::Tridiagonal{T}, i::Integer, j::Integer)
+function getindex(A::Tridiagonal{T}, i::Integer, j::Integer) where T
     if !(1 <= i <= size(A,2) && 1 <= j <= size(A,2))
         throw(BoundsError(A, (i,j)))
     end
@@ -559,15 +555,18 @@ function getindex{T}(A::Tridiagonal{T}, i::Integer, j::Integer)
 end
 
 function setindex!(A::Tridiagonal, x, i::Integer, j::Integer)
+    @boundscheck checkbounds(A, i, j)
     if i == j
-        A.d[i] = x
+        @inbounds A.d[i] = x
     elseif i - j == 1
-        A.dl[j] = x
+        @inbounds 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"))
+        @inbounds A.du[i] = x
+    elseif !iszero(x)
+        throw(ArgumentError(string("cannot set entry ($i, $j) off ",
+            "the tridiagonal band to a nonzero value ($x)")))
     end
+    return x
 end
 
 ## structured matrix methods ##
@@ -631,10 +630,10 @@ end
 inv(A::Tridiagonal) = inv_usmani(A.dl, A.d, A.du)
 det(A::Tridiagonal) = det_usmani(A.dl, A.d, A.du)
 
-convert{T}(::Type{Tridiagonal{T}},M::Tridiagonal) = Tridiagonal(convert(Vector{T}, M.dl), convert(Vector{T}, M.d), convert(Vector{T}, M.du), convert(Vector{T}, M.du2))
-convert{T}(::Type{AbstractMatrix{T}},M::Tridiagonal) = convert(Tridiagonal{T}, M)
-convert{T}(::Type{Tridiagonal{T}}, M::SymTridiagonal{T}) = Tridiagonal(M)
-function convert{T}(::Type{SymTridiagonal{T}}, M::Tridiagonal)
+convert(::Type{Tridiagonal{T}},M::Tridiagonal) where {T} = Tridiagonal(convert(Vector{T}, M.dl), convert(Vector{T}, M.d), convert(Vector{T}, M.du), convert(Vector{T}, M.du2))
+convert(::Type{AbstractMatrix{T}},M::Tridiagonal) where {T} = convert(Tridiagonal{T}, M)
+convert(::Type{Tridiagonal{T}}, M::SymTridiagonal{T}) where {T} = Tridiagonal(M)
+function convert(::Type{SymTridiagonal{T}}, M::Tridiagonal) where T
     if M.dl == M.du
         return SymTridiagonal(convert(Vector{T},M.d), convert(Vector{T},M.dl))
     else
diff --git a/base/linalg/uniformscaling.jl b/base/linalg/uniformscaling.jl
index d976aacc43f6f1..fcde2ca7552534 100644
--- a/base/linalg/uniformscaling.jl
+++ b/base/linalg/uniformscaling.jl
@@ -1,9 +1,32 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 import Base: copy, ctranspose, getindex, show, transpose, one, zero, inv,
-             @_pure_meta, hcat, vcat, hvcat
+             hcat, vcat, hvcat
 import Base.LinAlg: SingularException
 
+"""
+    UniformScaling{T<:Number}
+
+Generically sized uniform scaling operator defined as a scalar times the
+identity operator, `λ*I`. See also [`I`](@ref).
+
+# Examples
+```jldoctest
+julia> J = UniformScaling(2.)
+UniformScaling{Float64}
+2.0*I
+
+julia> A = [1. 2.; 3. 4.]
+2×2 Array{Float64,2}:
+ 1.0  2.0
+ 3.0  4.0
+
+julia> J*A
+2×2 Array{Float64,2}:
+ 2.0  4.0
+ 6.0  8.0
+```
+"""
 struct UniformScaling{T<:Number}
     λ::T
 end
@@ -11,10 +34,9 @@ end
 """
     I
 
-An object of type `UniformScaling`, representing an identity matrix of any size.
-
-# Example
+An object of type [`UniformScaling`](@ref), representing an identity matrix of any size.
 
+# Examples
 ```jldoctest
 julia> ones(5, 6) * I == ones(5, 6)
 true
@@ -27,22 +49,28 @@ julia> [1 2im 3; 1im 2 3] * I
 """
 const I = UniformScaling(1)
 
-eltype{T}(::Type{UniformScaling{T}}) = T
+eltype(::Type{UniformScaling{T}}) where {T} = T
 ndims(J::UniformScaling) = 2
 getindex(J::UniformScaling, i::Integer,j::Integer) = ifelse(i==j,J.λ,zero(J.λ))
 
-show(io::IO, J::UniformScaling) = print(io, "$(typeof(J))\n$(J.λ)*I")
+function show(io::IO, J::UniformScaling)
+    s = "$(J.λ)"
+    if ismatch(r"\w+\s*[\+\-]\s*\w+", s)
+        s = "($s)"
+    end
+    print(io, "$(typeof(J))\n$s*I")
+end
 copy(J::UniformScaling) = UniformScaling(J.λ)
 
 transpose(J::UniformScaling) = J
 ctranspose(J::UniformScaling) = UniformScaling(conj(J.λ))
 
-one{T}(::Type{UniformScaling{T}}) = UniformScaling(one(T))
-one{T}(J::UniformScaling{T}) = one(UniformScaling{T})
-oneunit{T}(::Type{UniformScaling{T}}) = UniformScaling(oneunit(T))
-oneunit{T}(J::UniformScaling{T}) = oneunit(UniformScaling{T})
-zero{T}(::Type{UniformScaling{T}}) = UniformScaling(zero(T))
-zero{T}(J::UniformScaling{T}) = zero(UniformScaling{T})
+one(::Type{UniformScaling{T}}) where {T} = UniformScaling(one(T))
+one(J::UniformScaling{T}) where {T} = one(UniformScaling{T})
+oneunit(::Type{UniformScaling{T}}) where {T} = UniformScaling(oneunit(T))
+oneunit(J::UniformScaling{T}) where {T} = oneunit(UniformScaling{T})
+zero(::Type{UniformScaling{T}}) where {T} = UniformScaling(zero(T))
+zero(J::UniformScaling{T}) where {T} = zero(UniformScaling{T})
 
 istriu(::UniformScaling) = true
 istril(::UniformScaling) = true
@@ -109,7 +137,7 @@ function (-)(J::UniformScaling, UL::Union{LowerTriangular,UnitLowerTriangular})
     return LowerTriangular(ULnew)
 end
 
-function (+){TA,TJ}(A::AbstractMatrix{TA}, J::UniformScaling{TJ})
+function (+)(A::AbstractMatrix{TA}, J::UniformScaling{TJ}) where {TA,TJ}
     n = checksquare(A)
     B = similar(A, promote_type(TA,TJ))
     copy!(B,A)
@@ -119,7 +147,7 @@ function (+){TA,TJ}(A::AbstractMatrix{TA}, J::UniformScaling{TJ})
     B
 end
 
-function (-){TA,TJ<:Number}(A::AbstractMatrix{TA}, J::UniformScaling{TJ})
+function (-)(A::AbstractMatrix{TA}, J::UniformScaling{TJ}) where {TA,TJ<:Number}
     n = checksquare(A)
     B = similar(A, promote_type(TA,TJ))
     copy!(B, A)
@@ -128,7 +156,7 @@ function (-){TA,TJ<:Number}(A::AbstractMatrix{TA}, J::UniformScaling{TJ})
     end
     B
 end
-function (-){TA,TJ<:Number}(J::UniformScaling{TJ}, A::AbstractMatrix{TA})
+function (-)(J::UniformScaling{TJ}, A::AbstractMatrix{TA}) where {TA,TJ<:Number}
     n = checksquare(A)
     B = convert(AbstractMatrix{promote_type(TJ,TA)}, -A)
     @inbounds for j = 1:n
@@ -138,6 +166,7 @@ function (-){TA,TJ<:Number}(J::UniformScaling{TJ}, A::AbstractMatrix{TA})
 end
 
 inv(J::UniformScaling) = UniformScaling(inv(J.λ))
+norm(J::UniformScaling, p::Real=2) = abs(J.λ)
 
 *(J1::UniformScaling, J2::UniformScaling) = UniformScaling(J1.λ*J2.λ)
 *(B::BitArray{2}, J::UniformScaling) = *(Array(B), J::UniformScaling)
@@ -154,7 +183,7 @@ inv(J::UniformScaling) = UniformScaling(inv(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) = scale!(inv(A), J.λ)
+\(A::Union{Bidiagonal{T},AbstractTriangular{T}}, J::UniformScaling) where {T<:Number} = scale!(inv(A), J.λ)
 \(J::UniformScaling, A::AbstractVecOrMat) = J.λ == 0 ? throw(SingularException(1)) : J.λ\A
 \(A::AbstractMatrix, J::UniformScaling) = scale!(inv(A), J.λ)
 
@@ -167,10 +196,18 @@ broadcast(::typeof(/), J::UniformScaling,x::Number) = UniformScaling(J.λ/x)
 
 ==(J1::UniformScaling,J2::UniformScaling) = (J1.λ == J2.λ)
 
-function isapprox{T<:Number,S<:Number}(J1::UniformScaling{T}, J2::UniformScaling{S};
-                              rtol::Real=Base.rtoldefault(T,S), atol::Real=0, nans::Bool=false)
+function isapprox(J1::UniformScaling{T}, J2::UniformScaling{S};
+            rtol::Real=Base.rtoldefault(T,S), atol::Real=0, nans::Bool=false) where {T<:Number,S<:Number}
     isapprox(J1.λ, J2.λ, rtol=rtol, atol=atol, nans=nans)
 end
+function isapprox(J::UniformScaling,A::AbstractMatrix;
+                  rtol::Real=rtoldefault(promote_leaf_eltypes(A),eltype(J)),
+                  atol::Real=0, nans::Bool=false, norm::Function=vecnorm)
+    n = checksquare(A)
+    Jnorm = norm === vecnorm ? abs(J.λ)*sqrt(n) : (norm === Base.norm ? abs(J.λ) : norm(diagm(fill(J.λ, n))))
+    return norm(A - J) <= atol + rtol*max(norm(A), Jnorm)
+end
+isapprox(A::AbstractMatrix,J::UniformScaling;kwargs...) = isapprox(J,A;kwargs...)
 
 function copy!(A::AbstractMatrix, J::UniformScaling)
     size(A,1)==size(A,2) || throw(DimensionMismatch("a UniformScaling can only be copied to a square matrix"))
@@ -182,7 +219,7 @@ function copy!(A::AbstractMatrix, J::UniformScaling)
     return A
 end
 
-function cond{T}(J::UniformScaling{T})
+function cond(J::UniformScaling{T}) where T
     onereal = inv(one(real(J.λ)))
     return J.λ ≠ zero(T) ? onereal : oftype(onereal, Inf)
 end
@@ -191,17 +228,17 @@ end
 # in A to matrices of type T and sizes given by n[k:end].  n is an array
 # so that the same promotion code can be used for hvcat.  We pass the type T
 # so that we can re-use this code for sparse-matrix hcat etcetera.
-promote_to_arrays_{T}(n::Int, ::Type{Matrix}, J::UniformScaling{T}) = copy!(Matrix{T}(n,n), J)
+promote_to_arrays_(n::Int, ::Type{Matrix}, J::UniformScaling{T}) where {T} = copy!(Matrix{T}(n,n), J)
 promote_to_arrays_(n::Int, ::Type, A::AbstractVecOrMat) = A
 promote_to_arrays(n,k, ::Type) = ()
-promote_to_arrays{T}(n,k, ::Type{T}, A) = (promote_to_arrays_(n[k], T, A),)
-promote_to_arrays{T}(n,k, ::Type{T}, A, B) =
+promote_to_arrays(n,k, ::Type{T}, A) where {T} = (promote_to_arrays_(n[k], T, A),)
+promote_to_arrays(n,k, ::Type{T}, A, B) where {T} =
     (promote_to_arrays_(n[k], T, A), promote_to_arrays_(n[k+1], T, B))
-promote_to_arrays{T}(n,k, ::Type{T}, A, B, C) =
+promote_to_arrays(n,k, ::Type{T}, A, B, C) where {T} =
     (promote_to_arrays_(n[k], T, A), promote_to_arrays_(n[k+1], T, B), promote_to_arrays_(n[k+2], T, C))
-promote_to_arrays{T}(n,k, ::Type{T}, A, B, Cs...) =
+promote_to_arrays(n,k, ::Type{T}, A, B, Cs...) where {T} =
     (promote_to_arrays_(n[k], T, A), promote_to_arrays_(n[k+1], T, B), promote_to_arrays(n,k+2, T, Cs...)...)
-promote_to_array_type(A::Tuple{Vararg{Union{AbstractVecOrMat,UniformScaling}}}) = (@_pure_meta; Matrix)
+promote_to_array_type(A::Tuple{Vararg{Union{AbstractVecOrMat,UniformScaling}}}) = Matrix
 
 for (f,dim,name) in ((:hcat,1,"rows"), (:vcat,2,"cols"))
     @eval begin
@@ -275,3 +312,27 @@ function hvcat(rows::Tuple{Vararg{Int}}, A::Union{AbstractVecOrMat,UniformScalin
     end
     return hvcat(rows, promote_to_arrays(n,1, promote_to_array_type(A), A...)...)
 end
+
+
+## Cholesky
+function _chol!(J::UniformScaling, uplo)
+    c, info = _chol!(J.λ, uplo)
+    UniformScaling(c), info
+end
+
+chol!(J::UniformScaling, uplo) = ((J, info) = _chol!(J, uplo); @assertposdef J info)
+
+"""
+    chol(J::UniformScaling) -> C
+
+Compute the square root of a non-negative UniformScaling `J`.
+
+# Examples
+```jldoctest
+julia> chol(16I)
+UniformScaling{Float64}
+4.0*I
+```
+"""
+chol(J::UniformScaling, args...) = ((C, info) = _chol!(J, nothing); @assertposdef C info)
+
diff --git a/base/loading.jl b/base/loading.jl
index aa746cdb018203..b3660159184014 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -1,19 +1,19 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Base.require is the implementation for the `import` statement
 
 # Cross-platform case-sensitive path canonicalization
 
-if is_unix() && !is_apple()
+if Sys.isunix() && !Sys.isapple()
     # assume case-sensitive filesystems, don't have to do anything
     isfile_casesensitive(path) = isfile(path)
-elseif is_windows()
+elseif Sys.iswindows()
     # GetLongPathName Win32 function returns the case-preserved filename on NTFS.
     function isfile_casesensitive(path)
         isfile(path) || return false  # Fail fast
         basename(Filesystem.longpath(path)) == basename(path)
     end
-elseif is_apple()
+elseif Sys.isapple()
     # 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.
@@ -47,7 +47,7 @@ elseif is_apple()
         path_basename = String(basename(path))
         local casepreserved_basename
         const header_size = 12
-        buf = Array{UInt8}(length(path_basename) + header_size + 1)
+        buf = Vector{UInt8}(length(path_basename) + header_size + 1)
         while true
             ret = ccall(:getattrlist, Cint,
                         (Cstring, Ptr{Void}, Ptr{Void}, Csize_t, Culong),
@@ -120,14 +120,6 @@ end
 find_in_path(name::AbstractString, wd::AbstractString = pwd()) =
     find_in_path(String(name), String(wd))
 
-function find_in_node_path(name::String, srcpath, node::Int=1)
-    if myid() == node
-        return find_in_path(name, srcpath)
-    else
-        return remotecall_fetch(find_in_path, node, name, srcpath)
-    end
-end
-
 function find_source_file(file::String)
     (isabspath(file) || isfile(file)) && return file
     file2 = find_in_path(file)
@@ -158,45 +150,9 @@ function _include_from_serialized(path::String)
 end
 
 # returns an array of modules loaded, or an Exception that describes why it failed
-# and also attempts to load the same file across all nodes (if toplevel_node and myid() == master)
 # and it reconnects the Base.Docs.META
-function _require_from_serialized(node::Int, mod::Symbol, path_to_try::String, toplevel_load::Bool)
-    local restored = nothing
-    local content::Vector{UInt8}
-    if toplevel_load && myid() == 1 && nprocs() > 1
-        # broadcast top-level import/using from node 1 (only)
-        if node == myid()
-            content = open(read, path_to_try)
-        else
-            content = remotecall_fetch(open, node, read, path_to_try)
-        end
-        restored = _include_from_serialized(content)
-        isa(restored, Exception) && return restored
-        others = filter(x -> x != myid(), procs())
-        refs = Any[
-            (p, @spawnat(p,
-                let m = try
-                            _include_from_serialized(content)
-                        catch ex
-                            isa(ex, Exception) ? ex : ErrorException(string(ex))
-                        end
-                    isa(m, Exception) ? m : nothing
-                end))
-            for p in others ]
-        for (id, ref) in refs
-            m = fetch(ref)
-            if m !== nothing
-                warn("Node state is inconsistent: node $id failed to load cache from $path_to_try. Got:")
-                warn(m, prefix="WARNING: ")
-            end
-        end
-    elseif node == myid()
-        restored = _include_from_serialized(path_to_try)
-    else
-        content = remotecall_fetch(open, node, read, path_to_try)
-        restored = _include_from_serialized(content)
-    end
-
+function _require_from_serialized(mod::Symbol, path_to_try::String)
+    restored = _include_from_serialized(path_to_try)
     if !isa(restored, Exception)
         for M in restored::Vector{Any}
             if isdefined(M, Base.Docs.META)
@@ -210,18 +166,13 @@ end
 # returns `true` if require found a precompile cache for this mod, but couldn't load it
 # returns `false` if the module isn't known to be precompilable
 # returns the set of modules restored if the cache load succeeded
-function _require_search_from_serialized(node::Int, mod::Symbol, sourcepath::String, toplevel_load::Bool)
-    if node == myid()
-        paths = find_all_in_cache_path(mod)
-    else
-        paths = @fetchfrom node find_all_in_cache_path(mod)
-    end
-
+function _require_search_from_serialized(mod::Symbol, sourcepath::String)
+    paths = find_all_in_cache_path(mod)
     for path_to_try in paths::Vector{String}
         if stale_cachefile(sourcepath, path_to_try)
             continue
         end
-        restored = _require_from_serialized(node, mod, path_to_try, toplevel_load)
+        restored = _require_from_serialized(mod, path_to_try)
         if isa(restored, Exception)
             if isa(restored, ErrorException) && endswith(restored.msg, " uuid did not match cache file.")
                 # can't use this cache due to a module uuid mismatch,
@@ -246,16 +197,24 @@ const DEBUG_LOADING = Ref(false)
 # to synchronize multiple tasks trying to import/using something
 const package_locks = Dict{Symbol,Condition}()
 
+# to notify downstream consumers that a module was successfully loaded
+# Callbacks take the form (mod::Symbol) -> nothing.
+# WARNING: This is an experimental feature and might change later, without deprecation.
+const package_callbacks = Any[]
+
 # used to optionally track dependencies when requiring a module:
 const _concrete_dependencies = Any[] # these dependency versions are "set in stone", and the process should try to avoid invalidating them
 const _require_dependencies = Any[] # a list of (path, mtime) tuples that are the file dependencies of the module currently being precompiled
 const _track_dependencies = Ref(false) # set this to true to track the list of file dependencies
 function _include_dependency(_path::AbstractString)
     prev = source_path(nothing)
-    path = (prev === nothing) ? abspath(_path) : joinpath(dirname(prev), _path)
-    if myid() == 1 && _track_dependencies[]
-        apath = abspath(path)
-        push!(_require_dependencies, (apath, mtime(apath)))
+    if prev === nothing
+        path = abspath(_path)
+    else
+        path = joinpath(dirname(prev), _path)
+    end
+    if _track_dependencies[]
+        push!(_require_dependencies, (path, mtime(path)))
     end
     return path, prev
 end
@@ -301,8 +260,7 @@ Specify whether the file calling this function is precompilable. If `isprecompil
 `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.
+`__precompile__()` should occur before the `module` declaration in the file.
 
 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.
@@ -311,34 +269,13 @@ order to throw an error if Julia attempts to precompile it.
 using `__precompile__()`. Failure to do so can result in a runtime error when loading the module.
 """
 function __precompile__(isprecompilable::Bool=true)
-    if (myid() == 1 &&
-        JLOptions().use_compilecache != 0 &&
+    if (JLOptions().use_compilecache != 0 &&
         isprecompilable != (0 != ccall(:jl_generating_output, Cint, ())) &&
-        !(isprecompilable && toplevel_load::Bool))
+        !(isprecompilable && toplevel_load[]))
         throw(PrecompilableError(isprecompilable))
     end
 end
 
-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 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
-    return name
-end
-
 """
     reload(name::AbstractString)
 
@@ -346,17 +283,17 @@ Force reloading of a package, even if it has been loaded before. This is intende
 during package development as code is modified.
 """
 function reload(name::AbstractString)
-    if isfile(name) || contains(name,Filesystem.path_separator)
+    if contains(name, Filesystem.path_separator) || contains(name, ".")
         # 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_modname(name)))
+        require(Symbol(name))
     end
 end
 
 # require always works in Main scope and loads files from node 1
-toplevel_load = true
+const toplevel_load = Ref(true)
 
 """
     require(module::Symbol)
@@ -378,13 +315,32 @@ all platforms, including those with case-insensitive filesystems like macOS and
 Windows.
 """
 function require(mod::Symbol)
+    _require(mod)
+    # After successfully loading, notify downstream consumers
+    if toplevel_load[] && myid() == 1 && nprocs() > 1
+        # broadcast top-level import/using from node 1 (only)
+        @sync for p in procs()
+            p == 1 && continue
+            @async remotecall_wait(p) do
+                if !isbindingresolved(Main, mod) || !isdefined(Main, mod)
+                    _require(mod)
+                end
+            end
+        end
+    end
+    for callback in package_callbacks
+        invokelatest(callback, mod)
+    end
+end
+
+function _require(mod::Symbol)
     # dependency-tracking is only used for one top-level include(path),
     # and is not applied recursively to imported modules:
     old_track_dependencies = _track_dependencies[]
     _track_dependencies[] = false
     DEBUG_LOADING[] = haskey(ENV, "JULIA_DEBUG_LOADING")
 
-    global toplevel_load
+    # handle recursive calls to require
     loading = get(package_locks, mod, false)
     if loading !== false
         # load already in progress for this module
@@ -393,12 +349,12 @@ function require(mod::Symbol)
     end
     package_locks[mod] = Condition()
 
-    last = toplevel_load::Bool
+    last = toplevel_load[]
     try
-        toplevel_load = false
+        toplevel_load[] = false
         # perform the search operation to select the module file require intends to load
         name = string(mod)
-        path = find_in_node_path(name, nothing, 1)
+        path = find_in_path(name, nothing)
         if path === nothing
             throw(ArgumentError("Module $name not found in current path.\nRun `Pkg.add(\"$name\")` to install the $name package."))
         end
@@ -406,7 +362,7 @@ function require(mod::Symbol)
         # attempt to load the module file via the precompile cache locations
         doneprecompile = false
         if JLOptions().use_compilecache != 0
-            doneprecompile = _require_search_from_serialized(1, mod, path, last)
+            doneprecompile = _require_search_from_serialized(mod, path)
             if !isa(doneprecompile, Bool)
                 return # success
             end
@@ -426,10 +382,10 @@ function require(mod::Symbol)
         end
 
         if doneprecompile === true || JLOptions().incremental != 0
-            # spawn off a new incremental pre-compile task from node 1 for recursive `require` calls
+            # spawn off a new incremental pre-compile task for recursive `require` calls
             # or if the require search declared it was pre-compiled before (and therefore is expected to still be pre-compilable)
             cachefile = compilecache(mod)
-            m = _require_from_serialized(1, mod, cachefile, last)
+            m = _require_from_serialized(mod, cachefile)
             if isa(m, Exception)
                 warn("The call to compilecache failed to create a usable precompiled cache file for module $name. Got:")
                 warn(m, prefix="WARNING: ")
@@ -442,23 +398,14 @@ function require(mod::Symbol)
         # just load the file normally via include
         # for unknown dependencies
         try
-            if last && myid() == 1 && nprocs() > 1
-                # include on node 1 first to check for PrecompilableErrors
-                eval(Main, :(Base.include_from_node1($path)))
-
-                # broadcast top-level import/using from node 1 (only)
-                refs = Any[ @spawnat p eval(Main, :(Base.include_from_node1($path))) for p in filter(x -> x != 1, procs()) ]
-                for r in refs; wait(r); end
-            else
-                eval(Main, :(Base.include_from_node1($path)))
-            end
+            Base.include_relative(Main, path)
         catch ex
             if doneprecompile === true || JLOptions().use_compilecache == 0 || !precompilableerror(ex, true)
                 rethrow() # rethrow non-precompilable=true errors
             end
             # the file requested `__precompile__`, so try to build a cache file and use that
             cachefile = compilecache(mod)
-            m = _require_from_serialized(1, mod, cachefile, last)
+            m = _require_from_serialized(mod, cachefile)
             if isa(m, Exception)
                 warn(m, prefix="WARNING: ")
                 # TODO: disable __precompile__(true) error and do normal include instead of error
@@ -466,7 +413,7 @@ function require(mod::Symbol)
             end
         end
     finally
-        toplevel_load = last
+        toplevel_load[] = last
         loading = pop!(package_locks, mod)
         notify(loading, all=true)
         _track_dependencies[] = old_track_dependencies
@@ -474,20 +421,19 @@ function require(mod::Symbol)
     nothing
 end
 
-# remote/parallel load
+# relative-path load
 
 """
-    include_string(code::AbstractString, filename::AbstractString="string")
+    include_string(m::Module, code::AbstractString, filename::AbstractString="string")
 
-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.
+Like `include`, except reads code from the given string rather than from a file.
 """
-include_string(txt::String, fname::String) =
-    ccall(:jl_load_file_string, Any, (Ptr{UInt8},Csize_t,Cstring),
-          txt, sizeof(txt), fname)
+include_string(m::Module, txt::String, fname::String) =
+    ccall(:jl_load_file_string, Any, (Ptr{UInt8}, Csize_t, Cstring, Any),
+          txt, sizeof(txt), fname, m)
 
-include_string(txt::AbstractString, fname::AbstractString="string") =
-    include_string(String(txt), String(fname))
+include_string(m::Module, txt::AbstractString, fname::AbstractString="string") =
+    include_string(m, String(txt), String(fname))
 
 function source_path(default::Union{AbstractString,Void}="")
     t = current_task()
@@ -505,42 +451,17 @@ end
 
 function source_dir()
     p = source_path(nothing)
-    p === nothing ? p : dirname(p)
+    p === nothing ? pwd() : dirname(p)
 end
 
-"""
-    @__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`](@ref).
-"""
-macro __FILE__() source_path() end
-
-"""
-    @__DIR__ -> AbstractString
-
-`@__DIR__` expands to a string with the directory part of the absolute path of the file
-containing the macro. Returns `nothing` if run from a REPL or an empty string if
-evaluated by `julia -e <expr>`.
-"""
-macro __DIR__() source_dir() end
-
-include_from_node1(path::AbstractString) = include_from_node1(String(path))
-function include_from_node1(_path::String)
+include_relative(mod::Module, path::AbstractString) = include_relative(mod, String(path))
+function include_relative(mod::Module, _path::String)
     path, prev = _include_dependency(_path)
     tls = task_local_storage()
     tls[:SOURCE_PATH] = path
     local result
     try
-        if myid()==1
-            # sleep a bit to process file requests from other nodes
-            nprocs()>1 && sleep(0.005)
-            result = Core.include(path)
-            nprocs()>1 && sleep(0.005)
-        else
-            result = include_string(remotecall_fetch(readstring, 1, path), path)
-        end
+        result = Core.include(mod, path)
     finally
         if prev === nothing
             delete!(tls, :SOURCE_PATH)
@@ -548,17 +469,16 @@ function include_from_node1(_path::String)
             tls[:SOURCE_PATH] = prev
         end
     end
-    result
+    return result
 end
 
 """
-    include(path::AbstractString)
+    include(m::Module, path::AbstractString)
 
-Evaluate the contents of the input source file in the current context. Returns the result
+Evaluate the contents of the input source file into module `m`. Returns the result
 of the last evaluated expression of the input file. 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
+relative to that path. This function is typically used to load source
 interactively, or to combine files in packages that are broken into multiple source files.
 """
 include # defined in sysimg.jl
@@ -573,9 +493,10 @@ function evalfile(path::AbstractString, args::Vector{String}=String[])
     return eval(Module(:__anon__),
                 Expr(:toplevel,
                      :(const ARGS = $args),
-                     :(eval(x) = Main.Core.eval(__anon__,x)),
-                     :(eval(m,x) = Main.Core.eval(m,x)),
-                     :(Main.Base.include($path))))
+                     :(eval(x) = $(Expr(:core, :eval))(__anon__, x)),
+                     :(eval(m, x) = $(Expr(:core, :eval))(m, x)),
+                     :(include(x) = $(Expr(:top, :include))(__anon__, x)),
+                     :(include($path))))
 end
 evalfile(path::AbstractString, args::Vector) = evalfile(path, String[args...])
 
@@ -586,14 +507,15 @@ function create_expr_cache(input::String, output::String, concrete_deps::Vector{
             eval(Main, deserialize(STDIN))
         end
         """
-    io, pobj = open(pipeline(detach(`$(julia_cmd()) -O0
-                                    --output-ji $output --output-incremental=yes
-                                    --startup-file=no --history-file=no
-                                    --color=$(have_color ? "yes" : "no")
-                                    --eval $code_object`), stderr=STDERR),
-                    "w", STDOUT)
+    io = open(pipeline(detach(`$(julia_cmd()) -O0
+                              --output-ji $output --output-incremental=yes
+                              --startup-file=no --history-file=no
+                              --color=$(have_color ? "yes" : "no")
+                              --eval $code_object`), stderr=STDERR),
+              "w", STDOUT)
+    in = io.in
     try
-        serialize(io, quote
+        serialize(in, quote
                   empty!(Base.LOAD_PATH)
                   append!(Base.LOAD_PATH, $LOAD_PATH)
                   empty!(Base.LOAD_CACHE_PATH)
@@ -606,22 +528,21 @@ function create_expr_cache(input::String, output::String, concrete_deps::Vector{
                   end)
         source = source_path(nothing)
         if source !== nothing
-            serialize(io, quote
+            serialize(in, quote
                       task_local_storage()[:SOURCE_PATH] = $(source)
                       end)
         end
-        serialize(io, :(Base.include($(abspath(input)))))
+        serialize(in, :(Base.include(Main, $(abspath(input)))))
         if source !== nothing
-            serialize(io, :(delete!(task_local_storage(), :SOURCE_PATH)))
+            serialize(in, :(delete!(task_local_storage(), :SOURCE_PATH)))
         end
-        close(io)
-        wait(pobj)
-        return pobj
-    catch
-        kill(pobj)
-        close(io)
-        rethrow()
+        close(in)
+    catch ex
+        close(in)
+        process_running(io) && Timer(t -> kill(io), 5.0) # wait a short time before killing the process to give it a chance to clean up on its own first
+        rethrow(ex)
     end
+    return io
 end
 
 compilecache(mod::Symbol) = compilecache(string(mod))
@@ -637,7 +558,6 @@ This can be used to reduce package load times. Cache files are stored in
 for important notes.
 """
 function compilecache(name::String)
-    myid() == 1 || error("can only precompile from node 1")
     # decide where to get the source file from
     path = find_in_path(name, nothing)
     path === nothing && throw(ArgumentError("$name not found in path"))
@@ -669,7 +589,12 @@ function compilecache(name::String)
             info("Precompiling module $name.")
         end
     end
-    if !success(create_expr_cache(path, cachefile, concrete_deps))
+    if success(create_expr_cache(path, cachefile, concrete_deps))
+        # append checksum to the end of the .ji file:
+        open(cachefile, "a+") do f
+            write(f, hton(crc32c(seekstart(f))))
+        end
+    else
         error("Failed to precompile $name to $cachefile.")
     end
     return cachefile
@@ -699,7 +624,16 @@ function parse_cache_header(f::IO)
         push!(files, (String(read(f, n)), ntoh(read(f, Float64))))
     end
     @assert totbytes == 4 "header of cache file appears to be corrupt"
-    return modules, files
+    # read the list of modules that are required to be present during loading
+    required_modules = Dict{Symbol,UInt64}()
+    while true
+        n = ntoh(read(f, Int32))
+        n == 0 && break
+        sym = Symbol(read(f, n)) # module symbol
+        uuid = ntoh(read(f, UInt64)) # module UUID
+        required_modules[sym] = uuid
+    end
+    return modules, files, required_modules
 end
 
 function parse_cache_header(cachefile::String)
@@ -713,15 +647,7 @@ function parse_cache_header(cachefile::String)
 end
 
 function cache_dependencies(f::IO)
-    defs, files = parse_cache_header(f)
-    modules = []
-    while true
-        n = ntoh(read(f, Int32))
-        n == 0 && break
-        sym = Symbol(read(f, n)) # module symbol
-        uuid = ntoh(read(f, UInt64)) # module UUID (mostly just a timestamp)
-        push!(modules, (sym, uuid))
-    end
+    defs, files, modules = parse_cache_header(f)
     return modules, files
 end
 
@@ -742,7 +668,22 @@ function stale_cachefile(modpath::String, cachefile::String)
             DEBUG_LOADING[] && info("JL_DEBUG_LOADING: Rejecting cache file $cachefile due to it containing an invalid cache header.")
             return true # invalid cache file
         end
-        modules, files = parse_cache_header(io)
+        modules, files, required_modules = parse_cache_header(io)
+
+        # Check if transitive dependencies can be fullfilled
+        for mod in keys(required_modules)
+            if mod == :Main || mod == :Core || mod == :Base
+                continue
+            # Module is already loaded
+            elseif isbindingresolved(Main, mod)
+                continue
+            end
+            name = string(mod)
+            path = find_in_path(name, nothing)
+            if path === nothing
+                return true # Won't be able to fullfill dependency
+            end
+        end
 
         # check if this file is going to provide one of our concrete dependencies
         # or if it provides a version that conflicts with our concrete dependencies
@@ -765,14 +706,58 @@ function stale_cachefile(modpath::String, cachefile::String)
         end
         for (f, ftime_req) in files
             # Issue #13606: compensate for Docker images rounding mtimes
+            # Issue #20837: compensate for GlusterFS truncating mtimes to microseconds
             ftime = mtime(f)
-            if ftime != ftime_req && ftime != floor(ftime_req)
+            if ftime != ftime_req && ftime != floor(ftime_req) && ftime != trunc(ftime_req, 6)
                 DEBUG_LOADING[] && info("JL_DEBUG_LOADING: Rejecting stale cache file $cachefile (mtime $ftime_req) because file $f (mtime $ftime) has changed.")
                 return true
             end
         end
+
+        # finally, verify that the cache file has a valid checksum
+        crc = crc32c(seekstart(io), filesize(io)-4)
+        if crc != ntoh(read(io, UInt32))
+            DEBUG_LOADING[] && info("JL_DEBUG_LOADING: Rejecting cache file $cachefile because it has an invalid checksum.")
+            return true
+        end
+
         return false # fresh cachefile
     finally
         close(io)
     end
 end
+
+"""
+    @__LINE__ -> Int
+
+`@__LINE__` expands to the line number of the location of the macrocall.
+Returns `0` if the line number could not be determined.
+"""
+macro __LINE__()
+    return __source__.line
+end
+
+"""
+    @__FILE__ -> AbstractString
+
+`@__FILE__` expands to a string with the path to the file containing the
+macrocall, or an empty string if evaluated by `julia -e <expr>`.
+Returns `nothing` if the macro was missing parser source information.
+Alternatively see [`PROGRAM_FILE`](@ref).
+"""
+macro __FILE__()
+    __source__.file === nothing && return nothing
+    return String(__source__.file)
+end
+
+"""
+    @__DIR__ -> AbstractString
+
+`@__DIR__` expands to a string with the absolute path to the directory of the file
+containing the macrocall.
+Returns the current working directory if run from a REPL or if evaluated by `julia -e <expr>`.
+"""
+macro __DIR__()
+    __source__.file === nothing && return nothing
+    return abspath(dirname(String(__source__.file)))
+end
diff --git a/base/lock.jl b/base/lock.jl
index 00d0fb9a93d951..533795a1cf072a 100644
--- a/base/lock.jl
+++ b/base/lock.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Advisory reentrant lock
 """
diff --git a/base/locks.jl b/base/locks.jl
index c6c8d2b0552d2f..e674d5d8771914 100644
--- a/base/locks.jl
+++ b/base/locks.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 import Base: _uv_hook_close, unsafe_convert,
     lock, trylock, unlock, islocked
diff --git a/base/markdown/Common/Common.jl b/base/markdown/Common/Common.jl
index de021f7be1f2e3..10e4e7b492712f 100644
--- a/base/markdown/Common/Common.jl
+++ b/base/markdown/Common/Common.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 include("block.jl")
 include("inline.jl")
diff --git a/base/markdown/Common/block.jl b/base/markdown/Common/block.jl
index 0594ffe48fabc7..a0c4a095d3bae0 100644
--- a/base/markdown/Common/block.jl
+++ b/base/markdown/Common/block.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # ––––––––––
 # Paragraphs
@@ -77,7 +77,7 @@ function setextheader(stream::IO, md::MD)
     withstream(stream) do
         eatindent(stream) || return false
         header = strip(readline(stream))
-        header == "" && return false
+        isempty(header) && return false
 
         eatindent(stream) || return false
         underline = strip(readline(stream))
diff --git a/base/markdown/Common/inline.jl b/base/markdown/Common/inline.jl
index 1ef1171a9f6475..276504cc5a13e8 100644
--- a/base/markdown/Common/inline.jl
+++ b/base/markdown/Common/inline.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # ––––––––
 # Emphasis
diff --git a/base/markdown/GitHub/GitHub.jl b/base/markdown/GitHub/GitHub.jl
index e29fdf62cad6b2..ae2cfd1120f3a6 100644
--- a/base/markdown/GitHub/GitHub.jl
+++ b/base/markdown/GitHub/GitHub.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 include("table.jl")
 
diff --git a/base/markdown/GitHub/table.jl b/base/markdown/GitHub/table.jl
index dc31fad954143d..a8313e3fa66299 100644
--- a/base/markdown/GitHub/table.jl
+++ b/base/markdown/GitHub/table.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 mutable struct Table
     rows::Vector{Vector{Any}}
@@ -10,9 +10,9 @@ function parserow(stream::IO)
         line = readline(stream)
         row = split(line, r"(?<!\\)\|")
         length(row) == 1 && return
-        row[1] == "" && shift!(row)
+        isempty(row[1]) && shift!(row)
         map!(x -> strip(replace(x, "\\|", "|")), row, row)
-        row[end] == "" && pop!(row)
+        isempty(row[end]) && pop!(row)
         return row
     end
 end
@@ -45,7 +45,7 @@ function github_table(stream::IO, md::MD)
         align = nothing
         while (row = parserow(stream)) !== nothing
             if length(rows) == 0
-                row[1] == "" && return false
+                isempty(row[1]) && return false
                 cols = length(row)
             end
             if align === nothing && length(rows) == 1 # Must have a --- row
diff --git a/base/markdown/IPython/IPython.jl b/base/markdown/IPython/IPython.jl
index 1cceb3e616d4dd..665c45b84c6c8e 100644
--- a/base/markdown/IPython/IPython.jl
+++ b/base/markdown/IPython/IPython.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 mutable struct LaTeX
     formula::String
diff --git a/base/markdown/Julia/Julia.jl b/base/markdown/Julia/Julia.jl
index ab18b8d92eeaac..abc4b84385d30c 100644
--- a/base/markdown/Julia/Julia.jl
+++ b/base/markdown/Julia/Julia.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # This file contains markdown extensions designed to make documenting
 # Julia easy peasy.
diff --git a/base/markdown/Julia/interp.jl b/base/markdown/Julia/interp.jl
index 26be8e4a180a48..a1d0a4d7e37222 100644
--- a/base/markdown/Julia/interp.jl
+++ b/base/markdown/Julia/interp.jl
@@ -1,8 +1,8 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 function Base.parse(stream::IO; greedy::Bool = true, raise::Bool = true)
     pos = position(stream)
-    ex, Δ = Base.parse(readstring(stream), 1, greedy = greedy, raise = raise)
+    ex, Δ = Base.parse(read(stream, String), 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 453bbc59106a02..40f8b8955b2731 100644
--- a/base/markdown/Markdown.jl
+++ b/base/markdown/Markdown.jl
@@ -1,30 +1,30 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module Markdown
 
 import Base: show, ==
 import Core: @doc_str
 
-include("parse/config.jl")
-include("parse/util.jl")
-include("parse/parse.jl")
+include(joinpath("parse", "config.jl"))
+include(joinpath("parse", "util.jl"))
+include(joinpath("parse", "parse.jl"))
 
-include("Common/Common.jl")
-include("GitHub/GitHub.jl")
-include("IPython/IPython.jl")
-include("Julia/Julia.jl")
+include(joinpath("Common", "Common.jl"))
+include(joinpath("GitHub", "GitHub.jl"))
+include(joinpath("IPython", "IPython.jl"))
+include(joinpath("Julia", "Julia.jl"))
 
-include("render/plain.jl")
-include("render/html.jl")
-include("render/latex.jl")
-include("render/rst.jl")
+include(joinpath("render", "plain.jl"))
+include(joinpath("render", "html.jl"))
+include(joinpath("render", "latex.jl"))
+include(joinpath("render", "rst.jl"))
 
-include("render/terminal/render.jl")
+include(joinpath("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(readstring(file), flavor = flavor)
+parse_file(file::AbstractString; flavor = julia) = parse(read(file, String), 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)
@@ -37,25 +37,23 @@ function mdexpr(s, flavor = :julia)
     esc(toexpr(md))
 end
 
-function docexpr(s, flavor = :julia)
-    quote
-        let md = $(mdexpr(s, flavor))
-            md.meta[:path] = @__FILE__
-            md.meta[:module] = current_module()
-            md
-        end
-    end
+function docexpr(source::LineNumberNode, mod::Module, s, flavor = :julia)
+    :($doc_str($(mdexpr(s, flavor)), $(QuoteNode(source)), $mod))
 end
 
 macro md_str(s, t...)
     mdexpr(s, t...)
 end
 
-doc_str(md, file, mod) = (md.meta[:path] = file; md.meta[:module] = mod; md)
-doc_str(md::AbstractString, file, mod) = doc_str(parse(md), file, mod)
+function doc_str(md, source::LineNumberNode, mod::Module)
+    md.meta[:path] = isa(source.file, Symbol) ? String(source.file) : ""
+    md.meta[:module] = mod
+    md
+end
+doc_str(md::AbstractString, source::LineNumberNode, mod::Module) = doc_str(parse(md), source, mod)
 
 macro doc_str(s::AbstractString, t...)
-    :($(doc_str)($(mdexpr(s, t...)), $(Base).@__FILE__, $(current_module)()))
+    docexpr(__source__, __module__, s, t...)
 end
 
 function Base.display(d::Base.REPL.REPLDisplay, md::Vector{MD})
diff --git a/base/markdown/parse/config.jl b/base/markdown/parse/config.jl
index 0defc1f1fac082..14d3a7aa77a071 100644
--- a/base/markdown/parse/config.jl
+++ b/base/markdown/parse/config.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 const InnerConfig = Dict{Char, Vector{Function}}
 
@@ -25,7 +25,7 @@ triggers(f) = get(meta(f), :triggers, Set{Char}())
 # Macros
 
 isexpr(x::Expr, ts...) = x.head in ts
-isexpr{T}(x::T, ts...) = T in ts
+isexpr(x::T, ts...) where {T} = T in ts
 
 macro breaking(ex)
     isexpr(ex, :->) || error("invalid @breaking form, use ->")
diff --git a/base/markdown/parse/parse.jl b/base/markdown/parse/parse.jl
index c061ee6d10ee8a..b9a2f9c1f36c27 100644
--- a/base/markdown/parse/parse.jl
+++ b/base/markdown/parse/parse.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 mutable struct MD
     content::Vector{Any}
@@ -72,10 +72,6 @@ end
 parseinline(s::AbstractString, md::MD, c::Config) =
     parseinline(IOBuffer(s), md, c)
 
-# TODO remove once GH #9888 is fixed
-parseinline{T}(s::SubString{T}, md::MD, c::Config) =
-    parseinline(convert(T, s), md, c)
-
 parseinline(s, md::MD) = parseinline(s, md, config(md))
 
 # Block parsing
diff --git a/base/markdown/parse/util.jl b/base/markdown/parse/util.jl
index 9b5598bbf97541..26aa1e6f5932f0 100644
--- a/base/markdown/parse/util.jl
+++ b/base/markdown/parse/util.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 import Base: peek
 
@@ -200,7 +200,7 @@ end
 
 function showrest(io::IO)
     start = position(io)
-    show(readstring(io))
+    show(read(io, String))
     println()
     seek(io, start)
 end
diff --git a/base/markdown/render/html.jl b/base/markdown/render/html.jl
index 7e2f256f4aa5cd..2c350c666680d8 100644
--- a/base/markdown/render/html.jl
+++ b/base/markdown/render/html.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 include("rich.jl")
 
@@ -26,7 +26,7 @@ const _htmlescape_chars = Dict('<'=>"&lt;",   '>'=>"&gt;",
                                '"'=>"&quot;", '&'=>"&amp;",
                                # ' '=>"&nbsp;",
                                )
-for ch in "'`!\$\%()=+{}[]"
+for ch in "'`!\$%()=+{}[]"
     _htmlescape_chars[ch] = "&#$(Int(ch));"
 end
 
@@ -39,12 +39,12 @@ end
 function htmlesc(io::IO, s::Symbol)
     htmlesc(io, string(s))
 end
-function htmlesc(io::IO, xs::Union{AbstractString, Symbol}...)
+function htmlesc(io::IO, xs::Union{AbstractString,Symbol}...)
     for s in xs
         htmlesc(io, s)
     end
 end
-function htmlesc(s::Union{AbstractString, Symbol})
+function htmlesc(s::Union{AbstractString,Symbol})
     sprint(htmlesc, s)
 end
 
@@ -59,7 +59,7 @@ end
 
 html(io::IO, md::MD) = html(io, md.content)
 
-function html{l}(io::IO, header::Header{l})
+function html(io::IO, header::Header{l}) where l
     withtag(io, "h$l") do
         htmlinline(io, header.text)
     end
@@ -67,7 +67,7 @@ end
 
 function html(io::IO, code::Code)
     withtag(io, :pre) do
-        maybe_lang = code.language != "" ? Any[:class=>"language-$(code.language)"] : []
+        maybe_lang = !isempty(code.language) ? Any[:class=>"language-$(code.language)"] : []
         withtag(io, :code, maybe_lang...) do
             htmlesc(io, code.code)
             # TODO should print newline if this is longer than one line ?
@@ -139,7 +139,7 @@ function htmlinline(io::IO, code::Code)
     end
 end
 
-function htmlinline(io::IO, md::Union{Symbol, AbstractString})
+function htmlinline(io::IO, md::Union{Symbol,AbstractString})
     htmlesc(io, md)
 end
 
diff --git a/base/markdown/render/latex.jl b/base/markdown/render/latex.jl
index ae1277eeb6d834..fb0650c5d66037 100644
--- a/base/markdown/render/latex.jl
+++ b/base/markdown/render/latex.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 export latex
 
@@ -24,7 +24,7 @@ function latex(io::IO, content::Vector)
     end
 end
 
-function latex{l}(io::IO, header::Header{l})
+function latex(io::IO, header::Header{l}) where l
     tag = l < 4 ? "sub"^(l-1) * "section" : "sub"^(l-4) * "paragraph"
     wrapinline(io, tag) do
         latexinline(io, header.text)
diff --git a/base/markdown/render/plain.jl b/base/markdown/render/plain.jl
index 01a3a8994d939a..5d50b5c2080f1b 100644
--- a/base/markdown/render/plain.jl
+++ b/base/markdown/render/plain.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 plain(x) = sprint(plain, x)
 
@@ -13,7 +13,7 @@ end
 
 plain(io::IO, md::MD) = plain(io, md.content)
 
-function plain{l}(io::IO, header::Header{l})
+function plain(io::IO, header::Header{l}) where l
     print(io, "#"^l*" ")
     plaininline(io, header.text)
     println(io)
diff --git a/base/markdown/render/rich.jl b/base/markdown/render/rich.jl
index f3bdcefad460e6..01617b5c814045 100644
--- a/base/markdown/render/rich.jl
+++ b/base/markdown/render/rich.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 function tohtml(io::IO, m::MIME"text/html", x)
     show(io, m, x)
diff --git a/base/markdown/render/rst.jl b/base/markdown/render/rst.jl
index ca5661520beffc..d9fadc4e7910ea 100644
--- a/base/markdown/render/rst.jl
+++ b/base/markdown/render/rst.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 rst(x) = sprint(rst, x)
 
@@ -13,7 +13,7 @@ end
 
 rst(io::IO, md::MD) = rst(io, md.content)
 
-function rst{l}(io::IO, header::Header{l})
+function rst(io::IO, header::Header{l}) where l
     s = rstinline(header.text)
     println(io, s)
     println(io, string("*=-~:.^"[l])^length(s))
diff --git a/base/markdown/render/terminal/formatting.jl b/base/markdown/render/terminal/formatting.jl
index 1d14f1d60be211..36a4d390a7138c 100644
--- a/base/markdown/render/terminal/formatting.jl
+++ b/base/markdown/render/terminal/formatting.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Styles
 
diff --git a/base/markdown/render/terminal/render.jl b/base/markdown/render/terminal/render.jl
index c3f97fa5c38b84..f7313dc36b23f5 100644
--- a/base/markdown/render/terminal/render.jl
+++ b/base/markdown/render/terminal/render.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 include("formatting.jl")
 
@@ -77,7 +77,7 @@ end
 const _header_underlines = collect("≡=–-⋅ ")
 # TODO settle on another option with unicode e.g. "≡=≃–∼⋅" ?
 
-function term{l}(io::IO, md::Header{l}, columns)
+function term(io::IO, md::Header{l}, columns) where l
     underline = _header_underlines[l]
     _term_header(io, md, underline, columns)
 end
diff --git a/base/math.jl b/base/math.jl
index 9fae027458b00d..07e17d69d57c11 100644
--- a/base/math.jl
+++ b/base/math.jl
@@ -1,8 +1,8 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module Math
 
-export sin, cos, tan, sinh, cosh, tanh, asin, acos, atan,
+export sin, cos, sincos, tan, sinh, cosh, tanh, asin, acos, atan,
        asinh, acosh, atanh, sec, csc, cot, asec, acsc, acot,
        sech, csch, coth, asech, acsch, acoth,
        sinpi, cospi, sinc, cosc,
@@ -20,13 +20,33 @@ import Base: log, exp, sin, cos, tan, sinh, cosh, tanh, asin,
              max, min, minmax, ^, exp2, muladd, rem,
              exp10, expm1, log1p
 
-using Base: sign_mask, exponent_mask, exponent_one, exponent_bias,
-            exponent_half, exponent_max, exponent_raw_max, fpinttype,
-            significand_mask, significand_bits, exponent_bits
+using Base: sign_mask, exponent_mask, exponent_one,
+            exponent_half, fpinttype, significand_mask
 
-using Core.Intrinsics: sqrt_llvm, powi_llvm
+using Core.Intrinsics: sqrt_llvm
+
+const IEEEFloat = Union{Float16, Float32, Float64}
+
+@noinline function throw_complex_domainerror(f, x)
+    throw(DomainError(x, string("$f will only return a complex result if called with a ",
+                                "complex argument. Try $f(Complex(x)).")))
+end
+@noinline function throw_exp_domainerror(x)
+    throw(DomainError(x, string("Exponentiation yielding a complex result requires a ",
+                                "complex argument.\nReplace x^y with (x+0im)^y, ",
+                                "Complex(x)^y, or similar.")))
+end
+
+for T in (Float16, Float32, Float64)
+    @eval significand_bits(::Type{$T}) = $(trailing_ones(significand_mask(T)))
+    @eval exponent_bits(::Type{$T}) = $(sizeof(T)*8 - significand_bits(T) - 1)
+    @eval exponent_bias(::Type{$T}) = $(Int(exponent_one(T) >> significand_bits(T)))
+    # maximum float exponent
+    @eval exponent_max(::Type{$T}) = $(Int(exponent_mask(T) >> significand_bits(T)) - exponent_bias(T))
+    # maximum float exponent without bias
+    @eval exponent_raw_max(::Type{$T}) = $(Int(exponent_mask(T) >> significand_bits(T)))
+end
 
-const IEEEFloat = Union{Float16,Float32,Float64}
 # non-type specific math functions
 
 """
@@ -43,7 +63,7 @@ julia> clamp.([pi, 1.0, big(10.)], 2., 9.)
  9.000000000000000000000000000000000000000000000000000000000000000000000000000000
 ```
 """
-clamp{X,L,H}(x::X, lo::L, hi::H) =
+clamp(x::X, lo::L, hi::H) where {X,L,H} =
     ifelse(x > hi, convert(promote_type(X,L,H), hi),
            ifelse(x < lo,
                   convert(promote_type(X,L,H), lo),
@@ -114,7 +134,7 @@ macro evalpoly(z, p...)
              :(s = muladd(x, x, y*y)),
              as...,
              :(muladd($ai, tt, $b)))
-    R = Expr(:macrocall, Symbol("@horner"), :tt, map(esc, p)...)
+    R = Expr(:macrocall, Symbol("@horner"), (), :tt, map(esc, p)...)
     :(let tt = $(esc(z))
           isa(tt, Complex) ? $C : $R
       end)
@@ -145,13 +165,16 @@ julia> deg2rad(90)
 deg2rad(z::AbstractFloat) = z * (oftype(z, pi) / 180)
 rad2deg(z::Real) = rad2deg(float(z))
 deg2rad(z::Real) = deg2rad(float(z))
+rad2deg(z::Number) = (z/pi)*180
+deg2rad(z::Number) = (z*pi)/180
 
-log{T<:Number}(b::T, x::T) = log(x)/log(b)
+log(b::T, x::T) where {T<:Number} = log(x)/log(b)
 
 """
     log(b,x)
 
-Compute the base `b` logarithm of `x`. Throws [`DomainError`](@ref) for negative `Real` arguments.
+Compute the base `b` logarithm of `x`. Throws [`DomainError`](@ref) for negative
+[`Real`](@ref) arguments.
 
 ```jldoctest
 julia> log(4,8)
@@ -229,9 +252,8 @@ for f in (:cbrt, :sinh, :cosh, :tanh, :atan, :asinh, :exp2, :expm1)
         ($f)(x::Real) = ($f)(float(x))
     end
 end
-# pure julia exp function
-include("special/exp.jl")
 exp(x::Real) = exp(float(x))
+exp10(x::Real) = exp10(float(x))
 
 # fallback definitions to prevent infinite loop from $f(x::Real) def above
 
@@ -253,14 +275,29 @@ cbrt(x::AbstractFloat) = x < 0 ? -(-x)^(1//3) : x^(1//3)
 """
     exp2(x)
 
-Compute ``2^x``.
+Compute the base 2 exponential of `x`, in other words ``2^x``.
 
+# Examples
 ```jldoctest
 julia> exp2(5)
 32.0
 ```
 """
 exp2(x::AbstractFloat) = 2^x
+
+"""
+    exp10(x)
+
+Compute the base 10 exponential of `x`, in other words ``10^x``.
+
+# Examples
+```jldoctest
+julia> exp10(2)
+100.0
+```
+"""
+exp10(x::AbstractFloat) = 10^x
+
 for f in (:sinh, :cosh, :tanh, :atan, :asinh, :exp, :expm1)
     @eval ($f)(x::AbstractFloat) = error("not implemented for ", typeof(x))
 end
@@ -280,13 +317,10 @@ end
     end
 end
 
-# TODO: GNU libc has exp10 as an extension; should openlibm?
-exp10(x::Float64) = 10.0^x
-exp10(x::Float32) = 10.0f0^x
-exp10(x::Integer) = exp10(float(x))
-
 # utility for converting NaN return to DomainError
-@inline nan_dom_err(f, x) = isnan(f) & !isnan(x) ? throw(DomainError()) : f
+# the branch in nan_dom_err prevents its callers from inlining, so be sure to force it
+# until the heuristics can be improved
+@inline nan_dom_err(out, x) = isnan(out) & !isnan(x) ? throw(DomainError(x, "NaN result for non-NaN input.")) : out
 
 # functions that return NaN on non-NaN argument for domain error
 """
@@ -341,8 +375,8 @@ atanh(x)
 """
     log(x)
 
-Compute the natural logarithm of `x`. Throws [`DomainError`](@ref) for negative `Real` arguments.
-Use complex negative arguments to obtain complex results.
+Compute the natural logarithm of `x`. Throws [`DomainError`](@ref) for negative
+[`Real`](@ref) 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.
@@ -352,9 +386,10 @@ log(x)
 """
     log2(x)
 
-Compute the logarithm of `x` to base 2. Throws [`DomainError`](@ref) for negative `Real` arguments.
+Compute the logarithm of `x` to base 2. Throws [`DomainError`](@ref) for negative
+[`Real`](@ref) arguments.
 
-# Example
+# Examples
 ```jldoctest
 julia> log2(4)
 2.0
@@ -369,9 +404,9 @@ log2(x)
     log10(x)
 
 Compute the logarithm of `x` to base 10.
-Throws [`DomainError`](@ref) for negative `Real` arguments.
+Throws [`DomainError`](@ref) for negative [`Real`](@ref) arguments.
 
-# Example
+# Examples
 ```jldoctest
 julia> log10(100)
 2.0
@@ -385,7 +420,8 @@ log10(x)
 """
     log1p(x)
 
-Accurate natural logarithm of `1+x`. Throws [`DomainError`](@ref) for `Real` arguments less than -1.
+Accurate natural logarithm of `1+x`. Throws [`DomainError`](@ref) for [`Real`](@ref)
+arguments less than -1.
 
 There is an experimental variant in the `Base.Math.JuliaLibm` module, which is typically
 faster and more accurate.
@@ -403,20 +439,35 @@ log1p(x)
 for f in (:sin, :cos, :tan, :asin, :acos, :acosh, :atanh, :log, :log2, :log10,
           :lgamma, :log1p)
     @eval begin
-        ($f)(x::Float64) = nan_dom_err(ccall(($(string(f)),libm), Float64, (Float64,), x), x)
-        ($f)(x::Float32) = nan_dom_err(ccall(($(string(f,"f")),libm), Float32, (Float32,), x), x)
-        ($f)(x::Real) = ($f)(float(x))
+        @inline ($f)(x::Float64) = nan_dom_err(ccall(($(string(f)), libm), Float64, (Float64,), x), x)
+        @inline ($f)(x::Float32) = nan_dom_err(ccall(($(string(f, "f")), libm), Float32, (Float32,), x), x)
+        @inline ($f)(x::Real) = ($f)(float(x))
     end
 end
 
-sqrt(x::Float64) = sqrt_llvm(x)
-sqrt(x::Float32) = sqrt_llvm(x)
+"""
+    sincos(x)
+
+Compute sine and cosine of `x`, where `x` is in radians.
+"""
+@inline function sincos(x)
+    res = Base.FastMath.sincos_fast(x)
+    if (isnan(res[1]) | isnan(res[2])) & !isnan(x)
+        throw(DomainError(x, "NaN result for non-NaN input."))
+    end
+    return res
+end
+
+@inline function sqrt(x::Union{Float32,Float64})
+    x < zero(x) && throw_complex_domainerror(:sqrt, x)
+    sqrt_llvm(x)
+end
 
 """
     sqrt(x)
 
-Return ``\\sqrt{x}``. Throws [`DomainError`](@ref) for negative `Real` arguments. Use complex
-negative arguments instead.  The prefix operator `√` is equivalent to `sqrt`.
+Return ``\\sqrt{x}``. Throws [`DomainError`](@ref) for negative [`Real`](@ref) arguments.
+Use complex negative arguments instead. The prefix operator `√` is equivalent to `sqrt`.
 """
 sqrt(x::Real) = sqrt(float(x))
 
@@ -433,14 +484,16 @@ julia> hypot(a, a)
 1.4142135623730951e10
 
 julia> √(a^2 + a^2) # a^2 overflows
-ERROR: DomainError:
-sqrt will only return a complex result if called with a complex argument. Try sqrt(complex(x)).
+ERROR: DomainError with -2.914184810805068e18:
+sqrt will only return a complex result if called with a complex argument. Try sqrt(Complex(x)).
 Stacktrace:
- [1] sqrt(::Int64) at ./math.jl:421
+ [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
+ [2] sqrt at ./math.jl:462 [inlined]
+ [3] sqrt(::Int64) at ./math.jl:472
 ```
 """
 hypot(x::Number, y::Number) = hypot(promote(x, y)...)
-function hypot{T<:Number}(x::T, y::T)
+function hypot(x::T, y::T) where T<:Number
     ax = abs(x)
     ay = abs(y)
     if ax < ay
@@ -479,19 +532,19 @@ Compute the inverse tangent of `y/x`, using the signs of both `x` and `y` to det
 quadrant of the return value.
 """
 atan2(y::Real, x::Real) = atan2(promote(float(y),float(x))...)
-atan2{T<:AbstractFloat}(y::T, x::T) = Base.no_op_err("atan2", T)
+atan2(y::T, x::T) where {T<:AbstractFloat} = Base.no_op_err("atan2", T)
 
 atan2(y::Float64, x::Float64) = ccall((:atan2,libm), Float64, (Float64, Float64,), y, x)
 atan2(y::Float32, x::Float32) = ccall((:atan2f,libm), Float32, (Float32, Float32), y, x)
 
-max{T<:AbstractFloat}(x::T, y::T) = ifelse((y > x) | (signbit(y) < signbit(x)),
+max(x::T, y::T) where {T<:AbstractFloat} = ifelse((y > x) | (signbit(y) < signbit(x)),
                                     ifelse(isnan(x), x, y), ifelse(isnan(y), y, x))
 
 
-min{T<:AbstractFloat}(x::T, y::T) = ifelse((y < x) | (signbit(y) > signbit(x)),
+min(x::T, y::T) where {T<:AbstractFloat} = ifelse((y < x) | (signbit(y) > signbit(x)),
                                     ifelse(isnan(x), x, y), ifelse(isnan(y), y, x))
 
-minmax{T<:AbstractFloat}(x::T, y::T) =
+minmax(x::T, y::T) where {T<:AbstractFloat} =
     ifelse(isnan(x) | isnan(y), ifelse(isnan(x), (x,x), (y,y)),
            ifelse((y > x) | (signbit(x) > signbit(y)), (x,y), (y,x)))
 
@@ -501,13 +554,13 @@ minmax{T<:AbstractFloat}(x::T, y::T) =
 
 Compute ``x \\times 2^n``.
 
-# Example
+# Examples
 ```jldoctest
 julia> ldexp(5., 2)
 20.0
 ```
 """
-function ldexp{T<:IEEEFloat}(x::T, e::Integer)
+function ldexp(x::T, e::Integer) where T<:IEEEFloat
     xu = reinterpret(Unsigned, x)
     xs = xu & ~sign_mask(T)
     xs >= exponent_mask(T) && return x # NaN or Inf
@@ -556,12 +609,14 @@ ldexp(x::Float16, q::Integer) = Float16(ldexp(Float32(x), q))
 
 Get the exponent of a normalized floating-point number.
 """
-function exponent{T<:IEEEFloat}(x::T)
+function exponent(x::T) where T<:IEEEFloat
+    @noinline throw1(x) = throw(DomainError(x, "Cannot be NaN or Inf."))
+    @noinline throw2(x) = throw(DomainError(x, "Cannot be subnormal converted to 0."))
     xs = reinterpret(Unsigned, x) & ~sign_mask(T)
-    xs >= exponent_mask(T) && return throw(DomainError()) # NaN or Inf
+    xs >= exponent_mask(T) && throw1(x)
     k = Int(xs >> significand_bits(T))
     if k == 0 # x is subnormal
-        xs == 0 && throw(DomainError())
+        xs == 0 && throw2(x)
         m = leading_zeros(xs) - exponent_bits(T)
         k = 1 - m
     end
@@ -584,7 +639,7 @@ julia> significand(15.2)*8
 15.2
 ```
 """
-function significand{T<:IEEEFloat}(x::T)
+function significand(x::T) where T<:IEEEFloat
     xu = reinterpret(Unsigned, x)
     xs = xu & ~sign_mask(T)
     xs >= exponent_mask(T) && return x # NaN or Inf
@@ -604,7 +659,7 @@ end
 Return `(x,exp)` such that `x` has a magnitude in the interval ``[1/2, 1)`` or 0,
 and `val` is equal to ``x \\times 2^{exp}``.
 """
-function frexp{T<:IEEEFloat}(x::T)
+function frexp(x::T) where T<:IEEEFloat
     xu = reinterpret(Unsigned, x)
     xs = xu & ~sign_mask(T)
     xs >= exponent_mask(T) && return x, 0 # NaN or Inf
@@ -663,7 +718,7 @@ rem(x::Float16, y::Float16, r::RoundingMode{:Nearest}) = Float16(rem(Float32(x),
 Return a tuple (fpart,ipart) of the fractional and integral parts of a number. Both parts
 have the same sign as the argument.
 
-# Example
+# Examples
 ```jldoctest
 julia> modf(3.5)
 (0.5, 3.0)
@@ -671,27 +726,36 @@ julia> modf(3.5)
 """
 modf(x) = rem(x,one(x)), trunc(x)
 
-const _modff_temp = Ref{Float32}()
 function modf(x::Float32)
-    f = ccall((:modff,libm), Float32, (Float32,Ptr{Float32}), x, _modff_temp)
-    f, _modff_temp[]
+    temp = Ref{Float32}()
+    f = ccall((:modff, libm), Float32, (Float32, Ptr{Float32}), x, temp)
+    f, temp[]
 end
 
-const _modf_temp = Ref{Float64}()
 function modf(x::Float64)
-    f = ccall((:modf,libm), Float64, (Float64,Ptr{Float64}), x, _modf_temp)
-    f, _modf_temp[]
+    temp = Ref{Float64}()
+    f = ccall((:modf, libm), Float64, (Float64, Ptr{Float64}), x, temp)
+    f, temp[]
 end
 
-^(x::Float64, y::Float64) = nan_dom_err(ccall((:pow,libm),  Float64, (Float64,Float64), x, y), x+y)
-^(x::Float32, y::Float32) = nan_dom_err(ccall((:powf,libm), Float32, (Float32,Float32), x, y), x+y)
-
-^(x::Float64, y::Integer) = x^Int32(y)
-^(x::Float64, y::Int32) = powi_llvm(x, y)
-^(x::Float32, y::Integer) = x^Int32(y)
-^(x::Float32, y::Int32) = powi_llvm(x, y)
-^(x::Float16, y::Integer) = Float16(Float32(x)^y)
-^{p}(x::Float16, ::Type{Val{p}}) = Float16(Float32(x)^Val{p})
+@inline function ^(x::Float64, y::Float64)
+    z = ccall("llvm.pow.f64", llvmcall, Float64, (Float64, Float64), x, y)
+    if isnan(z) & !isnan(x+y)
+        throw_exp_domainerror(x)
+    end
+    z
+end
+@inline function ^(x::Float32, y::Float32)
+    z = ccall("llvm.pow.f32", llvmcall, Float32, (Float32, Float32), x, y)
+    if isnan(z) & !isnan(x+y)
+        throw_exp_domainerror(x)
+    end
+    z
+end
+@inline ^(x::Float64, y::Integer) = x ^ Float64(y)
+@inline ^(x::Float32, y::Integer) = x ^ Float32(y)
+@inline ^(x::Float16, y::Integer) = Float16(Float32(x) ^ Float32(y))
+@inline literal_pow(::typeof(^), x::Float16, ::Val{p}) where {p} = Float16(literal_pow(^,Float32(x),Val(p)))
 
 function angle_restrict_symm(theta)
     const P1 = 4 * 7.8539812564849853515625e-01
@@ -709,32 +773,16 @@ end
 ## rem2pi-related calculations ##
 
 function add22condh(xh::Float64, xl::Float64, yh::Float64, yl::Float64)
-    # as above, but only compute and return high double
+    # This algorithm, due to Dekker, computes the sum of two
+    # double-double numbers and returns the high double. References:
+    # [1] http://www.digizeitschriften.de/en/dms/img/?PID=GDZPPN001170007
+    # [2] https://dx.doi.org/10.1007/BF01397083
     r = xh+yh
     s = (abs(xh) > abs(yh)) ? (xh-r+yh+yl+xl) : (yh-r+xh+xl+yl)
     zh = r+s
     return zh
 end
 
-function ieee754_rem_pio2(x::Float64)
-    # rem_pio2 essentially computes x mod pi/2 (ie within a quarter circle)
-    # and returns the result as
-    # y between + and - pi/4 (for maximal accuracy (as the sign bit is exploited)), and
-    # n, where n specifies the integer part of the division, or, at any rate,
-    # in which quadrant we are.
-    # The invariant fulfilled by the returned values seems to be
-    #  x = y + n*pi/2 (where y = y1+y2 is a double-double and y2 is the "tail" of y).
-    # Note: for very large x (thus n), the invariant might hold only modulo 2pi
-    # (in other words, n might be off by a multiple of 4, or a multiple of 100)
-
-    # this is just wrapping up
-    # https://github.com/JuliaLang/openspecfun/blob/master/rem_pio2/e_rem_pio2.c
-
-    y = [0.0,0.0]
-    n = ccall((:__ieee754_rem_pio2, openspecfun), Cint, (Float64,Ptr{Float64}), x, y)
-    return (n,y)
-end
-
 # multiples of pi/2, as double-double (ie with "tail")
 const pi1o2_h  = 1.5707963267948966     # convert(Float64, pi * BigFloat(1/2))
 const pi1o2_l  = 6.123233995736766e-17  # convert(Float64, pi * BigFloat(1/2) - pi1o2_h)
@@ -769,7 +817,7 @@ without any intermediate rounding. This internally uses a high precision approxi
 
 - if `r == RoundUp`, then the result is in the interval ``[-2π, 0]``.
 
-# Example
+# Examples
 ```jldoctest
 julia> rem2pi(7pi/4, RoundNearest)
 -0.7853981633974485
@@ -782,23 +830,23 @@ function rem2pi end
 function rem2pi(x::Float64, ::RoundingMode{:Nearest})
     abs(x) < pi && return x
 
-    (n,y) = ieee754_rem_pio2(x)
+    n,y = rem_pio2_kernel(x)
 
     if iseven(n)
         if n & 2 == 2 # n % 4 == 2: add/subtract pi
-            if y[1] <= 0
-                return add22condh(y[1],y[2],pi2o2_h,pi2o2_l)
+            if y.hi <= 0
+                return add22condh(y.hi,y.lo,pi2o2_h,pi2o2_l)
             else
-                return add22condh(y[1],y[2],-pi2o2_h,-pi2o2_l)
+                return add22condh(y.hi,y.lo,-pi2o2_h,-pi2o2_l)
             end
         else          # n % 4 == 0: add 0
-            return y[1]
+            return y.hi+y.lo
         end
     else
         if n & 2 == 2 # n % 4 == 3: subtract pi/2
-            return add22condh(y[1],y[2],-pi1o2_h,-pi1o2_l)
+            return add22condh(y.hi,y.lo,-pi1o2_h,-pi1o2_l)
         else          # n % 4 == 1: add pi/2
-            return add22condh(y[1],y[2],pi1o2_h,pi1o2_l)
+            return add22condh(y.hi,y.lo,pi1o2_h,pi1o2_l)
         end
     end
 end
@@ -806,23 +854,23 @@ function rem2pi(x::Float64, ::RoundingMode{:ToZero})
     ax = abs(x)
     ax <= 2*Float64(pi,RoundDown) && return x
 
-    (n,y) = ieee754_rem_pio2(ax)
+    n,y = rem_pio2_kernel(x)
 
     if iseven(n)
         if n & 2 == 2 # n % 4 == 2: add pi
-            z = add22condh(y[1],y[2],pi2o2_h,pi2o2_l)
+            z = add22condh(y.hi,y.lo,pi2o2_h,pi2o2_l)
         else          # n % 4 == 0: add 0 or 2pi
-            if y[1] > 0
-                z = y[1]
+            if y.hi > 0
+                z = y.hi+y.lo
             else      # negative: add 2pi
-                z = add22condh(y[1],y[2],pi4o2_h,pi4o2_l)
+                z = add22condh(y.hi,y.lo,pi4o2_h,pi4o2_l)
             end
         end
     else
         if n & 2 == 2 # n % 4 == 3: add 3pi/2
-            z = add22condh(y[1],y[2],pi3o2_h,pi3o2_l)
+            z = add22condh(y.hi,y.lo,pi3o2_h,pi3o2_l)
         else          # n % 4 == 1: add pi/2
-            z = add22condh(y[1],y[2],pi1o2_h,pi1o2_l)
+            z = add22condh(y.hi,y.lo,pi1o2_h,pi1o2_l)
         end
     end
     copysign(z,x)
@@ -836,23 +884,23 @@ function rem2pi(x::Float64, ::RoundingMode{:Down})
         end
     end
 
-    (n,y) = ieee754_rem_pio2(x)
+    n,y = rem_pio2_kernel(x)
 
     if iseven(n)
         if n & 2 == 2 # n % 4 == 2: add pi
-            return add22condh(y[1],y[2],pi2o2_h,pi2o2_l)
+            return add22condh(y.hi,y.lo,pi2o2_h,pi2o2_l)
         else          # n % 4 == 0: add 0 or 2pi
-            if y[1] > 0
-                return y[1]
+            if y.hi > 0
+                return y.hi+y.lo
             else      # negative: add 2pi
-                return add22condh(y[1],y[2],pi4o2_h,pi4o2_l)
+                return add22condh(y.hi,y.lo,pi4o2_h,pi4o2_l)
             end
         end
     else
         if n & 2 == 2 # n % 4 == 3: add 3pi/2
-            return add22condh(y[1],y[2],pi3o2_h,pi3o2_l)
+            return add22condh(y.hi,y.lo,pi3o2_h,pi3o2_l)
         else          # n % 4 == 1: add pi/2
-            return add22condh(y[1],y[2],pi1o2_h,pi1o2_l)
+            return add22condh(y.hi,y.lo,pi1o2_h,pi1o2_l)
         end
     end
 end
@@ -865,23 +913,23 @@ function rem2pi(x::Float64, ::RoundingMode{:Up})
         end
     end
 
-    (n,y) = ieee754_rem_pio2(x)
+    n,y = rem_pio2_kernel(x)
 
     if iseven(n)
         if n & 2 == 2 # n % 4 == 2: sub pi
-            return add22condh(y[1],y[2],-pi2o2_h,-pi2o2_l)
+            return add22condh(y.hi,y.lo,-pi2o2_h,-pi2o2_l)
         else          # n % 4 == 0: sub 0 or 2pi
-            if y[1] < 0
-                return y[1]
+            if y.hi < 0
+                return y.hi+y.lo
             else      # positive: sub 2pi
-                return add22condh(y[1],y[2],-pi4o2_h,-pi4o2_l)
+                return add22condh(y.hi,y.lo,-pi4o2_h,-pi4o2_l)
             end
         end
     else
         if n & 2 == 2 # n % 4 == 3: sub pi/2
-            return add22condh(y[1],y[2],-pi1o2_h,-pi1o2_l)
+            return add22condh(y.hi,y.lo,-pi1o2_h,-pi1o2_l)
         else          # n % 4 == 1: sub 3pi/2
-            return add22condh(y[1],y[2],-pi3o2_h,-pi3o2_l)
+            return add22condh(y.hi,y.lo,-pi3o2_h,-pi3o2_l)
         end
     end
 end
@@ -904,7 +952,7 @@ This function computes a floating point representation of the modulus after divi
 numerically exact `2π`, and is therefore not exactly the same as `mod(x,2π)`, which would
 compute the modulus of `x` relative to division by the floating-point number `2π`.
 
-# Example
+# Examples
 ```jldoctest
 julia> mod2pi(9*pi/4)
 0.7853981633974481
@@ -917,11 +965,14 @@ mod2pi(x) = rem2pi(x,RoundDown)
 """
     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.
+Combined multiply-add, computes `x*y+z` allowing the add and multiply to be contracted with
+each other or ones from other `muladd` and `@fastmath` to form `fma`
+if the transformation can improve performance.
+The result can be different on different machines and can also be different on the same machine
+due to constant propagation or other optimizations.
 See [`fma`](@ref).
 
-# Example
+# Examples
 ```jldoctest
 julia> muladd(3, 2, 1)
 7
@@ -935,7 +986,7 @@ muladd(x,y,z) = x*y+z
 # Float16 definitions
 
 for func in (:sin,:cos,:tan,:asin,:acos,:atan,:sinh,:cosh,:tanh,:asinh,:acosh,
-             :atanh,:exp,:log,:log2,:log10,:sqrt,:lgamma,:log1p)
+             :atanh,:exp,:exp2,:exp10,:log,:log2,:log10,:sqrt,:lgamma,:log1p)
     @eval begin
         $func(a::Float16) = Float16($func(Float32(a)))
         $func(a::Complex32) = Complex32($func(Complex64(a)))
@@ -951,11 +1002,14 @@ end
 cbrt(a::Float16) = Float16(cbrt(Float32(a)))
 
 # More special functions
-include("special/trig.jl")
-include("special/gamma.jl")
+include(joinpath("special", "exp.jl"))
+include(joinpath("special", "exp10.jl"))
+include(joinpath("special", "trig.jl"))
+include(joinpath("special", "gamma.jl"))
+include(joinpath("special", "rem_pio2.jl"))
 
 module JuliaLibm
-include("special/log.jl")
+include(joinpath("special", "log.jl"))
 end
 
 end # module
diff --git a/base/meta.jl b/base/meta.jl
index 84bcc86255dad8..b5f5b8dc9d1451 100644
--- a/base/meta.jl
+++ b/base/meta.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module Meta
 #
@@ -7,13 +7,13 @@ module Meta
 
 export quot,
        isexpr,
-       show_sexpr
+       show_sexpr,
+       @dump
 
 quot(ex) = Expr(:quote, ex)
 
 isexpr(ex::Expr, head)          = ex.head === head
-isexpr(ex::Expr, heads::Set)    = in(ex.head, heads)
-isexpr(ex::Expr, heads::Vector) = in(ex.head, heads)
+isexpr(ex::Expr, heads::Union{Set,Vector,Tuple}) = in(ex.head, heads)
 isexpr(ex,       head)          = false
 
 isexpr(ex,       head, n::Int)  = isexpr(ex, head) && length(ex.args) == n
@@ -46,4 +46,14 @@ function show_sexpr(io::IO, ex::Expr, indent::Int)
     end
 end
 
+"""
+    @dump expr
+
+Show every part of the representation of the given expression. Equivalent to
+`dump(:(expr))`.
+"""
+macro dump(expr)
+    dump(expr)
+end
+
 end # module
diff --git a/base/methodshow.jl b/base/methodshow.jl
index bc58520dd7a92e..d273dcb38eee84 100644
--- a/base/methodshow.jl
+++ b/base/methodshow.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Method and method table pretty-printing
 
@@ -49,15 +49,11 @@ function arg_decl_parts(m::Method)
         push!(tv, sig.var)
         sig = sig.body
     end
-    if isdefined(m, :source)
-        src = m.source
-    else
-        src = nothing
-    end
     file = m.file
     line = m.line
-    if src !== nothing && src.slotnames !== nothing
-        argnames = src.slotnames[1:m.nargs]
+    if isdefined(m, :source) || isdefined(m, :generator)
+        argnames = Vector{Any}(m.nargs)
+        ccall(:jl_fill_argnames, Void, (Any, Any), isdefined(m, :source) ? m.source : m.generator.inferred, argnames)
         show_env = ImmutableDict{Symbol, Any}()
         for t in tv
             show_env = ImmutableDict(show_env, :unionall_env => t)
@@ -72,17 +68,17 @@ end
 
 function kwarg_decl(m::Method, kwtype::DataType)
     sig = rewrap_unionall(Tuple{kwtype, Core.AnyVector, unwrap_unionall(m.sig).parameters...}, m.sig)
-    kwli = ccall(:jl_methtable_lookup, Any, (Any, Any, UInt), kwtype.name.mt, sig, max_world(m))
+    kwli = ccall(:jl_methtable_lookup, Any, (Any, Any, UInt), kwtype.name.mt, sig, typemax(UInt))
     if kwli !== nothing
         kwli = kwli::Method
-        src = kwli.source
-        kws = filter(x->!('#' in string(x)), src.slotnames[kwli.nargs+1:end])
+        src = uncompressed_ast(kwli)
+        kws = filter(x -> !('#' in string(x)), src.slotnames[(kwli.nargs + 1):end])
         # ensure the kwarg... is always printed last. The order of the arguments are not
         # necessarily the same as defined in the function
         i = findfirst(x -> endswith(string(x), "..."), kws)
-        i==0 && return kws
+        i == 0 && return kws
         push!(kws, kws[i])
-        return deleteat!(kws,i)
+        return deleteat!(kws, i)
     end
     return ()
 end
@@ -101,15 +97,16 @@ end
 function show(io::IO, m::Method; kwtype::Nullable{DataType}=Nullable{DataType}())
     tv, decls, file, line = arg_decl_parts(m)
     sig = unwrap_unionall(m.sig)
-    ft = unwrap_unionall(sig.parameters[1])
+    ft0 = sig.parameters[1]
+    ft = unwrap_unionall(ft0)
     d1 = decls[1]
     if sig === Tuple
         print(io, m.name)
         decls = Any[(), ("...", "")]
-    elseif ft <: Function &&
+    elseif ft <: Function && isa(ft, DataType) &&
             isdefined(ft.name.module, ft.name.mt.name) &&
                 # TODO: more accurate test? (tn.name === "#" name)
-            ft == typeof(getfield(ft.name.module, ft.name.mt.name))
+            ft0 === typeof(getfield(ft.name.module, ft.name.mt.name))
         print(io, ft.name.mt.name)
     elseif isa(ft, DataType) && ft.name === Type.body.name && isconcrete(ft)
         f = ft.parameters[1]
@@ -154,11 +151,15 @@ function show_method_table(io::IO, ms::MethodList, max::Int=-1, header::Bool=tru
     kwtype = isdefined(mt, :kwsorter) ? Nullable{DataType}(typeof(mt.kwsorter)) : Nullable{DataType}()
     n = rest = 0
     local last
+
+    resize!(LAST_SHOWN_LINE_INFOS, 0)
     for meth in ms
        if max==-1 || n<max
+            n += 1
             println(io)
+            print(io, "[$(n)] ")
             show(io, meth; kwtype=kwtype)
-            n += 1
+            push!(LAST_SHOWN_LINE_INFOS, (string(meth.file), meth.line))
         else
             rest += 1
             last = meth
@@ -193,7 +194,7 @@ function url(m::Method)
     file = string(m.file)
     line = m.line
     line <= 0 || ismatch(r"In\[[0-9]+\]", file) && return ""
-    is_windows() && (file = replace(file, '\\', '/'))
+    Sys.iswindows() && (file = replace(file, '\\', '/'))
     if inbase(M)
         if isempty(Base.GIT_VERSION_INFO.commit)
             # this url will only work if we're on a tagged release
@@ -226,11 +227,12 @@ end
 function show(io::IO, ::MIME"text/html", m::Method; kwtype::Nullable{DataType}=Nullable{DataType}())
     tv, decls, file, line = arg_decl_parts(m)
     sig = unwrap_unionall(m.sig)
-    ft = sig.parameters[1]
+    ft0 = sig.parameters[1]
+    ft = unwrap_unionall(ft0)
     d1 = decls[1]
-    if ft <: Function &&
+    if ft <: Function && isa(ft, DataType) &&
             isdefined(ft.name.module, ft.name.mt.name) &&
-            ft == typeof(getfield(ft.name.module, ft.name.mt.name))
+            ft0 === typeof(getfield(ft.name.module, ft.name.mt.name))
         print(io, ft.name.mt.name)
     elseif isa(ft, DataType) && ft.name === Type.body.name && isconcrete(ft)
         f = ft.parameters[1]
@@ -289,7 +291,16 @@ end
 
 show(io::IO, mime::MIME"text/html", mt::MethodTable) = show(io, mime, MethodList(mt))
 
-# pretty-printing of Vector{Method} for output of methodswith:
+# pretty-printing of AbstractVector{Method} for output of methodswith:
+function show(io::IO, mime::MIME"text/plain", mt::AbstractVector{Method})
+    resize!(LAST_SHOWN_LINE_INFOS, 0)
+    for (i, m) in enumerate(mt)
+        print(io, "[$(i)] ")
+        show(io, m)
+        println(io)
+        push!(LAST_SHOWN_LINE_INFOS, (string(m.file), m.line))
+    end
+end
 
 function show(io::IO, mime::MIME"text/html", mt::AbstractVector{Method})
     print(io, summary(mt))
diff --git a/base/mmap.jl b/base/mmap.jl
index 6ff2707d6e5cec..edc8c332ee7a4c 100644
--- a/base/mmap.jl
+++ b/base/mmap.jl
@@ -1,8 +1,8 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module Mmap
 
-const PAGESIZE = Int(is_unix() ? ccall(:jl_getpagesize, Clong, ()) : ccall(:jl_getallocationgranularity, Clong, ()))
+const PAGESIZE = Int(Sys.isunix() ? ccall(:jl_getpagesize, Clong, ()) : ccall(:jl_getallocationgranularity, Clong, ()))
 
 # for mmaps not backed by files
 mutable struct Anonymous <: IO
@@ -21,13 +21,13 @@ const INVALID_HANDLE_VALUE = -1
 gethandle(io::Anonymous) = INVALID_HANDLE_VALUE
 
 # platform-specific mmap utilities
-if is_unix()
+if Sys.isunix()
 
 const PROT_READ     = Cint(1)
 const PROT_WRITE    = Cint(2)
 const MAP_SHARED    = Cint(1)
 const MAP_PRIVATE   = Cint(2)
-const MAP_ANONYMOUS = Cint(is_apple() ? 0x1000 : 0x20)
+const MAP_ANONYMOUS = Cint(Sys.isbsd() ? 0x1000 : 0x20)
 const F_GETFL       = Cint(3)
 
 gethandle(io::IO) = fd(io)
@@ -65,7 +65,7 @@ function grow!(io::IO, offset::Integer, len::Integer)
     return
 end
 
-elseif is_windows()
+elseif Sys.iswindows()
 
 const DWORD = Culong
 
@@ -94,17 +94,17 @@ else
 end # os-test
 
 # core implementation 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)
+function mmap(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) where {T,N}
     # 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 && return Array{T}(ntuple(x->0,Val{N}))
+    len == 0 && return Array{T}(ntuple(x->0,Val(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"))
@@ -116,7 +116,7 @@ function mmap{T,N}(io::IO,
 
     file_desc = gethandle(io)
     # platform-specific mmapping
-    @static if is_unix()
+    @static if Sys.isunix()
         prot, flags, iswrite = settings(file_desc, shared)
         iswrite && grow && grow!(io, offset, len)
         # mmap the file
@@ -138,7 +138,7 @@ function mmap{T,N}(io::IO,
     # convert mmapped region to Julia Array at `ptr + (offset - offset_page)` since file was mapped at offset_page
     A = unsafe_wrap(Array, convert(Ptr{T}, UInt(ptr) + UInt(offset - offset_page)), dims)
     finalizer(A, function(x)
-        @static if is_unix()
+        @static if Sys.isunix()
             systemerror("munmap",  ccall(:munmap, Cint, (Ptr{Void}, Int), ptr, mmaplen) != 0)
         else
             status = ccall(:UnmapViewOfFile, stdcall, Cint, (Ptr{Void},), ptr)!=0
@@ -149,24 +149,24 @@ function mmap{T,N}(io::IO,
     return A
 end
 
-mmap{T<:Array,N}(file::AbstractString,
-                 ::Type{T}=Vector{UInt8},
-                 dims::NTuple{N,Integer}=(div(filesize(file),sizeof(eltype(T))),),
-                 offset::Integer=Int64(0); grow::Bool=true, shared::Bool=true) =
+mmap(file::AbstractString,
+     ::Type{T}=Vector{UInt8},
+     dims::NTuple{N,Integer}=(div(filesize(file),sizeof(eltype(T))),),
+     offset::Integer=Int64(0); grow::Bool=true, shared::Bool=true) where {T<:Array,N} =
     open(io->mmap(io, T, dims, offset; grow=grow, shared=shared), file, isfile(file) ? "r+" : "w+")::Array{eltype(T),N}
 
 # using a length argument instead of dims
-mmap{T<:Array}(io::IO, ::Type{T}, len::Integer, offset::Integer=position(io); grow::Bool=true, shared::Bool=true) =
+mmap(io::IO, ::Type{T}, len::Integer, offset::Integer=position(io); grow::Bool=true, shared::Bool=true) where {T<:Array} =
     mmap(io, T, (len,), offset; grow=grow, shared=shared)
-mmap{T<:Array}(file::AbstractString, ::Type{T}, len::Integer, offset::Integer=Int64(0); grow::Bool=true, shared::Bool=true) =
+mmap(file::AbstractString, ::Type{T}, len::Integer, offset::Integer=Int64(0); grow::Bool=true, shared::Bool=true) where {T<:Array} =
     open(io->mmap(io, T, (len,), offset; grow=grow, shared=shared), file, isfile(file) ? "r+" : "w+")::Vector{eltype(T)}
 
 # constructors for non-file-backed (anonymous) mmaps
-mmap{T<:Array,N}(::Type{T}, dims::NTuple{N,Integer}; shared::Bool=true) = mmap(Anonymous(), T, dims, Int64(0); shared=shared)
-mmap{T<:Array}(::Type{T}, i::Integer...; shared::Bool=true) = mmap(Anonymous(), T, convert(Tuple{Vararg{Int}},i), Int64(0); shared=shared)
+mmap(::Type{T}, dims::NTuple{N,Integer}; shared::Bool=true) where {T<:Array,N} = mmap(Anonymous(), T, dims, Int64(0); shared=shared)
+mmap(::Type{T}, i::Integer...; shared::Bool=true) where {T<:Array} = mmap(Anonymous(), T, convert(Tuple{Vararg{Int}},i), Int64(0); shared=shared)
 
-function mmap{N}(io::IOStream, ::Type{<:BitArray}, dims::NTuple{N,Integer},
-                 offset::Int64=position(io); grow::Bool=true, shared::Bool=true)
+function mmap(io::IOStream, ::Type{<:BitArray}, dims::NTuple{N,Integer},
+              offset::Int64=position(io); grow::Bool=true, shared::Bool=true) where N
     n = prod(dims)
     nc = Base.num_bit_chunks(n)
     chunks = mmap(io, Vector{UInt64}, (nc,), offset; grow=grow, shared=shared)
@@ -177,7 +177,7 @@ function mmap{N}(io::IOStream, ::Type{<:BitArray}, dims::NTuple{N,Integer},
             throw(ArgumentError("the given file does not contain a valid BitArray of size $(join(dims, 'x')) (open with \"r+\" mode to override)"))
         end
     end
-    B = BitArray{N}(ntuple(i->0,Val{N})...)
+    B = BitArray{N}(ntuple(i->0,Val(N))...)
     B.chunks = chunks
     B.len = n
     if N != 1
@@ -186,28 +186,28 @@ function mmap{N}(io::IOStream, ::Type{<:BitArray}, dims::NTuple{N,Integer},
     return B
 end
 
-mmap{T<:BitArray,N}(file::AbstractString, ::Type{T}, dims::NTuple{N,Integer}, offset::Integer=Int64(0); grow::Bool=true, shared::Bool=true) =
+mmap(file::AbstractString, ::Type{T}, dims::NTuple{N,Integer}, offset::Integer=Int64(0);grow::Bool=true, shared::Bool=true) where {T<:BitArray,N} =
     open(io->mmap(io, T, dims, offset; grow=grow, shared=shared), file, isfile(file) ? "r+" : "w+")::BitArray{N}
 
 # using a length argument instead of dims
-mmap{T<:BitArray}(io::IO, ::Type{T}, len::Integer, offset::Integer=position(io); grow::Bool=true, shared::Bool=true) =
+mmap(io::IO, ::Type{T}, len::Integer, offset::Integer=position(io); grow::Bool=true, shared::Bool=true) where {T<:BitArray} =
     mmap(io, T, (len,), offset; grow=grow, shared=shared)
-mmap{T<:BitArray}(file::AbstractString, ::Type{T}, len::Integer, offset::Integer=Int64(0); grow::Bool=true, shared::Bool=true) =
+mmap(file::AbstractString, ::Type{T}, len::Integer, offset::Integer=Int64(0); grow::Bool=true, shared::Bool=true) where {T<:BitArray} =
     open(io->mmap(io, T, (len,), offset; grow=grow, shared=shared), file, isfile(file) ? "r+" : "w+")::BitVector
 
 # constructors for non-file-backed (anonymous) mmaps
-mmap{T<:BitArray,N}(::Type{T}, dims::NTuple{N,Integer}; shared::Bool=true) = mmap(Anonymous(), T, dims, Int64(0); shared=shared)
-mmap{T<:BitArray}(::Type{T}, i::Integer...; shared::Bool=true) = mmap(Anonymous(), T, convert(Tuple{Vararg{Int}},i), Int64(0); shared=shared)
+mmap(::Type{T}, dims::NTuple{N,Integer}; shared::Bool=true) where {T<:BitArray,N} = mmap(Anonymous(), T, dims, Int64(0); shared=shared)
+mmap(::Type{T}, i::Integer...; shared::Bool=true) where {T<:BitArray} = mmap(Anonymous(), T, convert(Tuple{Vararg{Int}},i), Int64(0); shared=shared)
 
 # msync flags for unix
 const MS_ASYNC = 1
 const MS_INVALIDATE = 2
 const MS_SYNC = 4
 
-function sync!{T}(m::Array{T}, flags::Integer=MS_SYNC)
+function sync!(m::Array{T}, flags::Integer=MS_SYNC) where T
     offset = rem(UInt(pointer(m)), PAGESIZE)
     ptr = pointer(m) - offset
-    @static if is_unix()
+    @static if Sys.isunix()
         systemerror("msync",
                     ccall(:msync, Cint, (Ptr{Void}, Csize_t, Cint), ptr, length(m) * sizeof(T), flags) != 0)
     else
diff --git a/base/mpfr.jl b/base/mpfr.jl
index 8592f2e75043aa..29644bd2e7bf4b 100644
--- a/base/mpfr.jl
+++ b/base/mpfr.jl
@@ -1,23 +1,23 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module MPFR
 
 export
     BigFloat,
-    setprecision,
-    big_str
+    setprecision
 
 import
     Base: (*), +, -, /, <, <=, ==, >, >=, ^, ceil, cmp, convert, copysign, div,
         exp, exp2, exponent, factorial, floor, fma, hypot, isinteger,
         isfinite, isinf, isnan, ldexp, log, log2, log10, max, min, mod, modf,
-        nextfloat, prevfloat, promote_rule, rem, rem2pi, round, show,
+        nextfloat, prevfloat, promote_rule, rem, rem2pi, round, show, float,
         sum, sqrt, string, print, trunc, precision, exp10, expm1,
         gamma, lgamma, log1p,
-        eps, signbit, sin, cos, tan, sec, csc, cot, acos, asin, atan,
+        eps, signbit, sin, cos, sincos, tan, sec, csc, cot, acos, asin, atan,
         cosh, sinh, tanh, sech, csch, coth, acosh, asinh, atanh, atan2,
         cbrt, typemax, typemin, unsafe_trunc, realmin, realmax, rounding,
-        setrounding, maxintfloat, widen, significand, frexp, tryparse, iszero
+        setrounding, maxintfloat, widen, significand, frexp, tryparse, iszero,
+        isone, big
 
 import Base.Rounding: rounding_raw, setrounding_raw
 
@@ -25,6 +25,11 @@ import Base.GMP: ClongMax, CulongMax, CdoubleMax, Limb
 
 import Base.Math.lgamma_r
 
+import Base.FastMath.sincos_fast
+
+get_version() = VersionNumber(unsafe_string(ccall((:mpfr_get_version,:libmpfr), Ptr{Cchar}, ())))
+get_patches() = split(unsafe_string(ccall((:mpfr_get_patches,:libmpfr), Ptr{Cchar}, ())),' ')
+
 function __init__()
     try
         # set exponent to full range by default
@@ -42,23 +47,9 @@ const DEFAULT_PRECISION = [256]
 # Basic type and initialization definitions
 
 """
-    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`](@ref), or using the `big` string literal.
+    BigFloat <: AbstractFloat
 
-```jldoctest
-julia> BigFloat(2.1)
-2.100000000000000088817841970012523233890533447265625000000000000000000000000000
-
-julia> big"2.1"
-2.099999999999999999999999999999999999999999999999999999999999999999999999999986
-```
+Arbitrary precision floating point number type.
 """
 mutable struct BigFloat <: AbstractFloat
     prec::Clong
@@ -80,6 +71,27 @@ mutable struct BigFloat <: AbstractFloat
     end
 end
 
+"""
+    BigFloat(x)
+
+Create an arbitrary precision floating point number. `x` may be an [`Integer`](@ref), a
+[`Float64`](@ref) or a [`BigInt`](@ref). The usual mathematical operators are defined for
+this type, and results are promoted to a [`BigFloat`](@ref).
+
+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`](@ref), or using the `big` string literal.
+
+```jldoctest
+julia> BigFloat(2.1)
+2.100000000000000088817841970012523233890533447265625000000000000000000000000000
+
+julia> big"2.1"
+2.099999999999999999999999999999999999999999999999999999999999999999999999999986
+```
+"""
+BigFloat(x)
+
 widen(::Type{Float64}) = BigFloat
 widen(::Type{BigFloat}) = BigFloat
 
@@ -119,11 +131,13 @@ end
 convert(::Type{Rational}, x::BigFloat) = convert(Rational{BigInt}, x)
 convert(::Type{AbstractFloat}, x::BigInt) = BigFloat(x)
 
+float(::Type{BigInt}) = BigFloat
+
 # generic constructor with arbitrary precision:
 """
     BigFloat(x, prec::Int)
 
-Create a representation of `x` as a `BigFloat` with precision `prec`.
+Create a representation of `x` as a [`BigFloat`](@ref) with precision `prec`.
 """
 function BigFloat(x, prec::Int)
     setprecision(BigFloat, prec) do
@@ -134,7 +148,8 @@ end
 """
     BigFloat(x, prec::Int, rounding::RoundingMode)
 
-Create a representation of `x` as a `BigFloat` with precision `prec` and rounding mode `rounding`.
+Create a representation of `x` as a [`BigFloat`](@ref) with precision `prec` and
+rounding mode `rounding`.
 """
 function BigFloat(x, prec::Int, rounding::RoundingMode)
     setrounding(BigFloat, rounding) do
@@ -145,7 +160,8 @@ end
 """
     BigFloat(x, rounding::RoundingMode)
 
-Create a representation of `x` as a `BigFloat` with the current global precision and rounding mode `rounding`.
+Create a representation of `x` as a [`BigFloat`](@ref) with the current global precision
+and rounding mode `rounding`.
 """
 function BigFloat(x::Union{Integer, AbstractFloat, String}, rounding::RoundingMode)
     BigFloat(x, precision(BigFloat), rounding)
@@ -154,7 +170,7 @@ end
 """
     BigFloat(x::String)
 
-Create a representation of the string `x` as a `BigFloat`.
+Create a representation of the string `x` as a [`BigFloat`](@ref).
 """
 BigFloat(x::String) = parse(BigFloat, x)
 
@@ -169,10 +185,10 @@ function unsafe_cast(::Type{UInt64}, x::BigFloat, ri::Cint)
           (Ptr{BigFloat}, Cint), &x, ri)
 end
 
-function unsafe_cast{T<:Signed}(::Type{T}, x::BigFloat, ri::Cint)
+function unsafe_cast(::Type{T}, x::BigFloat, ri::Cint) where T<:Signed
     unsafe_cast(Int64, x, ri) % T
 end
-function unsafe_cast{T<:Unsigned}(::Type{T}, x::BigFloat, ri::Cint)
+function unsafe_cast(::Type{T}, x::BigFloat, ri::Cint) where T<:Unsigned
     unsafe_cast(UInt64, x, ri) % T
 end
 
@@ -185,25 +201,25 @@ function unsafe_cast(::Type{BigInt}, x::BigFloat, ri::Cint)
 end
 unsafe_cast(::Type{Int128}, x::BigFloat, ri::Cint) = Int128(unsafe_cast(BigInt,x,ri))
 unsafe_cast(::Type{UInt128}, x::BigFloat, ri::Cint) = UInt128(unsafe_cast(BigInt,x,ri))
-unsafe_cast{T<:Integer}(::Type{T}, x::BigFloat, r::RoundingMode) = unsafe_cast(T,x,to_mpfr(r))
+unsafe_cast(::Type{T}, x::BigFloat, r::RoundingMode) where {T<:Integer} = unsafe_cast(T,x,to_mpfr(r))
 
-unsafe_trunc{T<:Integer}(::Type{T}, x::BigFloat) = unsafe_cast(T,x,RoundToZero)
+unsafe_trunc(::Type{T}, x::BigFloat) where {T<:Integer} = unsafe_cast(T,x,RoundToZero)
 
-function trunc{T<:Union{Signed,Unsigned}}(::Type{T}, x::BigFloat)
-    (typemin(T) <= x <= typemax(T)) || throw(InexactError())
+function trunc(::Type{T}, x::BigFloat) where T<:Union{Signed,Unsigned}
+    (typemin(T) <= x <= typemax(T)) || throw(InexactError(:trunc, T, x))
     unsafe_cast(T,x,RoundToZero)
 end
-function floor{T<:Union{Signed,Unsigned}}(::Type{T}, x::BigFloat)
-    (typemin(T) <= x <= typemax(T)) || throw(InexactError())
+function floor(::Type{T}, x::BigFloat) where T<:Union{Signed,Unsigned}
+    (typemin(T) <= x <= typemax(T)) || throw(InexactError(:floor, T, x))
     unsafe_cast(T,x,RoundDown)
 end
-function ceil{T<:Union{Signed,Unsigned}}(::Type{T}, x::BigFloat)
-    (typemin(T) <= x <= typemax(T)) || throw(InexactError())
+function ceil(::Type{T}, x::BigFloat) where T<:Union{Signed,Unsigned}
+    (typemin(T) <= x <= typemax(T)) || throw(InexactError(:ceil, T, x))
     unsafe_cast(T,x,RoundUp)
 end
 
-function round{T<:Union{Signed,Unsigned}}(::Type{T}, x::BigFloat)
-    (typemin(T) <= x <= typemax(T)) || throw(InexactError())
+function round(::Type{T}, x::BigFloat) where T<:Union{Signed,Unsigned}
+    (typemin(T) <= x <= typemax(T)) || throw(InexactError(:round, T, x))
     unsafe_cast(T,x,ROUNDING_MODE[])
 end
 
@@ -218,40 +234,43 @@ floor(::Type{Integer}, x::BigFloat) = floor(BigInt, x)
 ceil(::Type{Integer}, x::BigFloat) = ceil(BigInt, x)
 round(::Type{Integer}, x::BigFloat) = round(BigInt, x)
 
-convert(::Type{Bool}, x::BigFloat) = x==0 ? false : x==1 ? true : throw(InexactError())
+convert(::Type{Bool}, x::BigFloat) = x==0 ? false : x==1 ? true :
+    throw(InexactError(:convert, Bool, x))
 function convert(::Type{BigInt},x::BigFloat)
-    isinteger(x) || throw(InexactError())
+    isinteger(x) || throw(InexactError(:convert, BigInt, x))
     trunc(BigInt,x)
 end
 
-function convert(::Type{Integer},x::BigFloat)
-    isinteger(x) || throw(InexactError())
+function convert(::Type{Integer}, x::BigFloat)
+    isinteger(x) || throw(InexactError(:convert, Integer, x))
     trunc(Integer,x)
 end
-function convert{T<:Integer}(::Type{T},x::BigFloat)
-    isinteger(x) || throw(InexactError())
+function convert(::Type{T},x::BigFloat) where T<:Integer
+    isinteger(x) || throw(InexactError(:convert, T, x))
     trunc(T,x)
 end
 
 ## BigFloat -> AbstractFloat
 convert(::Type{Float64}, x::BigFloat) =
-    ccall((:mpfr_get_d,:libmpfr), Float64, (Ptr{BigFloat},Int32), &x, ROUNDING_MODE[])
+    ccall((:mpfr_get_d,:libmpfr), Float64, (Ptr{BigFloat}, Int32), &x, ROUNDING_MODE[])
 convert(::Type{Float32}, x::BigFloat) =
-    ccall((:mpfr_get_flt,:libmpfr), Float32, (Ptr{BigFloat},Int32), &x, ROUNDING_MODE[])
+    ccall((:mpfr_get_flt,:libmpfr), Float32, (Ptr{BigFloat}, Int32), &x, ROUNDING_MODE[])
 # TODO: avoid double rounding
 convert(::Type{Float16}, x::BigFloat) = convert(Float16, convert(Float32, x))
 
-(::Type{Float64})(x::BigFloat, r::RoundingMode) =
-    ccall((:mpfr_get_d,:libmpfr), Float64, (Ptr{BigFloat},Int32), &x, to_mpfr(r))
-(::Type{Float32})(x::BigFloat, r::RoundingMode) =
-    ccall((:mpfr_get_flt,:libmpfr), Float32, (Ptr{BigFloat},Int32), &x, to_mpfr(r))
+Float64(x::BigFloat, r::RoundingMode) =
+    ccall((:mpfr_get_d,:libmpfr), Float64, (Ptr{BigFloat}, Int32), &x, to_mpfr(r))
+Float32(x::BigFloat, r::RoundingMode) =
+    ccall((:mpfr_get_flt,:libmpfr), Float32, (Ptr{BigFloat}, Int32), &x, to_mpfr(r))
 # TODO: avoid double rounding
-(::Type{Float16})(x::BigFloat, r::RoundingMode) =
+Float16(x::BigFloat, r::RoundingMode) =
     convert(Float16, Float32(x, r))
 
 promote_rule(::Type{BigFloat}, ::Type{<:Real}) = BigFloat
-promote_rule(::Type{BigInt},::Type{<:AbstractFloat}) = BigFloat
-promote_rule(::Type{BigFloat},::Type{<:AbstractFloat}) = BigFloat
+promote_rule(::Type{BigInt}, ::Type{<:AbstractFloat}) = BigFloat
+promote_rule(::Type{BigFloat}, ::Type{<:AbstractFloat}) = BigFloat
+
+big(::Type{<:AbstractFloat}) = BigFloat
 
 function convert(::Type{Rational{BigInt}}, x::AbstractFloat)
     if isnan(x); return zero(BigInt)//zero(BigInt); end
@@ -470,7 +489,7 @@ function sqrt(x::BigFloat)
     z = BigFloat()
     ccall((:mpfr_sqrt, :libmpfr), Int32, (Ptr{BigFloat}, Ptr{BigFloat}, Int32), &z, &x, ROUNDING_MODE[])
     if isnan(z)
-        throw(DomainError())
+        throw(DomainError(x, "NaN result for non-NaN input."))
     end
     return z
 end
@@ -504,9 +523,6 @@ end
 ^(x::BigFloat, y::Integer)  = typemin(Clong)  <= y <= typemax(Clong)  ? x^Clong(y)  : x^BigInt(y)
 ^(x::BigFloat, y::Unsigned) = typemin(Culong) <= y <= typemax(Culong) ? x^Culong(y) : x^BigInt(y)
 
-# override default inlining of x^2 etc.
-^{p}(x::BigFloat, ::Type{Val{p}}) = x^Culong(p)
-
 for f in (:exp, :exp2, :exp10, :expm1, :cosh, :sinh, :tanh, :sech, :csch, :coth, :cbrt)
     @eval function $f(x::BigFloat)
         z = BigFloat()
@@ -515,6 +531,15 @@ for f in (:exp, :exp2, :exp10, :expm1, :cosh, :sinh, :tanh, :sech, :csch, :coth,
     end
 end
 
+function sincos_fast(v::BigFloat)
+    s = BigFloat()
+    c = BigFloat()
+    ccall((:mpfr_sin_cos, :libmpfr), Int32, (Ptr{BigFloat}, Ptr{BigFloat}, Ptr{BigFloat}, Int32),
+          &s, &c, &v, ROUNDING_MODE[])
+    return (s, c)
+end
+sincos(v::BigFloat) = sincos_fast(v)
+
 # return log(2)
 function big_ln2()
     c = BigFloat()
@@ -539,7 +564,7 @@ ldexp(x::BigFloat, n::Integer) = x*exp2(BigFloat(n))
 
 function factorial(x::BigFloat)
     if x < 0 || !isinteger(x)
-        throw(DomainError())
+        throw(DomainError(x, "Must be a non-negative integer."))
     end
     ui = convert(Culong, x)
     z = BigFloat()
@@ -556,7 +581,8 @@ end
 for f in (:log, :log2, :log10)
     @eval function $f(x::BigFloat)
         if x < 0
-            throw(DomainError())
+            throw(DomainError(x, string($f, " will only return a complex result if called ",
+                              "with a complex argument. Try ", $f, "(complex(x)).")))
         end
         z = BigFloat()
         ccall(($(string(:mpfr_,f)), :libmpfr), Int32, (Ptr{BigFloat}, Ptr{BigFloat}, Int32), &z, &x, ROUNDING_MODE[])
@@ -566,7 +592,8 @@ end
 
 function log1p(x::BigFloat)
     if x < -1
-        throw(DomainError())
+        throw(DomainError(x, string("log1p will only return a complex result if called ",
+                                    "with a complex argument. Try log1p(complex(x)).")))
     end
     z = BigFloat()
     ccall((:mpfr_log1p, :libmpfr), Int32, (Ptr{BigFloat}, Ptr{BigFloat}, Int32), &z, &x, ROUNDING_MODE[])
@@ -635,7 +662,7 @@ for f in (:sin,:cos,:tan,:sec,:csc,
             z = BigFloat()
             ccall(($(string(:mpfr_,f)), :libmpfr), Int32, (Ptr{BigFloat}, Ptr{BigFloat}, Int32), &z, &x, ROUNDING_MODE[])
             if isnan(z)
-                throw(DomainError())
+                throw(DomainError(x, "NaN result for non-NaN input."))
             end
             return z
         end
@@ -643,14 +670,14 @@ for f in (:sin,:cos,:tan,:sec,:csc,
 end
 
 # log of absolute value of gamma function
-const lgamma_signp = Array{Cint}(1)
+const lgamma_signp = Ref{Cint}()
 function lgamma(x::BigFloat)
     z = BigFloat()
     ccall((:mpfr_lgamma,:libmpfr), Cint, (Ptr{BigFloat}, Ptr{Cint}, Ptr{BigFloat}, Int32), &z, lgamma_signp, &x, ROUNDING_MODE[])
     return z
 end
 
-lgamma_r(x::BigFloat) = (lgamma(x), lgamma_signp[1])
+lgamma_r(x::BigFloat) = (lgamma(x), lgamma_signp[])
 
 function atan2(y::BigFloat, x::BigFloat)
     z = BigFloat()
@@ -666,22 +693,23 @@ end
 >(x::BigFloat, y::BigFloat) = ccall((:mpfr_greater_p, :libmpfr), Int32, (Ptr{BigFloat}, Ptr{BigFloat}), &x, &y) != 0
 
 function cmp(x::BigFloat, y::BigInt)
-    isnan(x) && throw(DomainError())
+    isnan(x) && throw(DomainError(x, "`x` cannot be NaN."))
     ccall((:mpfr_cmp_z, :libmpfr), Int32, (Ptr{BigFloat}, Ptr{BigInt}), &x, &y)
 end
 function cmp(x::BigFloat, y::ClongMax)
-    isnan(x) && throw(DomainError())
+    isnan(x) && throw(DomainError(x, "`x` cannot be NaN."))
     ccall((:mpfr_cmp_si, :libmpfr), Int32, (Ptr{BigFloat}, Clong), &x, y)
 end
 function cmp(x::BigFloat, y::CulongMax)
-    isnan(x) && throw(DomainError())
+    isnan(x) && throw(DomainError(x, "`x` cannot be NaN."))
     ccall((:mpfr_cmp_ui, :libmpfr), Int32, (Ptr{BigFloat}, Culong), &x, y)
 end
 cmp(x::BigFloat, y::Integer) = cmp(x,big(y))
 cmp(x::Integer, y::BigFloat) = -cmp(y,x)
 
 function cmp(x::BigFloat, y::CdoubleMax)
-    (isnan(x) || isnan(y)) && throw(DomainError())
+    isnan(x) && throw(DomainError(x, "`x` cannot be NaN."))
+    isnan(y) && throw(DomainError(y, "`y` cannot be NaN."))
     ccall((:mpfr_cmp_d, :libmpfr), Int32, (Ptr{BigFloat}, Cdouble), &x, y)
 end
 cmp(x::CdoubleMax, y::BigFloat) = -cmp(y,x)
@@ -710,7 +738,7 @@ end
 """
     precision(BigFloat)
 
-Get the precision (in bits) currently used for `BigFloat` arithmetic.
+Get the precision (in bits) currently used for [`BigFloat`](@ref) arithmetic.
 """
 precision(::Type{BigFloat}) = DEFAULT_PRECISION[end]  # precision of the type BigFloat itself
 
@@ -721,7 +749,7 @@ Set the precision (in bits) to be used for `T` arithmetic.
 """
 function setprecision(::Type{BigFloat}, precision::Int)
     if precision < 2
-        throw(DomainError())
+        throw(DomainError(precision, "`precision` cannot be less than 2."))
     end
     DEFAULT_PRECISION[end] = precision
 end
@@ -768,7 +796,7 @@ end
 
 function exponent(x::BigFloat)
     if x == 0 || !isfinite(x)
-        throw(DomainError())
+        throw(DomainError(x, "`x` must be non-zero and finite."))
     end
     # The '- 1' is to make it work as Base.exponent
     return ccall((:mpfr_get_exp, :libmpfr), Clong, (Ptr{BigFloat},), &x) - 1
@@ -826,6 +854,7 @@ end
 isfinite(x::BigFloat) = !isinf(x) && !isnan(x)
 
 iszero(x::BigFloat) = x == Clong(0)
+isone(x::BigFloat) = x == Clong(1)
 
 @eval typemax(::Type{BigFloat}) = $(BigFloat( Inf))
 @eval typemin(::Type{BigFloat}) = $(BigFloat(-Inf))
@@ -864,7 +893,7 @@ It is logically equivalent to:
 
 Often used as `setprecision(T, precision) do ... end`
 """
-function setprecision{T}(f::Function, ::Type{T}, prec::Integer)
+function setprecision(f::Function, ::Type{T}, prec::Integer) where T
     old_prec = precision(T)
     setprecision(T, prec)
     try
diff --git a/base/multidimensional.jl b/base/multidimensional.jl
index 283b4d6801bc52..36afa13727d0bd 100644
--- a/base/multidimensional.jl
+++ b/base/multidimensional.jl
@@ -1,18 +1,63 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ### Multidimensional iterators
 module IteratorsMD
-    import Base: eltype, length, size, start, done, next, last, in, getindex,
+    import Base: eltype, length, size, start, done, next, first, last, in, getindex,
                  setindex!, IndexStyle, min, max, zero, one, isless, eachindex,
                  ndims, iteratorsize, convert
 
-    importall ..Base.Operators
+    import Base: +, -, *
     import Base: simd_outer_range, simd_inner_length, simd_index
     using Base: IndexLinear, IndexCartesian, AbstractCartesianIndex, fill_to_length, tail
 
     export CartesianIndex, CartesianRange
 
-    # CartesianIndex
+    """
+        CartesianIndex(i, j, k...)   -> I
+        CartesianIndex((i, j, k...)) -> I
+
+    Create a multidimensional index `I`, which can be used for
+    indexing a multidimensional array `A`.  In particular, `A[I]` is
+    equivalent to `A[i,j,k...]`.  One can freely mix integer and
+    `CartesianIndex` indices; for example, `A[Ipre, i, Ipost]` (where
+    `Ipre` and `Ipost` are `CartesianIndex` indices and `i` is an
+    `Int`) can be a useful expression when writing algorithms that
+    work along a single dimension of an array of arbitrary
+    dimensionality.
+
+    A `CartesianIndex` is sometimes produced by [`eachindex`](@ref), and
+    always when iterating with an explicit [`CartesianRange`](@ref).
+
+    # Examples
+    ```jldoctest
+    julia> A = reshape(collect(1:16), (2, 2, 2, 2))
+    2×2×2×2 Array{Int64,4}:
+    [:, :, 1, 1] =
+     1  3
+     2  4
+
+    [:, :, 2, 1] =
+     5  7
+     6  8
+
+    [:, :, 1, 2] =
+      9  11
+     10  12
+
+    [:, :, 2, 2] =
+     13  15
+     14  16
+
+    julia> A[CartesianIndex((1, 1, 1, 1))]
+    1
+
+    julia> A[CartesianIndex((1, 1, 1, 2))]
+    9
+
+    julia> A[CartesianIndex((1, 1, 2, 1))]
+    5
+    ```
+    """
     struct CartesianIndex{N} <: AbstractCartesianIndex{N}
         I::NTuple{N,Int}
         CartesianIndex{N}(index::NTuple{N,Integer}) where {N} = new(index)
@@ -22,7 +67,7 @@ module IteratorsMD
     CartesianIndex(index::Integer...) = CartesianIndex(index)
     CartesianIndex{N}(index::Vararg{Integer,N}) where {N} = CartesianIndex{N}(index)
     # Allow passing tuples smaller than N
-    CartesianIndex{N}(index::Tuple) where {N} = CartesianIndex{N}(fill_to_length(index, 1, Val{N}))
+    CartesianIndex{N}(index::Tuple) where {N} = CartesianIndex{N}(fill_to_length(index, 1, Val(N)))
     CartesianIndex{N}(index::Integer...) where {N} = CartesianIndex{N}(index)
     CartesianIndex{N}() where {N} = CartesianIndex{N}(())
     # Un-nest passed CartesianIndexes
@@ -37,91 +82,155 @@ module IteratorsMD
     CartesianIndex(index::Tuple{Vararg{Union{Integer, CartesianIndex}}}) = CartesianIndex(index...)
 
     # length
-    length{N}(::CartesianIndex{N})=N
-    length{N}(::Type{CartesianIndex{N}})=N
+    length(::CartesianIndex{N}) where {N} = N
+    length(::Type{CartesianIndex{N}}) where {N} = N
 
     # indexing
     getindex(index::CartesianIndex, i::Integer) = index.I[i]
 
     # zeros and ones
-    zero{N}(::CartesianIndex{N}) = zero(CartesianIndex{N})
-    zero{N}(::Type{CartesianIndex{N}}) = CartesianIndex(ntuple(x -> 0, Val{N}))
-    one{N}(::CartesianIndex{N}) = one(CartesianIndex{N})
-    one{N}(::Type{CartesianIndex{N}}) = CartesianIndex(ntuple(x -> 1, Val{N}))
+    zero(::CartesianIndex{N}) where {N} = zero(CartesianIndex{N})
+    zero(::Type{CartesianIndex{N}}) where {N} = CartesianIndex(ntuple(x -> 0, Val(N)))
+    one(::CartesianIndex{N}) where {N} = one(CartesianIndex{N})
+    one(::Type{CartesianIndex{N}}) where {N} = CartesianIndex(ntuple(x -> 1, Val(N)))
 
     # arithmetic, min/max
-    (-){N}(index::CartesianIndex{N}) = CartesianIndex{N}(map(-, index.I))
-    (+){N}(index1::CartesianIndex{N}, index2::CartesianIndex{N}) =
+    @inline (-)(index::CartesianIndex{N}) where {N} =
+        CartesianIndex{N}(map(-, index.I))
+    @inline (+)(index1::CartesianIndex{N}, index2::CartesianIndex{N}) where {N} =
         CartesianIndex{N}(map(+, index1.I, index2.I))
-    (-){N}(index1::CartesianIndex{N}, index2::CartesianIndex{N}) =
+    @inline (-)(index1::CartesianIndex{N}, index2::CartesianIndex{N}) where {N} =
         CartesianIndex{N}(map(-, index1.I, index2.I))
-    min{N}(index1::CartesianIndex{N}, index2::CartesianIndex{N}) =
+    @inline min(index1::CartesianIndex{N}, index2::CartesianIndex{N}) where {N} =
         CartesianIndex{N}(map(min, index1.I, index2.I))
-    max{N}(index1::CartesianIndex{N}, index2::CartesianIndex{N}) =
+    @inline max(index1::CartesianIndex{N}, index2::CartesianIndex{N}) where {N} =
         CartesianIndex{N}(map(max, index1.I, index2.I))
 
-    (+)(i::Integer, index::CartesianIndex) = index+i
-    (+){N}(index::CartesianIndex{N}, i::Integer) = CartesianIndex{N}(map(x->x+i, index.I))
-    (-){N}(index::CartesianIndex{N}, i::Integer) = CartesianIndex{N}(map(x->x-i, index.I))
-    (-){N}(i::Integer, index::CartesianIndex{N}) = CartesianIndex{N}(map(x->i-x, index.I))
-    (*){N}(a::Integer, index::CartesianIndex{N}) = CartesianIndex{N}(map(x->a*x, index.I))
-    (*)(index::CartesianIndex,a::Integer)=*(a,index)
+    @inline (+)(i::Integer, index::CartesianIndex) = index+i
+    @inline (+)(index::CartesianIndex{N}, i::Integer) where {N} = CartesianIndex{N}(map(x->x+i, index.I))
+    @inline (-)(index::CartesianIndex{N}, i::Integer) where {N} = CartesianIndex{N}(map(x->x-i, index.I))
+    @inline (-)(i::Integer, index::CartesianIndex{N}) where {N} = CartesianIndex{N}(map(x->i-x, index.I))
+    @inline (*)(a::Integer, index::CartesianIndex{N}) where {N} = CartesianIndex{N}(map(x->a*x, index.I))
+    @inline (*)(index::CartesianIndex, a::Integer) = *(a,index)
 
     # comparison
-    @inline isless{N}(I1::CartesianIndex{N}, I2::CartesianIndex{N}) = _isless(0, I1.I, I2.I)
-    @inline function _isless{N}(ret, I1::NTuple{N,Int}, I2::NTuple{N,Int})
+    @inline isless(I1::CartesianIndex{N}, I2::CartesianIndex{N}) where {N} = _isless(0, I1.I, I2.I)
+    @inline function _isless(ret, I1::NTuple{N,Int}, I2::NTuple{N,Int}) where N
         newret = ifelse(ret==0, icmp(I1[N], I2[N]), ret)
         _isless(newret, Base.front(I1), Base.front(I2))
     end
     _isless(ret, ::Tuple{}, ::Tuple{}) = ifelse(ret==1, true, false)
     icmp(a, b) = ifelse(isless(a,b), 1, ifelse(a==b, 0, -1))
 
-    # Iteration
-    struct CartesianRange{I<:CartesianIndex}
-        start::I
-        stop::I
+    # hashing
+    const cartindexhash_seed = UInt == UInt64 ? 0xd60ca92f8284b8b0 : 0xf2ea7c2e
+    function Base.hash(ci::CartesianIndex, h::UInt)
+        h += cartindexhash_seed
+        for i in ci.I
+            h = hash(i, h)
+        end
+        return h
     end
 
-    CartesianRange(index::CartesianIndex) = CartesianRange(one(index), index)
-    CartesianRange(::Tuple{}) = CartesianRange{CartesianIndex{0}}(CartesianIndex{0}(()),CartesianIndex{0}(()))
-    CartesianRange{N}(sz::NTuple{N,Int}) = CartesianRange(CartesianIndex(sz))
-    CartesianRange{N}(rngs::NTuple{N,Union{Integer,AbstractUnitRange}}) =
-        CartesianRange(CartesianIndex(map(first, rngs)), CartesianIndex(map(last, rngs)))
+    # Iteration
+    """
+        CartesianRange(sz::Dims) -> R
+        CartesianRange(istart:istop, jstart:jstop, ...) -> R
+
+    Define a region `R` spanning a multidimensional rectangular range
+    of integer indices. These are most commonly encountered in the
+    context of iteration, where `for I in R ... end` will return
+    [`CartesianIndex`](@ref) indices `I` equivalent to the nested loops
+
+        for j = jstart:jstop
+            for i = istart:istop
+                ...
+            end
+        end
+
+    Consequently these can be useful for writing algorithms that
+    work in arbitrary dimensions.
+
+    # Examples
+    ```jldoctest
+    julia> foreach(println, CartesianRange((2, 2, 2)))
+    CartesianIndex{3}((1, 1, 1))
+    CartesianIndex{3}((2, 1, 1))
+    CartesianIndex{3}((1, 2, 1))
+    CartesianIndex{3}((2, 2, 1))
+    CartesianIndex{3}((1, 1, 2))
+    CartesianIndex{3}((2, 1, 2))
+    CartesianIndex{3}((1, 2, 2))
+    CartesianIndex{3}((2, 2, 2))
+    ```
+    """
+    struct CartesianRange{N,R<:NTuple{N,AbstractUnitRange{Int}}}
+        indices::R
+    end
 
-    convert{N}(::Type{NTuple{N,UnitRange{Int}}}, R::CartesianRange{CartesianIndex{N}}) =
-        map((f,l)->f:l, first(R).I, last(R).I)
-    convert{N}(::Type{NTuple{N,UnitRange}}, R::CartesianRange) =
-        convert(NTuple{N,UnitRange{Int}}, R)
-    convert{N}(::Type{Tuple{Vararg{UnitRange{Int}}}}, R::CartesianRange{CartesianIndex{N}}) =
+    CartesianRange(::Tuple{}) = CartesianRange{0,typeof(())}(())
+    CartesianRange(inds::NTuple{N,AbstractUnitRange{Int}}) where {N} =
+        CartesianRange{N,typeof(inds)}(inds)
+    CartesianRange(inds::Vararg{AbstractUnitRange{Int},N}) where {N} =
+        CartesianRange(inds)
+    CartesianRange(inds::NTuple{N,AbstractUnitRange{<:Integer}}) where {N} =
+        CartesianRange(map(r->convert(AbstractUnitRange{Int}, r), inds))
+    CartesianRange(inds::Vararg{AbstractUnitRange{<:Integer},N}) where {N} =
+        CartesianRange(inds)
+
+    CartesianRange(index::CartesianIndex) = CartesianRange(index.I)
+    CartesianRange(sz::NTuple{N,<:Integer}) where {N} = CartesianRange(map(Base.OneTo, sz))
+    CartesianRange(inds::NTuple{N,Union{<:Integer,AbstractUnitRange{<:Integer}}}) where {N} =
+        CartesianRange(map(i->first(i):last(i), inds))
+
+    convert(::Type{Tuple{}}, R::CartesianRange{0}) = ()
+    convert(::Type{NTuple{N,AbstractUnitRange{Int}}}, R::CartesianRange{N}) where {N} =
+        R.indices
+    convert(::Type{NTuple{N,AbstractUnitRange}}, R::CartesianRange{N}) where {N} =
+        convert(NTuple{N,AbstractUnitRange{Int}}, R)
+    convert(::Type{NTuple{N,UnitRange{Int}}}, R::CartesianRange{N}) where {N} =
+        UnitRange{Int}.(convert(NTuple{N,AbstractUnitRange}, R))
+    convert(::Type{NTuple{N,UnitRange}}, R::CartesianRange{N}) where {N} =
+        UnitRange.(convert(NTuple{N,AbstractUnitRange}, R))
+    convert(::Type{Tuple{Vararg{AbstractUnitRange{Int}}}}, R::CartesianRange{N}) where {N} =
+        convert(NTuple{N,AbstractUnitRange{Int}}, R)
+    convert(::Type{Tuple{Vararg{AbstractUnitRange}}}, R::CartesianRange) =
+        convert(Tuple{Vararg{AbstractUnitRange{Int}}}, R)
+    convert(::Type{Tuple{Vararg{UnitRange{Int}}}}, R::CartesianRange{N}) where {N} =
         convert(NTuple{N,UnitRange{Int}}, R)
     convert(::Type{Tuple{Vararg{UnitRange}}}, R::CartesianRange) =
         convert(Tuple{Vararg{UnitRange{Int}}}, R)
 
-    ndims(R::CartesianRange) = length(R.start)
-    ndims{I<:CartesianIndex}(::Type{CartesianRange{I}}) = length(I)
+    ndims(R::CartesianRange) = ndims(typeof(R))
+    ndims(::Type{CartesianRange{N}}) where {N} = N
+    ndims(::Type{CartesianRange{N,TT}}) where {N,TT} = N
 
     eachindex(::IndexCartesian, A::AbstractArray) = CartesianRange(indices(A))
 
     @inline eachindex(::IndexCartesian, A::AbstractArray, B::AbstractArray...) =
-        CartesianRange(maxsize((), A, B...))
-    maxsize(sz) = sz
-    @inline maxsize(sz, A, B...) = maxsize(maxt(sz, size(A)), B...)
+        CartesianRange(maxsize(A, B...))
+    maxsize() = ()
+    @inline maxsize(A) = size(A)
+    @inline maxsize(A, B...) = maxt(size(A), maxsize(B...))
     @inline maxt(a::Tuple{}, b::Tuple{}) = ()
     @inline maxt(a::Tuple{}, b::Tuple)   = b
     @inline maxt(a::Tuple,   b::Tuple{}) = a
     @inline maxt(a::Tuple,   b::Tuple)   = (max(a[1], b[1]), maxt(tail(a), tail(b))...)
 
-    eltype{I}(::Type{CartesianRange{I}}) = I
+    eltype(R::CartesianRange) = eltype(typeof(R))
+    eltype(::Type{CartesianRange{N}}) where {N} = CartesianIndex{N}
+    eltype(::Type{CartesianRange{N,TT}}) where {N,TT} = CartesianIndex{N}
     iteratorsize(::Type{<:CartesianRange}) = Base.HasShape()
 
-    @inline function start(iter::CartesianRange{<:CartesianIndex})
-        if any(map(>, iter.start.I, iter.stop.I))
-            return iter.stop+1
+    @inline function start(iter::CartesianRange)
+        iterfirst, iterlast = first(iter), last(iter)
+        if any(map(>, iterfirst.I, iterlast.I))
+            return iterlast+1
         end
-        iter.start
+        iterfirst
     end
-    @inline function next{I<:CartesianIndex}(iter::CartesianRange{I}, state)
-        state, I(inc(state.I, iter.start.I, iter.stop.I))
+    @inline function next(iter::CartesianRange, state)
+        state, CartesianIndex(inc(state.I, first(iter).I, last(iter).I))
     end
     # increment & carry
     @inline inc(::Tuple{}, ::Tuple{}, ::Tuple{}) = ()
@@ -133,48 +242,57 @@ module IteratorsMD
         newtail = inc(tail(state), tail(start), tail(stop))
         (start[1], newtail...)
     end
-    @inline done(iter::CartesianRange{<:CartesianIndex}, state) = state.I[end] > iter.stop.I[end]
+    @inline done(iter::CartesianRange, state) = state.I[end] > last(iter.indices[end])
 
     # 0-d cartesian ranges are special-cased to iterate once and only once
-    start(iter::CartesianRange{<:CartesianIndex{0}}) = false
-    next(iter::CartesianRange{<:CartesianIndex{0}}, state) = iter.start, true
-    done(iter::CartesianRange{<:CartesianIndex{0}}, state) = state
+    start(iter::CartesianRange{0}) = false
+    next(iter::CartesianRange{0}, state) = CartesianIndex(), true
+    done(iter::CartesianRange{0}, state) = state
 
-    size(iter::CartesianRange{<:CartesianIndex}) = map(dimlength, iter.start.I, iter.stop.I)
+    size(iter::CartesianRange) = map(dimlength, first(iter).I, last(iter).I)
     dimlength(start, stop) = stop-start+1
 
     length(iter::CartesianRange) = prod(size(iter))
 
-    last(iter::CartesianRange) = iter.stop
+    first(iter::CartesianRange) = CartesianIndex(map(first, iter.indices))
+    last(iter::CartesianRange)  = CartesianIndex(map(last, iter.indices))
 
-    @inline function in{I<:CartesianIndex}(i::I, r::CartesianRange{I})
-        _in(true, i.I, r.start.I, r.stop.I)
+    @inline function in(i::CartesianIndex{N}, r::CartesianRange{N}) where {N}
+        _in(true, i.I, first(r).I, last(r).I)
     end
     _in(b, ::Tuple{}, ::Tuple{}, ::Tuple{}) = b
     @inline _in(b, i, start, stop) = _in(b & (start[1] <= i[1] <= stop[1]), tail(i), tail(start), tail(stop))
 
-    simd_outer_range(iter::CartesianRange{CartesianIndex{0}}) = iter
+    simd_outer_range(iter::CartesianRange{0}) = iter
     function simd_outer_range(iter::CartesianRange)
-        start = CartesianIndex(tail(iter.start.I))
-        stop  = CartesianIndex(tail(iter.stop.I))
-        CartesianRange(start, stop)
+        CartesianRange(tail(iter.indices))
     end
 
-    simd_inner_length(iter::CartesianRange{<:CartesianIndex{0}}, ::CartesianIndex) = 1
-    simd_inner_length(iter::CartesianRange, I::CartesianIndex) = iter.stop[1]-iter.start[1]+1
+    simd_inner_length(iter::CartesianRange{0}, ::CartesianIndex) = 1
+    simd_inner_length(iter::CartesianRange, I::CartesianIndex) = length(iter.indices[1])
 
-    simd_index(iter::CartesianRange{<:CartesianIndex{0}}, ::CartesianIndex, I1::Int) = iter.start
+    simd_index(iter::CartesianRange{0}, ::CartesianIndex, I1::Int) = first(iter)
     @inline function simd_index(iter::CartesianRange, Ilast::CartesianIndex, I1::Int)
-        CartesianIndex((I1+iter.start[1], Ilast.I...))
+        CartesianIndex((I1+first(iter.indices[1]), Ilast.I...))
     end
 
     # Split out the first N elements of a tuple
-    @inline split(t, V::Type{<:Val}) = _split((), t, V)
-    @inline _split(tN, trest, V) = _split((tN..., trest[1]), tail(trest), V)
+    @inline split(t, V::Val) = _split((), t, V)
+    @inline _split(tN, trest, V::Val) = _split((tN..., trest[1]), tail(trest), V)
     # exit either when we've exhausted the input tuple or when tN has length N
-    @inline _split{N}(tN::NTuple{N,Any}, ::Tuple{}, ::Type{Val{N}}) = tN, ()  # ambig.
-    @inline _split{N}(tN,                ::Tuple{}, ::Type{Val{N}}) = tN, ()
-    @inline _split{N}(tN::NTuple{N,Any},  trest,    ::Type{Val{N}}) = tN, trest
+    @inline _split(tN::NTuple{N,Any}, ::Tuple{}, ::Val{N}) where {N} = tN, ()  # ambig.
+    @inline _split(tN,                ::Tuple{}, ::Val{N}) where {N} = tN, ()
+    @inline _split(tN::NTuple{N,Any},  trest,    ::Val{N}) where {N} = tN, trest
+
+    @inline function split(I::CartesianIndex, V::Val)
+        i, j = split(I.I, V)
+        CartesianIndex(i), CartesianIndex(j)
+    end
+    function split(R::CartesianRange, V::Val)
+        istart, jstart = split(first(R), V)
+        istop,  jstop  = split(last(R), V)
+        CartesianRange(istart, istop), CartesianRange(jstart, jstop)
+    end
 end  # IteratorsMD
 
 
@@ -205,8 +323,8 @@ end
 # Support indexing with an array of CartesianIndex{N}s
 # Here we try to consume N of the indices (if there are that many available)
 # The first two simply handle ambiguities
-@inline function checkbounds_indices{N}(::Type{Bool}, ::Tuple{},
-        I::Tuple{AbstractArray{CartesianIndex{N}},Vararg{Any}})
+@inline function checkbounds_indices(::Type{Bool}, ::Tuple{},
+        I::Tuple{AbstractArray{CartesianIndex{N}},Vararg{Any}}) where N
     checkindex(Bool, (), I[1]) & checkbounds_indices(Bool, (), tail(I))
 end
 @inline function checkbounds_indices(::Type{Bool}, IA::Tuple{Any},
@@ -214,12 +332,12 @@ end
     checkbounds_indices(Bool, IA, tail(I))
 end
 @inline function checkbounds_indices(::Type{Bool}, IA::Tuple{Any},
-        I::Tuple{<:AbstractArray{<:CartesianIndex},Vararg{Any}})
+        I::Tuple{AbstractArray{CartesianIndex{N}},Vararg{Any}}) where N
     checkindex(Bool, IA, I[1]) & checkbounds_indices(Bool, (), tail(I))
 end
-@inline function checkbounds_indices{N}(::Type{Bool}, IA::Tuple,
-        I::Tuple{AbstractArray{CartesianIndex{N}},Vararg{Any}})
-    IA1, IArest = IteratorsMD.split(IA, Val{N})
+@inline function checkbounds_indices(::Type{Bool}, IA::Tuple,
+        I::Tuple{AbstractArray{CartesianIndex{N}},Vararg{Any}}) where N
+    IA1, IArest = IteratorsMD.split(IA, Val(N))
     checkindex(Bool, IA1, I[1]) & checkbounds_indices(Bool, IArest, tail(I))
 end
 
@@ -238,8 +356,8 @@ end
 @inline function index_ndims(i1::CartesianIndex, I...)
     (map(x->true, i1.I)..., index_ndims(I...)...)
 end
-@inline function index_ndims{N}(i1::AbstractArray{CartesianIndex{N}}, I...)
-    (ntuple(x->true, Val{N})..., index_ndims(I...)...)
+@inline function index_ndims(i1::AbstractArray{CartesianIndex{N}}, I...) where N
+    (ntuple(x->true, Val(N))..., index_ndims(I...)...)
 end
 index_ndims() = ()
 
@@ -248,8 +366,8 @@ index_ndims() = ()
 @inline index_dimsum(i1, I...) = (index_dimsum(I...)...)
 @inline index_dimsum(::Colon, I...) = (true, index_dimsum(I...)...)
 @inline index_dimsum(::AbstractArray{Bool}, I...) = (true, index_dimsum(I...)...)
-@inline function index_dimsum{_,N}(::AbstractArray{_,N}, I...)
-    (ntuple(x->true, Val{N})..., index_dimsum(I...)...)
+@inline function index_dimsum(::AbstractArray{<:Any,N}, I...) where N
+    (ntuple(x->true, Val(N))..., index_dimsum(I...)...)
 end
 index_dimsum() = ()
 
@@ -325,12 +443,12 @@ end
 @inline done(L::LogicalIndex{Int,<:BitArray}, s) = s[2] > length(L)
 
 # Checking bounds with LogicalIndex{Int} is tricky since we allow linear indexing over trailing dimensions
-@inline checkbounds_indices{N}(::Type{Bool},IA::Tuple{},I::Tuple{LogicalIndex{Int,AbstractArray{Bool,N}}}) =
+@inline checkbounds_indices(::Type{Bool},IA::Tuple{},I::Tuple{LogicalIndex{Int,AbstractArray{Bool,N}}}) where {N} =
     checkindex(Bool, IA, I[1])
-@inline checkbounds_indices{N}(::Type{Bool},IA::Tuple{Any},I::Tuple{LogicalIndex{Int,AbstractArray{Bool,N}}}) =
+@inline checkbounds_indices(::Type{Bool},IA::Tuple{Any},I::Tuple{LogicalIndex{Int,AbstractArray{Bool,N}}}) where {N} =
     checkindex(Bool, IA[1], I[1])
-@inline function checkbounds_indices{N}(::Type{Bool}, IA::Tuple, I::Tuple{LogicalIndex{Int,AbstractArray{Bool,N}}})
-    IA1, IArest = IteratorsMD.split(IA, Val{N})
+@inline function checkbounds_indices(::Type{Bool}, IA::Tuple, I::Tuple{LogicalIndex{Int,AbstractArray{Bool,N}}}) where N
+    IA1, IArest = IteratorsMD.split(IA, Val(N))
     checkindex(Bool, IA1, I[1])
 end
 @inline checkbounds(::Type{Bool}, A::AbstractArray, I::LogicalIndex{<:Any,<:AbstractArray{Bool,1}}) =
@@ -352,17 +470,17 @@ to_indices(A, I::Tuple{}) = ()
 @inline to_indices(A, inds, I::Tuple{CartesianIndex, Vararg{Any}}) =
     to_indices(A, inds, (I[1].I..., tail(I)...))
 # But for arrays of CartesianIndex, we just skip the appropriate number of inds
-@inline function to_indices{N}(A, inds, I::Tuple{AbstractArray{CartesianIndex{N}}, Vararg{Any}})
-    _, indstail = IteratorsMD.split(inds, Val{N})
+@inline function to_indices(A, inds, I::Tuple{AbstractArray{CartesianIndex{N}}, Vararg{Any}}) where N
+    _, indstail = IteratorsMD.split(inds, Val(N))
     (to_index(A, I[1]), to_indices(A, indstail, tail(I))...)
 end
 # And boolean arrays behave similarly; they also skip their number of dimensions
-@inline function to_indices{N}(A, inds, I::Tuple{AbstractArray{Bool, N}, Vararg{Any}})
-    _, indstail = IteratorsMD.split(inds, Val{N})
+@inline function to_indices(A, inds, I::Tuple{AbstractArray{Bool, N}, Vararg{Any}}) where N
+    _, indstail = IteratorsMD.split(inds, Val(N))
     (to_index(A, I[1]), to_indices(A, indstail, tail(I))...)
 end
 # As an optimization, we allow trailing Array{Bool} and BitArray to be linear over trailing dimensions
-@inline to_indices{N}(A, inds, I::Tuple{Union{Array{Bool,N}, BitArray{N}}}) =
+@inline to_indices(A, inds, I::Tuple{Union{Array{Bool,N}, BitArray{N}}}) where {N} =
     (_maybe_linear_logical_index(IndexStyle(A), A, I[1]),)
 _maybe_linear_logical_index(::IndexStyle, A, i) = to_index(A, i)
 _maybe_linear_logical_index(::IndexLinear, A, i) = LogicalIndex{Int}(i)
@@ -389,46 +507,37 @@ getindex(t::Tuple,  i::CartesianIndex{1}) = getindex(t, i.I[1])
 # These are not defined on directly on getindex to avoid
 # ambiguities for AbstractArray subtypes. See the note in abstractarray.jl
 
-@generated function _getindex(l::IndexStyle, A::AbstractArray, I::Union{Real, AbstractArray}...)
-    N = length(I)
-    quote
-        @_inline_meta
-        @boundscheck checkbounds(A, I...)
-        _unsafe_getindex(l, _maybe_reshape(l, A, I...), I...)
-    end
+@inline function _getindex(l::IndexStyle, A::AbstractArray, I::Union{Real, AbstractArray}...)
+    @boundscheck checkbounds(A, I...)
+    return _unsafe_getindex(l, _maybe_reshape(l, A, I...), I...)
 end
 # But we can speed up IndexCartesian arrays by reshaping them to the appropriate dimensionality:
 _maybe_reshape(::IndexLinear, A::AbstractArray, I...) = A
 _maybe_reshape(::IndexCartesian, A::AbstractVector, I...) = A
 @inline _maybe_reshape(::IndexCartesian, A::AbstractArray, I...) = __maybe_reshape(A, index_ndims(I...))
-@inline __maybe_reshape{T,N}(A::AbstractArray{T,N}, ::NTuple{N,Any}) = A
-@inline __maybe_reshape{N}(A::AbstractArray, ::NTuple{N,Any}) = reshape(A, Val{N})
-
-@generated function _unsafe_getindex(::IndexStyle, A::AbstractArray, I::Union{Real, AbstractArray}...)
-    N = length(I)
-    quote
-        # This is specifically not inlined to prevent exessive allocations in type unstable code
-        @nexprs $N d->(I_d = I[d])
-        shape = @ncall $N index_shape I
-        dest = similar(A, shape)
-        map(unsafe_length, indices(dest)) == map(unsafe_length, shape) || throw_checksize_error(dest, shape)
-        @ncall $N _unsafe_getindex! dest A I
-    end
+@inline __maybe_reshape(A::AbstractArray{T,N}, ::NTuple{N,Any}) where {T,N} = A
+@inline __maybe_reshape(A::AbstractArray, ::NTuple{N,Any}) where {N} = reshape(A, Val(N))
+
+function _unsafe_getindex(::IndexStyle, A::AbstractArray, I::Vararg{Union{Real, AbstractArray}, N}) where N
+    # This is specifically not inlined to prevent excessive allocations in type unstable code
+    shape = index_shape(I...)
+    dest = similar(A, shape)
+    map(unsafe_length, indices(dest)) == map(unsafe_length, shape) || throw_checksize_error(dest, shape)
+    _unsafe_getindex!(dest, A, I...) # usually a generated function, don't allow it to impact inference result
+    return dest
 end
 
 # Always index with the exactly indices provided.
-@generated function _unsafe_getindex!(dest::AbstractArray, src::AbstractArray, I::Union{Real, AbstractArray}...)
-    N = length(I)
+@generated function _unsafe_getindex!(dest::AbstractArray, src::AbstractArray, I::Vararg{Union{Real, AbstractArray}, N}) where N
     quote
-        $(Expr(:meta, :inline))
-        @nexprs $N d->(J_d = I[d])
+        @_inline_meta
         D = eachindex(dest)
         Ds = start(D)
-        @inbounds @nloops $N j d->J_d begin
+        @inbounds @nloops $N j d->I[d] begin
             d, Ds = next(D, Ds)
             dest[d] = @ncall $N getindex src j
         end
-        dest
+        return dest
     end
 end
 
@@ -465,10 +574,10 @@ end
 
 ##
 
-@generated function findn{T,N}(A::AbstractArray{T,N})
+@generated function findn(A::AbstractArray{T,N}) where {T,N}
     quote
         nnzA = countnz(A)
-        @nexprs $N d->(I_d = Array{Int}(nnzA))
+        @nexprs $N d->(I_d = Vector{Int}(nnzA))
         k = 1
         @nloops $N i A begin
             @inbounds if (@nref $N A i) != zero(T)
@@ -483,19 +592,19 @@ end
 
 # see discussion in #18364 ... we try not to widen type of the resulting array
 # from cumsum or cumprod, but in some cases (+, Bool) we may not have a choice.
-rcum_promote_type{T,S<:Number}(op, ::Type{T}, ::Type{S}) = promote_op(op, T, S)
-rcum_promote_type{T<:Number}(op, ::Type{T}) = rcum_promote_type(op, T,T)
-rcum_promote_type{T}(op, ::Type{T}) = T
+rcum_promote_type(op, ::Type{T}, ::Type{S}) where {T,S<:Number} = promote_op(op, T, S)
+rcum_promote_type(op, ::Type{T}) where {T<:Number} = rcum_promote_type(op, T,T)
+rcum_promote_type(op, ::Type{T}) where {T} = T
 
 # handle sums of Vector{Bool} and similar.   it would be nice to handle
 # any AbstractArray here, but it's not clear how that would be possible
-rcum_promote_type{T,N}(op, ::Type{Array{T,N}}) = Array{rcum_promote_type(op,T), N}
+rcum_promote_type(op, ::Type{Array{T,N}}) where {T,N} = Array{rcum_promote_type(op,T), N}
 
 # accumulate_pairwise slightly slower then accumulate, but more numerically
 # stable in certain situations (e.g. sums).
 # it does double the number of operations compared to accumulate,
 # though for cheap operations like + this does not have much impact (20%)
-function _accumulate_pairwise!{T, Op}(op::Op, c::AbstractVector{T}, v::AbstractVector, s, i1, n)::T
+function _accumulate_pairwise!(op::Op, c::AbstractVector{T}, v::AbstractVector, s, i1, n)::T where {T,Op}
     @inbounds if n < 128
         s_ = v[i1]
         c[i1] = op(s, s_)
@@ -511,7 +620,7 @@ function _accumulate_pairwise!{T, Op}(op::Op, c::AbstractVector{T}, v::AbstractV
     return s_
 end
 
-function accumulate_pairwise!{Op}(op::Op, result::AbstractVector, v::AbstractVector)
+function accumulate_pairwise!(op::Op, result::AbstractVector, v::AbstractVector) where Op
     li = linearindices(v)
     li != linearindices(result) && throw(DimensionMismatch("input and output array sizes and indices must match"))
     n = length(li)
@@ -523,19 +632,24 @@ function accumulate_pairwise!{Op}(op::Op, result::AbstractVector, v::AbstractVec
     return result
 end
 
-function accumulate_pairwise{T}(op, v::AbstractVector{T})
+function accumulate_pairwise(op, v::AbstractVector{T}) where T
     out = similar(v, rcum_promote_type(op, T))
     return accumulate_pairwise!(op, out, v)
 end
 
 function cumsum!(out, v::AbstractVector, axis::Integer=1)
-    # for types prone to numerical stability issues, we want
-    # accumulate_pairwise.
-    axis == 1 ? accumulate_pairwise!(+, out, v) : copy!(out,v)
+    # we dispatch on the possibility of numerical stability issues
+    _cumsum!(out, v, axis, TypeArithmetic(eltype(out)))
 end
 
-function cumsum!(out, v::AbstractVector{<:Integer}, axis::Integer=1)
-    axis == 1 ? accumulate!(+, out, v) : copy!(out,v)
+function _cumsum!(out, v, axis, ::ArithmeticRounds)
+    axis == 1 ? accumulate_pairwise!(+, out, v) : copy!(out, v)
+end
+function _cumsum!(out, v, axis, ::ArithmeticUnknown)
+    _cumsum!(out, v, axis, ArithmeticRounds())
+end
+function _cumsum!(out, v, axis, ::TypeArithmetic)
+    axis == 1 ? accumulate!(+, out, v) : copy!(out, v)
 end
 
 """
@@ -562,7 +676,7 @@ julia> cumsum(a,2)
  4  9  15
 ```
 """
-function cumsum{T}(A::AbstractArray{T}, axis::Integer=1)
+function cumsum(A::AbstractArray{T}, axis::Integer=1) where T
     out = similar(A, rcum_promote_type(+, T))
     cumsum!(out, A, axis)
 end
@@ -642,8 +756,9 @@ end
     accumulate(op, v0, A)
 
 Like `accumulate`, but using a starting element `v0`. The first entry of the result will be
-`op(v0, first(A))`. For example:
+`op(v0, first(A))`.
 
+# Examples
 ```jldoctest
 julia> accumulate(+, 100, [1,2,3])
 3-element Array{Int64,1}:
@@ -664,7 +779,7 @@ function accumulate(op, v0, A, axis::Integer=1)
     accumulate!(op, out, v0, A, 1)
 end
 
-function accumulate!{Op}(op::Op, B, A::AbstractVector, axis::Integer=1)
+function accumulate!(op::Op, B, A::AbstractVector, axis::Integer=1) where Op
     isempty(A) && return B
     v1 = first(A)
     _accumulate1!(op, B, v1, A, axis)
@@ -739,7 +854,7 @@ end
 
 ### from abstractarray.jl
 
-function fill!{T}(A::AbstractArray{T}, x)
+function fill!(A::AbstractArray{T}, x) where T
     xT = convert(T, x)
     for I in eachindex(A)
         @inbounds A[I] = xT
@@ -747,7 +862,14 @@ function fill!{T}(A::AbstractArray{T}, x)
     A
 end
 
-function copy!{T,N}(dest::AbstractArray{T,N}, src::AbstractArray{T,N})
+"""
+    copy!(dest, src) -> dest
+
+Copy all elements from collection `src` to array `dest`.
+"""
+copy!(dest, src)
+
+function copy!(dest::AbstractArray{T,N}, src::AbstractArray{T,N}) where {T,N}
     @boundscheck checkbounds(dest, indices(src)...)
     for I in eachindex(IndexStyle(src,dest), src)
         @inbounds dest[I] = src[I]
@@ -755,22 +877,38 @@ function copy!{T,N}(dest::AbstractArray{T,N}, src::AbstractArray{T,N})
     dest
 end
 
-function copy!(dest::AbstractArray, Rdest::CartesianRange, src::AbstractArray, Rsrc::CartesianRange)
-    isempty(Rdest) && return dest
-    if size(Rdest) != size(Rsrc)
-        throw(ArgumentError("source and destination must have same size (got $(size(Rsrc)) and $(size(Rdest)))"))
-    end
-    @boundscheck checkbounds(dest, Rdest.start)
-    @boundscheck checkbounds(dest, Rdest.stop)
-    @boundscheck checkbounds(src, Rsrc.start)
-    @boundscheck checkbounds(src, Rsrc.stop)
-    deltaI = Rdest.start - Rsrc.start
-    for I in Rsrc
-        @inbounds dest[I+deltaI] = src[I]
+@generated function copy!(dest::AbstractArray{T1,N},
+                          Rdest::CartesianRange{N},
+                          src::AbstractArray{T2,N},
+                          Rsrc::CartesianRange{N}) where {T1,T2,N}
+    quote
+        isempty(Rdest) && return dest
+        if size(Rdest) != size(Rsrc)
+            throw(ArgumentError("source and destination must have same size (got $(size(Rsrc)) and $(size(Rdest)))"))
+        end
+        @boundscheck checkbounds(dest, first(Rdest))
+        @boundscheck checkbounds(dest, last(Rdest))
+        @boundscheck checkbounds(src, first(Rsrc))
+        @boundscheck checkbounds(src, last(Rsrc))
+        ΔI = first(Rdest) - first(Rsrc)
+        # TODO: restore when #9080 is fixed
+        # for I in Rsrc
+        #     @inbounds dest[I+ΔI] = src[I]
+        @nloops $N i (n->Rsrc.indices[n]) begin
+            @inbounds @nref($N,dest,n->i_n+ΔI[n]) = @nref($N,src,i)
+        end
+        dest
     end
-    dest
 end
 
+"""
+    copy!(dest, Rdest::CartesianRange, src, Rsrc::CartesianRange) -> dest
+
+Copy the block of `src` in the range of `Rsrc` to the block of `dest`
+in the range of `Rdest`. The sizes of the two regions must match.
+"""
+copy!(::AbstractArray, ::CartesianRange, ::AbstractArray, ::CartesianRange)
+
 # circshift!
 circshift!(dest::AbstractArray, src, ::Tuple{}) = copy!(dest, src)
 """
@@ -782,13 +920,13 @@ Circularly shift the data in `src`, storing the result in
 The `dest` array must be distinct from the `src` array (they cannot
 alias each other).
 
-See also `circshift`.
+See also [`circshift`](@ref).
 """
-@noinline function circshift!{T,N}(dest::AbstractArray{T,N}, src, shiftamt::DimsInteger)
+@noinline function circshift!(dest::AbstractArray{T,N}, src, shiftamt::DimsInteger) where {T,N}
     dest === src && throw(ArgumentError("dest and src must be separate arrays"))
     inds = indices(src)
     indices(dest) == inds || throw(ArgumentError("indices of src and dest must match (got $inds and $(indices(dest)))"))
-    _circshift!(dest, (), src, (), inds, fill_to_length(shiftamt, 0, Val{N}))
+    _circshift!(dest, (), src, (), inds, fill_to_length(shiftamt, 0, Val(N)))
 end
 circshift!(dest::AbstractArray, src, shiftamt) = circshift!(dest, src, (shiftamt...,))
 
@@ -835,7 +973,8 @@ their indices; any offset results in a (circular) wraparound. If the
 arrays have overlapping indices, then on the domain of the overlap
 `dest` agrees with `src`.
 
-```julia
+# Examples
+```julia-repl
 julia> src = reshape(collect(1:16), (4,4))
 4×4 Array{Int64,2}:
  1  5   9  13
@@ -957,10 +1096,85 @@ end
 
 ## setindex!
 
+function copy_to_bitarray_chunks!(Bc::Vector{UInt64}, pos_d::Int, C::StridedArray, pos_s::Int, numbits::Int)
+    bind = pos_d
+    cind = pos_s
+    lastind = pos_d + numbits - 1
+    @inbounds while bind ≤ lastind
+        unsafe_bitsetindex!(Bc, Bool(C[cind]), bind)
+        bind += 1
+        cind += 1
+    end
+end
+
+# Note: the next two functions rely on the following definition of the conversion to Bool:
+#   convert(::Type{Bool}, x::Real) = x==0 ? false : x==1 ? true : throw(InexactError(...))
+# they're used to pre-emptively check in bulk when possible, which is much faster.
+# Also, the functions can be overloaded for custom types T<:Real :
+#  a) in the unlikely eventuality that they use a different logic for Bool conversion
+#  b) to skip the check if not necessary
+@inline try_bool_conversion(x::Real) =
+    x == 0 || x == 1 || throw(InexactError(:try_bool_conversion, Bool, x))
+@inline unchecked_bool_convert(x::Real) = x == 1
+
+function copy_to_bitarray_chunks!(Bc::Vector{UInt64}, pos_d::Int, C::StridedArray{<:Real}, pos_s::Int, numbits::Int)
+    @inbounds for i = (1:numbits) + pos_s - 1
+        try_bool_conversion(C[i])
+    end
+
+    kd0, ld0 = get_chunks_id(pos_d)
+    kd1, ld1 = get_chunks_id(pos_d + numbits - 1)
+
+    delta_kd = kd1 - kd0
+
+    u = _msk64
+    if delta_kd == 0
+        msk_d0 = msk_d1 = ~(u << ld0) | (u << (ld1+1))
+        lt0 = ld1
+    else
+        msk_d0 = ~(u << ld0)
+        msk_d1 = (u << (ld1+1))
+        lt0 = 63
+    end
+
+    bind = kd0
+    ind = pos_s
+    @inbounds if ld0 > 0
+        c = UInt64(0)
+        for j = ld0:lt0
+            c |= (UInt64(unchecked_bool_convert(C[ind])) << j)
+            ind += 1
+        end
+        Bc[kd0] = (Bc[kd0] & msk_d0) | (c & ~msk_d0)
+        bind += 1
+    end
+
+    nc = _div64(numbits - ind + pos_s)
+    @inbounds for i = 1:nc
+        c = UInt64(0)
+        for j = 0:63
+            c |= (UInt64(unchecked_bool_convert(C[ind])) << j)
+            ind += 1
+        end
+        Bc[bind] = c
+        bind += 1
+    end
+
+    @inbounds if bind ≤ kd1
+        @assert bind == kd1
+        c = UInt64(0)
+        for j = 0:ld1
+            c |= (UInt64(unchecked_bool_convert(C[ind])) << j)
+            ind += 1
+        end
+        Bc[kd1] = (Bc[kd1] & msk_d1) | (c & ~msk_d1)
+    end
+end
+
 # contiguous multidimensional indexing: if the first dimension is a range,
 # we can get some performance from using copy_chunks!
 
-@inline function setindex!(B::BitArray, X::Union{BitArray,Array}, J0::Union{Colon,UnitRange{Int}})
+@inline function setindex!(B::BitArray, X::StridedArray, J0::Union{Colon,UnitRange{Int}})
     I0 = to_indices(B, (J0,))[1]
     @boundscheck checkbounds(B, I0)
     l0 = length(I0)
@@ -971,13 +1185,13 @@ end
     return B
 end
 
-@inline function setindex!(B::BitArray, X::Union{BitArray,Array},
+@inline function setindex!(B::BitArray, X::StridedArray,
         I0::Union{Colon,UnitRange{Int}}, I::Union{Int,UnitRange{Int},Colon}...)
     J = to_indices(B, (I0, I...))
     @boundscheck checkbounds(B, J...)
     _unsafe_setindex!(B, X, J...)
 end
-@generated function _unsafe_setindex!(B::BitArray, X::Union{BitArray,Array},
+@generated function _unsafe_setindex!(B::BitArray, X::StridedArray,
         I0::Union{Slice,UnitRange{Int}}, I::Union{Int,UnitRange{Int},Slice}...)
     N = length(I)
     quote
@@ -1053,10 +1267,10 @@ end
 
 ## findn
 
-@generated function findn{N}(B::BitArray{N})
+@generated function findn(B::BitArray{N}) where N
     quote
         nnzB = countnz(B)
-        I = ntuple(x->Array{Int}(nnzB), $N)
+        I = ntuple(x->Vector{Int}(nnzB), Val($N))
         if nnzB > 0
             count = 1
             @nloops $N i B begin
@@ -1081,7 +1295,7 @@ end
         @nexprs $N d->begin
             l = size(B,d)
             stride *= l
-            1 <= I_{d-1} <= l || return false
+            @boundscheck 1 <= I_{d-1} <= l || return false
             index += (I_d - 1) * stride
         end
         return isassigned(B, index)
@@ -1101,7 +1315,7 @@ function permutedims(B::StridedArray, perm)
     permutedims!(P, B, perm)
 end
 
-function checkdims_perm{TP,TB,N}(P::AbstractArray{TP,N}, B::AbstractArray{TB,N}, perm)
+function checkdims_perm(P::AbstractArray{TP,N}, B::AbstractArray{TB,N}, perm) where {TP,TB,N}
     indsB = indices(B)
     length(perm) == N || throw(ArgumentError("expected permutation of size $N, but length(perm)=$(length(perm))"))
     isperm(perm) || throw(ArgumentError("input is not a permutation"))
@@ -1113,7 +1327,7 @@ function checkdims_perm{TP,TB,N}(P::AbstractArray{TP,N}, B::AbstractArray{TB,N},
 end
 
 for (V, PT, BT) in [((:N,), BitArray, BitArray), ((:T,:N), Array, StridedArray)]
-    @eval @generated function permutedims!{$(V...)}(P::$PT{$(V...)}, B::$BT{$(V...)}, perm)
+    @eval @generated function permutedims!(P::$PT{$(V...)}, B::$BT{$(V...)}, perm) where $(V...)
         quote
             checkdims_perm(P, B, perm)
 
@@ -1155,12 +1369,11 @@ end
 hash(x::Prehashed) = x.hash
 
 """
-    unique(itr[, dim])
+    unique(A::AbstractArray, dim::Int)
 
-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`.
+Return unique regions of `A` along dimension `dim`.
 
+# Examples
 ```jldoctest
 julia> A = map(isodd, reshape(collect(1:8), (2,2,2)))
 2×2×2 Array{Bool,3}:
@@ -1194,7 +1407,7 @@ julia> unique(A, 3)
  false  false
 ```
 """
-@generated function unique{T,N}(A::AbstractArray{T,N}, dim::Int)
+@generated function unique(A::AbstractArray{T,N}, dim::Int) where {T,N}
     inds = inds -> zeros(UInt, inds)
     quote
         1 <= dim <= $N || return copy(A)
@@ -1270,7 +1483,7 @@ end
 
 Compute the minimum and maximum elements of an array over the given dimensions.
 
-# Example
+# Examples
 ```jldoctest
 julia> A = reshape(collect(1:2:16), (2,2,2))
 2×2×2 Array{Int64,3}:
@@ -1298,7 +1511,7 @@ function extrema(A::AbstractArray, dims)
     return extrema!(B, A)
 end
 
-@generated function extrema!{T,N}(B, A::AbstractArray{T,N})
+@generated function extrema!(B, A::AbstractArray{T,N}) where {T,N}
     return quote
         sA = size(A)
         sB = size(B)
diff --git a/base/multimedia.jl b/base/multimedia.jl
index 9314d4b5ab5539..31e35bfbd4ad8f 100644
--- a/base/multimedia.jl
+++ b/base/multimedia.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module Multimedia
 
@@ -18,8 +18,8 @@ import Base: MIME, @MIME_str
 
 import Base: show, print, string, convert
 MIME(s) = MIME{Symbol(s)}()
-show{mime}(io::IO, ::MIME{mime}) = print(io, "MIME type ", string(mime))
-print{mime}(io::IO, ::MIME{mime}) = print(io, mime)
+show(io::IO, ::MIME{mime}) where {mime} = print(io, "MIME type ", string(mime))
+print(io::IO, ::MIME{mime}) where {mime} = print(io, mime)
 
 ###########################################################################
 # For any type T one can define show(io, ::MIME"type", x::T) = ...
@@ -31,9 +31,18 @@ print{mime}(io::IO, ::MIME{mime}) = print(io, mime)
 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 [`show`](@ref) method for `typeof(x)`.)
+
+# Examples
+```jldoctest
+julia> mimewritable(MIME("text/plain"), rand(5))
+true
+
+julia> mimewritable(MIME("img/png"), rand(5))
+false
+```
 """
-mimewritable{mime}(::MIME{mime}, x) =
-  method_exists(show, Tuple{IO, MIME{mime}, typeof(x)})
+mimewritable(::MIME{mime}, x) where {mime} =
+    method_exists(show, Tuple{IO, MIME{mime}, typeof(x)})
 
 # it is convenient to accept strings instead of ::MIME
 show(io::IO, m::AbstractString, x) = show(io, MIME(m), x)
@@ -90,6 +99,15 @@ _binstringmime(m::MIME, x::Vector{UInt8}) = base64encode(write, x)
 
 Determine whether a MIME type is text data. MIME types are assumed to be binary
 data except for a set of types known to be text data (possibly Unicode).
+
+# Examples
+```jldoctest
+julia> istextmime(MIME("text/plain"))
+true
+
+julia> istextmime(MIME("img/png"))
+false
+```
 """
 istextmime(m::MIME) = startswith(string(m), "text/")
 
@@ -167,10 +185,26 @@ close(d::TextDisplay) = close(d.io)
 # Display that is capable of displaying x (doesn't throw an error)
 
 const displays = Display[]
+
+"""
+    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`](@ref)).
+"""
 function pushdisplay(d::Display)
     global displays
     push!(displays, d)
 end
+
+"""
+    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() = pop!(displays)
 function popdisplay(d::Display)
     for i = length(displays):-1:1
@@ -187,6 +221,24 @@ end
 
 xdisplayable(D::Display, args...) = applicable(display, D, args...)
 
+"""
+    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`](@ref) output as a fallback.
+The `display(d, x)` variant attempts to display `x` on the given display `d` only, throwing
+a [`MethodError`](@ref) 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).
+"""
 function display(x)
     for i = length(displays):-1:1
         if xdisplayable(displays[i], x)
@@ -215,8 +267,8 @@ function display(m::MIME, x)
     throw(MethodError(display, (m, x)))
 end
 
-displayable{D<:Display,mime}(d::D, ::MIME{mime}) =
-  method_exists(display, Tuple{D, MIME{mime}, Any})
+displayable(d::D, ::MIME{mime}) where {D<:Display,mime} =
+    method_exists(display, Tuple{D,MIME{mime},Any})
 
 function displayable(m::MIME)
     for d in displays
@@ -233,6 +285,19 @@ end
 # for Matlab/Pylab-like stateful plotting interfaces, where
 # a plot is created and then modified many times (xlabel, title, etc.).
 
+"""
+    redisplay(x)
+    redisplay(d::Display, x)
+    redisplay(mime, x)
+    redisplay(d::Display, mime, x)
+
+By default, the `redisplay` functions simply call [`display`](@ref).
+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.
+"""
 function redisplay(x)
     for i = length(displays):-1:1
         if xdisplayable(displays[i], x)
diff --git a/base/multinverses.jl b/base/multinverses.jl
index 39109d16bcac87..319072e7214acd 100644
--- a/base/multinverses.jl
+++ b/base/multinverses.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module MultiplicativeInverses
 
@@ -11,7 +11,7 @@ unsigned(::Type{Int16}) = UInt16
 unsigned(::Type{Int32}) = UInt32
 unsigned(::Type{Int64}) = UInt64
 unsigned(::Type{Int128}) = UInt128
-unsigned{T<:Unsigned}(::Type{T}) = T
+unsigned(::Type{T}) where {T<:Unsigned} = T
 
 abstract type  MultiplicativeInverse{T} end
 
@@ -134,21 +134,21 @@ struct UnsignedMultiplicativeInverse{T<:Unsigned} <: MultiplicativeInverse{T}
 end
 UnsignedMultiplicativeInverse(x::Unsigned) = UnsignedMultiplicativeInverse{typeof(x)}(x)
 
-function div{T}(a::T, b::SignedMultiplicativeInverse{T})
-    x = ((widen(a)*b.multiplier) >>> sizeof(a)*8) % T
+function div(a::T, b::SignedMultiplicativeInverse{T}) where T
+    x = ((widen(a)*b.multiplier) >>> (sizeof(a)*8)) % T
     x += (a*b.addmul) % T
     ifelse(abs(b.divisor) == 1, a*b.divisor, (signbit(x) + (x >> b.shift)) % T)
 end
-function div{T}(a::T, b::UnsignedMultiplicativeInverse{T})
-    x = ((widen(a)*b.multiplier) >>> sizeof(a)*8) % T
+function div(a::T, b::UnsignedMultiplicativeInverse{T}) where T
+    x = ((widen(a)*b.multiplier) >>> (sizeof(a)*8)) % T
     x = ifelse(b.add, convert(T, convert(T, (convert(T, a - x) >>> 1)) + x), x)
     ifelse(b.divisor == 1, a, x >>> b.shift)
 end
 
-rem{T}(a::T, b::MultiplicativeInverse{T}) =
+rem(a::T, b::MultiplicativeInverse{T}) where {T} =
     a - div(a, b)*b.divisor
 
-function divrem{T}(a::T, b::MultiplicativeInverse{T})
+function divrem(a::T, b::MultiplicativeInverse{T}) where T
     d = div(a, b)
     (d, a - d*b.divisor)
 end
diff --git a/base/nofloat_hashing.jl b/base/nofloat_hashing.jl
index 675c27560a30da..3ef707d1c440f0 100644
--- a/base/nofloat_hashing.jl
+++ b/base/nofloat_hashing.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## hashing small, built-in numeric types
 ## for a system image built without floating point support
diff --git a/base/nullable.jl b/base/nullable.jl
index 43ff7066ac112d..493c9eb98d1f22 100644
--- a/base/nullable.jl
+++ b/base/nullable.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 struct NullException <: Exception
 end
@@ -14,7 +14,6 @@ wrapper that might contain a value of type `T`.
 field.
 
 # Examples
-
 ```jldoctest
 julia> Nullable(1)
 Nullable{Int64}(1)
@@ -31,31 +30,31 @@ Nullable{Int64}
   value: Int64 1
 ```
 """
-Nullable{T}(value::T, hasvalue::Bool=true) = Nullable{T}(value, hasvalue)
+Nullable(value::T, hasvalue::Bool=true) where {T} = Nullable{T}(value, hasvalue)
 Nullable() = Nullable{Union{}}()
 
-eltype{T}(::Type{Nullable{T}}) = T
+eltype(::Type{Nullable{T}}) where {T} = T
 
-convert{T}(::Type{Nullable{T}}, x::Nullable{T}) = x
-convert(   ::Type{Nullable   }, x::Nullable   ) = x
+convert(::Type{Nullable{T}}, x::Nullable{T}) where {T} = x
+convert(::Type{Nullable   }, x::Nullable   ) = x
 
-convert{T}(t::Type{Nullable{T}}, x::Any) = convert(t, convert(T, x))
+convert(t::Type{Nullable{T}}, x::Any) where {T} = convert(t, convert(T, x))
 
-function convert{T}(::Type{Nullable{T}}, x::Nullable)
+function convert(::Type{Nullable{T}}, x::Nullable) where T
     return isnull(x) ? Nullable{T}() : Nullable{T}(convert(T, get(x)))
 end
 
-convert{T<:Nullable}(::Type{Nullable{T}}, x::T) = Nullable{T}(x)
-convert{T}(::Type{Nullable{T}}, x::T) = Nullable{T}(x)
-convert{T}(::Type{Nullable   }, x::T) = Nullable{T}(x)
+convert(::Type{Nullable{T}}, x::T) where {T<:Nullable} = Nullable{T}(x)
+convert(::Type{Nullable{T}}, x::T) where {T} = Nullable{T}(x)
+convert(::Type{Nullable   }, x::T) where {T} = Nullable{T}(x)
 
-convert{T}(::Type{Nullable{T}}, ::Void) = Nullable{T}()
-convert(   ::Type{Nullable   }, ::Void) = Nullable{Union{}}()
+convert(::Type{Nullable{T}}, ::Void) where {T} = Nullable{T}()
+convert(::Type{Nullable   }, ::Void) = Nullable{Union{}}()
 
-promote_rule{S,T}(::Type{Nullable{S}}, ::Type{T}) = Nullable{promote_type(S, T)}
-promote_rule{S,T}(::Type{Nullable{S}}, ::Type{Nullable{T}}) = Nullable{promote_type(S, T)}
-promote_op{S,T}(op::Any, ::Type{Nullable{S}}, ::Type{Nullable{T}}) = Nullable{promote_op(op, S, T)}
-promote_op{S,T}(op::Type, ::Type{Nullable{S}}, ::Type{Nullable{T}}) = Nullable{promote_op(op, S, T)}
+promote_rule(::Type{Nullable{S}}, ::Type{T}) where {S,T} = Nullable{promote_type(S, T)}
+promote_rule(::Type{Nullable{S}}, ::Type{Nullable{T}}) where {S,T} = Nullable{promote_type(S, T)}
+promote_op(op::Any, ::Type{Nullable{S}}, ::Type{Nullable{T}}) where {S,T} = Nullable{promote_op(op, S, T)}
+promote_op(op::Type, ::Type{Nullable{S}}, ::Type{Nullable{T}}) where {S,T} = Nullable{promote_op(op, S, T)}
 
 function show(io::IO, x::Nullable)
     if get(io, :compact, false)
@@ -80,8 +79,19 @@ end
 
 Attempt to access the value of `x`. Returns the value if it is present;
 otherwise, returns `y` if provided, or throws a `NullException` if not.
+
+# Examples
+```jldoctest
+julia> get(Nullable(5))
+5
+
+julia> get(Nullable())
+ERROR: NullException()
+Stacktrace:
+ [1] get(::Nullable{Union{}}) at ./nullable.jl:102
+```
 """
-@inline function get{T}(x::Nullable{T}, y)
+@inline function get(x::Nullable{T}, y) where T
     if isbits(T)
         ifelse(isnull(x), y, x.value)
     else
@@ -100,6 +110,7 @@ all other `x`.
 This method does not check whether or not `x` is null before attempting to
 access the value of `x` for `x::Nullable` (hence "unsafe").
 
+# Examples
 ```jldoctest
 julia> x = Nullable(1)
 Nullable{Int64}(1)
@@ -113,7 +124,7 @@ Nullable{String}()
 julia> unsafe_get(x)
 ERROR: UndefRefError: access to undefined reference
 Stacktrace:
- [1] unsafe_get(::Nullable{String}) at ./nullable.jl:125
+ [1] unsafe_get(::Nullable{String}) at ./nullable.jl:136
 
 julia> x = 1
 1
@@ -132,7 +143,6 @@ Return whether or not `x` is null for [`Nullable`](@ref) `x`; return
 `false` for all other `x`.
 
 # Examples
-
 ```jldoctest
 julia> x = Nullable(1, false)
 Nullable{Int64}()
@@ -186,19 +196,13 @@ const NullSafeFloats = Union{Type{Float16}, Type{Float32}, Type{Float64}}
 const NullSafeTypes = Union{NullSafeInts, NullSafeFloats}
 const EqualOrLess = Union{typeof(isequal), typeof(isless)}
 
-null_safe_op{T}(::typeof(identity), ::Type{T}) = isbits(T)
-
-eltypes() = Tuple{}
-eltypes(x, xs...) = Tuple{eltype(x), eltypes(xs...).parameters...}
-
-@pure null_safe_eltype_op(op, xs...) =
-    null_safe_op(op, eltypes(xs...).parameters...)
+null_safe_op(::typeof(identity), ::Type{T}) where {T} = isbits(T)
 
 null_safe_op(f::EqualOrLess, ::NullSafeTypes, ::NullSafeTypes) = true
-null_safe_op{S,T}(f::EqualOrLess, ::Type{Rational{S}}, ::Type{T}) =
+null_safe_op(f::EqualOrLess, ::Type{Rational{S}}, ::Type{T}) where {S,T} =
     null_safe_op(f, T, S)
 # complex numbers can be compared for equality but not in general ordered
-null_safe_op{S,T}(::typeof(isequal), ::Type{Complex{S}}, ::Type{T}) =
+null_safe_op(::typeof(isequal), ::Type{Complex{S}}, ::Type{T}) where {S,T} =
     null_safe_op(isequal, T, S)
 
 """
@@ -207,8 +211,23 @@ null_safe_op{S,T}(::typeof(isequal), ::Type{Complex{S}}, ::Type{T}) =
 If neither `x` nor `y` is null, compare them according to their values
 (i.e. `isequal(get(x), get(y))`). Else, return `true` if both arguments are null,
 and `false` if one is null but not the other: nulls are considered equal.
+
+# Examples
+```jldoctest
+julia> isequal(Nullable(5), Nullable(5))
+true
+
+julia> isequal(Nullable(5), Nullable(4))
+false
+
+julia> isequal(Nullable(5), Nullable())
+false
+
+julia> isequal(Nullable(), Nullable())
+true
+```
 """
-@inline function isequal{S,T}(x::Nullable{S}, y::Nullable{T})
+@inline function isequal(x::Nullable{S}, y::Nullable{T}) where {S,T}
     if null_safe_op(isequal, S, T)
         (isnull(x) & isnull(y)) | (!isnull(x) & !isnull(y) & isequal(x.value, y.value))
     else
@@ -227,8 +246,29 @@ If neither `x` nor `y` is null, compare them according to their values
 (i.e. `isless(get(x), get(y))`). Else, return `true` if only `y` is null, and `false`
 otherwise: nulls are always considered greater than non-nulls, but not greater than
 another null.
+
+# Examples
+```jldoctest
+julia> isless(Nullable(6), Nullable(5))
+false
+
+julia> isless(Nullable(5), Nullable(6))
+true
+
+julia> isless(Nullable(5), Nullable(4))
+false
+
+julia> isless(Nullable(5), Nullable())
+true
+
+julia> isless(Nullable(), Nullable())
+false
+
+julia> isless(Nullable(), Nullable(5))
+false
+```
 """
-@inline function isless{S,T}(x::Nullable{S}, y::Nullable{T})
+@inline function isless(x::Nullable{S}, y::Nullable{T}) where {S,T}
     # NULL values are sorted last
     if null_safe_op(isless, S, T)
         (!isnull(x) & isnull(y)) | (!isnull(x) & !isnull(y) & isless(x.value, y.value))
@@ -258,8 +298,20 @@ end
     filter(p, x::Nullable)
 
 Return null if either `x` is null or `p(get(x))` is false, and `x` otherwise.
+
+# Examples
+```jldoctest
+julia> filter(isodd, Nullable(5))
+Nullable{Int64}(5)
+
+julia> filter(isodd, Nullable(4))
+Nullable{Int64}()
+
+julia> filter(isodd, Nullable{Int}())
+Nullable{Int64}()
+```
 """
-function filter{T}(p, x::Nullable{T})
+function filter(p, x::Nullable{T}) where T
     if isbits(T)
         val = unsafe_get(x)
         Nullable{T}(val, !isnull(x) && p(val))
@@ -271,7 +323,7 @@ end
 """
 Return the given type if it is concrete, and `Union{}` otherwise.
 """
-nullable_returntype{T}(::Type{T}) = isconcrete(T) ? T : Union{}
+nullable_returntype(::Type{T}) where {T} = isconcrete(T) ? T : Union{}
 
 """
     map(f, x::Nullable)
@@ -282,8 +334,20 @@ be either `Union{}` or a concrete type. Whichever of these is chosen is an
 implementation detail, but typically the choice that maximizes performance
 would be used. If `x` has a value, then the return type is guaranteed to be of
 type `Nullable{typeof(f(x))}`.
+
+# Examples
+```jldoctest
+julia> map(isodd, Nullable(1))
+Nullable{Bool}(true)
+
+julia> map(isodd, Nullable(2))
+Nullable{Bool}(false)
+
+julia> map(isodd, Nullable{Int}())
+Nullable{Bool}()
+```
 """
-function map{T}(f, x::Nullable{T})
+function map(f, x::Nullable{T}) where T
     S = promote_op(f, T)
     if isconcrete(S) && null_safe_op(f, T)
         Nullable(f(unsafe_get(x)), !isnull(x))
@@ -309,8 +373,8 @@ all(f::typeof(hasvalue), t::Tuple{}) = true
 # Note this list does not include sqrt since it can raise a DomainError
 for op in (+, -, abs, abs2)
     null_safe_op(::typeof(op), ::NullSafeTypes) = true
-    null_safe_op{S}(::typeof(op), ::Type{Complex{S}}) = null_safe_op(op, S)
-    null_safe_op{S}(::typeof(op), ::Type{Rational{S}}) = null_safe_op(op, S)
+    null_safe_op(::typeof(op), ::Type{Complex{S}}) where {S} = null_safe_op(op, S)
+    null_safe_op(::typeof(op), ::Type{Rational{S}}) where {S} = null_safe_op(op, S)
 end
 
 null_safe_op(::typeof(~), ::NullSafeInts) = true
@@ -329,8 +393,8 @@ for op in (+, -, *, /, &, |, <<, >>, >>>,
     null_safe_op(::typeof(op), ::NullSafeUnsignedInts, ::NullSafeUnsignedInts) = true
 end
 for op in (+, -, *, /)
-    null_safe_op{S,T}(::typeof(op), ::Type{Complex{S}}, ::Type{T}) =
+    null_safe_op(::typeof(op), ::Type{Complex{S}}, ::Type{T}) where {S,T} =
         null_safe_op(op, T, S)
-    null_safe_op{S,T}(::typeof(op), ::Type{Rational{S}}, ::Type{T}) =
+    null_safe_op(::typeof(op), ::Type{Rational{S}}, ::Type{T}) where {S,T} =
         null_safe_op(op, T, S)
 end
diff --git a/base/number.jl b/base/number.jl
index 687d76d59a1154..255ceebf9af6cb 100644
--- a/base/number.jl
+++ b/base/number.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## generic operations on numbers ##
 """
@@ -18,14 +18,32 @@ isinteger(x::Integer) = true
 
 Return `true` if `x == zero(x)`; if `x` is an array, this checks whether
 all of the elements of `x` are zero.
+
+```jldoctest
+julia> iszero(0.0)
+true
+```
 """
 iszero(x) = x == zero(x) # fallback method
 
+"""
+    isone(x)
+
+Return `true` if `x == one(x)`; if `x` is an array, this checks whether
+`x` is an identity matrix.
+
+```jldoctest
+julia> isone(1.0)
+true
+```
+"""
+isone(x) = x == one(x) # fallback method
+
 size(x::Number) = ()
 size(x::Number,d) = convert(Int,d)<1 ? throw(BoundsError()) : 1
 indices(x::Number) = ()
 indices(x::Number,d) = convert(Int,d)<1 ? throw(BoundsError()) : OneTo(1)
-eltype{T<:Number}(::Type{T}) = T
+eltype(::Type{T}) where {T<:Number} = T
 ndims(x::Number) = 0
 ndims(::Type{<:Number}) = 0
 length(x::Number) = 1
@@ -69,6 +87,27 @@ divrem(x,y) = (div(x,y),rem(x,y))
 The floored quotient and modulus after division. Equivalent to `(fld(x,y), mod(x,y))`.
 """
 fldmod(x,y) = (fld(x,y),mod(x,y))
+
+"""
+    signbit(x)
+
+Returns `true` if the value of the sign of `x` is negative, otherwise `false`.
+
+# Examples
+```jldoctest
+julia> signbit(-4)
+true
+
+julia> signbit(5)
+false
+
+julia> signbit(5.5)
+false
+
+julia> signbit(-4.1)
+true
+```
+"""
 signbit(x::Real) = x < 0
 
 """
@@ -85,6 +124,11 @@ abs(x::Real) = ifelse(signbit(x), -x, x)
     abs2(x)
 
 Squared absolute value of `x`.
+
+```jldoctest
+julia> abs2(-3)
+9
+```
 """
 abs2(x::Real) = x*x
 
@@ -92,16 +136,50 @@ abs2(x::Real) = x*x
     flipsign(x, y)
 
 Return `x` with its sign flipped if `y` is negative. For example `abs(x) = flipsign(x,x)`.
+
+```jldoctest
+julia> flipsign(5, 3)
+5
+
+julia> flipsign(5, -3)
+-5
+```
 """
-flipsign(x::Real, y::Real) = ifelse(signbit(y), -x, x)
-copysign(x::Real, y::Real) = ifelse(signbit(x)!=signbit(y), -x, x)
+flipsign(x::Real, y::Real) = ifelse(signbit(y), -x, +x) # the + is for type-stability on Bool
+copysign(x::Real, y::Real) = ifelse(signbit(x)!=signbit(y), -x, +x)
 
 conj(x::Real) = x
 transpose(x::Number) = x
 ctranspose(x::Number) = conj(x)
-inv(x::Number) = one(x)/x
 angle(z::Real) = atan2(zero(z), z)
 
+"""
+    inv(x)
+
+Return the multiplicative inverse of `x`, such that `x*inv(x)` or `inv(x)*x`
+yields [`one(x)`](@ref) (the multiplicative identity) up to roundoff errors.
+
+If `x` is a number, this is essentially the same as `one(x)/x`, but for
+some types `inv(x)` may be slightly more efficient.
+
+# Examples
+```jldoctest
+julia> inv(2)
+0.5
+
+julia> inv(1 + 2im)
+0.2 - 0.4im
+
+julia> inv(1 + 2im) * (1 + 2im)
+1.0 + 0.0im
+
+julia> inv(2//3)
+3//2
+```
+"""
+inv(x::Number) = one(x)/x
+
+
 """
     widemul(x, y)
 
@@ -126,9 +204,22 @@ map(f, x::Number, ys::Number...) = f(x, ys...)
     zero(x)
 
 Get the additive identity element for the type of `x` (`x` can also specify the type itself).
+
+```jldoctest
+julia> zero(1)
+0
+
+julia> zero(big"2.0")
+0.000000000000000000000000000000000000000000000000000000000000000000000000000000
+
+julia> zero(rand(2,2))
+2×2 Array{Float64,2}:
+ 0.0  0.0
+ 0.0  0.0
+```
 """
 zero(x::Number) = oftype(x,0)
-zero{T<:Number}(::Type{T}) = convert(T,0)
+zero(::Type{T}) where {T<:Number} = convert(T,0)
 
 """
     one(x)
@@ -160,8 +251,8 @@ julia> one(Dates.Day(1))
 1
 ```
 """
-one{T<:Number}(::Type{T}) = convert(T,1)
-one{T<:Number}(x::T) = one(T)
+one(::Type{T}) where {T<:Number} = convert(T,1)
+one(x::T) where {T<:Number} = one(T)
 # note that convert(T, 1) should throw an error if T is dimensionful,
 # so this fallback definition should be okay.
 
@@ -182,16 +273,16 @@ julia> oneunit(Dates.Day)
 1 day
 ```
 """
-oneunit{T}(x::T) = T(one(x))
-oneunit{T}(::Type{T}) = T(one(T))
+oneunit(x::T) where {T} = T(one(x))
+oneunit(::Type{T}) where {T} = T(one(T))
 
 _default_type(::Type{Number}) = Int
 
 """
     factorial(n)
 
-Factorial of `n`.  If `n` is an `Integer`, the factorial is computed as an
-integer (promoted to at least 64 bits).  Note that this may overflow if `n` is not small,
+Factorial of `n`. If `n` is an [`Integer`](@ref), 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)`](@ref).
 
@@ -211,3 +302,22 @@ julia> factorial(big(21))
 ```
 """
 factorial(x::Number) = gamma(x + 1) # fallback for x not Integer
+
+"""
+    big(T::Type)
+
+Compute the type that represents the numeric type `T` with arbitrary precision.
+Equivalent to `typeof(big(zero(T)))`.
+
+```jldoctest
+julia> big(Rational)
+Rational{BigInt}
+
+julia> big(Float64)
+BigFloat
+
+julia> big(Complex{Int})
+Complex{BigInt}
+```
+"""
+big(::Type{T}) where {T<:Number} = typeof(big(zero(T)))
diff --git a/base/operators.jl b/base/operators.jl
index 29e90e5890b880..afdd22823fd064 100644
--- a/base/operators.jl
+++ b/base/operators.jl
@@ -1,11 +1,12 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## types ##
 
 """
     <:(T1, T2)
 
-Subtype operator, equivalent to `issubtype(T1, T2)`.
+Subtype operator: returns `true` if and only if all values of type `T1` are
+also of type `T2`.
 
 ```jldoctest
 julia> Float64 <: AbstractFloat
@@ -18,14 +19,14 @@ julia> Matrix{Float64} <: Matrix{AbstractFloat}
 false
 ```
 """
-const (<:) = issubtype
+(<:)
 
 """
     >:(T1, T2)
 
-Supertype operator, equivalent to `issubtype(T2, T1)`.
+Supertype operator, equivalent to `T2 <: T1`.
 """
-const (>:)(a::ANY, b::ANY) = issubtype(b, a)
+const (>:)(@nospecialize(a), @nospecialize(b)) = (b <: a)
 
 """
     supertype(T::DataType)
@@ -70,6 +71,7 @@ Scalar types generally do not need to implement `isequal` separate from `==`, un
 represent floating-point numbers amenable to a more efficient implementation than that
 provided as a generic fallback (based on `isnan`, `signbit`, and `==`).
 
+# Examples
 ```jldoctest
 julia> isequal([1., NaN], [1., NaN])
 true
@@ -86,13 +88,17 @@ false
 """
 isequal(x, y) = x == y
 
-isequal(x::AbstractFloat, y::AbstractFloat) = (isnan(x) & isnan(y)) | (signbit(x) == signbit(y)) & (x == y)
-isequal(x::Real,          y::AbstractFloat) = (isnan(x) & isnan(y)) | (signbit(x) == signbit(y)) & (x == y)
-isequal(x::AbstractFloat, y::Real         ) = (isnan(x) & isnan(y)) | (signbit(x) == signbit(y)) & (x == y)
+signequal(x, y) = signbit(x)::Bool == signbit(y)::Bool
+signless(x, y) = signbit(x)::Bool & !signbit(y)::Bool
+
+isequal(x::AbstractFloat, y::AbstractFloat) = (isnan(x) & isnan(y)) | signequal(x, y) & (x == y)
+isequal(x::Real,          y::AbstractFloat) = (isnan(x) & isnan(y)) | signequal(x, y) & (x == y)
+isequal(x::AbstractFloat, y::Real         ) = (isnan(x) & isnan(y)) | signequal(x, y) & (x == y)
+
+isless(x::AbstractFloat, y::AbstractFloat) = (!isnan(x) & isnan(y)) | signless(x, y) | (x < y)
+isless(x::Real,          y::AbstractFloat) = (!isnan(x) & isnan(y)) | signless(x, y) | (x < y)
+isless(x::AbstractFloat, y::Real         ) = (!isnan(x) & isnan(y)) | signless(x, y) | (x < y)
 
-isless(x::AbstractFloat, y::AbstractFloat) = (!isnan(x) & isnan(y)) | (signbit(x) & !signbit(y)) | (x < y)
-isless(x::Real,          y::AbstractFloat) = (!isnan(x) & isnan(y)) | (signbit(x) & !signbit(y)) | (x < y)
-isless(x::AbstractFloat, y::Real         ) = (!isnan(x) & isnan(y)) | (signbit(x) & !signbit(y)) | (x < y)
 
 function ==(T::Type, S::Type)
     @_pure_meta
@@ -114,6 +120,7 @@ end
 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.
 
+# Examples
 ```jldoctest
 julia> 3 != 2
 true
@@ -122,7 +129,7 @@ julia> "foo" ≠ "foo"
 false
 ```
 """
-!=(x, y) = !(x == y)
+!=(x, y) = !(x == y)::Bool
 const ≠ = !=
 
 """
@@ -133,6 +140,7 @@ Determine whether `x` and `y` are identical, in the sense that no program could
 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`.
 
+# Examples
 ```jldoctest
 julia> a = [1, 2]; b = [1, 2];
 
@@ -155,6 +163,7 @@ const ≡ = ===
 
 Equivalent to `!(x === y)`.
 
+# Examples
 ```jldoctest
 julia> a = [1, 2]; b = [1, 2];
 
@@ -176,6 +185,7 @@ 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`.
 
+# Examples
 ```jldoctest
 julia> 'a' < 'b'
 true
@@ -195,6 +205,7 @@ false
 Greater-than comparison operator. Generally, new types should implement `<` instead of this
 function, and rely on the fallback definition `>(x, y) = y < x`.
 
+# Examples
 ```jldoctest
 julia> 'a' > 'b'
 false
@@ -217,6 +228,7 @@ true
 
 Less-than-or-equals comparison operator.
 
+# Examples
 ```jldoctest
 julia> 'a' <= 'b'
 true
@@ -231,7 +243,7 @@ julia> 5 <= 3
 false
 ```
 """
-<=(x, y) = !(y < x)
+<=(x, y) = (x < y) | (x == y)
 const ≤ = <=
 
 """
@@ -240,6 +252,7 @@ const ≤ = <=
 
 Greater-than-or-equals comparison operator.
 
+# Examples
 ```jldoctest
 julia> 'a' >= 'b'
 false
@@ -270,6 +283,7 @@ that it is an ordinary function, so all the arguments are evaluated first. In so
 using `ifelse` instead of an `if` statement can eliminate the branch in generated code and
 provide higher performance in tight loops.
 
+# Examples
 ```jldoctest
 julia> ifelse(1 > 2, 1, 2)
 2
@@ -284,6 +298,7 @@ Return -1, 0, or 1 depending on whether `x` is less than, equal to, or greater t
 respectively. Uses the total order implemented by `isless`. For floating-point numbers, uses `<`
 but throws an error for unordered arguments.
 
+# Examples
 ```jldoctest
 julia> cmp(1, 2)
 -1
@@ -305,6 +320,7 @@ Compare `x` and `y` lexicographically and return -1, 0, or 1 depending on whethe
 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.
 
+# Examples
 ```jldoctest
 julia> lexcmp("abc", "abd")
 -1
@@ -320,6 +336,7 @@ lexcmp(x, y) = cmp(x, y)
 
 Determine whether `x` is lexicographically less than `y`.
 
+# Examples
 ```jldoctest
 julia> lexless("abc", "abd")
 true
@@ -336,6 +353,7 @@ cmp(x::Integer, y::Integer) = ifelse(isless(x, y), -1, ifelse(isless(y, x), 1, 0
 Return the maximum of the arguments. See also the [`maximum`](@ref) function
 to take the maximum element from a collection.
 
+# Examples
 ```jldoctest
 julia> max(2, 5, 1)
 5
@@ -349,6 +367,7 @@ max(x, y) = ifelse(y < x, x, y)
 Return the minimum of the arguments. See also the [`minimum`](@ref) function
 to take the minimum element from a collection.
 
+# Examples
 ```jldoctest
 julia> min(2, 5, 1)
 1
@@ -361,6 +380,7 @@ min(x,y) = ifelse(y < x, y, x)
 
 Return `(min(x,y), max(x,y))`. See also: [`extrema`](@ref) that returns `(minimum(x), maximum(x))`.
 
+# Examples
 ```jldoctest
 julia> minmax('c','b')
 ('b', 'c')
@@ -385,6 +405,7 @@ scalarmin(x::AbstractArray, y               ) = throw(ArgumentError("ordering is
 
 The identity function. Returns its argument.
 
+# Examples
 ```jldoctest
 julia> identity("Well, what did you expect?")
 "Well, what did you expect?"
@@ -430,6 +451,7 @@ end
 Left division operator: multiplication of `y` by the inverse of `x` on the left. Gives
 floating-point results for integer arguments.
 
+# Examples
 ```jldoctest
 julia> 3 \\ 6
 2.0
@@ -463,6 +485,7 @@ Left bit shift operator, `x << n`. For `n >= 0`, the result is `x` shifted left
 by `n` bits, filling with `0`s. This is equivalent to `x * 2^n`. For `n < 0`,
 this is equivalent to `x >> -n`.
 
+# Examples
 ```jldoctest
 julia> Int8(3) << 2
 12
@@ -476,6 +499,7 @@ julia> bits(Int8(12))
 See also [`>>`](@ref), [`>>>`](@ref).
 """
 function <<(x::Integer, c::Integer)
+    @_inline_meta
     typemin(Int) <= c <= typemax(Int) && return x << (c % Int)
     (x >= 0 || c >= 0) && return zero(x)
     oftype(x, -1)
@@ -491,7 +515,7 @@ 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)`. For `n <
 0`, this is equivalent to `x << -n`.
 
-
+# Examples
 ```jldoctest
 julia> Int8(13) >> 2
 3
@@ -514,6 +538,7 @@ julia> bits(Int8(-4))
 See also [`>>>`](@ref), [`<<`](@ref).
 """
 function >>(x::Integer, c::Integer)
+    @_inline_meta
     typemin(Int) <= c <= typemax(Int) && return x >> (c % Int)
     (x >= 0 || c < 0) && return zero(x)
     oftype(x, -1)
@@ -528,9 +553,10 @@ Unsigned right bit shift operator, `x >>> n`. For `n >= 0`, the result is `x`
 shifted right by `n` bits, where `n >= 0`, filling with `0`s. For `n < 0`, this
 is equivalent to `x << -n`.
 
-For `Unsigned` integer types, this is equivalent to [`>>`](@ref). For
-`Signed` integer types, this is equivalent to `signed(unsigned(x) >> n)`.
+For [`Unsigned`](@ref) integer types, this is equivalent to [`>>`](@ref). For
+[`Signed`](@ref) integer types, this is equivalent to `signed(unsigned(x) >> n)`.
 
+# Examples
 ```jldoctest
 julia> Int8(-14) >>> 2
 60
@@ -541,46 +567,52 @@ julia> bits(Int8(-14))
 julia> bits(Int8(60))
 "00111100"
 ```
-`BigInt`s are treated as if having infinite size, so no filling is required and this
+
+[`BigInt`](@ref)s are treated as if having infinite size, so no filling is required and this
 is equivalent to [`>>`](@ref).
 
 See also [`>>`](@ref), [`<<`](@ref).
 """
->>>(x::Integer, c::Integer) =
+function >>>(x::Integer, c::Integer)
+    @_inline_meta
     typemin(Int) <= c <= typemax(Int) ? x >>> (c % Int) : zero(x)
+end
 >>>(x::Integer, c::Unsigned) = c <= typemax(UInt) ? x >>> (c % UInt) : zero(x)
 >>>(x::Integer, c::Int) = c >= 0 ? x >>> unsigned(c) : x << unsigned(-c)
 
 # fallback div, fld, and cld implementations
 # NOTE: C89 fmod() and x87 FPREM implicitly provide truncating float division,
 # so it is used here as the basis of float div().
-div{T<:Real}(x::T, y::T) = convert(T,round((x-rem(x,y))/y))
+div(x::T, y::T) where {T<:Real} = convert(T,round((x-rem(x,y))/y))
 
 """
     fld(x, y)
 
 Largest integer less than or equal to `x/y`.
 
+# Examples
 ```jldoctest
 julia> fld(7.3,5.5)
 1.0
 ```
 """
-fld{T<:Real}(x::T, y::T) = convert(T,round((x-mod(x,y))/y))
+fld(x::T, y::T) where {T<:Real} = convert(T,round((x-mod(x,y))/y))
 
 """
     cld(x, y)
 
 Smallest integer larger than or equal to `x/y`.
+
+# Examples
 ```jldoctest
 julia> cld(5.5,2.2)
 3.0
 ```
 """
-cld{T<:Real}(x::T, y::T) = convert(T,round((x-modCeil(x,y))/y))
-#rem{T<:Real}(x::T, y::T) = convert(T,x-y*trunc(x/y))
-#mod{T<:Real}(x::T, y::T) = convert(T,x-y*floor(x/y))
-modCeil{T<:Real}(x::T, y::T) = convert(T,x-y*ceil(x/y))
+cld(x::T, y::T) where {T<:Real} = convert(T,round((x-modCeil(x,y))/y))
+#rem(x::T, y::T) where {T<:Real} = convert(T,x-y*trunc(x/y))
+#mod(x::T, y::T) where {T<:Real} = convert(T,x-y*floor(x/y))
+modCeil(x::T, y::T) where {T<:Real} = convert(T,x-y*ceil(x/y))
 
 # operator alias
 
@@ -591,6 +623,7 @@ modCeil{T<:Real}(x::T, y::T) = convert(T,x-y*ceil(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.
 
+# Examples
 ```jldoctest
 julia> x = 15; y = 4;
 
@@ -610,6 +643,7 @@ const % = rem
 
 The quotient from Euclidean division. Computes `x/y`, truncated to an integer.
 
+# Examples
 ```jldoctest
 julia> 9 ÷ 4
 2
@@ -627,6 +661,7 @@ const ÷ = div
 Modulus after flooring division, returning a value `r` such that `mod(r, y) == mod(x, y)`
 in the range ``(0, y]`` for positive `y` and in the range ``[y,0)`` for negative `y`.
 
+# Examples
 ```jldoctest
 julia> mod1(4, 2)
 2
@@ -635,9 +670,9 @@ julia> mod1(4, 3)
 1
 ```
 """
-mod1{T<:Real}(x::T, y::T) = (m = mod(x, y); ifelse(m == 0, y, m))
+mod1(x::T, y::T) where {T<:Real} = (m = mod(x, y); ifelse(m == 0, y, m))
 # efficient version for integers
-mod1{T<:Integer}(x::T, y::T) = mod(x + y - T(1), y) + T(1)
+mod1(x::T, y::T) where {T<:Integer} = (@_inline_meta; mod(x + y - T(1), y) + T(1))
 
 
 """
@@ -647,6 +682,7 @@ Flooring division, returning a value consistent with `mod1(x,y)`
 
 See also: [`mod1`](@ref).
 
+# Examples
 ```jldoctest
 julia> x = 15; y = 4;
 
@@ -660,9 +696,9 @@ julia> x == (fld1(x, y) - 1) * y + mod1(x, y)
 true
 ```
 """
-fld1{T<:Real}(x::T, y::T) = (m=mod(x,y); fld(x-m,y))
+fld1(x::T, y::T) where {T<:Real} = (m=mod(x,y); fld(x-m,y))
 # efficient version for integers
-fld1{T<:Integer}(x::T, y::T) = fld(x+y-T(1),y)
+fld1(x::T, y::T) where {T<:Integer} = fld(x+y-T(1),y)
 
 """
     fldmod1(x, y)
@@ -671,9 +707,9 @@ Return `(fld1(x,y), mod1(x,y))`.
 
 See also: [`fld1`](@ref), [`mod1`](@ref).
 """
-fldmod1{T<:Real}(x::T, y::T) = (fld1(x,y), mod1(x,y))
+fldmod1(x::T, y::T) where {T<:Real} = (fld1(x,y), mod1(x,y))
 # efficient version for integers
-fldmod1{T<:Integer}(x::T, y::T) = (fld1(x,y), mod1(x,y))
+fldmod1(x::T, y::T) where {T<:Integer} = (fld1(x,y), mod1(x,y))
 
 # transpose
 
@@ -682,8 +718,7 @@ fldmod1{T<:Integer}(x::T, y::T) = (fld1(x,y), mod1(x,y))
 
 The conjugate transposition operator (`'`).
 
-# Example
-
+# Examples
 ```jldoctest
 julia> A =  [3+2im 9+2im; 8+7im  4+6im]
 2×2 Array{Complex{Int64},2}:
@@ -836,7 +871,23 @@ For matrices or vectors ``A`` and ``B``, calculates ``Aᴴ`` \\ ``Bᵀ``.
 """
 Ac_ldiv_Bt(a,b) = Ac_ldiv_B(a,transpose(b))
 
-widen{T<:Number}(x::T) = convert(widen(T), x)
+"""
+    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))`.
+
+# Examples
+```jldoctest
+julia> widen(Int32)
+Int64
+
+julia> widen(1.5f0)
+1.5
+```
+"""
+widen(x::T) where {T<:Number} = convert(widen(T), x)
 
 # function pipelining
 
@@ -845,6 +896,7 @@ widen{T<:Number}(x::T) = convert(widen(T), x)
 
 Applies a function to the preceding argument. This allows for easy function chaining.
 
+# Examples
 ```jldoctest
 julia> [1:5;] |> x->x.^2 |> sum |> inv
 0.01818181818181818
@@ -859,8 +911,8 @@ julia> [1:5;] |> x->x.^2 |> sum |> inv
 
 Compose functions: i.e. `(f ∘ g)(args...)` means `f(g(args...))`. The `∘` symbol can be
 entered in the Julia REPL (and most editors, appropriately configured) by typing `\\circ<tab>`.
-Example:
 
+# Examples
 ```jldoctest
 julia> map(uppercase∘hex, 250:255)
 6-element Array{String,1}:
@@ -879,8 +931,9 @@ julia> map(uppercase∘hex, 250:255)
     !f::Function
 
 Predicate function negation: when the argument of `!` is a function, it returns a
-function which computes the boolean negation of `f`. Example:
+function which computes the boolean negation of `f`.
 
+# Examples
 ```jldoctest
 julia> str = "∀ ε > 0, ∃ δ > 0: |x-y| < δ ⇒ |f(x)-f(y)| < ε"
 "∀ ε > 0, ∃ δ > 0: |x-y| < δ ⇒ |f(x)-f(y)| < ε"
@@ -893,74 +946,3 @@ julia> filter(!isalpha, str)
 ```
 """
 !(f::Function) = (x...)->!f(x...)
-
-# some operators not defined yet
-global //, >:, <|, hcat, hvcat, ⋅, ×, ∈, ∉, ∋, ∌, ⊆, ⊈, ⊊, ∩, ∪, √, ∛
-
-this_module = current_module()
-baremodule Operators
-
-export
-    !,
-    !=,
-    !==,
-    ===,
-    xor,
-    %,
-    ÷,
-    &,
-    *,
-    +,
-    -,
-    /,
-    //,
-    <,
-    <:,
-    >:,
-    <<,
-    <=,
-    ==,
-    >,
-    >=,
-    ≥,
-    ≤,
-    ≠,
-    >>,
-    >>>,
-    \,
-    ^,
-    |,
-    |>,
-    <|,
-    ~,
-    ⋅,
-    ×,
-    ∈,
-    ∉,
-    ∋,
-    ∌,
-    ⊆,
-    ⊈,
-    ⊊,
-    ∩,
-    ∪,
-    √,
-    ∛,
-    ⊻,
-    ∘,
-    colon,
-    hcat,
-    vcat,
-    hvcat,
-    getindex,
-    setindex!,
-    transpose,
-    ctranspose
-
-import ..this_module: !, !=, xor, %, ÷, &, *, +, -,
-    /, //, <, <:, <<, <=, ==, >, >=, >>, >>>,
-    <|, |>, \, ^, |, ~, !==, ===, >:, colon, hcat, vcat, hvcat, getindex, setindex!,
-    transpose, ctranspose,
-    ≥, ≤, ≠, ⋅, ×, ∈, ∉, ∋, ∌, ⊆, ⊈, ⊊, ∩, ∪, √, ∛, ⊻, ∘
-
-end
diff --git a/base/options.jl b/base/options.jl
index ac8d7643680d5b..872fa771ec2913 100644
--- a/base/options.jl
+++ b/base/options.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # NOTE: This type needs to be kept in sync with jl_options in src/julia.h
 struct JLOptions
@@ -26,29 +26,38 @@ struct JLOptions
     can_inline::Int8
     polly::Int8
     fast_math::Int8
-    worker::Ptr{UInt8}
+    worker::Int8
+    cookie::Ptr{UInt8}
     handle_signals::Int8
     use_precompiled::Int8
     use_compilecache::Int8
     bindto::Ptr{UInt8}
     outputbc::Ptr{UInt8}
+    outputunoptbc::Ptr{UInt8}
+    outputjitbc::Ptr{UInt8}
     outputo::Ptr{UInt8}
     outputji::Ptr{UInt8}
     incremental::Int8
 end
 
+# This runs early in the sysimage != is not defined yet
+if sizeof(JLOptions) === ccall(:jl_sizeof_jl_options, Int, ())
+else
+    ccall(:jl_throw, Void, (Any,), "Option structure mismatch")
+end
+
 JLOptions() = unsafe_load(cglobal(:jl_options, JLOptions))
 
 function show(io::IO, opt::JLOptions)
-    println(io, "JLOptions(")
-    fields = fieldnames(opt)
+    print(io, "JLOptions(")
+    fields = fieldnames(JLOptions)
     nfields = length(fields)
-    for (i,f) in enumerate(fieldnames(opt))
-        v = getfield(opt,f)
+    for (i, f) in enumerate(fields)
+        v = getfield(opt, i)
         if isa(v, Ptr{UInt8})
-            v = v != C_NULL ? unsafe_string(v) : ""
+            v = (v != C_NULL) ? unsafe_string(v) : ""
         end
-        println(io, "  ", f, " = ", repr(v), i < nfields ? "," : "")
+        print(io, f, " = ", repr(v), i < nfields ? ", " : "")
     end
-    print(io,")")
+    print(io, ")")
 end
diff --git a/base/ordering.jl b/base/ordering.jl
index 227bc48e8521df..95b86f4be57f02 100644
--- a/base/ordering.jl
+++ b/base/ordering.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module Order
 
@@ -19,7 +19,7 @@ struct ReverseOrdering{Fwd<:Ordering} <: Ordering
 end
 
 ReverseOrdering(rev::ReverseOrdering) = rev.fwd
-ReverseOrdering{Fwd}(fwd::Fwd) = ReverseOrdering{Fwd}(fwd)
+ReverseOrdering(fwd::Fwd) where {Fwd} = ReverseOrdering{Fwd}(fwd)
 
 const DirectOrdering = Union{ForwardOrdering,ReverseOrdering{ForwardOrdering}}
 
diff --git a/base/osutils.jl b/base/osutils.jl
index 0373c6d6c53eac..96b6434d7e0ab3 100644
--- a/base/osutils.jl
+++ b/base/osutils.jl
@@ -1,67 +1,20 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
-
-"""
-    is_unix([os])
-
-Predicate for testing if the OS provides a Unix-like interface.
-See documentation in [Handling Operating System Variation](@ref).
-"""
-function is_unix(os::Symbol)
-    if is_windows(os)
-        return false
-    elseif is_linux(os) || is_bsd(os)
-        return true
-    else
-        throw(ArgumentError("unknown operating system \"$os\""))
-    end
-end
-
-"""
-    is_linux([os])
-
-Predicate for testing if the OS is a derivative of Linux.
-See documentation in [Handling Operating System Variation](@ref).
-"""
-is_linux(os::Symbol) = (os == :Linux)
-
-"""
-    is_bsd([os])
-
-Predicate for testing if the OS is a derivative of BSD.
-See documentation in [Handling Operating System Variation](@ref).
-"""
-is_bsd(os::Symbol) = (os == :FreeBSD || os == :OpenBSD || os == :NetBSD || os == :DragonFly || os == :Darwin || os == :Apple)
-
-"""
-    is_windows([os])
-
-Predicate for testing if the OS is a derivative of Microsoft Windows NT.
-See documentation in [Handling Operating System Variation](@ref).
-"""
-is_windows(os::Symbol) = (os == :Windows || os == :NT)
-
-"""
-    is_apple([os])
-
-Predicate for testing if the OS is a derivative of Apple Macintosh OS X or Darwin.
-See documentation in [Handling Operating System Variation](@ref).
-"""
-is_apple(os::Symbol) = (os == :Apple || os == :Darwin)
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 """
     @static
 
-Partially evaluates an expression at parse time.
+Partially evaluate an expression at parse time.
 
-For example, `@static is_windows() ? foo : bar` will evaluate `is_windows()` and insert either `foo` or `bar` into the expression.
+For example, `@static Sys.iswindows() ? foo : bar` will evaluate `Sys.iswindows()` and insert
+either `foo` or `bar` into the expression.
 This is useful in cases where a construct would be invalid on other platforms,
 such as a `ccall` to a non-existent function.
-`@static if is_apple() foo end` and `@static foo <&&,||> bar` are also valid syntax.
+`@static if Sys.isapple() foo end` and `@static foo <&&,||> bar` are also valid syntax.
 """
 macro static(ex)
     if isa(ex, Expr)
         if ex.head === :if || ex.head === :&& || ex.head === :||
-            cond = eval(current_module(), ex.args[1])
+            cond = eval(__module__, ex.args[1])
             if xor(cond, ex.head === :||)
                 return esc(ex.args[2])
             elseif length(ex.args) == 3
@@ -75,12 +28,3 @@ macro static(ex)
     end
     throw(ArgumentError("invalid @static macro"))
 end
-
-let KERNEL = ccall(:jl_get_UNAME, Any, ())
-    # evaluate the zero-argument form of each of these functions
-    # as a function returning a static constant based on the build-time
-    # operating-system kernel
-    for f in (:is_unix, :is_linux, :is_bsd, :is_apple, :is_windows)
-        @eval $f() = $(getfield(current_module(),f)(KERNEL))
-    end
-end
diff --git a/base/pair.jl b/base/pair.jl
index 798694fd095c2d..3b04bdf91ce344 100644
--- a/base/pair.jl
+++ b/base/pair.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 struct Pair{A,B}
     first::A
@@ -10,7 +10,7 @@ const => = Pair
 start(p::Pair) = 1
 done(p::Pair, i) = i>2
 next(p::Pair, i) = (getfield(p,i), i+1)
-eltype{A,B}(p::Pair{A,B}) = Union{A,B}
+eltype(p::Pair{A,B}) where {A,B} = Union{A,B}
 
 indexed_next(p::Pair, i::Int, state) = (getfield(p,i), i+1)
 
@@ -23,17 +23,17 @@ 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{A,B}(p::Pair{A,B}) = Pair{B,A}(p.second, p.first)
+reverse(p::Pair{A,B}) where {A,B} = Pair{B,A}(p.second, p.first)
 
 endof(p::Pair) = 2
 length(p::Pair) = 2
 first(p::Pair) = p.first
 last(p::Pair) = p.second
 
-convert{A,B}(::Type{Pair{A,B}}, x::Pair{A,B}) = x
-function convert{A,B}(::Type{Pair{A,B}}, x::Pair)
-    Pair{A, B}(convert(A, x[1]), convert(B, x[2]))
+convert(::Type{Pair{A,B}}, x::Pair{A,B}) where {A,B} = x
+function convert(::Type{Pair{A,B}}, x::Pair) where {A,B}
+    Pair{A,B}(convert(A, x[1]), convert(B, x[2]))
 end
 
-promote_rule{A1, B1, A2, B2}(::Type{Pair{A1, B1}}, ::Type{Pair{A2, B2}}) =
+promote_rule(::Type{Pair{A1,B1}}, ::Type{Pair{A2,B2}}) where {A1,B1,A2,B2} =
     Pair{promote_type(A1, A2), promote_type(B1, B2)}
diff --git a/base/parse.jl b/base/parse.jl
index 7d31ea955019f9..543429ce142d93 100644
--- a/base/parse.jl
+++ b/base/parse.jl
@@ -1,10 +1,10 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 import Base.Checked: add_with_overflow, mul_with_overflow
 
 ## string to integer functions ##
 
-function parse{T<:Integer}(::Type{T}, c::Char, base::Integer=36)
+function parse(::Type{T}, c::Char, base::Integer=36) where T<:Integer
     a::Int = (base <= 36 ? 10 : 36)
     2 <= base <= 62 || throw(ArgumentError("invalid base: base must be 2 ≤ base ≤ 62, got $base"))
     d = '0' <= c <= '9' ? c-'0'    :
@@ -56,7 +56,7 @@ function parseint_preamble(signed::Bool, base::Int, s::AbstractString, startpos:
     return sgn, base, j
 end
 
-function tryparse_internal{T<:Integer}(::Type{T}, s::AbstractString, startpos::Int, endpos::Int, base_::Integer, raise::Bool)
+function tryparse_internal(::Type{T}, s::AbstractString, startpos::Int, endpos::Int, base_::Integer, raise::Bool) where T<:Integer
     _n = Nullable{T}()
     sgn, base, i = parseint_preamble(T<:Signed, Int(base_), s, startpos, endpos)
     if sgn == 0 && base == 0 && i == 0
@@ -140,10 +140,10 @@ function tryparse_internal(::Type{Bool}, sbuff::Union{String,SubString},
 
     # Ignore leading and trailing whitespace
     while isspace(sbuff[startpos]) && startpos <= endpos
-        startpos += 1
+        startpos = nextind(sbuff, startpos)
     end
     while isspace(sbuff[endpos]) && endpos >= startpos
-        endpos -= 1
+        endpos = prevind(sbuff, endpos)
     end
 
     len = endpos - startpos + 1
@@ -171,16 +171,22 @@ end
     throw(ArgumentError("invalid base: base must be 2 ≤ base ≤ 62, got $base"))
 end
 
-tryparse{T<:Integer}(::Type{T}, s::AbstractString, base::Integer) =
+"""
+    tryparse(type, str, [base])
+
+Like [`parse`](@ref), but returns a [`Nullable`](@ref) of the requested type. The result
+will be null if the string does not contain a valid number.
+"""
+tryparse(::Type{T}, s::AbstractString, base::Integer) where {T<:Integer} =
     tryparse_internal(T, s, start(s), endof(s), check_valid_base(base), false)
-tryparse{T<:Integer}(::Type{T}, s::AbstractString) =
+tryparse(::Type{T}, s::AbstractString) where {T<:Integer} =
     tryparse_internal(T, s, start(s), endof(s), 0, false)
 
-function parse{T<:Integer}(::Type{T}, s::AbstractString, base::Integer)
+function parse(::Type{T}, s::AbstractString, base::Integer) where T<:Integer
     get(tryparse_internal(T, s, start(s), endof(s), check_valid_base(base), true))
 end
 
-function parse{T<:Integer}(::Type{T}, s::AbstractString)
+function parse(::Type{T}, s::AbstractString) where T<:Integer
     get(tryparse_internal(T, s, start(s), endof(s), 0, true)) # Zero means, "figure it out"
 end
 
@@ -193,9 +199,11 @@ tryparse(::Type{Float64}, s::SubString{String}) = ccall(:jl_try_substrtod, Nulla
 tryparse(::Type{Float32}, s::String) = ccall(:jl_try_substrtof, Nullable{Float32}, (Ptr{UInt8},Csize_t,Csize_t), s, 0, sizeof(s))
 tryparse(::Type{Float32}, s::SubString{String}) = ccall(:jl_try_substrtof, Nullable{Float32}, (Ptr{UInt8},Csize_t,Csize_t), s.string, s.offset, s.endof)
 
-tryparse{T<:Union{Float32,Float64}}(::Type{T}, s::AbstractString) = tryparse(T, String(s))
+tryparse(::Type{T}, s::AbstractString) where {T<:Union{Float32,Float64}} = tryparse(T, String(s))
+
+tryparse(::Type{Float16}, s::AbstractString) = convert(Nullable{Float16}, tryparse(Float32, s))
 
-function parse{T<:AbstractFloat}(::Type{T}, s::AbstractString)
+function parse(::Type{T}, s::AbstractString) where T<:AbstractFloat
     result = tryparse(T, s)
     if isnull(result)
         throw(ArgumentError("cannot parse $(repr(s)) as $T"))
@@ -215,7 +223,7 @@ function parse(str::AbstractString, pos::Int; greedy::Bool=true, raise::Bool=tru
     bstr = String(str)
     ex, pos = ccall(:jl_parse_string, Any,
                     (Ptr{UInt8}, Csize_t, Int32, Int32),
-                    bstr, sizeof(bstr), pos-1, greedy ? 1:0)
+                    bstr, sizeof(bstr), pos-1, greedy ? 1 : 0)
     if raise && isa(ex,Expr) && ex.head === :error
         throw(ParseError(ex.args[1]))
     end
diff --git a/base/path.jl b/base/path.jl
index 6b04246a5f7777..c042bef833e1f5 100644
--- a/base/path.jl
+++ b/base/path.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 export
     abspath,
@@ -16,16 +16,15 @@ export
     splitdrive,
     splitext
 
-if is_unix()
+if Sys.isunix()
     const path_separator    = "/"
     const path_separator_re = r"/+"
-    const path_absolute_re  = r"^/"
     const path_directory_re = r"(?:^|/)\.{0,2}$"
     const path_dir_splitter = r"^(.*?)(/+)([^/]*)$"
     const path_ext_splitter = r"^((?:.*/)?(?:\.|[^/\.])[^/]*?)(\.[^/\.]*|)$"
 
     splitdrive(path::String) = ("",path)
-elseif is_windows()
+elseif Sys.iswindows()
     const path_separator    = "\\"
     const path_separator_re = r"[/\\]+"
     const path_absolute_re  = r"^(?:\w+:)?[/\\]"
@@ -54,6 +53,11 @@ splitdrive(path::AbstractString)
     homedir() -> AbstractString
 
 Return the current user's home directory.
+
+!!! note
+    `homedir` determines the home directory via `libuv`'s `uv_os_homedir`. For details
+    (for example on how to specify the home directory via environment variables), see the
+    [`uv_os_homedir` documentation](http://docs.libuv.org/en/v1.x/misc.html#c.uv_os_homedir).
 """
 function homedir()
     path_max = 1024
@@ -64,7 +68,7 @@ function homedir()
         if rc == 0
             resize!(buf, sz[])
             return String(buf)
-        elseif rc == UV_ENOBUFS
+        elseif rc == Base.UV_ENOBUFS
             resize!(buf, sz[] - 1)
         else
             error("unable to retrieve home directory")
@@ -73,6 +77,12 @@ function homedir()
 end
 
 
+if Sys.iswindows()
+    isabspath(path::String) = ismatch(path_absolute_re, path)
+else
+    isabspath(path::String) = startswith(path, '/')
+end
+
 """
     isabspath(path::AbstractString) -> Bool
 
@@ -86,7 +96,7 @@ julia> isabspath("home")
 false
 ```
 """
-isabspath(path::String) = ismatch(path_absolute_re, path)
+isabspath(path::AbstractString)
 
 """
     isdirpath(path::AbstractString) -> Bool
@@ -130,6 +140,8 @@ Get the directory part of a path.
 julia> dirname("/home/myuser")
 "/home"
 ```
+
+See also: [`basename`](@ref)
 """
  dirname(path::AbstractString) = splitdir(path)[1]
 
@@ -142,6 +154,8 @@ Get the file name part of a path.
 julia> basename("/home/myuser/example.jl")
 "example.jl"
 ```
+
+See also: [`dirname`](@ref)
 """
 basename(path::AbstractString) = splitdir(path)[2]
 
@@ -253,9 +267,16 @@ normpath(a::AbstractString, b::AbstractString...) = normpath(joinpath(a,b...))
 Convert a path to an absolute path by adding the current directory if necessary.
 """
 abspath(a::String) = normpath(isabspath(a) ? a : joinpath(pwd(),a))
+
+"""
+    abspath(path::AbstractString, paths::AbstractString...) -> AbstractString
+
+Convert a set of paths to an absolute path by joining them together and adding the
+current directory if necessary. Equivalent to `abspath(joinpath(path, paths...))`.
+"""
 abspath(a::AbstractString, b::AbstractString...) = abspath(joinpath(a,b...))
 
-if is_windows()
+if Sys.iswindows()
 function realpath(path::AbstractString)
     p = cwstring(path)
     buf = zeros(UInt16, length(p))
@@ -303,7 +324,7 @@ Canonicalize a path by expanding symbolic links and removing "." and ".." entrie
 realpath(path::AbstractString)
 
 
-if is_windows()
+if Sys.iswindows()
 expanduser(path::AbstractString) = path # on windows, ~ means "temporary file"
 else
 function expanduser(path::AbstractString)
diff --git a/base/pcre.jl b/base/pcre.jl
index f857c791bb61c5..97b7fae7000d76 100644
--- a/base/pcre.jl
+++ b/base/pcre.jl
@@ -1,27 +1,27 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## low-level pcre2 interface ##
 
 module PCRE
 
-include(string(length(Core.ARGS)>=2?Core.ARGS[2]:"","pcre_h.jl"))  # include($BUILDROOT/base/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"
 
-global JIT_STACK = C_NULL
-global MATCH_CONTEXT = C_NULL
+const JIT_STACK = Ref{Ptr{Void}}(C_NULL)
+const MATCH_CONTEXT = Ref{Ptr{Void}}(C_NULL)
 
 function __init__()
     try
         JIT_STACK_START_SIZE = 32768
         JIT_STACK_MAX_SIZE = 1048576
-        global JIT_STACK = ccall((:pcre2_jit_stack_create_8, PCRE_LIB), Ptr{Void},
+        JIT_STACK[] = ccall((:pcre2_jit_stack_create_8, PCRE_LIB), Ptr{Void},
                                  (Cint, Cint, Ptr{Void}),
                                  JIT_STACK_START_SIZE, JIT_STACK_MAX_SIZE, C_NULL)
-        global MATCH_CONTEXT = ccall((:pcre2_match_context_create_8, PCRE_LIB),
+        MATCH_CONTEXT[] = ccall((:pcre2_match_context_create_8, PCRE_LIB),
                                      Ptr{Void}, (Ptr{Void},), C_NULL)
         ccall((:pcre2_jit_stack_assign_8, PCRE_LIB), Void,
-              (Ptr{Void}, Ptr{Void}, Ptr{Void}), MATCH_CONTEXT, C_NULL, JIT_STACK)
+              (Ptr{Void}, Ptr{Void}, Ptr{Void}), MATCH_CONTEXT[], C_NULL, JIT_STACK[])
     catch ex
         Base.showerror_nostdio(ex,
             "WARNING: Error during initialization of module PCRE")
@@ -69,10 +69,10 @@ const OPTIONS_MASK = COMPILE_MASK | EXECUTE_MASK
 
 const UNSET = ~Csize_t(0)  # Indicates that an output vector element is unset
 
-function info(regex::Ptr{Void}, what::Integer, T)
-    buf = zeros(UInt8,sizeof(T))
+function info(regex::Ptr{Void}, what::Integer, ::Type{T}) where T
+    buf = Ref{T}()
     ret = ccall((:pcre2_pattern_info_8, PCRE_LIB), Int32,
-                (Ptr{Void}, Int32, Ptr{UInt8}),
+                (Ptr{Void}, Int32, Ptr{Void}),
                 regex, what, buf)
     if ret != 0
         error(ret == ERROR_NULL      ? "NULL regex object" :
@@ -80,7 +80,7 @@ function info(regex::Ptr{Void}, what::Integer, T)
               ret == ERROR_BADOPTION ? "invalid option flags" :
                                        "unknown error $ret")
     end
-    reinterpret(T,buf)[1]
+    buf[]
 end
 
 function get_ovec(match_data)
@@ -120,7 +120,7 @@ free_match_context(context) =
     ccall((:pcre2_match_context_free_8, PCRE_LIB), Void, (Ptr{Void},), context)
 
 function err_message(errno)
-    buffer = Array{UInt8}(256)
+    buffer = Vector{UInt8}(256)
     ccall((:pcre2_get_error_message_8, PCRE_LIB), Void,
           (Int32, Ptr{UInt8}, Csize_t), errno, buffer, sizeof(buffer))
     unsafe_string(pointer(buffer))
@@ -129,7 +129,7 @@ end
 function exec(re,subject,offset,options,match_data)
     rc = ccall((:pcre2_match_8, PCRE_LIB), Cint,
                (Ptr{Void}, Ptr{UInt8}, Csize_t, Csize_t, Cuint, Ptr{Void}, Ptr{Void}),
-               re, subject, sizeof(subject), offset, options, match_data, MATCH_CONTEXT)
+               re, subject, sizeof(subject), offset, options, match_data, MATCH_CONTEXT[])
     # rc == -1 means no match, -2 means partial match.
     rc < -2 && error("PCRE.exec error: $(err_message(rc))")
     rc >= 0
diff --git a/base/permuteddimsarray.jl b/base/permuteddimsarray.jl
index eb80321fbca394..5195dc76b08cfd 100644
--- a/base/permuteddimsarray.jl
+++ b/base/permuteddimsarray.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module PermutedDimsArrays
 
@@ -25,8 +25,7 @@ that no copying occurs (`B` shares storage with `A`).
 
 See also: [`permutedims`](@ref).
 
-# Example
-
+# Examples
 ```jldoctest
 julia> A = rand(3,5,4);
 
@@ -46,10 +45,10 @@ function PermutedDimsArray(data::AbstractArray{T,N}, perm) where {T,N}
 end
 
 Base.parent(A::PermutedDimsArray) = A.parent
-Base.size{T,N,perm}(A::PermutedDimsArray{T,N,perm})    = genperm(size(parent(A)),    perm)
-Base.indices{T,N,perm}(A::PermutedDimsArray{T,N,perm}) = genperm(indices(parent(A)), perm)
+Base.size(A::PermutedDimsArray{T,N,perm}) where {T,N,perm}    = genperm(size(parent(A)),    perm)
+Base.indices(A::PermutedDimsArray{T,N,perm}) where {T,N,perm} = genperm(indices(parent(A)), perm)
 
-Base.unsafe_convert{T}(::Type{Ptr{T}}, A::PermutedDimsArray{T}) = Base.unsafe_convert(Ptr{T}, parent(A))
+Base.unsafe_convert(::Type{Ptr{T}}, A::PermutedDimsArray{T}) where {T} = Base.unsafe_convert(Ptr{T}, parent(A))
 
 # It's OK to return a pointer to the first element, and indeed quite
 # useful for wrapping C routines that require a different storage
@@ -58,26 +57,23 @@ Base.unsafe_convert{T}(::Type{Ptr{T}}, A::PermutedDimsArray{T}) = Base.unsafe_co
 # or a linear index?
 Base.pointer(A::PermutedDimsArray, i::Integer) = throw(ArgumentError("pointer(A, i) is deliberately unsupported for PermutedDimsArray"))
 
-function Base.strides{T,N,perm}(A::PermutedDimsArray{T,N,perm})
+function Base.strides(A::PermutedDimsArray{T,N,perm}) where {T,N,perm}
     s = strides(parent(A))
-    ntuple(d->s[perm[d]], Val{N})
+    ntuple(d->s[perm[d]], Val(N))
 end
 
-@inline function Base.getindex{T,N,perm,iperm}(A::PermutedDimsArray{T,N,perm,iperm}, I::Vararg{Int,N})
+@inline function Base.getindex(A::PermutedDimsArray{T,N,perm,iperm}, I::Vararg{Int,N}) where {T,N,perm,iperm}
     @boundscheck checkbounds(A, I...)
     @inbounds val = getindex(A.parent, genperm(I, iperm)...)
     val
 end
-@inline function Base.setindex!{T,N,perm,iperm}(A::PermutedDimsArray{T,N,perm,iperm}, val, I::Vararg{Int,N})
+@inline function Base.setindex!(A::PermutedDimsArray{T,N,perm,iperm}, val, I::Vararg{Int,N}) where {T,N,perm,iperm}
     @boundscheck checkbounds(A, I...)
     @inbounds setindex!(A.parent, val, genperm(I, iperm)...)
     val
 end
 
-# For some reason this is faster than ntuple(d->I[perm[d]], Val{N}) (#15276?)
-@inline genperm{N}(I::NTuple{N,Any}, perm::Dims{N}) = _genperm((), I, perm...)
-_genperm(out, I) = out
-@inline _genperm(out, I, p, perm...) = _genperm((out..., I[p]), I, perm...)
+@inline genperm(I::NTuple{N,Any}, perm::Dims{N}) where {N} = ntuple(d -> I[perm[d]], Val(N))
 @inline genperm(I, perm::AbstractVector{Int}) = genperm(I, (perm...,))
 
 """
@@ -89,6 +85,7 @@ equivalent to `permutedims(A, [2,1])`.
 
 See also: [`PermutedDimsArray`](@ref).
 
+# Examples
 ```jldoctest
 julia> A = reshape(collect(1:8), (2,2,2))
 2×2×2 Array{Int64,3}:
@@ -124,6 +121,8 @@ vector specifying a permutation of length `ndims(src)`. The preallocated array `
 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.
+
+See also [`permutedims`](@ref).
 """
 function Base.permutedims!(dest, src::AbstractArray, perm)
     Base.checkdims_perm(dest, src, perm)
@@ -132,13 +131,13 @@ function Base.permutedims!(dest, src::AbstractArray, perm)
     return dest
 end
 
-function Base.copy!{T,N}(dest::PermutedDimsArray{T,N}, src::AbstractArray{T,N})
+function Base.copy!(dest::PermutedDimsArray{T,N}, src::AbstractArray{T,N}) where {T,N}
     checkbounds(dest, indices(src)...)
     _copy!(dest, src)
 end
 Base.copy!(dest::PermutedDimsArray, src::AbstractArray) = _copy!(dest, src)
 
-function _copy!{T,N,perm}(P::PermutedDimsArray{T,N,perm}, src)
+function _copy!(P::PermutedDimsArray{T,N,perm}, src) where {T,N,perm}
     # If dest/src are "close to dense," then it pays to be cache-friendly.
     # Determine the first permuted dimension
     d = 0  # d+1 will hold the first permuted dimension of src
@@ -157,7 +156,7 @@ function _copy!{T,N,perm}(P::PermutedDimsArray{T,N,perm}, src)
     return P
 end
 
-@noinline function _permutedims!(P::PermutedDimsArray, src, R1::CartesianRange{CartesianIndex{0}}, R2, R3, ds, dp)
+@noinline function _permutedims!(P::PermutedDimsArray, src, R1::CartesianRange{0}, R2, R3, ds, dp)
     ip, is = indices(src, dp), indices(src, ds)
     for jo in first(ip):8:last(ip), io in first(is):8:last(is)
         for I3 in R3, I2 in R2
diff --git a/base/pkg/cache.jl b/base/pkg/cache.jl
index c3d15899f8bb71..db9d2426c4704d 100644
--- a/base/pkg/cache.jl
+++ b/base/pkg/cache.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module Cache
 
@@ -18,7 +18,7 @@ function mkcachedir()
         return
     end
 
-    @static if is_unix()
+    @static if Sys.isunix()
         if Dir.isversioned(pwd())
             rootcache = joinpath(realpath(".."), ".cache")
             if !isdir(rootcache)
@@ -57,7 +57,7 @@ function prefetch(pkg::AbstractString, url::AbstractString, sha1s::Vector)
         end
     end
     try
-        LibGit2.set_remote_url(repo, normalized_url)
+        LibGit2.set_remote_url(repo, "origin", normalized_url)
         in_cache = BitArray(map(sha1->LibGit2.iscommit(sha1, repo), sha1s))
         if !all(in_cache)
             info("Updating cache of $pkg...")
diff --git a/base/pkg/dir.jl b/base/pkg/dir.jl
index 3b4d2da1bbd9c1..4bcd8fcef78363 100644
--- a/base/pkg/dir.jl
+++ b/base/pkg/dir.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module Dir
 
@@ -28,7 +28,13 @@ function cd(f::Function, args...; kws...)
         !haskey(ENV,"JULIA_PKGDIR") ? init() :
             throw(PkgError("Package metadata directory $metadata_dir doesn't exist; run Pkg.init() to initialize it."))
     end
-    Base.cd(()->f(args...; kws...), dir)
+    if haskey(ENV,"JULIA_PKGDIR")
+        withenv("JULIA_PKGDIR" => abspath(ENV["JULIA_PKGDIR"])) do
+            Base.cd(()->f(args...; kws...), dir)
+        end
+    else
+        Base.cd(()->f(args...; kws...), dir)
+    end
 end
 
 function init(meta::AbstractString=DEFAULT_META, branch::AbstractString=META_BRANCH)
@@ -37,7 +43,7 @@ function init(meta::AbstractString=DEFAULT_META, branch::AbstractString=META_BRA
     metadata_dir = joinpath(dir, "METADATA")
     if isdir(metadata_dir)
         info("Package directory $dir is already initialized.")
-        LibGit2.set_remote_url(metadata_dir, meta)
+        LibGit2.set_remote_url(metadata_dir, "origin", meta)
         return
     end
     local temp_dir = ""
@@ -47,7 +53,7 @@ function init(meta::AbstractString=DEFAULT_META, branch::AbstractString=META_BRA
         Base.cd(temp_dir) do
             info("Cloning METADATA from $meta")
             with(LibGit2.clone(meta, "METADATA", branch = branch)) do metadata_repo
-                LibGit2.set_remote_url(metadata_repo, meta)
+                LibGit2.set_remote_url(metadata_repo, "origin", meta)
             end
             touch("REQUIRE")
             touch("META_BRANCH")
diff --git a/base/pkg/entry.jl b/base/pkg/entry.jl
index 0d53268f96d5a0..41f638102cfdb4 100644
--- a/base/pkg/entry.jl
+++ b/base/pkg/entry.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module Entry
 
@@ -125,7 +125,7 @@ function installed(pkg::AbstractString)
 end
 
 function status(io::IO; pkgname::AbstractString = "")
-    showpkg(pkg) = (pkgname == "") ? (true) : (pkg == pkgname)
+    showpkg(pkg) = isempty(pkgname) ? true : (pkg == pkgname)
     reqs = Reqs.parse("REQUIRE")
     instd = Read.installed()
     required = sort!(collect(keys(reqs)))
@@ -193,7 +193,7 @@ function clone(url::AbstractString, pkg::AbstractString)
     ispath(pkg) && throw(PkgError("$pkg already exists"))
     try
         LibGit2.with(LibGit2.clone(url, pkg)) do repo
-            LibGit2.set_remote_url(repo, url)
+            LibGit2.set_remote_url(repo, "origin", url)
         end
     catch err
         isdir(pkg) && Base.rm(pkg, recursive=true)
@@ -206,21 +206,20 @@ function clone(url::AbstractString, pkg::AbstractString)
     end
 end
 
-function clone(url_or_pkg::AbstractString)
-    urlpath = joinpath("METADATA",url_or_pkg,"url")
-    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 || throw(PkgError("can't determine package name from URL: $url"))
-        pkg = m.captures[1]
+function url_and_pkg(url_or_pkg::AbstractString)
+    if !(':' in url_or_pkg)
+        # no colon, could be a package name
+        url_file = joinpath("METADATA", url_or_pkg, "url")
+        isfile(url_file) && return readchomp(url_file), url_or_pkg
     end
-    clone(url,pkg)
+    # try to parse as URL or local path
+    m = match(r"(?:^|[/\\])(\w+?)(?:\.jl)?(?:\.git)?$", url_or_pkg)
+    m === nothing && throw(PkgError("can't determine package name from URL: $url_or_pkg"))
+    return url_or_pkg, m.captures[1]
 end
 
+clone(url_or_pkg::AbstractString) = clone(url_and_pkg(url_or_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...")
@@ -542,7 +541,7 @@ function resolve(
                 info("$(up)grading $pkg: v$ver1 => v$ver2")
                 Write.update(pkg, Read.sha1(pkg,ver2))
                 pkgsym = Symbol(pkg)
-                if isdefined(Main, pkgsym) && isa(getfield(Main, pkgsym), Module)
+                if Base.isbindingresolved(Main, pkgsym) && isa(getfield(Main, pkgsym), Module)
                     push!(imported, "- $pkg")
                 end
             end
@@ -580,26 +579,9 @@ function warnbanner(msg...; label="[ WARNING ]", prefix="")
     warn(prefix="", "="^cols)
 end
 
-function build!(pkgs::Vector, buildstream::IO, seen::Set)
-    for pkg in pkgs
-        pkg == "julia" && continue
-        pkg in seen ? continue : push!(seen,pkg)
-        Read.isinstalled(pkg) || throw(PkgError("$pkg is not an installed package"))
-        build!(Read.requires_list(pkg),buildstream,seen)
-        path = abspath(pkg,"deps","build.jl")
-        isfile(path) || continue
-        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
+function build(pkg::AbstractString, build_file::AbstractString, errfile::AbstractString)
+    # To isolate the build from the running Julia process, we execute each build.jl file in
+    # a separate process. Errors are serialized to errfile for later reporting.
     # TODO: serialize the same way the load cache does, not with strings
     LOAD_PATH = filter(x -> x isa AbstractString, Base.LOAD_PATH)
     code = """
@@ -610,31 +592,48 @@ function build!(pkgs::Vector, errs::Dict, seen::Set=Set())
         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)
-                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)
+            pkg, build_file = "$pkg", "$(escape_string(build_file))"
+            try
+                info("Building \$pkg")
+                cd(dirname(build_file)) do
+                    evalfile(build_file)
                 end
+            catch err
+                Base.Pkg.Entry.warnbanner(err, label="[ ERROR: \$pkg ]")
+                serialize(f, pkg)
+                serialize(f, err)
             end
         end
-    """
-    io, pobj = open(pipeline(detach(`$(Base.julia_cmd()) -O0
-                                    --compilecache=$(Bool(Base.JLOptions().use_compilecache) ? "yes" : "no")
-                                    --history-file=no
-                                    --color=$(Base.have_color ? "yes" : "no")
-                                    --eval $code`), stderr=STDERR), "w", STDOUT)
+        """
+    cmd = ```
+        $(Base.julia_cmd()) -O0
+        --color=$(Base.have_color ? "yes" : "no")
+        --compilecache=$(Bool(Base.JLOptions().use_compilecache) ? "yes" : "no")
+        --history-file=no
+        --startup-file=$(Base.JLOptions().startupfile != 2 ? "yes" : "no")
+        --eval $code
+        ```
+
+    success(pipeline(cmd, stderr=STDERR))
+end
+
+function build!(pkgs::Vector, seen::Set, errfile::AbstractString)
+    for pkg in pkgs
+        pkg == "julia" && continue
+        pkg in seen ? continue : push!(seen,pkg)
+        Read.isinstalled(pkg) || throw(PkgError("$pkg is not an installed package"))
+        build!(Read.requires_list(pkg), seen, errfile)
+        path = abspath(pkg,"deps","build.jl")
+        isfile(path) || continue
+        build(pkg, path, errfile) || error("Build process failed.")
+    end
+end
+
+function build!(pkgs::Vector, errs::Dict, seen::Set=Set())
+    errfile = tempname()
+    touch(errfile)  # create empty file
     try
-        build!(pkgs, io, seen)
-        close(io)
-        wait(pobj)
-        success(pobj) || error("Build process failed.")
+        build!(pkgs, seen, errfile)
         open(errfile, "r") do f
             while !eof(f)
                 pkg = deserialize(f)
@@ -642,10 +641,6 @@ function build!(pkgs::Vector, errs::Dict, seen::Set=Set())
                 errs[pkg] = err
             end
         end
-    catch err
-        close(io)
-        isa(err, PkgError) ? wait(pobj) : kill(pobj)
-        rethrow(err)
     finally
         isfile(errfile) && Base.rm(errfile)
     end
@@ -717,11 +712,16 @@ function test!(pkg::AbstractString,
         info("Testing $pkg")
         cd(dirname(test_path)) do
             try
-                color = Base.have_color? "--color=yes" : "--color=no"
-                codecov = coverage? ["--code-coverage=user"] : ["--code-coverage=none"]
-                compilecache = "--compilecache=" * (Bool(Base.JLOptions().use_compilecache) ? "yes" : "no")
-                julia_exe = Base.julia_cmd()
-                run(`$julia_exe --check-bounds=yes $codecov $color $compilecache $test_path`)
+                cmd = ```
+                    $(Base.julia_cmd())
+                    --code-coverage=$(coverage ? "user" : "none")
+                    --color=$(Base.have_color ? "yes" : "no")
+                    --compilecache=$(Bool(Base.JLOptions().use_compilecache) ? "yes" : "no")
+                    --check-bounds=yes
+                    --startup-file=$(Base.JLOptions().startupfile != 2 ? "yes" : "no")
+                    $test_path
+                    ```
+                run(cmd)
                 info("$pkg tests passed")
             catch err
                 warnbanner(err, label="[ ERROR: $pkg ]")
diff --git a/base/pkg/pkg.jl b/base/pkg/pkg.jl
index c5d9836a0b9495..7d60ec9e6ce9d7 100644
--- a/base/pkg/pkg.jl
+++ b/base/pkg/pkg.jl
@@ -1,5 +1,16 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
+"""
+    Pkg
+
+The `Pkg` module provides package management for Julia.
+Use
+`Pkg.status()` for a list of installed packages,
+`Pkg.add("<pkg name>")` to add a package,
+`Pkg.update()` to update the installed packages.
+
+Please see the manual section on packages for more information.
+"""
 module Pkg
 
 export Dir, Types, Reqs, Cache, Read, Query, Resolve, Write, Entry
@@ -37,6 +48,10 @@ const cd = Dir.cd
 
 dir(path...) = Dir.path(path...)
 
+# remove extension .jl
+const PKGEXT = ".jl"
+splitjl(pkg::AbstractString) = endswith(pkg, PKGEXT) ? pkg[1:(end-length(PKGEXT))] : pkg
+
 """
     dir() -> AbstractString
 
@@ -90,7 +105,7 @@ edit() = cd(Entry.edit)
 
 Remove all requirement entries for `pkg` from `Pkg.dir("REQUIRE")` and call `Pkg.resolve()`.
 """
-rm(pkg::AbstractString) = cd(Entry.rm,pkg)
+rm(pkg::AbstractString) = cd(Entry.rm,splitjl(pkg))
 
 """
     add(pkg, vers...)
@@ -99,7 +114,7 @@ Add a requirement entry for `pkg` to `Pkg.dir("REQUIRE")` and call `Pkg.resolve(
 `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...)
+add(pkg::AbstractString, vers::VersionNumber...) = cd(Entry.add,splitjl(pkg),vers...)
 
 """
     available() -> Vector{String}
@@ -113,7 +128,7 @@ available() = cd(Entry.available)
 
 Returns the version numbers available for package `pkg`.
 """
-available(pkg::AbstractString) = cd(Entry.available,pkg)
+available(pkg::AbstractString) = cd(Entry.available,splitjl(pkg))
 
 """
     installed() -> Dict{String,VersionNumber}
@@ -129,7 +144,7 @@ installed() = cd(Entry.installed)
 If `pkg` is installed, return the installed version number. If `pkg` is registered,
 but not installed, return `nothing`.
 """
-installed(pkg::AbstractString) = cd(Entry.installed,pkg)
+installed(pkg::AbstractString) = cd(Entry.installed,splitjl(pkg))
 
 """
     status()
@@ -143,7 +158,7 @@ status(io::IO=STDOUT) = cd(Entry.status,io)
 
 Prints out a summary of what version and state `pkg`, specifically, is in.
 """
-status(pkg::AbstractString, io::IO=STDOUT) = cd(Entry.status,io,pkg)
+status(pkg::AbstractString, io::IO=STDOUT) = cd(Entry.status,io,splitjl(pkg))
 
 """
     clone(pkg)
@@ -160,7 +175,7 @@ Clone a package directly from the git URL `url`. The package does not need to be
 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)
+clone(url::AbstractString, pkg::AbstractString) = cd(Entry.clone,url,splitjl(pkg))
 
 """
     checkout(pkg, [branch="master"]; merge=true, pull=true)
@@ -171,7 +186,7 @@ Checkout the `Pkg.dir(pkg)` repo to the branch `branch`. Defaults to checking ou
 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)
+    cd(Entry.checkout,splitjl(pkg),branch,merge,pull)
 
 """
     free(pkg)
@@ -183,7 +198,7 @@ to determine optimal package versions after. This is an inverse for both `Pkg.ch
 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)
+free(pkg) = cd(Entry.free,splitjl.(pkg))
 
 """
     pin(pkg)
@@ -191,14 +206,14 @@ free(pkg) = cd(Entry.free,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::AbstractString) = cd(Entry.pin,splitjl(pkg))
 
 """
     pin(pkg, version)
 
 Pin `pkg` at registered version `version`.
 """
-pin(pkg::AbstractString, ver::VersionNumber) = cd(Entry.pin,pkg,ver)
+pin(pkg::AbstractString, ver::VersionNumber) = cd(Entry.pin,splitjl(pkg),ver)
 
 """
     update(pkgs...)
@@ -236,7 +251,7 @@ Run the build script in `deps/build.jl` for each package in `pkgs` and all of th
 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...])
+build(pkgs::AbstractString...) = cd(Entry.build,[splitjl.(pkgs)...])
 
 """
     test(; coverage=false)
@@ -258,14 +273,14 @@ installed for the duration of the test. A package is tested by running its
 Coverage statistics for the packages may be generated by passing `coverage=true`.
 The default behavior is not to run coverage.
 """
-test(pkgs::AbstractString...; coverage::Bool=false) = cd(Entry.test,AbstractString[pkgs...]; coverage=coverage)
+test(pkgs::AbstractString...; coverage::Bool=false) = cd(Entry.test,AbstractString[splitjl.(pkgs)...]; coverage=coverage)
 
 """
-    dependents(packagename)
+    dependents(pkg)
 
-List the packages that have `packagename` as a dependency.
+List the packages that have `pkg` as a dependency.
 """
-dependents(packagename::AbstractString) = Reqs.dependents(packagename)
+dependents(pkg::AbstractString) = Reqs.dependents(splitjl(pkg))
 
 """
     setprotocol!(proto)
diff --git a/base/pkg/query.jl b/base/pkg/query.jl
index 60af3e120715ff..dbe1919f0664d8 100644
--- a/base/pkg/query.jl
+++ b/base/pkg/query.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module Query
 
@@ -180,8 +180,8 @@ end
 const PackageState = Union{Void,VersionNumber}
 
 function diff(have::Dict, want::Dict, avail::Dict, fixed::Dict)
-    change = Array{Tuple{String,Tuple{PackageState,PackageState}}}(0)
-    remove = Array{Tuple{String,Tuple{PackageState,PackageState}}}(0)
+    change = Vector{Tuple{String,Tuple{PackageState,PackageState}}}(0)
+    remove = Vector{Tuple{String,Tuple{PackageState,PackageState}}}(0)
 
     for pkg in collect(union(keys(have),keys(want)))
         h, w = haskey(have,pkg), haskey(want,pkg)
diff --git a/base/pkg/read.jl b/base/pkg/read.jl
index a9e9144c8a313f..cd1f4461d1259f 100644
--- a/base/pkg/read.jl
+++ b/base/pkg/read.jl
@@ -1,11 +1,11 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module Read
 
 import ...LibGit2, ..Cache, ..Reqs, ...Pkg.PkgError, ..Dir
 using ..Types
 
-readstrip(path...) = strip(readstring(joinpath(path...)))
+readstrip(path...) = strip(read(joinpath(path...), String))
 
 url(pkg::AbstractString) = readstrip(Dir.path("METADATA"), pkg, "url")
 sha1(pkg::AbstractString, ver::VersionNumber) =
diff --git a/base/pkg/reqs.jl b/base/pkg/reqs.jl
index 61a108cf44881e..e424bca9fcd30e 100644
--- a/base/pkg/reqs.jl
+++ b/base/pkg/reqs.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module Reqs
 
@@ -90,16 +90,16 @@ function parse(lines::Vector{Line})
         if isa(line,Requirement)
             if !isempty(line.system)
                 applies = false
-                if is_windows(); applies |=  ("windows"  in line.system); end
-                if is_unix();    applies |=  ("unix"     in line.system); end
-                if is_apple();   applies |=  ("osx"      in line.system); end
-                if is_linux();   applies |=  ("linux"    in line.system); end
-                if is_bsd();     applies |=  ("bsd"      in line.system); end
-                if is_windows(); applies &= !("!windows" in line.system); end
-                if is_unix();    applies &= !("!unix"    in line.system); end
-                if is_apple();   applies &= !("!osx"     in line.system); end
-                if is_linux();   applies &= !("!linux"   in line.system); end
-                if is_bsd();     applies &= !("!bsd"     in line.system); end
+                if Sys.iswindows(); applies |=  ("windows"  in line.system); end
+                if Sys.isunix();    applies |=  ("unix"     in line.system); end
+                if Sys.isapple();   applies |=  ("osx"      in line.system); end
+                if Sys.islinux();   applies |=  ("linux"    in line.system); end
+                if Sys.isbsd();     applies |=  ("bsd"      in line.system); end
+                if Sys.iswindows(); applies &= !("!windows" in line.system); end
+                if Sys.isunix();    applies &= !("!unix"    in line.system); end
+                if Sys.isapple();   applies &= !("!osx"     in line.system); end
+                if Sys.islinux();   applies &= !("!linux"   in line.system); end
+                if Sys.isbsd();     applies &= !("!bsd"     in line.system); end
                 applies || continue
             end
             reqs[line.package] = haskey(reqs, line.package) ?
diff --git a/base/pkg/resolve.jl b/base/pkg/resolve.jl
index 6f59b96a7fe506..a8481a9aee5c0c 100644
--- a/base/pkg/resolve.jl
+++ b/base/pkg/resolve.jl
@@ -1,10 +1,10 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module Resolve
 
-include("resolve/versionweight.jl")
-include("resolve/interface.jl")
-include("resolve/maxsum.jl")
+include(joinpath("resolve", "versionweight.jl"))
+include(joinpath("resolve", "interface.jl"))
+include(joinpath("resolve", "maxsum.jl"))
 
 using ..Types, ..Query, .PkgToMaxSumInterface, .MaxSum
 import ...Pkg.PkgError
@@ -26,7 +26,7 @@ function resolve(reqs::Requires, deps::Dict{String,Dict{VersionNumber,Available}
         try
             sol = maxsum(graph, msgs)
         catch err
-            isa(err, UnsatError) || retrhow(err)
+            isa(err, UnsatError) || rethrow(err)
             p = interface.pkgs[err.info]
             # TODO: build tools to analyze the problem, and suggest to use them here.
             msg =
@@ -35,7 +35,7 @@ function resolve(reqs::Requires, deps::Dict{String,Dict{VersionNumber,Available}
                   The problem was detected when trying to find a feasible version
                   for package $p.
                   However, this only means that package $p is involved in an
-                  unsatifiable or difficult dependency relation, and the root of
+                  unsatisfiable or difficult dependency relation, and the root of
                   the problem may be elsewhere.
                 """
             if msgs.num_nondecimated != graph.np
@@ -74,7 +74,7 @@ function sanity_check(deps::Dict{String,Dict{VersionNumber,Available}},
         end
     end
 
-    vers = Array{Tuple{String,VersionNumber,VersionNumber}}(0)
+    vers = Vector{Tuple{String,VersionNumber,VersionNumber}}(0)
     for (p,d) in deps, vn in keys(d)
         lvns = VersionNumber[Iterators.filter(vn2->(vn2>vn), keys(d))...]
         nvn = isempty(lvns) ? typemax(VersionNumber) : minimum(lvns)
@@ -88,7 +88,7 @@ function sanity_check(deps::Dict{String,Dict{VersionNumber,Available}},
 
     checked = falses(nv)
 
-    problematic = Array{Tuple{String,VersionNumber,String}}(0)
+    problematic = Vector{Tuple{String,VersionNumber,String}}(0)
     i = 1
     psl = 0
     for (p,vn,nvn) in vers
diff --git a/base/pkg/resolve/fieldvalue.jl b/base/pkg/resolve/fieldvalue.jl
index ca64085644101a..01549cd8ca4b91 100644
--- a/base/pkg/resolve/fieldvalue.jl
+++ b/base/pkg/resolve/fieldvalue.jl
@@ -1,9 +1,8 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module FieldValues
 
 using ...VersionWeights
-importall .....Base.Operators
 
 export FieldValue, Field, validmax, secondmax
 
@@ -65,6 +64,15 @@ Base.:(==)(a::FieldValue, b::FieldValue) =
 
 Base.abs(a::FieldValue) = FieldValue(abs(a.l0), abs(a.l1), abs(a.l2), abs(a.l3), abs(a.l4), abs(a.l5))
 
+Base.copy(a::FieldValue) = FieldValue(a.l0, copy(a.l1), copy(a.l2), a.l3, a.l4, a.l5)
+
+function Base.unsafe_copy!(dest::Field, doffs, src::Field, soffs, n)
+    for i = 1:n
+        dest[doffs+i-1] = copy(src[soffs+i-1])
+    end
+    return dest
+end
+
 # if the maximum field has l0 < 0, it means that
 # some hard constraint is being violated
 validmax(a::FieldValue) = a.l0 >= 0
diff --git a/base/pkg/resolve/interface.jl b/base/pkg/resolve/interface.jl
index 67eda62e39ddc1..9ed3c6d531db50 100644
--- a/base/pkg/resolve/interface.jl
+++ b/base/pkg/resolve/interface.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module PkgToMaxSumInterface
 
@@ -52,7 +52,7 @@ mutable struct Interface
         pdict = Dict{String,Int}(pkgs[i] => i for i = 1:np)
 
         # generate spp and pvers
-        spp = Array{Int}(np)
+        spp = Vector{Int}(np)
 
         pvers = [VersionNumber[] for i = 1:np]
 
@@ -82,11 +82,11 @@ mutable struct Interface
         end
 
         ## generate wveights:
-        vweight = Array{Vector{VersionWeight}}(np)
+        vweight = Vector{Vector{VersionWeight}}(np)
         for p0 = 1:np
             pvers0 = pvers[p0]
             spp0 = spp[p0]
-            vweight0 = vweight[p0] = Array{VersionWeight}(spp0)
+            vweight0 = vweight[p0] = Vector{VersionWeight}(spp0)
             for v0 = 1:spp0-1
                 vweight0[v0] = VersionWeight(pvers0[v0])
             end
@@ -240,7 +240,7 @@ function enforce_optimality!(sol::Vector{Int}, interface::Interface)
 
     # prepare some useful structures
     # pdeps[p0][v0] has all dependencies of package p0 version v0
-    pdeps = [Array{Requires}(spp[p0]-1) for p0 = 1:np]
+    pdeps = [Vector{Requires}(spp[p0]-1) for p0 = 1:np]
     # prevdeps[p1][p0][v0] is the VersionSet of package p1 which package p0 version v0
     # depends upon
     prevdeps = [Dict{Int,Dict{Int,VersionSet}}() for p0 = 1:np]
diff --git a/base/pkg/resolve/maxsum.jl b/base/pkg/resolve/maxsum.jl
index 55c02a2925a9c6..3bb9f71a24b112 100644
--- a/base/pkg/resolve/maxsum.jl
+++ b/base/pkg/resolve/maxsum.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module MaxSum
 
@@ -170,6 +170,9 @@ mutable struct Messages
     #                 fields are not normalized
     fld::Vector{Field}
 
+    # backup of the initial value of fld, to be used when resetting
+    initial_fld::Vector{Field}
+
     # keep track of which variables have been decimated
     decimated::BitVector
     num_nondecimated::Int
@@ -221,11 +224,13 @@ mutable struct Messages
             end
         end
 
+        initial_fld = deepcopy(fld)
+
         # initialize cavity messages to 0
         gadj = graph.gadj
         msg = [[zeros(FieldValue, spp[p0]) for p1 = 1:length(gadj[p0])] for p0 = 1:np]
 
-        return new(msg, fld, falses(np), np)
+        return new(msg, fld, initial_fld, falses(np), np)
     end
 end
 
@@ -235,7 +240,7 @@ function getsolution(msgs::Messages)
 
     fld = msgs.fld
     np = length(fld)
-    sol = Array{Int}(np)
+    sol = Vector{Int}(np)
     for p0 = 1:np
         fld0 = fld[p0]
         s0 = indmax(fld0)
@@ -380,14 +385,27 @@ function decimate1(p0::Int, graph::Graph, msgs::Messages)
     #println("DECIMATING $p0 ($(packages()[p0]) s0=$s0)")
     for v0 = 1:length(fld0)
         if v0 != s0
-            fld0[v0] -= FieldValue(1)
+            fld0[v0] = FieldValue(-1)
         end
     end
-    update(p0, graph, msgs)
     msgs.decimated[p0] = true
     msgs.num_nondecimated -= 1
 end
 
+function reset_messages!(msgs::Messages)
+    msg = msgs.msg
+    fld = msgs.fld
+    initial_fld = msgs.initial_fld
+    decimated = msgs.decimated
+    np = length(fld)
+    for p0 = 1:np
+        map(m->fill!(m, zero(FieldValue)), msg[p0])
+        decimated[p0] && continue
+        fld[p0] = copy(initial_fld[p0])
+    end
+    return msgs
+end
+
 # If normal convergence fails (or is too slow) fix the most
 # polarized packages by adding extra infinite fields on every state
 # but the maximum
@@ -403,6 +421,7 @@ function decimate(n::Int, graph::Graph, msgs::Messages)
         n == 0 && break
     end
     @assert n == 0
+    reset_messages!(msgs)
     return
 end
 
@@ -449,7 +468,7 @@ function maxsum(graph::Graph, msgs::Messages)
         end
         if it >= params.nondec_iterations &&
            (it - params.nondec_iterations) % params.dec_interval == 0
-            numdec = clamp(floor(Int, params.dec_fraction * graph.np),  1, msgs.num_nondecimated)
+            numdec = clamp(floor(Int, params.dec_fraction * graph.np), 1, msgs.num_nondecimated)
             decimate(numdec, graph, msgs)
             msgs.num_nondecimated == 0 && break
         end
diff --git a/base/pkg/resolve/versionweight.jl b/base/pkg/resolve/versionweight.jl
index 4b93f257f94cdf..440483181c4c9b 100644
--- a/base/pkg/resolve/versionweight.jl
+++ b/base/pkg/resolve/versionweight.jl
@@ -1,9 +1,7 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module VersionWeights
 
-importall ....Base.Operators
-
 export VersionWeight
 
 struct HierarchicalValue{T}
@@ -11,15 +9,15 @@ struct HierarchicalValue{T}
     rest::T
 end
 
-HierarchicalValue{T}(v::Vector{T}) = HierarchicalValue{T}(v, zero(T))
+HierarchicalValue(v::Vector{T}) where {T} = HierarchicalValue{T}(v, zero(T))
 HierarchicalValue(T::Type) = HierarchicalValue(T[])
 
-Base.zero{T}(::Type{HierarchicalValue{T}}) = HierarchicalValue(T)
+Base.zero(::Type{HierarchicalValue{T}}) where {T} = HierarchicalValue(T)
 
-Base.typemin{T}(::Type{HierarchicalValue{T}}) = HierarchicalValue(T[], typemin(T))
+Base.typemin(::Type{HierarchicalValue{T}}) where {T} = HierarchicalValue(T[], typemin(T))
 
 for f in (:-, :+)
-    @eval function Base.$f{T}(a::HierarchicalValue{T}, b::HierarchicalValue{T})
+    @eval function Base.$f(a::HierarchicalValue{T}, b::HierarchicalValue{T}) where T
         av = a.v
         bv = b.v
         la = length(a.v)
@@ -27,7 +25,7 @@ for f in (:-, :+)
         l0 = min(la, lb)
         l1 = max(la, lb)
         ld = la - lb
-        rv = Array{T}(l1)
+        rv = Vector{T}(l1)
         rf = ($f)(a.rest, b.rest)
         @inbounds for i = 1:l0
             rv[i] = ($f)(av[i], bv[i])
@@ -44,7 +42,7 @@ end
 
 Base.:-(a::HierarchicalValue) = HierarchicalValue(-a.v, -a.rest)
 
-function Base.cmp{T}(a::HierarchicalValue{T}, b::HierarchicalValue{T})
+function Base.cmp(a::HierarchicalValue{T}, b::HierarchicalValue{T}) where T
     av = a.v
     bv = b.v
     la = length(a.v)
@@ -63,10 +61,12 @@ function Base.cmp{T}(a::HierarchicalValue{T}, b::HierarchicalValue{T})
     end
     return cmp(a.rest, b.rest)
 end
-Base.isless{T}(a::HierarchicalValue{T}, b::HierarchicalValue{T}) = cmp(a,b) < 0
-Base.:(==){T}(a::HierarchicalValue{T}, b::HierarchicalValue{T}) = cmp(a,b) == 0
+Base.isless(a::HierarchicalValue{T}, b::HierarchicalValue{T}) where {T} = cmp(a,b) < 0
+Base.:(==)(a::HierarchicalValue{T}, b::HierarchicalValue{T}) where {T} = cmp(a,b) == 0
+
+Base.abs(a::HierarchicalValue{T}) where {T} = HierarchicalValue(T[abs(x) for x in a.v], abs(a.rest))
 
-Base.abs{T}(a::HierarchicalValue{T}) = HierarchicalValue(T[abs(x) for x in a.v], abs(a.rest))
+Base.copy(a::HierarchicalValue{T}) where {T} = HierarchicalValue(T[copy(x) for x in a.v], copy(a.rest))
 
 struct VWPreBuildItem
     nonempty::Int
@@ -96,6 +96,8 @@ Base.:(==)(a::VWPreBuildItem, b::VWPreBuildItem) = cmp(a,b) == 0
 
 Base.abs(a::VWPreBuildItem) = VWPreBuildItem(abs(a.nonempty), abs(a.s), abs(a.i))
 
+Base.copy(a::VWPreBuildItem) = VWPreBuildItem(a.nonempty, copy(a.s), a.i)
+
 struct VWPreBuild
     nonempty::Int
     w::HierarchicalValue{VWPreBuildItem}
@@ -107,7 +109,7 @@ function VWPreBuild(ispre::Bool, desc::Tuple{Vararg{Union{Int,String}}})
     isempty(desc) && return _vwprebuild_zero
     desc == ("",) && return VWPreBuild(ispre ? -1 : 1, HierarchicalValue(VWPreBuildItem[]))
     nonempty = ispre ? -1 : 0
-    w = Array{VWPreBuildItem}(length(desc))
+    w = Vector{VWPreBuildItem}(length(desc))
     i = 1
     @inbounds for item in desc
         w[i] = VWPreBuildItem(item)
@@ -122,18 +124,18 @@ Base.zero(::Type{VWPreBuild}) = VWPreBuild()
 const _vwprebuild_min = VWPreBuild(typemin(Int), typemin(HierarchicalValue{VWPreBuildItem}))
 Base.typemin(::Type{VWPreBuild}) = _vwprebuild_min
 
-function Base.:-(a::VWPreBuild, b::VWPreBuild)
+function Base.:(-)(a::VWPreBuild, b::VWPreBuild)
     b === _vwprebuild_zero && return a
     a === _vwprebuild_zero && return -b
     VWPreBuild(a.nonempty-b.nonempty, a.w-b.w)
 end
-function Base.:+(a::VWPreBuild, b::VWPreBuild)
+function Base.:(+)(a::VWPreBuild, b::VWPreBuild)
     b === _vwprebuild_zero && return a
     a === _vwprebuild_zero && return b
     VWPreBuild(a.nonempty+b.nonempty, a.w+b.w)
 end
 
-function Base.:-(a::VWPreBuild)
+function Base.:(-)(a::VWPreBuild)
     a === _vwprebuild_zero && return a
     VWPreBuild(-a.nonempty, -a.w)
 end
@@ -151,6 +153,18 @@ function Base.abs(a::VWPreBuild)
     VWPreBuild(abs(a.nonempty), abs(a.w))
 end
 
+function Base.copy(a::VWPreBuild)
+    a === _vwprebuild_zero && return a
+    VWPreBuild(a.nonempty, copy(a.w))
+end
+
+function Base.deepcopy_internal(a::VWPreBuild, dict::ObjectIdDict)
+    haskey(dict, a) && return dict[a]
+    b = (a === _vwprebuild_zero) ? _vwprebuild_zero : VWPreBuild(a.nonempty, Base.deepcopy_internal(a.w, dict))
+    dict[a] = b
+    return b
+end
+
 # The numeric type used to determine how the different
 # versions of a package should be weighed
 struct VersionWeight
@@ -174,15 +188,15 @@ Base.zero(::Type{VersionWeight}) = VersionWeight()
 
 Base.typemin(::Type{VersionWeight}) = (x=typemin(Int); y=typemin(VWPreBuild); VersionWeight(x, x, x, y, y))
 
-Base.:-(a::VersionWeight, b::VersionWeight) =
+Base.:(-)(a::VersionWeight, b::VersionWeight) =
     VersionWeight(a.major-b.major, a.minor-b.minor, a.patch-b.patch,
                   a.prerelease-b.prerelease, a.build-b.build)
 
-Base.:+(a::VersionWeight, b::VersionWeight) =
+Base.:(+)(a::VersionWeight, b::VersionWeight) =
     VersionWeight(a.major+b.major, a.minor+b.minor, a.patch+b.patch,
                   a.prerelease+b.prerelease, a.build+b.build)
 
-Base.:-(a::VersionWeight) =
+Base.:(-)(a::VersionWeight) =
     VersionWeight(-a.major, -a.minor, -a.patch,
                   -a.prerelease, -a.build)
 
@@ -200,4 +214,8 @@ Base.abs(a::VersionWeight) =
     VersionWeight(abs(a.major), abs(a.minor), abs(a.patch),
                   abs(a.prerelease), abs(a.build))
 
+Base.copy(a::VersionWeight) =
+    VersionWeight(a.major, a.minor, a.patch,
+                  copy(a.prerelease), copy(a.build))
+
 end
diff --git a/base/pkg/types.jl b/base/pkg/types.jl
index 7434d84817eb70..c04fd1a92a1193 100644
--- a/base/pkg/types.jl
+++ b/base/pkg/types.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module Types
 
@@ -82,8 +82,8 @@ VersionSet(versions::VersionNumber...) = VersionSet(VersionNumber[versions...])
 const empty_versionset = VersionSet(VersionInterval[])
 
 # Windows console doesn't like Unicode
-const _empty_symbol = @static is_windows() ? "empty" : "∅"
-const _union_symbol = @static is_windows() ? " or " : " ∪ "
+const _empty_symbol = @static Sys.iswindows() ? "empty" : "∅"
+const _union_symbol = @static Sys.iswindows() ? " or " : " ∪ "
 show(io::IO, s::VersionSet) = isempty(s) ? print(io, _empty_symbol) :
                                            join(io, s.intervals, _union_symbol)
 isempty(s::VersionSet) = all(isempty, s.intervals)
diff --git a/base/pkg/write.jl b/base/pkg/write.jl
index c762b5598b3a51..ffc2c6f84fb508 100644
--- a/base/pkg/write.jl
+++ b/base/pkg/write.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module Write
 
@@ -27,7 +27,7 @@ function fetch(repo::GitRepo, pkg::AbstractString, sha1::AbstractString)
 end
 
 function checkout(repo::GitRepo, pkg::AbstractString, sha1::AbstractString)
-    LibGit2.set_remote_url(repo, Cache.normalize_url(Read.url(pkg)))
+    LibGit2.set_remote_url(repo, "origin", Cache.normalize_url(Read.url(pkg)))
     LibGit2.checkout!(repo, sha1)
 end
 
diff --git a/base/pointer.jl b/base/pointer.jl
index 7bb7d20128c477..fee9420a399502 100644
--- a/base/pointer.jl
+++ b/base/pointer.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 """
     Ptr{T}
@@ -20,16 +20,16 @@ const C_NULL = bitcast(Ptr{Void}, 0)
 # TODO: deprecate these conversions. C doesn't even allow them.
 
 # pointer to integer
-convert{T<:Union{Int,UInt}}(::Type{T}, x::Ptr) = bitcast(T, x)
-convert{T<:Integer}(::Type{T}, x::Ptr) = convert(T, convert(UInt, x))
+convert(::Type{T}, x::Ptr) where {T<:Union{Int,UInt}} = bitcast(T, x)
+convert(::Type{T}, x::Ptr) where {T<:Integer} = convert(T, convert(UInt, x))
 
 # integer to pointer
-convert{T}(::Type{Ptr{T}}, x::UInt) = bitcast(Ptr{T}, x)
-convert{T}(::Type{Ptr{T}}, x::Int) = bitcast(Ptr{T}, x)
+convert(::Type{Ptr{T}}, x::UInt) where {T} = bitcast(Ptr{T}, x)
+convert(::Type{Ptr{T}}, x::Int) where {T} = bitcast(Ptr{T}, x)
 
 # pointer to pointer
-convert{T}(::Type{Ptr{T}}, p::Ptr{T}) = p
-convert{T}(::Type{Ptr{T}}, p::Ptr) = bitcast(Ptr{T}, p)
+convert(::Type{Ptr{T}}, p::Ptr{T}) where {T} = p
+convert(::Type{Ptr{T}}, p::Ptr) where {T} = bitcast(Ptr{T}, p)
 
 # object to pointer (when used with ccall)
 unsafe_convert(::Type{Ptr{UInt8}}, x::Symbol) = ccall(:jl_symbol_name, Ptr{UInt8}, (Any,), x)
@@ -40,9 +40,9 @@ unsafe_convert(::Type{Ptr{Int8}}, s::String) = convert(Ptr{Int8}, pointer_from_o
 cconvert(::Type{Ptr{UInt8}}, s::AbstractString) = String(s)
 cconvert(::Type{Ptr{Int8}}, s::AbstractString) = String(s)
 
-unsafe_convert{T}(::Type{Ptr{T}}, a::Array{T}) = ccall(:jl_array_ptr, Ptr{T}, (Any,), a)
-unsafe_convert{S,T}(::Type{Ptr{S}}, a::AbstractArray{T}) = convert(Ptr{S}, unsafe_convert(Ptr{T}, a))
-unsafe_convert{T}(::Type{Ptr{T}}, a::AbstractArray{T}) = error("conversion to pointer not defined for $(typeof(a))")
+unsafe_convert(::Type{Ptr{T}}, a::Array{T}) where {T} = ccall(:jl_array_ptr, Ptr{T}, (Any,), a)
+unsafe_convert(::Type{Ptr{S}}, a::AbstractArray{T}) where {S,T} = convert(Ptr{S}, unsafe_convert(Ptr{T}, a))
+unsafe_convert(::Type{Ptr{T}}, a::AbstractArray{T}) where {T} = error("conversion to pointer not defined for $(typeof(a))")
 
 # unsafe pointer to array conversions
 """
@@ -57,17 +57,17 @@ calling `free` on the pointer when the array is no longer referenced.
 This function is labelled "unsafe" because it will crash if `pointer` is not
 a valid memory address to data of the requested length.
 """
-function unsafe_wrap{T,N}(::Union{Type{Array},Type{Array{T}},Type{Array{T,N}}},
-                          p::Ptr{T}, dims::NTuple{N,Int}, own::Bool=false)
+function unsafe_wrap(::Union{Type{Array},Type{Array{T}},Type{Array{T,N}}},
+                     p::Ptr{T}, dims::NTuple{N,Int}, own::Bool=false) where {T,N}
     ccall(:jl_ptr_to_array, Array{T,N}, (Any, Ptr{Void}, Any, Int32),
           Array{T,N}, p, dims, own)
 end
-function unsafe_wrap{T}(::Union{Type{Array},Type{Array{T}},Type{Array{T,1}}},
-                        p::Ptr{T}, d::Integer, own::Bool=false)
+function unsafe_wrap(::Union{Type{Array},Type{Array{T}},Type{Array{T,1}}},
+                     p::Ptr{T}, d::Integer, own::Bool=false) where {T}
     ccall(:jl_ptr_to_array_1d, Array{T,1},
           (Any, Ptr{Void}, Csize_t, Cint), Array{T,1}, p, d, own)
 end
-unsafe_wrap{N}(Atype::Type, p::Ptr, dims::NTuple{N,<:Integer}, own::Bool=false) =
+unsafe_wrap(Atype::Type, p::Ptr, dims::NTuple{N,<:Integer}, own::Bool=false) where {N} =
     unsafe_wrap(Atype, p, convert(Tuple{Vararg{Int}}, dims), own)
 
 """
@@ -92,8 +92,8 @@ The `unsafe` prefix on this function indicates that no validation is performed o
 pointer `p` to ensure that it is valid. Incorrect usage may corrupt or segfault your
 program, in the same manner as C.
 """
-unsafe_store!(p::Ptr{Any}, x::ANY, i::Integer=1) = pointerset(p, x, Int(i), 1)
-unsafe_store!{T}(p::Ptr{T}, x, i::Integer=1) = pointerset(p, convert(T,x), Int(i), 1)
+unsafe_store!(p::Ptr{Any}, @nospecialize(x), i::Integer=1) = pointerset(p, x, Int(i), 1)
+unsafe_store!(p::Ptr{T}, x, i::Integer=1) where {T} = pointerset(p, convert(T,x), Int(i), 1)
 
 # convert a raw Ptr to an object reference, and vice-versa
 """
@@ -112,10 +112,10 @@ Get the memory address of a Julia object as a `Ptr`. The existence of the result
 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(x::ANY) = ccall(:jl_value_ptr, Ptr{Void}, (Any,), x)
-data_pointer_from_objref(x::ANY) = pointer_from_objref(x)::Ptr{Void}
+pointer_from_objref(@nospecialize(x)) = ccall(:jl_value_ptr, Ptr{Void}, (Any,), x)
+data_pointer_from_objref(@nospecialize(x)) = pointer_from_objref(x)::Ptr{Void}
 
-eltype{T}(::Type{Ptr{T}}) = T
+eltype(::Type{Ptr{T}}) where {T} = T
 
 ## limited pointer arithmetic & comparison ##
 
diff --git a/base/poll.jl b/base/poll.jl
index 6cda7fa4ad8ca0..28deeb33fabf51 100644
--- a/base/poll.jl
+++ b/base/poll.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # filesystem operations
 
@@ -13,7 +13,7 @@ export
 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, |
-if is_windows()
+if Sys.iswindows()
     import Base.WindowsRawSocket
 end
 
@@ -106,7 +106,7 @@ mutable struct _FDWatcher
 
     let FDWatchers = Vector{Any}()
         global _FDWatcher
-        @static if is_unix()
+        @static if Sys.isunix()
             function _FDWatcher(fd::RawFD, readable::Bool, writable::Bool)
                 if !readable && !writable
                     throw(ArgumentError("must specify at least one of readable or writable to create a FDWatcher"))
@@ -154,7 +154,7 @@ mutable struct _FDWatcher
             end
             t.refcount = (0, 0)
             t.active = (false, false)
-            @static if is_unix()
+            @static if Sys.isunix()
                 if FDWatchers[t.fdnum] == t
                     FDWatchers[t.fdnum] = nothing
                 end
@@ -164,7 +164,7 @@ mutable struct _FDWatcher
         end
     end
 
-    @static if is_windows()
+    @static if Sys.iswindows()
         function _FDWatcher(fd::RawFD, readable::Bool, writable::Bool)
             handle = Libc._get_osfhandle(fd)
             return _FDWatcher(handle, readable, writable)
@@ -205,7 +205,7 @@ mutable struct FDWatcher
         finalizer(this, close)
         return this
     end
-    @static if is_windows()
+    @static if Sys.iswindows()
         function FDWatcher(fd::WindowsRawSocket, readable::Bool, writable::Bool)
             this = new(_FDWatcher(fd, readable, writable), readable, writable)
             finalizer(this, close)
@@ -263,9 +263,9 @@ function _uv_hook_close(uv::FileMonitor)
 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))
+    global uv_jl_pollcb        = cfunction(uv_pollcb, Void, Tuple{Ptr{Void}, Cint, Cint})
+    global uv_jl_fspollcb      = cfunction(uv_fspollcb, Void, Tuple{Ptr{Void}, Cint, Ptr{Void}, Ptr{Void}})
+    global uv_jl_fseventscb    = cfunction(uv_fseventscb, Void, Tuple{Ptr{Void}, Ptr{Int8}, Int32, Int32})
 end
 
 function uv_fseventscb(handle::Ptr{Void}, filename::Ptr, events::Int32, status::Int32)
@@ -406,7 +406,7 @@ function wait(fd::RawFD; readable=false, writable=false)
     end
 end
 
-if is_windows()
+if Sys.iswindows()
     function wait(socket::WindowsRawSocket; readable=false, writable=false)
         fdw = _FDWatcher(socket, readable, writable)
         try
@@ -443,7 +443,7 @@ 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.
 """
-function poll_fd(s::Union{RawFD, is_windows() ? WindowsRawSocket : Union{}}, timeout_s::Real=-1; readable=false, writable=false)
+function poll_fd(s::Union{RawFD, Sys.iswindows() ? WindowsRawSocket : Union{}}, timeout_s::Real=-1; readable=false, writable=false)
     wt = Condition()
     fdw = _FDWatcher(s, readable, writable)
     try
diff --git a/base/precompile.jl b/base/precompile.jl
index 6fe485436dd9e8..10f63a83e4baf1 100644
--- a/base/precompile.jl
+++ b/base/precompile.jl
@@ -1,486 +1,1878 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
-# prime method cache with some things we know we'll need right after startup
-precompile(!=, (Bool, Bool))
-precompile(!=, (SubString{String}, String))
-precompile(*, (String, String, String))
-precompile(-, (Int,))
-precompile(==, (String, String))
-precompile(==, (String, Char))
-precompile(==, (String, Int))
-precompile(==, (Array{Char, 1}, Array{Char, 1}))
-precompile(==, (Array{Char,1}, Array{Char,1}))
-precompile(==, (Base.LineEdit.HistoryPrompt{Base.REPL.REPLHistoryProvider}, Base.LineEdit.Prompt))
-precompile(==, (Base.LineEdit.Prompt, Base.LineEdit.Prompt))
-precompile(==, (Base.Multimedia.TextDisplay, Base.REPL.REPLDisplay{Base.REPL.LineEditREPL}))
-precompile(==, (Base.REPL.REPLDisplay{Base.REPL.LineEditREPL}, Base.Multimedia.TextDisplay))
-precompile(==, (Int32, Int32))
-precompile(==, (Int32, Int64))
-precompile(==, (Int64, Int32))
-precompile(==, (Int64, Int64))
-precompile(==, (Bool,Bool))
-precompile(==, (Char, String))
-precompile(==, (IOStream,Void))
-precompile(==, (Type{String}, Type{Any}))
-precompile(==, (Type{Base.LineEdit.Prompt}, Type{Base.LineEdit.Prompt}))
-precompile(==, (Type{Function}, Int))
-precompile(==, (Type{Function}, Type{String}))
-precompile(Base._atreplinit, (Base.REPL.LineEditREPL,))
-precompile(Base.BitArray, (Int,))
-precompile(Base.Dict, ())
-precompile(Base.Dict{Any,Any}, (Int,))
-precompile(Base.IOStream, (String, Array{UInt8,1}))
-precompile(Base.KeyError, (Int,))
-precompile(Base.LineEdit.Prompt, (String, String, String, Function, Function, Base.REPL.LineEditREPL, Base.REPL.REPLCompletionProvider, Function, Function, Base.LineEdit.EmptyHistoryProvider, Bool))
-precompile(Base.LineEdit.Prompt, (String, String, String, Function, Function, Base.REPL.LineEditREPL, Base.REPL.ShellCompletionProvider, Function, Function, Base.LineEdit.EmptyHistoryProvider, Bool))
-precompile(Base.LineEdit.Prompt, (String, String, Function, Function, Base.REPL.LineEditREPL, Base.REPL.REPLCompletionProvider, Function, Function, Base.LineEdit.EmptyHistoryProvider, Bool, String))
-precompile(Base.LineEdit.Prompt, (String, String, Function, Function, Base.REPL.LineEditREPL, Base.REPL.ShellCompletionProvider, Function, Function, Base.LineEdit.EmptyHistoryProvider, Bool, String))
-precompile(Base.LineEdit.PromptState, (Base.Terminals.TTYTerminal, Base.LineEdit.Prompt, IOBuffer, Base.LineEdit.InputAreaState, Int))
-precompile(Base.LineEdit.activate, (Base.LineEdit.Prompt, Base.LineEdit.MIState, Base.Terminals.TTYTerminal))
-precompile(Base.LineEdit.activate, (Base.LineEdit.Prompt, Base.LineEdit.PromptState, Base.Terminals.TTYTerminal))
-precompile(Base.LineEdit.activate, (Base.LineEdit.Prompt, Base.LineEdit.PromptState, Base.Terminals.TerminalBuffer))
-precompile(Base.LineEdit.add_history, (Base.LineEdit.PromptState,))
-precompile(Base.LineEdit.buffer, (Base.LineEdit.MIState,))
-precompile(Base.LineEdit.buffer, (Base.LineEdit.PromptState,))
-precompile(Base.LineEdit.char_move_left, (IOBuffer,))
-precompile(Base.LineEdit.clear_input_area, (Base.Terminals.TTYTerminal, Base.LineEdit.InputAreaState))
-precompile(Base.LineEdit.commit_line, (Base.LineEdit.MIState,))
-precompile(Base.LineEdit.deactivate, (Base.LineEdit.Prompt,Base.LineEdit.PromptState, Base.Terminals.TerminalBuffer))
-precompile(Base.LineEdit.edit_backspace, (Base.LineEdit.MIState,))
-precompile(Base.LineEdit.edit_backspace, (Base.LineEdit.PromptState,))
-precompile(Base.LineEdit.edit_backspace, (IOBuffer,))
-precompile(Base.LineEdit.edit_clear, (Base.LineEdit.MIState,))
-precompile(Base.LineEdit.edit_delete, (Base.LineEdit.MIState,))
-precompile(Base.LineEdit.edit_delete, (IOBuffer,))
-precompile(Base.LineEdit.edit_insert, (Base.LineEdit.MIState, Char))
-precompile(Base.LineEdit.edit_insert, (Base.LineEdit.PromptState, Char))
-precompile(Base.LineEdit.edit_insert, (IOBuffer, String))
-precompile(Base.LineEdit.edit_move_down, (Base.LineEdit.MIState,))
-precompile(Base.LineEdit.edit_move_left, (Base.LineEdit.MIState,))
-precompile(Base.LineEdit.edit_move_left, (Base.LineEdit.PromptState,))
-precompile(Base.LineEdit.edit_move_left, (IOBuffer,))
-precompile(Base.LineEdit.edit_move_right, (Base.LineEdit.MIState,))
-precompile(Base.LineEdit.edit_move_right, (Base.LineEdit.PromptState,))
-precompile(Base.LineEdit.edit_move_right, (IOBuffer,))
-precompile(Base.LineEdit.edit_move_up, (Base.LineEdit.MIState,))
-precompile(Base.LineEdit.edit_move_up, (IOBuffer,))
-precompile(Base.LineEdit.postprocess!, (Void, Int))
-precompile(Base.LineEdit.history_prev, (Base.LineEdit.MIState, Base.REPL.REPLHistoryProvider))
-precompile(Base.LineEdit.history_prev, (Base.LineEdit.MIState, Base.REPL.REPLHistoryProvider, Int))
-precompile(Base.LineEdit.init_state, (Base.Terminals.TTYTerminal, Base.LineEdit.HistoryPrompt{Base.REPL.REPLHistoryProvider}))
-precompile(Base.LineEdit.init_state, (Base.Terminals.TTYTerminal, Base.LineEdit.Prompt))
-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, String))
-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}))
-precompile(Base.LineEdit.mode, (Base.LineEdit.MIState,))
-precompile(Base.LineEdit.move_line_end, (Base.LineEdit.MIState,))
-precompile(Base.LineEdit.on_enter, (Base.LineEdit.MIState,))
-precompile(Base.LineEdit.on_enter, (Base.LineEdit.PromptState,))
-precompile(Base.LineEdit.prompt!, (Base.Terminals.TTYTerminal, Base.LineEdit.ModalInterface, Base.LineEdit.MIState))
-precompile(Base.LineEdit.refresh_line, (Base.LineEdit.MIState,))
-precompile(Base.LineEdit.refresh_multi_line, (Base.LineEdit.MIState,))
-precompile(Base.LineEdit.refresh_multi_line, (Base.LineEdit.PromptState,))
-precompile(Base.LineEdit.refresh_multi_line, (Base.Terminals.TTYTerminal, Base.LineEdit.PromptState))
-precompile(Base.LineEdit.refresh_multi_line, (Base.Terminals.TerminalBuffer, Base.LineEdit.SearchState))
-precompile(Base.LineEdit.refresh_multi_line, (Base.Terminals.TerminalBuffer, Base.Terminals.TTYTerminal, Base.LineEdit.PromptState))
-precompile(Base.LineEdit.replace_line, (Base.LineEdit.PromptState, String))
-precompile(Base.LineEdit.replace_line, (Base.LineEdit.PromptState, Base.IOBuffer))
-precompile(Base.LineEdit.reset_key_repeats, (Function, Base.LineEdit.MIState,))
-precompile(Base.LineEdit.reset_state, (Base.LineEdit.MIState,))
-precompile(Base.LineEdit.reset_state, (Base.LineEdit.PromptState,))
-precompile(Base.LineEdit.reset_state, (Base.LineEdit.SearchState,))
-precompile(Base.LineEdit.run_interface, (Base.Terminals.TTYTerminal, Base.LineEdit.ModalInterface))
-precompile(Base.LineEdit.setup_search_keymap, (Base.REPL.REPLHistoryProvider,))
-precompile(Base.LineEdit.splice_buffer!, (IOBuffer, UnitRange{Int}, String))
-precompile(Base.LineEdit.state, (Base.LineEdit.MIState, Base.LineEdit.Prompt))
-precompile(Base.LineEdit.terminal, (Base.LineEdit.MIState,))
-precompile(Base.LineEdit.terminal, (Base.LineEdit.PromptState,))
-precompile(Base.LineEdit.transition, (Base.LineEdit.MIState, Base.LineEdit.Prompt))
-precompile(Base.LineEdit.transition, (Base.LineEdit.MIState, Symbol))
-precompile(Base.LineEdit.update_key_repeats, (Base.LineEdit.MIState, Array{Char, 1}))
-precompile(Base.LineEdit.update_key_repeats, (Base.LineEdit.MIState, Array{Char,1}))
-precompile(Base.LineEdit.write_prompt, (Base.Terminals.TTYTerminal, Base.LineEdit.Prompt))
-precompile(Base.LineEdit.write_prompt, (Base.Terminals.TerminalBuffer, Base.LineEdit.PromptState))
-precompile(Base.Multimedia.TextDisplay, (Base.TTY,))
-precompile(Base.Multimedia.display, (Int,))
-precompile(Base.Distributed.ProcessGroup, (Int, Array{Any,1}, Array{Any,1}))
-precompile(Base.REPL.:(==), (Base.REPL.REPLDisplay{Base.REPL.LineEditREPL}, Base.REPL.REPLDisplay{Base.REPL.LineEditREPL}))
-precompile(Base.REPL.LineEditREPL, (Base.Terminals.TTYTerminal, Bool, String, String, String, String, String, Bool, Bool, Bool, Bool))
-precompile(Base.REPL.LineEditREPL, (Base.Terminals.TTYTerminal,))
-precompile(Base.REPL.REPLBackendRef, (Channel{Any}, Channel{Any}))
-precompile(Base.REPL.REPLDisplay, (Base.REPL.BasicREPL,))
-precompile(Base.REPL.REPLDisplay, (Base.REPL.LineEditREPL,))
-precompile(Base.REPL.add_history, (Base.REPL.REPLHistoryProvider, Base.LineEdit.PromptState))
-precompile(Base.REPL.backend, (Base.REPL.LineEditREPL,))
-precompile(Base.REPL.display, (Base.REPL.REPLDisplay{Base.REPL.LineEditREPL}, Base.Multimedia.MIME{Symbol("text/plain")}, Int))
-precompile(Base.REPL.display, (Base.REPL.REPLDisplay{Base.REPL.LineEditREPL}, Int))
-precompile(Base.REPL.ends_with_semicolon, (String,))
-precompile(Base.REPL.find_hist_file, ())
-precompile(Base.REPL.hist_from_file, (Base.REPL.REPLHistoryProvider, IOStream, String))
-precompile(Base.REPL.history_next, (Base.LineEdit.MIState,  Base.REPL.REPLHistoryProvider, Int))
-precompile(Base.REPL.history_next_prefix, (Base.LineEdit.MIState, Base.REPL.REPLHistoryProvider,))
-precompile(Base.REPL.history_prev_prefix, (Base.LineEdit.MIState, Base.REPL.REPLHistoryProvider,))
-precompile(Base.REPL.mode_idx, (Base.REPL.REPLHistoryProvider, Base.LineEdit.Prompt))
-precompile(Base.REPL.reset, (Base.REPL.LineEditREPL,))
-precompile(Base.REPL.reset_state, (Base.REPL.REPLHistoryProvider,))
-precompile(Base.REPL.respond, (Function, Base.REPL.LineEditREPL, Base.LineEdit.Prompt))
-precompile(Base.REPL.return_callback, (Base.LineEdit.PromptState,))
-precompile(Base.REPL.run_repl, (Base.REPL.LineEditREPL,))
-precompile(Base.REPL.send_to_backend, (Expr, Base.REPL.REPLBackendRef))
-precompile(Base.REPL.send_to_backend, (Expr, Channel{Any}, Channel{Any}))
-precompile(Base.REPL.send_to_backend, (Symbol, Base.REPL.REPLBackendRef))
-precompile(Base.REPL.start_repl_backend, (Channel{Any}, Channel{Any}))
-precompile(Base.REPLCompletions.complete_methods, (String,))
-precompile(Base.REPLCompletions.complete_symbol, (String, Function))
-precompile(Base.REPLCompletions.completions, (String, Int))
-precompile(Base.Random.srand, ())
-precompile(Base.Random.srand, (String, Int))
-precompile(Base.Random.srand, (UInt,))
-precompile(Base.Distributed.RemoteChannel, (Int, Int, Int))
-precompile(Base.Distributed.RemoteValue, ())
-precompile(Base.Set, ())
-precompile(Base.SystemError, (String,))
-precompile(Base.TCPSocket, (Ptr{Void},))
-precompile(Base.TTY, (Ptr{Void},))
-precompile(Base.Terminals.TTYTerminal, (String, Base.TTY, Base.TTY, Base.TTY))
-precompile(Base.Terminals.beep, (Base.Terminals.TTYTerminal,))
-precompile(Base.Terminals.raw!, (Base.Terminals.TTYTerminal, Bool))
-precompile(Base.Terminals.write, (Base.Terminals.TTYTerminal, Array{UInt8, 1}))
-precompile(Libc.TmStruct, (Float64,))
-precompile(Base.VersionNumber, (Int, Int, Int, Tuple{}, Tuple{String}))
-precompile(Base._atexit, ())
-precompile(Base._deleteat!, (Array{UInt8, 1}, Int, Int))
-precompile(Base._growat!, (Array{UInt8, 1}, Int, Int))
-precompile(Base._setindex!, (Base.Dict{Symbol, Any}, Base.LineEdit.Prompt, Symbol, Int))
-precompile(Base._setindex!, (Dict{Any, Any}, Base.LineEdit.PromptState, Base.LineEdit.Prompt, Int))
-precompile(Base._setindex!, (Dict{Any, Any}, Bool, WeakRef, Int))
-precompile(Base._setindex!, (Dict{UInt8, Any}, Base.LineEdit.Prompt, UInt8, Int))
-precompile(Base._start, ())
-precompile(Base.abs, (Char,))
-precompile(Base.abspath, (String, String))
-precompile(Base.abspath, (String,))
-precompile(Base.alignment, (Base.IOContext, Float64,))
-precompile(Base.any, (Function, Array{Any,1}))
-precompile(Base.arg_gen, (String,))
-precompile(Base.associate_julia_struct, (Ptr{Void}, Base.TTY))
-precompile(Base.async_run_thunk, (Function,))
-precompile(Base.atexit, (Function,))
-precompile(Base.banner, (Base.Terminals.TTYTerminal,))
-precompile(Base.startswith, (String, String))
-precompile(Base.String, (String,))
-precompile(Base.chop, (String,))
-precompile(Base.close, (Base.TTY,))
-precompile(Base.close, (IOStream,))
-precompile(Base.cmp, (Int32, Int32))
-precompile(Base.convert, (Type{Any}, Base.LineEdit.ModalInterface))
-precompile(Base.convert, (Type{Any}, Base.LineEdit.Prompt))
-precompile(Base.convert, (Type{Any}, Base.ObjectIdDict))
-precompile(Base.convert, (Type{Any}, Base.REPL.LatexCompletions))
-precompile(Base.convert, (Type{Any}, Base.REPL.REPLHistoryProvider))
-precompile(Base.convert, (Type{Any}, Function))
-precompile(Base.convert, (Type{Any}, IOStream))
-precompile(Base.convert, (Type{Any}, Int))
-precompile(Base.convert, (Type{Any}, Void))
-precompile(Base.convert, (Type{Base.IPAddr}, Base.IPv4))
-precompile(Base.convert, (Type{Base.LineEdit.InputAreaState}, Base.LineEdit.InputAreaState))
-precompile(Base.convert, (Type{Char}, Char))
-precompile(Base.convert, (Type{Function}, Function))
-precompile(Base.convert, (Type{IOBuffer}, IOBuffer))
-precompile(Base.convert, (Type{Module}, Module))
-precompile(Base.convert, (Type{AbstractString}, String))
-precompile(Base.copy!, (Array{Dict{Any, Any}, 1}, Int, Array{Dict{Any, Any}, 1}, Int, Int))
-precompile(Base.copy, (Bool,))
-precompile(Base.deleteat!, (Array{UInt8, 1}, Base.UnitRange{Int}))
-precompile(Base.done, (Array{Base.LineEdit.TextInterface, 1}, Int))
-precompile(Base.done, (Dict{Any,Any}, Int))
-precompile(Base.done, (Dict{Symbol,Any}, Int))
-precompile(Base.done, (IntSet, Int))
-precompile(Base.done, (UnitRange{Int},Int))
-precompile(Base.endof, (Array{Any,1},))
-precompile(Base.enq_work, (Task,))
-precompile(Base.eval_user_input, (Expr, Bool))
-precompile(Base.fdio, (Int32,))
-precompile(Base.fill!, (BitArray{1}, Bool))
-precompile(Base.first, (UnitRange{Int},))
-precompile(Base.flush, (IOStream,))
-precompile(Base.Distributed.flush_gc_msgs, ())
-precompile(Base.Distributed.flush_gc_msgs, (Base.Distributed.Worker,))
-precompile(Base.get, (Base.EnvHash, String, String))
-precompile(Base.get, (Dict{Any, Any}, Tuple{Int, Int}, Bool))
-precompile(Base.get, (Dict{Any,Any}, Symbol, String))
-precompile(Base.get_chunks_id, (Int,))
-precompile(Base.getindex, (Array{Base.LineEdit.TextInterface, 1}, Int))
-precompile(Base.getindex, (BitArray{1}, Int,))
-precompile(Base.getindex, (Dict{Any, Any}, Base.LineEdit.Prompt))
-precompile(Base.getindex, (Dict{Any,Any}, Int32))
-precompile(Base.getindex, (Dict{Symbol,Any},Symbol))
-precompile(Base.getindex, (Type{AbstractString},))
-precompile(Base.getindex, (Type{String}, String, String))
-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, (Base.Distributed.RemoteChannel, UInt))
-precompile(Base.hash, (Base.Distributed.RemoteChannel,))
-precompile(Base.haskey, (Base.EnvHash, String))
-precompile(Base.haskey, (Dict{Symbol,Any}, Symbol))
-precompile(Base.haskey, (ObjectIdDict, Symbol))
-precompile(Base.hex, (Char, Int))
-precompile(Base.ht_keyindex, (Dict{Any, Any}, Base.LineEdit.Prompt))
-precompile(Base.ht_keyindex, (Dict{Any,Any}, Int32))
-precompile(Base.ht_keyindex, (Dict{UInt8, Any}, UInt8))
-precompile(Base.ht_keyindex2, (Dict{Any, Any}, Base.LineEdit.Prompt))
-precompile(Base.ht_keyindex2, (Dict{UInt8, Any}, UInt8))
-precompile(Base.in, (Char, String))
-precompile(Base.in, (Int, Base.UnitRange{Int}))
-precompile(Base.in, (UInt8, Base.KeyIterator{Dict{UInt8, Any}}))
-precompile(Base.include_from_node1, (String,))
-precompile(Base.init_stdio, (Ptr{Void},))
-precompile(Base.input_color, ())
-precompile(Base.insert!, (Array{Any,1}, Int, Base.GlobalRef))
-precompile(Base.Int, (Int,))
-precompile(Base.Int, (UInt,))
-precompile(Base.isabspath, (String,))
-precompile(Base.isempty, (String,))
-precompile(Base.isempty, (Array{Any,1},))
-precompile(Base.isempty, (Base.LineEdit.MIState,))
-precompile(Base.isempty, (Base.LineEdit.PromptState,))
-precompile(Base.isempty, (SubString{String},))
-precompile(Base.isequal, (Tuple{Int,Int},Tuple{Int,Int}))
-precompile(Base.isequal, (Base.LineEdit.Prompt, Base.LineEdit.Prompt))
-precompile(Base.isequal, (Bool, Bool))
-precompile(Base.isequal, (Char, String))
-precompile(Base.isequal, (Int,Int))
-precompile(Base.isequal, (Base.Distributed.RemoteChannel, Base.Distributed.RemoteChannel))
-precompile(Base.isequal, (Base.Distributed.RemoteChannel, WeakRef))
-precompile(Base.isequal, (Symbol, Symbol))
-precompile(Base.isequal, (VersionNumber, VersionNumber))
-precompile(Base.isequal, (Void, Void))
-precompile(Base.isfile, (String,))
-precompile(Base.ismatch, (Regex, String))
-precompile(Base.isslotempty, (Dict{Any,Any}, Int))
-precompile(Base.istaskdone, (Task,))
-precompile(Base.joinpath, (String, String))
-precompile(Base.joinpath, (String, String, String))
-precompile(Base.keys, (Dict{UInt8, Any},))
-precompile(Base.last, (UnitRange{Int},))
-precompile(Base.length, (String,))
-precompile(Base.length, (Array{UInt8,1},))
-precompile(Base.length, (UnitRange{Int},))
-precompile(Base.match, (Regex, String))
-precompile(Base.match, (Regex, String, Int))
-precompile(Base.min, (Int32, Int32))
-precompile(Base.next, (Array{Base.LineEdit.TextInterface, 1}, Int))
-precompile(Base.next, (Dict{Any,Any}, Int))
-precompile(Base.next, (Dict{Symbol,Any},Int))
-precompile(Base.next, (IntSet, Int))
-precompile(Base.next, (UnitRange{Int},Int))
-precompile(Base.nextind, (String, Int))
-precompile(Base.normpath, (String, String))
-precompile(Base.normpath, (String,))
-precompile(Base.notify, (Condition, Any))
-precompile(Base.open, (String, String))
-precompile(Base.parse_input_line, (String,))
-precompile(Base.parse, (Type{Int}, String, Int))
-precompile(Base.peek, (Base.IOBuffer,))
-precompile(Base.pop!, (Array{Any,1},))
-precompile(Base.position, (IOBuffer,))
-precompile(Base.prepend!, (Array{Dict{Any, Any}, 1}, Array{Dict{Any, Any}, 1}))
-precompile(Base.print, (String,))
-precompile(Base.print, (Base.TTY, String))
-precompile(Base.print, (Base.TTY,Char))
-precompile(Base.print, (Base.Terminals.TTYTerminal, String))
-precompile(Base.print, (Base.Terminals.TTYTerminal, String, Char))
-precompile(Base.print, (Base.Terminals.TTYTerminal, String, Char,))
-precompile(Base.print, (Float64,))
-precompile(Base.print, (IOBuffer, String))
-precompile(Base.print, (IOBuffer, VersionNumber))
-precompile(Base.print, (IOStream, Int32))
-precompile(Base.print, (IOStream,String))
-precompile(Base.join, (IOBuffer, Tuple{String}, Char))
-precompile(Base.join, (IOBuffer, Tuple{Int}, Char))
-precompile(Base.join, (IOBuffer, Array{String,1}, Char))
-precompile(Base.join, (IOBuffer, Array{AbstractString,1}, String))
-precompile(Base.join, (IOBuffer, Array{SubString{String}, 1}, String))
-precompile(Base.println, (Base.TTY,))
-precompile(Base.println, (Base.Terminals.TTYTerminal,))
-precompile(Base.promote_type, (Type{Base.LineEdit.Prompt}, Type{Base.LineEdit.HistoryPrompt{Base.REPL.REPLHistoryProvider}}))
-precompile(Base.promote_type, (Type{Base.LineEdit.Prompt}, Type{Base.LineEdit.Prompt}))
-precompile(Base.promote_type, (Type{Base.LineEdit.Prompt}, Type{Base.LineEdit.TextInterface}))
-precompile(Base.promote_type, (Type{Int}, Bool))
-precompile(Base.push!, (Array{AbstractString, 1}, String))
-precompile(Base.push!, (Array{AbstractString,1}, String))
-precompile(Base.push!, (Array{Base.Multimedia.Display, 1}, Base.Multimedia.TextDisplay))
-precompile(Base.push!, (Array{Char, 1}, Char))
-precompile(Base.push!, (Array{Union{String, String}, 1}, String))
-precompile(Base.pushdisplay, (Base.Multimedia.TextDisplay,))
-precompile(Base.pwd, ())
-precompile(Base.read, (Base.Terminals.TTYTerminal, Type{Char}))
-precompile(Base.read, (IOBuffer, Type{Char}))
-precompile(Base.read, (IOBuffer, Type{UInt8}))
-precompile(Base.read, (IOStream, Array{UInt32,1}))
-precompile(Base.readline, (String,))
-precompile(Base.readline, (IOBuffer,))
-precompile(Base.readline, (IOStream,))
-precompile(Base.readuntil, (IOBuffer, Char))
-precompile(Base.readuntil, (IOBuffer, UInt8))
-precompile(Base.rehash!, (Dict{Any,Any}, Int))
-precompile(Base.rehash!, (Dict{UInt8, Any}, Int))
-precompile(Base.reinit_stdio, ())
-precompile(Base.repeat, (String, Int))
-precompile(Base.repl_cmd, (Cmd, Base.Terminals.TTYTerminal))
-precompile(Base.require, (Symbol,))
-precompile(Base.Distributed.remoteref_id, (Base.Distributed.RemoteChannel,))
-precompile(Base.rsearch, (String, Char))
-precompile(Base.rstrip, (String,))
-precompile(Base.run, (Cmd,))
-precompile(Base.search, (String, Regex, Int))
-precompile(Base.search, (IOBuffer, UInt8))
-precompile(Base.seek, (IOBuffer, Int))
-precompile(Base.seekend, (IOStream,))
-precompile(Base.setindex!, (Array{AbstractString, 1}, String, Int))
-precompile(Base.setindex!, (Array{Any, 1}, Array{UInt8, 1}, Int))
-precompile(Base.setindex!, (Array{Any, 1}, Base.NewvarNode, Int))
-precompile(Base.setindex!, (Array{Any, 1}, GlobalRef, Int))
-precompile(Base.setindex!, (Array{Any,1}, WeakRef, Int))
-precompile(Base.setindex!, (Array{Base.LineEdit.TextInterface, 1}, Base.LineEdit.HistoryPrompt{Base.REPL.REPLHistoryProvider}, UnitRange{Int}))
-precompile(Base.setindex!, (Array{Base.LineEdit.TextInterface, 1}, Base.LineEdit.Prompt, UnitRange{Int}))
-precompile(Base.setindex!, (Array{Char, 1}, Char, Int))
-precompile(Base.setindex!, (Array{Symbol, 1}, Symbol, Int))
-precompile(Base.setindex!, (Array{UInt8,1}, UInt8, Int))
-precompile(Base.setindex!, (Base.Dict{Symbol, Any}, Base.LineEdit.Prompt, Symbol))
-precompile(Base.setindex!, (BitArray{1}, Bool, Int,))
-precompile(Base.setindex!, (Dict{Any, Any}, Base.LineEdit.PromptState, Base.LineEdit.Prompt))
-precompile(Base.setindex!, (Dict{Any,Any}, Base.LineEdit.SearchState, Base.LineEdit.HistoryPrompt{Base.REPL.REPLHistoryProvider}))
-precompile(Base.setindex!, (Dict{Any,Any}, Bool, Cmd))
-precompile(Base.setindex!, (Dict{UInt8, Any}, Base.LineEdit.Prompt, UInt8))
-precompile(Base.setindex!, (Base.EnvHash, String, String))
-precompile(Base.setindex!, (Vector{Any}, UInt8, Int))
-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.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))
-precompile(Base.sizeof, (String,))
-precompile(Base.source_path, (Void,))
-precompile(Base.splice!, (Array{UInt8, 1}, Base.UnitRange{Int}, Array{UInt8, 1}))
-precompile(Base.split, (String, String))
-precompile(Base.split, (String, Regex))
-precompile(Base.split, (String,))
-precompile(Base.srand, (Array{UInt32,1},))
-precompile(Base.start, (Array{Base.LineEdit.TextInterface, 1},))
-precompile(Base.start, (Dict{Any,Any},))
-precompile(Base.start, (Dict{Symbol,Any},))
-precompile(Base.start, (UnitRange{Int},))
-precompile(Base.start_reading, (Base.TTY,))
-precompile(Base.stop_reading, (Base.TTY,))
-precompile(Libc.strftime, (String, Libc.TmStruct))
-precompile(Base.string, (Int,))
-precompile(Base.strip, (String,))
-precompile(Base.strwidth, (String,))
-precompile(Base.Symbol, (SubString{String},))
-precompile(Base.sync_begin, ())
-precompile(Base.sync_end, ())
-precompile(Base.systemerror, (Symbol, Bool))
-precompile(Base.Distributed.take!, (Base.Distributed.RemoteValue,))
-precompile(Base.Distributed.take!, (Base.Distributed.RemoteChannel,))
-precompile(Base.Distributed.take_ref, (Tuple{Int,Int},))
-precompile(Base.take!, (IOBuffer,))
-precompile(Base.task_local_storage, ())
-precompile(Base.Distributed.terminate_all_workers, ())
-precompile(Base.try_include, (String,))
-precompile(Base.UInt, (UInt,))
-precompile(Base.unsafe_copy!, (Array{Dict{Any, Any}, 1}, Int, Array{Dict{Any, Any}, 1}, Int, Int))
-precompile(Base.unsafe_copy!, (Ptr{Dict{Any, Any}}, Ptr{Dict{Any, Any}}, Int))
-precompile(Base.unshift!, (Array{Any,1}, Task))
-precompile(Base.uv_error, (String, Bool))
-precompile(Base.uvfinalize, (Base.TTY,))
-precompile(Base.vcat, (Base.LineEdit.Prompt,))
-precompile(Base.wait, ())
-precompile(Base.Distributed.wait, (Base.Distributed.RemoteChannel,))
-precompile(Base.write, (Base.Terminals.TTYTerminal, String))
-precompile(Base.write, (Base.Terminals.TerminalBuffer, String))
-precompile(Base.write, (IOBuffer, Vector{UInt8}))
-precompile(Base.show, (Base.Terminals.TTYTerminal, Base.Multimedia.MIME{Symbol("text/plain")}, Int))
+# Steps to regenerate this file:
+# 1. Remove all `precompile` calls
+# 2. Rebuild system image
+# 3. Enable TRACE_COMPILE in options.h and rebuild
+# 4. Run `./julia 2> precompiles.txt` and do various things.
+# 5. Run `grep -v '#[0-9]' precompiles.txt >> base/precompile.jl` (filters out closures, which
+#    might have different generated names in different environments)
 
-# The following are intended to help speed Pkg.update()
-precompile(Base.Pkg.Entry.update, (String,))
-precompile(Base.Pkg.Query.prune_dependencies, (Dict{String, Base.Pkg.Types.VersionSet}, Dict{String, Dict{VersionNumber, Base.Pkg.Types.Available}}))
-precompile(Base.Pkg.Read.installed_version, (String, Dict{VersionNumber, Base.Pkg.Types.Available}))
-precompile(Base.Pkg.Resolve.resolve, (Dict{String, Base.Pkg.Types.VersionSet}, Dict{String, Dict{VersionNumber, Base.Pkg.Types.Available}}))
-precompile(Base.Pkg.update, ())
-precompile(Base.Sort.sort!, (Array{Any, 1}, Base.Sort.MergeSortAlg, Base.Order.ForwardOrdering))
-precompile(Base.Sort.sort!, (Array{Any, 1}, Int, Int, Base.Sort.InsertionSortAlg, Base.Order.ForwardOrdering))
-precompile(Base.Sort.sort!, (Array{Any,1},))
-precompile(Base.Sort.sort!, (Array{VersionNumber, 1}, Int, Int, Base.Sort.InsertionSortAlg, Base.Order.ForwardOrdering))
-precompile(Base.info, (String,))
-precompile(Base.isempty, (Array{Void, 1},))
-precompile(Base.setindex!, (Dict{String, VersionNumber}, VersionNumber, String))
-precompile(Base.spawn, (Cmd, Tuple{Base.TTY, Base.TTY, Base.TTY}, Bool, Bool))
-precompile(Base.spawn, (Cmd,))
-
-# For repl startup
-precompile(Base.yieldto, (Task, Int))
-precompile(Base.open, (String, Bool, Bool, Bool, Bool, Bool))
-precompile(Base.setindex!, (Base.Dict{Any, Any}, Char, Char))
-precompile(Base.setindex!, (Base.Dict{Any, Any}, Char, String))
-precompile(Base.in, (String, Array{Any, 1}))
-precompile(Base.getindex, (Base.Dict{Any, Any}, String))
-precompile(Base.LineEdit.setup_prefix_keymap, (Base.REPL.REPLHistoryProvider, Base.LineEdit.Prompt))
-precompile(Base.convert, (Type{Any}, Base.Dict{Char, Any}))
-precompile(Base.REPL.mode_keymap, (Base.LineEdit.Prompt,))
-precompile(Base.promote_type, (Type{Base.LineEdit.Prompt}, Type{Base.LineEdit.HistoryPrompt{Base.REPL.REPLHistoryProvider}}, Type))
-precompile(Base.promote_type, (Type{Base.LineEdit.HistoryPrompt{Base.REPL.REPLHistoryProvider}}, Type{Base.LineEdit.PrefixHistoryPrompt{Base.REPL.REPLHistoryProvider}}))
-precompile(Base.similar, (Array{Base.LineEdit.Prompt, 1}, Type{Base.LineEdit.TextInterface}, Tuple{Int64}))
-precompile(Base.setindex!, (Array{Base.LineEdit.TextInterface, 1}, Base.LineEdit.PrefixHistoryPrompt{Base.REPL.REPLHistoryProvider}, Base.UnitRange{Int64}))
-precompile(Base.LineEdit.init_state, (Base.Terminals.TTYTerminal, Base.LineEdit.PrefixHistoryPrompt{Base.REPL.REPLHistoryProvider}))
-precompile(Base.setindex!, (Base.Dict{Any, Any}, Base.LineEdit.PrefixSearchState, Base.LineEdit.PrefixHistoryPrompt{Base.REPL.REPLHistoryProvider}))
-precompile(Base.get, (Base.Dict{Any, Any}, Tuple{Int64, Int64}, Bool))
-precompile(Base.LineEdit.refresh_multi_line, (Array{Any, 1}, Base.Terminals.TerminalBuffer, Base.Terminals.TTYTerminal, Base.IOBuffer, Base.LineEdit.InputAreaState, Base.LineEdit.PromptState))
-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.Distributed.RemoteChannel, WeakRef))
-precompile(==, (Base.Distributed.RemoteChannel, Base.Distributed.RemoteChannel))
-precompile(Base.Distributed.send_del_client, (Base.Distributed.RemoteChannel,))
-precompile(!=, (Base.SubString{String}, String))
-precompile(Base.join, (Base.IOBuffer, Array{Base.SubString{String}, 1}, String))
-precompile(Base.joinpath, (String, String, String, String))
-precompile(Base.string, (String, String, Char))
-precompile(Base.string, (String, String, Int))
-precompile(Base.vect, (Base.LineEdit.Prompt, String))
-
-# Speed up type inference in the post-Base world redefinition of convert
-isdefined(Core, :Inference) && Base.code_typed(Base.code_typed)
-
-# Speeding up addprocs for LocalManager
-precompile(Base.Distributed.start_worker, ())
-precompile(Base.Distributed.start_worker, (Base.TTY,))
-precompile(Base.Distributed.process_messages, (Base.TCPSocket, Base.TCPSocket))
-precompile(Base.Distributed.process_messages, (Base.TCPSocket, Base.TCPSocket, Void))
-precompile(Base.Distributed.process_tcp_streams, (Base.TCPSocket, Base.TCPSocket, Void))
-precompile(Base.Distributed.message_handler_loop, (Base.TCPSocket, Base.TCPSocket, Void))
-precompile(Base.Distributed.connect_to_peer, (Base.Distributed.LocalManager, Int64, Base.Distributed.WorkerConfig))
-precompile(Base.Distributed.connect, (Base.Distributed.LocalManager, Int64, Base.Distributed.WorkerConfig))
-precompile(Base.Distributed.connect_w2w, (Int64, Base.Distributed.WorkerConfig))
-precompile(Base.Distributed.connect_to_worker, (String, Int64))
-precompile(Base.Distributed.addprocs, (Base.Distributed.LocalManager, ))
-precompile(Base.Distributed.addprocs, (Int, ))
-precompile(Base.Distributed.setup_launched_worker, (Base.Distributed.LocalManager, Dict, Base.Distributed.WorkerConfig, Array{Int,1}))
-precompile(Base.Distributed.create_worker, (Base.Distributed.LocalManager, Dict, Base.Distributed.WorkerConfig))
-precompile(Base.Distributed.launch, (Base.Distributed.LocalManager, Dict, Array{Base.Distributed.WorkerConfig, 1}, Base.Condition))
-precompile(Base.Distributed.set_valid_processes, (Array{Int, 1}, ))
-
-# Speed up repl help
-sprint(Markdown.term, @doc mean)
-sprint(Docs.repl_search, "mean")
-sprint(Docs.repl_corrections, "meen")
-
-# Speed up repl completions
-Base.REPLCompletions.completions("IOBuffer().",11)
-Base.REPLCompletions.completions("max([1],",8)
+precompile(Tuple{typeof(Base.pointer), Array{UInt8, 1}, UInt64})
+precompile(Tuple{typeof(Base.convert), Type{Ptr{Int32}}, Ptr{UInt8}})
+if USE_GPL_LIBS
+precompile(Tuple{typeof(Base.SparseArrays.CHOLMOD.set_print_level), Array{UInt8, 1}, Int64})
+end
+precompile(Tuple{Type{Base.Multimedia.TextDisplay}, Base.TTY})
+precompile(Tuple{typeof(Base._start)})
+precompile(Tuple{typeof(Base.copy!), Array{String, 1}, Int64, Array{Any, 1}, Int64, Int64})
+precompile(Tuple{typeof(Base.empty!), Base.Dict{Int64, Union{Base.Distributed.Worker, Base.Distributed.LocalProcess}}})
+precompile(Tuple{typeof(Core.Inference.isbits), Base.Distributed.DefaultClusterManager})
+precompile(Tuple{typeof(Base.Distributed.init_worker), String, Base.Distributed.DefaultClusterManager})
+precompile(Tuple{typeof(Base.finalizer), Base.TCPServer, typeof(Base.uvfinalize)})
+precompile(Tuple{Type{Base.TCPServer}, Ptr{Void}, Int64})
+precompile(Tuple{typeof(Base.show), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, Int32})
+precompile(Tuple{typeof(Base.print), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.Libc.RawFD})
+precompile(Tuple{typeof(Base.uv_status_string), Base.TCPServer})
+precompile(Tuple{typeof(Base._fd), Base.TCPServer})
+precompile(Tuple{typeof(Base.print), Base.GenericIOBuffer{Array{UInt8, 1}}, Type{Base.TCPServer}, String, Base.Libc.RawFD, String, String, String})
+precompile(Tuple{typeof(Base.print), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.TCPServer})
+precompile(Tuple{typeof(Base.isopen), Base.TCPServer})
+precompile(Tuple{typeof(Base.check_open), Base.TCPServer})
+precompile(Tuple{typeof(Base.unpreserve_handle), Base.TCPServer})
+precompile(Tuple{typeof(Base.stream_wait), Base.TCPServer, Base.Condition})
+precompile(Tuple{Type{Base.TCPServer}})
+precompile(Tuple{typeof(Base.close), Base.TCPServer})
+precompile(Tuple{getfield(Base, Symbol("#kw##listen")), Array{Any, 1}, typeof(Base.listen), Base.TCPServer})
+precompile(Tuple{getfield(Base, Symbol("#kw##listen")), Array{Any, 1}, typeof(Base.listen), Base.InetAddr{Base.IPv4}})
+precompile(Tuple{typeof(Base.ndigits0z), UInt16})
+precompile(Tuple{typeof(Base.dec), UInt16, Int64, Bool})
+precompile(Tuple{typeof(Base.Libc.strerror), Int32})
+precompile(Tuple{typeof(Base.copy!), Array{Any, 1}, Base.KeyIterator{Base.Dict{Any, Any}}})
+precompile(Tuple{typeof(Base.promoteK), Type{Any}})
+precompile(Tuple{typeof(Core.Inference.length), Tuple{Core.Inference.Const, DataType, Core.Inference.Const, Core.Inference.Const}})
+precompile(Tuple{typeof(Core.Inference.getindex), Tuple{Core.Inference.Const, DataType, Core.Inference.Const, Core.Inference.Const}, Int64})
+precompile(Tuple{typeof(Base.sync_add), Task})
+precompile(Tuple{typeof(Core.Inference.getindex), Tuple{Int64, Tuple{Int64, Tuple{}}}, Int64})
+precompile(Tuple{typeof(Base.Distributed.local_remotecall_thunk), typeof(Base.Distributed.set_valid_processes), Tuple{Array{Int64, 1}}, Array{Any, 1}})
+precompile(Tuple{typeof(Base.Distributed.remote_do), typeof(Base.Distributed.set_valid_processes), Base.Distributed.Worker, Array{Int64, 1}})
+precompile(Tuple{typeof(Base.Distributed.remote_do), typeof(Base.Distributed.set_valid_processes), Base.Distributed.LocalProcess, Array{Int64, 1}})
+precompile(Tuple{getfield(Base.Distributed, Symbol("#kw##remote_do")), Array{Any, 1}, typeof(Base.Distributed.remote_do), typeof(Base.Distributed.set_valid_processes), Base.Distributed.Worker, Array{Int64, 1}})
+precompile(Tuple{getfield(Base.Distributed, Symbol("#kw##remote_do")), Array{Any, 1}, typeof(Base.Distributed.remote_do), typeof(Base.Distributed.set_valid_processes), Base.Distributed.LocalProcess, Array{Int64, 1}})
+precompile(Tuple{typeof(Base.Sort.Float.isnan), Base.Order.ForwardOrdering, Float32})
+precompile(Tuple{typeof(Base.Sort.Float.isnan), Base.Order.ForwardOrdering, Float64})
+precompile(Tuple{typeof(Base.Sort.Float.isnan), Base.Order.ReverseOrdering{Base.Order.ForwardOrdering}, Float32})
+precompile(Tuple{typeof(Base.Sort.Float.isnan), Base.Order.ReverseOrdering{Base.Order.ForwardOrdering}, Float64})
+precompile(Tuple{typeof(Base.Sort.Float.issignleft), Base.Order.ForwardOrdering, Float32})
+precompile(Tuple{typeof(Base.Sort.Float.issignleft), Base.Order.ReverseOrdering{Base.Order.ForwardOrdering}, Float32})
+precompile(Tuple{typeof(Base.Sort.Float.issignleft), Base.Order.ForwardOrdering, Float64})
+precompile(Tuple{typeof(Base.Sort.Float.issignleft), Base.Order.ReverseOrdering{Base.Order.ForwardOrdering}, Float64})
+precompile(Tuple{typeof(Core.Inference.isbits), Base.Sort.Float.Left})
+precompile(Tuple{typeof(Base.Sort.Float.left), Base.Order.ForwardOrdering})
+precompile(Tuple{typeof(Base.Sort.Float.left), Base.Order.ReverseOrdering{Base.Order.ForwardOrdering}})
+precompile(Tuple{typeof(Core.Inference.isbits), Base.Sort.Float.Right})
+precompile(Tuple{typeof(Base.Sort.Float.right), Base.Order.ForwardOrdering})
+precompile(Tuple{typeof(Base.Sort.Float.right), Base.Order.ReverseOrdering{Base.Order.ForwardOrdering}})
+precompile(Tuple{typeof(Base.stat), Int64})
+precompile(Tuple{typeof(Base.readbytes_all!), Base.IOStream, Array{UInt8, 1}, Int64})
+precompile(Tuple{typeof(Base.read), Base.IOStream})
+precompile(Tuple{typeof(Base.rstrip), Base.SubString{String}, Array{Char, 1}})
+precompile(Tuple{typeof(Base.lstrip), Base.SubString{String}, Array{Char, 1}})
+precompile(Tuple{getfield(Base, Symbol("#kw##split")), Array{Any, 1}, typeof(Base.split), String, Char})
+precompile(Tuple{getfield(Base, Symbol("#kw##split")), Array{Any, 1}, typeof(Base.split), Base.SubString{String}, Char})
+precompile(Tuple{typeof(Base.map!), typeof(Base.strip), Array{Base.SubString{String}, 1}, Array{Base.SubString{String}, 1}})
+precompile(Tuple{typeof(Base.UTF8proc.isnumber), Base.SubString{String}})
+precompile(Tuple{Type{Core.Inference.Generator{I, F} where F where I}, Type{Core.Inference.Const}, Tuple{Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}}})
+precompile(Tuple{Type{Core.Inference.Generator{Tuple{Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}}, Type{Core.Inference.Const}}}, Type{Core.Inference.Const}, Tuple{Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}}})
+precompile(Tuple{typeof(Core.Inference.convert), Type{Tuple{Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}}}, Tuple{Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}}})
+precompile(Tuple{typeof(Core.Inference.collect), Type{Any}, Core.Inference.Generator{Tuple{Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}}, Type{Core.Inference.Const}}})
+precompile(Tuple{typeof(Core.Inference.iteratorsize), Core.Inference.Generator{Tuple{Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}}, Type{Core.Inference.Const}}})
+precompile(Tuple{typeof(Core.Inference.iteratorsize), Type{Core.Inference.Generator{Tuple{Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}}, Type{Core.Inference.Const}}}})
+precompile(Tuple{typeof(Core.Inference.iteratorsize), Type{Tuple{Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}}}})
+precompile(Tuple{typeof(Core.Inference._collect), Type{Any}, Core.Inference.Generator{Tuple{Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}}, Type{Core.Inference.Const}}, Core.Inference.HasLength})
+precompile(Tuple{typeof(Core.Inference.length), Core.Inference.Generator{Tuple{Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}}, Type{Core.Inference.Const}}})
+precompile(Tuple{typeof(Core.Inference.length), Tuple{Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}}})
+precompile(Tuple{typeof(Core.Inference.copy!), Array{Any, 1}, Core.Inference.Generator{Tuple{Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}}, Type{Core.Inference.Const}}})
+precompile(Tuple{typeof(Core.Inference.start), Core.Inference.Generator{Tuple{Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}}, Type{Core.Inference.Const}}})
+precompile(Tuple{typeof(Core.Inference.start), Tuple{Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}}})
+precompile(Tuple{typeof(Core.Inference.done), Core.Inference.Generator{Tuple{Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}}, Type{Core.Inference.Const}}, Int64})
+precompile(Tuple{typeof(Core.Inference.done), Tuple{Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}}, Int64})
+precompile(Tuple{typeof(Core.Inference.next), Core.Inference.Generator{Tuple{Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}}, Type{Core.Inference.Const}}, Int64})
+precompile(Tuple{typeof(Core.Inference.next), Tuple{Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}}, Int64})
+precompile(Tuple{typeof(Core.Inference.getindex), Tuple{Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}}, Int64})
+precompile(Tuple{typeof(Core.Inference.start), Tuple{Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}, Int64}})
+precompile(Tuple{typeof(Core.Inference.indexed_next), Tuple{Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}, Int64}, Int64, Int64})
+precompile(Tuple{typeof(Core.Inference.getindex), Tuple{Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}, Int64}, Int64})
+precompile(Tuple{typeof(Core.Inference.isbits), Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}})
+precompile(Tuple{typeof(Core.Inference.isbits), Tuple{Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}}})
+precompile(Tuple{Type{Core.Inference.Generator{I, F} where F where I}, Type{QuoteNode}, Tuple{Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}}})
+precompile(Tuple{Type{Core.Inference.Generator{Tuple{Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}}, Type{QuoteNode}}}, Type{QuoteNode}, Tuple{Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}}})
+precompile(Tuple{typeof(Core.Inference.iteratorsize), Type{Core.Inference.Generator{Tuple{Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}}, Type{QuoteNode}}}})
+precompile(Tuple{typeof(Core.Inference._collect), Type{Any}, Core.Inference.Generator{Tuple{Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}}, Type{QuoteNode}}, Core.Inference.HasLength})
+precompile(Tuple{typeof(Core.Inference.length), Core.Inference.Generator{Tuple{Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}}, Type{QuoteNode}}})
+precompile(Tuple{typeof(Core.Inference.copy!), Array{Any, 1}, Core.Inference.Generator{Tuple{Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}}, Type{QuoteNode}}})
+precompile(Tuple{typeof(Core.Inference.start), Core.Inference.Generator{Tuple{Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}}, Type{QuoteNode}}})
+precompile(Tuple{typeof(Core.Inference.done), Core.Inference.Generator{Tuple{Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}}, Type{QuoteNode}}, Int64})
+precompile(Tuple{typeof(Core.Inference.next), Core.Inference.Generator{Tuple{Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}}, Type{QuoteNode}}, Int64})
+precompile(Tuple{typeof(Core.Inference.isbits), Base.DevNullStream})
+precompile(Tuple{typeof(Base.finalizer), Base.Process, typeof(Base.uvfinalize)})
+precompile(Tuple{typeof(Core.Inference.isbits), Tuple{Base.DevNullStream, Bool}})
+precompile(Tuple{Type{Ref{Base.Cstring}}, Array{String, 1}})
+precompile(Tuple{typeof(Core.Inference.eltype), Type{Array{String, 1}}})
+precompile(Tuple{typeof(Base.string), Void, String, DataType})
+precompile(Tuple{typeof(Base.print), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, String, Char})
+precompile(Tuple{typeof(Base.throw_boundserror), Base.UnitRange{Int64}, Tuple{Base.UnitRange{Int64}}})
+precompile(Tuple{typeof(Core.Inference.convert), Type{DataType}, Type{Bool}})
+precompile(Tuple{typeof(Core.Inference.convert), Type{DataType}, Type{Base.OneTo{Int64}}})
+precompile(Tuple{typeof(Core.Inference.length), Tuple{DataType, DataType, typeof(Type), Core.Inference.Const, Core.Inference.Const}})
+precompile(Tuple{typeof(Core.Inference.getindex), Tuple{DataType, DataType, typeof(Type), Core.Inference.Const, Core.Inference.Const}, Int64})
+precompile(Tuple{Type{Core.Inference.Generator{I, F} where F where I}, Type{Core.Inference.Const}, Tuple{Tuple{}, Tuple{}, Int64}})
+precompile(Tuple{Type{Core.Inference.Generator{Tuple{Tuple{}, Tuple{}, Int64}, Type{Core.Inference.Const}}}, Type{Core.Inference.Const}, Tuple{Tuple{}, Tuple{}, Int64}})
+precompile(Tuple{typeof(Core.Inference.convert), Type{Tuple{Tuple{}, Tuple{}, Int64}}, Tuple{Tuple{}, Tuple{}, Int64}})
+precompile(Tuple{typeof(Core.Inference.collect), Type{Any}, Core.Inference.Generator{Tuple{Tuple{}, Tuple{}, Int64}, Type{Core.Inference.Const}}})
+precompile(Tuple{typeof(Core.Inference.iteratorsize), Core.Inference.Generator{Tuple{Tuple{}, Tuple{}, Int64}, Type{Core.Inference.Const}}})
+precompile(Tuple{typeof(Core.Inference.iteratorsize), Type{Core.Inference.Generator{Tuple{Tuple{}, Tuple{}, Int64}, Type{Core.Inference.Const}}}})
+precompile(Tuple{typeof(Core.Inference.iteratorsize), Type{Tuple{Tuple{}, Tuple{}, Int64}}})
+precompile(Tuple{typeof(Core.Inference._collect), Type{Any}, Core.Inference.Generator{Tuple{Tuple{}, Tuple{}, Int64}, Type{Core.Inference.Const}}, Core.Inference.HasLength})
+precompile(Tuple{typeof(Core.Inference.length), Core.Inference.Generator{Tuple{Tuple{}, Tuple{}, Int64}, Type{Core.Inference.Const}}})
+precompile(Tuple{typeof(Core.Inference.length), Tuple{Tuple{}, Tuple{}, Int64}})
+precompile(Tuple{typeof(Core.Inference.copy!), Array{Any, 1}, Core.Inference.Generator{Tuple{Tuple{}, Tuple{}, Int64}, Type{Core.Inference.Const}}})
+precompile(Tuple{typeof(Core.Inference.start), Core.Inference.Generator{Tuple{Tuple{}, Tuple{}, Int64}, Type{Core.Inference.Const}}})
+precompile(Tuple{typeof(Core.Inference.start), Tuple{Tuple{}, Tuple{}, Int64}})
+precompile(Tuple{typeof(Core.Inference.done), Core.Inference.Generator{Tuple{Tuple{}, Tuple{}, Int64}, Type{Core.Inference.Const}}, Int64})
+precompile(Tuple{typeof(Core.Inference.done), Tuple{Tuple{}, Tuple{}, Int64}, Int64})
+precompile(Tuple{typeof(Core.Inference.next), Core.Inference.Generator{Tuple{Tuple{}, Tuple{}, Int64}, Type{Core.Inference.Const}}, Int64})
+precompile(Tuple{typeof(Core.Inference.next), Tuple{Tuple{}, Tuple{}, Int64}, Int64})
+precompile(Tuple{typeof(Core.Inference.getindex), Tuple{Tuple{}, Tuple{}, Int64}, Int64})
+precompile(Tuple{typeof(Core.Inference.isbits), Tuple{Tuple{}, Tuple{}, Int64}})
+precompile(Tuple{Type{Core.Inference.Generator{I, F} where F where I}, Type{QuoteNode}, Tuple{Tuple{}, Tuple{}, Int64}})
+precompile(Tuple{Type{Core.Inference.Generator{Tuple{Tuple{}, Tuple{}, Int64}, Type{QuoteNode}}}, Type{QuoteNode}, Tuple{Tuple{}, Tuple{}, Int64}})
+precompile(Tuple{typeof(Core.Inference.iteratorsize), Type{Core.Inference.Generator{Tuple{Tuple{}, Tuple{}, Int64}, Type{QuoteNode}}}})
+precompile(Tuple{typeof(Core.Inference._collect), Type{Any}, Core.Inference.Generator{Tuple{Tuple{}, Tuple{}, Int64}, Type{QuoteNode}}, Core.Inference.HasLength})
+precompile(Tuple{typeof(Core.Inference.length), Core.Inference.Generator{Tuple{Tuple{}, Tuple{}, Int64}, Type{QuoteNode}}})
+precompile(Tuple{typeof(Core.Inference.copy!), Array{Any, 1}, Core.Inference.Generator{Tuple{Tuple{}, Tuple{}, Int64}, Type{QuoteNode}}})
+precompile(Tuple{typeof(Core.Inference.start), Core.Inference.Generator{Tuple{Tuple{}, Tuple{}, Int64}, Type{QuoteNode}}})
+precompile(Tuple{typeof(Core.Inference.done), Core.Inference.Generator{Tuple{Tuple{}, Tuple{}, Int64}, Type{QuoteNode}}, Int64})
+precompile(Tuple{typeof(Core.Inference.next), Core.Inference.Generator{Tuple{Tuple{}, Tuple{}, Int64}, Type{QuoteNode}}, Int64})
+precompile(Tuple{Type{Core.Inference.Generator{I, F} where F where I}, Type{Core.Inference.Const}, Tuple{Tuple{}, Tuple{}}})
+precompile(Tuple{Type{Core.Inference.Generator{Tuple{Tuple{}, Tuple{}}, Type{Core.Inference.Const}}}, Type{Core.Inference.Const}, Tuple{Tuple{}, Tuple{}}})
+precompile(Tuple{typeof(Core.Inference.convert), Type{Tuple{Tuple{}, Tuple{}}}, Tuple{Tuple{}, Tuple{}}})
+precompile(Tuple{typeof(Core.Inference.collect), Type{Any}, Core.Inference.Generator{Tuple{Tuple{}, Tuple{}}, Type{Core.Inference.Const}}})
+precompile(Tuple{typeof(Core.Inference.iteratorsize), Core.Inference.Generator{Tuple{Tuple{}, Tuple{}}, Type{Core.Inference.Const}}})
+precompile(Tuple{typeof(Core.Inference.iteratorsize), Type{Core.Inference.Generator{Tuple{Tuple{}, Tuple{}}, Type{Core.Inference.Const}}}})
+precompile(Tuple{typeof(Core.Inference.iteratorsize), Type{Tuple{Tuple{}, Tuple{}}}})
+precompile(Tuple{typeof(Core.Inference._collect), Type{Any}, Core.Inference.Generator{Tuple{Tuple{}, Tuple{}}, Type{Core.Inference.Const}}, Core.Inference.HasLength})
+precompile(Tuple{typeof(Core.Inference.length), Core.Inference.Generator{Tuple{Tuple{}, Tuple{}}, Type{Core.Inference.Const}}})
+precompile(Tuple{typeof(Core.Inference.length), Tuple{Tuple{}, Tuple{}}})
+precompile(Tuple{typeof(Core.Inference.copy!), Array{Any, 1}, Core.Inference.Generator{Tuple{Tuple{}, Tuple{}}, Type{Core.Inference.Const}}})
+precompile(Tuple{typeof(Core.Inference.start), Core.Inference.Generator{Tuple{Tuple{}, Tuple{}}, Type{Core.Inference.Const}}})
+precompile(Tuple{typeof(Core.Inference.start), Tuple{Tuple{}, Tuple{}}})
+precompile(Tuple{typeof(Core.Inference.done), Core.Inference.Generator{Tuple{Tuple{}, Tuple{}}, Type{Core.Inference.Const}}, Int64})
+precompile(Tuple{typeof(Core.Inference.done), Tuple{Tuple{}, Tuple{}}, Int64})
+precompile(Tuple{typeof(Core.Inference.next), Core.Inference.Generator{Tuple{Tuple{}, Tuple{}}, Type{Core.Inference.Const}}, Int64})
+precompile(Tuple{typeof(Core.Inference.next), Tuple{Tuple{}, Tuple{}}, Int64})
+precompile(Tuple{typeof(Core.Inference.getindex), Tuple{Tuple{}, Tuple{}}, Int64})
+precompile(Tuple{Type{Core.Inference.Generator{I, F} where F where I}, Type{QuoteNode}, Tuple{Tuple{}, Tuple{}}})
+precompile(Tuple{Type{Core.Inference.Generator{Tuple{Tuple{}, Tuple{}}, Type{QuoteNode}}}, Type{QuoteNode}, Tuple{Tuple{}, Tuple{}}})
+precompile(Tuple{typeof(Core.Inference.iteratorsize), Type{Core.Inference.Generator{Tuple{Tuple{}, Tuple{}}, Type{QuoteNode}}}})
+precompile(Tuple{typeof(Core.Inference._collect), Type{Any}, Core.Inference.Generator{Tuple{Tuple{}, Tuple{}}, Type{QuoteNode}}, Core.Inference.HasLength})
+precompile(Tuple{typeof(Core.Inference.length), Core.Inference.Generator{Tuple{Tuple{}, Tuple{}}, Type{QuoteNode}}})
+precompile(Tuple{typeof(Core.Inference.copy!), Array{Any, 1}, Core.Inference.Generator{Tuple{Tuple{}, Tuple{}}, Type{QuoteNode}}})
+precompile(Tuple{typeof(Core.Inference.start), Core.Inference.Generator{Tuple{Tuple{}, Tuple{}}, Type{QuoteNode}}})
+precompile(Tuple{typeof(Core.Inference.done), Core.Inference.Generator{Tuple{Tuple{}, Tuple{}}, Type{QuoteNode}}, Int64})
+precompile(Tuple{typeof(Core.Inference.next), Core.Inference.Generator{Tuple{Tuple{}, Tuple{}}, Type{QuoteNode}}, Int64})
+precompile(Tuple{typeof(Core.Inference.length), Tuple{DataType, DataType, DataType, Core.Inference.Const, Core.Inference.Const}})
+precompile(Tuple{typeof(Core.Inference.getindex), Tuple{DataType, DataType, DataType, Core.Inference.Const, Core.Inference.Const}, Int64})
+precompile(Tuple{typeof(Core.Inference.length), Tuple{DataType, DataType, typeof(Type), typeof(Type), Core.Inference.Const}})
+precompile(Tuple{typeof(Core.Inference.getindex), Tuple{DataType, DataType, typeof(Type), typeof(Type), Core.Inference.Const}, Int64})
+precompile(Tuple{typeof(Core.Inference.length), Tuple{DataType, DataType, DataType, DataType, Core.Inference.Const}})
+precompile(Tuple{typeof(Core.Inference.getindex), Tuple{DataType, DataType, DataType, DataType, Core.Inference.Const}, Int64})
+precompile(Tuple{typeof(Base.unpreserve_handle), Base.Process})
+precompile(Tuple{typeof(Base.stream_wait), Base.Process, Base.Condition})
+precompile(Tuple{typeof(Base.kill), Base.Process, Int64})
+precompile(Tuple{typeof(Base.banner), Base.Terminals.TTYTerminal})
+precompile(Tuple{typeof(Core.Inference.isbits), Base.Dict{Any, Any}})
+precompile(Tuple{typeof(Base.answer_color)})
+precompile(Tuple{typeof(Base.input_color)})
+precompile(Tuple{typeof(Base.show_circular), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, Tuple{}})
+precompile(Tuple{typeof(Base.show_delim_array), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, Tuple{}, Char, Char, Char, Bool, Int64, Int64})
+precompile(Tuple{typeof(Base.throw_boundserror), Array{Base.StackTraces.StackFrame, 1}, Tuple{Base.UnitRange{Int64}}})
+precompile(Tuple{typeof(Base.splice!), Array{Base.StackTraces.StackFrame, 1}, Base.UnitRange{Int64}, Array{Any, 1}})
+precompile(Tuple{typeof(Base.REPL.ip_matches_func), Ptr{Void}, Symbol})
+precompile(Tuple{typeof(Base.throw_boundserror), Array{Ptr{Void}, 1}, Tuple{Base.UnitRange{Int64}}})
+precompile(Tuple{typeof(Base.unsafe_copy!), Array{Ptr{Void}, 1}, Int64, Array{Ptr{Void}, 1}, Int64, Int64})
+precompile(Tuple{Type{Base.Channel{Any}}, Int64})
+precompile(Tuple{typeof(Base.rsearch), String, UInt8, Int64})
+precompile(Tuple{typeof(Base.rsearch), String, Char, Int64})
+precompile(Tuple{typeof(Base.rsearch), Array{UInt8, 1}, UInt8, Int64})
+precompile(Tuple{typeof(Base._rsearchindex), Array{UInt8, 1}, Array{UInt8, 1}, Int64})
+precompile(Tuple{typeof(Base._rsearch), Array{UInt8, 1}, Array{UInt8, 1}, Int64})
+precompile(Tuple{typeof(Base.rsearch), Array{Int8, 1}, UInt8, Int64})
+precompile(Tuple{typeof(Base._rsearchindex), Array{Int8, 1}, Array{UInt8, 1}, Int64})
+precompile(Tuple{typeof(Base._rsearch), Array{Int8, 1}, Array{UInt8, 1}, Int64})
+precompile(Tuple{typeof(Base.rsearch), Array{UInt8, 1}, Char, Int64})
+precompile(Tuple{typeof(Base.rsearch), Array{Int8, 1}, Char, Int64})
+precompile(Tuple{typeof(Base.splice!), Array{Base.Multimedia.Display, 1}, Int64, Array{Any, 1}})
+precompile(Tuple{typeof(Core.Inference.isbits), Base.LineEdit.EmptyCompletionProvider})
+precompile(Tuple{typeof(Core.Inference.isbits), Base.LineEdit.EmptyHistoryProvider})
+precompile(Tuple{typeof(Base._setindex!), Base.Dict{Symbol, Any}, Base.LineEdit.Prompt, Symbol, Int64})
+precompile(Tuple{typeof(Base.sizehint!), Base.Dict{Symbol, Any}, Int64})
+precompile(Tuple{typeof(Base.setindex!), Base.Dict{Symbol, Any}, Base.LineEdit.Prompt, Symbol})
+precompile(Tuple{typeof(Base.copy!), Base.IndexLinear, Array{Symbol, 1}, Base.IndexLinear, Array{UInt8, 1}})
+precompile(Tuple{getfield(Base, Symbol("#kw##readline")), Array{Any, 1}, typeof(Base.readline), Base.IOStream})
+precompile(Tuple{Type{Core.Inference.Generator{I, F} where F where I}, Type{Core.Inference.Const}, Tuple{Void}})
+precompile(Tuple{Type{Core.Inference.Generator{Tuple{Void}, Type{Core.Inference.Const}}}, Type{Core.Inference.Const}, Tuple{Void}})
+precompile(Tuple{typeof(Core.Inference.convert), Type{Tuple{Void}}, Tuple{Void}})
+precompile(Tuple{typeof(Core.Inference.collect), Type{Any}, Core.Inference.Generator{Tuple{Void}, Type{Core.Inference.Const}}})
+precompile(Tuple{typeof(Core.Inference.iteratorsize), Core.Inference.Generator{Tuple{Void}, Type{Core.Inference.Const}}})
+precompile(Tuple{typeof(Core.Inference.iteratorsize), Type{Core.Inference.Generator{Tuple{Void}, Type{Core.Inference.Const}}}})
+precompile(Tuple{typeof(Core.Inference.iteratorsize), Type{Tuple{Void}}})
+precompile(Tuple{typeof(Core.Inference._collect), Type{Any}, Core.Inference.Generator{Tuple{Void}, Type{Core.Inference.Const}}, Core.Inference.HasLength})
+precompile(Tuple{typeof(Core.Inference.length), Core.Inference.Generator{Tuple{Void}, Type{Core.Inference.Const}}})
+precompile(Tuple{typeof(Core.Inference.length), Tuple{Void}})
+precompile(Tuple{typeof(Core.Inference.copy!), Array{Any, 1}, Core.Inference.Generator{Tuple{Void}, Type{Core.Inference.Const}}})
+precompile(Tuple{typeof(Core.Inference.start), Core.Inference.Generator{Tuple{Void}, Type{Core.Inference.Const}}})
+precompile(Tuple{typeof(Core.Inference.start), Tuple{Void}})
+precompile(Tuple{typeof(Core.Inference.done), Core.Inference.Generator{Tuple{Void}, Type{Core.Inference.Const}}, Int64})
+precompile(Tuple{typeof(Core.Inference.done), Tuple{Void}, Int64})
+precompile(Tuple{typeof(Core.Inference.next), Core.Inference.Generator{Tuple{Void}, Type{Core.Inference.Const}}, Int64})
+precompile(Tuple{typeof(Core.Inference.next), Tuple{Void}, Int64})
+precompile(Tuple{typeof(Core.Inference.getindex), Tuple{Void}, Int64})
+precompile(Tuple{typeof(Base.join), Base.GenericIOBuffer{Array{UInt8, 1}}, Array{String, 1}, Char})
+precompile(Tuple{Type{Core.Inference.Generator{I, F} where F where I}, Type{Core.Inference.Const}, Tuple{String, typeof(Base.info)}})
+precompile(Tuple{Type{Core.Inference.Generator{Tuple{String, typeof(Base.info)}, Type{Core.Inference.Const}}}, Type{Core.Inference.Const}, Tuple{String, typeof(Base.info)}})
+precompile(Tuple{typeof(Core.Inference.convert), Type{Tuple{String, typeof(Base.info)}}, Tuple{String, typeof(Base.info)}})
+precompile(Tuple{typeof(Core.Inference.collect), Type{Any}, Core.Inference.Generator{Tuple{String, typeof(Base.info)}, Type{Core.Inference.Const}}})
+precompile(Tuple{typeof(Core.Inference.iteratorsize), Core.Inference.Generator{Tuple{String, typeof(Base.info)}, Type{Core.Inference.Const}}})
+precompile(Tuple{typeof(Core.Inference.iteratorsize), Type{Core.Inference.Generator{Tuple{String, typeof(Base.info)}, Type{Core.Inference.Const}}}})
+precompile(Tuple{typeof(Core.Inference.iteratorsize), Type{Tuple{String, typeof(Base.info)}}})
+precompile(Tuple{typeof(Core.Inference._collect), Type{Any}, Core.Inference.Generator{Tuple{String, typeof(Base.info)}, Type{Core.Inference.Const}}, Core.Inference.HasLength})
+precompile(Tuple{typeof(Core.Inference.length), Core.Inference.Generator{Tuple{String, typeof(Base.info)}, Type{Core.Inference.Const}}})
+precompile(Tuple{typeof(Core.Inference.length), Tuple{String, typeof(Base.info)}})
+precompile(Tuple{typeof(Core.Inference.copy!), Array{Any, 1}, Core.Inference.Generator{Tuple{String, typeof(Base.info)}, Type{Core.Inference.Const}}})
+precompile(Tuple{typeof(Core.Inference.start), Core.Inference.Generator{Tuple{String, typeof(Base.info)}, Type{Core.Inference.Const}}})
+precompile(Tuple{typeof(Core.Inference.start), Tuple{String, typeof(Base.info)}})
+precompile(Tuple{typeof(Core.Inference.done), Core.Inference.Generator{Tuple{String, typeof(Base.info)}, Type{Core.Inference.Const}}, Int64})
+precompile(Tuple{typeof(Core.Inference.done), Tuple{String, typeof(Base.info)}, Int64})
+precompile(Tuple{typeof(Core.Inference.next), Core.Inference.Generator{Tuple{String, typeof(Base.info)}, Type{Core.Inference.Const}}, Int64})
+precompile(Tuple{typeof(Core.Inference.next), Tuple{String, typeof(Base.info)}, Int64})
+precompile(Tuple{typeof(Core.Inference.getindex), Tuple{String, typeof(Base.info)}, Int64})
+precompile(Tuple{typeof(Core.Inference.start), Tuple{String, Int64}})
+precompile(Tuple{typeof(Core.Inference.start), Tuple{typeof(Base.info), Int64}})
+precompile(Tuple{typeof(Core.Inference.indexed_next), Tuple{typeof(Base.info), Int64}, Int64, Int64})
+precompile(Tuple{typeof(Core.Inference.getindex), Tuple{typeof(Base.info), Int64}, Int64})
+precompile(Tuple{typeof(Base.print), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, Base.SubString{String}, Char})
+precompile(Tuple{typeof(Base.sizehint!), Base.Dict{Any, Any}, Int64})
+precompile(Tuple{typeof(Base.LineEdit.getEntry), Base.Dict{Char, Any}, Char})
+precompile(Tuple{typeof(Base.LineEdit.getEntry), Base.Dict{Char, Any}, String})
+precompile(Tuple{typeof(Base.unsafe_copy!), Array{Base.Dict{Any, Any}, 1}, Int64, Array{Base.Dict{Any, Any}, 1}, Int64, Int64})
+precompile(Tuple{typeof(Base.copy!), Array{Base.Dict{Any, Any}, 1}, Int64, Array{Base.Dict{Any, Any}, 1}, Int64, Int64})
+precompile(Tuple{typeof(Base.promote_type), Type{Base.LineEdit.HistoryPrompt{Base.REPL.REPLHistoryProvider}}, Type{Base.LineEdit.PrefixHistoryPrompt{Base.REPL.REPLHistoryProvider}}})
+precompile(Tuple{typeof(Base.promote_rule), Type{Base.LineEdit.HistoryPrompt{Base.REPL.REPLHistoryProvider}}, Type{Base.LineEdit.PrefixHistoryPrompt{Base.REPL.REPLHistoryProvider}}})
+precompile(Tuple{typeof(Base.promote_rule), Type{Base.LineEdit.PrefixHistoryPrompt{Base.REPL.REPLHistoryProvider}}, Type{Base.LineEdit.HistoryPrompt{Base.REPL.REPLHistoryProvider}}})
+precompile(Tuple{typeof(Base.promote_result), Type{Base.LineEdit.HistoryPrompt{Base.REPL.REPLHistoryProvider}}, Type{Base.LineEdit.PrefixHistoryPrompt{Base.REPL.REPLHistoryProvider}}, Type{Union{}}, Type{Union{}}})
+precompile(Tuple{typeof(Base.promote_type), Type{Base.LineEdit.Prompt}, Type{Base.LineEdit.TextInterface}})
+precompile(Tuple{typeof(Base.promote_rule), Type{Base.LineEdit.Prompt}, Type{Base.LineEdit.TextInterface}})
+precompile(Tuple{typeof(Base.promote_rule), Type{Base.LineEdit.TextInterface}, Type{Base.LineEdit.Prompt}})
+precompile(Tuple{typeof(Base.promote_result), Type{Base.LineEdit.Prompt}, Type{Base.LineEdit.TextInterface}, Type{Union{}}, Type{Union{}}})
+precompile(Tuple{typeof(Base.setindex!), Array{Base.LineEdit.TextInterface, 1}, Base.LineEdit.Prompt, Int64})
+precompile(Tuple{typeof(Base.setindex!), Array{Base.LineEdit.TextInterface, 1}, Base.LineEdit.HistoryPrompt{Base.REPL.REPLHistoryProvider}, Int64})
+precompile(Tuple{typeof(Base.setindex!), Array{Base.LineEdit.TextInterface, 1}, Base.LineEdit.PrefixHistoryPrompt{Base.REPL.REPLHistoryProvider}, Int64})
+precompile(Tuple{typeof(Base.copy!), Array{Base.LineEdit.TextInterface, 1}, Tuple{Base.LineEdit.Prompt, Base.LineEdit.Prompt, Base.LineEdit.Prompt, Base.LineEdit.HistoryPrompt{Base.REPL.REPLHistoryProvider}, Base.LineEdit.PrefixHistoryPrompt{Base.REPL.REPLHistoryProvider}}})
+precompile(Tuple{typeof(Base.print), Base.GenericIOBuffer{Array{UInt8, 1}}, String, Int64, String, Bool})
+precompile(Tuple{typeof(Base.uv_status_string), Base.UDPSocket})
+precompile(Tuple{typeof(Base.Terminals.cmove_up), Base.Terminals.TerminalBuffer, Int64})
+precompile(Tuple{typeof(Base.Terminals.cmove_down), Base.Terminals.TerminalBuffer, Int64})
+precompile(Tuple{typeof(Base.readuntil), Base.GenericIOBuffer{Array{UInt8, 1}}, UInt8})
+precompile(Tuple{typeof(Base.Terminals.cmove_right), Base.Terminals.TerminalBuffer, Int64})
+precompile(Tuple{typeof(Base.LineEdit._clear_input_area), Base.Terminals.TerminalBuffer, Base.LineEdit.InputAreaState})
+precompile(Tuple{typeof(Base.seek), Base.GenericIOBuffer{Array{UInt8, 1}}, Int64})
+precompile(Tuple{getfield(Base, Symbol("#kw##readline")), Array{Any, 1}, typeof(Base.readline), Base.GenericIOBuffer{Array{UInt8, 1}}})
+precompile(Tuple{typeof(Base.endswith), String, String})
+precompile(Tuple{getfield(Base, Symbol("#kw##readline")), Array{Any, 1}, typeof(Base.readline), Base.Terminals.TerminalBuffer})
+precompile(Tuple{typeof(Base.LineEdit.write_prompt), Base.Terminals.TerminalBuffer, Base.LineEdit.Prompt})
+precompile(Tuple{getfield(Base.LineEdit, Symbol("#kw##refresh_multi_line")), Array{Any, 1}, typeof(Base.LineEdit.refresh_multi_line), Base.Terminals.TerminalBuffer, Base.Terminals.TerminalBuffer, Base.Terminals.TerminalBuffer, Base.LineEdit.InputAreaState, String})
+precompile(Tuple{typeof(Base.:(==)), Array{Char, 1}, Array{Char, 1}})
+precompile(Tuple{typeof(Base.LineEdit.update_key_repeats), Base.LineEdit.MIState, Array{Char, 1}})
+precompile(Tuple{typeof(Base.LineEdit.reset_state), Base.LineEdit.MIState})
+precompile(Tuple{Type{Base.Dict{Any, Any}}, Array{Any, 1}})
+precompile(Tuple{typeof(Base.Distributed.default_addprocs_params)})
+precompile(Tuple{typeof(Base.Distributed.topology), Symbol})
+precompile(Tuple{typeof(Base.shift!), Array{Base.Distributed.WorkerConfig, 1}})
+precompile(Tuple{typeof(Base.sync_end)})
+precompile(Tuple{typeof(Base.wait), Task})
+precompile(Tuple{typeof(Base.Distributed.workers)})
+precompile(Tuple{typeof(Base.sort!), Array{Int64, 1}})
+precompile(Tuple{typeof(Base.lock), Base.ReentrantLock})
+precompile(Tuple{getfield(Base.Distributed, Symbol("#kw##addprocs_locked")), Array{Any, 1}, typeof(Base.Distributed.addprocs_locked), Base.Distributed.SSHManager})
+precompile(Tuple{typeof(Base.unlock), Base.ReentrantLock})
+precompile(Tuple{typeof(Base.Distributed.check_addprocs_args), Array{Any, 1}})
+precompile(Tuple{Type{Base.Distributed.SSHManager}, Array{Any, 1}})
+precompile(Tuple{getfield(Base.Distributed, Symbol("#kw##addprocs")), Array{Any, 1}, typeof(Base.Distributed.addprocs), Base.Distributed.SSHManager})
+precompile(Tuple{typeof(Base.cmd_gen), Tuple{Tuple{}}})
+precompile(Tuple{typeof(Base.extrema), Array{Int64, 1}})
+precompile(Tuple{typeof(Base.Sort.sort_int_range!), Array{Int64, 1}, Int64, Int64})
+precompile(Tuple{typeof(Core.Inference.isbits), Base.Sort.QuickSortAlg})
+precompile(Tuple{getfield(Base.Distributed, Symbol("#kw##addprocs_locked")), Array{Any, 1}, typeof(Base.Distributed.addprocs_locked), Base.Distributed.LocalManager})
+precompile(Tuple{typeof(Base.ht_keyindex2), Base.Dict{Any, Any}, Symbol})
+precompile(Tuple{typeof(Base._setindex!), Base.Dict{Any, Any}, Symbol, Symbol, Int64})
+precompile(Tuple{Type{Base.Dict{Any, Any}}, Base.Pair{Symbol, Symbol}, Base.Pair{Symbol, String}, Base.Pair{Symbol, String}, Base.Pair{Symbol, Base.Cmd}, Base.Pair{Symbol, Bool}})
+precompile(Tuple{getfield(Base.Distributed, Symbol("#kw##addprocs")), Array{Any, 1}, typeof(Base.Distributed.addprocs), Base.Distributed.LocalManager})
+precompile(Tuple{typeof(Base.listenany), Base.IPv4, UInt16})
+precompile(Tuple{typeof(Base.Distributed.check_master_connect)})
+precompile(Tuple{typeof(Base.load_machine_file), String})
+precompile(Tuple{typeof(Base.load_juliarc)})
+precompile(Tuple{typeof(Base.shift!), Array{String, 1}})
+precompile(Tuple{typeof(Base.print), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, String, String, Char})
+precompile(Tuple{typeof(Base.read), Base.GenericIOBuffer{Array{UInt8, 1}}, Type{Char}})
+precompile(Tuple{typeof(Base.write), Base.Terminals.TerminalBuffer, Array{UInt8, 1}})
+precompile(Tuple{typeof(Base.LineEdit.keymap), Array{Base.Dict{Any, Any}, 1}})
+precompile(Tuple{typeof(Base.LineEdit.add_specialisations), Base.Dict{Char, Any}, Base.Dict{Char, Any}, Int64})
+precompile(Tuple{typeof(Base.setindex!), Base.Dict{Char, Any}, Base.Dict{Char, Any}, Char})
+precompile(Tuple{typeof(Base.ht_keyindex2), Base.Dict{Char, Any}, Char})
+precompile(Tuple{typeof(Base._setindex!), Base.Dict{Char, Any}, Base.Dict{Char, Any}, Char, Int64})
+precompile(Tuple{typeof(Base.setdiff), Base.KeyIterator{Base.Dict{Any, Any}}, Base.KeyIterator{Base.Dict{Any, Any}}})
+precompile(Tuple{typeof(Base.LineEdit.keymap_merge), Base.Dict{Char, Any}, Base.Dict{Any, Any}})
+precompile(Tuple{typeof(Base.LineEdit.postprocess!), Base.Dict{Char, Any}})
+precompile(Tuple{typeof(Base.LineEdit.keymap_unify), Array{Base.Dict{Any, Any}, 1}})
+precompile(Tuple{typeof(Base.LineEdit.validate_keymap), Base.Dict{Char, Any}})
+precompile(Tuple{Type{Expr}, Symbol, GlobalRef, SSAValue, SSAValue, SSAValue, SSAValue, SSAValue, SSAValue, SSAValue, SSAValue, SSAValue, SSAValue, SSAValue, SSAValue, SSAValue, SSAValue, SSAValue, SSAValue, SSAValue, SSAValue, SSAValue, SSAValue, SSAValue, SSAValue, SSAValue, SSAValue, SSAValue, SSAValue, SSAValue, SSAValue, SSAValue, SSAValue, SSAValue, SSAValue, SSAValue, SSAValue, SSAValue, SSAValue, SSAValue, SSAValue, SSAValue})
+precompile(Tuple{typeof(Core.Inference.isbits), Tuple{String, typeof(Base.info)}})
+precompile(Tuple{typeof(Base.:(==)), Void, String})
+precompile(Tuple{Type{Symbol}, Void})
+precompile(Tuple{Type{Symbol}, Base.SubString{String}})
+precompile(Tuple{typeof(Core.Inference.isbits), Base.REPL.REPLCompletionProvider})
+precompile(Tuple{getfield(Core, Symbol("#kw#Type")), Array{Any, 1}, Type{Base.LineEdit.Prompt}, String})
+precompile(Tuple{typeof(Core.Inference.isbits), Base.REPL.ShellCompletionProvider})
+precompile(Tuple{Type{Base.Dict{Symbol, Any}}, Base.Pair{Symbol, Base.LineEdit.Prompt}, Base.Pair{Symbol, Base.LineEdit.Prompt}, Base.Pair{Symbol, Base.LineEdit.Prompt}})
+precompile(Tuple{Type{Base.REPL.REPLHistoryProvider}, Base.Dict{Symbol, Any}})
+precompile(Tuple{typeof(Base.REPL.find_hist_file)})
+precompile(Tuple{typeof(Base.REPL.history_reset_state), Base.REPL.REPLHistoryProvider})
+precompile(Tuple{typeof(Base.LineEdit.setup_search_keymap), Base.REPL.REPLHistoryProvider})
+precompile(Tuple{typeof(Core.Inference.isbits), Base.REPL.LatexCompletions})
+precompile(Tuple{typeof(Base.LineEdit.setup_prefix_keymap), Base.REPL.REPLHistoryProvider, Base.LineEdit.Prompt})
+precompile(Tuple{typeof(Base.getindex), Type{Base.Dict{Any, Any}}, Base.Dict{Any, Any}, Base.Dict{Any, Any}, Base.Dict{Any, Any}, Base.Dict{Any, Any}, Base.Dict{Any, Any}, Base.Dict{Any, Any}})
+precompile(Tuple{typeof(Base.prepend!), Array{Base.Dict{Any, Any}, 1}, Array{Base.Dict{Any, Any}, 1}})
+precompile(Tuple{typeof(Base.REPL.mode_keymap), Base.LineEdit.Prompt})
+precompile(Tuple{typeof(Core.Inference.isbits), Array{Base.Multimedia.Display, 1}})
+precompile(Tuple{typeof(Base.Multimedia.popdisplay), Base.REPL.REPLDisplay{Base.REPL.LineEditREPL}})
+precompile(Tuple{Type{String}, Base.BitArray{1}})
+precompile(Tuple{typeof(Base.REPL.ends_with_semicolon), String})
+precompile(Tuple{typeof(Core.Inference.isbits), Tuple{Void, Int64}})
+precompile(Tuple{typeof(Base.Multimedia.popdisplay), Base.REPL.REPLDisplay{Base.REPL.BasicREPL}})
+precompile(Tuple{typeof(Base.Multimedia.popdisplay), Base.REPL.REPLDisplay{Base.REPL.StreamREPL}})
+precompile(Tuple{typeof(Base.REPL.start_repl_backend), Base.Channel{Any}, Base.Channel{Any}})
+precompile(Tuple{typeof(Base._collect), Array{Ptr{Void}, 1}, Base.Generator{Array{Ptr{Void}, 1}, typeof(Base.StackTraces.lookup)}, Base.EltypeUnknown, Base.HasShape})
+precompile(Tuple{typeof(Base.shift!), Array{Base.StackTraces.StackFrame, 1}})
+precompile(Tuple{typeof(Base.StackTraces.stacktrace), Array{Ptr{Void}, 1}, Bool})
+precompile(Tuple{typeof(Base.success), Base.Process})
+precompile(Tuple{typeof(Base.mapreduce_impl), typeof(Base.success), typeof(Base.:(&)), Array{Base.Process, 1}, Int64, Int64, Int64})
+precompile(Tuple{typeof(Base.string), Base.Cmd})
+precompile(Tuple{typeof(Base.test_success), Base.Process})
+precompile(Tuple{typeof(Base._mapreduce), typeof(Base.success), typeof(Base.:(&)), Base.IndexLinear, Array{Base.Process, 1}})
+precompile(Tuple{typeof(Core.Inference.isbits), Tuple{String, String, String}})
+precompile(Tuple{getfield(Base, Symbol("#kw##shell_escape")), Array{Any, 1}, typeof(Base.shell_escape), Base.Cmd})
+precompile(Tuple{typeof(Base.show), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.Cmd})
+precompile(Tuple{typeof(Base.print), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.Cmd})
+precompile(Tuple{typeof(Core.Inference.isbits), Ptr{Void}})
+precompile(Tuple{typeof(Base.cconvert), Type{Ptr{Base.Cstring}}, Ptr{Void}})
+precompile(Tuple{typeof(Base.cconvert), Type{Ptr{Base.Cstring}}, Void})
+precompile(Tuple{typeof(Base.cconvert), Type{Base.Cstring}, Ptr{Void}})
+precompile(Tuple{typeof(Base.unsafe_convert), Type{Ptr{Base.Cstring}}, Ptr{Void}})
+precompile(Tuple{typeof(Base.unsafe_convert), Type{Ptr{Base.Cstring}}, Base.RefArray{Base.Cstring, Array{Base.Cstring, 1}, Any}})
+precompile(Tuple{Type{Base.Process}, Base.Cmd, Ptr{Void}, Base.DevNullStream, Base.DevNullStream, Base.DevNullStream})
+precompile(Tuple{getfield(Base, Symbol("#kw##spawn")), Array{Any, 1}, typeof(Base.spawn), Base.Cmd, Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}})
+precompile(Tuple{typeof(Core.Inference.isbits), Tuple{Tuple{String}, Tuple{String}, Tuple{String}}})
+precompile(Tuple{typeof(Base.cmd_gen), Tuple{Tuple{String}, Tuple{String}, Tuple{String}}})
+precompile(Tuple{typeof(Base.append!), Array{String, 1}, Array{Any, 1}})
+precompile(Tuple{typeof(Base.process_options), Base.JLOptions})
+precompile(Tuple{typeof(Base.Terminals.hascolor), Base.Terminals.TTYTerminal})
+precompile(Tuple{Type{Base.REPL.LineEditREPL}, Base.Terminals.TTYTerminal, Bool})
+precompile(Tuple{typeof(Base.close), Base.IOStream})
+precompile(Tuple{typeof(Base._atexit)})
+precompile(Tuple{typeof(Base.Distributed.terminate_all_workers)})
+precompile(Tuple{getfield(Base, Symbol("#kw##notify")), Array{Any, 1}, typeof(Base.notify), Base.Condition, Void})
+precompile(Tuple{typeof(Base.Distributed.local_remotecall_thunk), typeof(Base.exit), Tuple{}, Array{Any, 1}})
+precompile(Tuple{typeof(Base.Distributed.remote_do), typeof(Base.exit), Base.Distributed.Worker})
+precompile(Tuple{typeof(Base.Distributed.remote_do), typeof(Base.exit), Base.Distributed.LocalProcess})
+precompile(Tuple{getfield(Base.Distributed, Symbol("#kw##remote_do")), Array{Any, 1}, typeof(Base.Distributed.remote_do), typeof(Base.exit), Base.Distributed.Worker})
+precompile(Tuple{getfield(Base.Distributed, Symbol("#kw##remote_do")), Array{Any, 1}, typeof(Base.Distributed.remote_do), typeof(Base.exit), Base.Distributed.LocalProcess})
+precompile(Tuple{typeof(Base.Distributed.set_worker_state), Base.Distributed.Worker, Base.Distributed.WorkerState})
+precompile(Tuple{typeof(Base.Distributed.set_worker_state), Base.Distributed.LocalProcess, Base.Distributed.WorkerState})
+precompile(Tuple{getfield(Base.Distributed, Symbol("#kw##rmprocs")), Array{Any, 1}, typeof(Base.Distributed.rmprocs), Array{Int64, 1}})
+precompile(Tuple{typeof(Base.Distributed.interrupt), Array{Int64, 1}})
+precompile(Tuple{typeof(Base.uvfinalize), Base.TTY})
+precompile(Tuple{typeof(Base.uv_status_string), Base.TTY})
+precompile(Tuple{typeof(Base._fd), Base.TTY})
+precompile(Tuple{typeof(Base.print), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.TTY})
+precompile(Tuple{typeof(Base.unpreserve_handle), Base.TTY})
+precompile(Tuple{typeof(Base.isopen), Base.TTY})
+precompile(Tuple{typeof(Base.stream_wait), Base.TTY, Base.Condition})
+precompile(Tuple{typeof(Base.close), Base.TTY})
+precompile(Tuple{typeof(Base.unsafe_store!), Ptr{Int32}, Int64})
+precompile(Tuple{Type{Base.Terminals.TTYTerminal}, String, Base.TTY, Base.TTY, Base.IOStream})
+precompile(Tuple{typeof(Base.unsafe_write), Base.TTY, Ptr{UInt8}, UInt64})
+precompile(Tuple{typeof(Base.unpreserve_handle), Task})
+precompile(Tuple{typeof(Base.check_open), Base.TTY})
+precompile(Tuple{typeof(Base.stream_wait), Task})
+precompile(Tuple{typeof(Base.uv_write), Base.TTY, Ptr{UInt8}, UInt64})
+precompile(Tuple{typeof(Base.flush), Base.TTY})
+precompile(Tuple{typeof(Base.Distributed.flush_gc_msgs)})
+precompile(Tuple{typeof(Base.__atreplinit), Base.REPL.LineEditREPL})
+precompile(Tuple{typeof(Base.:(==)), Base.Multimedia.TextDisplay, Base.REPL.REPLDisplay{Base.REPL.LineEditREPL}})
+precompile(Tuple{typeof(Base.:(==)), Base.REPL.REPLDisplay{Base.REPL.LineEditREPL}, Base.REPL.REPLDisplay{Base.REPL.LineEditREPL}})
+precompile(Tuple{typeof(Base.REPL.hist_from_file), Base.REPL.REPLHistoryProvider, Base.IOStream, String})
+precompile(Tuple{typeof(Base.REPL.hist_getline), Base.IOStream})
+precompile(Tuple{typeof(Base.push!), Array{String, 1}, Base.SubString{String}})
+precompile(Tuple{typeof(Base.setindex!), Base.Dict{Any, Any}, Char, Char})
+precompile(Tuple{typeof(Base._setindex!), Base.Dict{Any, Any}, Char, Char, Int64})
+precompile(Tuple{typeof(Base.setindex!), Base.Dict{Any, Any}, Base.LineEdit.KeyAlias, Int64})
+precompile(Tuple{typeof(Base.ht_keyindex2), Base.Dict{Any, Any}, Int64})
+precompile(Tuple{typeof(Base._setindex!), Base.Dict{Any, Any}, Base.LineEdit.KeyAlias, Int64, Int64})
+precompile(Tuple{typeof(Base.setindex!), Base.Dict{Any, Any}, String, String})
+precompile(Tuple{typeof(Base._setindex!), Base.Dict{Any, Any}, String, String, Int64})
+precompile(Tuple{typeof(Base.setindex!), Base.Dict{Any, Any}, Void, String})
+precompile(Tuple{typeof(Base._setindex!), Base.Dict{Any, Any}, Void, String, Int64})
+precompile(Tuple{typeof(Base.setindex!), Base.Dict{Any, Any}, Base.LineEdit.KeyAlias, String})
+precompile(Tuple{typeof(Base._setindex!), Base.Dict{Any, Any}, Base.LineEdit.KeyAlias, String, Int64})
+precompile(Tuple{typeof(Base.setindex!), Base.Dict{Any, Any}, Char, String})
+precompile(Tuple{typeof(Base._setindex!), Base.Dict{Any, Any}, Char, String, Int64})
+precompile(Tuple{getfield(Base.LineEdit, Symbol("#kw##add_nested_key!")), Array{Any, 1}, typeof(Base.LineEdit.add_nested_key!), Base.Dict{Char, Any}, String, Void})
+precompile(Tuple{typeof(Base._setindex!), Base.Dict{Char, Any}, Void, Char, Int64})
+precompile(Tuple{typeof(Base.setindex!), Base.Dict{Char, Any}, Void, Char})
+precompile(Tuple{getfield(Base.LineEdit, Symbol("#kw##add_nested_key!")), Array{Any, 1}, typeof(Base.LineEdit.add_nested_key!), Base.Dict{Char, Any}, String, Base.LineEdit.KeyAlias})
+precompile(Tuple{typeof(Base._setindex!), Base.Dict{Char, Any}, Base.LineEdit.KeyAlias, Char, Int64})
+precompile(Tuple{typeof(Base.setindex!), Base.Dict{Char, Any}, Base.LineEdit.KeyAlias, Char})
+precompile(Tuple{typeof(Base.setindex!), Base.Dict{Any, Void}, Void, String})
+precompile(Tuple{typeof(Base.ht_keyindex2), Base.Dict{Any, Void}, String})
+precompile(Tuple{typeof(Base._setindex!), Base.Dict{Any, Void}, Void, String, Int64})
+precompile(Tuple{typeof(Base.LineEdit.fixup_keymaps!), Base.Dict{Char, Any}, Int64, Char, Void})
+precompile(Tuple{typeof(Base.LineEdit.run_interface), Base.Terminals.TTYTerminal, Base.LineEdit.ModalInterface})
+precompile(Tuple{getfield(Base.LineEdit, Symbol("#kw##refresh_multi_line")), Array{Any, 1}, typeof(Base.LineEdit.refresh_multi_line), Base.Terminals.TerminalBuffer, Base.Terminals.TTYTerminal, Base.GenericIOBuffer{Array{UInt8, 1}}, Base.LineEdit.InputAreaState, Base.LineEdit.PromptState})
+precompile(Tuple{getfield(Base.LineEdit, Symbol("#kw##refresh_multi_line")), Array{Any, 1}, typeof(Base.LineEdit.refresh_multi_line), Base.Terminals.TerminalBuffer, Base.Terminals.TTYTerminal, Base.GenericIOBuffer{Array{UInt8, 1}}, Base.LineEdit.InputAreaState, Base.LineEdit.PrefixSearchState})
+precompile(Tuple{typeof(Base.write), Base.Terminals.TTYTerminal, Array{UInt8, 1}})
+precompile(Tuple{typeof(Base.LineEdit.init_state), Base.Terminals.TTYTerminal, Base.LineEdit.ModalInterface})
+precompile(Tuple{typeof(Base.LineEdit.prompt!), Base.Terminals.TTYTerminal, Base.LineEdit.ModalInterface, Base.LineEdit.MIState})
+precompile(Tuple{typeof(Base.getindex), Array{Base.LineEdit.TextInterface, 1}, Int64})
+precompile(Tuple{typeof(Base.start), Array{Base.LineEdit.TextInterface, 1}})
+precompile(Tuple{typeof(Base.done), Array{Base.LineEdit.TextInterface, 1}, Int64})
+precompile(Tuple{typeof(Base.next), Array{Base.LineEdit.TextInterface, 1}, Int64})
+precompile(Tuple{typeof(Base.LineEdit.init_state), Base.Terminals.TTYTerminal, Base.LineEdit.Prompt})
+precompile(Tuple{typeof(Base.setindex!), Base.Dict{Any, Any}, Base.LineEdit.PromptState, Base.LineEdit.Prompt})
+precompile(Tuple{typeof(Base.ht_keyindex2), Base.Dict{Any, Any}, Base.LineEdit.Prompt})
+precompile(Tuple{typeof(Base._setindex!), Base.Dict{Any, Any}, Base.LineEdit.PromptState, Base.LineEdit.Prompt, Int64})
+precompile(Tuple{typeof(Base.LineEdit.init_state), Base.Terminals.TTYTerminal, Base.LineEdit.HistoryPrompt{Base.REPL.REPLHistoryProvider}})
+precompile(Tuple{typeof(Base.setindex!), Base.Dict{Any, Any}, Base.LineEdit.SearchState, Base.LineEdit.HistoryPrompt{Base.REPL.REPLHistoryProvider}})
+precompile(Tuple{typeof(Base.ht_keyindex2), Base.Dict{Any, Any}, Base.LineEdit.HistoryPrompt{Base.REPL.REPLHistoryProvider}})
+precompile(Tuple{typeof(Base._setindex!), Base.Dict{Any, Any}, Base.LineEdit.SearchState, Base.LineEdit.HistoryPrompt{Base.REPL.REPLHistoryProvider}, Int64})
+precompile(Tuple{typeof(Base.LineEdit.init_state), Base.Terminals.TTYTerminal, Base.LineEdit.PrefixHistoryPrompt{Base.REPL.REPLHistoryProvider}})
+precompile(Tuple{typeof(Base.setindex!), Base.Dict{Any, Any}, Base.LineEdit.PrefixSearchState, Base.LineEdit.PrefixHistoryPrompt{Base.REPL.REPLHistoryProvider}})
+precompile(Tuple{typeof(Base.ht_keyindex2), Base.Dict{Any, Any}, Base.LineEdit.PrefixHistoryPrompt{Base.REPL.REPLHistoryProvider}})
+precompile(Tuple{typeof(Base._setindex!), Base.Dict{Any, Any}, Base.LineEdit.PrefixSearchState, Base.LineEdit.PrefixHistoryPrompt{Base.REPL.REPLHistoryProvider}, Int64})
+precompile(Tuple{typeof(Core.Inference.isbits), Tuple{Tuple{}, Void}})
+precompile(Tuple{typeof(Base.take!), Base.Channel{Any}})
+precompile(Tuple{typeof(Base.n_avail), Base.Channel{Any}})
+precompile(Tuple{typeof(Base.check_channel_state), Base.Channel{Any}})
+precompile(Tuple{typeof(Base.wait_impl), Base.Channel{Any}})
+precompile(Tuple{typeof(Base.wait_unbuffered), Base.Channel{Any}})
+precompile(Tuple{typeof(Base.wait), Base.Channel{Any}})
+precompile(Tuple{typeof(Base.take_unbuffered), Base.Channel{Any}})
+precompile(Tuple{typeof(Base.LineEdit.activate), Base.LineEdit.Prompt, Base.LineEdit.MIState, Base.Terminals.TTYTerminal, Base.Terminals.TTYTerminal})
+precompile(Tuple{typeof(Base.:(==)), Base.LineEdit.Prompt, Base.LineEdit.Prompt})
+precompile(Tuple{typeof(Base.getindex), Base.Dict{Any, Any}, Base.LineEdit.Prompt})
+precompile(Tuple{typeof(Base.ht_keyindex), Base.Dict{Any, Any}, Base.LineEdit.Prompt})
+precompile(Tuple{typeof(Base.LineEdit.activate), Base.LineEdit.Prompt, Base.LineEdit.PromptState, Base.Terminals.TTYTerminal, Base.Terminals.TTYTerminal})
+precompile(Tuple{typeof(Base.LineEdit.refresh_multi_line), Base.Terminals.TerminalBuffer, Base.Terminals.TerminalBuffer, Base.Terminals.TTYTerminal, Base.LineEdit.PromptState})
+precompile(Tuple{getfield(Base.LineEdit, Symbol("#kw##refresh_multi_line")), Array{Any, 1}, typeof(Base.LineEdit.refresh_multi_line), Base.Terminals.TerminalBuffer, Base.Terminals.TerminalBuffer, Base.Terminals.TTYTerminal, Base.LineEdit.PromptState})
+precompile(Tuple{getfield(Base.LineEdit, Symbol("#kw##refresh_multi_line")), Array{Any, 1}, typeof(Base.LineEdit.refresh_multi_line), Base.Terminals.TerminalBuffer, Base.Terminals.TTYTerminal, Base.LineEdit.PromptState})
+precompile(Tuple{typeof(Base.LineEdit.refresh_multi_line), Base.Terminals.TerminalBuffer, Base.Terminals.TTYTerminal, Base.LineEdit.PromptState})
+precompile(Tuple{typeof(Base.displaysize), Base.TTY})
+precompile(Tuple{typeof(Base.divrem), Int64, Int64})
+precompile(Tuple{typeof(Base.LineEdit.match_input), Base.Dict{Char, Any}, Base.LineEdit.MIState})
+precompile(Tuple{typeof(Base.LineEdit.match_input), Base.Dict{Char, Any}, Base.LineEdit.MIState, Base.GenericIOBuffer{Array{UInt8, 1}}, Array{Char, 1}, Base.Dict{Char, Any}})
+precompile(Tuple{typeof(Base.LineEdit.terminal), Base.LineEdit.PromptState})
+precompile(Tuple{typeof(Base.LineEdit.match_input), Base.Dict{Char, Any}, Base.LineEdit.MIState, Base.Terminals.TTYTerminal, Array{Char, 1}, Base.Dict{Char, Any}})
+precompile(Tuple{typeof(Base.read), Base.Terminals.TTYTerminal, Type{Char}})
+precompile(Tuple{typeof(Base.eof), Base.TTY})
+precompile(Tuple{typeof(Base.isreadable), Base.TTY})
+precompile(Tuple{typeof(Base.start_reading), Base.TTY})
+precompile(Tuple{typeof(Base.wait_readnb), Base.TTY, Int64})
+precompile(Tuple{typeof(Base.alloc_buf_hook), Base.TTY, UInt64})
+precompile(Tuple{typeof(Base.read), Base.TTY, Type{UInt8}})
+precompile(Tuple{typeof(Base.throw_boundserror), Array{UInt8, 1}, Tuple{Base.UnitRange{Int64}}})
+precompile(Tuple{typeof(Base.deleteat!), Array{UInt8, 1}, Base.UnitRange{Int64}})
+precompile(Tuple{typeof(Base.splice!), Array{UInt8, 1}, Base.UnitRange{Int64}, Array{UInt8, 1}})
+precompile(Tuple{typeof(Base.LineEdit.splice_buffer!), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.UnitRange{Int64}, String})
+precompile(Tuple{typeof(Base.LineEdit.refresh_multi_line), Base.Terminals.TerminalBuffer, Base.LineEdit.PromptState})
+precompile(Tuple{typeof(Base.LineEdit.edit_insert), Base.GenericIOBuffer{Array{UInt8, 1}}, String})
+precompile(Tuple{typeof(Base.LineEdit.edit_insert), Base.LineEdit.PromptState, String})
+precompile(Tuple{typeof(Base.Terminals.width), Base.Terminals.TTYTerminal})
+precompile(Tuple{Type{Base.Libc.TmStruct}, Float64})
+precompile(Tuple{typeof(Base.Libc.strftime), String, Base.Libc.TmStruct})
+precompile(Tuple{typeof(Base.replace), String, Base.Regex, String, Int64})
+precompile(Tuple{typeof(Base.REPL.mode_idx), Base.REPL.REPLHistoryProvider, Base.LineEdit.Prompt})
+precompile(Tuple{typeof(Base.LineEdit.commit_line), Base.LineEdit.MIState})
+precompile(Tuple{typeof(Base.LineEdit.on_enter), Base.LineEdit.PromptState})
+precompile(Tuple{typeof(Base.REPL.return_callback), Base.LineEdit.PromptState})
+precompile(Tuple{typeof(Base.LineEdit.refresh_multi_line), Base.LineEdit.PromptState})
+precompile(Tuple{typeof(Base.LineEdit.refresh_multi_line), Base.Terminals.TTYTerminal, Base.LineEdit.PromptState})
+precompile(Tuple{typeof(Base.println), Base.Terminals.TTYTerminal})
+precompile(Tuple{typeof(Base.write), Base.Terminals.TTYTerminal, Char})
+precompile(Tuple{typeof(Base.write), Base.TTY, UInt8})
+precompile(Tuple{typeof(Base.unsafe_write), Base.TTY, Base.RefValue{UInt8}, Int64})
+precompile(Tuple{typeof(Base.LineEdit.add_history), Base.LineEdit.PromptState})
+precompile(Tuple{typeof(Base.LineEdit.add_history), Base.REPL.REPLHistoryProvider, Base.LineEdit.PromptState})
+precompile(Tuple{typeof(Base.start), Base.Pair{Symbol, Any}})
+precompile(Tuple{typeof(Base.print), Base.IOStream, String})
+precompile(Tuple{typeof(Base.unsafe_write), Base.IOStream, Ptr{UInt8}, UInt64})
+precompile(Tuple{typeof(Base.flush), Base.IOStream})
+precompile(Tuple{typeof(Base.LineEdit.mode), Base.LineEdit.PromptState})
+precompile(Tuple{typeof(Base.REPL.reset), Base.REPL.LineEditREPL})
+precompile(Tuple{getfield(Base, Symbol("#kw##parse_input_line")), Array{Any, 1}, typeof(Base.parse_input_line), String})
+precompile(Tuple{typeof(Base.put!), Base.Channel{Any}, Tuple{Expr, Int64}})
+precompile(Tuple{typeof(Base.put_buffered), Base.Channel{Any}, Tuple{Expr, Int64}})
+precompile(Tuple{typeof(Base.put_unbuffered), Base.Channel{Any}, Tuple{Expr, Int64}})
+precompile(Tuple{typeof(Base.REPL.eval_user_input), Expr, Base.REPL.REPLBackend})
+precompile(Tuple{typeof(Base.put!), Base.Channel{Any}, Tuple{Int64, Void}})
+precompile(Tuple{typeof(Base.put_buffered), Base.Channel{Any}, Tuple{Int64, Void}})
+precompile(Tuple{typeof(Base.put_unbuffered), Base.Channel{Any}, Tuple{Int64, Void}})
+precompile(Tuple{typeof(Base.start), Tuple{Int64, Void}})
+precompile(Tuple{typeof(Base.REPL.print_response), Base.REPL.LineEditREPL, Int64, Void, Bool, Bool})
+precompile(Tuple{typeof(Base.REPL.print_response), Base.Terminals.TTYTerminal, Int64, Void, Bool, Bool, Void})
+precompile(Tuple{typeof(Base.print), Base.Terminals.TTYTerminal, DataType})
+precompile(Tuple{typeof(Base.print), Base.Terminals.TTYTerminal, Char})
+precompile(Tuple{typeof(Base.print), Base.Terminals.TTYTerminal, String, DataType, String, Char})
+precompile(Tuple{typeof(Base.print), Base.Terminals.TTYTerminal, String, Char})
+precompile(Tuple{Type{Base.IOContext{Base.Terminals.TTYTerminal}}, Base.Terminals.TTYTerminal, Base.ImmutableDict{Symbol, Any}})
+precompile(Tuple{getfield(Base, Symbol("#kw##with_output_color")), Array{Any, 1}, typeof(Base.with_output_color), typeof(Base.print), Symbol, Base.IOContext{Base.Terminals.TTYTerminal}, String})
+precompile(Tuple{getfield(Base, Symbol("#kw##with_output_color")), Array{Any, 1}, typeof(Base.with_output_color), typeof(Base.print), Int64, Base.IOContext{Base.Terminals.TTYTerminal}, String})
+precompile(Tuple{typeof(Base.write), Base.IOContext{Base.Terminals.TTYTerminal}, Symbol})
+precompile(Tuple{typeof(Base.show), Base.IOContext{Base.Terminals.TTYTerminal}, Module})
+precompile(Tuple{typeof(Base.print), Base.IOContext{Base.Terminals.TTYTerminal}, String})
+precompile(Tuple{typeof(Base.print), Base.IOContext{Base.Terminals.TTYTerminal}, Module})
+precompile(Tuple{typeof(Base.show), Base.IOContext{Base.Terminals.TTYTerminal}, Int32})
+precompile(Tuple{typeof(Base.print), Base.IOContext{Base.Terminals.TTYTerminal}, Symbol})
+precompile(Tuple{typeof(Base.print), Base.IOContext{Base.Terminals.TTYTerminal}, Int32})
+precompile(Tuple{typeof(Base.show), Base.IOContext{Base.Terminals.TTYTerminal}, Int64})
+precompile(Tuple{typeof(Base.print), Base.IOContext{Base.Terminals.TTYTerminal}, Int64})
+precompile(Tuple{typeof(Base.print), Base.IOContext{Base.Terminals.TTYTerminal}, String, Int64, String})
+precompile(Tuple{typeof(Base.write), Base.IOContext{Base.Terminals.TTYTerminal}, Char})
+precompile(Tuple{typeof(Base.show_circular), Base.IOContext{Base.Terminals.TTYTerminal}, Array{Any, 1}})
+precompile(Tuple{typeof(Base.show_delim_array), Base.IOContext{Base.Terminals.TTYTerminal}, Array{Any, 1}, Char, Char, Char, Bool, Int64, Int64})
+precompile(Tuple{typeof(Base.join), Base.IOContext{Base.Terminals.TTYTerminal}, Array{Any, 1}, String, String})
+precompile(Tuple{typeof(Base.join), Base.IOContext{Base.Terminals.TTYTerminal}, Tuple{}, String, String})
+precompile(Tuple{typeof(Base.show_method_params), Base.IOContext{Base.Terminals.TTYTerminal}, Array{Any, 1}})
+precompile(Tuple{typeof(Base.print), Base.IOContext{Base.Terminals.TTYTerminal}, String, Module})
+precompile(Tuple{typeof(Base.print), Base.IOContext{Base.Terminals.TTYTerminal}, String, Symbol, String, Int32})
+precompile(Tuple{typeof(Base.show_tuple_as_call), Base.IOContext{Base.Terminals.TTYTerminal}, Symbol, Type})
+precompile(Tuple{typeof(Base.print_with_color), Symbol, Base.IOContext{Base.Terminals.TTYTerminal}, String})
+precompile(Tuple{typeof(Base.print_with_color), Int64, Base.IOContext{Base.Terminals.TTYTerminal}, String})
+precompile(Tuple{typeof(Base.show), Base.IOContext{Base.Terminals.TTYTerminal}, Core.MethodInstance})
+precompile(Tuple{typeof(Base.StackTraces.show_spec_linfo), Base.IOContext{Base.Terminals.TTYTerminal}, Base.StackTraces.StackFrame})
+precompile(Tuple{getfield(Base, Symbol("#kw##show")), Array{Any, 1}, typeof(Base.show), Base.IOContext{Base.Terminals.TTYTerminal}, Base.StackTraces.StackFrame})
+precompile(Tuple{getfield(Base, Symbol("#kw##show_trace_entry")), Array{Any, 1}, typeof(Base.show_trace_entry), Base.IOContext{Base.Terminals.TTYTerminal}, Base.StackTraces.StackFrame, Int64})
+precompile(Tuple{typeof(Base.show_backtrace), Base.Terminals.TTYTerminal, Array{Ptr{Void}, 1}})
+precompile(Tuple{typeof(Base.Multimedia.display), Int64})
+precompile(Tuple{typeof(Core.Inference.isbits), Base.MIME{Symbol("text/plain")}})
+precompile(Tuple{typeof(Core.Inference.isbits), Tuple{typeof(Base.Multimedia.display), typeof(Base.show)}})
+precompile(Tuple{typeof(Base.Multimedia.display), Base.REPL.REPLDisplay{Base.REPL.LineEditREPL}, Int64})
+precompile(Tuple{Type{Base.MIME{Symbol("text/plain")}}})
+precompile(Tuple{typeof(Base.Multimedia.display), Base.REPL.REPLDisplay{Base.REPL.LineEditREPL}, Base.MIME{Symbol("text/plain")}, Int64})
+precompile(Tuple{typeof(Base.start), Base.Pair{Any, Any}})
+precompile(Tuple{typeof(Base.LineEdit.reset_state), Base.LineEdit.PromptState})
+precompile(Tuple{typeof(Base.LineEdit.reset_state), Base.LineEdit.SearchState})
+precompile(Tuple{typeof(Base.LineEdit.reset_state), Base.REPL.REPLHistoryProvider})
+precompile(Tuple{typeof(Base.LineEdit.reset_state), Base.LineEdit.PrefixSearchState})
+precompile(Tuple{typeof(Base.haskey), Base.Dict{Any, Any}, Base.LineEdit.Prompt})
+precompile(Tuple{typeof(Base.LineEdit.deactivate), Base.LineEdit.Prompt, Base.LineEdit.PromptState, Base.Terminals.TerminalBuffer, Base.Terminals.TTYTerminal})
+precompile(Tuple{typeof(Base.LineEdit.activate), Base.LineEdit.Prompt, Base.LineEdit.PromptState, Base.Terminals.TerminalBuffer, Base.Terminals.TTYTerminal})
+precompile(Tuple{typeof(Base.LineEdit.commit_changes), Base.Terminals.TTYTerminal, Base.Terminals.TerminalBuffer})
+precompile(Tuple{typeof(Base.LineEdit.complete_line), Base.LineEdit.PromptState, Int64})
+precompile(Tuple{typeof(Base.LineEdit.input_string_newlines_aftercursor), Base.LineEdit.PromptState})
+precompile(Tuple{typeof(Base.LineEdit.complete_line), Base.REPL.REPLCompletionProvider, Base.LineEdit.PromptState})
+precompile(Tuple{getfield(Base, Symbol("#kw##parse")), Array{Any, 1}, typeof(Base.parse), String})
+precompile(Tuple{typeof(Base.isvalid), Base.RevString{String}, Int64})
+precompile(Tuple{typeof(Base.nextind), Base.RevString{String}, Int64})
+precompile(Tuple{typeof(Base.search), Base.RevString{String}, Array{Char, 1}, Int64})
+precompile(Tuple{typeof(Base.rsearch), String, Array{Char, 1}, Int64})
+precompile(Tuple{getfield(Base.REPLCompletions, Symbol("#kw##find_start_brace")), Array{Any, 1}, typeof(Base.REPLCompletions.find_start_brace), String})
+precompile(Tuple{typeof(Core.Inference.isbits), Tuple{Void, Void, Void}})
+precompile(Tuple{typeof(Base.isidentifier), Base.SubString{String}})
+precompile(Tuple{typeof(Core.Inference.isbits), Tuple{Bool, Void, Void}})
+precompile(Tuple{typeof(Base.Filesystem.readdir), String})
+precompile(Tuple{typeof(Base.cmp), String, Base.SubString{String}})
+precompile(Tuple{typeof(Base.skip_deleted), Base.Dict{String, Void}, Int64})
+precompile(Tuple{typeof(Base.PCRE.exec), Ptr{Void}, String, UInt32, UInt32, Ptr{Void}})
+precompile(Tuple{typeof(Base.PCRE.exec), Ptr{Void}, String, UInt64, UInt32, Ptr{Void}})
+precompile(Tuple{typeof(Base.nextind), String, UInt64})
+precompile(Tuple{typeof(Base.matchall), Base.Regex, String, Bool})
+precompile(Tuple{typeof(Base.skip_deleted), Base.Dict{String, String}, Int64})
+precompile(Tuple{typeof(Base.reverse), String})
+precompile(Tuple{typeof(Core.Inference.isbits), Tuple{Void, Bool}})
+precompile(Tuple{typeof(Base._convert), Type{Array{Method, 1}}, Base.BitArray{1}})
+precompile(Tuple{typeof(Base.unsafe_copy!), Array{Method, 1}, Int64, Array{Method, 1}, Int64, Int64})
+precompile(Tuple{typeof(Base.copy!), Array{Method, 1}, Int64, Array{Method, 1}, Int64, Int64})
+precompile(Tuple{typeof(Core.Inference.length), Tuple{Core.Inference.PartialTypeVar}})
+precompile(Tuple{typeof(Core.Inference.getindex), Tuple{Core.Inference.PartialTypeVar}, Int64})
+precompile(Tuple{typeof(Base.show_delim_array), Base.GenericIOBuffer{Array{UInt8, 1}}, Array{Any, 1}, Char, Char, Char, Bool, Int64, Int64})
+precompile(Tuple{typeof(Base.join), Base.GenericIOBuffer{Array{UInt8, 1}}, Array{Any, 1}, String, String})
+precompile(Tuple{typeof(Base.join), Base.GenericIOBuffer{Array{UInt8, 1}}, Tuple{}, String, String})
+precompile(Tuple{typeof(Base.show_method_params), Base.GenericIOBuffer{Array{UInt8, 1}}, Array{Any, 1}})
+precompile(Tuple{typeof(Base.print), Base.GenericIOBuffer{Array{UInt8, 1}}, String, Module})
+precompile(Tuple{typeof(Base.print), Base.GenericIOBuffer{Array{UInt8, 1}}, String, Symbol, String, Int32})
+precompile(Tuple{typeof(Base.reverseind), String, Int64})
+precompile(Tuple{typeof(Base.Pkg.Dir.path)})
+precompile(Tuple{typeof(Base.promote_type), Type{String}, Type{Union{}}})
+precompile(Tuple{typeof(Base.promote_type), Type{Any}, Type{String}})
+precompile(Tuple{typeof(Base.promote_rule), Type{Any}, Type{String}})
+precompile(Tuple{typeof(Base.promote_rule), Type{String}, Type{Any}})
+precompile(Tuple{typeof(Base.promote_result), Type{Any}, Type{String}, Type{Union{}}, Type{Union{}}})
+precompile(Tuple{typeof(Base.promote_type), Type{String}, Type{Any}})
+precompile(Tuple{typeof(Base.promote_result), Type{String}, Type{Any}, Type{Union{}}, Type{Union{}}})
+precompile(Tuple{typeof(Base.cat_indices), String, Int64})
+precompile(Tuple{typeof(Base.cat_size), String, Int64})
+precompile(Tuple{typeof(Base.setindex!), Array{Any, 1}, String, Base.UnitRange{Int64}})
+precompile(Tuple{typeof(Base._cat), Array{Any, 1}, Tuple{Int64}, Tuple{Bool}, String, Array{Any, 1}, String})
+precompile(Tuple{typeof(Base.cat_t), Base.Val{1}, Type{Any}, String, Array{Any, 1}, String})
+precompile(Tuple{typeof(Base.Sort.searchsortedfirst), Array{String, 1}, String, Int64, Int64, Base.Order.ForwardOrdering})
+precompile(Tuple{typeof(Base.Sort.searchsortedlast), Array{String, 1}, String, Int64, Int64, Base.Order.ForwardOrdering})
+precompile(Tuple{typeof(Base.Sort.searchsorted), Array{String, 1}, String, Int64, Int64, Base.Order.ForwardOrdering})
+precompile(Tuple{typeof(Base.Sort.searchsorted), Array{String, 1}, String, Base.Order.ForwardOrdering})
+precompile(Tuple{typeof(Base.throw_boundserror), Array{String, 1}, Tuple{Base.UnitRange{Int64}}})
+precompile(Tuple{typeof(Core.Inference.precise_container_type), String, Core.Inference.Const, Array{Any, 1}, Core.Inference.InferenceState})
+precompile(Tuple{typeof(Base._rsearchindex), String, String, Int64})
+precompile(Tuple{typeof(Base.deleteat!), Array{Symbol, 1}, Base.UnitRange{Int64}})
+precompile(Tuple{typeof(Base.copy!), Array{String, 1}, Base.Generator{Array{Symbol, 1}, typeof(Base.string)}})
+precompile(Tuple{typeof(Base.deleteat!), Array{String, 1}, Base.UnitRange{Int64}})
+precompile(Tuple{typeof(Base.ht_keyindex), Base.Dict{String, Void}, String})
+precompile(Tuple{typeof(Base.push!), Base.Set{String}, String})
+precompile(Tuple{typeof(Base.isstructtype), DataType})
+precompile(Tuple{typeof(Base.start), Array{Int64, 1}})
+precompile(Tuple{typeof(Base.to_tuple_type), Type{Tuple}})
+precompile(Tuple{typeof(Base.append!), Array{Any, 1}, Array{Any, 1}})
+precompile(Tuple{typeof(Core.Inference.isbits), Tuple{DataType, Bool}})
+precompile(Tuple{typeof(Base.is_default_method), Method})
+precompile(Tuple{getfield(Base, Symbol("#kw##show")), Array{Any, 1}, typeof(Base.show), Base.GenericIOBuffer{Array{UInt8, 1}}, Method})
+precompile(Tuple{typeof(Base.sort!), Array{String, 1}})
+precompile(Tuple{typeof(Base.rehash!), Base.Dict{String, Void}, Int64})
+precompile(Tuple{typeof(Base.ht_keyindex2), Base.Dict{String, Void}, String})
+precompile(Tuple{typeof(Base._setindex!), Base.Dict{String, Void}, Void, String, Int64})
+precompile(Tuple{typeof(Base.setindex!), Base.Dict{String, Void}, Void, String})
+precompile(Tuple{typeof(Base.Filesystem.realpath), Base.SubString{String}})
+precompile(Tuple{typeof(Base.Filesystem.readdir), Base.SubString{String}})
+precompile(Tuple{typeof(Base.REPLCompletions.dict_identifier_key), String, Symbol})
+precompile(Tuple{typeof(Base.Filesystem.expanduser), String})
+precompile(Tuple{typeof(Base.REPLCompletions.bslash_completions), String, Int64})
+precompile(Tuple{typeof(Base.REPLCompletions.should_method_complete), String})
+precompile(Tuple{typeof(Base.REPLCompletions.afterusing), String, Int64})
+precompile(Tuple{typeof(Base.REPLCompletions.complete_keyword), String})
+precompile(Tuple{typeof(Base.in), Char, Array{Any, 1}})
+precompile(Tuple{typeof(Base.string), Char, Char})
+precompile(Tuple{typeof(Base.unique), Array{String, 1}})
+precompile(Tuple{typeof(Base.REPL.beforecursor), Base.GenericIOBuffer{Array{UInt8, 1}}})
+precompile(Tuple{typeof(Base.REPLCompletions.completions), String, Int64})
+precompile(Tuple{typeof(Base.incomplete_tag), Symbol})
+precompile(Tuple{typeof(Base.rsearchindex), String, String, Int64})
+precompile(Tuple{typeof(Base._rsearch), String, String, Int64})
+precompile(Tuple{typeof(Base.unshift!), Array{Base.SubString{String}, 1}, Base.SubString{String}})
+precompile(Tuple{typeof(Base.startswith), String, Base.SubString{String}})
+precompile(Tuple{typeof(Base.rsearch), String, Array{Char, 1}})
+precompile(Tuple{getfield(Base, Symbol("#kw##rsplit")), Array{Any, 1}, typeof(Base.rsplit), String, String})
+precompile(Tuple{typeof(Base.sort!), Array{String, 1}, Base.Sort.MergeSortAlg, Base.Order.ForwardOrdering})
+precompile(Tuple{typeof(Base.sort!), Array{String, 1}, Int64, Int64, Base.Sort.InsertionSortAlg, Base.Order.ForwardOrdering})
+precompile(Tuple{typeof(Base.sort!), Array{String, 1}, Int64, Int64, Base.Sort.MergeSortAlg, Base.Order.ForwardOrdering, Array{String, 1}})
+precompile(Tuple{typeof(Base.start), Tuple{Array{String, 1}, String, Bool}})
+precompile(Tuple{typeof(Base.indexed_next), Tuple{Array{String, 1}, String, Bool}, Int64, Int64})
+precompile(Tuple{typeof(Base.LineEdit.common_prefix), Array{String, 1}})
+precompile(Tuple{typeof(Base.LineEdit.show_completions), Base.LineEdit.PromptState, Array{String, 1}})
+precompile(Tuple{typeof(Base.collect_to!), Array{Int64, 1}, Base.Generator{Array{String, 1}, typeof(Base.length)}, Int64, Int64})
+precompile(Tuple{typeof(Base._collect), Array{String, 1}, Base.Generator{Array{String, 1}, typeof(Base.length)}, Base.EltypeUnknown, Base.HasShape})
+precompile(Tuple{typeof(Base.mapreduce_impl), typeof(Base.identity), typeof(Base.scalarmax), Array{Int64, 1}, Int64, Int64})
+precompile(Tuple{typeof(Base._mapreduce), typeof(Base.identity), typeof(Base.scalarmax), Base.IndexLinear, Array{Int64, 1}})
+precompile(Tuple{typeof(Base.Terminals.cmove_down), Base.Terminals.TTYTerminal, Int64})
+precompile(Tuple{typeof(Base.Terminals.cmove_col), Base.Terminals.TTYTerminal, Int64})
+precompile(Tuple{typeof(Base.Terminals.cmove_right), Base.Terminals.TTYTerminal, Int64})
+precompile(Tuple{typeof(Base.write), Base.TTY, Char})
+precompile(Tuple{typeof(Base.LineEdit.match_input), Base.LineEdit.KeyAlias, Base.LineEdit.MIState, Base.Terminals.TTYTerminal, Array{Char, 1}, Base.Dict{Char, Any}})
+precompile(Tuple{typeof(Base.peek), Base.GenericIOBuffer{Array{UInt8, 1}}})
+precompile(Tuple{typeof(Base.LineEdit.char_move_left), Base.GenericIOBuffer{Array{UInt8, 1}}})
+precompile(Tuple{typeof(Base.LineEdit.edit_backspace), Base.GenericIOBuffer{Array{UInt8, 1}}})
+precompile(Tuple{typeof(Base.LineEdit.edit_backspace), Base.LineEdit.PromptState})
+precompile(Tuple{typeof(Base.Terminals.beep), Base.Terminals.TTYTerminal})
+precompile(Tuple{typeof(Base.LineEdit.edit_move_down), Base.GenericIOBuffer{Array{UInt8, 1}}})
+precompile(Tuple{typeof(Core.Inference.length), Tuple{Core.Inference.Const, Core.Inference.Const, Core.Inference.Const, DataType}})
+precompile(Tuple{typeof(Core.Inference.getindex), Tuple{Core.Inference.Const, Core.Inference.Const, Core.Inference.Const, DataType}, Int64})
+precompile(Tuple{typeof(Base.LineEdit.replace_line), Base.LineEdit.PrefixSearchState, String})
+precompile(Tuple{typeof(Base.LineEdit.refresh_multi_line), Base.Terminals.TerminalBuffer, Base.LineEdit.PrefixSearchState})
+precompile(Tuple{typeof(Base.copy), Base.GenericIOBuffer{Array{UInt8, 1}}})
+precompile(Tuple{typeof(Base.REPL.history_move), Base.LineEdit.PrefixSearchState, Base.REPL.REPLHistoryProvider, Int64, Int64})
+precompile(Tuple{typeof(Base.LineEdit.edit_move_down), Base.LineEdit.MIState})
+precompile(Tuple{typeof(Base.LineEdit.enter_prefix_search), Base.LineEdit.MIState, Base.LineEdit.PrefixHistoryPrompt{Base.REPL.REPLHistoryProvider}, Bool})
+precompile(Tuple{typeof(Base.haskey), Base.Dict{Any, Any}, Base.LineEdit.PrefixHistoryPrompt{Base.REPL.REPLHistoryProvider}})
+precompile(Tuple{typeof(Base.ht_keyindex), Base.Dict{Any, Any}, Base.LineEdit.PrefixHistoryPrompt{Base.REPL.REPLHistoryProvider}})
+precompile(Tuple{typeof(Base.getindex), Base.Dict{Any, Any}, Base.LineEdit.PrefixHistoryPrompt{Base.REPL.REPLHistoryProvider}})
+precompile(Tuple{typeof(Base.LineEdit.copybuf!), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.GenericIOBuffer{Array{UInt8, 1}}})
+precompile(Tuple{typeof(Base.LineEdit.activate), Base.LineEdit.PrefixHistoryPrompt{Base.REPL.REPLHistoryProvider}, Base.LineEdit.PrefixSearchState, Base.Terminals.TerminalBuffer, Base.Terminals.TTYTerminal})
+precompile(Tuple{typeof(Base.LineEdit.refresh_multi_line), Base.Terminals.TerminalBuffer, Base.Terminals.TTYTerminal, Base.LineEdit.PrefixSearchState})
+precompile(Tuple{typeof(Base.LineEdit.history_next_prefix), Base.LineEdit.PrefixSearchState, Base.REPL.REPLHistoryProvider, String})
+precompile(Tuple{typeof(Base.REPL.history_move_prefix), Base.LineEdit.PrefixSearchState, Base.REPL.REPLHistoryProvider, String, Bool, Int64})
+precompile(Tuple{typeof(Base.LineEdit.keymap), Base.LineEdit.PrefixSearchState, Base.LineEdit.PrefixHistoryPrompt{Base.REPL.REPLHistoryProvider}})
+precompile(Tuple{typeof(Base.LineEdit.terminal), Base.LineEdit.PrefixSearchState})
+precompile(Tuple{typeof(Base.LineEdit.keymap_data), Base.LineEdit.PrefixSearchState, Base.LineEdit.PrefixHistoryPrompt{Base.REPL.REPLHistoryProvider}})
+precompile(Tuple{typeof(Base.LineEdit.history_prev_prefix), Base.LineEdit.PrefixSearchState, Base.REPL.REPLHistoryProvider, String})
+precompile(Tuple{typeof(Base.getindex), Base.Dict{Symbol, Any}, Symbol})
+precompile(Tuple{typeof(Base.LineEdit.transition), Base.LineEdit.MIState, Base.LineEdit.Prompt})
+precompile(Tuple{typeof(Base.LineEdit.deactivate), Base.LineEdit.PrefixHistoryPrompt{Base.REPL.REPLHistoryProvider}, Base.LineEdit.PrefixSearchState, Base.Terminals.TerminalBuffer, Base.Terminals.TTYTerminal})
+precompile(Tuple{typeof(Base.LineEdit.refresh_multi_line), Base.Terminals.TTYTerminal, Base.LineEdit.PrefixSearchState})
+precompile(Tuple{typeof(Base.LineEdit.refresh_multi_line), Base.Terminals.TerminalBuffer, Base.Terminals.TerminalBuffer, Base.Terminals.TTYTerminal, Base.LineEdit.PrefixSearchState})
+precompile(Tuple{getfield(Base.LineEdit, Symbol("#kw##refresh_multi_line")), Array{Any, 1}, typeof(Base.LineEdit.refresh_multi_line), Base.Terminals.TerminalBuffer, Base.Terminals.TerminalBuffer, Base.Terminals.TTYTerminal, Base.LineEdit.PrefixSearchState})
+precompile(Tuple{getfield(Base.LineEdit, Symbol("#kw##refresh_multi_line")), Array{Any, 1}, typeof(Base.LineEdit.refresh_multi_line), Base.Terminals.TerminalBuffer, Base.Terminals.TTYTerminal, Base.LineEdit.PrefixSearchState})
+precompile(Tuple{typeof(Base.LineEdit.replace_line), Base.LineEdit.PrefixSearchState, Base.GenericIOBuffer{Array{UInt8, 1}}})
+precompile(Tuple{typeof(Base.LineEdit.accept_result), Base.LineEdit.MIState, Base.LineEdit.PrefixHistoryPrompt{Base.REPL.REPLHistoryProvider}})
+precompile(Tuple{typeof(Core.Inference.length), Tuple{Core.Inference.Const, Core.Inference.Const, DataType}})
+precompile(Tuple{typeof(Core.Inference.getindex), Tuple{Core.Inference.Const, Core.Inference.Const, DataType}, Int64})
+precompile(Tuple{typeof(Base.LineEdit.replace_line), Base.LineEdit.PromptState, Base.GenericIOBuffer{Array{UInt8, 1}}})
+precompile(Tuple{typeof(Base.LineEdit.match_input), Base.Dict{Char, Any}, Base.LineEdit.MIState, Base.GenericIOBuffer{Array{UInt8, 1}}})
+precompile(Tuple{typeof(Base.LineEdit.edit_move_left), Base.GenericIOBuffer{Array{UInt8, 1}}})
+precompile(Tuple{typeof(Base.LineEdit.edit_move_left), Base.LineEdit.PromptState})
+precompile(Tuple{typeof(Base.LineEdit.edit_move_right), Base.GenericIOBuffer{Array{UInt8, 1}}})
+precompile(Tuple{typeof(Base.LineEdit.edit_move_right), Base.LineEdit.PromptState})
+precompile(Tuple{typeof(Base.LineEdit.move_line_start), Base.LineEdit.MIState})
+precompile(Tuple{typeof(Base.LineEdit.move_line_end), Base.GenericIOBuffer{Array{UInt8, 1}}})
+precompile(Tuple{typeof(Base.LineEdit.move_line_end), Base.LineEdit.MIState})
+precompile(Tuple{typeof(Base.LineEdit.edit_move_up), Base.GenericIOBuffer{Array{UInt8, 1}}})
+precompile(Tuple{typeof(Base.LineEdit.edit_move_up), Base.LineEdit.MIState})
+precompile(Tuple{typeof(Base.:(==)), Symbol, Base.LineEdit.Prompt})
+precompile(Tuple{typeof(Base.isempty), Base.LineEdit.PromptState})
+precompile(Tuple{typeof(Base.LineEdit.default_enter_cb), Base.LineEdit.PromptState})
+precompile(Tuple{typeof(Base.Docs.helpmode), String})
+precompile(Tuple{typeof(Base.ht_keyindex), Base.Dict{Symbol, Base.Docs.DocStr}, Symbol})
+precompile(Tuple{typeof(Base.Docs.helpmode), Base.TTY, String})
+precompile(Tuple{getfield(Base.Docs, Symbol("#@repl")), Base.TTY, Symbol})
+precompile(Tuple{typeof(Base.Docs.repl), Base.TTY, Symbol})
+precompile(Tuple{typeof(Base.Docs._repl), Symbol})
+precompile(Tuple{getfield(Core, Symbol("#@doc")), Symbol})
+precompile(Tuple{typeof(Base.Docs.docm), LineNumberNode, Module, Symbol})
+precompile(Tuple{typeof(Base._setindex!), Base.Dict{Any, Any}, Base.Markdown.Config, Symbol, Int64})
+precompile(Tuple{Type{Base.Markdown.MD}})
+precompile(Tuple{typeof(Base.setindex!), Base.Dict{Any, Any}, Base.Markdown.Config, Symbol})
+precompile(Tuple{typeof(Base.Markdown.skipblank), Base.GenericIOBuffer{Array{UInt8, 1}}})
+precompile(Tuple{typeof(Base.vcat), Array{Function, 1}, Array{Function, 1}})
+precompile(Tuple{typeof(Base.Docs.formatdoc), Base.Docs.DocStr})
+precompile(Tuple{typeof(Base.Docs.parsedoc), Base.Docs.DocStr})
+precompile(Tuple{typeof(Base.Docs.repl_latex), Base.TTY, String})
+precompile(Tuple{typeof(Base.ht_keyindex), Base.Dict{String, String}, String})
+precompile(Tuple{typeof(Base.ht_keyindex), Base.Dict{Symbol, Tuple{String, String}}, Symbol})
+precompile(Tuple{typeof(Base.print), Base.TTY, Char, Char})
+precompile(Tuple{typeof(Base.rehash!), Base.Dict{String, String}, Int64})
+precompile(Tuple{typeof(Base.ht_keyindex2), Base.Dict{String, String}, String})
+precompile(Tuple{typeof(Base._setindex!), Base.Dict{String, String}, String, String, Int64})
+precompile(Tuple{typeof(Core.Inference.isbits), Base.Dict{String, String}})
+precompile(Tuple{typeof(Base.setindex!), Base.Dict{String, String}, String, String})
+precompile(Tuple{typeof(Base.Docs.symbol_latex), String})
+precompile(Tuple{typeof(Base.Docs.repl_search), Base.TTY, String})
+precompile(Tuple{typeof(Base.print), Base.TTY, String})
+precompile(Tuple{typeof(Base.print), Base.TTY, Char})
+precompile(Tuple{typeof(Base.print), Base.TTY, String, Char})
+precompile(Tuple{typeof(Base.mapreduce_impl), typeof(Base.identity), typeof(Base.:(+)), Array{Int64, 1}, Int64, Int64, Int64})
+precompile(Tuple{typeof(Base._mapreduce), typeof(Base.identity), typeof(Base.:(+)), Base.IndexLinear, Array{Int64, 1}})
+precompile(Tuple{typeof(Base.shift!), Array{Char, 1}})
+precompile(Tuple{typeof(Base.Docs.avgdistance), Array{Int64, 1}})
+precompile(Tuple{typeof(Core.Inference.isbits), Tuple{Array{String, 1}}})
+precompile(Tuple{typeof(Base.Docs.accessible), Module})
+precompile(Tuple{Type{Base.Generator{I, F} where F where I}, typeof(Base.names), Array{Any, 1}})
+precompile(Tuple{typeof(Base.iteratoreltype), Type{Base.Generator{Array{Any, 1}, typeof(Base.names)}}})
+precompile(Tuple{typeof(Base.iteratorsize), Type{Base.Generator{Array{Any, 1}, typeof(Base.names)}}})
+precompile(Tuple{typeof(Base._collect), Array{Any, 1}, Base.Generator{Array{Any, 1}, typeof(Base.names)}, Base.EltypeUnknown, Base.HasShape})
+precompile(Tuple{typeof(Base.collect_to!), Array{Array{Symbol, 1}, 1}, Base.Generator{Array{Any, 1}, typeof(Base.names)}, Int64, Int64})
+precompile(Tuple{typeof(Base.names), Module})
+precompile(Tuple{typeof(Base.vcat), Array{Symbol, 1}, Array{Symbol, 1}, Array{Symbol, 1}, Array{String, 1}})
+precompile(Tuple{typeof(Base.throw_boundserror), Array{Symbol, 2}, Tuple{Base.UnitRange{Int64}}})
+precompile(Tuple{typeof(Base.unsafe_copy!), Array{Symbol, 2}, Int64, Array{Symbol, 1}, Int64, Int64})
+precompile(Tuple{typeof(Base.promote_eltype), Array{Symbol, 1}, Array{Symbol, 1}, Array{Symbol, 1}, Array{String, 1}})
+precompile(Tuple{typeof(Base.promote_eltype), Array{Symbol, 1}, Array{String, 1}})
+precompile(Tuple{typeof(Base.promote_eltype), Array{String, 1}})
+precompile(Tuple{typeof(Base.promote_type), Type{Symbol}, Type{String}})
+precompile(Tuple{typeof(Base.promote_rule), Type{Symbol}, Type{String}})
+precompile(Tuple{typeof(Base.promote_rule), Type{String}, Type{Symbol}})
+precompile(Tuple{typeof(Base.promote_result), Type{Symbol}, Type{String}, Type{Union{}}, Type{Union{}}})
+precompile(Tuple{typeof(Base.typed_vcat), Type{Any}, Array{Symbol, 1}, Array{Symbol, 1}, Array{Symbol, 1}, Array{String, 1}})
+precompile(Tuple{typeof(Base.setindex!), Array{Any, 1}, Array{Symbol, 1}, Base.UnitRange{Int64}})
+precompile(Tuple{typeof(Base.setindex!), Array{Any, 1}, Array{String, 1}, Base.UnitRange{Int64}})
+precompile(Tuple{typeof(Base.throw_setindex_mismatch), Array{String, 1}, Tuple{Int64}})
+precompile(Tuple{typeof(Base.setindex_shape_check), Array{String, 1}, Int64})
+precompile(Tuple{typeof(Base.unique), Array{Any, 1}})
+precompile(Tuple{typeof(Base.getindex), Type{Symbol}, Symbol})
+precompile(Tuple{Type{Base.Set{Symbol}}, Tuple{Symbol}})
+precompile(Tuple{typeof(Base.union!), Base.Set{Symbol}, Tuple{Symbol}})
+precompile(Tuple{typeof(Base.unique_from), Array{Any, 1}, Array{Symbol, 1}, Base.Set{Symbol}, Int64})
+precompile(Tuple{typeof(Base.convert), Type{Base.Set{Any}}, Base.Set{Symbol}})
+precompile(Tuple{typeof(Base.ht_keyindex2), Base.Dict{Any, Void}, Symbol})
+precompile(Tuple{typeof(Base._setindex!), Base.Dict{Any, Void}, Void, Symbol, Int64})
+precompile(Tuple{typeof(Base.setindex!), Base.Dict{Any, Void}, Void, Symbol})
+precompile(Tuple{typeof(Base.union!), Base.Set{Any}, Base.Set{Symbol}})
+precompile(Tuple{typeof(Base.convert), Type{Array{Any, 1}}, Array{Symbol, 1}})
+precompile(Tuple{typeof(Base.copy!), Base.IndexLinear, Array{Any, 1}, Base.IndexLinear, Array{Symbol, 1}})
+precompile(Tuple{typeof(Base.:(==)), String, Symbol})
+precompile(Tuple{typeof(Base.unique_from), Array{Any, 1}, Array{Any, 1}, Base.Set{Any}, Int64})
+precompile(Tuple{Type{Base.Generator{I, F} where F where I}, typeof(Base.string), Array{Any, 1}})
+precompile(Tuple{typeof(Base.iteratoreltype), Type{Base.Generator{Array{Any, 1}, typeof(Base.string)}}})
+precompile(Tuple{typeof(Base.iteratorsize), Type{Base.Generator{Array{Any, 1}, typeof(Base.string)}}})
+precompile(Tuple{typeof(Base._collect), Array{Any, 1}, Base.Generator{Array{Any, 1}, typeof(Base.string)}, Base.EltypeUnknown, Base.HasShape})
+precompile(Tuple{typeof(Base.similar), Array{Any, 1}, Type{String}, Tuple{Base.OneTo{Int64}}})
+precompile(Tuple{typeof(Base.collect_to!), Array{String, 1}, Base.Generator{Array{Any, 1}, typeof(Base.string)}, Int64, Int64})
+precompile(Tuple{typeof(Base.UTF8proc.isalpha), Char})
+precompile(Tuple{getfield(Base.Docs, Symbol("#kw##matchinds")), Array{Any, 1}, typeof(Base.Docs.matchinds), String, String})
+precompile(Tuple{typeof(Base.Docs.bestmatch), String, String})
+precompile(Tuple{typeof(Base.length), Tuple{DataType, DataType}})
+precompile(Tuple{Type{BoundsError}, Array{Int64, 2}, Tuple{Base.UnitRange{Int64}, Int64}})
+precompile(Tuple{typeof(Base.throw_boundserror), Array{Int64, 2}, Tuple{Base.UnitRange{Int64}, Int64}})
+precompile(Tuple{getfield(Base.Cartesian, Symbol("#@nexprs")), Int64, Expr})
+precompile(Tuple{typeof(Base.Cartesian._nexprs), Int64, Expr})
+precompile(Tuple{typeof(Core.Inference.findnext), Array{Function, 1}, typeof(===), Int64})
+precompile(Tuple{typeof(Core.Inference.builtin_tfunction), typeof(===), Array{Any, 1}, Core.Inference.InferenceState, Core.Inference.InferenceParams})
+precompile(Tuple{typeof(Core.Inference.typeinf_frame), Core.MethodInstance, Bool, Bool, Core.Inference.InferenceParams})
+precompile(Tuple{typeof(Core.Inference.typeinf), Core.Inference.InferenceState})
+precompile(Tuple{typeof(Base.Cartesian.inlineanonymous), Expr, Int64})
+precompile(Tuple{typeof(Base.Cartesian.lreplace), Expr, Symbol, Int64})
+precompile(Tuple{typeof(Base.copy), Expr})
+precompile(Tuple{typeof(Base.copy_exprargs), Array{Any, 1}})
+precompile(Tuple{typeof(Base.collect), Type{Any}, Base.Generator{Array{Any, 1}, typeof(Base.copy_exprs)}})
+precompile(Tuple{typeof(Base._collect), Type{Any}, Base.Generator{Array{Any, 1}, typeof(Base.copy_exprs)}, Base.HasShape})
+precompile(Tuple{typeof(Base.copy!), Array{Any, 1}, Base.Generator{Array{Any, 1}, typeof(Base.copy_exprs)}})
+precompile(Tuple{typeof(Base.next), Base.Generator{Array{Any, 1}, typeof(Base.copy_exprs)}, Int64})
+precompile(Tuple{typeof(Base.copy_exprs), Expr})
+precompile(Tuple{typeof(Base.Cartesian.lreplace!), Expr, Base.Cartesian.LReplace{String}})
+precompile(Tuple{typeof(Base.Cartesian.lreplace!), Symbol, Base.Cartesian.LReplace{String}})
+precompile(Tuple{typeof(Base.Cartesian.lreplace!), String, Base.Cartesian.LReplace{String}})
+precompile(Tuple{typeof(Base.Cartesian.exprresolve), Expr})
+precompile(Tuple{Type{BoundsError}, Array{Expr, 1}, Base.UnitRange{Int64}})
+precompile(Tuple{getfield(Base.Cartesian, Symbol("#@ncall")), Int64, Symbol, Symbol})
+precompile(Tuple{typeof(Base.Cartesian._ncall), Int64, Symbol, Symbol})
+precompile(Tuple{typeof(Base.getindex), Tuple{Symbol}, Base.UnitRange{Int64}})
+precompile(Tuple{getfield(Base.Cartesian, Symbol("#@ncall")), Int64, Symbol, Symbol, Expr})
+precompile(Tuple{typeof(Base.Cartesian._ncall), Int64, Symbol, Symbol, Expr})
+precompile(Tuple{typeof(Base.endof), Tuple{Symbol, Expr}})
+precompile(Tuple{typeof(Base.getindex), Tuple{Symbol, Expr}, Base.UnitRange{Int64}})
+precompile(Tuple{getfield(Base.Cartesian, Symbol("#@nloops")), Int64, Symbol, Expr, Expr})
+precompile(Tuple{typeof(Base.Cartesian._nloops), Int64, Symbol, Expr, Expr})
+precompile(Tuple{typeof(Base.endof), Tuple{Expr}})
+precompile(Tuple{typeof(Base.endof), Tuple{Symbol, Symbol, Symbol}})
+precompile(Tuple{typeof(Base.getindex), Tuple{Symbol, Symbol, Symbol}, Base.UnitRange{Int64}})
+precompile(Tuple{Type{Expr}, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol})
+precompile(Tuple{typeof(Base.join), Base.GenericIOBuffer{Array{UInt8, 1}}, Tuple{String, String}, Char})
+precompile(Tuple{typeof(Base.dims2string), Tuple{Int64, Int64}})
+precompile(Tuple{typeof(Base.throw_setindex_mismatch), Base.UnitRange{Int64}, Tuple{Int64, Int64}})
+precompile(Tuple{typeof(Base.setindex_shape_check), Base.UnitRange{Int64}, Int64, Int64})
+precompile(Tuple{typeof(Base._unsafe_setindex!), Base.IndexLinear, Array{Int64, 2}, Base.UnitRange{Int64}, Base.UnitRange{Int64}, Int64})
+precompile(Tuple{Type{BoundsError}, Array{Int64, 2}, Tuple{Int64, Base.UnitRange{Int64}}})
+precompile(Tuple{typeof(Base.throw_boundserror), Array{Int64, 2}, Tuple{Int64, Base.UnitRange{Int64}}})
+precompile(Tuple{typeof(Base._unsafe_setindex!), Base.IndexLinear, Array{Int64, 2}, Base.UnitRange{Int64}, Int64, Base.UnitRange{Int64}})
+precompile(Tuple{typeof(Base.Docs.levenshtein), String, String})
+precompile(Tuple{typeof(Base.Docs.fuzzyscore), String, String})
+precompile(Tuple{typeof(Core.Inference.copy_exprargs), Array{Any, 1}})
+precompile(Tuple{typeof(Core.Inference.copy), Expr})
+precompile(Tuple{typeof(Core.Inference.copy!), Array{Any, 1}, Core.Inference.Generator{Array{Any, 1}, typeof(Core.Inference.copy_exprs)}})
+precompile(Tuple{typeof(Core.Inference._widen_all_consts!), Expr, Array{Bool, 1}})
+precompile(Tuple{typeof(Core.Inference._delete!), Core.Inference.IntSet, Int64})
+precompile(Tuple{typeof(Core.Inference.promote_type), Type{Float16}, Type{Int64}})
+precompile(Tuple{typeof(Core.Inference.mk_tuplecall), Array{Any, 1}, Core.Inference.InferenceState})
+precompile(Tuple{typeof(Core.Inference.inlining_pass), Expr, Core.Inference.InferenceState, Array{Any, 1}, Int64})
+precompile(Tuple{typeof(Core.Inference.annotate_slot_load!), Expr, Array{Any, 1}, Core.Inference.InferenceState, Array{Bool, 1}})
+precompile(Tuple{typeof(Core.Inference.record_slot_assign!), Core.Inference.InferenceState})
+precompile(Tuple{typeof(Core.Inference.type_annotate!), Core.Inference.InferenceState})
+precompile(Tuple{typeof(Core.Inference.inlining_pass!), Core.Inference.InferenceState})
+precompile(Tuple{typeof(Core.Inference.alloc_elim_pass!), Core.Inference.InferenceState})
+precompile(Tuple{typeof(Core.Inference.getfield_elim_pass!), Core.Inference.InferenceState})
+precompile(Tuple{typeof(Core.Inference.popmeta!), Array{Any, 1}, Symbol})
+precompile(Tuple{typeof(Core.Inference.widen_all_consts!), CodeInfo})
+precompile(Tuple{typeof(Core.Inference.stupdate!), Array{Any, 1}, Array{Any, 1}})
+precompile(Tuple{typeof(Core.Inference.push!), Core.Inference.IntSet, Int64})
+precompile(Tuple{typeof(Core.Inference.abstract_eval_call), Expr, Array{Any, 1}, Core.Inference.InferenceState})
+precompile(Tuple{typeof(Core.Inference.return_type_tfunc), Array{Any, 1}, Array{Any, 1}, Core.Inference.InferenceState})
+precompile(Tuple{typeof(Core.Inference.abstract_call), typeof(===), Tuple{}, Array{Any, 1}, Array{Any, 1}, Core.Inference.InferenceState})
+precompile(Tuple{typeof(Core.Inference.abstract_call), typeof(===), Array{Any, 1}, Array{Any, 1}, Array{Any, 1}, Core.Inference.InferenceState})
+precompile(Tuple{typeof(Core.Inference.type_too_complex), TypeVar, Int64})
+precompile(Tuple{typeof(Core.Inference.abstract_eval), Expr, Array{Any, 1}, Core.Inference.InferenceState})
+precompile(Tuple{typeof(Core.Inference._setint!), Core.Inference.IntSet, Int64, Bool})
+precompile(Tuple{typeof(Core.Inference.stupdate1!), Array{Any, 1}, Core.Inference.StateUpdate})
+precompile(Tuple{typeof(Core.Inference.optimize), Core.Inference.InferenceState})
+precompile(Tuple{typeof(Core.Inference.deleteat!), Core.Inference.BitArray{1}, Core.Inference.UnitRange{Int64}})
+precompile(Tuple{typeof(Core.Inference.resize!), Core.Inference.BitArray{1}, Int64})
+precompile(Tuple{typeof(Core.Inference.copy_chunks!), Array{UInt64, 1}, Int64, Array{UInt64, 1}, Int64, Int64})
+precompile(Tuple{typeof(Core.Inference.copy_chunks_rtol!), Array{UInt64, 1}, Int64, Int64, Int64})
+precompile(Tuple{typeof(Core.Inference.find_ssavalue_uses), Array{Any, 1}})
+precompile(Tuple{typeof(Base.sortperm), Array{Tuple{Float64, Int64}, 1}})
+precompile(Tuple{Type{Base.Order.Perm{O, V} where V<:(AbstractArray{T, 1} where T) where O<:Base.Order.Ordering}, Base.Order.ForwardOrdering, Array{Tuple{Float64, Int64}, 1}})
+precompile(Tuple{typeof(Base.sort!), Array{Int64, 1}, Base.Sort.QuickSortAlg, Base.Order.Perm{Base.Order.ForwardOrdering, Array{Tuple{Float64, Int64}, 1}}})
+precompile(Tuple{typeof(Base.isequal), Float64, Float64})
+precompile(Tuple{typeof(Base.isequal), Int64, Float64})
+precompile(Tuple{typeof(Base.isequal), Float64, Int64})
+precompile(Tuple{typeof(Base.isless), Int64, Float64})
+precompile(Tuple{typeof(Base.isless), Float64, Int64})
+precompile(Tuple{typeof(Base.isless), Tuple{Float64, Int64}, Tuple{Float64, Int64}})
+precompile(Tuple{typeof(Base.sort!), Array{Int64, 1}, Int64, Int64, Base.Sort.InsertionSortAlg, Base.Order.Perm{Base.Order.ForwardOrdering, Array{Tuple{Float64, Int64}, 1}}})
+precompile(Tuple{typeof(Base.Sort.partition!), Array{Int64, 1}, Int64, Int64, Base.Order.Perm{Base.Order.ForwardOrdering, Array{Tuple{Float64, Int64}, 1}}})
+precompile(Tuple{typeof(Base.sort!), Array{Int64, 1}, Int64, Int64, Base.Sort.QuickSortAlg, Base.Order.Perm{Base.Order.ForwardOrdering, Array{Tuple{Float64, Int64}, 1}}})
+precompile(Tuple{typeof(Base.getindex), Array{String, 1}, Array{Int64, 1}})
+precompile(Tuple{typeof(Base.throw_boundserror), Array{String, 1}, Tuple{Array{Int64, 1}}})
+precompile(Tuple{typeof(Base.throw_checksize_error), Array{String, 1}, Tuple{Base.OneTo{Int64}}})
+precompile(Tuple{typeof(Base._unsafe_getindex), Base.IndexLinear, Array{String, 1}, Array{Int64, 1}})
+precompile(Tuple{typeof(Base.reverse), Array{String, 1}})
+precompile(Tuple{typeof(Base.reverse), Array{String, 1}, Int64, Int64})
+precompile(Tuple{getfield(Base.Docs, Symbol("#kw##printmatches")), Array{Any, 1}, typeof(Base.Docs.printmatches), Base.TTY, String, Array{String, 1}})
+precompile(Tuple{typeof(Base.Docs.printmatch), Base.TTY, String, String})
+precompile(Tuple{typeof(Base.Markdown.with_output_format), typeof(Base.print), Array{Symbol, 1}, Base.TTY, Char})
+precompile(Tuple{typeof(Base.Docs.doc), Base.Docs.Binding})
+precompile(Tuple{typeof(Base.print), Base.GenericIOBuffer{Array{UInt8, 1}}, String, Base.Docs.Binding, String, String, String, Char})
+precompile(Tuple{typeof(Base.show_method_table), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.MethodList, Int64, Bool})
+precompile(Tuple{typeof(Base.print), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.MethodList})
+precompile(Tuple{typeof(Base.print), Base.GenericIOBuffer{Array{UInt8, 1}}, String, Base.MethodList, String, Char})
+precompile(Tuple{typeof(Base.print), Base.GenericIOBuffer{Array{UInt8, 1}}, String, String, DataType, String, DataType, Char})
+precompile(Tuple{typeof(Base.print), Base.GenericIOBuffer{Array{UInt8, 1}}, DataType, Char})
+precompile(Tuple{typeof(Base.print), Base.GenericIOBuffer{Array{UInt8, 1}}, typeof(Type), Char})
+precompile(Tuple{typeof(Base.print), Base.GenericIOBuffer{Array{UInt8, 1}}, String, Module, String, Char})
+precompile(Tuple{typeof(Base.Pkg.dir), String, String})
+precompile(Tuple{typeof(Base._setindex!), Base.Dict{Any, Any}, Array{Base.Docs.DocStr, 1}, Symbol, Int64})
+precompile(Tuple{typeof(Base._setindex!), Base.Dict{Any, Any}, Base.Docs.Binding, Symbol, Int64})
+precompile(Tuple{typeof(Base._setindex!), Base.Dict{Any, Any}, Type{Union{}}, Symbol, Int64})
+precompile(Tuple{typeof(Base._collect), Array{Base.Docs.DocStr, 1}, Base.Generator{Array{Base.Docs.DocStr, 1}, typeof(Base.Docs.parsedoc)}, Base.EltypeUnknown, Base.HasShape})
+precompile(Tuple{typeof(Base.ht_keyindex2), Base.Dict{Union{DataType, typeof(Type)}, Void}, typeof(Type)})
+precompile(Tuple{typeof(Base._setindex!), Base.Dict{Union{DataType, typeof(Type)}, Void}, Void, typeof(Type), Int64})
+precompile(Tuple{typeof(Base.ht_keyindex2), Base.Dict{Union{DataType, typeof(Type)}, Void}, DataType})
+precompile(Tuple{typeof(Base._setindex!), Base.Dict{Union{DataType, typeof(Type)}, Void}, Void, DataType, Int64})
+precompile(Tuple{typeof(Base.setindex!), Base.Dict{Union{DataType, typeof(Type)}, Void}, Void, DataType})
+precompile(Tuple{typeof(Base.setindex!), Base.Dict{Union{DataType, typeof(Type)}, Void}, Void, typeof(Type)})
+precompile(Tuple{typeof(Base.rehash!), Base.Dict{Union{DataType, typeof(Type)}, Void}, Int64})
+precompile(Tuple{typeof(Base._subtypes), Module, DataType, Base.Set{Union{DataType, typeof(Type)}}, Base.Set{Module}})
+precompile(Tuple{typeof(Base._subtypes), Module, DataType})
+precompile(Tuple{typeof(Base.isempty), Array{Int64, 1}})
+precompile(Tuple{typeof(Base.Iterators.zip), Array{Int64, 1}, SimpleVector})
+precompile(Tuple{typeof(Base.Iterators.zip), Array{Symbol, 1}, SimpleVector})
+precompile(Tuple{typeof(Base.start), Base.Iterators.Zip2{Array{Int64, 1}, SimpleVector}})
+precompile(Tuple{typeof(Base.start), Base.Iterators.Zip2{Array{Symbol, 1}, SimpleVector}})
+precompile(Tuple{typeof(Base.done), Base.Iterators.Zip2{Array{Int64, 1}, SimpleVector}, Tuple{Int64, Int64}})
+precompile(Tuple{typeof(Base.done), Base.Iterators.Zip2{Array{Symbol, 1}, SimpleVector}, Tuple{Int64, Int64}})
+precompile(Tuple{typeof(Base.next), Base.Iterators.Zip2{Array{Int64, 1}, SimpleVector}, Tuple{Int64, Int64}})
+precompile(Tuple{typeof(Base.next), Base.Iterators.Zip2{Array{Symbol, 1}, SimpleVector}, Tuple{Int64, Int64}})
+precompile(Tuple{typeof(Base.println), Base.GenericIOBuffer{Array{UInt8, 1}}, DataType})
+precompile(Tuple{typeof(Base.println), Base.GenericIOBuffer{Array{UInt8, 1}}, typeof(Type)})
+precompile(Tuple{typeof(Base.setindex!), Base.Dict{Any, Any}, Array{Base.Docs.DocStr, 1}, Symbol})
+precompile(Tuple{typeof(Base.setindex!), Base.Dict{Any, Any}, Base.Docs.Binding, Symbol})
+precompile(Tuple{typeof(Base.setindex!), Base.Dict{Any, Any}, Type{Union{}}, Symbol})
+precompile(Tuple{typeof(Base.Docs.aliasof), Base.Docs.Binding})
+precompile(Tuple{typeof(Base.Docs.summarize), Base.Docs.Binding, Type{Union{}}})
+precompile(Tuple{typeof(Base.Docs.doc), Base.Docs.Binding, Type{Union{}}})
+precompile(Tuple{typeof(Base.haskey), Base.ObjectIdDict, Base.Docs.Binding})
+precompile(Tuple{typeof(Base.getindex), Base.ObjectIdDict, Base.Docs.Binding})
+precompile(Tuple{typeof(Base.push!), Array{Base.Docs.MultiDoc, 1}, Base.Docs.MultiDoc})
+precompile(Tuple{typeof(Base.start), Array{Type{T} where T, 1}})
+precompile(Tuple{typeof(Base.done), Array{Type{T} where T, 1}, Int64})
+precompile(Tuple{typeof(Base.next), Array{Type{T} where T, 1}, Int64})
+precompile(Tuple{typeof(Base.getindex), Base.ObjectIdDict, Type{Tuple{Any}}})
+precompile(Tuple{typeof(Base.push!), Array{Base.Docs.DocStr, 1}, Base.Docs.DocStr})
+precompile(Tuple{typeof(Base.Docs.formatdoc), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.Docs.DocStr, String})
+precompile(Tuple{typeof(Base.Markdown.hashheader), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.Markdown.MD})
+precompile(Tuple{typeof(Base.Markdown.parseinline), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.Markdown.MD, Array{Function, 1}})
+precompile(Tuple{typeof(Base.Markdown.config), Base.Markdown.MD})
+precompile(Tuple{typeof(Base.Markdown.parseinline), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.Markdown.MD, Base.Markdown.Config})
+precompile(Tuple{typeof(Base.Markdown.list), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.Markdown.MD})
+precompile(Tuple{typeof(Base.searchindex), String, String})
+precompile(Tuple{typeof(Base._searchindex), Base.SubString{String}, String, Int64})
+precompile(Tuple{getfield(Base.Markdown, Symbol("#kw##skipwhitespace")), Array{Any, 1}, typeof(Base.Markdown.skipwhitespace), Base.GenericIOBuffer{Array{UInt8, 1}}})
+precompile(Tuple{typeof(Base.ht_keyindex), Base.Dict{Symbol, Base.Markdown.Config}, Symbol})
+precompile(Tuple{getfield(Base.Markdown, Symbol("#kw##parse")), Array{Any, 1}, typeof(Base.Markdown.parse), Base.GenericIOBuffer{Array{UInt8, 1}}})
+precompile(Tuple{getfield(Base.Markdown, Symbol("#kw##startswith")), Array{Any, 1}, typeof(Base.Markdown.startswith), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.Regex})
+precompile(Tuple{typeof(Core.Inference.isbits), Tuple{Int64, Base.Regex}})
+precompile(Tuple{typeof(Base.contains), String, String})
+precompile(Tuple{typeof(Base.contains), Base.SubString{String}, String})
+precompile(Tuple{typeof(Base.Markdown.pushitem!), Base.Markdown.List, Base.GenericIOBuffer{Array{UInt8, 1}}})
+precompile(Tuple{typeof(Base.Markdown.fencedcode), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.Markdown.MD})
+precompile(Tuple{getfield(Base.Markdown, Symbol("#kw##startswith")), Array{Any, 1}, typeof(Base.Markdown.startswith), Base.GenericIOBuffer{Array{UInt8, 1}}, String})
+precompile(Tuple{typeof(Base.skip), Base.GenericIOBuffer{Array{UInt8, 1}}, Int64})
+precompile(Tuple{typeof(Base.lstrip), String, Char})
+precompile(Tuple{typeof(Base.Markdown.blockquote), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.Markdown.MD})
+precompile(Tuple{getfield(Base.Markdown, Symbol("#kw##parse")), Array{Any, 1}, typeof(Base.Markdown.parse), String})
+precompile(Tuple{typeof(Base.Markdown.admonition), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.Markdown.MD})
+precompile(Tuple{typeof(Base.UTF8proc.isupper), Char})
+precompile(Tuple{getfield(Base.Markdown, Symbol("#kw##linecontains")), Array{Any, 1}, typeof(Base.Markdown.linecontains), Base.GenericIOBuffer{Array{UInt8, 1}}, String})
+precompile(Tuple{typeof(Base.ucfirst), Base.SubString{String}})
+precompile(Tuple{typeof(Base.Markdown.blocktex), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.Markdown.MD})
+precompile(Tuple{typeof(Core.Inference.length), Tuple{DataType, Core.Inference.Const, DataType}})
+precompile(Tuple{typeof(Core.Inference.getindex), Tuple{DataType, Core.Inference.Const, DataType}, Int64})
+precompile(Tuple{getfield(Base.Markdown, Symbol("#kw##parse_inline_wrapper")), Array{Any, 1}, typeof(Base.Markdown.parse_inline_wrapper), Base.GenericIOBuffer{Array{UInt8, 1}}, String})
+precompile(Tuple{typeof(Base.Markdown.startswith), Base.GenericIOBuffer{Array{UInt8, 1}}, String})
+precompile(Tuple{typeof(Base.Markdown.blockinterp), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.Markdown.MD})
+precompile(Tuple{getfield(Base, Symbol("#kw##parse")), Array{Any, 1}, typeof(Base.parse), Base.GenericIOBuffer{Array{UInt8, 1}}})
+precompile(Tuple{typeof(Base.Markdown.interpinner), Base.GenericIOBuffer{Array{UInt8, 1}}, Bool})
+precompile(Tuple{typeof(Base.Markdown.indentcode), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.Markdown.MD})
+precompile(Tuple{typeof(Base.Markdown.footnote), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.Markdown.MD})
+precompile(Tuple{Type{Base.Markdown.Footnote}, Void, Array{Any, 1}})
+precompile(Tuple{Type{Base.Markdown.Footnote}, Base.SubString{String}, Array{Any, 1}})
+precompile(Tuple{typeof(Base.Markdown.github_table), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.Markdown.MD})
+precompile(Tuple{typeof(Base.replace), String, String, String, Int64})
+precompile(Tuple{typeof(Base.pop!), Array{Base.SubString{String}, 1}})
+precompile(Tuple{typeof(Base.union!), Base.Set{Char}, String})
+precompile(Tuple{typeof(Base.ht_keyindex), Base.Dict{Char, Void}, Char})
+precompile(Tuple{typeof(Base.issubset), Base.SubString{String}, Base.Set{Char}})
+precompile(Tuple{typeof(Core.Inference.length), Tuple{Core.Inference.Const, Core.Inference.Const, Core.Inference.Const, Core.Inference.Const, Core.Inference.Const}})
+precompile(Tuple{typeof(Core.Inference.getindex), Tuple{Core.Inference.Const, Core.Inference.Const, Core.Inference.Const, Core.Inference.Const, Core.Inference.Const}, Int64})
+precompile(Tuple{typeof(Base.throw_boundserror), Base.SubArray{UInt8, 1, Array{UInt8, 1}, Tuple{Base.UnitRange{Int64}}, true}, Tuple{Int64}})
+precompile(Tuple{typeof(Base.peek), Base.GenericIOBuffer{Base.SubArray{UInt8, 1, Array{UInt8, 1}, Tuple{Base.UnitRange{Int64}}, true}}})
+precompile(Tuple{typeof(Base.Markdown.parseinline), Base.GenericIOBuffer{Base.SubArray{UInt8, 1, Array{UInt8, 1}, Tuple{Base.UnitRange{Int64}}, true}}, Base.Markdown.MD, Array{Function, 1}})
+precompile(Tuple{typeof(Base.read), Base.GenericIOBuffer{Base.SubArray{UInt8, 1, Array{UInt8, 1}, Tuple{Base.UnitRange{Int64}}, true}}, Type{Char}})
+precompile(Tuple{typeof(Base.Markdown.parseinline), Base.GenericIOBuffer{Base.SubArray{UInt8, 1, Array{UInt8, 1}, Tuple{Base.UnitRange{Int64}}, true}}, Base.Markdown.MD, Base.Markdown.Config})
+precompile(Tuple{typeof(Base.copy!), Base.IndexLinear, Array{Array{Any, 1}, 1}, Base.IndexLinear, Array{Any, 1}})
+precompile(Tuple{typeof(Base.Markdown.parsealign), Void})
+precompile(Tuple{typeof(Base.Markdown.parsealign), Array{Base.SubString{String}, 1}})
+precompile(Tuple{typeof(Base.Markdown.rowlength!), Void, Int64})
+precompile(Tuple{typeof(Base.Markdown.rowlength!), Array{Base.SubString{String}, 1}, Int64})
+precompile(Tuple{Type{Base.Markdown.Table}, Array{Any, 1}, Void})
+precompile(Tuple{Type{Base.Markdown.Table}, Array{Any, 1}, Array{Symbol, 1}})
+precompile(Tuple{typeof(Base.Markdown.horizontalrule), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.Markdown.MD})
+precompile(Tuple{typeof(Core.Inference.isbits), Base.Markdown.HorizontalRule})
+precompile(Tuple{typeof(Base.Markdown.setextheader), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.Markdown.MD})
+precompile(Tuple{typeof(Base.Markdown.paragraph), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.Markdown.MD})
+precompile(Tuple{getfield(Base.Markdown, Symbol("#kw##parse")), Array{Any, 1}, typeof(Base.Markdown.parse), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.Markdown.MD, Base.Markdown.Config})
+precompile(Tuple{getfield(Base.Markdown, Symbol("#kw##parse")), Array{Any, 1}, typeof(Base.Markdown.parse), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.Markdown.MD})
+precompile(Tuple{typeof(Base.Markdown.inline_code), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.Markdown.MD})
+precompile(Tuple{typeof(Base.Markdown.readuntil), Base.GenericIOBuffer{Array{UInt8, 1}}, String})
+precompile(Tuple{typeof(Base.Markdown.readuntil), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.SubString{String}})
+precompile(Tuple{typeof(Base.setindex!), Base.Dict{Any, Any}, Module, Symbol})
+precompile(Tuple{typeof(Base._setindex!), Base.Dict{Any, Any}, Module, Symbol, Int64})
+precompile(Tuple{typeof(Base.setindex!), Base.Dict{Any, Any}, String, Symbol})
+precompile(Tuple{typeof(Base._setindex!), Base.Dict{Any, Any}, String, Symbol, Int64})
+precompile(Tuple{typeof(Base.similar), Array{Base.Docs.DocStr, 1}, Type{Base.Markdown.MD}, Tuple{Base.OneTo{Int64}}})
+precompile(Tuple{typeof(Base.setindex!), Array{Base.Markdown.MD, 1}, Base.Markdown.MD, Int64})
+precompile(Tuple{typeof(Base.collect_to!), Array{Base.Markdown.MD, 1}, Base.Generator{Array{Base.Docs.DocStr, 1}, typeof(Base.Docs.parsedoc)}, Int64, Int64})
+precompile(Tuple{typeof(Base.unsafe_copy!), Array{Base.Markdown.MD, 1}, Int64, Array{Base.Markdown.MD, 1}, Int64, Int64})
+precompile(Tuple{typeof(Base.Docs.catdoc), Base.Markdown.MD})
+precompile(Tuple{typeof(Base.copy!), Base.IndexLinear, Array{Any, 1}, Base.IndexLinear, Array{Base.Markdown.MD, 1}})
+precompile(Tuple{Type{Base.Markdown.MD}, Array{Base.Markdown.MD, 1}})
+precompile(Tuple{Type{Base.Markdown.MD}, Base.Markdown.MD})
+precompile(Tuple{typeof(Base.vcat), Base.Markdown.MD})
+precompile(Tuple{typeof(Base.put!), Base.Channel{Any}, Tuple{Base.Markdown.MD, Void}})
+precompile(Tuple{typeof(Base.put_buffered), Base.Channel{Any}, Tuple{Base.Markdown.MD, Void}})
+precompile(Tuple{typeof(Base.put_unbuffered), Base.Channel{Any}, Tuple{Base.Markdown.MD, Void}})
+precompile(Tuple{typeof(Base.start), Tuple{Base.Markdown.MD, Void}})
+precompile(Tuple{typeof(Base.indexed_next), Tuple{Base.Markdown.MD, Void}, Int64, Int64})
+precompile(Tuple{typeof(Base.Multimedia.display), Base.Markdown.MD})
+precompile(Tuple{typeof(Base.Multimedia.display), Base.REPL.REPLDisplay{Base.REPL.LineEditREPL}, Base.Markdown.MD})
+precompile(Tuple{typeof(Base.displaysize), Base.Terminals.TTYTerminal})
+precompile(Tuple{typeof(Base.Markdown.term), Base.Terminals.TTYTerminal, Array{Any, 1}, Int64})
+precompile(Tuple{typeof(Base.Markdown.term), Base.Terminals.TTYTerminal, Base.Markdown.MD, Int64})
+precompile(Tuple{typeof(Base.Markdown.term), Base.Terminals.TTYTerminal, Base.Markdown.Code, Int64})
+precompile(Tuple{typeof(Base.write), Base.Terminals.TTYTerminal, Base.SubString{String}})
+precompile(Tuple{typeof(Base.print), Base.Terminals.TTYTerminal, Base.SubString{String}})
+precompile(Tuple{typeof(Base.print), Base.Terminals.TTYTerminal, Base.SubString{String}, Char})
+precompile(Tuple{typeof(Base.Markdown.term), Base.Terminals.TTYTerminal, Base.Markdown.Paragraph, Int64})
+precompile(Tuple{typeof(Core.Inference.eltype), Type{Array{T, 2} where T}})
+precompile(Tuple{getfield(Base.Markdown, Symbol("#kw##wrapped_lines")), Array{Any, 1}, typeof(Base.Markdown.wrapped_lines), String})
+precompile(Tuple{typeof(Base.start), Tuple{Symbol, String}})
+precompile(Tuple{typeof(Base.Markdown.terminline), Base.GenericIOBuffer{Array{UInt8, 1}}, Array{Any, 1}})
+precompile(Tuple{typeof(Base.Markdown.terminline), Base.GenericIOBuffer{Array{UInt8, 1}}, String})
+precompile(Tuple{typeof(Base.Markdown.terminline), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.Markdown.Code})
+precompile(Tuple{typeof(Base._search), Base.SubString{String}, String, Int64})
+precompile(Tuple{typeof(Base._split), Base.SubString{String}, String, Int64, Bool, Array{Base.SubString{String}, 1}})
+precompile(Tuple{getfield(Base.Markdown, Symbol("#kw##wrapped_lines")), Array{Any, 1}, typeof(Base.Markdown.wrapped_lines), Base.SubString{String}})
+precompile(Tuple{typeof(Base.endof), Array{AbstractString, 1}})
+precompile(Tuple{typeof(Base.getindex), Array{AbstractString, 1}, Base.UnitRange{Int64}})
+precompile(Tuple{typeof(Base.throw_boundserror), Array{AbstractString, 1}, Tuple{Base.UnitRange{Int64}}})
+precompile(Tuple{typeof(Base.unsafe_copy!), Array{AbstractString, 1}, Int64, Array{AbstractString, 1}, Int64, Int64})
+precompile(Tuple{typeof(Base.start), Array{AbstractString, 1}})
+precompile(Tuple{typeof(Base.done), Array{AbstractString, 1}, Int64})
+precompile(Tuple{typeof(Base.replace), String, Base.Regex, String})
+precompile(Tuple{typeof(Base.Distributed.addprocs), Int64})
+precompile(Tuple{typeof(Base.setindex!), Base.Dict{Any, Any}, Base.Cmd, Symbol})
+precompile(Tuple{typeof(Base._setindex!), Base.Dict{Any, Any}, Base.Cmd, Symbol, Int64})
+precompile(Tuple{typeof(Base.setindex!), Base.Dict{Any, Any}, Bool, Symbol})
+precompile(Tuple{typeof(Base._setindex!), Base.Dict{Any, Any}, Bool, Symbol, Int64})
+precompile(Tuple{typeof(Base.merge!), Base.Dict{Any, Any}, Base.Dict{Any, Any}, Base.Dict{Any, Any}})
+precompile(Tuple{Type{Symbol}, Symbol})
+precompile(Tuple{typeof(Core.Inference.mk_getfield), TypedSlot, Int64, Type{String}})
+precompile(Tuple{getfield(Core, Symbol("#kw#Type")), Array{Any, 1}, Type{Base.Cmd}, Base.Cmd})
+precompile(Tuple{typeof(Base.uv_status_string), Base.PipeEndpoint})
+precompile(Tuple{typeof(Base._fd), Base.PipeEndpoint})
+precompile(Tuple{typeof(Base.print), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.PipeEndpoint})
+precompile(Tuple{typeof(Base.unpreserve_handle), Base.PipeEndpoint})
+precompile(Tuple{typeof(Base.isopen), Base.PipeEndpoint})
+precompile(Tuple{typeof(Base.stream_wait), Base.PipeEndpoint, Base.Condition})
+precompile(Tuple{typeof(Base.close), Base.PipeEndpoint})
+precompile(Tuple{getfield(Base, Symbol("#kw##setenv")), Array{Any, 1}, typeof(Base.setenv), Base.Cmd})
+precompile(Tuple{Type{Base.Distributed.WorkerConfig}})
+precompile(Tuple{typeof(Base.Distributed.launch), Base.Distributed.LocalManager, Base.Dict{Any, Any}, Array{Base.Distributed.WorkerConfig, 1}, Base.Condition})
+precompile(Tuple{typeof(Base.julia_cmd), String})
+precompile(Tuple{typeof(Base.cmd_gen), Tuple{Tuple{String}, Tuple{String, String}, Tuple{String, String}, Tuple{String, String}, Tuple{String, String}}})
+precompile(Tuple{typeof(Base.arg_gen), String, String})
+precompile(Tuple{typeof(Base.cmd_gen), Tuple{Tuple{Base.Cmd}, Tuple{Base.Cmd}, Tuple{String}, Tuple{Base.Cmd}, Tuple{String}, Tuple{String}}})
+precompile(Tuple{typeof(Base.arg_gen), Base.Cmd})
+precompile(Tuple{typeof(Base.promote_type), Type{Bool}, Type{UInt8}})
+precompile(Tuple{typeof(Base.promote_rule), Type{UInt8}, Type{Bool}})
+precompile(Tuple{typeof(Base.promote_result), Type{Bool}, Type{UInt8}, Type{UInt8}, Type{Union{}}})
+precompile(Tuple{typeof(Base.promote_type), Type{UInt8}, Type{Union{}}})
+precompile(Tuple{typeof(Base.detach), Base.Cmd})
+precompile(Tuple{typeof(Base.open), Base.CmdRedirect, String, Base.DevNullStream})
+precompile(Tuple{typeof(Base.spawn), Base.CmdRedirect, Tuple{Base.DevNullStream, Base.Pipe, Base.IOStream}})
+precompile(Tuple{getfield(Base, Symbol("#kw##spawn")), Array{Any, 1}, typeof(Base.spawn), Base.Cmd, Tuple{Base.DevNullStream, Base.Pipe, Base.IOStream}})
+precompile(Tuple{getfield(Base, Symbol("#kw##init_pipe!")), Array{Any, 1}, typeof(Base.init_pipe!), Base.PipeEndpoint})
+precompile(Tuple{typeof(Base._link_pipe), Ptr{Void}, Ptr{Void}})
+precompile(Tuple{typeof(Base.link_pipe), Base.PipeEndpoint, Bool, Base.PipeEndpoint, Bool})
+precompile(Tuple{typeof(Base.close), Base.Filesystem.File})
+precompile(Tuple{typeof(Base.setup_stdio), Base.Pipe, Bool})
+precompile(Tuple{typeof(Base.setup_stdio), Base.IOStream, Bool})
+precompile(Tuple{Type{Base.Process}, Base.Cmd, Ptr{Void}, Base.DevNullStream, Base.Pipe, Base.IOStream})
+precompile(Tuple{typeof(Base._jl_spawn), String, Array{String, 1}, Ptr{Void}, Base.Process, Base.DevNullStream, Base.PipeEndpoint, Base.Filesystem.File})
+precompile(Tuple{Type{Base.Timer}, Int64, Float64})
+precompile(Tuple{typeof(Base.sleep), Int64})
+precompile(Tuple{typeof(Base._uv_hook_close), Base.PipeEndpoint})
+precompile(Tuple{typeof(Base.eltype), Type{Base.Nullable{IO}}})
+precompile(Tuple{Type{Base.Nullable{IO}}})
+precompile(Tuple{typeof(Base.eltype), Type{Base.Nullable{AbstractString}}})
+precompile(Tuple{Type{Base.Nullable{AbstractString}}})
+precompile(Tuple{typeof(Base.eltype), Type{Base.Nullable{Integer}}})
+precompile(Tuple{Type{Base.Nullable{Integer}}})
+precompile(Tuple{typeof(Base.eltype), Type{Base.Nullable{Union{Int64, Symbol}}}})
+precompile(Tuple{Type{Base.Nullable{Union{Int64, Symbol}}}})
+precompile(Tuple{typeof(Base.eltype), Type{Base.Nullable{Base.Cmd}}})
+precompile(Tuple{Type{Base.Nullable{Base.Cmd}}})
+precompile(Tuple{typeof(Base.eltype), Type{Base.Nullable{Any}}})
+precompile(Tuple{Type{Base.Nullable{Any}}})
+precompile(Tuple{typeof(Base.eltype), Type{Base.Nullable{Bool}}})
+precompile(Tuple{Type{Base.Nullable{Bool}}})
+precompile(Tuple{typeof(Base.eltype), Type{Base.Nullable{Base.Process}}})
+precompile(Tuple{Type{Base.Nullable{Base.Process}}})
+precompile(Tuple{typeof(Base.eltype), Type{Base.Nullable{Base.Dict{K, V} where V where K}}})
+precompile(Tuple{Type{Base.Nullable{Base.Dict{K, V} where V where K}}})
+precompile(Tuple{typeof(Base.eltype), Type{Base.Nullable{Array{T, N} where N where T}}})
+precompile(Tuple{Type{Base.Nullable{Array{T, N} where N where T}}})
+precompile(Tuple{typeof(Base.convert), Type{Base.Nullable{Base.Process}}, Base.Process})
+precompile(Tuple{typeof(Base.convert), Type{Base.Nullable{Bool}}, Bool})
+precompile(Tuple{typeof(Base.task_done_hook), Task})
+precompile(Tuple{typeof(Base.getindex), Tuple{Array{Any, 1}, Tuple{}}, Int64})
+precompile(Tuple{Type{Base.TCPSocket}})
+precompile(Tuple{typeof(Base.getsockname), Base.TCPSocket})
+precompile(Tuple{typeof(Base.unsafe_store!), Ptr{Int32}, Int64})
+precompile(Tuple{Type{Base.Multimedia.TextDisplay}, Base.PipeEndpoint})
+precompile(Tuple{typeof(Base.Distributed.start_worker), Base.PipeEndpoint, String})
+precompile(Tuple{typeof(Core.Inference.isbits), OutOfMemoryError})
+precompile(Tuple{typeof(Core.Inference.isbits), Tuple{Int64, Int64, Int64, Int64, Int64, Int64, Int64, Int64, Int64, Int64, Int64, Int64, Int64}})
+precompile(Tuple{typeof(Base.getaddrinfo), String})
+precompile(Tuple{typeof(Base.uv_status_string), Base.PipeEndpoint})
+precompile(Tuple{typeof(Base._fd), Base.PipeEndpoint})
+precompile(Tuple{typeof(Base.print), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.PipeEndpoint})
+precompile(Tuple{typeof(Base.print), Base.GenericIOBuffer{Array{UInt8, 1}}, UInt16})
+precompile(Tuple{typeof(Base.isopen), Base.PipeEndpoint})
+precompile(Tuple{typeof(Base.unpreserve_handle), Task})
+precompile(Tuple{typeof(Base.check_open), Base.PipeEndpoint})
+precompile(Tuple{typeof(Base.stream_wait), Task})
+precompile(Tuple{typeof(Base.uv_write), Base.PipeEndpoint, Ptr{UInt8}, UInt64})
+precompile(Tuple{typeof(Base.flush), Base.PipeEndpoint})
+precompile(Tuple{typeof(Base.unsafe_write), Base.PipeEndpoint, Ptr{UInt8}, UInt64})
+precompile(Tuple{typeof(Base.unsafe_write), Base.PipeEndpoint, Base.RefValue{UInt8}, Int64})
+precompile(Tuple{typeof(Base.uv_status_string), Base.TCPSocket})
+precompile(Tuple{typeof(Base._fd), Base.TCPSocket})
+precompile(Tuple{typeof(Base.print), Base.PipeEndpoint, String})
+precompile(Tuple{typeof(Base.print), Base.PipeEndpoint, Char})
+precompile(Tuple{typeof(Base.print), Base.PipeEndpoint, String, Char})
+precompile(Tuple{typeof(Base.print), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.TCPSocket})
+precompile(Tuple{typeof(Base.write), Base.PipeEndpoint, Char})
+precompile(Tuple{typeof(Base.isopen), Base.TCPSocket})
+precompile(Tuple{typeof(Base.unpreserve_handle), Base.TCPSocket})
+precompile(Tuple{typeof(Base.check_open), Base.TCPSocket})
+precompile(Tuple{typeof(Base.stream_wait), Base.TCPSocket, Base.Condition})
+precompile(Tuple{typeof(Base.wait_connected), Base.TCPSocket})
+precompile(Tuple{typeof(Base.print), Base.GenericIOBuffer{Array{UInt8, 1}}, String, Base.IPv4, String})
+precompile(Tuple{typeof(Base.print), Base.GenericIOBuffer{Array{UInt8, 1}}, String, Base.IPv6, String})
+precompile(Tuple{typeof(Base.Distributed.socket_reuse_port)})
+precompile(Tuple{typeof(Base.promote_type), Type{Int64}, Type{Int16}})
+precompile(Tuple{typeof(Base.promote_rule), Type{Int16}, Type{Int64}})
+precompile(Tuple{typeof(Base.promote_result), Type{Int64}, Type{Int16}, Type{Int64}, Type{Union{}}})
+precompile(Tuple{typeof(Base.Distributed.flush_gc_msgs)})
+precompile(Tuple{typeof(Base.show), Base.GenericIOBuffer{Array{UInt8, 1}}, Int16})
+precompile(Tuple{typeof(Base.print), Base.GenericIOBuffer{Array{UInt8, 1}}, Int16})
+precompile(Tuple{typeof(Base.uv_status_string), Base.PipeServer})
+precompile(Tuple{typeof(Base._fd), Base.PipeServer})
+precompile(Tuple{typeof(Base.convert), Type{Int16}, Int16})
+precompile(Tuple{typeof(Base.string), String, Int16, String, String, String, String})
+precompile(Tuple{typeof(Base.print), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.PipeServer})
+precompile(Tuple{typeof(Base.unpreserve_handle), Base.PipeServer})
+precompile(Tuple{typeof(Base.isopen), Base.PipeServer})
+precompile(Tuple{typeof(Base.accept_nonblock), Base.PipeServer, Base.PipeEndpoint})
+precompile(Tuple{typeof(Base.stream_wait), Base.PipeServer, Base.Condition})
+precompile(Tuple{getfield(Base, Symbol("#kw##init_pipe!")), Array{Any, 1}, typeof(Base.init_pipe!), Base.PipeEndpoint})
+precompile(Tuple{typeof(Base.accept), Base.PipeServer, Base.PipeEndpoint})
+precompile(Tuple{typeof(Base.accept_nonblock), Base.TCPServer, Base.TCPSocket})
+precompile(Tuple{Type{Base.TCPSocket}})
+precompile(Tuple{typeof(Base.accept), Base.TCPServer, Base.TCPSocket})
+precompile(Tuple{typeof(Base.accept), Base.TCPServer})
+precompile(Tuple{typeof(Base.tryparse_internal), Type{Int16}, Base.SubString{String}, Int64, Int64, Int64, Bool})
+precompile(Tuple{typeof(Base.parse), Type{Int16}, Base.SubString{String}})
+precompile(Tuple{typeof(Base.write), Base.PipeEndpoint, String})
+precompile(Tuple{typeof(Base.Distributed.disable_nagle), Base.TCPServer})
+precompile(Tuple{typeof(Base.Distributed.next_tunnel_port)})
+precompile(Tuple{typeof(Core.Inference.isbits), Tuple{Tuple{String}, Tuple{String}, Tuple{String}, Tuple{String}, Tuple{String}, Tuple{String}}})
+precompile(Tuple{typeof(Base.cmd_gen), Tuple{Tuple{String}, Tuple{String}, Tuple{String}, Tuple{String}, Tuple{String}, Tuple{String}}})
+precompile(Tuple{typeof(Base._delete!), Base.Dict{Int64, Union{Base.Distributed.Worker, Base.Distributed.LocalProcess}}, Int64})
+precompile(Tuple{typeof(Base.ndigits0z), UInt8})
+precompile(Tuple{typeof(Base.dec), UInt8, Int64, Bool})
+precompile(Tuple{typeof(Core.Inference.length), Tuple{Core.Inference.Const, typeof(Type), Core.Inference.Const}})
+precompile(Tuple{typeof(Core.Inference.getindex), Tuple{Core.Inference.Const, typeof(Type), Core.Inference.Const}, Int64})
+precompile(Tuple{typeof(Base.Distributed.send_msg_), Base.Distributed.Worker, Base.Distributed.MsgHeader, Base.Distributed.JoinPGRPMsg, Bool})
+precompile(Tuple{typeof(Base.Distributed.send_msg_now), Base.Distributed.Worker, Base.Distributed.MsgHeader, Base.Distributed.JoinPGRPMsg})
+precompile(Tuple{typeof(Base.rehash!), Base.Dict{Int64, Void}, Int64})
+precompile(Tuple{typeof(Base.ht_keyindex2), Base.Dict{Int64, Void}, Int64})
+precompile(Tuple{typeof(Base._setindex!), Base.Dict{Int64, Void}, Void, Int64, Int64})
+precompile(Tuple{typeof(Base.rehash!), Base.Dict{AbstractString, Base.Semaphore}, Int64})
+precompile(Tuple{typeof(Base.resize!), Array{Base.Semaphore, 1}, Int64})
+precompile(Tuple{typeof(Base.Distributed.connect_w2w), Int64, Base.Distributed.WorkerConfig})
+precompile(Tuple{typeof(Base.acquire), Base.Semaphore})
+precompile(Tuple{typeof(Base.release), Base.Semaphore})
+precompile(Tuple{typeof(Base.Distributed.create_worker), Base.Distributed.LocalManager, Base.Distributed.WorkerConfig})
+precompile(Tuple{typeof(Base.Distributed.setup_launched_worker), Base.Distributed.LocalManager, Base.Distributed.WorkerConfig, Array{Int64, 1}})
+precompile(Tuple{typeof(Base.connect), Base.Distributed.LocalManager, Int64, Base.Distributed.WorkerConfig})
+precompile(Tuple{typeof(Base.Distributed.read_worker_host_port), Base.Pipe})
+precompile(Tuple{typeof(Base.isreadable), Base.PipeEndpoint})
+precompile(Tuple{typeof(Base.search), Base.GenericIOBuffer{Array{UInt8, 1}}, UInt8})
+precompile(Tuple{typeof(Base.start_reading), Base.PipeEndpoint})
+precompile(Tuple{typeof(Base.wait_readbyte), Base.PipeEndpoint, UInt8})
+precompile(Tuple{typeof(Base.readuntil), Base.PipeEndpoint, UInt8})
+precompile(Tuple{typeof(Base.alloc_buf_hook), Base.PipeEndpoint, UInt64})
+precompile(Tuple{typeof(Base._uv_hook_close), Base.Timer})
+precompile(Tuple{typeof(Base.notify), Base.Condition, Base.EOFError, Bool, Bool})
+precompile(Tuple{typeof(Base.unpreserve_handle), Base.Timer})
+precompile(Tuple{typeof(Base.disassociate_julia_struct), Base.Timer})
+precompile(Tuple{typeof(Base.Distributed.parse_connection_info), String})
+precompile(Tuple{typeof(Base._uv_hook_close), Base.Timer})
+precompile(Tuple{typeof(Base.notify), Base.Condition, Base.EOFError, Bool, Bool})
+precompile(Tuple{typeof(Base.unpreserve_handle), Base.Timer})
+precompile(Tuple{typeof(Base.disassociate_julia_struct), Base.Timer})
+precompile(Tuple{typeof(Base.convert), Type{Base.Nullable{AbstractString}}, Base.SubString{String}})
+precompile(Tuple{typeof(Base.Distributed.connect_to_worker), Base.SubString{String}, Int16})
+precompile(Tuple{typeof(Base.connect!), Base.TCPSocket, Base.SubString{String}, UInt16})
+precompile(Tuple{typeof(Base.notify), Base.Condition, Base.IPv4, Bool, Bool})
+precompile(Tuple{typeof(Base.schedule), Task, Base.IPv4})
+precompile(Tuple{typeof(Base.connect!), Base.TCPSocket, Base.IPv4, UInt16})
+precompile(Tuple{typeof(Base.Distributed.process_messages), Base.TCPSocket, Base.TCPSocket, Bool})
+precompile(Tuple{typeof(Base.uv_status_string), Base.TCPSocket})
+precompile(Tuple{typeof(Base._fd), Base.TCPSocket})
+precompile(Tuple{typeof(Base.print), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.TCPSocket})
+precompile(Tuple{typeof(Base.isopen), Base.TCPSocket})
+precompile(Tuple{typeof(Base.convert), Type{Base.Nullable{AbstractString}}, String})
+precompile(Tuple{typeof(Base.unpreserve_handle), Base.TCPSocket})
+precompile(Tuple{typeof(Base.check_open), Base.TCPSocket})
+precompile(Tuple{typeof(Base.stream_wait), Base.TCPSocket, Base.Condition})
+precompile(Tuple{getfield(Core, Symbol("#kw#Type")), Array{Any, 1}, Type{Base.Distributed.Worker}, Int64, Base.TCPSocket, Base.TCPSocket, Base.Distributed.LocalManager})
+precompile(Tuple{typeof(Base.read_sub), Base.GenericIOBuffer{Array{UInt8, 1}}, Array{UInt8, 1}, Int64, Int64})
+precompile(Tuple{typeof(Base.isreadable), Base.TCPSocket})
+precompile(Tuple{typeof(Base.start_reading), Base.TCPSocket})
+precompile(Tuple{typeof(Base.write_sub), Base.GenericIOBuffer{Array{UInt8, 1}}, Array{UInt8, 1}, Int64, Int64})
+precompile(Tuple{typeof(Base.readbytes!), Base.GenericIOBuffer{Array{UInt8, 1}}, Array{UInt8, 1}, Int64})
+precompile(Tuple{typeof(Base.wait_readnb), Base.TCPSocket, Int64})
+precompile(Tuple{typeof(Base.write), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.GenericIOBuffer{Array{UInt8, 1}}})
+precompile(Tuple{typeof(Base.readbytes!), Base.TCPSocket, Array{UInt8, 1}, Int64})
+precompile(Tuple{typeof(Base.read), Base.TCPSocket, Int64})
+precompile(Tuple{typeof(Base.Distributed.worker_id_from_socket), Base.TCPSocket})
+precompile(Tuple{Type{Base.Distributed.ClusterSerializer{Base.TCPSocket}}, Base.TCPSocket})
+precompile(Tuple{typeof(Base.unsafe_read), Base.TCPSocket, Ptr{UInt8}, UInt64})
+precompile(Tuple{typeof(Base.read!), Base.TCPSocket, Array{Int64, 1}})
+precompile(Tuple{typeof(Base.read), Base.TCPSocket, Type{UInt8}})
+precompile(Tuple{typeof(Base.Distributed.send_msg_), Base.Distributed.Worker, Base.Distributed.MsgHeader, Base.Distributed.ResultMsg, Bool})
+precompile(Tuple{typeof(Base.Distributed.send_msg_now), Base.Distributed.Worker, Base.Distributed.MsgHeader, Base.Distributed.ResultMsg})
+precompile(Tuple{Type{Core.Inference.Generator{I, F} where F where I}, Type{Core.Inference.Const}, Tuple{Int64, typeof(Base.Distributed.rmprocs)}})
+precompile(Tuple{Type{Core.Inference.Generator{Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Type{Core.Inference.Const}}}, Type{Core.Inference.Const}, Tuple{Int64, typeof(Base.Distributed.rmprocs)}})
+precompile(Tuple{typeof(Core.Inference.convert), Type{Tuple{Int64, typeof(Base.Distributed.rmprocs)}}, Tuple{Int64, typeof(Base.Distributed.rmprocs)}})
+precompile(Tuple{typeof(Core.Inference.collect), Type{Any}, Core.Inference.Generator{Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Type{Core.Inference.Const}}})
+precompile(Tuple{typeof(Core.Inference.iteratorsize), Core.Inference.Generator{Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Type{Core.Inference.Const}}})
+precompile(Tuple{typeof(Core.Inference.iteratorsize), Type{Core.Inference.Generator{Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Type{Core.Inference.Const}}}})
+precompile(Tuple{typeof(Core.Inference.iteratorsize), Type{Tuple{Int64, typeof(Base.Distributed.rmprocs)}}})
+precompile(Tuple{typeof(Core.Inference._collect), Type{Any}, Core.Inference.Generator{Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Type{Core.Inference.Const}}, Core.Inference.HasLength})
+precompile(Tuple{typeof(Core.Inference.length), Core.Inference.Generator{Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Type{Core.Inference.Const}}})
+precompile(Tuple{typeof(Core.Inference.length), Tuple{Int64, typeof(Base.Distributed.rmprocs)}})
+precompile(Tuple{typeof(Core.Inference.copy!), Array{Any, 1}, Core.Inference.Generator{Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Type{Core.Inference.Const}}})
+precompile(Tuple{typeof(Core.Inference.start), Core.Inference.Generator{Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Type{Core.Inference.Const}}})
+precompile(Tuple{typeof(Core.Inference.start), Tuple{Int64, typeof(Base.Distributed.rmprocs)}})
+precompile(Tuple{typeof(Core.Inference.done), Core.Inference.Generator{Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Type{Core.Inference.Const}}, Int64})
+precompile(Tuple{typeof(Core.Inference.done), Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Int64})
+precompile(Tuple{typeof(Core.Inference.next), Core.Inference.Generator{Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Type{Core.Inference.Const}}, Int64})
+precompile(Tuple{typeof(Core.Inference.next), Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Int64})
+precompile(Tuple{typeof(Core.Inference.getindex), Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Int64})
+precompile(Tuple{typeof(Core.Inference.start), Tuple{typeof(Base.Distributed.rmprocs), Int64}})
+precompile(Tuple{typeof(Core.Inference.indexed_next), Tuple{typeof(Base.Distributed.rmprocs), Int64}, Int64, Int64})
+precompile(Tuple{typeof(Core.Inference.getindex), Tuple{typeof(Base.Distributed.rmprocs), Int64}, Int64})
+precompile(Tuple{typeof(Base.Distributed.register_worker_streams), Base.Distributed.Worker})
+precompile(Tuple{typeof(Base.Distributed.register_worker_streams), Base.Distributed.LocalProcess})
+precompile(Tuple{typeof(Base.convert), Type{IO}, Base.TCPSocket})
+precompile(Tuple{Type{Base.Distributed.ClusterSerializer{Base.TCPSocket}}, Base.TCPSocket})
+precompile(Tuple{typeof(Base.Distributed.worker_id_from_socket), Base.TCPSocket})
+precompile(Tuple{typeof(Base.convert), Type{Base.Distributed.ClusterSerializer{I} where I<:IO}, Base.Distributed.ClusterSerializer{Base.TCPSocket}})
+precompile(Tuple{typeof(Base.convert), Type{Base.Distributed.ClusterManager}, Base.Distributed.LocalManager})
+precompile(Tuple{typeof(Base.convert), Type{Base.Distributed.WorkerConfig}, Base.Distributed.WorkerConfig})
+precompile(Tuple{typeof(Base.convert), Type{Base.Nullable{Base.VersionNumber}}, Base.Nullable{Base.VersionNumber}})
+precompile(Tuple{typeof(Base.join), Base.GenericIOBuffer{Array{UInt8, 1}}, Tuple{Int64}, Char})
+precompile(Tuple{typeof(Base.get), Base.Dict{Any, Any}, Base.Distributed.RRID, Bool})
+precompile(Tuple{typeof(Base.ht_keyindex), Base.Dict{Any, Any}, Base.Distributed.RRID})
+precompile(Tuple{typeof(Core.Inference.isbits), Tuple{Int64, typeof(Base.Distributed.rmprocs)}})
+precompile(Tuple{Type{Core.Inference.Generator{I, F} where F where I}, Type{QuoteNode}, Tuple{Int64, typeof(Base.Distributed.rmprocs)}})
+precompile(Tuple{Type{Core.Inference.Generator{Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Type{QuoteNode}}}, Type{QuoteNode}, Tuple{Int64, typeof(Base.Distributed.rmprocs)}})
+precompile(Tuple{typeof(Core.Inference.iteratorsize), Type{Core.Inference.Generator{Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Type{QuoteNode}}}})
+precompile(Tuple{typeof(Core.Inference._collect), Type{Any}, Core.Inference.Generator{Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Type{QuoteNode}}, Core.Inference.HasLength})
+precompile(Tuple{typeof(Core.Inference.length), Core.Inference.Generator{Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Type{QuoteNode}}})
+precompile(Tuple{typeof(Core.Inference.copy!), Array{Any, 1}, Core.Inference.Generator{Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Type{QuoteNode}}})
+precompile(Tuple{typeof(Core.Inference.start), Core.Inference.Generator{Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Type{QuoteNode}}})
+precompile(Tuple{typeof(Core.Inference.done), Core.Inference.Generator{Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Type{QuoteNode}}, Int64})
+precompile(Tuple{typeof(Core.Inference.next), Core.Inference.Generator{Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Type{QuoteNode}}, Int64})
+precompile(Tuple{typeof(Base.Distributed.local_remotecall_thunk), typeof(Base.Distributed.rmprocs), Tuple{Int64}, Array{Any, 1}})
+precompile(Tuple{typeof(Base.Distributed.remote_do), typeof(Base.Distributed.rmprocs), Base.Distributed.Worker, Int64})
+precompile(Tuple{typeof(Base.Distributed.remote_do), typeof(Base.Distributed.rmprocs), Base.Distributed.LocalProcess, Int64})
+precompile(Tuple{getfield(Base.Distributed, Symbol("#kw##remote_do")), Array{Any, 1}, typeof(Base.Distributed.remote_do), typeof(Base.Distributed.rmprocs), Base.Distributed.Worker, Int64})
+precompile(Tuple{getfield(Base.Distributed, Symbol("#kw##remote_do")), Array{Any, 1}, typeof(Base.Distributed.remote_do), typeof(Base.Distributed.rmprocs), Base.Distributed.LocalProcess, Int64})
+precompile(Tuple{Type{Base.Distributed.ResultMsg}, Base.Distributed.RemoteException})
+precompile(Tuple{Type{Base.Distributed.ResultMsg}, Symbol})
+precompile(Tuple{typeof(Base.Distributed.send_msg_now), Base.TCPSocket, Base.Distributed.MsgHeader, Base.Distributed.ResultMsg})
+precompile(Tuple{typeof(Base.close), Base.TCPSocket})
+precompile(Tuple{typeof(Base._delete!), Base.Dict{Int64, Union{Base.Distributed.Worker, Base.Distributed.LocalProcess}}, Int64})
+precompile(Tuple{typeof(Base.Distributed.def_rv_channel)})
+precompile(Tuple{typeof(Base.convert), Type{Base.AbstractChannel}, Base.Channel{Any}})
+precompile(Tuple{typeof(Base.ndigits0z), UInt8})
+precompile(Tuple{typeof(Base.setindex!), Base.Dict{Any, Any}, Base.Distributed.RemoteValue, Base.Distributed.RRID})
+precompile(Tuple{typeof(Base.dec), UInt8, Int64, Bool})
+precompile(Tuple{typeof(Core.Inference.mk_getfield), TypedSlot, Int64, Type{Integer}})
+precompile(Tuple{typeof(Base.ht_keyindex2), Base.Dict{Any, Any}, Base.Distributed.RRID})
+precompile(Tuple{typeof(Base._setindex!), Base.Dict{Any, Any}, Base.Distributed.RemoteValue, Base.Distributed.RRID, Int64})
+precompile(Tuple{typeof(Core.Inference.length), Tuple{Core.Inference.Const, DataType, Core.Inference.Const}})
+precompile(Tuple{typeof(Core.Inference.getindex), Tuple{Core.Inference.Const, DataType, Core.Inference.Const}, Int64})
+precompile(Tuple{typeof(Base.notify), Base.Condition, Base.Distributed.ProcessExitedException, Bool, Bool})
+precompile(Tuple{typeof(Base.rehash!), Base.Dict{Int64, Void}, Int64})
+precompile(Tuple{typeof(Base.Distributed.process_messages), Base.TCPSocket, Base.TCPSocket, Bool})
+precompile(Tuple{typeof(Base.ht_keyindex2), Base.Dict{Int64, Void}, Int64})
+precompile(Tuple{typeof(Base._setindex!), Base.Dict{Int64, Void}, Void, Int64, Int64})
+precompile(Tuple{typeof(Base.setindex!), Base.Dict{Int64, Void}, Void, Int64})
+precompile(Tuple{typeof(Base.pop!), Base.Dict{Int64, Union{Base.Distributed.Worker, Base.Distributed.LocalProcess}}, Int64, Void})
+precompile(Tuple{typeof(Base.Distributed.send_connection_hdr), Base.Distributed.Worker, Bool})
+precompile(Tuple{typeof(Base.Distributed.deregister_worker), Base.Distributed.ProcessGroup, Int64})
+precompile(Tuple{typeof(Base.Distributed.process_hdr), Base.TCPSocket, Bool})
+precompile(Tuple{typeof(Base.Distributed.deserialize_msg), Base.Distributed.ClusterSerializer{Base.TCPSocket}})
+precompile(Tuple{typeof(Base.Distributed.null_id), Base.Distributed.RRID})
+precompile(Tuple{typeof(Base.Distributed.deliver_result), Base.TCPSocket, Symbol, Base.Distributed.RRID, Base.Distributed.RemoteException})
+precompile(Tuple{typeof(Base.Distributed.disable_nagle), Base.TCPSocket})
+precompile(Tuple{typeof(Base.wait_connected), Base.TCPSocket})
+precompile(Tuple{typeof(Base.Distributed.message_handler_loop), Base.TCPSocket, Base.TCPSocket, Bool})
+precompile(Tuple{typeof(Base.Distributed.process_tcp_streams), Base.TCPSocket, Base.TCPSocket, Bool})
+precompile(Tuple{typeof(Base.write), Base.TCPSocket, String})
+precompile(Tuple{typeof(Base.uv_write), Base.TCPSocket, Ptr{UInt8}, UInt64})
+precompile(Tuple{typeof(Base.flush), Base.TCPSocket})
+precompile(Tuple{typeof(Base.unsafe_write), Base.TCPSocket, Ptr{UInt8}, UInt64})
+precompile(Tuple{Type{Base.Distributed.JoinPGRPMsg}, Int64, Array{Union{Tuple{Any, Int64}, Tuple{Tuple{}, Any, Bool}}, 1}, Symbol, Bool})
+precompile(Tuple{typeof(Base.write), Base.TCPSocket, Int64, Int64, Int64, Int64})
+precompile(Tuple{typeof(Base.unsafe_write), Base.TCPSocket, Base.RefValue{Int64}, Int64})
+precompile(Tuple{typeof(Base.Serializer.serialize), Base.Distributed.ClusterSerializer{Base.TCPSocket}, Base.Distributed.JoinPGRPMsg})
+precompile(Tuple{typeof(Base.unsafe_write), Base.TCPSocket, Base.RefValue{UInt8}, Int64})
+precompile(Tuple{typeof(Base.Serializer.serialize), Base.Distributed.ClusterSerializer{Base.TCPSocket}, Int64})
+precompile(Tuple{typeof(Base.Serializer.serialize), Base.Distributed.ClusterSerializer{Base.TCPSocket}, Array{Union{Tuple{Any, Int64}, Tuple{Tuple{}, Any, Bool}}, 1}})
+precompile(Tuple{typeof(Core.Inference.length), Tuple{Core.Inference.Const, DataType, Core.Inference.Const}})
+precompile(Tuple{typeof(Core.Inference.getindex), Tuple{Core.Inference.Const, DataType, Core.Inference.Const}, Int64})
+precompile(Tuple{typeof(Base.unsafe_write), Base.TCPSocket, Base.RefValue{Int32}, Int64})
+precompile(Tuple{typeof(Base.Serializer.write_as_tag), Base.TCPSocket, Int32})
+precompile(Tuple{typeof(Base.copy!), Array{Any, 1}, Base.MethodList})
+precompile(Tuple{typeof(Base.Serializer.should_send_whole_type), Base.Distributed.ClusterSerializer{Base.TCPSocket}, Type{Any}})
+precompile(Tuple{typeof(Base.Serializer.serialize), Base.Distributed.ClusterSerializer{Base.TCPSocket}, SimpleVector})
+precompile(Tuple{typeof(Base.Serializer.serialize_type_data), Base.Distributed.ClusterSerializer{Base.TCPSocket}, Type{Any}, Bool})
+precompile(Tuple{typeof(Base.Serializer.serialize), Base.Distributed.ClusterSerializer{Base.TCPSocket}, Type{Any}})
+precompile(Tuple{typeof(Base.Serializer.serialize), Base.Distributed.ClusterSerializer{Base.TCPSocket}, Tuple{Int64}})
+precompile(Tuple{typeof(Base.ht_keyindex), Base.Dict{UInt64, UInt64}, UInt64})
+precompile(Tuple{typeof(Base.unique), Array{Symbol, 1}})
+precompile(Tuple{typeof(Base.Serializer.serialize_cycle), Base.Distributed.ClusterSerializer{Base.TCPSocket}, Type{Union{Tuple{Any, Int64}, Tuple{Tuple{}, Any, Bool}}}})
+precompile(Tuple{typeof(Base.Serializer.serialize_type), Base.Distributed.ClusterSerializer{Base.TCPSocket}, DataType})
+precompile(Tuple{typeof(Base.rehash!), Base.Dict{UInt64, UInt64}, Int64})
+precompile(Tuple{typeof(Base.resize!), Array{UInt64, 1}, Int64})
+precompile(Tuple{typeof(Base.ht_keyindex2), Base.Dict{UInt64, UInt64}, UInt64})
+precompile(Tuple{typeof(Base.Serializer.serialize), Base.Distributed.ClusterSerializer{Base.TCPSocket}, Bool})
+precompile(Tuple{typeof(Base.Distributed.serialize_global_from_main), Base.Distributed.ClusterSerializer{Base.TCPSocket}, Symbol})
+precompile(Tuple{typeof(Base.Serializer.serialize_mod_names), Base.Distributed.ClusterSerializer{Base.TCPSocket}, Module})
+precompile(Tuple{typeof(Base.Serializer.serialize), Base.Distributed.ClusterSerializer{Base.TCPSocket}, Symbol})
+precompile(Tuple{typeof(Core.Inference.isbits), Symbol})
+precompile(Tuple{typeof(Base.Serializer.serialize), Base.Distributed.ClusterSerializer{Base.TCPSocket}, Module})
+precompile(Tuple{typeof(Base.isassigned), Array{Symbol, 1}, Int64})
+precompile(Tuple{typeof(Base.rehash!), Base.Dict{UInt64, Void}, Int64})
+precompile(Tuple{typeof(Base.ht_keyindex2), Base.Dict{UInt64, Void}, UInt64})
+precompile(Tuple{typeof(Base._setindex!), Base.Dict{UInt64, Void}, Void, UInt64, Int64})
+precompile(Tuple{typeof(Base.Serializer.serialize), Base.Distributed.ClusterSerializer{Base.TCPSocket}, Array{Any, 1}})
+precompile(Tuple{typeof(Base.ht_keyindex), Base.Dict{WeakRef, Any}, TypeName})
+precompile(Tuple{typeof(Base.Serializer.serialize_cycle), Base.Distributed.ClusterSerializer{Base.TCPSocket}, TypeName})
+precompile(Tuple{typeof(Base.Serializer.object_number), TypeName})
+precompile(Tuple{typeof(Base.Serializer.serialize_typename), Base.Distributed.ClusterSerializer{Base.TCPSocket}, TypeName})
+precompile(Tuple{typeof(Base.Serializer.serialize), Base.Distributed.ClusterSerializer{Base.TCPSocket}, Array{Symbol, 1}})
+precompile(Tuple{typeof(Base.Serializer.serialize), Base.Distributed.ClusterSerializer{Base.TCPSocket}, TypeName})
+precompile(Tuple{typeof(Base.Serializer.serialize_cycle_header), Base.Distributed.ClusterSerializer{Base.TCPSocket}, Type{Union{Tuple{Any, Int64}, Tuple{Tuple{}, Any, Bool}}}})
+precompile(Tuple{typeof(Base.Serializer.serialize_any), Base.Distributed.ClusterSerializer{Base.TCPSocket}, Type{Union{Tuple{Any, Int64}, Tuple{Tuple{}, Any, Bool}}}})
+precompile(Tuple{typeof(Base.isassigned), Array{Union{Tuple{Any, Int64}, Tuple{Tuple{}, Any, Bool}}, 1}, Int64})
+precompile(Tuple{typeof(Base.uvfinalize), Base.TCPSocket})
+precompile(Tuple{typeof(Base.close), Base.TCPSocket})
+precompile(Tuple{typeof(Base.write), Base.TCPSocket, Array{UInt8, 1}})
+precompile(Tuple{typeof(Base.wait_readnb), Base.PipeEndpoint, Int64})
+precompile(Tuple{typeof(Base.eof), Base.PipeEndpoint})
+precompile(Tuple{typeof(Base.unsafe_read), Base.TCPSocket, Base.RefValue{Int32}, Int64})
+precompile(Tuple{typeof(Base.unsafe_read), Base.TCPSocket, Base.RefValue{Int64}, Int64})
+precompile(Tuple{typeof(Base.read!), Base.TCPSocket, Array{UInt8, 1}})
+precompile(Tuple{typeof(Base.read_sub), Base.GenericIOBuffer{Array{UInt8, 1}}, Array{UInt8, 1}, Int64, Int64})
+precompile(Tuple{typeof(Base.isreadable), Base.TCPSocket})
+precompile(Tuple{typeof(Base.start_reading), Base.TCPSocket})
+precompile(Tuple{typeof(Base.write_sub), Base.GenericIOBuffer{Array{UInt8, 1}}, Array{UInt8, 1}, Int64, Int64})
+precompile(Tuple{typeof(Base.readbytes!), Base.GenericIOBuffer{Array{UInt8, 1}}, Array{UInt8, 1}, Int64})
+precompile(Tuple{typeof(Base.wait_readnb), Base.TCPSocket, Int64})
+precompile(Tuple{typeof(Base.write), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.GenericIOBuffer{Array{UInt8, 1}}})
+precompile(Tuple{typeof(Base.readbytes!), Base.TCPSocket, Array{UInt8, 1}, Int64})
+precompile(Tuple{typeof(Base.read), Base.TCPSocket, Int64})
+precompile(Tuple{typeof(Base.promote_type), Type{Int64}, Type{UInt8}})
+precompile(Tuple{typeof(Base.promote_rule), Type{Int64}, Type{UInt8}})
+precompile(Tuple{typeof(Base.promote_result), Type{Int64}, Type{UInt8}, Type{Union{}}, Type{Int64}})
+precompile(Tuple{typeof(Base.read!), Base.TCPSocket, Array{UInt64, 1}})
+precompile(Tuple{typeof(Base.unsafe_read), Base.TCPSocket, Ptr{UInt8}, UInt64})
+precompile(Tuple{typeof(Base.read!), Base.TCPSocket, Array{Int64, 1}})
+precompile(Tuple{typeof(Base.read), Base.TCPSocket, Type{UInt8}})
+precompile(Tuple{typeof(Base.Distributed.send_msg_), Base.Distributed.Worker, Base.Distributed.MsgHeader, Base.Distributed.ResultMsg, Bool})
+precompile(Tuple{typeof(Base.Distributed.send_msg_now), Base.Distributed.Worker, Base.Distributed.MsgHeader, Base.Distributed.ResultMsg})
+precompile(Tuple{Type{Core.Inference.Generator{I, F} where F where I}, Type{Core.Inference.Const}, Tuple{Int64, typeof(Base.Distributed.rmprocs)}})
+precompile(Tuple{Type{Core.Inference.Generator{Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Type{Core.Inference.Const}}}, Type{Core.Inference.Const}, Tuple{Int64, typeof(Base.Distributed.rmprocs)}})
+precompile(Tuple{typeof(Core.Inference.convert), Type{Tuple{Int64, typeof(Base.Distributed.rmprocs)}}, Tuple{Int64, typeof(Base.Distributed.rmprocs)}})
+precompile(Tuple{typeof(Core.Inference.collect), Type{Any}, Core.Inference.Generator{Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Type{Core.Inference.Const}}})
+precompile(Tuple{typeof(Core.Inference.iteratorsize), Core.Inference.Generator{Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Type{Core.Inference.Const}}})
+precompile(Tuple{typeof(Core.Inference.iteratorsize), Type{Core.Inference.Generator{Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Type{Core.Inference.Const}}}})
+precompile(Tuple{typeof(Core.Inference.iteratorsize), Type{Tuple{Int64, typeof(Base.Distributed.rmprocs)}}})
+precompile(Tuple{typeof(Core.Inference._collect), Type{Any}, Core.Inference.Generator{Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Type{Core.Inference.Const}}, Core.Inference.HasLength})
+precompile(Tuple{typeof(Core.Inference.length), Core.Inference.Generator{Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Type{Core.Inference.Const}}})
+precompile(Tuple{typeof(Core.Inference.length), Tuple{Int64, typeof(Base.Distributed.rmprocs)}})
+precompile(Tuple{typeof(Core.Inference.copy!), Array{Any, 1}, Core.Inference.Generator{Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Type{Core.Inference.Const}}})
+precompile(Tuple{typeof(Core.Inference.start), Core.Inference.Generator{Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Type{Core.Inference.Const}}})
+precompile(Tuple{typeof(Core.Inference.start), Tuple{Int64, typeof(Base.Distributed.rmprocs)}})
+precompile(Tuple{typeof(Core.Inference.done), Core.Inference.Generator{Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Type{Core.Inference.Const}}, Int64})
+precompile(Tuple{typeof(Core.Inference.done), Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Int64})
+precompile(Tuple{typeof(Core.Inference.next), Core.Inference.Generator{Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Type{Core.Inference.Const}}, Int64})
+precompile(Tuple{typeof(Core.Inference.next), Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Int64})
+precompile(Tuple{typeof(Core.Inference.getindex), Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Int64})
+precompile(Tuple{typeof(Core.Inference.start), Tuple{typeof(Base.Distributed.rmprocs), Int64}})
+precompile(Tuple{typeof(Core.Inference.indexed_next), Tuple{typeof(Base.Distributed.rmprocs), Int64}, Int64, Int64})
+precompile(Tuple{typeof(Core.Inference.getindex), Tuple{typeof(Base.Distributed.rmprocs), Int64}, Int64})
+precompile(Tuple{typeof(Base.Serializer.deserialize), Base.Distributed.ClusterSerializer{Base.TCPSocket}})
+precompile(Tuple{typeof(Base.Serializer.deserialize_cycle), Base.Distributed.ClusterSerializer{Base.TCPSocket}, Expr})
+precompile(Tuple{typeof(Base.Serializer.handle_deserialize), Base.Distributed.ClusterSerializer{Base.TCPSocket}, Int32})
+precompile(Tuple{typeof(Base._array_for), Type{Union{}}, Base.UnitRange{Int64}, Base.HasShape})
+precompile(Tuple{typeof(Base.Serializer.deserialize_array), Base.Distributed.ClusterSerializer{Base.TCPSocket}})
+precompile(Tuple{typeof(Base.Serializer.deserialize_datatype), Base.Distributed.ClusterSerializer{Base.TCPSocket}})
+precompile(Tuple{typeof(Base.Serializer.deserialize_expr), Base.Distributed.ClusterSerializer{Base.TCPSocket}, Int64})
+precompile(Tuple{typeof(Base.join), Base.GenericIOBuffer{Array{UInt8, 1}}, Tuple{Int64}, Char})
+precompile(Tuple{typeof(Core.Inference.isbits), Tuple{Int64, typeof(Base.Distributed.rmprocs)}})
+precompile(Tuple{Type{Core.Inference.Generator{I, F} where F where I}, Type{QuoteNode}, Tuple{Int64, typeof(Base.Distributed.rmprocs)}})
+precompile(Tuple{Type{Core.Inference.Generator{Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Type{QuoteNode}}}, Type{QuoteNode}, Tuple{Int64, typeof(Base.Distributed.rmprocs)}})
+precompile(Tuple{typeof(Core.Inference.iteratorsize), Type{Core.Inference.Generator{Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Type{QuoteNode}}}})
+precompile(Tuple{typeof(Core.Inference._collect), Type{Any}, Core.Inference.Generator{Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Type{QuoteNode}}, Core.Inference.HasLength})
+precompile(Tuple{typeof(Core.Inference.length), Core.Inference.Generator{Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Type{QuoteNode}}})
+precompile(Tuple{typeof(Core.Inference.copy!), Array{Any, 1}, Core.Inference.Generator{Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Type{QuoteNode}}})
+precompile(Tuple{typeof(Core.Inference.start), Core.Inference.Generator{Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Type{QuoteNode}}})
+precompile(Tuple{typeof(Core.Inference.done), Core.Inference.Generator{Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Type{QuoteNode}}, Int64})
+precompile(Tuple{typeof(Core.Inference.next), Core.Inference.Generator{Tuple{Int64, typeof(Base.Distributed.rmprocs)}, Type{QuoteNode}}, Int64})
+precompile(Tuple{typeof(Base.Distributed.local_remotecall_thunk), typeof(Base.Distributed.rmprocs), Tuple{Int64}, Array{Any, 1}})
+precompile(Tuple{typeof(Base.Distributed.remote_do), typeof(Base.Distributed.rmprocs), Base.Distributed.Worker, Int64})
+precompile(Tuple{typeof(Base.Distributed.remote_do), typeof(Base.Distributed.rmprocs), Base.Distributed.LocalProcess, Int64})
+precompile(Tuple{getfield(Base.Distributed, Symbol("#kw##remote_do")), Array{Any, 1}, typeof(Base.Distributed.remote_do), typeof(Base.Distributed.rmprocs), Base.Distributed.Worker, Int64})
+precompile(Tuple{getfield(Base.Distributed, Symbol("#kw##remote_do")), Array{Any, 1}, typeof(Base.Distributed.remote_do), typeof(Base.Distributed.rmprocs), Base.Distributed.LocalProcess, Int64})
+precompile(Tuple{Type{Base.Distributed.ResultMsg}, Base.Distributed.RemoteException})
+precompile(Tuple{Type{Base.Distributed.ResultMsg}, Symbol})
+precompile(Tuple{typeof(Base.Distributed.send_msg_now), Base.TCPSocket, Base.Distributed.MsgHeader, Base.Distributed.ResultMsg})
+precompile(Tuple{typeof(Base.setindex!), Base.Dict{Int64, Void}, Void, Int64})
+precompile(Tuple{typeof(Base.notify), Base.Condition, Base.Distributed.ProcessExitedException, Bool, Bool})
+precompile(Tuple{typeof(Base.pop!), Base.Dict{Int64, Union{Base.Distributed.Worker, Base.Distributed.LocalProcess}}, Int64, Void})
+precompile(Tuple{typeof(Base.Distributed.deregister_worker), Base.Distributed.ProcessGroup, Int64})
+precompile(Tuple{typeof(Base.Distributed.process_hdr), Base.TCPSocket, Bool})
+precompile(Tuple{typeof(Base.Distributed.null_id), Base.Distributed.RRID})
+precompile(Tuple{typeof(Base.Distributed.deliver_result), Base.TCPSocket, Symbol, Base.Distributed.RRID, Base.Distributed.RemoteException})
+precompile(Tuple{typeof(Base.Distributed.disable_nagle), Base.TCPSocket})
+precompile(Tuple{typeof(Base.Distributed.message_handler_loop), Base.TCPSocket, Base.TCPSocket, Bool})
+precompile(Tuple{typeof(Base.Distributed.process_tcp_streams), Base.TCPSocket, Base.TCPSocket, Bool})
+precompile(Tuple{typeof(Base.Serializer.deserialize), Base.Distributed.ClusterSerializer{Base.TCPSocket}, Type{Union}})
+precompile(Tuple{typeof(Base.Serializer.deserialize), Base.Distributed.ClusterSerializer{Base.TCPSocket}, Type{Module}})
+precompile(Tuple{typeof(Base.Serializer.deserialize), Base.Distributed.ClusterSerializer{Base.TCPSocket}, Type{SimpleVector}})
+precompile(Tuple{Type{Array{Union{Tuple{Any, Int64}, Tuple{Tuple{}, Any, Bool}}, 1}}, Tuple{Int64}})
+precompile(Tuple{typeof(Base.eachindex), Array{Union{Tuple{Any, Int64}, Tuple{Tuple{}, Any, Bool}}, 1}})
+precompile(Tuple{Type{Base.Distributed.JoinPGRPMsg}, Int64, Array{Union{Tuple{Any, Int64}, Tuple{Tuple{}, Any, Bool}}, 1}, Symbol, Bool})
+precompile(Tuple{typeof(Base.Distributed.handle_msg), Base.Distributed.JoinPGRPMsg, Base.Distributed.MsgHeader, Base.TCPSocket, Base.TCPSocket, Base.VersionNumber})
+precompile(Tuple{Type{Base.Distributed.WorkerConfig}})
+precompile(Tuple{typeof(Base.LinAlg.BLAS.set_num_threads), Int64})
+precompile(Tuple{typeof(Base.Distributed.send_msg_), Base.Distributed.Worker, Base.Distributed.MsgHeader, Base.Distributed.JoinCompleteMsg, Bool})
+precompile(Tuple{typeof(Base.Distributed.send_msg_now), Base.Distributed.Worker, Base.Distributed.MsgHeader, Base.Distributed.JoinCompleteMsg})
+precompile(Tuple{getfield(Core, Symbol("#kw#Type")), Array{Any, 1}, Type{Base.Distributed.Worker}, Int64, Base.TCPSocket, Base.TCPSocket, Base.Distributed.DefaultClusterManager})
+precompile(Tuple{typeof(Base.eltype), Type{Base.Nullable{IO}}})
+precompile(Tuple{Type{Base.Nullable{IO}}})
+precompile(Tuple{typeof(Base.eltype), Type{Base.Nullable{AbstractString}}})
+precompile(Tuple{Type{Base.Nullable{AbstractString}}})
+precompile(Tuple{typeof(Base.eltype), Type{Base.Nullable{Integer}}})
+precompile(Tuple{Type{Base.Nullable{Integer}}})
+precompile(Tuple{typeof(Base.eltype), Type{Base.Nullable{Union{Int64, Symbol}}}})
+precompile(Tuple{Type{Base.Nullable{Union{Int64, Symbol}}}})
+precompile(Tuple{typeof(Base.eltype), Type{Base.Nullable{Base.Cmd}}})
+precompile(Tuple{Type{Base.Nullable{Base.Cmd}}})
+precompile(Tuple{typeof(Base.eltype), Type{Base.Nullable{Any}}})
+precompile(Tuple{Type{Base.Nullable{Any}}})
+precompile(Tuple{typeof(Base.eltype), Type{Base.Nullable{Bool}}})
+precompile(Tuple{Type{Base.Nullable{Bool}}})
+precompile(Tuple{typeof(Base.eltype), Type{Base.Nullable{Base.Process}}})
+precompile(Tuple{Type{Base.Nullable{Base.Process}}})
+precompile(Tuple{typeof(Base.eltype), Type{Base.Nullable{Base.Dict{K, V} where V where K}}})
+precompile(Tuple{Type{Base.Nullable{Base.Dict{K, V} where V where K}}})
+precompile(Tuple{typeof(Base.eltype), Type{Base.Nullable{Array{T, N} where N where T}}})
+precompile(Tuple{Type{Base.Nullable{Array{T, N} where N where T}}})
+precompile(Tuple{typeof(Base.Distributed.register_worker_streams), Base.Distributed.Worker})
+precompile(Tuple{typeof(Base.Distributed.register_worker_streams), Base.Distributed.LocalProcess})
+precompile(Tuple{typeof(Base.convert), Type{IO}, Base.TCPSocket})
+precompile(Tuple{typeof(Base.convert), Type{Base.Distributed.ClusterSerializer{I} where I<:IO}, Base.Distributed.ClusterSerializer{Base.TCPSocket}})
+precompile(Tuple{typeof(Base.convert), Type{Base.Distributed.ClusterManager}, Base.Distributed.DefaultClusterManager})
+precompile(Tuple{typeof(Base.convert), Type{Base.Distributed.WorkerConfig}, Base.Distributed.WorkerConfig})
+precompile(Tuple{typeof(Base.convert), Type{Base.Nullable{Base.VersionNumber}}, Base.VersionNumber})
+precompile(Tuple{typeof(Base.Distributed.send_connection_hdr), Base.Distributed.Worker, Bool})
+precompile(Tuple{typeof(Base.unsafe_write), Base.TCPSocket, Ptr{UInt8}, UInt64})
+precompile(Tuple{typeof(Base.Distributed.manage), Base.Distributed.LocalManager, Int64, Base.Distributed.WorkerConfig, Symbol})
+precompile(Tuple{typeof(Base.uv_write), Base.TCPSocket, Ptr{UInt8}, UInt64})
+precompile(Tuple{typeof(Base.flush), Base.TCPSocket})
+precompile(Tuple{typeof(Base.write), Base.TCPSocket, Int64, Int64, Int64, Int64})
+precompile(Tuple{typeof(Base.unsafe_write), Base.TCPSocket, Base.RefValue{Int64}, Int64})
+precompile(Tuple{typeof(Base.Serializer.serialize), Base.Distributed.ClusterSerializer{Base.TCPSocket}, Base.Distributed.JoinCompleteMsg})
+precompile(Tuple{typeof(Base.unsafe_write), Base.TCPSocket, Base.RefValue{UInt8}, Int64})
+precompile(Tuple{typeof(Base.Serializer.serialize), Base.Distributed.ClusterSerializer{Base.TCPSocket}, Int64})
+precompile(Tuple{typeof(Base.write), Base.TCPSocket, Array{UInt8, 1}})
+precompile(Tuple{typeof(Base.unsafe_read), Base.TCPSocket, Base.RefValue{Int32}, Int64})
+precompile(Tuple{typeof(Base.unsafe_read), Base.TCPSocket, Base.RefValue{Int64}, Int64})
+precompile(Tuple{typeof(Base.read!), Base.TCPSocket, Array{UInt8, 1}})
+precompile(Tuple{typeof(Base.promote_type), Type{Int64}, Type{UInt8}})
+precompile(Tuple{typeof(Base.promote_rule), Type{Int64}, Type{UInt8}})
+precompile(Tuple{typeof(Base.promote_result), Type{Int64}, Type{UInt8}, Type{Union{}}, Type{Int64}})
+precompile(Tuple{typeof(Base.read!), Base.TCPSocket, Array{UInt64, 1}})
+precompile(Tuple{typeof(Base.Serializer.deserialize), Base.Distributed.ClusterSerializer{Base.TCPSocket}})
+precompile(Tuple{typeof(Base.Serializer.deserialize_cycle), Base.Distributed.ClusterSerializer{Base.TCPSocket}, Expr})
+precompile(Tuple{typeof(Base.Serializer.handle_deserialize), Base.Distributed.ClusterSerializer{Base.TCPSocket}, Int32})
+precompile(Tuple{typeof(Base._array_for), Type{Union{}}, Base.UnitRange{Int64}, Base.HasShape})
+precompile(Tuple{typeof(Base.Serializer.deserialize_array), Base.Distributed.ClusterSerializer{Base.TCPSocket}})
+precompile(Tuple{typeof(Base.Serializer.deserialize_datatype), Base.Distributed.ClusterSerializer{Base.TCPSocket}})
+precompile(Tuple{typeof(Base.Serializer.deserialize_expr), Base.Distributed.ClusterSerializer{Base.TCPSocket}, Int64})
+precompile(Tuple{typeof(Base.Serializer.deserialize), Base.Distributed.ClusterSerializer{Base.TCPSocket}, Type{Int64}})
+precompile(Tuple{typeof(Base.read), Base.TCPSocket, Type{Int64}})
+precompile(Tuple{Type{Base.Distributed.JoinCompleteMsg}, Int64, Int64})
+precompile(Tuple{typeof(Base.Distributed.handle_msg), Base.Distributed.JoinCompleteMsg, Base.Distributed.MsgHeader, Base.TCPSocket, Base.TCPSocket, Base.VersionNumber})
+precompile(Tuple{typeof(Base.hash), Base.Distributed.RemoteChannel{Base.Channel{Any}}, UInt64})
+precompile(Tuple{typeof(Base.ht_keyindex), Base.Dict{WeakRef, Void}, Base.Distributed.RemoteChannel{Base.Channel{Any}}})
+precompile(Tuple{typeof(Base.Distributed.remotecall_fetch), typeof(Base.Distributed.put_ref), Base.Distributed.Worker, Base.Distributed.RRID, Base.Distributed.WorkerPool})
+precompile(Tuple{typeof(Base.Distributed.remotecall_fetch), typeof(Base.Distributed.put_ref), Base.Distributed.LocalProcess, Base.Distributed.RRID, Base.Distributed.WorkerPool})
+precompile(Tuple{getfield(Base.Distributed, Symbol("#kw##remotecall_fetch")), Array{Any, 1}, typeof(Base.Distributed.remotecall_fetch), typeof(Base.Distributed.put_ref), Base.Distributed.Worker, Base.Distributed.RRID, Base.Distributed.WorkerPool})
+precompile(Tuple{getfield(Base.Distributed, Symbol("#kw##remotecall_fetch")), Array{Any, 1}, typeof(Base.Distributed.remotecall_fetch), typeof(Base.Distributed.put_ref), Base.Distributed.LocalProcess, Base.Distributed.RRID, Base.Distributed.WorkerPool})
+precompile(Tuple{typeof(Base.rehash!), Base.Dict{WeakRef, Void}, Int64})
+precompile(Tuple{typeof(Base.ht_keyindex2), Base.Dict{WeakRef, Void}, WeakRef})
+precompile(Tuple{typeof(Base._setindex!), Base.Dict{WeakRef, Void}, Void, WeakRef, Int64})
+precompile(Tuple{typeof(Base.setindex!), Base.Dict{WeakRef, Void}, Void, WeakRef})
+precompile(Tuple{typeof(Base.finalizer), Base.Distributed.RemoteChannel{Base.Channel{Any}}, typeof(Base.Distributed.finalize_ref)})
+precompile(Tuple{typeof(Base.Distributed.test_existing_ref), Base.Distributed.RemoteChannel{Base.Channel{Any}}})
+precompile(Tuple{Type{Base.Distributed.RemoteChannel{T} where T<:Base.AbstractChannel}, Int64})
+precompile(Tuple{Type{Base.Channel{Int64}}, Int64})
+precompile(Tuple{Type{Base.Distributed.WorkerPool}})
+precompile(Tuple{typeof(Base.Distributed.default_worker_pool)})
+precompile(Tuple{typeof(Base.get), Base.Nullable{Base.Dict{K, V} where V where K}, Base.Dict{Any, Any}})
+precompile(Tuple{typeof(Base.setindex!), Base.Dict{Any, Any}, Int64, Symbol})
+precompile(Tuple{typeof(Base._setindex!), Base.Dict{Any, Any}, Int64, Symbol, Int64})
+precompile(Tuple{typeof(Base.convert), Type{Base.Nullable{Base.Dict{K, V} where V where K}}, Base.Dict{Any, Any}})
+precompile(Tuple{typeof(Base.convert), Type{Base.Nullable{Integer}}, Int64})
+precompile(Tuple{typeof(Base.convert), Type{Base.Nullable{Base.VersionNumber}}, Base.VersionNumber})
+precompile(Tuple{typeof(Base.put!), Base.Channel{Any}, Int64})
+precompile(Tuple{typeof(Base.put_buffered), Base.Channel{Any}, Int64})
+precompile(Tuple{typeof(Base.put_unbuffered), Base.Channel{Any}, Int64})
+precompile(Tuple{typeof(Base.Distributed.call_on_owner), typeof(Base.Distributed.put_ref), Base.Distributed.RemoteChannel{Base.Channel{Any}}, Base.Distributed.WorkerPool})
+precompile(Tuple{typeof(Base.Distributed.put_ref), Base.Distributed.RRID, Base.Distributed.WorkerPool})
+precompile(Tuple{typeof(Base.put!), Base.Distributed.RemoteValue, Base.Distributed.WorkerPool})
+precompile(Tuple{typeof(Base.put!), Base.Channel{Any}, Base.Distributed.WorkerPool})
+precompile(Tuple{typeof(Base.put_buffered), Base.Channel{Any}, Base.Distributed.WorkerPool})
+precompile(Tuple{typeof(Base.put_unbuffered), Base.Channel{Any}, Base.Distributed.WorkerPool})
+precompile(Tuple{typeof(Base.push!), Base.Distributed.WorkerPool, Int64})
+precompile(Tuple{typeof(Base.check_channel_state), Base.Channel{Int64}})
+precompile(Tuple{typeof(Base.put_buffered), Base.Channel{Int64}, Int64})
+precompile(Tuple{typeof(Base.put_unbuffered), Base.Channel{Int64}, Int64})
+precompile(Tuple{typeof(Base.put!), Base.Channel{Int64}, Int64})
+precompile(Tuple{typeof(Base._delete!), Base.Dict{Any, Any}, Int64})
+precompile(Tuple{typeof(Base.Serializer.serialize), Base.Distributed.ClusterSerializer{Base.TCPSocket}, Base.Distributed.RemoteDoMsg})
+precompile(Tuple{typeof(Base.Serializer.serialize), Base.Distributed.ClusterSerializer{Base.TCPSocket}, typeof(Base.Distributed.set_valid_processes)})
+precompile(Tuple{typeof(Base.Serializer.serialize), Base.Distributed.ClusterSerializer{Base.TCPSocket}, Tuple{Array{Int64, 1}}})
+precompile(Tuple{typeof(Base.write), Base.TCPSocket, Array{Int64, 1}})
+precompile(Tuple{typeof(Base.Serializer.serialize_array_data), Base.TCPSocket, Array{Int64, 1}})
+precompile(Tuple{typeof(Base.Serializer.serialize), Base.Distributed.ClusterSerializer{Base.TCPSocket}, Array{Int64, 1}})
+precompile(Tuple{typeof(Base.sort!), Array{Int64, 1}, Int64, Int64, Base.Sort.InsertionSortAlg, Base.Order.ForwardOrdering})
+precompile(Tuple{typeof(Base.Sort.partition!), Array{Int64, 1}, Int64, Int64, Base.Order.ForwardOrdering})
+precompile(Tuple{typeof(Base.sort!), Array{Int64, 1}, Int64, Int64, Base.Sort.QuickSortAlg, Base.Order.ForwardOrdering})
+precompile(Tuple{typeof(Base.Serializer.deserialize), Base.Distributed.ClusterSerializer{Base.TCPSocket}, Type{typeof(Base.Distributed.set_valid_processes)}})
+precompile(Tuple{typeof(Base.Distributed.handle_msg), Base.Distributed.RemoteDoMsg, Base.Distributed.MsgHeader, Base.TCPSocket, Base.TCPSocket, Base.VersionNumber})
+precompile(Tuple{typeof(Base.put!), Base.Channel{Any}, Tuple{Array{Int64, 1}, Void}})
+precompile(Tuple{typeof(Base.put_buffered), Base.Channel{Any}, Tuple{Array{Int64, 1}, Void}})
+precompile(Tuple{typeof(Base.put_unbuffered), Base.Channel{Any}, Tuple{Array{Int64, 1}, Void}})
+precompile(Tuple{typeof(Base.Distributed.set_valid_processes), Array{Int64, 1}})
+precompile(Tuple{typeof(Base.promote_type), Type{Int64}, Type{Int64}})
+precompile(Tuple{typeof(Base.sizehint!), Base.Dict{Int64, Void}, Int64})
+precompile(Tuple{typeof(Base.union!), Base.Set{Int64}, Array{Int64, 1}})
+precompile(Tuple{typeof(Base.start), Tuple{Array{Int64, 1}, Void}})
+precompile(Tuple{typeof(Base.indexed_next), Tuple{Array{Int64, 1}, Void}, Int64, Int64})
+precompile(Tuple{typeof(Base.setdiff), Array{Int64, 1}, Array{Int64, 1}})
+precompile(Tuple{typeof(Base.Multimedia.display), Array{Int64, 1}})
+precompile(Tuple{typeof(Base.isassigned), Array{Int64, 1}, Int64})
+precompile(Tuple{typeof(Base.array_eltype_show_how), Array{Int64, 1}})
+precompile(Tuple{typeof(Base._summary), Array{Int64, 1}, Tuple{Base.OneTo{Int64}}})
+precompile(Tuple{typeof(Base.isassigned), Array{Int64, 1}, Int64, Int64})
+precompile(Tuple{typeof(Base.isassigned), Array{Int64, 1}})
+precompile(Tuple{typeof(Base.Multimedia.display), Base.REPL.REPLDisplay{Base.REPL.LineEditREPL}, Array{Int64, 1}})
+precompile(Tuple{typeof(Base.Multimedia.display), Base.REPL.REPLDisplay{Base.REPL.LineEditREPL}, Base.MIME{Symbol("text/plain")}, Array{Int64, 1}})
+precompile(Tuple{typeof(Base.show_delim_array), Base.IOContext{Base.Terminals.TTYTerminal}, Array{Int64, 1}, String, String, String, Bool, Int64, Int64})
+precompile(Tuple{typeof(Base.print), Base.IOContext{Base.Terminals.TTYTerminal}, Char})
+precompile(Tuple{typeof(Base.print), Base.IOContext{Base.Terminals.TTYTerminal}, String, Char})
+precompile(Tuple{typeof(Base.print), Base.IOContext{Base.Terminals.TTYTerminal}, String, String})
+precompile(Tuple{typeof(Base.print), Base.IOContext{Base.Terminals.TTYTerminal}, String, String, Char})
+precompile(Tuple{typeof(Base.show_vector), Base.IOContext{Base.Terminals.TTYTerminal}, Array{Int64, 1}, String, String})
+precompile(Tuple{typeof(Base.print_matrix_repr), Base.IOContext{Base.Terminals.TTYTerminal}, Array{Int64, 1}})
+precompile(Tuple{typeof(Base.show_nd), Base.IOContext{Base.Terminals.TTYTerminal}, Array{Int64, 1}, typeof(Base.print_matrix_repr), Bool})
+precompile(Tuple{typeof(Base.repremptyarray), Base.IOContext{Base.Terminals.TTYTerminal}, Array{Int64, 1}})
+precompile(Tuple{typeof(Base.print_matrix), Base.IOContext{Base.Terminals.TTYTerminal}, Array{Int64, 1}, String, String, String})
+precompile(Tuple{typeof(Base.getindex), Base.ImmutableDict{Symbol, Any}, Symbol})
+precompile(Tuple{typeof(Base.vcat), Base.OneTo{Int64}})
+precompile(Tuple{typeof(Base.collect_to!), Array{Int64, 1}, Base.Generator{Array{Tuple{Int64, Int64}, 1}, typeof(Base.sum)}, Int64, Int64})
+precompile(Tuple{typeof(Base._collect), Array{Tuple{Int64, Int64}, 1}, Base.Generator{Array{Tuple{Int64, Int64}, 1}, typeof(Base.sum)}, Base.EltypeUnknown, Base.HasShape})
+precompile(Tuple{typeof(Base.pop!), Array{Tuple{Int64, Int64}, 1}})
+precompile(Tuple{typeof(Base.reverse), Array{Tuple{Int64, Int64}, 1}, Int64, Int64})
+precompile(Tuple{typeof(Base.print_matrix_vdots), Base.IOContext{Base.Terminals.TTYTerminal}, String, Array{Tuple{Int64, Int64}, 1}, String, Int64, Int64})
+precompile(Tuple{typeof(Base.print_matrix), Base.IOContext{Base.Terminals.TTYTerminal}, Array{Int64, 1}, String, String, String, String, String, String, Int64, Int64})
+precompile(Tuple{typeof(Base.alignment), Base.IOContext{Base.Terminals.TTYTerminal}, Array{Int64, 1}, Array{Int64, 1}, Array{Int64, 1}, Int64, Int64, Int64})
+precompile(Tuple{getfield(Base, Symbol("#kw##sprint")), Array{Any, 1}, typeof(Base.sprint), Int64, typeof(Base.show), Int64})
+precompile(Tuple{typeof(Base.sub2ind), Tuple{Int64}, Int64, Int64})
+precompile(Tuple{typeof(Base._sub2ind), Tuple{Int64}, Int64, Int64, Int64, Int64})
+precompile(Tuple{typeof(Base._sub2ind), Tuple{}, Int64, Int64, Int64})
+precompile(Tuple{typeof(Base.first), Array{Int64, 1}})
+precompile(Tuple{typeof(Base.print_matrix_row), Base.IOContext{Base.Terminals.TTYTerminal}, Array{Int64, 1}, Array{Tuple{Int64, Int64}, 1}, Int64, Array{Int64, 1}, String})
+precompile(Tuple{typeof(Base.print), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.OneTo{Int64}})
+precompile(Tuple{typeof(Base.last), Array{Int64, 1}})
+precompile(Tuple{typeof(Base.LineEdit.edit_delete), Base.GenericIOBuffer{Array{UInt8, 1}}})
+precompile(Tuple{typeof(Base.print), String})
+precompile(Tuple{typeof(Base.vcat), Array{Int64, 1}})
+precompile(Tuple{typeof(Base.Distributed._rmprocs), Array{Int64, 1}, Float64})
+precompile(Tuple{typeof(Core.Inference.eltype), Type{Array{Int64, 1}}})
+precompile(Tuple{typeof(Base.vcat), Int64})
+precompile(Tuple{typeof(Base.kill), Base.Distributed.LocalManager, Int64, Base.Distributed.WorkerConfig})
+precompile(Tuple{typeof(Base.Serializer.serialize), Base.Distributed.ClusterSerializer{Base.TCPSocket}, typeof(Base.exit)})
+precompile(Tuple{typeof(Base.Serializer.serialize), Base.Distributed.ClusterSerializer{Base.TCPSocket}, Tuple{}})
+precompile(Tuple{typeof(Base.Serializer.deserialize), Base.Distributed.ClusterSerializer{Base.TCPSocket}, Type{typeof(Base.exit)}})
+precompile(Tuple{typeof(Base.uvfinalize), Base.PipeEndpoint})
+precompile(Tuple{typeof(Base.unpreserve_handle), Base.PipeEndpoint})
+precompile(Tuple{typeof(Base.stream_wait), Base.PipeEndpoint, Base.Condition})
+precompile(Tuple{typeof(Base.close), Base.PipeEndpoint})
+precompile(Tuple{typeof(Base.uvfinalize), Base.TCPServer})
+precompile(Tuple{typeof(Base.uvfinalize), Base.TCPSocket})
+precompile(Tuple{typeof(Base._uv_hook_close), Base.TCPSocket})
+precompile(Tuple{typeof(Base.in), Int64, Base.IntSet})
+precompile(Tuple{typeof(Base._uv_hook_close), Base.Process})
+precompile(Tuple{typeof(Base.Distributed.finalize_ref), Base.Distributed.RemoteChannel{Base.Channel{Any}}})
+precompile(Tuple{typeof(Base._delete!), Base.Dict{WeakRef, Void}, Int64})
+precompile(Tuple{typeof(Base.Distributed.send_del_client), Base.Distributed.RemoteChannel{Base.Channel{Any}}})
+precompile(Tuple{typeof(Base.:(==)), Base.Distributed.RemoteChannel{Base.Channel{Any}}, Base.Distributed.RemoteChannel{Base.Channel{Any}}})
+precompile(Tuple{typeof(Base.delete!), Base.IntSet, Int64})
+precompile(Tuple{typeof(Base.isempty), Base.IntSet})
+precompile(Tuple{typeof(Base.any), Base.BitArray{1}})
+precompile(Tuple{typeof(Base.uvfinalize), Base.PipeEndpoint})
+precompile(Tuple{typeof(Base.uvfinalize), Base.Process})
+precompile(Tuple{getfield(Base.Distributed, Symbol("#kw##remotecall_fetch")), Array{Any, 1}, typeof(Base.Distributed.remotecall_fetch), typeof(Base.Distributed.fetch_future), Base.Distributed.Worker, Base.Distributed.RRID, Int64})
+precompile(Tuple{getfield(Base.Distributed, Symbol("#kw##remotecall_fetch")), Array{Any, 1}, typeof(Base.Distributed.remotecall_fetch), typeof(Base.open), Base.Distributed.LocalProcess, typeof(Base.read), String})
+precompile(Tuple{getfield(Base.Distributed, Symbol("#kw##remotecall_fetch")), Array{Any, 1}, typeof(Base.Distributed.remotecall_fetch), typeof(Base.open), Base.Distributed.Worker, typeof(Base.read), String})
+precompile(Tuple{getfield(Base.Distributed, Symbol("#kw##remote_do")), Array{Any, 1}, typeof(Base.Distributed.remote_do), typeof(Base.exit), Base.Distributed.Worker})
+precompile(Tuple{getfield(Base.Distributed, Symbol("#kw##rmprocs")), Array{Any, 1}, typeof(Base.Distributed.rmprocs), Array{Int64, 1}})
+precompile(Tuple{getfield(Base.Filesystem, Symbol("#kw##rm")), Array{Any, 1}, typeof(Base.Filesystem.rm), String})
+precompile(Tuple{getfield(Base, Symbol("#kw##info")), Array{Any, 1}, typeof(Base.info), Base.IOStream, String})
+precompile(Tuple{getfield(Base, Symbol("#kw##print_with_color")), Array{Any, 1}, typeof(Base.print_with_color), Symbol, Base.IOStream, String})
+precompile(Tuple{getfield(Base, Symbol("#kw##readbytes!")), Array{Any, 1}, typeof(Base.readbytes!), Base.IOStream, Array{UInt8, 1}, Int32})
+precompile(Tuple{getfield(Base, Symbol("#kw##spawn")), Array{Any, 1}, typeof(Base.spawn), Base.Cmd, Tuple{Base.Pipe, Base.TTY, Base.IOStream}})
+precompile(Tuple{getfield(Base, Symbol("#kw##systemerror")), Array{Any, 1}, typeof(Base.systemerror), Symbol, Bool})
+precompile(Tuple{getfield(Base, Symbol("#kw##with_output_color")), Array{Any, 1}, typeof(Base.with_output_color), typeof(Base.println), Symbol, Base.IOStream, Base.SubString{String}})
+precompile(Tuple{getfield(Base, Symbol("#kw##with_output_color")), Array{Any, 1}, typeof(Base.with_output_color), typeof(Base.print), Symbol, Base.IOStream, String})
+precompile(Tuple{Type{Base.Distributed.Future}, Int64})
+precompile(Tuple{Type{Base.Process}, Base.Cmd, Ptr{Void}, Base.Pipe, Base.TTY, Base.IOStream})
+precompile(Tuple{Type{Base.Set{Tuple{String, Float64}}}, Tuple{Tuple{String, Float64}}})
+precompile(Tuple{Type{Base.VersionNumber}, Int64, Int64, Int64, Tuple{String, Int64}, Tuple{}})
+precompile(Tuple{Type{Base.VersionNumber}, Int64, Int64, Int64, Tuple{String}, Tuple{Int64}})
+precompile(Tuple{Type{Core.Inference.Generator{I, F} where F where I}, Type{Core.Inference.Const}, Tuple{Symbol, Expr}})
+precompile(Tuple{Type{Core.Inference.Generator{Tuple{Symbol, Expr}, Type{Core.Inference.Const}}}, Type{Core.Inference.Const}, Tuple{Symbol, Expr}})
+precompile(Tuple{typeof(Base.cmd_gen), Tuple{Tuple{Base.Cmd}, Tuple{String}, Tuple{String}, Tuple{String}, Tuple{String}, Tuple{String}, Tuple{String}, Tuple{String, String}, Tuple{String}, Tuple{String}}})
+precompile(Tuple{typeof(Base._collect), Array{Any, 1}, Base.Generator{Array{Any, 1}, typeof(Base.FastMath.make_fastmath)}, Base.EltypeUnknown, Base.HasShape})
+precompile(Tuple{typeof(Base._collect), Array{Base.Process, 1}, Base.Generator{Array{Base.Process, 1}, typeof(Base.kill)}, Base.EltypeUnknown, Base.HasShape})
+precompile(Tuple{typeof(Base.collect_to!), Array{Any, 1}, Base.Generator{Array{Any, 1}, typeof(Base.FastMath.make_fastmath)}, Int64, Int64})
+precompile(Tuple{typeof(Base.collect_to!), Array{Expr, 1}, Base.Generator{Array{Any, 1}, typeof(Base.FastMath.make_fastmath)}, Int64, Int64})
+precompile(Tuple{typeof(Base.collect_to!), Array{Int32, 1}, Base.Generator{Array{Base.Process, 1}, typeof(Base.kill)}, Int64, Int64})
+precompile(Tuple{typeof(Base.collect_to!), Array{Symbol, 1}, Base.Generator{Array{Any, 1}, typeof(Base.FastMath.make_fastmath)}, Int64, Int64})
+precompile(Tuple{typeof(Base.compilecache), String})
+precompile(Tuple{typeof(Base.copy!), Array{Tuple{String, Float64}, 1}, Int64, Array{Tuple{String, Float64}, 1}, Int64, Int64})
+precompile(Tuple{typeof(Base.create_expr_cache), String, String, Array{Any, 1}})
+precompile(Tuple{typeof(Base._delete!), Base.Dict{Symbol, Base.Condition}, Int64})
+precompile(Tuple{typeof(Base.Distributed.call_on_owner), typeof(Base.Distributed.fetch_future), Base.Distributed.Future, Int64})
+precompile(Tuple{typeof(Base.Distributed.fetch_future), Base.Distributed.RRID, Int64})
+precompile(Tuple{typeof(Base.Distributed.flush_gc_msgs), Base.Distributed.Worker})
+precompile(Tuple{typeof(Base.Distributed.remotecall_fetch), typeof(Base.Distributed.fetch_future), Base.Distributed.Worker, Base.Distributed.RRID, Int64})
+precompile(Tuple{typeof(Base.Distributed.remote_do), typeof(Base.exit), Base.Distributed.Worker})
+precompile(Tuple{typeof(Base.Distributed.send_del_client), Base.Distributed.Future})
+precompile(Tuple{typeof(Base.Distributed.send_msg), Base.Distributed.Worker, Base.Distributed.MsgHeader, Base.Distributed.CallMsg{:call}})
+precompile(Tuple{typeof(Base.Distributed.send_msg_), Base.Distributed.Worker, Base.Distributed.MsgHeader, Base.Distributed.CallMsg{:call}, Bool})
+precompile(Tuple{typeof(Base.Distributed.send_msg), Base.Distributed.Worker, Base.Distributed.MsgHeader, Base.Distributed.CallMsg{:call_fetch}})
+precompile(Tuple{typeof(Base.Distributed.send_msg_), Base.Distributed.Worker, Base.Distributed.MsgHeader, Base.Distributed.CallMsg{:call_fetch}, Bool})
+precompile(Tuple{typeof(Base.Distributed.send_msg), Base.Distributed.Worker, Base.Distributed.MsgHeader, Base.Distributed.RemoteDoMsg})
+precompile(Tuple{typeof(Base.Distributed.send_msg_), Base.Distributed.Worker, Base.Distributed.MsgHeader, Base.Distributed.RemoteDoMsg, Bool})
+precompile(Tuple{typeof(Base.Distributed.terminate_all_workers)})
+precompile(Tuple{typeof(Base.Distributed.test_existing_ref), Base.Distributed.Future})
+precompile(Tuple{typeof(Base.Docs.docm), LineNumberNode, Module, String, Expr})
+precompile(Tuple{typeof(Base.Docs.docm), LineNumberNode, Module, String, Expr, Bool})
+precompile(Tuple{typeof(Base.Docs.keyworddoc), String, Base.BaseDocs.Keyword})
+precompile(Tuple{typeof(Base.Docs.objectdoc), String, Expr, Expr, Expr})
+precompile(Tuple{typeof(Base.FastMath.make_fastmath), Expr})
+precompile(Tuple{typeof(Base.Filesystem.lstat), String})
+precompile(Tuple{typeof(Base.Filesystem.mkdir), String, UInt16})
+precompile(Tuple{typeof(Base.Filesystem.mkpath), String, UInt16})
+precompile(Tuple{typeof(Base.Filesystem.samefile), String, String})
+precompile(Tuple{typeof(Base.Filesystem.unlink), String})
+precompile(Tuple{typeof(Base.finalizer), Base.Distributed.Future, typeof(Base.Distributed.finalize_ref)})
+precompile(Tuple{typeof(Base.find_all_in_cache_path), Symbol})
+precompile(Tuple{typeof(Base.find_in_path), String, Void})
+precompile(Tuple{typeof(Base.getindex), Base.ObjectIdDict, Symbol})
+precompile(Tuple{typeof(Base.getindex), Type{Tuple{String, Float64}}, Tuple{String, Float64}})
+precompile(Tuple{typeof(Base.Grisu._show), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, Float64, Int64, Int64, Bool, Bool})
+precompile(Tuple{typeof(Base.hash), Base.Distributed.Future, UInt64})
+precompile(Tuple{typeof(Base.hash), Tuple{String, Float64}, UInt64})
+precompile(Tuple{typeof(Base.ht_keyindex2), Base.Dict{Symbol, Base.Condition}, Symbol})
+precompile(Tuple{typeof(Base.ht_keyindex2), Base.Dict{Symbol, UInt64}, Symbol})
+precompile(Tuple{typeof(Base.ht_keyindex2), Base.Dict{Tuple{String, Float64}, Void}, Tuple{String, Float64}})
+precompile(Tuple{typeof(Base.ht_keyindex), Base.Dict{Symbol, Base.Condition}, Symbol})
+precompile(Tuple{typeof(Base.ht_keyindex), Base.Dict{Symbol, UInt64}, Symbol})
+precompile(Tuple{typeof(Base.ht_keyindex), Base.Dict{Tuple{String, Float64}, Void}, Tuple{String, Float64}})
+precompile(Tuple{typeof(Base.ht_keyindex), Base.Dict{WeakRef, Void}, Base.Distributed.Future})
+precompile(Tuple{typeof(Base.ident_cmp), Tuple{String, String, Int64}, Tuple{String, Int64}})
+precompile(Tuple{typeof(Base.include_relative), String})
+precompile(Tuple{typeof(Base._include_from_serialized), String})
+precompile(Tuple{typeof(Base.indexed_next), Tuple{Symbol, UInt64}, Int64, Int64})
+precompile(Tuple{typeof(Base.indexed_next), Tuple{Void, Void}, Int64, Int64})
+precompile(Tuple{typeof(Base.isassigned), Array{String, 1}, Int64})
+precompile(Tuple{typeof(Base.isempty), Tuple{String, Int64}})
+precompile(Tuple{typeof(Base.isequal), Float64, String})
+precompile(Tuple{typeof(Base.isequal), String, Float64})
+precompile(Tuple{typeof(Base.isequal), Tuple{String, Float64}, Tuple{String, Float64}})
+precompile(Tuple{typeof(Base._jl_spawn), String, Array{String, 1}, Ptr{Void}, Base.Process, Base.PipeEndpoint, Base.TTY, Base.Filesystem.File})
+precompile(Tuple{typeof(Base.julia_cmd)})
+precompile(Tuple{typeof(Base.load_hook), String, String, String})
+precompile(Tuple{typeof(Base.load_hook), String, String, Void})
+precompile(Tuple{typeof(Base.next), Base.Generator{Array{Any, 1}, typeof(Base.FastMath.make_fastmath)}, Int64})
+precompile(Tuple{typeof(Base.open), Base.CmdRedirect, String, Base.TTY})
+precompile(Tuple{typeof(Base.open), String, String})
+precompile(Tuple{typeof(Base.open), typeof(Base.read), String})
+precompile(Tuple{typeof(Base.parse_cache_header), Base.IOStream})
+precompile(Tuple{typeof(Base.pop!), Base.Dict{Symbol, Base.Condition}, Symbol})
+precompile(Tuple{typeof(Base.precompilableerror), Base.LoadError, Bool})
+precompile(Tuple{typeof(Base.precompilableerror), Base.PrecompilableError, Bool})
+precompile(Tuple{typeof(Base.__precompile__)})
+precompile(Tuple{typeof(Base.__precompile__), Bool})
+precompile(Tuple{typeof(Base.println_with_color), Symbol, Base.IOStream, Base.SubString{String}})
+precompile(Tuple{typeof(Base.push!), Array{Tuple{String, Float64}, 1}, Tuple{String, Float64}})
+precompile(Tuple{typeof(Base.put!), Base.Channel{Any}, Tuple{Void, Void}})
+precompile(Tuple{typeof(Base.put_buffered), Base.Channel{Any}, Tuple{Void, Void}})
+precompile(Tuple{typeof(Base.put_unbuffered), Base.Channel{Any}, Tuple{Void, Void}})
+precompile(Tuple{typeof(Base.read), Base.IOStream, Type{Int32}})
+precompile(Tuple{typeof(Base.read), Base.IOStream, Type{Int64}})
+precompile(Tuple{typeof(Base.read), Base.IOStream, Type{UInt64}})
+precompile(Tuple{typeof(Base.read!), Base.PipeEndpoint, Array{UInt64, 1}})
+precompile(Tuple{typeof(Base.read!), Base.PipeEndpoint, Array{UInt8, 1}})
+precompile(Tuple{typeof(Base.read), Base.PipeEndpoint, Type{Int64}})
+precompile(Tuple{typeof(Base.read), Base.PipeEndpoint, Type{UInt64}})
+precompile(Tuple{typeof(Base.read), Base.PipeEndpoint, Type{UInt8}})
+precompile(Tuple{typeof(Base.readbytes_all!), Base.IOStream, Array{UInt8, 1}, Int32})
+precompile(Tuple{typeof(Base.readbytes_some!), Base.IOStream, Array{UInt8, 1}, Int32})
+precompile(Tuple{typeof(Base._redirect), Base.IOStream, Base.Dict{Tuple{Union{Module, Void}, Union{Symbol, Void}}, IO}, Base.StackTraces.StackFrame})
+precompile(Tuple{typeof(Base._redirect), Base.IOStream, Base.Dict{Tuple{Union{Module, Void}, Union{Symbol, Void}}, IO}, Symbol})
+precompile(Tuple{typeof(Base.rehash!), Base.Dict{Symbol, Base.Condition}, Int64})
+precompile(Tuple{typeof(Base.rehash!), Base.Dict{Symbol, UInt64}, Int64})
+precompile(Tuple{typeof(Base.rehash!), Base.Dict{Tuple{String, Float64}, Void}, Int64})
+precompile(Tuple{typeof(Base.remove_linenums!), Module})
+precompile(Tuple{typeof(Base._require_from_serialized), Symbol, String})
+precompile(Tuple{typeof(Base._require_search_from_serialized), Symbol, String})
+precompile(Tuple{typeof(Base.require), Symbol})
+precompile(Tuple{typeof(Base.resize!), Array{Base.Condition, 1}, Int64})
+precompile(Tuple{typeof(Base.resize!), Array{Tuple{String, Float64}, 1}, Int64})
+precompile(Tuple{typeof(Base.resize!), Array{UInt8, 1}, Int32})
+precompile(Tuple{typeof(Base.Serializer.deserialize_array), Base.Serializer.SerializationState{Base.PipeEndpoint}})
+precompile(Tuple{typeof(Base.Serializer.deserialize), Base.PipeEndpoint})
+precompile(Tuple{typeof(Base.Serializer.deserialize), Base.Serializer.SerializationState{Base.PipeEndpoint}})
+precompile(Tuple{typeof(Base.Serializer.deserialize), Base.Serializer.SerializationState{Base.PipeEndpoint}, Type{Int64}})
+precompile(Tuple{typeof(Base.Serializer.deserialize), Base.Serializer.SerializationState{Base.PipeEndpoint}, Type{QuoteNode}})
+precompile(Tuple{typeof(Base.Serializer.deserialize), Base.Serializer.SerializationState{Base.PipeEndpoint}, Type{String}})
+precompile(Tuple{typeof(Base.Serializer.deserialize), Base.Serializer.SerializationState{Base.PipeEndpoint}, Type{UInt64}})
+precompile(Tuple{typeof(Base.Serializer.deserialize_cycle), Base.Serializer.SerializationState{Base.PipeEndpoint}, Expr})
+precompile(Tuple{typeof(Base.Serializer.deserialize_datatype), Base.Serializer.SerializationState{Base.PipeEndpoint}})
+precompile(Tuple{typeof(Base.Serializer.deserialize_expr), Base.Serializer.SerializationState{Base.PipeEndpoint}, Int64})
+precompile(Tuple{typeof(Base.Serializer.handle_deserialize), Base.Serializer.SerializationState{Base.PipeEndpoint}, Int32})
+precompile(Tuple{typeof(Base.Serializer.serialize_any), Base.Serializer.SerializationState{Base.Pipe}, QuoteNode})
+precompile(Tuple{typeof(Base.Serializer.serialize), Base.Serializer.SerializationState{Base.Pipe}, Array{Any, 1}})
+precompile(Tuple{typeof(Base.Serializer.serialize), Base.Serializer.SerializationState{Base.Pipe}, Array{String, 1}})
+precompile(Tuple{typeof(Base.Serializer.serialize), Base.Serializer.SerializationState{Base.Pipe}, Bool})
+precompile(Tuple{typeof(Base.Serializer.serialize), Base.Serializer.SerializationState{Base.Pipe}, Expr})
+precompile(Tuple{typeof(Base.Serializer.serialize), Base.Serializer.SerializationState{Base.Pipe}, Int64})
+precompile(Tuple{typeof(Base.Serializer.serialize), Base.Serializer.SerializationState{Base.Pipe}, Module})
+precompile(Tuple{typeof(Base.Serializer.serialize), Base.Serializer.SerializationState{Base.Pipe}, QuoteNode})
+precompile(Tuple{typeof(Base.Serializer.serialize), Base.Serializer.SerializationState{Base.Pipe}, SimpleVector})
+precompile(Tuple{typeof(Base.Serializer.serialize), Base.Serializer.SerializationState{Base.Pipe}, String})
+precompile(Tuple{typeof(Base.Serializer.serialize), Base.Serializer.SerializationState{Base.Pipe}, Symbol})
+precompile(Tuple{typeof(Base.Serializer.serialize), Base.Serializer.SerializationState{Base.Pipe}, Tuple{Int64}})
+precompile(Tuple{typeof(Base.Serializer.serialize), Base.Serializer.SerializationState{Base.Pipe}, Tuple{Symbol, UInt64}})
+precompile(Tuple{typeof(Base.Serializer.serialize), Base.Serializer.SerializationState{Base.Pipe}, Type{Any}})
+precompile(Tuple{typeof(Base.Serializer.serialize), Base.Serializer.SerializationState{Base.Pipe}, TypeName})
+precompile(Tuple{typeof(Base.Serializer.serialize), Base.Serializer.SerializationState{Base.Pipe}, UInt64})
+precompile(Tuple{typeof(Base.Serializer.serialize_cycle), Base.Serializer.SerializationState{Base.Pipe}, Expr})
+precompile(Tuple{typeof(Base.Serializer.serialize_cycle), Base.Serializer.SerializationState{Base.Pipe}, TypeName})
+precompile(Tuple{typeof(Base.Serializer.serialize_cycle), Base.Serializer.SerializationState{Base.Pipe}, UInt64})
+precompile(Tuple{typeof(Base.Serializer.serialize_cycle_header), Base.Serializer.SerializationState{Base.Pipe}, QuoteNode})
+precompile(Tuple{typeof(Base.Serializer.serialize_mod_names), Base.Serializer.SerializationState{Base.Pipe}, Module})
+precompile(Tuple{typeof(Base.Serializer.serialize_type), Base.Serializer.SerializationState{Base.Pipe}, DataType})
+precompile(Tuple{typeof(Base.Serializer.serialize_type_data), Base.Serializer.SerializationState{Base.Pipe}, Type{Any}, Bool})
+precompile(Tuple{typeof(Base.Serializer.serialize_typename), Base.Serializer.SerializationState{Base.Pipe}, TypeName})
+precompile(Tuple{typeof(Base.Serializer.should_send_whole_type), Base.Serializer.SerializationState{Base.Pipe}, Type{Any}})
+precompile(Tuple{typeof(Base.Serializer.write_as_tag), Base.Pipe, Int32})
+precompile(Tuple{typeof(Base.setindex!), Base.Dict{Symbol, Base.Condition}, Base.Condition, Symbol})
+precompile(Tuple{typeof(Base._setindex!), Base.Dict{Symbol, Base.Condition}, Base.Condition, Symbol, Int64})
+precompile(Tuple{typeof(Base.setindex!), Base.Dict{Symbol, UInt64}, UInt64, Symbol})
+precompile(Tuple{typeof(Base._setindex!), Base.Dict{Symbol, UInt64}, UInt64, Symbol, Int64})
+precompile(Tuple{typeof(Base.setindex!), Base.Dict{Tuple{String, Float64}, Void}, Void, Tuple{String, Float64}})
+precompile(Tuple{typeof(Base._setindex!), Base.Dict{Tuple{String, Float64}, Void}, Void, Tuple{String, Float64}, Int64})
+precompile(Tuple{typeof(Base.show), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, Float64})
+precompile(Tuple{typeof(Base.show_delim_array), Base.GenericIOBuffer{Array{UInt8, 1}}, Tuple{String, Float64}, Char, Char, Char, Bool, Int64, Int64})
+precompile(Tuple{typeof(Base.show_unquoted), Base.GenericIOBuffer{Array{UInt8, 1}}, Expr})
+precompile(Tuple{typeof(Base.skip_deleted), Base.Dict{Tuple{String, Float64}, Void}, Int64})
+precompile(Tuple{typeof(Base.spawn), Base.CmdRedirect, Tuple{Base.Pipe, Base.TTY, Base.IOStream}})
+precompile(Tuple{typeof(Base.stale_cachefile), String, String})
+precompile(Tuple{typeof(Base.start), Tuple{Symbol, UInt64}})
+precompile(Tuple{typeof(Base.start), Tuple{Void, Void}})
+precompile(Tuple{typeof(Base.:(>)), String, String})
+precompile(Tuple{typeof(Base._str), String})
+precompile(Tuple{typeof(Base._str), Void})
+precompile(Tuple{typeof(Base.sync_add), Base.Distributed.Future})
+precompile(Tuple{typeof(Base.trunc), Float64, Int64, Int64})
+precompile(Tuple{typeof(Base.union!), Base.Set{Tuple{String, Float64}}, Tuple{Tuple{String, Float64}}})
+precompile(Tuple{typeof(Base.unique_from), Array{Any, 1}, Array{Tuple{String, Float64}, 1}, Base.Set{Tuple{String, Float64}}, Int64})
+precompile(Tuple{typeof(Base.unsafe_copy!), Array{Tuple{String, Float64}, 1}, Int64, Array{Tuple{String, Float64}, 1}, Int64, Int64})
+precompile(Tuple{typeof(Base.unsafe_read), Base.IOStream, Base.RefValue{Float64}, Int64})
+precompile(Tuple{typeof(Base.unsafe_read), Base.PipeEndpoint, Base.RefValue{Int32}, Int64})
+precompile(Tuple{typeof(Base.unsafe_read), Base.PipeEndpoint, Base.RefValue{Int64}, Int64})
+precompile(Tuple{typeof(Base.unsafe_read), Base.PipeEndpoint, Base.RefValue{UInt64}, Int64})
+precompile(Tuple{typeof(Base.unsafe_read), Base.PipeEndpoint, Ptr{UInt8}, UInt64})
+precompile(Tuple{typeof(Base.unsafe_write), Base.Pipe, Base.RefValue{Int32}, Int64})
+precompile(Tuple{typeof(Base.unsafe_write), Base.Pipe, Base.RefValue{Int64}, Int64})
+precompile(Tuple{typeof(Base.unsafe_write), Base.Pipe, Base.RefValue{UInt64}, Int64})
+precompile(Tuple{typeof(Base.write), Base.Pipe, UInt64})
+precompile(Tuple{typeof(Core.Inference.collect), Type{Any}, Core.Inference.Generator{Tuple{Symbol, Expr}, Type{Core.Inference.Const}}})
+precompile(Tuple{typeof(Core.Inference._collect), Type{Any}, Core.Inference.Generator{Tuple{Symbol, Expr}, Type{Core.Inference.Const}}, Core.Inference.HasLength})
+precompile(Tuple{typeof(Core.Inference.convert), Type{Tuple{Symbol, Expr}}, Tuple{Symbol, Expr}})
+precompile(Tuple{typeof(Core.Inference.copy!), Array{Any, 1}, Core.Inference.Generator{Tuple{Symbol, Expr}, Type{Core.Inference.Const}}})
+precompile(Tuple{typeof(Core.Inference.done), Core.Inference.Generator{Tuple{Symbol, Expr}, Type{Core.Inference.Const}}, Int64})
+precompile(Tuple{typeof(Core.Inference.done), Tuple{Symbol, Expr}, Int64})
+precompile(Tuple{typeof(Core.Inference.getindex), Tuple{Symbol, Expr}, Int64})
+precompile(Tuple{typeof(Core.Inference.isbits), Array{Module, 1}})
+precompile(Tuple{typeof(Core.Inference.iteratorsize), Core.Inference.Generator{Tuple{Symbol, Expr}, Type{Core.Inference.Const}}})
+precompile(Tuple{typeof(Core.Inference.iteratorsize), Type{Core.Inference.Generator{Tuple{Symbol, Expr}, Type{Core.Inference.Const}}}})
+precompile(Tuple{typeof(Core.Inference.iteratorsize), Type{Tuple{Symbol, Expr}}})
+precompile(Tuple{typeof(Core.Inference.length), Core.Inference.Generator{Tuple{Symbol, Expr}, Type{Core.Inference.Const}}})
+precompile(Tuple{typeof(Core.Inference.length), Tuple{Symbol, Expr}})
+precompile(Tuple{typeof(Core.Inference.next), Core.Inference.Generator{Tuple{Symbol, Expr}, Type{Core.Inference.Const}}, Int64})
+precompile(Tuple{typeof(Core.Inference.next), Tuple{Symbol, Expr}, Int64})
+precompile(Tuple{typeof(Core.Inference.start), Core.Inference.Generator{Tuple{Symbol, Expr}, Type{Core.Inference.Const}}})
+precompile(Tuple{typeof(Core.Inference.start), Tuple{Expr, Int64}})
+precompile(Tuple{typeof(Core.Inference.start), Tuple{Symbol, Expr}})
+precompile(Tuple{Type{Union{}}, Base.Distributed.RRID})
diff --git a/base/printf.jl b/base/printf.jl
index 754e91276b1760..47ade065971714 100644
--- a/base/printf.jl
+++ b/base/printf.jl
@@ -1,7 +1,7 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module Printf
-using Base.Grisu
+using Base: Grisu, GMP
 export @printf, @sprintf
 
 ### printf formatter generation ###
@@ -299,8 +299,8 @@ function gen_d(flags::String, width::Int, precision::Int, c::Char)
         push!(blk.args, pad(width-precision, padding, ' '))
     end
     # print sign
-    '+' in flags ? push!(blk.args, :(write(out, neg?'-':'+'))) :
-    ' ' in flags ? push!(blk.args, :(write(out, neg?'-':' '))) :
+    '+' in flags ? push!(blk.args, :(write(out, neg ? '-' : '+'))) :
+    ' ' in flags ? push!(blk.args, :(write(out, neg ? '-' : ' '))) :
                    push!(blk.args, :(neg && write(out, '-')))
     # print prefix
     for ch in prefix
@@ -362,8 +362,8 @@ function gen_f(flags::String, width::Int, precision::Int, c::Char)
         push!(blk.args, pad(width-1, padding, ' '))
     end
     # print sign
-    '+' in flags ? push!(blk.args, :(write(out, neg?'-':'+'))) :
-    ' ' in flags ? push!(blk.args, :(write(out, neg?'-':' '))) :
+    '+' in flags ? push!(blk.args, :(write(out, neg ? '-' : '+'))) :
+    ' ' in flags ? push!(blk.args, :(write(out, neg ? '-' : ' '))) :
                    push!(blk.args, :(neg && write(out, '-')))
     # print zero padding
     if padding !== nothing && !('-' in flags) && '0' in flags
@@ -456,8 +456,8 @@ function gen_e(flags::String, width::Int, precision::Int, c::Char, inside_g::Boo
         push!(blk.args, pad(width, padding, ' '))
     end
     # print sign
-    '+' in flags ? push!(blk.args, :(write(out, neg?'-':'+'))) :
-    ' ' in flags ? push!(blk.args, :(write(out, neg?'-':' '))) :
+    '+' in flags ? push!(blk.args, :(write(out, neg ? '-' : '+'))) :
+    ' ' in flags ? push!(blk.args, :(write(out, neg ? '-' : ' '))) :
                    push!(blk.args, :(neg && write(out, '-')))
     # print zero padding
     if padding !== nothing && !('-' in flags) && '0' in flags
@@ -554,7 +554,7 @@ function gen_a(flags::String, width::Int, precision::Int, c::Char)
         if '#' in flags
             padding = :($padding - (len-1))
         else
-            padding = :($padding - (len>1?len:0))
+            padding = :($padding - (len>1 ? len : 0))
         end
     end
     # print space padding
@@ -562,8 +562,8 @@ function gen_a(flags::String, width::Int, precision::Int, c::Char)
         push!(blk.args, pad(width, padding, ' '))
     end
     # print sign
-    '+' in flags ? push!(blk.args, :(write(out, neg?'-':'+'))) :
-    ' ' in flags ? push!(blk.args, :(write(out, neg?'-':' '))) :
+    '+' in flags ? push!(blk.args, :(write(out, neg ? '-' : '+'))) :
+    ' ' in flags ? push!(blk.args, :(write(out, neg ? '-' : ' '))) :
                     push!(blk.args, :(neg && write(out, '-')))
     # hex prefix
     for ch in hexmark
@@ -630,7 +630,7 @@ function _limit(s, prec)
     prec >= sizeof(s) && return s
     p = prevind(s, prec+1)
     n = nextind(s, p)-1
-    s[1:(prec>=n?n:prevind(s,p))]
+    s[1:(prec>=n ? n : prevind(s,p))]
 end
 
 function gen_s(flags::String, width::Int, precision::Int, c::Char)
@@ -755,8 +755,8 @@ function gen_g(flags::String, width::Int, precision::Int, c::Char)
                           $padexpr; end))
     end
     # print sign
-    '+' in flags ? push!(blk.args, :(write(out, neg?'-':'+'))) :
-    ' ' in flags ? push!(blk.args, :(write(out, neg?'-':' '))) :
+    '+' in flags ? push!(blk.args, :(write(out, neg ? '-' : '+'))) :
+    ' ' in flags ? push!(blk.args, :(write(out, neg ? '-' : ' '))) :
                    push!(blk.args, :(neg && write(out, '-')))
     # print zero padding
     if !('-' in flags) && '0' in flags
@@ -881,8 +881,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), Cstring,
-          (Ptr{UInt8}, Cint, Ptr{BigInt}), DIGITS, b, &x)
+    GMP.MPZ.get_str!(DIGITS, b, x)
     neg && (x.size = -x.size)
     return Int32(pt), Int32(pt), neg
 end
@@ -901,8 +900,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), Cstring,
-          (Ptr{UInt8}, Cint, Ptr{BigInt}), p, 8, &x)
+    GMP.MPZ.get_str!(p, 8, x)
     neg && (x.size = -x.size)
     return neg, Int32(pt), Int32(pt)
 end
@@ -1130,10 +1128,12 @@ function bigfloat_printf(out, d, flags::String, width::Int, precision::Int, c::C
     write(fmt, UInt8(0))
     printf_fmt = take!(fmt)
     @assert length(printf_fmt) == fmt_len
-    bufsiz = length(DIGITS) - 1
-    lng = ccall((:mpfr_snprintf,:libmpfr), Int32, (Ptr{UInt8}, Culong, Ptr{UInt8}, Ptr{BigFloat}...), DIGITS, bufsiz, printf_fmt, &d)
+    bufsiz = length(DIGITS)
+    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")
-    unsafe_write(out, pointer(DIGITS), min(lng,bufsiz))
+    unsafe_write(out, pointer(DIGITS), min(lng, bufsiz-1))
     return (false, ())
 end
 
@@ -1196,16 +1196,20 @@ end
 
 Print `args` using C `printf()` style format specification string, with some caveats:
 `Inf` and `NaN` are printed consistently as `Inf` and `NaN` for flags `%a`, `%A`,
-`%e`, `%E`, `%f`, `%F`, `%g`, and `%G`.
+`%e`, `%E`, `%f`, `%F`, `%g`, and `%G`. Furthermore, if a floating point number is
+equally close to the numeric values of two possible output strings, the output
+string further away from zero is chosen.
 
 Optionally, an `IOStream`
 may be passed as the first argument to redirect output.
 
 # Examples
-
 ```jldoctest
 julia> @printf("%f %F %f %F\\n", Inf, Inf, NaN, NaN)
 Inf Inf NaN NaN\n
+
+julia> @printf "%.0f %.1f %f\\n" 0.5 0.025 -0.0078125
+1 0.0 -0.007813
 ```
 """
 macro printf(args...)
@@ -1225,7 +1229,6 @@ end
 Return `@printf` formatted output as string.
 
 # Examples
-
 ```jldoctest
 julia> s = @sprintf "this is a %s %15.1f" "test" 34.567;
 
diff --git a/base/process.jl b/base/process.jl
index cd15390ca42d65..31791b8d83af8b 100644
--- a/base/process.jl
+++ b/base/process.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 abstract type AbstractCmd end
 
@@ -31,42 +31,37 @@ struct Cmd <: AbstractCmd
 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.
+    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.
+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)
 """
@@ -104,14 +99,14 @@ function show(io::IO, cmd::Cmd)
     print_env = cmd.env !== nothing
     print_dir = !isempty(cmd.dir)
     (print_env || print_dir) && print(io, "setenv(")
-    esc = shell_escape(cmd, special=shell_special)
     print(io, '`')
-    for c in esc
-        if c == '`'
-            print(io, '\\')
-        end
-        print(io, c)
-    end
+    print(io, join(map(cmd.exec) do arg
+        replace(sprint() do io
+            with_output_color(:underline, io) do io
+                print_shell_word(io, arg, shell_special)
+            end
+        end, '`', "\\`")
+    end, ' '))
     print(io, '`')
     print_env && (print(io, ","); show(io, cmd.env))
     print_dir && (print(io, "; dir="); show(io, cmd.dir))
@@ -141,7 +136,7 @@ struct FileRedirect
     filename::AbstractString
     append::Bool
     function FileRedirect(filename, append)
-        if lowercase(filename) == (@static is_windows() ? "nul" : "/dev/null")
+        if lowercase(filename) == (@static Sys.iswindows() ? "nul" : "/dev/null")
             warn_once("for portability use DevNull instead of a file redirect")
         end
         new(filename, append)
@@ -213,7 +208,7 @@ byteenv(env::AbstractArray{<:AbstractString}) =
 byteenv(env::Associative) =
     String[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}}}}) =
+byteenv(env::Union{AbstractVector{Pair{T}}, Tuple{Vararg{Pair{T}}}}) where {T<:AbstractString} =
     String[cstr(k*"="*string(v)) for (k,v) in env]
 
 """
@@ -315,6 +310,7 @@ mutable struct Process <: AbstractPipe
     termsignal::Int32
     exitnotify::Condition
     closenotify::Condition
+    openstream::Symbol # for open(cmd) deprecation
     function Process(cmd::Cmd, handle::Ptr{Void},
                      in::Union{Redirectable, Ptr{Void}},
                      out::Union{Redirectable, Ptr{Void}},
@@ -344,7 +340,9 @@ struct ProcessChain <: AbstractPipe
     in::Redirectable
     out::Redirectable
     err::Redirectable
+    openstream::Symbol # for open(cmd) deprecation
     ProcessChain(stdios::StdIOSet) = new(Process[], stdios[1], stdios[2], stdios[3])
+    ProcessChain(chain::ProcessChain, openstream::Symbol) = new(chain.processes, chain.in, chain.out, chain.err, openstream) # for open(cmd) deprecation
 end
 pipe_reader(p::ProcessChain) = p.out
 pipe_writer(p::ProcessChain) = p.in
@@ -555,16 +553,15 @@ spawn_opts_inherit(in::Redirectable=RawFD(0), out::Redirectable=RawFD(1), err::R
 spawn(cmds::AbstractCmd, args...; chain::Nullable{ProcessChain}=Nullable{ProcessChain}()) =
     spawn(cmds, spawn_opts_swallow(args...)...; chain=chain)
 
-function eachline(cmd::AbstractCmd, stdin; chomp::Bool=true)
+function eachline(cmd::AbstractCmd; chomp::Bool=true)
     stdout = Pipe()
-    processes = spawn(cmd, (stdin,stdout,STDERR))
+    processes = spawn(cmd, (DevNull,stdout,STDERR))
     close(stdout.in)
     out = stdout.out
     # implicitly close after reading lines, since we opened
     return EachLine(out, chomp=chomp,
         ondone=()->(close(out); success(processes) || pipeline_error(processes)))::EachLine
 end
-eachline(cmd::AbstractCmd; chomp::Bool=true) = eachline(cmd, DevNull, chomp=chomp)
 
 # return a Process object to read-to/write-from the pipeline
 """
@@ -577,38 +574,55 @@ the process's standard input and `stdio` optionally specifies the process's stan
 stream.
 """
 function open(cmds::AbstractCmd, mode::AbstractString="r", other::Redirectable=DevNull)
-    if mode == "r"
+    if mode == "r+" || mode == "w+"
+        other === DevNull || throw(ArgumentError("no other stream for mode rw+"))
+        in = Pipe()
+        out = Pipe()
+        processes = spawn(cmds, (in,out,STDERR))
+        close(in.out)
+        close(out.in)
+    elseif mode == "r"
         in = other
-        out = io = Pipe()
+        out = Pipe()
         processes = spawn(cmds, (in,out,STDERR))
         close(out.in)
+        if isa(processes, ProcessChain) # for open(cmd) deprecation
+            processes = ProcessChain(processes, :out)
+        else
+            processes.openstream = :out
+        end
     elseif mode == "w"
-        in = io = Pipe()
+        in = Pipe()
         out = other
         processes = spawn(cmds, (in,out,STDERR))
         close(in.out)
+        if isa(processes, ProcessChain) # for open(cmd) deprecation
+            processes = ProcessChain(processes, :in)
+        else
+            processes.openstream = :in
+        end
     else
         throw(ArgumentError("mode must be \"r\" or \"w\", not \"$mode\""))
     end
-    return (io, processes)
+    return processes
 end
 
 """
     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`.
+Similar to `open(command, mode, stdio)`, but calls `f(stream)` on the resulting process
+stream, then closes the input stream and waits for the process to complete.
+Returns the value returned by `f`.
 """
 function open(f::Function, cmds::AbstractCmd, args...)
-    io, P = open(cmds, args...)
+    P = open(cmds, args...)
     ret = try
-        f(io)
-    catch
+        f(P)
+    catch e
         kill(P)
-        rethrow()
+        rethrow(e)
     finally
-        close(io)
+        close(P.in)
     end
     success(P) || pipeline_error(P)
     return ret
@@ -623,27 +637,18 @@ Starts running a command asynchronously, and returns a tuple (stdout,stdin,proce
 output stream and input stream of the process, and the process object itself.
 """
 function readandwrite(cmds::AbstractCmd)
-    in = Pipe()
-    out, processes = open(cmds, "r", in)
-    (out, in, processes)
+    processes = open(cmds, "r+")
+    return (processes.out, processes.in, processes)
 end
 
-function read(cmd::AbstractCmd, stdin::Redirectable=DevNull)
-    out, procs = open(cmd, "r", stdin)
-    bytes = read(out)
-    !success(procs) && pipeline_error(procs)
+function read(cmd::AbstractCmd)
+    procs = open(cmd, "r", DevNull)
+    bytes = read(procs.out)
+    success(procs) || pipeline_error(procs)
     return bytes
 end
 
-function readstring(cmd::AbstractCmd, stdin::Redirectable=DevNull)
-    return String(read(cmd, stdin))
-end
-
-function writeall(cmd::AbstractCmd, stdin::AbstractString, stdout::Redirectable=DevNull)
-    open(cmd, "w", stdout) do io
-        write(io, stdin)
-    end
-end
+read(cmd::AbstractCmd, ::Type{String}) = String(read(cmd))
 
 """
     run(command, args...)
@@ -656,9 +661,17 @@ function run(cmds::AbstractCmd, args...)
     success(ps) ? nothing : pipeline_error(ps)
 end
 
-const SIGPIPE = 13
+# some common signal numbers that are usually available on all platforms
+# and might be useful as arguments to `kill` or testing against `Process.termsignal`
+const SIGHUP  = 1
+const SIGINT  = 2
+const SIGQUIT = 3 # !windows
+const SIGKILL = 9
+const SIGPIPE = 13 # !windows
+const SIGTERM = 15
+
 function test_success(proc::Process)
-    assert(process_exited(proc))
+    @assert process_exited(proc)
     if proc.exitcode < 0
         #TODO: this codepath is not currently tested
         throw(UVError("could not start process $(string(proc.cmd))", proc.exitcode))
@@ -668,8 +681,7 @@ end
 
 function success(x::Process)
     wait(x)
-    kill(x)
-    test_success(x)
+    return test_success(x)
 end
 success(procs::Vector{Process}) = mapreduce(success, &, procs)
 success(procs::ProcessChain) = success(procs.processes)
@@ -705,8 +717,6 @@ function pipeline_error(procs::ProcessChain)
     error(msg)
 end
 
-_jl_kill(p::Process, signum::Integer) = ccall(:uv_process_kill, Int32, (Ptr{Void},Int32), p.handle, signum)
-
 """
     kill(p::Process, signum=SIGTERM)
 
@@ -715,14 +725,14 @@ Send a signal to a process. The default is to terminate the process.
 function kill(p::Process, signum::Integer)
     if process_running(p)
         @assert p.handle != C_NULL
-        _jl_kill(p, signum)
+        ccall(:uv_process_kill, Int32, (Ptr{Void}, Int32), p.handle, signum)
     else
         Int32(-1)
     end
 end
 kill(ps::Vector{Process}) = map(kill, ps)
 kill(ps::ProcessChain) = map(kill, ps.processes)
-kill(p::Process) = kill(p, 15) #SIGTERM
+kill(p::Process) = kill(p, SIGTERM)
 
 function _contains_newline(bufptr::Ptr{Void}, len::Int32)
     return (ccall(:memchr, Ptr{Void}, (Ptr{Void},Int32,Csize_t), bufptr, '\n', len) != C_NULL)
@@ -798,10 +808,18 @@ function cmd_gen(parsed)
 end
 
 macro cmd(str)
-    return :(cmd_gen($(shell_parse(str, special=shell_special)[1])))
+    return :(cmd_gen($(esc(shell_parse(str, special=shell_special)[1]))))
 end
 
 wait(x::Process)      = if !process_exited(x); stream_wait(x, x.exitnotify); end
 wait(x::ProcessChain) = for p in x.processes; wait(p); end
 
 show(io::IO, p::Process) = print(io, "Process(", p.cmd, ", ", process_status(p), ")")
+
+# allow the elements of the Cmd to be accessed as an array or iterator
+for f in (:length, :endof, :start, :eachindex, :eltype, :first, :last)
+    @eval $f(cmd::Cmd) = $f(cmd.exec)
+end
+for f in (:next, :done, :getindex)
+    @eval $f(cmd::Cmd, i) = $f(cmd.exec, i)
+end
diff --git a/base/profile.jl b/base/profile.jl
index 05e0ae8668f539..922ec8414b805a 100644
--- a/base/profile.jl
+++ b/base/profile.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module Profile
 
@@ -60,7 +60,7 @@ end
 
 # init with default values
 # Use a max size of 1M profile samples, and fire timer every 1ms
-if is_windows()
+if Sys.iswindows()
     __init__() = init(1_000_000, 0.01)
 else
     __init__() = init(1_000_000, 0.001)
@@ -108,7 +108,7 @@ The keyword arguments can be any combination of:
 
  - `C` -- If `true`, backtraces from C and Fortran code are shown (normally they are excluded).
 
- - `combine` -- If true` (default), instruction pointers are merged that correspond to the same line of code.
+ - `combine` -- If `true` (default), instruction pointers are merged that correspond to the same line of code.
 
  - `maxdepth` -- Limits the depth higher than `maxdepth` in the `:tree` format.
 
@@ -316,7 +316,7 @@ const btskip = 0
 
 ## Print as a flat list
 # Counts the number of times each line appears, at any nesting level
-function count_flat{T<:Unsigned}(data::Vector{T})
+function count_flat(data::Vector{T}) where T<:Unsigned
     linecount = Dict{T,Int}()
     toskip = btskip
     for ip in data
@@ -330,8 +330,8 @@ function count_flat{T<:Unsigned}(data::Vector{T})
         end
         linecount[ip] = get(linecount, ip, 0)+1
     end
-    iplist = Array{T}(0)
-    n = Array{Int}(0)
+    iplist = Vector{T}(0)
+    n = Vector{Int}(0)
     for (k,v) in linecount
         push!(iplist, k)
         push!(n, v)
@@ -444,8 +444,8 @@ function tree_aggregate(data::Vector{UInt64})
         treecount[tmp] = get(treecount, tmp, 0) + 1
         istart = iend + 1 + btskip
     end
-    bt = Array{Vector{UInt64}}(0)
-    counts = Array{Int}(0)
+    bt = Vector{Vector{UInt64}}(0)
+    counts = Vector{Int}(0)
     for (k, v) in treecount
         if !isempty(k)
             push!(bt, k)
@@ -464,7 +464,7 @@ function tree_format(lilist::Vector{StackFrame}, counts::Vector{Int}, level::Int
     ntext = cols - nindent - ndigcounts - ndigline - 5
     widthfile = floor(Integer, 0.4ntext)
     widthfunc = floor(Integer, 0.6ntext)
-    strs = Array{String}(length(lilist))
+    strs = Vector{String}(length(lilist))
     showextra = false
     if level > nindent
         nextra = level - nindent
@@ -528,9 +528,9 @@ function tree(io::IO, bt::Vector{Vector{UInt64}}, counts::Vector{Int},
         end
         # Generate counts
         dlen = length(d)
-        lilist = Array{StackFrame}(dlen)
-        group = Array{Vector{Int}}(dlen)
-        n = Array{Int}(dlen)
+        lilist = Vector{StackFrame}(dlen)
+        group = Vector{Vector{Int}}(dlen)
+        n = Vector{Int}(dlen)
         i = 1
         for (key, v) in d
             lilist[i] = key
@@ -551,9 +551,9 @@ function tree(io::IO, bt::Vector{Vector{UInt64}}, counts::Vector{Int},
         end
         # Generate counts, and do the code lookup
         dlen = length(d)
-        lilist = Array{StackFrame}(dlen)
-        group = Array{Vector{Int}}(dlen)
-        n = Array{Int}(dlen)
+        lilist = Vector{StackFrame}(dlen)
+        group = Vector{Vector{Int}}(dlen)
+        n = Vector{Int}(dlen)
         i = 1
         for (key, v) in d
             lilist[i] = lidict[key]
@@ -656,7 +656,7 @@ truncto(str::Symbol, w::Int) = truncto(string(str), w)
 
 # Order alphabetically (file, function) and then by line number
 function liperm(lilist::Vector{StackFrame})
-    comb = Array{String}(length(lilist))
+    comb = Vector{String}(length(lilist))
     for i = 1:length(lilist)
         li = lilist[i]
         if li != UNKNOWN
diff --git a/base/promotion.jl b/base/promotion.jl
index 832b80caa6dcfc..bf01d51d16c1d0 100644
--- a/base/promotion.jl
+++ b/base/promotion.jl
@@ -1,11 +1,11 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## type join (closest common ancestor, or least upper bound) ##
 
 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)
+typejoin(@nospecialize(t)) = (@_pure_meta; t)
+typejoin(@nospecialize(t), ts...) = (@_pure_meta; typejoin(t, typejoin(ts...)))
+function typejoin(@nospecialize(a), @nospecialize(b))
     @_pure_meta
     if a <: b
         return b
@@ -122,14 +122,14 @@ end
 
 ## promotion mechanism ##
 
-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()  = Bottom
+promote_type(T) = T
+promote_type(T, S, U, V...) = (@_inline_meta; promote_type(T, promote_type(S, U, V...)))
 
-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)
+promote_type(::Type{Bottom}, ::Type{Bottom}) = Bottom
+promote_type(::Type{T}, ::Type{T}) where {T} = T
+promote_type(::Type{T}, ::Type{Bottom}) where {T} = T
+promote_type(::Type{Bottom}, ::Type{T}) where {T} = T
 
 """
     promote_type(type1, type2)
@@ -137,8 +137,8 @@ promote_type{T}(::Type{Bottom}, ::Type{T}) = (@_pure_meta; T)
 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.
+[`Float64`](@ref) even though strictly, not all [`Int64`](@ref) values can be represented
+exactly as `Float64` values.
 
 ```jldoctest
 julia> promote_type(Int64, Float64)
@@ -151,8 +151,8 @@ julia> promote_type(Float32, BigInt)
 BigFloat
 ```
 """
-function promote_type{T,S}(::Type{T}, ::Type{S})
-    @_pure_meta
+function promote_type(::Type{T}, ::Type{S}) where {T,S}
+    @_inline_meta
     # 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) =>
@@ -161,31 +161,34 @@ function promote_type{T,S}(::Type{T}, ::Type{S})
     promote_result(T, S, promote_rule(T,S), promote_rule(S,T))
 end
 
-promote_rule(T, S) = (@_pure_meta; Bottom)
+promote_rule(::Type{<:Any}, ::Type{<:Any}) = Bottom
 
-promote_result(t,s,T,S) = (@_pure_meta; promote_type(T,S))
+promote_result(::Type{<:Any},::Type{<:Any},::Type{T},::Type{S}) where {T,S} = (@_inline_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}) = (@_pure_meta; typejoin(T, S))
+promote_result(::Type{T},::Type{S},::Type{Bottom},::Type{Bottom}) where {T,S} = (@_inline_meta; typejoin(T, S))
 
 promote() = ()
 promote(x) = (x,)
-function promote{T,S}(x::T, y::S)
+function promote(x::T, y::S) where {T,S}
+    @_inline_meta
     (convert(promote_type(T,S),x), convert(promote_type(T,S),y))
 end
-promote_typeof(x) = (@_pure_meta; typeof(x))
-promote_typeof(x, xs...) = (@_pure_meta; promote_type(typeof(x), promote_typeof(xs...)))
+promote_typeof(x) = typeof(x)
+promote_typeof(x, xs...) = (@_inline_meta; promote_type(typeof(x), promote_typeof(xs...)))
 function promote(x, y, z)
+    @_inline_meta
     (convert(promote_typeof(x,y,z), x),
      convert(promote_typeof(x,y,z), y),
      convert(promote_typeof(x,y,z), z))
 end
 function promote(x, y, zs...)
+    @_inline_meta
     (convert(promote_typeof(x,y,zs...), x),
      convert(promote_typeof(x,y,zs...), y),
      convert(Tuple{Vararg{promote_typeof(x,y,zs...)}}, zs)...)
 end
-# TODO: promote{T}(x::T, ys::T...) here to catch all circularities?
+# TODO: promote(x::T, ys::T...) where {T} here to catch all circularities?
 
 ## promotions in arithmetic, etc. ##
 
@@ -194,18 +197,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.
-function promote_result{T<:Number,S<:Number}(::Type{T},::Type{S},::Type{Bottom},::Type{Bottom})
-    @_pure_meta
+function promote_result(::Type{T},::Type{S},::Type{Bottom},::Type{Bottom}) where {T<:Number,S<:Number}
+    @_inline_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_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) =
+promote_to_supertype(::Type{T}, ::Type{T}, ::Type{T}) where {T<:Number}           = (@_inline_meta; T)
+promote_to_supertype(::Type{T}, ::Type{S}, ::Type{T}) where {T<:Number,S<:Number} = (@_inline_meta; T)
+promote_to_supertype(::Type{T}, ::Type{S}, ::Type{S}) where {T<:Number,S<:Number} = (@_inline_meta; S)
+promote_to_supertype(::Type{T}, ::Type{S}, ::Type) where {T<:Number,S<:Number} =
     error("no promotion exists for ", T, " and ", S)
 
 # promotion with a check for circularity. Can be used to catch what
@@ -229,9 +232,9 @@ function promote_noncircular(x, y, z, a...)
 end
 not_all_sametype(x, y) = nothing
 not_all_sametype(x, y, z) = nothing
-not_all_sametype{S,T}(x::Tuple{S,S}, y::Tuple{T,T}) = sametype_error(x[1], y[1])
-not_all_sametype{R,S,T}(x::Tuple{R,R}, y::Tuple{S,S}, z::Tuple{T,T}) = sametype_error(x[1], y[1], z[1])
-function not_all_sametype{R,S,T}(::Tuple{R,R}, y::Tuple{S,S}, z::Tuple{T,T}, args...)
+not_all_sametype(x::Tuple{S,S}, y::Tuple{T,T}) where {S,T} = sametype_error(x[1], y[1])
+not_all_sametype(x::Tuple{R,R}, y::Tuple{S,S}, z::Tuple{T,T}) where {R,S,T} = sametype_error(x[1], y[1], z[1])
+function not_all_sametype(::Tuple{R,R}, y::Tuple{S,S}, z::Tuple{T,T}, args...) where {R,S,T}
     @_inline_meta
     not_all_sametype(y, z, args...)
 end
@@ -254,9 +257,11 @@ end
 Exponentiation operator. If `x` is a matrix, computes matrix exponentiation.
 
 If `y` is an `Int` literal (e.g. `2` in `x^2` or `-3` in `x^-3`), the Julia code
-`x^y` is transformed by the compiler to `x^Val{y}`, to enable compile-time
-specialization on the value of the exponent.  (As a default fallback,
-however, `x^Val{y}` simply calls the `^(x,y)` function.)
+`x^y` is transformed by the compiler to `Base.literal_pow(^, x, Val(y))`, to
+enable compile-time specialization on the value of the exponent.
+(As a default fallback we have `Base.literal_pow(^, x, Val(y)) = ^(x,y)`,
+where usually `^ == Base.^` unless `^` has been defined in the calling
+namespace.)
 
 ```jldoctest
 julia> 3^5
@@ -302,22 +307,22 @@ minmax(x::Real, y::Real) = minmax(promote(x, y)...)
 # "Promotion" that takes a function into account and tries to preserve
 # non-concrete types. These are meant to be used mainly by elementwise
 # operations, so it is advised against overriding them
-_default_type(T::Type) = (@_pure_meta; T)
+_default_type(T::Type) = (@_inline_meta; T)
 
 if isdefined(Core, :Inference)
-    _return_type(f::ANY, t::ANY) = Core.Inference.return_type(f, t)
+    const _return_type = Core.Inference.return_type
 else
-    _return_type(f::ANY, t::ANY) = Any
+    _return_type(@nospecialize(f), @nospecialize(t)) = Any
 end
 
-promote_op(::Any...) = (@_pure_meta; Any)
-function promote_op{S}(f, ::Type{S})
+promote_op(::Any...) = (@_inline_meta; Any)
+function promote_op(f, ::Type{S}) where S
     @_inline_meta
     T = _return_type(f, Tuple{_default_type(S)})
     isconcrete(S) && return isconcrete(T) ? T : Any
     return typejoin(S, T)
 end
-function promote_op{R,S}(f, ::Type{R}, ::Type{S})
+function promote_op(f, ::Type{R}, ::Type{S}) where {R,S}
     @_inline_meta
     T = _return_type(f, Tuple{_default_type(R), _default_type(S)})
     isconcrete(R) && isconcrete(S) && return isconcrete(T) ? T : Any
@@ -327,31 +332,31 @@ end
 ## catch-alls to prevent infinite recursion when definitions are missing ##
 
 no_op_err(name, T) = error(name," not defined for ",T)
-+{T<:Number}(x::T, y::T) = no_op_err("+", T)
-*{T<:Number}(x::T, y::T) = no_op_err("*", T)
--{T<:Number}(x::T, y::T) = no_op_err("-", T)
-/{T<:Number}(x::T, y::T) = no_op_err("/", T)
-^{T<:Number}(x::T, y::T) = no_op_err("^", T)
+(+)(x::T, y::T) where {T<:Number} = no_op_err("+", T)
+(*)(x::T, y::T) where {T<:Number} = no_op_err("*", T)
+(-)(x::T, y::T) where {T<:Number} = no_op_err("-", T)
+(/)(x::T, y::T) where {T<:Number} = no_op_err("/", T)
+(^)(x::T, y::T) where {T<:Number} = no_op_err("^", T)
 
-fma{T<:Number}(x::T, y::T, z::T) = no_op_err("fma", T)
+fma(x::T, y::T, z::T) where {T<:Number} = no_op_err("fma", T)
 fma(x::Integer, y::Integer, z::Integer) = x*y+z
-muladd{T<:Number}(x::T, y::T, z::T) = x*y+z
+muladd(x::T, y::T, z::T) where {T<:Number} = x*y+z
 
-(&){T<:Integer}(x::T, y::T) = no_op_err("&", T)
-(|){T<:Integer}(x::T, y::T) = no_op_err("|", T)
-xor{T<:Integer}(x::T, y::T) = no_op_err("xor", T)
+(&)(x::T, y::T) where {T<:Integer} = no_op_err("&", T)
+(|)(x::T, y::T) where {T<:Integer} = no_op_err("|", T)
+xor(x::T, y::T) where {T<:Integer} = no_op_err("xor", T)
 
-=={T<:Number}(x::T, y::T) = x === y
- <{T<:Real}(x::T, y::T) = no_op_err("<" , T)
-<={T<:Real}(x::T, y::T) = no_op_err("<=", T)
+(==)(x::T, y::T) where {T<:Number} = x === y
+(< )(x::T, y::T) where {T<:Real} = no_op_err("<" , T)
+(<=)(x::T, y::T) where {T<:Real} = no_op_err("<=", 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)
+rem(x::T, y::T) where {T<:Real} = no_op_err("rem", T)
+mod(x::T, y::T) where {T<:Real} = no_op_err("mod", 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)
+max(x::T, y::T) where {T<:Real} = select_value(y < x, x, y)
+min(x::T, y::T) where {T<:Real} = select_value(y < x, y, x)
+minmax(x::T, y::T) where {T<:Real} = y < x ? (y, x) : (x, y)
diff --git a/base/random.jl b/base/random.jl
index 074cd1cbc7bc35..b6dd5b48273194 100644
--- a/base/random.jl
+++ b/base/random.jl
@@ -1,10 +1,10 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module Random
 
 using Base.dSFMT
-using Base.GMP: GMP_VERSION, Limb
-import Base: copymutable, copy, copy!, ==
+using Base.GMP: Limb, MPZ
+import Base: copymutable, copy, copy!, ==, hash
 
 export srand,
        rand, rand!,
@@ -12,9 +12,10 @@ export srand,
        randexp, randexp!,
        bitrand,
        randstring,
-       randsubseq,randsubseq!,
-       shuffle,shuffle!,
-       randperm, randcycle,
+       randsubseq, randsubseq!,
+       shuffle, shuffle!,
+       randperm, randperm!,
+       randcycle, randcycle!,
        AbstractRNG, MersenneTwister, RandomDevice,
        GLOBAL_RNG, randjump
 
@@ -28,20 +29,22 @@ mutable struct Close1Open2 <: FloatInterval end
 
 ## RandomDevice
 
-if is_windows()
+const BoolBitIntegerType = Union{Type{Bool},Base.BitIntegerType}
+const BoolBitIntegerArray = Union{Array{Bool},Base.BitIntegerArray}
 
+if Sys.iswindows()
     struct RandomDevice <: AbstractRNG
         buffer::Vector{UInt128}
 
-        RandomDevice() = new(Array{UInt128}(1))
+        RandomDevice() = new(Vector{UInt128}(1))
     end
 
-    function rand{T<:Union{Bool, Base.BitInteger}}(rd::RandomDevice, ::Type{T})
+    function rand(rd::RandomDevice, T::BoolBitIntegerType)
         win32_SystemFunction036!(rd.buffer)
         @inbounds return rd.buffer[1] % T
     end
 
-    rand!(rd::RandomDevice, A::Array{<:Union{Bool, Base.BitInteger}}) = (win32_SystemFunction036!(A); A)
+    rand!(rd::RandomDevice, A::BoolBitIntegerArray) = (win32_SystemFunction036!(A); A)
 else # !windows
     struct RandomDevice <: AbstractRNG
         file::IOStream
@@ -50,11 +53,10 @@ else # !windows
         RandomDevice(unlimited::Bool=true) = new(open(unlimited ? "/dev/urandom" : "/dev/random"), unlimited)
     end
 
-    rand{T<:Union{Bool, Base.BitInteger}}(rd::RandomDevice, ::Type{T}) = read( rd.file, T)
-    rand!(rd::RandomDevice, A::Array{<:Union{Bool, Base.BitInteger}})  = read!(rd.file, A)
+    rand(rd::RandomDevice, T::BoolBitIntegerType)   = read( rd.file, T)
+    rand!(rd::RandomDevice, A::BoolBitIntegerArray) = read!(rd.file, A)
 end # os-test
 
-
 """
     RandomDevice()
 
@@ -80,7 +82,9 @@ mutable struct MersenneTwister <: AbstractRNG
     idx::Int
 
     function MersenneTwister(seed, state, vals, idx)
-        length(vals) == MTCacheLength &&  0 <= idx <= MTCacheLength || throw(DomainError())
+        if !(length(vals) == MTCacheLength &&  0 <= idx <= MTCacheLength)
+            throw(DomainError(idx, "`length(vals)` and `idx` must be consistent with $MTCacheLength"))
+        end
         new(seed, state, vals, idx)
     end
 end
@@ -89,12 +93,32 @@ MersenneTwister(seed::Vector{UInt32}, state::DSFMT_state) =
     MersenneTwister(seed, state, zeros(Float64, MTCacheLength), MTCacheLength)
 
 """
-    MersenneTwister(seed=0)
+    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.
+
+# Examples
+```jldoctest
+julia> rng = MersenneTwister(1234);
+
+julia> x1 = rand(rng, 2)
+2-element Array{Float64,1}:
+ 0.590845
+ 0.766797
+
+julia> rng = MersenneTwister(1234);
+
+julia> x2 = rand(rng, 2)
+2-element Array{Float64,1}:
+ 0.590845
+ 0.766797
+
+julia> x1 == x2
+true
+```
 """
-MersenneTwister(seed=0) = srand(MersenneTwister(Vector{UInt32}(), DSFMT_state()), seed)
+MersenneTwister(seed) = srand(MersenneTwister(Vector{UInt32}(), DSFMT_state()), seed)
 
 function copy!(dst::MersenneTwister, src::MersenneTwister)
     copy!(resize!(dst.seed, length(src.seed)), src.seed)
@@ -110,6 +134,7 @@ copy(src::MersenneTwister) =
 ==(r1::MersenneTwister, r2::MersenneTwister) =
     r1.seed == r2.seed && r1.state == r2.state && isequal(r1.vals, r2.vals) && r1.idx == r2.idx
 
+hash(r::MersenneTwister, h::UInt) = foldr(hash, h, (r.seed, r.state, r.vals, r.idx))
 
 ## Low level API for MersenneTwister
 
@@ -124,10 +149,10 @@ function gen_rand(r::MersenneTwister)
     mt_setfull!(r)
 end
 
-@inline reserve_1(r::MersenneTwister) = mt_empty(r) && gen_rand(r)
+@inline reserve_1(r::MersenneTwister) = (mt_empty(r) && gen_rand(r); nothing)
 # `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)
+@inline reserve(r::MersenneTwister, n::Int) = (mt_avail(r) < n && gen_rand(r); nothing)
 
 # precondition: !mt_empty(r)
 @inline rand_inbounds(r::MersenneTwister, ::Type{Close1Open2}) = mt_pop!(r)
@@ -135,7 +160,7 @@ end
 @inline rand_inbounds(r::MersenneTwister) = rand_inbounds(r, CloseOpen)
 
 # produce Float64 values
-@inline rand{I<:FloatInterval}(r::MersenneTwister, ::Type{I}) = (reserve_1(r); rand_inbounds(r, I))
+@inline rand(r::MersenneTwister, ::Type{I}) where {I<:FloatInterval} = (reserve_1(r); rand_inbounds(r, I))
 
 @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))
@@ -166,7 +191,7 @@ function randjump(mt::MersenneTwister, jumps::Integer, jumppoly::AbstractString)
     push!(mts, mt)
     for i in 1:jumps-1
         cmt = mts[end]
-        push!(mts, MersenneTwister(cmt.seed, dSFMT.dsfmt_jump(cmt.state, jumppoly)))
+        push!(mts, MersenneTwister(copy(cmt.seed), dSFMT.dsfmt_jump(cmt.state, jumppoly)))
     end
     return mts
 end
@@ -195,14 +220,14 @@ function make_seed()
         seed = reinterpret(UInt64, time())
         seed = hash(seed, UInt64(getpid()))
         try
-        seed = hash(seed, parse(UInt64, readstring(pipeline(`ifconfig`, `sha1sum`))[1:40], 16))
+        seed = hash(seed, parse(UInt64, read(pipeline(`ifconfig`, `sha1sum`), String)[1:40], 16))
         end
         return make_seed(seed)
     end
 end
 
 function make_seed(n::Integer)
-    n < 0 && throw(DomainError())
+    n < 0 && throw(DomainError(n, "`n` must be non-negative."))
     seed = UInt32[]
     while true
         push!(seed, n & 0xffffffff)
@@ -213,24 +238,39 @@ function make_seed(n::Integer)
     end
 end
 
-function make_seed(filename::AbstractString, n::Integer)
-    read!(filename, Array{UInt32}(Int(n)))
-end
-
 ## srand()
 
 """
-    srand([rng=GLOBAL_RNG], [seed])
+    srand([rng=GLOBAL_RNG], seed) -> rng
+    srand([rng=GLOBAL_RNG]) -> rng
 
 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.
+`MersenneTwister`, the `seed` may be a non-negative integer or a vector of [`UInt32`](@ref)
+integers. `RandomDevice` does not support seeding.
+
+# Examples
+```jldoctest
+julia> srand(1234);
+
+julia> x1 = rand(2)
+2-element Array{Float64,1}:
+ 0.590845
+ 0.766797
+
+julia> srand(1234);
+
+julia> x2 = rand(2)
+2-element Array{Float64,1}:
+ 0.590845
+ 0.766797
+
+julia> x1 == x2
+true
+```
 """
 srand(r::MersenneTwister) = srand(r, make_seed())
 srand(r::MersenneTwister, n::Integer) = srand(r, make_seed(n))
-srand(r::MersenneTwister, filename::AbstractString, n::Integer=4) = srand(r, make_seed(filename, n))
 
 
 function dsfmt_gv_srand()
@@ -244,19 +284,14 @@ function srand()
     dsfmt_gv_srand()
 end
 
-function srand(seed::Union{Integer, Vector{UInt32}})
+function srand(seed::Union{Integer,Vector{UInt32}})
     srand(GLOBAL_RNG, seed)
     dsfmt_gv_srand()
 end
 
-function srand(filename::AbstractString, n::Integer=4)
-    srand(GLOBAL_RNG, filename, n)
-    dsfmt_gv_srand()
-end
-
 ## Global RNG
 
-const GLOBAL_RNG = MersenneTwister()
+const GLOBAL_RNG = MersenneTwister(0)
 globalRNG() = GLOBAL_RNG
 
 # rand: a non-specified RNG defaults to GLOBAL_RNG
@@ -266,33 +301,70 @@ globalRNG() = GLOBAL_RNG
 
 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
+* an indexable collection (for example `1:n` or `['x','y','z']`),
+* an `Associative` or `AbstractSet` object,
+* a string (considered as a collection of characters), 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`.
+  integers (this is not applicable to [`BigInt`](@ref)), and to ``[0, 1)`` for floating
+  point numbers;
+
+`S` defaults to [`Float64`](@ref).
+
+# Examples
+```julia-repl
+julia> rand(Int, 2)
+2-element Array{Int64,1}:
+ 1339893410598768192
+ 1575814717733606317
+
+julia> rand(MersenneTwister(0), Dict(1=>2, 3=>4))
+1=>2
+```
+
+!!! note
+    The complexity of `rand(rng, s::Union{Associative,AbstractSet})`
+    is linear in the length of `s`, unless an optimized method with
+    constant complexity is available, which is the case for `Dict`,
+    `Set` and `IntSet`. For more than a few calls, use `rand(rng,
+    collect(s))` instead, or either `rand(rng, Dict(s))` or `rand(rng,
+    Set(s))` as appropriate.
 """
 @inline rand() = rand(GLOBAL_RNG, CloseOpen)
 @inline rand(T::Type) = rand(GLOBAL_RNG, T)
 rand(dims::Dims) = rand(GLOBAL_RNG, dims)
-rand(dims::Integer...) = rand(convert(Tuple{Vararg{Int}}, dims))
+rand(dims::Integer...) = rand(convert(Dims, dims))
 rand(T::Type, dims::Dims) = rand(GLOBAL_RNG, T, dims)
-rand(T::Type, d1::Integer, dims::Integer...) = rand(T, tuple(Int(d1), convert(Tuple{Vararg{Int}}, dims)...))
+rand(T::Type, d1::Integer, dims::Integer...) = rand(T, tuple(Int(d1), convert(Dims, dims)...))
 rand!(A::AbstractArray) = rand!(GLOBAL_RNG, A)
 
 rand(r::AbstractArray) = rand(GLOBAL_RNG, r)
 
 """
-    rand!([rng=GLOBAL_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!([rng=GLOBAL_RNG], A, [S=eltype(A)])
+
+Populate the array `A` with random values. If `S` is specified
+(`S` can be a type or a collection, cf. [`rand`](@ref) for details),
+the values are picked randomly from `S`.
+This is equivalent to `copy!(A, rand(rng, S, size(A)))`
+but without allocating a new array.
+
+# Examples
+```jldoctest
+julia> rng = MersenneTwister(1234);
+
+julia> rand!(rng, zeros(5))
+5-element Array{Float64,1}:
+ 0.590845
+ 0.766797
+ 0.566237
+ 0.460085
+ 0.794026
+```
 """
 rand!(A::AbstractArray, r::AbstractArray) = rand!(GLOBAL_RNG, A, r)
 
 rand(r::AbstractArray, dims::Dims) = rand(GLOBAL_RNG, r, dims)
-rand(r::AbstractArray, dims::Integer...) = rand(GLOBAL_RNG, r, convert(Tuple{Vararg{Int}}, dims))
+rand(r::AbstractArray, dims::Integer...) = rand(GLOBAL_RNG, r, convert(Dims, dims))
 
 ## random floating point values
 
@@ -320,7 +392,8 @@ rand(r::Union{RandomDevice,MersenneTwister}, ::Type{Float32}) =
 
 # MersenneTwister
 
-@inline rand{T<:Union{Bool, Int8, UInt8, Int16, UInt16, Int32, UInt32}}(r::MersenneTwister, ::Type{T}) = rand_ui52_raw(r) % T
+@inline rand(r::MersenneTwister, ::Type{T}) where {T<:Union{Bool,Int8,UInt8,Int16,UInt16,Int32,UInt32}} =
+    rand_ui52_raw(r) % T
 
 function rand(r::MersenneTwister, ::Type{UInt64})
     reserve(r, 2)
@@ -339,7 +412,7 @@ rand(r::MersenneTwister, ::Type{Int128})  = reinterpret(Int128, rand(r, UInt128)
 
 ## random Complex values
 
-rand{T<:Real}(r::AbstractRNG, ::Type{Complex{T}}) = complex(rand(r, T), rand(r, T))
+rand(r::AbstractRNG, ::Type{Complex{T}}) where {T<:Real} = complex(rand(r, T), rand(r, T))
 
 # random Char values
 # returns a random valid Unicode scalar value (i.e. 0 - 0xd7ff, 0xe000 - # 0x10ffff)
@@ -348,40 +421,83 @@ function rand(r::AbstractRNG, ::Type{Char})
     (c < 0xd800) ? Char(c) : Char(c+0x800)
 end
 
-# random values from Dict or Set (for efficiency)
+# random values from Dict, Set, IntSet (for efficiency)
 function rand(r::AbstractRNG, t::Dict)
-    isempty(t) && throw(ArgumentError("dict must be non-empty"))
-    n = length(t.slots)
+    isempty(t) && throw(ArgumentError("collection must be non-empty"))
+    rg = RangeGenerator(1:length(t.slots))
     while true
-        i = rand(r, 1:n)
-        Base.isslotfilled(t, i) && return (t.keys[i] => t.vals[i])
+        i = rand(r, rg)
+        Base.isslotfilled(t, i) && @inbounds return (t.keys[i] => t.vals[i])
     end
 end
-rand(t::Dict) = rand(GLOBAL_RNG, t)
+
 rand(r::AbstractRNG, s::Set) = rand(r, s.dict).first
-rand(s::Set) = rand(GLOBAL_RNG, s)
+
+function rand(r::AbstractRNG, s::IntSet)
+    isempty(s) && throw(ArgumentError("collection must be non-empty"))
+    # s can be empty while s.bits is not, so we cannot rely on the
+    # length check in RangeGenerator below
+    rg = RangeGenerator(1:length(s.bits))
+    while true
+        n = rand(r, rg)
+        @inbounds b = s.bits[n]
+        b && return n
+    end
+end
+
+function nth(iter, n::Integer)::eltype(iter)
+    for (i, x) in enumerate(iter)
+        i == n && return x
+    end
+end
+nth(iter::AbstractArray, n::Integer) = iter[n]
+
+rand(r::AbstractRNG, s::Union{Associative,AbstractSet}) = nth(s, rand(r, 1:length(s)))
+
+rand(s::Union{Associative,AbstractSet}) = rand(GLOBAL_RNG, s)
 
 ## Arrays of random numbers
 
 rand(r::AbstractRNG, dims::Dims) = rand(r, Float64, dims)
-rand(r::AbstractRNG, dims::Integer...) = rand(r, convert(Tuple{Vararg{Int}}, dims))
+rand(r::AbstractRNG, dims::Integer...) = rand(r, convert(Dims, dims))
 
 rand(r::AbstractRNG, T::Type, dims::Dims) = rand!(r, Array{T}(dims))
-rand(r::AbstractRNG, T::Type, d1::Integer, dims::Integer...) = rand(r, T, tuple(Int(d1), convert(Tuple{Vararg{Int}}, dims)...))
+rand(r::AbstractRNG, T::Type, d1::Integer, dims::Integer...) = rand(r, T, tuple(Int(d1), convert(Dims, dims)...))
 # note: the above method would trigger an ambiguity warning if d1 was not separated out:
 # rand(r, ()) would match both this method and rand(r, dims::Dims)
 # moreover, a call like rand(r, NotImplementedType()) would be an infinite loop
 
-function rand!{T}(r::AbstractRNG, A::AbstractArray{T})
+function rand!(r::AbstractRNG, A::AbstractArray{T}, ::Type{X}=T) where {T,X}
     for i in eachindex(A)
-        @inbounds A[i] = rand(r, T)
+        @inbounds A[i] = rand(r, X)
     end
     A
 end
 
+rand!(A::AbstractArray, ::Type{X}) where {X} = rand!(GLOBAL_RNG, A, X)
+
+function rand!(r::AbstractRNG, A::AbstractArray, s::Union{Dict,Set,IntSet})
+    for i in eachindex(A)
+        @inbounds A[i] = rand(r, s)
+    end
+    A
+end
+
+# avoid linear complexity for repeated calls with generic containers
+rand!(r::AbstractRNG, A::AbstractArray, s::Union{Associative,AbstractSet}) = rand!(r, A, collect(s))
+
+rand!(A::AbstractArray, s::Union{Associative,AbstractSet}) = rand!(GLOBAL_RNG, A, s)
+
+rand(r::AbstractRNG, s::Associative{K,V}, dims::Dims) where {K,V} = rand!(r, Array{Pair{K,V}}(dims), s)
+rand(r::AbstractRNG, s::AbstractSet{T}, dims::Dims) where {T} = rand!(r, Array{T}(dims), s)
+rand(r::AbstractRNG, s::Union{Associative,AbstractSet}, dims::Integer...) = rand(r, s, convert(Dims, dims))
+rand(s::Union{Associative,AbstractSet}, dims::Integer...) = rand(GLOBAL_RNG, s, convert(Dims, dims))
+rand(s::Union{Associative,AbstractSet}, dims::Dims) = rand(GLOBAL_RNG, s, dims)
+
 # MersenneTwister
 
-function rand_AbstractArray_Float64!{I<:FloatInterval}(r::MersenneTwister, A::AbstractArray{Float64}, n=length(A), ::Type{I}=CloseOpen)
+function rand_AbstractArray_Float64!(r::MersenneTwister, A::AbstractArray{Float64},
+                                     n=length(A), ::Type{I}=CloseOpen) where I<:FloatInterval
     # what follows is equivalent to this simple loop but more efficient:
     # for i=1:n
     #     @inbounds A[i] = rand(r, I)
@@ -407,7 +523,7 @@ rand!(r::MersenneTwister, A::AbstractArray{Float64}) = rand_AbstractArray_Float6
 fill_array!(s::DSFMT_state, A::Ptr{Float64}, n::Int, ::Type{CloseOpen}) = dsfmt_fill_array_close_open!(s, A, n)
 fill_array!(s::DSFMT_state, A::Ptr{Float64}, n::Int, ::Type{Close1Open2}) = dsfmt_fill_array_close1_open2!(s, A, n)
 
-function rand!{I<:FloatInterval}(r::MersenneTwister, A::Array{Float64}, n::Int=length(A), ::Type{I}=CloseOpen)
+function rand!(r::MersenneTwister, A::Array{Float64}, n::Int=length(A), ::Type{I}=CloseOpen) where I<:FloatInterval
     # depending on the alignment of A, the data written by fill_array! may have
     # to be left-shifted by up to 15 bytes (cf. unsafe_copy! below) for
     # reproducibility purposes;
@@ -440,7 +556,8 @@ end
 @inline mask128(u::UInt128, ::Type{Float16}) = (u & 0x03ff03ff03ff03ff03ff03ff03ff03ff) | 0x3c003c003c003c003c003c003c003c00
 @inline mask128(u::UInt128, ::Type{Float32}) = (u & 0x007fffff007fffff007fffff007fffff) | 0x3f8000003f8000003f8000003f800000
 
-function rand!{T<:Union{Float16, Float32}}(r::MersenneTwister, A::Array{T}, ::Type{Close1Open2})
+function rand!(r::MersenneTwister, A::Union{Array{Float16},Array{Float32}}, ::Type{Close1Open2})
+    T = eltype(A)
     n = length(A)
     n128 = n * sizeof(T) ÷ 16
     rand!(r, unsafe_wrap(Array, convert(Ptr{Float64}, pointer(A)), 2*n128), 2*n128, Close1Open2)
@@ -464,17 +581,16 @@ function rand!{T<:Union{Float16, Float32}}(r::MersenneTwister, A::Array{T}, ::Ty
     A
 end
 
-function rand!{T<:Union{Float16, Float32}}(r::MersenneTwister, A::Array{T}, ::Type{CloseOpen})
+function rand!(r::MersenneTwister, A::Union{Array{Float16},Array{Float32}}, ::Type{CloseOpen})
     rand!(r, A, Close1Open2)
     I32 = one(Float32)
     for i in eachindex(A)
-        @inbounds A[i] = T(Float32(A[i])-I32) # faster than "A[i] -= one(T)" for T==Float16
+        @inbounds A[i] = Float32(A[i])-I32 # faster than "A[i] -= one(T)" for T==Float16
     end
     A
 end
 
-rand!(r::MersenneTwister, A::Array{<:Union{Float16, Float32}}) = rand!(r, A, CloseOpen)
-
+rand!(r::MersenneTwister, A::Union{Array{Float16},Array{Float32}}) = rand!(r, A, CloseOpen)
 
 function rand!(r::MersenneTwister, A::Array{UInt128}, n::Int=length(A))
     if n > length(A)
@@ -498,14 +614,16 @@ function rand!(r::MersenneTwister, A::Array{UInt128}, n::Int=length(A))
     if n > 0
         u = rand_ui2x52_raw(r)
         for i = 1:n
-            @inbounds A[i] ⊻= u << 12*i
+            @inbounds A[i] ⊻= u << (12*i)
         end
     end
     A
 end
 
-function rand!{T<:Union{Int8, UInt8, Int16, UInt16, Int32, UInt32, Int64, UInt64, Int128}}(r::MersenneTwister, A::Array{T})
-    n=length(A)
+# A::Array{UInt128} will match the specialized method above
+function rand!(r::MersenneTwister, A::Base.BitIntegerArray)
+    n = length(A)
+    T = eltype(A)
     n128 = n * sizeof(T) ÷ 16
     rand!(r, unsafe_wrap(Array, convert(Ptr{UInt128}, pointer(A)), n128))
     for i = 16*n128÷sizeof(T)+1:n
@@ -518,29 +636,29 @@ end
 
 # remainder function according to Knuth, where rem_knuth(a, 0) = a
 rem_knuth(a::UInt, b::UInt) = a % (b + (b == 0)) + a * (b == 0)
-rem_knuth{T<:Unsigned}(a::T, b::T) = b != 0 ? a % b : a
+rem_knuth(a::T, b::T) where {T<:Unsigned} = b != 0 ? a % b : a
 
 # maximum multiple of k <= 2^bits(T) decremented by one,
 # that is 0xFFFF...FFFF if k = typemax(T) - typemin(T) with intentional underflow
 # see http://stackoverflow.com/questions/29182036/integer-arithmetic-add-1-to-uint-max-and-divide-by-n-without-overflow
-maxmultiple{T<:Unsigned}(k::T) = (div(typemax(T) - k + oneunit(k), k + (k == 0))*k + k - oneunit(k))::T
+maxmultiple(k::T) where {T<:Unsigned} = (div(typemax(T) - k + oneunit(k), k + (k == 0))*k + k - oneunit(k))::T
 
 # maximum multiple of k within 1:2^32 or 1:2^64 decremented by one, depending on size
 maxmultiplemix(k::UInt64) = if k >> 32 != 0; maxmultiple(k); else (div(0x0000000100000000, k + (k == 0))*k - oneunit(k))::UInt64; end
 
 abstract type RangeGenerator end
 
-struct RangeGeneratorInt{T<:Integer, U<:Unsigned} <: RangeGenerator
+struct RangeGeneratorInt{T<:Integer,U<:Unsigned} <: RangeGenerator
     a::T   # first element of the range
     k::U   # range length or zero for full range
     u::U   # rejection threshold
 end
 # generators with 32, 128 bits entropy
-RangeGeneratorInt{T, U<:Union{UInt32, UInt128}}(a::T, k::U) = RangeGeneratorInt{T, U}(a, k, maxmultiple(k))
+RangeGeneratorInt(a::T, k::U) where {T,U<:Union{UInt32,UInt128}} = RangeGeneratorInt{T,U}(a, k, maxmultiple(k))
 # mixed 32/64 bits entropy generator
-RangeGeneratorInt{T}(a::T, k::UInt64) = RangeGeneratorInt{T,UInt64}(a, k, maxmultiplemix(k))
+RangeGeneratorInt(a::T, k::UInt64) where {T} = RangeGeneratorInt{T,UInt64}(a, k, maxmultiplemix(k))
 # generator for ranges
-RangeGenerator{T<:Unsigned}(r::UnitRange{T}) = begin
+function RangeGenerator(r::UnitRange{T}) where T<:Unsigned
     if isempty(r)
         throw(ArgumentError("range must be non-empty"))
     end
@@ -560,23 +678,12 @@ for (T, U) in [(UInt8, UInt32), (UInt16, UInt32),
     end
 end
 
-if GMP_VERSION.major >= 6
-    struct RangeGeneratorBigInt <: RangeGenerator
-        a::BigInt             # first
-        m::BigInt             # range length - 1
-        nlimbs::Int           # number of limbs in generated BigInt's
-        mask::Limb            # applied to the highest limb
-    end
-
-else
-    struct RangeGeneratorBigInt <: RangeGenerator
-        a::BigInt             # first
-        m::BigInt             # range length - 1
-        limbs::Vector{Limb}   # buffer to be copied into generated BigInt's
-        mask::Limb            # applied to the highest limb
-
-        RangeGeneratorBigInt(a, m, nlimbs, mask) = new(a, m, Array{Limb}(nlimbs), mask)
-    end
+struct RangeGeneratorBigInt <: RangeGenerator
+    a::BigInt         # first
+    m::BigInt         # range length - 1
+    nlimbs::Int       # number of limbs in generated BigInt's (z ∈ [0, m])
+    nlimbsmax::Int    # max number of limbs for z+a
+    mask::Limb        # applied to the highest limb
 end
 
 
@@ -587,13 +694,14 @@ function RangeGenerator(r::UnitRange{BigInt})
     nlimbs, highbits = divrem(nd, 8*sizeof(Limb))
     highbits > 0 && (nlimbs += 1)
     mask = highbits == 0 ? ~zero(Limb) : one(Limb)<<highbits - one(Limb)
-    return RangeGeneratorBigInt(first(r), m, nlimbs, mask)
+    nlimbsmax = max(nlimbs, abs(last(r).size), abs(first(r).size))
+    return RangeGeneratorBigInt(first(r), m, nlimbs, nlimbsmax, mask)
 end
 
 
 # this function uses 32 bit entropy for small ranges of length <= typemax(UInt32) + 1
 # RangeGeneratorInt is responsible for providing the right value of k
-function rand{T<:Union{UInt64, Int64}}(rng::AbstractRNG, g::RangeGeneratorInt{T,UInt64})
+function rand(rng::AbstractRNG, g::RangeGeneratorInt{T,UInt64}) where T<:Union{UInt64,Int64}
     local x::UInt64
     if (g.k - 1) >> 32 == 0
         x = rand(rng, UInt32)
@@ -609,7 +717,7 @@ function rand{T<:Union{UInt64, Int64}}(rng::AbstractRNG, g::RangeGeneratorInt{T,
     return reinterpret(T, reinterpret(UInt64, g.a) + rem_knuth(x, g.k))
 end
 
-function rand{T<:Integer, U<:Unsigned}(rng::AbstractRNG, g::RangeGeneratorInt{T,U})
+function rand(rng::AbstractRNG, g::RangeGeneratorInt{T,U}) where U<:Unsigned where T<:Integer
     x = rand(rng, U)
     while x > g.u
         x = rand(rng, U)
@@ -617,36 +725,21 @@ function rand{T<:Integer, U<:Unsigned}(rng::AbstractRNG, g::RangeGeneratorInt{T,
     (unsigned(g.a) + rem_knuth(x, g.k)) % T
 end
 
-if GMP_VERSION.major >= 6
-    # mpz_limbs_write and mpz_limbs_finish are available only in GMP version 6
-    function rand(rng::AbstractRNG, g::RangeGeneratorBigInt)
-        x = BigInt()
-        while true
-            # note: on CRAY computers, the second argument may be of type Cint (48 bits) and not Clong
-            xd = ccall((:__gmpz_limbs_write, :libgmp), Ptr{Limb}, (Ptr{BigInt}, Clong), &x, g.nlimbs)
-            limbs = unsafe_wrap(Array, xd, g.nlimbs)
-            rand!(rng, limbs)
-            limbs[end] &= g.mask
-            ccall((:__gmpz_limbs_finish, :libgmp), Void, (Ptr{BigInt}, Clong), &x, g.nlimbs)
-            x <= g.m && break
-        end
-        ccall((:__gmpz_add, :libgmp), Void, (Ptr{BigInt}, Ptr{BigInt}, Ptr{BigInt}), &x, &x, &g.a)
-        return x
+function rand(rng::AbstractRNG, g::RangeGeneratorBigInt)
+    x = MPZ.realloc2(g.nlimbsmax*8*sizeof(Limb))
+    limbs = unsafe_wrap(Array, x.d, g.nlimbs)
+    while true
+        rand!(rng, limbs)
+        @inbounds limbs[end] &= g.mask
+        MPZ.mpn_cmp(x, g.m, g.nlimbs) <= 0 && break
     end
-else
-    function rand(rng::AbstractRNG, g::RangeGeneratorBigInt)
-        x = BigInt()
-        while true
-            rand!(rng, g.limbs)
-            g.limbs[end] &= g.mask
-            ccall((:__gmpz_import, :libgmp), Void,
-                  (Ptr{BigInt}, Csize_t, Cint, Csize_t, Cint, Csize_t, Ptr{Limb}),
-                  &x, length(g.limbs), -1, sizeof(Limb), 0, 0, g.limbs)
-            x <= g.m && break
-        end
-        ccall((:__gmpz_add, :libgmp), Void, (Ptr{BigInt}, Ptr{BigInt}, Ptr{BigInt}), &x, &x, &g.a)
-        return x
+    # adjust x.size (normally done by mpz_limbs_finish, in GMP version >= 6)
+    x.size = g.nlimbs
+    while x.size > 0
+        @inbounds limbs[x.size] != 0 && break
+        x.size -= 1
     end
+    MPZ.add!(x, g.a)
 end
 
 rand(rng::AbstractRNG, r::UnitRange{<:Union{Signed,Unsigned,BigInt,Bool}}) = rand(rng, RangeGenerator(r))
@@ -673,8 +766,35 @@ function rand!(rng::AbstractRNG, A::AbstractArray, r::AbstractArray)
     return A
 end
 
-rand{T}(rng::AbstractRNG, r::AbstractArray{T}, dims::Dims) = rand!(rng, Array{T}(dims), r)
-rand(rng::AbstractRNG, r::AbstractArray, dims::Int...) = rand(rng, r, dims)
+rand(rng::AbstractRNG, r::AbstractArray{T}, dims::Dims) where {T} = rand!(rng, Array{T}(dims), r)
+rand(rng::AbstractRNG, r::AbstractArray, dims::Integer...) = rand(rng, r, convert(Dims, dims))
+
+# rand from a string
+
+isvalid_unsafe(s::String, i) = !Base.is_valid_continuation(unsafe_load(pointer(s), i))
+isvalid_unsafe(s::AbstractString, i) = isvalid(s, i)
+_endof(s::String) = sizeof(s)
+_endof(s::AbstractString) = endof(s)
+
+function rand(rng::AbstractRNG, s::AbstractString)::Char
+    g = RangeGenerator(1:_endof(s))
+    while true
+        pos = rand(rng, g)
+        isvalid_unsafe(s, pos) && return s[pos]
+    end
+end
+
+rand(s::AbstractString) = rand(GLOBAL_RNG, s)
+
+## rand from a string for arrays
+# we use collect(str), which is most of the time more efficient than specialized methods
+# (except maybe for very small arrays)
+rand!(rng::AbstractRNG, A::AbstractArray, str::AbstractString) = rand!(rng, A, collect(str))
+rand!(A::AbstractArray, str::AbstractString) = rand!(GLOBAL_RNG, A, str)
+rand(rng::AbstractRNG, str::AbstractString, dims::Dims) = rand!(rng, Array{eltype(str)}(dims), str)
+rand(rng::AbstractRNG, str::AbstractString, d1::Integer, dims::Integer...) = rand(rng, str, convert(Dims, tuple(d1, dims...)))
+rand(str::AbstractString, dims::Dims) = rand(GLOBAL_RNG, str, dims)
+rand(str::AbstractString, d1::Integer, dims::Integer...) = rand(GLOBAL_RNG, str, d1, dims...)
 
 ## random BitArrays (AbstractRNG)
 
@@ -690,12 +810,30 @@ end
     bitrand([rng=GLOBAL_RNG], [dims...])
 
 Generate a `BitArray` of random boolean values.
+
+# Examples
+```jldoctest
+julia> rng = MersenneTwister(1234);
+
+julia> bitrand(rng, 10)
+10-element BitArray{1}:
+  true
+  true
+  true
+ false
+  true
+ false
+ false
+  true
+ false
+  true
+```
 """
 bitrand(r::AbstractRNG, dims::Dims)   = rand!(r, BitArray(dims))
-bitrand(r::AbstractRNG, dims::Int...) = rand!(r, BitArray(dims))
+bitrand(r::AbstractRNG, dims::Integer...) = rand!(r, BitArray(convert(Dims, dims)))
 
 bitrand(dims::Dims)   = rand!(BitArray(dims))
-bitrand(dims::Int...) = rand!(BitArray(dims))
+bitrand(dims::Integer...) = rand!(BitArray(convert(Dims, dims)))
 
 ## randn() - Normally distributed random numbers using Ziggurat algorithm
 
@@ -1197,7 +1335,22 @@ const ziggurat_exp_r      = 7.6971174701310497140446280481
 Generate a normally-distributed random number of type `T` with mean 0 and standard deviation 1.
 Optionally generate an array of normally-distributed random numbers.
 The `Base` module currently provides an implementation for the types
-`Float16`, `Float32`, and `Float64` (the default).
+[`Float16`](@ref), [`Float32`](@ref), and [`Float64`](@ref) (the default), and their
+[`Complex`](@ref) counterparts. When the type argument is complex, the values are drawn
+from the circularly symmetric complex normal distribution.
+
+# Examples
+```jldoctest
+julia> rng = MersenneTwister(1234);
+
+julia> randn(rng, Complex128)
+0.6133070881429037 - 0.6376291670853887im
+
+julia> randn(rng, Complex64, (2, 3))
+2×3 Array{Complex{Float32},2}:
+ -0.349649-0.638457im  0.376756-0.192146im  -0.396334-0.0136413im
+  0.611224+1.56403im   0.355204-0.365563im  0.0905552+1.31012im
+```
 """
 @inline function randn(rng::AbstractRNG=GLOBAL_RNG)
     @inbounds begin
@@ -1231,7 +1384,21 @@ end
 Generate a random number of type `T` according to the exponential distribution with scale 1.
 Optionally generate an array of such random numbers.
 The `Base` module currently provides an implementation for the types
-`Float16`, `Float32`, and `Float64` (the default).
+[`Float16`](@ref), [`Float32`](@ref), and [`Float64`](@ref) (the default).
+
+# Examples
+```jldoctest
+julia> rng = MersenneTwister(1234);
+
+julia> randexp(rng, Float32)
+2.4835055f0
+
+julia> randexp(rng, 3, 3)
+3×3 Array{Float64,2}:
+ 1.5167    1.30652   0.344435
+ 0.604436  2.78029   0.418516
+ 0.695867  0.693292  0.643644
+```
 """
 @inline function randexp(rng::AbstractRNG=GLOBAL_RNG)
     @inbounds begin
@@ -1258,6 +1425,19 @@ end
 
 Fill the array `A` with normally-distributed (mean 0, standard deviation 1) random numbers.
 Also see the [`rand`](@ref) function.
+
+# Examples
+```jldoctest
+julia> rng = MersenneTwister(1234);
+
+julia> randn!(rng, zeros(5))
+5-element Array{Float64,1}:
+  0.867347
+ -0.901744
+ -0.494479
+ -0.902914
+  0.864401
+```
 """
 function randn! end
 
@@ -1265,41 +1445,58 @@ function randn! end
     randexp!([rng=GLOBAL_RNG], A::AbstractArray) -> A
 
 Fill the array `A` with random numbers following the exponential distribution (with scale 1).
+
+# Examples
+```jldoctest
+julia> rng = MersenneTwister(1234);
+
+julia> randexp!(rng, zeros(5))
+5-element Array{Float64,1}:
+ 2.48351
+ 1.5167
+ 0.604436
+ 0.695867
+ 1.30652
+```
 """
 function randexp! end
 
-let Floats = Union{Float16,Float32,Float64}
-    for randfun in [:randn, :randexp]
-        randfun! = Symbol(randfun, :!)
-        @eval begin
-            # scalars
-            $randfun{T<:$Floats}(rng::AbstractRNG, ::Type{T}) = convert(T, $randfun(rng))
-            $randfun{T}(::Type{T}) = $randfun(GLOBAL_RNG, T)
-
-            # filling arrays
-            function $randfun!{T}(rng::AbstractRNG, A::AbstractArray{T})
-                for i in eachindex(A)
-                    @inbounds A[i] = $randfun(rng, T)
-                end
-                A
+for randfun in [:randn, :randexp]
+    randfun! = Symbol(randfun, :!)
+    @eval begin
+        # scalars
+        $randfun(rng::AbstractRNG, T::Union{Type{Float16},Type{Float32},Type{Float64}}) =
+            convert(T, $randfun(rng))
+        $randfun(::Type{T}) where {T} = $randfun(GLOBAL_RNG, T)
+
+        # filling arrays
+        function $randfun!(rng::AbstractRNG, A::AbstractArray{T}) where T
+            for i in eachindex(A)
+                @inbounds A[i] = $randfun(rng, T)
             end
-
-            $randfun!(A::AbstractArray) = $randfun!(GLOBAL_RNG, A)
-
-            # generating arrays
-            $randfun{T}(rng::AbstractRNG, ::Type{T}, dims::Dims                     ) = $randfun!(rng, Array{T}(dims))
-            # Note that this method explicitly does not define $randfun(rng, T), in order to prevent an infinite recursion.
-            $randfun{T}(rng::AbstractRNG, ::Type{T}, dim1::Integer, dims::Integer...) = $randfun!(rng, Array{T}(dim1, dims...))
-            $randfun{T}(                  ::Type{T}, dims::Dims                     ) = $randfun(GLOBAL_RNG, T, dims)
-            $randfun{T}(                  ::Type{T}, dims::Integer...               ) = $randfun(GLOBAL_RNG, T, dims...)
-            $randfun(   rng::AbstractRNG,            dims::Dims                     ) = $randfun(rng, Float64, dims)
-            $randfun(   rng::AbstractRNG,            dims::Integer...               ) = $randfun(rng, Float64, dims...)
-            $randfun(                                dims::Dims                     ) = $randfun(GLOBAL_RNG, Float64, dims)
-            $randfun(                                dims::Integer...               ) = $randfun(GLOBAL_RNG, Float64, dims...)
+            A
         end
+
+        $randfun!(A::AbstractArray) = $randfun!(GLOBAL_RNG, A)
+
+        # generating arrays
+        $randfun(rng::AbstractRNG, ::Type{T}, dims::Dims                     ) where {T} = $randfun!(rng, Array{T}(dims))
+        # Note that this method explicitly does not define $randfun(rng, T), in order to prevent an infinite recursion.
+        $randfun(rng::AbstractRNG, ::Type{T}, dim1::Integer, dims::Integer...) where {T} = $randfun!(rng, Array{T}(dim1, dims...))
+        $randfun(                  ::Type{T}, dims::Dims                     ) where {T} = $randfun(GLOBAL_RNG, T, dims)
+        $randfun(                  ::Type{T}, dims::Integer...               ) where {T} = $randfun(GLOBAL_RNG, T, dims...)
+        $randfun(rng::AbstractRNG,            dims::Dims                     )           = $randfun(rng, Float64, dims)
+        $randfun(rng::AbstractRNG,            dims::Integer...               )           = $randfun(rng, Float64, dims...)
+        $randfun(                             dims::Dims                     )           = $randfun(GLOBAL_RNG, Float64, dims)
+        $randfun(                             dims::Integer...               )           = $randfun(GLOBAL_RNG, Float64, dims...)
     end
 end
 
+# complex randn
+Base.@irrational SQRT_HALF 0.7071067811865475244008  sqrt(big(0.5))
+randn(rng::AbstractRNG, ::Type{Complex{T}}) where {T<:AbstractFloat} =
+    Complex{T}(SQRT_HALF * randn(rng, T), SQRT_HALF * randn(rng, T))
+
 ## random UUID generation
 
 struct UUID
@@ -1314,6 +1511,14 @@ end
 Generates a version 1 (time-based) universally unique identifier (UUID), as specified
 by RFC 4122. Note that the Node ID is randomly generated (does not identify the host)
 according to section 4.5 of the RFC.
+
+# Examples
+```jldoctest
+julia> rng = MersenneTwister(1234);
+
+julia> Base.Random.uuid1(rng)
+2cc938da-5937-11e7-196e-0f4ef71aa64b
+```
 """
 function uuid1(rng::AbstractRNG=GLOBAL_RNG)
     u = rand(rng, UInt128)
@@ -1343,6 +1548,14 @@ end
 
 Generates a version 4 (random or pseudo-random) universally unique identifier (UUID),
 as specified by RFC 4122.
+
+# Examples
+```jldoctest
+julia> rng = MersenneTwister(1234);
+
+julia> Base.Random.uuid4(rng)
+82015f10-44cc-4827-996e-0f4ef71aa64b
+```
 """
 function uuid4(rng::AbstractRNG=GLOBAL_RNG)
     u = rand(rng, UInt128)
@@ -1355,6 +1568,14 @@ end
     uuid_version(u::UUID) -> Integer
 
 Inspects the given UUID and returns its version (see RFC 4122).
+
+# Examples
+```jldoctest
+julia> rng = MersenneTwister(1234);
+
+julia> Base.Random.uuid_version(Base.Random.uuid4(rng))
+4
+```
 """
 function uuid_version(u::UUID)
     Int((u.value >> 76) & 0xf)
@@ -1380,7 +1601,7 @@ end
 
 function Base.repr(u::UUID)
     u = u.value
-    a = Array{UInt8}(36)
+    a = Vector{UInt8}(36)
     for i = [36:-1:25; 23:-1:20; 18:-1:15; 13:-1:10; 8:-1:1]
         d = u & 0xf
         a[i] = '0'+d+39*(d>9)
@@ -1394,15 +1615,42 @@ end
 Base.show(io::IO, u::UUID) = write(io, Base.repr(u))
 
 # return a random string (often useful for temporary filenames/dirnames)
+
+"""
+    randstring([rng=GLOBAL_RNG], [chars], [len=8])
+
+Create a random string of length `len`, consisting of characters from
+`chars`, which defaults to the set of upper- and lower-case letters
+and the digits 0-9. The optional `rng` argument specifies a random
+number generator, see [Random Numbers](@ref).
+
+# Examples
+```jldoctest
+julia> srand(0); randstring()
+"c03rgKi1"
+
+julia> randstring(MersenneTwister(0), 'a':'z', 6)
+"wijzek"
+
+julia> randstring("ACGT")
+"TATCGGTC"
+```
+
+!!! note
+    `chars` can be any collection of characters, of type `Char` or
+    `UInt8` (more efficient), provided [`rand`](@ref) can randomly
+    pick characters from it.
+"""
+function randstring end
+
 let b = UInt8['0':'9';'A':'Z';'a':'z']
     global randstring
-    randstring(r::AbstractRNG, n::Int) = String(b[rand(r, 1:length(b), n)])
-    randstring(r::AbstractRNG) = randstring(r,8)
-    randstring(n::Int) = randstring(GLOBAL_RNG, n)
-    randstring() = randstring(GLOBAL_RNG)
+    randstring(r::AbstractRNG, chars=b, n::Integer=8) = String(rand(r, chars, n))
+    randstring(r::AbstractRNG, n::Integer) = randstring(r, b, n)
+    randstring(chars=b, n::Integer=8) = randstring(GLOBAL_RNG, chars, n)
+    randstring(n::Integer) = randstring(GLOBAL_RNG, b, n)
 end
 
-
 # Fill S (resized as needed) with a random subsequence of A, where
 # each element of A is included in S with independent probability p.
 # (Note that this is different from the problem of finding a random
@@ -1443,7 +1691,7 @@ function randsubseq!(r::AbstractRNG, S::AbstractArray, A::AbstractArray, p::Real
 end
 randsubseq!(S::AbstractArray, A::AbstractArray, p::Real) = randsubseq!(GLOBAL_RNG, S, A, p)
 
-randsubseq{T}(r::AbstractRNG, A::AbstractArray{T}, p::Real) = randsubseq!(r, T[], A, p)
+randsubseq(r::AbstractRNG, A::AbstractArray{T}, p::Real) where {T} = randsubseq!(r, T[], A, p)
 
 """
     randsubseq(A, p) -> Vector
@@ -1466,12 +1714,36 @@ randsubseq(A::AbstractArray, p::Real) = randsubseq(GLOBAL_RNG, A, p)
 end
 
 """
-    shuffle!([rng=GLOBAL_RNG,] v)
+    shuffle!([rng=GLOBAL_RNG,] v::AbstractArray)
 
-In-place version of [`shuffle`](@ref): randomly permute the array `v` in-place,
+In-place version of [`shuffle`](@ref): randomly permute `v` in-place,
 optionally supplying the random-number generator `rng`.
+
+# Examples
+```jldoctest
+julia> rng = MersenneTwister(1234);
+
+julia> shuffle!(rng, collect(1:16))
+16-element Array{Int64,1}:
+  2
+ 15
+  5
+ 14
+  1
+  9
+ 10
+  6
+ 11
+  3
+ 16
+  7
+  4
+ 12
+  8
+ 13
+```
 """
-function shuffle!(r::AbstractRNG, a::AbstractVector)
+function shuffle!(r::AbstractRNG, a::AbstractArray)
     n = length(a)
     @assert n <= Int64(2)^52
     mask = nextpow2(n) - 1
@@ -1483,36 +1755,83 @@ function shuffle!(r::AbstractRNG, a::AbstractVector)
     return a
 end
 
-shuffle!(a::AbstractVector) = shuffle!(GLOBAL_RNG, a)
+shuffle!(a::AbstractArray) = shuffle!(GLOBAL_RNG, a)
 
 """
-    shuffle([rng=GLOBAL_RNG,] v)
+    shuffle([rng=GLOBAL_RNG,] v::AbstractArray)
 
 Return a randomly permuted copy of `v`. The optional `rng` argument specifies a random
 number generator (see [Random Numbers](@ref)).
-To permute `v` in-place, see [`shuffle!`](@ref).  To obtain randomly permuted
+To permute `v` in-place, see [`shuffle!`](@ref). To obtain randomly permuted
 indices, see [`randperm`](@ref).
+
+# Examples
+```jldoctest
+julia> rng = MersenneTwister(1234);
+
+julia> shuffle(rng, collect(1:10))
+10-element Array{Int64,1}:
+  6
+  1
+ 10
+  2
+  3
+  9
+  5
+  7
+  4
+  8
+```
 """
-shuffle(r::AbstractRNG, a::AbstractVector) = shuffle!(r, copymutable(a))
-shuffle(a::AbstractVector) = shuffle(GLOBAL_RNG, a)
+shuffle(r::AbstractRNG, a::AbstractArray) = shuffle!(r, copymutable(a))
+shuffle(a::AbstractArray) = shuffle(GLOBAL_RNG, a)
 
 """
     randperm([rng=GLOBAL_RNG,] n::Integer)
 
 Construct a random permutation of length `n`. The optional `rng` argument specifies a random
 number generator (see [Random Numbers](@ref)).
-To randomly permute a arbitrary vector, see [`shuffle`](@ref)
+To randomly permute an arbitrary vector, see [`shuffle`](@ref)
 or [`shuffle!`](@ref).
+
+# Examples
+```jldoctest
+julia> randperm(MersenneTwister(1234), 4)
+4-element Array{Int64,1}:
+ 2
+ 1
+ 4
+ 3
+```
+"""
+randperm(r::AbstractRNG, n::Integer) = randperm!(r, Vector{Int}(n))
+randperm(n::Integer) = randperm(GLOBAL_RNG, n)
+
+"""
+    randperm!([rng=GLOBAL_RNG,] A::Array{<:Integer})
+
+Construct in `A` a random permutation of length `length(A)`. The
+optional `rng` argument specifies a random number generator (see
+[Random Numbers](@ref)). To randomly permute an arbitrary vector, see
+[`shuffle`](@ref) or [`shuffle!`](@ref).
+
+# Examples
+```jldoctest
+julia> randperm!(MersenneTwister(1234), Vector{Int}(4))
+4-element Array{Int64,1}:
+ 2
+ 1
+ 4
+ 3
+```
 """
-function randperm(r::AbstractRNG, n::Integer)
-    a = Array{typeof(n)}(n)
+function randperm!(r::AbstractRNG, a::Array{<:Integer})
+    n = length(a)
     @assert n <= Int64(2)^52
-    if n == 0
-       return a
-    end
+    n == 0 && return a
     a[1] = 1
     mask = 3
-    @inbounds for i = 2:Int(n)
+    @inbounds for i = 2:n
         j = 1 + rand_lt(r, i, mask)
         if i != j # a[i] is uninitialized (and could be #undef)
             a[i] = a[j]
@@ -1522,21 +1841,57 @@ function randperm(r::AbstractRNG, n::Integer)
     end
     return a
 end
-randperm(n::Integer) = randperm(GLOBAL_RNG, n)
+
+randperm!(a::Array{<:Integer}) = randperm!(GLOBAL_RNG, a)
+
 
 """
     randcycle([rng=GLOBAL_RNG,] n::Integer)
 
 Construct a random cyclic permutation of length `n`. The optional `rng`
 argument specifies a random number generator, see [Random Numbers](@ref).
+
+# Examples
+```jldoctest
+julia> randcycle(MersenneTwister(1234), 6)
+6-element Array{Int64,1}:
+ 3
+ 5
+ 4
+ 6
+ 1
+ 2
+```
 """
-function randcycle(r::AbstractRNG, n::Integer)
-    a = Array{typeof(n)}(n)
+randcycle(r::AbstractRNG, n::Integer) = randcycle!(r, Vector{Int}(n))
+randcycle(n::Integer) = randcycle(GLOBAL_RNG, n)
+
+"""
+    randcycle!([rng=GLOBAL_RNG,] A::Array{<:Integer})
+
+Construct in `A` a random cyclic permutation of length `length(A)`.
+The optional `rng` argument specifies a random number generator, see
+[Random Numbers](@ref).
+
+# Examples
+```jldoctest
+julia> randcycle!(MersenneTwister(1234), Vector{Int}(6))
+6-element Array{Int64,1}:
+ 3
+ 5
+ 4
+ 6
+ 1
+ 2
+```
+"""
+function randcycle!(r::AbstractRNG, a::Array{<:Integer})
+    n = length(a)
     n == 0 && return a
     @assert n <= Int64(2)^52
     a[1] = 1
     mask = 3
-    @inbounds for i = 2:Int(n)
+    @inbounds for i = 2:n
         j = 1 + rand_lt(r, i-1, mask)
         a[i] = a[j]
         a[j] = i
@@ -1544,6 +1899,7 @@ function randcycle(r::AbstractRNG, n::Integer)
     end
     return a
 end
-randcycle(n::Integer) = randcycle(GLOBAL_RNG, n)
+
+randcycle!(a::Array{<:Integer}) = randcycle!(GLOBAL_RNG, a)
 
 end # module
diff --git a/base/range.jl b/base/range.jl
index cc2ad162eb7ff6..381efd9ea5f2f2 100644
--- a/base/range.jl
+++ b/base/range.jl
@@ -1,18 +1,19 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 colon(a::Real, b::Real) = colon(promote(a,b)...)
 
-colon{T<:Real}(start::T, stop::T) = UnitRange{T}(start, stop)
+colon(start::T, stop::T) where {T<:Real} = UnitRange{T}(start, stop)
 
 range(a::Real, len::Integer) = UnitRange{typeof(a)}(a, oftype(a, a+len-1))
 
-colon{T}(start::T, stop::T) = colon(start, oftype(stop-start, 1), stop)
+colon(start::T, stop::T) where {T} = colon(start, oftype(stop-start, 1), stop)
 
 range(a, len::Integer) = range(a, oftype(a-a, 1), len)
 
 # first promote start and stop, leaving step alone
-colon{A<:Real,C<:Real}(start::A, step, stop::C) = colon(convert(promote_type(A,C),start), step, convert(promote_type(A,C),stop))
-colon{T<:Real}(start::T, step::Real, stop::T) = colon(promote(start, step, stop)...)
+colon(start::A, step, stop::C) where {A<:Real,C<:Real} =
+    colon(convert(promote_type(A,C),start), step, convert(promote_type(A,C),stop))
+colon(start::T, step::Real, stop::T) where {T<:Real} = colon(promote(start, step, stop)...)
 
 """
     colon(start, [step], stop)
@@ -24,12 +25,16 @@ julia> colon(1, 2, 5)
 1:2:5
 ```
 """
-colon{T<:AbstractFloat}(start::T, step::T, stop::T) = _colon(TypeOrder(T), TypeArithmetic(T), start, step, stop)
-colon{T<:Real}(start::T, step::T, stop::T) = _colon(TypeOrder(T), TypeArithmetic(T), start, step, stop)
-_colon{T}(::HasOrder, ::Any, start::T, step, stop::T) = StepRange(start, step, stop)
+colon(start::T, step::T, stop::T) where {T<:AbstractFloat} =
+    _colon(TypeOrder(T), TypeArithmetic(T), start, step, stop)
+colon(start::T, step::T, stop::T) where {T<:Real} =
+    _colon(TypeOrder(T), TypeArithmetic(T), start, step, stop)
+_colon(::HasOrder, ::Any, start::T, step, stop::T) where {T} = StepRange(start, step, stop)
 # for T<:Union{Float16,Float32,Float64} see twiceprecision.jl
-_colon{T}(::HasOrder, ::ArithmeticRounds, start::T, step, stop::T) = StepRangeLen(start, step, floor(Int, (stop-start)/step)+1)
-_colon{T}(::Any, ::Any, start::T, step, stop::T) = StepRangeLen(start, step, floor(Int, (stop-start)/step)+1)
+_colon(::HasOrder, ::ArithmeticRounds, start::T, step, stop::T) where {T} =
+    StepRangeLen(start, step, floor(Int, (stop-start)/step)+1)
+_colon(::Any, ::Any, start::T, step, stop::T) where {T} =
+    StepRangeLen(start, step, floor(Int, (stop-start)/step)+1)
 
 """
     :(start, [step], stop)
@@ -38,7 +43,11 @@ Range operator. `a:b` constructs a range from `a` to `b` with a step size of 1,
 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{T}(start::T, step, stop::T)
+colon(start::T, step, stop::T) where {T} = _colon(start, step, stop)
+colon(start::T, step, stop::T) where {T<:Real} = _colon(start, step, stop)
+# without the second method above, the first method above is ambiguous with
+# colon(start::A, step, stop::C) where {A<:Real,C<:Real}
+function _colon(start::T, step, stop::T) where T
     T′ = typeof(start+step)
     StepRange(convert(T′,start), step, convert(T′,stop))
 end
@@ -48,17 +57,19 @@ end
 
 Construct a range by length, given a starting value and optional step (defaults to 1).
 """
-range{T}(a::T, step, len::Integer) = _range(TypeOrder(T), TypeArithmetic(T), a, step, len)
-_range{T,S}(::HasOrder, ::ArithmeticOverflows, a::T, step::S, len::Integer) = StepRange{T,S}(a, step, convert(T, a+step*(len-1)))
-_range{T,S}(::Any, ::Any, a::T, step::S, len::Integer) = StepRangeLen{typeof(a+0*step),T,S}(a, step, len)
+range(a::T, step, len::Integer) where {T} = _range(TypeOrder(T), TypeArithmetic(T), a, step, len)
+_range(::HasOrder, ::ArithmeticOverflows, a::T, step::S, len::Integer) where {T,S} =
+    StepRange{T,S}(a, step, convert(T, a+step*(len-1)))
+_range(::Any, ::Any, a::T, step::S, len::Integer) where {T,S} =
+    StepRangeLen{typeof(a+0*step),T,S}(a, step, len)
 
 # AbstractFloat specializations
-colon{T<:AbstractFloat}(a::T, b::T) = colon(a, T(1), b)
+colon(a::T, b::T) where {T<:AbstractFloat} = colon(a, T(1), b)
 range(a::AbstractFloat, len::Integer) = range(a, oftype(a, 1), len)
 
-colon{T<:Real}(a::T, b::AbstractFloat, c::T) = colon(promote(a,b,c)...)
-colon{T<:AbstractFloat}(a::T, b::AbstractFloat, c::T) = colon(promote(a,b,c)...)
-colon{T<:AbstractFloat}(a::T, b::Real, c::T) = colon(promote(a,b,c)...)
+colon(a::T, b::AbstractFloat, c::T) where {T<:Real} = colon(promote(a,b,c)...)
+colon(a::T, b::AbstractFloat, c::T) where {T<:AbstractFloat} = colon(promote(a,b,c)...)
+colon(a::T, b::Real, c::T) where {T<:AbstractFloat} = colon(promote(a,b,c)...)
 
 range(a::AbstractFloat, st::AbstractFloat, len::Integer) = range(promote(a, st)..., len)
 range(a::Real, st::AbstractFloat, len::Integer) = range(float(a), st, len)
@@ -84,7 +95,7 @@ struct StepRange{T,S} <: OrdinalRange{T,S}
 end
 
 # to make StepRange constructor inlineable, so optimizer can see `step` value
-function steprange_last{T}(start::T, step, stop)
+function steprange_last(start::T, step, stop) where T
     if isa(start,AbstractFloat) || isa(step,AbstractFloat)
         throw(ArgumentError("StepRange should not be used with floating point"))
     end
@@ -136,17 +147,22 @@ StepRange(start::T, step::S, stop::T) where {T,S} = StepRange{T,S}(start, step,
 struct UnitRange{T<:Real} <: AbstractUnitRange{T}
     start::T
     stop::T
-    UnitRange{T}(start, stop) where T<:Real = new(start, unitrange_last(start,stop))
+    UnitRange{T}(start, stop) where {T<:Real} = new(start, unitrange_last(start,stop))
 end
-UnitRange(start::T, stop::T) where T<:Real = UnitRange{T}(start, stop)
+UnitRange(start::T, stop::T) where {T<:Real} = UnitRange{T}(start, stop)
 
 unitrange_last(::Bool, stop::Bool) = stop
-unitrange_last{T<:Integer}(start::T, stop::T) =
+unitrange_last(start::T, stop::T) where {T<:Integer} =
     ifelse(stop >= start, stop, convert(T,start-oneunit(stop-start)))
-unitrange_last{T}(start::T, stop::T) =
+unitrange_last(start::T, stop::T) where {T} =
     ifelse(stop >= start, convert(T,start+floor(stop-start)),
                           convert(T,start-oneunit(stop-start)))
 
+if isdefined(Main, :Base)
+    getindex(t::Tuple, r::AbstractUnitRange{<:Real}) =
+        (o = first(r) - 1; ntuple(n -> t[o + n], length(r)))
+end
+
 """
     Base.OneTo(n)
 
@@ -156,21 +172,23 @@ be 1.
 """
 struct OneTo{T<:Integer} <: AbstractUnitRange{T}
     stop::T
-    OneTo{T}(stop) where T<:Integer = new(max(zero(T), stop))
+    OneTo{T}(stop) where {T<:Integer} = new(max(zero(T), stop))
 end
-OneTo(stop::T) where T<:Integer = OneTo{T}(stop)
+OneTo(stop::T) where {T<:Integer} = OneTo{T}(stop)
 
-## Step ranges parametrized by length
+## Step ranges parameterized by length
 
 """
-    StepRangeLen{T,R,S}(ref::R, step::S, len, [offset=1])
-
-A range `r` where `r[i]` produces values of type `T`, parametrized by
-a `ref`erence value, a `step`, and the `len`gth.  By default `ref` is
-the starting value `r[1]`, but alternatively you can supply it as the
-value of `r[offset]` for some other index `1 <= offset <= len`.  In
-conjunction with `TwicePrecision` this can be used to implement ranges
-that are free of roundoff error.
+    StepRangeLen{T,R,S}(ref::R, step::S, len, [offset=1]) where {T,R,S}
+    StepRangeLen(       ref::R, step::S, len, [offset=1]) where {  R,S}
+
+A range `r` where `r[i]` produces values of type `T` (in the second
+form, `T` is deduced automatically), parameterized by a `ref`erence
+value, a `step`, and the `len`gth. By default `ref` is the starting
+value `r[1]`, but alternatively you can supply it as the value of
+`r[offset]` for some other index `1 <= offset <= len`. In conjunction
+with `TwicePrecision` this can be used to implement ranges that are
+free of roundoff error.
 """
 struct StepRangeLen{T,R,S} <: Range{T}
     ref::R       # reference value (might be smallest-magnitude value in the range)
@@ -222,12 +240,13 @@ julia> linspace(1.3,2.9,9)
 ```
 """
 linspace(start, stop, len::Real=50) = linspace(promote_noncircular(start, stop)..., Int(len))
+linspace(start::T, stop::T, len::Real=50) where {T} = linspace(start, stop, Int(len))
 
 linspace(start::Real, stop::Real, len::Integer) = linspace(promote(start, stop)..., len)
-linspace{T<:Integer}(start::T, stop::T, len::Integer) = linspace(Float64, start, stop, len, 1)
+linspace(start::T, stop::T, len::Integer) where {T<:Integer} = linspace(Float64, start, stop, len, 1)
 # for Float16, Float32, and Float64 see twiceprecision.jl
-linspace{T<:Real}(start::T, stop::T, len::Integer) = LinSpace{T}(start, stop, len)
-linspace{T}(start::T, stop::T, len::Integer) = LinSpace{T}(start, stop, len)
+linspace(start::T, stop::T, len::Integer) where {T<:Real} = LinSpace{T}(start, stop, len)
+linspace(start::T, stop::T, len::Integer) where {T} = LinSpace{T}(start, stop, len)
 
 function show(io::IO, r::LinSpace)
     print(io, "linspace(")
@@ -297,9 +316,9 @@ function print_range(io::IO, r::Range,
 end
 
 """
-    logspace(start::Real, stop::Real, n::Integer=50)
+    logspace(start::Real, stop::Real, n::Integer=50; base=10)
 
-Construct a vector of `n` logarithmically spaced numbers from `10^start` to `10^stop`.
+Construct a vector of `n` logarithmically spaced numbers from `base^start` to `base^stop`.
 
 ```jldoctest
 julia> logspace(1.,10.,5)
@@ -309,9 +328,17 @@ julia> logspace(1.,10.,5)
     3.16228e5
     5.62341e7
     1.0e10
+
+julia> logspace(1.,10.,5,base=2)
+5-element Array{Float64,1}:
+    2.0
+    9.51366
+   45.2548
+  215.269
+ 1024.0
 ```
 """
-logspace(start::Real, stop::Real, n::Integer=50) = 10.^linspace(start, stop, n)
+logspace(start::Real, stop::Real, n::Integer=50; base=10) = base.^linspace(start, stop, n)
 
 ## interface implementations
 
@@ -360,7 +387,7 @@ length(r::OneTo) = unsafe_length(r)
 length(r::StepRangeLen) = r.len
 length(r::LinSpace) = r.len
 
-function length{T<:Union{Int,UInt,Int64,UInt64}}(r::StepRange{T})
+function length(r::StepRange{T}) where T<:Union{Int,UInt,Int64,UInt64}
     isempty(r) && return zero(T)
     if r.step > 1
         return checked_add(convert(T, div(unsigned(r.stop - r.start), r.step)), one(T))
@@ -371,13 +398,13 @@ function length{T<:Union{Int,UInt,Int64,UInt64}}(r::StepRange{T})
     end
 end
 
-function length{T<:Union{Int,Int64}}(r::AbstractUnitRange{T})
+function length(r::AbstractUnitRange{T}) where T<:Union{Int,Int64}
     @_inline_meta
     checked_add(checked_sub(last(r), first(r)), one(T))
 end
-length{T<:Union{Int,Int64}}(r::OneTo{T}) = T(r.stop)
+length(r::OneTo{T}) where {T<:Union{Int,Int64}} = T(r.stop)
 
-length{T<:Union{UInt,UInt64}}(r::AbstractUnitRange{T}) =
+length(r::AbstractUnitRange{T}) where {T<:Union{UInt,UInt64}} =
     r.stop < r.start ? zero(T) : checked_add(last(r) - first(r), one(T))
 
 # some special cases to favor default Int type
@@ -395,12 +422,12 @@ let smallint = (Int === Int64 ?
     length(r::OneTo{<:smallint}) = Int(r.stop)
 end
 
-first{T}(r::OrdinalRange{T}) = convert(T, r.start)
-first{T}(r::OneTo{T}) = oneunit(T)
+first(r::OrdinalRange{T}) where {T} = convert(T, r.start)
+first(r::OneTo{T}) where {T} = oneunit(T)
 first(r::StepRangeLen) = unsafe_getindex(r, 1)
 first(r::LinSpace) = r.start
 
-last{T}(r::OrdinalRange{T}) = convert(T, r.stop)
+last(r::OrdinalRange{T}) where {T} = convert(T, r.stop)
 last(r::StepRangeLen) = unsafe_getindex(r, length(r))
 last(r::LinSpace) = r.stop
 
@@ -423,21 +450,21 @@ function next(r::LinSpace, i::Int)
 end
 
 start(r::StepRange) = oftype(r.start + r.step, r.start)
-next{T}(r::StepRange{T}, i) = (convert(T,i), i+r.step)
+next(r::StepRange{T}, i) where {T} = (convert(T,i), i+r.step)
 done(r::StepRange, i) = isempty(r) | (i < min(r.start, r.stop)) | (i > max(r.start, r.stop))
 done(r::StepRange, i::Integer) =
     isempty(r) | (i == oftype(i, r.stop) + r.step)
 
 # see also twiceprecision.jl
 start(r::StepRangeLen) = (unsafe_getindex(r, 1), 1)
-next{T}(r::StepRangeLen{T}, s) = s[1], (T(s[1]+r.step), s[2]+1)
+next(r::StepRangeLen{T}, s) where {T} = s[1], (T(s[1]+r.step), s[2]+1)
 done(r::StepRangeLen, s) = s[2] > length(r)
 
-start{T}(r::UnitRange{T}) = oftype(r.start + oneunit(T), r.start)
-next{T}(r::AbstractUnitRange{T}, i) = (convert(T, i), i + oneunit(T))
-done{T}(r::AbstractUnitRange{T}, i) = i == oftype(i, r.stop) + oneunit(T)
+start(r::UnitRange{T}) where {T} = oftype(r.start + oneunit(T), r.start)
+next(r::AbstractUnitRange{T}, i) where {T} = (convert(T, i), i + oneunit(T))
+done(r::AbstractUnitRange{T}, i) where {T} = i == oftype(i, r.stop) + oneunit(T)
 
-start{T}(r::OneTo{T}) = oneunit(T)
+start(r::OneTo{T}) where {T} = oneunit(T)
 
 # some special cases to favor default Int type to avoid overflow
 let smallint = (Int === Int64 ?
@@ -446,28 +473,28 @@ let smallint = (Int === Int64 ?
     global start
     global next
     start(r::StepRange{<:smallint}) = convert(Int, r.start)
-    next{T<:smallint}(r::StepRange{T}, i) = (i % T, i + r.step)
+    next(r::StepRange{T}, i) where {T<:smallint} = (i % T, i + r.step)
     start(r::UnitRange{<:smallint}) = convert(Int, r.start)
-    next{T<:smallint}(r::AbstractUnitRange{T}, i) = (i % T, i + 1)
+    next(r::AbstractUnitRange{T}, i) where {T<:smallint} = (i % T, i + 1)
     start(r::OneTo{<:smallint}) = 1
 end
 
 ## indexing
 
-function getindex{T}(v::UnitRange{T}, i::Integer)
+function getindex(v::UnitRange{T}, i::Integer) where T
     @_inline_meta
     ret = convert(T, first(v) + i - 1)
     @boundscheck ((i > 0) & (ret <= v.stop) & (ret >= v.start)) || throw_boundserror(v, i)
     ret
 end
 
-function getindex{T}(v::OneTo{T}, i::Integer)
+function getindex(v::OneTo{T}, i::Integer) where T
     @_inline_meta
     @boundscheck ((i > 0) & (i <= v.stop)) || throw_boundserror(v, i)
     convert(T, i)
 end
 
-function getindex{T}(v::Range{T}, i::Integer)
+function getindex(v::Range{T}, i::Integer) where T
     @_inline_meta
     ret = convert(T, first(v) + (i - 1)*step(v))
     ok = ifelse(step(v) > zero(step(v)),
@@ -484,7 +511,7 @@ function getindex(r::Union{StepRangeLen,LinSpace}, i::Integer)
 end
 
 # This is separate to make it useful even when running with --check-bounds=yes
-function unsafe_getindex{T}(r::StepRangeLen{T}, i::Integer)
+function unsafe_getindex(r::StepRangeLen{T}, i::Integer) where T
     u = i - r.offset
     T(r.ref + u*r.step)
 end
@@ -493,7 +520,7 @@ function unsafe_getindex(r::LinSpace, i::Integer)
     lerpi.(i-1, r.lendiv, r.start, r.stop)
 end
 
-function lerpi{T}(j::Integer, d::Integer, a::T, b::T)
+function lerpi(j::Integer, d::Integer, a::T, b::T) where T
     @_inline_meta
     t = j/d
     T((1-t)*a + t*b)
@@ -509,7 +536,7 @@ function getindex(r::AbstractUnitRange, s::AbstractUnitRange{<:Integer})
     range(st, length(s))
 end
 
-function getindex{T}(r::OneTo{T}, s::OneTo)
+function getindex(r::OneTo{T}, s::OneTo) where T
     @_inline_meta
     @boundscheck checkbounds(r, s)
     OneTo(T(s.stop))
@@ -548,13 +575,13 @@ show(io::IO, r::Range) = print(io, repr(first(r)), ':', repr(step(r)), ':', repr
 show(io::IO, r::UnitRange) = print(io, repr(first(r)), ':', repr(last(r)))
 show(io::IO, r::OneTo) = print(io, "Base.OneTo(", r.stop, ")")
 
-=={T<:Range}(r::T, s::T) =
+==(r::T, s::T) where {T<:Range} =
     (first(r) == first(s)) & (step(r) == step(s)) & (last(r) == last(s))
 ==(r::OrdinalRange, s::OrdinalRange) =
     (first(r) == first(s)) & (step(r) == step(s)) & (last(r) == last(s))
-=={T<:Union{StepRangeLen,LinSpace}}(r::T, s::T) =
+==(r::T, s::T) where {T<:Union{StepRangeLen,LinSpace}} =
     (first(r) == first(s)) & (length(r) == length(s)) & (last(r) == last(s))
-=={T}(r::Union{StepRange{T},StepRangeLen{T,T}}, s::Union{StepRange{T},StepRangeLen{T,T}}) =
+==(r::Union{StepRange{T},StepRangeLen{T,T}}, s::Union{StepRange{T},StepRangeLen{T,T}}) where {T} =
     (first(r) == first(s)) & (last(r) == last(s)) & (step(r) == step(s))
 
 function ==(r::Range, s::Range)
@@ -736,72 +763,89 @@ end
 
 /(x::Number, r::Range) = [ x/y for y=r ]
 
-promote_rule{T1,T2}(::Type{UnitRange{T1}},::Type{UnitRange{T2}}) =
-    UnitRange{promote_type(T1,T2)}
-convert{T<:Real}(::Type{UnitRange{T}}, r::UnitRange{T}) = r
-convert{T<:Real}(::Type{UnitRange{T}}, r::UnitRange) = UnitRange{T}(r.start, r.stop)
-
-promote_rule{T1,T2}(::Type{OneTo{T1}},::Type{OneTo{T2}}) =
-    OneTo{promote_type(T1,T2)}
-convert{T<:Real}(::Type{OneTo{T}}, r::OneTo{T}) = r
-convert{T<:Real}(::Type{OneTo{T}}, r::OneTo) = OneTo{T}(r.stop)
-
-promote_rule{T1,UR<:AbstractUnitRange}(::Type{UnitRange{T1}}, ::Type{UR}) =
-    UnitRange{promote_type(T1,eltype(UR))}
-convert{T<:Real}(::Type{UnitRange{T}}, r::AbstractUnitRange) = UnitRange{T}(first(r), last(r))
+# promote eltype if at least one container wouldn't change, otherwise join container types.
+el_same(::Type{T}, a::Type{<:AbstractArray{T,n}}, b::Type{<:AbstractArray{T,n}}) where {T,n}   = a
+el_same(::Type{T}, a::Type{<:AbstractArray{T,n}}, b::Type{<:AbstractArray{S,n}}) where {T,S,n} = a
+el_same(::Type{T}, a::Type{<:AbstractArray{S,n}}, b::Type{<:AbstractArray{T,n}}) where {T,S,n} = b
+el_same(::Type, a, b) = typejoin(a, b)
+
+promote_rule(a::Type{UnitRange{T1}}, b::Type{UnitRange{T2}}) where {T1,T2} =
+    el_same(promote_type(T1,T2), a, b)
+convert(::Type{UnitRange{T}}, r::UnitRange{T}) where {T<:Real} = r
+convert(::Type{UnitRange{T}}, r::UnitRange) where {T<:Real} = UnitRange{T}(r.start, r.stop)
+
+promote_rule(a::Type{OneTo{T1}}, b::Type{OneTo{T2}}) where {T1,T2} =
+    el_same(promote_type(T1,T2), a, b)
+convert(::Type{OneTo{T}}, r::OneTo{T}) where {T<:Real} = r
+convert(::Type{OneTo{T}}, r::OneTo) where {T<:Real} = OneTo{T}(r.stop)
+
+promote_rule(a::Type{UnitRange{T1}}, ::Type{UR}) where {T1,UR<:AbstractUnitRange} =
+    promote_rule(a, UnitRange{eltype(UR)})
+convert(::Type{UnitRange{T}}, r::AbstractUnitRange) where {T<:Real} = UnitRange{T}(first(r), last(r))
 convert(::Type{UnitRange}, r::AbstractUnitRange) = UnitRange(first(r), last(r))
 
-promote_rule{T1a,T1b,T2a,T2b}(::Type{StepRange{T1a,T1b}},::Type{StepRange{T2a,T2b}}) =
-    StepRange{promote_type(T1a,T2a),promote_type(T1b,T2b)}
-convert{T1,T2}(::Type{StepRange{T1,T2}}, r::StepRange{T1,T2}) = r
+convert(::Type{AbstractUnitRange{T}}, r::AbstractUnitRange{T}) where {T} = r
+convert(::Type{AbstractUnitRange{T}}, r::UnitRange) where {T} = convert(UnitRange{T}, r)
+convert(::Type{AbstractUnitRange{T}}, r::OneTo) where {T} = convert(OneTo{T}, r)
 
-promote_rule{T1a,T1b,UR<:AbstractUnitRange}(::Type{StepRange{T1a,T1b}},::Type{UR}) =
-    StepRange{promote_type(T1a,eltype(UR)),promote_type(T1b,eltype(UR))}
-convert{T1,T2}(::Type{StepRange{T1,T2}}, r::Range) =
+promote_rule(::Type{StepRange{T1a,T1b}}, ::Type{StepRange{T2a,T2b}}) where {T1a,T1b,T2a,T2b} =
+    el_same(promote_type(T1a,T2a),
+            # el_same only operates on array element type, so just promote second type parameter
+            StepRange{T1a, promote_type(T1b,T2b)},
+            StepRange{T2a, promote_type(T1b,T2b)})
+convert(::Type{StepRange{T1,T2}}, r::StepRange{T1,T2}) where {T1,T2} = r
+
+promote_rule(a::Type{StepRange{T1a,T1b}}, ::Type{UR}) where {T1a,T1b,UR<:AbstractUnitRange} =
+    promote_rule(a, StepRange{eltype(UR), eltype(UR)})
+convert(::Type{StepRange{T1,T2}}, r::Range) where {T1,T2} =
     StepRange{T1,T2}(convert(T1, first(r)), convert(T2, step(r)), convert(T1, last(r)))
-convert{T}(::Type{StepRange}, r::AbstractUnitRange{T}) =
+convert(::Type{StepRange}, r::AbstractUnitRange{T}) where {T} =
     StepRange{T,T}(first(r), step(r), last(r))
-
-promote_rule{T1,T2,R1,R2,S1,S2}(::Type{StepRangeLen{T1,R1,S1}},::Type{StepRangeLen{T2,R2,S2}}) =
-    StepRangeLen{promote_type(T1,T2), promote_type(R1,R2), promote_type(S1,S2)}
-convert{T,R,S}(::Type{StepRangeLen{T,R,S}}, r::StepRangeLen{T,R,S}) = r
-convert{T,R,S}(::Type{StepRangeLen{T,R,S}}, r::StepRangeLen) =
+convert(::Type{StepRange{T1,T2} where T1}, r::Range) where {T2} =
+    convert(StepRange{eltype(r),T2}, r)
+
+promote_rule(::Type{StepRangeLen{T1,R1,S1}},::Type{StepRangeLen{T2,R2,S2}}) where {T1,T2,R1,R2,S1,S2} =
+    el_same(promote_type(T1,T2),
+            StepRangeLen{T1,promote_type(R1,R2),promote_type(S1,S2)},
+            StepRangeLen{T2,promote_type(R1,R2),promote_type(S1,S2)})
+convert(::Type{StepRangeLen{T,R,S}}, r::StepRangeLen{T,R,S}) where {T,R,S} = r
+convert(::Type{StepRangeLen{T,R,S}}, r::StepRangeLen) where {T,R,S} =
     StepRangeLen{T,R,S}(convert(R, r.ref), convert(S, r.step), length(r), r.offset)
-convert{T}(::Type{StepRangeLen{T}}, r::StepRangeLen) =
+convert(::Type{StepRangeLen{T}}, r::StepRangeLen) where {T} =
     StepRangeLen(convert(T, r.ref), convert(T, r.step), length(r), r.offset)
 
-promote_rule{T,R,S,OR<:Range}(::Type{StepRangeLen{T,R,S}}, ::Type{OR}) =
-    StepRangeLen{promote_type(T,eltype(OR)),promote_type(R,eltype(OR)),promote_type(S,eltype(OR))}
-convert{T,R,S}(::Type{StepRangeLen{T,R,S}}, r::Range) =
+promote_rule(a::Type{StepRangeLen{T,R,S}}, ::Type{OR}) where {T,R,S,OR<:Range} =
+    promote_rule(a, StepRangeLen{eltype(OR), eltype(OR), eltype(OR)})
+convert(::Type{StepRangeLen{T,R,S}}, r::Range) where {T,R,S} =
     StepRangeLen{T,R,S}(R(first(r)), S(step(r)), length(r))
-convert{T}(::Type{StepRangeLen{T}}, r::Range) =
+convert(::Type{StepRangeLen{T}}, r::Range) where {T} =
     StepRangeLen(T(first(r)), T(step(r)), length(r))
 convert(::Type{StepRangeLen}, r::Range) = convert(StepRangeLen{eltype(r)}, r)
 
-promote_rule{T1,T2}(::Type{LinSpace{T1}},::Type{LinSpace{T2}}) =
-    LinSpace{promote_type(T1,T2)}
-convert{T}(::Type{LinSpace{T}}, r::LinSpace{T}) = r
-convert{T}(::Type{LinSpace{T}}, r::Range) =
+promote_rule(a::Type{LinSpace{T1}}, b::Type{LinSpace{T2}}) where {T1,T2} =
+    el_same(promote_type(T1,T2), a, b)
+convert(::Type{LinSpace{T}}, r::LinSpace{T}) where {T} = r
+convert(::Type{LinSpace{T}}, r::Range) where {T} =
     LinSpace{T}(first(r), last(r), length(r))
-convert{T}(::Type{LinSpace}, r::Range{T}) =
+convert(::Type{LinSpace}, r::Range{T}) where {T} =
     convert(LinSpace{T}, r)
 
-promote_rule{T,OR<:OrdinalRange}(::Type{LinSpace{T}}, ::Type{OR}) =
-    LinSpace{promote_type(T,eltype(OR))}
+promote_rule(a::Type{LinSpace{T}}, ::Type{OR}) where {T,OR<:OrdinalRange} =
+    promote_rule(a, LinSpace{eltype(OR)})
 
-promote_rule{L,T,R,S}(::Type{LinSpace{L}}, ::Type{StepRangeLen{T,R,S}}) =
-    StepRangeLen{promote_type(L,T),promote_type(L,R),promote_type(L,S)}
+promote_rule(::Type{LinSpace{L}}, b::Type{StepRangeLen{T,R,S}}) where {L,T,R,S} =
+    promote_rule(StepRangeLen{L,L,L}, b)
 
 # +/- of ranges is defined in operators.jl (to be able to use @eval etc.)
 
 ## concatenation ##
 
-function vcat{T}(rs::Range{T}...)
+function vcat(rs::Range{T}...) where T
     n::Int = 0
     for ra in rs
         n += length(ra)
     end
-    a = Array{T}(n)
+    a = Vector{T}(n)
     i = 1
     for ra in rs, x in ra
         @inbounds a[i] = x
@@ -810,7 +854,7 @@ function vcat{T}(rs::Range{T}...)
     return a
 end
 
-convert{T}(::Type{Array{T,1}}, r::Range{T}) = vcat(r)
+convert(::Type{Array{T,1}}, r::Range{T}) where {T} = vcat(r)
 collect(r::Range) = vcat(r)
 
 reverse(r::OrdinalRange) = colon(last(r), -step(r), first(r))
@@ -844,18 +888,31 @@ end
 
 median(r::Range{<:Real}) = mean(r)
 
-function in(x, r::Range)
-    n = step(r) == 0 ? 1 : round(Integer,(x-first(r))/step(r))+1
-    n >= 1 && n <= length(r) && r[n] == x
+function _in_range(x, r::Range)
+    if step(r) == 0
+        return !isempty(r) && first(r) == x
+    else
+        n = round(Integer, (x - first(r)) / step(r)) + 1
+        return n >= 1 && n <= length(r) && r[n] == x
+    end
 end
+in(x::Real, r::Range{<:Real}) = _in_range(x, r)
+# This method needs to be defined separately since -(::T, ::T) can be implemented
+# even if -(::T, ::Real) is not
+in(x::T, r::Range{T}) where {T} = _in_range(x, r)
 
 in(x::Integer, r::AbstractUnitRange{<:Integer}) = (first(r) <= x) & (x <= last(r))
-in{T<:Integer}(x, r::Range{T}) = isinteger(x) && !isempty(r) && x>=minimum(r) && x<=maximum(r) && (mod(convert(T,x),step(r))-mod(first(r),step(r)) == 0)
-in(x::Char, r::Range{Char}) = !isempty(r) && x >= minimum(r) && x <= maximum(r) && (mod(Int(x) - Int(first(r)), step(r)) == 0)
+
+in(x::Real, r::Range{T}) where {T<:Integer} =
+    isinteger(x) && !isempty(r) && x >= minimum(r) && x <= maximum(r) &&
+        (mod(convert(T,x),step(r))-mod(first(r),step(r)) == 0)
+in(x::Char, r::Range{Char}) =
+    !isempty(r) && x >= minimum(r) && x <= maximum(r) &&
+        (mod(Int(x) - Int(first(r)), step(r)) == 0)
 
 # Addition/subtraction of ranges
 
-function _define_range_op(f::ANY)
+function _define_range_op(@nospecialize f)
     @eval begin
         function $f(r1::OrdinalRange, r2::OrdinalRange)
             r1l = length(r1)
@@ -864,7 +921,7 @@ function _define_range_op(f::ANY)
             range($f(first(r1),first(r2)), $f(step(r1),step(r2)), r1l)
         end
 
-        function $f{T}(r1::LinSpace{T}, r2::LinSpace{T})
+        function $f(r1::LinSpace{T}, r2::LinSpace{T}) where T
             len = r1.len
             (len == r2.len ||
              throw(DimensionMismatch("argument dimensions must match")))
@@ -880,7 +937,7 @@ end
 _define_range_op(:+)
 _define_range_op(:-)
 
-function +{T,S}(r1::StepRangeLen{T,S}, r2::StepRangeLen{T,S})
+function +(r1::StepRangeLen{T,S}, r2::StepRangeLen{T,S}) where {T,S}
     len = length(r1)
     (len == length(r2) ||
         throw(DimensionMismatch("argument dimensions must match")))
diff --git a/base/rational.jl b/base/rational.jl
index 37bc0568313344..775fde17793ae9 100644
--- a/base/rational.jl
+++ b/base/rational.jl
@@ -1,5 +1,10 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
+"""
+    Rational{T<:Integer} <: Real
+
+Rational number type, with numerator and denominator of type `T`.
+"""
 struct Rational{T<:Integer} <: Real
     num::T
     den::T
@@ -10,7 +15,7 @@ struct Rational{T<:Integer} <: Real
         new(div(num, g), div(den, g))
     end
 end
-Rational(n::T, d::T) where T<:Integer = Rational{T}(n,d)
+Rational(n::T, d::T) where {T<:Integer} = Rational{T}(n,d)
 Rational(n::Integer, d::Integer) = Rational(promote(n,d)...)
 Rational(n::Integer) = Rational(n,one(n))
 
@@ -22,7 +27,7 @@ end
 """
     //(num, den)
 
-Divide two integers or rational numbers, giving a `Rational` result.
+Divide two integers or rational numbers, giving a [`Rational`](@ref) result.
 
 ```jldoctest
 julia> 3 // 5
@@ -32,9 +37,9 @@ julia> (3 // 5) // (2 // 1)
 3//10
 ```
 """
-//(n::Integer,  d::Integer ) = Rational(n,d)
+//(n::Integer,  d::Integer) = Rational(n,d)
 
-function //(x::Rational, y::Integer )
+function //(x::Rational, y::Integer)
     xn,yn = divgcd(x.num,y)
     xn//checked_mul(x.den,yn)
 end
@@ -60,7 +65,7 @@ function show(io::IO, x::Rational)
     show(io, denominator(x))
 end
 
-function read{T<:Integer}(s::IO, ::Type{Rational{T}})
+function read(s::IO, ::Type{Rational{T}}) where T<:Integer
     r = read(s,T)
     i = read(s,T)
     r//i
@@ -69,25 +74,28 @@ function write(s::IO, z::Rational)
     write(s,numerator(z),denominator(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))
+convert(::Type{Rational{T}}, x::Rational) where {T<:Integer} = Rational{T}(convert(T,x.num),convert(T,x.den))
+convert(::Type{Rational{T}}, x::Integer) where {T<:Integer} = Rational{T}(convert(T,x), convert(T,1))
 
 convert(::Type{Rational}, x::Rational) = x
 convert(::Type{Rational}, x::Integer) = convert(Rational{typeof(x)},x)
 
-convert(::Type{Bool}, x::Rational) = x==0 ? false : x==1 ? true : throw(InexactError()) # to resolve ambiguity
-convert(::Type{Integer}, x::Rational) = (isinteger(x) ? convert(Integer, x.num) : throw(InexactError()))
-convert{T<:Integer}(::Type{T}, x::Rational) = (isinteger(x) ? convert(T, x.num) : throw(InexactError()))
+convert(::Type{Bool}, x::Rational) = x==0 ? false : x==1 ? true :
+    throw(InexactError(:convert, Bool, x)) # to resolve ambiguity
+convert(::Type{Integer}, x::Rational) = (isinteger(x) ? convert(Integer, x.num) :
+    throw(InexactError(:convert, Integer, x)))
+convert(::Type{T}, x::Rational) where {T<:Integer} = (isinteger(x) ? convert(T, x.num) :
+    throw(InexactError(:convert, T, x)))
 
 convert(::Type{AbstractFloat}, x::Rational) = float(x.num)/float(x.den)
-function convert{T<:AbstractFloat,S}(::Type{T}, x::Rational{S})
+function convert(::Type{T}, x::Rational{S}) where T<:AbstractFloat where S
     P = promote_type(T,S)
     convert(T, convert(P,x.num)/convert(P,x.den))
 end
 
-function convert{T<:Integer}(::Type{Rational{T}}, x::AbstractFloat)
+function convert(::Type{Rational{T}}, x::AbstractFloat) where T<:Integer
     r = rationalize(T, x, tol=0)
-    x == convert(typeof(x), r) || throw(InexactError())
+    x == convert(typeof(x), r) || throw(InexactError(:convert, Rational{T}, x))
     r
 end
 convert(::Type{Rational}, x::Float64) = convert(Rational{Int64}, x)
@@ -95,16 +103,16 @@ convert(::Type{Rational}, x::Float32) = convert(Rational{Int}, x)
 
 big(z::Complex{<:Rational{<:Integer}}) = Complex{Rational{BigInt}}(z)
 
-promote_rule{T<:Integer,S<:Integer}(::Type{Rational{T}}, ::Type{S}) = Rational{promote_type(T,S)}
-promote_rule{T<:Integer,S<:Integer}(::Type{Rational{T}}, ::Type{Rational{S}}) = Rational{promote_type(T,S)}
-promote_rule{T<:Integer,S<:AbstractFloat}(::Type{Rational{T}}, ::Type{S}) = promote_type(T,S)
+promote_rule(::Type{Rational{T}}, ::Type{S}) where {T<:Integer,S<:Integer} = Rational{promote_type(T,S)}
+promote_rule(::Type{Rational{T}}, ::Type{Rational{S}}) where {T<:Integer,S<:Integer} = Rational{promote_type(T,S)}
+promote_rule(::Type{Rational{T}}, ::Type{S}) where {T<:Integer,S<:AbstractFloat} = promote_type(T,S)
 
-widen{T}(::Type{Rational{T}}) = Rational{widen(T)}
+widen(::Type{Rational{T}}) where {T} = Rational{widen(T)}
 
 """
     rationalize([T<:Integer=Int,] x; tol::Real=eps(x))
 
-Approximate floating point number `x` as a `Rational` number with components
+Approximate floating point number `x` as a [`Rational`](@ref) number with components
 of the given integer type. The result will differ from `x` by no more than `tol`.
 If `T` is not provided, it defaults to `Int`.
 
@@ -119,7 +127,7 @@ julia> typeof(numerator(a))
 BigInt
 ```
 """
-function rationalize{T<:Integer}(::Type{T}, x::AbstractFloat, tol::Real)
+function rationalize(::Type{T}, x::AbstractFloat, tol::Real) where T<:Integer
     if tol < 0
         throw(ArgumentError("negative tolerance $tol"))
     end
@@ -178,7 +186,7 @@ function rationalize{T<:Integer}(::Type{T}, x::AbstractFloat, tol::Real)
         return p // q
     end
 end
-rationalize{T<:Integer}(::Type{T}, x::AbstractFloat; tol::Real=eps(x)) = rationalize(T, x, tol)::Rational{T}
+rationalize(::Type{T}, x::AbstractFloat; tol::Real = eps(x)) where {T<:Integer} = rationalize(T, x, tol)::Rational{T}
 rationalize(x::AbstractFloat; kvs...) = rationalize(Int, x; kvs...)
 
 """
@@ -218,17 +226,17 @@ signbit(x::Rational) = signbit(x.num)
 copysign(x::Rational, y::Real) = copysign(x.num,y) // x.den
 copysign(x::Rational, y::Rational) = copysign(x.num,y.num) // x.den
 
-typemin{T<:Integer}(::Type{Rational{T}}) = -one(T)//zero(T)
-typemax{T<:Integer}(::Type{Rational{T}}) = one(T)//zero(T)
+typemin(::Type{Rational{T}}) where {T<:Integer} = -one(T)//zero(T)
+typemax(::Type{Rational{T}}) where {T<:Integer} = one(T)//zero(T)
 
 isinteger(x::Rational) = x.den == 1
 
 -(x::Rational) = (-x.num) // x.den
-function -{T<:Signed}(x::Rational{T})
+function -(x::Rational{T}) where T<:Signed
     x.num == typemin(T) && throw(OverflowError())
     (-x.num) // x.den
 end
-function -{T<:Unsigned}(x::Rational{T})
+function -(x::Rational{T}) where T<:Unsigned
     x.num != zero(T) && throw(OverflowError())
     x
 end
@@ -250,6 +258,7 @@ function *(x::Rational, y::Rational)
 end
 /(x::Rational, y::Rational) = x//y
 /(x::Rational, y::Complex{<:Union{Integer,Rational}}) = x//y
+inv(x::Rational) = Rational(x.den, x.num)
 
 fma(x::Rational, y::Rational, z::Rational) = x*y+z
 
@@ -281,7 +290,8 @@ for rel in (:<,:<=,:cmp)
     for (Tx,Ty) in ((Rational,AbstractFloat), (AbstractFloat,Rational))
         @eval function ($rel)(x::$Tx, y::$Ty)
             if isnan(x) || isnan(y)
-                $(rel == :cmp ? :(throw(DomainError())) : :(return false))
+                $(rel == :cmp ? :(throw(DomainError((x,y), "Inputs cannot be NaN."))) :
+                                :(return false))
             end
 
             xn, xp, xd = decompose(x)
@@ -345,12 +355,12 @@ for op in (:div, :fld, :cld)
     end
 end
 
-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))
+trunc(::Type{T}, x::Rational) where {T} = convert(T,div(x.num,x.den))
+floor(::Type{T}, x::Rational) where {T} = convert(T,fld(x.num,x.den))
+ceil(::Type{T}, x::Rational) where {T} = convert(T,cld(x.num,x.den))
 
 
-function round{T, Tr}(::Type{T}, x::Rational{Tr}, ::RoundingMode{:Nearest})
+function round(::Type{T}, x::Rational{Tr}, ::RoundingMode{:Nearest}) where {T,Tr}
     if denominator(x) == zero(Tr) && T <: Integer
         throw(DivideError())
     elseif denominator(x) == zero(Tr)
@@ -364,9 +374,9 @@ function round{T, Tr}(::Type{T}, x::Rational{Tr}, ::RoundingMode{:Nearest})
     convert(T, s)
 end
 
-round{T}(::Type{T}, x::Rational) = round(T, x, RoundNearest)
+round(::Type{T}, x::Rational) where {T} = round(T, x, RoundNearest)
 
-function round{T, Tr}(::Type{T}, x::Rational{Tr}, ::RoundingMode{:NearestTiesAway})
+function round(::Type{T}, x::Rational{Tr}, ::RoundingMode{:NearestTiesAway}) where {T,Tr}
     if denominator(x) == zero(Tr) && T <: Integer
         throw(DivideError())
     elseif denominator(x) == zero(Tr)
@@ -380,7 +390,7 @@ function round{T, Tr}(::Type{T}, x::Rational{Tr}, ::RoundingMode{:NearestTiesAwa
     convert(T, s)
 end
 
-function round{T, Tr}(::Type{T}, x::Rational{Tr}, ::RoundingMode{:NearestTiesUp})
+function round(::Type{T}, x::Rational{Tr}, ::RoundingMode{:NearestTiesUp}) where {T,Tr}
     if denominator(x) == zero(Tr) && T <: Integer
         throw(DivideError())
     elseif denominator(x) == zero(Tr)
@@ -394,30 +404,30 @@ function round{T, Tr}(::Type{T}, x::Rational{Tr}, ::RoundingMode{:NearestTiesUp}
     convert(T, s)
 end
 
-function round{T}(::Type{T}, x::Rational{Bool})
-    if denominator(x) == false && issubtype(T, Union{Integer, Bool})
+function round(::Type{T}, x::Rational{Bool}) where T
+    if denominator(x) == false && (T <: Union{Integer, Bool})
         throw(DivideError())
     end
     convert(T, x)
 end
 
-round{T}(::Type{T}, x::Rational{Bool}, ::RoundingMode{:Nearest}) = round(T, x)
-round{T}(::Type{T}, x::Rational{Bool}, ::RoundingMode{:NearestTiesAway}) = round(T, x)
-round{T}(::Type{T}, x::Rational{Bool}, ::RoundingMode{:NearestTiesUp}) = round(T, x)
-round{T}(::Type{T}, x::Rational{Bool}, ::RoundingMode) = round(T, x)
+round(::Type{T}, x::Rational{Bool}, ::RoundingMode{:Nearest}) where {T} = round(T, x)
+round(::Type{T}, x::Rational{Bool}, ::RoundingMode{:NearestTiesAway}) where {T} = round(T, x)
+round(::Type{T}, x::Rational{Bool}, ::RoundingMode{:NearestTiesUp}) where {T} = round(T, x)
+round(::Type{T}, x::Rational{Bool}, ::RoundingMode) where {T} = 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))
-round{T}(x::Rational{T}) = Rational(round(T,x))
+trunc(x::Rational{T}) where {T} = Rational(trunc(T,x))
+floor(x::Rational{T}) where {T} = Rational(floor(T,x))
+ceil(x::Rational{T}) where {T} = Rational(ceil(T,x))
+round(x::Rational{T}) where {T} = Rational(round(T,x))
 
 function ^(x::Rational, n::Integer)
     n >= 0 ? power_by_squaring(x,n) : power_by_squaring(inv(x),-n)
 end
 
 ^(x::Number, y::Rational) = x^(y.num/y.den)
-^{T<:AbstractFloat}(x::T, y::Rational) = x^convert(T,y)
-^{T<:AbstractFloat}(x::Complex{T}, y::Rational) = x^convert(T,y)
+^(x::T, y::Rational) where {T<:AbstractFloat} = x^convert(T,y)
+^(x::Complex{T}, y::Rational) where {T<:AbstractFloat} = x^convert(T,y)
 
 ^(z::Complex{<:Rational}, n::Bool) = n ? z : one(z) # to resolve ambiguity
 function ^(z::Complex{<:Rational}, n::Integer)
@@ -425,7 +435,10 @@ function ^(z::Complex{<:Rational}, n::Integer)
 end
 
 iszero(x::Rational) = iszero(numerator(x))
+isone(x::Rational) = isone(numerator(x)) & isone(denominator(x))
 
 function lerpi(j::Integer, d::Integer, a::Rational, b::Rational)
     ((d-j)*a)/d + (j*b)/d
 end
+
+float(::Type{Rational{T}}) where {T<:Integer} = float(T)
diff --git a/base/reduce.jl b/base/reduce.jl
index 8aa76b7ac55352..3ca6351ebfb993 100644
--- a/base/reduce.jl
+++ b/base/reduce.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## reductions ##
 
@@ -17,23 +17,23 @@ const WidenReduceResult = Union{SmallSigned, SmallUnsigned, Float16}
 
 # r_promote_type: promote T to the type of reduce(op, ::Array{T})
 # (some "extra" methods are required here to avoid ambiguity warnings)
-r_promote_type{T}(op, ::Type{T}) = T
-r_promote_type{T<:WidenReduceResult}(op, ::Type{T}) = widen(T)
-r_promote_type{T<:WidenReduceResult}(::typeof(+), ::Type{T}) = widen(T)
-r_promote_type{T<:WidenReduceResult}(::typeof(*), ::Type{T}) = widen(T)
-r_promote_type{T<:Number}(::typeof(+), ::Type{T}) = typeof(zero(T)+zero(T))
-r_promote_type{T<:Number}(::typeof(*), ::Type{T}) = typeof(one(T)*one(T))
-r_promote_type{T<:WidenReduceResult}(::typeof(scalarmax), ::Type{T}) = T
-r_promote_type{T<:WidenReduceResult}(::typeof(scalarmin), ::Type{T}) = T
-r_promote_type{T<:WidenReduceResult}(::typeof(max), ::Type{T}) = T
-r_promote_type{T<:WidenReduceResult}(::typeof(min), ::Type{T}) = T
+r_promote_type(op, ::Type{T}) where {T} = T
+r_promote_type(op, ::Type{T}) where {T<:WidenReduceResult} = widen(T)
+r_promote_type(::typeof(+), ::Type{T}) where {T<:WidenReduceResult} = widen(T)
+r_promote_type(::typeof(*), ::Type{T}) where {T<:WidenReduceResult} = widen(T)
+r_promote_type(::typeof(+), ::Type{T}) where {T<:Number} = typeof(zero(T)+zero(T))
+r_promote_type(::typeof(*), ::Type{T}) where {T<:Number} = typeof(one(T)*one(T))
+r_promote_type(::typeof(scalarmax), ::Type{T}) where {T<:WidenReduceResult} = T
+r_promote_type(::typeof(scalarmin), ::Type{T}) where {T<:WidenReduceResult} = T
+r_promote_type(::typeof(max), ::Type{T}) where {T<:WidenReduceResult} = T
+r_promote_type(::typeof(min), ::Type{T}) where {T<:WidenReduceResult} = T
 
 # r_promote: promote x to the type of reduce(op, [x])
-r_promote{T}(op, x::T) = convert(r_promote_type(op, T), x)
+r_promote(op, x::T) where {T} = convert(r_promote_type(op, T), x)
 
 ## foldl && mapfoldl
 
-function mapfoldl_impl(f, op, v0, itr, i)
+@noinline 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)
@@ -104,7 +104,7 @@ foldl(op, itr) = mapfoldl(identity, op, itr)
 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 isempty(itr)
+    if isempty(itr) || i == 0
         return r_promote(op, v0)
     else
         x = itr[i]
@@ -167,15 +167,25 @@ foldr(op, itr) = mapfoldr(identity, op, itr)
 
 ## reduce & mapreduce
 
-function mapreduce_impl(f, op, A::AbstractArray, ifirst::Integer, ilast::Integer, blksize::Int=pairwise_blocksize(f, op))
-    if ifirst + blksize > ilast
+# `mapreduce_impl()` is called by `mapreduce()` (via `_mapreduce()`, when `A`
+# supports linear indexing) and does actual calculations (for `A[ifirst:ilast]` subset).
+# For efficiency, no parameter validity checks are done, it's the caller's responsibility.
+# `ifirst:ilast` range is assumed to be a valid non-empty subset of `A` indices.
+
+# This is a generic implementation of `mapreduce_impl()`,
+# certain `op` (e.g. `min` and `max`) may have their own specialized versions.
+@noinline function mapreduce_impl(f, op, A::AbstractArray, ifirst::Integer, ilast::Integer, blksize::Int)
+    if ifirst == ilast
+        @inbounds a1 = A[ifirst]
+        return r_promote(op, f(a1))
+    elseif ifirst + blksize > ilast
         # sequential portion
-        fx1 = r_promote(op, f(A[ifirst]))
-        fx2 = r_promote(op, f(A[ifirst + 1]))
-        v = op(fx1, fx2)
+        @inbounds a1 = A[ifirst]
+        @inbounds a2 = A[ifirst+1]
+        v = op(r_promote(op, f(a1)), r_promote(op, f(a2)))
         @simd for i = ifirst + 2 : ilast
-            @inbounds Ai = A[i]
-            v = op(v, f(Ai))
+            @inbounds ai = A[i]
+            v = op(v, f(ai))
         end
         return v
     else
@@ -187,6 +197,9 @@ function mapreduce_impl(f, op, A::AbstractArray, ifirst::Integer, ilast::Integer
     end
 end
 
+mapreduce_impl(f, op, A::AbstractArray, ifirst::Integer, ilast::Integer) =
+    mapreduce_impl(f, op, A, ifirst, ilast, pairwise_blocksize(f, op))
+
 """
     mapreduce(f, op, itr)
 
@@ -248,27 +261,26 @@ mr_empty_iter(f, op, itr, ::EltypeUnknown) = _empty_reduce_error()
 
 _mapreduce(f, op, A::AbstractArray) = _mapreduce(f, op, IndexStyle(A), A)
 
-function _mapreduce{T}(f, op, ::IndexLinear, A::AbstractArray{T})
+function _mapreduce(f, op, ::IndexLinear, A::AbstractArray{T}) where T
     inds = linearindices(A)
     n = length(inds)
-    @inbounds begin
-        if n == 0
-            return mr_empty(f, op, T)
-        elseif n == 1
-            return r_promote(op, f(A[inds[1]]))
-        elseif n < 16
-            fx1 = r_promote(op, f(A[inds[1]]))
-            fx2 = r_promote(op, f(A[inds[2]]))
-            s = op(fx1, fx2)
-            i = inds[2]
-            while i < last(inds)
-                Ai = A[i+=1]
-                s = op(s, f(Ai))
-            end
-            return s
-        else
-            return mapreduce_impl(f, op, A, first(inds), last(inds))
+    if n == 0
+        return mr_empty(f, op, T)
+    elseif n == 1
+        @inbounds a1 = A[inds[1]]
+        return r_promote(op, f(a1))
+    elseif n < 16 # process short array here, avoid mapreduce_impl() compilation
+        @inbounds i = inds[1]
+        @inbounds a1 = A[i]
+        @inbounds a2 = A[i+=1]
+        s = op(r_promote(op, f(a1)), r_promote(op, f(a2)))
+        while i < last(inds)
+            @inbounds Ai = A[i+=1]
+            s = op(s, f(Ai))
         end
+        return s
+    else
+        return mapreduce_impl(f, op, A, first(inds), last(inds))
     end
 end
 
@@ -298,7 +310,6 @@ be executed in groups. Future versions of Julia might change the algorithm. Note
 elements are not reordered if you use an ordered collection.
 
 # Examples
-
 ```jldoctest
 julia> reduce(*, 1, [2; 3; 4])
 24
@@ -415,17 +426,12 @@ function mapreduce_impl(f, op::Union{typeof(scalarmax),
                                      typeof(min)},
                         A::AbstractArray, first::Int, last::Int)
     # locate the first non NaN number
-    v = f(A[first])
+    @inbounds a1 = A[first]
+    v = f(a1)
     i = first + 1
-    while v != v && i <= last
-        @inbounds Ai = A[i]
-        v = f(Ai)
-        i += 1
-    end
-    while i <= last
-        @inbounds Ai = A[i]
-        x = f(Ai)
-        v = op(v, x)
+    while (v == v) && (i <= last)
+        @inbounds ai = A[i]
+        v = op(v, f(ai))
         i += 1
     end
     v
@@ -637,7 +643,7 @@ const ∈ = in
 Returns `true` if there is at least one element `y` in `itr` such that `fun(y,x)` is `true`.
 
 ```jldoctest
-julia> vec = [ 10, 100, 200 ]
+julia> vec = [10, 100, 200]
 3-element Array{Int64,1}:
   10
  100
diff --git a/base/reducedim.jl b/base/reducedim.jl
index b6592764952b19..84a168e1245df1 100644
--- a/base/reducedim.jl
+++ b/base/reducedim.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## Functions to compute the reduced shape
 
@@ -8,7 +8,7 @@ reduced_indices(a::AbstractArray, region) = reduced_indices(indices(a), region)
 # for reductions that keep 0 dims as 0
 reduced_indices0(a::AbstractArray, region) = reduced_indices0(indices(a), region)
 
-function reduced_indices{N}(inds::Indices{N}, d::Int, rd::AbstractUnitRange)
+function reduced_indices(inds::Indices{N}, d::Int, rd::AbstractUnitRange) where N
     d < 1 && throw(ArgumentError("dimension must be ≥ 1, got $d"))
     if d == 1
         return (oftype(inds[1], rd), tail(inds)...)
@@ -20,7 +20,7 @@ function reduced_indices{N}(inds::Indices{N}, d::Int, rd::AbstractUnitRange)
 end
 reduced_indices(inds::Indices, d::Int) = reduced_indices(inds, d, OneTo(1))
 
-function reduced_indices0{N}(inds::Indices{N}, d::Int)
+function reduced_indices0(inds::Indices{N}, d::Int) where N
     d < 1 && throw(ArgumentError("dimension must be ≥ 1, got $d"))
     if d <= N
         return reduced_indices(inds, d, (inds[d] == OneTo(0) ? OneTo(0) : OneTo(1)))
@@ -29,7 +29,7 @@ function reduced_indices0{N}(inds::Indices{N}, d::Int)
     end
 end
 
-function reduced_indices{N}(inds::Indices{N}, region)
+function reduced_indices(inds::Indices{N}, region) where N
     rinds = [inds...]
     for i in region
         isa(i, Integer) || throw(ArgumentError("reduced dimension(s) must be integers"))
@@ -43,7 +43,7 @@ function reduced_indices{N}(inds::Indices{N}, region)
     tuple(rinds...)::typeof(inds)
 end
 
-function reduced_indices0{N}(inds::Indices{N}, region)
+function reduced_indices0(inds::Indices{N}, region) where N
     rinds = [inds...]
     for i in region
         isa(i, Integer) || throw(ArgumentError("reduced dimension(s) must be integers"))
@@ -63,18 +63,18 @@ end
 ## initialization
 
 for (Op, initfun) in ((:(typeof(+)), :zero), (:(typeof(*)), :one), (:(typeof(scalarmax)), :typemin), (:(typeof(scalarmin)), :typemax), (:(typeof(max)), :typemin), (:(typeof(min)), :typemax))
-    @eval initarray!{T}(a::AbstractArray{T}, ::$(Op), init::Bool) = (init && fill!(a, $(initfun)(T)); a)
+    @eval initarray!(a::AbstractArray{T}, ::$(Op), init::Bool) where {T} = (init && fill!(a, $(initfun)(T)); a)
 end
 
 for (Op, initval) in ((:(typeof(&)), true), (:(typeof(|)), false))
     @eval initarray!(a::AbstractArray, ::$(Op), init::Bool) = (init && fill!(a, $initval); a)
 end
 
-reducedim_initarray{R}(A::AbstractArray, region, v0, ::Type{R}) = fill!(similar(A,R,reduced_indices(A,region)), v0)
-reducedim_initarray{T}(A::AbstractArray, region, v0::T) = reducedim_initarray(A, region, v0, T)
+reducedim_initarray(A::AbstractArray, region, v0, ::Type{R}) where {R} = fill!(similar(A,R,reduced_indices(A,region)), v0)
+reducedim_initarray(A::AbstractArray, region, v0::T) where {T} = reducedim_initarray(A, region, v0, T)
 
-reducedim_initarray0{R}(A::AbstractArray, region, v0, ::Type{R}) = fill!(similar(A,R,reduced_indices0(A,region)), v0)
-reducedim_initarray0{T}(A::AbstractArray, region, v0::T) = reducedim_initarray0(A, region, v0, T)
+reducedim_initarray0(A::AbstractArray, region, v0, ::Type{R}) where {R} = fill!(similar(A,R,reduced_indices0(A,region)), v0)
+reducedim_initarray0(A::AbstractArray, region, v0::T) where {T} = reducedim_initarray0(A, region, v0, T)
 
 # TODO: better way to handle reducedim initialization
 #
@@ -106,9 +106,9 @@ reducedim_init(f, op::typeof(max), A::AbstractArray, region) = reducedim_init(f,
 reducedim_init(f, op::typeof(min), A::AbstractArray, region) = reducedim_init(f, scalarmin, A, region)
 reducedim_init(f::Union{typeof(abs),typeof(abs2)}, op::typeof(max), A::AbstractArray, region) = reducedim_init(f, scalarmax, A, region)
 
-reducedim_init{T}(f, op::typeof(scalarmax), A::AbstractArray{T}, region) = reducedim_initarray0(A, region, typemin(f(zero(T))))
-reducedim_init{T}(f, op::typeof(scalarmin), A::AbstractArray{T}, region) = reducedim_initarray0(A, region, typemax(f(zero(T))))
-reducedim_init{T}(f::Union{typeof(abs),typeof(abs2)}, op::typeof(scalarmax), A::AbstractArray{T}, region) =
+reducedim_init(f, op::typeof(scalarmax), A::AbstractArray{T}, region) where {T} = reducedim_initarray0(A, region, typemin(f(zero(T))))
+reducedim_init(f, op::typeof(scalarmin), A::AbstractArray{T}, region) where {T} = reducedim_initarray0(A, region, typemax(f(zero(T))))
+reducedim_init(f::Union{typeof(abs),typeof(abs2)}, op::typeof(scalarmax), A::AbstractArray{T}, region) where {T} =
     reducedim_initarray(A, region, zero(f(zero(T))))
 
 reducedim_init(f, op::typeof(&), A::AbstractArray, region) = reducedim_initarray(A, region, true)
@@ -210,7 +210,7 @@ end
 mapreducedim!(f, op, R::AbstractArray, A::AbstractArray) =
     (_mapreducedim!(f, op, R, A); R)
 
-reducedim!{RT}(op, R::AbstractArray{RT}, A::AbstractArray) =
+reducedim!(op, R::AbstractArray{RT}, A::AbstractArray) where {RT} =
     mapreducedim!(identity, op, R, A, zero(RT))
 
 """
@@ -219,6 +219,7 @@ reducedim!{RT}(op, R::AbstractArray{RT}, A::AbstractArray) =
 Evaluates to the same as `reducedim(op, map(f, A), region, f(v0))`, but is generally
 faster because the intermediate array is avoided.
 
+# Examples
 ```jldoctest
 julia> a = reshape(collect(1:16), (4,4))
 4×4 Array{Int64,2}:
@@ -252,6 +253,7 @@ The associativity of the reduction is implementation-dependent; if you need a pa
 associativity, e.g. left-to-right, you should write your own loop. See documentation for
 [`reduce`](@ref).
 
+# Examples
 ```jldoctest
 julia> a = reshape(collect(1:16), (4,4))
 4×4 Array{Int64,2}:
@@ -282,6 +284,7 @@ reducedim(op, A::AbstractArray, region) = mapreducedim(identity, op, A, region)
 
 Sum elements of an array over the given dimensions.
 
+# Examples
 ```jldoctest
 julia> A = [1 2; 3 4]
 2×2 Array{Int64,2}:
@@ -305,6 +308,7 @@ sum(A, dims)
 
 Sum elements of `A` over the singleton dimensions of `r`, and write results to `r`.
 
+# Examples
 ```jldoctest
 julia> A = [1 2; 3 4]
 2×2 Array{Int64,2}:
@@ -328,6 +332,7 @@ sum!(r, A)
 
 Multiply elements of an array over the given dimensions.
 
+# Examples
 ```jldoctest
 julia> A = [1 2; 3 4]
 2×2 Array{Int64,2}:
@@ -351,6 +356,7 @@ prod(A, dims)
 
 Multiply elements of `A` over the singleton dimensions of `r`, and write results to `r`.
 
+# Examples
 ```jldoctest
 julia> A = [1 2; 3 4]
 2×2 Array{Int64,2}:
@@ -399,6 +405,7 @@ maximum(A, dims)
 
 Compute the maximum value of `A` over the singleton dimensions of `r`, and write results to `r`.
 
+# Examples
 ```jldoctest
 julia> A = [1 2; 3 4]
 2×2 Array{Int64,2}:
@@ -424,6 +431,7 @@ Compute the minimum value of an array over the given dimensions. See also the
 [`min(a,b)`](@ref) function to take the minimum of two or more arguments,
 which can be applied elementwise to arrays via `min.(a,b)`.
 
+# Examples
 ```jldoctest
 julia> A = [1 2; 3 4]
 2×2 Array{Int64,2}:
@@ -447,6 +455,7 @@ minimum(A, dims)
 
 Compute the minimum value of `A` over the singleton dimensions of `r`, and write results to `r`.
 
+# Examples
 ```jldoctest
 julia> A = [1 2; 3 4]
 2×2 Array{Int64,2}:
@@ -470,6 +479,7 @@ minimum!(r, A)
 
 Test whether all values along the given dimensions of an array are `true`.
 
+# Examples
 ```jldoctest
 julia> A = [true false; true true]
 2×2 Array{Bool,2}:
@@ -493,6 +503,7 @@ all(A::AbstractArray, dims)
 
 Test whether all values in `A` along the singleton dimensions of `r` are `true`, and write results to `r`.
 
+# Examples
 ```jldoctest
 julia> A = [true false; true false]
 2×2 Array{Bool,2}:
@@ -516,6 +527,7 @@ all!(r, A)
 
 Test whether any values along the given dimensions of an array are `true`.
 
+# Examples
 ```jldoctest
 julia> A = [true false; true false]
 2×2 Array{Bool,2}:
@@ -540,6 +552,7 @@ any(::AbstractArray,dims)
 Test whether any values in `A` along the singleton dimensions of `r` are `true`, and write
 results to `r`.
 
+# Examples
 ```jldoctest
 julia> A = [true false; true false]
 2×2 Array{Bool,2}:
@@ -576,7 +589,7 @@ end
 
 ##### findmin & findmax #####
 
-function findminmax!{T,N}(f, Rval, Rind, A::AbstractArray{T,N})
+function findminmax!(f, Rval, Rind, A::AbstractArray{T,N}) where {T,N}
     (isempty(Rval) || isempty(A)) && return Rval, Rind
     lsiz = check_reducedims(Rval, A)
     for i = 1:N
@@ -637,6 +650,7 @@ end
 
 For an array input, returns the value and index of the minimum over the given region.
 
+# Examples
 ```jldoctest
 julia> A = [1 2; 3 4]
 2×2 Array{Int64,2}:
@@ -650,7 +664,7 @@ julia> findmin(A, 2)
 ([1; 3], [1; 2])
 ```
 """
-function findmin{T}(A::AbstractArray{T}, region)
+function findmin(A::AbstractArray{T}, region) where T
     if isempty(A)
         return (similar(A, reduced_indices0(A, region)),
                 similar(dims->zeros(Int, dims), reduced_indices0(A, region)))
@@ -675,6 +689,7 @@ end
 
 For an array input, returns the value and index of the maximum over the given region.
 
+# Examples
 ```jldoctest
 julia> A = [1 2; 3 4]
 2×2 Array{Int64,2}:
@@ -688,7 +703,7 @@ julia> findmax(A,2)
 ([2; 4], [3; 4])
 ```
 """
-function findmax{T}(A::AbstractArray{T}, region)
+function findmax(A::AbstractArray{T}, region) where T
     if isempty(A)
         return (similar(A, reduced_indices0(A,region)),
                 similar(dims->zeros(Int, dims), reduced_indices0(A,region)))
diff --git a/base/reflection.jl b/base/reflection.jl
index c0ce88531a2c8e..fd18f94d8b1883 100644
--- a/base/reflection.jl
+++ b/base/reflection.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # name and module reflection
 
@@ -7,6 +7,7 @@
 
 Get the name of a `Module` as a `Symbol`.
 
+# Examples
 ```jldoctest
 julia> module_name(Base.LinAlg)
 :LinAlg
@@ -18,6 +19,8 @@ module_name(m::Module) = ccall(:jl_module_name, Ref{Symbol}, (Any,), m)
     module_parent(m::Module) -> Module
 
 Get a module's enclosing `Module`. `Main` is its own parent, as is `LastMain` after `workspace()`.
+
+# Examples
 ```jldoctest
 julia> module_parent(Main)
 Main
@@ -29,18 +32,21 @@ Base.LinAlg
 module_parent(m::Module) = ccall(:jl_module_parent, Ref{Module}, (Any,), m)
 
 """
-    current_module() -> Module
+    @__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.
+Get the `Module` of the toplevel eval,
+which is the `Module` code is currently being read from.
 """
-current_module() = ccall(:jl_get_current_module, Ref{Module}, ())
+macro __MODULE__()
+    return __module__
+end
 
 """
     fullname(m::Module)
 
 Get the fully-qualified name of a module as a tuple of symbols. For example,
 
+# Examples
 ```jldoctest
 julia> fullname(Base.Pkg)
 (:Base, :Pkg)
@@ -89,7 +95,6 @@ isexported(m::Module, s::Symbol) = ccall(:jl_module_exports_p, Cint, (Any, Any),
 isdeprecated(m::Module, s::Symbol) = ccall(:jl_is_binding_deprecated, Cint, (Any, Any), m, s) != 0
 isbindingresolved(m::Module, var::Symbol) = ccall(:jl_binding_resolved_p, Cint, (Any, Any), m, var) != 0
 
-binding_module(s::Symbol) = binding_module(current_module(), s)
 function binding_module(m::Module, s::Symbol)
     p = ccall(:jl_get_module_of_binding, Ptr{Void}, (Any, Any), m, s)
     p == C_NULL && return m
@@ -108,23 +113,26 @@ end
 
 Get the name of field `i` of a `DataType`.
 
+# Examples
 ```jldoctest
-julia> fieldname(SparseMatrixCSC,1)
+julia> fieldname(SparseMatrixCSC, 1)
 :m
 
-julia> fieldname(SparseMatrixCSC,5)
+julia> fieldname(SparseMatrixCSC, 5)
 :nzval
 ```
 """
 fieldname(t::DataType, i::Integer) = t.name.names[i]::Symbol
 fieldname(t::UnionAll, i::Integer) = fieldname(unwrap_unionall(t), i)
-fieldname(t::Type{<:Tuple}, i::Integer) = i < 1 || i > nfields(t) ? throw(BoundsError(t, i)) : Int(i)
+fieldname(t::Type{<:Tuple}, i::Integer) =
+    i < 1 || i > fieldcount(t) ? throw(BoundsError(t, i)) : Int(i)
 
 """
     fieldnames(x::DataType)
 
 Get an array of the fields of a `DataType`.
 
+# Examples
 ```jldoctest
 julia> fieldnames(Hermitian)
 2-element Array{Symbol,1}:
@@ -132,21 +140,26 @@ julia> fieldnames(Hermitian)
  :uplo
 ```
 """
-function fieldnames(v)
-    t = typeof(v)
-    if !isa(t,DataType)
-        throw(ArgumentError("cannot call fieldnames() on a non-composite type"))
-    end
-    return fieldnames(t)
-end
-fieldnames(t::DataType) = Symbol[fieldname(t, n) for n in 1:nfields(t)]
+fieldnames(t::DataType) = Symbol[fieldname(t, n) for n in 1:fieldcount(t)]
 fieldnames(t::UnionAll) = fieldnames(unwrap_unionall(t))
-fieldnames(t::Type{<:Tuple}) = Int[n for n in 1:nfields(t)]
+fieldnames(t::Type{<:Tuple}) = Int[n for n in 1:fieldcount(t)]
 
 """
     Base.datatype_name(t) -> Symbol
 
 Get the name of a (potentially UnionAll-wrapped) `DataType` (without its parent module) as a symbol.
+
+# Examples
+```jldoctest
+julia> module Foo
+           struct S{T}
+           end
+       end
+Foo
+
+julia> Base.datatype_name(Foo.S{T} where T)
+:S
+```
 """
 datatype_name(t::DataType) = t.name.name
 datatype_name(t::UnionAll) = datatype_name(unwrap_unionall(t))
@@ -155,22 +168,56 @@ datatype_name(t::UnionAll) = datatype_name(unwrap_unionall(t))
     Base.datatype_module(t::DataType) -> Module
 
 Determine the module containing the definition of a `DataType`.
+
+# Examples
+```jldoctest
+julia> module Foo
+           struct Int end
+       end
+Foo
+
+julia> Base.datatype_module(Int)
+Core
+
+julia> Base.datatype_module(Foo.Int)
+Foo
+```
 """
 datatype_module(t::DataType) = t.name.module
 
-isconst(s::Symbol) = ccall(:jl_is_const, Cint, (Ptr{Void}, Any), C_NULL, s) != 0
-
 """
-    isconst([m::Module], s::Symbol) -> Bool
+    isconst(m::Module, s::Symbol) -> Bool
 
-Determine whether a global is declared `const` in a given `Module`. The default `Module`
-argument is [`current_module()`](@ref).
+Determine whether a global is declared `const` in a given `Module`.
 """
 isconst(m::Module, s::Symbol) =
     ccall(:jl_is_const, Cint, (Any, Any), m, s) != 0
 
+"""
+    @isdefined s -> Bool
+
+Tests whether variable `s` is defined in the current scope.
+
+# Examples
+```jldoctest
+julia> function f()
+           println(@isdefined x)
+           x = 3
+           println(@isdefined x)
+       end
+f (generic function with 1 method)
+
+julia> f()
+false
+true
+```
+"""
+macro isdefined(s::Symbol)
+    return Expr(:isdefined, esc(s))
+end
+
 # return an integer such that object_id(x)==object_id(y) if x===y
-object_id(x::ANY) = ccall(:jl_object_id, UInt, (Any,), x)
+object_id(@nospecialize(x)) = ccall(:jl_object_id, UInt, (Any,), x)
 
 struct DataTypeLayout
     nfields::UInt32
@@ -202,6 +249,7 @@ Return `true` iff value `v` is immutable.  See [Mutable Composite Types](@ref)
 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.
 
+# Examples
 ```jldoctest
 julia> isimmutable(1)
 true
@@ -210,17 +258,18 @@ julia> isimmutable([1,2])
 false
 ```
 """
-isimmutable(x::ANY) = (@_pure_meta; (isa(x,Tuple) || !typeof(x).mutable))
-isstructtype(t::DataType) = (@_pure_meta; nfields(t) != 0 || (t.size==0 && !t.abstract))
+isimmutable(@nospecialize(x)) = (@_pure_meta; (isa(x,Tuple) || !typeof(x).mutable))
+isstructtype(t::DataType) = (@_pure_meta; length(t.types) != 0 || (t.size==0 && !t.abstract))
 isstructtype(x) = (@_pure_meta; false)
 
 """
     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}`.
+references to other values. Typical examples are numeric types such as [`UInt8`](@ref),
+[`Float64`](@ref), and [`Complex{Float64}`](@ref).
 
+# Examples
 ```jldoctest
 julia> isbits(Complex{Float64})
 true
@@ -239,6 +288,7 @@ isbits(x) = (@_pure_meta; isbits(typeof(x)))
 Determine whether `T`'s only subtypes are itself and `Union{}`. This means `T` is
 a concrete type that can have instances.
 
+# Examples
 ```jldoctest
 julia> isconcrete(Complex)
 false
@@ -253,7 +303,7 @@ julia> isconcrete(Vector{Complex{Float32}})
 true
 ```
 """
-isconcrete(t::ANY) = (@_pure_meta; isa(t, DataType) && t.isconcrete)
+isconcrete(@nospecialize(t)) = (@_pure_meta; isa(t, DataType) && t.isconcrete)
 
 """
     Base.isabstract(T)
@@ -261,6 +311,7 @@ isconcrete(t::ANY) = (@_pure_meta; isa(t, DataType) && t.isconcrete)
 Determine whether `T` was declared as an abstract type (i.e. using the
 `abstract` keyword).
 
+# Examples
 ```jldoctest
 julia> Base.isabstract(AbstractArray)
 true
@@ -269,7 +320,7 @@ julia> Base.isabstract(Vector)
 false
 ```
 """
-function isabstract(t::ANY)
+function isabstract(@nospecialize(t))
     @_pure_meta
     t = unwrap_unionall(t)
     isa(t,DataType) && t.abstract
@@ -279,6 +330,8 @@ end
     Base.parameter_upper_bound(t::UnionAll, idx)
 
 Determine the upper bound of a type parameter in the underlying type. E.g.:
+
+# Examples
 ```jldoctest
 julia> struct Foo{T<:AbstractFloat, N}
            x::Tuple{T, N}
@@ -302,8 +355,8 @@ end
 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(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)
+typeintersect(@nospecialize(a),@nospecialize(b)) = (@_pure_meta; ccall(:jl_type_intersection, Any, (Any,Any), a, b))
+typeseq(@nospecialize(a),@nospecialize(b)) = (@_pure_meta; a<:b && b<:a)
 
 """
     fieldoffset(type, i)
@@ -312,7 +365,7 @@ The byte offset of field `i` of a type relative to the data start. For example,
 use it in the following manner to summarize information about a struct:
 
 ```jldoctest
-julia> structinfo(T) = [(fieldoffset(T,i), fieldname(T,i), fieldtype(T,i)) for i = 1:nfields(T)];
+julia> structinfo(T) = [(fieldoffset(T,i), fieldname(T,i), fieldtype(T,i)) for i = 1:fieldcount(T)];
 
 julia> structinfo(Base.Filesystem.StatStruct)
 12-element Array{Tuple{UInt64,Symbol,DataType},1}:
@@ -337,8 +390,9 @@ fieldoffset(x::DataType, idx::Integer) = (@_pure_meta; ccall(:jl_get_field_offse
 
 Determine the declared type of a field (specified by name or index) in a composite DataType `T`.
 
+# Examples
 ```jldoctest
-julia> immutable Foo
+julia> struct Foo
            x::Int64
            y::String
        end
@@ -358,8 +412,9 @@ fieldtype
 Get the index of a named field, throwing an error if the field does not exist (when err==true)
 or returning 0 (when err==false).
 
+# Examples
 ```jldoctest
-julia> immutable Foo
+julia> struct Foo
            x::Int64
            y::String
        end
@@ -379,6 +434,31 @@ end
 
 type_alignment(x::DataType) = (@_pure_meta; ccall(:jl_get_alignment, Csize_t, (Any,), x))
 
+"""
+    fieldcount(t::Type)
+
+Get the number of fields that an instance of the given type would have.
+An error is thrown if the type is too abstract to determine this.
+"""
+function fieldcount(@nospecialize t)
+    if t isa UnionAll || t isa Union
+        t = ccall(:jl_argument_datatype, Any, (Any,), t)
+        if t === nothing
+            error("type does not have a definite number of fields")
+        end
+        t = t::DataType
+    elseif t == Union{}
+        return 0
+    end
+    if !(t isa DataType)
+        throw(TypeError(:fieldcount, "", Type, t))
+    end
+    if t.abstract || (t.name === Tuple.name && isvatuple(t))
+        error("type does not have a definite number of fields")
+    end
+    return length(t.types)
+end
+
 # return all instances, for types that can be enumerated
 
 """
@@ -387,6 +467,7 @@ type_alignment(x::DataType) = (@_pure_meta; ccall(:jl_get_alignment, Csize_t, (A
 Return a collection of all instances of the given type, if applicable. Mostly used for
 enumerated types (see `@enum`).
 
+# Example
 ```jldoctest
 julia> @enum Colors Red Blue Green
 
@@ -446,6 +527,7 @@ end
 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.
 
+# Examples
 ```jldoctest
 julia> subtypes(Integer)
 4-element Array{Union{DataType, UnionAll},1}:
@@ -457,7 +539,7 @@ julia> subtypes(Integer)
 """
 subtypes(x::Union{DataType,UnionAll}) = subtypes(Main, x)
 
-function to_tuple_type(t::ANY)
+function to_tuple_type(@nospecialize(t))
     @_pure_meta
     if isa(t,Tuple) || isa(t,AbstractArray) || isa(t,SimpleVector)
         t = Tuple{t...}
@@ -472,17 +554,16 @@ function to_tuple_type(t::ANY)
     t
 end
 
-tt_cons(t::ANY, tup::ANY) = (@_pure_meta; Tuple{t, (isa(tup, Type) ? tup.parameters : tup)...})
+tt_cons(@nospecialize(t), @nospecialize(tup)) = (@_pure_meta; Tuple{t, (isa(tup, Type) ? tup.parameters : tup)...})
 
 """
     code_lowered(f, types)
 
 Returns an array of lowered ASTs for the methods matching the given generic function and type signature.
 """
-function code_lowered(f::ANY, t::ANY=Tuple)
+function code_lowered(@nospecialize(f), @nospecialize t = Tuple)
     asts = map(methods(f, t)) do m
-        m = m::Method
-        return uncompressed_ast(m, m.source)
+        return uncompressed_ast(m::Method)
     end
     return asts
 end
@@ -490,62 +571,25 @@ end
 # low-level method lookup functions used by the compiler
 
 unionlen(x::Union) = unionlen(x.a) + unionlen(x.b)
-unionlen(x::ANY) = 1
+unionlen(@nospecialize(x)) = 1
 
 _uniontypes(x::Union, ts) = (_uniontypes(x.a,ts); _uniontypes(x.b,ts); ts)
-_uniontypes(x::ANY, ts) = (push!(ts, x); ts)
-uniontypes(x::ANY) = _uniontypes(x, Any[])
+_uniontypes(@nospecialize(x), ts) = (push!(ts, x); ts)
+uniontypes(@nospecialize(x)) = _uniontypes(x, Any[])
 
-function _methods(f::ANY, t::ANY, lim::Int, world::UInt)
+function _methods(@nospecialize(f), @nospecialize(t), lim::Int, world::UInt)
     ft = isa(f,Type) ? Type{f} : typeof(f)
     tt = isa(t,Type) ? Tuple{ft, t.parameters...} : Tuple{ft, t...}
     return _methods_by_ftype(tt, lim, world)
 end
 
-function _methods_by_ftype(t::ANY, lim::Int, world::UInt)
+function _methods_by_ftype(@nospecialize(t), lim::Int, world::UInt)
     return _methods_by_ftype(t, lim, world, UInt[typemin(UInt)], UInt[typemax(UInt)])
 end
-function _methods_by_ftype(t::ANY, lim::Int, world::UInt, min::Array{UInt,1}, max::Array{UInt,1})
-    tp = unwrap_unionall(t).parameters::SimpleVector
-    nu = 1
-    for ti in tp
-        if isa(ti, Union)
-            nu *= unionlen(ti::Union)
-        end
-    end
-    if 1 < nu <= 64
-        return _methods_by_ftype(Any[tp...], t, length(tp), lim, [], world, min, max)
-    end
-    # XXX: the following can return incorrect answers that the above branch would have corrected
+function _methods_by_ftype(@nospecialize(t), lim::Int, world::UInt, min::Array{UInt,1}, max::Array{UInt,1})
     return ccall(:jl_matching_methods, Any, (Any, Cint, Cint, UInt, Ptr{UInt}, Ptr{UInt}), t, lim, 0, world, min, max)
 end
 
-function _methods_by_ftype(t::Array, origt::ANY, i, lim::Integer, matching::Array{Any,1},
-                           world::UInt, min::Array{UInt,1}, max::Array{UInt,1})
-    if i == 0
-        world = typemax(UInt)
-        new = ccall(:jl_matching_methods, Any, (Any, Cint, Cint, UInt, Ptr{UInt}, Ptr{UInt}),
-                    rewrap_unionall(Tuple{t...}, origt), lim, 0, world, min, max)
-        new === false && return false
-        append!(matching, new::Array{Any,1})
-    else
-        ti = t[i]
-        if isa(ti, Union)
-            for ty in uniontypes(ti::Union)
-                t[i] = ty
-                if _methods_by_ftype(t, origt, i - 1, lim, matching, world, min, max) === false
-                    t[i] = ti
-                    return false
-                end
-            end
-            t[i] = ti
-        else
-            return _methods_by_ftype(t, origt, i - 1, lim, matching, world, min, max)
-        end
-    end
-    return matching
-end
-
 # high-level, more convenient method lookup functions
 
 # type for reflecting and pretty-printing a subset of methods
@@ -575,7 +619,7 @@ Returns the method table for `f`.
 
 If `types` is specified, returns an array of methods whose types match.
 """
-function methods(f::ANY, t::ANY)
+function methods(@nospecialize(f), @nospecialize(t))
     if isa(f, Core.Builtin)
         throw(ArgumentError("argument is not a generic function"))
     end
@@ -586,7 +630,7 @@ end
 
 methods(f::Core.Builtin) = MethodList(Method[], typeof(f).name.mt)
 
-function methods_including_ambiguous(f::ANY, t::ANY)
+function methods_including_ambiguous(@nospecialize(f), @nospecialize(t))
     ft = isa(f,Type) ? Type{f} : typeof(f)
     tt = isa(t,Type) ? Tuple{ft, t.parameters...} : Tuple{ft, t...}
     world = typemax(UInt)
@@ -595,7 +639,7 @@ function methods_including_ambiguous(f::ANY, t::ANY)
     ms = ccall(:jl_matching_methods, Any, (Any, Cint, Cint, UInt, Ptr{UInt}, Ptr{UInt}), tt, -1, 1, world, min, max)::Array{Any,1}
     return MethodList(Method[m[3] for m in ms], typeof(f).name.mt)
 end
-function methods(f::ANY)
+function methods(@nospecialize(f))
     # return all matches
     return methods(f, Tuple{Vararg{Any}})
 end
@@ -638,14 +682,9 @@ function length(mt::MethodTable)
 end
 isempty(mt::MethodTable) = (mt.defs === nothing)
 
-uncompressed_ast(m::Method) = uncompressed_ast(m, m.source)
-function uncompressed_ast(m::Method, s::CodeInfo)
-    if isa(s.code, Array{UInt8,1})
-        s = ccall(:jl_copy_code_info, Ref{CodeInfo}, (Any,), s)
-        s.code = ccall(:jl_uncompress_ast, Array{Any,1}, (Any, Any), m, s.code)
-    end
-    return s
-end
+uncompressed_ast(m::Method) = uncompressed_ast(m, isdefined(m,:source) ? m.source : m.generator.inferred)
+uncompressed_ast(m::Method, s::CodeInfo) = s
+uncompressed_ast(m::Method, s::Array{UInt8,1}) = ccall(:jl_uncompress_ast, Any, (Any, Any), m, s)::CodeInfo
 
 # this type mirrors jl_cghooks_t (documented in julia.h)
 struct CodegenHooks
@@ -685,7 +724,7 @@ struct CodegenParams
 end
 
 # Printing code representations in IR and assembly
-function _dump_function(f::ANY, t::ANY, native::Bool, wrapper::Bool,
+function _dump_function(@nospecialize(f), @nospecialize(t), native::Bool, wrapper::Bool,
                         strip_ir_metadata::Bool, dump_module::Bool, syntax::Symbol=:att,
                         optimize::Bool=true, params::CodegenParams=CodegenParams())
     ccall(:jl_is_in_pure_context, Bool, ()) && error("code reflection cannot be used from generated functions")
@@ -741,10 +780,10 @@ function and type signature to `io` which defaults to `STDOUT`.
 
 All metadata and dbg.* calls are removed from the printed bitcode. Use code_llvm_raw for the full IR.
 """
-code_llvm(io::IO, f::ANY, types::ANY=Tuple, strip_ir_metadata=true, dump_module=false) =
+code_llvm(io::IO, @nospecialize(f), @nospecialize(types=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=Tuple) = code_llvm(STDOUT, f, types)
-code_llvm_raw(f::ANY, types::ANY=Tuple) = code_llvm(STDOUT, f, types, false)
+code_llvm(@nospecialize(f), @nospecialize(types=Tuple)) = code_llvm(STDOUT, f, types)
+code_llvm_raw(@nospecialize(f), @nospecialize(types=Tuple)) = code_llvm(STDOUT, f, types, false)
 
 """
     code_native([io], f, types, [syntax])
@@ -753,21 +792,20 @@ Prints the native assembly instructions generated for running the method matchin
 generic function and type signature to `io` which defaults to `STDOUT`.
 Switch assembly syntax using `syntax` symbol parameter set to `:att` for AT&T syntax or `:intel` for Intel syntax. Output is AT&T syntax by default.
 """
-code_native(io::IO, f::ANY, types::ANY=Tuple, syntax::Symbol=:att) =
+code_native(io::IO, @nospecialize(f), @nospecialize(types=Tuple), syntax::Symbol=:att) =
     print(io, _dump_function(f, types, true, false, false, false, syntax))
-code_native(f::ANY, types::ANY=Tuple, syntax::Symbol=:att) = code_native(STDOUT, f, types, syntax)
-code_native(::IO, ::ANY, ::Symbol) = error("illegal code_native call") # resolve ambiguous call
+code_native(@nospecialize(f), @nospecialize(types=Tuple), syntax::Symbol=:att) = code_native(STDOUT, f, types, syntax)
+code_native(::IO, ::Any, ::Symbol) = error("illegal code_native call") # resolve ambiguous call
 
 # give a decent error message if we try to instantiate a staged function on non-concrete types
-function func_for_method_checked(m::Method, types::ANY)
-    if m.isstaged && !isconcrete(types)
+function func_for_method_checked(m::Method, @nospecialize types)
+    if isdefined(m,:generator) && !isdefined(m,:source) && !isconcrete(types)
         error("cannot call @generated function `", m, "` ",
               "with abstract argument types: ", types)
     end
     return m
 end
 
-
 """
     code_typed(f, types; optimize=true)
 
@@ -775,14 +813,14 @@ Returns an array of lowered and type-inferred ASTs for the methods matching the
 generic function and type signature. The keyword argument `optimize` controls whether
 additional optimizations, such as inlining, are also applied.
 """
-function code_typed(f::ANY, types::ANY=Tuple; optimize=true)
+function code_typed(@nospecialize(f), @nospecialize(types=Tuple); optimize=true)
     ccall(:jl_is_in_pure_context, Bool, ()) && error("code reflection cannot be used from generated functions")
     if isa(f, Core.Builtin)
         throw(ArgumentError("argument is not a generic function"))
     end
     types = to_tuple_type(types)
     asts = []
-    world = typemax(UInt)
+    world = ccall(:jl_get_world_counter, UInt, ())
     params = Core.Inference.InferenceParams(world)
     for x in _methods(f, types, -1, world)
         meth = func_for_method_checked(x[3], types)
@@ -793,14 +831,14 @@ function code_typed(f::ANY, types::ANY=Tuple; optimize=true)
     return asts
 end
 
-function return_types(f::ANY, types::ANY=Tuple)
+function return_types(@nospecialize(f), @nospecialize(types=Tuple))
     ccall(:jl_is_in_pure_context, Bool, ()) && error("code reflection cannot be used from generated functions")
     if isa(f, Core.Builtin)
         throw(ArgumentError("argument is not a generic function"))
     end
     types = to_tuple_type(types)
     rt = []
-    world = typemax(UInt)
+    world = ccall(:jl_get_world_counter, UInt, ())
     params = Core.Inference.InferenceParams(world)
     for x in _methods(f, types, -1, world)
         meth = func_for_method_checked(x[3], types)
@@ -818,7 +856,7 @@ Returns the method of `f` (a `Method` object) that would be called for arguments
 
 If `types` is an abstract type, then the method that would be called by `invoke` is returned.
 """
-function which(f::ANY, t::ANY)
+function which(@nospecialize(f), @nospecialize(t))
     if isa(f, Core.Builtin)
         throw(ArgumentError("argument is not a generic function"))
     end
@@ -846,9 +884,9 @@ end
 """
     which(symbol)
 
-Return the module in which the binding for the variable referenced by `symbol` was created.
+Return the module in which the binding for the variable referenced by `symbol` in module `Main` was created.
 """
-which(s::Symbol) = which_module(current_module(), s)
+which(s::Symbol) = which_module(Main, s)
 # TODO: making this a method of which() causes a strange error
 function which_module(m::Module, s::Symbol)
     if !isdefined(m, s)
@@ -885,9 +923,9 @@ end
 
 Returns a tuple `(filename,line)` giving the location of a generic `Function` definition.
 """
-functionloc(f::ANY, types::ANY) = functionloc(which(f,types))
+functionloc(@nospecialize(f), @nospecialize(types)) = functionloc(which(f,types))
 
-function functionloc(f::ANY)
+function functionloc(@nospecialize(f))
     mt = methods(f)
     if isempty(mt)
         if isa(f, Function)
@@ -915,7 +953,7 @@ function_module(f::Function) = datatype_module(typeof(f))
 
 Determine the module containing a given definition of a generic function.
 """
-function function_module(f::ANY, types::ANY)
+function function_module(@nospecialize(f), @nospecialize(types))
     m = methods(f, types)
     if isempty(m)
         error("no matching methods")
@@ -924,30 +962,61 @@ function function_module(f::ANY, types::ANY)
 end
 
 """
-    method_exists(f, Tuple type) -> Bool
+    method_exists(f, Tuple type, world=typemax(UInt)) -> Bool
 
 Determine whether the given generic function has a method matching the given
-`Tuple` of argument types.
+`Tuple` of argument types with the upper bound of world age given by `world`.
 
+# Examples
 ```jldoctest
 julia> method_exists(length, Tuple{Array})
 true
 ```
 """
-function method_exists(f::ANY, t::ANY)
+function method_exists(@nospecialize(f), @nospecialize(t), world=typemax(UInt))
     t = to_tuple_type(t)
     t = Tuple{isa(f,Type) ? Type{f} : typeof(f), t.parameters...}
-    return ccall(:jl_method_exists, Cint, (Any, Any, UInt), typeof(f).name.mt, t,
-        typemax(UInt)) != 0
+    return ccall(:jl_method_exists, Cint, (Any, Any, UInt), typeof(f).name.mt, t, world) != 0
 end
 
-function isambiguous(m1::Method, m2::Method, allow_bottom_tparams::Bool=true)
+"""
+    isambiguous(m1, m2; ambiguous_bottom=false) -> Bool
+
+Determine whether two methods `m1` and `m2` (typically of the same
+function) are ambiguous.  This test is performed in the context of
+other methods of the same function; in isolation, `m1` and `m2` might
+be ambiguous, but if a third method resolving the ambiguity has been
+defined, this returns `false`.
+
+For parametric types, the `ambiguous_bottom` keyword argument controls whether
+`Union{}` counts as an ambiguous intersection of type parameters – when `true`,
+it is considered ambiguous, when `false` it is not.
+
+# Examples
+```jldoctest
+julia> foo(x::Complex{<:Integer}) = 1
+foo (generic function with 1 method)
+
+julia> foo(x::Complex{<:Rational}) = 2
+foo (generic function with 2 methods)
+
+julia> m1, m2 = collect(methods(foo));
+
+julia> typeintersect(m1.sig, m2.sig)
+Tuple{#foo,Complex{Union{}}}
+
+julia> Base.isambiguous(m1, m2, ambiguous_bottom=true)
+true
+
+julia> Base.isambiguous(m1, m2, ambiguous_bottom=false)
+false
+```
+"""
+function isambiguous(m1::Method, m2::Method; ambiguous_bottom::Bool=false)
     ti = typeintersect(m1.sig, m2.sig)
     ti === Bottom && return false
-    if !allow_bottom_tparams
-        (_, env) = ccall(:jl_match_method, Ref{SimpleVector}, (Any, Any),
-                         ti, m1.sig)
-        any(x->x === Bottom, env) && return false
+    if !ambiguous_bottom
+        has_bottom_parameter(ti) && return false
     end
     ml = _methods_by_ftype(ti, -1, typemax(UInt))
     isempty(ml) && return true
@@ -959,7 +1028,24 @@ function isambiguous(m1::Method, m2::Method, allow_bottom_tparams::Bool=true)
     return true
 end
 
+"""
+    has_bottom_parameter(t) -> Bool
+
+Determine whether `t` is a Type for which one or more of its parameters is `Union{}`.
+"""
+function has_bottom_parameter(t::Type)
+    ret = false
+    for p in t.parameters
+        ret |= (p == Bottom) || has_bottom_parameter(p)
+    end
+    ret
+end
+has_bottom_parameter(t::UnionAll) = has_bottom_parameter(unwrap_unionall(t))
+has_bottom_parameter(t::Union) = has_bottom_parameter(t.a) & has_bottom_parameter(t.b)
+has_bottom_parameter(t::TypeVar) = has_bottom_parameter(t.ub)
+has_bottom_parameter(::Any) = false
+
 min_world(m::Method) = reinterpret(UInt, m.min_world)
-max_world(m::Method) = reinterpret(UInt, m.max_world)
+max_world(m::Method) = typemax(UInt)
 min_world(m::Core.MethodInstance) = reinterpret(UInt, m.min_world)
 max_world(m::Core.MethodInstance) = reinterpret(UInt, m.max_world)
diff --git a/base/refpointer.jl b/base/refpointer.jl
index 5fa34cd1919d87..44a625c76b6cf7 100644
--- a/base/refpointer.jl
+++ b/base/refpointer.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 """
     Ref{T}
@@ -27,12 +27,12 @@ end
 
 ### General Methods for Ref{T} type
 
-eltype{T}(x::Type{Ref{T}}) = T
-convert{T}(::Type{Ref{T}}, x::Ref{T}) = x
+eltype(x::Type{Ref{T}}) where {T} = T
+convert(::Type{Ref{T}}, x::Ref{T}) where {T} = x
 
 # create Ref objects for general object conversion
-unsafe_convert{T}(::Type{Ref{T}}, x::Ref{T}) = unsafe_convert(Ptr{T}, x)
-unsafe_convert{T}(::Type{Ref{T}}, x) = unsafe_convert(Ptr{T}, x)
+unsafe_convert(::Type{Ref{T}}, x::Ref{T}) where {T} = unsafe_convert(Ptr{T}, x)
+unsafe_convert(::Type{Ref{T}}, x) where {T} = unsafe_convert(Ptr{T}, x)
 
 ### Methods for a Ref object that can store a single value of any type
 
@@ -41,42 +41,49 @@ mutable struct RefValue{T} <: Ref{T}
     RefValue{T}() where {T} = new()
     RefValue{T}(x) where {T} = new(x)
 end
-RefValue{T}(x::T) = RefValue{T}(x)
+RefValue(x::T) where {T} = RefValue{T}(x)
 isassigned(x::RefValue) = isdefined(x, :x)
 
 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::Ptr{T}, i::Integer=1) where {T} = x + (i-1)*Core.sizeof(T)
 Ref(x, i::Integer) = (i != 1 && error("Object only has one element"); Ref(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)
+Ref{T}() where {T} = RefValue{T}() # Ref{T}()
+Ref{T}(x) where {T} = RefValue{T}(x) # Ref{T}(x)
+convert(::Type{Ref{T}}, x) where {T} = RefValue{T}(x)
 
-function unsafe_convert{T}(P::Type{Ptr{T}}, b::RefValue{T})
+function unsafe_convert(P::Type{Ptr{T}}, b::RefValue{T}) where T
     if isbits(T)
-        return convert(P, data_pointer_from_objref(b))
+        return convert(P, pointer_from_objref(b))
+    elseif isleaftype(T)
+        return convert(P, pointer_from_objref(b.x))
     else
-        return convert(P, data_pointer_from_objref(b.x))
+        # If the slot is not leaf type, it could be either isbits or not.
+        # If it is actually an isbits type and the type inference can infer that
+        # it can rebox the `b.x` if we simply call `pointer_from_objref(b.x)` on it.
+        # Instead, explicitly load the pointer from the `RefValue` so that the pointer
+        # is the same as the one rooted in the `RefValue` object.
+        return convert(P, pointerref(Ptr{Ptr{Void}}(pointer_from_objref(b)), 1, 0))
     end
 end
 function unsafe_convert(P::Type{Ptr{Any}}, b::RefValue{Any})
     return convert(P, data_pointer_from_objref(b))
 end
-unsafe_convert{T}(::Type{Ptr{Void}}, b::RefValue{T}) = convert(Ptr{Void}, unsafe_convert(Ptr{T}, b))
+unsafe_convert(::Type{Ptr{Void}}, b::RefValue{T}) where {T} = convert(Ptr{Void}, unsafe_convert(Ptr{T}, b))
 
 ### Methods for a Ref object that is backed by an array at index i
-struct RefArray{T, A<:AbstractArray{T}, R} <: Ref{T}
+struct RefArray{T,A<:AbstractArray{T},R} <: Ref{T}
     x::A
     i::Int
     roots::R # should be either ::Void or ::Any
     RefArray{T,A,R}(x,i,roots=nothing) where {T,A<:AbstractArray{T},R} = new(x,i,roots)
 end
-RefArray{T}(x::AbstractArray{T},i::Int,roots::Any) = RefArray{T,typeof(x),Any}(x, i, roots)
-RefArray{T}(x::AbstractArray{T},i::Int=1,roots::Void=nothing) = RefArray{T,typeof(x),Void}(x, i, nothing)
-convert{T}(::Type{Ref{T}}, x::AbstractArray{T}) = RefArray(x, 1)
+RefArray(x::AbstractArray{T}, i::Int, roots::Any) where {T} = RefArray{T,typeof(x),Any}(x, i, roots)
+RefArray(x::AbstractArray{T}, i::Int=1, roots::Void=nothing) where {T} = RefArray{T,typeof(x),Void}(x, i, nothing)
+convert(::Type{Ref{T}}, x::AbstractArray{T}) where {T} = RefArray(x, 1)
 Ref(x::AbstractArray, i::Integer=1) = RefArray(x, i)
 
-function unsafe_convert{T}(P::Type{Ptr{T}}, b::RefArray{T})
+function unsafe_convert(P::Type{Ptr{T}}, b::RefArray{T}) where T
     if isbits(T)
         convert(P, pointer(b.x, b.i))
     else
@@ -86,19 +93,19 @@ end
 function unsafe_convert(P::Type{Ptr{Any}}, b::RefArray{Any})
     return convert(P, pointer(b.x, b.i))
 end
-unsafe_convert{T}(::Type{Ptr{Void}}, b::RefArray{T}) = convert(Ptr{Void}, unsafe_convert(Ptr{T}, b))
+unsafe_convert(::Type{Ptr{Void}}, b::RefArray{T}) where {T} = convert(Ptr{Void}, unsafe_convert(Ptr{T}, b))
 
 # convert Arrays to pointer arrays for ccall
-function (::Type{Ref{<:Union{Ptr,Cwstring,Cstring}}})(a::Array{<:Union{Ptr,Cwstring,Cstring}}) # Ref{P<:Ptr}(a::Array{T<:Ptr})
+function Ref{P}(a::Array{<:Union{Ptr,Cwstring,Cstring}}) where P<:Union{Ptr,Cwstring,Cstring}
     return RefArray(a) # effectively a no-op
 end
-function (::Type{Ref{P}}){P<:Union{Ptr,Cwstring,Cstring},T}(a::Array{T}) # Ref{P<:Ptr}(a::Array)
+function Ref{P}(a::Array{T}) where P<:Union{Ptr,Cwstring,Cstring} where T
     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))
+        ptrs = Vector{P}(length(a)+1)
+        roots = Vector{Any}(length(a))
         for i = 1:length(a)
             root = cconvert(P, a[i])
             ptrs[i] = unsafe_convert(P, root)::P
@@ -108,10 +115,10 @@ function (::Type{Ref{P}}){P<:Union{Ptr,Cwstring,Cstring},T}(a::Array{T}) # Ref{P
         return RefArray(ptrs,1,roots)
     end
 end
-cconvert{P<:Ptr}(::Type{Ptr{P}}, a::Array{<:Ptr}) = a
-cconvert{P<:Ptr}(::Type{Ref{P}}, a::Array{<:Ptr}) = a
-cconvert{P<:Union{Ptr,Cwstring,Cstring}}(::Type{Ptr{P}}, a::Array) = Ref{P}(a)
-cconvert{P<:Union{Ptr,Cwstring,Cstring}}(::Type{Ref{P}}, a::Array) = Ref{P}(a)
+cconvert(::Type{Ptr{P}}, a::Array{<:Ptr}) where {P<:Ptr} = a
+cconvert(::Type{Ref{P}}, a::Array{<:Ptr}) where {P<:Ptr} = a
+cconvert(::Type{Ptr{P}}, a::Array) where {P<:Union{Ptr,Cwstring,Cstring}} = Ref{P}(a)
+cconvert(::Type{Ref{P}}, a::Array) where {P<:Union{Ptr,Cwstring,Cstring}} = Ref{P}(a)
 
 ###
 
diff --git a/base/regex.jl b/base/regex.jl
index e2161c90874f3d..75e8dcc70e8216 100644
--- a/base/regex.jl
+++ b/base/regex.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## object-oriented Regex interface ##
 
@@ -75,7 +75,7 @@ after the ending quote, to change its behaviour:
 
 For example, this regex has all three flags enabled:
 
-```julia
+```jldoctest
 julia> match(r"a+.*b+.*?d\$"ism, "Goodbye,\\nOh, angry,\\nBad world\\n")
 RegexMatch("angry,\\nBad world")
 ```
diff --git a/base/LineEdit.jl b/base/repl/LineEdit.jl
similarity index 93%
rename from base/LineEdit.jl
rename to base/repl/LineEdit.jl
index bc9367022511a6..f5410022da8e98 100644
--- a/base/LineEdit.jl
+++ b/base/repl/LineEdit.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module LineEdit
 
@@ -15,14 +15,33 @@ abstract type ModeState end
 export run_interface, Prompt, ModalInterface, transition, reset_state, edit_insert, keymap
 
 struct ModalInterface <: TextInterface
-    modes
+    modes::Array{Base.LineEdit.TextInterface,1}
 end
 
+mutable struct Prompt <: TextInterface
+    # A string or function to be printed as the prompt.
+    prompt::Union{String,Function}
+    # A string or function to be printed before the prompt. May not change the length of the prompt.
+    # This may be used for changing the color, issuing other terminal escape codes, etc.
+    prompt_prefix::Union{String,Function}
+    # Same as prefix except after the prompt
+    prompt_suffix::Union{String,Function}
+    keymap_dict::Dict{Char}
+    keymap_func_data # ::AbstractREPL
+    complete # ::REPLCompletionProvider
+    on_enter::Function
+    on_done::Function
+    hist # ::REPLHistoryProvider
+    sticky::Bool
+end
+
+show(io::IO, x::Prompt) = show(io, string("Prompt(\"", prompt_string(x.prompt), "\",...)"))
+
 mutable struct MIState
     interface::ModalInterface
-    current_mode
+    current_mode::TextInterface
     aborted::Bool
-    mode_state
+    mode_state::Dict
     kill_buffer::String
     previous_key::Array{Char,1}
     key_repeats::Int
@@ -33,38 +52,20 @@ function show(io::IO, s::MIState)
     print(io, "MI State (", s.current_mode, " active)")
 end
 
-mutable struct Prompt <: TextInterface
-    prompt
-    # A string or function to be printed before the prompt. May not change the length of the prompt.
-    # This may be used for changing the color, issuing other terminal escape codes, etc.
-    prompt_prefix
-    # Same as prefix except after the prompt
-    prompt_suffix
-    keymap_dict
-    keymap_func_data
-    complete
-    on_enter
-    on_done
-    hist
-    sticky::Bool
-end
-
-show(io::IO, x::Prompt) = show(io, string("Prompt(\"", x.prompt, "\",...)"))
-
 struct InputAreaState
     num_rows::Int64
     curs_row::Int64
 end
 
 mutable struct PromptState <: ModeState
-    terminal
+    terminal::AbstractTerminal
     p::Prompt
     input_buffer::IOBuffer
     ias::InputAreaState
     indent::Int
 end
 
-input_string(s::PromptState) = String(s.input_buffer)
+input_string(s::PromptState) = String(take!(copy(s.input_buffer)))
 
 input_string_newlines(s::PromptState) = count(c->(c == '\n'), input_string(s))
 function input_string_newlines_aftercursor(s::PromptState)
@@ -77,11 +78,8 @@ end
 abstract type HistoryProvider end
 abstract type CompletionProvider end
 
-mutable struct EmptyCompletionProvider <: CompletionProvider
-end
-
-mutable struct EmptyHistoryProvider <: HistoryProvider
-end
+struct EmptyCompletionProvider <: CompletionProvider end
+struct EmptyHistoryProvider <: HistoryProvider end
 
 reset_state(::EmptyHistoryProvider) = nothing
 
@@ -185,8 +183,10 @@ function _clear_input_area(terminal, state::InputAreaState)
     clear_line(terminal)
 end
 
-prompt_string(s::PromptState) = s.p.prompt
+prompt_string(s::PromptState) = prompt_string(s.p)
+prompt_string(p::Prompt) = prompt_string(p.prompt)
 prompt_string(s::AbstractString) = s
+prompt_string(f::Function) = Base.invokelatest(f)
 
 refresh_multi_line(s::ModeState) = refresh_multi_line(terminal(s), s)
 refresh_multi_line(termbuf::TerminalBuffer, s::ModeState) = refresh_multi_line(termbuf, terminal(s), s)
@@ -204,7 +204,7 @@ function refresh_multi_line(termbuf::TerminalBuffer, terminal::UnixTerminal, buf
     write_prompt(termbuf, prompt)
     prompt = prompt_string(prompt)
     # Count the '\n' at the end of the line if the terminal emulator does (specific to DOS cmd prompt)
-    miscountnl = @static is_windows() ? (isa(Terminals.pipe_reader(terminal), Base.TTY) && !Base.ispty(Terminals.pipe_reader(terminal))) : false
+    miscountnl = @static Sys.iswindows() ? (isa(Terminals.pipe_reader(terminal), Base.TTY) && !Base.ispty(Terminals.pipe_reader(terminal))) : false
     lindent = strwidth(prompt)
 
     # Now go through the buffer line by line
@@ -274,7 +274,7 @@ end
 
 
 # Edit functionality
-is_non_word_char(c) = c in " \t\n\"\\'`@\$><=:;|&{}()[].,+-*/?%^~"
+is_non_word_char(c) = c in """ \t\n\"\\'`@\$><=:;|&{}()[].,+-*/?%^~"""
 
 function reset_key_repeats(f::Function, s::MIState)
     key_repeats_sav = s.key_repeats
@@ -457,7 +457,7 @@ function edit_insert(s::PromptState, c)
     end
     str = string(c)
     edit_insert(buf, str)
-    offset = s.ias.curs_row == 1 ? sizeof(s.p.prompt) : s.indent
+    offset = s.ias.curs_row == 1 ? sizeof(prompt_string(s.p.prompt)) : s.indent
     if !('\n' in str) && eof(buf) &&
         ((line_size() + offset + sizeof(str) - 1) < width(terminal(s)))
         # Avoid full update when appending characters to the end
@@ -591,6 +591,8 @@ end
 
 history_prev(::EmptyHistoryProvider) = ("", false)
 history_next(::EmptyHistoryProvider) = ("", false)
+history_first(::EmptyHistoryProvider) = ("", false)
+history_last(::EmptyHistoryProvider) = ("", false)
 history_search(::EmptyHistoryProvider, args...) = false
 add_history(::EmptyHistoryProvider, s) = nothing
 add_history(s::PromptState) = add_history(mode(s).hist, s)
@@ -626,15 +628,15 @@ default_enter_cb(_) = true
 
 write_prompt(terminal, s::PromptState) = write_prompt(terminal, s.p)
 function write_prompt(terminal, p::Prompt)
-    prefix = isa(p.prompt_prefix,Function) ? eval(Expr(:call, p.prompt_prefix)) : p.prompt_prefix
-    suffix = isa(p.prompt_suffix,Function) ? eval(Expr(:call, p.prompt_suffix)) : p.prompt_suffix
+    prefix = prompt_string(p.prompt_prefix)
+    suffix = prompt_string(p.prompt_suffix)
     write(terminal, prefix)
     write(terminal, Base.text_colors[:bold])
-    write(terminal, p.prompt)
+    write(terminal, prompt_string(p.prompt))
     write(terminal, Base.text_colors[:normal])
     write(terminal, suffix)
 end
-write_prompt(terminal, s::String) = write(terminal, s)
+write_prompt(terminal, s::Union{AbstractString,Function}) = write(terminal, prompt_string(s))
 
 ### Keymap Support
 
@@ -725,6 +727,9 @@ function match_input(k::Dict, s, term=terminal(s), cs=Char[], keymap = k)
     # return an empty keymap function
     eof(term) && return keymap_fcn(nothing, "")
     c = read(term, Char)
+    # Ignore any '\0' (eg, CTRL-space in xterm), as this is used as a
+    # placeholder for the wildcard (see normalize_key("*"))
+    c != '\0' || return keymap_fcn(nothing, "")
     push!(cs, c)
     key = haskey(k, c) ? c : '\0'
     # if we don't match on the key, look for a default action then fallback on 'nothing' to ignore
@@ -864,7 +869,7 @@ function keymap_merge(target,source)
     for key in setdiff(keys(source), keys(direct_keys))
         # We first resolve redirects in the source
         value = source[key]
-        visited = Array{Any}(0)
+        visited = Vector{Any}(0)
         while isa(value, Union{Char,AbstractString})
             value = normalize_key(value)
             if value in visited
@@ -960,22 +965,22 @@ 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, readstring(data.response_buffer))
+    write(s.input_buffer, read(data.response_buffer, String))
     s.input_buffer.ptr = offset + ptr - 2
     data.response_buffer.ptr = ptr
     refresh_line(s)
 end
 
 mutable struct SearchState <: ModeState
-    terminal
-    histprompt
+    terminal::AbstractTerminal
+    histprompt # ::HistoryPrompt
     #rsearch (true) or ssearch (false)
     backward::Bool
     query_buffer::IOBuffer
     response_buffer::IOBuffer
     ias::InputAreaState
     #The prompt whose input will be replaced by the matched history
-    parent
+    parent::Prompt
     SearchState(terminal, histprompt, backward, query_buffer, response_buffer) =
         new(terminal, histprompt, backward, query_buffer, response_buffer, InputAreaState(0,0))
 end
@@ -996,7 +1001,7 @@ function history_set_backward(s::SearchState, backward)
     s.backward = backward
 end
 
-input_string(s::SearchState) = String(s.query_buffer)
+input_string(s::SearchState) = String(take!(copy(s.query_buffer)))
 
 function reset_state(s::SearchState)
     if s.query_buffer.size != 0
@@ -1012,7 +1017,7 @@ end
 
 mutable struct HistoryPrompt{T<:HistoryProvider} <: TextInterface
     hp::T
-    complete
+    complete # ::CompletionProvider
     keymap_dict::Dict{Char,Any}
     HistoryPrompt{T}(hp) where T<:HistoryProvider = new(hp, EmptyCompletionProvider())
 end
@@ -1021,16 +1026,16 @@ HistoryPrompt(hp::T) where T<:HistoryProvider = HistoryPrompt{T}(hp)
 init_state(terminal, p::HistoryPrompt) = SearchState(terminal, p, true, IOBuffer(), IOBuffer())
 
 mutable struct PrefixSearchState <: ModeState
-    terminal
-    histprompt
+    terminal::AbstractTerminal
+    histprompt # ::HistoryPrompt
     prefix::String
     response_buffer::IOBuffer
     ias::InputAreaState
     indent::Int
     # The modal interface state, if present
-    mi
+    mi::MIState
     #The prompt whose input will be replaced by the matched history
-    parent
+    parent::Prompt
     PrefixSearchState(terminal, histprompt, prefix, response_buffer) =
         new(terminal, histprompt, prefix, response_buffer, InputAreaState(0,0), 0)
 end
@@ -1045,14 +1050,14 @@ refresh_multi_line(termbuf::TerminalBuffer, terminal::UnixTerminal,
     s::Union{PromptState,PrefixSearchState}) = s.ias =
     refresh_multi_line(termbuf, terminal, buffer(s), s.ias, s, indent = s.indent)
 
-input_string(s::PrefixSearchState) = String(s.response_buffer)
+input_string(s::PrefixSearchState) = String(take!(copy(s.response_buffer)))
 
 # a meta-prompt that presents itself as parent_prompt, but which has an independent keymap
 # for prefix searching
 mutable struct PrefixHistoryPrompt{T<:HistoryProvider} <: TextInterface
     hp::T
     parent_prompt::Prompt
-    complete
+    complete # ::CompletionProvider
     keymap_dict::Dict{Char,Any}
     PrefixHistoryPrompt{T}(hp, parent_prompt) where T<:HistoryProvider =
         new(hp, parent_prompt, EmptyCompletionProvider())
@@ -1062,7 +1067,7 @@ PrefixHistoryPrompt(hp::T, parent_prompt) where T<:HistoryProvider = PrefixHisto
 init_state(terminal, p::PrefixHistoryPrompt) = PrefixSearchState(terminal, p, "", IOBuffer())
 
 write_prompt(terminal, s::PrefixSearchState) = write_prompt(terminal, s.histprompt.parent_prompt)
-prompt_string(s::PrefixSearchState) = s.histprompt.parent_prompt.prompt
+prompt_string(s::PrefixSearchState) = prompt_string(s.histprompt.parent_prompt.prompt)
 
 terminal(s::PrefixSearchState) = s.terminal
 
@@ -1101,7 +1106,7 @@ function refresh_multi_line(termbuf::TerminalBuffer, s::SearchState)
     offset = buf.ptr
     ptr = s.response_buffer.ptr
     seek(s.response_buffer, 0)
-    write(buf, readstring(s.response_buffer))
+    write(buf, read(s.response_buffer, String))
     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)`")
@@ -1443,7 +1448,9 @@ const history_keymap = AnyDict(
     # Page Up
     "\e[5~" => (s,o...)->(history_prev(s, mode(s).hist)),
     # Page Down
-    "\e[6~" => (s,o...)->(history_next(s, mode(s).hist))
+    "\e[6~" => (s,o...)->(history_next(s, mode(s).hist)),
+    "\e<" => (s,o...)->(history_first(s, mode(s).hist)),
+    "\e>" => (s,o...)->(history_last(s, mode(s).hist)),
 )
 
 const prefix_history_keymap = merge!(
@@ -1559,7 +1566,9 @@ end
 
 run_interface(::Prompt) = nothing
 
-init_state(terminal, prompt::Prompt) = PromptState(terminal, prompt, IOBuffer(), InputAreaState(1, 1), #=indent(spaces)=#strwidth(prompt.prompt))
+init_state(terminal, prompt::Prompt) =
+    PromptState(terminal, prompt, IOBuffer(), InputAreaState(1, 1),
+    #=indent(spaces)=# strwidth(prompt_string(prompt)))
 
 function init_state(terminal, m::ModalInterface)
     s = MIState(m, m.modes[1], false, Dict{Any,Any}())
@@ -1572,13 +1581,19 @@ end
 function run_interface(terminal, m::ModalInterface)
     s::MIState = init_state(terminal, m)
     while !s.aborted
-        p = s.current_mode
         buf, ok, suspend = prompt!(terminal, m, s)
         while suspend
-            @static if is_unix(); ccall(:jl_repl_raise_sigtstp, Cint, ()); end
+            @static if Sys.isunix(); ccall(:jl_repl_raise_sigtstp, Cint, ()); end
             buf, ok, suspend = prompt!(terminal, m, s)
         end
-        mode(state(s, s.current_mode)).on_done(s, buf, ok)
+        eval(Main,
+            Expr(:body,
+                Expr(:return,
+                     Expr(:call,
+                          QuoteNode(mode(state(s, s.current_mode)).on_done),
+                          QuoteNode(s),
+                          QuoteNode(buf),
+                          QuoteNode(ok)))))
     end
 end
 
@@ -1597,17 +1612,22 @@ function prompt!(term, prompt, s = init_state(term, prompt))
     enable_bracketed_paste(term)
     try
         activate(prompt, s, term, term)
+        old_state = mode(s)
         while true
-            map = keymap(s, prompt)
-            fcn = match_input(map, s)
+            kmap = keymap(s, prompt)
+            fcn = match_input(kmap, s)
+            kdata = keymap_data(s, prompt)
             # errors in keymaps shouldn't cause the REPL to fail, so wrap in a
             # try/catch block
             local state
             try
-                state = fcn(s, keymap_data(s, prompt))
+                state = fcn(s, kdata)
             catch e
-                warn("Caught an exception in the keymap:")
-                warn(e)
+                bt = catch_backtrace()
+                warn(e, bt = bt, prefix = "ERROR (in the keymap): ")
+                # try to cleanup and get `s` back to its original state before returning
+                transition(s, :reset)
+                transition(s, old_state)
                 state = :done
             end
             if state === :abort
@@ -1615,7 +1635,7 @@ function prompt!(term, prompt, s = init_state(term, prompt))
             elseif state === :done
                 return buffer(s), true, false
             elseif state === :suspend
-                if is_unix()
+                if Sys.isunix()
                     return buffer(s), true, true
                 end
             else
diff --git a/base/REPL.jl b/base/repl/REPL.jl
similarity index 84%
rename from base/REPL.jl
rename to base/repl/REPL.jl
index c65876b3c984d8..3bb8fd98345e3e 100644
--- a/base/REPL.jl
+++ b/base/repl/REPL.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module REPL
 
@@ -8,6 +8,7 @@ using ..LineEdit
 using ..REPLCompletions
 
 export
+    AbstractREPL,
     BasicREPL,
     LineEditREPL,
     StreamREPL
@@ -28,6 +29,8 @@ import ..LineEdit:
     history_next_prefix,
     history_prev,
     history_prev_prefix,
+    history_first,
+    history_last,
     history_search,
     accept_result,
     terminal
@@ -52,7 +55,7 @@ mutable struct REPLBackend
         new(repl_channel, response_channel, in_eval)
 end
 
-function eval_user_input(ast::ANY, backend::REPLBackend)
+function eval_user_input(@nospecialize(ast), backend::REPLBackend)
     iserr, lasterr = false, ((), nothing)
     Base.sigatomic_begin()
     while true
@@ -65,7 +68,7 @@ function eval_user_input(ast::ANY, backend::REPLBackend)
                 backend.in_eval = true
                 value = eval(Main, ast)
                 backend.in_eval = false
-                # note: value wrapped in a closure to ensure it doesn't get passed through expand
+                # note: value wrapped carefully here to ensure it doesn't get passed through expand
                 eval(Main, Expr(:body, Expr(:(=), :ans, QuoteNode(value)), Expr(:return, nothing)))
                 put!(backend.response_channel, (value, nothing))
             end
@@ -124,11 +127,11 @@ function display(d::REPLDisplay, mime::MIME"text/plain", x)
 end
 display(d::REPLDisplay, x) = display(d, MIME("text/plain"), x)
 
-function print_response(repl::AbstractREPL, val::ANY, bt, show_value::Bool, have_color::Bool)
+function print_response(repl::AbstractREPL, @nospecialize(val), bt, show_value::Bool, have_color::Bool)
     repl.waserror = bt !== nothing
     print_response(outstream(repl), val, bt, show_value, have_color, specialdisplay(repl))
 end
-function print_response(errio::IO, val::ANY, bt, show_value::Bool, have_color::Bool, specialdisplay=nothing)
+function print_response(errio::IO, @nospecialize(val), bt, show_value::Bool, have_color::Bool, specialdisplay=nothing)
     Base.sigatomic_begin()
     while true
         try
@@ -172,7 +175,7 @@ struct REPLBackendRef
     response_channel::Channel
 end
 
-function run_repl(repl::AbstractREPL, consumer = x->nothing)
+function run_repl(repl::AbstractREPL, consumer::Function = x->nothing)
     repl_channel = Channel(1)
     response_channel = Channel(1)
     backend = start_repl_backend(repl_channel, response_channel)
@@ -254,8 +257,8 @@ mutable struct LineEditREPL <: AbstractREPL
     in_help::Bool
     envcolors::Bool
     waserror::Bool
-    specialdisplay
-    interface
+    specialdisplay::Union{Void,Display}
+    interface::ModalInterface
     backendref::REPLBackendRef
     LineEditREPL(t,hascolor,prompt_color,input_color,answer_color,shell_color,help_color,history_file,in_shell,in_help,envcolors) =
         new(t,true,prompt_color,input_color,answer_color,shell_color,help_color,history_file,in_shell,
@@ -266,20 +269,19 @@ specialdisplay(r::LineEditREPL) = r.specialdisplay
 specialdisplay(r::AbstractREPL) = nothing
 terminal(r::LineEditREPL) = r.t
 
-LineEditREPL(t::TextTerminal, envcolors = false) =  LineEditREPL(t,
-                                              true,
-                                              Base.text_colors[:light_green],
-                                              Base.input_color(),
-                                              Base.answer_color(),
-                                              Base.text_colors[:red],
-                                              Base.text_colors[:yellow],
-                                              false, false, false, envcolors)
-
-mutable struct REPLCompletionProvider <: CompletionProvider; end
-
-mutable struct ShellCompletionProvider <: CompletionProvider; end
+LineEditREPL(t::TextTerminal, envcolors::Bool=false) =
+    LineEditREPL(t, true,
+        Base.text_colors[:green],
+        Base.input_color(),
+        Base.answer_color(),
+        Base.text_colors[:red],
+        Base.text_colors[:yellow],
+        false, false, false, envcolors
+    )
 
-struct LatexCompletions <: CompletionProvider; end
+mutable struct REPLCompletionProvider <: CompletionProvider end
+mutable struct ShellCompletionProvider <: CompletionProvider end
+struct LatexCompletions <: CompletionProvider end
 
 beforecursor(buf::IOBuffer) = String(buf.data[1:buf.ptr-1])
 
@@ -305,16 +307,15 @@ function complete_line(c::LatexCompletions, s)
     return ret, partial[range], should_complete
 end
 
-
 mutable struct REPLHistoryProvider <: HistoryProvider
     history::Array{String,1}
-    history_file
+    history_file::Union{Void,IO}
     start_idx::Int
     cur_idx::Int
     last_idx::Int
     last_buffer::IOBuffer
-    last_mode
-    mode_mapping
+    last_mode::Union{Void,Prompt}
+    mode_mapping::Dict
     modes::Array{Symbol,1}
 end
 REPLHistoryProvider(mode_mapping) =
@@ -393,7 +394,7 @@ function mode_idx(hist::REPLHistoryProvider, mode)
 end
 
 function add_history(hist::REPLHistoryProvider, s)
-    str = rstrip(String(s.input_buffer))
+    str = rstrip(String(take!(copy(s.input_buffer))))
     isempty(strip(str)) && return
     mode = mode_idx(hist, LineEdit.mode(s))
     !isempty(hist.history) &&
@@ -464,9 +465,10 @@ function LineEdit.accept_result(s, p::LineEdit.HistoryPrompt{REPLHistoryProvider
 end
 
 function history_prev(s::LineEdit.MIState, hist::REPLHistoryProvider,
-        save_idx::Int = hist.cur_idx)
+                      num::Int=1, save_idx::Int = hist.cur_idx)
+    num <= 0 && return history_next(s, hist, -num, save_idx)
     hist.last_idx = -1
-    m = history_move(s, hist, hist.cur_idx-1, save_idx)
+    m = history_move(s, hist, hist.cur_idx-num, save_idx)
     if m === :ok
         LineEdit.move_input_start(s)
         LineEdit.reset_key_repeats(s) do
@@ -474,15 +476,19 @@ function history_prev(s::LineEdit.MIState, hist::REPLHistoryProvider,
         end
         LineEdit.refresh_line(s)
     elseif m === :skip
-        hist.cur_idx -= 1
-        history_prev(s, hist, save_idx)
+        history_prev(s, hist, num+1, save_idx)
     else
         Terminals.beep(LineEdit.terminal(s))
     end
 end
 
 function history_next(s::LineEdit.MIState, hist::REPLHistoryProvider,
-        save_idx::Int = hist.cur_idx)
+                      num::Int=1, save_idx::Int = hist.cur_idx)
+    if num == 0
+        Terminals.beep(LineEdit.terminal(s))
+        return
+    end
+    num < 0 && return history_prev(s, hist, -num, save_idx)
     cur_idx = hist.cur_idx
     max_idx = length(hist.history) + 1
     if cur_idx == max_idx && 0 < hist.last_idx
@@ -490,24 +496,29 @@ function history_next(s::LineEdit.MIState, hist::REPLHistoryProvider,
         cur_idx = hist.last_idx
         hist.last_idx = -1
     end
-    m = history_move(s, hist, cur_idx+1, save_idx)
+    m = history_move(s, hist, cur_idx+num, save_idx)
     if m === :ok
         LineEdit.move_input_end(s)
         LineEdit.refresh_line(s)
     elseif m === :skip
-        hist.cur_idx += 1
-        history_next(s, hist, save_idx)
+        history_next(s, hist, num+1, save_idx)
     else
         Terminals.beep(LineEdit.terminal(s))
     end
 end
 
+history_first(s::LineEdit.MIState, hist::REPLHistoryProvider) =
+    history_prev(s, hist, hist.cur_idx - 1)
+
+history_last(s::LineEdit.MIState, hist::REPLHistoryProvider) =
+    history_next(s, hist, length(hist.history) - hist.cur_idx + 1)
+
 function history_move_prefix(s::LineEdit.PrefixSearchState,
                              hist::REPLHistoryProvider,
                              prefix::AbstractString,
                              backwards::Bool,
                              cur_idx = hist.cur_idx)
-    cur_response = String(LineEdit.buffer(s))
+    cur_response = String(take!(copy(LineEdit.buffer(s))))
     # when searching forward, start at last_idx
     if !backwards && hist.last_idx > 0
         cur_idx = hist.last_idx
@@ -548,11 +559,11 @@ function history_search(hist::REPLHistoryProvider, query_buffer::IOBuffer, respo
     qpos = position(query_buffer)
     qpos > 0 || return true
     searchdata = beforecursor(query_buffer)
-    response_str = String(response_buffer)
+    response_str = String(take!(copy(response_buffer)))
 
     # Alright, first try to see if the current match still works
-    a = position(response_buffer) + 1
-    b = min(endof(response_str), prevind(response_str, a + sizeof(searchdata)))
+    a = position(response_buffer) + 1 # position is zero-indexed
+    b = min(endof(response_str), prevind(response_str, a + sizeof(searchdata))) # ensure that b is valid
 
     !skip_current && searchdata == response_str[a:b] && return true
 
@@ -565,7 +576,7 @@ function history_search(hist::REPLHistoryProvider, query_buffer::IOBuffer, respo
     if 1 <= searchstart <= endof(response_str)
         match = searchfunc(response_str, searchdata, searchstart)
         if match != 0:-1
-            seek(response_buffer, prevind(response_str, first(match)))
+            seek(response_buffer, first(match) - 1)
             return true
         end
     end
@@ -578,7 +589,7 @@ function history_search(hist::REPLHistoryProvider, query_buffer::IOBuffer, respo
         if match != 0:-1 && h != response_str && haskey(hist.mode_mapping, hist.modes[idx])
             truncate(response_buffer, 0)
             write(response_buffer, h)
-            seek(response_buffer, prevind(h, first(match)))
+            seek(response_buffer, first(match) - 1)
             hist.cur_idx = idx
             return true
         end
@@ -597,7 +608,7 @@ LineEdit.reset_state(hist::REPLHistoryProvider) = history_reset_state(hist)
 
 function return_callback(s)
     ast = Base.syntax_deprecation_warnings(false) do
-        Base.parse_input_line(String(LineEdit.buffer(s)))
+        Base.parse_input_line(String(take!(copy(LineEdit.buffer(s)))))
     end
     if  !isa(ast, Expr) || (ast.head != :continue && ast.head != :incomplete)
         return true
@@ -619,21 +630,31 @@ end
 
 backend(r::AbstractREPL) = r.backendref
 
-send_to_backend(ast, backend::REPLBackendRef) = send_to_backend(ast, backend.repl_channel, backend.response_channel)
+send_to_backend(ast, backend::REPLBackendRef) =
+    send_to_backend(ast, backend.repl_channel, backend.response_channel)
+
 function send_to_backend(ast, req, rep)
     put!(req, (ast, 1))
-    val, bt = take!(rep)
+    return take!(rep) # (val, bt)
 end
 
 function respond(f, repl, main; pass_empty = false)
-    (s,buf,ok)->begin
+    return function do_respond(s, buf, ok)
         if !ok
             return transition(s, :abort)
         end
         line = String(take!(buf))
         if !isempty(line) || pass_empty
             reset(repl)
-            val, bt = send_to_backend(eval(:(($f)($line))), backend(repl))
+            local val, bt
+            try
+                # note: value wrapped carefully here to ensure it doesn't get passed through expand
+                response = eval(Main, Expr(:body, Expr(:return, Expr(:call, QuoteNode(f), QuoteNode(line)))))
+                val, bt = send_to_backend(response, backend(repl))
+            catch err
+                val = err
+                bt = catch_backtrace()
+            end
             if !ends_with_semicolon(line) || bt !== nothing
                 print_response(repl, val, bt, true, Base.have_color)
             end
@@ -653,7 +674,7 @@ function prepare_next(repl::LineEditREPL)
     println(terminal(repl))
 end
 
-function mode_keymap(julia_prompt)
+function mode_keymap(julia_prompt::Prompt)
     AnyDict(
     '\b' => function (s,o...)
         if isempty(s) || position(LineEdit.buffer(s)) == 0
@@ -678,10 +699,14 @@ end
 repl_filename(repl, hp::REPLHistoryProvider) = "REPL[$(length(hp.history)-hp.start_idx)]"
 repl_filename(repl, hp) = "REPL"
 
-const JL_PROMT_PASTE = Ref(true)
-enable_promtpaste(v::Bool) = JL_PROMT_PASTE[] = v
+const JL_PROMPT_PASTE = Ref(true)
+enable_promptpaste(v::Bool) = JL_PROMPT_PASTE[] = v
 
-function setup_interface(repl::LineEditREPL; hascolor = repl.hascolor, extra_repl_keymap = Dict{Any,Any}[])
+function setup_interface(
+    repl::LineEditREPL;
+    hascolor::Bool = repl.hascolor,
+    extra_repl_keymap::Union{Dict,Vector{<:Dict}} = Dict{Any,Any}[]
+)
     ###
     #
     # This function returns the main interface that describes the REPL
@@ -742,7 +767,9 @@ function setup_interface(repl::LineEditREPL; hascolor = repl.hascolor, extra_rep
         # and pass into Base.repl_cmd for processing (handles `ls` and `cd`
         # special)
         on_done = respond(repl, julia_prompt) do line
-            Expr(:call, :(Base.repl_cmd), Cmd(Base.shell_split(line)), outstream(repl))
+            Expr(:call, :(Base.repl_cmd),
+                :(Base.cmd_gen($(Base.shell_parse(line)[1]))),
+                outstream(repl))
         end)
 
 
@@ -829,7 +856,7 @@ function setup_interface(repl::LineEditREPL; hascolor = repl.hascolor, extra_rep
             firstline = true
             isprompt_paste = false
             while !done(input, oldpos) # loop until all lines have been executed
-                if JL_PROMT_PASTE[]
+                if JL_PROMPT_PASTE[]
                     # Check if the next statement starts with "julia> ", in that case
                     # skip it. But first skip whitespace
                     while input[oldpos] in ('\n', ' ', '\t')
@@ -884,11 +911,11 @@ function setup_interface(repl::LineEditREPL; hascolor = repl.hascolor, extra_rep
             end
         end,
 
-        # Open the editor at the location of a stackframe
+        # Open the editor at the location of a stackframe or method
         # This is accessing a global variable that gets set in
-        # the show_backtrace function.
+        # the show_backtrace and show_method_table functions.
         "^Q" => (s, o...) -> begin
-            linfos = Base.LAST_BACKTRACE_LINE_INFOS
+            linfos = Base.LAST_SHOWN_LINE_INFOS
             str = String(take!(LineEdit.buffer(s)))
             n = tryparse(Int, str)
             isnull(n) && @goto writeback
@@ -922,7 +949,7 @@ function setup_interface(repl::LineEditREPL; hascolor = repl.hascolor, extra_rep
     ModalInterface([julia_prompt, shell_mode, help_mode, search_prompt, prefix_prompt])
 end
 
-function run_frontend(repl::LineEditREPL, backend)
+function run_frontend(repl::LineEditREPL, backend::REPLBackendRef)
     d = REPLDisplay(repl)
     dopushdisplay = repl.specialdisplay === nothing && !in(d,Base.Multimedia.displays)
     dopushdisplay && pushdisplay(d)
@@ -953,7 +980,7 @@ mutable struct StreamREPL <: AbstractREPL
     waserror::Bool
     StreamREPL(stream,pc,ic,ac) = new(stream,pc,ic,ac,false)
 end
-StreamREPL(stream::IO) = StreamREPL(stream, Base.text_colors[:light_green], Base.input_color(), Base.answer_color())
+StreamREPL(stream::IO) = StreamREPL(stream, Base.text_colors[:green], Base.input_color(), Base.answer_color())
 run_repl(stream::IO) = run_repl(StreamREPL(stream))
 
 outstream(s::StreamREPL) = s.stream
@@ -963,11 +990,51 @@ answer_color(r::StreamREPL) = r.answer_color
 input_color(r::LineEditREPL) = r.envcolors ? Base.input_color() : r.input_color
 input_color(r::StreamREPL) = r.input_color
 
-function ends_with_semicolon(line)
+# heuristic function to decide if the presence of a semicolon
+# at the end of the expression was intended for suppressing output
+function ends_with_semicolon(line::AbstractString)
     match = rsearch(line, ';')
     if match != 0
-        for c in line[(match+1):end]
-            isspace(c) || return c == '#'
+        # state for comment parser, assuming that the `;` isn't in a string or comment
+        # so input like ";#" will still thwart this to give the wrong (anti-conservative) answer
+        comment = false
+        comment_start = false
+        comment_close = false
+        comment_multi = 0
+        for c in line[(match + 1):end]
+            if comment_multi > 0
+                # handle nested multi-line comments
+                if comment_close && c == '#'
+                    comment_close = false
+                    comment_multi -= 1
+                elseif comment_start && c == '='
+                    comment_start = false
+                    comment_multi += 1
+                else
+                    comment_start = (c == '#')
+                    comment_close = (c == '=')
+                end
+            elseif comment
+                # handle line comments
+                if c == '\r' || c == '\n'
+                    comment = false
+                end
+            elseif comment_start
+                # see what kind of comment this is
+                comment_start = false
+                if c == '='
+                    comment_multi = 1
+                else
+                    comment = true
+                end
+            elseif c == '#'
+                # start handling for a comment
+                comment_start = true
+            else
+                # outside of a comment, encountering anything but whitespace
+                # means the semi-colon was internal to the expression
+                isspace(c) || return false
+            end
         end
         return true
     end
@@ -1007,7 +1074,7 @@ function run_frontend(repl::StreamREPL, backend::REPLBackendRef)
     dopushdisplay && popdisplay(d)
 end
 
-function start_repl_server(port)
+function start_repl_server(port::Int)
     listen(port) do server, status
         client = accept(server)
         run_repl(client)
diff --git a/base/REPLCompletions.jl b/base/repl/REPLCompletions.jl
similarity index 95%
rename from base/REPLCompletions.jl
rename to base/repl/REPLCompletions.jl
index 971a78a32fa020..23f9124e9d0bc0 100644
--- a/base/REPLCompletions.jl
+++ b/base/repl/REPLCompletions.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module REPLCompletions
 
@@ -101,7 +101,7 @@ function complete_keyword(s::String)
 end
 
 function complete_path(path::AbstractString, pos; use_envpath=false)
-    if Base.is_unix() && ismatch(r"^~(?:/|$)", path)
+    if Base.Sys.isunix() && ismatch(r"^~(?:/|$)", path)
         # if the path is just "~", don't consider the expanded username as a prefix
         if path == "~"
             dir, prefix = homedir(), ""
@@ -129,13 +129,13 @@ function complete_path(path::AbstractString, pos; use_envpath=false)
         if startswith(file, prefix)
             id = try isdir(joinpath(dir, file)) catch; false end
             # joinpath is not used because windows needs to complete with double-backslash
-            push!(matches, id ? file * (@static is_windows() ? "\\\\" : "/") : file)
+            push!(matches, id ? file * (@static Sys.iswindows() ? "\\\\" : "/") : file)
         end
     end
 
     if use_envpath && length(dir) == 0
         # Look for files in PATH as well
-        local pathdirs = split(ENV["PATH"], @static is_windows() ? ";" : ":")
+        local pathdirs = split(ENV["PATH"], @static Sys.iswindows() ? ";" : ":")
 
         for pathdir in pathdirs
             local actualpath
@@ -282,7 +282,7 @@ function get_type_call(expr::Expr)
         found ? push!(args, typ) : push!(args, Any)
     end
     # use _methods_by_ftype as the function is supplied as a type
-    world = typemax(UInt)
+    world = ccall(:jl_get_world_counter, UInt, ())
     mt = Base._methods_by_ftype(Tuple{ft, args...}, -1, world)
     length(mt) == 1 || return (Any, false)
     m = first(mt)
@@ -292,9 +292,10 @@ function get_type_call(expr::Expr)
     return_type === nothing && return (Any, false)
     return (return_type, true)
 end
-# Returns the return type. example: get_type(:(Base.strip("",' ')),Main) returns (String,true)
-function get_type(sym::Expr, fn)
-    sym=expand(sym)
+
+# Returns the return type. example: get_type(:(Base.strip("", ' ')), Main) returns (String, true)
+function get_type(sym::Expr, fn::Module)
+    sym = expand(fn, sym)
     val, found = get_value(sym, fn)
     found && return Base.typesof(val).parameters[1], found
     if sym.head === :call
@@ -310,10 +311,11 @@ function get_type(sym::Expr, fn)
     end
     return (Any, false)
 end
-function get_type(sym, fn)
+function get_type(sym, fn::Module)
     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 = Any[]
@@ -330,8 +332,14 @@ function complete_methods(ex_org::Expr)
     kwtype = isdefined(ml.mt, :kwsorter) ? Nullable{DataType}(typeof(ml.mt.kwsorter)) : Nullable{DataType}()
     io = IOBuffer()
     for method in ml
-        # Check if the method's type signature intersects the input types
         ms = method.sig
+
+        # Do not suggest the default method from sysimg.jl.
+        if Base.is_default_method(method)
+            continue
+        end
+
+        # Check if the method's type signature intersects the input types
         if typeintersect(Base.rewrap_unionall(Tuple{Base.unwrap_unionall(ms).parameters[1 : min(na, end)]...}, ms), t_in) != Union{}
             show(io, method, kwtype=kwtype)
             push!(out, String(take!(io)))
@@ -399,10 +407,10 @@ function dict_identifier_key(str,tag)
         str_close = str
     end
 
-    frange, end_of_indentifier = find_start_brace(str_close, c_start='[', c_end=']')
+    frange, end_of_identifier = find_start_brace(str_close, c_start='[', c_end=']')
     isempty(frange) && return (nothing, nothing, nothing)
     obj = Main
-    for name in split(str[frange[1]:end_of_indentifier], '.')
+    for name in split(str[frange[1]:end_of_identifier], '.')
         Base.isidentifier(name) || return (nothing, nothing, nothing)
         sym = Symbol(name)
         isdefined(obj, sym) || return (nothing, nothing, nothing)
@@ -410,7 +418,7 @@ function dict_identifier_key(str,tag)
         # Avoid `isdefined(::Array, ::Symbol)`
         isa(obj, Array) && return (nothing, nothing, nothing)
     end
-    begin_of_key = findnext(x->!in(x,whitespace_chars), str, end_of_indentifier+2)
+    begin_of_key = first(search(str, r"\S", nextind(str, end_of_identifier) + 1)) # 1 for [
     begin_of_key==0 && return (true, nothing, nothing)
     partial_key = str[begin_of_key:end]
     (isa(obj, Associative) && length(obj) < 1e6) || return (true, nothing, nothing)
@@ -539,7 +547,7 @@ function completions(string, pos)
                 elseif c==']'
                     c_start='['; c_end=']'
                 end
-                frange, end_of_indentifier = find_start_brace(string[1:prevind(string, i)], c_start=c_start, c_end=c_end)
+                frange, end_of_identifier = find_start_brace(string[1:prevind(string, i)], c_start=c_start, c_end=c_end)
                 startpos = start(frange)
                 i = prevind(string, startpos)
             elseif c in ["\'\"\`"...]
@@ -580,7 +588,7 @@ function shell_completions(string, pos)
         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))
+    elseif isexpr(arg, :incomplete) || isexpr(arg, :error)
         r = first(last_parse):prevind(last_parse, last(last_parse))
         partial = scs[r]
         ret, range = completions(partial, endof(partial))
diff --git a/base/Terminals.jl b/base/repl/Terminals.jl
similarity index 70%
rename from base/Terminals.jl
rename to base/repl/Terminals.jl
index f60f8506162609..ad7382009d8329 100644
--- a/base/Terminals.jl
+++ b/base/repl/Terminals.jl
@@ -1,8 +1,9 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module Terminals
 
 export
+    AbstractTerminal,
     TextTerminal,
     UnixTerminal,
     TerminalBuffer,
@@ -33,11 +34,15 @@ import Base:
     read,
     readuntil
 
+## AbstractTerminal: abstract supertype of all terminals ##
+
+abstract type AbstractTerminal <: Base.AbstractPipe end
+
 ## TextTerminal ##
 
-abstract type TextTerminal <: Base.AbstractPipe end
+abstract type TextTerminal <: AbstractTerminal end
 
-# INTERFACE
+# Terminal interface:
 pipe_reader(::TextTerminal) = error("Unimplemented")
 pipe_writer(::TextTerminal) = error("Unimplemented")
 displaysize(::TextTerminal) = error("Unimplemented")
@@ -95,14 +100,14 @@ pipe_reader(t::UnixTerminal) = t.in_stream
 pipe_writer(t::UnixTerminal) = t.out_stream
 
 mutable struct TerminalBuffer <: UnixTerminal
-    out_stream::Base.IO
+    out_stream::IO
 end
 
 mutable struct TTYTerminal <: UnixTerminal
     term_type::String
-    in_stream::Base.TTY
-    out_stream::Base.TTY
-    err_stream::Base.TTY
+    in_stream::IO
+    out_stream::IO
+    err_stream::IO
 end
 
 const CSI = "\x1b["
@@ -113,22 +118,17 @@ cmove_right(t::UnixTerminal, n) = write(t.out_stream, "$(CSI)$(n)C")
 cmove_left(t::UnixTerminal, n) = write(t.out_stream, "$(CSI)$(n)D")
 cmove_line_up(t::UnixTerminal, n) = (cmove_up(t, n); cmove_col(t, 1))
 cmove_line_down(t::UnixTerminal, n) = (cmove_down(t, n); cmove_col(t, 1))
-cmove_col(t::UnixTerminal, n) = write(t.out_stream, "$(CSI)$(n)G")
+cmove_col(t::UnixTerminal, n) = (write(t.out_stream, '\r'); n > 1 && cmove_right(t, n-1))
 
-if is_windows()
+if Sys.iswindows()
     function raw!(t::TTYTerminal,raw::Bool)
         check_open(t.in_stream)
         if Base.ispty(t.in_stream)
-            run(if raw
-                    `stty raw -echo onlcr -ocrnl opost`
-                else
-                    `stty sane`
-                end,t.in_stream,t.out_stream,t.err_stream)
+            run((raw ? `stty raw -echo onlcr -ocrnl opost` : `stty sane`),
+                t.in_stream, t.out_stream, t.err_stream)
             true
         else
-            ccall(:jl_tty_set_mode,
-                 Int32, (Ptr{Void},Int32),
-                 t.in_stream.handle, raw) != -1
+            ccall(:jl_tty_set_mode, Int32, (Ptr{Void},Int32), t.in_stream.handle, raw) != -1
         end
     end
 else
@@ -137,26 +137,30 @@ else
         ccall(:jl_tty_set_mode, Int32, (Ptr{Void},Int32), t.in_stream.handle, raw) != -1
     end
 end
-enable_bracketed_paste(t::UnixTerminal) = write(t.out_stream, "$(CSI)?2004h")
-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>")
 
-function Base.displaysize(t::UnixTerminal)
-    return displaysize(t.out_stream)
-end
+# eval some of these definitions to insert CSI as a constant string
+@eval enable_bracketed_paste(t::UnixTerminal) = write(t.out_stream, $"$(CSI)?2004h")
+@eval disable_bracketed_paste(t::UnixTerminal) = write(t.out_stream, $"$(CSI)?2004l")
+@eval end_keypad_transmit_mode(t::UnixTerminal) = # tput rmkx
+    write(t.out_stream, $"$(CSI)?1l\x1b>")
 
-clear(t::UnixTerminal) = write(t.out_stream, "\x1b[H\x1b[2J")
-clear_line(t::UnixTerminal) = write(t.out_stream, "\x1b[1G\x1b[0K")
+@eval clear(t::UnixTerminal) = write(t.out_stream, $"$(CSI)H$(CSI)2J")
+@eval clear_line(t::UnixTerminal) = write(t.out_stream, $"\r$(CSI)0K")
 #beep(t::UnixTerminal) = write(t.err_stream,"\x7")
 
-if is_windows()
+Base.displaysize(t::UnixTerminal) = displaysize(t.out_stream)
+
+if Sys.iswindows()
     hascolor(t::TTYTerminal) = true
 else
     function hascolor(t::TTYTerminal)
         startswith(t.term_type, "xterm") && return true
         try
-            return success(`tput setaf 0`)
+            @static if Sys.KERNEL == :FreeBSD
+                return success(`tput AF 0`)
+            else
+                return success(`tput setaf 0`)
+            end
         catch
             return false
         end
diff --git a/base/emoji_symbols.jl b/base/repl/emoji_symbols.jl
similarity index 99%
rename from base/emoji_symbols.jl
rename to base/repl/emoji_symbols.jl
index e65d9b9be476b3..f8a5043f19f367 100644
--- a/base/emoji_symbols.jl
+++ b/base/repl/emoji_symbols.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #=
 import JSON
diff --git a/base/latex_symbols.jl b/base/repl/latex_symbols.jl
similarity index 99%
rename from base/latex_symbols.jl
rename to base/repl/latex_symbols.jl
index 2e2d2af8da6572..2a546b01259ebf 100644
--- a/base/latex_symbols.jl
+++ b/base/repl/latex_symbols.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Mapping from LaTeX math symbol to the corresponding Unicode codepoint.
 # This is used for tab substitution in the REPL.
@@ -84,6 +84,10 @@ const latex_symbols = Dict(
     "\\backpprime" => "‶",
     "\\backppprime" => "‷",
     "\\xor" => "⊻",
+    "\\iff" => "⟺",
+    "\\implies" => "⟹",
+    "\\impliedby" => "⟸",
+    "\\to" => "→",
 
     # Superscripts
     "\\^0" => "⁰",
diff --git a/base/replutil.jl b/base/replutil.jl
index 78d8878ae31cdc..d760c7d0a56346 100644
--- a/base/replutil.jl
+++ b/base/replutil.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # fallback text/plain representation of any type:
 show(io::IO, ::MIME"text/plain", x) = show(io, x)
@@ -15,14 +15,14 @@ function show(io::IO, ::MIME"text/plain", iter::Union{KeyIterator,ValueIterator}
         rows < 2 && (print(io, " …"); return)
         cols < 4 && (cols = 4)
         cols -= 2 # For prefix "  "
-        rows -= 2 # For summary and final ⋮ continuation lines
+        rows -= 1 # For summary
     else
-        rows = cols = 0
+        rows = cols = typemax(Int)
     end
 
     for (i, v) in enumerate(iter)
         print(io, "\n  ")
-        limit && i >= rows && (print(io, "⋮"); break)
+        i == rows < length(iter) && (print(io, "⋮"); break)
 
         if limit
             str = sprint(0, show, v, env=io)
@@ -34,7 +34,7 @@ function show(io::IO, ::MIME"text/plain", iter::Union{KeyIterator,ValueIterator}
     end
 end
 
-function show{K,V}(io::IO, ::MIME"text/plain", t::Associative{K,V})
+function show(io::IO, ::MIME"text/plain", t::Associative{K,V}) where {K,V}
     # show more descriptively, with one line per key/value pair
     recur_io = IOContext(io, :SHOWN_SET => t)
     limit::Bool = get(io, :limit, false)
@@ -44,7 +44,7 @@ function show{K,V}(io::IO, ::MIME"text/plain", t::Associative{K,V})
 
     print(io, summary(t))
     isempty(t) && return
-    print(io, ":\n  ")
+    print(io, ":")
     show_circular(io, t) && return
     if limit
         sz = displaysize(io)
@@ -52,11 +52,11 @@ function show{K,V}(io::IO, ::MIME"text/plain", t::Associative{K,V})
         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
+        rows -= 1 # Subtract the summary
 
         # determine max key width to align the output, caching the strings
-        ks = Array{AbstractString}(min(rows, length(t)))
-        vs = Array{AbstractString}(min(rows, length(t)))
+        ks = Vector{AbstractString}(min(rows, length(t)))
+        vs = Vector{AbstractString}(min(rows, length(t)))
         keylen = 0
         vallen = 0
         for (i, (k, v)) in enumerate(t)
@@ -70,14 +70,12 @@ function show{K,V}(io::IO, ::MIME"text/plain", t::Associative{K,V})
             keylen = max(cld(cols, 3), cols - vallen)
         end
     else
-        rows = cols = 0
+        rows = cols = typemax(Int)
     end
 
-    first = true
     for (i, (k, v)) in enumerate(t)
-        first || print(io, "\n  ")
-        first = false
-        limit && i > rows && (print(io, rpad("⋮", keylen), " => ⋮"); break)
+        print(io, "\n  ")
+        i == rows < length(t) && (print(io, rpad("⋮", keylen), " => ⋮"); break)
 
         if limit
             key = rpad(_truncate_at_width_or_chars(ks[i], keylen, "\r\n"), keylen)
@@ -151,8 +149,28 @@ function show(io::IO, ::MIME"text/plain", s::String)
     end
 end
 
+function show(io::IO, ::MIME"text/plain", opt::JLOptions)
+    println(io, "JLOptions(")
+    fields = fieldnames(JLOptions)
+    nfields = length(fields)
+    for (i, f) in enumerate(fields)
+        v = getfield(opt, i)
+        if isa(v, Ptr{UInt8})
+            v = (v != C_NULL) ? unsafe_string(v) : ""
+        end
+        println(io, "  ", f, " = ", repr(v), i < nfields ? "," : "")
+    end
+    print(io, ")")
+end
+
+
 # showing exception objects as descriptive error messages
 
+"""
+    showerror(io, e)
+
+Show a descriptive representation of an exception object.
+"""
 showerror(io::IO, ex) = show(io, ex)
 
 function showerror(io::IO, ex::BoundsError)
@@ -179,7 +197,6 @@ end
 
 function showerror(io::IO, ex::TypeError)
     print(io, "TypeError: ")
-    ctx = isempty(ex.context) ? "" : "in $(ex.context), "
     if ex.expected === Bool
         print(io, "non-boolean ($(typeof(ex.got))) used in boolean context")
     else
@@ -188,7 +205,12 @@ function showerror(io::IO, ex::TypeError)
         else
             tstr = string(typeof(ex.got))
         end
-        print(io, "$(ex.func): $(ctx)expected $(ex.expected), got $tstr")
+        if isempty(ex.context)
+            ctx = "in $(ex.func)"
+        else
+            ctx = "in $(ex.func), in $(ex.context)"
+        end
+        print(io, ctx, ", expected $(ex.expected), got ", tstr)
     end
 end
 
@@ -217,29 +239,15 @@ end
 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 = StackTraces.lookup(b)[1]
-        if !code.from_c
-            if code.func == :nan_dom_err
-                continue
-            elseif code.func in (:log, :log2, :log10, :sqrt)
-                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.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
-        end
+    if isa(ex.val, AbstractArray)
+        compact = get(io, :compact, true)
+        limit = get(io, :limit, true)
+        print(IOContext(io, compact=compact, limit=limit), "DomainError with ", ex.val)
+    else
+        print(io, "DomainError with ", ex.val)
+    end
+    if isdefined(ex, :msg)
+        print(io, ":\n", ex.msg)
     end
     backtrace && show_backtrace(io, bt)
     nothing
@@ -279,6 +287,10 @@ function showerror(io::IO, ex::UndefVarError)
     print(io, "UndefVarError: $(ex.var) not defined")
 end
 
+function showerror(io::IO, ex::InexactError)
+    print(io, "InexactError: ", ex.func, '(', ex.T, ", ", ex.val, ')')
+end
+
 function showerror(io::IO, ex::MethodError)
     # ex.args is a tuple type if it was thrown from `invoke` and is
     # a tuple of the arguments otherwise.
@@ -322,6 +334,18 @@ function showerror(io::IO, ex::MethodError)
             f_is_function = true
             print(io, "no method matching ", name)
         elseif isa(f, Type)
+            if isa(f, DataType) && f.abstract
+                # Print a more appropriate message if the only method
+                # on the type is the default one from sysimg.jl.
+                ms = methods(f)
+                if length(ms) == 1
+                    m = first(ms)
+                    if Base.is_default_method(m)
+                        print(io, "no constructors have been defined for $f")
+                        return
+                    end
+                end
+            end
             print(io, "no method matching ", f)
         else
             print(io, "no method matching (::", ft, ")")
@@ -352,7 +376,8 @@ function showerror(io::IO, ex::MethodError)
             print(io, "You may have intended to import Base.", name)
         end
     end
-    if method_exists(ex.f, arg_types)
+    if (ex.world != typemax(UInt) && method_exists(ex.f, arg_types) &&
+        !method_exists(ex.f, arg_types, ex.world))
         curworld = ccall(:jl_get_world_counter, UInt, ())
         println(io)
         print(io, "The applicable method may be too new: running in world age $(ex.world), while current world is $(curworld).")
@@ -389,7 +414,7 @@ function showerror(io::IO, ex::MethodError)
     end
 end
 
-striptype{T}(::Type{T}) = T
+striptype(::Type{T}) where {T} = T
 striptype(::Any) = nothing
 
 function showerror_ambiguous(io::IO, meth, f, args)
@@ -400,8 +425,14 @@ function showerror_ambiguous(io::IO, meth, f, args)
         i < length(p) && print(io, ", ")
     end
     print(io, ") is ambiguous. Candidates:")
+    sigfix = Any
     for m in meth
         print(io, "\n  ", m)
+        sigfix = typeintersect(m.sig, sigfix)
+    end
+    if isa(unwrap_unionall(sigfix), DataType) && sigfix <: Tuple
+        print(io, "\nPossible fix, define\n  ")
+        Base.show_tuple_as_call(io, :function,  sigfix)
     end
     nothing
 end
@@ -444,6 +475,9 @@ function show_method_candidates(io::IO, ex::MethodError, kwargs::Vector=Any[])
             buf = IOBuffer()
             tv = Any[]
             sig0 = method.sig
+            if Base.is_default_method(method)
+                continue
+            end
             while isa(sig0, UnionAll)
                 push!(tv, sig0.var)
                 sig0 = sig0.body
@@ -559,9 +593,6 @@ function show_method_candidates(io::IO, ex::MethodError, kwargs::Vector=Any[])
                 if ex.world < min_world(method)
                     print(buf, " (method too new to be called from this world context.)")
                 end
-                if ex.world > max_world(method)
-                    print(buf, " (method deleted before this world age.)")
-                end
                 # TODO: indicate if it's in the wrong world
                 push!(lines, (buf, right_matches))
             end
@@ -594,20 +625,20 @@ function show_trace_entry(io, frame, n; prefix = "")
 end
 
 # Contains file name and file number. Gets set when a backtrace
-# is shown. Used by the REPL to make it possible to open
-# the location of a stackframe in the edítor.
-global LAST_BACKTRACE_LINE_INFOS = Tuple{String, Int}[]
+# or methodlist is shown. Used by the REPL to make it possible to open
+# the location of a stackframe/method in the editor.
+global LAST_SHOWN_LINE_INFOS = Tuple{String, Int}[]
 
 function show_backtrace(io::IO, t::Vector)
     n_frames = 0
     frame_counter = 0
-    resize!(LAST_BACKTRACE_LINE_INFOS, 0)
+    resize!(LAST_SHOWN_LINE_INFOS, 0)
     process_backtrace((a,b) -> n_frames += 1, t)
     n_frames != 0 && print(io, "\nStacktrace:")
     process_entry = (last_frame, n) -> begin
         frame_counter += 1
         show_trace_entry(IOContext(io, :backtrace => true), last_frame, n, prefix = string(" [", frame_counter, "] "))
-        push!(LAST_BACKTRACE_LINE_INFOS, (string(last_frame.file), last_frame.line))
+        push!(LAST_SHOWN_LINE_INFOS, (string(last_frame.file), last_frame.line))
     end
     process_backtrace(process_entry, t)
 end
@@ -650,3 +681,11 @@ function process_backtrace(process_func::Function, t::Vector, limit::Int=typemax
         process_func(last_frame, n)
     end
 end
+
+"""
+Determines whether a method is the default method which is provided to all types from sysimg.jl.
+Such a method is usually undesirable to be displayed to the user in the REPL.
+"""
+function is_default_method(m::Method)
+    return m.module == Base && m.file == Symbol("sysimg.jl") && m.sig == Tuple{Type{T},Any} where T
+end
diff --git a/base/reshapedarray.jl b/base/reshapedarray.jl
index 58abec2e26c378..1c63d5b5349c2c 100644
--- a/base/reshapedarray.jl
+++ b/base/reshapedarray.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using  Base.MultiplicativeInverses: SignedMultiplicativeInverse
 
@@ -7,10 +7,10 @@ struct ReshapedArray{T,N,P<:AbstractArray,MI<:Tuple{Vararg{SignedMultiplicativeI
     dims::NTuple{N,Int}
     mi::MI
 end
-ReshapedArray{T,N}(parent::AbstractArray{T}, dims::NTuple{N,Int}, mi) = ReshapedArray{T,N,typeof(parent),typeof(mi)}(parent, dims, mi)
+ReshapedArray(parent::AbstractArray{T}, dims::NTuple{N,Int}, mi) where {T,N} = ReshapedArray{T,N,typeof(parent),typeof(mi)}(parent, dims, mi)
 
 # IndexLinear ReshapedArray
-ReshapedArrayLF{T,N,P<:AbstractArray} = ReshapedArray{T,N,P,Tuple{}}
+const ReshapedArrayLF{T,N,P<:AbstractArray} = ReshapedArray{T,N,P,Tuple{}}
 
 # Fast iteration on ReshapedArrays: use the parent iterator
 struct ReshapedArrayIterator{I,M}
@@ -18,7 +18,7 @@ struct ReshapedArrayIterator{I,M}
     mi::NTuple{M,SignedMultiplicativeInverse{Int}}
 end
 ReshapedArrayIterator(A::ReshapedArray) = _rs_iterator(parent(A), A.mi)
-function _rs_iterator{M}(P, mi::NTuple{M})
+function _rs_iterator(P, mi::NTuple{M}) where M
     iter = eachindex(P)
     ReshapedArrayIterator{typeof(iter),M}(iter, mi)
 end
@@ -37,15 +37,19 @@ end
 length(R::ReshapedArrayIterator) = length(R.iter)
 
 """
-    reshape(A, dims...)
-    reshape(A, dims)
+    reshape(A, dims...) -> R
+    reshape(A, dims) -> R
 
-Return an array with the same data as the given array, but with different dimensions.
+Return an array `R` with the same data as `A`, but with different
+dimension sizes or number of dimensions. The two arrays share the same
+underlying data, so that setting elements of `R` alters the values of
+`A` and vice versa.
 
-The new dimensions may be specified either as a list of arguments or as a shape
-tuple. At most one dimension may be specified with a `:`, in which case its
-length is computed such that its product with all the specified dimensions is
-equal to the length of the original array A.
+The new dimensions may be specified either as a list of arguments or
+as a shape tuple. At most one dimension may be specified with a `:`,
+in which case its length is computed such that its product with all
+the specified dimensions is equal to the length of the original array
+`A`. The total number of elements must not change.
 
 ```jldoctest
 julia> A = collect(1:16)
@@ -91,38 +95,44 @@ reshape(parent::AbstractArray, dims::Dims)        = _reshape(parent, dims)
 reshape(parent::AbstractArray, dims::Int...) = reshape(parent, dims)
 reshape(parent::AbstractArray, dims::Union{Int,Colon}...) = reshape(parent, dims)
 reshape(parent::AbstractArray, dims::Tuple{Vararg{Union{Int,Colon}}}) = _reshape(parent, _reshape_uncolon(parent, dims))
-# Recursively move dimensions to pre and post tuples, splitting on the Colon
-@inline _reshape_uncolon(A, dims) = _reshape_uncolon(A, (), nothing, (), dims)
-@inline _reshape_uncolon(A, pre, c::Void,  post, dims::Tuple{Any, Vararg{Any}}) =
-    _reshape_uncolon(A, (pre..., dims[1]), c, post, tail(dims))
-@inline _reshape_uncolon(A, pre, c::Void,  post, dims::Tuple{Colon, Vararg{Any}}) =
-    _reshape_uncolon(A, pre, dims[1], post, tail(dims))
-@inline _reshape_uncolon(A, pre, c::Colon, post, dims::Tuple{Any, Vararg{Any}}) =
-    _reshape_uncolon(A, pre, c, (post..., dims[1]), tail(dims))
-_reshape_uncolon(A, pre, c::Colon, post, dims::Tuple{Colon, Vararg{Any}}) =
-    throw(DimensionMismatch("new dimensions $((pre..., c, post..., dims...)) may only have at most one omitted dimension specified by Colon()"))
-@inline function _reshape_uncolon(A, pre, c::Colon, post, dims::Tuple{})
+@inline function _reshape_uncolon(A, dims)
+    @noinline throw1(dims) = throw(DimensionMismatch(string("new dimensions $(dims) ",
+        "may have at most one omitted dimension specified by `Colon()`")))
+    @noinline throw2(A, dims) = throw(DimensionMismatch(string("array size $(length(A)) ",
+        "must be divisible by the product of the new dimensions $dims")))
+    pre = _before_colon(dims...)
+    post = _after_colon(dims...)
+    any(d -> d isa Colon, post) && throw1(dims)
     sz, remainder = divrem(length(A), prod(pre)*prod(post))
-    remainder == 0 || _throw_reshape_colon_dimmismatch(A, pre, post)
+    remainder == 0 || throw2(A, dims)
     (pre..., sz, post...)
 end
-_throw_reshape_colon_dimmismatch(A, pre, post) =
-    throw(DimensionMismatch("array size $(length(A)) must be divisible by the product of the new dimensions $((pre..., :, post...))"))
+@inline _before_colon(dim::Any, tail...) =  (dim, _before_colon(tail...)...)
+@inline _before_colon(dim::Colon, tail...) = ()
+@inline _after_colon(dim::Any, tail...) =  _after_colon(tail...)
+@inline _after_colon(dim::Colon, tail...) = tail
 
-reshape{T,N}(parent::AbstractArray{T,N}, ndims::Type{Val{N}}) = parent
-function reshape{N}(parent::AbstractArray, ndims::Type{Val{N}})
-    reshape(parent, rdims((), indices(parent), Val{N}))
+reshape(parent::AbstractArray{T,N}, ndims::Val{N}) where {T,N} = parent
+function reshape(parent::AbstractArray, ndims::Val{N}) where N
+    reshape(parent, rdims(Val(N), indices(parent)))
 end
+
 # Move elements from inds to out until out reaches the desired
 # dimensionality N, either filling with OneTo(1) or collapsing the
 # product of trailing dims into the last element
-@pure rdims{N}(out::NTuple{N,Any}, inds::Tuple{}, ::Type{Val{N}}) = out
-@pure function rdims{N}(out::NTuple{N,Any}, inds::Tuple{Any, Vararg{Any}}, ::Type{Val{N}})
-    l = length(last(out)) * prod(map(length, inds))
-    (front(out)..., OneTo(l))
-end
-@pure rdims{N}(out::Tuple, inds::Tuple{}, ::Type{Val{N}}) = rdims((out..., OneTo(1)), (), Val{N})
-@pure rdims{N}(out::Tuple, inds::Tuple{Any, Vararg{Any}}, ::Type{Val{N}}) = rdims((out..., first(inds)), tail(inds), Val{N})
+rdims_trailing(l, inds...) = length(l) * rdims_trailing(inds...)
+rdims_trailing(l) = length(l)
+rdims(out::Val{N}, inds::Tuple) where {N} = rdims(ntuple(i -> OneTo(1), Val(N)), inds)
+rdims(out::Tuple{}, inds::Tuple{}) = () # N == 0, M == 0
+@noinline rdims(out::Tuple{}, inds::Tuple{Any}) = throw(ArgumentError("new dimensions cannot be empty")) # N == 0
+@noinline rdims(out::Tuple{}, inds::NTuple{M,Any}) where {M} = throw(ArgumentError("new dimensions cannot be empty")) # N == 0
+rdims(out::Tuple{Any}, inds::Tuple{}) = out # N == 1, M == 0
+rdims(out::NTuple{N,Any}, inds::Tuple{}) where {N} = out # N > 1, M == 0
+rdims(out::Tuple{Any}, inds::Tuple{Any}) = inds # N == 1, M == 1
+rdims(out::Tuple{Any}, inds::NTuple{M,Any}) where {M} = (OneTo(rdims_trailing(inds...)),) # N == 1, M > 1
+rdims(out::NTuple{N,Any}, inds::NTuple{N,Any}) where {N} = inds # N > 1, M == N
+rdims(out::NTuple{N,Any}, inds::NTuple{M,Any}) where {N,M} = (first(inds), rdims(tail(out), tail(inds))...) # N > 1, M > 1, M != N
+
 
 # _reshape on Array returns an Array
 _reshape(parent::Vector, dims::Dims{1}) = parent
@@ -132,23 +142,27 @@ _reshape(parent::Array, dims::Dims) = reshape(parent, dims)
 # When reshaping Vector->Vector, don't wrap with a ReshapedArray
 function _reshape(v::AbstractVector, dims::Dims{1})
     len = dims[1]
-    len == length(v) || throw(DimensionMismatch("parent has $(length(v)) elements, which is incompatible with length $len"))
+    len == length(v) || _throw_dmrs(n, "length", len)
     v
 end
 # General reshape
 function _reshape(parent::AbstractArray, dims::Dims)
     n = _length(parent)
-    prod(dims) == n || throw(DimensionMismatch("parent has $n elements, which is incompatible with size $dims"))
+    prod(dims) == n || _throw_dmrs(n, "size", dims)
     __reshape((parent, IndexStyle(parent)), dims)
 end
 
+@noinline function _throw_dmrs(n, str, dims)
+    throw(DimensionMismatch("parent has $n elements, which is incompatible with $str $dims"))
+end
+
 # Reshaping a ReshapedArray
 _reshape(v::ReshapedArray{<:Any,1}, dims::Dims{1}) = _reshape(v.parent, dims)
 _reshape(R::ReshapedArray, dims::Dims) = _reshape(R.parent, dims)
 
 function __reshape(p::Tuple{AbstractArray,IndexCartesian}, dims::Dims)
     parent = p[1]
-    strds = front(size_strides(parent))
+    strds = front(size_to_strides(size(parent)..., 1))
     strds1 = map(s->max(1,s), strds)  # for resizing empty arrays
     mi = map(SignedMultiplicativeInverse, strds1)
     ReshapedArray(parent, dims, reverse(mi))
@@ -159,23 +173,19 @@ function __reshape(p::Tuple{AbstractArray,IndexLinear}, dims::Dims)
     ReshapedArray(parent, dims, ())
 end
 
-@inline size_strides(A::AbstractArray) = tail(size_strides((1,), size(A)...))
-size_strides(out::Tuple) = out
-@inline size_strides(out, s, sz...) = size_strides((out..., out[end]*s), sz...)
-
 size(A::ReshapedArray) = A.dims
 similar(A::ReshapedArray, eltype::Type, dims::Dims) = similar(parent(A), eltype, dims)
 IndexStyle(::Type{<:ReshapedArrayLF}) = IndexLinear()
 parent(A::ReshapedArray) = A.parent
 parentindexes(A::ReshapedArray) = map(s->1:s, size(parent(A)))
-reinterpret{T}(::Type{T}, A::ReshapedArray, dims::Dims) = reinterpret(T, parent(A), dims)
+reinterpret(::Type{T}, A::ReshapedArray, dims::Dims) where {T} = reinterpret(T, parent(A), dims)
 
 @inline ind2sub_rs(::Tuple{}, i::Int) = i
-@inline ind2sub_rs(strds, i) = ind2sub_rs((), strds, i-1)
-@inline ind2sub_rs(out, ::Tuple{}, ind) = (ind+1, out...)
-@inline function ind2sub_rs(out, strds, ind)
+@inline ind2sub_rs(strds, i) = _ind2sub_rs(strds, i - 1)
+@inline _ind2sub_rs(::Tuple{}, ind) = (ind + 1,)
+@inline function _ind2sub_rs(strds, ind)
     d, r = divrem(ind, strds[1])
-    ind2sub_rs((d+1, out...), tail(strds), r)
+    (_ind2sub_rs(tail(strds), r)..., d + 1)
 end
 
 @inline function getindex(A::ReshapedArrayLF, index::Int)
@@ -183,7 +193,7 @@ end
     @inbounds ret = parent(A)[index]
     ret
 end
-@inline function getindex(A::ReshapedArray, indexes::Int...)
+@inline function getindex(A::ReshapedArray{T,N}, indexes::Vararg{Int,N}) where {T,N}
     @boundscheck checkbounds(A, indexes...)
     _unsafe_getindex(A, indexes...)
 end
@@ -193,21 +203,20 @@ end
     ret
 end
 
-@inline function _unsafe_getindex(A::ReshapedArray, indexes::Int...)
-    @inbounds ret = parent(A)[ind2sub_rs(A.mi, sub2ind(size(A), indexes...))...]
-    ret
-end
-@inline function _unsafe_getindex(A::ReshapedArrayLF, indexes::Int...)
-    @inbounds ret = parent(A)[sub2ind(size(A), indexes...)]
-    ret
+@inline function _unsafe_getindex(A::ReshapedArray{T,N}, indexes::Vararg{Int,N}) where {T,N}
+    i = sub2ind(size(A), indexes...)
+    I = ind2sub_rs(A.mi, i)
+    _unsafe_getindex_rs(parent(A), I)
 end
+_unsafe_getindex_rs(A, i::Integer) = (@inbounds ret = A[i]; ret)
+@inline _unsafe_getindex_rs(A, I) = (@inbounds ret = A[I...]; ret)
 
 @inline function setindex!(A::ReshapedArrayLF, val, index::Int)
     @boundscheck checkbounds(A, index)
     @inbounds parent(A)[index] = val
     val
 end
-@inline function setindex!(A::ReshapedArray, val, indexes::Int...)
+@inline function setindex!(A::ReshapedArray{T,N}, val, indexes::Vararg{Int,N}) where {T,N}
     @boundscheck checkbounds(A, indexes...)
     _unsafe_setindex!(A, val, indexes...)
 end
@@ -217,21 +226,17 @@ end
     val
 end
 
-@inline function _unsafe_setindex!(A::ReshapedArray, val, indexes::Int...)
+@inline function _unsafe_setindex!(A::ReshapedArray{T,N}, val, indexes::Vararg{Int,N}) where {T,N}
     @inbounds parent(A)[ind2sub_rs(A.mi, sub2ind(size(A), indexes...))...] = val
     val
 end
-@inline function _unsafe_setindex!(A::ReshapedArrayLF, val, indexes::Int...)
-    @inbounds parent(A)[sub2ind(size(A), indexes...)] = val
-    val
-end
 
 # helpful error message for a common failure case
-ReshapedRange{T,N,A<:Range} = ReshapedArray{T,N,A,Tuple{}}
+const ReshapedRange{T,N,A<:Range} = ReshapedArray{T,N,A,Tuple{}}
 setindex!(A::ReshapedRange, val, index::Int) = _rs_setindex!_err()
-setindex!(A::ReshapedRange, val, indexes::Int...) = _rs_setindex!_err()
+setindex!(A::ReshapedRange{T,N}, val, indexes::Vararg{Int,N}) where {T,N} = _rs_setindex!_err()
 setindex!(A::ReshapedRange, val, index::ReshapedIndex) = _rs_setindex!_err()
 
-_rs_setindex!_err() = error("indexed assignment fails for a reshaped range; consider calling collect")
+@noinline _rs_setindex!_err() = error("indexed assignment fails for a reshaped range; consider calling collect")
 
-unsafe_convert{T}(::Type{Ptr{T}}, a::ReshapedArray{T}) = unsafe_convert(Ptr{T}, parent(a))
+unsafe_convert(::Type{Ptr{T}}, a::ReshapedArray{T}) where {T} = unsafe_convert(Ptr{T}, parent(a))
diff --git a/base/rounding.jl b/base/rounding.jl
index 2c24beb512aad5..bcb9b6328ac15e 100644
--- a/base/rounding.jl
+++ b/base/rounding.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module Rounding
 
@@ -37,7 +37,7 @@ Currently supported rounding modes are:
 - [`RoundNearestTiesAway`](@ref)
 - [`RoundNearestTiesUp`](@ref)
 - [`RoundToZero`](@ref)
-- `RoundFromZero` (`BigFloat` only)
+- `RoundFromZero` ([`BigFloat`](@ref) only)
 - [`RoundUp`](@ref)
 - [`RoundDown`](@ref)
 """
@@ -118,9 +118,9 @@ arithmetic functions ([`+`](@ref), [`-`](@ref), [`*`](@ref),
 functions may give incorrect or invalid values when using rounding modes other than the
 default `RoundNearest`.
 
-Note that this may affect other types, for instance changing the rounding mode of `Float64`
-will change the rounding mode of `Float32`. See [`RoundingMode`](@ref) for
-available modes.
+Note that this may affect other types, for instance changing the rounding mode of
+[`Float64`](@ref) will change the rounding mode of [`Float32`](@ref).
+See [`RoundingMode`](@ref) for available modes.
 
 !!! warning
 
@@ -139,11 +139,11 @@ See [`RoundingMode`](@ref) for available modes.
 """
 :rounding
 
-setrounding_raw(::Type{<:Union{Float32,Float64}},i::Integer) = ccall(:fesetround, Int32, (Int32,), i)
+setrounding_raw(::Type{<:Union{Float32,Float64}}, i::Integer) = ccall(:fesetround, Int32, (Int32,), i)
 rounding_raw(::Type{<:Union{Float32,Float64}}) = ccall(:fegetround, Int32, ())
 
-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))
+setrounding(::Type{T}, r::RoundingMode) where {T<:Union{Float32,Float64}} = setrounding_raw(T,to_fenv(r))
+rounding(::Type{T}) where {T<:Union{Float32,Float64}} = from_fenv(rounding_raw(T))
 
 """
     setrounding(f::Function, T, mode)
@@ -180,7 +180,7 @@ See [`RoundingMode`](@ref) for available rounding modes.
                end
         1.2
 """
-function setrounding{T}(f::Function, ::Type{T}, rounding::RoundingMode)
+function setrounding(f::Function, ::Type{T}, rounding::RoundingMode) where T
     old_rounding_raw = rounding_raw(T)
     setrounding(T,rounding)
     try
@@ -199,18 +199,18 @@ end
 # Assumes conversion is performed by rounding to nearest value.
 
 # To avoid ambiguous dispatch with methods in mpfr.jl:
-(::Type{T}){T<:AbstractFloat}(x::Real,r::RoundingMode) = _convert_rounding(T,x,r)
+(::Type{T})(x::Real, r::RoundingMode) where {T<:AbstractFloat} = _convert_rounding(T,x,r)
 
-_convert_rounding{T<:AbstractFloat}(::Type{T},x::Real,r::RoundingMode{:Nearest}) = convert(T,x)
-function _convert_rounding{T<:AbstractFloat}(::Type{T},x::Real,r::RoundingMode{:Down})
+_convert_rounding(::Type{T}, x::Real, r::RoundingMode{:Nearest}) where {T<:AbstractFloat} = convert(T,x)
+function _convert_rounding(::Type{T}, x::Real, r::RoundingMode{:Down}) where T<:AbstractFloat
     y = convert(T,x)
     y > x ? prevfloat(y) : y
 end
-function _convert_rounding{T<:AbstractFloat}(::Type{T},x::Real,r::RoundingMode{:Up})
+function _convert_rounding(::Type{T}, x::Real, r::RoundingMode{:Up}) where T<:AbstractFloat
     y = convert(T,x)
     y < x ? nextfloat(y) : y
 end
-function _convert_rounding{T<:AbstractFloat}(::Type{T},x::Real,r::RoundingMode{:ToZero})
+function _convert_rounding(::Type{T}, x::Real, r::RoundingMode{:ToZero}) where T<:AbstractFloat
     y = convert(T,x)
     if x > 0.0
         y > x ? prevfloat(y) : y
diff --git a/base/serialize.jl b/base/serialize.jl
index b6008df568cccc..6a6847a850e90a 100644
--- a/base/serialize.jl
+++ b/base/serialize.jl
@@ -1,8 +1,8 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module Serializer
 
-import Base: GMP, Bottom, unsafe_convert, uncompressed_ast, datatype_pointerfree
+import Base: GMP, Bottom, unsafe_convert, uncompressed_ast
 import Core: svec
 using Base: ViewIndex, Slice, index_lengths, unwrap_unionall
 
@@ -12,7 +12,9 @@ mutable struct SerializationState{I<:IO} <: AbstractSerializer
     io::I
     counter::Int
     table::ObjectIdDict
-    SerializationState{I}(io::I) where I<:IO = new(io, 0, ObjectIdDict())
+    pending_refs::Vector{Int}
+    known_object_data::Dict{UInt64,Any}
+    SerializationState{I}(io::I) where I<:IO = new(io, 0, ObjectIdDict(), Int[], Dict{UInt64,Any}())
 end
 
 SerializationState(io::IO) = SerializationState{typeof(io)}(io)
@@ -21,72 +23,103 @@ SerializationState(io::IO) = SerializationState{typeof(io)}(io)
 
 # types AbstractSerializer and Serializer  # defined in dict.jl
 
+const n_int_literals = 33
+const n_reserved_slots = 12
+
 const TAGS = Any[
-    Symbol, Int8, UInt8, Int16, UInt16, Int32, UInt32,
-    Int64, UInt64, Int128, UInt128, Float32, Float64, Char, Ptr,
-    DataType, Union, TypeName, Tuple, Array, Expr,
-    #LongSymbol, LongTuple, LongExpr,
-    Symbol, Tuple, Expr,  # dummy entries, intentionally shadowed by earlier ones
-    LineNumberNode, Slot, LabelNode, GotoNode,
-    QuoteNode, CodeInfo, TypeVar, Core.Box, Core.MethodInstance,
-    Module, #=UndefRefTag=#Symbol, Task, String, Float16,
-    SimpleVector, #=BackrefTag=#Symbol, Method, GlobalRef, UnionAll,
-
-    (), Bool, Any, :Any, Bottom, Core.BottomType, :reserved22, Type,
-    :Array, :TypeVar, :Box,
-    :lambda, :body, :return, :call, Symbol("::"),
-    :(=), :null, :gotoifnot, :A, :B, :C, :M, :N, :T, :S, :X, :Y,
-    :a, :b, :c, :d, :e, :f, :g, :h, :i, :j, :k, :l, :m, :n, :o,
-    :p, :q, :r, :s, :t, :u, :v, :w, :x, :y, :z,
-    :add_int, :sub_int, :mul_int, :add_float, :sub_float,
-    :mul_float, :bitcast, :box,
-    :eq_int, :slt_int, :sle_int, :ne_int,
-    :arrayset, :arrayref,
-    :Core, :Base, svec(), Tuple{},
-    :reserved17, :reserved18, :reserved19, :reserved20,
-    false, true, nothing, 0, 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
+    Symbol, Int8, UInt8, Int16, UInt16, Int32, UInt32, Int64, UInt64, Int128, UInt128,
+    Float16, Float32, Float64, Char, DataType, Union, UnionAll, TypeName, Tuple,
+    Array, Expr, LineNumberNode, LabelNode, GotoNode, QuoteNode, CodeInfo, TypeVar,
+    Core.Box, Core.MethodInstance, Module, Task, String, SimpleVector, Method,
+    GlobalRef, SlotNumber, TypedSlot, NewvarNode, SSAValue,
+
+    # dummy entries for tags that don't correspond directly to types
+    Symbol, # UNDEFREF_TAG
+    Symbol, # BACKREF_TAG
+    Symbol, # LONGBACKREF_TAG
+    Symbol, # SHORTBACKREF_TAG
+    Symbol, # LONGTUPLE_TAG
+    Symbol, # LONGSYMBOL_TAG
+    Symbol, # LONGEXPR_TAG
+    Symbol, # LONGSTRING_TAG
+    Symbol, # SHORTINT64_TAG
+    Symbol, # FULL_DATATYPE_TAG
+    Symbol, # WRAPPER_DATATYPE_TAG
+    Symbol, # OBJECT_TAG
+    Symbol, # REF_OBJECT_TAG
+    Symbol, # FULL_GLOBALREF_TAG
+
+    (), Bool, Any, Bottom, Core.TypeofBottom, Type, svec(), Tuple{}, false, true, nothing,
+    :Any, :Array, :TypeVar, :Box, :Tuple, :Ptr, :return, :call, Symbol("::"), :Function,
+    :(=), :(==), :(===), :gotoifnot, :A, :B, :C, :M, :N, :T, :S, :X, :Y, :a, :b, :c, :d, :e, :f,
+    :g, :h, :i, :j, :k, :l, :m, :n, :o, :p, :q, :r, :s, :t, :u, :v, :w, :x, :y, :z, :add_int,
+    :sub_int, :mul_int, :add_float, :sub_float, :new, :mul_float, :bitcast, :start, :done, :next,
+    :indexed_next, :getfield, :meta, :eq_int, :slt_int, :sle_int, :ne_int, :push_loc, :pop_loc,
+    :pop, :arrayset, :arrayref, :apply_type, :inbounds, :getindex, :setindex!, :Core, :!, :+,
+    :Base, :static_parameter, :convert, :colon, Symbol("#self#"), Symbol("#temp#"), :tuple,
+
+    fill(:_reserved_, n_reserved_slots)...,
+
+    (Int32(0):Int32(n_int_literals-1))...,
+    (Int64(0):Int64(n_int_literals-1))...
 ]
 
-const ser_version = 5 # do not make changes without bumping the version #!
+@assert length(TAGS) <= 255
+
+const ser_version = 6 # do not make changes without bumping the version #!
 
 const NTAGS = length(TAGS)
 
-function sertag(v::ANY)
+function sertag(@nospecialize(v))
     ptr = pointer_from_objref(v)
     ptags = convert(Ptr{Ptr{Void}}, pointer(TAGS))
-    @inbounds for i in 1:NTAGS
-        ptr == unsafe_load(ptags,i) && return (i+1)%Int32
+    # note: constant ints & reserved slots never returned here
+    @inbounds for i in 1:(NTAGS-(n_reserved_slots+2*n_int_literals))
+        ptr == unsafe_load(ptags,i) && return i%Int32
     end
     return Int32(-1)
 end
-desertag(i::Int32) = TAGS[i-1]
+desertag(i::Int32) = TAGS[i]
 
 # tags >= this just represent themselves, their whole representation is 1 byte
 const VALUE_TAGS = sertag(())
-const ZERO_TAG = sertag(0)
+const ZERO32_TAG = Int32(NTAGS-(2*n_int_literals-1))
+const ZERO64_TAG = Int64(NTAGS-(n_int_literals-1))
 const TRUE_TAG = sertag(true)
 const FALSE_TAG = sertag(false)
 const EMPTYTUPLE_TAG = sertag(())
 const TUPLE_TAG = sertag(Tuple)
-const LONGTUPLE_TAG = Int32(sertag(Expr)+2)
 const SIMPLEVECTOR_TAG = sertag(SimpleVector)
 const SYMBOL_TAG = sertag(Symbol)
-const LONGSYMBOL_TAG = Int32(sertag(Expr)+1)
 const ARRAY_TAG = sertag(Array)
-const UNDEFREF_TAG = Int32(sertag(Module)+1)
-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 METHODINSTANCE_TAG = sertag(Core.MethodInstance)
 const METHOD_TAG = sertag(Method)
 const TASK_TAG = sertag(Task)
 const DATATYPE_TAG = sertag(DataType)
 const TYPENAME_TAG = sertag(TypeName)
-const INT_TAG = sertag(Int)
+const INT32_TAG = sertag(Int32)
+const INT64_TAG = sertag(Int64)
 const GLOBALREF_TAG = sertag(GlobalRef)
+const BOTTOM_TAG = sertag(Bottom)
+const UNIONALL_TAG = sertag(UnionAll)
+const STRING_TAG = sertag(String)
+const o0 = sertag(SSAValue)
+const UNDEFREF_TAG         = Int32(o0+1)
+const BACKREF_TAG          = Int32(o0+2)
+const LONGBACKREF_TAG      = Int32(o0+3)
+const SHORTBACKREF_TAG     = Int32(o0+4)
+const LONGTUPLE_TAG        = Int32(o0+5)
+const LONGSYMBOL_TAG       = Int32(o0+6)
+const LONGEXPR_TAG         = Int32(o0+7)
+const LONGSTRING_TAG       = Int32(o0+8)
+const SHORTINT64_TAG       = Int32(o0+9)
+const FULL_DATATYPE_TAG    = Int32(o0+10)
+const WRAPPER_DATATYPE_TAG = Int32(o0+11)
+const OBJECT_TAG           = Int32(o0+12)
+const REF_OBJECT_TAG       = Int32(o0+13)
+const FULL_GLOBALREF_TAG   = Int32(o0+14)
 
 writetag(s::IO, tag) = write(s, UInt8(tag))
 
@@ -97,30 +130,35 @@ end
 
 # cycle handling
 function serialize_cycle(s::AbstractSerializer, x)
-    if !isimmutable(x) && !datatype_pointerfree(typeof(x))
-        offs = get(s.table, x, -1)
-        if offs != -1
+    offs = get(s.table, x, -1)::Int
+    if offs != -1
+        if offs <= typemax(UInt16)
+            writetag(s.io, SHORTBACKREF_TAG)
+            write(s.io, UInt16(offs))
+        elseif offs <= typemax(Int32)
             writetag(s.io, BACKREF_TAG)
-            write(s.io, Int(offs))
-            return true
+            write(s.io, Int32(offs))
+        else
+            writetag(s.io, LONGBACKREF_TAG)
+            write(s.io, Int64(offs))
         end
-        s.table[x] = s.counter
-        s.counter += 1
+        return true
     end
+    s.table[x] = s.counter
+    s.counter += 1
     return false
 end
 
-function serialize_cycle_header(s::AbstractSerializer, x::ANY)
-    t = typeof(x)
-    t.mutable && haskey(s.table, x) && serialize_cycle(s, x) && return true
-    serialize_type(s, t)
-    t.mutable && serialize_cycle(s, x)
+function serialize_cycle_header(s::AbstractSerializer, @nospecialize(x))
+    serialize_cycle(s, x) && return true
+    serialize_type(s, typeof(x), true)
     return false
 end
 
 function reset_state(s::AbstractSerializer)
     s.counter = 0
-    s.table = ObjectIdDict()
+    empty!(s.table)
+    empty!(s.pending_refs)
     s
 end
 
@@ -159,20 +197,23 @@ function serialize(s::AbstractSerializer, x::Symbol)
         return write_as_tag(s.io, tag)
     end
     pname = unsafe_convert(Ptr{UInt8}, x)
-    ln = Int(ccall(:strlen, Csize_t, (Cstring,), pname))
-    if ln <= 255
+    len = Int(ccall(:strlen, Csize_t, (Cstring,), pname))
+    if len > 7
+        serialize_cycle(s, x) && return
+    end
+    if len <= 255
         writetag(s.io, SYMBOL_TAG)
-        write(s.io, UInt8(ln))
+        write(s.io, UInt8(len))
     else
         writetag(s.io, LONGSYMBOL_TAG)
-        write(s.io, Int32(ln))
+        write(s.io, Int32(len))
     end
-    unsafe_write(s.io, pname, ln)
+    unsafe_write(s.io, pname, len)
 end
 
 function serialize_array_data(s::IO, a)
-    elty = eltype(a)
-    if elty === Bool && !isempty(a)
+    isempty(a) && return 0
+    if eltype(a) === Bool
         last = a[1]
         count = 1
         for i = 2:length(a)
@@ -191,26 +232,12 @@ function serialize_array_data(s::IO, a)
 end
 
 function serialize(s::AbstractSerializer, a::Array)
+    serialize_cycle(s, a) && return
     elty = eltype(a)
-    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
@@ -219,7 +246,8 @@ function serialize(s::AbstractSerializer, a::Array)
     if isbits(elty)
         serialize_array_data(s.io, a)
     else
-        for i in eachindex(a)
+        sizehint!(s.table, div(length(a),4))  # prepare for lots of pointers
+        @inbounds for i in eachindex(a)
             if isassigned(a, i)
                 serialize(s, a[i])
             else
@@ -229,12 +257,12 @@ function serialize(s::AbstractSerializer, a::Array)
     end
 end
 
-function serialize{T,N,A<:Array}(s::AbstractSerializer, a::SubArray{T,N,A})
+function serialize(s::AbstractSerializer, a::SubArray{T,N,A}) where {T,N,A<:Array}
     b = trimmedsubarray(a)
     serialize_any(s, b)
 end
 
-function trimmedsubarray{T,N,A<:Array}(V::SubArray{T,N,A})
+function trimmedsubarray(V::SubArray{T,N,A}) where {T,N,A<:Array}
     dest = Array{eltype(V)}(trimmedsize(V))
     copy!(dest, V)
     _trimmedsubarray(dest, V, (), V.indexes...)
@@ -242,7 +270,7 @@ end
 
 trimmedsize(V) = index_lengths(V.indexes...)
 
-function _trimmedsubarray{T,N,P,I,LD}(A, V::SubArray{T,N,P,I,LD}, newindexes)
+function _trimmedsubarray(A, V::SubArray{T,N,P,I,LD}, newindexes) where {T,N,P,I,LD}
     LD && return SubArray{T,N,P,I,LD}(A, newindexes, Base.compute_offset1(A, 1, newindexes), 1)
     SubArray{T,N,P,I,LD}(A, newindexes, 0, 0)
 end
@@ -254,12 +282,18 @@ trimmedindex(P, d, i::Slice) = i
 trimmedindex(P, d, i::AbstractArray) = oftype(i, reshape(linearindices(i), indices(i)))
 
 function serialize(s::AbstractSerializer, ss::String)
-    serialize_type(s, String)
-    write(s.io, sizeof(ss))
+    len = sizeof(ss)
+    if len <= 255
+        writetag(s.io, STRING_TAG)
+        write(s.io, UInt8(len))
+    else
+        writetag(s.io, LONGSTRING_TAG)
+        write(s.io, Int64(len))
+    end
     write(s.io, ss)
 end
 
-function serialize{T<:AbstractString}(s::AbstractSerializer, ss::SubString{T})
+function serialize(s::AbstractSerializer, ss::SubString{T}) where T<:AbstractString
     # avoid saving a copy of the parent string, keeping the type of ss
     serialize_any(s, convert(SubString{T}, convert(T,ss)))
 end
@@ -299,10 +333,10 @@ function serialize(s::AbstractSerializer, ex::Expr)
     end
 end
 
-function serialize(s::AbstractSerializer, t::Dict)
-    serialize_cycle_header(s, t) && return
-    write(s.io, Int32(length(t)))
-    for (k,v) in t
+function serialize(s::AbstractSerializer, d::Dict)
+    serialize_cycle_header(s, d) && return
+    write(s.io, Int32(length(d)))
+    for (k,v) in d
         serialize(s, k)
         serialize(s, v)
     end
@@ -324,20 +358,33 @@ end
 
 # 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)
+const obj_number_salt = Ref(0)
+function object_number(@nospecialize(l))
     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 = obj_number_salt+(UInt64(myid())<<44)
-    obj_number_salt += 1
+    ln = obj_number_salt[]+(UInt64(myid())<<44)
+    obj_number_salt[] += 1
     object_numbers[l] = ln
     return ln::UInt64
 end
 
+lookup_object_number(s::AbstractSerializer, n::UInt64) = nothing
+
+remember_object(s::AbstractSerializer, @nospecialize(o), n::UInt64) = nothing
+
+function lookup_object_number(s::SerializationState, n::UInt64)
+    return get(s.known_object_data, n, nothing)
+end
+
+function remember_object(s::SerializationState, @nospecialize(o), n::UInt64)
+    s.known_object_data[n] = o
+    return nothing
+end
+
 function serialize(s::AbstractSerializer, meth::Method)
     serialize_cycle(s, meth) && return
     writetag(s.io, METHOD_TAG)
@@ -351,14 +398,22 @@ function serialize(s::AbstractSerializer, meth::Method)
     serialize(s, meth.ambig)
     serialize(s, meth.nargs)
     serialize(s, meth.isva)
-    serialize(s, meth.isstaged)
-    serialize(s, uncompressed_ast(meth, meth.source))
+    if isdefined(meth, :source)
+        serialize(s, uncompressed_ast(meth, meth.source))
+    else
+        serialize(s, nothing)
+    end
+    if isdefined(meth, :generator)
+        serialize(s, uncompressed_ast(meth, meth.generator.inferred))
+    else
+        serialize(s, nothing)
+    end
     nothing
 end
 
 function serialize(s::AbstractSerializer, linfo::Core.MethodInstance)
     serialize_cycle(s, linfo) && return
-    isdefined(linfo, :def) && error("can only serialize toplevel MethodInstance objects")
+    isa(linfo.def, Module) || error("can only serialize toplevel MethodInstance objects")
     writetag(s.io, METHODINSTANCE_TAG)
     serialize(s, linfo.inferred)
     if isdefined(linfo, :inferred_const)
@@ -369,6 +424,8 @@ function serialize(s::AbstractSerializer, linfo::Core.MethodInstance)
     serialize(s, linfo.sparam_vals)
     serialize(s, linfo.rettype)
     serialize(s, linfo.specTypes)
+    serialize(s, linfo.def)
+    nothing
 end
 
 function serialize(s::AbstractSerializer, t::Task)
@@ -388,24 +445,24 @@ function serialize(s::AbstractSerializer, t::Task)
 end
 
 function serialize(s::AbstractSerializer, g::GlobalRef)
-    writetag(s.io, GLOBALREF_TAG)
-    if g.mod === Main && isdefined(g.mod, g.name) && isconst(g.mod, g.name)
+    if (g.mod === __deserialized_types__ ) ||
+        (g.mod === Main && isdefined(g.mod, g.name) && isconst(g.mod, g.name))
+
         v = getfield(g.mod, g.name)
         unw = unwrap_unionall(v)
         if isa(unw,DataType) && v === unw.name.wrapper && should_send_whole_type(s, unw)
             # handle references to types in Main by sending the whole type.
             # needed to be able to send nested functions (#15451).
-            write(s.io, UInt8(1))
+            writetag(s.io, FULL_GLOBALREF_TAG)
             serialize(s, v)
             return
         end
     end
-    write(s.io, UInt8(0))
+    writetag(s.io, GLOBALREF_TAG)
     serialize(s, g.mod)
     serialize(s, g.name)
 end
 
-
 function serialize(s::AbstractSerializer, t::TypeName)
     serialize_cycle(s, t) && return
     writetag(s.io, TYPENAME_TAG)
@@ -459,30 +516,33 @@ function should_send_whole_type(s, t::DataType)
     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::DataType, type_itself::Bool)
+function serialize_type_data(s, t::DataType)
     whole = should_send_whole_type(s, t)
-    form = type_itself ? UInt8(0) : UInt8(1)
-    if whole
-        form |= UInt8(2)
+    iswrapper = (t === unwrap_unionall(t.name.wrapper))
+    if whole && iswrapper
+        writetag(s.io, WRAPPER_DATATYPE_TAG)
+        serialize(s, t.name)
+        return
     end
-    writetag(s.io, DATATYPE_TAG)
-    write(s.io, form)
+    serialize_cycle(s, t) && return
     if whole
+        writetag(s.io, FULL_DATATYPE_TAG)
         serialize(s, t.name)
     else
+        writetag(s.io, DATATYPE_TAG)
         tname = t.name.name
         serialize(s, tname)
         mod = t.name.module
         serialize(s, mod)
     end
     if !isempty(t.parameters)
-        if (whole ? (t === unwrap_unionall(t.name.wrapper)) :
-                    (isdefined(mod,tname) && t === unwrap_unionall(getfield(mod,tname))))
-            serialize(s, svec())
+        if iswrapper
+            write(s.io, Int32(0))
         else
-            serialize(s, t.parameters)
+            write(s.io, Int32(length(t.parameters)))
+            for p in t.parameters
+                serialize(s, p)
+            end
         end
     end
 end
@@ -497,38 +557,76 @@ function serialize(s::AbstractSerializer, t::DataType)
         # only type with this property. issue #15849
         return write_as_tag(s.io, TUPLE_TAG)
     end
-    serialize_type_data(s, t, true)
+    serialize_type_data(s, t)
 end
 
-function serialize_type(s::AbstractSerializer, t::DataType)
+function serialize_type(s::AbstractSerializer, t::DataType, ref::Bool = false)
     tag = sertag(t)
     tag > 0 && return writetag(s.io, tag)
-    serialize_type_data(s, t, false)
+    writetag(s.io, ref ? REF_OBJECT_TAG : OBJECT_TAG)
+    serialize_type_data(s, t)
 end
 
-function serialize(s::AbstractSerializer, n::Int)
-    if 0 <= n <= 32
-        write(s.io, UInt8(ZERO_TAG+n))
-        return
+function serialize(s::AbstractSerializer, n::Int32)
+    if 0 <= n <= (n_int_literals-1)
+        write(s.io, UInt8(ZERO32_TAG+n))
+    else
+        writetag(s.io, INT32_TAG)
+        write(s.io, n)
+    end
+end
+
+function serialize(s::AbstractSerializer, n::Int64)
+    if 0 <= n <= (n_int_literals-1)
+        write(s.io, UInt8(ZERO64_TAG+n))
+    elseif typemin(Int32) <= n <= typemax(Int32)
+        writetag(s.io, SHORTINT64_TAG)
+        write(s.io, Int32(n))
+    else
+        writetag(s.io, INT64_TAG)
+        write(s.io, n)
+    end
+end
+
+serialize(s::AbstractSerializer, ::Type{Bottom}) = write_as_tag(s.io, BOTTOM_TAG)
+
+function serialize(s::AbstractSerializer, u::UnionAll)
+    writetag(s.io, UNIONALL_TAG)
+    n = 0; t = u
+    while isa(t, UnionAll)
+        t = t.body
+        n += 1
+    end
+    if isa(t, DataType) && t === unwrap_unionall(t.name.wrapper)
+        write(s.io, UInt8(1))
+        write(s.io, Int16(n))
+        serialize(s, t)
+    else
+        write(s.io, UInt8(0))
+        serialize(s, u.var)
+        serialize(s, u.body)
     end
-    writetag(s.io, INT_TAG)
-    write(s.io, n)
 end
 
-serialize(s::AbstractSerializer, x::ANY) = serialize_any(s, x)
+serialize(s::AbstractSerializer, @nospecialize(x)) = serialize_any(s, x)
 
-function serialize_any(s::AbstractSerializer, x::ANY)
+function serialize_any(s::AbstractSerializer, @nospecialize(x))
     tag = sertag(x)
     if tag > 0
         return write_as_tag(s.io, tag)
     end
     t = typeof(x)::DataType
-    nf = nfields(t)
+    nf = nfields(x)
     if nf == 0 && t.size > 0
         serialize_type(s, t)
         write(s.io, x)
     else
-        serialize_cycle_header(s, x) && return
+        if t.mutable && nf > 0
+            serialize_cycle(s, x) && return
+            serialize_type(s, t, true)
+        else
+            serialize_type(s, t, false)
+        end
         for i in 1:nf
             if isdefined(x, i)
                 serialize(s, getfield(x, i))
@@ -549,11 +647,20 @@ function deserialize(s::AbstractSerializer)
     handle_deserialize(s, Int32(read(s.io, UInt8)::UInt8))
 end
 
-function deserialize_cycle(s::AbstractSerializer, x::ANY)
-    if !isimmutable(x) && !datatype_pointerfree(typeof(x))
-        s.table[s.counter] = x
-        s.counter += 1
-    end
+function deserialize_cycle(s::AbstractSerializer, @nospecialize(x))
+    slot = pop!(s.pending_refs)
+    s.table[slot] = x
+    nothing
+end
+
+# optimized version of:
+#     slot = s.counter; s.counter += 1
+#     push!(s.pending_refs, slot)
+#     slot = pop!(s.pending_refs)
+#     s.table[slot] = x
+function resolve_ref_immediately(s::AbstractSerializer, @nospecialize(x))
+    s.table[s.counter] = x
+    s.counter += 1
     nothing
 end
 
@@ -568,35 +675,85 @@ function handle_deserialize(s::AbstractSerializer, b::Int32)
         return desertag(b)
     elseif b == TUPLE_TAG
         return deserialize_tuple(s, Int(read(s.io, UInt8)::UInt8))
-    elseif b == LONGTUPLE_TAG
-        return deserialize_tuple(s, Int(read(s.io, Int32)::Int32))
+    elseif b == SHORTBACKREF_TAG
+        id = read(s.io, UInt16)::UInt16
+        return s.table[Int(id)]
     elseif b == BACKREF_TAG
-        id = read(s.io, Int)::Int
-        return s.table[id]
+        id = read(s.io, Int32)::Int32
+        return s.table[Int(id)]
     elseif b == ARRAY_TAG
         return deserialize_array(s)
     elseif b == DATATYPE_TAG
-        return deserialize_datatype(s)
+        return deserialize_datatype(s, false)
+    elseif b == FULL_DATATYPE_TAG
+        return deserialize_datatype(s, true)
+    elseif b == WRAPPER_DATATYPE_TAG
+        tname = deserialize(s)::TypeName
+        return unwrap_unionall(tname.wrapper)
+    elseif b == OBJECT_TAG
+        t = deserialize(s)
+        return deserialize(s, t)
+    elseif b == REF_OBJECT_TAG
+        slot = s.counter; s.counter += 1
+        push!(s.pending_refs, slot)
+        t = deserialize(s)
+        return deserialize(s, t)
     elseif b == SYMBOL_TAG
-        return Symbol(read(s.io, UInt8, Int(read(s.io, UInt8)::UInt8)))
-    elseif b == LONGSYMBOL_TAG
-        return Symbol(read(s.io, UInt8, Int(read(s.io, Int32)::Int32)))
+        return deserialize_symbol(s, Int(read(s.io, UInt8)::UInt8))
+    elseif b == SHORTINT64_TAG
+        return Int64(read(s.io, Int32)::Int32)
     elseif b == EXPR_TAG
         return deserialize_expr(s, Int(read(s.io, UInt8)::UInt8))
+    elseif b == MODULE_TAG
+        return deserialize_module(s)
+    elseif b == STRING_TAG
+        return deserialize_string(s, Int(read(s.io, UInt8)::UInt8))
+    elseif b == LONGSTRING_TAG
+        return deserialize_string(s, Int(read(s.io, Int64)::Int64))
+    elseif b == SIMPLEVECTOR_TAG
+        return deserialize_svec(s)
+    elseif b == GLOBALREF_TAG
+        return GlobalRef(deserialize(s)::Module, deserialize(s)::Symbol)
+    elseif b == FULL_GLOBALREF_TAG
+        ty = deserialize(s)
+        tn = unwrap_unionall(ty).name
+        return GlobalRef(tn.module, tn.name)
+    elseif b == LONGTUPLE_TAG
+        return deserialize_tuple(s, Int(read(s.io, Int32)::Int32))
     elseif b == LONGEXPR_TAG
         return deserialize_expr(s, Int(read(s.io, Int32)::Int32))
+    elseif b == LONGBACKREF_TAG
+        id = read(s.io, Int64)::Int64
+        return s.table[Int(id)]
+    elseif b == LONGSYMBOL_TAG
+        return deserialize_symbol(s, Int(read(s.io, Int32)::Int32))
+    end
+    t = desertag(b)
+    if t.mutable && length(t.types) > 0  # manual specialization of fieldcount
+        slot = s.counter; s.counter += 1
+        push!(s.pending_refs, slot)
     end
-    return deserialize(s, desertag(b))
+    return deserialize(s, t)
+end
+
+function deserialize_symbol(s::AbstractSerializer, len::Int)
+    str = Base._string_n(len)
+    unsafe_read(s.io, pointer(str), len)
+    sym = Symbol(str)
+    if len > 7
+        resolve_ref_immediately(s, sym)
+    end
+    return sym
 end
 
 deserialize_tuple(s::AbstractSerializer, len) = ntuple(i->deserialize(s), len)
 
-function deserialize(s::AbstractSerializer, ::Type{SimpleVector})
+function deserialize_svec(s::AbstractSerializer)
     n = read(s.io, Int32)
     svec(Any[ deserialize(s) for i=1:n ]...)
 end
 
-function deserialize(s::AbstractSerializer, ::Type{Module})
+function deserialize_module(s::AbstractSerializer)
     path = deserialize(s)
     m = Main
     if isa(path,Tuple) && path !== ()
@@ -614,15 +771,14 @@ function deserialize(s::AbstractSerializer, ::Type{Module})
     m
 end
 
-const known_object_data = Dict()
-
 function deserialize(s::AbstractSerializer, ::Type{Method})
     lnumber = read(s.io, UInt64)
-    if haskey(known_object_data, lnumber)
-        meth = known_object_data[lnumber]::Method
+    meth = lookup_object_number(s, lnumber)
+    if meth !== nothing
+        meth = meth::Method
         makenew = false
     else
-        meth = ccall(:jl_new_method_uninit, Ref{Method}, ())
+        meth = ccall(:jl_new_method_uninit, Ref{Method}, (Any,), Main)
         makenew = true
     end
     deserialize_cycle(s, meth)
@@ -635,8 +791,8 @@ function deserialize(s::AbstractSerializer, ::Type{Method})
     ambig = deserialize(s)::Union{Array{Any,1}, Void}
     nargs = deserialize(s)::Int32
     isva = deserialize(s)::Bool
-    isstaged = deserialize(s)::Bool
-    template = deserialize(s)::CodeInfo
+    template = deserialize(s)
+    generator = deserialize(s)
     if makenew
         meth.module = mod
         meth.name = name
@@ -645,22 +801,25 @@ function deserialize(s::AbstractSerializer, ::Type{Method})
         meth.sig = sig
         meth.sparam_syms = sparam_syms
         meth.ambig = ambig
-        meth.isstaged = isstaged
         meth.nargs = nargs
         meth.isva = isva
         # TODO: compress template
-        meth.source = template
-        if isstaged
+        if template !== nothing
+            meth.source = template
+            meth.pure = template.pure
+        end
+        if generator !== nothing
             linfo = ccall(:jl_new_method_instance_uninit, Ref{Core.MethodInstance}, ())
             linfo.specTypes = Tuple
-            linfo.inferred = template
+            linfo.inferred = generator
+            linfo.def = meth
             meth.generator = linfo
         end
         ftype = ccall(:jl_first_argument_datatype, Any, (Any,), sig)::DataType
         if isdefined(ftype.name, :mt) && nothing === ccall(:jl_methtable_lookup, Any, (Any, Any, UInt), ftype.name.mt, sig, typemax(UInt))
             ccall(:jl_method_table_insert, Void, (Any, Any, Ptr{Void}), ftype.name.mt, meth, C_NULL)
         end
-        known_object_data[lnumber] = meth
+        remember_object(s, meth, lnumber)
     end
     return meth
 end
@@ -676,10 +835,12 @@ function deserialize(s::AbstractSerializer, ::Type{Core.MethodInstance})
     linfo.sparam_vals = deserialize(s)::SimpleVector
     linfo.rettype = deserialize(s)
     linfo.specTypes = deserialize(s)
+    linfo.def = deserialize(s)::Module
     return linfo
 end
 
 function deserialize_array(s::AbstractSerializer)
+    slot = s.counter; s.counter += 1
     d1 = deserialize(s)
     if isa(d1, Type)
         elty = d1
@@ -690,6 +851,7 @@ function deserialize_array(s::AbstractSerializer)
     if isa(d1, Integer)
         if elty !== Bool && isbits(elty)
             a = Array{elty, 1}(d1)
+            s.table[slot] = a
             return read!(s.io, a)
         end
         dims = (Int(d1),)
@@ -712,53 +874,43 @@ function deserialize_array(s::AbstractSerializer)
                 end
             end
         else
-            A = read(s.io, elty, dims)
+            A = read!(s.io, Array{elty}(dims))
         end
+        s.table[slot] = A
         return A
     end
     A = Array{elty, length(dims)}(dims)
-    deserialize_cycle(s, A)
+    s.table[slot] = A
+    sizehint!(s.table, s.counter + div(length(A),4))
     for i = eachindex(A)
         tag = Int32(read(s.io, UInt8)::UInt8)
         if tag != UNDEFREF_TAG
-            A[i] = handle_deserialize(s, tag)
+            @inbounds A[i] = handle_deserialize(s, tag)
         end
     end
     return A
 end
 
 function deserialize_expr(s::AbstractSerializer, len)
-    hd = deserialize(s)::Symbol
-    e = Expr(hd)
-    deserialize_cycle(s, e)
+    e = Expr(:temp)
+    resolve_ref_immediately(s, e)
+    e.head = deserialize(s)::Symbol
     ty = deserialize(s)
-    e.args = Any[ deserialize(s) for i=1:len ]
+    e.args = Any[ deserialize(s) for i = 1:len ]
     e.typ = ty
     e
 end
 
-function deserialize(s::AbstractSerializer, ::Type{GlobalRef})
-    kind = read(s.io, UInt8)
-    if kind == 0
-        return GlobalRef(deserialize(s)::Module, deserialize(s)::Symbol)
-    else
-        ty = deserialize(s)
-        return GlobalRef(ty.name.module, ty.name.name)
-    end
-end
-
 module __deserialized_types__ end
 
 function deserialize(s::AbstractSerializer, ::Type{TypeName})
-    # the deserialize_cycle call can be delayed, since neither
-    # Symbol nor Module will use the backref table
     number = read(s.io, UInt64)
     return deserialize_typename(s, number)
 end
 
 function deserialize_typename(s::AbstractSerializer, number)
     name = deserialize(s)::Symbol
-    tn = get(known_object_data, number, nothing)
+    tn = lookup_object_number(s, number)
     if tn !== nothing
         makenew = false
     else
@@ -767,12 +919,8 @@ function deserialize_typename(s::AbstractSerializer, number)
         tn = ccall(:jl_new_typename_in, Ref{TypeName}, (Any, Any),
                    tn_name, __deserialized_types__)
         makenew = true
-        known_object_data[number] = tn
-    end
-    if !haskey(object_numbers, tn)
-        # set up reverse mapping for serialize
-        object_numbers[tn] = number
     end
+    remember_object(s, tn, number)
     deserialize_cycle(s, tn)
 
     names = deserialize(s)::SimpleVector
@@ -789,8 +937,8 @@ function deserialize_typename(s::AbstractSerializer, number)
         # TODO: there's an unhanded cycle in the dependency graph at this point:
         # while deserializing super and/or types, we may have encountered
         # tn.wrapper and throw UndefRefException before we get to this point
-        ndt = ccall(:jl_new_datatype, Any, (Any, Any, Any, Any, Any, Cint, Cint, Cint),
-                    tn, super, parameters, names, types,
+        ndt = ccall(:jl_new_datatype, Any, (Any, Any, Any, Any, Any, Any, Cint, Cint, Cint),
+                    tn, tn.module, super, parameters, names, types,
                     abstr, mutabl, ninitialized)
         tn.wrapper = ndt.name.wrapper
         ccall(:jl_set_const, Void, (Any, Any, Any), tn.module, tn.name, tn.wrapper)
@@ -827,9 +975,9 @@ function deserialize_typename(s::AbstractSerializer, number)
     return tn::TypeName
 end
 
-function deserialize_datatype(s::AbstractSerializer)
-    form = read(s.io, UInt8)::UInt8
-    if (form&2) != 0
+function deserialize_datatype(s::AbstractSerializer, full::Bool)
+    slot = s.counter; s.counter += 1
+    if full
         tname = deserialize(s)::TypeName
         ty = tname.wrapper
     else
@@ -840,17 +988,56 @@ function deserialize_datatype(s::AbstractSerializer)
     if isa(ty,DataType) && isempty(ty.parameters)
         t = ty
     else
-        params = deserialize(s)
-        if isempty(params)
-            @assert (form&1) == 0
-            return unwrap_unionall(ty)
+        np = Int(read(s.io, Int32)::Int32)
+        if np == 0
+            t = unwrap_unionall(ty)
+        elseif ty === Tuple
+            # note np==0 has its own tag
+            if np == 1
+                t = Tuple{deserialize(s)}
+            elseif np == 2
+                t = Tuple{deserialize(s), deserialize(s)}
+            elseif np == 3
+                t = Tuple{deserialize(s), deserialize(s), deserialize(s)}
+            elseif np == 4
+                t = Tuple{deserialize(s), deserialize(s), deserialize(s), deserialize(s)}
+            else
+                t = Tuple{Any[ deserialize(s) for i=1:np ]...}
+            end
+        else
+            t = ty
+            for i = 1:np
+                t = t{deserialize(s)}
+            end
         end
-        t = ty{params...}
     end
-    if (form&1) == 0
-        return t
+    s.table[slot] = t
+    return t
+end
+
+function deserialize(s::AbstractSerializer, ::Type{UnionAll})
+    form = read(s.io, UInt8)
+    if form == 0
+        var = deserialize(s)
+        body = deserialize(s)
+        return UnionAll(var, body)
+    else
+        n = read(s.io, Int16)
+        t = deserialize(s)::DataType
+        w = t.name.wrapper
+        k = 0
+        while isa(w, UnionAll)
+            w = w.body
+            k += 1
+        end
+        w = t.name.wrapper
+        k -= n
+        while k > 0
+            w = w.body
+            k -= 1
+        end
+        return w
     end
-    deserialize(s, t)
 end
 
 function deserialize(s::AbstractSerializer, ::Type{Task})
@@ -864,16 +1051,15 @@ function deserialize(s::AbstractSerializer, ::Type{Task})
     t
 end
 
-function deserialize(s::AbstractSerializer, ::Type{String})
-    n = read(s.io, Int)
-    out = ccall(:jl_alloc_string, Ref{String}, (Csize_t,), n)
-    unsafe_read(s.io, pointer(out), n)
+function deserialize_string(s::AbstractSerializer, len::Int)
+    out = ccall(:jl_alloc_string, Ref{String}, (Csize_t,), len)
+    unsafe_read(s.io, pointer(out), len)
     return out
 end
 
 # default DataType deserializer
 function deserialize(s::AbstractSerializer, t::DataType)
-    nf = nfields(t)
+    nf = length(t.types)
     if nf == 0 && t.size > 0
         # bits type
         return read(s.io, t)
@@ -910,7 +1096,7 @@ function deserialize(s::AbstractSerializer, t::DataType)
     end
 end
 
-function deserialize{K,V}(s::AbstractSerializer, T::Type{Dict{K,V}})
+function deserialize(s::AbstractSerializer, T::Type{Dict{K,V}}) where {K,V}
     n = read(s.io, Int32)
     t = T(); sizehint!(t, n)
     deserialize_cycle(s, t)
@@ -933,7 +1119,7 @@ function deserialize(s::AbstractSerializer, t::Type{Regex})
     Regex(pattern, compile_options, match_options)
 end
 
-if !is_windows()
+if !Sys.iswindows()
     function serialize(s::AbstractSerializer, rd::RandomDevice)
         serialize_type(s, typeof(rd))
         serialize(s, rd.unlimited)
diff --git a/base/set.jl b/base/set.jl
index 8d941a54d3c0d0..b077f83fe07dc9 100644
--- a/base/set.jl
+++ b/base/set.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 mutable struct Set{T} <: AbstractSet{T}
     dict::Dict{T,Void}
@@ -7,6 +7,14 @@ mutable struct Set{T} <: AbstractSet{T}
     Set{T}(itr) where {T} = union!(new(Dict{T,Void}()), itr)
 end
 Set() = Set{Any}()
+
+"""
+    Set([itr])
+
+Construct a [`Set`](@ref) of the values generated by the given iterable object, or an
+empty set. Should be used instead of [`IntSet`](@ref) for sparse integer sets, or
+for sets of arbitrary objects.
+"""
 Set(itr) = Set{eltype(itr)}(itr)
 function Set(g::Generator)
     T = _default_eltype(typeof(g))
@@ -14,19 +22,19 @@ function Set(g::Generator)
     return Set{T}(g)
 end
 
-eltype{T}(::Type{Set{T}}) = T
-similar{T}(s::Set{T}) = Set{T}()
+eltype(::Type{Set{T}}) where {T} = T
+similar(s::Set{T}) where {T} = Set{T}()
 similar(s::Set, T::Type) = Set{T}()
 
 function show(io::IO, s::Set)
-    print(io,"Set")
+    print(io, "Set")
     if isempty(s)
-        print(io,"{",eltype(s),"}()")
+        print(io, "{", eltype(s), "}()")
         return
     end
-    print(io,"(")
-    show_vector(io,s,"[","]")
-    print(io,")")
+    print(io, "(")
+    show_vector(io, s, "[", "]")
+    print(io, ")")
 end
 
 isempty(s::Set) = isempty(s.dict)
@@ -35,7 +43,15 @@ 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) = x in s ? pop!(s, x) : deflt
-pop!(s::Set) = (idx = start(s.dict); val = s.dict.keys[idx]; _delete!(s.dict, idx); val)
+
+function pop!(s::Set)
+    isempty(s) && throw(ArgumentError("set must be non-empty"))
+    idx = start(s.dict)
+    val = s.dict.keys[idx]
+    _delete!(s.dict, idx)
+    val
+end
+
 delete!(s::Set, x) = (delete!(s.dict, x); s)
 
 copy(s::Set) = union!(similar(s), s)
@@ -47,21 +63,44 @@ rehash!(s::Set) = (rehash!(s.dict); s)
 start(s::Set)       = start(s.dict)
 done(s::Set, state) = done(s.dict, state)
 # NOTE: manually optimized to take advantage of Dict representation
-next(s::Set, i)     = (s.dict.keys[i], skip_deleted(s.dict,i+1))
+next(s::Set, i)     = (s.dict.keys[i], skip_deleted(s.dict, i+1))
 
 union() = Set()
 union(s::Set) = copy(s)
 function union(s::Set, sets::Set...)
     u = Set{join_eltype(s, sets...)}()
-    union!(u,s)
+    union!(u, s)
     for t in sets
-        union!(u,t)
+        union!(u, t)
     end
     return u
 end
 const ∪ = union
-union!(s::Set, xs) = (for x=xs; push!(s,x); end; s)
-union!(s::Set, xs::AbstractArray) = (sizehint!(s,length(xs));for x=xs; push!(s,x); end; s)
+
+"""
+    union!(s, iterable)
+
+Union each element of `iterable` into set `s` in-place.
+
+# Examples
+```jldoctest
+julia> a = Set([1, 3, 4, 5]);
+
+julia> union!(a, 1:2:8);
+
+julia> a
+Set([7, 4, 3, 5, 1])
+```
+"""
+function union!(s::Set{T}, xs) where T
+    haslength(xs) && sizehint!(s, length(xs))
+    for x=xs
+        push!(s, x)
+        length(s) == max_values(T) && break
+    end
+    s
+end
+
 join_eltype() = Bottom
 join_eltype(v1, vs...) = typejoin(eltype(v1), join_eltype(vs...))
 
@@ -71,7 +110,7 @@ function intersect(s::Set, sets::Set...)
     for x in s
         inall = true
         for t in sets
-            if !in(x,t)
+            if !in(x, t)
                 inall = false
                 break
             end
@@ -91,12 +130,45 @@ function setdiff(a::Set, b::Set)
     end
     d
 end
-setdiff!(s::Set, xs) = (for x=xs; delete!(s,x); end; s)
+
+"""
+    setdiff!(s, iterable)
+
+Remove each element of `iterable` from set `s` in-place.
+
+# Examples
+```jldoctest
+julia> a = Set([1, 3, 4, 5]);
+
+julia> setdiff!(a, 1:2:6);
+
+julia> a
+Set([4])
+```
+"""
+setdiff!(s::Set, xs) = (for x=xs; delete!(s, x); end; s)
 
 ==(l::Set, r::Set) = (length(l) == length(r)) && (l <= r)
 <( l::Set, r::Set) = (length(l) < length(r)) && (l <= r)
 <=(l::Set, r::Set) = issubset(l, r)
 
+"""
+    issubset(a, b)
+    ⊆(a,b) -> Bool
+    ⊈(a,b) -> Bool
+    ⊊(a,b) -> Bool
+
+Determine whether every element of `a` is also in `b`, using [`in`](@ref).
+
+# Examples
+```jldoctest
+julia> issubset([1, 2], [1, 2, 3])
+true
+
+julia> issubset([1, 2, 3], [1, 2])
+false
+```
+"""
 function issubset(l, r)
     for elt in l
         if !in(elt, r)
@@ -108,15 +180,20 @@ end
 const ⊆ = issubset
 ⊊(l::Set, r::Set) = <(l, r)
 ⊈(l::Set, r::Set) = !⊆(l, r)
+⊇(l, r) = issubset(r, l)
+⊉(l::Set, r::Set) = !⊇(l, r)
+⊋(l::Set, r::Set) = <(r, l)
 
 """
     unique(itr)
 
-Returns an array containing one value from `itr` for each unique value,
-as determined by [`isequal`](@ref).
+Return an array containing only the unique elements of collection `itr`,
+as determined by [`isequal`](@ref), in the order that the first of each
+set of equivalent elements originally appears.
 
+# Examples
 ```jldoctest
-julia> unique([1; 2; 2; 6])
+julia> unique([1, 2, 6, 2])
 3-element Array{Int64,1}:
  1
  2
@@ -142,7 +219,7 @@ function unique(itr)
 end
 
 _unique_from(itr, out, seen, i) = unique_from(itr, out, seen, i)
-@inline function unique_from{T}(itr, out::Vector{T}, seen, i)
+@inline function unique_from(itr, out::Vector{T}, seen, i) where T
     while !done(itr, i)
         x, i = next(itr, i)
         S = typeof(x)
@@ -170,11 +247,13 @@ end
 Returns an array containing one value from `itr` for each unique value produced by `f`
 applied to elements of `itr`.
 
+# Examples
 ```jldoctest
-julia> unique(isodd, [1; 2; 2; 6])
-2-element Array{Int64,1}:
+julia> unique(x -> x^2, [1, -1, 3, -3, 4])
+3-element Array{Int64,1}:
  1
- 2
+ 3
+ 4
 ```
 """
 function unique(f::Callable, C)
@@ -190,11 +269,101 @@ function unique(f::Callable, C)
     out
 end
 
+# If A is not grouped, then we will need to keep track of all of the elements that we have
+# seen so far.
+function _unique!(A::AbstractVector)
+    seen = Set{eltype(A)}()
+    idxs = eachindex(A)
+    i = state = start(idxs)
+    for x in A
+        if x ∉ seen
+            push!(seen, x)
+            i, state = next(idxs, state)
+            A[i] = x
+        end
+    end
+    resize!(A, i - first(idxs) + 1)
+end
+
+# If A is grouped, so that each unique element is in a contiguous group, then we only
+# need to keep track of one element at a time. We replace the elements of A with the
+# unique elements that we see in the order that we see them. Once we have iterated
+# through A, we resize A based on the number of unique elements that we see.
+function _groupedunique!(A::AbstractVector)
+    isempty(A) && return A
+    idxs = eachindex(A)
+    y = first(A)
+    state = start(idxs)
+    i, state = next(idxs, state)
+    for x in A
+        if !isequal(x, y)
+            i, state = next(idxs, state)
+            y = A[i] = x
+        end
+    end
+    resize!(A, i - first(idxs) + 1)
+end
+
+"""
+    unique!(A::AbstractVector)
+
+Remove duplicate items as determined by [`isequal`](@ref), then return the modified `A`.
+`unique!` will return the elements of `A` in the order that they occur. If you do not care
+about the order of the returned data, then calling `(sort!(A); unique!(A))` will be much
+more efficient as long as the elements of `A` can be sorted.
+
+# Examples
+```jldoctest
+julia> unique!([1, 1, 1])
+1-element Array{Int64,1}:
+ 1
+
+julia> A = [7, 3, 2, 3, 7, 5];
+
+julia> unique!(A)
+4-element Array{Int64,1}:
+ 7
+ 3
+ 2
+ 5
+
+julia> B = [7, 6, 42, 6, 7, 42];
+
+julia> sort!(B);  # unique! is able to process sorted data much more efficiently.
+
+julia> unique!(B)
+3-element Array{Int64,1}:
+  6
+  7
+ 42
+```
+"""
+function unique!(A::Union{AbstractVector{<:Real}, AbstractVector{<:AbstractString},
+                          AbstractVector{<:Symbol}})
+    if isempty(A)
+        return A
+    elseif issorted(A) || issorted(A, rev=true)
+        return _groupedunique!(A)
+    else
+        return _unique!(A)
+    end
+end
+# issorted fails for some element types, so the method above has to be restricted to
+# elements with isless/< defined.
+function unique!(A)
+    if isempty(A)
+        return A
+    else
+        return _unique!(A)
+    end
+end
+
 """
     allunique(itr) -> Bool
 
 Return `true` if all values from `itr` are distinct when compared with [`isequal`](@ref).
 
+# Examples
 ```jldoctest
 julia> a = [1; 2; 3]
 3-element Array{Int64,1}:
@@ -220,7 +389,7 @@ end
 
 allunique(::Set) = true
 
-allunique{T}(r::Range{T}) = (step(r) != zero(T)) || (length(r) <= 1)
+allunique(r::Range{T}) where {T} = (step(r) != zero(T)) || (length(r) <= 1)
 
 function filter(f, s::Set)
     u = similar(s)
@@ -249,5 +418,5 @@ function hash(s::Set, h::UInt)
     return h
 end
 
-convert{T}(::Type{Set{T}}, s::Set{T}) = s
-convert{T}(::Type{Set{T}}, x::Set) = Set{T}(x)
+convert(::Type{Set{T}}, s::Set{T}) where {T} = s
+convert(::Type{Set{T}}, x::Set) where {T} = Set{T}(x)
diff --git a/base/sharedarray.jl b/base/sharedarray.jl
index c48eb8d790e291..479eee1bcc898f 100644
--- a/base/sharedarray.jl
+++ b/base/sharedarray.jl
@@ -1,8 +1,10 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 import .Serializer: serialize_cycle_header, serialize_type, writetag, UNDEFREF_TAG
+import .Distributed: RRID
 
 mutable struct SharedArray{T,N} <: DenseArray{T,N}
+    id::RRID
     dims::NTuple{N,Int}
     pids::Vector{Int}
     refs::Vector
@@ -24,10 +26,14 @@ mutable struct SharedArray{T,N} <: DenseArray{T,N}
     loc_subarr_1d::SubArray{T,1,Array{T,1},Tuple{UnitRange{Int}},true}
 
     function SharedArray{T,N}(d,p,r,sn,s) where {T,N}
-        new(d,p,r,sn,s,0,view(Array{T}(ntuple(d->0,N)), 1:0))
+        S = new(RRID(),d,p,r,sn,s,0,view(Array{T}(ntuple(d->0,N)), 1:0))
+        sa_refs[S.id] = WeakRef(S)
+        S
     end
 end
 
+const sa_refs = Dict{RRID, WeakRef}()
+
 """
     SharedArray{T}(dims::NTuple; init=false, pids=Int[])
     SharedArray{T,N}(...)
@@ -45,6 +51,9 @@ 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.
 
+The shared array is valid as long as a reference to the `SharedArray` object exists on the node
+which created the mapping.
+
     SharedArray{T}(filename::AbstractString, dims::NTuple, [offset=0]; mode=nothing, init=false, pids=Int[])
     SharedArray{T,N}(...)
 
@@ -77,7 +86,7 @@ beginning of the file.
 """
 SharedArray
 
-function (::Type{SharedArray{T,N}}){T,N}(dims::Dims{N}; init=false, pids=Int[])
+function SharedArray{T,N}(dims::Dims{N}; init=false, pids=Int[]) where {T,N}
     isbits(T) || throw(ArgumentError("type of SharedArray elements must be bits types, got $(T)"))
 
     pids, onlocalhost = shared_pids(pids)
@@ -103,7 +112,7 @@ function (::Type{SharedArray{T,N}}){T,N}(dims::Dims{N}; init=false, pids=Int[])
 
         func_mapshmem = () -> shm_mmap_array(T, dims, shm_seg_name, JL_O_RDWR)
 
-        refs = Array{Future}(length(pids))
+        refs = Vector{Future}(length(pids))
         for (i, p) in enumerate(pids)
             refs[i] = remotecall(func_mapshmem, p)
         end
@@ -127,28 +136,28 @@ function (::Type{SharedArray{T,N}}){T,N}(dims::Dims{N}; init=false, pids=Int[])
         shm_seg_name = ""
 
     finally
-        if shm_seg_name != ""
+        if !isempty(shm_seg_name)
             remotecall_fetch(shm_unlink, shmmem_create_pid, shm_seg_name)
         end
     end
     S
 end
 
-(::Type{SharedArray{T,N}}){T,N}(I::Integer...; kwargs...) =
+SharedArray{T,N}(I::Integer...; kwargs...) where {T,N} =
     SharedArray{T,N}(I; kwargs...)
-(::Type{SharedArray{T}}){T}(d::NTuple; kwargs...) =
+SharedArray{T}(d::NTuple; kwargs...) where {T} =
     SharedArray{T,length(d)}(d; kwargs...)
-(::Type{SharedArray{T}}){T}(I::Integer...; kwargs...) =
+SharedArray{T}(I::Integer...; kwargs...) where {T} =
     SharedArray{T,length(I)}(I; kwargs...)
-(::Type{SharedArray{T}}){T}(m::Integer; kwargs...) =
+SharedArray{T}(m::Integer; kwargs...) where {T} =
     SharedArray{T,1}(m; kwargs...)
-(::Type{SharedArray{T}}){T}(m::Integer, n::Integer; kwargs...) =
+SharedArray{T}(m::Integer, n::Integer; kwargs...) where {T} =
     SharedArray{T,2}(m, n; kwargs...)
-(::Type{SharedArray{T}}){T}(m::Integer, n::Integer, o::Integer; kwargs...) =
+SharedArray{T}(m::Integer, n::Integer, o::Integer; kwargs...) where {T} =
     SharedArray{T,3}(m, n, o; kwargs...)
 
-function (::Type{SharedArray{T,N}}){T,N}(filename::AbstractString, dims::NTuple{N,Int},
-        offset::Integer=0; mode=nothing, init=false, pids::Vector{Int}=Int[])
+function SharedArray{T,N}(filename::AbstractString, dims::NTuple{N,Int}, offset::Integer=0;
+                          mode=nothing, init=false, pids::Vector{Int}=Int[]) where {T,N}
     if !isabspath(filename)
         throw(ArgumentError("$filename is not an absolute path; try abspath(filename)?"))
     end
@@ -180,7 +189,7 @@ function (::Type{SharedArray{T,N}}){T,N}(filename::AbstractString, dims::NTuple{
     end
 
     # Create the file if it doesn't exist, map it if it does
-    refs = Array{Future}(length(pids))
+    refs = Vector{Future}(length(pids))
     func_mmap = mode -> open(filename, mode) do io
         Mmap.mmap(io, Array{T,N}, dims, offset; shared=true)
     end
@@ -213,8 +222,8 @@ function (::Type{SharedArray{T,N}}){T,N}(filename::AbstractString, dims::NTuple{
     S
 end
 
-(::Type{SharedArray{T}}){T,N}(filename::AbstractString, dims::NTuple{N,Int}, offset::Integer=0;
-                              mode=nothing, init=false, pids::Vector{Int}=Int[]) =
+SharedArray{T}(filename::AbstractString, dims::NTuple{N,Int}, offset::Integer=0;
+               mode=nothing, init=false, pids::Vector{Int}=Int[]) where {T,N} =
     SharedArray{T,N}(filename, dims, offset; mode=mode, init=init, pids=pids)
 
 function initialize_shared_array(S, onlocalhost, init, pids)
@@ -237,7 +246,7 @@ function initialize_shared_array(S, onlocalhost, init, pids)
     S
 end
 
-function finalize_refs{T,N}(S::SharedArray{T,N})
+function finalize_refs(S::SharedArray{T,N}) where T where N
     if length(S.pids) > 0
         for r in S.refs
             finalize(r)
@@ -246,19 +255,21 @@ function finalize_refs{T,N}(S::SharedArray{T,N})
         empty!(S.refs)
         init_loc_flds(S)
         S.s = Array{T}(ntuple(d->0,N))
+        delete!(sa_refs, S.id)
     end
     S
 end
 
-SharedVector{T} = SharedArray{T,1}
-SharedMatrix{T} = SharedArray{T,2}
+
+const SharedVector{T} = SharedArray{T,1}
+const SharedMatrix{T} = SharedArray{T,2}
 
 length(S::SharedArray) = prod(S.dims)
 size(S::SharedArray) = S.dims
 ndims(S::SharedArray) = length(S.dims)
 IndexStyle(::Type{<:SharedArray}) = IndexLinear()
 
-function reshape{T,N}(a::SharedArray{T}, dims::NTuple{N,Int})
+function reshape(a::SharedArray{T}, dims::NTuple{N,Int}) where {T,N}
     if length(a) != prod(dims)
         throw(DimensionMismatch("dimensions must be consistent with array size"))
     end
@@ -314,18 +325,18 @@ 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{T}) = unsafe_convert(Ptr{T}, sdata(S))
-unsafe_convert{T}(::Type{Ptr{T}}, S::SharedArray   ) = unsafe_convert(Ptr{T}, sdata(S))
+unsafe_convert(::Type{Ptr{T}}, S::SharedArray{T}) where {T} = unsafe_convert(Ptr{T}, sdata(S))
+unsafe_convert(::Type{Ptr{T}}, S::SharedArray   ) where {T} = unsafe_convert(Ptr{T}, sdata(S))
 
 function convert(::Type{SharedArray}, A::Array)
     S = SharedArray{eltype(A),ndims(A)}(size(A))
     copy!(S, A)
 end
-function convert{T}(::Type{SharedArray{T}}, A::Array)
+function convert(::Type{SharedArray{T}}, A::Array) where T
     S = SharedArray{T,ndims(A)}(size(A))
     copy!(S, A)
 end
-function convert{TS,TA,N}(::Type{SharedArray{TS,N}}, A::Array{TA,N})
+function convert(::Type{SharedArray{TS,N}}, A::Array{TA,N}) where {TS,TA,N}
     S = SharedArray{TS,ndims(A)}(size(A))
     copy!(S, A)
 end
@@ -377,7 +388,7 @@ end
 
 sub_1dim(S::SharedArray, pidx) = view(S.s, range_1dim(S, pidx))
 
-function init_loc_flds{T,N}(S::SharedArray{T,N}, empty_local=false)
+function init_loc_flds(S::SharedArray{T,N}, empty_local=false) where T where N
     if myid() in S.pids
         S.pidx = findfirst(S.pids, myid())
         if isa(S.refs[1], Future)
@@ -402,6 +413,17 @@ end
 # pidx, which is relevant to the current process only
 function serialize(s::AbstractSerializer, S::SharedArray)
     serialize_cycle_header(s, S) && return
+
+    destpid = worker_id_from_socket(s.io)
+    if S.id.whence == destpid
+        # The shared array was created from destpid, hence a reference to it
+        # must be available at destpid.
+        serialize(s, true)
+        serialize(s, S.id.whence)
+        serialize(s, S.id.id)
+        return
+    end
+    serialize(s, false)
     for n in fieldnames(SharedArray)
         if n in [:s, :pidx, :loc_subarr_1d]
             writetag(s.io, UNDEFREF_TAG)
@@ -421,9 +443,18 @@ function serialize(s::AbstractSerializer, S::SharedArray)
 end
 
 function deserialize(s::AbstractSerializer, t::Type{<:SharedArray})
+    ref_exists = deserialize(s)
+    if ref_exists
+        sref = sa_refs[RRID(deserialize(s), deserialize(s))]
+        if sref.value !== nothing
+            return sref.value
+        end
+        error("Expected reference to shared array instance not found")
+    end
+
     S = invoke(deserialize, Tuple{AbstractSerializer,DataType}, s, t)
     init_loc_flds(S, true)
-    S
+    return S
 end
 
 function show(io::IO, S::SharedArray)
@@ -460,7 +491,7 @@ function fill!(S::SharedArray, v)
     return S
 end
 
-function rand!{T}(S::SharedArray{T})
+function rand!(S::SharedArray{T}) where T
     f = S->map!(x -> rand(T), S.loc_subarr_1d, S.loc_subarr_1d)
     @sync for p in procs(S)
         @async remotecall_wait(f, p, S)
@@ -507,12 +538,11 @@ similar(S::SharedArray, dims::Dims) = similar(S.s, eltype(S), dims)
 similar(S::SharedArray) = similar(S.s, eltype(S), size(S))
 
 reduce(f, S::SharedArray) =
-    mapreduce(fetch, f,
-              Any[ @spawnat p reduce(f, S.loc_subarr_1d) for p in procs(S) ])
+    mapreduce(fetch, f, Any[ @spawnat p reduce(f, S.loc_subarr_1d) for p in procs(S) ])
 
 
 function map!(f, S::SharedArray, Q::SharedArray)
-    if !(S === Q) && (procs(S) != procs(Q) || localindexes(S) != localindexes(Q))
+    if (S !== Q) && (procs(S) != procs(Q) || localindexes(S) != localindexes(Q))
         throw(ArgumentError("incompatible source and destination arguments"))
     end
     @sync for p in procs(S)
@@ -549,17 +579,22 @@ end
 
 function print_shmem_limits(slen)
     try
-        if is_linux()
+        if Sys.islinux()
             pfx = "kernel"
-        elseif is_apple()
+        elseif Sys.isapple()
             pfx = "kern.sysv"
+        elseif Sys.KERNEL == :FreeBSD || Sys.KERNEL == :DragonFly
+            pfx = "kern.ipc"
+        elseif Sys.KERNEL == :OpenBSD
+            pfx = "kern.shminfo"
         else
+            # seems NetBSD does not have *.shmall
             return
         end
 
-        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)
+        shmmax_MB = div(parse(Int, split(read(`sysctl $(pfx).shmmax`, String))[end]), 1024*1024)
+        page_size = parse(Int, split(read(`getconf PAGE_SIZE`, String))[end])
+        shmall_MB = div(parse(Int, split(read(`sysctl $(pfx).shmall`, String))[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,
@@ -598,7 +633,7 @@ end
 
 # platform-specific code
 
-if is_windows()
+if Sys.iswindows()
 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
diff --git a/base/shell.jl b/base/shell.jl
index fee255181225dc..841865790b9c9e 100644
--- a/base/shell.jl
+++ b/base/shell.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## shell-like command parsing ##
 
@@ -8,11 +8,8 @@ const shell_special = "#{}()[]<>|&*?~;"
 @noinline warn_shell_special(special) =
     depwarn("special characters \"$special\" should now be quoted in commands", :warn_shell_special)
 
-function shell_parse(
-        str::AbstractString,
-        interpolate::Bool=true;
-        special::AbstractString=""
-    )
+function shell_parse(str::AbstractString, interpolate::Bool=true;
+                     special::AbstractString="")
     s = lstrip(str)
     # strips the end but respects the space when the string ends with "\\ "
     r = RevString(s)
@@ -78,7 +75,7 @@ function shell_parse(
             stpos = j
             ex, j = parse(s,j,greedy=false)
             last_parse = stpos:j
-            update_arg(esc(ex)); i = j
+            update_arg(ex); i = j
         else
             if !in_double_quotes && c == '\''
                 in_single_quotes = !in_single_quotes
@@ -129,7 +126,7 @@ function shell_split(s::AbstractString)
     parsed = shell_parse(s, false)[1]
     args = String[]
     for arg in parsed
-       push!(args, string(arg...))
+        push!(args, string(arg...))
     end
     args
 end
@@ -164,10 +161,8 @@ function print_shell_word(io::IO, word::AbstractString, special::AbstractString
     end
 end
 
-function print_shell_escaped(
-        io::IO, cmd::AbstractString, args::AbstractString...;
-        special::AbstractString=""
-    )
+function print_shell_escaped(io::IO, cmd::AbstractString, args::AbstractString...;
+                             special::AbstractString="")
     print_shell_word(io, cmd, special)
     for arg in args
         print(io, ' ')
@@ -183,13 +178,16 @@ The unexported `shell_escape` function is the inverse of the unexported `shell_s
 it takes a string or command object and escapes any special characters in such a way that calling
 `shell_split` on it would give back the array of words in the original command. The `special`
 keyword argument controls what characters in addition to whitespace, backslashes, quotes and
-dollar signs are considered to be special (default: none). Examples:
+dollar signs are considered to be special (default: none).
 
-    julia> Base.shell_escape("cat", "/foo/bar baz", "&&", "echo", "done")
-    "cat '/foo/bar baz' && echo done"
+# Examples
+```jldoctest
+julia> Base.shell_escape("cat", "/foo/bar baz", "&&", "echo", "done")
+"cat '/foo/bar baz' && echo done"
 
-    julia> Base.shell_escape("echo", "this", "&&", "that")
-    "echo this '&&' that"
+julia> Base.shell_escape("echo", "this", "&&", "that")
+"echo this && that"
+```
 """
 shell_escape(args::AbstractString...; special::AbstractString="") =
     sprint(io->print_shell_escaped(io, args..., special=special))
diff --git a/base/show.jl b/base/show.jl
index d74e3f963bbeda..d88ef13665f07d 100644
--- a/base/show.jl
+++ b/base/show.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 print(io::IO, s::Symbol) = (write(io,s); nothing)
 
@@ -107,8 +107,8 @@ get(io::IO, key, default) = default
 
 displaysize(io::IOContext) = haskey(io, :displaysize) ? io[:displaysize] : displaysize(io.io)
 
-show_circular(io::IO, x::ANY) = false
-function show_circular(io::IOContext, x::ANY)
+show_circular(io::IO, @nospecialize(x)) = false
+function show_circular(io::IOContext, @nospecialize(x))
     d = 1
     for (k, v) in io.dict
         if k === :SHOWN_SET
@@ -122,12 +122,12 @@ function show_circular(io::IOContext, x::ANY)
     return false
 end
 
-show(io::IO, x::ANY) = show_default(io, x)
-function show_default(io::IO, x::ANY)
+show(io::IO, @nospecialize(x)) = show_default(io, x)
+function show_default(io::IO, @nospecialize(x))
     t = typeof(x)::DataType
     show(io, t)
     print(io, '(')
-    nf = nfields(t)
+    nf = nfields(x)
     nb = sizeof(x)
     if nf != 0 || nb == 0
         if !show_circular(io, x)
@@ -183,7 +183,7 @@ function show(io::IO, x::Core.IntrinsicFunction)
     print(io, unsafe_string(name))
 end
 
-show(io::IO, ::Core.BottomType) = print(io, "Union{}")
+show(io::IO, ::Core.TypeofBottom) = print(io, "Union{}")
 
 function show(io::IO, x::Union)
     print(io, "Union")
@@ -191,7 +191,7 @@ function show(io::IO, x::Union)
     show_comma_array(io, sorted_types, '{', '}')
 end
 
-function print_without_params(x::ANY)
+function print_without_params(@nospecialize(x))
     if isa(x,UnionAll)
         b = unwrap_unionall(x)
         return isa(b,DataType) && b.name.wrapper === x
@@ -211,11 +211,12 @@ end
 show(io::IO, x::DataType) = show_datatype(io, x)
 
 function show_datatype(io::IO, x::DataType)
-    if (!isempty(x.parameters) || x.name === Tuple.name) && x !== Tuple
+    istuple = x.name === Tuple.name
+    if (!isempty(x.parameters) || istuple) && x !== Tuple
         n = length(x.parameters)
 
         # Print homogeneous tuples with more than 3 elements compactly as NTuple{N, T}
-        if n > 3 && all(i -> (x.parameters[1] === i), x.parameters)
+        if istuple && n > 3 && all(i -> (x.parameters[1] === i), x.parameters)
             print(io, "NTuple{", n, ',', x.parameters[1], "}")
         else
             show(io, x.name)
@@ -235,13 +236,29 @@ function show_datatype(io::IO, x::DataType)
     end
 end
 
+function show_supertypes(io::IO, typ::DataType)
+    print(io, typ)
+    while typ != Any
+        typ = supertype(typ)
+        print(io, " <: ", typ)
+    end
+end
+
+show_supertypes(typ::DataType) = show_supertypes(STDOUT, typ)
+
+"""
+    @show
+
+Show an expression and result, returning the result.
+"""
 macro show(exs...)
     blk = Expr(:block)
     for ex in exs
-        push!(blk.args, :(println($(sprint(show_unquoted,ex)*" = "),
-                                  repr(begin value=$(esc(ex)) end))))
+        push!(blk.args, :(print($(sprint(show_unquoted,ex)*" = "))))
+        push!(blk.args, :(show(STDOUT, "text/plain", begin value=$(esc(ex)) end)))
+        push!(blk.args, :(println()))
     end
-    if !isempty(exs); push!(blk.args, :value); end
+    isempty(exs) || push!(blk.args, :value)
     return blk
 end
 
@@ -261,19 +278,26 @@ print(io::IO, n::Unsigned) = print(io, dec(n))
 
 show(io::IO, p::Ptr) = print(io, typeof(p), " @0x$(hex(UInt(p), Sys.WORD_SIZE>>2))")
 
+has_tight_type(p::Pair) =
+    typeof(p.first)  == typeof(p).parameters[1] &&
+    typeof(p.second) == typeof(p).parameters[2]
+
+isdelimited(io::IO, x) = true
+
+isdelimited(io::IO, p::Pair) = !has_tight_type(p)
+
 function show(io::IO, p::Pair)
-    if typeof(p.first) != typeof(p).parameters[1] ||
-       typeof(p.second) != typeof(p).parameters[2]
-        return show_default(io, p)
-    end
-
-    isa(p.first,Pair) && print(io, "(")
-    show(io, p.first)
-    isa(p.first,Pair) && print(io, ")")
-    print(io, "=>")
-    isa(p.second,Pair) && print(io, "(")
-    show(io, p.second)
-    isa(p.second,Pair) && print(io, ")")
+    compact = get(io, :compact, false)
+    iocompact = IOContext(io, :compact => get(io, :compact, true))
+    has_tight_type(p) || return show_default(iocompact, p)
+
+    isdelimited(iocompact, p.first) || print(io, "(")
+    show(iocompact, p.first)
+    isdelimited(iocompact, p.first) || print(io, ")")
+    print(io, compact ? "=>" : " => ")
+    isdelimited(iocompact, p.second) || print(io, "(")
+    show(iocompact, p.second)
+    isdelimited(iocompact, p.second) || print(io, ")")
     nothing
 end
 
@@ -306,13 +330,14 @@ function sourceinfo_slotnames(src::CodeInfo)
 end
 
 function show(io::IO, l::Core.MethodInstance)
-    if isdefined(l, :def)
-        if l.def.isstaged && l === l.def.generator
+    def = l.def
+    if isa(def, Method)
+        if isdefined(def, :generator) && l === def.generator
             print(io, "MethodInstance generator for ")
-            show(io, l.def)
+            show(io, def)
         else
             print(io, "MethodInstance for ")
-            show_lambda_types(io, l)
+            show_tuple_as_call(io, def.name, l.specTypes)
         end
     else
         print(io, "Toplevel MethodInstance thunk")
@@ -322,17 +347,13 @@ end
 function show(io::IO, src::CodeInfo)
     # Fix slot names and types in function body
     print(io, "CodeInfo(")
-    if isa(src.code, Array{Any,1})
-        lambda_io = IOContext(io, :SOURCEINFO => src)
-        if src.slotnames !== nothing
-            lambda_io = IOContext(lambda_io, :SOURCE_SLOTNAMES => sourceinfo_slotnames(src))
-        end
-        body = Expr(:body)
-        body.args = src.code
-        show(lambda_io, body)
-    else
-        print(io, "<compressed>")
+    lambda_io = IOContext(io, :SOURCEINFO => src)
+    if src.slotnames !== nothing
+        lambda_io = IOContext(lambda_io, :SOURCE_SLOTNAMES => sourceinfo_slotnames(src))
     end
+    body = Expr(:body)
+    body.args = src.code
+    show(lambda_io, body)
     print(io, ")")
 end
 
@@ -452,7 +473,8 @@ const all_ops = union(quoted_syms, uni_ops, expr_infix_any)
 const expr_calls  = Dict(:call => ('(',')'), :calldecl => ('(',')'),
                          :ref => ('[',']'), :curly => ('{','}'), :(.) => ('(',')'))
 const expr_parens = Dict(:tuple=>('(',')'), :vcat=>('[',']'),
-                         :hcat =>('[',']'), :row =>('[',']'), :vect=>('[',']'))
+                         :hcat =>('[',']'), :row =>('[',']'), :vect=>('[',']'),
+                         :braces=>('{','}'), :bracescat=>('{','}'))
 
 ## AST decoding helpers ##
 
@@ -472,6 +494,23 @@ end
 isidentifier(s::Symbol) = isidentifier(string(s))
 
 isoperator(s::Symbol) = ccall(:jl_is_operator, Cint, (Cstring,), s) != 0
+
+"""
+    operator_precedence(s::Symbol)
+
+Return an integer representing the precedence of operator `s`, relative to
+other operators. Higher-numbered operators take precedence over lower-numbered
+operators. Return `0` if `s` is not a valid operator.
+
+# Examples
+```jldoctest
+julia> Base.operator_precedence(:+), Base.operator_precedence(:*), Base.operator_precedence(:.)
+(9,11,15)
+
+julia> Base.operator_precedence(:+=), Base.operator_precedence(:(=))  # (Note the necessary parens on `:(=)`)
+(1,1)
+```
+"""
 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(:(^))
@@ -480,10 +519,6 @@ 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
 
-is_linenumber(ex::LineNumberNode) = true
-is_linenumber(ex::Expr)           = (ex.head == :line)
-is_linenumber(ex)                 = false
-
 is_quoted(ex)            = false
 is_quoted(ex::QuoteNode) = true
 is_quoted(ex::Expr)      = is_expr(ex, :quote, 1) || is_expr(ex, :inert, 1)
@@ -497,7 +532,7 @@ typeemphasize(io::IO) = get(io, :TYPEEMPHASIZE, false) === true
 
 const indent_width = 4
 
-function show_expr_type(io::IO, ty, emph)
+function show_expr_type(io::IO, @nospecialize(ty), emph::Bool)
     if ty === Function
         print(io, "::F")
     elseif ty === Core.IntrinsicFunction
@@ -513,18 +548,22 @@ end
 
 emphasize(io, str::AbstractString) = have_color ? print_with_color(Base.error_color(), io, str; bold = true) : print(io, uppercase(str))
 
-show_linenumber(io::IO, line)       = print(io," # line ",line,':')
-show_linenumber(io::IO, line, file) = print(io," # ", file,", line ",line,':')
+show_linenumber(io::IO, line)       = print(io, "#= line ", line, " =#")
+show_linenumber(io::IO, line, file) = print(io, "#= ", file, ":", line, " =#")
+show_linenumber(io::IO, line, file::Void) = show_linenumber(io, line)
 
 # show a block, e g if/for/etc
 function show_block(io::IO, head, args::Vector, body, indent::Int)
-    print(io, head, ' ')
-    show_list(io, args, ", ", indent)
+    print(io, head)
+    if !isempty(args)
+        print(io, ' ')
+        show_list(io, args, ", ", indent)
+    end
 
     ind = head === :module || head === :baremodule ? indent : indent + indent_width
     exs = (is_expr(body, :block) || is_expr(body, :body)) ? body.args : Any[body]
     for ex in exs
-        if !is_linenumber(ex); print(io, '\n', " "^ind); end
+        print(io, '\n', " "^ind)
         show_unquoted(io, ex, ind, -1)
     end
     print(io, '\n', " "^indent)
@@ -541,14 +580,18 @@ end
 # show an indented list
 function show_list(io::IO, items, sep, indent::Int, prec::Int=0, enclose_operators::Bool=false)
     n = length(items)
-    if n == 0; return end
+    n == 0 && return
     indent += indent_width
     first = true
     for item in items
         !first && print(io, sep)
-        parens = enclose_operators && isa(item,Symbol) && isoperator(item)
+        parens = !is_quoted(item) &&
+            (first && prec >= prec_power &&
+             ((item isa Expr && item.head === :call && item.args[1] in uni_ops) ||
+              (item isa Real && item < 0))) ||
+              (enclose_operators && item isa Symbol && isoperator(item))
         parens && print(io, '(')
-        show_unquoted(io, item, indent, prec)
+        show_unquoted(io, item, indent, parens ? 0 : prec)
         parens && print(io, ')')
         first = false
     end
@@ -588,7 +631,7 @@ end
 ## AST printing ##
 
 show_unquoted(io::IO, sym::Symbol, ::Int, ::Int)        = print(io, sym)
-show_unquoted(io::IO, ex::LineNumberNode, ::Int, ::Int) = show_linenumber(io, ex.line)
+show_unquoted(io::IO, ex::LineNumberNode, ::Int, ::Int) = show_linenumber(io, ex.line, ex.file)
 show_unquoted(io::IO, ex::LabelNode, ::Int, ::Int)      = print(io, ex.label, ": ")
 show_unquoted(io::IO, ex::GotoNode, ::Int, ::Int)       = print(io, "goto ", ex.label)
 show_unquoted(io::IO, ex::GlobalRef, ::Int, ::Int)      = print(io, ex.mod, '.', ex.name)
@@ -602,7 +645,7 @@ function show_unquoted(io::IO, ex::Slot, ::Int, ::Int)
         if isa(slottypes, Array) && slotid <= length(slottypes::Array)
             slottype = slottypes[slotid]
             # The Slot in assignment can somehow have an Any type
-            if slottype <: typ
+            if isa(slottype, Type) && isa(typ, Type) && slottype <: typ
                 typ = slottype
             end
         end
@@ -692,15 +735,9 @@ function show_unquoted(io::IO, ex::Expr, indent::Int, prec::Int)
     end
     # dot (i.e. "x.y"), but not compact broadcast exps
     if head === :(.) && !is_expr(args[2], :tuple)
-        show_unquoted(io, args[1], indent + indent_width)
-        print(io, '.')
-        if is_quoted(args[2])
-            show_unquoted(io, unquoted(args[2]), indent + indent_width)
-        else
-            print(io, '(')
-            show_unquoted(io, args[2], indent + indent_width)
-            print(io, ')')
-        end
+        func_prec = operator_precedence(head)
+        args_ = (args[1], (is_quoted(arg) && !is_quoted(unquoted(arg)) ? unquoted(arg) : arg for arg in args[2:end])...)
+        show_list(io, args_, head, indent, func_prec)
 
     # infix (i.e. "x <: y" or "x = y")
     elseif (head in expr_infix_any && nargs==2) || (head === :(:) && nargs==3)
@@ -715,7 +752,7 @@ function show_unquoted(io::IO, ex::Expr, indent::Int, prec::Int)
     # list (i.e. "(1, 2, 3)" or "[1, 2, 3]")
     elseif haskey(expr_parens, head)               # :tuple/:vcat
         op, cl = expr_parens[head]
-        if head === :vcat
+        if head === :vcat || head === :bracescat
             sep = "; "
         elseif head === :hcat || head === :row
             sep = " "
@@ -766,7 +803,7 @@ function show_unquoted(io::IO, ex::Expr, indent::Int, prec::Int)
             if isa(func_args[1], Expr) || func_args[1] in all_ops
                 show_enclosed_list(io, '(', func_args, ", ", ')', indent, func_prec)
             else
-                show_unquoted(io, func_args[1])
+                show_unquoted(io, func_args[1], indent, func_prec)
             end
 
         # binary operator (i.e. "x + y")
@@ -775,6 +812,7 @@ function show_unquoted(io::IO, ex::Expr, indent::Int, prec::Int)
             if (na == 2 || (na > 2 && func in (:+, :++, :*))) &&
                     all(!isa(a, Expr) || a.head !== :... for a in func_args)
                 sep = " $func "
+
                 if func_prec <= prec
                     show_enclosed_list(io, '(', func_args, sep, ')', indent, func_prec, true)
                 else
@@ -888,12 +926,20 @@ function show_unquoted(io::IO, ex::Expr, indent::Int, prec::Int)
         print(io, head, ' ')
         show_list(io, args, ", ", indent)
 
-    elseif head === :macrocall && nargs >= 1
+    elseif head === :macrocall && nargs >= 2
+        # first show the line number argument as a comment
+        if isa(args[2], LineNumberNode) || is_expr(args[2], :line)
+            print(io, args[2], ' ')
+        end
         # Use the functional syntax unless specifically designated with prec=-1
+        # and hide the line number argument from the argument list
         if prec >= 0
-            show_call(io, :call, ex.args[1], ex.args[2:end], indent)
+            show_call(io, :call, args[1], args[3:end], indent)
         else
-            show_list(io, args, ' ', indent)
+            show_args = Vector{Any}(length(args) - 1)
+            show_args[1] = args[1]
+            show_args[2:end] = args[3:end]
+            show_list(io, show_args, ' ', indent)
         end
 
     elseif head === :line && 1 <= nargs <= 2
@@ -1011,7 +1057,9 @@ function show_unquoted(io::IO, ex::Expr, indent::Int, prec::Int)
         show_type = false
     # print anything else as "Expr(head, args...)"
     else
-        show_type = false
+        if head !== :invoke
+            show_type = false
+        end
         if emphstate && ex.head !== :lambda && ex.head !== :method
             io = IOContext(io, :TYPEEMPHASIZE => false)
             emphstate = false
@@ -1028,22 +1076,21 @@ function show_unquoted(io::IO, ex::Expr, indent::Int, prec::Int)
     nothing
 end
 
-function show_lambda_types(io::IO, li::Core.MethodInstance)
+function show_tuple_as_call(io::IO, name::Symbol, sig::Type)
     # print a method signature tuple for a lambda definition
-    local sig
-    returned_from_do = false
-    Base.with_output_color(have_color && get(io, :backtrace, false) ? stackframe_function_color() : :nothing, io) do io
-        if li.specTypes === Tuple
-            print(io, li.def.name, "(...)")
-            returned_from_do = true
-            return
-        end
-        sig = li.specTypes.parameters
+    color = have_color && get(io, :backtrace, false) ? stackframe_function_color() : :nothing
+    if sig === Tuple
+        Base.print_with_color(color, io, name, "(...)")
+        return
+    end
+    sig = unwrap_unionall(sig).parameters
+    Base.with_output_color(color, io) do io
         ft = sig[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)
+        uw = unwrap_unionall(ft)
+        if ft <: Function && isa(uw,DataType) && isempty(uw.parameters) &&
+                isdefined(uw.name.module, uw.name.mt.name) &&
+                ft == typeof(getfield(uw.name.module, uw.name.mt.name))
+            print(io, uw.name.mt.name)
         elseif isa(ft, DataType) && ft.name === Type.body.name && isconcrete(ft)
             f = ft.parameters[1]
             print(io, f)
@@ -1051,7 +1098,6 @@ function show_lambda_types(io::IO, li::Core.MethodInstance)
             print(io, "(::", ft, ")")
         end
     end
-    returned_from_do && return
     first = true
     print_style = have_color && get(io, :backtrace, false) ? :bold : :nothing
     print_with_color(print_style, io, "(")
@@ -1064,12 +1110,30 @@ function show_lambda_types(io::IO, li::Core.MethodInstance)
     nothing
 end
 
+resolvebinding(@nospecialize(ex)) = ex
+resolvebinding(ex::QuoteNode) = ex.value
+resolvebinding(ex::Symbol) = resolvebinding(GlobalRef(Main, ex))
+function resolvebinding(ex::Expr)
+    if ex.head == :. && isa(ex.args[2], Symbol)
+        parent = resolvebinding(ex.args[1])
+        if isa(parent, Module)
+            return resolvebinding(GlobalRef(parent, ex.args[2]))
+        end
+    end
+    return nothing
+end
+function resolvebinding(ex::GlobalRef)
+    isdefined(ex.mod, ex.name) || return nothing
+    isconst(ex.mod, ex.name) || return nothing
+    m = getfield(ex.mod, ex.name)
+    isa(m, Module) || return nothing
+    return m
+end
+
 function ismodulecall(ex::Expr)
     return ex.head == :call && (ex.args[1] === GlobalRef(Base,:getfield) ||
                                 ex.args[1] === GlobalRef(Core,:getfield)) &&
-        isa(ex.args[2], Symbol) &&
-        isdefined(current_module(), ex.args[2]) &&
-        isa(getfield(current_module(), ex.args[2]), Module)
+           isa(resolvebinding(ex.args[2]), Module)
 end
 
 function show(io::IO, tv::TypeVar)
@@ -1079,7 +1143,7 @@ function show(io::IO, tv::TypeVar)
     # Otherwise, the lower bound should be printed if it is not `Bottom`
     # and the upper bound should be printed if it is not `Any`.
     in_env = (:unionall_env => tv) in io
-    function show_bound(io::IO, b::ANY)
+    function show_bound(io::IO, @nospecialize(b))
         parens = isa(b,UnionAll) && !print_without_params(b)
         parens && print(io, "(")
         show(io, b)
@@ -1126,14 +1190,14 @@ function dump(io::IO, x::SimpleVector, n::Int, indent)
     nothing
 end
 
-function dump(io::IO, x::ANY, n::Int, indent)
+function dump(io::IO, @nospecialize(x), n::Int, indent)
     T = typeof(x)
     if isa(x, Function)
         print(io, x, " (function of type ", T, ")")
     else
         print(io, T)
     end
-    if nfields(T) > 0
+    if nfields(x) > 0
         if n > 0
             for field in (isa(x,Tuple) ? (1:length(x)) : fieldnames(T))
                 println(io)
@@ -1197,7 +1261,7 @@ function dump(io::IO, x::DataType, n::Int, indent)
     if x !== Any
         print(io, " <: ", supertype(x))
     end
-    if n > 0 && !(x <: Tuple)
+    if n > 0 && !(x <: Tuple) && !x.abstract
         tvar_io::IOContext = io
         for tparam in x.parameters
             # approximately recapture the list of tvar parameterization
@@ -1219,7 +1283,7 @@ end
 
 # dumptype is for displaying abstract type hierarchies,
 # based on Jameson Nash's examples/typetree.jl
-function dumptype(io::IO, x::ANY, n::Int, indent)
+function dumptype(io::IO, @nospecialize(x), n::Int, indent)
     print(io, x)
     n == 0 && return  # too deeply nested
     isa(x, DataType) && x.abstract && dumpsubtypes(io, x, Main, n, indent)
@@ -1310,7 +1374,7 @@ function alignment(io::IO, x::Real)
 end
 "`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, show, x, env=io))
+    m = match(r"^(.*[^e][\+\-])(.*)$", sprint(0, show, x, env=io))
     m === nothing ? (length(sprint(0, show, x, env=io)), 0) :
                    (length(m.captures[1]), length(m.captures[2]))
 end
@@ -1320,6 +1384,19 @@ function alignment(io::IO, x::Rational)
                    (length(m.captures[1]), length(m.captures[2]))
 end
 
+function alignment(io::IO, x::Pair)
+    s = sprint(0, show, x, env=io)
+    if has_tight_type(x) # i.e. use "=>" for display
+        iocompact = IOContext(io, :compact => get(io, :compact, true))
+        left = length(sprint(0, show, x.first, env=iocompact))
+        left += 2 * !isdelimited(iocompact, x.first) # for parens around p.first
+        left += !get(io, :compact, false) # spaces are added around "=>"
+        (left+1, length(s)-left-1) # +1 for the "=" part of "=>"
+    else
+        (0, length(s)) # as for x::Any
+    end
+end
+
 const undef_ref_str = "#undef"
 const undef_ref_alignment = (3,3)
 
@@ -1479,7 +1556,7 @@ function print_matrix(io::IO, X::AbstractVecOrMat,
                 print(io, i == first(rowsA) ? pre : presp)
                 print_matrix_row(io, X,A,i,colsA,sep)
                 print(io, i == last(rowsA) ? post : postsp)
-                if i != last(rowsA); println(io, ); end
+                if i != last(rowsA); println(io); end
             end
         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
@@ -1492,7 +1569,7 @@ function print_matrix(io::IO, X::AbstractVecOrMat,
                 print(io, (i - first(rowsA)) % hmod == 0 ? hdots : repeat(" ", length(hdots)))
                 print_matrix_row(io, X,Ralign,i,n-length(Ralign)+colsA,sep)
                 print(io, i == last(rowsA) ? post : postsp)
-                if i != last(rowsA); println(io, ); end
+                if i != last(rowsA); println(io); end
             end
         end
     else # rows don't fit so will need vertical ellipsis
@@ -1501,7 +1578,7 @@ function print_matrix(io::IO, X::AbstractVecOrMat,
                 print(io, i == first(rowsA) ? pre : presp)
                 print_matrix_row(io, X,A,i,colsA,sep)
                 print(io, i == last(rowsA) ? post : postsp)
-                if i != rowsA[end]; println(io, ); end
+                if i != rowsA[end]; println(io); end
                 if i == rowsA[halfheight]
                     print(io, i == first(rowsA) ? pre : presp)
                     print_matrix_vdots(io, vdots,A,sep,vmod,1)
@@ -1520,7 +1597,7 @@ function print_matrix(io::IO, X::AbstractVecOrMat,
                 print(io, (i - first(rowsA)) % hmod == 0 ? hdots : repeat(" ", length(hdots)))
                 print_matrix_row(io, X,Ralign,i,n-length(Ralign)+colsA,sep)
                 print(io, i == last(rowsA) ? post : postsp)
-                if i != rowsA[end]; println(io, ); end
+                if i != rowsA[end]; println(io); end
                 if i == rowsA[halfheight]
                     print(io, i == first(rowsA) ? pre : presp)
                     print_matrix_vdots(io, vdots,Lalign,sep,vmod,1)
@@ -1537,7 +1614,7 @@ end
     summary(x)
 
 Return a string giving a brief description of a value. By default returns
-`string(typeof(x))`, e.g. `Int64`.
+`string(typeof(x))`, e.g. [`Int64`](@ref).
 
 For arrays, returns a string of size and type info,
 e.g. `10-element Array{Int64,1}`.
@@ -1660,14 +1737,14 @@ end
 
 show(io::IO, X::AbstractArray) = showarray(io, X, true)
 
-repremptyarray{T}(io::IO, X::Array{T}) = print(io, "Array{$T}(", join(size(X),','), ')')
+repremptyarray(io::IO, X::Array{T}) where {T} = print(io, "Array{$T}(", join(size(X),','), ')')
 repremptyarray(io, X) = nothing # by default, we don't know this constructor
 
 function showarray(io::IO, X::AbstractArray, repr::Bool = true; header = true)
     if repr && ndims(X) == 1
         return show_vector(io, X, "[", "]")
     end
-    if !haskey(io, :compact)
+    if !haskey(io, :compact) && length(indices(X, 2)) > 1
         io = IOContext(io, :compact => true)
     end
     if !repr && get(io, :limit, false) && eltype(X) === Method
@@ -1705,15 +1782,20 @@ function showarray(io::IO, X::AbstractArray, repr::Bool = true; header = true)
     end
 end
 
-showall(x) = showall(STDOUT, x)
-function showall(io::IO, x)
-    if !get(io, :limit, false)
-        show(io, x)
-    else
-        show(IOContext(io, :limit => false), x)
-    end
-end
+"""
+    showcompact(x)
+    showcompact(io::IO, x)
 
+Show a compact representation of a value to `io`. If `io` is not specified, the
+default is to print to [`STDOUT`](@ref).
+
+This is used for printing array elements without repeating type information (which would
+be redundant with that printed once for the whole array), and without line breaks inside
+the representation of an element.
+
+To offer a compact representation different from its standard one, a custom type should
+test `get(io, :compact, false)` in its normal [`show`](@ref) method.
+"""
 showcompact(x) = showcompact(STDOUT, x)
 function showcompact(io::IO, x)
     if get(io, :compact, false)
diff --git a/base/simdloop.jl b/base/simdloop.jl
index 9f1946e35ee15f..d83f51916acd5a 100644
--- a/base/simdloop.jl
+++ b/base/simdloop.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Support for @simd for
 
diff --git a/base/socket.jl b/base/socket.jl
index 421e6fece73d4d..fd1298fdb5f9f3 100644
--- a/base/socket.jl
+++ b/base/socket.jl
@@ -1,9 +1,9 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## IP ADDRESS HANDLING ##
 abstract type IPAddr end
 
-Base.isless{T<:IPAddr}(a::T, b::T) = isless(a.host, b.host)
+Base.isless(a::T, b::T) where {T<:IPAddr} = isless(a.host, b.host)
 Base.convert(dt::Type{<:Integer}, ip::IPAddr) = dt(ip.host)
 
 struct IPv4 <: IPAddr
@@ -24,7 +24,7 @@ end
 """
     IPv4(host::Integer) -> IPv4
 
-Returns an IPv4 object from ip address `host` formatted as an `Integer`.
+Returns an IPv4 object from ip address `host` formatted as an [`Integer`](@ref).
 
 ```jldoctest
 julia> IPv4(3223256218)
@@ -76,7 +76,7 @@ end
 """
     IPv6(host::Integer) -> IPv6
 
-Returns an IPv6 object from ip address `host` formatted as an `Integer`.
+Returns an IPv6 object from ip address `host` formatted as an [`Integer`](@ref).
 
 ```jldoctest
 julia> IPv6(3223256218)
@@ -199,7 +199,7 @@ function parseipv6fields(fields,num_fields)
     cf = 7
     ret = UInt128(0)
     for f in fields
-        if f == ""
+        if isempty(f)
             # ::abc:... and ..:abc::
             if cf != 7 && cf != 0
                 cf -= num_fields-length(fields)
@@ -282,10 +282,14 @@ mutable struct TCPSocket <: LibuvStream
         return tcp
     end
 end
-function TCPSocket()
+
+# kw arg "delay": if true, libuv delays creation of the socket fd till the first bind call
+function TCPSocket(; delay=true)
     tcp = TCPSocket(Libc.malloc(_sizeof_uv_tcp), StatusUninit)
-    err = ccall(:uv_tcp_init, Cint, (Ptr{Void}, Ptr{Void}),
-                eventloop(), tcp.handle)
+    af_spec = delay ? 0 : 2   # AF_UNSPEC is 0, AF_INET is 2
+
+    err = ccall(:uv_tcp_init_ex, Cint, (Ptr{Void}, Ptr{Void}, Cuint),
+                eventloop(), tcp.handle, af_spec)
     uv_error("failed to create tcp socket", err)
     tcp.status = StatusInit
     return tcp
@@ -325,7 +329,7 @@ iswritable(io::TCPSocket) = isopen(io) && io.status != StatusClosing
 _jl_connect_raw(sock::TCPSocket, sockaddr::Ptr{Void}) =
     ccall(:jl_connect_raw, Int32, (Ptr{Void}, Ptr{Void}, Ptr{Void}), sock.handle, sockaddr, uv_jl_connectcb::Ptr{Void})
 _jl_sockaddr_from_addrinfo(addrinfo::Ptr{Void}) =
-    ccall(:jl_sockaddr_from_addrinfo, Ptr{Void}, (Ptr{Void}, ), addrinfo)
+    ccall(:jl_sockaddr_from_addrinfo, Ptr{Void}, (Ptr{Void},), addrinfo)
 _jl_sockaddr_set_port(ptr::Ptr{Void}, port::UInt16) =
     ccall(:jl_sockaddr_set_port, Void, (Ptr{Void}, UInt16), ptr, port)
 
@@ -451,8 +455,8 @@ Set UDP socket options.
 
 * `multicast_loop`: loopback for multicast packets (default: `true`).
 * `multicast_ttl`: TTL for multicast packets (default: `nothing`).
-* `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`).
+* `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 (default: `nothing`).
 """
 function setopt(sock::UDPSocket; multicast_loop = nothing, multicast_ttl=nothing, enable_broadcast=nothing, ttl=nothing)
@@ -589,18 +593,18 @@ function uv_getaddrinfocb(req::Ptr{Void}, status::Cint, addrinfo::Ptr{Void})
     cb = unsafe_pointer_to_objref(data)::Function
     pop!(callback_dict,cb) # using pop forces an error if cb not in callback_dict
     if status != 0 || addrinfo == C_NULL
-        cb(UVError("uv_getaddrinfocb received an unexpected status code", status))
+        invokelatest(cb, UVError("uv_getaddrinfocb received an unexpected status code", status))
     else
         freeaddrinfo = addrinfo
         while addrinfo != C_NULL
             sockaddr = ccall(:jl_sockaddr_from_addrinfo, Ptr{Void}, (Ptr{Void},), addrinfo)
             if ccall(:jl_sockaddr_is_ip4, Int32, (Ptr{Void},), sockaddr) == 1
-                cb(IPv4(ntoh(ccall(:jl_sockaddr_host4, UInt32, (Ptr{Void},), sockaddr))))
+                invokelatest(cb, IPv4(ntoh(ccall(:jl_sockaddr_host4, UInt32, (Ptr{Void},), sockaddr))))
                 break
             #elseif ccall(:jl_sockaddr_is_ip6, Int32, (Ptr{Void},), sockaddr) == 1
-            #    host = Array{UInt128}(1)
+            #    host = Vector{UInt128}(1)
             #    scope_id = ccall(:jl_sockaddr_host6, UInt32, (Ptr{Void}, Ptr{UInt128}), sockaddr, host)
-            #    cb(IPv6(ntoh(host[1])))
+            #    invokelatest(cb, IPv6(ntoh(host[1])))
             #    break
             end
             addrinfo = ccall(:jl_next_from_addrinfo, Ptr{Void}, (Ptr{Void},), addrinfo)
@@ -684,7 +688,7 @@ function getipaddr()
             return rv
         # Uncomment to enbable IPv6
         #elseif ccall(:jl_sockaddr_in_is_ip6, Int32, (Ptr{Void},), sockaddr) == 1
-        #   host = Array{UInt128}(1)
+        #   host = Vector{UInt128}(1)
         #   ccall(:jl_sockaddr_host6, UInt32, (Ptr{Void}, Ptr{UInt128}), sockaddrr, host)
         #   return IPv6(ntoh(host[1]))
         end
@@ -822,6 +826,10 @@ function listenany(host::IPAddr, default_port)
     while true
         sock = TCPServer()
         if bind(sock, addr) && trylisten(sock) == 0
+            if default_port == 0
+                _addr, port = getsockname(sock)
+                return (port, sock)
+            end
             return (addr.port, sock)
         end
         close(sock)
@@ -837,34 +845,57 @@ listenany(default_port) = listenany(IPv4(UInt32(0)), default_port)
 """
     getsockname(sock::Union{TCPServer, TCPSocket}) -> (IPAddr, UInt16)
 
-Get the IP address and the port that the given `TCPSocket` is connected to
-(or bound to, in the case of `TCPServer`).
+Get the IP address and port that the given socket is bound to.
+"""
+getsockname(sock::Union{TCPSocket, TCPServer}) = _sockname(sock, true)
+
+
+"""
+    getpeername(sock::TCPSocket) -> (IPAddr, UInt16)
+
+Get the IP address and port of the remote endpoint that the given
+socket is connected to. Valid only for connected TCP sockets.
 """
-function getsockname(sock::Union{TCPServer,TCPSocket})
+getpeername(sock::TCPSocket) = _sockname(sock, false)
+
+function _sockname(sock, self=true)
     rport = Ref{Cushort}(0)
     raddress = zeros(UInt8, 16)
     rfamily = Ref{Cuint}(0)
-    r = if isa(sock, TCPServer)
-        ccall(:jl_tcp_getsockname, Int32,
+
+    if self
+        r = ccall(:jl_tcp_getsockname, Int32,
                 (Ptr{Void}, Ref{Cushort}, Ptr{Void}, Ref{Cuint}),
                 sock.handle, rport, raddress, rfamily)
     else
-        ccall(:jl_tcp_getpeername, Int32,
+        r = 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[])
+        af_inet6 = @static if Sys.iswindows() # AF_INET6 in <sys/socket.h>
+            23
+        elseif Sys.isapple()
+            30
+        elseif Sys.KERNEL ∈ (:FreeBSD, :DragonFly)
+            28
+        elseif Sys.KERNEL ∈ (:NetBSD, :OpenBSD)
+            24
+        else
+            10
+        end
+
         if rfamily[] == 2 # AF_INET
             addrv4 = raddress[1:4]
             naddr = ntoh(unsafe_load(Ptr{Cuint}(pointer(addrv4)), 1))
             addr = IPv4(naddr)
-        elseif rfamily[] == @static is_windows() ? 23 : (@static is_apple() ? 30 : 10) # AF_INET6
+        elseif rfamily[] == af_inet6
             naddr = ntoh(unsafe_load(Ptr{UInt128}(pointer(raddress)), 1))
             addr = IPv6(naddr)
         else
-            error("unsupported address family: $(getindex(rfamily))")
+            error(string("unsupported address family: ", getindex(rfamily)))
         end
     else
         error("cannot obtain socket name")
diff --git a/base/sort.jl b/base/sort.jl
index 78330f425d8cc0..717de598a23aae 100644
--- a/base/sort.jl
+++ b/base/sort.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module Sort
 
@@ -63,6 +63,7 @@ end
 Test whether a vector is in sorted order. The `lt`, `by` and `rev` keywords modify what
 order is considered to be sorted just as they do for [`sort`](@ref).
 
+# Examples
 ```jldoctest
 julia> issorted([1, 2, 3])
 true
@@ -72,6 +73,9 @@ true
 
 julia> issorted([(1, "b"), (2, "a")], by = x -> x[2])
 false
+
+julia> issorted([(1, "b"), (2, "a")], by = x -> x[2], rev=true)
+true
 ```
 """
 issorted(itr;
@@ -215,6 +219,72 @@ for s in [:searchsortedfirst, :searchsortedlast, :searchsorted]
     end
 end
 
+"""
+    searchsorted(a, x, [by=<transform>,] [lt=<comparison>,] [rev=false])
+
+Return the range of indices of `a` which compare as equal to `x` (using binary search)
+according to the order specified by the `by`, `lt` and `rev` keywords, assuming that `a`
+is already sorted in that order. Return an empty range located at the insertion point
+if `a` does not contain values equal to `x`.
+
+# Examples
+```jldoctest
+julia> a = [4, 3, 2, 1]
+4-element Array{Int64,1}:
+ 4
+ 3
+ 2
+ 1
+
+julia> searchsorted(a, 4)
+5:4
+
+julia> searchsorted(a, 4, rev=true)
+1:1
+```
+""" searchsorted
+
+"""
+    searchsortedfirst(a, x, [by=<transform>,] [lt=<comparison>,] [rev=false])
+
+Return the index of the first value in `a` greater than or equal to `x`, according to the
+specified order. Return `length(a) + 1` if `x` is greater than all values in `a`.
+`a` is assumed to be sorted.
+
+# Examples
+```jldoctest
+julia> searchsortedfirst([1, 2, 4, 5, 14], 4)
+3
+
+julia> searchsortedfirst([1, 2, 4, 5, 14], 4, rev=true)
+1
+
+julia> searchsortedfirst([1, 2, 4, 5, 14], 15)
+6
+```
+""" searchsortedfirst
+
+"""
+    searchsortedlast(a, x, [by=<transform>,] [lt=<comparison>,] [rev=false])
+
+Return the index of the last value in `a` less than or equal to `x`, according to the
+specified order. Return `0` if `x` is less than all values in `a`. `a` is assumed to
+be sorted.
+
+# Examples
+```jldoctest
+julia> searchsortedlast([1, 2, 4, 5, 14], 4)
+3
+
+julia> searchsortedlast([1, 2, 4, 5, 14], 4, rev=true)
+5
+
+julia> searchsortedlast([1, 2, 4, 5, 14], -1)
+0
+```
+""" searchsortedlast
+
+
 ## sorting algorithms ##
 
 abstract type Algorithm end
@@ -444,6 +514,7 @@ options are independent and can be used together in all possible combinations: i
 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.
 
+# Examples
 ```jldoctest
 julia> v = [3, 1, 2]; sort!(v); v
 3-element Array{Int64,1}:
@@ -519,6 +590,7 @@ end
 
 Variant of [`sort!`](@ref) that returns a sorted copy of `v` leaving `v` itself unmodified.
 
+# Examples
 ```jldoctest
 julia> v = [3, 1, 2];
 
@@ -575,6 +647,7 @@ specified using the same keywords as `sort!`.
 
 See also [`sortperm!`](@ref).
 
+# Examples
 ```jldoctest
 julia> v = [3, 1, 2];
 
@@ -623,6 +696,7 @@ end
 Like [`sortperm`](@ref), but accepts a preallocated index vector `ix`.  If `initialized` is `false`
 (the default), `ix` is initialized to contain the values `1:length(v)`.
 
+# Examples
 ```jldoctest
 julia> v = [3, 1, 2]; p = zeros(Int, 3);
 
@@ -688,6 +762,7 @@ Sort a multidimensional array `A` along the given dimension.
 See [`sort!`](@ref) for a description of possible
 keyword arguments.
 
+# Examples
 ```jldoctest
 julia> A = [4 3; 1 2]
 2×2 Array{Int64,2}:
@@ -742,6 +817,27 @@ end
 Sort the rows of matrix `A` lexicographically.
 See [`sort!`](@ref) for a description of possible
 keyword arguments.
+
+# Examples
+```jldoctest
+julia> sortrows([7 3 5; -1 6 4; 9 -2 8])
+3×3 Array{Int64,2}:
+ -1   6  4
+  7   3  5
+  9  -2  8
+
+julia> sortrows([7 3 5; -1 6 4; 9 -2 8], lt=(x,y)->isless(x[2],y[2]))
+3×3 Array{Int64,2}:
+  9  -2  8
+  7   3  5
+ -1   6  4
+
+julia> sortrows([7 3 5; -1 6 4; 9 -2 8], rev=true)
+3×3 Array{Int64,2}:
+  9  -2  8
+  7   3  5
+ -1   6  4
+```
 """
 function sortrows(A::AbstractMatrix; kws...)
     inds = indices(A,1)
@@ -760,6 +856,27 @@ end
 Sort the columns of matrix `A` lexicographically.
 See [`sort!`](@ref) for a description of possible
 keyword arguments.
+
+# Examples
+```jldoctest
+julia> sortcols([7 3 5; 6 -1 -4; 9 -2 8])
+3×3 Array{Int64,2}:
+  3   5  7
+ -1  -4  6
+ -2   8  9
+
+julia> sortcols([7 3 5; 6 -1 -4; 9 -2 8], alg=InsertionSort, lt=(x,y)->isless(x[2],y[2]))
+3×3 Array{Int64,2}:
+  5   3  7
+ -4  -1  6
+  8  -2  9
+
+julia> sortcols([7 3 5; 6 -1 -4; 9 -2 8], rev=true)
+3×3 Array{Int64,2}:
+ 7   5   3
+ 6  -4  -1
+ 9   8  -2
+```
 """
 function sortcols(A::AbstractMatrix; kws...)
     inds = indices(A,2)
@@ -772,13 +889,13 @@ function sortcols(A::AbstractMatrix; kws...)
     A[:,p]
 end
 
-function slicetypeof{T}(A::AbstractArray{T}, i1, i2)
+function slicetypeof(A::AbstractArray{T}, i1, i2) where T
     I = map(slice_dummy, to_indices(A, (i1, i2)))
     fast = isa(IndexStyle(viewindexing(I), IndexStyle(A)), IndexLinear)
     SubArray{T,1,typeof(A),typeof(I),fast}
 end
 slice_dummy(S::Slice) = S
-slice_dummy{T}(::AbstractUnitRange{T}) = oneunit(T)
+slice_dummy(::AbstractUnitRange{T}) where {T} = oneunit(T)
 
 ## fast clever sorting for floats ##
 
@@ -801,8 +918,8 @@ right(::DirectOrdering) = Right()
 left(o::Perm) = Perm(left(o.order), o.data)
 right(o::Perm) = Perm(right(o.order), o.data)
 
-lt{T<:Floats}(::Left, x::T, y::T) = slt_int(y, x)
-lt{T<:Floats}(::Right, x::T, y::T) = slt_int(x, y)
+lt(::Left, x::T, y::T) where {T<:Floats} = slt_int(y, x)
+lt(::Right, x::T, y::T) where {T<:Floats} = slt_int(x, y)
 
 isnan(o::DirectOrdering, x::Floats) = (x!=x)
 isnan(o::Perm, i::Int) = isnan(o.order,o.data[i])
diff --git a/base/sparse/abstractsparse.jl b/base/sparse/abstractsparse.jl
index 9e7281e392f59f..e17d3be97dbcbb 100644
--- a/base/sparse/abstractsparse.jl
+++ b/base/sparse/abstractsparse.jl
@@ -1,9 +1,9 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 abstract type AbstractSparseArray{Tv,Ti,N} <: AbstractArray{Tv,N} end
 
-AbstractSparseVector{Tv,Ti} = AbstractSparseArray{Tv,Ti,1}
-AbstractSparseMatrix{Tv,Ti} = AbstractSparseArray{Tv,Ti,2}
+const AbstractSparseVector{Tv,Ti} = AbstractSparseArray{Tv,Ti,1}
+const AbstractSparseMatrix{Tv,Ti} = AbstractSparseArray{Tv,Ti,2}
 
 """
     issparse(S)
@@ -20,4 +20,4 @@ issparse(S::LinAlg.UnitLowerTriangular{<:Any,<:AbstractSparseMatrix}) = true
 issparse(S::UpperTriangular{<:Any,<:AbstractSparseMatrix}) = true
 issparse(S::LinAlg.UnitUpperTriangular{<:Any,<:AbstractSparseMatrix}) = true
 
-indtype{Tv,Ti}(S::AbstractSparseArray{Tv,Ti}) = (Base.@_pure_meta; Ti)
+indtype(S::AbstractSparseArray{<:Any,Ti}) where {Ti} = Ti
diff --git a/base/sparse/cholmod.jl b/base/sparse/cholmod.jl
index 451d200c6ad87d..5351a0717c041d 100644
--- a/base/sparse/cholmod.jl
+++ b/base/sparse/cholmod.jl
@@ -1,13 +1,13 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module CHOLMOD
 
-import Base: (*), convert, copy, eltype, get, getindex, show, size,
+import Base: (*), convert, copy, eltype, getindex, show, size,
              IndexStyle, IndexLinear, IndexCartesian, ctranspose
 
 import Base.LinAlg: (\), A_mul_Bc, A_mul_Bt, Ac_ldiv_B, Ac_mul_B, At_ldiv_B, At_mul_B,
                  cholfact, cholfact!, det, diag, ishermitian, isposdef,
-                 issymmetric, ldltfact, ldltfact!, logdet
+                 issuccess, issymmetric, ldltfact, ldltfact!, logdet
 
 importall ..SparseArrays
 
@@ -29,7 +29,7 @@ const CHOLMOD_MIN_VERSION = v"2.1.1"
 ### These offsets are defined in SuiteSparse_wrapper.c
 const common_size = ccall((:jl_cholmod_common_size,:libsuitesparse_wrapper),Int,())
 
-const cholmod_com_offsets = Array{Csize_t}(19)
+const cholmod_com_offsets = Vector{Csize_t}(19)
 ccall((:jl_cholmod_common_offsets, :libsuitesparse_wrapper),
     Void, (Ptr{Csize_t},), cholmod_com_offsets)
 
@@ -58,7 +58,7 @@ end
 
 common() = commonStruct
 
-const build_version_array = Array{Cint}(3)
+const build_version_array = Vector{Cint}(3)
 ccall((:jl_cholmod_version, :libsuitesparse_wrapper), Cint, (Ptr{Cint},), build_version_array)
 const build_version = VersionNumber(build_version_array...)
 
@@ -66,7 +66,7 @@ function __init__()
     try
         ### Check if the linked library is compatible with the Julia code
         if Libdl.dlsym_e(Libdl.dlopen("libcholmod"), :cholmod_version) != C_NULL
-            current_version_array = Array{Cint}(3)
+            current_version_array = Vector{Cint}(3)
             ccall((:cholmod_version, :libcholmod), Cint, (Ptr{Cint},), current_version_array)
             current_version = VersionNumber(current_version_array...)
         else # CHOLMOD < 2.1.1 does not include cholmod_version()
@@ -196,7 +196,17 @@ end
 
 mutable struct Dense{T<:VTypes} <: DenseMatrix{T}
     p::Ptr{C_Dense{T}}
+    function Dense{Tv}(p::Ptr{C_Dense{Tv}}) where Tv<:VTypes
+        if p == C_NULL
+            throw(ArgumentError("dense matrix construction failed for " *
+                "unknown reasons. Please submit a bug report."))
+        end
+        A = new(p)
+        finalizer(A, free!)
+        return A
+    end
 end
+Dense(p::Ptr{C_Dense{Tv}}) where {Tv<:VTypes} = Dense{Tv}(p)
 
 # Sparse
 struct C_Sparse{Tv<:VTypes} <: SuiteSparseStruct
@@ -243,10 +253,14 @@ mutable struct Sparse{Tv<:VTypes} <: AbstractSparseMatrix{Tv,SuiteSparse_long}
             throw(ArgumentError("sparse matrix construction failed for " *
                 "unknown reasons. Please submit a bug report."))
         end
-        new(p)
+        A = new(p)
+        finalizer(A, free!)
+        return A
     end
 end
-Sparse(p::Ptr{C_Sparse{Tv}}) where Tv<:VTypes = Sparse{Tv}(p)
+Sparse(p::Ptr{C_Sparse{Tv}}) where {Tv<:VTypes} = Sparse{Tv}(p)
+
+Base.unsafe_convert(::Type{Ptr{Tv}}, A::Sparse{Tv}) where {Tv} = A.p
 
 # Factor
 
@@ -317,35 +331,41 @@ end
 
 mutable struct Factor{Tv} <: Factorization{Tv}
     p::Ptr{C_Factor{Tv}}
-    function Factor{Tv}(p::Ptr{C_Factor{Tv}}) where Tv
+    function Factor{Tv}(p::Ptr{C_Factor{Tv}}, register_finalizer = true) where Tv
         if p == C_NULL
             throw(ArgumentError("factorization construction failed for " *
                 "unknown reasons. Please submit a bug report."))
         end
-        new(p)
+        F = new(p)
+        if register_finalizer
+            finalizer(F, free!)
+        end
+        return F
     end
 end
-Factor(p::Ptr{C_Factor{Tv}}) where Tv<:VTypes = Factor{Tv}(p)
+Factor(p::Ptr{C_Factor{Tv}}) where {Tv<:VTypes} = 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
+# All pointer loads should be checked 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
+function Base.unsafe_convert(::Type{Ptr{T}}, x::Union{Dense,Sparse,Factor}) where T<:SuiteSparseStruct
+    if x.p == C_NULL
         throw(ArgumentError("pointer to the $T object is null. This can " *
             "happen if the object has been serialized."))
     else
-        return p
+        return x.p
     end
 end
+Base.pointer(x::Dense{Tv}) where {Tv}  = Base.unsafe_convert(Ptr{C_Dense{Tv}}, x)
+Base.pointer(x::Sparse{Tv}) where {Tv} = Base.unsafe_convert(Ptr{C_Sparse{Tv}}, x)
+Base.pointer(x::Factor{Tv}) where {Tv} = Base.unsafe_convert(Ptr{C_Factor{Tv}}, x)
 
 # FactorComponent, for encoding particular factors from a factorization
 mutable struct FactorComponent{Tv,S} <: AbstractMatrix{Tv}
     F::Factor{Tv}
 
     function FactorComponent{Tv,S}(F::Factor{Tv}) where {Tv,S}
-        s = unsafe_load(get(F.p))
+        s = unsafe_load(pointer(F))
         if s.is_ll != 0
             if !(S == :L || S == :U || S == :PtL || S == :UP)
                 throw(CHOLMODException(string(S, " not supported for sparse ",
@@ -375,69 +395,57 @@ Factor(FC::FactorComponent) = Factor(FC.F)
 
 ### cholmod_core_h ###
 function allocate_dense(nrow::Integer, ncol::Integer, d::Integer, ::Type{Float64})
-    d = Dense(ccall((:cholmod_l_allocate_dense, :libcholmod), Ptr{C_Dense{Float64}},
+    Dense(ccall((:cholmod_l_allocate_dense, :libcholmod), Ptr{C_Dense{Float64}},
         (Csize_t, Csize_t, Csize_t, Cint, Ptr{Void}),
         nrow, ncol, d, REAL, common()))
-    finalizer(d, free!)
-    d
 end
 function allocate_dense(nrow::Integer, ncol::Integer, d::Integer, ::Type{Complex{Float64}})
-    d = Dense(ccall((:cholmod_l_allocate_dense, :libcholmod), Ptr{C_Dense{Complex{Float64}}},
+    Dense(ccall((:cholmod_l_allocate_dense, :libcholmod), Ptr{C_Dense{Complex{Float64}}},
         (Csize_t, Csize_t, Csize_t, Cint, Ptr{Void}),
         nrow, ncol, d, COMPLEX, common()))
-    finalizer(d, free!)
-    d
 end
 
-free_dense!{T}(p::Ptr{C_Dense{T}}) = ccall((:cholmod_l_free_dense, :libcholmod),
+free_dense!(p::Ptr{C_Dense{T}}) where {T} = ccall((:cholmod_l_free_dense, :libcholmod),
     Cint, (Ref{Ptr{C_Dense{T}}}, Ptr{Void}), p, common())
 
-function zeros{T<:VTypes}(m::Integer, n::Integer, ::Type{T})
-    d = Dense(ccall((:cholmod_l_zeros, :libcholmod), Ptr{C_Dense{T}},
+function zeros(m::Integer, n::Integer, ::Type{T}) where T<:VTypes
+    Dense(ccall((:cholmod_l_zeros, :libcholmod), Ptr{C_Dense{T}},
         (Csize_t, Csize_t, Cint, Ptr{UInt8}),
          m, n, xtyp(T), common()))
-    finalizer(d, free!)
-    d
 end
 zeros(m::Integer, n::Integer) = zeros(m, n, Float64)
 
-function ones{T<:VTypes}(m::Integer, n::Integer, ::Type{T})
-    d = Dense(ccall((:cholmod_l_ones, :libcholmod), Ptr{C_Dense{T}},
+function ones(m::Integer, n::Integer, ::Type{T}) where T<:VTypes
+    Dense(ccall((:cholmod_l_ones, :libcholmod), Ptr{C_Dense{T}},
         (Csize_t, Csize_t, Cint, Ptr{UInt8}),
          m, n, xtyp(T), common()))
-    finalizer(d, free!)
-    d
 end
 ones(m::Integer, n::Integer) = ones(m, n, Float64)
 
-function eye{T<:VTypes}(m::Integer, n::Integer, ::Type{T})
-    d = Dense(ccall((:cholmod_l_eye, :libcholmod), Ptr{C_Dense{T}},
+function eye(m::Integer, n::Integer, ::Type{T}) where T<:VTypes
+    Dense(ccall((:cholmod_l_eye, :libcholmod), Ptr{C_Dense{T}},
         (Csize_t, Csize_t, Cint, Ptr{UInt8}),
          m, n, xtyp(T), common()))
-    finalizer(d, free!)
-    d
 end
 eye(m::Integer, n::Integer) = eye(m, n, Float64)
 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}},
+function copy_dense(A::Dense{Tv}) where Tv<:VTypes
+    Dense(ccall((:cholmod_l_copy_dense, :libcholmod), Ptr{C_Dense{Tv}},
         (Ptr{C_Dense{Tv}}, Ptr{UInt8}),
-         get(A.p), common()))
-    finalizer(d, free!)
-    d
+         A, common()))
 end
 
-function sort!{Tv<:VTypes}(S::Sparse{Tv})
+function sort!(S::Sparse{Tv}) where Tv<:VTypes
     @isok ccall((:cholmod_l_sort, :libcholmod), SuiteSparse_long,
         (Ptr{C_Sparse{Tv}}, Ptr{UInt8}),
-         get(S.p), common())
+         S, common())
     return S
 end
 
 ### cholmod_matrixops.h ###
-function norm_dense{Tv<:VTypes}(D::Dense{Tv}, p::Integer)
-    s = unsafe_load(get(D.p))
+function norm_dense(D::Dense{Tv}, p::Integer) where Tv<:VTypes
+    s = unsafe_load(pointer(D))
     if p == 2
         if s.ncol > 1
             throw(ArgumentError("2 norm only supported when matrix has one column"))
@@ -447,41 +455,37 @@ 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}),
-          get(D.p), p, common())
+          D, p, common())
 end
 
 ### cholmod_check.h ###
-function check_dense{T<:VTypes}(A::Dense{T})
+function check_dense(A::Dense{T}) where T<:VTypes
     ccall((:cholmod_l_check_dense, :libcholmod), Cint,
           (Ptr{C_Dense{T}}, Ptr{UInt8}),
-          A.p, common())!=0
+          A.p, common()) != 0
 end
 
 # Non-Dense wrappers
 ### cholmod_core.h ###
 function allocate_sparse(nrow::Integer, ncol::Integer, nzmax::Integer,
         sorted::Bool, packed::Bool, stype::Integer, ::Type{Float64})
-    s = Sparse(ccall((@cholmod_name("allocate_sparse", SuiteSparse_long), :libcholmod),
+    Sparse(ccall((@cholmod_name("allocate_sparse", SuiteSparse_long), :libcholmod),
             Ptr{C_Sparse{Float64}},
                 (Csize_t, Csize_t, Csize_t, Cint,
                  Cint, Cint, Cint, Ptr{Void}),
                 nrow, ncol, nzmax, sorted,
                 packed, stype, REAL, common()))
-    finalizer(s, free!)
-    s
 end
 function allocate_sparse(nrow::Integer, ncol::Integer, nzmax::Integer,
         sorted::Bool, packed::Bool, stype::Integer, ::Type{Complex{Float64}})
-    s = Sparse(ccall((@cholmod_name("allocate_sparse", SuiteSparse_long), :libcholmod),
+    Sparse(ccall((@cholmod_name("allocate_sparse", SuiteSparse_long), :libcholmod),
             Ptr{C_Sparse{Complex{Float64}}},
                 (Csize_t, Csize_t, Csize_t, Cint,
                  Cint, Cint, Cint, Ptr{Void}),
                 nrow, ncol, nzmax, sorted,
                 packed, stype, COMPLEX, common()))
-    finalizer(s, free!)
-    s
 end
-function free_sparse!{Tv<:VTypes}(ptr::Ptr{C_Sparse{Tv}})
+function free_sparse!(ptr::Ptr{C_Sparse{Tv}}) where Tv<:VTypes
     @isok ccall((@cholmod_name("free_sparse", SuiteSparse_long), :libcholmod), Cint,
             (Ptr{Ptr{C_Sparse{Tv}}}, Ptr{UInt8}),
                 &ptr, common())
@@ -493,194 +497,172 @@ function free_sparse!(ptr::Ptr{C_SparseVoid})
                 &ptr, common())
 end
 
-function free_factor!{Tv<:VTypes}(ptr::Ptr{C_Factor{Tv}})
+function free_factor!(ptr::Ptr{C_Factor{Tv}}) where Tv<:VTypes
     # Warning! Important that finalizer doesn't modify the global Common struct.
     @isok ccall((@cholmod_name("free_factor", SuiteSparse_long), :libcholmod), Cint,
             (Ptr{Ptr{C_Factor{Tv}}}, Ptr{Void}),
                 &ptr, common())
 end
 
-function aat{Tv<:VRealTypes}(A::Sparse{Tv}, fset::Vector{SuiteSparse_long}, mode::Integer)
-    s = Sparse(ccall((@cholmod_name("aat", SuiteSparse_long), :libcholmod),
+function aat(A::Sparse{Tv}, fset::Vector{SuiteSparse_long}, mode::Integer) where Tv<:VRealTypes
+    Sparse(ccall((@cholmod_name("aat", SuiteSparse_long), :libcholmod),
         Ptr{C_Sparse{Tv}},
             (Ptr{C_Sparse{Tv}}, Ptr{SuiteSparse_long}, Csize_t, Cint, Ptr{UInt8}),
-                get(A.p), fset, length(fset), mode, common()))
-    finalizer(s, free!)
-    s
+                A, fset, length(fset), mode, common()))
 end
 
-function sparse_to_dense{Tv<:VTypes}(A::Sparse{Tv})
-    d = Dense(ccall((@cholmod_name("sparse_to_dense", SuiteSparse_long),:libcholmod),
+function sparse_to_dense(A::Sparse{Tv}) where Tv<:VTypes
+    Dense(ccall((@cholmod_name("sparse_to_dense", SuiteSparse_long),:libcholmod),
         Ptr{C_Dense{Tv}},
             (Ptr{C_Sparse{Tv}}, Ptr{UInt8}),
-                get(A.p), common()))
-    finalizer(d, free!)
-    d
+                A, common()))
 end
-function dense_to_sparse{Tv<:VTypes}(D::Dense{Tv}, ::Type{SuiteSparse_long})
-    s = Sparse(ccall((@cholmod_name("dense_to_sparse", SuiteSparse_long),:libcholmod),
+function dense_to_sparse(D::Dense{Tv}, ::Type{SuiteSparse_long}) where Tv<:VTypes
+    Sparse(ccall((@cholmod_name("dense_to_sparse", SuiteSparse_long),:libcholmod),
         Ptr{C_Sparse{Tv}},
             (Ptr{C_Dense{Tv}}, Cint, Ptr{UInt8}),
-                get(D.p), true, common()))
-    finalizer(s, free!)
-    s
+                D, true, common()))
 end
 
-function factor_to_sparse!{Tv<:VTypes}(F::Factor{Tv})
-    ss = unsafe_load(F.p)
+function factor_to_sparse!(F::Factor{Tv}) where Tv<:VTypes
+    ss = unsafe_load(pointer(F))
     ss.xtype > PATTERN || throw(CHOLMODException("only numeric factors are supported"))
-    s = Sparse(ccall((@cholmod_name("factor_to_sparse", SuiteSparse_long),:libcholmod),
+    Sparse(ccall((@cholmod_name("factor_to_sparse", SuiteSparse_long),:libcholmod),
         Ptr{C_Sparse{Tv}},
             (Ptr{C_Factor{Tv}}, Ptr{UInt8}),
-                get(F.p), common()))
-    finalizer(s, free!)
-    s
+                F, common()))
 end
 
-function change_factor!{Tv<:VTypes}(::Type{Float64}, to_ll::Bool,
-        to_super::Bool, to_packed::Bool, to_monotonic::Bool, F::Factor{Tv})
+function change_factor!(::Type{Float64}, to_ll::Bool,
+        to_super::Bool, to_packed::Bool, to_monotonic::Bool, F::Factor{Tv}) where Tv<:VTypes
     @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, get(F.p), common())
-    Factor{Float64}(F.p)
+                REAL, to_ll, to_super, to_packed, to_monotonic, F, common())
+    # don't register finalizer since we reuse object
+    Factor{Float64}(pointer(F), false)
 end
 
-function change_factor!{Tv<:VTypes}(::Type{Complex{Float64}}, to_ll::Bool,
-        to_super::Bool, to_packed::Bool, to_monotonic::Bool, F::Factor{Tv})
+function change_factor!(::Type{Complex{Float64}}, to_ll::Bool,
+        to_super::Bool, to_packed::Bool, to_monotonic::Bool, F::Factor{Tv}) where Tv<:VTypes
     @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, get(F.p), common())
-    Factor{Complex{Float64}}(F.p)
+                COMPLEX, to_ll, to_super, to_packed, to_monotonic, F, common())
+    # don't register finalizer since we reuse object
+    Factor{Complex{Float64}}(pointer(F), false)
 end
 
-function check_sparse{Tv<:VTypes}(A::Sparse{Tv})
+function check_sparse(A::Sparse{Tv}) where Tv<:VTypes
     ccall((@cholmod_name("check_sparse", SuiteSparse_long),:libcholmod), Cint,
           (Ptr{C_Sparse{Tv}}, Ptr{UInt8}),
-          get(A.p), common())!=0
+           A, common()) != 0
 end
 
-function check_factor{Tv<:VTypes}(F::Factor{Tv})
+function check_factor(F::Factor{Tv}) where Tv<:VTypes
     ccall((@cholmod_name("check_factor", SuiteSparse_long),:libcholmod), Cint,
           (Ptr{C_Factor{Tv}}, Ptr{UInt8}),
-          get(F.p), common())!=0
+           F, common()) != 0
 end
 
-function nnz{Tv<:VTypes}(A::Sparse{Tv})
+function nnz(A::Sparse{Tv}) where Tv<:VTypes
     ccall((@cholmod_name("nnz", SuiteSparse_long),:libcholmod), Int,
             (Ptr{C_Sparse{Tv}}, Ptr{UInt8}),
-                get(A.p), common())
+                A, common())
 end
 
-function speye{Tv<:VTypes}(m::Integer, n::Integer, ::Type{Tv})
-    s = Sparse(ccall((@cholmod_name("speye", SuiteSparse_long), :libcholmod),
+function speye(m::Integer, n::Integer, ::Type{Tv}) where Tv<:VTypes
+    Sparse(ccall((@cholmod_name("speye", SuiteSparse_long), :libcholmod),
         Ptr{C_Sparse{Tv}},
             (Csize_t, Csize_t, Cint, Ptr{UInt8}),
                 m, n, xtyp(Tv), common()))
-    finalizer(s, free!)
-    s
 end
 
-function spzeros{Tv<:VTypes}(m::Integer, n::Integer, nzmax::Integer, ::Type{Tv})
-    s = Sparse(ccall((@cholmod_name("spzeros", SuiteSparse_long), :libcholmod),
+function spzeros(m::Integer, n::Integer, nzmax::Integer, ::Type{Tv}) where Tv<:VTypes
+    Sparse(ccall((@cholmod_name("spzeros", SuiteSparse_long), :libcholmod),
         Ptr{C_Sparse{Tv}},
             (Csize_t, Csize_t, Csize_t, Cint, Ptr{UInt8}),
              m, n, nzmax, xtyp(Tv), common()))
-    finalizer(s, free!)
-    s
 end
 
-function transpose_{Tv<:VTypes}(A::Sparse{Tv}, values::Integer)
-    s = Sparse(ccall((@cholmod_name("transpose", SuiteSparse_long),:libcholmod),
+function transpose_(A::Sparse{Tv}, values::Integer) where Tv<:VTypes
+    Sparse(ccall((@cholmod_name("transpose", SuiteSparse_long),:libcholmod),
         Ptr{C_Sparse{Tv}},
             (Ptr{C_Sparse{Tv}}, Cint, Ptr{UInt8}),
-                get(A.p), values, common()))
-    finalizer(s, free!)
-    s
+                A, values, common()))
 end
 
-function copy_factor{Tv<:VTypes}(F::Factor{Tv})
-    f = Factor(ccall((@cholmod_name("copy_factor", SuiteSparse_long),:libcholmod),
+function copy_factor(F::Factor{Tv}) where Tv<:VTypes
+    Factor(ccall((@cholmod_name("copy_factor", SuiteSparse_long),:libcholmod),
         Ptr{C_Factor{Tv}},
             (Ptr{C_Factor{Tv}}, Ptr{UInt8}),
-                get(F.p), common()))
-    finalizer(f, free!)
-    f
+                F, common()))
 end
-function copy_sparse{Tv<:VTypes}(A::Sparse{Tv})
-    s = Sparse(ccall((@cholmod_name("copy_sparse", SuiteSparse_long),:libcholmod),
+function copy_sparse(A::Sparse{Tv}) where Tv<:VTypes
+    Sparse(ccall((@cholmod_name("copy_sparse", SuiteSparse_long),:libcholmod),
         Ptr{C_Sparse{Tv}},
             (Ptr{C_Sparse{Tv}}, Ptr{UInt8}),
-                get(A.p), common()))
-    finalizer(s, free!)
-    s
+                A, common()))
 end
-function copy{Tv<:VRealTypes}(A::Sparse{Tv}, stype::Integer, mode::Integer)
-    s = Sparse(ccall((@cholmod_name("copy", SuiteSparse_long),:libcholmod),
+function copy(A::Sparse{Tv}, stype::Integer, mode::Integer) where Tv<:VRealTypes
+    Sparse(ccall((@cholmod_name("copy", SuiteSparse_long),:libcholmod),
         Ptr{C_Sparse{Tv}},
             (Ptr{C_Sparse{Tv}}, Cint, Cint, Ptr{UInt8}),
-                get(A.p), stype, mode, common()))
-    finalizer(s, free!)
-    s
+                A, stype, mode, common()))
 end
 
 ### cholmod_check.h ###
-function print_sparse{Tv<:VTypes}(A::Sparse{Tv}, name::String)
+function print_sparse(A::Sparse{Tv}, name::String) where Tv<:VTypes
     isascii(name) || error("non-ASCII name: $name")
     cm = common()
     set_print_level(cm, 3)
     @isok ccall((@cholmod_name("print_sparse", SuiteSparse_long),:libcholmod), Cint,
             (Ptr{C_Sparse{Tv}}, Ptr{UInt8}, Ptr{UInt8}),
-                 get(A.p), name, cm)
+                 A, name, cm)
     nothing
 end
-function print_factor{Tv<:VTypes}(F::Factor{Tv}, name::String)
+function print_factor(F::Factor{Tv}, name::String) where Tv<:VTypes
     cm = common()
     set_print_level(cm, 3)
     @isok ccall((@cholmod_name("print_factor", SuiteSparse_long),:libcholmod), Cint,
             (Ptr{C_Factor{Tv}}, Ptr{UInt8}, Ptr{UInt8}),
-                get(F.p), name, cm)
+                F, 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(get(A.p))
-    lB = unsafe_load(get(B.p))
+function ssmult(A::Sparse{Tv}, B::Sparse{Tv}, stype::Integer,
+        values::Bool, sorted::Bool) where Tv<:VRealTypes
+    lA = unsafe_load(pointer(A))
+    lB = unsafe_load(pointer(B))
     if lA.ncol != lB.nrow
         throw(DimensionMismatch("inner matrix dimensions do not fit"))
     end
-    s = Sparse(ccall((@cholmod_name("ssmult", SuiteSparse_long),:libcholmod),
+    Sparse(ccall((@cholmod_name("ssmult", SuiteSparse_long),:libcholmod),
         Ptr{C_Sparse{Tv}},
             (Ptr{C_Sparse{Tv}}, Ptr{C_Sparse{Tv}}, Cint, Cint,
                 Cint, Ptr{UInt8}),
-             get(A.p), get(B.p), stype, values,
+             A, B, stype, values,
                 sorted, common()))
-    finalizer(s, free!)
-    s
 end
 
-function norm_sparse{Tv<:VTypes}(A::Sparse{Tv}, norm::Integer)
+function norm_sparse(A::Sparse{Tv}, norm::Integer) where Tv<:VTypes
     if norm != 0 && norm != 1
         throw(ArgumentError("norm argument must be either 0 or 1"))
     end
     ccall((@cholmod_name("norm_sparse", SuiteSparse_long), :libcholmod), Cdouble,
             (Ptr{C_Sparse{Tv}}, Cint, Ptr{UInt8}),
-                get(A.p), norm, common())
+                A, norm, common())
 end
 
-function horzcat{Tv<:VRealTypes}(A::Sparse{Tv}, B::Sparse{Tv}, values::Bool)
-    s = Sparse(ccall((@cholmod_name("horzcat", SuiteSparse_long), :libcholmod),
+function horzcat(A::Sparse{Tv}, B::Sparse{Tv}, values::Bool) where Tv<:VRealTypes
+    Sparse(ccall((@cholmod_name("horzcat", SuiteSparse_long), :libcholmod),
         Ptr{C_Sparse{Tv}},
             (Ptr{C_Sparse{Tv}}, Ptr{C_Sparse{Tv}}, Cint, Ptr{UInt8}),
-             get(A.p), get(B.p), values, common()))
-    finalizer(s, free!)
-    s
+             A, B, values, common()))
 end
 
-function scale!{Tv<:VRealTypes}(S::Dense{Tv}, scale::Integer, A::Sparse{Tv})
-    sS = unsafe_load(get(S.p))
-    sA = unsafe_load(get(A.p))
+function scale!(S::Dense{Tv}, scale::Integer, A::Sparse{Tv}) where Tv<:VRealTypes
+    sS = unsafe_load(pointer(S))
+    sA = unsafe_load(pointer(A))
     if sS.ncol != 1 && sS.nrow != 1
         throw(DimensionMismatch("first argument must be a vector"))
     end
@@ -701,15 +683,15 @@ function scale!{Tv<:VRealTypes}(S::Dense{Tv}, scale::Integer, A::Sparse{Tv})
         end
     end
 
-    sA = unsafe_load(get(A.p))
+    sA = unsafe_load(pointer(A))
     @isok ccall((@cholmod_name("scale",SuiteSparse_long),:libcholmod), Cint,
             (Ptr{C_Dense{Tv}}, Cint, Ptr{C_Sparse{Tv}}, Ptr{UInt8}),
-                get(S.p), scale, get(A.p), common())
+                S, scale, A, common())
     A
 end
 
-function sdmult!{Tv<:VTypes}(A::Sparse{Tv}, transpose::Bool,
-        α::Number, β::Number, X::Dense{Tv}, Y::Dense{Tv})
+function sdmult!(A::Sparse{Tv}, transpose::Bool,
+        α::Number, β::Number, X::Dense{Tv}, Y::Dense{Tv}) where Tv<:VTypes
     m, n = size(A)
     nc = transpose ? m : n
     nr = transpose ? n : m
@@ -720,93 +702,91 @@ function sdmult!{Tv<:VTypes}(A::Sparse{Tv}, transpose::Bool,
             (Ptr{C_Sparse{Tv}}, Cint,
              Ref{Complex128}, Ref{Complex128},
              Ptr{C_Dense{Tv}}, Ptr{C_Dense{Tv}}, Ptr{UInt8}),
-                get(A.p), transpose, α, β, get(X.p), get(Y.p), common())
+                A, transpose, α, β, X, Y, common())
     Y
 end
 
-function vertcat{Tv<:VRealTypes}(A::Sparse{Tv}, B::Sparse{Tv}, values::Bool)
-    s = Sparse(ccall((@cholmod_name("vertcat", SuiteSparse_long), :libcholmod),
+function vertcat(A::Sparse{Tv}, B::Sparse{Tv}, values::Bool) where Tv<:VRealTypes
+    Sparse(ccall((@cholmod_name("vertcat", SuiteSparse_long), :libcholmod),
             Ptr{C_Sparse{Tv}},
             (Ptr{C_Sparse{Tv}}, Ptr{C_Sparse{Tv}}, Cint, Ptr{UInt8}),
-                get(A.p), get(B.p), values, common()))
-    finalizer(s, free!)
-    s
+                A, B, values, common()))
 end
 
-function symmetry{Tv<:VTypes}(A::Sparse{Tv}, option::Integer)
-    xmatched = Array{SuiteSparse_long}(1)
-    pmatched = Array{SuiteSparse_long}(1)
-    nzoffdiag = Array{SuiteSparse_long}(1)
-    nzdiag = Array{SuiteSparse_long}(1)
+function symmetry(A::Sparse{Tv}, option::Integer) where Tv<:VTypes
+    xmatched = Ref{SuiteSparse_long}()
+    pmatched = Ref{SuiteSparse_long}()
+    nzoffdiag = Ref{SuiteSparse_long}()
+    nzdiag = Ref{SuiteSparse_long}()
     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}),
-                    get(A.p), option, xmatched, pmatched,
+                    A, option, xmatched, pmatched,
                         nzoffdiag, nzdiag, common())
-    rv, xmatched[1], pmatched[1], nzoffdiag[1], nzdiag[1]
+    rv, xmatched[], pmatched[], nzoffdiag[], nzdiag[]
 end
 
 # cholmod_cholesky.h
 # For analyze, analyze_p, and factorize_p!, the Common argument must be
 # supplied in order to control if the factorization is LLt or LDLt
-function analyze{Tv<:VTypes}(A::Sparse{Tv}, cmmn::Vector{UInt8})
-    f = Factor(ccall((@cholmod_name("analyze", SuiteSparse_long),:libcholmod),
+function analyze(A::Sparse{Tv}, cmmn::Vector{UInt8}) where Tv<:VTypes
+    Factor(ccall((@cholmod_name("analyze", SuiteSparse_long),:libcholmod),
         Ptr{C_Factor{Tv}},
             (Ptr{C_Sparse{Tv}}, Ptr{UInt8}),
-                get(A.p), cmmn))
-    finalizer(f, free!)
-    f
+                A, cmmn))
 end
-function analyze_p{Tv<:VTypes}(A::Sparse{Tv}, perm::Vector{SuiteSparse_long},
-    cmmn::Vector{UInt8})
+function analyze_p(A::Sparse{Tv}, perm::Vector{SuiteSparse_long},
+                   cmmn::Vector{UInt8}) where Tv<:VTypes
     length(perm) != size(A,1) && throw(BoundsError())
-    f = Factor(ccall((@cholmod_name("analyze_p", SuiteSparse_long),:libcholmod),
+    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}),
-                get(A.p), perm, C_NULL, 0, cmmn))
-    finalizer(f, free!)
-    f
+                A, perm, C_NULL, 0, cmmn))
 end
-function factorize!{Tv<:VTypes}(A::Sparse{Tv}, F::Factor{Tv}, cmmn::Vector{UInt8})
+function factorize!(A::Sparse{Tv}, F::Factor{Tv}, cmmn::Vector{UInt8}) where Tv<:VTypes
     @isok ccall((@cholmod_name("factorize", SuiteSparse_long),:libcholmod), Cint,
         (Ptr{C_Sparse{Tv}}, Ptr{C_Factor{Tv}}, Ptr{UInt8}),
-            get(A.p), get(F.p), cmmn)
+            A, F, cmmn)
     F
 end
-function factorize_p!{Tv<:VTypes}(A::Sparse{Tv}, β::Real, F::Factor{Tv}, cmmn::Vector{UInt8})
+function factorize_p!(A::Sparse{Tv}, β::Real, F::Factor{Tv}, cmmn::Vector{UInt8}) where Tv<:VTypes
     # note that β is passed as a complex number (double beta[2]),
     # but the CHOLMOD manual says that only beta[0] (real part) is used
     @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}),
-            get(A.p), β, C_NULL, 0, get(F.p), cmmn)
+            A, β, C_NULL, 0, F, cmmn)
     F
 end
 
-function solve{Tv<:VTypes}(sys::Integer, F::Factor{Tv}, B::Dense{Tv})
+function solve(sys::Integer, F::Factor{Tv}, B::Dense{Tv}) where Tv<:VTypes
     if size(F,1) != size(B,1)
         throw(DimensionMismatch("LHS and RHS should have the same number of rows. " *
             "LHS has $(size(F,1)) rows, but RHS has $(size(B,1)) rows."))
     end
-    d = Dense(ccall((@cholmod_name("solve", SuiteSparse_long),:libcholmod), Ptr{C_Dense{Tv}},
+    if !issuccess(F)
+        s = unsafe_load(pointer(F))
+        if s.is_ll == 1
+            throw(LinAlg.PosDefException(s.minor))
+        else
+            throw(ArgumentError("factorized matrix has one or more zero pivots. Try using lufact instead."))
+        end
+    end
+    Dense(ccall((@cholmod_name("solve", SuiteSparse_long),:libcholmod), Ptr{C_Dense{Tv}},
             (Cint, Ptr{C_Factor{Tv}}, Ptr{C_Dense{Tv}}, Ptr{UInt8}),
-                sys, get(F.p), get(B.p), common()))
-    finalizer(d, free!)
-    d
+                sys, F, B, common()))
 end
 
-function spsolve{Tv<:VTypes}(sys::Integer, F::Factor{Tv}, B::Sparse{Tv})
+function spsolve(sys::Integer, F::Factor{Tv}, B::Sparse{Tv}) where Tv<:VTypes
     if size(F,1) != size(B,1)
         throw(DimensionMismatch("LHS and RHS should have the same number of rows. " *
             "LHS has $(size(F,1)) rows, but RHS has $(size(B,1)) rows."))
     end
-    s = Sparse(ccall((@cholmod_name("spsolve", SuiteSparse_long),:libcholmod),
+    Sparse(ccall((@cholmod_name("spsolve", SuiteSparse_long),:libcholmod),
         Ptr{C_Sparse{Tv}},
             (Cint, Ptr{C_Factor{Tv}}, Ptr{C_Sparse{Tv}}, Ptr{UInt8}),
-                sys, get(F.p), get(B.p), common()))
-    finalizer(s, free!)
-    s
+                sys, F, B, common()))
 end
 
 # Autodetects the types
@@ -818,9 +798,7 @@ function read_sparse(file::Libc.FILE, ::Type{SuiteSparse_long})
     if ptr == C_NULL
         throw(ArgumentError("sparse matrix construction failed. Check that input file is valid."))
     end
-    s = Sparse(ptr)
-    finalizer(s, free!)
-    s
+    Sparse(ptr)
 end
 
 function read_sparse(file::IO, T)
@@ -831,9 +809,9 @@ function read_sparse(file::IO, T)
 end
 
 function get_perm(F::Factor)
-    s = unsafe_load(get(F.p))
+    s = unsafe_load(pointer(F))
     p = unsafe_wrap(Array, s.Perm, s.n, false)
-    p+1
+    p + 1
 end
 get_perm(FC::FactorComponent) = get_perm(Factor(FC))
 
@@ -842,7 +820,7 @@ get_perm(FC::FactorComponent) = get_perm(Factor(FC))
 #########################
 
 # Convertion/construction
-function convert{T<:VTypes}(::Type{Dense{T}}, A::StridedVecOrMat)
+function convert(::Type{Dense{T}}, A::StridedVecOrMat) where T<:VTypes
     d = allocate_dense(size(A, 1), size(A, 2), stride(A, 2), T)
     s = unsafe_load(d.p)
     for i in eachindex(A)
@@ -857,9 +835,9 @@ end
 convert(::Type{Dense}, A::Sparse) = sparse_to_dense(A)
 
 # This constructior assumes zero based colptr and rowval
-function (::Type{Sparse}){Tv<:VTypes}(m::Integer, n::Integer,
+function Sparse(m::Integer, n::Integer,
         colptr0::Vector{SuiteSparse_long}, rowval0::Vector{SuiteSparse_long},
-        nzval::Vector{Tv}, stype)
+        nzval::Vector{Tv}, stype) where Tv<:VTypes
     # checks
     ## length of input
     if length(colptr0) <= n
@@ -892,7 +870,7 @@ function (::Type{Sparse}){Tv<:VTypes}(m::Integer, n::Integer,
     return o
 end
 
-function (::Type{Sparse})(m::Integer, n::Integer,
+function Sparse(m::Integer, n::Integer,
         colptr0::Vector{SuiteSparse_long},
         rowval0::Vector{SuiteSparse_long},
         nzval::Vector{<:VTypes})
@@ -908,7 +886,7 @@ function (::Type{Sparse})(m::Integer, n::Integer,
     o
 end
 
-function (::Type{Sparse}){Tv<:VTypes}(A::SparseMatrixCSC{Tv,SuiteSparse_long}, stype::Integer)
+function Sparse(A::SparseMatrixCSC{Tv,SuiteSparse_long}, stype::Integer) where Tv<:VTypes
     ## Check length of input. This should never fail but see #20024
     if length(A.colptr) <= A.n
         throw(ArgumentError("length of colptr must be at least size(A,2) + 1 = $(A.n + 1) but was $(length(A.colptr))"))
@@ -950,20 +928,20 @@ convert(::Type{Sparse}, A::SparseMatrixCSC{Complex{Float32},<:ITypes}) =
     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}}) =
+convert(::Type{Sparse}, A::Hermitian{Tv,SparseMatrixCSC{Tv,SuiteSparse_long}}) where {Tv<:VTypes} =
     Sparse(A.data, A.uplo == 'L' ? -1 : 1)
-function convert{Ti<:ITypes}(::Type{Sparse},
-    A::Union{SparseMatrixCSC{BigFloat,Ti},
-             Symmetric{BigFloat,SparseMatrixCSC{BigFloat,Ti}},
-             Hermitian{Complex{BigFloat},SparseMatrixCSC{Complex{BigFloat},Ti}}},
-    args...)
+function convert(::Type{Sparse},
+                 A::Union{SparseMatrixCSC{BigFloat,Ti},
+                          Symmetric{BigFloat,SparseMatrixCSC{BigFloat,Ti}},
+                          Hermitian{Complex{BigFloat},SparseMatrixCSC{Complex{BigFloat},Ti}}},
+                 args...) where Ti<:ITypes
     throw(MethodError(convert, (Sparse, A)))
 end
-function convert{T,Ti<:ITypes}(::Type{Sparse},
+function convert(::Type{Sparse},
     A::Union{SparseMatrixCSC{T,Ti},
              Symmetric{T,SparseMatrixCSC{T,Ti}},
              Hermitian{T,SparseMatrixCSC{T,Ti}}},
-    args...)
+    args...) where T where Ti<:ITypes
     return Sparse(convert(AbstractMatrix{promote_type(Float64, T)}, A), args...)
 end
 
@@ -1022,16 +1000,16 @@ function (::Type{Sparse})(filename::String)
 end
 
 ## convertion back to base Julia types
-function convert{T}(::Type{Matrix{T}}, D::Dense{T})
+function convert(::Type{Matrix{T}}, D::Dense{T}) where T
     s = unsafe_load(D.p)
-    a = Array{T}(s.nrow, s.ncol)
+    a = Matrix{T}(s.nrow, s.ncol)
     copy!(a, D)
 end
 
 Base.copy!(dest::Base.PermutedDimsArrays.PermutedDimsArray, src::Dense) = _copy!(dest, src) # ambig
-Base.copy!{T<:VTypes}(dest::Dense{T}, D::Dense{T}) = _copy!(dest, D)
-Base.copy!{T<:VTypes}(dest::AbstractArray{T}, D::Dense{T}) = _copy!(dest, D)
-Base.copy!{T<:VTypes}(dest::AbstractArray{T,2}, D::Dense{T}) = _copy!(dest, D)
+Base.copy!(dest::Dense{T}, D::Dense{T}) where {T<:VTypes} = _copy!(dest, D)
+Base.copy!(dest::AbstractArray{T}, D::Dense{T}) where {T<:VTypes} = _copy!(dest, D)
+Base.copy!(dest::AbstractArray{T,2}, D::Dense{T}) where {T<:VTypes} = _copy!(dest, D)
 Base.copy!(dest::AbstractArray, D::Dense) = _copy!(dest, D)
 
 function _copy!(dest::AbstractArray, D::Dense)
@@ -1050,16 +1028,16 @@ function _copy!(dest::AbstractArray, D::Dense)
     end
     dest
 end
-convert{T}(::Type{Matrix}, D::Dense{T}) = convert(Matrix{T}, D)
-function convert{T}(::Type{Vector{T}}, D::Dense{T})
+convert(::Type{Matrix}, D::Dense{T}) where {T} = convert(Matrix{T}, D)
+function convert(::Type{Vector{T}}, D::Dense{T}) where T
     if size(D, 2) > 1
         throw(DimensionMismatch("input must be a vector but had $(size(D, 2)) columns"))
     end
-    copy!(Array{T}(size(D, 1)), D)
+    copy!(Vector{T}(size(D, 1)), D)
 end
-convert{T}(::Type{Vector}, D::Dense{T}) = convert(Vector{T}, D)
+convert(::Type{Vector}, D::Dense{T}) where {T} = convert(Vector{T}, D)
 
-function convert{Tv}(::Type{SparseMatrixCSC{Tv,SuiteSparse_long}}, A::Sparse{Tv})
+function convert(::Type{SparseMatrixCSC{Tv,SuiteSparse_long}}, A::Sparse{Tv}) where Tv
     s = unsafe_load(A.p)
     if s.stype != 0
         throw(ArgumentError("matrix has stype != 0. Convert to matrix " *
@@ -1094,7 +1072,7 @@ function convert(::Type{Symmetric{Float64,SparseMatrixCSC{Float64,SuiteSparse_lo
         return B
     end
 end
-function convert{Tv<:VTypes}(::Type{Hermitian{Tv,SparseMatrixCSC{Tv,SuiteSparse_long}}}, A::Sparse{Tv})
+function convert(::Type{Hermitian{Tv,SparseMatrixCSC{Tv,SuiteSparse_long}}}, A::Sparse{Tv}) where Tv<:VTypes
     s = unsafe_load(A.p)
     if !ishermitian(A)
         throw(ArgumentError("matrix is not Hermitian"))
@@ -1126,7 +1104,7 @@ function sparse(A::Sparse{Complex{Float64}}) # Notice! Cannot be type stable bec
     return convert(Hermitian{Complex{Float64},SparseMatrixCSC{Complex{Float64},SuiteSparse_long}}, A)
 end
 function sparse(F::Factor)
-    s = unsafe_load(F.p)
+    s = unsafe_load(pointer(F))
     if s.is_ll != 0
         L = Sparse(F)
         A = sparse(L*L')
@@ -1138,7 +1116,7 @@ function sparse(F::Factor)
     SparseArrays.sortSparseMatrixCSC!(A)
     p = get_perm(F)
     if p != [1:s.n;]
-        pinv = Array{Int}(length(p))
+        pinv = Vector{Int}(length(p))
         for k = 1:length(p)
             pinv[p[k]] = k
         end
@@ -1149,15 +1127,15 @@ end
 
 sparse(D::Dense) = sparse(Sparse(D))
 
-function sparse{Tv}(FC::FactorComponent{Tv,:L})
+function sparse(FC::FactorComponent{Tv,:L}) where Tv
     F = Factor(FC)
-    s = unsafe_load(F.p)
+    s = unsafe_load(pointer(F))
     if s.is_ll == 0
         throw(CHOLMODException("sparse: supported only for :LD on LDLt factorizations"))
     end
     sparse(Sparse(F))
 end
-sparse{Tv}(FC::FactorComponent{Tv,:LD}) = sparse(Sparse(Factor(FC)))
+sparse(FC::FactorComponent{Tv,:LD}) where {Tv} = sparse(Sparse(Factor(FC)))
 
 # Calculate the offset into the stype field of the cholmod_sparse_struct and
 # change the value
@@ -1169,13 +1147,13 @@ let offset = fieldoffset(C_Sparse{Float64}, findfirst(name -> name === :stype, f
     end
 end
 
-free!(A::Dense) = free_dense!(A.p)
-free!(A::Sparse) = free_sparse!(A.p)
-free!(F::Factor) = free_factor!(F.p)
+free!(A::Dense)  = free_dense!( pointer(A))
+free!(A::Sparse) = free_sparse!(pointer(A))
+free!(F::Factor) = free_factor!(pointer(F))
 
-eltype{T<:VTypes}(::Type{Dense{T}}) = T
-eltype{T<:VTypes}(::Type{Factor{T}}) = T
-eltype{T<:VTypes}(::Type{Sparse{T}}) = T
+eltype(::Type{Dense{T}}) where {T<:VTypes} = T
+eltype(::Type{Factor{T}}) where {T<:VTypes} = T
+eltype(::Type{Sparse{T}}) where {T<:VTypes} = T
 
 nnz(F::Factor) = nnz(Sparse(F))
 
@@ -1190,11 +1168,12 @@ function show(io::IO, FC::FactorComponent)
 end
 
 function showfactor(io::IO, F::Factor)
-    s = unsafe_load(get(F.p))
+    s = unsafe_load(pointer(F))
     @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))
+    @printf(io, "success: %9s\n", "$(s.minor == size(F, 1))")
 end
 
 # getindex not defined for these, so don't use the normal array printer
@@ -1210,14 +1189,14 @@ copy(A::Sparse) = copy_sparse(A)
 copy(A::Factor) = copy_factor(A)
 
 function size(A::Union{Dense,Sparse})
-    s = unsafe_load(get(A.p))
+    s = unsafe_load(pointer(A))
     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(get(F.p))
+    s = unsafe_load(pointer(F))
     if i <= 2
         return Int(s.n)
     end
@@ -1230,25 +1209,25 @@ IndexStyle(::Dense) = IndexLinear()
 size(FC::FactorComponent, i::Integer) = size(FC.F, i)
 size(FC::FactorComponent) = size(FC.F)
 
-ctranspose{Tv}(FC::FactorComponent{Tv,:L}) = FactorComponent{Tv,:U}(FC.F)
-ctranspose{Tv}(FC::FactorComponent{Tv,:U}) = FactorComponent{Tv,:L}(FC.F)
-ctranspose{Tv}(FC::FactorComponent{Tv,:PtL}) = FactorComponent{Tv,:UP}(FC.F)
-ctranspose{Tv}(FC::FactorComponent{Tv,:UP}) = FactorComponent{Tv,:PtL}(FC.F)
-ctranspose{Tv}(FC::FactorComponent{Tv,:D}) = FC
-ctranspose{Tv}(FC::FactorComponent{Tv,:LD}) = FactorComponent{Tv,:DU}(FC.F)
-ctranspose{Tv}(FC::FactorComponent{Tv,:DU}) = FactorComponent{Tv,:LD}(FC.F)
-ctranspose{Tv}(FC::FactorComponent{Tv,:PtLD}) = FactorComponent{Tv,:DUP}(FC.F)
-ctranspose{Tv}(FC::FactorComponent{Tv,:DUP}) = FactorComponent{Tv,:PtLD}(FC.F)
+ctranspose(FC::FactorComponent{Tv,:L}) where {Tv} = FactorComponent{Tv,:U}(FC.F)
+ctranspose(FC::FactorComponent{Tv,:U}) where {Tv} = FactorComponent{Tv,:L}(FC.F)
+ctranspose(FC::FactorComponent{Tv,:PtL}) where {Tv} = FactorComponent{Tv,:UP}(FC.F)
+ctranspose(FC::FactorComponent{Tv,:UP}) where {Tv} = FactorComponent{Tv,:PtL}(FC.F)
+ctranspose(FC::FactorComponent{Tv,:D}) where {Tv} = FC
+ctranspose(FC::FactorComponent{Tv,:LD}) where {Tv} = FactorComponent{Tv,:DU}(FC.F)
+ctranspose(FC::FactorComponent{Tv,:DU}) where {Tv} = FactorComponent{Tv,:LD}(FC.F)
+ctranspose(FC::FactorComponent{Tv,:PtLD}) where {Tv} = FactorComponent{Tv,:DUP}(FC.F)
+ctranspose(FC::FactorComponent{Tv,:DUP}) where {Tv} = FactorComponent{Tv,:PtLD}(FC.F)
 
 function getindex(A::Dense, i::Integer)
-    s = unsafe_load(get(A.p))
+    s = unsafe_load(pointer(A))
     0 < i <= s.nrow*s.ncol || throw(BoundsError())
     unsafe_load(s.x, i)
 end
 
 IndexStyle(::Sparse) = IndexCartesian()
-function getindex{T}(A::Sparse{T}, i0::Integer, i1::Integer)
-    s = unsafe_load(get(A.p))
+function getindex(A::Sparse{T}, i0::Integer, i1::Integer) where T
+    s = unsafe_load(pointer(A))
     !(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])
@@ -1267,7 +1246,7 @@ function getindex(F::Factor, sym::Symbol)
 end
 
 function getLd!(S::SparseMatrixCSC)
-    d = Array{eltype(S)}(size(S, 1))
+    d = Vector{eltype(S)}(size(S, 1))
     fill!(d, 0)
     col = 1
     for k = 1:nnz(S)
@@ -1287,7 +1266,7 @@ end
 (*)(A::Sparse, B::Dense) = sdmult!(A, false, 1., 0., B, zeros(size(A, 1), size(B, 2)))
 (*)(A::Sparse, B::VecOrMat) = (*)(A, Dense(B))
 
-function A_mul_Bc{Tv<:VRealTypes}(A::Sparse{Tv}, B::Sparse{Tv})
+function A_mul_Bc(A::Sparse{Tv}, B::Sparse{Tv}) where Tv<:VRealTypes
     cm = common()
 
     if A !== B
@@ -1328,7 +1307,7 @@ function fact_(A::Sparse{<:VTypes}, cm::Array{UInt8};
     perm::AbstractVector{SuiteSparse_long}=SuiteSparse_long[],
     postorder::Bool=true, userperm_only::Bool=true)
 
-    sA = unsafe_load(get(A.p))
+    sA = unsafe_load(pointer(A))
     sA.stype == 0 && throw(ArgumentError("sparse matrix is not symmetric/Hermitian"))
 
     if !postorder
@@ -1347,7 +1326,7 @@ function fact_(A::Sparse{<:VTypes}, cm::Array{UInt8};
     return F
 end
 
-function cholfact!{Tv}(F::Factor{Tv}, A::Sparse{Tv}; shift::Real=0.0)
+function cholfact!(F::Factor{Tv}, A::Sparse{Tv}; shift::Real=0.0) where Tv
     cm = common()
 
     # Makes it an LLt
@@ -1356,8 +1335,6 @@ function cholfact!{Tv}(F::Factor{Tv}, A::Sparse{Tv}; shift::Real=0.0)
     # 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
 
@@ -1365,8 +1342,8 @@ end
     cholfact!(F::Factor, A; shift = 0.0) -> CHOLMOD.Factor
 
 Compute the Cholesky (``LL'``) factorization of `A`, reusing the symbolic
-factorization `F`. `A` must be a `SparseMatrixCSC`, `Symmetric{SparseMatrixCSC}`,
-or `Hermitian{SparseMatrixCSC}`. Note that even if `A` doesn't
+factorization `F`. `A` must be a [`SparseMatrixCSC`](@ref) or a [`Symmetric`](@ref)/
+[`Hermitian`](@ref) view of a `SparseMatrixCSC`. Note that even if `A` doesn't
 have the type tag, it must still be symmetric or Hermitian.
 
 See also [`cholfact`](@ref).
@@ -1377,12 +1354,12 @@ See also [`cholfact`](@ref).
     be converted to `SparseMatrixCSC{Float64}` or `SparseMatrixCSC{Complex128}`
     as appropriate.
 """
-cholfact!{T<:Real}(F::Factor, A::Union{SparseMatrixCSC{T},
+cholfact!(F::Factor, A::Union{SparseMatrixCSC{T},
         SparseMatrixCSC{Complex{T}},
         Symmetric{T,SparseMatrixCSC{T,SuiteSparse_long}},
         Hermitian{Complex{T},SparseMatrixCSC{Complex{T},SuiteSparse_long}},
         Hermitian{T,SparseMatrixCSC{T,SuiteSparse_long}}};
-    shift = 0.0) =
+    shift = 0.0) where {T<:Real} =
     cholfact!(F, Sparse(A); shift = shift)
 
 function cholfact(A::Sparse; shift::Real=0.0,
@@ -1397,8 +1374,6 @@ function cholfact(A::Sparse; shift::Real=0.0,
     # 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
 
@@ -1406,8 +1381,8 @@ end
     cholfact(A; shift = 0.0, perm = Int[]) -> CHOLMOD.Factor
 
 Compute the Cholesky factorization of a sparse positive definite matrix `A`.
-`A` must be a `SparseMatrixCSC`, `Symmetric{SparseMatrixCSC}`, or
-`Hermitian{SparseMatrixCSC}`. Note that even if `A` doesn't
+`A` must be a [`SparseMatrixCSC`](@ref) or a [`Symmetric`](@ref)/[`Hermitian`](@ref)
+view of a `SparseMatrixCSC`. Note that even if `A` doesn't
 have the type tag, it must still be symmetric or Hermitian.
 A fill-reducing permutation is used.
 `F = cholfact(A)` is most frequently used to solve systems of equations with `F\\b`,
@@ -1435,21 +1410,25 @@ it should be a permutation of `1:size(A,1)` giving the ordering to use
     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}},
+cholfact(A::Union{SparseMatrixCSC{T}, SparseMatrixCSC{Complex{T}},
     Symmetric{T,SparseMatrixCSC{T,SuiteSparse_long}},
     Hermitian{Complex{T},SparseMatrixCSC{Complex{T},SuiteSparse_long}},
     Hermitian{T,SparseMatrixCSC{T,SuiteSparse_long}}};
-    kws...) = cholfact(Sparse(A); kws...)
+    kws...) where {T<:Real} = cholfact(Sparse(A); kws...)
 
 
-function ldltfact!{Tv}(F::Factor{Tv}, A::Sparse{Tv}; shift::Real=0.0)
-    cm = common()
+function ldltfact!(F::Factor{Tv}, A::Sparse{Tv}; shift::Real=0.0) where Tv
+    cm = defaults(common())
+    set_print_level(cm, 0)
+
+    # Makes it an LDLt
+    unsafe_store!(common_final_ll, 0)
+    # Really make sure it's an LDLt by avoiding supernodal factorization
+    unsafe_store!(common_supernodal, 0)
 
     # Compute the numerical factorization
     factorize_p!(A, shift, F, cm)
 
-    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
 
@@ -1457,8 +1436,8 @@ end
     ldltfact!(F::Factor, A; shift = 0.0) -> CHOLMOD.Factor
 
 Compute the ``LDL'`` factorization of `A`, reusing the symbolic factorization `F`.
-`A` must be a `SparseMatrixCSC`, `Symmetric{SparseMatrixCSC}`, or
-`Hermitian{SparseMatrixCSC}`. Note that even if `A` doesn't
+`A` must be a [`SparseMatrixCSC`](@ref) or a [`Symmetric`](@ref)/[`Hermitian`](@ref)
+view of a `SparseMatrixCSC`. Note that even if `A` doesn't
 have the type tag, it must still be symmetric or Hermitian.
 
 See also [`ldltfact`](@ref).
@@ -1469,12 +1448,12 @@ See also [`ldltfact`](@ref).
     be converted to `SparseMatrixCSC{Float64}` or `SparseMatrixCSC{Complex128}`
     as appropriate.
 """
-ldltfact!{T<:Real}(F::Factor, A::Union{SparseMatrixCSC{T},
+ldltfact!(F::Factor, A::Union{SparseMatrixCSC{T},
     SparseMatrixCSC{Complex{T}},
     Symmetric{T,SparseMatrixCSC{T,SuiteSparse_long}},
     Hermitian{Complex{T},SparseMatrixCSC{Complex{T},SuiteSparse_long}},
     Hermitian{T,SparseMatrixCSC{T,SuiteSparse_long}}};
-    shift = 0.0) =
+    shift = 0.0) where {T<:Real} =
     ldltfact!(F, Sparse(A), shift = shift)
 
 function ldltfact(A::Sparse; shift::Real=0.0,
@@ -1494,10 +1473,6 @@ function ldltfact(A::Sparse; shift::Real=0.0,
     # Compute the numerical factorization
     ldltfact!(F, A; shift = shift)
 
-    s = unsafe_load(get(F.p))
-    if s.minor < size(A, 1)
-        throw(Base.LinAlg.ArgumentError("matrix has one or more zero pivots"))
-    end
     return F
 end
 
@@ -1505,13 +1480,13 @@ end
     ldltfact(A; shift = 0.0, perm=Int[]) -> CHOLMOD.Factor
 
 Compute the ``LDL'`` factorization of a sparse matrix `A`.
-`A` must be a `SparseMatrixCSC`, `Symmetric{SparseMatrixCSC}`, or
-`Hermitian{SparseMatrixCSC}`. Note that even if `A` doesn't
+`A` must be a [`SparseMatrixCSC`](@ref) or a [`Symmetric`](@ref)/[`Hermitian`](@ref)
+view of a `SparseMatrixCSC`. Note that even if `A` doesn't
 have the type tag, it must still be symmetric or Hermitian.
 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`](@ref),
-[`det`](@ref), and [`logdet`](@ref).
+[`det`](@ref), [`logdet`](@ref), and [`inv`](@ref).
 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`;
@@ -1535,47 +1510,129 @@ it should be a permutation of `1:size(A,1)` giving the ordering to use
     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}},
+ldltfact(A::Union{SparseMatrixCSC{T},SparseMatrixCSC{Complex{T}},
     Symmetric{T,SparseMatrixCSC{T,SuiteSparse_long}},
     Hermitian{Complex{T},SparseMatrixCSC{Complex{T},SuiteSparse_long}},
     Hermitian{T,SparseMatrixCSC{T,SuiteSparse_long}}};
-    kws...) = ldltfact(Sparse(A); kws...)
+    kws...) where {T<:Real} = ldltfact(Sparse(A); kws...)
+
+## Rank updates
+
+"""
+    lowrankupdowndate!(F::Factor, C::Sparse, update::Cint)
+
+Update an `LDLt` or `LLt` Factorization `F` of `A` to a factorization of `A ± C*C'`.
+
+If sparsity preserving factorization is used, i.e. `L*L' == P*A*P'` then the new
+factor will be `L*L' == P*A*P' + C'*C`
+
+update: `Cint(1)` for `A + CC'`, `Cint(0)` for `A - CC'`
+"""
+function lowrankupdowndate!(F::Factor{Tv}, C::Sparse{Tv}, update::Cint) where Tv<:VTypes
+    lF = unsafe_load(pointer(F))
+    lC = unsafe_load(pointer(C))
+    if lF.n != lC.nrow
+        throw(DimensionMismatch("matrix dimensions do not fit"))
+    end
+    @isok ccall((:cholmod_l_updown, :libcholmod), Cint,
+        (Cint, Ptr{C_Sparse{Tv}}, Ptr{C_Factor{Tv}}, Ptr{Void}),
+        update, C, F, common())
+    F
+end
+
+#Helper functions for rank updates
+lowrank_reorder(V::AbstractArray,p) = Sparse(sparse(V[p,:]))
+lowrank_reorder(V::AbstractSparseArray,p) = Sparse(V[p,:])
+
+"""
+    lowrankupdate!(F::Factor, C)
+
+Update an `LDLt` or `LLt` Factorization `F` of `A` to a factorization of `A + C*C'`.
+
+`LLt` factorizations are converted to `LDLt`.
+
+See also [`lowrankupdate`](@ref), [`lowrankdowndate`](@ref), [`lowrankdowndate!`](@ref).
+"""
+function lowrankupdate!(F::Factor{Tv}, V::AbstractArray{Tv}) where Tv<:VTypes
+    #Reorder and copy V to account for permutation
+    C = lowrank_reorder(V, get_perm(F))
+    lowrankupdowndate!(F, C, Cint(1))
+end
+
+"""
+    lowrankdowndate!(F::Factor, C)
+
+Update an `LDLt` or `LLt` Factorization `F` of `A` to a factorization of `A - C*C'`.
+
+`LLt` factorizations are converted to `LDLt`.
+
+See also [`lowrankdowndate`](@ref), [`lowrankupdate`](@ref), [`lowrankupdate!`](@ref).
+"""
+function lowrankdowndate!(F::Factor{Tv}, V::AbstractArray{Tv}) where Tv<:VTypes
+    #Reorder and copy V to account for permutation
+    C = lowrank_reorder(V, get_perm(F))
+    lowrankupdowndate!(F, C, Cint(0))
+end
+
+"""
+    lowrankupdate(F::Factor, C) -> FF::Factor
+
+Get an `LDLt` Factorization of `A + C*C'` given an `LDLt` or `LLt` factorization `F` of `A`.
+
+The returned factor is always an `LDLt` factorization.
+
+See also [`lowrankupdate!`](@ref), [`lowrankdowndate`](@ref), [`lowrankdowndate!`](@ref).
+"""
+lowrankupdate(F::Factor{Tv}, V::AbstractArray{Tv}) where {Tv<:VTypes} =
+    lowrankupdate!(copy(F), V)
+
+"""
+    lowrankupdate(F::Factor, C) -> FF::Factor
+
+Get an `LDLt` Factorization of `A + C*C'` given an `LDLt` or `LLt` factorization `F` of `A`.
+
+The returned factor is always an `LDLt` factorization.
+
+See also [`lowrankdowndate!`](@ref), [`lowrankupdate`](@ref), [`lowrankupdate!`](@ref).
+"""
+lowrankdowndate(F::Factor{Tv}, V::AbstractArray{Tv}) where {Tv<:VTypes} =
+    lowrankdowndate!(copy(F), V)
 
 ## Solvers
 
 for (T, f) in ((:Dense, :solve), (:Sparse, :spsolve))
     @eval begin
         # Solve Lx = b and L'x=b where A = L*L'
-        function (\){T}(L::FactorComponent{T,:L}, B::$T)
+        function (\)(L::FactorComponent{T,:L}, B::$T) where T
             ($f)(CHOLMOD_L, Factor(L), B)
         end
-        function (\){T}(L::FactorComponent{T,:U}, B::$T)
+        function (\)(L::FactorComponent{T,:U}, B::$T) where T
             ($f)(CHOLMOD_Lt, Factor(L), B)
         end
         # Solve PLx = b and L'P'x=b where A = P*L*L'*P'
-        function (\){T}(L::FactorComponent{T,:PtL}, B::$T)
+        function (\)(L::FactorComponent{T,:PtL}, B::$T) where T
             F = Factor(L)
             ($f)(CHOLMOD_L, F, ($f)(CHOLMOD_P, F, B)) # Confusingly, CHOLMOD_P solves P'x = b
         end
-        function (\){T}(L::FactorComponent{T,:UP}, B::$T)
+        function (\)(L::FactorComponent{T,:UP}, B::$T) where T
             F = Factor(L)
             ($f)(CHOLMOD_Pt, F, ($f)(CHOLMOD_Lt, F, B))
         end
         # Solve various equations for A = L*D*L' and A = P*L*D*L'*P'
-        function (\){T}(L::FactorComponent{T,:D}, B::$T)
+        function (\)(L::FactorComponent{T,:D}, B::$T) where T
             ($f)(CHOLMOD_D, Factor(L), B)
         end
-        function (\){T}(L::FactorComponent{T,:LD}, B::$T)
+        function (\)(L::FactorComponent{T,:LD}, B::$T) where T
             ($f)(CHOLMOD_LD, Factor(L), B)
         end
-        function (\){T}(L::FactorComponent{T,:DU}, B::$T)
+        function (\)(L::FactorComponent{T,:DU}, B::$T) where T
             ($f)(CHOLMOD_DLt, Factor(L), B)
         end
-        function (\){T}(L::FactorComponent{T,:PtLD}, B::$T)
+        function (\)(L::FactorComponent{T,:PtLD}, B::$T) where T
             F = Factor(L)
             ($f)(CHOLMOD_LD, F, ($f)(CHOLMOD_P, F, B))
         end
-        function (\){T}(L::FactorComponent{T,:DUP}, B::$T)
+        function (\)(L::FactorComponent{T,:DUP}, B::$T) where T
             F = Factor(L)
             ($f)(CHOLMOD_Pt, F, ($f)(CHOLMOD_DLt, F, B))
         end
@@ -1597,12 +1654,13 @@ end
 Ac_ldiv_B(L::FactorComponent, B) = ctranspose(L)\B
 Ac_ldiv_B(L::FactorComponent, B::RowVector) = ctranspose(L)\B # ambiguity
 
-(\){T<:VTypes}(L::Factor{T}, B::Dense{T}) = solve(CHOLMOD_A, L, B)
-(\)(L::Factor{Float64}, B::VecOrMat{Complex{Float64}}) = complex.(L\real(B), L\imag(B))
-# First explicit TypeVars are necessary to avoid ambiguity errors with definition in
-# linalg/factorizations.jl
-(\){T<:VTypes}(L::Factor{T}, b::StridedVector) = Vector(L\convert(Dense{T}, b))
-(\){T<:VTypes}(L::Factor{T}, B::StridedMatrix) = Matrix(L\convert(Dense{T}, B))
+(\)(L::Factor{T}, B::Dense{T}) where {T<:VTypes} = solve(CHOLMOD_A, L, B)
+# Explicit typevars are necessary to avoid ambiguities with defs in linalg/factorizations.jl
+# Likewise the two following explicit Vector and Matrix defs (rather than a single VecOrMat)
+(\)(L::Factor{T}, B::Vector{Complex{T}}) where {T<:Float64} = complex.(L\real(B), L\imag(B))
+(\)(L::Factor{T}, B::Matrix{Complex{T}}) where {T<:Float64} = complex.(L\real(B), L\imag(B))
+(\)(L::Factor{T}, b::StridedVector) where {T<:VTypes} = Vector(L\convert(Dense{T}, b))
+(\)(L::Factor{T}, B::StridedMatrix) where {T<:VTypes} = Matrix(L\convert(Dense{T}, 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::SparseVecOrMat) = sparse(spsolve(CHOLMOD_A, L, Sparse(B, 0)))
@@ -1616,18 +1674,23 @@ for f in (:\, :Ac_ldiv_B)
     @eval function ($f)(A::Union{Symmetric{Float64,SparseMatrixCSC{Float64,SuiteSparse_long}},
                           Hermitian{Float64,SparseMatrixCSC{Float64,SuiteSparse_long}},
                           Hermitian{Complex{Float64},SparseMatrixCSC{Complex{Float64},SuiteSparse_long}}}, B::StridedVecOrMat)
-        try
-            return ($f)(cholfact(A), B)
-        catch e
-            isa(e, LinAlg.PosDefException) || rethrow(e)
-            return ($f)(ldltfact(A) , B)
+        F = cholfact(A)
+        if issuccess(F)
+            return ($f)(F, B)
+        else
+            ldltfact!(F, A)
+            if issuccess(F)
+                return ($f)(F, B)
+            else
+                return ($f)(lufact(convert(SparseMatrixCSC{eltype(A), SuiteSparse_long}, A)), B)
+            end
         end
     end
 end
 
 ## Other convenience methods
-function diag{Tv}(F::Factor{Tv})
-    f = unsafe_load(get(F.p))
+function diag(F::Factor{Tv}) where Tv
+    f = unsafe_load(pointer(F))
     fsuper = f.super
     fpi = f.pi
     res = Base.zeros(Tv, Int(f.n))
@@ -1658,8 +1721,8 @@ function diag{Tv}(F::Factor{Tv})
     res
 end
 
-function logdet{Tv<:VTypes}(F::Factor{Tv})
-    f = unsafe_load(get(F.p))
+function logdet(F::Factor{Tv}) where Tv<:VTypes
+    f = unsafe_load(pointer(F))
     res = zero(Tv)
     for d in diag(F); res += log(abs(d)) end
     f.is_ll!=0 ? 2res : res
@@ -1667,17 +1730,27 @@ end
 
 det(L::Factor) = exp(logdet(L))
 
-function isposdef(A::SparseMatrixCSC{<:VTypes,SuiteSparse_long})
-    if !ishermitian(A)
-        return false
-    end
-    try
-        f = cholfact(A)
-    catch e
-        isa(e, LinAlg.PosDefException) || rethrow(e)
+function issuccess(F::Factor)
+    s = unsafe_load(pointer(F))
+    return s.minor == size(F, 1)
+end
+
+function isposdef(F::Factor)
+    if issuccess(F)
+        s = unsafe_load(pointer(F))
+        if s.is_ll == 1
+            return true
+        else
+            # try conversion to LLt
+            change_factor!(eltype(F), true, s.is_super, true, s.is_monotonic, F)
+            b = issuccess(F)
+            # convert back
+            change_factor!(eltype(F), false, s.is_super, true, s.is_monotonic, F)
+            return b
+        end
+    else
         return false
     end
-    true
 end
 
 function ishermitian(A::Sparse{Float64})
@@ -1707,11 +1780,18 @@ function ishermitian(A::Sparse{Complex{Float64}})
     end
 end
 
-(*){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))
-(*){Ti}(A::Hermitian{Float64,SparseMatrixCSC{Float64,Ti}},
-    B::SparseVecOrMat{Float64,Ti}) = sparse(Sparse(A)*Sparse(B))
+(*)(A::Symmetric{Float64,SparseMatrixCSC{Float64,Ti}},
+    B::SparseVecOrMat{Float64,Ti}) where {Ti} = sparse(Sparse(A)*Sparse(B))
+(*)(A::Hermitian{Complex{Float64},SparseMatrixCSC{Complex{Float64},Ti}},
+    B::SparseVecOrMat{Complex{Float64},Ti}) where {Ti} = sparse(Sparse(A)*Sparse(B))
+(*)(A::Hermitian{Float64,SparseMatrixCSC{Float64,Ti}},
+    B::SparseVecOrMat{Float64,Ti}) where {Ti} = sparse(Sparse(A)*Sparse(B))
+
+(*)(A::SparseVecOrMat{Float64,Ti},
+    B::Symmetric{Float64,SparseMatrixCSC{Float64,Ti}}) where {Ti} = sparse(Sparse(A)*Sparse(B))
+(*)(A::SparseVecOrMat{Complex{Float64},Ti},
+    B::Hermitian{Complex{Float64},SparseMatrixCSC{Complex{Float64},Ti}}) where {Ti} = sparse(Sparse(A)*Sparse(B))
+(*)(A::SparseVecOrMat{Float64,Ti},
+    B::Hermitian{Float64,SparseMatrixCSC{Float64,Ti}}) where {Ti} = sparse(Sparse(A)*Sparse(B))
 
 end #module
diff --git a/base/sparse/cholmod_h.jl b/base/sparse/cholmod_h.jl
index f0e7a4d44ae2cb..7b7b11035c6e5a 100644
--- a/base/sparse/cholmod_h.jl
+++ b/base/sparse/cholmod_h.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## CHOLMOD
 const TRUE  = Int32(1)
@@ -59,7 +59,7 @@ const MM_HERMITIAN_POSDIAG  = 7
 # check the size of SuiteSparse_long
 if Int(ccall((:jl_cholmod_sizeof_long, :libsuitesparse_wrapper),Csize_t,())) == 4
     const SuiteSparse_long = Int32
-    const IndexTypes = (:Int32, )
+    const IndexTypes = (:Int32,)
     const ITypes = Union{Int32}
 else
     const SuiteSparse_long = Int64
diff --git a/base/sparse/higherorderfns.jl b/base/sparse/higherorderfns.jl
index 858d4527fdb496..c7431a04087302 100644
--- a/base/sparse/higherorderfns.jl
+++ b/base/sparse/higherorderfns.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module HigherOrderFns
 
@@ -6,10 +6,11 @@ module HigherOrderFns
 # particularly map[!]/broadcast[!] for SparseVectors and SparseMatrixCSCs at present.
 import Base: map, map!, broadcast, broadcast!
 import Base.Broadcast: _containertype, promote_containertype,
-    broadcast_indices, broadcast_c, broadcast_c!
+                       broadcast_indices, broadcast_c, broadcast_c!
 
 using Base: front, tail, to_shape
-using ..SparseArrays: SparseVector, SparseMatrixCSC, AbstractSparseArray, indtype
+using ..SparseArrays: SparseVector, SparseMatrixCSC, AbstractSparseVector,
+                      AbstractSparseMatrix, AbstractSparseArray, indtype, nnz, nzrange
 
 # This module is organized as follows:
 # (1) Define a common interface to SparseVectors and SparseMatrixCSCs sufficient for
@@ -64,23 +65,23 @@ end
 
 
 # (2) map[!] entry points
-map{Tf}(f::Tf, A::SparseVector) = _noshapecheck_map(f, A)
-map{Tf}(f::Tf, A::SparseMatrixCSC) = _noshapecheck_map(f, A)
-map{Tf,N}(f::Tf, A::SparseMatrixCSC, Bs::Vararg{SparseMatrixCSC,N}) =
+map(f::Tf, A::SparseVector) where {Tf} = _noshapecheck_map(f, A)
+map(f::Tf, A::SparseMatrixCSC) where {Tf} = _noshapecheck_map(f, A)
+map(f::Tf, A::SparseMatrixCSC, Bs::Vararg{SparseMatrixCSC,N}) where {Tf,N} =
     (_checksameshape(A, Bs...); _noshapecheck_map(f, A, Bs...))
-map{Tf,N}(f::Tf, A::SparseVecOrMat, Bs::Vararg{SparseVecOrMat,N}) =
+map(f::Tf, A::SparseVecOrMat, Bs::Vararg{SparseVecOrMat,N}) where {Tf,N} =
     (_checksameshape(A, Bs...); _noshapecheck_map(f, A, Bs...))
-map!{Tf,N}(f::Tf, C::SparseMatrixCSC, A::SparseMatrixCSC, Bs::Vararg{SparseMatrixCSC,N}) =
+map!(f::Tf, C::SparseMatrixCSC, A::SparseMatrixCSC, Bs::Vararg{SparseMatrixCSC,N}) where {Tf,N} =
     (_checksameshape(C, A, Bs...); _noshapecheck_map!(f, C, A, Bs...))
-map!{Tf,N}(f::Tf, C::SparseVecOrMat, A::SparseVecOrMat, Bs::Vararg{SparseVecOrMat,N}) =
+map!(f::Tf, C::SparseVecOrMat, A::SparseVecOrMat, Bs::Vararg{SparseVecOrMat,N}) where {Tf,N} =
     (_checksameshape(C, A, Bs...); _noshapecheck_map!(f, C, A, Bs...))
-function _noshapecheck_map!{Tf,N}(f::Tf, C::SparseVecOrMat, A::SparseVecOrMat, Bs::Vararg{SparseVecOrMat,N})
+function _noshapecheck_map!(f::Tf, C::SparseVecOrMat, A::SparseVecOrMat, Bs::Vararg{SparseVecOrMat,N}) where {Tf,N}
     fofzeros = f(_zeros_eltypes(A, Bs...)...)
     fpreszeros = _iszero(fofzeros)
     return fpreszeros ? _map_zeropres!(f, C, A, Bs...) :
                         _map_notzeropres!(f, fofzeros, C, A, Bs...)
 end
-function _noshapecheck_map{Tf,N}(f::Tf, A::SparseVecOrMat, Bs::Vararg{SparseVecOrMat,N})
+function _noshapecheck_map(f::Tf, A::SparseVecOrMat, Bs::Vararg{SparseVecOrMat,N}) where {Tf,N}
     fofzeros = f(_zeros_eltypes(A, Bs...)...)
     fpreszeros = _iszero(fofzeros)
     maxnnzC = fpreszeros ? min(length(A), _sumnnzs(A, Bs...)) : length(A)
@@ -91,9 +92,9 @@ function _noshapecheck_map{Tf,N}(f::Tf, A::SparseVecOrMat, Bs::Vararg{SparseVecO
                         _map_notzeropres!(f, fofzeros, C, A, Bs...)
 end
 # (3) broadcast[!] entry points
-broadcast{Tf}(f::Tf, A::SparseVector) = _noshapecheck_map(f, A)
-broadcast{Tf}(f::Tf, A::SparseMatrixCSC) = _noshapecheck_map(f, A)
-function broadcast!{Tf}(f::Tf, C::SparseVecOrMat)
+broadcast(f::Tf, A::SparseVector) where {Tf} = _noshapecheck_map(f, A)
+broadcast(f::Tf, A::SparseMatrixCSC) where {Tf} = _noshapecheck_map(f, A)
+function broadcast!(f::Tf, C::SparseVecOrMat) where Tf
     isempty(C) && return _finishempty!(C)
     fofnoargs = f()
     if _iszero(fofnoargs) # f() is zero, so empty C
@@ -106,7 +107,7 @@ function broadcast!{Tf}(f::Tf, C::SparseVecOrMat)
     end
     return C
 end
-function broadcast!{Tf,N}(f::Tf, C::SparseVecOrMat, A::SparseVecOrMat, Bs::Vararg{SparseVecOrMat,N})
+function broadcast!(f::Tf, C::SparseVecOrMat, A::SparseVecOrMat, Bs::Vararg{SparseVecOrMat,N}) where {Tf,N}
     _aresameshape(C, A, Bs...) && return _noshapecheck_map!(f, C, A, Bs...)
     Base.Broadcast.check_broadcast_indices(indices(C), A, Bs...)
     fofzeros = f(_zeros_eltypes(A, Bs...)...)
@@ -115,13 +116,13 @@ function broadcast!{Tf,N}(f::Tf, C::SparseVecOrMat, A::SparseVecOrMat, Bs::Varar
                         _broadcast_notzeropres!(f, fofzeros, C, A, Bs...)
 end
 # the following three similar defs are necessary for type stability in the mixed vector/matrix case
-broadcast{Tf,N}(f::Tf, A::SparseVector, Bs::Vararg{SparseVector,N}) =
+broadcast(f::Tf, A::SparseVector, Bs::Vararg{SparseVector,N}) where {Tf,N} =
     _aresameshape(A, Bs...) ? _noshapecheck_map(f, A, Bs...) : _diffshape_broadcast(f, A, Bs...)
-broadcast{Tf,N}(f::Tf, A::SparseMatrixCSC, Bs::Vararg{SparseMatrixCSC,N}) =
+broadcast(f::Tf, A::SparseMatrixCSC, Bs::Vararg{SparseMatrixCSC,N}) where {Tf,N} =
     _aresameshape(A, Bs...) ? _noshapecheck_map(f, A, Bs...) : _diffshape_broadcast(f, A, Bs...)
-broadcast{Tf,N}(f::Tf, A::SparseVecOrMat, Bs::Vararg{SparseVecOrMat,N}) =
+broadcast(f::Tf, A::SparseVecOrMat, Bs::Vararg{SparseVecOrMat,N}) where {Tf,N} =
     _diffshape_broadcast(f, A, Bs...)
-function _diffshape_broadcast{Tf,N}(f::Tf, A::SparseVecOrMat, Bs::Vararg{SparseVecOrMat,N})
+function _diffshape_broadcast(f::Tf, A::SparseVecOrMat, Bs::Vararg{SparseVecOrMat,N}) where {Tf,N}
     fofzeros = f(_zeros_eltypes(A, Bs...)...)
     fpreszeros = _iszero(fofzeros)
     indextypeC = _promote_indtype(A, Bs...)
@@ -169,7 +170,7 @@ end
     return SparseMatrixCSC(shape..., pointers, storedinds, storedvals)
 end
 # Ambiguity killers, TODO: nix conflicting specializations
-ambiguityfunnel{Tf}(f::Tf, x, y) = _aresameshape(x, y) ? _noshapecheck_map(f, x, y) : _diffshape_broadcast(f, x, y)
+ambiguityfunnel(f::Tf, x, y) where {Tf} = _aresameshape(x, y) ? _noshapecheck_map(f, x, y) : _diffshape_broadcast(f, x, y)
 broadcast(::typeof(+), x::SparseVector, y::SparseVector) = ambiguityfunnel(+, x, y) # base/sparse/sparsevectors.jl:1266
 broadcast(::typeof(-), x::SparseVector, y::SparseVector) = ambiguityfunnel(-, x, y) # base/sparse/sparsevectors.jl:1266
 broadcast(::typeof(*), x::SparseVector, y::SparseVector) = ambiguityfunnel(*, x, y) # base/sparse/sparsevectors.jl:1266
@@ -177,7 +178,7 @@ broadcast(::typeof(*), x::SparseVector, y::SparseVector) = ambiguityfunnel(*, x,
 
 # (4) _map_zeropres!/_map_notzeropres! specialized for a single sparse vector/matrix
 "Stores only the nonzero entries of `map(f, Array(A))` in `C`."
-function _map_zeropres!{Tf}(f::Tf, C::SparseVecOrMat, A::SparseVecOrMat)
+function _map_zeropres!(f::Tf, C::SparseVecOrMat, A::SparseVecOrMat) where Tf
     spaceC::Int = min(length(storedinds(C)), length(storedvals(C)))
     Ck = 1
     @inbounds for j in columns(C)
@@ -200,7 +201,7 @@ end
 Densifies `C`, storing `fillvalue` in place of each unstored entry in `A` and
 `f(A[i])`/`f(A[i,j])` in place of each stored entry `A[i]`/`A[i,j]` in `A`.
 """
-function _map_notzeropres!{Tf}(f::Tf, fillvalue, C::SparseVecOrMat, A::SparseVecOrMat)
+function _map_notzeropres!(f::Tf, fillvalue, C::SparseVecOrMat, A::SparseVecOrMat) where Tf
     # Build dense matrix structure in C, expanding storage if necessary
     _densestructure!(C)
     # Populate values
@@ -235,7 +236,7 @@ end
 
 
 # (5) _map_zeropres!/_map_notzeropres! specialized for a pair of sparse vectors/matrices
-function _map_zeropres!{Tf}(f::Tf, C::SparseVecOrMat, A::SparseVecOrMat, B::SparseVecOrMat)
+function _map_zeropres!(f::Tf, C::SparseVecOrMat, A::SparseVecOrMat, B::SparseVecOrMat) where Tf
     spaceC::Int = min(length(storedinds(C)), length(storedvals(C)))
     rowsentinelA = convert(indtype(A), numrows(C) + 1)
     rowsentinelB = convert(indtype(B), numrows(C) + 1)
@@ -277,7 +278,7 @@ function _map_zeropres!{Tf}(f::Tf, C::SparseVecOrMat, A::SparseVecOrMat, B::Spar
     trimstorage!(C, Ck - 1)
     return C
 end
-function _map_notzeropres!{Tf}(f::Tf, fillvalue, C::SparseVecOrMat, A::SparseVecOrMat, B::SparseVecOrMat)
+function _map_notzeropres!(f::Tf, fillvalue, C::SparseVecOrMat, A::SparseVecOrMat, B::SparseVecOrMat) where Tf
     # Build dense matrix structure in C, expanding storage if necessary
     _densestructure!(C)
     # Populate values
@@ -312,7 +313,7 @@ end
 
 
 # (6) _map_zeropres!/_map_notzeropres! for more than two sparse matrices / vectors
-function _map_zeropres!{Tf,N}(f::Tf, C::SparseVecOrMat, As::Vararg{SparseVecOrMat,N})
+function _map_zeropres!(f::Tf, C::SparseVecOrMat, As::Vararg{SparseVecOrMat,N}) where {Tf,N}
     spaceC::Int = min(length(storedinds(C)), length(storedvals(C)))
     rowsentinel = numrows(C) + 1
     Ck = 1
@@ -324,10 +325,6 @@ function _map_zeropres!{Tf,N}(f::Tf, C::SparseVecOrMat, As::Vararg{SparseVecOrMa
         rows = _rowforind_all(rowsentinel, ks, stopks, As)
         activerow = min(rows...)
         while activerow < rowsentinel
-            # activerows = _isactiverow_all(activerow, rows)
-            # Cx = f(_gatherargs(activerows, ks, As)...)
-            # ks = _updateind_all(activerows, ks)
-            # rows = _updaterow_all(rowsentinel, activerows, rows, ks, stopks, As)
             vals, ks, rows = _fusedupdate_all(rowsentinel, activerow, rows, ks, stopks, As)
             Cx = f(vals...)
             if !_iszero(Cx)
@@ -343,7 +340,7 @@ function _map_zeropres!{Tf,N}(f::Tf, C::SparseVecOrMat, As::Vararg{SparseVecOrMa
     trimstorage!(C, Ck - 1)
     return C
 end
-function _map_notzeropres!{Tf,N}(f::Tf, fillvalue, C::SparseVecOrMat, As::Vararg{SparseVecOrMat,N})
+function _map_notzeropres!(f::Tf, fillvalue, C::SparseVecOrMat, As::Vararg{SparseVecOrMat,N}) where {Tf,N}
     # Build dense matrix structure in C, expanding storage if necessary
     _densestructure!(C)
     # Populate values
@@ -358,10 +355,6 @@ function _map_notzeropres!{Tf,N}(f::Tf, fillvalue, C::SparseVecOrMat, As::Vararg
         rows = _rowforind_all(rowsentinel, ks, stopks, As)
         activerow = min(rows...)
         while activerow < rowsentinel
-            # activerows = _isactiverow_all(activerow, rows)
-            # Cx = f(_gatherargs(activerows, ks, As)...)
-            # ks = _updateind_all(activerows, ks)
-            # rows = _updaterow_all(rowsentinel, activerows, rows, ks, stopks, As)
             vals, ks, rows = _fusedupdate_all(rowsentinel, activerow, rows, ks, stopks, As)
             Cx = f(vals...)
             Cx != fillvalue && (storedvals(C)[jo + activerow] = Cx)
@@ -370,6 +363,7 @@ function _map_notzeropres!{Tf,N}(f::Tf, fillvalue, C::SparseVecOrMat, As::Vararg
     end
     return C
 end
+
 # helper methods for map/map! methods just above
 @inline _colstartind(j, A) = colstartind(A, j)
 @inline _colstartind_all(j, ::Tuple{}) = ()
@@ -387,28 +381,7 @@ end
 @inline _rowforind_all(rowsentinel, ks, stopks, As) = (
     _rowforind(rowsentinel, first(ks), first(stopks), first(As)),
     _rowforind_all(rowsentinel, tail(ks), tail(stopks), tail(As))...)
-# fusing the following defs. avoids a few branches, yielding 5-30% runtime reduction
-# @inline _isactiverow(activerow, row) = row == activerow
-# @inline _isactiverow_all(activerow, ::Tuple{}) = ()
-# @inline _isactiverow_all(activerow, rows) = (
-#     _isactiverow(activerow, first(rows)),
-#     _isactiverow_all(activerow, tail(rows))...)
-# @inline _gatherarg(isactiverow, k, A) = isactiverow ? storedvals(A)[k] : zero(eltype(A))
-# @inline _gatherargs(::Tuple{}, ::Tuple{}, ::Tuple{}) = ()
-# @inline _gatherargs(activerows, ks, As) = (
-#     _gatherarg(first(activerows), first(ks), first(As)),
-#     _gatherargs(tail(activerows), tail(ks), tail(As))...)
-# @inline _updateind(isactiverow, k) = isactiverow ? (k + oneunit(k)) : k
-# @inline _updateind_all(::Tuple{}, ::Tuple{}) = ()
-# @inline _updateind_all(activerows, ks) = (
-#     _updateind(first(activerows), first(ks)),
-#     _updateind_all(tail(activerows), tail(ks))...)
-# @inline _updaterow(rowsentinel, isrowactive, presrow, k, stopk, A) =
-#     isrowactive ? (k < stopk ? storedinds(A)[k] : oftype(presrow, rowsentinel)) : presrow
-# @inline _updaterow_all(rowsentinel, ::Tuple{}, ::Tuple{}, ::Tuple{}, ::Tuple{}, ::Tuple{}) = ()
-# @inline _updaterow_all(rowsentinel, activerows, rows, ks, stopks, As) = (
-#     _updaterow(rowsentinel, first(activerows), first(rows), first(ks), first(stopks), first(As)),
-#     _updaterow_all(rowsentinel, tail(activerows), tail(rows), tail(ks), tail(stopks), tail(As))...)
+
 @inline function _fusedupdate(rowsentinel, activerow, row, k, stopk, A)
     # returns (val, nextk, nextrow)
     if row == activerow
@@ -418,19 +391,16 @@ end
         (zero(eltype(A)), k, row)
     end
 end
-@inline _fusedupdate_all(rowsentinel, activerow, rows, ks, stopks, As) =
-    _fusedupdate_all((#=vals=#), (#=nextks=#), (#=nextrows=#), rowsentinel, activerow, rows, ks, stopks, As)
-@inline _fusedupdate_all(vals, nextks, nextrows, rowsent, activerow, ::Tuple{}, ::Tuple{}, ::Tuple{}, ::Tuple{}) =
-    (vals, nextks, nextrows)
-@inline function _fusedupdate_all(vals, nextks, nextrows, rowsentinel, activerow, rows, ks, stopks, As)
+@inline _fusedupdate_all(rowsentinel, activerow, ::Tuple{}, ::Tuple{}, ::Tuple{}, ::Tuple{}) = ((#=vals=#), (#=nextks=#), (#=nextrows=#))
+@inline function _fusedupdate_all(rowsentinel, activerow, rows, ks, stopks, As)
     val, nextk, nextrow = _fusedupdate(rowsentinel, activerow, first(rows), first(ks), first(stopks), first(As))
-    return _fusedupdate_all((vals..., val), (nextks..., nextk), (nextrows..., nextrow),
-                        rowsentinel, activerow, tail(rows), tail(ks), tail(stopks), tail(As))
+    vals, nextks, nextrows = _fusedupdate_all(rowsentinel, activerow, tail(rows), tail(ks), tail(stopks), tail(As))
+    return ((val, vals...), (nextk, nextks...), (nextrow, nextrows...))
 end
 
 
 # (7) _broadcast_zeropres!/_broadcast_notzeropres! specialized for a single (input) sparse vector/matrix
-function _broadcast_zeropres!{Tf}(f::Tf, C::SparseVecOrMat, A::SparseVecOrMat)
+function _broadcast_zeropres!(f::Tf, C::SparseVecOrMat, A::SparseVecOrMat) where Tf
     isempty(C) && return _finishempty!(C)
     spaceC::Int = min(length(storedinds(C)), length(storedvals(C)))
     # C and A cannot have the same shape, as we directed that case to map in broadcast's
@@ -481,7 +451,7 @@ function _broadcast_zeropres!{Tf}(f::Tf, C::SparseVecOrMat, A::SparseVecOrMat)
     trimstorage!(C, Ck - 1)
     return C
 end
-function _broadcast_notzeropres!{Tf}(f::Tf, fillvalue, C::SparseVecOrMat, A::SparseVecOrMat)
+function _broadcast_notzeropres!(f::Tf, fillvalue, C::SparseVecOrMat, A::SparseVecOrMat) where Tf
     # For information on this code, see comments in similar code in _broadcast_zeropres! above
     # Build dense matrix structure in C, expanding storage if necessary
     _densestructure!(C)
@@ -510,21 +480,20 @@ end
 
 
 # (8) _broadcast_zeropres!/_broadcast_notzeropres! specialized for a pair of (input) sparse vectors/matrices
-function _broadcast_zeropres!{Tf}(f::Tf, C::SparseVecOrMat, A::SparseVecOrMat, B::SparseVecOrMat)
+function _broadcast_zeropres!(f::Tf, C::SparseVecOrMat, A::SparseVecOrMat, B::SparseVecOrMat) where Tf
     isempty(C) && return _finishempty!(C)
     spaceC::Int = min(length(storedinds(C)), length(storedvals(C)))
     rowsentinelA = convert(indtype(A), numrows(C) + 1)
     rowsentinelB = convert(indtype(B), numrows(C) + 1)
-    # A and B cannot have the same shape, as we directed that case to map in broadcast's
-    # entry point; here we need efficiently handle only heterogeneous combinations of matrices
-    # with no singleton dimensions ("matrices" hereafter), one singleton dimension ("columns"
-    # and "rows"), and two singleton dimensions ("scalars"). Cases involving scalars should
-    # be rare and optimizing that case complicates the code appreciably, so we largely
-    # ignore that case's performance below.
+    # C, A, and B cannot all have the same shape, as we directed that case to map in broadcast's
+    # entry point; here we need efficiently handle only heterogeneous combinations of mats/vecs
+    # with no singleton dimensions, one singleton dimension, and two singleton dimensions.
+    # Cases involving objects with two singleton dimensions should be rare and optimizing
+    # that case complicates the code appreciably, so we largely ignore that case's
+    # performance below.
     #
-    # We first divide the cases into two groups: those in which neither argument expands
-    # vertically (matrix-column combinations) and those in which an argument expands
-    # vertically (matrix-row and column-row combinations).
+    # We first divide the cases into two groups: those in which neither input argument
+    # expands vertically, and those in which at least one argument expands vertically.
     #
     # NOTE: Placing the loops over columns outside the conditional chain segregating
     # argument shape combinations eliminates some code replication but unfortunately
@@ -532,7 +501,7 @@ function _broadcast_zeropres!{Tf}(f::Tf, C::SparseVecOrMat, A::SparseVecOrMat, B
     #
     # Cases without vertical expansion
     Ck = 1
-    if numrows(A) == numrows(B)
+    if numrows(A) == numrows(B) == numrows(C)
         @inbounds for j in columns(C)
             setcolptr!(C, j, Ck)
             Ak, stopAk = numcols(A) == 1 ? (colstartind(A, 1), colboundind(A, 1)) : (colstartind(A, j), colboundind(A, j))
@@ -575,14 +544,31 @@ function _broadcast_zeropres!{Tf}(f::Tf, C::SparseVecOrMat, A::SparseVecOrMat, B
             end
         end
     # Cases with vertical expansion
-    elseif numrows(A) == 1 # && numrows(B) != 1, vertically expand first argument
+    elseif numrows(A) == numrows(B) == 1 # && numrows(C) != 1, vertically expand both A and B
+        @inbounds for j in columns(C)
+            setcolptr!(C, j, Ck)
+            Ak, stopAk = numcols(A) == 1 ? (colstartind(A, 1), colboundind(A, 1)) : (colstartind(A, j), colboundind(A, j))
+            Bk, stopBk = numcols(B) == 1 ? (colstartind(B, 1), colboundind(B, 1)) : (colstartind(B, j), colboundind(B, j))
+            Ax = Ak < stopAk ? storedvals(A)[Ak] : zero(eltype(A))
+            Bx = Bk < stopBk ? storedvals(B)[Bk] : zero(eltype(B))
+            Cx = f(Ax, Bx)
+            if !_iszero(Cx)
+                for Ci::indtype(C) in 1:numrows(C)
+                    Ck > spaceC && (spaceC = expandstorage!(C, _unchecked_maxnnzbcres(size(C), A, B)))
+                    storedinds(C)[Ck] = Ci
+                    storedvals(C)[Ck] = Cx
+                    Ck += 1
+                end
+            end
+        end
+    elseif numrows(A) == 1 # && numrows(B) == numrows(C) != 1 , vertically expand only A
         @inbounds for j in columns(C)
             setcolptr!(C, j, Ck)
             Ak, stopAk = numcols(A) == 1 ? (colstartind(A, 1), colboundind(A, 1)) : (colstartind(A, j), colboundind(A, j))
             Bk, stopBk = numcols(B) == 1 ? (colstartind(B, 1), colboundind(B, 1)) : (colstartind(B, j), colboundind(B, j))
             Ax = Ak < stopAk ? storedvals(A)[Ak] : zero(eltype(A))
             fvAzB = f(Ax, zero(eltype(B)))
-            if fvAzB == zero(eltype(C))
+            if _iszero(fvAzB)
                 # either A's jth column is empty, or A's jth column contains a nonzero value
                 # Ax but f(Ax, zero(eltype(B))) is nonetheless zero, so we can scan through
                 # B's jth column without storing every entry in C's jth column
@@ -616,14 +602,14 @@ function _broadcast_zeropres!{Tf}(f::Tf, C::SparseVecOrMat, A::SparseVecOrMat, B
                 end
             end
         end
-    elseif numrows(B) == 1 # && numrows(A) != 1, vertically expand second argument
+    else # numrows(B) == 1 && numrows(A) == numrows(C) != 1, vertically expand only B
         @inbounds for j in columns(C)
             setcolptr!(C, j, Ck)
             Ak, stopAk = numcols(A) == 1 ? (colstartind(A, 1), colboundind(A, 1)) : (colstartind(A, j), colboundind(A, j))
             Bk, stopBk = numcols(B) == 1 ? (colstartind(B, 1), colboundind(B, 1)) : (colstartind(B, j), colboundind(B, j))
             Bx = Bk < stopBk ? storedvals(B)[Bk] : zero(eltype(B))
             fzAvB = f(zero(eltype(A)), Bx)
-            if fzAvB == zero(eltype(C))
+            if _iszero(fzAvB)
                 # either B's jth column is empty, or B's jth column contains a nonzero value
                 # Bx but f(zero(eltype(A)), Bx) is nonetheless zero, so we can scan through
                 # A's jth column without storing every entry in C's jth column
@@ -662,7 +648,7 @@ function _broadcast_zeropres!{Tf}(f::Tf, C::SparseVecOrMat, A::SparseVecOrMat, B
     trimstorage!(C, Ck - 1)
     return C
 end
-function _broadcast_notzeropres!{Tf}(f::Tf, fillvalue, C::SparseVecOrMat, A::SparseVecOrMat, B::SparseVecOrMat)
+function _broadcast_notzeropres!(f::Tf, fillvalue, C::SparseVecOrMat, A::SparseVecOrMat, B::SparseVecOrMat) where Tf
     # For information on this code, see comments in similar code in _broadcast_zeropres! above
     # Build dense matrix structure in C, expanding storage if necessary
     _densestructure!(C)
@@ -671,7 +657,7 @@ function _broadcast_notzeropres!{Tf}(f::Tf, fillvalue, C::SparseVecOrMat, A::Spa
     rowsentinelA = convert(indtype(A), numrows(C) + 1)
     rowsentinelB = convert(indtype(B), numrows(C) + 1)
     # Cases without vertical expansion
-    if numrows(A) == numrows(B)
+    if numrows(A) == numrows(B) == numrows(C)
         @inbounds for (j, jo) in zip(columns(C), _densecoloffsets(C))
             Ak, stopAk = numcols(A) == 1 ? (colstartind(A, 1), colboundind(A, 1)) : (colstartind(A, j), colboundind(A, j))
             Bk, stopBk = numcols(B) == 1 ? (colstartind(B, 1), colboundind(B, 1)) : (colstartind(B, j), colboundind(B, j))
@@ -695,13 +681,26 @@ function _broadcast_notzeropres!{Tf}(f::Tf, fillvalue, C::SparseVecOrMat, A::Spa
             end
         end
     # Cases with vertical expansion
-    elseif numrows(A) == 1 # && numrows(B) != 1, vertically expand first argument
+    elseif numrows(A) == numrows(B) == 1 # && numrows(C) != 1, vertically expand both A and B
+        @inbounds for (j, jo) in zip(columns(C), _densecoloffsets(C))
+            Ak, stopAk = numcols(A) == 1 ? (colstartind(A, 1), colboundind(A, 1)) : (colstartind(A, j), colboundind(A, j))
+            Bk, stopBk = numcols(B) == 1 ? (colstartind(B, 1), colboundind(B, 1)) : (colstartind(B, j), colboundind(B, j))
+            Ax = Ak < stopAk ? storedvals(A)[Ak] : zero(eltype(A))
+            Bx = Bk < stopBk ? storedvals(B)[Bk] : zero(eltype(B))
+            Cx = f(Ax, Bx)
+            if Cx != fillvalue
+                for Ck::Int in (jo + 1):(jo + numrows(C))
+                    storedvals(C)[Ck] = Cx
+                end
+            end
+        end
+    elseif numrows(A) == 1 # && numrows(B) == numrows(C) != 1, vertically expand only A
         @inbounds for (j, jo) in zip(columns(C), _densecoloffsets(C))
             Ak, stopAk = numcols(A) == 1 ? (colstartind(A, 1), colboundind(A, 1)) : (colstartind(A, j), colboundind(A, j))
             Bk, stopBk = numcols(B) == 1 ? (colstartind(B, 1), colboundind(B, 1)) : (colstartind(B, j), colboundind(B, j))
             Ax = Ak < stopAk ? storedvals(A)[Ak] : zero(eltype(A))
             fvAzB = f(Ax, zero(eltype(B)))
-            if fvAzB == zero(eltype(C))
+            if _iszero(fvAzB)
                 while Bk < stopBk
                     Cx = f(Ax, storedvals(B)[Bk])
                     Cx != fillvalue && (storedvals(C)[jo + storedinds(B)[Bk]] = Cx)
@@ -720,13 +719,13 @@ function _broadcast_notzeropres!{Tf}(f::Tf, fillvalue, C::SparseVecOrMat, A::Spa
                 end
             end
         end
-    elseif numrows(B) == 1 # && numrows(A) != 1, vertically expand second argument
+    else # numrows(B) == 1 && numrows(A) == numrows(C) != 1, vertically expand only B
         @inbounds for (j, jo) in zip(columns(C), _densecoloffsets(C))
             Ak, stopAk = numcols(A) == 1 ? (colstartind(A, 1), colboundind(A, 1)) : (colstartind(A, j), colboundind(A, j))
             Bk, stopBk = numcols(B) == 1 ? (colstartind(B, 1), colboundind(B, 1)) : (colstartind(B, j), colboundind(B, j))
             Bx = Bk < stopBk ? storedvals(B)[Bk] : zero(eltype(B))
             fzAvB = f(zero(eltype(A)), Bx)
-            if fzAvB == zero(eltype(C))
+            if _iszero(fzAvB)
                 while Ak < stopAk
                     Cx = f(storedvals(A)[Ak], Bx)
                     Cx != fillvalue && (storedvals(C)[jo + storedinds(A)[Ak]] = Cx)
@@ -753,7 +752,7 @@ _finishempty!(C::SparseMatrixCSC) = (fill!(C.colptr, 1); C)
 
 
 # (9) _broadcast_zeropres!/_broadcast_notzeropres! for more than two (input) sparse vectors/matrices
-function _broadcast_zeropres!{Tf,N}(f::Tf, C::SparseVecOrMat, As::Vararg{SparseVecOrMat,N})
+function _broadcast_zeropres!(f::Tf, C::SparseVecOrMat, As::Vararg{SparseVecOrMat,N}) where {Tf,N}
     isempty(C) && return _finishempty!(C)
     spaceC::Int = min(length(storedinds(C)), length(storedvals(C)))
     expandsverts = _expandsvert_all(C, As)
@@ -771,12 +770,8 @@ function _broadcast_zeropres!{Tf,N}(f::Tf, C::SparseVecOrMat, As::Vararg{SparseV
         rows = _initrowforcol_all(j, rowsentinel, isemptys, expandsverts, ks, As)
         defaultCx = f(defargs...)
         activerow = min(rows...)
-        if defaultCx == zero(eltype(C)) # zero-preserving column scan
+        if _iszero(defaultCx) # zero-preserving column scan
             while activerow < rowsentinel
-                # activerows = _isactiverow_all(activerow, rows)
-                # Cx = f(_gatherbcargs(activerows, defargs, ks, As)...)
-                # ks = _updateind_all(activerows, ks)
-                # rows = _updaterow_all(rowsentinel, activerows, rows, ks, stopks, As)
                 args, ks, rows = _fusedupdatebc_all(rowsentinel, activerow, rows, defargs, ks, stopks, As)
                 Cx = f(args...)
                 if !_iszero(Cx)
@@ -790,10 +785,6 @@ function _broadcast_zeropres!{Tf,N}(f::Tf, C::SparseVecOrMat, As::Vararg{SparseV
         else # zero-non-preserving column scan
             for Ci in 1:numrows(C)
                 if Ci == activerow
-                    # activerows = _isactiverow_all(activerow, rows)
-                    # Cx = f(_gatherbcargs(activerows, defargs, ks, As)...)
-                    # ks = _updateind_all(activerows, ks)
-                    # rows = _updaterow_all(rowsentinel, activerows, rows, ks, stopks, As)
                     args, ks, rows = _fusedupdatebc_all(rowsentinel, activerow, rows, defargs, ks, stopks, As)
                     Cx = f(args...)
                     activerow = min(rows...)
@@ -813,7 +804,7 @@ function _broadcast_zeropres!{Tf,N}(f::Tf, C::SparseVecOrMat, As::Vararg{SparseV
     trimstorage!(C, Ck - 1)
     return C
 end
-function _broadcast_notzeropres!{Tf,N}(f::Tf, fillvalue, C::SparseVecOrMat, As::Vararg{SparseVecOrMat,N})
+function _broadcast_notzeropres!(f::Tf, fillvalue, C::SparseVecOrMat, As::Vararg{SparseVecOrMat,N}) where {Tf,N}
     isempty(C) && return _finishempty!(C)
     # Build dense matrix structure in C, expanding storage if necessary
     _densestructure!(C)
@@ -834,10 +825,6 @@ function _broadcast_notzeropres!{Tf,N}(f::Tf, fillvalue, C::SparseVecOrMat, As::
         activerow = min(rows...)
         if defaultCx == fillvalue # fillvalue-preserving column scan
             while activerow < rowsentinel
-                # activerows = _isactiverow_all(activerow, rows)
-                # Cx = f(_gatherbcargs(activerows, defargs, ks, As)...)
-                # ks = _updateind_all(activerows, ks)
-                # rows = _updaterow_all(rowsentinel, activerows, rows, ks, stopks, As)
                 args, ks, rows = _fusedupdatebc_all(rowsentinel, activerow, rows, defargs, ks, stopks, As)
                 Cx = f(args...)
                 Cx != fillvalue && (storedvals(C)[jo + activerow] = Cx)
@@ -846,10 +833,6 @@ function _broadcast_notzeropres!{Tf,N}(f::Tf, fillvalue, C::SparseVecOrMat, As::
         else # fillvalue-non-preserving column scan
             for Ci in 1:numrows(C)
                 if Ci == activerow
-                    # activerows = _isactiverow_all(activerow, rows)
-                    # Cx = f(_gatherbcargs(activerows, defargs, ks, As)...)
-                    # ks = _updateind_all(activerows, ks)
-                    # rows = _updaterow_all(rowsentinel, activerows, rows, ks, stopks, As)
                     args, ks, rows = _fusedupdatebc_all(rowsentinel, activerow, rows, defargs, ks, stopks, As)
                     Cx = f(args...)
                     activerow = min(rows...)
@@ -862,6 +845,7 @@ function _broadcast_notzeropres!{Tf,N}(f::Tf, fillvalue, C::SparseVecOrMat, As::
     end
     return C
 end
+
 # helper method for broadcast/broadcast! methods just above
 @inline _expandsvert(C, A) = numrows(A) != numrows(C)
 @inline _expandsvert_all(C, ::Tuple{}) = ()
@@ -896,28 +880,6 @@ end
 @inline _defargforcol_all(j, isemptys, expandsverts, ks, As) = (
     _defargforcol(j, first(isemptys), first(expandsverts), first(ks), first(As)),
     _defargforcol_all(j, tail(isemptys), tail(expandsverts), tail(ks), tail(As))...)
-# fusing the following defs. avoids a few branches and construction of a tuple, yielding 1-20% runtime reduction
-# @inline _isactiverow(activerow, row) = row == activerow
-# @inline _isactiverow_all(activerow, ::Tuple{}) = ()
-# @inline _isactiverow_all(activerow, rows) = (
-#     _isactiverow(activerow, first(rows)),
-#     _isactiverow_all(activerow, tail(rows))...)
-# @inline _gatherbcarg(isactiverow, defarg, k, A) = isactiverow ? storedvals(A)[k] : defarg
-# @inline _gatherbcargs(::Tuple{}, ::Tuple{}, ::Tuple{}, ::Tuple{}) = ()
-# @inline _gatherbcargs(activerows, defargs, ks, As) = (
-#     _gatherbcarg(first(activerows), first(defargs), first(ks), first(As)),
-#     _gatherbcargs(tail(activerows), tail(defargs), tail(ks), tail(As))...)
-# @inline _updateind(isactiverow, k) = isactiverow ? (k + oneunit(k)) : k
-# @inline _updateind_all(::Tuple{}, ::Tuple{}) = ()
-# @inline _updateind_all(activerows, ks) = (
-#     _updateind(first(activerows), first(ks)),
-#     _updateind_all(tail(activerows), tail(ks))...)
-# @inline _updaterow(rowsentinel, isrowactive, presrow, k, stopk, A) =
-#     isrowactive ? (k < stopk ? storedinds(A)[k] : oftype(presrow, rowsentinel)) : presrow
-# @inline _updaterow_all(rowsentinel, ::Tuple{}, ::Tuple{}, ::Tuple{}, ::Tuple{}, ::Tuple{}) = ()
-# @inline _updaterow_all(rowsentinel, activerows, rows, ks, stopks, As) = (
-#     _updaterow(rowsentinel, first(activerows), first(rows), first(ks), first(stopks), first(As)),
-#     _updaterow_all(rowsentinel, tail(activerows), tail(rows), tail(ks), tail(stopks), tail(As))...)
 @inline function _fusedupdatebc(rowsentinel, activerow, row, defarg, k, stopk, A)
     # returns (val, nextk, nextrow)
     if row == activerow
@@ -927,14 +889,11 @@ end
         (defarg, k, row)
     end
 end
-@inline _fusedupdatebc_all(rowsentinel, activerow, rows, defargs, ks, stopks, As) =
-    _fusedupdatebc_all((#=vals=#), (#=nextks=#), (#=nextrows=#), rowsentinel, activerow, rows, defargs, ks, stopks, As)
-@inline _fusedupdatebc_all(vals, nextks, nextrows, rowsent, activerow, ::Tuple{}, ::Tuple{}, ::Tuple{}, ::Tuple{}, ::Tuple{}) =
-    (vals, nextks, nextrows)
-@inline function _fusedupdatebc_all(vals, nextks, nextrows, rowsentinel, activerow, rows, defargs, ks, stopks, As)
+@inline _fusedupdatebc_all(rowsent, activerow, ::Tuple{}, ::Tuple{}, ::Tuple{}, ::Tuple{}, ::Tuple{}) = ((#=vals=#), (#=nextks=#), (#=nextrows=#))
+@inline function _fusedupdatebc_all(rowsentinel, activerow, rows, defargs, ks, stopks, As)
     val, nextk, nextrow = _fusedupdatebc(rowsentinel, activerow, first(rows), first(defargs), first(ks), first(stopks), first(As))
-    return _fusedupdatebc_all((vals..., val), (nextks..., nextk), (nextrows..., nextrow),
-                        rowsentinel, activerow, tail(rows), tail(defargs), tail(ks), tail(stopks), tail(As))
+    vals, nextks, nextrows = _fusedupdatebc_all(rowsentinel, activerow, tail(rows), tail(defargs), tail(ks), tail(stopks), tail(As))
+    return ((val, vals...), (nextk, nextks...), (nextrow, nextrows...))
 end
 
 
@@ -953,11 +912,11 @@ promote_containertype(::Type{Tuple}, ::Type{AbstractSparseArray}) = Array
 promote_containertype(::Type{AbstractSparseArray}, ::Type{Tuple}) = Array
 
 # broadcast[!] entry points for combinations of sparse arrays and other (scalar) types
-@inline function broadcast_c{N}(f, ::Type{AbstractSparseArray}, mixedargs::Vararg{Any,N})
+@inline function broadcast_c(f, ::Type{AbstractSparseArray}, mixedargs::Vararg{Any,N}) where N
     parevalf, passedargstup = capturescalars(f, mixedargs)
     return broadcast(parevalf, passedargstup...)
 end
-@inline function broadcast_c!{N}(f, ::Type{AbstractSparseArray}, dest::SparseVecOrMat, mixedsrcargs::Vararg{Any,N})
+@inline function broadcast_c!(f, ::Type{AbstractSparseArray}, dest::SparseVecOrMat, mixedsrcargs::Vararg{Any,N}) where N
     parevalf, passedsrcargstup = capturescalars(f, mixedsrcargs)
     return broadcast!(parevalf, dest, passedsrcargstup...)
 end
@@ -966,26 +925,42 @@ end
 # evaluated f) and a reduced argument tuple (passedargstup) containing only the sparse
 # vectors/matrices in mixedargs in their orginal order, and such that the result of
 # broadcast(parevalf, passedargstup...) is broadcast(f, mixedargs...)
-@inline capturescalars(f, mixedargs) =
-    capturescalars((passed, tofill) -> f(tofill...), (), mixedargs...)
-# Recursion cases for capturescalars
-@inline capturescalars(f, passedargstup, scalararg, mixedargs...) =
-    capturescalars(capturescalar(f, scalararg), passedargstup, mixedargs...)
-@inline capturescalars(f, passedargstup, nonscalararg::SparseVecOrMat, mixedargs...) =
-    capturescalars(passnonscalar(f), (passedargstup..., nonscalararg), mixedargs...)
-@inline passnonscalar(f) = (passed, tofill) -> f(Base.front(passed), (last(passed), tofill...))
-@inline capturescalar(f, scalararg) = (passed, tofill) -> f(passed, (scalararg, tofill...))
-# Base cases for capturescalars
-@inline capturescalars(f, passedargstup, scalararg) =
-    (capturelastscalar(f, scalararg), passedargstup)
-@inline capturescalars(f, passedargstup, nonscalararg::SparseVecOrMat) =
-    (passlastnonscalar(f), (passedargstup..., nonscalararg))
-@inline passlastnonscalar(f) = (passed...) -> f(Base.front(passed), (last(passed),))
-@inline capturelastscalar(f, scalararg) = (passed...) -> f(passed, (scalararg,))
+@inline function capturescalars(f, mixedargs)
+    let makeargs = _capturescalars(mixedargs...),
+        parevalf = (passed...) -> f(makeargs(passed...)...),
+        passedsrcargstup = _capturenonscalars(mixedargs...)
+        return (parevalf, passedsrcargstup)
+    end
+end
+
+@inline _capturenonscalars(nonscalararg::SparseVecOrMat, mixedargs...) =
+    (nonscalararg, _capturenonscalars(mixedargs...)...)
+@inline _capturenonscalars(scalararg, mixedargs...) =
+    _capturenonscalars(mixedargs...)
+@inline _capturenonscalars() = ()
+
+@inline _capturescalars(nonscalararg::SparseVecOrMat, mixedargs...) =
+    let f = _capturescalars(mixedargs...)
+        (head, tail...) -> (head, f(tail...)...) # pass-through
+    end
+@inline _capturescalars(scalararg, mixedargs...) =
+    let f = _capturescalars(mixedargs...)
+        (tail...) -> (scalararg, f(tail...)...) # add scalararg
+    end
+# TODO: use the implicit version once inference can handle it
+# handle too-many-arguments explicitly
+@inline function _capturescalars()
+    too_many_arguments() = ()
+    too_many_arguments(tail...) = throw(ArgumentError("too many"))
+end
+#@inline _capturescalars(nonscalararg::SparseVecOrMat) =
+#    (head,) -> (head,) # pass-through
+#@inline _capturescalars(scalararg) =
+#    () -> (scalararg,) # add scalararg
 
 # NOTE: The following two method definitions work around #19096.
-broadcast{Tf,T}(f::Tf, ::Type{T}, A::SparseMatrixCSC) = broadcast(y -> f(T, y), A)
-broadcast{Tf,T}(f::Tf, A::SparseMatrixCSC, ::Type{T}) = broadcast(x -> f(x, T), A)
+broadcast(f::Tf, ::Type{T}, A::SparseMatrixCSC) where {Tf,T} = broadcast(y -> f(T, y), A)
+broadcast(f::Tf, A::SparseMatrixCSC, ::Type{T}) where {Tf,T} = broadcast(x -> f(x, T), A)
 
 
 # (11) broadcast[!] over combinations of scalars, sparse vectors/matrices, structured matrices,
@@ -1009,6 +984,7 @@ struct PromoteToSparse end
 # broadcast containertype definitions for structured matrices
 StructuredMatrix = Union{Diagonal,Bidiagonal,Tridiagonal,SymTridiagonal}
 _containertype(::Type{<:StructuredMatrix}) = PromoteToSparse
+broadcast_indices(::Type{PromoteToSparse}, A) = indices(A)
 
 # combinations explicitly involving Tuples and PromoteToSparse collections
 # divert to the generic AbstractArray broadcast code
@@ -1033,6 +1009,7 @@ promote_containertype(::Type{Array}, ::Type{AbstractSparseArray}) = PromoteToSpa
 _spcontainertype(x) = _containertype(x)
 _spcontainertype(::Type{<:Vector}) = Vector
 _spcontainertype(::Type{<:Matrix}) = Matrix
+_spcontainertype(::Type{<:RowVector}) = Matrix
 _spcontainertype(::Type{<:Ref}) = AbstractArray
 _spcontainertype(::Type{<:AbstractArray}) = AbstractArray
 # need the following two methods to override the immediately preceding method
@@ -1042,7 +1019,7 @@ spcontainertype(x) = _spcontainertype(typeof(x))
 spcontainertype(ct1, ct2) = promote_spcontainertype(spcontainertype(ct1), spcontainertype(ct2))
 @inline spcontainertype(ct1, ct2, cts...) = promote_spcontainertype(spcontainertype(ct1), spcontainertype(ct2, cts...))
 
-promote_spcontainertype{T}(::Type{T}, ::Type{T}) = T
+promote_spcontainertype(::Type{T}, ::Type{T}) where {T} = T
 # combinations involving AbstractArrays and/or Tuples divert to the generic AbstractArray broadcast code
 DivertToAbsArrayBC = Union{Type{AbstractArray},Type{Tuple}}
 promote_spcontainertype(::DivertToAbsArrayBC, ct) = AbstractArray
@@ -1056,39 +1033,40 @@ promote_spcontainertype(::FunnelToSparseBC, ::FunnelToSparseBC) = PromoteToSpars
 
 # first (Broadcast containertype) dispatch layer
 # (broadcast_c[!], containertype, promote_containertype)
-@inline broadcast_c{N}(f, ::Type{PromoteToSparse}, As::Vararg{Any,N}) =
+@inline broadcast_c(f, ::Type{PromoteToSparse}, As::Vararg{Any,N}) where {N} =
     spbroadcast_c(f, spcontainertype(As...), As...)
-@inline broadcast_c!{N}(f, ::Type{AbstractSparseArray}, ::Type{PromoteToSparse}, C, B, As::Vararg{Any,N}) =
+@inline broadcast_c!(f, ::Type{AbstractSparseArray}, ::Type{PromoteToSparse}, C, B, As::Vararg{Any,N}) where {N} =
     spbroadcast_c!(f, AbstractSparseArray, spcontainertype(B, As...), C, B, As...)
 # where destination C is not an AbstractSparseArray, divert to generic AbstractArray broadcast code
-@inline broadcast_c!{N}(f, CT::Type, ::Type{PromoteToSparse}, C, B, As::Vararg{Any,N}) =
+@inline broadcast_c!(f, CT::Type, ::Type{PromoteToSparse}, C, B, As::Vararg{Any,N}) where {N} =
     broadcast_c!(f, CT, Array, C, B, As...)
 
 # second (internal sparse broadcast containertype) dispatch layer
 # (spbroadcast_c[!], spcontainertype, promote_spcontainertype)
-@inline spbroadcast_c{N}(f, ::Type{PromoteToSparse}, As::Vararg{Any,N}) =
+@inline spbroadcast_c(f, ::Type{PromoteToSparse}, As::Vararg{Any,N}) where {N} =
     broadcast(f, map(_sparsifystructured, As)...)
-@inline spbroadcast_c{N}(f, ::Type{AbstractArray}, As::Vararg{Any,N}) =
+@inline spbroadcast_c(f, ::Type{AbstractArray}, As::Vararg{Any,N}) where {N} =
     broadcast_c(f, Array, As...)
-@inline spbroadcast_c!{N}(f, ::Type{AbstractSparseArray}, ::Type{PromoteToSparse}, C, B, As::Vararg{Any,N}) =
+@inline spbroadcast_c!(f, ::Type{AbstractSparseArray}, ::Type{PromoteToSparse}, C, B, As::Vararg{Any,N}) where {N} =
     broadcast!(f, C, _sparsifystructured(B), map(_sparsifystructured, As)...)
-@inline spbroadcast_c!{N}(f, ::Type{AbstractSparseArray}, ::Type{AbstractArray}, C, B, As::Vararg{Any,N}) =
+@inline spbroadcast_c!(f, ::Type{AbstractSparseArray}, ::Type{AbstractArray}, C, B, As::Vararg{Any,N}) where {N} =
     broadcast_c!(f, Array, Array, C, B, As...)
 
-@inline _sparsifystructured(A::AbstractSparseArray) = A
-@inline _sparsifystructured(M::StructuredMatrix) = SparseMatrixCSC(M)
-@inline _sparsifystructured(M::Matrix) = SparseMatrixCSC(M)
-@inline _sparsifystructured(V::Vector) = SparseVector(V)
+@inline _sparsifystructured(M::AbstractMatrix) = SparseMatrixCSC(M)
+@inline _sparsifystructured(V::AbstractVector) = SparseVector(V)
+@inline _sparsifystructured(M::AbstractSparseMatrix) = SparseMatrixCSC(M)
+@inline _sparsifystructured(V::AbstractSparseVector) = SparseVector(V)
+@inline _sparsifystructured(S::SparseVecOrMat) = S
 @inline _sparsifystructured(x) = x
 
 
 # (12) map[!] over combinations of sparse and structured matrices
 StructuredMatrix = Union{Diagonal,Bidiagonal,Tridiagonal,SymTridiagonal}
 SparseOrStructuredMatrix = Union{SparseMatrixCSC,StructuredMatrix}
-map{Tf}(f::Tf, A::StructuredMatrix) = _noshapecheck_map(f, _sparsifystructured(A))
-map{Tf,N}(f::Tf, A::SparseOrStructuredMatrix, Bs::Vararg{SparseOrStructuredMatrix,N}) =
+map(f::Tf, A::StructuredMatrix) where {Tf} = _noshapecheck_map(f, _sparsifystructured(A))
+map(f::Tf, A::SparseOrStructuredMatrix, Bs::Vararg{SparseOrStructuredMatrix,N}) where {Tf,N} =
     (_checksameshape(A, Bs...); _noshapecheck_map(f, _sparsifystructured(A), map(_sparsifystructured, Bs)...))
-map!{Tf,N}(f::Tf, C::SparseMatrixCSC, A::SparseOrStructuredMatrix, Bs::Vararg{SparseOrStructuredMatrix,N}) =
+map!(f::Tf, C::SparseMatrixCSC, A::SparseOrStructuredMatrix, Bs::Vararg{SparseOrStructuredMatrix,N}) where {Tf,N} =
     (_checksameshape(C, A, Bs...); _noshapecheck_map!(f, C, _sparsifystructured(A), map(_sparsifystructured, Bs)...))
 
 end
diff --git a/base/sparse/linalg.jl b/base/sparse/linalg.jl
index 6884421febf0b0..eefd80f9d09b6e 100644
--- a/base/sparse/linalg.jl
+++ b/base/sparse/linalg.jl
@@ -1,18 +1,18 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 import Base.LinAlg: checksquare
 
 ## Functions to switch to 0-based indexing to call external sparse solvers
 
 # Convert from 1-based to 0-based indices
-function decrement!{T<:Integer}(A::AbstractArray{T})
+function decrement!(A::AbstractArray{T}) where T<:Integer
     for i in 1:length(A); A[i] -= oneunit(T) end
     A
 end
 decrement(A::AbstractArray{<:Integer}) = decrement!(copy(A))
 
 # Convert from 0-based to 1-based indices
-function increment!{T<:Integer}(A::AbstractArray{T})
+function increment!(A::AbstractArray{T}) where T<:Integer
     for i in 1:length(A); A[i] += oneunit(T) end
     A
 end
@@ -20,20 +20,20 @@ increment(A::AbstractArray{<:Integer}) = increment!(copy(A))
 
 ## sparse matrix multiplication
 
-function (*){TvA,TiA,TvB,TiB}(A::SparseMatrixCSC{TvA,TiA}, B::SparseMatrixCSC{TvB,TiB})
+function (*)(A::SparseMatrixCSC{TvA,TiA}, B::SparseMatrixCSC{TvB,TiB}) where {TvA,TiA,TvB,TiB}
     (*)(sppromote(A, B)...)
 end
 for f in (:A_mul_Bt, :A_mul_Bc,
           :At_mul_B, :Ac_mul_B,
           :At_mul_Bt, :Ac_mul_Bc)
     @eval begin
-        function ($f){TvA,TiA,TvB,TiB}(A::SparseMatrixCSC{TvA,TiA}, B::SparseMatrixCSC{TvB,TiB})
+        function ($f)(A::SparseMatrixCSC{TvA,TiA}, B::SparseMatrixCSC{TvB,TiB}) where {TvA,TiA,TvB,TiB}
             ($f)(sppromote(A, B)...)
         end
     end
 end
 
-function sppromote{TvA,TiA,TvB,TiB}(A::SparseMatrixCSC{TvA,TiA}, B::SparseMatrixCSC{TvB,TiB})
+function sppromote(A::SparseMatrixCSC{TvA,TiA}, B::SparseMatrixCSC{TvB,TiB}) where {TvA,TiA,TvB,TiB}
     Tv = promote_type(TvA, TvB)
     Ti = promote_type(TiA, TiB)
     A  = convert(SparseMatrixCSC{Tv,Ti}, A)
@@ -61,8 +61,8 @@ for (f, op, transp) in ((:A_mul_B, :identity, false),
             if β != 1
                 β != 0 ? scale!(C, β) : fill!(C, zero(eltype(C)))
             end
-            for col = 1:A.n
-                for k = 1:size(C, 2)
+            for k = 1:size(C, 2)
+                for col = 1:A.n
                     if $transp
                         tmp = zero(eltype(C))
                         @inbounds for j = A.colptr[col]:(A.colptr[col + 1] - 1)
@@ -80,11 +80,11 @@ for (f, op, transp) in ((:A_mul_B, :identity, false),
             C
         end
 
-        function $(f){TA,S,Tx}(A::SparseMatrixCSC{TA,S}, x::StridedVector{Tx})
+        function $(f)(A::SparseMatrixCSC{TA,S}, x::StridedVector{Tx}) where {TA,S,Tx}
             T = promote_type(TA, Tx)
             $(Symbol(f,:!))(one(T), A, x, zero(T), similar(x, T, A.n))
         end
-        function $(f){TA,S,Tx}(A::SparseMatrixCSC{TA,S}, B::StridedMatrix{Tx})
+        function $(f)(A::SparseMatrixCSC{TA,S}, B::StridedMatrix{Tx}) where {TA,S,Tx}
             T = promote_type(TA, Tx)
             $(Symbol(f,:!))(one(T), A, B, zero(T), similar(B, T, (A.n, size(B, 2))))
         end
@@ -98,7 +98,7 @@ Ac_mul_B!(C::StridedVecOrMat, A::SparseMatrixCSC, B::StridedVecOrMat) = Ac_mul_B
 At_mul_B!(C::StridedVecOrMat, A::SparseMatrixCSC, B::StridedVecOrMat) = At_mul_B!(one(eltype(B)), A, B, zero(eltype(C)), C)
 
 
-function (*){TX,TvA,TiA}(X::StridedMatrix{TX}, A::SparseMatrixCSC{TvA,TiA})
+function (*)(X::StridedMatrix{TX}, A::SparseMatrixCSC{TvA,TiA}) where {TX,TvA,TiA}
     mX, nX = size(X)
     nX == A.m || throw(DimensionMismatch())
     Y = zeros(promote_type(TX,TvA), mX, A.n)
@@ -122,7 +122,7 @@ end
 # Sparse matrix multiplication as described in [Gustavson, 1978]:
 # http://dl.acm.org/citation.cfm?id=355796
 
-(*){Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, B::SparseMatrixCSC{Tv,Ti}) = spmatmul(A,B)
+(*)(A::SparseMatrixCSC{Tv,Ti}, B::SparseMatrixCSC{Tv,Ti}) where {Tv,Ti} = spmatmul(A,B)
 for (f, opA, opB) in ((:A_mul_Bt, :identity, :transpose),
                       (:A_mul_Bc, :identity, :ctranspose),
                       (:At_mul_B, :transpose, :identity),
@@ -130,14 +130,14 @@ for (f, opA, opB) in ((:A_mul_Bt, :identity, :transpose),
                       (:At_mul_Bt, :transpose, :transpose),
                       (:Ac_mul_Bc, :ctranspose, :ctranspose))
     @eval begin
-        function ($f){Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, B::SparseMatrixCSC{Tv,Ti})
+        function ($f)(A::SparseMatrixCSC{Tv,Ti}, B::SparseMatrixCSC{Tv,Ti}) where {Tv,Ti}
             spmatmul(($opA)(A), ($opB)(B))
         end
     end
 end
 
-function spmatmul{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, B::SparseMatrixCSC{Tv,Ti};
-                         sortindices::Symbol = :sortcols)
+function spmatmul(A::SparseMatrixCSC{Tv,Ti}, B::SparseMatrixCSC{Tv,Ti};
+                  sortindices::Symbol = :sortcols) where {Tv,Ti}
     mA, nA = size(A)
     mB, nB = size(B)
     nA==mB || throw(DimensionMismatch())
@@ -146,9 +146,9 @@ function spmatmul{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, B::SparseMatrixCSC{Tv,Ti};
     colptrB = B.colptr; rowvalB = B.rowval; nzvalB = B.nzval
     # TODO: Need better estimation of result space
     nnzC = min(mA*nB, length(nzvalA) + length(nzvalB))
-    colptrC = Array{Ti}(nB+1)
-    rowvalC = Array{Ti}(nnzC)
-    nzvalC = Array{Tv}(nnzC)
+    colptrC = Vector{Ti}(nB+1)
+    rowvalC = Vector{Ti}(nnzC)
+    nzvalC = Vector{Tv}(nnzC)
 
     @inbounds begin
         ip = 1
@@ -194,7 +194,7 @@ function spmatmul{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, B::SparseMatrixCSC{Tv,Ti};
 end
 
 ## solvers
-function fwdTriSolve!(A::SparseMatrixCSC, B::AbstractVecOrMat)
+function fwdTriSolve!(A::SparseMatrixCSCUnion, B::AbstractVecOrMat)
 # forward substitution for CSC matrices
     nrowB, ncolB  = size(B, 1), size(B, 2)
     ncol = LinAlg.checksquare(A)
@@ -202,9 +202,9 @@ function fwdTriSolve!(A::SparseMatrixCSC, B::AbstractVecOrMat)
         throw(DimensionMismatch("A is $(ncol) columns and B has $(nrowB) rows"))
     end
 
-    aa = A.nzval
-    ja = A.rowval
-    ia = A.colptr
+    aa = getnzval(A)
+    ja = getrowval(A)
+    ia = getcolptr(A)
 
     joff = 0
     for k = 1:ncolB
@@ -239,7 +239,7 @@ function fwdTriSolve!(A::SparseMatrixCSC, B::AbstractVecOrMat)
     B
 end
 
-function bwdTriSolve!(A::SparseMatrixCSC, B::AbstractVecOrMat)
+function bwdTriSolve!(A::SparseMatrixCSCUnion, B::AbstractVecOrMat)
 # backward substitution for CSC matrices
     nrowB, ncolB = size(B, 1), size(B, 2)
     ncol = LinAlg.checksquare(A)
@@ -247,9 +247,9 @@ function bwdTriSolve!(A::SparseMatrixCSC, B::AbstractVecOrMat)
         throw(DimensionMismatch("A is $(ncol) columns and B has $(nrowB) rows"))
     end
 
-    aa = A.nzval
-    ja = A.rowval
-    ia = A.colptr
+    aa = getnzval(A)
+    ja = getrowval(A)
+    ia = getcolptr(A)
 
     joff = 0
     for k = 1:ncolB
@@ -284,20 +284,41 @@ function bwdTriSolve!(A::SparseMatrixCSC, B::AbstractVecOrMat)
     B
 end
 
-A_ldiv_B!{T}(L::LowerTriangular{T,<:SparseMatrixCSC{T}}, B::StridedVecOrMat) = fwdTriSolve!(L.data, B)
-A_ldiv_B!{T}(U::UpperTriangular{T,<:SparseMatrixCSC{T}}, B::StridedVecOrMat) = bwdTriSolve!(U.data, B)
+A_ldiv_B!(L::LowerTriangular{T,<:SparseMatrixCSCUnion{T}}, B::StridedVecOrMat) where {T} = fwdTriSolve!(L.data, B)
+A_ldiv_B!(U::UpperTriangular{T,<:SparseMatrixCSCUnion{T}}, B::StridedVecOrMat) where {T} = bwdTriSolve!(U.data, B)
 
-(\){T}(L::LowerTriangular{T,<:SparseMatrixCSC{T}}, B::SparseMatrixCSC) = A_ldiv_B!(L, Array(B))
-(\){T}(U::UpperTriangular{T,<:SparseMatrixCSC{T}}, B::SparseMatrixCSC) = A_ldiv_B!(U, Array(B))
+(\)(L::LowerTriangular{T,<:SparseMatrixCSCUnion{T}}, B::SparseMatrixCSC) where {T} = A_ldiv_B!(L, Array(B))
+(\)(U::UpperTriangular{T,<:SparseMatrixCSCUnion{T}}, B::SparseMatrixCSC) where {T} = A_ldiv_B!(U, Array(B))
+
+function A_rdiv_B!(A::SparseMatrixCSC{T}, D::Diagonal{T}) where T
+    dd = D.diag
+    if (k = length(dd)) ≠ A.n
+        throw(DimensionMismatch("size(A, 2)=$(A.n) should be size(D, 1)=$k"))
+    end
+    nonz = nonzeros(A)
+    @inbounds for j in 1:k
+        ddj = dd[j]
+        if iszero(ddj)
+            throw(LinAlg.SingularException(j))
+        end
+        for k in nzrange(A, j)
+            nonz[k] /= ddj
+        end
+    end
+    A
+end
+
+A_rdiv_Bc!(A::SparseMatrixCSC{T}, D::Diagonal{T}) where {T} = A_rdiv_B!(A, conj(D))
+A_rdiv_Bt!(A::SparseMatrixCSC{T}, D::Diagonal{T}) where {T} = A_rdiv_B!(A, D)
 
 ## triu, tril
 
-function triu{Tv,Ti}(S::SparseMatrixCSC{Tv,Ti}, k::Integer=0)
+function triu(S::SparseMatrixCSC{Tv,Ti}, k::Integer=0) where {Tv,Ti}
     m,n = size(S)
     if (k > 0 && k > n) || (k < 0 && -k > m)
         throw(BoundsError())
     end
-    colptr = Array{Ti}(n+1)
+    colptr = Vector{Ti}(n+1)
     nnz = 0
     for col = 1 : min(max(k+1,1), n+1)
         colptr[col] = 1
@@ -309,8 +330,8 @@ function triu{Tv,Ti}(S::SparseMatrixCSC{Tv,Ti}, k::Integer=0)
         end
         colptr[col+1] = nnz+1
     end
-    rowval = Array{Ti}(nnz)
-    nzval = Array{Tv}(nnz)
+    rowval = Vector{Ti}(nnz)
+    nzval = Vector{Tv}(nnz)
     A = SparseMatrixCSC(m, n, colptr, rowval, nzval)
     for col = max(k+1,1) : n
         c1 = S.colptr[col]
@@ -323,12 +344,12 @@ function triu{Tv,Ti}(S::SparseMatrixCSC{Tv,Ti}, k::Integer=0)
     A
 end
 
-function tril{Tv,Ti}(S::SparseMatrixCSC{Tv,Ti}, k::Integer=0)
+function tril(S::SparseMatrixCSC{Tv,Ti}, k::Integer=0) where {Tv,Ti}
     m,n = size(S)
     if (k > 0 && k > n) || (k < 0 && -k > m)
         throw(BoundsError())
     end
-    colptr = Array{Ti}(n+1)
+    colptr = Vector{Ti}(n+1)
     nnz = 0
     colptr[1] = 1
     for col = 1 : min(n, m+k)
@@ -342,8 +363,8 @@ function tril{Tv,Ti}(S::SparseMatrixCSC{Tv,Ti}, k::Integer=0)
     for col = max(min(n, m+k)+2,1) : n+1
         colptr[col] = nnz+1
     end
-    rowval = Array{Ti}(nnz)
-    nzval = Array{Tv}(nnz)
+    rowval = Vector{Ti}(nnz)
+    nzval = Vector{Tv}(nnz)
     A = SparseMatrixCSC(m, n, colptr, rowval, nzval)
     for col = 1 : min(n, m+k)
         c1 = S.colptr[col+1]-1
@@ -359,13 +380,13 @@ end
 
 ## diff
 
-function sparse_diff1{Tv,Ti}(S::SparseMatrixCSC{Tv,Ti})
+function sparse_diff1(S::SparseMatrixCSC{Tv,Ti}) where {Tv,Ti}
     m,n = size(S)
     m > 1 || return SparseMatrixCSC(0, n, ones(Ti,n+1), Ti[], Tv[])
-    colptr = Array{Ti}(n+1)
+    colptr = Vector{Ti}(n+1)
     numnz = 2 * nnz(S) # upper bound; will shrink later
-    rowval = Array{Ti}(numnz)
-    nzval = Array{Tv}(numnz)
+    rowval = Vector{Ti}(numnz)
+    nzval = Vector{Tv}(numnz)
     numnz = 0
     colptr[1] = 1
     for col = 1 : n
@@ -399,12 +420,12 @@ function sparse_diff1{Tv,Ti}(S::SparseMatrixCSC{Tv,Ti})
     return SparseMatrixCSC(m-1, n, colptr, rowval, nzval)
 end
 
-function sparse_diff2{Tv,Ti}(a::SparseMatrixCSC{Tv,Ti})
+function sparse_diff2(a::SparseMatrixCSC{Tv,Ti}) where {Tv,Ti}
     m,n = size(a)
-    colptr = Array{Ti}(max(n,1))
+    colptr = Vector{Ti}(max(n,1))
     numnz = 2 * nnz(a) # upper bound; will shrink later
-    rowval = Array{Ti}(numnz)
-    nzval = Array{Tv}(numnz)
+    rowval = Vector{Ti}(numnz)
+    nzval = Vector{Tv}(numnz)
 
     z = zero(Tv)
 
@@ -545,7 +566,7 @@ function cond(A::SparseMatrixCSC, p::Real=2)
     end
 end
 
-function normestinv{T}(A::SparseMatrixCSC{T}, t::Integer = min(2,maximum(size(A))))
+function normestinv(A::SparseMatrixCSC{T}, t::Integer = min(2,maximum(size(A)))) where T
     maxiter = 5
     # Check the input
     n = checksquare(A)
@@ -556,8 +577,8 @@ function normestinv{T}(A::SparseMatrixCSC{T}, t::Integer = min(2,maximum(size(A)
     if t > n
         throw(ArgumentError("number of blocks must not be greater than $n"))
     end
-    ind = Array{Int64}(n)
-    ind_hist = Array{Int64}(maxiter * t)
+    ind = Vector{Int64}(n)
+    ind_hist = Vector{Int64}(maxiter * t)
 
     Ti = typeof(float(zero(T)))
 
@@ -565,7 +586,7 @@ function normestinv{T}(A::SparseMatrixCSC{T}, t::Integer = min(2,maximum(size(A)
 
     function _rand_pm1!(v)
         for i in eachindex(v)
-            v[i] = rand()<0.5?1:-1
+            v[i] = rand()<0.5 ? 1 : -1
         end
     end
 
@@ -579,7 +600,7 @@ function normestinv{T}(A::SparseMatrixCSC{T}, t::Integer = min(2,maximum(size(A)
     end
 
     # Generate the block matrix
-    X = Array{Ti}(n, t)
+    X = Matrix{Ti}(n, t)
     X[1:n,1] = 1
     for j = 2:t
         while true
@@ -590,7 +611,7 @@ function normestinv{T}(A::SparseMatrixCSC{T}, t::Integer = min(2,maximum(size(A)
             end
         end
     end
-    scale!(X, 1./n)
+    scale!(X, 1 ./ n)
 
     iter = 0
     local est
@@ -622,7 +643,7 @@ function normestinv{T}(A::SparseMatrixCSC{T}, t::Integer = min(2,maximum(size(A)
         S_old = copy(S)
         for j = 1:t
             for i = 1:n
-                S[i,j] = Y[i,j]==0?one(Y[i,j]):sign(Y[i,j])
+                S[i,j] = Y[i,j]==0 ? one(Y[i,j]) : sign(Y[i,j])
             end
         end
 
@@ -718,7 +739,7 @@ end
 
 # kron
 
-function kron{Tv,Ti}(a::SparseMatrixCSC{Tv,Ti}, b::SparseMatrixCSC{Tv,Ti})
+function kron(a::SparseMatrixCSC{Tv,Ti}, b::SparseMatrixCSC{Tv,Ti}) where {Tv,Ti}
     numnzA = nnz(a)
     numnzB = nnz(b)
 
@@ -729,9 +750,9 @@ function kron{Tv,Ti}(a::SparseMatrixCSC{Tv,Ti}, b::SparseMatrixCSC{Tv,Ti})
 
     m,n = mA*mB, nA*nB
 
-    colptr = Array{Ti}(n+1)
-    rowval = Array{Ti}(numnz)
-    nzval = Array{Tv}(numnz)
+    colptr = Vector{Ti}(n+1)
+    rowval = Vector{Ti}(numnz)
+    nzval = Vector{Tv}(numnz)
 
     colptr[1] = 1
 
@@ -773,7 +794,7 @@ function kron{Tv,Ti}(a::SparseMatrixCSC{Tv,Ti}, b::SparseMatrixCSC{Tv,Ti})
     SparseMatrixCSC(m, n, colptr, rowval, nzval)
 end
 
-function kron{Tv1,Ti1,Tv2,Ti2}(A::SparseMatrixCSC{Tv1,Ti1}, B::SparseMatrixCSC{Tv2,Ti2})
+function kron(A::SparseMatrixCSC{Tv1,Ti1}, B::SparseMatrixCSC{Tv2,Ti2}) where {Tv1,Ti1,Tv2,Ti2}
     Tv_res = promote_type(Tv1, Tv2)
     Ti_res = promote_type(Ti1, Ti2)
     A = convert(SparseMatrixCSC{Tv_res,Ti_res}, A)
@@ -851,29 +872,32 @@ end
 scale!(A::SparseMatrixCSC, b::Number) = (scale!(A.nzval, b); A)
 scale!(b::Number, A::SparseMatrixCSC) = (scale!(b, A.nzval); A)
 
-function (\)(A::SparseMatrixCSC, B::AbstractVecOrMat)
-    m, n = size(A)
-    if m == n
-        if istril(A)
-            if istriu(A)
-                return Diagonal(A) \ B
+for f in (:\, :Ac_ldiv_B, :At_ldiv_B)
+    @eval begin
+        function ($f)(A::SparseMatrixCSC, B::AbstractVecOrMat)
+            m, n = size(A)
+            if m == n
+                if istril(A)
+                    if istriu(A)
+                        return ($f)(Diagonal(A), B)
+                    else
+                        return ($f)(LowerTriangular(A), B)
+                    end
+                elseif istriu(A)
+                    return ($f)(UpperTriangular(A), B)
+                end
+                if ishermitian(A)
+                    return ($f)(Hermitian(A), B)
+                end
+                return ($f)(lufact(A), B)
             else
-                return LowerTriangular(A) \ B
+                return ($f)(qrfact(A), B)
             end
-        elseif istriu(A)
-            return UpperTriangular(A) \ B
-        end
-        if ishermitian(A)
-            Hermitian(A) \ B
         end
-        return lufact(A) \ B
-    else
-        return qrfact(A) \ B
+        ($f)(::SparseMatrixCSC, ::RowVector) = throw(DimensionMismatch("Cannot left-divide matrix by transposed vector"))
     end
 end
 
-(\)(::SparseMatrixCSC, ::RowVector) = throw(DimensionMismatch("Cannot left-divide matrix by transposed vector"))
-
 function factorize(A::SparseMatrixCSC)
     m, n = size(A)
     if m == n
@@ -887,12 +911,7 @@ function factorize(A::SparseMatrixCSC)
             return UpperTriangular(A)
         end
         if ishermitian(A)
-            try
-                return cholfact(Hermitian(A))
-            catch e
-                isa(e, PosDefException) || rethrow(e)
-                return ldltfact(Hermitian(A))
-            end
+            return factorize(Hermitian(A))
         end
         return lufact(A)
     else
@@ -900,20 +919,22 @@ function factorize(A::SparseMatrixCSC)
     end
 end
 
-function factorize{Ti}(A::Symmetric{Float64,SparseMatrixCSC{Float64,Ti}})
-    try
-        return cholfact(A)
-    catch e
-        isa(e, PosDefException) || rethrow(e)
-        return ldltfact(A)
-    end
-end
-function factorize{Ti}(A::Hermitian{Complex{Float64}, SparseMatrixCSC{Complex{Float64},Ti}})
-    try
-        return cholfact(A)
-    catch e
-        isa(e, PosDefException) || rethrow(e)
-        return ldltfact(A)
+# function factorize(A::Symmetric{Float64,SparseMatrixCSC{Float64,Ti}}) where Ti
+#     F = cholfact(A)
+#     if LinAlg.issuccess(F)
+#         return F
+#     else
+#         ldltfact!(F, A)
+#         return F
+#     end
+# end
+function factorize(A::LinAlg.RealHermSymComplexHerm{Float64,<:SparseMatrixCSC})
+    F = cholfact(A)
+    if LinAlg.issuccess(F)
+        return F
+    else
+        ldltfact!(F, A)
+        return F
     end
 end
 
diff --git a/base/sparse/sparse.jl b/base/sparse/sparse.jl
index 8f97fcecb57de3..28126d551c10ba 100644
--- a/base/sparse/sparse.jl
+++ b/base/sparse/sparse.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module SparseArrays
 
@@ -10,7 +10,7 @@ import Base: +, -, *, \, /, &, |, xor, ==
 import Base: A_mul_B!, Ac_mul_B, Ac_mul_B!, At_mul_B, At_mul_B!
 import Base: A_mul_Bc, A_mul_Bt, Ac_mul_Bc, At_mul_Bt
 import Base: At_ldiv_B, Ac_ldiv_B, A_ldiv_B!
-import Base.LinAlg: At_ldiv_B!, Ac_ldiv_B!
+import Base.LinAlg: At_ldiv_B!, Ac_ldiv_B!, A_rdiv_B!, A_rdiv_Bc!
 
 import Base: @get!, acos, acosd, acot, acotd, acsch, asech, asin, asind, asinh,
     atan, atand, atanh, broadcast!, chol, conj!, cos, cosc, cosd, cosh, cospi, cot,
@@ -26,10 +26,8 @@ import Base: @get!, acos, acosd, acot, acotd, acsch, asech, asin, asind, asinh,
     rotl90, rotr90, round, scale!, setindex!, similar, size, transpose, tril,
     triu, vec, permute!, map, map!
 
-import Base.Broadcast: broadcast_indices
-
 export AbstractSparseArray, AbstractSparseMatrix, AbstractSparseVector,
-    SparseMatrixCSC, SparseVector, blkdiag, dense, droptol!, dropzeros!, dropzeros,
+    SparseMatrixCSC, SparseVector, blkdiag, droptol!, dropzeros!, dropzeros,
     issparse, nonzeros, nzrange, rowvals, sparse, sparsevec, spdiagm, speye, spones,
     sprand, sprandn, spzeros, nnz, permute
 
diff --git a/base/sparse/sparsematrix.jl b/base/sparse/sparsematrix.jl
index d5600a5aebea7b..11a0a434edc7e0 100644
--- a/base/sparse/sparsematrix.jl
+++ b/base/sparse/sparsematrix.jl
@@ -1,21 +1,29 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Compressed sparse columns data structure
 # Assumes that no zeros are stored in the data structure
 # Assumes that row values in rowval for each column are sorted
 #      issorted(rowval[colptr[i]:(colptr[i+1]-1)]) == true
 
+"""
+    SparseMatrixCSC{Tv,Ti<:Integer} <: AbstractSparseMatrix{Tv,Ti}
+
+Matrix type for storing sparse matrices in the
+[Compressed Sparse Column](@ref man-csc) format.
+"""
 struct SparseMatrixCSC{Tv,Ti<:Integer} <: AbstractSparseMatrix{Tv,Ti}
     m::Int                  # Number of rows
     n::Int                  # Number of columns
     colptr::Vector{Ti}      # Column i is in colptr[i]:(colptr[i+1]-1)
-    rowval::Vector{Ti}      # Row values of nonzeros
-    nzval::Vector{Tv}       # Nonzero values
+    rowval::Vector{Ti}      # Row indices of stored values
+    nzval::Vector{Tv}       # Stored values, typically nonzeros
 
     function SparseMatrixCSC{Tv,Ti}(m::Integer, n::Integer, colptr::Vector{Ti}, rowval::Vector{Ti},
                                     nzval::Vector{Tv}) where {Tv,Ti<:Integer}
-        m < 0 && throw(ArgumentError("number of rows (m) must be ≥ 0, got $m"))
-        n < 0 && throw(ArgumentError("number of columns (n) must be ≥ 0, got $n"))
+        @noinline throwsz(str, lbl, k) =
+            throw(ArgumentError("number of $str ($lbl) must be ≥ 0, got $k"))
+        m < 0 && throwsz("rows", 'm', m)
+        n < 0 && throwsz("columns", 'n', n)
         new(Int(m), Int(n), colptr, rowval, nzval)
     end
 end
@@ -27,11 +35,30 @@ end
 
 size(S::SparseMatrixCSC) = (S.m, S.n)
 
+# Define an alias for views of a SparseMatrixCSC which include all rows and a unit range of the columns.
+# Also define a union of SparseMatrixCSC and this view since many methods can be defined efficiently for
+# this union by extracting the fields via the get function: getcolptr, getrowval, and getnzval. The key
+# insight is that getcolptr on a SparseMatrixCSCView returns an offset view of the colptr of the
+# underlying SparseMatrixCSC
+const SparseMatrixCSCView{Tv,Ti} =
+    SubArray{Tv,2,SparseMatrixCSC{Tv,Ti},
+        Tuple{Base.Slice{Base.OneTo{Int}},I}} where {I<:AbstractUnitRange}
+const SparseMatrixCSCUnion{Tv,Ti} = Union{SparseMatrixCSC{Tv,Ti}, SparseMatrixCSCView{Tv,Ti}}
+
+getcolptr(S::SparseMatrixCSC)     = S.colptr
+getcolptr(S::SparseMatrixCSCView) = view(S.parent.colptr, first(indices(S, 2)):(last(indices(S, 2)) + 1))
+getrowval(S::SparseMatrixCSC)     = S.rowval
+getrowval(S::SparseMatrixCSCView) = S.parent.rowval
+getnzval( S::SparseMatrixCSC)     = S.nzval
+getnzval( S::SparseMatrixCSCView) = S.parent.nzval
+
+
 """
     nnz(A)
 
 Returns the number of stored (filled) elements in a sparse array.
 
+# Examples
 ```jldoctest
 julia> A = speye(3)
 3×3 SparseMatrixCSC{Float64,Int64} with 3 stored entries:
@@ -56,6 +83,7 @@ vector points directly to the internal nonzero storage of `A`, and any
 modifications to the returned vector will mutate `A` as well. See
 [`rowvals`](@ref) and [`nzrange`](@ref).
 
+# Examples
 ```jldoctest
 julia> A = speye(3)
 3×3 SparseMatrixCSC{Float64,Int64} with 3 stored entries:
@@ -80,6 +108,7 @@ 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`](@ref) and [`nzrange`](@ref).
 
+# Examples
 ```jldoctest
 julia> A = speye(3)
 3×3 SparseMatrixCSC{Float64,Int64} with 3 stored entries:
@@ -132,38 +161,59 @@ function Base.show(io::IOContext, S::SparseMatrixCSC)
     if nnz(S) == 0
         return show(io, MIME("text/plain"), S)
     end
-
     limit::Bool = get(io, :limit, false)
-    if limit
-        rows = displaysize(io)[1]
-        half_screen_rows = div(rows - 8, 2)
+    rows = displaysize(io)[1] - 4 # -4 from [Prompt, header, newline after elements, new prompt]
+    will_fit = !limit || rows >= nnz(S) # Will the whole matrix fit when printed?
+
+    if rows <= 2 && !will_fit
+        print(io, "\n  \u22ee")
+        return
+    end
+
+    iob = IOBuffer()
+    ioc = IOContext(iob, :compact => true)
+
+    function _format_line(r, col)
+        pad = ndigits(max(S.m, S.n))
+        print(ioc, "  [", rpad(S.rowval[r], pad), ", ", lpad(col, pad), "]  =  ")
+        if isassigned(S.nzval, Int(r))
+            show(ioc, S.nzval[r])
+        else
+            print(ioc, Base.undef_ref_str)
+        end
+        return String(take!(iob))
+    end
+
+    if will_fit
+        print_count = nnz(S)
     else
-        half_screen_rows = typemax(Int)
-    end
-    pad = ndigits(max(S.m,S.n))
-    k = 0
-    sep = "\n  "
-    if !haskey(io, :compact)
-        io = IOContext(io, :compact => true)
-    end
-    for col = 1:S.n, k = S.colptr[col] : (S.colptr[col+1]-1)
-        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, Int(k))
-                show(io, S.nzval[k])
-            else
-                print(io, Base.undef_ref_str)
-            end
-        elseif k == half_screen_rows
-            print(io, sep, '\u22ee')
+        print_count = div(rows-1, 2)
+    end
+
+    count = 0
+    for col = 1:S.n, r = nzrange(S, col)
+        count += 1
+        print(io, "\n", _format_line(r, col))
+        count == print_count && break
+    end
+
+    if !will_fit
+        print(io, "\n  \u22ee")
+        # find the column to start printing in for the last print_count elements
+        nextcol = searchsortedfirst(S.colptr, nnz(S) - print_count + 1)
+        for r = (nnz(S) - print_count + 1) : (S.colptr[nextcol] - 1)
+            print(io, "\n", _format_line(r, nextcol - 1))
+        end
+        # print all of the remaining columns
+        for col = nextcol:S.n, r = nzrange(S, col)
+            print(io, "\n", _format_line(r, col))
         end
-        k += 1
     end
 end
 
 ## Reinterpret and Reshape
 
-function reinterpret{T,Tv}(::Type{T}, a::SparseMatrixCSC{Tv})
+function reinterpret(::Type{T}, a::SparseMatrixCSC{Tv}) where {T,Tv}
     if sizeof(T) != sizeof(Tv)
         throw(ArgumentError("SparseMatrixCSC reinterpret is only supported for element types of the same size"))
     end
@@ -174,7 +224,9 @@ function reinterpret{T,Tv}(::Type{T}, a::SparseMatrixCSC{Tv})
     return SparseMatrixCSC(mA, nA, colptr, rowval, nzval)
 end
 
-function sparse_compute_reshaped_colptr_and_rowval{Ti}(colptrS::Vector{Ti}, rowvalS::Vector{Ti}, mS::Int, nS::Int, colptrA::Vector{Ti}, rowvalA::Vector{Ti}, mA::Int, nA::Int)
+function sparse_compute_reshaped_colptr_and_rowval(colptrS::Vector{Ti}, rowvalS::Vector{Ti},
+                                                   mS::Int, nS::Int, colptrA::Vector{Ti},
+                                                   rowvalA::Vector{Ti}, mA::Int, nA::Int) where Ti
     lrowvalA = length(rowvalA)
     maxrowvalA = (lrowvalA > 0) ? maximum(rowvalA) : zero(Ti)
     ((length(colptrA) == (nA+1)) && (maximum(colptrA) <= (lrowvalA+1)) && (maxrowvalA <= mA)) || throw(BoundsError())
@@ -206,7 +258,7 @@ function sparse_compute_reshaped_colptr_and_rowval{Ti}(colptrS::Vector{Ti}, rowv
     end
 end
 
-function reinterpret{T,Tv,Ti,N}(::Type{T}, a::SparseMatrixCSC{Tv,Ti}, dims::NTuple{N,Int})
+function reinterpret(::Type{T}, a::SparseMatrixCSC{Tv,Ti}, dims::NTuple{N,Int}) where {T,Tv,Ti,N}
     if sizeof(T) != sizeof(Tv)
         throw(ArgumentError("SparseMatrixCSC reinterpret is only supported for element types of the same size"))
     end
@@ -216,7 +268,7 @@ function reinterpret{T,Tv,Ti,N}(::Type{T}, a::SparseMatrixCSC{Tv,Ti}, dims::NTup
     mS,nS = dims
     mA,nA = size(a)
     numnz = nnz(a)
-    colptr = Array{Ti}(nS+1)
+    colptr = Vector{Ti}(nS+1)
     rowval = similar(a.rowval)
     nzval = reinterpret(T, a.nzval)
 
@@ -292,22 +344,25 @@ function copy!(A::SparseMatrixCSC, B::SparseMatrixCSC)
     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)))
-function similar{Tv,Ti}(S::SparseMatrixCSC, ::Type{Tv}, ::Type{Ti})
+function similar(S::SparseMatrixCSC, ::Type{Tv} = eltype(S)) where Tv
+    SparseMatrixCSC(S.m, S.n, copy(S.colptr), copy(S.rowval), Vector{Tv}(length(S.nzval)))
+end
+
+function similar(S::SparseMatrixCSC, ::Type{Tv}, ::Type{Ti}) where {Tv,Ti}
     new_colptr = copy!(similar(S.colptr, Ti), S.colptr)
     new_rowval = copy!(similar(S.rowval, Ti), S.rowval)
     new_nzval =  copy!(similar(S.nzval,  Tv), S.nzval)
     SparseMatrixCSC(S.m, S.n, new_colptr, new_rowval, new_nzval)
 end
-@inline similar{Tv}(S::SparseMatrixCSC, ::Type{Tv}, d::Dims) = spzeros(Tv, d...)
+@inline similar(S::SparseMatrixCSC, ::Type{Tv}, d::Dims) where {Tv} = spzeros(Tv, d...)
 
 # convert'ing between SparseMatrixCSC types
-convert{Tv}(::Type{AbstractMatrix{Tv}}, A::SparseMatrixCSC{Tv}) = A
-convert{Tv}(::Type{AbstractMatrix{Tv}}, A::SparseMatrixCSC) = convert(SparseMatrixCSC{Tv}, A)
-convert{Tv}(::Type{SparseMatrixCSC{Tv}}, S::SparseMatrixCSC{Tv}) = S
-convert{Tv}(::Type{SparseMatrixCSC{Tv}}, S::SparseMatrixCSC) = convert(SparseMatrixCSC{Tv,eltype(S.colptr)}, S)
-convert{Tv,Ti}(::Type{SparseMatrixCSC{Tv,Ti}}, S::SparseMatrixCSC{Tv,Ti}) = S
-function convert{Tv,Ti}(::Type{SparseMatrixCSC{Tv,Ti}}, S::SparseMatrixCSC)
+convert(::Type{AbstractMatrix{Tv}}, A::SparseMatrixCSC{Tv}) where {Tv} = A
+convert(::Type{AbstractMatrix{Tv}}, A::SparseMatrixCSC) where {Tv} = convert(SparseMatrixCSC{Tv}, A)
+convert(::Type{SparseMatrixCSC{Tv}}, S::SparseMatrixCSC{Tv}) where {Tv} = S
+convert(::Type{SparseMatrixCSC{Tv}}, S::SparseMatrixCSC) where {Tv} = convert(SparseMatrixCSC{Tv,eltype(S.colptr)}, S)
+convert(::Type{SparseMatrixCSC{Tv,Ti}}, S::SparseMatrixCSC{Tv,Ti}) where {Tv,Ti} = S
+function convert(::Type{SparseMatrixCSC{Tv,Ti}}, S::SparseMatrixCSC) where {Tv,Ti}
     eltypeTicolptr = convert(Vector{Ti}, S.colptr)
     eltypeTirowval = convert(Vector{Ti}, S.rowval)
     eltypeTvnzval = convert(Vector{Tv}, S.nzval)
@@ -315,9 +370,9 @@ function convert{Tv,Ti}(::Type{SparseMatrixCSC{Tv,Ti}}, S::SparseMatrixCSC)
 end
 # convert'ing from other matrix types to SparseMatrixCSC (also see sparse())
 convert(::Type{SparseMatrixCSC}, M::Matrix) = sparse(M)
-convert{Tv}(::Type{SparseMatrixCSC}, M::AbstractMatrix{Tv}) = convert(SparseMatrixCSC{Tv,Int}, M)
-convert{Tv}(::Type{SparseMatrixCSC{Tv}}, M::AbstractMatrix{Tv}) = convert(SparseMatrixCSC{Tv,Int}, M)
-function convert{Tv,Ti}(::Type{SparseMatrixCSC{Tv,Ti}}, M::AbstractMatrix)
+convert(::Type{SparseMatrixCSC}, M::AbstractMatrix{Tv}) where {Tv} = convert(SparseMatrixCSC{Tv,Int}, M)
+convert(::Type{SparseMatrixCSC{Tv}}, M::AbstractMatrix{Tv}) where {Tv} = convert(SparseMatrixCSC{Tv,Int}, M)
+function convert(::Type{SparseMatrixCSC{Tv,Ti}}, M::AbstractMatrix) where {Tv,Ti}
     (I, J, V) = findnz(M)
     eltypeTiI = convert(Vector{Ti}, I)
     eltypeTiJ = convert(Vector{Ti}, J)
@@ -325,9 +380,9 @@ function convert{Tv,Ti}(::Type{SparseMatrixCSC{Tv,Ti}}, M::AbstractMatrix)
     return sparse_IJ_sorted!(eltypeTiI, eltypeTiJ, eltypeTvV, size(M)...)
 end
 # convert'ing from SparseMatrixCSC to other matrix types
-function convert{Tv}(::Type{Matrix}, S::SparseMatrixCSC{Tv})
+function convert(::Type{Matrix}, S::SparseMatrixCSC{Tv}) where Tv
     # Handle cases where zero(Tv) is not defined but the array is dense.
-    A = length(S) == nnz(S) ? Array{Tv}(S.m, S.n) : zeros(Tv, S.m, S.n)
+    A = length(S) == nnz(S) ? Matrix{Tv}(S.m, S.n) : zeros(Tv, S.m, S.n)
     for Sj in 1:S.n
         for Sk in nzrange(S, Sj)
             Si = S.rowval[Sk]
@@ -345,6 +400,7 @@ full(S::SparseMatrixCSC) = convert(Array, S)
 
 Convert a sparse matrix or vector `S` into a dense matrix or vector.
 
+# Examples
 ```jldoctest
 julia> A = speye(3)
 3×3 SparseMatrixCSC{Float64,Int64} with 3 stored entries:
@@ -375,6 +431,7 @@ vec(S::SparseMatrixCSC) = S[:]
 
 Convert an AbstractMatrix `A` into a sparse matrix.
 
+# Examples
 ```jldoctest
 julia> A = eye(3)
 3×3 Array{Float64,2}:
@@ -389,7 +446,7 @@ julia> sparse(A)
   [3, 3]  =  1.0
 ```
 """
-sparse{Tv}(A::AbstractMatrix{Tv}) = convert(SparseMatrixCSC{Tv,Int}, A)
+sparse(A::AbstractMatrix{Tv}) where {Tv} = convert(SparseMatrixCSC{Tv,Int}, A)
 
 sparse(S::SparseMatrixCSC) = copy(S)
 
@@ -397,10 +454,9 @@ sparse_IJ_sorted!(I,J,V,m,n) = sparse_IJ_sorted!(I,J,V,m,n,+)
 
 sparse_IJ_sorted!(I,J,V::AbstractVector{Bool},m,n) = sparse_IJ_sorted!(I,J,V,m,n,|)
 
-function sparse_IJ_sorted!{Ti<:Integer}(I::AbstractVector{Ti}, J::AbstractVector{Ti},
-                                        V::AbstractVector,
-                                        m::Integer, n::Integer, combine::Function)
-
+function sparse_IJ_sorted!(I::AbstractVector{Ti}, J::AbstractVector{Ti},
+                           V::AbstractVector,
+                           m::Integer, n::Integer, combine::Function) where Ti<:Integer
     m = m < 0 ? 0 : m
     n = n < 0 ? 0 : n
     if isempty(V); return spzeros(eltype(V),Ti,m,n); end
@@ -456,6 +512,7 @@ retained as structural nonzeros; to drop numerical zeros, use [`dropzeros!`](@re
 
 For additional documentation and an expert driver, see `Base.SparseArrays.sparse!`.
 
+# Examples
 ```jldoctest
 julia> Is = [1; 2; 3];
 
@@ -470,7 +527,7 @@ julia> sparse(Is, Js, Vs)
   [3, 3]  =  3
 ```
 """
-function sparse{Tv,Ti<:Integer}(I::AbstractVector{Ti}, J::AbstractVector{Ti}, V::AbstractVector{Tv}, m::Integer, n::Integer, combine)
+function sparse(I::AbstractVector{Ti}, J::AbstractVector{Ti}, V::AbstractVector{Tv}, m::Integer, n::Integer, combine) where {Tv,Ti<:Integer}
     coolen = length(I)
     if length(J) != coolen || length(V) != coolen
         throw(ArgumentError(string("the first three arguments' lengths must match, ",
@@ -504,7 +561,7 @@ function sparse{Tv,Ti<:Integer}(I::AbstractVector{Ti}, J::AbstractVector{Ti}, V:
 
         sparse!(I, J, V, m, n, combine, klasttouch,
                 csrrowptr, csrcolval, csrnzval,
-                csccolptr, cscrowval, cscnzval )
+                csccolptr, cscrowval, cscnzval)
     end
 end
 
@@ -512,18 +569,17 @@ sparse(I::AbstractVector, J::AbstractVector, V::AbstractVector, m::Integer, n::I
     sparse(AbstractVector{Int}(I), AbstractVector{Int}(J), V, m, n, combine)
 
 """
-    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}] )
+    sparse!(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}] ) where {Tv,Ti<:Integer}
 
 Parent of and expert driver for [`sparse`](@ref);
 see [`sparse`](@ref) 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.
+of [`SparseMatrixCSC`](@ref)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
@@ -560,10 +616,10 @@ F. Gustavson, "Two fast algorithms for sparse matrices: multiplication and permu
 transposition," ACM TOMS 4(3), 250-269 (1978) inspired this method's use of a pair of
 counting sorts.
 """
-function sparse!{Tv,Ti<:Integer}(I::AbstractVector{Ti}, J::AbstractVector{Ti},
+function sparse!(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} )
+        csccolptr::Vector{Ti}, cscrowval::Vector{Ti}, cscnzval::Vector{Tv}) where {Tv,Ti<:Integer}
 
     # Compute the CSR form's row counts and store them shifted forward by one in csrrowptr
     fill!(csrrowptr, 0)
@@ -662,20 +718,20 @@ function sparse!{Tv,Ti<:Integer}(I::AbstractVector{Ti}, J::AbstractVector{Ti},
 
     SparseMatrixCSC(m, n, csccolptr, cscrowval, cscnzval)
 end
-function sparse!{Tv,Ti<:Integer}(I::AbstractVector{Ti}, J::AbstractVector{Ti},
+function sparse!(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} )
+        csccolptr::Vector{Ti}) where {Tv,Ti<:Integer}
     sparse!(I, J, V, m, n, combine, klasttouch,
             csrrowptr, csrcolval, csrnzval,
-            csccolptr, Vector{Ti}(), Vector{Tv}() )
+            csccolptr, Vector{Ti}(), Vector{Tv}())
 end
-function sparse!{Tv,Ti<:Integer}(I::AbstractVector{Ti}, J::AbstractVector{Ti},
+function sparse!(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} )
+        csrrowptr::Vector{Ti}, csrcolval::Vector{Ti}, csrnzval::Vector{Tv}) where {Tv,Ti<:Integer}
     sparse!(I, J, V, m, n, combine, klasttouch,
             csrrowptr, csrcolval, csrnzval,
-            Vector{Ti}(n+1), Vector{Ti}(), Vector{Tv}() )
+            Vector{Ti}(n+1), Vector{Ti}(), Vector{Tv}())
 end
 
 dimlub(I) = isempty(I) ? 0 : Int(maximum(I)) #least upper bound on required sparse matrix dimension
@@ -704,15 +760,15 @@ end
 
 function sparse(B::Bidiagonal)
     m = length(B.dv)
-    B.isupper || return sparse([1:m;2:m],[1:m;1:m-1],[B.dv;B.ev], Int(m), Int(m)) # lower bidiagonal
+    B.uplo == 'U' || return sparse([1:m;2:m],[1:m;1:m-1],[B.dv;B.ev], Int(m), Int(m)) # lower bidiagonal
     return sparse([1:m;1:m-1],[1:m;2:m],[B.dv;B.ev], Int(m), Int(m)) # upper bidiagonal
 end
 
 ## Transposition and permutation methods
 
 """
-    halfperm!{Tv,Ti}(X::SparseMatrixCSC{Tv,Ti}, A::SparseMatrixCSC{Tv,Ti},
-        q::AbstractVector{<:Integer}, f::Function = identity)
+    halfperm!(X::SparseMatrixCSC{Tv,Ti}, A::SparseMatrixCSC{Tv,Ti},
+              q::AbstractVector{<:Integer}, f::Function = identity) where {Tv,Ti}
 
 Column-permute and transpose `A`, simultaneously applying `f` to each entry of `A`, storing
 the result `(f(A)Q)^T` (`map(f, transpose(A[:,q]))`) in `X`.
@@ -723,16 +779,16 @@ and  `length(X.nzval) >= nnz(A)`). Column-permutation `q`'s length must match `A
 count (`length(q) == A.n`).
 
 This method is the parent of several methods performing transposition and permutation
-operations on `SparseMatrixCSC`s. As this method performs no argument checking, prefer
-the safer child methods (`[c]transpose[!]`, `permute[!]`) to direct use.
+operations on [`SparseMatrixCSC`](@ref)s. As this method performs no argument checking,
+prefer the safer child methods (`[c]transpose[!]`, `permute[!]`) to direct use.
 
 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.
 """
-function halfperm!{Tv,Ti}(X::SparseMatrixCSC{Tv,Ti}, A::SparseMatrixCSC{Tv,Ti},
-        q::AbstractVector{<:Integer}, f::Function = identity)
+function halfperm!(X::SparseMatrixCSC{Tv,Ti}, A::SparseMatrixCSC{Tv,Ti},
+        q::AbstractVector{<:Integer}, f::Function = identity) where {Tv,Ti}
     _computecolptrs_halfperm!(X, A)
     _distributevals_halfperm!(X, A, q, f)
     return X
@@ -741,7 +797,7 @@ end
 Helper method for `halfperm!`. Computes `transpose(A[:,q])`'s column pointers, storing them
 shifted one position forward in `X.colptr`; `_distributevals_halfperm!` fixes this shift.
 """
-function _computecolptrs_halfperm!{Tv,Ti}(X::SparseMatrixCSC{Tv,Ti}, A::SparseMatrixCSC{Tv,Ti})
+function _computecolptrs_halfperm!(X::SparseMatrixCSC{Tv,Ti}, A::SparseMatrixCSC{Tv,Ti}) where {Tv,Ti}
     # Compute `transpose(A[:,q])`'s column counts. Store shifted forward one position in X.colptr.
     fill!(X.colptr, 0)
     @inbounds for k in 1:nnz(A)
@@ -762,8 +818,8 @@ position forward in `X.colptr`, computes `map(f, transpose(A[:,q]))` by appropri
 distributing `A.rowval` and `f`-transformed `A.nzval` into `X.rowval` and `X.nzval`
 respectively. Simultaneously fixes the one-position-forward shift in `X.colptr`.
 """
-function _distributevals_halfperm!{Tv,Ti}(X::SparseMatrixCSC{Tv,Ti},
-        A::SparseMatrixCSC{Tv,Ti}, q::AbstractVector{<:Integer}, f::Function)
+@noinline function _distributevals_halfperm!(X::SparseMatrixCSC{Tv,Ti},
+        A::SparseMatrixCSC{Tv,Ti}, q::AbstractVector{<:Integer}, f::Function) where {Tv,Ti}
     @inbounds for Xi in 1:A.n
         Aj = q[Xi]
         for Ak in nzrange(A, Aj)
@@ -777,7 +833,7 @@ function _distributevals_halfperm!{Tv,Ti}(X::SparseMatrixCSC{Tv,Ti},
     return # kill potential type instability
 end
 
-function ftranspose!{Tv,Ti}(X::SparseMatrixCSC{Tv,Ti}, A::SparseMatrixCSC{Tv,Ti}, f::Function)
+function ftranspose!(X::SparseMatrixCSC{Tv,Ti}, A::SparseMatrixCSC{Tv,Ti}, f::Function) where {Tv,Ti}
     # Check compatibility of source argument A and destination argument X
     if X.n != A.m
         throw(DimensionMismatch(string("destination argument `X`'s column count, ",
@@ -796,10 +852,10 @@ function ftranspose!{Tv,Ti}(X::SparseMatrixCSC{Tv,Ti}, A::SparseMatrixCSC{Tv,Ti}
     end
     halfperm!(X, A, 1:A.n, f)
 end
-transpose!{Tv,Ti}(X::SparseMatrixCSC{Tv,Ti}, A::SparseMatrixCSC{Tv,Ti}) = ftranspose!(X, A, identity)
-ctranspose!{Tv,Ti}(X::SparseMatrixCSC{Tv,Ti}, A::SparseMatrixCSC{Tv,Ti}) = ftranspose!(X, A, conj)
+transpose!(X::SparseMatrixCSC{Tv,Ti}, A::SparseMatrixCSC{Tv,Ti}) where {Tv,Ti} = ftranspose!(X, A, identity)
+ctranspose!(X::SparseMatrixCSC{Tv,Ti}, A::SparseMatrixCSC{Tv,Ti}) where {Tv,Ti} = ftranspose!(X, A, conj)
 
-function ftranspose{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, f::Function)
+function ftranspose(A::SparseMatrixCSC{Tv,Ti}, f::Function) where {Tv,Ti}
     X = SparseMatrixCSC(A.n, A.m, Vector{Ti}(A.m+1), Vector{Ti}(nnz(A)), Vector{Tv}(nnz(A)))
     halfperm!(X, A, 1:A.n, f)
 end
@@ -807,9 +863,9 @@ transpose(A::SparseMatrixCSC) = ftranspose(A, identity)
 ctranspose(A::SparseMatrixCSC) = ftranspose(A, conj)
 
 """
-    unchecked_noalias_permute!{Tv,Ti}(X::SparseMatrixCSC{Tv,Ti},
+    unchecked_noalias_permute!(X::SparseMatrixCSC{Tv,Ti},
         A::SparseMatrixCSC{Tv,Ti}, p::AbstractVector{<:Integer},
-        q::AbstractVector{<:Integer}, C::SparseMatrixCSC{Tv,Ti})
+        q::AbstractVector{<:Integer}, C::SparseMatrixCSC{Tv,Ti}) where {Tv,Ti}
 
 See [`permute!`](@ref) for basic usage. Parent of `permute[!]`
 methods operating on `SparseMatrixCSC`s that assume none of `X`, `A`, and `C` alias each
@@ -828,29 +884,29 @@ information.
 
 See also: `unchecked_aliasing_permute!`
 """
-function unchecked_noalias_permute!{Tv,Ti}(X::SparseMatrixCSC{Tv,Ti},
+function unchecked_noalias_permute!(X::SparseMatrixCSC{Tv,Ti},
         A::SparseMatrixCSC{Tv,Ti}, p::AbstractVector{<:Integer},
-        q::AbstractVector{<:Integer}, C::SparseMatrixCSC{Tv,Ti})
+        q::AbstractVector{<:Integer}, C::SparseMatrixCSC{Tv,Ti}) where {Tv,Ti}
     halfperm!(C, A, q)
     _computecolptrs_permute!(X, A, q, X.colptr)
     _distributevals_halfperm!(X, C, p, identity)
     return X
 end
 """
-    unchecked_aliasing_permute!{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti},
+    unchecked_aliasing_permute!(A::SparseMatrixCSC{Tv,Ti},
         p::AbstractVector{<:Integer}, q::AbstractVector{<:Integer},
-        C::SparseMatrixCSC{Tv,Ti}, workcolptr::Vector{Ti})
+        C::SparseMatrixCSC{Tv,Ti}, workcolptr::Vector{Ti}) where {Tv,Ti}
 
 See [`permute!`](@ref) for basic usage. Parent of `permute!`
-methods operating on `SparseMatrixCSC`s where the source and destination matrices are the
-same. See `unchecked_noalias_permute!`
+methods operating on [`SparseMatrixCSC`](@ref)s where the source and destination matrices
+are the same. See `unchecked_noalias_permute!`
 for additional information; these methods are identical but for this method's requirement of
 the additional `workcolptr`, `length(workcolptr) >= A.n + 1`, which enables efficient
 handling of the source-destination aliasing.
 """
-function unchecked_aliasing_permute!{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti},
+function unchecked_aliasing_permute!(A::SparseMatrixCSC{Tv,Ti},
         p::AbstractVector{<:Integer}, q::AbstractVector{<:Integer},
-        C::SparseMatrixCSC{Tv,Ti}, workcolptr::Vector{Ti})
+        C::SparseMatrixCSC{Tv,Ti}, workcolptr::Vector{Ti}) where {Tv,Ti}
     halfperm!(C, A, q)
     _computecolptrs_permute!(A, A, q, workcolptr)
     _distributevals_halfperm!(A, C, p, identity)
@@ -862,8 +918,8 @@ Computes `PAQ`'s column pointers, storing them shifted one position forward in `
 `_distributevals_halfperm!` fixes this shift. Saves some work relative to
 `_computecolptrs_halfperm!` as described in `uncheckednoalias_permute!`'s documentation.
 """
-function _computecolptrs_permute!{Tv,Ti}(X::SparseMatrixCSC{Tv,Ti},
-        A::SparseMatrixCSC{Tv,Ti}, q::AbstractVector{<:Integer}, workcolptr::Vector{Ti})
+function _computecolptrs_permute!(X::SparseMatrixCSC{Tv,Ti},
+        A::SparseMatrixCSC{Tv,Ti}, q::AbstractVector{<:Integer}, workcolptr::Vector{Ti}) where {Tv,Ti}
     # Compute `A[p,q]`'s column counts. Store shifted forward one position in workcolptr.
     @inbounds for k in 1:A.n
         workcolptr[k+1] = A.colptr[q[k] + 1] - A.colptr[q[k]]
@@ -899,9 +955,9 @@ end
 Helper method for `permute` and `permute!` methods operating on `SparseMatrixCSC`s.
 Checks whether row- and column- permutation arguments `p` and `q` are valid permutations.
 """
-function _checkargs_permutationsvalid_permute!{Ti<:Integer}(
+function _checkargs_permutationsvalid_permute!(
         p::AbstractVector{<:Integer}, pcheckspace::Vector{Ti},
-        q::AbstractVector{<:Integer}, qcheckspace::Vector{Ti})
+        q::AbstractVector{<:Integer}, qcheckspace::Vector{Ti}) where Ti<:Integer
     if !_ispermutationvalid_permute!(p, pcheckspace)
         throw(ArgumentError("row-permutation argument `p` must be a valid permutation"))
     elseif !_ispermutationvalid_permute!(q, qcheckspace)
@@ -921,8 +977,8 @@ end
 Helper method for `permute` and `permute!` methods operating on `SparseMatrixCSC`s.
 Checks compatibility of source argument `A` and destination argument `X`.
 """
-function _checkargs_sourcecompatdest_permute!{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti},
-        X::SparseMatrixCSC{Tv,Ti})
+function _checkargs_sourcecompatdest_permute!(A::SparseMatrixCSC{Tv,Ti},
+        X::SparseMatrixCSC{Tv,Ti}) where {Tv,Ti}
     if X.m != A.m
         throw(DimensionMismatch(string("destination argument `X`'s row count, ",
             "`X.m (= $(X.m))`, must match source argument `A`'s row count, `A.m (= $(A.m))`")))
@@ -943,8 +999,8 @@ end
 Helper method for `permute` and `permute!` methods operating on `SparseMatrixCSC`s.
 Checks compatibility of source argument `A` and intermediate result argument `C`.
 """
-function _checkargs_sourcecompatworkmat_permute!{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti},
-        C::SparseMatrixCSC{Tv,Ti})
+function _checkargs_sourcecompatworkmat_permute!(A::SparseMatrixCSC{Tv,Ti},
+        C::SparseMatrixCSC{Tv,Ti}) where {Tv,Ti}
     if C.n != A.m
         throw(DimensionMismatch(string("intermediate result argument `C`'s column count, ",
             "`C.n (= $(C.n))`, must match source argument `A`'s row count, `A.m (= $(A.m))`")))
@@ -965,8 +1021,8 @@ end
 Helper method for `permute` and `permute!` methods operating on `SparseMatrixCSC`s.
 Checks compatibility of source argument `A` and workspace argument `workcolptr`.
 """
-function _checkargs_sourcecompatworkcolptr_permute!{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti},
-        workcolptr::Vector{Ti})
+function _checkargs_sourcecompatworkcolptr_permute!(A::SparseMatrixCSC{Tv,Ti},
+        workcolptr::Vector{Ti}) where {Tv,Ti}
     if length(workcolptr) <= A.n
         throw(DimensionMismatch(string("argument `workcolptr`'s length, ",
             "`length(workcolptr) (= $(length(workcolptr)))`, must exceed source argument ",
@@ -974,16 +1030,18 @@ function _checkargs_sourcecompatworkcolptr_permute!{Tv,Ti}(A::SparseMatrixCSC{Tv
     end
 end
 """
-    permute!{Tv,Ti}(X::SparseMatrixCSC{Tv,Ti}, A::SparseMatrixCSC{Tv,Ti},
-        p::AbstractVector{<:Integer}, q::AbstractVector{<:Integer}[, C::SparseMatrixCSC{Tv,Ti}])
+    permute!(X::SparseMatrixCSC{Tv,Ti}, A::SparseMatrixCSC{Tv,Ti},
+             p::AbstractVector{<:Integer}, q::AbstractVector{<:Integer},
+             [C::SparseMatrixCSC{Tv,Ti}]) where {Tv,Ti}
 
 Bilaterally permute `A`, storing result `PAQ` (`A[p,q]`) in `X`. Stores intermediate result
 `(AQ)^T` (`transpose(A[:,q])`) in optional argument `C` if present. Requires that none of
 `X`, `A`, and, if present, `C` alias each other; to store result `PAQ` back into `A`, use
 the following method lacking `X`:
 
-    permute!{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, p::AbstractVector{<:Integer},
-        q::AbstractVector{<:Integer}[, C::SparseMatrixCSC{Tv,Ti}[, workcolptr::Vector{Ti}]])
+    permute!(A::SparseMatrixCSC{Tv,Ti}, p::AbstractVector{<:Integer},
+             q::AbstractVector{<:Integer}[, C::SparseMatrixCSC{Tv,Ti},
+             [workcolptr::Vector{Ti}]]) where {Tv,Ti}
 
 `X`'s dimensions must match those of `A` (`X.m == A.m` and `X.n == A.n`), and `X` must
 have enough storage to accommodate all allocated entries in `A` (`length(X.rowval) >= nnz(A)`
@@ -992,51 +1050,51 @@ count (`length(q) == A.n`). Row-permutation `p`'s length must match `A`'s row co
 (`length(p) == A.m`).
 
 `C`'s dimensions must match those of `transpose(A)` (`C.m == A.n` and `C.n == A.m`), and `C`
-must have enough storage to accommodate all allocated entries in `A` (`length(C.rowval)` >= nnz(A)`
+must have enough storage to accommodate all allocated entries in `A` (`length(C.rowval) >= nnz(A)`
 and `length(C.nzval) >= nnz(A)`).
 
 For additional (algorithmic) information, and for versions of these methods that forgo
 argument checking, see (unexported) parent methods `unchecked_noalias_permute!`
 and `unchecked_aliasing_permute!`.
 
-See also: [`permute`](@ref)
+See also: [`permute`](@ref).
 """
-function permute!{Tv,Ti}(X::SparseMatrixCSC{Tv,Ti}, A::SparseMatrixCSC{Tv,Ti},
-        p::AbstractVector{<:Integer}, q::AbstractVector{<:Integer})
+function permute!(X::SparseMatrixCSC{Tv,Ti}, A::SparseMatrixCSC{Tv,Ti},
+        p::AbstractVector{<:Integer}, q::AbstractVector{<:Integer}) where {Tv,Ti}
     _checkargs_sourcecompatdest_permute!(A, X)
     _checkargs_sourcecompatperms_permute!(A, p, q)
     C = SparseMatrixCSC(A.n, A.m, Vector{Ti}(A.m + 1), Vector{Ti}(nnz(A)), Vector{Tv}(nnz(A)))
     _checkargs_permutationsvalid_permute!(p, C.colptr, q, X.colptr)
     unchecked_noalias_permute!(X, A, p, q, C)
 end
-function permute!{Tv,Ti}(X::SparseMatrixCSC{Tv,Ti}, A::SparseMatrixCSC{Tv,Ti},
+function permute!(X::SparseMatrixCSC{Tv,Ti}, A::SparseMatrixCSC{Tv,Ti},
         p::AbstractVector{<:Integer}, q::AbstractVector{<:Integer},
-        C::SparseMatrixCSC{Tv,Ti})
+        C::SparseMatrixCSC{Tv,Ti}) where {Tv,Ti}
     _checkargs_sourcecompatdest_permute!(A, X)
     _checkargs_sourcecompatperms_permute!(A, p, q)
     _checkargs_sourcecompatworkmat_permute!(A, C)
     _checkargs_permutationsvalid_permute!(p, C.colptr, q, X.colptr)
     unchecked_noalias_permute!(X, A, p, q, C)
 end
-function permute!{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, p::AbstractVector{<:Integer},
-        q::AbstractVector{<:Integer})
+function permute!(A::SparseMatrixCSC{Tv,Ti}, p::AbstractVector{<:Integer},
+        q::AbstractVector{<:Integer}) where {Tv,Ti}
     _checkargs_sourcecompatperms_permute!(A, p, q)
     C = SparseMatrixCSC(A.n, A.m, Vector{Ti}(A.m + 1), Vector{Ti}(nnz(A)), Vector{Tv}(nnz(A)))
     workcolptr = Vector{Ti}(A.n + 1)
     _checkargs_permutationsvalid_permute!(p, C.colptr, q, workcolptr)
     unchecked_aliasing_permute!(A, p, q, C, workcolptr)
 end
-function permute!{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, p::AbstractVector{<:Integer},
-        q::AbstractVector{<:Integer}, C::SparseMatrixCSC{Tv,Ti})
+function permute!(A::SparseMatrixCSC{Tv,Ti}, p::AbstractVector{<:Integer},
+        q::AbstractVector{<:Integer}, C::SparseMatrixCSC{Tv,Ti}) where {Tv,Ti}
     _checkargs_sourcecompatperms_permute!(A, p, q)
     _checkargs_sourcecompatworkmat_permute!(A, C)
     workcolptr = Vector{Ti}(A.n + 1)
     _checkargs_permutationsvalid_permute!(p, C.colptr, q, workcolptr)
     unchecked_aliasing_permute!(A, p, q, C, workcolptr)
 end
-function permute!{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, p::AbstractVector{<:Integer},
+function permute!(A::SparseMatrixCSC{Tv,Ti}, p::AbstractVector{<:Integer},
         q::AbstractVector{<:Integer}, C::SparseMatrixCSC{Tv,Ti},
-        workcolptr::Vector{Ti})
+        workcolptr::Vector{Ti}) where {Tv,Ti}
     _checkargs_sourcecompatperms_permute!(A, p, q)
     _checkargs_sourcecompatworkmat_permute!(A, C)
     _checkargs_sourcecompatworkcolptr_permute!(A, workcolptr)
@@ -1044,17 +1102,50 @@ function permute!{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, p::AbstractVector{<:Integer}
     unchecked_aliasing_permute!(A, p, q, C, workcolptr)
 end
 """
-    permute{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, p::AbstractVector{<:Integer},
-        q::AbstractVector{<:Integer})
+    permute(A::SparseMatrixCSC{Tv,Ti}, p::AbstractVector{<:Integer},
+            q::AbstractVector{<:Integer}) where {Tv,Ti}
 
 Bilaterally permute `A`, returning `PAQ` (`A[p,q]`). Column-permutation `q`'s length must
 match `A`'s column count (`length(q) == A.n`). Row-permutation `p`'s length must match `A`'s
 row count (`length(p) == A.m`).
 
 For expert drivers and additional information, see [`permute!`](@ref).
+
+# Examples
+```jldoctest
+julia> A = spdiagm([1, 2, 3, 4], 0, 4, 4) + spdiagm([5, 6, 7], 1, 4, 4)
+4×4 SparseMatrixCSC{Int64,Int64} with 7 stored entries:
+  [1, 1]  =  1
+  [1, 2]  =  5
+  [2, 2]  =  2
+  [2, 3]  =  6
+  [3, 3]  =  3
+  [3, 4]  =  7
+  [4, 4]  =  4
+
+julia> permute(A, [4, 3, 2, 1], [1, 2, 3, 4])
+4×4 SparseMatrixCSC{Int64,Int64} with 7 stored entries:
+  [4, 1]  =  1
+  [3, 2]  =  2
+  [4, 2]  =  5
+  [2, 3]  =  3
+  [3, 3]  =  6
+  [1, 4]  =  4
+  [2, 4]  =  7
+
+julia> permute(A, [1, 2, 3, 4], [4, 3, 2, 1])
+4×4 SparseMatrixCSC{Int64,Int64} with 7 stored entries:
+  [3, 1]  =  7
+  [4, 1]  =  4
+  [2, 2]  =  6
+  [3, 2]  =  3
+  [1, 3]  =  5
+  [2, 3]  =  2
+  [1, 4]  =  1
+```
 """
-function permute{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, p::AbstractVector{<:Integer},
-        q::AbstractVector{<:Integer})
+function permute(A::SparseMatrixCSC{Tv,Ti}, p::AbstractVector{<:Integer},
+        q::AbstractVector{<:Integer}) where {Tv,Ti}
     _checkargs_sourcecompatperms_permute!(A, p, q)
     X = SparseMatrixCSC(A.m, A.n, Vector{Ti}(A.n + 1), Vector{Ti}(nnz(A)), Vector{Tv}(nnz(A)))
     C = SparseMatrixCSC(A.n, A.m, Vector{Ti}(A.m + 1), Vector{Ti}(nnz(A)), Vector{Tv}(nnz(A)))
@@ -1076,6 +1167,21 @@ value. This method makes a single sweep
 through `A`, requiring `O(A.n, nnz(A))`-time for matrices and `O(nnz(A))`-time for vectors
 and no space beyond that passed in. If `trim` is `true`, this method trims `A.rowval` or `A.nzind` and
 `A.nzval` to length `nnz(A)` after dropping elements.
+
+# Examples
+```jldoctest
+julia> A = spdiagm([1, 2, 3, 4])
+4×4 SparseMatrixCSC{Int64,Int64} with 4 stored entries:
+  [1, 1]  =  1
+  [2, 2]  =  2
+  [3, 3]  =  3
+  [4, 4]  =  4
+
+julia> Base.SparseArrays.fkeep!(A, (i, j, v) -> isodd(v))
+4×4 SparseMatrixCSC{Int64,Int64} with 2 stored entries:
+  [1, 1]  =  1
+  [3, 3]  =  3
+```
 """
 function fkeep!(A::SparseMatrixCSC, f, trim::Bool = true)
     An = A.n
@@ -1151,6 +1257,20 @@ Generates a copy of `A` and removes stored numerical zeros from that copy, optio
 trimming excess space from the result's `rowval` and `nzval` arrays when `trim` is `true`.
 
 For an in-place version and algorithmic information, see [`dropzeros!`](@ref).
+
+# Examples
+```jldoctest
+julia> A = sparse([1, 2, 3], [1, 2, 3], [1.0, 0.0, 1.0])
+3×3 SparseMatrixCSC{Float64,Int64} with 3 stored entries:
+  [1, 1]  =  1.0
+  [2, 2]  =  0.0
+  [3, 3]  =  1.0
+
+julia> dropzeros(A)
+3×3 SparseMatrixCSC{Float64,Int64} with 2 stored entries:
+  [1, 1]  =  1.0
+  [3, 3]  =  1.0
+```
 """
 dropzeros(A::SparseMatrixCSC, trim::Bool = true) = dropzeros!(copy(A), trim)
 
@@ -1163,10 +1283,10 @@ function find(S::SparseMatrixCSC)
     return sub2ind(sz, I, J)
 end
 
-function findn{Tv,Ti}(S::SparseMatrixCSC{Tv,Ti})
+function findn(S::SparseMatrixCSC{Tv,Ti}) where {Tv,Ti}
     numnz = nnz(S)
-    I = Array{Ti}(numnz)
-    J = Array{Ti}(numnz)
+    I = Vector{Ti}(numnz)
+    J = Vector{Ti}(numnz)
 
     count = 1
     @inbounds for col = 1 : S.n, k = S.colptr[col] : (S.colptr[col+1]-1)
@@ -1186,11 +1306,11 @@ function findn{Tv,Ti}(S::SparseMatrixCSC{Tv,Ti})
     return (I, J)
 end
 
-function findnz{Tv,Ti}(S::SparseMatrixCSC{Tv,Ti})
+function findnz(S::SparseMatrixCSC{Tv,Ti}) where {Tv,Ti}
     numnz = nnz(S)
-    I = Array{Ti}(numnz)
-    J = Array{Ti}(numnz)
-    V = Array{Tv}(numnz)
+    I = Vector{Ti}(numnz)
+    J = Vector{Ti}(numnz)
+    V = Vector{Tv}(numnz)
 
     count = 1
     @inbounds for col = 1 : S.n, k = S.colptr[col] : (S.colptr[col+1]-1)
@@ -1219,7 +1339,7 @@ function sprand_IJ(r::AbstractRNG, m::Integer, n::Integer, density::AbstractFloa
     0 <= density <= 1 || throw(ArgumentError("$density not in [0,1]"))
     N = n*m
 
-    I, J = Array{Int}(0), Array{Int}(0) # indices of nonzero elements
+    I, J = Vector{Int}(0), Vector{Int}(0) # indices of nonzero elements
     sizehint!(I, round(Int,N*density))
     sizehint!(J, round(Int,N*density))
 
@@ -1229,7 +1349,7 @@ function sprand_IJ(r::AbstractRNG, m::Integer, n::Integer, density::AbstractFloa
     colsparsity = exp(m*L) # = 1 - coldensity
     iL = 1/L
 
-    rows = Array{Int}(0)
+    rows = Vector{Int}(0)
     for j in randsubseq(r, 1:n, coldensity)
         # To get the right statistics, we *must* have a nonempty column j
         # even if p*m << 1.   To do this, we use an approach similar to
@@ -1261,6 +1381,7 @@ values are sampled from the distribution specified by `rfn` and have the type `t
 distribution is used in case `rfn` is not specified. The optional `rng`
 argument specifies a random number generator, see [Random Numbers](@ref).
 
+# Examples
 ```jldoctest
 julia> rng = MersenneTwister(1234);
 
@@ -1272,10 +1393,10 @@ julia> sprand(rng, Bool, 2, 2, 0.5)
 julia> sprand(rng, Float64, 3, 0.75)
 3-element SparseVector{Float64,Int64} with 1 stored entry:
   [3]  =  0.298614
-````
+```
 """
-function sprand{T}(r::AbstractRNG, m::Integer, n::Integer, density::AbstractFloat,
-                rfn::Function, ::Type{T}=eltype(rfn(r,1)))
+function sprand(r::AbstractRNG, m::Integer, n::Integer, density::AbstractFloat,
+                rfn::Function, ::Type{T}=eltype(rfn(r,1))) where T
     N = m*n
     N == 0 && return spzeros(T,m,n)
     N == 1 && return rand(r) <= density ? sparse([1], [1], rfn(r,1)) : spzeros(T,1,1)
@@ -1284,8 +1405,8 @@ function sprand{T}(r::AbstractRNG, m::Integer, n::Integer, density::AbstractFloa
     sparse_IJ_sorted!(I, J, rfn(r,length(I)), m, n, +)  # it will never need to combine
 end
 
-function sprand{T}(m::Integer, n::Integer, density::AbstractFloat,
-                rfn::Function, ::Type{T}=eltype(rfn(1)))
+function sprand(m::Integer, n::Integer, density::AbstractFloat,
+                rfn::Function, ::Type{T}=eltype(rfn(1))) where T
     N = m*n
     N == 0 && return spzeros(T,m,n)
     N == 1 && return rand() <= density ? sparse([1], [1], rfn(1)) : spzeros(T,1,1)
@@ -1299,9 +1420,9 @@ truebools(r::AbstractRNG, n::Integer) = ones(Bool, n)
 sprand(m::Integer, n::Integer, density::AbstractFloat) = sprand(GLOBAL_RNG,m,n,density)
 
 sprand(r::AbstractRNG, m::Integer, n::Integer, density::AbstractFloat) = sprand(r,m,n,density,rand,Float64)
-sprand{T}(r::AbstractRNG, ::Type{T}, m::Integer, n::Integer, density::AbstractFloat) = sprand(r,m,n,density,(r, i) -> rand(r, T, i), T)
+sprand(r::AbstractRNG, ::Type{T}, m::Integer, n::Integer, density::AbstractFloat) where {T} = sprand(r,m,n,density,(r, i) -> rand(r, T, i), T)
 sprand(r::AbstractRNG, ::Type{Bool}, m::Integer, n::Integer, density::AbstractFloat) = sprand(r,m,n,density, truebools, Bool)
-sprand{T}(::Type{T}, m::Integer, n::Integer, density::AbstractFloat) = sprand(GLOBAL_RNG, T, m, n, density)
+sprand(::Type{T}, m::Integer, n::Integer, density::AbstractFloat) where {T} = sprand(GLOBAL_RNG, T, m, n, density)
 
 
 """
@@ -1312,6 +1433,7 @@ with the specified (independent) probability `p` of any entry being nonzero,
 where nonzero values are sampled from the normal distribution. The optional `rng`
 argument specifies a random number generator, see [Random Numbers](@ref).
 
+# Examples
 ```jldoctest
 julia> rng = MersenneTwister(1234);
 
@@ -1332,6 +1454,7 @@ sprandn(m::Integer, n::Integer, density::AbstractFloat) = sprandn(GLOBAL_RNG,m,n
 Create a sparse array with the same structure as that of `S`, but with every nonzero
 element having the value `1.0`.
 
+# Examples
 ```jldoctest
 julia> A = sparse([1,2,3,4],[2,4,3,1],[5.,4.,3.,2.])
 4×4 SparseMatrixCSC{Float64,Int64} with 4 stored entries:
@@ -1350,7 +1473,7 @@ julia> spones(A)
 
 Note the difference from [`speye`](@ref).
 """
-spones{T}(S::SparseMatrixCSC{T}) =
+spones(S::SparseMatrixCSC{T}) where {T} =
      SparseMatrixCSC(S.m, S.n, copy(S.colptr), copy(S.rowval), ones(T, S.colptr[end]-1))
 
 """
@@ -1358,9 +1481,10 @@ spones{T}(S::SparseMatrixCSC{T}) =
 
 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
+for nonzero values during construction. The type defaults to [`Float64`](@ref) if not
 specified.
 
+# Examples
 ```jldoctest
 julia> spzeros(3, 3)
 3×3 SparseMatrixCSC{Float64,Int64} with 0 stored entries
@@ -1370,16 +1494,18 @@ julia> spzeros(Float32, 4)
 ```
 """
 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)
+spzeros(::Type{Tv}, m::Integer, n::Integer) where {Tv} = spzeros(Tv, Int, m, n)
+function spzeros(::Type{Tv}, ::Type{Ti}, m::Integer, n::Integer) where {Tv, Ti}
     ((m < 0) || (n < 0)) && throw(ArgumentError("invalid Array dimensions"))
-    SparseMatrixCSC(m, n, ones(Ti, n+1), Array{Ti}(0), Array{Tv}(0))
+    SparseMatrixCSC(m, n, ones(Ti, n+1), Vector{Ti}(0), Vector{Tv}(0))
 end
 # de-splatting variant
-spzeros(Tv::Type, Ti::Type, sz::Tuple{Integer,Integer}) = spzeros(Tv, Ti, sz[1], sz[2])
+function spzeros(::Type{Tv}, ::Type{Ti}, sz::Tuple{Integer,Integer}) where {Tv, Ti}
+    spzeros(Tv, Ti, sz[1], sz[2])
+end
 
 speye(n::Integer) = speye(Float64, n)
-speye(T::Type, n::Integer) = speye(T, n, n)
+speye(::Type{T}, n::Integer) where {T} = speye(T, n, n)
 speye(m::Integer, n::Integer) = speye(Float64, m, n)
 
 """
@@ -1387,6 +1513,7 @@ speye(m::Integer, n::Integer) = speye(Float64, m, n)
 
 Create a sparse identity matrix with the same size as `S`.
 
+# Examples
 ```jldoctest
 julia> A = sparse([1,2,3,4],[2,4,3,1],[5.,4.,3.,2.])
 4×4 SparseMatrixCSC{Float64,Int64} with 4 stored entries:
@@ -1405,23 +1532,23 @@ julia> speye(A)
 
 Note the difference from [`spones`](@ref).
 """
-speye{T}(S::SparseMatrixCSC{T}) = speye(T, size(S, 1), size(S, 2))
+speye(S::SparseMatrixCSC{T}) where {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`
+create a sparse identity matrix of size `m x n`. The type defaults to [`Float64`](@ref)
 if not specified.
 
 `sparse(I, m, n)` is equivalent to `speye(Int, m, n)`, and
 `sparse(α*I, m, n)` can be used to efficiently create a sparse
 multiple `α` of the identity matrix.
 """
-speye(T::Type, m::Integer, n::Integer) = speye_scaled(T, oneunit(T), m, n)
+speye(::Type{T}, m::Integer, n::Integer) where {T} = speye_scaled(T, oneunit(T), m, n)
 
-function one{T}(S::SparseMatrixCSC{T})
+function one(S::SparseMatrixCSC{T}) where T
     m,n = size(S)
     if m != n; throw(DimensionMismatch("multiplicative identity only defined for square matrices")); end
     speye(T, m)
@@ -1429,10 +1556,13 @@ end
 
 speye_scaled(diag, m::Integer, n::Integer) = speye_scaled(typeof(diag), diag, m, n)
 
-function speye_scaled(T, diag, m::Integer, n::Integer)
+function speye_scaled(::Type{T}, diag, m::Integer, n::Integer) where T
     ((m < 0) || (n < 0)) && throw(ArgumentError("invalid array dimensions"))
+    if iszero(diag)
+        return SparseMatrixCSC(m, n, ones(Int, n+1), Vector{Int}(0), Vector{T}(0))
+    end
     nnz = min(m,n)
-    colptr = Array{Int,1}(1+n)
+    colptr = Vector{Int}(1+n)
     colptr[1:nnz+1] = 1:nnz+1
     colptr[nnz+2:end] = nnz+1
     SparseMatrixCSC(Int(m), Int(n), colptr, Vector{Int}(1:nnz), fill!(Vector{T}(nnz), diag))
@@ -1445,19 +1575,23 @@ sparse(S::UniformScaling, m::Integer, n::Integer=m) = speye_scaled(S.λ, m, n)
 conj!(A::SparseMatrixCSC) = (@inbounds broadcast!(conj, A.nzval, A.nzval); A)
 (-)(A::SparseMatrixCSC) = SparseMatrixCSC(A.m, A.n, copy(A.colptr), copy(A.rowval), map(-, A.nzval))
 
+# the rest of real, conj, imag are handled correctly via AbstractArray methods
+conj(A::SparseMatrixCSC{<:Complex}) =
+    SparseMatrixCSC(A.m, A.n, copy(A.colptr), copy(A.rowval), conj(A.nzval))
+imag(A::SparseMatrixCSC{Tv,Ti}) where {Tv<:Real,Ti} = spzeros(Tv, Ti, A.m, A.n)
 
 ## Binary arithmetic and boolean operators
 (+)(A::SparseMatrixCSC, B::SparseMatrixCSC) = map(+, A, B)
 (-)(A::SparseMatrixCSC, B::SparseMatrixCSC) = map(-, A, B)
 
-( +)(A::SparseMatrixCSC, B::Array ) = Array(A)  + B
-( +)(A::Array , B::SparseMatrixCSC) = A  + Array(B)
-( -)(A::SparseMatrixCSC, B::Array ) = Array(A)  - B
-( -)(A::Array , B::SparseMatrixCSC) = A  - Array(B)
+(+)(A::SparseMatrixCSC, B::Array) = Array(A) + B
+(+)(A::Array, B::SparseMatrixCSC) = A + Array(B)
+(-)(A::SparseMatrixCSC, B::Array) = Array(A) - B
+(-)(A::Array, B::SparseMatrixCSC) = A - Array(B)
 
 ## full equality
 function ==(A1::SparseMatrixCSC, A2::SparseMatrixCSC)
-    size(A1)!=size(A2) && return false
+    size(A1) != size(A2) && return false
     vals1, vals2 = nonzeros(A1), nonzeros(A2)
     rows1, rows2 = rowvals(A1), rowvals(A2)
     m, n = size(A1)
@@ -1465,7 +1599,7 @@ function ==(A1::SparseMatrixCSC, A2::SparseMatrixCSC)
         nz1,nz2 = nzrange(A1,i), nzrange(A2,i)
         j1,j2 = first(nz1), first(nz2)
         # step through the rows of both matrices at once:
-        while j1<=last(nz1) && j2<=last(nz2)
+        while j1 <= last(nz1) && j2 <= last(nz2)
             r1,r2 = rows1[j1], rows2[j2]
             if r1==r2
                 vals1[j1]!=vals2[j2] && return false
@@ -1497,13 +1631,13 @@ end
 # In general, output of sparse matrix reductions will not be sparse,
 # and computing reductions along columns into SparseMatrixCSC is
 # non-trivial, so use Arrays for output
-Base.reducedim_initarray{R}(A::SparseMatrixCSC, region, v0, ::Type{R}) =
+Base.reducedim_initarray(A::SparseMatrixCSC, region, v0, ::Type{R}) where {R} =
     fill!(similar(dims->Array{R}(dims), Base.reduced_indices(A,region)), v0)
-Base.reducedim_initarray0{R}(A::SparseMatrixCSC, region, v0, ::Type{R}) =
+Base.reducedim_initarray0(A::SparseMatrixCSC, region, v0, ::Type{R}) where {R} =
     fill!(similar(dims->Array{R}(dims), Base.reduced_indices0(A,region)), v0)
 
 # General mapreduce
-function _mapreducezeros(f, op, T::Type, nzeros::Int, v0)
+function _mapreducezeros(f, op, ::Type{T}, nzeros::Int, v0) where T
     nzeros == 0 && return v0
 
     # Reduce over first zero
@@ -1522,7 +1656,7 @@ function _mapreducezeros(f, op, T::Type, nzeros::Int, v0)
     v
 end
 
-function Base._mapreduce{T}(f, op, ::Base.IndexCartesian, A::SparseMatrixCSC{T})
+function Base._mapreduce(f, op, ::Base.IndexCartesian, A::SparseMatrixCSC{T}) where T
     z = nnz(A)
     n = length(A)
     if z == 0
@@ -1537,12 +1671,12 @@ function Base._mapreduce{T}(f, op, ::Base.IndexCartesian, A::SparseMatrixCSC{T})
 end
 
 # Specialized mapreduce for +/*
-_mapreducezeros(f, ::typeof(+), T::Type, nzeros::Int, v0) =
+_mapreducezeros(f, ::typeof(+), ::Type{T}, nzeros::Int, v0) where {T} =
     nzeros == 0 ? v0 : f(zero(T))*nzeros + v0
-_mapreducezeros(f, ::typeof(*), T::Type, nzeros::Int, v0) =
+_mapreducezeros(f, ::typeof(*), ::Type{T}, nzeros::Int, v0) where {T} =
     nzeros == 0 ? v0 : f(zero(T))^nzeros * v0
 
-function Base._mapreduce{T}(f, op::typeof(*), A::SparseMatrixCSC{T})
+function Base._mapreduce(f, op::typeof(*), A::SparseMatrixCSC{T}) where T
     nzeros = length(A)-nnz(A)
     if nzeros == 0
         # No zeros, so don't compute f(0) since it might throw
@@ -1555,7 +1689,7 @@ function Base._mapreduce{T}(f, op::typeof(*), A::SparseMatrixCSC{T})
 end
 
 # General mapreducedim
-function _mapreducerows!{T}(f, op, R::AbstractArray, A::SparseMatrixCSC{T})
+function _mapreducerows!(f, op, R::AbstractArray, A::SparseMatrixCSC{T}) where T
     colptr = A.colptr
     rowval = A.rowval
     nzval = A.nzval
@@ -1570,7 +1704,7 @@ function _mapreducerows!{T}(f, op, R::AbstractArray, A::SparseMatrixCSC{T})
     R
 end
 
-function _mapreducecols!{Tv,Ti}(f, op, R::AbstractArray, A::SparseMatrixCSC{Tv,Ti})
+function _mapreducecols!(f, op, R::AbstractArray, A::SparseMatrixCSC{Tv,Ti}) where {Tv,Ti}
     colptr = A.colptr
     rowval = A.rowval
     nzval = A.nzval
@@ -1589,7 +1723,7 @@ function _mapreducecols!{Tv,Ti}(f, op, R::AbstractArray, A::SparseMatrixCSC{Tv,T
     R
 end
 
-function Base._mapreducedim!{T}(f, op, R::AbstractArray, A::SparseMatrixCSC{T})
+function Base._mapreducedim!(f, op, R::AbstractArray, A::SparseMatrixCSC{T}) where T
     lsiz = Base.check_reducedims(R,A)
     isempty(A) && return R
 
@@ -1639,7 +1773,7 @@ end
 
 # Specialized mapreducedim for + cols to avoid allocating a
 # temporary array when f(0) == 0
-function _mapreducecols!{Tv,Ti}(f, op::typeof(+), R::AbstractArray, A::SparseMatrixCSC{Tv,Ti})
+function _mapreducecols!(f, op::typeof(+), R::AbstractArray, A::SparseMatrixCSC{Tv,Ti}) where {Tv,Ti}
     nzval = A.nzval
     m, n = size(A)
     if length(nzval) == m*n
@@ -1679,7 +1813,7 @@ function _mapreducecols!{Tv,Ti}(f, op::typeof(+), R::AbstractArray, A::SparseMat
 end
 
 # findmax/min and indmax/min methods
-function _findz{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, rows=1:A.m, cols=1:A.n)
+function _findz(A::SparseMatrixCSC{Tv,Ti}, rows=1:A.m, cols=1:A.n) where {Tv,Ti}
     colptr = A.colptr; rowval = A.rowval; nzval = A.nzval
     zval = zero(Tv)
     col = cols[1]; row = 0
@@ -1716,7 +1850,7 @@ macro _findr(op, A, region, Tv, Ti)
 
     if $region == 1 || $region == (1,)
         (N == 0) && (return (fill(zval,1,n), fill(convert($Ti,1),1,n)))
-        S = Array{$Tv}(n); I = Array{$Ti}(n)
+        S = Vector{$Tv}(n); I = Vector{$Ti}(n)
         @inbounds for i = 1 : n
             Sc = zval; Ic = _findz($A, 1:m, i:i)
             if Ic == 0
@@ -1735,7 +1869,7 @@ macro _findr(op, A, region, Tv, Ti)
         return(reshape(S,1,n), reshape(I,1,n))
     elseif $region == 2 || $region == (2,)
         (N == 0) && (return (fill(zval,m,1), fill(convert($Ti,1),m,1)))
-        S = Array{$Tv}(m); I = Array{$Ti}(m)
+        S = Vector{$Tv}(m); I = Vector{$Ti}(m)
         @inbounds for row in 1:m
             S[row] = zval; I[row] = _findz($A, row:row, 1:n)
             if I[row] == 0
@@ -1769,8 +1903,8 @@ macro _findr(op, A, region, Tv, Ti)
     end) #quote
 end
 
-findmin{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, region) = @_findr(<, A, region, Tv, Ti)
-findmax{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, region) = @_findr(>, A, region, Tv, Ti)
+findmin(A::SparseMatrixCSC{Tv,Ti}, region) where {Tv,Ti} = @_findr(<, A, region, Tv, Ti)
+findmax(A::SparseMatrixCSC{Tv,Ti}, region) where {Tv,Ti} = @_findr(>, A, region, Tv, Ti)
 findmin(A::SparseMatrixCSC) = (r=findmin(A,(1,2)); (r[1][1], r[2][1]))
 findmax(A::SparseMatrixCSC) = (r=findmax(A,(1,2)); (r[1][1], r[2][1]))
 
@@ -1790,7 +1924,7 @@ end
 
 getindex(A::SparseMatrixCSC, I::Tuple{Integer,Integer}) = getindex(A, I[1], I[2])
 
-function getindex{T}(A::SparseMatrixCSC{T}, i0::Integer, i1::Integer)
+function getindex(A::SparseMatrixCSC{T}, i0::Integer, i1::Integer) where T
     if !(1 <= i0 <= A.m && 1 <= i1 <= A.n); throw(BoundsError()); end
     r1 = Int(A.colptr[i1])
     r2 = Int(A.colptr[i1+1]-1)
@@ -1804,14 +1938,14 @@ 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)
+function getindex_cols(A::SparseMatrixCSC{Tv,Ti}, J::AbstractVector) where {Tv,Ti}
     # for indexing whole columns
     (m, n) = size(A)
     nJ = length(J)
 
     colptrA = A.colptr; rowvalA = A.rowval; nzvalA = A.nzval
 
-    colptrS = Array{Ti}(nJ+1)
+    colptrS = Vector{Ti}(nJ+1)
     colptrS[1] = 1
     nnzS = 0
 
@@ -1822,8 +1956,8 @@ function getindex_cols{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, J::AbstractVector)
         colptrS[j+1] = nnzS + 1
     end
 
-    rowvalS = Array{Ti}(nnzS)
-    nzvalS  = Array{Tv}(nnzS)
+    rowvalS = Vector{Ti}(nnzS)
+    nzvalS  = Vector{Tv}(nnzS)
     ptrS = 0
 
     @inbounds for j = 1:nJ
@@ -1837,7 +1971,10 @@ function getindex_cols{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, J::AbstractVector)
     return SparseMatrixCSC(m, nJ, colptrS, rowvalS, nzvalS)
 end
 
-function getindex{Tv,Ti<:Integer}(A::SparseMatrixCSC{Tv,Ti}, I::Range, J::AbstractVector)
+getindex_traverse_col(::AbstractUnitRange, lo::Int, hi::Int) = lo:hi
+getindex_traverse_col(I::StepRange, lo::Int, hi::Int) = step(I) > 0 ? (lo:1:hi) : (hi:-1:lo)
+
+function getindex(A::SparseMatrixCSC{Tv,Ti}, I::Range, J::AbstractVector) where {Tv,Ti<:Integer}
     # Ranges for indexing rows
     (m, n) = size(A)
     # whole columns:
@@ -1849,7 +1986,7 @@ function getindex{Tv,Ti<:Integer}(A::SparseMatrixCSC{Tv,Ti}, I::Range, J::Abstra
     nI == 0 || (minimum(I) >= 1 && maximum(I) <= m) || throw(BoundsError())
     nJ = length(J)
     colptrA = A.colptr; rowvalA = A.rowval; nzvalA = A.nzval
-    colptrS = Array{Ti}(nJ+1)
+    colptrS = Vector{Ti}(nJ+1)
     colptrS[1] = 1
     nnzS = 0
 
@@ -1864,13 +2001,13 @@ function getindex{Tv,Ti<:Integer}(A::SparseMatrixCSC{Tv,Ti}, I::Range, J::Abstra
     end
 
     # Populate the values in the result
-    rowvalS = Array{Ti}(nnzS)
-    nzvalS  = Array{Tv}(nnzS)
+    rowvalS = Vector{Ti}(nnzS)
+    nzvalS  = Vector{Tv}(nnzS)
     ptrS    = 1
 
     @inbounds for j = 1:nJ
         col = J[j]
-        for k = colptrA[col]:colptrA[col+1]-1
+        for k = getindex_traverse_col(I, colptrA[col], colptrA[col+1]-1)
             rowA = rowvalA[k]
             i = rangesearch(I, rowA)
             if i > 0
@@ -1884,7 +2021,7 @@ function getindex{Tv,Ti<:Integer}(A::SparseMatrixCSC{Tv,Ti}, I::Range, J::Abstra
     return SparseMatrixCSC(nI, nJ, colptrS, rowvalS, nzvalS)
 end
 
-function getindex_I_sorted{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, I::AbstractVector, J::AbstractVector)
+function getindex_I_sorted(A::SparseMatrixCSC{Tv,Ti}, I::AbstractVector, J::AbstractVector) where {Tv,Ti}
     # Sorted vectors for indexing rows.
     # Similar to getindex_general but without the transpose trick.
     (m, n) = size(A)
@@ -1904,12 +2041,12 @@ function getindex_I_sorted{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, I::AbstractVector,
     getindex_I_sorted_linear(A, I, J)
 end
 
-function getindex_I_sorted_bsearch_A{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, I::AbstractVector, J::AbstractVector)
+function getindex_I_sorted_bsearch_A(A::SparseMatrixCSC{Tv,Ti}, I::AbstractVector, J::AbstractVector) where {Tv,Ti}
     const nI = length(I)
     const nJ = length(J)
 
     colptrA = A.colptr; rowvalA = A.rowval; nzvalA = A.nzval
-    colptrS = Array{Ti}(nJ+1)
+    colptrS = Vector{Ti}(nJ+1)
     colptrS[1] = 1
 
     ptrS = 1
@@ -1934,8 +2071,8 @@ function getindex_I_sorted_bsearch_A{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, I::Abstra
         colptrS[j+1] = ptrS
     end
 
-    rowvalS = Array{Ti}(ptrS-1)
-    nzvalS  = Array{Tv}(ptrS-1)
+    rowvalS = Vector{Ti}(ptrS-1)
+    nzvalS  = Vector{Tv}(ptrS-1)
 
     # fill the values
     ptrS = 1
@@ -1963,12 +2100,12 @@ function getindex_I_sorted_bsearch_A{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, I::Abstra
     return SparseMatrixCSC(nI, nJ, colptrS, rowvalS, nzvalS)
 end
 
-function getindex_I_sorted_linear{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, I::AbstractVector, J::AbstractVector)
+function getindex_I_sorted_linear(A::SparseMatrixCSC{Tv,Ti}, I::AbstractVector, J::AbstractVector) where {Tv,Ti}
     const nI = length(I)
     const nJ = length(J)
 
     colptrA = A.colptr; rowvalA = A.rowval; nzvalA = A.nzval
-    colptrS = Array{Ti}(nJ+1)
+    colptrS = Vector{Ti}(nJ+1)
     colptrS[1] = 1
     cacheI = zeros(Int, A.m)
 
@@ -1996,8 +2133,8 @@ function getindex_I_sorted_linear{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, I::AbstractV
         colptrS[j+1] = ptrS
     end
 
-    rowvalS = Array{Ti}(ptrS-1)
-    nzvalS  = Array{Tv}(ptrS-1)
+    rowvalS = Vector{Ti}(ptrS-1)
+    nzvalS  = Vector{Tv}(ptrS-1)
 
     # fill the values
     ptrS = 1
@@ -2022,12 +2159,12 @@ function getindex_I_sorted_linear{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, I::AbstractV
     return SparseMatrixCSC(nI, nJ, colptrS, rowvalS, nzvalS)
 end
 
-function getindex_I_sorted_bsearch_I{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, I::AbstractVector, J::AbstractVector)
+function getindex_I_sorted_bsearch_I(A::SparseMatrixCSC{Tv,Ti}, I::AbstractVector, J::AbstractVector) where {Tv,Ti}
     const nI = length(I)
     const nJ = length(J)
 
     colptrA = A.colptr; rowvalA = A.rowval; nzvalA = A.nzval
-    colptrS = Array{Ti}(nJ+1)
+    colptrS = Vector{Ti}(nJ+1)
     colptrS[1] = 1
 
     m = A.m
@@ -2061,8 +2198,8 @@ function getindex_I_sorted_bsearch_I{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, I::Abstra
             break
         end
     end
-    rowvalS = Array{Ti}(ptrS)
-    nzvalS  = Array{Tv}(ptrS)
+    rowvalS = Vector{Ti}(ptrS)
+    nzvalS  = Vector{Tv}(ptrS)
     colptrS[nJ+1] = ptrS+1
 
     # fill the values
@@ -2091,14 +2228,14 @@ function getindex_I_sorted_bsearch_I{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, I::Abstra
     return SparseMatrixCSC(nI, nJ, colptrS, rowvalS, nzvalS)
 end
 
-function permute_rows!{Tv,Ti}(S::SparseMatrixCSC{Tv,Ti}, pI::Vector{Int})
+function permute_rows!(S::SparseMatrixCSC{Tv,Ti}, pI::Vector{Int}) where {Tv,Ti}
     (m, n) = size(S)
     colptrS = S.colptr; rowvalS = S.rowval; nzvalS = S.nzval
     # preallocate temporary sort space
     nr = min(nnz(S), m)
-    rowperm = Array{Int}(nr)
-    rowvalTemp = Array{Ti}(nr)
-    nzvalTemp = Array{Tv}(nr)
+    rowperm = Vector{Int}(nr)
+    rowvalTemp = Vector{Ti}(nr)
+    nzvalTemp = Vector{Tv}(nr)
 
     @inbounds for j in 1:n
         rowrange = colptrS[j]:(colptrS[j+1]-1)
@@ -2111,7 +2248,7 @@ function permute_rows!{Tv,Ti}(S::SparseMatrixCSC{Tv,Ti}, pI::Vector{Int})
             nzvalTemp[k] = nzvalS[i]
             k += 1
         end
-        sortperm!(unsafe_wrap(Array, pointer(rowperm), nr), unsafe_wrap(Array, pointer(rowvalTemp), nr))
+        sortperm!(unsafe_wrap(Vector{Int}, pointer(rowperm), nr), unsafe_wrap(Vector{Ti}, pointer(rowvalTemp), nr))
         k = 1
         for i in rowrange
             kperm = rowperm[k]
@@ -2130,7 +2267,7 @@ function getindex_general(A::SparseMatrixCSC, I::AbstractVector, J::AbstractVect
 end
 
 # the general case:
-function getindex{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, I::AbstractVector, J::AbstractVector)
+function getindex(A::SparseMatrixCSC{Tv,Ti}, I::AbstractVector, J::AbstractVector) where {Tv,Ti}
     (m, n) = size(A)
 
     if !isempty(J)
@@ -2154,7 +2291,7 @@ function getindex{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, I::AbstractVector, J::Abstra
     end
 end
 
-function getindex{Tv}(A::SparseMatrixCSC{Tv}, I::AbstractArray)
+function getindex(A::SparseMatrixCSC{Tv}, I::AbstractArray) where Tv
     szA = size(A)
     nA = szA[1]*szA[2]
     colptrA = A.colptr
@@ -2166,8 +2303,8 @@ function getindex{Tv}(A::SparseMatrixCSC{Tv}, I::AbstractArray)
     outn = size(I,2)
     szB = (outm, outn)
     colptrB = zeros(Int, outn+1)
-    rowvalB = Array{Int}(n)
-    nzvalB = Array{Tv}(n)
+    rowvalB = Vector{Int}(n)
+    nzvalB = Vector{Tv}(n)
 
     colB = 1
     rowB = 1
@@ -2208,10 +2345,10 @@ getindex(A::SparseMatrixCSC, I::AbstractVector{<:Integer}, J::AbstractVector{Boo
 getindex(A::SparseMatrixCSC, I::AbstractVector{Bool}, J::AbstractVector{<:Integer}) = A[find(I),J]
 
 ## setindex!
-function setindex!{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, v, i::Integer, j::Integer)
+function setindex!(A::SparseMatrixCSC{Tv,Ti}, v, i::Integer, j::Integer) where Tv where Ti
     setindex!(A, convert(Tv, v), convert(Ti, i), convert(Ti, j))
 end
-function setindex!{Tv,Ti<:Integer}(A::SparseMatrixCSC{Tv,Ti}, v::Tv, i::Ti, j::Ti)
+function setindex!(A::SparseMatrixCSC{Tv,Ti}, v::Tv, i::Ti, j::Ti) where Tv where Ti<:Integer
     if !((1 <= i <= A.m) & (1 <= j <= A.n))
         throw(BoundsError(A, (i,j)))
     end
@@ -2247,8 +2384,8 @@ setindex!(A::SparseMatrixCSC, x, ::Colon, ::Colon) = setindex!(A, x, 1:size(A, 1
 setindex!(A::SparseMatrixCSC, x, ::Colon, j::Union{Integer, AbstractVector}) = setindex!(A, x, 1:size(A, 1), j)
 setindex!(A::SparseMatrixCSC, x, i::Union{Integer, AbstractVector}, ::Colon) = setindex!(A, x, i, 1:size(A, 2))
 
-function setindex!{Tv}(A::SparseMatrixCSC{Tv}, x::Number,
-        I::AbstractVector{<:Integer}, J::AbstractVector{<:Integer})
+function setindex!(A::SparseMatrixCSC{Tv}, x::Number,
+        I::AbstractVector{<:Integer}, J::AbstractVector{<:Integer}) where Tv
     if isempty(I) || isempty(J); return A; end
     # lt=≤ to check for strict sorting
     if !issorted(I, lt=≤); I = sort!(unique(I)); end
@@ -2302,8 +2439,8 @@ Helper method for immediately preceding setindex! method. For all (i,j) such tha
 and j in J, assigns x to A[i,j] if A[i,j] is a presently-stored entry, and allocates and
 assigns x to A[i,j] if A[i,j] is not presently stored.
 """
-function _spsetnz_setindex!{Tv}(A::SparseMatrixCSC{Tv}, x::Tv,
-        I::AbstractVector{<:Integer}, J::AbstractVector{<:Integer})
+function _spsetnz_setindex!(A::SparseMatrixCSC{Tv}, x::Tv,
+        I::AbstractVector{<:Integer}, J::AbstractVector{<:Integer}) where Tv
     m, n = size(A)
     lenI = length(I)
 
@@ -2408,17 +2545,17 @@ function _spsetnz_setindex!{Tv}(A::SparseMatrixCSC{Tv}, x::Tv,
     return A
 end
 
-setindex!{Tv,Ti,T<:Integer}(A::SparseMatrixCSC{Tv,Ti}, S::Matrix, I::AbstractVector{T}, J::AbstractVector{T}) =
+setindex!(A::SparseMatrixCSC{Tv,Ti}, S::Matrix, I::AbstractVector{T}, J::AbstractVector{T}) where {Tv,Ti,T<:Integer} =
       setindex!(A, convert(SparseMatrixCSC{Tv,Ti}, S), I, J)
 
 setindex!(A::SparseMatrixCSC, v::AbstractVector, I::AbstractVector{<:Integer}, j::Integer) = setindex!(A, v, I, [j])
 setindex!(A::SparseMatrixCSC, v::AbstractVector, i::Integer, J::AbstractVector{<:Integer}) = setindex!(A, v, [i], J)
-setindex!{T<:Integer}(A::SparseMatrixCSC, v::AbstractVector, I::AbstractVector{T}, J::AbstractVector{T}) =
+setindex!(A::SparseMatrixCSC, v::AbstractVector, I::AbstractVector{T}, J::AbstractVector{T}) where {T<:Integer} =
       setindex!(A, reshape(v, length(I), length(J)), I, J)
 
 
 # A[I,J] = B
-function setindex!{Tv,Ti,T<:Integer}(A::SparseMatrixCSC{Tv,Ti}, B::SparseMatrixCSC{Tv,Ti}, I::AbstractVector{T}, J::AbstractVector{T})
+function setindex!(A::SparseMatrixCSC{Tv,Ti}, B::SparseMatrixCSC{Tv,Ti}, I::AbstractVector{T}, J::AbstractVector{T}) where {Tv,Ti,T<:Integer}
     if size(B,1) != length(I) || size(B,2) != length(J)
         throw(DimensionMismatch(""))
     end
@@ -2809,6 +2946,22 @@ stored and otherwise do nothing. Derivative forms:
 
     dropstored!(A::SparseMatrixCSC, i::Integer, J::AbstractVector{<:Integer})
     dropstored!(A::SparseMatrixCSC, I::AbstractVector{<:Integer}, j::Integer)
+
+# Examples
+```jldoctest
+julia> A = spdiagm([1, 2, 3, 4])
+4×4 SparseMatrixCSC{Int64,Int64} with 4 stored entries:
+  [1, 1]  =  1
+  [2, 2]  =  2
+  [3, 3]  =  3
+  [4, 4]  =  4
+
+julia> Base.SparseArrays.dropstored!(A, [1, 2], [1, 1])
+4×4 SparseMatrixCSC{Int64,Int64} with 3 stored entries:
+  [2, 2]  =  2
+  [3, 3]  =  3
+  [4, 4]  =  4
+```
 """
 function dropstored!(A::SparseMatrixCSC,
         I::AbstractVector{<:Integer}, J::AbstractVector{<:Integer})
@@ -2901,9 +3054,9 @@ function vcat(X::SparseMatrixCSC...)
 
     nnzX = Int[ nnz(x) for x in X ]
     nnz_res = sum(nnzX)
-    colptr = Array{Ti}(n + 1)
-    rowval = Array{Ti}(nnz_res)
-    nzval  = Array{Tv}(nnz_res)
+    colptr = Vector{Ti}(n+1)
+    rowval = Vector{Ti}(nnz_res)
+    nzval  = Vector{Tv}(nnz_res)
 
     colptr[1] = 1
     for c = 1:n
@@ -2952,11 +3105,11 @@ function hcat(X::SparseMatrixCSC...)
     Tv = promote_eltype(X...)
     Ti = promote_eltype(map(x->x.rowval, X)...)
 
-    colptr = Array{Ti}(n + 1)
+    colptr = Vector{Ti}(n+1)
     nnzX = Int[ nnz(x) for x in X ]
     nnz_res = sum(nnzX)
-    rowval = Array{Ti}(nnz_res)
-    nzval = Array{Tv}(nnz_res)
+    rowval = Vector{Ti}(nnz_res)
+    nzval = Vector{Tv}(nnz_res)
 
     nnz_sofar = 0
     nX_sofar = 0
@@ -2982,7 +3135,7 @@ end
 
 Concatenate matrices block-diagonally. Currently only implemented for sparse matrices.
 
-# Example
+# Examples
 ```jldoctest
 julia> blkdiag(speye(3), 2*speye(2))
 5×5 SparseMatrixCSC{Float64,Int64} with 5 stored entries:
@@ -3003,11 +3156,11 @@ function blkdiag(X::SparseMatrixCSC...)
     Tv = promote_type(map(x->eltype(x.nzval), X)...)
     Ti = promote_type(map(x->eltype(x.rowval), X)...)
 
-    colptr = Array{Ti}(n + 1)
+    colptr = Vector{Ti}(n+1)
     nnzX = Int[ nnz(x) for x in X ]
     nnz_res = sum(nnzX)
-    rowval = Array{Ti}(nnz_res)
-    nzval = Array{Tv}(nnz_res)
+    rowval = Vector{Ti}(nnz_res)
+    nzval = Vector{Tv}(nnz_res)
 
     nnz_sofar = 0
     nX_sofar = 0
@@ -3153,9 +3306,9 @@ function spdiagm_internal(B, d)
     for vec in B
         ncoeffs += length(vec)
     end
-    I = Array{Int}(ncoeffs)
-    J = Array{Int}(ncoeffs)
-    V = Array{promote_type(map(eltype, B)...)}(ncoeffs)
+    I = Vector{Int}(ncoeffs)
+    J = Vector{Int}(ncoeffs)
+    V = Vector{promote_type(map(eltype, B)...)}(ncoeffs)
     id = 0
     i = 0
     for vec in B
@@ -3191,6 +3344,7 @@ one diagonal, `B` can be a vector (instead of a tuple) and `d` can be the diagon
 (instead of a tuple), defaulting to 0 (diagonal). Optionally, `m` and `n` specify the size
 of the resulting sparse matrix.
 
+# Examples
 ```jldoctest
 julia> spdiagm(([1,2,3,4],[4,3,2,1]),(-1,1))
 5×5 SparseMatrixCSC{Int64,Int64} with 8 stored entries:
@@ -3238,7 +3392,7 @@ length(d::SpDiagIterator) = d.n
 start(d::SpDiagIterator) = 1
 done(d::SpDiagIterator, j) = j > d.n
 
-function next{Tv}(d::SpDiagIterator{Tv}, j)
+function next(d::SpDiagIterator{Tv}, j) where Tv
     A = d.A
     r1 = Int(A.colptr[j])
     r2 = Int(A.colptr[j+1]-1)
@@ -3247,7 +3401,7 @@ function next{Tv}(d::SpDiagIterator{Tv}, j)
     (((r1 > r2) || (A.rowval[r1] != j)) ? zero(Tv) : A.nzval[r1], j+1)
 end
 
-function trace{Tv}(A::SparseMatrixCSC{Tv})
+function trace(A::SparseMatrixCSC{Tv}) where Tv
     if size(A,1) != size(A,2)
         throw(DimensionMismatch("expected square matrix"))
     end
@@ -3258,18 +3412,18 @@ function trace{Tv}(A::SparseMatrixCSC{Tv})
     s
 end
 
-diag{Tv}(A::SparseMatrixCSC{Tv}) = Tv[d for d in SpDiagIterator(A)]
+diag(A::SparseMatrixCSC{Tv}) where {Tv} = Tv[d for d in SpDiagIterator(A)]
 
-function diagm{Tv,Ti}(v::SparseMatrixCSC{Tv,Ti})
-    if (size(v,1) != 1 && size(v,2) != 1)
+function diagm(v::SparseMatrixCSC{Tv,Ti}) where {Tv,Ti}
+    if size(v,1) != 1 && size(v,2) != 1
         throw(DimensionMismatch("input should be nx1 or 1xn"))
     end
 
     n = length(v)
     numnz = nnz(v)
-    colptr = Array{Ti}(n+1)
-    rowval = Array{Ti}(numnz)
-    nzval = Array{Tv}(numnz)
+    colptr = Vector{Ti}(n+1)
+    rowval = Vector{Ti}(numnz)
+    nzval = Vector{Tv}(numnz)
 
     if size(v,1) == 1
         copy!(colptr, 1, v.colptr, 1, n+1)
@@ -3307,10 +3461,10 @@ end
 # Sort all the indices in each column of a CSC sparse matrix
 # sortSparseMatrixCSC!(A, sortindices = :sortcols)        # Sort each column with sort()
 # sortSparseMatrixCSC!(A, sortindices = :doubletranspose) # Sort with a double transpose
-function sortSparseMatrixCSC!{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}; sortindices::Symbol = :sortcols)
+function sortSparseMatrixCSC!(A::SparseMatrixCSC{Tv,Ti}; sortindices::Symbol = :sortcols) where {Tv,Ti}
     if sortindices == :doubletranspose
         nB, mB = size(A)
-        B = SparseMatrixCSC(mB, nB, Array{Ti}(nB+1), similar(A.rowval), similar(A.nzval))
+        B = SparseMatrixCSC(mB, nB, Vector{Ti}(nB+1), similar(A.rowval), similar(A.nzval))
         transpose!(B, A)
         transpose!(A, B)
         return A
@@ -3347,8 +3501,8 @@ function sortSparseMatrixCSC!{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}; sortindices::Sym
             jj += 1
         end
 
-        sortperm!(unsafe_wrap(Array, pointer(index), numrows),
-                  unsafe_wrap(Array, pointer(row), numrows))
+        sortperm!(unsafe_wrap(Vector{Ti}, pointer(index), numrows),
+                  unsafe_wrap(Vector{Ti}, pointer(row), numrows))
 
         jj = 1
         @simd for j = col_start:col_end
@@ -3406,7 +3560,7 @@ end
     hash(val, h)
 end
 
-function hash{T}(A::SparseMatrixCSC{T}, h::UInt)
+function hash(A::SparseMatrixCSC{T}, h::UInt) where T
     h += Base.hashaa_seed
     sz = size(A)
     h += hash(sz)
@@ -3441,7 +3595,7 @@ end
 ## Statistics
 
 # This is the function that does the reduction underlying var/std
-function Base.centralize_sumabs2!{S,Tv,Ti}(R::AbstractArray{S}, A::SparseMatrixCSC{Tv,Ti}, means::AbstractArray)
+function Base.centralize_sumabs2!(R::AbstractArray{S}, A::SparseMatrixCSC{Tv,Ti}, means::AbstractArray) where {S,Tv,Ti}
     lsiz = Base.check_reducedims(R,A)
     size(means) == size(R) || error("size of means must match size of R")
     isempty(R) || fill!(R, zero(S))
diff --git a/base/sparse/sparsevector.jl b/base/sparse/sparsevector.jl
index a4f7bac6b244a1..a3de2b2a45d588 100644
--- a/base/sparse/sparsevector.jl
+++ b/base/sparse/sparsevector.jl
@@ -1,18 +1,23 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ### Common definitions
 
-import Base: scalarmax, scalarmin, sort, find, findnz, @_pure_meta
+import Base: scalarmax, scalarmin, sort, find, findnz
 import Base.LinAlg: promote_to_array_type, promote_to_arrays_
 
 ### The SparseVector
 
 ### Types
 
+"""
+    SparseVector{Tv,Ti<:Integer} <: AbstractSparseVector{Tv,Ti}
+
+Vector type for storing sparse vectors.
+"""
 struct 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
+    n::Int              # Length of the sparse vector
+    nzind::Vector{Ti}   # Indices of stored values
+    nzval::Vector{Tv}   # Stored values, typically nonzeros
 
     function SparseVector{Tv,Ti}(n::Integer, nzind::Vector{Ti}, nzval::Vector{Tv}) where {Tv,Ti<:Integer}
         n >= 0 || throw(ArgumentError("The number of elements must be non-negative."))
@@ -25,6 +30,11 @@ end
 SparseVector(n::Integer, nzind::Vector{Ti}, nzval::Vector{Tv}) where {Tv,Ti} =
     SparseVector{Tv,Ti}(n, nzind, nzval)
 
+# Define an alias for a view of a whole column of a SparseMatrixCSC. Many methods can be written for the
+# union of such a view and a SparseVector so we define an alias for such a union as well
+const SparseColumnView{T}  = SubArray{T,1,<:SparseMatrixCSC,Tuple{Base.Slice{Base.OneTo{Int}},Int},false}
+const SparseVectorUnion{T} = Union{SparseVector{T}, SparseColumnView{T}}
+
 ### Basic properties
 
 length(x::SparseVector) = x.n
@@ -32,23 +42,37 @@ size(x::SparseVector) = (x.n,)
 nnz(x::SparseVector) = length(x.nzval)
 countnz(x::SparseVector) = countnz(x.nzval)
 count(x::SparseVector) = count(x.nzval)
+
 nonzeros(x::SparseVector) = x.nzval
+function nonzeros(x::SparseColumnView)
+    rowidx, colidx = parentindexes(x)
+    A = parent(x)
+    @inbounds y = view(A.nzval, nzrange(A, colidx))
+    return y
+end
+
 nonzeroinds(x::SparseVector) = x.nzind
+function nonzeroinds(x::SparseColumnView)
+    rowidx, colidx = parentindexes(x)
+    A = parent(x)
+    @inbounds y = view(A.rowval, nzrange(A, colidx))
+    return y
+end
 
-similar(x::SparseVector, Tv::Type=eltype(x)) = SparseVector(x.n, copy(x.nzind), Array{Tv}(length(x.nzval)))
-function similar{Tv,Ti}(x::SparseVector, ::Type{Tv}, ::Type{Ti})
+similar(x::SparseVector, Tv::Type=eltype(x)) = SparseVector(x.n, copy(x.nzind), Vector{Tv}(length(x.nzval)))
+function similar(x::SparseVector, ::Type{Tv}, ::Type{Ti}) where {Tv,Ti}
     return SparseVector(x.n, copy!(similar(x.nzind, Ti), x.nzind), copy!(similar(x.nzval, Tv), x.nzval))
 end
-similar{T}(x::SparseVector, ::Type{T}, D::Dims) = spzeros(T, D...)
+similar(x::SparseVector, ::Type{T}, D::Dims) where {T} = spzeros(T, D...)
 
 ### Construct empty sparse vector
 
 spzeros(len::Integer) = spzeros(Float64, len)
-spzeros{T}(::Type{T}, len::Integer) = SparseVector(len, Int[], T[])
-spzeros{Tv, Ti <: Integer}(::Type{Tv}, ::Type{Ti}, len::Integer) = SparseVector(len, Ti[], Tv[])
+spzeros(::Type{T}, len::Integer) where {T} = SparseVector(len, Int[], T[])
+spzeros(::Type{Tv}, ::Type{Ti}, len::Integer) where {Tv,Ti<:Integer} = SparseVector(len, Ti[], Tv[])
 
 # Construction of same structure, but with all ones
-spones{T}(x::SparseVector{T}) = SparseVector(x.n, copy(x.nzind), ones(T, length(x.nzval)))
+spones(x::SparseVector{T}) where {T} = SparseVector(x.n, copy(x.nzind), ones(T, length(x.nzval)))
 
 ### Construction from lists of indices and values
 
@@ -103,6 +127,7 @@ 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 `|`.
 
+# Examples
 ```jldoctest
 julia> II = [1, 3, 3, 5]; V = [0.1, 0.2, 0.3, 0.2];
 
@@ -176,6 +201,7 @@ sparsevec(I::AbstractVector, v::Number, len::Integer, combine::Function) =
 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.
 
+# Examples
 ```jldoctest
 julia> sparsevec(Dict(1 => 3, 2 => 2))
 2-element SparseVector{Int64,Int64} with 2 stored entries:
@@ -183,10 +209,10 @@ julia> sparsevec(Dict(1 => 3, 2 => 2))
   [2]  =  2
 ```
 """
-function sparsevec{Tv,Ti<:Integer}(dict::Associative{Ti,Tv})
+function sparsevec(dict::Associative{Ti,Tv}) where {Tv,Ti<:Integer}
     m = length(dict)
-    nzind = Array{Ti}(m)
-    nzval = Array{Tv}(m)
+    nzind = Vector{Ti}(m)
+    nzval = Vector{Tv}(m)
 
     cnt = 0
     len = zero(Ti)
@@ -204,10 +230,10 @@ function sparsevec{Tv,Ti<:Integer}(dict::Associative{Ti,Tv})
     _sparsevector!(nzind, nzval, len)
 end
 
-function sparsevec{Tv,Ti<:Integer}(dict::Associative{Ti,Tv}, len::Integer)
+function sparsevec(dict::Associative{Ti,Tv}, len::Integer) where {Tv,Ti<:Integer}
     m = length(dict)
-    nzind = Array{Ti}(m)
-    nzval = Array{Tv}(m)
+    nzind = Vector{Ti}(m)
+    nzval = Vector{Tv}(m)
 
     cnt = 0
     maxk = convert(Ti, len)
@@ -225,7 +251,7 @@ end
 
 ### Element access
 
-function setindex!{Tv,Ti<:Integer}(x::SparseVector{Tv,Ti}, v::Tv, i::Ti)
+function setindex!(x::SparseVector{Tv,Ti}, v::Tv, i::Ti) where {Tv,Ti<:Integer}
     checkbounds(x, i)
     nzind = nonzeroinds(x)
     nzval = nonzeros(x)
@@ -243,7 +269,7 @@ function setindex!{Tv,Ti<:Integer}(x::SparseVector{Tv,Ti}, v::Tv, i::Ti)
     x
 end
 
-setindex!{Tv, Ti<:Integer}(x::SparseVector{Tv,Ti}, v, i::Integer) =
+setindex!(x::SparseVector{Tv,Ti}, v, i::Integer) where {Tv,Ti<:Integer} =
     setindex!(x, convert(Tv, v), convert(Ti, i))
 
 
@@ -253,6 +279,7 @@ setindex!{Tv, Ti<:Integer}(x::SparseVector{Tv,Ti}, v, i::Integer) =
 
 Drop entry `x[i]` from `x` if `x[i]` is stored and otherwise do nothing.
 
+# Examples
 ```jldoctest
 julia> x = sparsevec([1, 3], [1.0, 2.0])
 3-element SparseVector{Float64,Int64} with 2 stored entries:
@@ -287,15 +314,15 @@ end
 ### Conversion
 
 # convert SparseMatrixCSC to SparseVector
-function convert{Tv,Ti<:Integer}(::Type{SparseVector{Tv,Ti}}, s::SparseMatrixCSC{Tv,Ti})
+function convert(::Type{SparseVector{Tv,Ti}}, s::SparseMatrixCSC{Tv,Ti}) where {Tv,Ti<:Integer}
     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(::Type{SparseVector{Tv}}, s::SparseMatrixCSC{Tv,Ti}) where {Tv,Ti} =
     convert(SparseVector{Tv,Ti}, s)
 
-convert{Tv,Ti}(::Type{SparseVector}, s::SparseMatrixCSC{Tv,Ti}) =
+convert(::Type{SparseVector}, s::SparseMatrixCSC{Tv,Ti}) where {Tv,Ti} =
     convert(SparseVector{Tv,Ti}, s)
 
 # convert Vector to SparseVector
@@ -305,6 +332,7 @@ convert{Tv,Ti}(::Type{SparseVector}, s::SparseMatrixCSC{Tv,Ti}) =
 
 Convert a vector `A` into a sparse vector of length `m`.
 
+# Examples
 ```jldoctest
 julia> sparsevec([1.0, 2.0, 0.0, 0.0, 3.0, 0.0])
 6-element SparseVector{Float64,Int64} with 3 stored entries:
@@ -313,17 +341,18 @@ julia> sparsevec([1.0, 2.0, 0.0, 0.0, 3.0, 0.0])
   [5]  =  3.0
 ```
 """
-sparsevec{T}(a::AbstractVector{T}) = convert(SparseVector{T, Int}, a)
+sparsevec(a::AbstractVector{T}) where {T} = convert(SparseVector{T, Int}, a)
 sparsevec(a::AbstractArray) = sparsevec(vec(a))
 sparsevec(a::AbstractSparseArray) = vec(a)
+sparsevec(a::AbstractSparseVector) = vec(a)
 sparse(a::AbstractVector) = sparsevec(a)
 
-function _dense2sparsevec{Tv,Ti}(s::AbstractArray{Tv}, initcap::Ti)
+function _dense2sparsevec(s::AbstractArray{Tv}, initcap::Ti) where {Tv,Ti}
     # pre-condition: initcap > 0; the initcap determines the index type
     n = length(s)
     cap = initcap
-    nzind = Array{Ti}(cap)
-    nzval = Array{Tv}(cap)
+    nzind = Vector{Ti}(cap)
+    nzval = Vector{Tv}(cap)
     c = 0
     @inbounds for i = 1:n
         v = s[i]
@@ -345,23 +374,23 @@ function _dense2sparsevec{Tv,Ti}(s::AbstractArray{Tv}, initcap::Ti)
     SparseVector(n, nzind, nzval)
 end
 
-convert{Tv,Ti}(::Type{SparseVector{Tv,Ti}}, s::AbstractVector{Tv}) =
+convert(::Type{SparseVector{Tv,Ti}}, s::AbstractVector{Tv}) where {Tv,Ti} =
     _dense2sparsevec(s, convert(Ti, max(8, div(length(s), 8))))
 
-convert{Tv}(::Type{SparseVector{Tv}}, s::AbstractVector{Tv}) =
+convert(::Type{SparseVector{Tv}}, s::AbstractVector{Tv}) where {Tv} =
     convert(SparseVector{Tv,Int}, s)
 
-convert{Tv}(::Type{SparseVector}, s::AbstractVector{Tv}) =
+convert(::Type{SparseVector}, s::AbstractVector{Tv}) where {Tv} =
     convert(SparseVector{Tv,Int}, s)
 
 
 # convert between different types of SparseVector
-convert{Tv}(::Type{SparseVector{Tv}}, s::SparseVector{Tv}) = s
-convert{Tv,Ti}(::Type{SparseVector{Tv,Ti}}, s::SparseVector{Tv,Ti}) = s
-convert{Tv,Ti}(::Type{SparseVector{Tv,Ti}}, s::SparseVector) =
+convert(::Type{SparseVector{Tv}}, s::SparseVector{Tv}) where {Tv} = s
+convert(::Type{SparseVector{Tv,Ti}}, s::SparseVector{Tv,Ti}) where {Tv,Ti} = s
+convert(::Type{SparseVector{Tv,Ti}}, s::SparseVector) where {Tv,Ti} =
     SparseVector{Tv,Ti}(s.n, convert(Vector{Ti}, s.nzind), convert(Vector{Tv}, s.nzval))
 
-convert{Tv,Ti}(::Type{SparseVector{Tv}}, s::SparseVector{<:Any,Ti}) =
+convert(::Type{SparseVector{Tv}}, s::SparseVector{<:Any,Ti}) where {Tv,Ti} =
     SparseVector{Tv,Ti}(s.n, s.nzind, convert(Vector{Tv}, s.nzval))
 
 
@@ -415,13 +444,13 @@ function copy!(A::SparseVector, B::SparseMatrixCSC)
     return A
 end
 
-copy!{TvB, TiB}(A::SparseMatrixCSC, B::SparseVector{TvB,TiB}) =
+copy!(A::SparseMatrixCSC, B::SparseVector{TvB,TiB}) where {TvB,TiB} =
     copy!(A, SparseMatrixCSC{TvB,TiB}(B.n, 1, TiB[1, length(B.nzind)+1], B.nzind, B.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})
+sprand(n::Integer, p::AbstractFloat, rfn::Function, ::Type{T}) where {T} = sprand(GLOBAL_RNG, n, p, rfn, T)
+function sprand(r::AbstractRNG, n::Integer, p::AbstractFloat, rfn::Function, ::Type{T}) where T
     I = randsubseq(r, 1:convert(Int, n), p)
     V = rfn(r, T, length(I))
     SparseVector(n, I, V)
@@ -437,9 +466,9 @@ end
 sprand(n::Integer, p::AbstractFloat) = sprand(GLOBAL_RNG, n, p, rand)
 
 sprand(r::AbstractRNG, n::Integer, p::AbstractFloat) = sprand(r, n, p, rand)
-sprand{T}(r::AbstractRNG, ::Type{T}, n::Integer, p::AbstractFloat) = sprand(r, n, p, (r, i) -> rand(r, T, i))
+sprand(r::AbstractRNG, ::Type{T}, n::Integer, p::AbstractFloat) where {T} = sprand(r, n, p, (r, i) -> rand(r, T, i))
 sprand(r::AbstractRNG, ::Type{Bool}, n::Integer, p::AbstractFloat) = sprand(r, n, p, truebools)
-sprand{T}(::Type{T}, n::Integer, p::AbstractFloat) = sprand(GLOBAL_RNG, T, n, p)
+sprand(::Type{T}, n::Integer, p::AbstractFloat) where {T} = sprand(GLOBAL_RNG, T, n, p)
 
 sprandn(n::Integer, p::AbstractFloat) = sprand(GLOBAL_RNG, n, p, randn)
 sprandn(r::AbstractRNG, n::Integer, p::AbstractFloat) = sprand(r, n, p, randn)
@@ -454,7 +483,7 @@ function getindex(x::SparseMatrixCSC, ::Colon, j::Integer)
     SparseVector(x.m, x.rowval[r1:r2], x.nzval[r1:r2])
 end
 
-function getindex(x::SparseMatrixCSC, I::UnitRange, j::Integer)
+function getindex(x::SparseMatrixCSC, I::AbstractUnitRange, j::Integer)
     checkbounds(x, I, j)
     # Get the selected column
     c1 = convert(Int, x.colptr[j])
@@ -473,13 +502,13 @@ end
 
 # Row slices
 getindex(A::SparseMatrixCSC, i::Integer, ::Colon) = A[i, 1:end]
-function Base.getindex{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, i::Integer, J::AbstractVector)
+function Base.getindex(A::SparseMatrixCSC{Tv,Ti}, i::Integer, J::AbstractVector) where {Tv,Ti}
     checkbounds(A, i, J)
     nJ = length(J)
     colptrA = A.colptr; rowvalA = A.rowval; nzvalA = A.nzval
 
-    nzinds = Array{Ti}(0)
-    nzvals = Array{Tv}(0)
+    nzinds = Vector{Ti}(0)
+    nzvals = Vector{Tv}(0)
 
     # adapted from SparseMatrixCSC's sorted_bsearch_A
     ptrI = 1
@@ -506,14 +535,14 @@ end
 # Logical and linear indexing into SparseMatrices
 getindex(A::SparseMatrixCSC, I::AbstractVector{Bool}) = _logical_index(A, I) # Ambiguities
 getindex(A::SparseMatrixCSC, I::AbstractArray{Bool}) = _logical_index(A, I)
-function _logical_index{Tv}(A::SparseMatrixCSC{Tv}, I::AbstractArray{Bool})
+function _logical_index(A::SparseMatrixCSC{Tv}, I::AbstractArray{Bool}) where Tv
     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)
+    rowvalB = Vector{Int}(nnzB)
+    nzvalB = Vector{Tv}(nnzB)
     c = 1
     rowB = 1
 
@@ -547,7 +576,7 @@ 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)
+function getindex(A::SparseMatrixCSC{Tv}, I::AbstractUnitRange) where Tv
     checkbounds(A, I)
     szA = size(A)
     nA = szA[1]*szA[2]
@@ -557,8 +586,8 @@ function getindex{Tv}(A::SparseMatrixCSC{Tv}, I::UnitRange)
 
     n = length(I)
     nnzB = min(n, nnz(A))
-    rowvalB = Array{Int}(nnzB)
-    nzvalB = Array{Tv}(nnzB)
+    rowvalB = Vector{Int}(nnzB)
+    nzvalB = Vector{Tv}(nnzB)
 
     rowstart,colstart = ind2sub(szA, first(I))
     rowend,colend = ind2sub(szA, last(I))
@@ -583,7 +612,7 @@ function getindex{Tv}(A::SparseMatrixCSC{Tv}, I::UnitRange)
     SparseVector(n, rowvalB, nzvalB)
 end
 
-function getindex{Tv}(A::SparseMatrixCSC{Tv}, I::AbstractVector)
+function getindex(A::SparseMatrixCSC{Tv}, I::AbstractVector) where Tv
     szA = size(A)
     nA = szA[1]*szA[2]
     colptrA = A.colptr
@@ -592,8 +621,8 @@ function getindex{Tv}(A::SparseMatrixCSC{Tv}, I::AbstractVector)
 
     n = length(I)
     nnzB = min(n, nnz(A))
-    rowvalB = Array{Int}(nnzB)
-    nzvalB = Array{Tv}(nnzB)
+    rowvalB = Vector{Int}(nnzB)
+    nzvalB = Vector{Tv}(nnzB)
 
     idxB = 1
     for i in 1:n
@@ -620,9 +649,9 @@ function getindex{Tv}(A::SparseMatrixCSC{Tv}, I::AbstractVector)
     SparseVector(n, rowvalB, nzvalB)
 end
 
-function find{Ti}(x::SparseVector{<:Any,Ti})
+function find(x::SparseVector{<:Any,Ti}) where Ti
     numnz = nnz(x)
-    I = Array{Ti,1}(numnz)
+    I = Vector{Ti}(numnz)
 
     nzind = x.nzind
     nzval = x.nzval
@@ -643,11 +672,11 @@ function find{Ti}(x::SparseVector{<:Any,Ti})
     return I
 end
 
-function findnz{Tv,Ti}(x::SparseVector{Tv,Ti})
+function findnz(x::SparseVector{Tv,Ti}) where {Tv,Ti}
     numnz = nnz(x)
 
-    I = Array{Ti,1}(numnz)
-    V = Array{Tv,1}(numnz)
+    I = Vector{Ti}(numnz)
+    V = Vector{Tv}(numnz)
 
     nzind = x.nzind
     nzval = x.nzval
@@ -674,7 +703,7 @@ end
 
 ### getindex
 
-function _spgetindex{Tv,Ti}(m::Int, nzind::AbstractVector{Ti}, nzval::AbstractVector{Tv}, i::Integer)
+function _spgetindex(m::Int, nzind::AbstractVector{Ti}, nzval::AbstractVector{Tv}, i::Integer) where {Tv,Ti}
     ii = searchsortedfirst(nzind, convert(Ti, i))
     (ii <= m && nzind[ii] == i) ? nzval[ii] : zero(Tv)
 end
@@ -684,7 +713,7 @@ function getindex(x::AbstractSparseVector, i::Integer)
     _spgetindex(nnz(x), nonzeroinds(x), nonzeros(x), i)
 end
 
-function getindex{Tv,Ti}(x::AbstractSparseVector{Tv,Ti}, I::UnitRange)
+function getindex(x::AbstractSparseVector{Tv,Ti}, I::AbstractUnitRange) where {Tv,Ti}
     checkbounds(x, I)
     xlen = length(x)
     i0 = first(I)
@@ -702,8 +731,8 @@ function getindex{Tv,Ti}(x::AbstractSparseVector{Tv,Ti}, I::UnitRange)
     # compute the number of non-zeros
     jrgn = j0:j1
     mr = length(jrgn)
-    rind = Array{Ti}(mr)
-    rval = Array{Tv}(mr)
+    rind = Vector{Ti}(mr)
+    rval = Vector{Tv}(mr)
     if mr > 0
         c = 0
         for j in jrgn
@@ -776,7 +805,7 @@ end
 
 ### Conversion to matrix
 
-function convert{Tv,Ti}(::Type{SparseMatrixCSC{Tv,Ti}}, x::AbstractSparseVector)
+function convert(::Type{SparseMatrixCSC{Tv,Ti}}, x::AbstractSparseVector) where {Tv,Ti}
     n = length(x)
     xnzind = nonzeroinds(x)
     xnzval = nonzeros(x)
@@ -789,13 +818,13 @@ function convert{Tv,Ti}(::Type{SparseMatrixCSC{Tv,Ti}}, x::AbstractSparseVector)
     SparseMatrixCSC(n, 1, colptr, rowval, nzval)
 end
 
-convert{Tv,Ti}(::Type{SparseMatrixCSC{Tv}}, x::AbstractSparseVector{<:Any,Ti}) =
+convert(::Type{SparseMatrixCSC{Tv}}, x::AbstractSparseVector{<:Any,Ti}) where {Tv,Ti} =
     convert(SparseMatrixCSC{Tv,Ti}, x)
 
-convert{Tv,Ti}(::Type{SparseMatrixCSC}, x::AbstractSparseVector{Tv,Ti}) =
+convert(::Type{SparseMatrixCSC}, x::AbstractSparseVector{Tv,Ti}) where {Tv,Ti} =
     convert(SparseMatrixCSC{Tv,Ti}, x)
 
-function convert{Tv}(::Type{Vector}, x::AbstractSparseVector{Tv})
+function convert(::Type{Vector}, x::AbstractSparseVector{Tv}) where Tv
     n = length(x)
     n == 0 && return Vector{Tv}(0)
     nzind = nonzeroinds(x)
@@ -817,7 +846,7 @@ 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})
+function reinterpret(::Type{T}, x::AbstractSparseVector{Tv}) where {T,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)))
@@ -838,9 +867,9 @@ complex(x::AbstractSparseVector) =
 # back to the horizontal concatenation method that ensures that combinations of
 # sparse/special/dense matrix/vector types concatenate to SparseMatrixCSCs, instead
 # of _absspvec_hcat below. The <:Integer qualifications are necessary for correct dispatch.
-hcat{Tv,Ti<:Integer}(X::SparseVector{Tv,Ti}...) = _absspvec_hcat(X...)
-hcat{Tv,Ti<:Integer}(X::AbstractSparseVector{Tv,Ti}...) = _absspvec_hcat(X...)
-function _absspvec_hcat{Tv,Ti}(X::AbstractSparseVector{Tv,Ti}...)
+hcat(X::SparseVector{Tv,Ti}...) where {Tv,Ti<:Integer} = _absspvec_hcat(X...)
+hcat(X::AbstractSparseVector{Tv,Ti}...) where {Tv,Ti<:Integer} = _absspvec_hcat(X...)
+function _absspvec_hcat(X::AbstractSparseVector{Tv,Ti}...) where {Tv,Ti}
     # check sizes
     n = length(X)
     m = length(X[1])
@@ -852,9 +881,9 @@ function _absspvec_hcat{Tv,Ti}(X::AbstractSparseVector{Tv,Ti}...)
     end
 
     # construction
-    colptr = Array{Ti}(n+1)
-    nzrow = Array{Ti}(tnnz)
-    nzval = Array{Tv}(tnnz)
+    colptr = Vector{Ti}(n+1)
+    nzrow = Vector{Ti}(tnnz)
+    nzval = Vector{Tv}(tnnz)
     roff = 1
     @inbounds for j = 1:n
         xj = X[j]
@@ -873,9 +902,14 @@ end
 # back to the vertical concatenation method that ensures that combinations of
 # sparse/special/dense matrix/vector types concatenate to SparseMatrixCSCs, instead
 # of _absspvec_vcat below. The <:Integer qualifications are necessary for correct dispatch.
-vcat{Tv,Ti<:Integer}(X::SparseVector{Tv,Ti}...) = _absspvec_vcat(X...)
-vcat{Tv,Ti<:Integer}(X::AbstractSparseVector{Tv,Ti}...) = _absspvec_vcat(X...)
-function _absspvec_vcat{Tv,Ti}(X::AbstractSparseVector{Tv,Ti}...)
+vcat(X::SparseVector{Tv,Ti}...) where {Tv,Ti<:Integer} = _absspvec_vcat(X...)
+vcat(X::AbstractSparseVector{Tv,Ti}...) where {Tv,Ti<:Integer} = _absspvec_vcat(X...)
+function vcat(X::SparseVector...)
+    commeltype = promote_type(map(eltype, X)...)
+    commindtype = promote_type(map(indtype, X)...)
+    vcat(map(x -> SparseVector{commeltype,commindtype}(x), X)...)
+end
+function _absspvec_vcat(X::AbstractSparseVector{Tv,Ti}...) where {Tv,Ti}
     # check sizes
     n = length(X)
     tnnz = 0
@@ -884,8 +918,8 @@ function _absspvec_vcat{Tv,Ti}(X::AbstractSparseVector{Tv,Ti}...)
     end
 
     # construction
-    rnzind = Array{Ti}(tnnz)
-    rnzval = Array{Tv}(tnnz)
+    rnzind = Vector{Ti}(tnnz)
+    rnzval = Vector{Tv}(tnnz)
     ir = 0
     len = 0
     @inbounds for j = 1:n
@@ -905,6 +939,12 @@ end
 
 hcat(Xin::Union{Vector, AbstractSparseVector}...) = hcat(map(sparse, Xin)...)
 vcat(Xin::Union{Vector, AbstractSparseVector}...) = vcat(map(sparse, Xin)...)
+# Without the following method, vertical concatenations of SparseVectors with Vectors
+# fall back to the vertical concatenation method that ensures that combinations of
+# sparse/special/dense matrix/vector types concatenate to SparseMatrixCSCs (because
+# the vcat method immediately above is less specific, being defined in AbstractSparseVector
+# rather than SparseVector).
+vcat(X::Union{Vector,SparseVector}...) = vcat(map(sparse, X)...)
 
 
 ### Concatenation of un/annotated sparse/special/dense vectors/matrices
@@ -951,7 +991,7 @@ end
 function hvcat(rows::Tuple{Vararg{Int}}, X::_SparseConcatGroup...)
     nbr = length(rows)  # number of block rows
 
-    tmp_rows = Array{SparseMatrixCSC}(nbr)
+    tmp_rows = Vector{SparseMatrixCSC}(nbr)
     k = 0
     @inbounds for i = 1 : nbr
         tmp_rows[i] = hcat(X[(1 : rows[i]) + k]...)
@@ -961,8 +1001,8 @@ function hvcat(rows::Tuple{Vararg{Int}}, X::_SparseConcatGroup...)
 end
 
 # make sure UniformScaling objects are converted to sparse matrices for concatenation
-promote_to_array_type(A::Tuple{Vararg{Union{_SparseConcatGroup,UniformScaling}}}) = (@_pure_meta; SparseMatrixCSC)
-promote_to_array_type(A::Tuple{Vararg{Union{_DenseConcatGroup,UniformScaling}}}) = (@_pure_meta; Matrix)
+promote_to_array_type(A::Tuple{Vararg{Union{_SparseConcatGroup,UniformScaling}}}) = SparseMatrixCSC
+promote_to_array_type(A::Tuple{Vararg{Union{_DenseConcatGroup,UniformScaling}}}) = Matrix
 promote_to_arrays_(n::Int, ::Type{SparseMatrixCSC}, J::UniformScaling) = sparse(J, n, n)
 
 # Concatenations strictly involving un/annotated dense matrices/vectors should yield dense arrays
@@ -973,10 +1013,10 @@ hcat(A::Vector...) = Base.typed_hcat(promote_eltype(A...), A...)
 hcat(A::_DenseConcatGroup...) = Base.typed_hcat(promote_eltype(A...), A...)
 hvcat(rows::Tuple{Vararg{Int}}, xs::_DenseConcatGroup...) = Base.typed_hvcat(promote_eltype(xs...), rows, xs...)
 # For performance, specially handle the case where the matrices/vectors have homogeneous eltype
-cat{T}(catdims, xs::_TypedDenseConcatGroup{T}...) = Base.cat_t(catdims, T, xs...)
-vcat{T}(A::_TypedDenseConcatGroup{T}...) = Base.typed_vcat(T, A...)
-hcat{T}(A::_TypedDenseConcatGroup{T}...) = Base.typed_hcat(T, A...)
-hvcat{T}(rows::Tuple{Vararg{Int}}, xs::_TypedDenseConcatGroup{T}...) = Base.typed_hvcat(T, rows, xs...)
+cat(catdims, xs::_TypedDenseConcatGroup{T}...) where {T} = Base.cat_t(catdims, T, xs...)
+vcat(A::_TypedDenseConcatGroup{T}...) where {T} = Base.typed_vcat(T, A...)
+hcat(A::_TypedDenseConcatGroup{T}...) where {T} = Base.typed_hcat(T, A...)
+hvcat(rows::Tuple{Vararg{Int}}, xs::_TypedDenseConcatGroup{T}...) where {T} = Base.typed_hvcat(T, rows, xs...)
 
 
 ### math functions
@@ -984,7 +1024,6 @@ hvcat{T}(rows::Tuple{Vararg{Int}}, xs::_TypedDenseConcatGroup{T}...) = Base.type
 ### Unary Map
 
 # zero-preserving functions (z->z, nz->nz)
-conj(x::SparseVector) = SparseVector(length(x), copy(nonzeroinds(x)), conj(nonzeros(x)))
 -(x::SparseVector) = SparseVector(length(x), copy(nonzeroinds(x)), -(nonzeros(x)))
 
 # functions f, such that
@@ -993,14 +1032,14 @@ conj(x::SparseVector) = SparseVector(length(x), copy(nonzeroinds(x)), conj(nonze
 #
 macro unarymap_nz2z_z2z(op, TF)
     esc(quote
-        function $(op){Tv<:$(TF),Ti<:Integer}(x::AbstractSparseVector{Tv,Ti})
+        function $(op)(x::AbstractSparseVector{Tv,Ti}) where Tv<:$(TF) where Ti<:Integer
             R = typeof($(op)(zero(Tv)))
             xnzind = nonzeroinds(x)
             xnzval = nonzeros(x)
             m = length(xnzind)
 
-            ynzind = Array{Ti}(m)
-            ynzval = Array{R}(m)
+            ynzind = Vector{Ti}(m)
+            ynzval = Vector{R}(m)
             ir = 0
             @inbounds for j = 1:m
                 i = xnzind[j]
@@ -1018,10 +1057,10 @@ macro unarymap_nz2z_z2z(op, TF)
     end)
 end
 
-real(x::AbstractSparseVector{<:Real}) = x
+# the rest of real, conj, imag are handled correctly via AbstractArray methods
 @unarymap_nz2z_z2z real Complex
-
-imag{Tv<:Real,Ti<:Integer}(x::AbstractSparseVector{Tv,Ti}) = SparseVector(length(x), Ti[], Tv[])
+conj(x::SparseVector{<:Complex}) = SparseVector(length(x), copy(nonzeroinds(x)), conj(nonzeros(x)))
+imag(x::AbstractSparseVector{Tv,Ti}) where {Tv<:Real,Ti<:Integer} = SparseVector(length(x), Ti[], Tv[])
 @unarymap_nz2z_z2z imag Complex
 
 for op in [:floor, :ceil, :trunc, :round]
@@ -1039,7 +1078,7 @@ end
 
 macro unarymap_z2nz(op, TF)
     esc(quote
-        function $(op){Tv<:$(TF)}(x::AbstractSparseVector{Tv,<:Integer})
+        function $(op)(x::AbstractSparseVector{Tv,<:Integer}) where Tv<:$(TF)
             v0 = $(op)(zero(Tv))
             R = typeof(v0)
             xnzind = nonzeroinds(x)
@@ -1072,10 +1111,10 @@ end
 # 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::Function,
-                           x::AbstractSparseVector{Tx},
-                           y::AbstractSparseVector{Ty},
-                           mode::Int)
+function _binarymap(f::Function,
+                    x::AbstractSparseVector{Tx},
+                    y::AbstractSparseVector{Ty},
+                    mode::Int) where {Tx,Ty}
     0 <= mode <= 2 || throw(ArgumentError("Incorrect mode $mode."))
     R = typeof(f(zero(Tx), zero(Ty)))
     n = length(x)
@@ -1089,8 +1128,8 @@ function _binarymap{Tx,Ty}(f::Function,
     my = length(ynzind)
     cap = (mode == 0 ? min(mx, my) : mx + my)::Int
 
-    rind = Array{Int}(cap)
-    rval = Array{R}(cap)
+    rind = Vector{Int}(cap)
+    rval = Vector{R}(cap)
     ir = 0
     ix = 1
     iy = 1
@@ -1129,10 +1168,10 @@ function _binarymap_mode_0!(f::Function, mx::Int, my::Int,
     return ir
 end
 
-function _binarymap_mode_1!{Tx,Ty}(f::Function, mx::Int, my::Int,
-                                   xnzind, xnzval::AbstractVector{Tx},
-                                   ynzind, ynzval::AbstractVector{Ty},
-                                   rind, rval)
+function _binarymap_mode_1!(f::Function, mx::Int, my::Int,
+                            xnzind, xnzval::AbstractVector{Tx},
+                            ynzind, ynzval::AbstractVector{Ty},
+                            rind, rval) where {Tx,Ty}
     # 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
@@ -1167,10 +1206,10 @@ function _binarymap_mode_1!{Tx,Ty}(f::Function, mx::Int, my::Int,
     return ir
 end
 
-function _binarymap_mode_2!{Tx,Ty}(f::Function, mx::Int, my::Int,
-                                   xnzind, xnzval::AbstractVector{Tx},
-                                   ynzind, ynzval::AbstractVector{Ty},
-                                   rind, rval)
+function _binarymap_mode_2!(f::Function, mx::Int, my::Int,
+                            xnzind, xnzval::AbstractVector{Tx},
+                            ynzind, ynzval::AbstractVector{Ty},
+                            rind, rval) where {Tx,Ty}
     # 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
@@ -1213,10 +1252,10 @@ function _binarymap_mode_2!{Tx,Ty}(f::Function, mx::Int, my::Int,
     return ir
 end
 
-function _binarymap{Tx,Ty}(f::Function,
-                           x::AbstractVector{Tx},
-                           y::AbstractSparseVector{Ty},
-                           mode::Int)
+function _binarymap(f::Function,
+                    x::AbstractVector{Tx},
+                    y::AbstractSparseVector{Ty},
+                    mode::Int) where {Tx,Ty}
     0 <= mode <= 2 || throw(ArgumentError("Incorrect mode $mode."))
     R = typeof(f(zero(Tx), zero(Ty)))
     n = length(x)
@@ -1226,7 +1265,7 @@ function _binarymap{Tx,Ty}(f::Function,
     ynzval = nonzeros(y)
     m = length(ynzind)
 
-    dst = Array{R}(n)
+    dst = Vector{R}(n)
     if mode == 0
         ii = 1
         @inbounds for i = 1:m
@@ -1255,10 +1294,10 @@ function _binarymap{Tx,Ty}(f::Function,
     return dst
 end
 
-function _binarymap{Tx,Ty}(f::Function,
-                           x::AbstractSparseVector{Tx},
-                           y::AbstractVector{Ty},
-                           mode::Int)
+function _binarymap(f::Function,
+                    x::AbstractSparseVector{Tx},
+                    y::AbstractVector{Ty},
+                    mode::Int) where {Tx,Ty}
     0 <= mode <= 2 || throw(ArgumentError("Incorrect mode $mode."))
     R = typeof(f(zero(Tx), zero(Ty)))
     n = length(x)
@@ -1268,7 +1307,7 @@ function _binarymap{Tx,Ty}(f::Function,
     xnzval = nonzeros(x)
     m = length(xnzind)
 
-    dst = Array{R}(n)
+    dst = Vector{R}(n)
     if mode == 0
         ii = 1
         @inbounds for i = 1:m
@@ -1349,7 +1388,7 @@ complex(x::AbstractSparseVector{<:Real}, y::StridedVector{<:Real}) = _binarymap(
 
 sum(x::AbstractSparseVector) = sum(nonzeros(x))
 
-function maximum{T<:Real}(x::AbstractSparseVector{T})
+function maximum(x::AbstractSparseVector{T}) where T<:Real
     n = length(x)
     n > 0 || throw(ArgumentError("maximum over empty array is not allowed."))
     m = nnz(x)
@@ -1358,7 +1397,7 @@ function maximum{T<:Real}(x::AbstractSparseVector{T})
      max(zero(T), maximum(nonzeros(x))))::T
 end
 
-function minimum{T<:Real}(x::AbstractSparseVector{T})
+function minimum(x::AbstractSparseVector{T}) where T<:Real
     n = length(x)
     n > 0 || throw(ArgumentError("minimum over empty array is not allowed."))
     m = nnz(x)
@@ -1370,13 +1409,13 @@ end
 for f in [:sum, :maximum, :minimum], op in [:abs, :abs2]
     SV = :AbstractSparseVector
     if f == :minimum
-        @eval ($f){T<:Number}(::typeof($op), x::$SV{T}) = nnz(x) < length(x) ? ($op)(zero(T)) : ($f)($op, nonzeros(x))
+        @eval ($f)(::typeof($op), x::$SV{T}) where {T<:Number} = nnz(x) < length(x) ? ($op)(zero(T)) : ($f)($op, nonzeros(x))
     else
         @eval ($f)(::typeof($op), x::$SV) = ($f)($op, nonzeros(x))
     end
 end
 
-vecnorm(x::AbstractSparseVector, p::Real=2) = vecnorm(nonzeros(x), p)
+vecnorm(x::SparseVectorUnion, p::Real=2) = vecnorm(nonzeros(x), p)
 
 ### linalg.jl
 
@@ -1389,7 +1428,7 @@ vecnorm(x::AbstractSparseVector, p::Real=2) = vecnorm(nonzeros(x), p)
 
 # axpy
 
-function LinAlg.axpy!(a::Number, x::AbstractSparseVector, y::StridedVector)
+function LinAlg.axpy!(a::Number, x::SparseVectorUnion, y::StridedVector)
     length(x) == length(y) || throw(DimensionMismatch())
     nzind = nonzeroinds(x)
     nzval = nonzeros(x)
@@ -1426,16 +1465,15 @@ scale!(a::Real, x::AbstractSparseVector) = (scale!(nonzeros(x), a); x)
 scale!(a::Complex, x::AbstractSparseVector) = (scale!(nonzeros(x), a); x)
 
 
-*(x::AbstractSparseVector, a::Number) = SparseVector(length(x), copy(nonzeroinds(x)), nonzeros(x) * a)
-*(a::Number, x::AbstractSparseVector) = SparseVector(length(x), copy(nonzeroinds(x)), a * nonzeros(x))
-/(x::AbstractSparseVector, a::Number) = SparseVector(length(x), copy(nonzeroinds(x)), nonzeros(x) / a)
+(*)(x::AbstractSparseVector, a::Number) = SparseVector(length(x), copy(nonzeroinds(x)), nonzeros(x) * a)
+(*)(a::Number, x::AbstractSparseVector) = SparseVector(length(x), copy(nonzeroinds(x)), a * nonzeros(x))
+(/)(x::AbstractSparseVector, a::Number) = SparseVector(length(x), copy(nonzeroinds(x)), nonzeros(x) / a)
 broadcast(::typeof(*), x::AbstractSparseVector, a::Number) = x * a
 broadcast(::typeof(*), a::Number, x::AbstractSparseVector) = a * x
 broadcast(::typeof(/), x::AbstractSparseVector, a::Number) = x / a
 
 # dot
-
-function dot{Tx<:Number,Ty<:Number}(x::StridedVector{Tx}, y::AbstractSparseVector{Ty})
+function dot(x::StridedVector{Tx}, y::SparseVectorUnion{Ty}) where {Tx<:Number,Ty<:Number}
     n = length(x)
     length(y) == n || throw(DimensionMismatch())
     nzind = nonzeroinds(y)
@@ -1447,13 +1485,13 @@ function dot{Tx<:Number,Ty<:Number}(x::StridedVector{Tx}, y::AbstractSparseVecto
     return s
 end
 
-function dot{Tx<:Number,Ty<:Number}(x::AbstractSparseVector{Tx}, y::AbstractVector{Ty})
+function dot(x::SparseVectorUnion{Tx}, y::AbstractVector{Ty}) where {Tx<:Number,Ty<:Number}
     n = length(y)
     length(x) == n || throw(DimensionMismatch())
     nzind = nonzeroinds(x)
     nzval = nonzeros(x)
     s = zero(Tx) * zero(Ty)
-    for i = 1:length(nzind)
+    @inbounds for i = 1:length(nzind)
         s += conj(nzval[i]) * y[nzind[i]]
     end
     return s
@@ -1480,7 +1518,7 @@ function _spdot(f::Function,
     s
 end
 
-function dot(x::AbstractSparseVector{<:Number}, y::AbstractSparseVector{<:Number})
+function dot(x::SparseVectorUnion{<:Number}, y::SparseVectorUnion{<:Number})
     x === y && return sum(abs2, x)
     n = length(x)
     length(y) == n || throw(DimensionMismatch())
@@ -1498,17 +1536,30 @@ end
 
 ### BLAS-2 / dense A * sparse x -> dense y
 
+# lowrankupdate (BLAS.ger! like)
+function LinAlg.lowrankupdate!(A::StridedMatrix, x::StridedVector, y::SparseVectorUnion, α::Number = 1)
+    nzi = nonzeroinds(y)
+    nzv = nonzeros(y)
+    @inbounds for (j,v) in zip(nzi,nzv)
+        αv = α*v'
+        for i in indices(x, 1)
+            A[i,j] += x[i]*αv
+        end
+    end
+    return A
+end
+
 # A_mul_B
 
-function *{Ta,Tx}(A::StridedMatrix{Ta}, x::AbstractSparseVector{Tx})
+function (*)(A::StridedMatrix{Ta}, x::AbstractSparseVector{Tx}) where {Ta,Tx}
     m, n = size(A)
     length(x) == n || throw(DimensionMismatch())
     Ty = promote_type(Ta, Tx)
-    y = Array{Ty}(m)
+    y = Vector{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!(y::StridedVector{Ty}, A::StridedMatrix, x::AbstractSparseVector{Tx}) where {Tx,Ty} =
     A_mul_B!(one(Tx), A, x, zero(Ty), y)
 
 function A_mul_B!(α::Number, A::StridedMatrix, x::AbstractSparseVector, β::Number, y::StridedVector)
@@ -1537,15 +1588,15 @@ end
 
 # At_mul_B
 
-function At_mul_B{Ta,Tx}(A::StridedMatrix{Ta}, x::AbstractSparseVector{Tx})
+function At_mul_B(A::StridedMatrix{Ta}, x::AbstractSparseVector{Tx}) where {Ta,Tx}
     m, n = size(A)
     length(x) == m || throw(DimensionMismatch())
     Ty = promote_type(Ta, Tx)
-    y = Array{Ty}(n)
+    y = Vector{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!(y::StridedVector{Ty}, A::StridedMatrix, x::AbstractSparseVector{Tx}) where {Tx,Ty} =
     At_mul_B!(one(Tx), A, x, zero(Ty), y)
 
 function At_mul_B!(α::Number, A::StridedMatrix, x::AbstractSparseVector, β::Number, y::StridedVector)
@@ -1588,7 +1639,7 @@ function densemv(A::SparseMatrixCSC, x::AbstractSparseVector; trans::Char='N')
     end
     xlen == length(x) || throw(DimensionMismatch())
     T = promote_type(eltype(A), eltype(x))
-    y = Array{T}(ylen)
+    y = Vector{T}(ylen)
     if trans == 'N' || trans == 'N'
         A_mul_B!(y, A, x)
     elseif trans == 'T' || trans == 't'
@@ -1603,7 +1654,7 @@ end
 
 # A_mul_B
 
-A_mul_B!{Tx,Ty}(y::StridedVector{Ty}, A::SparseMatrixCSC, x::AbstractSparseVector{Tx}) =
+A_mul_B!(y::StridedVector{Ty}, A::SparseMatrixCSC, x::AbstractSparseVector{Tx}) where {Tx,Ty} =
     A_mul_B!(one(Tx), A, x, zero(Ty), y)
 
 function A_mul_B!(α::Number, A::SparseMatrixCSC, x::AbstractSparseVector, β::Number, y::StridedVector)
@@ -1636,13 +1687,13 @@ end
 
 # At_mul_B
 
-At_mul_B!{Tx,Ty}(y::StridedVector{Ty}, A::SparseMatrixCSC, x::AbstractSparseVector{Tx}) =
+At_mul_B!(y::StridedVector{Ty}, A::SparseMatrixCSC, x::AbstractSparseVector{Tx}) where {Tx,Ty} =
     At_mul_B!(one(Tx), A, x, zero(Ty), y)
 
 At_mul_B!(α::Number, A::SparseMatrixCSC, x::AbstractSparseVector, β::Number, y::StridedVector) =
     _At_or_Ac_mul_B!(*, α, A, x, β, y)
 
-Ac_mul_B!{Tx,Ty}(y::StridedVector{Ty}, A::SparseMatrixCSC, x::AbstractSparseVector{Tx}) =
+Ac_mul_B!(y::StridedVector{Ty}, A::SparseMatrixCSC, x::AbstractSparseVector{Tx}) where {Tx,Ty} =
     Ac_mul_B!(one(Tx), A, x, zero(Ty), y)
 
 Ac_mul_B!(α::Number, A::SparseMatrixCSC, x::AbstractSparseVector, β::Number, y::StridedVector) =
@@ -1690,7 +1741,7 @@ At_mul_B(A::SparseMatrixCSC, x::AbstractSparseVector) =
 Ac_mul_B(A::SparseMatrixCSC, x::AbstractSparseVector) =
     _At_or_Ac_mul_B(dot, A, x)
 
-function _At_or_Ac_mul_B{TvA,TiA,TvX,TiX}(tfun::Function, A::SparseMatrixCSC{TvA,TiA}, x::AbstractSparseVector{TvX,TiX})
+function _At_or_Ac_mul_B(tfun::Function, A::SparseMatrixCSC{TvA,TiA}, x::AbstractSparseVector{TvX,TiX}) where {TvA,TiA,TvX,TiX}
     m, n = size(A)
     length(x) == m || throw(DimensionMismatch())
     Tv = promote_type(TvA, TvX)
@@ -1703,8 +1754,8 @@ function _At_or_Ac_mul_B{TvA,TiA,TvX,TiX}(tfun::Function, A::SparseMatrixCSC{TvA
     Anzval = A.nzval
     mx = length(xnzind)
 
-    ynzind = Array{Ti}(n)
-    ynzval = Array{Tv}(n)
+    ynzind = Vector{Ti}(n)
+    ynzval = Vector{Tv}(n)
 
     jr = 0
     for j = 1:n
@@ -1740,7 +1791,7 @@ for isunittri in (true, false), islowertri in (true, false)
         (true,  :(Ac_ldiv_B), :(Ac_ldiv_B!)) )
 
         # broad method where elements are Numbers
-        @eval function ($func){TA<:Number,Tb<:Number}(A::$tritype{TA,<:AbstractMatrix}, b::SparseVector{Tb})
+        @eval function ($func)(A::$tritype{TA,<:AbstractMatrix}, b::SparseVector{Tb}) where {TA<:Number,Tb<:Number}
             TAb = $(isunittri ?
                 :(typeof(zero(TA)*zero(Tb) + zero(TA)*zero(Tb))) :
                 :(typeof((zero(TA)*zero(Tb) + zero(TA)*zero(Tb))/one(TA))) )
@@ -1749,7 +1800,7 @@ for isunittri in (true, false), islowertri in (true, false)
 
         # faster method requiring good view support of the
         # triangular matrix type. hence the StridedMatrix restriction.
-        @eval function ($func){TA<:Number,Tb<:Number}(A::$tritype{TA,<:StridedMatrix}, b::SparseVector{Tb})
+        @eval function ($func)(A::$tritype{TA,<:StridedMatrix}, b::SparseVector{Tb}) where {TA<:Number,Tb<:Number}
             TAb = $(isunittri ?
                 :(typeof(zero(TA)*zero(Tb) + zero(TA)*zero(Tb))) :
                 :(typeof((zero(TA)*zero(Tb) + zero(TA)*zero(Tb))/one(TA))) )
@@ -1856,7 +1907,7 @@ function _densifystarttolastnz!(x::SparseVector)
 end
 
 #sorting
-function sort{Tv,Ti}(x::SparseVector{Tv,Ti}; kws...)
+function sort(x::SparseVector{Tv,Ti}; kws...) where {Tv,Ti}
     allvals = push!(copy(nonzeros(x)),zero(Tv))
     sinds = sortperm(allvals;kws...)
     n,k = length(x),length(allvals)
@@ -1917,11 +1968,25 @@ Generates a copy of `x` and removes numerical zeros from that copy, optionally t
 excess space from the result's `nzind` and `nzval` arrays when `trim` is `true`.
 
 For an in-place version and algorithmic information, see [`dropzeros!`](@ref).
+
+# Examples
+```jldoctest
+julia> A = sparsevec([1, 2, 3], [1.0, 0.0, 1.0])
+3-element SparseVector{Float64,Int64} with 3 stored entries:
+  [1]  =  1.0
+  [2]  =  0.0
+  [3]  =  1.0
+
+julia> dropzeros(A)
+3-element SparseVector{Float64,Int64} with 2 stored entries:
+  [1]  =  1.0
+  [3]  =  1.0
+```
 """
 dropzeros(x::SparseVector, trim::Bool = true) = dropzeros!(copy(x), trim)
 
 
-function _fillnonzero!{Tv,Ti}(arr::SparseMatrixCSC{Tv, Ti}, val)
+function _fillnonzero!(arr::SparseMatrixCSC{Tv, Ti}, val) where {Tv,Ti}
     m, n = size(arr)
     resize!(arr.colptr, n+1)
     resize!(arr.rowval, m*n)
@@ -1938,7 +2003,7 @@ function _fillnonzero!{Tv,Ti}(arr::SparseMatrixCSC{Tv, Ti}, val)
     arr
 end
 
-function _fillnonzero!{Tv,Ti}(arr::SparseVector{Tv,Ti}, val)
+function _fillnonzero!(arr::SparseVector{Tv,Ti}, val) where {Tv,Ti}
     n = arr.n
     resize!(arr.nzind, n)
     resize!(arr.nzval, n)
diff --git a/base/sparse/spqr.jl b/base/sparse/spqr.jl
index 66deb05e5d3207..6b27d0b25146b1 100644
--- a/base/sparse/spqr.jl
+++ b/base/sparse/spqr.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module SPQR
 
@@ -19,135 +19,312 @@ const ORDERING_BESTAMD = Int32(9) # try COLAMD and AMD; pick best#
 # Let [m n] = size of the matrix after pruning singletons.  The default
 # ordering strategy is to use COLAMD if m <= 2*n.  Otherwise, AMD(A'A) is
 # tried.  If there is a high fill-in with AMD then try METIS(A'A) and take
-# the best of AMD and METIS.  METIS is not tried if it isn't installed.
+# the best of AMD and METIS. METIS is not tried if it isn't installed.
 
-# tol options
-const DEFAULT_TOL = Int32(-2) # if tol <= -2, the default tol is used
-const NO_TOL      = Int32(-1) # if -2 < tol < 0, then no tol is used
-
-# for qmult, method can be 0,1,2,3:
-const QTX = Int32(0)
-const QX  = Int32(1)
-const XQT = Int32(2)
-const XQ  = Int32(3)
+using ..SparseArrays: SparseMatrixCSC
+using ..SparseArrays.CHOLMOD
+using ..SparseArrays.CHOLMOD: change_stype!, free!
 
-# system can be 0,1,2,3:  Given Q*R=A*E from SuiteSparseQR_factorize:
-const RX_EQUALS_B    = Int32(0) # solve R*X=B      or X = R\B
-const RETX_EQUALS_B  = Int32(1) # solve R*E'*X=B   or X = E*(R\B)
-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)
+function _qr!(ordering::Integer, tol::Real, econ::Integer, getCTX::Integer,
+        A::Sparse{Tv},
+        Bsparse::Union{Sparse{Tv}                      , Ptr{Void}} = C_NULL,
+        Bdense::Union{Dense{Tv}                        , Ptr{Void}} = C_NULL,
+        Zsparse::Union{Ref{Ptr{CHOLMOD.C_Sparse{Tv}}}  , Ptr{Void}} = C_NULL,
+        Zdense::Union{Ref{Ptr{CHOLMOD.C_Dense{Tv}}}    , Ptr{Void}} = C_NULL,
+        R::Union{Ref{Ptr{CHOLMOD.C_Sparse{Tv}}}        , Ptr{Void}} = C_NULL,
+        E::Union{Ref{Ptr{CHOLMOD.SuiteSparse_long}}    , Ptr{Void}} = C_NULL,
+        H::Union{Ref{Ptr{CHOLMOD.C_Sparse{Tv}}}        , Ptr{Void}} = C_NULL,
+        HPinv::Union{Ref{Ptr{CHOLMOD.SuiteSparse_long}}, Ptr{Void}} = C_NULL,
+        HTau::Union{Ref{Ptr{CHOLMOD.C_Dense{Tv}}}      , Ptr{Void}} = C_NULL) where {Tv<:CHOLMOD.VTypes}
 
+    AA   = unsafe_load(pointer(A))
+    m, n = AA.nrow, AA.ncol
+    rnk  = ccall((:SuiteSparseQR_C, :libspqr), CHOLMOD.SuiteSparse_long,
+        (Cint, Cdouble, CHOLMOD.SuiteSparse_long, Cint,
+         Ptr{CHOLMOD.C_Sparse{Tv}}, Ptr{CHOLMOD.C_Sparse{Tv}}, Ptr{CHOLMOD.C_Dense{Tv}},
+         Ptr{Ptr{CHOLMOD.C_Sparse{Tv}}}, Ptr{Ptr{CHOLMOD.C_Dense{Tv}}}, Ptr{Ptr{CHOLMOD.C_Sparse{Tv}}},
+         Ptr{Ptr{CHOLMOD.SuiteSparse_long}}, Ptr{Ptr{CHOLMOD.C_Sparse{Tv}}}, Ptr{Ptr{CHOLMOD.SuiteSparse_long}},
+         Ptr{Ptr{CHOLMOD.C_Dense{Tv}}}, Ptr{Void}),
+        ordering,       # all, except 3:given treated as 0:fixed
+        tol,            # columns with 2-norm <= tol treated as 0
+        econ,           # e = max(min(m,econ),rank(A))
+        getCTX,         # 0: Z=C (e-by-k), 1: Z=C', 2: Z=X (e-by-k)
+        A,              # m-by-n sparse matrix to factorize
+        Bsparse,        # sparse m-by-k B
+        Bdense,         # dense  m-by-k B
+        # /* outputs: */
+        Zsparse,        # sparse Z
+        Zdense,         # dense Z
+        R,              # e-by-n sparse matrix */
+        E,              # size n column perm, NULL if identity */
+        H,              # m-by-nh Householder vectors
+        HPinv,          # size m row permutation
+        HTau,           # 1-by-nh Householder coefficients
+        CHOLMOD.common()) # /* workspace and parameters */
 
-using ..SparseArrays: SparseMatrixCSC
-using ..SparseArrays.CHOLMOD: C_Dense, C_Sparse, Dense, ITypes, Sparse, SuiteSparseStruct, VTypes, common
+    if rnk < 0
+        error("Sparse QR factorization failed")
+    end
 
-import Base: size
-import Base.LinAlg: qrfact
-import ..SparseArrays.CHOLMOD: convert, free!
+    e = E[]
+    if e == C_NULL
+        _E = Vector{CHOLMOD.SuiteSparse_long}()
+    else
+        _E = Vector{CHOLMOD.SuiteSparse_long}(n)
+        for i in 1:n
+            @inbounds _E[i] = unsafe_load(e, i) + 1
+        end
+        # Free memory allocated by SPQR. This call will make sure that the
+        # correct deallocator function is called and that the memory count in
+        # the common struct is updated
+        ccall((:cholmod_l_free, :libcholmod), Void,
+            (Csize_t, Cint, Ptr{CHOLMOD.SuiteSparse_long}, Ptr{Void}),
+            n, sizeof(CHOLMOD.SuiteSparse_long), e, CHOLMOD.common())
+    end
+    hpinv = HPinv[]
+    if hpinv == C_NULL
+        _HPinv = Vector{CHOLMOD.SuiteSparse_long}()
+    else
+        _HPinv = Vector{CHOLMOD.SuiteSparse_long}(m)
+        for i in 1:m
+            @inbounds _HPinv[i] = unsafe_load(hpinv, i) + 1
+        end
+        # Free memory allocated by SPQR. This call will make sure that the
+        # correct deallocator function is called and that the memory count in
+        # the common struct is updated
+        ccall((:cholmod_l_free, :libcholmod), Void,
+            (Csize_t, Cint, Ptr{CHOLMOD.SuiteSparse_long}, Ptr{Void}),
+            m, sizeof(CHOLMOD.SuiteSparse_long), hpinv, CHOLMOD.common())
+    end
 
-struct C_Factorization{Tv<:VTypes} <: SuiteSparseStruct
-    xtype::Cint
-    factors::Ptr{Tv}
+    return rnk, _E, _HPinv
 end
 
-mutable struct Factorization{Tv<:VTypes} <: Base.LinAlg.Factorization{Tv}
-    m::Int
-    n::Int
-    p::Ptr{C_Factorization{Tv}}
-    function Factorization{Tv}(m::Integer, n::Integer, p::Ptr{C_Factorization{Tv}}) where Tv<:VTypes
-        if p == C_NULL
-            throw(ArgumentError("factorization failed for unknown reasons. Please submit a bug report."))
-        end
-        new(m, n, p)
-    end
+# Struct for storing sparse QR from SPQR such that
+# A[invperm(rpivinv), cpiv] = (I - factors[:,1]*τ[1]*factors[:,1]')*...*(I - factors[:,k]*τ[k]*factors[:,k]')*R
+# with k = size(factors, 2).
+struct QRSparse{Tv,Ti} <: LinAlg.Factorization{Tv}
+    factors::SparseMatrixCSC{Tv,Ti}
+    τ::Vector{Tv}
+    R::SparseMatrixCSC{Tv,Ti}
+    cpiv::Vector{Ti}
+    rpivinv::Vector{Ti}
 end
-Factorization(m::Integer, n::Integer, p::Ptr{C_Factorization{Tv}}) where Tv<:VTypes = Factorization{Tv}(m, n, p)
 
-size(F::Factorization) = (F.m, F.n)
-function size(F::Factorization, i::Integer)
-    if i < 1
-        throw(ArgumentError("dimension must be positive"))
-    end
+Base.size(F::QRSparse) = (size(F.factors, 1), size(F.R, 2))
+function Base.size(F::QRSparse, i::Integer)
     if i == 1
-        return F.m
+        return size(F.factors, 1)
     elseif i == 2
-        return F.n
+        return size(F.R, 2)
+    elseif i > 2
+        return 1
+    else
+        throw(ArgumentError("second argument must be positive"))
     end
-    return 1
 end
 
-function free!{Tv<:VTypes}(F::Factorization{Tv})
-    ccall((:SuiteSparseQR_C_free, :libspqr), Cint,
-        (Ptr{Ptr{C_Factorization{Tv}}}, Ptr{Void}),
-            &F.p, common()) == 1
+struct QRSparseQ{Tv<:CHOLMOD.VTypes,Ti<:Integer} <: LinAlg.AbstractQ{Tv}
+    factors::SparseMatrixCSC{Tv,Ti}
+    τ::Vector{Tv}
 end
 
-function backslash{Tv<:VTypes}(ordering::Integer, tol::Real, A::Sparse{Tv}, B::Dense{Tv})
-    m, n  = size(A)
-    if m != size(B, 1)
-        throw(DimensionMismatch("left hand side and right hand side must have same number of rows"))
-    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, get(A.p), get(B.p), common()))
-    finalizer(d, free!)
-    d
+Base.size(Q::QRSparseQ) = (size(Q.factors, 1), size(Q.factors, 1))
+
+# From SPQR manual p. 6
+_default_tol(A::SparseMatrixCSC) =
+    20*sum(size(A))*eps(real(eltype(A)))*maximum(norm(view(A, :, i))^2 for i in 1:size(A, 2))
+
+function Base.LinAlg.qrfact(A::SparseMatrixCSC{Tv}; tol = _default_tol(A)) where {Tv <: CHOLMOD.VTypes}
+    R     = Ref{Ptr{CHOLMOD.C_Sparse{Tv}}}()
+    E     = Ref{Ptr{CHOLMOD.SuiteSparse_long}}()
+    H     = Ref{Ptr{CHOLMOD.C_Sparse{Tv}}}()
+    HPinv = Ref{Ptr{CHOLMOD.SuiteSparse_long}}()
+    HTau  = Ref{Ptr{CHOLMOD.C_Dense{Tv}}}(C_NULL)
+
+    # SPQR doesn't accept symmetric matrices so we explicitly set the stype
+    r, p, hpinv = _qr!(ORDERING_DEFAULT, tol, 0, 0, Sparse(A, 0),
+        C_NULL, C_NULL, C_NULL, C_NULL,
+        R, E, H, HPinv, HTau)
+
+    return QRSparse(SparseMatrixCSC(Sparse(H[])),
+                    vec(Array(CHOLMOD.Dense(HTau[]))),
+                    SparseMatrixCSC(Sparse(R[])),
+                    p, hpinv)
 end
 
-function factorize{Tv<:VTypes}(ordering::Integer, tol::Real, A::Sparse{Tv})
-    s = unsafe_load(A.p)
-    if s.stype != 0
-        throw(ArgumentError("stype must be zero"))
+"""
+    qrfact(A) -> QRSparse
+
+Compute the `QR` factorization of a sparse matrix `A`. Fill-reducing row and column permutations
+are used such that `F[:R] = F[:Q]'*A[F[:prow],F[:pcol]]`. The main application of this type is to
+solve least squares or underdetermined problems with [`\\`](@ref). The function calls the C library SPQR.
+
+# Examples
+```jldoctest
+julia> A = sparse([1,2,3,4], [1,1,2,2], ones(4))
+4×2 SparseMatrixCSC{Float64,Int64} with 4 stored entries:
+  [1, 1]  =  1.0
+  [2, 1]  =  1.0
+  [3, 2]  =  1.0
+  [4, 2]  =  1.0
+
+julia> qrfact(A)
+Base.SparseArrays.SPQR.QRSparse{Float64,Int64}
+Q factor:
+4×4 Base.SparseArrays.SPQR.QRSparseQ{Float64,Int64}:
+ -0.707107   0.0        0.0       -0.707107
+  0.0       -0.707107  -0.707107   0.0
+  0.0       -0.707107   0.707107   0.0
+ -0.707107   0.0        0.0        0.707107
+R factor:
+2×2 SparseMatrixCSC{Float64,Int64} with 2 stored entries:
+  [1, 1]  =  -1.41421
+  [2, 2]  =  -1.41421
+Row permutation:
+4-element Array{Int64,1}:
+ 1
+ 3
+ 4
+ 2
+Column permutation:
+2-element Array{Int64,1}:
+ 1
+ 2
+```
+"""
+Base.LinAlg.qrfact(A::SparseMatrixCSC; tol = _default_tol(A)) = qrfact(A, Val{true}, tol = tol)
+
+Base.LinAlg.qr(A::SparseMatrixCSC; tol = _default_tol(A)) = qr(A, Val{true}, tol = tol)
+
+function Base.A_mul_B!(Q::QRSparseQ, A::StridedVecOrMat)
+    if size(A, 1) != size(Q, 1)
+        throw(DimensionMismatch("size(Q) = $(size(Q)) but size(A) = $(size(A))"))
+    end
+    for l in size(Q.factors, 2):-1:1
+        τl = -Q.τ[l]
+        h = view(Q.factors, :, l)
+        for j in 1:size(A, 2)
+            a = view(A, :, j)
+            LinAlg.axpy!(τl*dot(h, a), h, a)
+        end
     end
-    f = Factorization(size(A)..., ccall((:SuiteSparseQR_C_factorize, :libspqr), Ptr{C_Factorization{Tv}},
-        (Cint, Cdouble, Ptr{Sparse{Tv}}, Ptr{Void}),
-            ordering, tol, get(A.p), common()))
-    finalizer(f, free!)
-    f
+    return A
 end
 
-function solve{Tv<:VTypes}(system::Integer, QR::Factorization{Tv}, B::Dense{Tv})
-    m, n = size(QR)
-    mB = size(B, 1)
-    if (system == RX_EQUALS_B || system == RETX_EQUALS_B) && m != mB
-        throw(DimensionMismatch("number of rows in factorized matrix must equal number of rows in right hand side"))
-    elseif (system == RTX_EQUALS_ETB || system == RTX_EQUALS_B) && n != mB
-        throw(DimensionMismatch("number of columns in factorized matrix must equal number of rows in right hand side"))
+function Base.A_mul_B!(A::StridedMatrix, Q::QRSparseQ)
+    if size(A, 2) != size(Q, 1)
+        throw(DimensionMismatch("size(Q) = $(size(Q)) but size(A) = $(size(A))"))
     end
-    d = Dense(ccall((:SuiteSparseQR_C_solve, :libspqr), Ptr{C_Dense{Tv}},
-        (Cint, Ptr{C_Factorization{Tv}}, Ptr{C_Dense{Tv}}, Ptr{Void}),
-            system, get(QR.p), get(B.p), common()))
-    finalizer(d, free!)
-    d
+    tmp = similar(A, size(A, 1))
+    for l in 1:size(Q.factors, 2)
+        τl = -Q.τ[l]
+        h = view(Q.factors, :, l)
+        A_mul_B!(tmp, A, h)
+        LinAlg.lowrankupdate!(A, tmp, h, τl)
+    end
+    return A
 end
 
-function qmult{Tv<:VTypes}(method::Integer, QR::Factorization{Tv}, X::Dense{Tv})
-    mQR, nQR = size(QR)
-    mX, nX = size(X)
-    if (method == QTX || method == QX) && mQR != mX
-        throw(DimensionMismatch("Q matrix size $mQR and dense matrix has $mX rows"))
-    elseif (method == XQT || method == XQ) && mQR != nX
-        throw(DimensionMismatch("Q matrix size $mQR and dense matrix has $nX columns"))
+function Base.Ac_mul_B!(Q::QRSparseQ, A::StridedVecOrMat)
+    if size(A, 1) != size(Q, 1)
+        throw(DimensionMismatch("size(Q) = $(size(Q)) but size(A) = $(size(A))"))
+    end
+    for l in 1:size(Q.factors, 2)
+        τl = -Q.τ[l]
+        h = view(Q.factors, :, l)
+        for j in 1:size(A, 2)
+            a = view(A, :, j)
+            LinAlg.axpy!(τl'*dot(h, a), h, a)
+        end
     end
-    d = Dense(ccall((:SuiteSparseQR_C_qmult, :libspqr), Ptr{C_Dense{Tv}},
-            (Cint, Ptr{C_Factorization{Tv}}, Ptr{C_Dense{Tv}}, Ptr{Void}),
-                method, get(QR.p), get(X.p), common()))
-    finalizer(d, free!)
-    d
+    return A
 end
 
+function Base.A_mul_Bc!(A::StridedMatrix, Q::QRSparseQ)
+    if size(A, 2) != size(Q, 1)
+        throw(DimensionMismatch("size(Q) = $(size(Q)) but size(A) = $(size(A))"))
+    end
+    tmp = similar(A, size(A, 1))
+    for l in size(Q.factors, 2):-1:1
+        τl = -Q.τ[l]
+        h = view(Q.factors, :, l)
+        A_mul_B!(tmp, A, h)
+        LinAlg.lowrankupdate!(A, tmp, h, τl')
+    end
+    return A
+end
 
-qrfact(A::SparseMatrixCSC, ::Type{Val{true}}) = factorize(ORDERING_DEFAULT, DEFAULT_TOL, Sparse(A, 0))
+Base.LinAlg.getq(F::QRSparse) = QRSparseQ(F.factors, F.τ)
 
 """
-    qrfact(A) -> SPQR.Factorization
+    getindex(F::QRSparse, d::Symbol)
+
+Extract factors of a QRSparse factorization. Possible values of `d` are
+- `:Q` : `QRSparseQ` matrix of the ``Q`` factor in Householder form
+- `:R` : `UpperTriangular` ``R`` factor
+- `:prow` : Vector of the row permutations applied to the factorized matrix
+- `:pcol` : Vector of the column permutations applied to the factorized matrix
+
+# Examples
+```jldoctest
+julia> F = qrfact(sparse([1,3,2,3,4], [1,1,2,3,4], [1.0,2.0,3.0,4.0,5.0]));
+
+julia> F[:Q]
+4×4 Base.SparseArrays.SPQR.QRSparseQ{Float64,Int64}:
+ 1.0  0.0  0.0  0.0
+ 0.0  1.0  0.0  0.0
+ 0.0  0.0  1.0  0.0
+ 0.0  0.0  0.0  1.0
+
+julia> F[:R]
+4×4 SparseMatrixCSC{Float64,Int64} with 5 stored entries:
+  [1, 1]  =  3.0
+  [2, 2]  =  4.0
+  [3, 3]  =  5.0
+  [2, 4]  =  2.0
+  [4, 4]  =  1.0
 
-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 [`\\`](@ref). The function
-calls the C library SPQR and a few additional functions from the library are wrapped but not
-exported.
+julia> F[:prow]
+4-element Array{Int64,1}:
+ 2
+ 3
+ 4
+ 1
+
+julia> F[:pcol]
+4-element Array{Int64,1}:
+ 2
+ 3
+ 4
+ 1
+```
 """
-qrfact(A::SparseMatrixCSC) = qrfact(A, Val{true})
+function Base.getindex(F::QRSparse, d::Symbol)
+    if d == :Q
+        return LinAlg.getq(F)
+    elseif d == :R
+        return F.R
+    elseif d == :prow
+        return invperm(F.rpivinv)
+    elseif d == :pcol
+        return F.cpiv
+    else
+        throw(KeyError(d))
+    end
+end
+
+function Base.show(io::IO, mime::MIME{Symbol("text/plain")}, F::QRSparse)
+    println(io, summary(F))
+    println(io, "Q factor:")
+    show(io, mime, F[:Q])
+    println(io, "\nR factor:")
+    show(io, mime, F[:R])
+    println(io, "\nRow permutation:")
+    show(io, mime, F[:prow])
+    println(io, "\nColumn permutation:")
+    show(io, mime, F[:pcol])
+end
 
 # 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
@@ -156,10 +333,10 @@ qrfact(A::SparseMatrixCSC) = qrfact(A, Val{true})
 # here we have to use \ instead of A_ldiv_B! because of limitations in SPQR
 
 ## Two helper methods
-_ret_size(F::Factorization, b::AbstractVector) = (size(F, 2),)
-_ret_size(F::Factorization, B::AbstractMatrix) = (size(F, 2), size(B, 2))
+_ret_size(F::QRSparse, b::AbstractVector) = (size(F, 2),)
+_ret_size(F::QRSparse, B::AbstractMatrix) = (size(F, 2), size(B, 2))
 
-function (\)(F::Factorization{Float64}, B::VecOrMat{Complex{Float64}})
+function (\)(F::QRSparse{Float64}, B::VecOrMat{Complex{Float64}})
 # |z1|z3|  reinterpret  |x1|x2|x3|x4|  transpose  |x1|y1|  reshape  |x1|y1|x3|y3|
 # |z2|z4|      ->       |y1|y2|y3|y4|     ->      |x2|y2|     ->    |x2|y2|x4|y4|
 #                                                 |x3|y3|
@@ -174,11 +351,65 @@ function (\)(F::Factorization{Float64}, B::VecOrMat{Complex{Float64}})
     return reinterpret(Complex{Float64}, transpose(reshape(x, (length(x) >> 1), 2)), _ret_size(F, B))
 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))
+function _ldiv_basic(F::QRSparse, B::StridedVecOrMat)
+    if size(F, 1) != size(B, 1)
+        throw(DimensionMismatch("size(F) = $(size(F)) but size(B) = $(size(B))"))
+    end
+
+    # The rank of F equal to the number of rows in R
+    rnk = size(F.R, 1)
+
+    # allocate an array for the return value large enough to hold B and X
+    # For overdetermined problem, B is larger than X and vice versa
+    X   = similar(B, ntuple(i -> i == 1 ? max(size(F, 2), size(B, 1)) : size(B, 2), Val(ndims(B))))
+
+    # Fill will zeros. These will eventually become the zeros in the basic solution
+    # fill!(X, 0)
+    # Apply left permutation to the solution and store in X
+    for j in 1:size(B, 2)
+        for i in 1:length(F.rpivinv)
+            @inbounds X[F.rpivinv[i], j] = B[i, j]
+        end
+    end
+
+    # Make a view into X corresponding to the size of B
+    X0 = view(X, 1:size(B, 1), :)
+
+    # Apply Q' to B
+    Ac_mul_B!(LinAlg.getq(F), X0)
+
+    # Zero out to get basic solution
+    X[rnk + 1:end, :] = 0
+
+    # Solve R*X = B
+    A_ldiv_B!(UpperTriangular(view(F.R, :, Base.OneTo(rnk))), view(X0, Base.OneTo(rnk), :))
+
+    # Apply right permutation and extract solution from X
+    return getindex(X, ntuple(i -> i == 1 ? invperm(F.cpiv) : :, Val(ndims(B)))...)
 end
 
-(\)(F::Factorization, B::StridedVecOrMat) = F\convert(AbstractArray{eltype(F)}, B)
+(\)(F::QRSparse{T}, B::StridedVecOrMat{T}) where {T} = _ldiv_basic(F, B)
+"""
+    (\\)(F::QRSparse, B::StridedVecOrMat)
+
+Solve the least squares problem ``\\min\\|Ax - b\\|^2`` or the linear system of equations
+``Ax=b`` when `F` is the sparse QR factorization of ``A``. A basic solution is returned
+when the problem is underdetermined.
+
+# Examples
+```jldoctest
+julia> A = sparse([1,2,4], [1,1,1], ones(3), 4, 2)
+4×2 SparseMatrixCSC{Float64,Int64} with 3 stored entries:
+  [1, 1]  =  1.0
+  [2, 1]  =  1.0
+  [4, 1]  =  1.0
+
+julia> qrfact(A)\\ones(4)
+2-element Array{Float64,1}:
+ 1.0
+ 0.0
+```
+"""
+(\)(F::QRSparse, B::StridedVecOrMat) = F\convert(AbstractArray{eltype(F)}, B)
 
 end # module
diff --git a/base/sparse/umfpack.jl b/base/sparse/umfpack.jl
index 6cfd5ae8beddb0..d123ffe04581b6 100644
--- a/base/sparse/umfpack.jl
+++ b/base/sparse/umfpack.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module UMFPACK
 
@@ -71,9 +71,9 @@ const UMFVTypes = Union{Float64,Complex128}
 ## UMFPACK
 
 # the control and info arrays
-const umf_ctrl = Array{Float64}(UMFPACK_CONTROL)
+const umf_ctrl = Vector{Float64}(UMFPACK_CONTROL)
 ccall((:umfpack_dl_defaults,:libumfpack), Void, (Ptr{Float64},), umf_ctrl)
-const umf_info = Array{Float64}(UMFPACK_INFO)
+const umf_info = Vector{Float64}(UMFPACK_INFO)
 
 function show_umf_ctrl(level::Real = 2.0)
     old_prt::Float64 = umf_ctrl[1]
@@ -107,8 +107,8 @@ end
 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`).
+`UmfpackLU{Tv, Ti}`, with `Tv` = [`Float64`](@ref) or `Complex128` respectively and
+`Ti` is an integer type ([`Int32`](@ref) or [`Int64`](@ref)).
 
 The individual components of the factorization `F` can be accessed by indexing:
 
@@ -133,7 +133,7 @@ The relation between `F` and `A` is
 
 !!! note
     `lufact(A::SparseMatrixCSC)` uses the UMFPACK library that is part of
-    SuiteSparse. As this library only supports sparse matrices with `Float64` or
+    SuiteSparse. As this library only supports sparse matrices with [`Float64`](@ref) or
     `Complex128` elements, `lufact` converts `A` into a copy that is of type
     `SparseMatrixCSC{Float64}` or `SparseMatrixCSC{Complex128}` as appropriate.
 """
@@ -146,11 +146,11 @@ function lufact(S::SparseMatrixCSC{<:UMFVTypes,<:UMFITypes})
     finalizer(res, umfpack_free_symbolic)
     umfpack_numeric!(res)
 end
-lufact{Ti<:UMFITypes}(A::SparseMatrixCSC{<:Union{Float16,Float32},Ti}) =
+lufact(A::SparseMatrixCSC{<:Union{Float16,Float32},Ti}) where {Ti<:UMFITypes} =
     lufact(convert(SparseMatrixCSC{Float64,Ti}, A))
-lufact{Ti<:UMFITypes}(A::SparseMatrixCSC{<:Union{Complex32,Complex64},Ti}) =
+lufact(A::SparseMatrixCSC{<:Union{Complex32,Complex64},Ti}) where {Ti<:UMFITypes} =
     lufact(convert(SparseMatrixCSC{Complex128,Ti}, A))
-lufact{T<:AbstractFloat}(A::Union{SparseMatrixCSC{T},SparseMatrixCSC{Complex{T}}}) =
+lufact(A::Union{SparseMatrixCSC{T},SparseMatrixCSC{Complex{T}}}) where {T<:AbstractFloat} =
     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(Array(A)) for generic ",
@@ -197,7 +197,7 @@ for itype in UmfpackIndexTypes
     @eval begin
         function umfpack_symbolic!(U::UmfpackLU{Float64,$itype})
             if U.symbolic != C_NULL return U end
-            tmp = Array{Ptr{Void}}(1)
+            tmp = Vector{Ptr{Void}}(1)
             @isok ccall(($sym_r, :libumfpack), $itype,
                         ($itype, $itype, Ptr{$itype}, Ptr{$itype}, Ptr{Float64}, Ptr{Void},
                          Ptr{Float64}, Ptr{Float64}),
@@ -208,7 +208,7 @@ for itype in UmfpackIndexTypes
         end
         function umfpack_symbolic!(U::UmfpackLU{Complex128,$itype})
             if U.symbolic != C_NULL return U end
-            tmp = Array{Ptr{Void}}(1)
+            tmp = Vector{Ptr{Void}}(1)
             @isok ccall(($sym_c, :libumfpack), $itype,
                         ($itype, $itype, Ptr{$itype}, Ptr{$itype}, Ptr{Float64}, Ptr{Float64}, Ptr{Void},
                          Ptr{Float64}, Ptr{Float64}),
@@ -220,7 +220,7 @@ for itype in UmfpackIndexTypes
         function umfpack_numeric!(U::UmfpackLU{Float64,$itype})
             if U.numeric != C_NULL return U end
             if U.symbolic == C_NULL umfpack_symbolic!(U) end
-            tmp = Array{Ptr{Void}}(1)
+            tmp = Vector{Ptr{Void}}(1)
             status = ccall(($num_r, :libumfpack), $itype,
                            (Ptr{$itype}, Ptr{$itype}, Ptr{Float64}, Ptr{Void}, Ptr{Void},
                             Ptr{Float64}, Ptr{Float64}),
@@ -235,7 +235,7 @@ for itype in UmfpackIndexTypes
         function umfpack_numeric!(U::UmfpackLU{Complex128,$itype})
             if U.numeric != C_NULL return U end
             if U.symbolic == C_NULL umfpack_symbolic!(U) end
-            tmp = Array{Ptr{Void}}(1)
+            tmp = Vector{Ptr{Void}}(1)
             status = ccall(($num_c, :libumfpack), $itype,
                            (Ptr{$itype}, Ptr{$itype}, Ptr{Float64}, Ptr{Float64}, Ptr{Void}, Ptr{Void},
                             Ptr{Float64}, Ptr{Float64}),
@@ -285,54 +285,54 @@ for itype in UmfpackIndexTypes
             return x
         end
         function det(lu::UmfpackLU{Float64,$itype})
-            mx = Array{Float64}(1)
+            mx = Ref{Float64}()
             @isok ccall(($det_r,:libumfpack), $itype,
                            (Ptr{Float64},Ptr{Float64},Ptr{Void},Ptr{Float64}),
                            mx, C_NULL, lu.numeric, umf_info)
-            mx[1]
+            mx[]
         end
         function det(lu::UmfpackLU{Complex128,$itype})
-            mx = Array{Float64}(1)
-            mz = Array{Float64}(1)
+            mx = Ref{Float64}()
+            mz = Ref{Float64}()
             @isok ccall(($det_z,:libumfpack), $itype,
                         (Ptr{Float64},Ptr{Float64},Ptr{Float64},Ptr{Void},Ptr{Float64}),
                         mx, mz, C_NULL, lu.numeric, umf_info)
-            complex(mx[1], mz[1])
+            complex(mx[], mz[])
         end
         function umf_lunz(lu::UmfpackLU{Float64,$itype})
-            lnz = Array{$itype}(1)
-            unz = Array{$itype}(1)
-            n_row = Array{$itype}(1)
-            n_col = Array{$itype}(1)
-            nz_diag = Array{$itype}(1)
+            lnz = Ref{$itype}()
+            unz = Ref{$itype}()
+            n_row = Ref{$itype}()
+            n_col = Ref{$itype}()
+            nz_diag = Ref{$itype}()
             @isok ccall(($lunz_r,:libumfpack), $itype,
                            (Ptr{$itype},Ptr{$itype},Ptr{$itype},Ptr{$itype},Ptr{$itype},Ptr{Void}),
                            lnz, unz, n_row, n_col, nz_diag, lu.numeric)
-            (lnz[1], unz[1], n_row[1], n_col[1], nz_diag[1])
+            (lnz[], unz[], n_row[], n_col[], nz_diag[])
         end
         function umf_lunz(lu::UmfpackLU{Complex128,$itype})
-            lnz = Array{$itype}(1)
-            unz = Array{$itype}(1)
-            n_row = Array{$itype}(1)
-            n_col = Array{$itype}(1)
-            nz_diag = Array{$itype}(1)
+            lnz = Ref{$itype}()
+            unz = Ref{$itype}()
+            n_row = Ref{$itype}()
+            n_col = Ref{$itype}()
+            nz_diag = Ref{$itype}()
             @isok ccall(($lunz_z,:libumfpack), $itype,
                            (Ptr{$itype},Ptr{$itype},Ptr{$itype},Ptr{$itype},Ptr{$itype},Ptr{Void}),
                            lnz, unz, n_row, n_col, nz_diag, lu.numeric)
-            (lnz[1], unz[1], n_row[1], n_col[1], nz_diag[1])
+            (lnz[], unz[], n_row[], n_col[], nz_diag[])
         end
         function umf_extract(lu::UmfpackLU{Float64,$itype})
             umfpack_numeric!(lu)        # ensure the numeric decomposition exists
             (lnz, unz, n_row, n_col, nz_diag) = umf_lunz(lu)
-            Lp = Array{$itype}(n_row + 1)
-            Lj = Array{$itype}(lnz) # L is returned in CSR (compressed sparse row) format
-            Lx = Array{Float64}(lnz)
-            Up = Array{$itype}(n_col + 1)
-            Ui = Array{$itype}(unz)
-            Ux = Array{Float64}(unz)
-            P  = Array{$itype}(n_row)
-            Q  = Array{$itype}(n_col)
-            Rs = Array{Float64}(n_row)
+            Lp = Vector{$itype}(n_row + 1)
+            Lj = Vector{$itype}(lnz) # L is returned in CSR (compressed sparse row) format
+            Lx = Vector{Float64}(lnz)
+            Up = Vector{$itype}(n_col + 1)
+            Ui = Vector{$itype}(unz)
+            Ux = Vector{Float64}(unz)
+            P  = Vector{$itype}(n_row)
+            Q  = Vector{$itype}(n_col)
+            Rs = Vector{Float64}(n_row)
             @isok ccall(($get_num_r,:libumfpack), $itype,
                         (Ptr{$itype},Ptr{$itype},Ptr{Float64},
                          Ptr{$itype},Ptr{$itype},Ptr{Float64},
@@ -349,17 +349,17 @@ for itype in UmfpackIndexTypes
         function umf_extract(lu::UmfpackLU{Complex128,$itype})
             umfpack_numeric!(lu)        # ensure the numeric decomposition exists
             (lnz, unz, n_row, n_col, nz_diag) = umf_lunz(lu)
-            Lp = Array{$itype}(n_row + 1)
-            Lj = Array{$itype}(lnz) # L is returned in CSR (compressed sparse row) format
-            Lx = Array{Float64}(lnz)
-            Lz = Array{Float64}(lnz)
-            Up = Array{$itype}(n_col + 1)
-            Ui = Array{$itype}(unz)
-            Ux = Array{Float64}(unz)
-            Uz = Array{Float64}(unz)
-            P  = Array{$itype}(n_row)
-            Q  = Array{$itype}(n_col)
-            Rs = Array{Float64}(n_row)
+            Lp = Vector{$itype}(n_row + 1)
+            Lj = Vector{$itype}(lnz) # L is returned in CSR (compressed sparse row) format
+            Lx = Vector{Float64}(lnz)
+            Lz = Vector{Float64}(lnz)
+            Up = Vector{$itype}(n_col + 1)
+            Ui = Vector{$itype}(unz)
+            Ux = Vector{Float64}(unz)
+            Uz = Vector{Float64}(unz)
+            P  = Vector{$itype}(n_row)
+            Q  = Vector{$itype}(n_col)
+            Rs = Vector{Float64}(n_row)
             @isok ccall(($get_num_z,:libumfpack), $itype,
                         (Ptr{$itype},Ptr{$itype},Ptr{Float64},Ptr{Float64},
                          Ptr{$itype},Ptr{$itype},Ptr{Float64},Ptr{Float64},
@@ -382,25 +382,25 @@ function nnz(lu::UmfpackLU)
 end
 
 ### Solve with Factorization
-A_ldiv_B!{T<:UMFVTypes}(lu::UmfpackLU{T}, B::StridedVecOrMat{T}) = A_ldiv_B!(B, lu, copy(B))
-At_ldiv_B!{T<:UMFVTypes}(lu::UmfpackLU{T}, B::StridedVecOrMat{T}) = At_ldiv_B!(B, lu, copy(B))
-Ac_ldiv_B!{T<:UMFVTypes}(lu::UmfpackLU{T}, B::StridedVecOrMat{T}) = Ac_ldiv_B!(B, lu, copy(B))
+A_ldiv_B!(lu::UmfpackLU{T}, B::StridedVecOrMat{T}) where {T<:UMFVTypes} = A_ldiv_B!(B, lu, copy(B))
+At_ldiv_B!(lu::UmfpackLU{T}, B::StridedVecOrMat{T}) where {T<:UMFVTypes} = At_ldiv_B!(B, lu, copy(B))
+Ac_ldiv_B!(lu::UmfpackLU{T}, B::StridedVecOrMat{T}) where {T<:UMFVTypes} = Ac_ldiv_B!(B, lu, copy(B))
 A_ldiv_B!(lu::UmfpackLU{Float64}, B::StridedVecOrMat{<:Complex}) = A_ldiv_B!(B, lu, copy(B))
 At_ldiv_B!(lu::UmfpackLU{Float64}, B::StridedVecOrMat{<:Complex}) = At_ldiv_B!(B, lu, copy(B))
 Ac_ldiv_B!(lu::UmfpackLU{Float64}, B::StridedVecOrMat{<:Complex}) = Ac_ldiv_B!(B, lu, copy(B))
 
-A_ldiv_B!{T<:UMFVTypes}(X::StridedVecOrMat{T}, lu::UmfpackLU{T}, B::StridedVecOrMat{T}) =
+A_ldiv_B!(X::StridedVecOrMat{T}, lu::UmfpackLU{T}, B::StridedVecOrMat{T}) where {T<:UMFVTypes} =
     _Aq_ldiv_B!(X, lu, B, UMFPACK_A)
-At_ldiv_B!{T<:UMFVTypes}(X::StridedVecOrMat{T}, lu::UmfpackLU{T}, B::StridedVecOrMat{T}) =
-    _Aq_ldiv_B!(X, lu, B, UMFPACK_At)
-Ac_ldiv_B!{T<:UMFVTypes}(X::StridedVecOrMat{T}, lu::UmfpackLU{T}, B::StridedVecOrMat{T}) =
+At_ldiv_B!(X::StridedVecOrMat{T}, lu::UmfpackLU{T}, B::StridedVecOrMat{T}) where {T<:UMFVTypes} =
     _Aq_ldiv_B!(X, lu, B, UMFPACK_Aat)
-A_ldiv_B!{Tb<:Complex}(X::StridedVecOrMat{Tb}, lu::UmfpackLU{Float64}, B::StridedVecOrMat{Tb}) =
-    _Aq_ldiv_B!(X, lu, B, UMFPACK_A)
-At_ldiv_B!{Tb<:Complex}(X::StridedVecOrMat{Tb}, lu::UmfpackLU{Float64}, B::StridedVecOrMat{Tb}) =
+Ac_ldiv_B!(X::StridedVecOrMat{T}, lu::UmfpackLU{T}, B::StridedVecOrMat{T}) where {T<:UMFVTypes} =
     _Aq_ldiv_B!(X, lu, B, UMFPACK_At)
-Ac_ldiv_B!{Tb<:Complex}(X::StridedVecOrMat{Tb}, lu::UmfpackLU{Float64}, B::StridedVecOrMat{Tb}) =
+A_ldiv_B!(X::StridedVecOrMat{Tb}, lu::UmfpackLU{Float64}, B::StridedVecOrMat{Tb}) where {Tb<:Complex} =
+    _Aq_ldiv_B!(X, lu, B, UMFPACK_A)
+At_ldiv_B!(X::StridedVecOrMat{Tb}, lu::UmfpackLU{Float64}, B::StridedVecOrMat{Tb}) where {Tb<:Complex} =
     _Aq_ldiv_B!(X, lu, B, UMFPACK_Aat)
+Ac_ldiv_B!(X::StridedVecOrMat{Tb}, lu::UmfpackLU{Float64}, B::StridedVecOrMat{Tb}) where {Tb<:Complex} =
+    _Aq_ldiv_B!(X, lu, B, UMFPACK_At)
 
 function _Aq_ldiv_B!(X::StridedVecOrMat, lu::UmfpackLU, B::StridedVecOrMat, transposeoptype)
     if size(X, 2) != size(B, 2)
@@ -409,25 +409,25 @@ function _Aq_ldiv_B!(X::StridedVecOrMat, lu::UmfpackLU, B::StridedVecOrMat, tran
     _AqldivB_kernel!(X, lu, B, transposeoptype)
     return X
 end
-function _AqldivB_kernel!{T<:UMFVTypes}(x::StridedVector{T}, lu::UmfpackLU{T},
-                                        b::StridedVector{T}, transposeoptype)
+function _AqldivB_kernel!(x::StridedVector{T}, lu::UmfpackLU{T},
+                          b::StridedVector{T}, transposeoptype) where T<:UMFVTypes
     solve!(x, lu, b, transposeoptype)
 end
-function _AqldivB_kernel!{T<:UMFVTypes}(X::StridedMatrix{T}, lu::UmfpackLU{T},
-                                        B::StridedMatrix{T}, transposeoptype)
+function _AqldivB_kernel!(X::StridedMatrix{T}, lu::UmfpackLU{T},
+                          B::StridedMatrix{T}, transposeoptype) where T<:UMFVTypes
     for col in 1:size(X, 2)
         solve!(view(X, :, col), lu, view(B, :, col), transposeoptype)
     end
 end
-function _AqldivB_kernel!{Tb<:Complex}(x::StridedVector{Tb}, lu::UmfpackLU{Float64},
-                                        b::StridedVector{Tb}, transposeoptype)
+function _AqldivB_kernel!(x::StridedVector{Tb}, lu::UmfpackLU{Float64},
+                          b::StridedVector{Tb}, transposeoptype) where Tb<:Complex
     r, i = similar(b, Float64), similar(b, Float64)
     solve!(r, lu, Vector{Float64}(real(b)), transposeoptype)
     solve!(i, lu, Vector{Float64}(imag(b)), transposeoptype)
     map!(complex, x, r, i)
 end
-function _AqldivB_kernel!{Tb<:Complex}(X::StridedMatrix{Tb}, lu::UmfpackLU{Float64},
-                                        B::StridedMatrix{Tb}, transposeoptype)
+function _AqldivB_kernel!(X::StridedMatrix{Tb}, lu::UmfpackLU{Float64},
+                          B::StridedMatrix{Tb}, transposeoptype) where Tb<:Complex
     r = similar(B, Float64, size(B, 1))
     i = similar(B, Float64, size(B, 1))
     for j in 1:size(B, 2)
diff --git a/base/sparse/umfpack_h.jl b/base/sparse/umfpack_h.jl
index c4abdae0a5bf82..ec3a7c5382a42a 100644
--- a/base/sparse/umfpack_h.jl
+++ b/base/sparse/umfpack_h.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## UMFPACK
 
diff --git a/base/special/exp.jl b/base/special/exp.jl
index 9d7012a98034ff..e49bfb5ed942b8 100644
--- a/base/special/exp.jl
+++ b/base/special/exp.jl
@@ -1,4 +1,4 @@
-# Based on FreeBSD lib/msun/src/e_exp.c
+# Based on FDLIBM http://www.netlib.org/fdlibm/e_exp.c
 # which is made available under the following licence
 
 ## Copyright (C) 2004 by Sun Microsystems, Inc. All rights reserved. Permission
@@ -32,52 +32,56 @@
 # log(2)
 const LN2 = 6.931471805599453094172321214581765680755001343602552541206800094933936219696955e-01
 # log2(e)
-const LOG2E = 1.442695040888963407359924681001892137426646
+const LOG2_E = 1.442695040888963407359924681001892137426646
 
-# log(2) into upper and lower
+# log(2) into upper and lower bits
 LN2U(::Type{Float64}) = 6.93147180369123816490e-1
 LN2U(::Type{Float32}) = 6.9313812256f-1
 
 LN2L(::Type{Float64}) = 1.90821492927058770002e-10
 LN2L(::Type{Float32}) = 9.0580006145f-6
 
-# max and min arguments for exponential fucntions
-MAXEXP(::Type{Float64}) = 7.09782712893383996732e2 # log 2^1023*(2-2^-52)
-MAXEXP(::Type{Float32}) = 88.72283905206835f0      # log 2^127 *(2-2^-23)
+# max and min arguments
+MAX_EXP(::Type{Float64}) = 7.09782712893383996732e2 # log 2^1023*(2-2^-52)
+MAX_EXP(::Type{Float32}) = 88.72283905206835f0      # log 2^127 *(2-2^-23)
 
 # one less than the min exponent since we can sqeeze a bit more from the exp function
-MINEXP(::Type{Float64}) = -7.451332191019412076235e2 # log 2^-1075
-MINEXP(::Type{Float32}) = -103.97207708f0            # log 2^-150
+MIN_EXP(::Type{Float64}) = -7.451332191019412076235e2 # log 2^-1075
+MIN_EXP(::Type{Float32}) = -103.97207708f0            # log 2^-150
 
 @inline exp_kernel(x::Float64) = @horner(x, 1.66666666666666019037e-1,
-        -2.77777777770155933842e-3, 6.61375632143793436117e-5,
-        -1.65339022054652515390e-6, 4.13813679705723846039e-8)
+    -2.77777777770155933842e-3, 6.61375632143793436117e-5,
+    -1.65339022054652515390e-6, 4.13813679705723846039e-8)
 
 @inline exp_kernel(x::Float32) = @horner(x, 1.6666625440f-1, -2.7667332906f-3)
 
 # for values smaller than this threshold just use a Taylor expansion
-exp_small_thres(::Type{Float64}) = 2.0^-28
-exp_small_thres(::Type{Float32}) = 2.0f0^-13
+@eval exp_small_thres(::Type{Float64}) = $(2.0^-28)
+@eval exp_small_thres(::Type{Float32}) = $(2.0f0^-13)
 
 """
     exp(x)
 
 Compute the natural base exponential of `x`, in other words ``e^x``.
+
+```jldoctest
+julia> exp(1.0)
+2.718281828459045
+```
 """
-function exp{T<:Union{Float32,Float64}}(x::T)
+function exp(x::T) where T<:Union{Float32,Float64}
     xa = reinterpret(Unsigned, x) & ~sign_mask(T)
     xsb = signbit(x)
 
     # filter out non-finite arguments
-    if xa > reinterpret(Unsigned, MAXEXP(T))
+    if xa > reinterpret(Unsigned, MAX_EXP(T))
         if xa >= exponent_mask(T)
             xa & significand_mask(T) != 0 && return T(NaN)
             return xsb ? T(0.0) : T(Inf) # exp(+-Inf)
         end
-        x > MAXEXP(T) && return T(Inf)
-        x < MINEXP(T) && return T(0.0)
+        x > MAX_EXP(T) && return T(Inf)
+        x < MIN_EXP(T) && return T(0.0)
     end
-
     # This implementation gives 2.7182818284590455 for exp(1.0) when T ==
     # Float64, which is well within the allowable error; however,
     # 2.718281828459045 is closer to the true value so we prefer that answer,
@@ -85,7 +89,7 @@ function exp{T<:Union{Float32,Float64}}(x::T)
     if x == T(1.0) && T == Float64
         return 2.718281828459045235360
     end
-
+    # compute approximation
     if xa > reinterpret(Unsigned, T(0.5)*T(LN2)) # |x| > 0.5 log(2)
         # argument reduction
         if xa < reinterpret(Unsigned, T(1.5)*T(LN2)) # |x| < 1.5 log(2)
@@ -99,31 +103,29 @@ function exp{T<:Union{Float32,Float64}}(x::T)
                 lo = LN2L(T)
             end
         else
-            n = round(T(LOG2E)*x)
+            n = round(T(LOG2_E)*x)
             k = unsafe_trunc(Int,n)
             hi = muladd(n, -LN2U(T), x)
             lo = n*LN2L(T)
         end
-        r = hi - lo
-
         # compute approximation on reduced argument
+        r = hi - lo
         z = r*r
         p = r - z*exp_kernel(z)
         y = T(1.0) - ((lo - (r*p)/(T(2.0) - p)) - hi)
-
         # scale back
         if k > -significand_bits(T)
             # multiply by 2.0 first to prevent overflow, which helps extends the range
-            k == exponent_max(T) && return y*T(2.0)*T(2.0)^(exponent_max(T) - 1)
+            k == exponent_max(T) && return y * T(2.0) * T(2.0)^(exponent_max(T) - 1)
             twopk = reinterpret(T, rem(exponent_bias(T) + k, fpinttype(T)) << significand_bits(T))
             return y*twopk
         else
             # add significand_bits(T) + 1 to lift the range outside the subnormals
             twopk = reinterpret(T, rem(exponent_bias(T) + significand_bits(T) + 1 + k, fpinttype(T)) << significand_bits(T))
-            return y*twopk*T(2.0)^(-significand_bits(T) - 1)
+            return y * twopk * T(2.0)^(-significand_bits(T) - 1)
         end
     elseif xa < reinterpret(Unsigned, exp_small_thres(T)) # |x| < exp_small_thres
-        # Taylor approximation for small x
+        # Taylor approximation for small values: exp(x) ≈ 1.0 + x
         return T(1.0) + x
     else
         # primary range with k = 0, so compute approximation directly
diff --git a/base/special/exp10.jl b/base/special/exp10.jl
new file mode 100644
index 00000000000000..2cfb4ff50057e2
--- /dev/null
+++ b/base/special/exp10.jl
@@ -0,0 +1,122 @@
+#  Method
+#  1. Argument reduction: Reduce x to an r so that |r| <= 0.5*log10(2). Given x,
+#     find r and integer k such that
+#
+#                x = k*log10(2) + r,  |r| <= 0.5*log10(2).
+#
+# 2. Approximate exp10(r) by a polynomial on the interval [-0.5*log10(2), 0.5*log10(2)]:
+#
+#           exp10(x) = 1.0 + polynomial(x),
+#
+#    sup norm relative error within the interval of the polynomial approximations:
+#    Float64 : [2.7245504724394698952e-18; 2.7245529895753476720e-18]
+#    Float32 : [9.6026471477842205871e-10; 9.6026560194009888672e-10]
+#
+# 3. Scale back: exp10(x) = 2^k * exp10(r)
+
+# log2(10)
+const LOG2_10 = 3.321928094887362347870319429489390175864831393024580612054756395815934776608624
+# log10(2)
+const LOG10_2 = 3.010299956639811952137388947244930267681898814621085413104274611271081892744238e-01
+# log(10)
+const LN10 = 2.302585092994045684017991454684364207601101488628772976033327900967572609677367
+
+# log10(2) into upper and lower bits
+LOG10_2U(::Type{Float64}) = 3.01025390625000000000e-1
+LOG10_2U(::Type{Float32}) = 3.00781250000000000000f-1
+
+LOG10_2L(::Type{Float64}) = 4.60503898119521373889e-6
+LOG10_2L(::Type{Float32}) = 2.48745663981195213739f-4
+
+# max and min arguments
+MAX_EXP10(::Type{Float64}) = 3.08254715559916743851e2 # log 2^1023*(2-2^-52)
+MAX_EXP10(::Type{Float32}) = 38.531839419103626f0     # log 2^127 *(2-2^-23)
+
+# one less than the min exponent since we can sqeeze a bit more from the exp10 function
+MIN_EXP10(::Type{Float64}) = -3.23607245338779784854769e2 # log10 2^-1075
+MIN_EXP10(::Type{Float32}) = -45.15449934959718f0         # log10 2^-150
+
+@inline exp10_kernel(x::Float64) =
+    @horner(x, 1.0,
+    2.30258509299404590109361379290930926799774169921875,
+    2.6509490552391992146397114993305876851081848144531,
+    2.03467859229323178027470930828712880611419677734375,
+    1.17125514891212478829629617393948137760162353515625,
+    0.53938292928868392106522833273629657924175262451172,
+    0.20699584873167015119932443667494226247072219848633,
+    6.8089348259156870502017966373387025669217109680176e-2,
+    1.9597690535095281527677713029333972372114658355713e-2,
+    5.015553121397981796436571499953060992993414402008e-3,
+    1.15474960721768829356725927226534622604958713054657e-3,
+    1.55440426715227567738830671828509366605430841445923e-4,
+    3.8731032432074128681303432086835414338565897196531e-5,
+    2.3804466459036747669197886523306806338950991630554e-3,
+    9.3881392238209649520573607528461934634833596646786e-5,
+    -2.64330486232183387018679354696359951049089431762695e-2)
+
+@inline exp10_kernel(x::Float32) =
+    @horner(x, 1.0f0,
+    2.302585124969482421875f0,
+    2.650949001312255859375f0,
+    2.0346698760986328125f0,
+    1.17125606536865234375f0,
+    0.5400512218475341796875f0,
+    0.20749187469482421875f0,
+    5.2789829671382904052734375f-2)
+
+@eval exp10_small_thres(::Type{Float64}) = $(2.0^-29)
+@eval exp10_small_thres(::Type{Float32}) = $(2.0f0^-14)
+
+function exp10(x::T) where T<:Union{Float32,Float64}
+    xa = reinterpret(Unsigned, x) & ~sign_mask(T)
+    xsb = signbit(x)
+
+    # filter out non-finite arguments
+    if xa > reinterpret(Unsigned, MAX_EXP10(T))
+        if xa >= exponent_mask(T)
+            xa & significand_mask(T) != 0 && return T(NaN)
+            return xsb ? T(0.0) : T(Inf) # exp10(+-Inf)
+        end
+        x > MAX_EXP10(T) && return T(Inf)
+        x < MIN_EXP10(T) && return T(0.0)
+    end
+    # compute approximation
+    if xa > reinterpret(Unsigned, T(0.5)*T(LOG10_2)) # |x| > 0.5 log10(2).
+        # argument reduction
+        if xa < reinterpret(Unsigned, T(1.5)*T(LOG10_2)) # |x| <= 1.5 log10(2)
+            if xsb
+                k = -1
+                r = LOG10_2U(T) + x
+                r = LOG10_2L(T) + r
+            else
+                k = 1
+                r = x - LOG10_2U(T)
+                r = r - LOG10_2L(T)
+            end
+        else
+            n = round(T(LOG2_10)*x)
+            k = unsafe_trunc(Int,n)
+            r = muladd(n, -LOG10_2U(T), x)
+            r = muladd(n, -LOG10_2L(T), r)
+        end
+        # compute approximation on reduced argument
+        y = exp10_kernel(r)
+        # scale back
+        if k > -significand_bits(T)
+            # multiply by 2.0 first to prevent overflow, extending the range
+            k == exponent_max(T) && return y * T(2.0) * T(2.0)^(exponent_max(T) - 1)
+            twopk = reinterpret(T, rem(exponent_bias(T) + k, fpinttype(T)) << significand_bits(T))
+            return y*twopk
+        else
+            # add significand_bits(T) + 1 to lift the range outside the subnormals
+            twopk = reinterpret(T, rem(exponent_bias(T) + significand_bits(T) + 1 + k, fpinttype(T)) << significand_bits(T))
+            return y * twopk * T(2.0)^(-significand_bits(T) - 1)
+        end
+    elseif xa < reinterpret(Unsigned, exp10_small_thres(T))  # |x| < exp10_small_thres
+        # Taylor approximation for small values: exp10(x) ≈ 1.0 + log(10)*x
+        return muladd(x, T(LN10), T(1.0))
+    else
+        # primary range with k = 0, so compute approximation directly
+        return exp10_kernel(x)
+    end
+end
diff --git a/base/special/gamma.jl b/base/special/gamma.jl
index 61952ce1edf229..b6b4539fb46fc3 100644
--- a/base/special/gamma.jl
+++ b/base/special/gamma.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 gamma(x::Float64) = nan_dom_err(ccall((:tgamma,libm),  Float64, (Float64,), x), x)
 gamma(x::Float32) = nan_dom_err(ccall((:tgammaf,libm),  Float32, (Float32,), x), x)
@@ -11,14 +11,14 @@ Compute the gamma function of `x`.
 gamma(x::Real) = gamma(float(x))
 
 function lgamma_r(x::Float64)
-    signp = Array{Int32}(1)
+    signp = Ref{Int32}()
     y = ccall((:lgamma_r,libm),  Float64, (Float64, Ptr{Int32}), x, signp)
-    return y, signp[1]
+    return y, signp[]
 end
 function lgamma_r(x::Float32)
-    signp = Array{Int32}(1)
+    signp = Ref{Int32}()
     y = ccall((:lgammaf_r,libm),  Float32, (Float32, Ptr{Int32}), x, signp)
-    return y, signp[1]
+    return y, signp[]
 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
@@ -27,15 +27,17 @@ lgamma_r(x::Number) = lgamma(x), 1 # lgamma does not take abs for non-real x
 """
     lfact(x)
 
-Compute the logarithmic factorial of `x`
+Compute the logarithmic factorial of a nonnegative integer `x`.
+Equivalent to [`lgamma`](@ref) of `x + 1`, but `lgamma` extends this function
+to non-integer `x`.
 """
-lfact(x::Real) = (x<=1 ? zero(float(x)) : lgamma(x+oneunit(x)))
+lfact(x::Integer) = x < 0 ? throw(DomainError(x, "`x` must be non-negative.")) : lgamma(x + oneunit(x))
 
 """
     lgamma(x)
 
 Compute the logarithm of the absolute value of [`gamma`](@ref) for
-`Real` `x`, while for `Complex` `x` it computes the
+[`Real`](@ref) `x`, while for [`Complex`](@ref) `x` compute the
 principal branch cut of the logarithm of `gamma(x)` (defined for negative `real(x)`
 by analytic continuation from positive `real(x)`).
 """
@@ -129,8 +131,8 @@ function lgamma(z::Complex{Float64})
     end
     return lgamma_asymptotic(Complex(x,y)) - shift
 end
-lgamma{T<:Union{Integer,Rational}}(z::Complex{T}) = lgamma(float(z))
-lgamma{T<:Union{Float32,Float16}}(z::Complex{T}) = Complex{T}(lgamma(Complex{Float64}(z)))
+lgamma(z::Complex{T}) where {T<:Union{Integer,Rational}} = lgamma(float(z))
+lgamma(z::Complex{T}) where {T<:Union{Float32,Float16}} = Complex{T}(lgamma(Complex{Float64}(z)))
 
 gamma(z::Complex) = exp(lgamma(z))
 
diff --git a/base/special/log.jl b/base/special/log.jl
index dc3473828335b5..e62ddf541705e4 100644
--- a/base/special/log.jl
+++ b/base/special/log.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Implementation of
 #  "Table-driven Implementation of the Logarithm Function in IEEE Floating-point Arithmetic"
@@ -282,7 +282,7 @@ function log(x::Float64)
     elseif isnan(x)
         NaN
     else
-        throw(DomainError())
+        throw_complex_domainerror(x, :log)
     end
 end
 
@@ -318,7 +318,7 @@ function log(x::Float32)
     elseif isnan(x)
         NaN32
     else
-        throw(DomainError())
+        throw_complex_domainerror(x, :log)
     end
 end
 
@@ -353,7 +353,7 @@ function log1p(x::Float64)
     elseif isnan(x)
         NaN
     else
-        throw(DomainError())
+        throw_complex_domainerror(x, :log1p)
     end
 end
 
@@ -386,7 +386,7 @@ function log1p(x::Float32)
     elseif isnan(x)
         NaN32
     else
-        throw(DomainError())
+        throw_complex_domainerror(x, :log1p)
     end
 end
 
diff --git a/base/special/rem_pio2.jl b/base/special/rem_pio2.jl
new file mode 100644
index 00000000000000..9d8f830c03f92a
--- /dev/null
+++ b/base/special/rem_pio2.jl
@@ -0,0 +1,294 @@
+# This file is a part of Julia. Except for the rem_pio2_kernel, and
+# cody_waite_* methods (see below) license is MIT: https://julialang.org/license
+
+# rem_pio2_kernel and cody_waite_* methods are heavily based on FDLIBM code:
+# __ieee754_rem_pio2, that is made available under the following licence:
+
+## Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+##
+## Developed at SunPro, a Sun Microsystems, Inc. business.
+## Permission to use, copy, modify, and distribute this
+## software is freely granted, provided that this notice
+## is preserved.
+
+# Bits of 1/2π
+#   1/2π == sum(x / 0x1p64^i for i,x = enumerate(INV_2PI))
+# Can be obtained by:
+#
+#    setprecision(BigFloat, 4096)
+#    I = 0.5/big(pi)
+#    for i = 1:19
+#        I *= 0x1p64
+#        k = trunc(UInt64, I)
+#        @printf "0x%016x,\n" k
+#        I -= k
+#    end
+const INV_2PI = UInt64[
+    0x28be_60db_9391_054a,
+    0x7f09_d5f4_7d4d_3770,
+    0x36d8_a566_4f10_e410,
+    0x7f94_58ea_f7ae_f158,
+    0x6dc9_1b8e_9093_74b8,
+    0x0192_4bba_8274_6487,
+    0x3f87_7ac7_2c4a_69cf,
+    0xba20_8d7d_4bae_d121,
+    0x3a67_1c09_ad17_df90,
+    0x4e64_758e_60d4_ce7d,
+    0x2721_17e2_ef7e_4a0e,
+    0xc7fe_25ff_f781_6603,
+    0xfbcb_c462_d682_9b47,
+    0xdb4d_9fb3_c9f2_c26d,
+    0xd3d1_8fd9_a797_fa8b,
+    0x5d49_eeb1_faf9_7c5e,
+    0xcf41_ce7d_e294_a4ba,
+    0x9afe_d7ec_47e3_5742,
+    0x1580_cc11_bf1e_daea]
+
+"""
+    highword(x)
+
+Return the high word of `x` as a `UInt32`.
+"""
+@inline highword(x::UInt64) = unsafe_trunc(UInt32,x >> 32)
+@inline highword(x::Float64) = highword(reinterpret(UInt64, x))
+
+"""
+    poshighword(x)
+
+Return positive part of the high word of `x` as a `UInt32`.
+"""
+@inline poshighword(x::UInt64) = unsafe_trunc(UInt32,x >> 32)&0x7fffffff
+@inline poshighword(x::Float64) = poshighword(reinterpret(UInt64, x))
+
+@inline function cody_waite_2c_pio2(x::Float64, fn, n)
+    pio2_1 = 1.57079632673412561417e+00
+    pio2_1t = 6.07710050650619224932e-11
+
+    z = muladd(-fn, pio2_1, x) # x - fn*pio2_1
+    y1 = muladd(-fn, pio2_1t, z) # z - fn*pio2_1t
+    y2 = muladd(-fn, pio2_1t, (z - y1)) # (z - y1) - fn*pio2_1t
+    n, DoubleFloat64(y1, y2)
+end
+
+@inline function cody_waite_ext_pio2(x::Float64, xhp)
+    pio2_1 = 1.57079632673412561417e+00
+    pio2_1t = 6.07710050650619224932e-11
+    pio2_2 = 6.07710050630396597660e-11
+    pio2_2t = 2.02226624879595063154e-21
+    pio2_3 = 2.02226624871116645580e-21
+    pio2_3t = 8.47842766036889956997e-32
+
+    fn = round(x*(2/pi)) # round to integer
+    # on older systems, the above could be faster with
+    # rf = 1.5/eps(Float64)
+    # fn = (x*(2/pi)+rf)-rf
+
+    r  = muladd(-fn, pio2_1, x) # x - fn*pio2_1
+    w  = fn*pio2_1t # 1st round good to 85 bit
+    j  = xhp>>20
+    y1 = r-w
+    high = highword(y1)
+    i = j-((high>>20)&0x7ff)
+    if i>16  # 2nd iteration needed, good to 118
+        t  = r
+        w  = fn*pio2_2
+        r  = t-w
+        w  = muladd(fn, pio2_2t,-((t-r)-w))
+        y1 = r-w
+        high = highword(y1)
+        i = j-((high>>20)&0x7ff)
+        if i>49 # 3rd iteration need, 151 bits acc
+            t  = r # will cover all possible cases
+            w  = fn*pio2_3
+            r  = t-w
+            w  = muladd(fn, pio2_3t, -((t-r)-w))
+            y1 = r-w
+        end
+    end
+    y2 = (r-y1)-w
+    return unsafe_trunc(Int, fn), DoubleFloat64(y1, y2)
+end
+
+"""
+    fromfraction(f::Int128)
+
+Compute a tuple of values `(z1,z2)` such that
+    ``z1 + z2 == f / 2^128``
+and the significand of `z1` has 27 trailing zeros.
+"""
+function fromfraction(f::Int128)
+    if f == 0
+        return (0.0,0.0)
+    end
+
+    # 1. get leading term truncated to 26 bits
+    s = ((f < 0) % UInt64) << 63     # sign bit
+    x = abs(f) % UInt128             # magnitude
+    n1 = 128-leading_zeros(x)         # ndigits0z(x,2)
+    m1 = ((x >> (n1-26)) % UInt64) << 27
+    d1 = ((n1-128+1021) % UInt64) << 52
+    z1 = reinterpret(Float64, s | (d1 + m1))
+
+    # 2. compute remaining term
+    x2 = (x - (UInt128(m1) << (n1-53)))
+    if x2 == 0
+        return (z1, 0.0)
+    end
+    n2 = 128-leading_zeros(x2)
+    m2 = (x2 >> (n2-53)) % UInt64
+    d2 = ((n2-128+1021) % UInt64) << 52
+    z2 = reinterpret(Float64,  s | (d2 + m2))
+    return (z1,z2)
+end
+
+function paynehanek(x::Float64)
+    # 1. Convert to form
+    #
+    #    x = X * 2^k,
+    #
+    # where 2^(n-1) <= X < 2^n  is an n-bit integer (n = 53, k = exponent(x)-52 )
+
+    # Computations are integer based, so reinterpret x as UInt64
+    u = reinterpret(UInt64, x)
+    # Strip x of exponent bits and replace with ^1
+    X = (u & significand_mask(Float64)) | (one(UInt64) << significand_bits(Float64))
+    # Get k from formula above
+    # k = exponent(x)-52
+    k = Int((u & exponent_mask(Float64)) >> significand_bits(Float64)) - exponent_bias(Float64) - significand_bits(Float64)
+
+    # 2. Let α = 1/2π, then:
+    #
+    #    α*x mod 1 ≡ [(α*2^k mod 1)*X] mod 1
+    #
+    # so we can ignore the first k bits of α. Extract the next 3 64-bit parts of α.
+    #
+    # i.e. equivalent to
+    #     setprecision(BigFloat,4096)
+    #     α  = 1/(2*big(pi))
+    #     A  = mod(ldexp(α,k), 1)
+    #     z1 = ldexp(A,64)
+    #     a1 = trunc(UInt64, z1)
+    #     z2 = ldexp(z1-a1, 64)
+    #     a2 = trunc(UInt64, z2)
+    #     z3 = ldexp(z2-a2, 64)
+    #     a3 = trunc(UInt64, z3)
+
+    # This is equivalent to
+    #     idx, shift = divrem(k, 64)
+    # but divrem is slower.
+    idx = k >> 6
+
+    shift = k - (idx << 6)
+    if shift == 0
+        @inbounds a1 = INV_2PI[idx+1]
+        @inbounds a2 = INV_2PI[idx+2]
+        @inbounds a3 = INV_2PI[idx+3]
+    else
+        # use shifts to extract the relevant 64 bit window
+        @inbounds a1 = (idx < 0 ? zero(UInt64) : INV_2PI[idx+1] << shift) | (INV_2PI[idx+2] >> (64 - shift))
+        @inbounds a2 = (INV_2PI[idx+2] << shift) | (INV_2PI[idx+3] >> (64 - shift))
+        @inbounds a3 = (INV_2PI[idx+3] << shift) | (INV_2PI[idx+4] >> (64 - shift))
+    end
+
+    # 3. Perform the multiplication:
+    #
+    #      X.  0  0  0
+    #   ×  0. a1 a2 a3
+    #   ==============
+    #      _.  w  w  _
+    #
+    # (i.e. ignoring integer and lowest bit parts of result)
+
+    w1 = UInt128(X*a1) << 64 # overflow becomes integer
+    w2 = widemul(X,a2)
+    w3 = widemul(X,a3) >> 64
+    w = w1 + w2 + w3         # quotient fraction after division by 2π
+
+    # adjust for sign of x
+    w = flipsign(w,x)
+
+    # 4. convert to quadrant, quotient fraction after division by π/2:
+    q = (((w>>125)%Int +1)>>1) # nearest quadrant
+    f = (w<<2) % Int128 # fraction part of quotient after division by π/2, taking values on [-0.5,0.5)
+
+    # 5. convert quotient fraction to split precision Float64
+    z_hi,z_lo = fromfraction(f)
+
+    # 6. multiply by π/2
+    pio2 = 1.5707963267948966
+    pio2_hi = 1.5707963407039642
+    pio2_lo = -1.3909067614167116e-8
+    y_hi = (z_hi+z_lo)*pio2
+    y_lo = (((z_hi*pio2_hi - y_hi) + z_hi*pio2_lo) + z_lo*pio2_hi) + z_lo*pio2_lo
+    return q, DoubleFloat64(y_hi, y_lo)
+end
+
+"""
+    rem_pio2_kernel(x, xhp)
+
+Return the remainder of `x` modulo π/2 as a double-double pair, along with a `k`
+such that ``k \\mod 3 == K \\mod 3`` where ``K*π/2 = x - rem``. Note, that it is
+only meant for use when ``|x|>=π/4``, and that ``π/2`` is always subtracted or
+added for ``π/4<|x|<=π/2`` instead of simply returning `x`.
+"""
+@inline function rem_pio2_kernel(x::Float64)
+    xhp = poshighword(x)
+    #  xhp <= highword(5pi/4) implies |x| ~<= 5pi/4,
+    if xhp <= 0x400f6a7a
+        #  last five bits of xhp == last five bits of highword(pi/2) or
+        #  highword(2pi/2) implies |x| ~= pi/2 or 2pi/2,
+        if (xhp & 0xfffff) == 0x921fb # use precise Cody Waite scheme
+            return cody_waite_ext_pio2(x, xhp)
+        end
+        # use Cody Waite with two constants
+        #  xhp <= highword(3pi/4) implies |x| ~<= 3pi/4
+        if xhp <= 0x4002d97c
+            if x > 0.0
+                return cody_waite_2c_pio2(x, 1.0, 1)
+            else
+                return cody_waite_2c_pio2(x, -1.0, -1)
+            end
+        # 3pi/4 < |x| <= 5pi/4
+        else
+            if x > 0.0
+                return cody_waite_2c_pio2(x, 2.0, 2)
+            else
+                return cody_waite_2c_pio2(x, -2.0, -2)
+            end
+        end
+    end
+    #  xhp <= highword(9pi/4) implies |x| ~<= 9pi/4
+    if xhp <= 0x401c463b
+        #  xhp <= highword(7pi/4) implies |x| ~<= 7pi/4
+        if xhp <= 0x4015fdbc
+            #  xhp == highword(3pi/2) implies |x| ~= 3pi/2
+            if xhp == 0x4012d97c # use precise Cody Waite scheme
+                return cody_waite_ext_pio2(x, xhp)
+            end
+            # use Cody Waite with two constants
+            if x > 0.0
+                return cody_waite_2c_pio2(x, 3.0, 3)
+            else
+                return cody_waite_2c_pio2(x, -3.0, -3)
+            end
+        # 7pi/4 < |x| =< 9pi/4
+        else
+            #  xhp == highword(4pi/2) implies |x| ~= 4pi/2
+            if xhp == 0x401921fb # use precise Cody Waite scheme
+                return cody_waite_ext_pio2(x, xhp)
+            end
+            # use Cody Waite with two constants
+            if x > 0.0
+                return cody_waite_2c_pio2(x, 4.0, 4)
+            else
+                return cody_waite_2c_pio2(x, -4.0, -4)
+            end
+        end
+    end
+    #  xhp < highword(2.0^20*pi/2) implies |x| ~< 2^20*pi/2
+    if xhp < 0x413921fb # use precise Cody Waite scheme
+        return cody_waite_ext_pio2(x, xhp)
+    end
+    # if |x| >= 2^20*pi/2 switch to Payne Hanek
+    return paynehanek(x)
+end
diff --git a/base/special/trig.jl b/base/special/trig.jl
index 80a0d9073bf610..6c1c81c300d932 100644
--- a/base/special/trig.jl
+++ b/base/special/trig.jl
@@ -1,5 +1,5 @@
 # This file is a part of Julia. Except for the *_kernel functions (see below),
-# license is MIT: http://julialang.org/license
+# license is MIT: https://julialang.org/license
 
 struct DoubleFloat64
     hi::Float64
@@ -103,10 +103,10 @@ mulpi_ext(x::Real) = pi*x # Fallback
 
 Compute ``\\sin(\\pi x)`` more accurately than `sin(pi*x)`, especially for large `x`.
 """
-function sinpi{T<:AbstractFloat}(x::T)
+function sinpi(x::T) where T<:AbstractFloat
     if !isfinite(x)
         isnan(x) && return x
-        throw(DomainError())
+        throw(DomainError(x, "`x` cannot be infinite."))
     end
 
     ax = abs(x)
@@ -132,11 +132,11 @@ function sinpi{T<:AbstractFloat}(x::T)
     end
 end
 
-# Rationals and other Real types
-function sinpi{T<:Real}(x::T)
-    Tf = typeof(float(x))
+# Integers and Rationals
+function sinpi(x::T) where T<:Union{Integer,Rational}
+    Tf = float(T)
     if !isfinite(x)
-        throw(DomainError())
+        throw(DomainError(x, "`x` must be finite."))
     end
 
     # until we get an IEEE remainder function (#9283)
@@ -166,10 +166,10 @@ end
 
 Compute ``\\cos(\\pi x)`` more accurately than `cos(pi*x)`, especially for large `x`.
 """
-function cospi{T<:AbstractFloat}(x::T)
+function cospi(x::T) where T<:AbstractFloat
     if !isfinite(x)
         isnan(x) && return x
-        throw(DomainError())
+        throw(DomainError(x, "`x` cannot be infinite."))
     end
 
     ax = abs(x)
@@ -191,10 +191,10 @@ function cospi{T<:AbstractFloat}(x::T)
     end
 end
 
-# Rationals and other Real types
-function cospi{T<:Real}(x::T)
+# Integers and Rationals
+function cospi(x::T) where T<:Union{Integer,Rational}
     if !isfinite(x)
-        throw(DomainError())
+        throw(DomainError(x, "`x` must be finite."))
     end
 
     ax = abs(x)
@@ -217,8 +217,10 @@ end
 
 sinpi(x::Integer) = x >= 0 ? zero(float(x)) : -zero(float(x))
 cospi(x::Integer) = isodd(x) ? -one(float(x)) : one(float(x))
+sinpi(x::Real) = sinpi(float(x))
+cospi(x::Real) = cospi(float(x))
 
-function sinpi{T}(z::Complex{T})
+function sinpi(z::Complex{T}) where T
     F = float(T)
     zr, zi = reim(z)
     if isinteger(zr)
@@ -250,7 +252,7 @@ function sinpi{T}(z::Complex{T})
     end
 end
 
-function cospi{T}(z::Complex{T})
+function cospi(z::Complex{T}) where T
     F = float(T)
     zr, zi = reim(z)
     if isinteger(zr)
@@ -292,7 +294,8 @@ Compute ``\\sin(\\pi x) / (\\pi x)`` if ``x \\neq 0``, and ``1`` if ``x = 0``.
 """
 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::Complex{<:AbstractFloat}) = x==0 ? one(x) : oftype(x, sinpi(x)/(pi*x))
+sinc(x::Complex) = sinc(float(x))
 sinc(x::Real) = x==0 ? one(x) : isinf(x) ? zero(x) : sinpi(x)/(pi*x)
 
 """
@@ -303,14 +306,32 @@ Compute ``\\cos(\\pi x) / x - \\sin(\\pi x) / (\\pi x^2)`` if ``x \\neq 0``, and
 """
 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::Complex{<:AbstractFloat}) = x==0 ? zero(x) : oftype(x,(cospi(x)-sinpi(x)/(pi*x))/x)
+cosc(x::Complex) = cosc(float(x))
 cosc(x::Real) = x==0 || isinf(x) ? zero(x) : (cospi(x)-sinpi(x)/(pi*x))/x
 
-for (finv, f) in ((:sec, :cos), (:csc, :sin), (:cot, :tan),
-                  (:sech, :cosh), (:csch, :sinh), (:coth, :tanh),
-                  (:secd, :cosd), (:cscd, :sind), (:cotd, :tand))
+for (finv, f, finvh, fh, finvd, fd, fn) in ((:sec, :cos, :sech, :cosh, :secd, :cosd, "secant"),
+                                            (:csc, :sin, :csch, :sinh, :cscd, :sind, "cosecant"),
+                                            (:cot, :tan, :coth, :tanh, :cotd, :tand, "cotangent"))
+    name = string(finv)
+    hname = string(finvh)
+    dname = string(finvd)
     @eval begin
-        ($finv){T<:Number}(z::T) = one(T) / (($f)(z))
+        @doc """
+            $($name)(x)
+
+        Compute the $($fn) of `x`, where `x` is in radians.
+        """ ($finv)(z::T) where {T<:Number} = one(T) / (($f)(z))
+        @doc """
+            $($hname)(x)
+
+        Compute the hyperbolic $($fn) of `x`.
+        """ ($finvh)(z::T) where {T<:Number} = one(T) / (($fh)(z))
+        @doc """
+            $($dname)(x)
+
+        Compute the $($fn) of `x`, where `x` is in degrees.
+        """ ($finvd)(z::T) where {T<:Number} = one(T) / (($fd)(z))
     end
 end
 
@@ -322,10 +343,10 @@ for (tfa, tfainv, hfa, hfainv, fn) in ((:asec, :acos, :asech, :acosh, "secant"),
     @eval begin
         @doc """
             $($tname)(x)
-        Compute the inverse $($fn) of `x`, where the output is in radians. """ ($tfa){T<:Number}(y::T) = ($tfainv)(one(T) / y)
+        Compute the inverse $($fn) of `x`, where the output is in radians. """ ($tfa)(y::T) where {T<:Number} = ($tfainv)(one(T) / y)
         @doc """
             $($hname)(x)
-        Compute the inverse hyperbolic $($fn) of `x`. """ ($hfa){T<:Number}(y::T) = ($hfainv)(one(T) / y)
+        Compute the inverse hyperbolic $($fn) of `x`. """ ($hfa)(y::T) where {T<:Number} = ($hfainv)(one(T) / y)
     end
 end
 
@@ -350,7 +371,7 @@ deg2rad_ext(x::Real) = deg2rad(x) # Fallback
 
 function sind(x::Real)
     if isinf(x)
-        return throw(DomainError())
+        return throw(DomainError(x, "`x` cannot be infinite."))
     elseif isnan(x)
         return oftype(x,NaN)
     end
@@ -381,7 +402,7 @@ end
 
 function cosd(x::Real)
     if isinf(x)
-        return throw(DomainError())
+        return throw(DomainError(x, "`x` cannot be infinite."))
     elseif isnan(x)
         return oftype(x,NaN)
     end
diff --git a/base/stacktraces.jl b/base/stacktraces.jl
index a7d9af70379999..8fbe116a6270c7 100644
--- a/base/stacktraces.jl
+++ b/base/stacktraces.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module StackTraces
 
@@ -37,7 +37,7 @@ Stack information representing execution context, with the following fields:
 
   True if the code is from an inlined frame.
 
-- `pointer::Int64`
+- `pointer::UInt64`
 
   Representation of the pointer to the execution context as returned by `backtrace`.
 
@@ -124,7 +124,7 @@ inlined at that point, innermost function first.
 function lookup(pointer::Ptr{Void})
     infos = ccall(:jl_lookup_code_address, Any, (Ptr{Void}, Cint), pointer - 1, false)
     isempty(infos) && return [StackFrame(empty_sym, empty_sym, -1, Nullable{Core.MethodInstance}(), true, false, convert(UInt64, pointer))]
-    res = Array{StackFrame}(length(infos))
+    res = Vector{StackFrame}(length(infos))
     for i in 1:length(infos)
         info = infos[i]
         @assert(length(info) == 7)
@@ -136,6 +136,10 @@ end
 
 lookup(pointer::UInt) = lookup(convert(Ptr{Void}, pointer))
 
+# allow lookup on already-looked-up data for easier handling of pre-processed frames
+lookup(s::StackFrame) = StackFrame[s]
+lookup(s::Tuple{StackFrame,Int}) = StackFrame[s[1]]
+
 """
     stacktrace([trace::Vector{Ptr{Void}},] [c_funcs::Bool=false]) -> StackTrace
 
@@ -190,6 +194,16 @@ function remove_frames!(stack::StackTrace, names::Vector{Symbol})
     return stack
 end
 
+"""
+    remove_frames!(stack::StackTrace, m::Module)
+
+Returns the `StackTrace` with all `StackFrame`s from the provided `Module` removed.
+"""
+function remove_frames!(stack::StackTrace, m::Module)
+    filter!(f -> !from(f, m), stack)
+    return stack
+end
+
 function show_spec_linfo(io::IO, frame::StackFrame)
     if isnull(frame.linfo)
         if frame.func === empty_sym
@@ -199,8 +213,8 @@ function show_spec_linfo(io::IO, frame::StackFrame)
         end
     else
         linfo = get(frame.linfo)
-        if isdefined(linfo, :def)
-            Base.show_lambda_types(io, linfo)
+        if isa(linfo.def, Method)
+            Base.show_tuple_as_call(io, linfo.def.name, linfo.specTypes)
         else
             Base.show(io, linfo)
         end
@@ -226,4 +240,22 @@ function show(io::IO, frame::StackFrame; full_path::Bool=false)
     end
 end
 
+"""
+    from(frame::StackFrame, filter_mod::Module) -> Bool
+
+Returns whether the `frame` is from the provided `Module`
+"""
+function from(frame::StackFrame, m::Module)
+    finfo = frame.linfo
+    result = false
+
+    if !isnull(finfo)
+        frame_m = get(finfo).def
+        isa(frame_m, Method) && (frame_m = frame_m.module)
+        result = module_name(frame_m) === module_name(m)
+    end
+
+    return result
+end
+
 end
diff --git a/base/stat.jl b/base/stat.jl
index d6922fc626572c..0de651cd9f6dee 100644
--- a/base/stat.jl
+++ b/base/stat.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # filesystem operations
 
@@ -57,11 +57,11 @@ 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(filemode(st),6)), size=$(filesize(st)))")
+show(io::IO, st::StatStruct) = print(io, "StatStruct(mode=0o$(oct(filemode(st),6)), size=$(filesize(st)))")
 
 # stat & lstat functions
 
-const stat_buf = Array{UInt8}(ccall(:jl_sizeof_stat, Int32, ()))
+const stat_buf = Vector{UInt8}(ccall(:jl_sizeof_stat, Int32, ()))
 macro stat_call(sym, arg1type, arg)
     quote
         fill!(stat_buf,0)
diff --git a/base/statistics.jl b/base/statistics.jl
index 16528d73bd600c..e0e5a3ea2da156 100644
--- a/base/statistics.jl
+++ b/base/statistics.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ##### mean #####
 
@@ -35,16 +35,34 @@ mean(iterable) = mean(identity, iterable)
 mean(f::Callable, A::AbstractArray) = sum(f, A) / _length(A)
 mean(A::AbstractArray) = sum(A) / _length(A)
 
+"""
+    mean!(r, v)
+
+Compute the mean of `v` over the singleton dimensions of `r`, and write results to `r`.
+
+# Examples
+```jldoctest
+julia> v = [1 2; 3 4]
+2×2 Array{Int64,2}:
+ 1  2
+ 3  4
+
+julia> mean!([1., 1.], v)
+2-element Array{Float64,1}:
+ 1.5
+ 3.5
+
+julia> mean!([1. 1.], v)
+1×2 Array{Float64,2}:
+ 2.0  3.0
+```
+"""
 function mean!(R::AbstractArray, A::AbstractArray)
     sum!(R, A; init=true)
     scale!(R, _length(R) / _length(A))
     return R
 end
 
-momenttype{T}(::Type{T}) = typeof((zero(T)*zero(T) + zero(T)*zero(T)) / 2)
-momenttype(::Type{Float32}) = Float32
-momenttype(::Type{<:Union{Float64,Int32,Int64,UInt32,UInt64}}) = Float64
-
 """
     mean(v[, region])
 
@@ -54,9 +72,8 @@ Compute the mean of whole array `v`, or optionally along the dimensions in `regi
     Julia does not ignore `NaN` values in the computation. For applications requiring the
     handling of missing data, the `DataArrays.jl` package is recommended.
 """
-mean{T}(A::AbstractArray{T}, region) =
-    mean!(reducedim_initarray(A, region, 0, momenttype(T)), A)
-
+mean(A::AbstractArray{T}, region) where {T} =
+    mean!(reducedim_init(t -> t/2, +, A, region), A)
 
 ##### variances #####
 
@@ -108,7 +125,7 @@ centralize_sumabs2(A::AbstractArray, m::Number) =
 centralize_sumabs2(A::AbstractArray, m::Number, ifirst::Int, ilast::Int) =
     mapreduce_impl(centralizedabs2fun(m), +, A, ifirst, ilast)
 
-function centralize_sumabs2!{S}(R::AbstractArray{S}, A::AbstractArray, means::AbstractArray)
+function centralize_sumabs2!(R::AbstractArray{S}, A::AbstractArray, means::AbstractArray) where S
     # following the implementation of _mapreducedim! at base/reducedim.jl
     lsiz = check_reducedims(R,A)
     isempty(R) || fill!(R, zero(S))
@@ -147,19 +164,18 @@ function centralize_sumabs2!{S}(R::AbstractArray{S}, A::AbstractArray, means::Ab
     return R
 end
 
-function varm{T}(A::AbstractArray{T}, m::Number; corrected::Bool=true)
+function varm(A::AbstractArray{T}, m::Number; corrected::Bool=true) where T
     n = _length(A)
-    n == 0 && return convert(real(momenttype(T)), NaN)
-    n == 1 && return convert(real(momenttype(T)), abs2(A[1] - m)/(1 - Int(corrected)))
+    n == 0 && return typeof((abs2(zero(T)) + abs2(zero(T)))/2)(NaN)
     return centralize_sumabs2(A, m) / (n - Int(corrected))
 end
 
-function varm!{S}(R::AbstractArray{S}, A::AbstractArray, m::AbstractArray; corrected::Bool=true)
+function varm!(R::AbstractArray{S}, A::AbstractArray, m::AbstractArray; corrected::Bool=true) where S
     if isempty(A)
         fill!(R, convert(S, NaN))
     else
         rn = div(_length(A), _length(R)) - Int(corrected)
-        scale!(centralize_sumabs2!(R, A, m), convert(S, 1/rn))
+        scale!(centralize_sumabs2!(R, A, m), one(S)/rn)
     end
     return R
 end
@@ -177,13 +193,12 @@ whereas the sum is scaled with `n` if `corrected` is `false` where `n = length(x
     applications requiring the handling of missing data, the
     `DataArrays.jl` package is recommended.
 """
-varm{T}(A::AbstractArray{T}, m::AbstractArray, region; corrected::Bool=true) =
-    varm!(reducedim_initarray(A, region, 0, real(momenttype(T))), A, m; corrected=corrected)
+varm(A::AbstractArray{T}, m::AbstractArray, region; corrected::Bool=true) where {T} =
+    varm!(reducedim_init(t -> abs2(t)/2, +, A, region), A, m; corrected=corrected)
 
 
-var{T}(A::AbstractArray{T}; corrected::Bool=true, mean=nothing) =
-    convert(real(momenttype(T)),
-            varm(A, mean === nothing ? Base.mean(A) : mean; corrected=corrected))
+var(A::AbstractArray{T}; corrected::Bool=true, mean=nothing) where {T} =
+    real(varm(A, mean === nothing ? Base.mean(A) : mean; corrected=corrected))
 
 """
     var(v[, region]; corrected::Bool=true, mean=nothing)
@@ -210,22 +225,24 @@ varm(iterable, m::Number; corrected::Bool=true) =
 ## variances over ranges
 
 function varm(v::Range, m::Number)
-    f = first(v) - m
-    s = step(v)
-    l = length(v)
+    f  = first(v) - m
+    s  = step(v)
+    l  = length(v)
+    vv = f^2 * l / (l - 1) + f * s * l + s^2 * l * (2 * l - 1) / 6
     if l == 0 || l == 1
-           return NaN
+        return typeof(vv)(NaN)
     end
-    return f^2 * l / (l - 1) + f * s * l + s^2 * l * (2 * l - 1) / 6
+    return vv
 end
 
 function var(v::Range)
-    s = step(v)
-    l = length(v)
+    s  = step(v)
+    l  = length(v)
+    vv = abs2(s) * (l + 1) * l / 12
     if l == 0 || l == 1
-        return NaN
+        return typeof(vv)(NaN)
     end
-    return abs2(s) * (l + 1) * l / 12
+    return vv
 end
 
 
@@ -307,7 +324,7 @@ _vmean(x::AbstractMatrix, vardim::Int) = mean(x, vardim)
 unscaled_covzm(x::AbstractVector) = sum(abs2, x)
 unscaled_covzm(x::AbstractMatrix, vardim::Int) = (vardim == 1 ? _conj(x'x) : x * x')
 
-unscaled_covzm(x::AbstractVector, y::AbstractVector) = dot(x, y)
+unscaled_covzm(x::AbstractVector, y::AbstractVector) = dot(y, x)
 unscaled_covzm(x::AbstractVector, y::AbstractMatrix, vardim::Int) =
     (vardim == 1 ? At_mul_B(x, _conj(y)) : At_mul_Bt(x, _conj(y)))
 unscaled_covzm(x::AbstractMatrix, y::AbstractVector, vardim::Int) =
@@ -317,89 +334,87 @@ unscaled_covzm(x::AbstractMatrix, y::AbstractMatrix, vardim::Int) =
 
 # covzm (with centered data)
 
-covzm(x::AbstractVector, corrected::Bool=true) = unscaled_covzm(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)
-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; corrected::Bool=true) =
+    covzm(x .- xmean; corrected=corrected)
+covm(x::AbstractMatrix, xmean, vardim::Int=1; corrected::Bool=true) =
+    covzm(x .- xmean, vardim; corrected=corrected)
+covm(x::AbstractVector, xmean, y::AbstractVector, ymean; corrected::Bool=true) =
+    covzm(x .- xmean, y .- ymean; corrected=corrected)
+covm(x::AbstractVecOrMat, xmean, y::AbstractVecOrMat, ymean, vardim::Int=1; corrected::Bool=true) =
+    covzm(x .- xmean, y .- ymean, vardim; corrected=corrected)
 
 # cov (API)
 """
-    cov(x[, corrected=true])
+    cov(x::AbstractVector; corrected::Bool=true)
 
 Compute the variance of the vector `x`. If `corrected` is `true` (the default) then the sum
 is scaled with `n-1`, whereas 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(x::AbstractVector) = covm(x, Base.mean(x), true)
+cov(x::AbstractVector; corrected::Bool=true) = covm(x, Base.mean(x); corrected=corrected)
 
 """
-    cov(X[, vardim=1, corrected=true])
+    cov(X::AbstractMatrix[, vardim::Int=1]; corrected::Bool=true)
 
 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`, whereas 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(X::AbstractMatrix) = cov(X, 1, true)
+cov(X::AbstractMatrix, vardim::Int=1; corrected::Bool=true) =
+    covm(X, _vmean(X, vardim), vardim; corrected=corrected)
 
 """
-    cov(x, y[, corrected=true])
+    cov(x::AbstractVector, y::AbstractVector; corrected::Bool=true)
 
-Compute the covariance between the vectors `x` and `y`. If `corrected` is `true` (the default)
-then the sum is scaled with `n-1`, whereas the sum is scaled with `n` if `corrected` is `false`
-where `n = length(x) = length(y)`.
+Compute the covariance between the vectors `x` and `y`. If `corrected` is `true` (the
+default), computes ``\\frac{1}{n-1}\\sum_{i=1}^n (x_i-\\bar x) (y_i-\\bar y)^*`` where
+``*`` denotes the complex conjugate and `n = length(x) = length(y)`. If `corrected` is
+`false`, computes ``\\frac{1}{n}\\sum_{i=1}^n (x_i-\\bar x) (y_i-\\bar 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(x::AbstractVector, y::AbstractVector) =
-    covm(x, Base.mean(x), y, Base.mean(y), true)
+cov(x::AbstractVector, y::AbstractVector; corrected::Bool=true) =
+    covm(x, Base.mean(x), y, Base.mean(y); corrected=corrected)
 
 """
-    cov(X, Y[, vardim=1, corrected=true])
+    cov(X::AbstractVecOrMat, Y::AbstractVecOrMat[, vardim::Int=1]; corrected::Bool=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`, whereas
 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)
+cov(X::AbstractVecOrMat, Y::AbstractVecOrMat, vardim::Int=1; corrected::Bool=true) =
+    covm(X, _vmean(X, vardim), Y, _vmean(Y, vardim), vardim; corrected=corrected)
 
 ##### correlation #####
 
+"""
+    clampcor(x)
+
+Clamp a real correlation to between -1 and 1, leaving complex correlations unchanged
+"""
+clampcor(x::Real) = clamp(x, -1, 1)
+clampcor(x) = x
+
 # cov2cor!
 
-function cov2cor!{T}(C::AbstractMatrix{T}, xsd::AbstractArray)
+function cov2cor!(C::AbstractMatrix{T}, xsd::AbstractArray) where T
     nx = length(xsd)
     size(C) == (nx, nx) || throw(DimensionMismatch("inconsistent dimensions"))
     for j = 1:nx
         for i = 1:j-1
-            C[i,j] = C[j,i]
+            C[i,j] = C[j,i]'
         end
         C[j,j] = oneunit(T)
         for i = j+1:nx
-            C[i,j] = clamp(C[i,j] / (xsd[i] * xsd[j]), -1, 1)
+            C[i,j] = clampcor(C[i,j] / (xsd[i] * xsd[j]))
         end
     end
     return C
@@ -409,7 +424,7 @@ function cov2cor!(C::AbstractMatrix, xsd::Number, ysd::AbstractArray)
     length(ysd) == ny || throw(DimensionMismatch("inconsistent dimensions"))
     for (j, y) in enumerate(ysd)   # fixme (iter): here and in all `cov2cor!` we assume that `C` is efficiently indexed by integers
         for i in 1:nx
-            C[i,j] = clamp(C[i, j] / (xsd * y), -1, 1)
+            C[i,j] = clampcor(C[i, j] / (xsd * y))
         end
     end
     return C
@@ -419,7 +434,7 @@ function cov2cor!(C::AbstractMatrix, xsd::AbstractArray, ysd::Number)
     length(xsd) == nx || throw(DimensionMismatch("inconsistent dimensions"))
     for j in 1:ny
         for (i, x) in enumerate(xsd)
-            C[i,j] = clamp(C[i,j] / (x * ysd), -1, 1)
+            C[i,j] = clampcor(C[i,j] / (x * ysd))
         end
     end
     return C
@@ -430,7 +445,7 @@ function cov2cor!(C::AbstractMatrix, xsd::AbstractArray, ysd::AbstractArray)
         throw(DimensionMismatch("inconsistent dimensions"))
     for (i, x) in enumerate(xsd)
         for (j, y) in enumerate(ysd)
-            C[i,j] = clamp(C[i,j] / (x * y), -1, 1)
+            C[i,j] = clampcor(C[i,j] / (x * y))
         end
     end
     return C
@@ -438,7 +453,7 @@ end
 
 # corzm (non-exported, with centered data)
 
-corzm{T}(x::AbstractVector{T}) = one(real(T))
+corzm(x::AbstractVector{T}) where {T} = one(real(T))
 function corzm(x::AbstractMatrix, vardim::Int=1)
     c = unscaled_covzm(x, vardim)
     return cov2cor!(c, sqrt!(diag(c)))
@@ -452,7 +467,7 @@ corzm(x::AbstractMatrix, y::AbstractMatrix, vardim::Int=1) =
 
 # corm
 
-corm{T}(x::AbstractVector{T}, xmean) = one(real(T))
+corm(x::AbstractVector{T}, xmean) where {T} = one(real(T))
 corm(x::AbstractMatrix, xmean, vardim::Int=1) = corzm(x .- xmean, vardim)
 function corm(x::AbstractVector, mx::Number, y::AbstractVector, my::Number)
     n = length(x)
@@ -461,11 +476,11 @@ function corm(x::AbstractVector, mx::Number, y::AbstractVector, my::Number)
 
     @inbounds begin
         # Initialize the accumulators
-        xx = zero(sqrt(x[1] * x[1]))
-        yy = zero(sqrt(y[1] * y[1]))
-        xy = zero(xx * yy)
+        xx = zero(sqrt(abs2(x[1])))
+        yy = zero(sqrt(abs2(y[1])))
+        xy = zero(x[1] * y[1]')
 
-        @simd for i = 1:n
+        @simd for i in eachindex(x, y)
             xi = x[i] - mx
             yi = y[i] - my
             xx += abs2(xi)
@@ -473,48 +488,41 @@ function corm(x::AbstractVector, mx::Number, y::AbstractVector, my::Number)
             xy += xi * yi'
         end
     end
-    return clamp(xy / max(xx, yy) / sqrt(min(xx, yy) / max(xx, yy)), -1, 1)
+    return clampcor(xy / max(xx, yy) / sqrt(min(xx, yy) / max(xx, yy)))
 end
+
 corm(x::AbstractVecOrMat, xmean, y::AbstractVecOrMat, ymean, vardim::Int=1) =
     corzm(x .- xmean, y .- ymean, vardim)
 
 # cor
 """
-    cor(x)
+    cor(x::AbstractVector)
 
 Return the number one.
 """
 cor(x::AbstractVector) = 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
 
 """
-    cor(X[, vardim=1])
+    cor(X::AbstractMatrix[, vardim::Int=1])
 
 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(X::AbstractMatrix) = cor(X, 1)
+cor(X::AbstractMatrix, vardim::Int=1) = corm(X, _vmean(X, vardim), vardim)
 
 """
-    cor(x, y)
+    cor(x::AbstractVector, y::AbstractVector)
 
 Compute the Pearson correlation between the vectors `x` and `y`.
 """
 cor(x::AbstractVector, y::AbstractVector) = 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])
+    cor(X::AbstractVecOrMat, Y::AbstractVecOrMat[, 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) =
+cor(x::AbstractVecOrMat, y::AbstractVecOrMat, vardim::Int=1) =
     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 #####
 
@@ -592,7 +600,7 @@ function median!(v::AbstractVector)
     end
 end
 median!(v::AbstractArray) = median!(vec(v))
-median{T}(v::AbstractArray{T}) = median!(copy!(Array{T,1}(_length(v)), v))
+median(v::AbstractArray{T}) where {T} = median!(copy!(Array{T,1}(_length(v)), v))
 
 """
     median(v[, region])
@@ -613,10 +621,11 @@ median(v::AbstractArray, region) = mapslices(median!, v, region)
 """
     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.
+Compute the quantile(s) of a vector `v` at the probability or probabilities `p`, which
+can be given as a single value, a vector, or a tuple. If `p` is a vector, an optional
+output array `q` may also be specified. (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.
@@ -638,19 +647,10 @@ function quantile!(q::AbstractArray, v::AbstractVector, p::AbstractArray;
     if size(p) != size(q)
         throw(DimensionMismatch("size of p, $(size(p)), must equal size of q, $(size(q))"))
     end
+    isempty(q) && return q
 
-    isempty(v) && throw(ArgumentError("empty data vector"))
-
-    lv = length(v)
-    if !sorted
-        minp, maxp = extrema(p)
-        lo = floor(Int,1+minp*(lv-1))
-        hi = ceil(Int,1+maxp*(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"))
+    minp, maxp = extrema(p)
+    _quantilesort!(v, sorted, minp, maxp)
 
     for (i, j) in zip(eachindex(p), eachindex(q))
         @inbounds q[j] = _quantile(v,p[i])
@@ -661,44 +661,53 @@ end
 quantile!(v::AbstractVector, p::AbstractArray; sorted::Bool=false) =
     quantile!(similar(p,float(eltype(v))), v, p; sorted=sorted)
 
-function quantile!(v::AbstractVector, p::Real;
-                   sorted::Bool=false)
+quantile!(v::AbstractVector, p::Real; sorted::Bool=false) =
+    _quantile(_quantilesort!(v, sorted, p, p), p)
+
+function quantile!(v::AbstractVector, p::Tuple{Vararg{Real}}; sorted::Bool=false)
+    isempty(p) && return ()
+    minp, maxp = extrema(p)
+    _quantilesort!(v, sorted, minp, maxp)
+    return map(x->_quantile(v, x), p)
+end
+
+# Function to perform partial sort of v for quantiles in given range
+function _quantilesort!(v::AbstractArray, sorted::Bool, minp::Real, maxp::Real)
     isempty(v) && throw(ArgumentError("empty data vector"))
 
-    lv = length(v)
     if !sorted
-        lo = floor(Int,1+p*(lv-1))
-        hi = ceil(Int,1+p*(lv-1))
+        lv = length(v)
+        lo = floor(Int,1+minp*(lv-1))
+        hi = ceil(Int,1+maxp*(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)
+    return v
 end
 
 # Core quantile lookup function: assumes `v` sorted
 @inline function _quantile(v::AbstractVector, p::Real)
-    T = float(eltype(v))
-    isnan(p) && return T(NaN)
     0 <= p <= 1 || throw(ArgumentError("input probability out of [0,1] range"))
 
     lv = length(v)
-    f0 = (lv-1)*p # 0-based interpolated index
+    f0 = (lv - 1)*p # 0-based interpolated index
     t0 = trunc(f0)
-    h = f0 - t0
-    i = trunc(Int,t0) + 1
+    h  = f0 - t0
+    i  = trunc(Int,t0) + 1
+
+    T  = promote_type(eltype(v), typeof(v[1]*h))
 
     if h == 0
         return T(v[i])
     else
-        a = T(v[i])
-        b = T(v[i+1])
+        a = v[i]
+        b = v[i+1]
         if isfinite(a) && isfinite(b)
-            return a + h*(b-a)
+            return T(a + h*(b-a))
         else
-            return (1-h)*a + h*b
+            return T((1-h)*a + h*b)
         end
     end
 end
@@ -707,8 +716,9 @@ 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.
+Compute the quantile(s) of a vector `v` at a specified probability or vector or tuple of
+probabilities `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.
 
@@ -721,7 +731,7 @@ for `k = 1:n` where `n = length(v)`. This corresponds to Definition 7 of Hyndman
     handling of missing data, the `DataArrays.jl` package is recommended. `quantile` will
     throw an `ArgumentError` in the presence of `NaN` values in the data array.
 
-* Hyndman, R.J and Fan, Y. (1996) "Sample Quantiles in Statistical Packages",
+- 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) =
diff --git a/base/stream.jl b/base/stream.jl
index b695ac664cb8af..dc41a701a8f734 100644
--- a/base/stream.jl
+++ b/base/stream.jl
@@ -1,7 +1,7 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 import .Libc: RawFD, dup
-if is_windows()
+if Sys.iswindows()
     import .Libc: WindowsRawSocket
 end
 
@@ -11,7 +11,7 @@ abstract type LibuvServer <: IOServer end
 abstract type LibuvStream <: IO end
 
 # IO
-# +- AbstractIOBuffer{T<:AbstractArray{UInt8,1}} (not exported)
+# +- GenericIOBuffer{T<:AbstractArray{UInt8,1}} (not exported)
 # +- AbstractPipe (not exported)
 # .  +- Pipe
 # .  +- Process (not exported)
@@ -26,7 +26,7 @@ abstract type LibuvStream <: IO end
 # .  +- TCPSocket
 # .  +- TTY (not exported)
 # .  +- UDPSocket
-# +- IOBuffer = Base.AbstractIOBuffer{Array{UInt8,1}}
+# +- IOBuffer = Base.GenericIOBuffer{Array{UInt8,1}}
 # +- IOStream
 
 # IOServer
@@ -159,7 +159,7 @@ mutable struct TTY <: LibuvStream
     sendbuf::Nullable{IOBuffer}
     lock::ReentrantLock
     throttle::Int
-    @static if is_windows(); ispty::Bool; end
+    @static if Sys.iswindows(); ispty::Bool; end
     TTY() = TTY(Libc.malloc(_sizeof_uv_tty), StatusUninit)
     function TTY(handle::Ptr{Void}, status)
         tty = new(
@@ -172,7 +172,7 @@ mutable struct TTY <: LibuvStream
             DEFAULT_READ_BUFFER_SZ)
         associate_julia_struct(handle, tty)
         finalizer(tty, uvfinalize)
-        @static if is_windows()
+        @static if Sys.iswindows()
             tty.ispty = ccall(:jl_ispty, Cint, (Ptr{Void},), handle) != 0
         end
         return tty
@@ -343,7 +343,7 @@ function uvfinalize(uv::Union{LibuvStream, LibuvServer})
     nothing
 end
 
-if is_windows()
+if Sys.iswindows()
     ispty(s::TTY) = s.ispty
     ispty(s::IO) = false
 end
@@ -358,11 +358,11 @@ function displaysize(io::TTY)
     local h::Int, w::Int
     default_size = displaysize()
 
-    @static if is_windows()
+    @static if Sys.iswindows()
         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(String["stty", "size"]), "r", io)[1])))
+                h, w = parse.(Int, split(read(open(Base.Cmd(String["stty", "size"]), "r", io).out, String)))
                 h > 0 || (h = default_size[1])
                 w > 0 || (w = default_size[2])
                 return h, w
@@ -676,7 +676,7 @@ function start_reading(stream::LibuvStream)
     end
 end
 
-if is_windows()
+if Sys.iswindows()
     # the low performance version of stop_reading is required
     # on Windows due to a NT kernel bug that we can't use a blocking
     # stream for non-blocking (overlapped) calls,
@@ -794,7 +794,7 @@ uv_write(s::LibuvStream, p::Vector{UInt8}) = uv_write(s, pointer(p), UInt(sizeof
 function uv_write(s::LibuvStream, p::Ptr{UInt8}, n::UInt)
     check_open(s)
     uvw = Libc.malloc(_sizeof_uv_write)
-    uv_req_set_data(uvw,C_NULL)
+    uv_req_set_data(uvw, C_NULL) # in case we get interrupted before arriving at the wait call
     err = ccall(:jl_uv_write,
                 Int32,
                 (Ptr{Void}, Ptr{Void}, UInt, Ptr{Void}, Ptr{Void}),
@@ -805,8 +805,21 @@ function uv_write(s::LibuvStream, p::Ptr{UInt8}, n::UInt)
         uv_error("write", err)
     end
     ct = current_task()
-    uv_req_set_data(uvw,ct)
-    stream_wait(ct)
+    preserve_handle(ct)
+    try
+        uv_req_set_data(uvw, ct)
+        wait()
+    finally
+        if uv_req_data(uvw) != C_NULL
+            # uvw is still alive,
+            # so make sure we don't get spurious notifications later
+            uv_req_set_data(uvw, C_NULL)
+        else
+            # done with uvw
+            Libc.free(uvw)
+        end
+        unpreserve_handle(ct)
+    end
     return Int(n)
 end
 
@@ -850,19 +863,30 @@ buffer_writes(s::LibuvStream, bufsize) = (s.sendbuf=PipeBuffer(bufsize); s)
 
 ## low-level calls to libuv ##
 
-write(s::LibuvStream, b::UInt8) = write(s, Ref{UInt8}(b))
+function write(s::LibuvStream, b::UInt8)
+    if !isnull(s.sendbuf)
+        buf = get(s.sendbuf)
+        if nb_available(buf) + 1 < buf.maxsize
+            return write(buf, b)
+        end
+    end
+    return write(s, Ref{UInt8}(b))
+end
 
 function uv_writecb_task(req::Ptr{Void}, status::Cint)
     d = uv_req_data(req)
     if d != C_NULL
+        uv_req_set_data(req, C_NULL)
         if status < 0
-            err = UVError("write",status)
-            schedule(unsafe_pointer_to_objref(d)::Task,err,error=true)
+            err = UVError("write", status)
+            schedule(unsafe_pointer_to_objref(d)::Task, err, error=true)
         else
             schedule(unsafe_pointer_to_objref(d)::Task)
         end
+    else
+        # no owner for this req, safe to just free it
+        Libc.free(req)
     end
-    Libc.free(req)
     nothing
 end
 
@@ -948,7 +972,7 @@ end
 function connect!(sock::PipeEndpoint, path::AbstractString)
     @assert sock.status == StatusInit
     req = Libc.malloc(_sizeof_uv_connect)
-    uv_req_set_data(req,C_NULL)
+    uv_req_set_data(req, C_NULL)
     ccall(:uv_pipe_connect, Void, (Ptr{Void}, Ptr{Void}, Cstring, Ptr{Void}), req, sock.handle, path, uv_jl_connectcb::Ptr{Void})
     sock.status = StatusConnecting
     return sock
@@ -970,8 +994,8 @@ Connect to the named pipe / UNIX domain socket at `path`.
 """
 connect(path::AbstractString) = connect(init_pipe!(PipeEndpoint(); readable=false, writable=false, julia_only=true),path)
 
-const OS_HANDLE = is_windows() ? WindowsRawSocket : RawFD
-const INVALID_OS_HANDLE = is_windows() ? WindowsRawSocket(Ptr{Void}(-1)) : RawFD(-1)
+const OS_HANDLE = Sys.iswindows() ? WindowsRawSocket : RawFD
+const INVALID_OS_HANDLE = Sys.iswindows() ? WindowsRawSocket(Ptr{Void}(-1)) : RawFD(-1)
 _fd(x::IOStream) = RawFD(fd(x))
 function _fd(x::Union{LibuvStream, LibuvServer})
     fd = Ref{OS_HANDLE}(INVALID_OS_HANDLE)
@@ -991,25 +1015,26 @@ for (x, writable, unix_fd, c_symbol) in
     @eval begin
         function ($_f)(stream)
             global $x
-            @static if is_windows()
-                ccall(:SetStdHandle,stdcall,Int32,(Int32,Ptr{Void}),
-                    $(-10 - unix_fd), Libc._get_osfhandle(_fd(stream)).handle)
-            else
-                dup(_fd(stream),  RawFD($unix_fd))
+            posix_fd = _fd(stream)
+            @static if Sys.iswindows()
+                ccall(:SetStdHandle, stdcall, Int32, (Int32, Ptr{Void}),
+                    $(-10 - unix_fd), Libc._get_osfhandle(posix_fd).handle)
             end
+            dup(posix_fd,  RawFD($unix_fd))
             $x = stream
+            nothing
         end
         function ($f)(handle::Union{LibuvStream,IOStream})
             $(_f)(handle)
             unsafe_store!(cglobal($(Expr(:quote,c_symbol)),Ptr{Void}),
                 handle.handle)
-            handle
+            return handle
         end
         function ($f)()
-            read,write = (PipeEndpoint(), PipeEndpoint())
-            link_pipe(read,$(writable),write,$(!writable))
-            ($f)($(writable? :write : :read))
-            (read,write)
+            read, write = (PipeEndpoint(), PipeEndpoint())
+            link_pipe(read, $(writable), write, $(!writable))
+            ($f)($(writable ? :write : :read))
+            return (read, write)
         end
     end
 end
diff --git a/base/strings/basic.jl b/base/strings/basic.jl
index c4cfcf280e27d7..6609cd1417b96a 100644
--- a/base/strings/basic.jl
+++ b/base/strings/basic.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## core string functions ##
 
@@ -39,6 +39,7 @@ getindex(s::AbstractString, v::AbstractVector{<:Integer}) =
 getindex(s::AbstractString, v::AbstractVector{Bool}) =
     throw(ArgumentError("logical indexing not supported for strings"))
 
+get(s::AbstractString, i::Integer, default) = isvalid(s,i) ? s[i] : default
 Symbol(s::AbstractString) = Symbol(String(s))
 
 """
@@ -46,6 +47,7 @@ Symbol(s::AbstractString) = Symbol(String(s))
 
 The number of bytes in string `s`.
 
+# Examples
 ```jldoctest
 julia> sizeof("❤")
 3
@@ -56,20 +58,23 @@ sizeof(s::AbstractString) = error("type $(typeof(s)) has no canonical binary rep
 eltype(::Type{<:AbstractString}) = Char
 
 """
-```
-*(s::AbstractString, t::AbstractString)
-```
+    *(s::Union{AbstractString, Char}, t::Union{AbstractString, Char}...)
 
-Concatenate strings. The `*` operator is an alias to this function.
+Concatenate strings and/or characters, producing a [`String`](@ref). This is equivalent
+to calling the [`string`](@ref) function on the arguments.
 
+# Examples
 ```jldoctest
 julia> "Hello " * "world"
 "Hello world"
+
+julia> 'j' * "ulia"
+"julia"
 ```
 """
-(*)(s1::AbstractString, ss::AbstractString...) = string(s1, ss...)
+(*)(s1::Union{Char, AbstractString}, ss::Union{Char, AbstractString}...) = string(s1, ss...)
 
-one{T<:AbstractString}(::Union{T,Type{T}}) = convert(T, "")
+one(::Union{T,Type{T}}) where {T<:AbstractString} = convert(T, "")
 
 length(s::DirectIndexString) = endof(s)
 
@@ -78,6 +83,7 @@ length(s::DirectIndexString) = endof(s)
 
 The number of characters in string `s`.
 
+# Examples
 ```jldoctest
 julia> length("jμΛIα")
 5
@@ -138,6 +144,7 @@ isvalid(s::DirectIndexString, i::Integer) = (start(s) <= i <= endof(s))
 
 Tells whether index `i` is valid for the given string.
 
+# Examples
 ```jldoctest
 julia> str = "αβγdef";
 
@@ -179,6 +186,7 @@ nextind(s::AbstractArray    , i::Integer) = Int(i)+1
 Get the previous valid string index before `i`.
 Returns a value less than `1` at the beginning of the string.
 
+# Examples
 ```jldoctest
 julia> prevind("αβγdef", 3)
 1
@@ -208,6 +216,7 @@ end
 Get the next valid string index after `i`.
 Returns a value greater than `endof(str)` at or after the end of the string.
 
+# Examples
 ```jldoctest
 julia> str = "αβγdef";
 
@@ -255,6 +264,7 @@ respect to string `s`.
 
 See also [`chr2ind`](@ref).
 
+# Examples
 ```jldoctest
 julia> str = "αβγdef";
 
@@ -286,6 +296,7 @@ Convert a character index `i` to a byte index.
 
 See also [`ind2chr`](@ref).
 
+# Examples
 ```jldoctest
 julia> str = "αβγdef";
 
@@ -328,6 +339,7 @@ eltype(::Type{EachStringIndex}) = Int
 
 Gives the number of columns needed to print a string.
 
+# Examples
 ```jldoctest
 julia> strwidth("March")
 5
@@ -354,6 +366,7 @@ promote_rule(::Type{<:AbstractString}, ::Type{<:AbstractString}) = String
 Tests whether a character is a valid hexadecimal digit. Note that this does not
 include `x` (as in the standard `0x` prefix).
 
+# Examples
 ```jldoctest
 julia> isxdigit('a')
 true
@@ -371,6 +384,7 @@ isxdigit(c::Char) = '0'<=c<='9' || 'a'<=c<='f' || 'A'<=c<='F'
 
 Returns `s` with all characters converted to uppercase.
 
+# Examples
 ```jldoctest
 julia> uppercase("Julia")
 "JULIA"
@@ -383,6 +397,7 @@ uppercase(s::AbstractString) = map(uppercase, s)
 
 Returns `s` with all characters converted to lowercase.
 
+# Examples
 ```jldoctest
 julia> lowercase("STRINGS AND THINGS")
 "strings and things"
@@ -394,7 +409,10 @@ lowercase(s::AbstractString) = map(lowercase, s)
     titlecase(s::AbstractString)
 
 Capitalizes the first character of each word in `s`.
+See also [`ucfirst`](@ref) to capitalize only the first
+character in `s`.
 
+# Examples
 ```jldoctest
 julia> titlecase("the julia programming language")
 "The Julia Programming Language"
@@ -418,15 +436,22 @@ end
 """
     ucfirst(s::AbstractString)
 
-Returns `string` with the first character converted to uppercase.
+Returns `string` with the first character converted to uppercase
+(technically "title case" for Unicode).
+See also [`titlecase`](@ref) to capitalize the first character of
+every word in `s`.
 
+# Examples
 ```jldoctest
 julia> ucfirst("python")
 "Python"
 ```
 """
 function ucfirst(s::AbstractString)
-    isempty(s) || isupper(s[1]) ? s : string(uppercase(s[1]),s[nextind(s,1):end])
+    isempty(s) && return s
+    c = s[1]
+    tc = titlecase(c)
+    return c==tc ? s : string(tc,s[nextind(s,1):end])
 end
 
 """
@@ -434,6 +459,7 @@ end
 
 Returns `string` with the first character converted to lowercase.
 
+# Examples
 ```jldoctest
 julia> lcfirst("Julia")
 "julia"
diff --git a/base/strings/errors.jl b/base/strings/errors.jl
index 8f80e5b1f8c308..2d3aa42455286d 100644
--- a/base/strings/errors.jl
+++ b/base/strings/errors.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ##    Error messages for Unicode / UTF support
 
diff --git a/base/strings/io.jl b/base/strings/io.jl
index 124a865daa00e4..ca8ca956ae3f89 100644
--- a/base/strings/io.jl
+++ b/base/strings/io.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## core text I/O ##
 
@@ -12,6 +12,7 @@ of a value if there is one, otherwise call [`show`](@ref).
 The representation used by `print` includes minimal formatting and tries to
 avoid Julia-specific details.
 
+# Examples
 ```jldoctest
 julia> print("Hello World!")
 Hello World!
@@ -74,6 +75,7 @@ end
 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.
 
+# Examples
 ```jldoctest
 julia> sprint(showcompact, 66.66666)
 "66.6667"
@@ -112,6 +114,7 @@ string_with_env(env, xs...) = print_to_string(xs...; env=env)
 
 Create a string from any values using the [`print`](@ref) function.
 
+# Examples
 ```jldoctest
 julia> string("a", 1, true)
 "a1true"
@@ -123,7 +126,7 @@ print(io::IO, s::AbstractString) = (write(io, s); nothing)
 write(io::IO, s::AbstractString) = (len = 0; for c in s; len += write(io, c); end; len)
 show(io::IO, s::AbstractString) = print_quoted(io, s)
 
-write(to::AbstractIOBuffer, s::SubString{String}) =
+write(to::GenericIOBuffer, s::SubString{String}) =
     s.endof==0 ? 0 : unsafe_write(to, pointer(s.string, s.offset + 1), UInt(nextind(s, s.endof) - 1))
 
 ## printing literal quoted string data ##
@@ -139,11 +142,11 @@ end
 """
     repr(x)
 
-Create a string from any value using the [`showall`](@ref) function.
+Create a string from any value using the [`show`](@ref) function.
 """
 function repr(x)
     s = IOBuffer()
-    showall(s, x)
+    show(s, x)
     String(take!(s))
 end
 
@@ -154,6 +157,7 @@ end
 
 Create a read-only `IOBuffer` on the data underlying the given string.
 
+# Examples
 ```jldoctest
 julia> io = IOBuffer("Haho");
 
@@ -176,6 +180,7 @@ Join an array of `strings` into a single string, inserting the given delimiter b
 adjacent strings. If `last` is given, it will be used instead of `delim` between the last
 two strings. For example,
 
+# Examples
 ```jldoctest
 julia> join(["apples", "bananas", "pineapples"], ", ", " and ")
 "apples, bananas and pineapples"
@@ -299,7 +304,8 @@ function unescape_string(io, s::AbstractString)
                     i = j
                 end
                 if k == 1
-                    throw(ArgumentError("\\x used with no following hex digits in $(repr(s))"))
+                    throw(ArgumentError("invalid $(m == 2 ? "hex (\\x)" :
+                                            "unicode (\\u)") escape sequence used in $(repr(s))"))
                 end
                 if m == 2 # \x escape sequence
                     write(io, UInt8(n))
diff --git a/base/strings/search.jl b/base/strings/search.jl
index 16ee1019eadc1f..23f813ea28b260 100644
--- a/base/strings/search.jl
+++ b/base/strings/search.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 const Chars = Union{Char,Tuple{Vararg{Char}},AbstractVector{Char},Set{Char}}
 
@@ -16,6 +16,7 @@ value is a range of indexes where the matching sequence is found, such that `s[s
 
 `search(string, 'c')` = `index` such that `string[index] == 'c'`, or `0` if unmatched.
 
+# Examples
 ```jldoctest
 julia> search("Hello to the world", "z")
 0:-1
@@ -76,6 +77,8 @@ function _searchindex(s, t, i)
     end
 end
 
+_searchindex(s, t::Char, i) = search(s, t, i)
+
 function _search_bloom_mask(c)
     UInt64(1) << (c & 63)
 end
@@ -152,6 +155,7 @@ searchindex(s::ByteArray, t::ByteArray, i) = _searchindex(s,t,i)
 Similar to [`search`](@ref), but return only the start index at which
 the substring is found, or `0` if it is not.
 
+# Examples
 ```jldoctest
 julia> searchindex("Hello to the world", "z")
 0
@@ -202,6 +206,7 @@ end
 Similar to [`search`](@ref), but returning the last occurrence of the given characters within the
 given string, searching in reverse from `start`.
 
+# Examples
 ```jldoctest
 julia> rsearch("aaabbb","b")
 6:6
@@ -316,6 +321,7 @@ rsearchindex(s::ByteArray, t::ByteArray, i::Integer) = _rsearchindex(s,t,i)
 
 Similar to [`rsearch`](@ref), but return only the start index at which the substring is found, or `0` if it is not.
 
+# Examples
 ```jldoctest
 julia> rsearchindex("aaabbb","b")
 6
@@ -366,15 +372,16 @@ rsearch(s::AbstractString, t::AbstractString, i::Integer=endof(s)) = _rsearch(s,
 rsearch(s::ByteArray, t::ByteArray, i::Integer=endof(s)) = _rsearch(s, t, i)
 
 """
-    contains(haystack::AbstractString, needle::AbstractString)
+    contains(haystack::AbstractString, needle::Union{AbstractString,Char})
 
 Determine whether the second argument is a substring of the first.
 
+# Examples
 ```jldoctest
 julia> contains("JuliaLang is pretty cool!", "Julia")
 true
 ```
 """
-contains(haystack::AbstractString, needle::AbstractString) = searchindex(haystack,needle)!=0
+contains(haystack::AbstractString, needle::Union{AbstractString,Char}) = searchindex(haystack,needle)!=0
 
 in(::AbstractString, ::AbstractString) = error("use contains(x,y) for string containment")
diff --git a/base/strings/string.jl b/base/strings/string.jl
index e7bad62e866133..6a9ebb3880e395 100644
--- a/base/strings/string.jl
+++ b/base/strings/string.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 const ByteArray = Union{Vector{UInt8},Vector{Int8}}
 
@@ -51,7 +51,7 @@ convert(::Type{String}, v::Vector{UInt8}) = String(v)
 pointer(s::String) = unsafe_convert(Ptr{UInt8}, s)
 pointer(s::String, i::Integer) = pointer(s)+(i-1)
 
-sizeof(s::String) = s.len
+sizeof(s::String) = Core.sizeof(s)
 
 """
     codeunit(s::AbstractString, i::Integer)
@@ -62,31 +62,33 @@ returns the `i`th byte of the representation of a UTF-8 string.
 codeunit(s::AbstractString, i::Integer)
 
 @inline function codeunit(s::String, i::Integer)
-    @boundscheck if (i < 1) | (i > s.len)
+    @boundscheck if (i < 1) | (i > sizeof(s))
         throw(BoundsError(s,i))
     end
     unsafe_load(pointer(s),i)
 end
 
-write(io::IO, s::String) = unsafe_write(io, pointer(s), UInt(s.len))
+write(io::IO, s::String) = unsafe_write(io, pointer(s), reinterpret(UInt, sizeof(s)))
 
 ## comparison ##
 
 function cmp(a::String, b::String)
+    al, bl = sizeof(a), sizeof(b)
     c = ccall(:memcmp, Int32, (Ptr{UInt8}, Ptr{UInt8}, UInt),
-              a, b, min(a.len,b.len))
-    return c < 0 ? -1 : c > 0 ? +1 : cmp(a.len,b.len)
+              a, b, min(al,bl))
+    return c < 0 ? -1 : c > 0 ? +1 : cmp(al,bl)
 end
 
 function ==(a::String, b::String)
-    a.len == b.len && 0 == ccall(:memcmp, Int32, (Ptr{UInt8}, Ptr{UInt8}, UInt), a, b, a.len)
+    al = sizeof(a)
+    al == sizeof(b) && 0 == ccall(:memcmp, Int32, (Ptr{UInt8}, Ptr{UInt8}, UInt), a, b, al)
 end
 
 ## prevind and nextind ##
 
 function prevind(s::String, i::Integer)
     j = Int(i)
-    e = s.len
+    e = sizeof(s)
     if j > e
         return endof(s)
     end
@@ -102,7 +104,7 @@ function nextind(s::String, i::Integer)
     if j < 1
         return 1
     end
-    e = s.len
+    e = sizeof(s)
     j += 1
     @inbounds while j <= e && is_valid_continuation(codeunit(s,j))
         j += 1
@@ -115,7 +117,7 @@ end
 byte_string_classify(data::Vector{UInt8}) =
     ccall(:u8_isvalid, Int32, (Ptr{UInt8}, Int), data, length(data))
 byte_string_classify(s::String) =
-    ccall(:u8_isvalid, Int32, (Ptr{UInt8}, Int), s, s.len)
+    ccall(:u8_isvalid, Int32, (Ptr{UInt8}, Int), s, sizeof(s))
     # 0: neither valid ASCII nor UTF-8
     # 1: valid ASCII
     # 2: valid UTF-8
@@ -151,7 +153,7 @@ const utf8_trailing = [
 
 function endof(s::String)
     p = pointer(s)
-    i = s.len
+    i = sizeof(s)
     while i > 0 && is_valid_continuation(unsafe_load(p,i))
         i -= 1
     end
@@ -161,7 +163,7 @@ end
 function length(s::String)
     p = pointer(s)
     cnum = 0
-    for i = 1:s.len
+    for i = 1:sizeof(s)
         cnum += !is_valid_continuation(unsafe_load(p,i))
     end
     cnum
@@ -187,13 +189,13 @@ end
 
 # This implementation relies on `next` returning a value past the end of the
 # String's underlying data, which is true for valid Strings
-done(s::String, state) = state > s.len
+done(s::String, state) = state > sizeof(s)
 
 @inline function next(s::String, i::Int)
     # function is split into this critical fast-path
     # for pure ascii data, such as parsing numbers,
     # and a longer function that can handle any utf8 data
-    @boundscheck if (i < 1) | (i > s.len)
+    @boundscheck if (i < 1) | (i > sizeof(s))
         throw(BoundsError(s,i))
     end
     p = pointer(s)
@@ -201,7 +203,7 @@ done(s::String, state) = state > s.len
     if b < 0x80
         return Char(b), i + 1
     end
-    return slow_utf8_next(p, b, i, s.len)
+    return slow_utf8_next(p, b, i, sizeof(s))
 end
 
 function first_utf8_byte(ch::Char)
@@ -214,7 +216,7 @@ function first_utf8_byte(ch::Char)
 end
 
 function reverseind(s::String, i::Integer)
-    j = s.len + 1 - i
+    j = sizeof(s) + 1 - i
     p = pointer(s)
     while is_valid_continuation(unsafe_load(p,j))
         j -= 1
@@ -225,12 +227,12 @@ end
 ## overload methods for efficiency ##
 
 isvalid(s::String, i::Integer) =
-    (1 <= i <= s.len) && !is_valid_continuation(unsafe_load(pointer(s),i))
+    (1 <= i <= sizeof(s)) && !is_valid_continuation(unsafe_load(pointer(s),i))
 
 function getindex(s::String, r::UnitRange{Int})
     isempty(r) && return ""
     i, j = first(r), last(r)
-    l = s.len
+    l = sizeof(s)
     if i < 1 || i > l
         throw(BoundsError(s, i))
     end
@@ -282,7 +284,7 @@ function search(a::ByteArray, b::Char, i::Integer = 1)
     end
 end
 
-function rsearch(s::String, c::Char, i::Integer = s.len)
+function rsearch(s::String, c::Char, i::Integer = sizeof(s))
     c < Char(0x80) && return rsearch(s, c%UInt8, i)
     b = first_utf8_byte(c)
     while true
@@ -292,7 +294,7 @@ function rsearch(s::String, c::Char, i::Integer = s.len)
     end
 end
 
-function rsearch(a::Union{String,ByteArray}, b::Union{Int8,UInt8}, i::Integer = s.len)
+function rsearch(a::Union{String,ByteArray}, b::Union{Int8,UInt8}, i::Integer = sizeof(s))
     if i < 1
         return i == 0 ? 0 : throw(BoundsError(a, i))
     end
@@ -321,13 +323,13 @@ function string(a::String...)
     end
     n = 0
     for str in a
-        n += str.len
+        n += sizeof(str)
     end
     out = _string_n(n)
     offs = 1
     for str in a
-        unsafe_copy!(pointer(out,offs), pointer(str), str.len)
-        offs += str.len
+        unsafe_copy!(pointer(out,offs), pointer(str), sizeof(str))
+        offs += sizeof(str)
     end
     return out
 end
@@ -353,7 +355,7 @@ function string(a::Union{String,Char}...)
         if isa(d,Char)
             n += codelen(d::Char)
         else
-            n += (d::String).len
+            n += sizeof(d::String)
         end
     end
     out = _string_n(n)
@@ -383,7 +385,7 @@ function string(a::Union{String,Char}...)
                 unsafe_store!(p, 0xbd, offs); offs += 1
             end
         else
-            l = (d::String).len
+            l = sizeof(d::String)
             unsafe_copy!(pointer(out,offs), pointer(d::String), l)
             offs += l
         end
@@ -425,10 +427,36 @@ end
 
 function repeat(s::String, r::Integer)
     r < 0 && throw(ArgumentError("can't repeat a string $r times"))
-    n = s.len
+    n = sizeof(s)
     out = _string_n(n*r)
-    for i=1:r
-        unsafe_copy!(pointer(out, 1+(i-1)*n), pointer(s), n)
+    if n == 1 # common case: repeating a single ASCII char
+        ccall(:memset, Ptr{Void}, (Ptr{UInt8}, Cint, Csize_t), out, unsafe_load(pointer(s)), r)
+    else
+        for i=1:r
+            unsafe_copy!(pointer(out, 1+(i-1)*n), pointer(s), n)
+        end
     end
     return out
 end
+
+"""
+    repeat(c::Char, r::Integer) -> String
+
+Repeat a character `r` times. This can equivalently be accomplished by calling [`c^r`](@ref ^).
+
+# Examples
+```jldoctest
+julia> repeat('A', 3)
+"AAA"
+```
+"""
+function repeat(c::Char, r::Integer)
+    if isascii(c)
+        r < 0 && throw(ArgumentError("can't repeat a character $r times"))
+        out = _string_n(r)
+        ccall(:memset, Ptr{Void}, (Ptr{UInt8}, Cint, Csize_t), out, c, r)
+        return out
+    else
+        return repeat(string(c), r)
+    end
+end
diff --git a/base/strings/strings.jl b/base/strings/strings.jl
index 2f175900e37d58..bc1f302b7a6ad6 100644
--- a/base/strings/strings.jl
+++ b/base/strings/strings.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 include("strings/errors.jl")
 include("strings/types.jl")
diff --git a/base/strings/types.jl b/base/strings/types.jl
index 6b51d60176527e..3fe9b0ca0fb784 100644
--- a/base/strings/types.jl
+++ b/base/strings/types.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # SubString and RevString types
 
@@ -26,7 +26,7 @@ struct SubString{T<:AbstractString} <: AbstractString
         end
     end
 end
-SubString(s::T, i::Int, j::Int) where T<:AbstractString = SubString{T}(s, i, j)
+SubString(s::T, i::Int, j::Int) where {T<:AbstractString} = SubString{T}(s, i, j)
 SubString(s::SubString, i::Int, j::Int) = SubString(s.string, s.offset+i, s.offset+j)
 SubString(s::AbstractString, i::Integer, j::Integer) = SubString(s, Int(i), Int(j))
 SubString(s::AbstractString, i::Integer) = SubString(s, i, endof(s))
@@ -73,7 +73,7 @@ chr2ind(s::SubString{<:DirectIndexString}, i::Integer) = begin checkbounds(s,i);
 nextind(s::SubString, i::Integer) = nextind(s.string, i+s.offset)-s.offset
 prevind(s::SubString, i::Integer) = prevind(s.string, i+s.offset)-s.offset
 
-convert{T<:AbstractString}(::Type{SubString{T}}, s::T) = SubString(s, 1, endof(s))
+convert(::Type{SubString{T}}, s::T) where {T<:AbstractString} = SubString(s, 1, endof(s))
 
 String(p::SubString{String}) =
     unsafe_string(pointer(p.string, p.offset+1), nextind(p, p.endof)-1)
@@ -94,7 +94,7 @@ end
 # don't make unnecessary copies when passing substrings to C functions
 cconvert(::Type{Ptr{UInt8}}, s::SubString{String}) = s
 cconvert(::Type{Ptr{Int8}}, s::SubString{String}) = s
-function unsafe_convert{R<:Union{Int8, UInt8}}(::Type{Ptr{R}}, s::SubString{String})
+function unsafe_convert(::Type{Ptr{R}}, s::SubString{String}) where R<:Union{Int8, UInt8}
     convert(Ptr{R}, pointer(s.string)) + s.offset
 end
 
@@ -117,6 +117,8 @@ end
     reverse(s::AbstractString) -> AbstractString
 
 Reverses a string.
+
+# Examples
 ```jldoctest
 julia> reverse("JuliaLang")
 "gnaLailuJ"
@@ -127,31 +129,56 @@ reverse(s::RevString) = s.string
 
 ## reverse an index i so that reverse(s)[i] == s[reverseind(s,i)]
 
+"""
+    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.)
+
+# Examples
+```jldoctest
+julia> r = reverse("Julia")
+"ailuJ"
+
+julia> for i in 1:length(r)
+           print(r[reverseind("Julia", i)])
+       end
+Julia
+```
+"""
 reverseind(s::AbstractString, i) = chr2ind(s, length(s) + 1 - ind2chr(reverse(s), i))
 reverseind(s::Union{DirectIndexString,SubString{DirectIndexString}}, i::Integer) = length(s) + 1 - i
 reverseind(s::RevString, i::Integer) = endof(s) - i + 1
 reverseind(s::SubString{String}, i::Integer) =
     reverseind(s.string, nextind(s.string, endof(s.string))-s.offset-s.endof+i-1) - s.offset
 
-function repeat(s::AbstractString, r::Integer)
-    r <  0 ? throw(ArgumentError("can't repeat a string $r times")) :
-    r == 0 ? "" :
-    r == 1 ? s  :
-    repeat(convert(String, s), r)
-end
+"""
+    repeat(s::AbstractString, r::Integer)
+
+Repeat a string `r` times. This can equivalently be accomplished by calling [`s^r`](@ref ^).
+
+# Examples
+```jldoctest
+julia> repeat("ha", 3)
+"hahaha"
+```
+"""
+repeat(s::AbstractString, r::Integer) = repeat(convert(String, s), r)
 
 """
-    ^(s::AbstractString, n::Integer)
+    ^(s::Union{AbstractString,Char}, n::Integer)
 
-Repeat `n` times the string `s`.
+Repeat a string or character `n` times.
 The [`repeat`](@ref) function is an alias to this operator.
 
+# Examples
 ```jldoctest
 julia> "Test "^3
 "Test Test Test "
 ```
 """
-(^)(s::AbstractString, r::Integer) = repeat(s,r)
+(^)(s::Union{AbstractString,Char}, r::Integer) = repeat(s,r)
 
 pointer(x::SubString{String}) = pointer(x.string) + x.offset
 pointer(x::SubString{String}, i::Integer) = pointer(x.string) + x.offset + (i-1)
diff --git a/base/strings/utf8proc.jl b/base/strings/utf8proc.jl
index 591d0b5793dd86..a3ebd46ca04143 100644
--- a/base/strings/utf8proc.jl
+++ b/base/strings/utf8proc.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Various Unicode functionality from the utf8proc library
 module UTF8proc
@@ -160,18 +160,19 @@ Alternatively, finer control and additional transformations may be be obtained b
 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)
+* `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
+* `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
+  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
 
@@ -352,7 +353,8 @@ letter combined with an accent mark is a single grapheme.)
 """
 graphemes(s::AbstractString) = GraphemeIterator{typeof(s)}(s)
 
-eltype{S}(::Type{GraphemeIterator{S}}) = SubString{S}
+eltype(::Type{GraphemeIterator{S}}) where {S} = SubString{S}
+eltype(::Type{GraphemeIterator{SubString{S}}}) where {S} = SubString{S}
 
 function length(g::GraphemeIterator)
     c0 = Char(0x00ad) # soft hyphen (grapheme break always allowed after this)
@@ -387,9 +389,9 @@ end
 hash(g::GraphemeIterator, h::UInt) = hash(g.s, h)
 isless(g1::GraphemeIterator, g2::GraphemeIterator) = isless(g1.s, g2.s)
 
-convert{S<:AbstractString}(::Type{S}, g::GraphemeIterator) = convert(S, g.s)
+convert(::Type{S}, g::GraphemeIterator) where {S<:AbstractString} = convert(S, g.s)
 
-show{S}(io::IO, g::GraphemeIterator{S}) = print(io, "length-$(length(g)) GraphemeIterator{$S} for \"$(g.s)\"")
+show(io::IO, g::GraphemeIterator{S}) where {S} = print(io, "length-$(length(g)) GraphemeIterator{$S} for \"$(g.s)\"")
 
 ############################################################################
 
diff --git a/base/strings/util.jl b/base/strings/util.jl
index d38bacbc759b27..c020bd2a64faa1 100644
--- a/base/strings/util.jl
+++ b/base/strings/util.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # starts with and ends with predicates
 
@@ -10,6 +10,7 @@ of characters, tests whether the first character of `s` belongs to that set.
 
 See also [`endswith`](@ref).
 
+# Examples
 ```jldoctest
 julia> startswith("JuliaLang", "Julia")
 true
@@ -21,7 +22,7 @@ function startswith(a::AbstractString, b::AbstractString)
     while !done(a,i) && !done(b,i)
         c, i = next(a,i)
         d, j = next(b,j)
-        if c != d return false end
+        (c != d) && (return false)
     end
     done(b,i)
 end
@@ -35,6 +36,7 @@ characters, tests whether the last character of `s` belongs to that set.
 
 See also [`startswith`](@ref).
 
+# Examples
 ```jldoctest
 julia> endswith("Sunday", "day")
 true
@@ -48,7 +50,7 @@ function endswith(a::AbstractString, b::AbstractString)
     while a1 <= i && b1 <= j
         c = a[i]
         d = b[j]
-        if c != d return false end
+        (c != d) && (return false)
         i = prevind(a,i)
         j = prevind(b,j)
     end
@@ -57,7 +59,7 @@ end
 endswith(str::AbstractString, chars::Chars) = !isempty(str) && last(str) in chars
 
 startswith(a::String, b::String) =
-    (a.len >= b.len && ccall(:memcmp, Int32, (Ptr{UInt8}, Ptr{UInt8}, UInt), a, b, b.len) == 0)
+    (sizeof(a) >= sizeof(b) && ccall(:memcmp, Int32, (Ptr{UInt8}, Ptr{UInt8}, UInt), a, b, sizeof(b)) == 0)
 startswith(a::Vector{UInt8}, b::Vector{UInt8}) =
     (length(a) >= length(b) && ccall(:memcmp, Int32, (Ptr{UInt8}, Ptr{UInt8}, UInt), a, b, length(b)) == 0)
 
@@ -68,6 +70,7 @@ startswith(a::Vector{UInt8}, b::Vector{UInt8}) =
 
 Remove the last character from `s`.
 
+# Examples
 ```jldoctest
 julia> a = "March"
 "March"
@@ -83,6 +86,7 @@ chop(s::AbstractString) = SubString(s, 1, endof(s)-1)
 
 Remove a single trailing newline from a string.
 
+# Examples
 ```jldoctest
 julia> chomp("Hello\\n")
 "Hello"
@@ -90,9 +94,9 @@ julia> chomp("Hello\\n")
 """
 function chomp(s::AbstractString)
     i = endof(s)
-    if (i < 1 || s[i] != '\n') return SubString(s, 1, i) end
+    (i < 1 || s[i] != '\n') && (return SubString(s, 1, i))
     j = prevind(s,i)
-    if (j < 1 || s[j] != '\r') return SubString(s, 1, i-1) end
+    (j < 1 || s[j] != '\r') && (return SubString(s, 1, i-1))
     return SubString(s, 1, j-1)
 end
 function chomp(s::String)
@@ -109,7 +113,7 @@ end
 # NOTE: use with caution -- breaks the immutable string convention!
 # TODO: this is hard to provide with the new representation
 #function chomp!(s::String)
-#    if !isempty(s) && codeunit(s,s.len) == 0x0a
+#    if !isempty(s) && codeunit(s,sizeof(s)) == 0x0a
 #        n = (endof(s) < 2 || s.data[end-1] != 0x0d) ? 1 : 2
 #        ccall(:jl_array_del_end, Void, (Any, UInt), s.data, n)
 #    end
@@ -128,6 +132,7 @@ The default delimiters to remove are `' '`, `\\t`, `\\n`, `\\v`,
 If `chars` (a character, or vector or set of characters) is provided,
 instead remove characters contained in it.
 
+# Examples
 ```jldoctest
 julia> a = lpad("March", 20)
 "               March"
@@ -137,15 +142,16 @@ julia> lstrip(a)
 ```
 """
 function lstrip(s::AbstractString, chars::Chars=_default_delims)
+    e = endof(s)
     i = start(s)
     while !done(s,i)
         c, j = next(s,i)
         if !(c in chars)
-            return s[i:end]
+            return SubString(s, i, e)
         end
         i = j
     end
-    s[end+1:end]
+    SubString(s, e+1, e)
 end
 
 """
@@ -157,6 +163,7 @@ The default delimiters to remove are `' '`, `\\t`, `\\n`, `\\v`,
 If `chars` (a character, or vector or set of characters) is provided,
 instead remove characters contained in it.
 
+# Examples
 ```jldoctest
 julia> a = rpad("March", 20)
 "March               "
@@ -171,11 +178,11 @@ function rstrip(s::AbstractString, chars::Chars=_default_delims)
     while !done(r,i)
         c, j = next(r,i)
         if !(c in chars)
-            return s[1:end-i+1]
+            return SubString(s, 1, endof(s)-i+1)
         end
         i = j
     end
-    s[1:0]
+    SubString(s, 1, 0)
 end
 
 """
@@ -185,6 +192,7 @@ Return `s` 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.
 
+# Examples
 ```jldoctest
 julia> strip("{3, 5}\\n", ['{', '}', '\\n'])
 "3, 5"
@@ -197,7 +205,7 @@ strip(s::AbstractString, chars::Chars) = lstrip(rstrip(s, chars), chars)
 
 function lpad(s::AbstractString, n::Integer, p::AbstractString=" ")
     m = n - strwidth(s)
-    if m <= 0; return s; end
+    (m <= 0) && (return s)
     l = strwidth(p)
     if l==1
         return string(p^m, s)
@@ -210,7 +218,7 @@ end
 
 function rpad(s::AbstractString, n::Integer, p::AbstractString=" ")
     m = n - strwidth(s)
-    if m <= 0; return s; end
+    (m <= 0) && (return s)
     l = strwidth(p)
     if l==1
         return string(s, p^m)
@@ -227,6 +235,7 @@ end
 Make a string at least `n` columns wide when printed by padding `s` on the left
 with copies of `p`.
 
+# Examples
 ```jldoctest
 julia> lpad("March",10)
 "     March"
@@ -240,6 +249,7 @@ lpad(s, n::Integer, p=" ") = lpad(string(s),n,string(p))
 Make a string at least `n` columns wide when printed by padding `s` on the right
 with copies of `p`.
 
+# Examples
 ```jldoctest
 julia> rpad("March",20)
 "March               "
@@ -250,7 +260,8 @@ cpad(s, n::Integer, p=" ") = rpad(lpad(s,div(n+strwidth(s),2),p),n,p)
 
 # splitter can be a Char, Vector{Char}, AbstractString, Regex, ...
 # any splitter that provides search(s::AbstractString, splitter)
-split{T<:SubString}(str::T, splitter; limit::Integer=0, keep::Bool=true) = _split(str, splitter, limit, keep, T[])
+split(str::T, splitter; limit::Integer=0, keep::Bool=true) where {T<:SubString} =
+    _split(str, splitter, limit, keep, T[])
 
 """
     split(s::AbstractString, [chars]; limit::Integer=0, keep::Bool=true)
@@ -263,6 +274,7 @@ expression). If `chars` is omitted, it defaults to the set of all space characte
 maximum size for the result and a flag determining whether empty fields should be kept in
 the result.
 
+# Examples
 ```jldoctest
 julia> a = "Ma.rch"
 "Ma.rch"
@@ -273,7 +285,8 @@ julia> split(a,".")
  "rch"
 ```
 """
-split{T<:AbstractString}(str::T, splitter; limit::Integer=0, keep::Bool=true) = _split(str, splitter, limit, keep, SubString{T}[])
+split(str::T, splitter; limit::Integer=0, keep::Bool=true) where {T<:AbstractString} =
+    _split(str, splitter, limit, keep, SubString{T}[])
 function _split(str::AbstractString, splitter, limit::Integer, keep_empty::Bool, strs::Array)
     i = start(str)
     n = endof(str)
@@ -286,7 +299,7 @@ function _split(str::AbstractString, splitter, limit::Integer, keep_empty::Bool,
             end
             i = k
         end
-        if k <= j; k = nextind(str,j) end
+        (k <= j) && (k = nextind(str,j))
         r = search(str,splitter,k)
         j, k = first(r), nextind(str,last(r))
     end
@@ -299,13 +312,15 @@ end
 # a bit oddball, but standard behavior in Perl, Ruby & Python:
 split(str::AbstractString) = split(str, _default_delims; limit=0, keep=false)
 
-rsplit{T<:SubString}(str::T, splitter; limit::Integer=0, keep::Bool=true) = _rsplit(str, splitter, limit, keep, T[])
+rsplit(str::T, splitter; limit::Integer=0, keep::Bool=true) where {T<:SubString} =
+    _rsplit(str, splitter, limit, keep, T[])
 
 """
     rsplit(s::AbstractString, [chars]; limit::Integer=0, keep::Bool=true)
 
 Similar to [`split`](@ref), but starting from the end of the string.
 
+# Examples
 ```jldoctest
 julia> a = "M.a.r.c.h"
 "M.a.r.c.h"
@@ -328,7 +343,8 @@ julia> rsplit(a,".";limit=2)
  "h"
 ```
 """
-rsplit{T<:AbstractString}(str::T, splitter   ; limit::Integer=0, keep::Bool=true) = _rsplit(str, splitter, limit, keep, SubString{T}[])
+rsplit(str::T, splitter; limit::Integer=0, keep::Bool=true) where {T<:AbstractString} =
+    _rsplit(str, splitter, limit, keep, SubString{T}[])
 function _rsplit(str::AbstractString, splitter, limit::Integer, keep_empty::Bool, strs::Array)
     i = start(str)
     n = endof(str)
@@ -354,7 +370,10 @@ _replace(io, repl, str, r, pattern) = print(io, repl)
 _replace(io, repl::Function, str, r, pattern) =
     print(io, repl(SubString(str, first(r), last(r))))
 
-function replace(str::String, pattern, repl, limit::Integer)
+# TODO: rename to `replace` when `replace` is removed from deprecated.jl
+function replace_new(str::String, pattern, repl, count::Integer)
+    count == 0 && return str
+    count < 0 && throw(DomainError(count, "`count` must be non-negative."))
     n = 1
     e = endof(str)
     i = a = start(str)
@@ -379,7 +398,7 @@ function replace(str::String, pattern, repl, limit::Integer)
         end
         r = search(str,pattern,k)
         j, k = first(r), last(r)
-        n == limit && break
+        n == count && break
         n += 1
     end
     write(out, SubString(str,i))
@@ -387,17 +406,21 @@ function replace(str::String, pattern, repl, limit::Integer)
 end
 
 """
-    replace(string::AbstractString, pat, r[, n::Integer=0])
+    replace(s::AbstractString, pat, r, [count::Integer])
 
-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
+Search for the given pattern `pat` in `s`, and replace each occurrence with `r`.
+If `count` is provided, replace at most `count` occurrences.
+As with [`search`](@ref), 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(s::AbstractString, pat, f, n::Integer) = replace(String(s), pat, f, n)
-replace(s::AbstractString, pat, r) = replace(s, pat, r, 0)
+replace(s::AbstractString, pat, f) = replace_new(String(s), pat, f, typemax(Int))
+# TODO: change this to the following when `replace` is removed from deprecated.jl:
+# replace(s::AbstractString, pat, f, count::Integer=typemax(Int)) =
+#     replace(String(s), pat, f, count)
+
 
 # hex <-> bytes conversion
 
@@ -407,6 +430,7 @@ replace(s::AbstractString, pat, r) = replace(s, pat, r, 0)
 Convert an arbitrarily long hexadecimal string to its binary representation. Returns an
 `Array{UInt8,1}`, i.e. an array of bytes.
 
+# Examples
 ```jldoctest
 julia> a = hex(12345)
 "3039"
@@ -445,6 +469,7 @@ end
 Convert an array of bytes to its hexadecimal representation.
 All characters are in lower-case.
 
+# Examples
 ```jldoctest
 julia> a = hex(12345)
 "3039"
@@ -483,11 +508,12 @@ end
 Convert a string to `String` type and check that it contains only ASCII data, otherwise
 throwing an `ArgumentError` indicating the position of the first non-ASCII byte.
 
+# Examples
 ```jldoctest
 julia> ascii("abcdeγfgh")
 ERROR: ArgumentError: invalid ASCII at index 6 in "abcdeγfgh"
 Stacktrace:
- [1] ascii(::String) at ./strings/util.jl:475
+ [1] ascii(::String) at ./strings/util.jl:479
 
 julia> ascii("abcdefgh")
 "abcdefgh"
diff --git a/base/subarray.jl b/base/subarray.jl
index 536c569f11920d..ad591d6ad5e9c5 100644
--- a/base/subarray.jl
+++ b/base/subarray.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 abstract type AbstractCartesianIndex{N} end # This is a hacky forward declaration for CartesianIndex
 const ViewIndex = Union{Real, AbstractArray}
@@ -33,8 +33,8 @@ function SubArray(::IndexLinear, parent::P, indexes::I, ::NTuple{N,Any}) where {
 end
 
 check_parent_index_match(parent, indexes) = check_parent_index_match(parent, index_ndims(indexes...))
-check_parent_index_match{T,N}(parent::AbstractArray{T,N}, ::NTuple{N, Bool}) = nothing
-check_parent_index_match{N}(parent, ::NTuple{N, Bool}) =
+check_parent_index_match(parent::AbstractArray{T,N}, ::NTuple{N, Bool}) where {T,N} = nothing
+check_parent_index_match(parent, ::NTuple{N, Bool}) where {N} =
     throw(ArgumentError("number of indices ($N) must match the parent dimensionality ($(ndims(parent)))"))
 
 # This computes the linear indexing compatability for a given tuple of indices
@@ -73,10 +73,10 @@ parentindexes(a::AbstractArray) = ntuple(i->OneTo(size(a,i)), ndims(a))
 # indices that end up getting passed to it, so we store the parent as a
 # ReshapedArray view if necessary. The trouble is that arrays of `CartesianIndex`
 # can make the number of effective indices not equal to length(I).
-_maybe_reshape_parent(A::AbstractArray, ::NTuple{1, Bool}) = reshape(A, Val{1})
-_maybe_reshape_parent{_}(A::AbstractArray{_,1}, ::NTuple{1, Bool}) = reshape(A, Val{1})
-_maybe_reshape_parent{_,N}(A::AbstractArray{_,N}, ::NTuple{N, Bool}) = A
-_maybe_reshape_parent{N}(A::AbstractArray, ::NTuple{N, Bool}) = reshape(A, Val{N}) # TODO: DEPRECATE FOR #14770
+_maybe_reshape_parent(A::AbstractArray, ::NTuple{1, Bool}) = reshape(A, Val(1))
+_maybe_reshape_parent(A::AbstractArray{<:Any,1}, ::NTuple{1, Bool}) = reshape(A, Val(1))
+_maybe_reshape_parent(A::AbstractArray{<:Any,N}, ::NTuple{N, Bool}) where {N} = A
+_maybe_reshape_parent(A::AbstractArray, ::NTuple{N, Bool}) where {N} = reshape(A, Val(N)) # TODO: DEPRECATE FOR #14770
 """
     view(A, inds...)
 
@@ -107,14 +107,14 @@ julia> A # Note A has changed even though we modified b
  0  4
 ```
 """
-function view(A::AbstractArray, I...)
+function view(A::AbstractArray, I::Vararg{Any,N}) where {N}
     @_inline_meta
     J = to_indices(A, I)
     @boundscheck checkbounds(A, J...)
     unsafe_view(_maybe_reshape_parent(A, index_ndims(J...)), J...)
 end
 
-function unsafe_view(A::AbstractArray, I::ViewIndex...)
+function unsafe_view(A::AbstractArray, I::Vararg{ViewIndex,N}) where {N}
     @_inline_meta
     SubArray(A, I)
 end
@@ -124,7 +124,8 @@ end
 # might span multiple parent indices, making the reindex calculation very hard.
 # So we use _maybe_reindex to figure out if there are any arrays of
 # `CartesianIndex`, and if so, we punt and keep two layers of indirection.
-unsafe_view(V::SubArray, I::ViewIndex...) = (@_inline_meta; _maybe_reindex(V, I))
+unsafe_view(V::SubArray, I::Vararg{ViewIndex,N}) where {N} =
+    (@_inline_meta; _maybe_reindex(V, I))
 _maybe_reindex(V, I) = (@_inline_meta; _maybe_reindex(V, I, I))
 _maybe_reindex(V, I, ::Tuple{AbstractArray{<:AbstractCartesianIndex}, Vararg{Any}}) =
     (@_inline_meta; SubArray(V, I))
@@ -167,7 +168,7 @@ reindex(V, idxs::Tuple{AbstractMatrix, Vararg{Any}}, subidxs::Tuple{Any, Any, Va
     (@_propagate_inbounds_meta; (idxs[1][subidxs[1], subidxs[2]], reindex(V, tail(idxs), tail(tail(subidxs)))...))
 
 # In general, we index N-dimensional parent arrays with N indices
-@generated function reindex{T,N}(V, idxs::Tuple{AbstractArray{T,N}, Vararg{Any}}, subidxs::Tuple{Vararg{Any}})
+@generated function reindex(V, idxs::Tuple{AbstractArray{T,N}, Vararg{Any}}, subidxs::Tuple{Vararg{Any}}) where {T,N}
     if length(subidxs.parameters) >= N
         subs = [:(subidxs[$d]) for d in 1:N]
         tail = [:(subidxs[$d]) for d in N+1:length(subidxs.parameters)]
@@ -179,7 +180,7 @@ end
 
 # In general, we simply re-index the parent indices by the provided ones
 SlowSubArray{T,N,P,I} = SubArray{T,N,P,I,false}
-function getindex{T,N}(V::SlowSubArray{T,N}, I::Vararg{Int,N})
+function getindex(V::SlowSubArray{T,N}, I::Vararg{Int,N}) where {T,N}
     @_inline_meta
     @boundscheck checkbounds(V, I...)
     @inbounds r = V.parent[reindex(V, V.indexes, I)...]
@@ -202,7 +203,7 @@ function getindex(V::FastContiguousSubArray, i::Int)
     r
 end
 
-function setindex!{T,N}(V::SlowSubArray{T,N}, x, I::Vararg{Int,N})
+function setindex!(V::SlowSubArray{T,N}, x, I::Vararg{Int,N}) where {T,N}
     @_inline_meta
     @boundscheck checkbounds(V, I...)
     @inbounds V.parent[reindex(V, V.indexes, I)...] = x
@@ -237,8 +238,8 @@ substrides(s, parent, dim, I::Tuple{Any, Vararg{Any}}) = throw(ArgumentError("st
 
 stride(V::SubArray, d::Integer) = d <= ndims(V) ? strides(V)[d] : strides(V)[end] * size(V)[end]
 
-compute_stride1{N}(parent::AbstractArray, I::NTuple{N,Any}) =
-    (@_inline_meta; compute_stride1(1, fill_to_length(indices(parent), OneTo(1), Val{N}), I))
+compute_stride1(parent::AbstractArray, I::NTuple{N,Any}) where {N} =
+    (@_inline_meta; compute_stride1(1, fill_to_length(indices(parent), OneTo(1), Val(N)), I))
 compute_stride1(s, inds, I::Tuple{}) = s
 compute_stride1(s, inds, I::Tuple{ScalarIndex, Vararg{Any}}) =
     (@_inline_meta; compute_stride1(s*unsafe_length(inds[1]), tail(inds), tail(I)))
@@ -264,15 +265,15 @@ end
 # indexing uses the indices along the given dimension. Otherwise
 # linear indexing always starts with 1.
 compute_offset1(parent, stride1::Integer, I::Tuple) =
-    (@_inline_meta; compute_offset1(parent, stride1, find_extended_dims(I)..., I))
+    (@_inline_meta; compute_offset1(parent, stride1, find_extended_dims(1, I...), find_extended_inds(I...), I))
 compute_offset1(parent, stride1::Integer, dims::Tuple{Int}, inds::Tuple{Slice}, I::Tuple) =
     (@_inline_meta; compute_linindex(parent, I) - stride1*first(indices(parent, dims[1])))  # index-preserving case
 compute_offset1(parent, stride1::Integer, dims, inds, I::Tuple) =
     (@_inline_meta; compute_linindex(parent, I) - stride1)  # linear indexing starts with 1
 
-function compute_linindex{N}(parent, I::NTuple{N,Any})
+function compute_linindex(parent, I::NTuple{N,Any}) where N
     @_inline_meta
-    IP = fill_to_length(indices(parent), OneTo(1), Val{N})
+    IP = fill_to_length(indices(parent), OneTo(1), Val(N))
     compute_linindex(1, 1, IP, I)
 end
 function compute_linindex(f, s, IP::Tuple, I::Tuple{ScalarIndex, Vararg{Any}})
@@ -287,14 +288,14 @@ function compute_linindex(f, s, IP::Tuple, I::Tuple{Any, Vararg{Any}})
 end
 compute_linindex(f, s, IP::Tuple, I::Tuple{}) = f
 
-find_extended_dims(I) = (@_inline_meta; _find_extended_dims((), (), 1, I...))
-_find_extended_dims(dims, inds, dim) = dims, inds
-_find_extended_dims(dims, inds, dim, ::ScalarIndex, I...) =
-    (@_inline_meta; _find_extended_dims(dims, inds, dim+1, I...))
-_find_extended_dims(dims, inds, dim, i1, I...) =
-    (@_inline_meta; _find_extended_dims((dims..., dim), (inds..., i1), dim+1, I...))
+find_extended_dims(dim, ::ScalarIndex, I...) = (@_inline_meta; find_extended_dims(dim + 1, I...))
+find_extended_dims(dim, i1, I...) = (@_inline_meta; (dim, find_extended_dims(dim + 1, I...)...))
+find_extended_dims(dim) = ()
+find_extended_inds(::ScalarIndex, I...) = (@_inline_meta; find_extended_inds(I...))
+find_extended_inds(i1, I...) = (@_inline_meta; (i1, find_extended_inds(I...)...))
+find_extended_inds() = ()
 
-unsafe_convert{T,N,P}(::Type{Ptr{T}}, V::SubArray{T,N,P,<:Tuple{Vararg{RangeIndex}}}) =
+unsafe_convert(::Type{Ptr{T}}, V::SubArray{T,N,P,<:Tuple{Vararg{RangeIndex}}}) where {T,N,P} =
     unsafe_convert(Ptr{T}, V.parent) + (first_index(V)-1)*sizeof(T)
 
 pointer(V::FastSubArray, i::Int) = pointer(V.parent, V.offset1 + V.stride1*i)
@@ -303,7 +304,7 @@ pointer(V::SubArray, i::Int) = _pointer(V, i)
 _pointer(V::SubArray{<:Any,1}, i::Int) = pointer(V, (i,))
 _pointer(V::SubArray, i::Int) = pointer(V, ind2sub(indices(V), i))
 
-function pointer{T,N}(V::SubArray{T,N,<:Array,<:Tuple{Vararg{RangeIndex}}}, is::Tuple{Vararg{Int}})
+function pointer(V::SubArray{T,N,<:Array,<:Tuple{Vararg{RangeIndex}}}, is::Tuple{Vararg{Int}}) where {T,N}
     index = first_index(V)
     strds = strides(V)
     for d = 1:length(is)
@@ -327,7 +328,7 @@ end
 # deprecate?
 function parentdims(s::SubArray)
     nd = ndims(s)
-    dimindex = Array{Int}(nd)
+    dimindex = Vector{Int}(nd)
     sp = strides(s.parent)
     sv = strides(s)
     j = 1
diff --git a/base/summarysize.jl b/base/summarysize.jl
index 174f18f3cf8fc7..414b94b90d02e8 100644
--- a/base/summarysize.jl
+++ b/base/summarysize.jl
@@ -1,3 +1,5 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
 struct SummarySize
     seen::ObjectIdDict
     frontier_x::Vector{Any}
@@ -6,6 +8,7 @@ struct SummarySize
     chargeall::Any
 end
 
+_nfields(@nospecialize x) = length(typeof(x).types)
 
 """
     Base.summarysize(obj; exclude=Union{...}, chargeall=Union{...}) -> Int
@@ -13,13 +16,14 @@ end
 Compute the amount of memory used by all unique objects reachable from the argument.
 
 # Keyword Arguments
-* `exclude`: specifies the types of objects to exclude from the traversal.
-* `chargeall`: specifies the types of objects to always charge the size of all of their fields,
-               even if those fields would normally be excluded.
+- `exclude`: specifies the types of objects to exclude from the traversal.
+- `chargeall`: specifies the types of objects to always charge the size of all of their
+  fields, even if those fields would normally be excluded.
 """
-function summarysize(obj::ANY;
-                     exclude::ANY = Union{DataType, TypeName, Method},
-                     chargeall::ANY = Union{TypeMapEntry, Core.MethodInstance})
+function summarysize(obj;
+                     exclude = Union{DataType, TypeName, Method},
+                     chargeall = Union{TypeMapEntry, Core.MethodInstance})
+    @nospecialize obj exclude chargeall
     ss = SummarySize(ObjectIdDict(), Any[], Int[], exclude, chargeall)
     size::Int = ss(obj)
     while !isempty(ss.frontier_x)
@@ -39,7 +43,7 @@ function summarysize(obj::ANY;
                 val = x[i]
             end
         else
-            nf = nfields(x)
+            nf = _nfields(x)
             ft = typeof(x).types
             if !isbits(ft[i]) && isdefined(x, i)
                 val = getfield(x, i)
@@ -58,16 +62,16 @@ function summarysize(obj::ANY;
     return size
 end
 
-(ss::SummarySize)(obj::ANY) = _summarysize(ss, obj)
+(ss::SummarySize)(@nospecialize obj) = _summarysize(ss, obj)
 # define the general case separately to make sure it is not specialized for every type
-@noinline function _summarysize(ss::SummarySize, obj::ANY)
+@noinline function _summarysize(ss::SummarySize, @nospecialize obj)
     key = pointer_from_objref(obj)
     haskey(ss.seen, key) ? (return 0) : (ss.seen[key] = true)
-    if nfields(obj) > 0
+    if _nfields(obj) > 0
         push!(ss.frontier_x, obj)
         push!(ss.frontier_i, 1)
     end
-    if isa(obj, UnionAll)
+    if isa(obj, UnionAll) || isa(obj, Union)
         # black-list of items that don't have a Core.sizeof
         return 2 * sizeof(Int)
     end
@@ -82,7 +86,7 @@ function (ss::SummarySize)(obj::DataType)
     key = pointer_from_objref(obj)
     haskey(ss.seen, key) ? (return 0) : (ss.seen[key] = true)
     size::Int = 7 * Core.sizeof(Int) + 6 * Core.sizeof(Int32)
-    size += 4 * nfields(obj) + ifelse(Sys.WORD_SIZE == 64, 4, 0)
+    size += 4 * _nfields(obj) + ifelse(Sys.WORD_SIZE == 64, 4, 0)
     size += ss(obj.parameters)::Int
     size += ss(obj.types)::Int
     return size
diff --git a/base/sysimg.jl b/base/sysimg.jl
index 602c1acdabf593..a30ec87bf7f5e1 100644
--- a/base/sysimg.jl
+++ b/base/sysimg.jl
@@ -1,30 +1,54 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 baremodule Base
 
 using Core.Intrinsics
-ccall(:jl_set_istopmod, Void, (Bool,), true)
-function include(path::AbstractString)
+ccall(:jl_set_istopmod, Void, (Any, Bool), Base, true)
+function include(mod::Module, path::AbstractString)
     local result
     if INCLUDE_STATE === 1
-        result = Core.include(path)
+        result = Core.include(mod, path)
     elseif INCLUDE_STATE === 2
-        result = _include(path)
+        result = _include(mod, path)
     elseif INCLUDE_STATE === 3
-        result = include_from_node1(path)
+        result = include_relative(mod, path)
+    end
+    result
+end
+function include(path::AbstractString)
+    local result
+    if INCLUDE_STATE === 1
+        result = Core.include(Base, path)
+    elseif INCLUDE_STATE === 2
+        result = _include(Base, path)
+    else
+        # to help users avoid error (accidentally evaluating into Base), this is deprecated
+        depwarn("Base.include(string) is deprecated, use `include(fname)` or `Base.include(@__MODULE__, fname)` instead.", :include)
+        result = include_relative(_current_module(), path)
     end
     result
 end
+let SOURCE_PATH = ""
+    # simple, race-y TLS, relative include
+    global _include
+    function _include(mod::Module, path)
+        prev = SOURCE_PATH
+        path = joinpath(dirname(prev), path)
+        SOURCE_PATH = path
+        result = Core.include(mod, path)
+        SOURCE_PATH = prev
+        result
+    end
+end
 INCLUDE_STATE = 1 # include = Core.include
 
 include("coreio.jl")
 
 eval(x) = Core.eval(Base, x)
 eval(m, x) = Core.eval(m, x)
-(::Type{T}){T}(arg) = convert(T, arg)::T
-(::Type{VecElement{T}}){T}(arg) = VecElement{T}(convert(T, arg))
-convert{T<:VecElement}(::Type{T}, arg) = T(arg)
-convert{T<:VecElement}(::Type{T}, arg::T) = arg
+VecElement{T}(arg) where {T} = VecElement{T}(convert(T, arg))
+convert(::Type{T}, arg)  where {T<:VecElement} = T(arg)
+convert(::Type{T}, arg::T) where {T<:VecElement} = arg
 
 # init core docsystem
 import Core: @doc, @__doc__, @doc_str
@@ -40,9 +64,9 @@ if false
     # goes wrong during bootstrap before printing code is available.
     # otherwise, they just just eventually get (noisily) overwritten later
     global show, print, println
-    show(io::IO, x::ANY) = Core.show(io, x)
-    print(io::IO, a::ANY...) = Core.print(io, a...)
-    println(io::IO, x::ANY...) = Core.println(io, x...)
+    show(io::IO, x) = Core.show(io, x)
+    print(io::IO, a...) = Core.print(io, a...)
+    println(io::IO, x...) = Core.println(io, x...)
 end
 
 ## Load essential files and libraries
@@ -73,6 +97,10 @@ include("refpointer.jl")
 include("checked.jl")
 importall .Checked
 
+# buggy handling of ispure in type-inference means this should be
+# after re-defining the basic operations that they might try to call
+(::Type{T})(arg) where {T} = convert(T, arg)::T # Hidden from the REPL.
+
 # vararg Symbol constructor
 Symbol(x...) = Symbol(string(x...))
 
@@ -90,16 +118,16 @@ include("abstractarray.jl")
 include("subarray.jl")
 
 # Array convenience converting constructors
-(::Type{Array{T}}){T}(m::Integer) = Array{T,1}(Int(m))
-(::Type{Array{T}}){T}(m::Integer, n::Integer) = Array{T,2}(Int(m), Int(n))
-(::Type{Array{T}}){T}(m::Integer, n::Integer, o::Integer) = Array{T,3}(Int(m), Int(n), Int(o))
-(::Type{Array{T}}){T}(d::Integer...) = Array{T}(convert(Tuple{Vararg{Int}}, d))
+Array{T}(m::Integer) where {T} = Array{T,1}(Int(m))
+Array{T}(m::Integer, n::Integer) where {T} = Array{T,2}(Int(m), Int(n))
+Array{T}(m::Integer, n::Integer, o::Integer) where {T} = Array{T,3}(Int(m), Int(n), Int(o))
+Array{T}(d::Integer...) where {T} = Array{T}(convert(Tuple{Vararg{Int}}, d))
 
-(::Type{Vector})() = Array{Any,1}(0)
-(::Type{Vector{T}}){T}(m::Integer) = Array{T,1}(Int(m))
-(::Type{Vector})(m::Integer) = Array{Any,1}(Int(m))
-(::Type{Matrix{T}}){T}(m::Integer, n::Integer) = Matrix{T}(Int(m), Int(n))
-(::Type{Matrix})(m::Integer, n::Integer) = Matrix{Any}(Int(m), Int(n))
+Vector() = Array{Any,1}(0)
+Vector{T}(m::Integer) where {T} = Array{T,1}(Int(m))
+Vector(m::Integer) = Array{Any,1}(Int(m))
+Matrix{T}(m::Integer, n::Integer) where {T} = Matrix{T}(Int(m), Int(n))
+Matrix(m::Integer, n::Integer) = Matrix{Any}(Int(m), Int(n))
 
 # numeric operations
 include("hashing.jl")
@@ -141,10 +169,16 @@ using .Iterators: zip, enumerate
 using .Iterators: Flatten, product  # for generators
 
 # Definition of StridedArray
-StridedReshapedArray{T,N,A<:DenseArray} = ReshapedArray{T,N,A}
-StridedArray{T,N,A<:Union{DenseArray,StridedReshapedArray},I<:Tuple{Vararg{Union{RangeIndex, AbstractCartesianIndex}}}} = Union{DenseArray{T,N}, SubArray{T,N,A,I}, StridedReshapedArray{T,N}}
-StridedVector{T,A<:Union{DenseArray,StridedReshapedArray},I<:Tuple{Vararg{Union{RangeIndex, AbstractCartesianIndex}}}} = Union{DenseArray{T,1}, SubArray{T,1,A,I}, StridedReshapedArray{T,1}}
-StridedMatrix{T,A<:Union{DenseArray,StridedReshapedArray},I<:Tuple{Vararg{Union{RangeIndex, AbstractCartesianIndex}}}} = Union{DenseArray{T,2}, SubArray{T,2,A,I}, StridedReshapedArray{T,2}}
+StridedReshapedArray{T,N,A<:Union{DenseArray,FastContiguousSubArray}} = ReshapedArray{T,N,A}
+StridedArray{T,N,A<:Union{DenseArray,StridedReshapedArray},
+    I<:Tuple{Vararg{Union{RangeIndex, AbstractCartesianIndex}}}} =
+    Union{DenseArray{T,N}, SubArray{T,N,A,I}, StridedReshapedArray{T,N}}
+StridedVector{T,A<:Union{DenseArray,StridedReshapedArray},
+    I<:Tuple{Vararg{Union{RangeIndex, AbstractCartesianIndex}}}} =
+    Union{DenseArray{T,1}, SubArray{T,1,A,I}, StridedReshapedArray{T,1}}
+StridedMatrix{T,A<:Union{DenseArray,StridedReshapedArray},
+    I<:Tuple{Vararg{Union{RangeIndex, AbstractCartesianIndex}}}} =
+    Union{DenseArray{T,2}, SubArray{T,2,A,I}, StridedReshapedArray{T,2}}
 StridedVecOrMat{T} = Union{StridedVector{T}, StridedMatrix{T}}
 
 # For OS specific stuff
@@ -153,7 +187,6 @@ include(string((length(Core.ARGS)>=2 ? Core.ARGS[2] : ""), "version_git.jl")) #
 
 include("osutils.jl")
 include("c.jl")
-include("sysinfo.jl")
 
 if !isdefined(Core, :Inference)
     include("docs/core.jl")
@@ -186,6 +219,25 @@ include("nullable.jl")
 include("broadcast.jl")
 importall .Broadcast
 
+# define the real ntuple functions
+@generated function ntuple(f::F, ::Val{N}) where {F,N}
+    Core.typeassert(N, Int)
+    (N >= 0) || return :(throw($(ArgumentError(string("tuple length should be ≥0, got ", N)))))
+    return quote
+        $(Expr(:meta, :inline))
+        @nexprs $N i -> t_i = f(i)
+        @ncall $N tuple t
+    end
+end
+@generated function fill_to_length(t::Tuple, val, ::Val{N}) where {N}
+    M = length(t.parameters)
+    M > N  && return :(throw($(ArgumentError("input tuple of length $M, requested $N"))))
+    return quote
+        $(Expr(:meta, :inline))
+        (t..., $(Any[ :val for i = (M + 1):N ]...))
+    end
+end
+
 # base64 conversions (need broadcast)
 include("base64.jl")
 importall .Base64
@@ -194,6 +246,7 @@ importall .Base64
 include("version.jl")
 
 # system & environment
+include("sysinfo.jl")
 include("libc.jl")
 using .Libc: getpid, gethostname, time
 include("libdl.jl")
@@ -227,15 +280,6 @@ importall .Math
 const (√)=sqrt
 const (∛)=cbrt
 
-let SOURCE_PATH = ""
-    global function _include(path)
-        prev = SOURCE_PATH
-        path = joinpath(dirname(prev),path)
-        SOURCE_PATH = path
-        Core.include(path)
-        SOURCE_PATH = prev
-    end
-end
 INCLUDE_STATE = 2 # include = _include (from lines above)
 
 # reduction along dims
@@ -249,11 +293,21 @@ importall .Order
 include("sort.jl")
 importall .Sort
 
+# Fast math
+include("fastmath.jl")
+importall .FastMath
+
 function deepcopy_internal end
 
 # BigInts and BigFloats
 include("gmp.jl")
 importall .GMP
+
+for T in [Signed, Integer, BigInt, Float32, Float64, Real, Complex, Rational]
+    @eval flipsign(x::$T, ::Unsigned) = +x
+    @eval copysign(x::$T, ::Unsigned) = +x
+end
+
 include("mpfr.jl")
 importall .MPFR
 big(n::Integer) = convert(BigInt,n)
@@ -265,6 +319,9 @@ include("combinatorics.jl")
 # more hashing definitions
 include("hashing2.jl")
 
+# irrational mathematical constants
+include("irrationals.jl")
+
 # random number generation
 include("dSFMT.jl")
 include("random.jl")
@@ -303,10 +360,10 @@ using .I18n
 
 # frontend
 include("initdefs.jl")
-include("Terminals.jl")
-include("LineEdit.jl")
-include("REPLCompletions.jl")
-include("REPL.jl")
+include("repl/Terminals.jl")
+include("repl/LineEdit.jl")
+include("repl/REPLCompletions.jl")
+include("repl/REPL.jl")
 include("client.jl")
 
 # Stack frames and traces
@@ -325,19 +382,6 @@ const × = cross
 # statistics
 include("statistics.jl")
 
-# irrational mathematical constants
-include("irrationals.jl")
-
-# signal processing
-include("dft.jl")
-importall .DFT
-include("dsp.jl")
-importall .DSP
-
-# Fast math
-include("fastmath.jl")
-importall .FastMath
-
 # libgit2 support
 include("libgit2/libgit2.jl")
 
@@ -391,12 +435,11 @@ function __init__()
     init_threadcall()
 end
 
-INCLUDE_STATE = 3 # include = include_from_node1
-include("precompile.jl")
+INCLUDE_STATE = 3 # include = include_relative
+include(Base, "precompile.jl")
 
 end # baremodule Base
 
 using Base
-importall Base.Operators
 
-Base.isfile("userimg.jl") && Base.include("userimg.jl")
+Base.isfile("userimg.jl") && Base.include(Main, "userimg.jl")
diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index d23f709a140f4f..434e9f18009455 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -1,20 +1,25 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module Sys
 
-export  CPU_CORES,
-        WORD_SIZE,
-        ARCH,
-        MACHINE,
-        KERNEL,
-        JIT,
-        cpu_info,
-        cpu_name,
-        cpu_summary,
-        uptime,
-        loadavg,
-        free_memory,
-        total_memory
+export CPU_CORES,
+       WORD_SIZE,
+       ARCH,
+       MACHINE,
+       KERNEL,
+       JIT,
+       cpu_info,
+       cpu_name,
+       cpu_summary,
+       uptime,
+       loadavg,
+       free_memory,
+       total_memory,
+       isapple,
+       isbsd,
+       islinux,
+       isunix,
+       iswindows
 
 import ..Base: show
 
@@ -92,7 +97,7 @@ CPUinfo(info::UV_cpu_info_t) = CPUinfo(unsafe_string(info.model), info.speed,
 
 show(io::IO, info::CPUinfo) = Base._show_cpuinfo(io, info, true, "    ")
 
-function _cpu_summary(io::IO, cpu::Array{CPUinfo}, i, j)
+function _cpu_summary(io::IO, cpu::AbstractVector{CPUinfo}, i, j)
     if j-i < 9
         header = true
         for x = i:j
@@ -117,7 +122,7 @@ function _cpu_summary(io::IO, cpu::Array{CPUinfo}, i, j)
     println(io)
 end
 
-function cpu_summary(io::IO=STDOUT, cpu::Array{CPUinfo}=cpu_info())
+function cpu_summary(io::IO=STDOUT, cpu::AbstractVector{CPUinfo} = cpu_info())
     model = cpu[1].model
     first = 1
     for i = 2:length(cpu)
@@ -130,25 +135,35 @@ function cpu_summary(io::IO=STDOUT, cpu::Array{CPUinfo}=cpu_info())
 end
 
 function cpu_info()
-    UVcpus = Array{Ptr{UV_cpu_info_t}}(1)
-    count = Array{Int32}(1)
+    UVcpus = Ref{Ptr{UV_cpu_info_t}}()
+    count = Ref{Int32}()
     Base.uv_error("uv_cpu_info",ccall(:uv_cpu_info, Int32, (Ptr{Ptr{UV_cpu_info_t}}, Ptr{Int32}), UVcpus, count))
-    cpus = Array{CPUinfo}(count[1])
+    cpus = Vector{CPUinfo}(count[])
     for i = 1:length(cpus)
-        cpus[i] = CPUinfo(unsafe_load(UVcpus[1], i))
+        cpus[i] = CPUinfo(unsafe_load(UVcpus[], i))
     end
-    ccall(:uv_free_cpu_info, Void, (Ptr{UV_cpu_info_t}, Int32), UVcpus[1], count[1])
+    ccall(:uv_free_cpu_info, Void, (Ptr{UV_cpu_info_t}, Int32), UVcpus[], count[])
     return cpus
 end
 
+"""
+    Sys.uptime()
+
+Gets the current system uptime in seconds.
+"""
 function uptime()
-    uptime_ = Array{Float64}(1)
+    uptime_ = Ref{Float64}()
     Base.uv_error("uv_uptime",ccall(:uv_uptime, Int32, (Ptr{Float64},), uptime_))
-    return uptime_[1]
+    return uptime_[]
 end
 
+"""
+    Sys.loadavg()
+
+Get the load average. See: https://en.wikipedia.org/wiki/Load_(computing).
+"""
 function loadavg()
-    loadavg_ = Array{Float64}(3)
+    loadavg_ = Vector{Float64}(3)
     ccall(:uv_loadavg, Void, (Ptr{Float64},), loadavg_)
     return loadavg_
 end
@@ -159,10 +174,10 @@ total_memory() = ccall(:uv_get_total_memory, UInt64, ())
 """
     Sys.get_process_title()
 
-Get the process title. On some systems, will always return empty string. (not exported)
+Get the process title. On some systems, will always return an empty string.
 """
 function get_process_title()
-    buf = zeros(UInt8, 512)
+    buf = Vector{UInt8}(512)
     err = ccall(:uv_get_process_title, Cint, (Ptr{UInt8}, Cint), buf, 512)
     Base.uv_error("get_process_title", err)
     return unsafe_string(pointer(buf))
@@ -171,31 +186,91 @@ end
 """
     Sys.set_process_title(title::AbstractString)
 
-Set the process title. No-op on some operating systems. (not exported)
+Set the process title. No-op on some operating systems.
 """
 function set_process_title(title::AbstractString)
     err = ccall(:uv_set_process_title, Cint, (Cstring,), title)
     Base.uv_error("set_process_title", err)
 end
 
+"""
+    Sys.maxrss()
+
+Get the maximum resident set size utilized in bytes.
+See also:
+    - man page of getrusage(2) on Linux and FreeBSD.
+    - windows api `GetProcessMemoryInfo`
+"""
 maxrss() = ccall(:jl_maxrss, Csize_t, ())
 
-if is_windows()
+"""
+    Sys.isunix([os])
+
+Predicate for testing if the OS provides a Unix-like interface.
+See documentation in [Handling Operating System Variation](@ref).
+"""
+function isunix(os::Symbol)
+    if iswindows(os)
+        return false
+    elseif islinux(os) || isbsd(os)
+        return true
+    else
+        throw(ArgumentError("unknown operating system \"$os\""))
+    end
+end
+
+"""
+    Sys.islinux([os])
+
+Predicate for testing if the OS is a derivative of Linux.
+See documentation in [Handling Operating System Variation](@ref).
+"""
+islinux(os::Symbol) = (os == :Linux)
+
+"""
+    Sys.isbsd([os])
+
+Predicate for testing if the OS is a derivative of BSD.
+See documentation in [Handling Operating System Variation](@ref).
+"""
+isbsd(os::Symbol) = (os == :FreeBSD || os == :OpenBSD || os == :NetBSD || os == :DragonFly || os == :Darwin || os == :Apple)
+
+"""
+    Sys.iswindows([os])
+
+Predicate for testing if the OS is a derivative of Microsoft Windows NT.
+See documentation in [Handling Operating System Variation](@ref).
+"""
+iswindows(os::Symbol) = (os == :Windows || os == :NT)
+
+"""
+    Sys.isapple([os])
+
+Predicate for testing if the OS is a derivative of Apple Macintosh OS X or Darwin.
+See documentation in [Handling Operating System Variation](@ref).
+"""
+isapple(os::Symbol) = (os == :Apple || os == :Darwin)
+
+for f in (:isunix, :islinux, :isbsd, :isapple, :iswindows)
+    @eval $f() = $(getfield(@__MODULE__, f)(KERNEL))
+end
+
+if iswindows()
     function windows_version()
         verinfo = ccall(:GetVersion, UInt32, ())
-        (Int(verinfo & 0xFF), Int((verinfo >> 8) & 0xFF))
+        VersionNumber(verinfo & 0xFF, (verinfo >> 8) & 0xFF, verinfo >> 16)
     end
 else
-    windows_version() = (0, 0)
+    windows_version() = v"0.0"
 end
 """
-    windows_version()
+    Sys.windows_version()
 
-Returns the version number for the Windows NT Kernel as a (major, minor) pair,
-or `(0, 0)` if this is not running on Windows.
+Returns the version number for the Windows NT Kernel as a `VersionNumber`,
+i.e. `v"major.minor.build"`, or `v"0.0.0"` if this is not running on Windows.
 """
 windows_version
 
-const WINDOWS_VISTA_VER = (6, 0)
+const WINDOWS_VISTA_VER = v"6.0"
 
 end # module Sys
diff --git a/base/task.jl b/base/task.jl
index a25bc78cd65b6f..5639bb444a7396 100644
--- a/base/task.jl
+++ b/base/task.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## basic task functions and TLS
 
@@ -209,7 +209,7 @@ function task_done_hook(t::Task)
 
     if isa(t.donenotify, Condition) && !isempty(t.donenotify.waitq)
         handled = true
-        notify(t.donenotify, result, error=err)
+        notify(t.donenotify, result, true, err)
     end
 
     # Execute any other hooks registered in the TLS
@@ -238,7 +238,7 @@ function task_done_hook(t::Task)
         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)
+            throwto(active_repl_backend.backend_task, result) # this terminates the task
         end
         if !suppress_excp_printing(t)
             let bt = t.backtrace
@@ -253,7 +253,7 @@ function task_done_hook(t::Task)
     end
     # Clear sigatomic before waiting
     sigatomic_end()
-    wait()
+    wait() # this will not return
 end
 
 
diff --git a/base/test.jl b/base/test.jl
index f460b97a739896..32cd0e1be0ce46 100644
--- a/base/test.jl
+++ b/base/test.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 """
 Simple unit testing functionality:
@@ -11,6 +11,8 @@ 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`.
 """
+:Test # cf. #22288
+
 module Test
 
 export @test, @test_throws, @test_broken, @test_skip, @test_warn, @test_nowarn
@@ -18,7 +20,7 @@ export @testset
 # Legacy approximate testing functions, yet to be included
 export @inferred
 export detect_ambiguities
-export GenericString
+export GenericString, GenericSet, GenericDict, GenericArray
 
 #-----------------------------------------------------------------------
 
@@ -67,14 +69,14 @@ struct Pass <: Result
     value
 end
 function Base.show(io::IO, t::Pass)
-    print_with_color(:green, io, "Test Passed\n"; bold = true)
+    print_with_color(:green, io, "Test Passed"; bold = true)
     if !(t.orig_expr === nothing)
-        print(io, "  Expression: ", t.orig_expr)
+        print(io, "\n  Expression: ", t.orig_expr)
     end
     if t.test_type == :test_throws
         # The correct type of exception was thrown
         print(io, "\n      Thrown: ", typeof(t.value))
-    elseif t.test_type == :test && isa(t.data,Expr) && t.data.head == :comparison
+    elseif t.test_type == :test && isa(t.data, Expr)
         # The test was an expression, so display the term-by-term
         # evaluated version as well
         print(io, "\n   Evaluated: ", t.data)
@@ -99,12 +101,12 @@ function Base.show(io::IO, t::Fail)
     if t.test_type == :test_throws_wrong
         # An exception was thrown, but it was of the wrong type
         print(io, "\n    Expected: ", t.data)
-        print(io, "\n      Thrown: ", typeof(t.value))
+        print(io, "\n      Thrown: ", isa(t.data, Type) ? typeof(t.value) : t.value)
     elseif t.test_type == :test_throws_nothing
         # An exception was expected, but no exception was thrown
         print(io, "\n    Expected: ", t.data)
         print(io, "\n  No exception thrown")
-    elseif t.test_type == :test && isa(t.data,Expr) && t.data.head == :comparison
+    elseif t.test_type == :test && isa(t.data, Expr)
         # The test was an expression, so display the term-by-term
         # evaluated version as well
         print(io, "\n   Evaluated: ", t.data)
@@ -115,7 +117,7 @@ end
     Error
 
 The test condition couldn't be evaluated due to an exception, or
-it evaluated to something other than a `Bool`.
+it evaluated to something other than a [`Bool`](@ref).
 In the case of `@test_broken` it is used to indicate that an
 unexpected `Pass` `Result` occurred.
 """
@@ -186,19 +188,44 @@ struct Threw <: ExecutionResult
     backtrace
 end
 
-function eval_comparison(ex::Expr)
+function eval_test(evaluated::Expr, quoted::Expr)
     res = true
     i = 1
-    a = ex.args
-    n = length(a)
-    while i < n
-        res = a[i+1](a[i], a[i+2])
-        if !isa(res,Bool) || !res
-            break
+    evaled_args = evaluated.args
+    quoted_args = quoted.args
+    n = length(evaled_args)
+    if evaluated.head == :comparison
+        args = evaled_args
+        while i < n
+            a, op, b = args[i], args[i+1], args[i+2]
+            if res
+                res = op(a, b) === true  # Keep `res` type stable
+            end
+            quoted_args[i] = a
+            quoted_args[i+2] = b
+            i += 2
         end
-        i += 2
+
+    elseif evaluated.head == :call
+        op = evaled_args[1]
+        kwargs = evaled_args[2].args  # Keyword arguments from `Expr(:parameters, ...)`
+        args = evaled_args[3:n]
+
+        res = op(args...; kwargs...) === true
+
+        # Create "Evaluated" expression which looks like the original call but has all of
+        # the arguments evaluated
+        func_sym = quoted_args[1]
+        if isempty(kwargs)
+            quoted = Expr(:call, func_sym, args...)
+        else
+            kwargs_expr = Expr(:parameters, [Expr(:kw, k, v) for (k, v) in kwargs]...)
+            quoted = Expr(:call, func_sym, kwargs_expr, args...)
+        end
+    else
+        throw(ArgumentError("Unhandled expression type: $(evaluated.head)"))
     end
-    Returned(res, ex)
+    Returned(res, quoted)
 end
 
 const comparison_prec = Base.operator_precedence(:(==))
@@ -291,20 +318,63 @@ end
 # evaluate each term in the comparison individually so the results
 # can be displayed nicely.
 function get_test_result(ex)
-    orig_ex = Expr(:inert, ex)
     # Normalize non-dot comparison operator calls to :comparison expressions
-    if isa(ex, Expr) && ex.head == :call && length(ex.args)==3 &&
-        first(string(ex.args[1])) != '.' &&
+    is_splat = x -> isa(x, Expr) && x.head == :...
+    if isa(ex, Expr) && ex.head == :call && length(ex.args) == 3 &&
+        first(string(ex.args[1])) != '.' && !is_splat(ex.args[2]) && !is_splat(ex.args[3]) &&
         (ex.args[1] === :(==) || Base.operator_precedence(ex.args[1]) == comparison_prec)
-        testret = :(eval_comparison(Expr(:comparison,
-                                         $(esc(ex.args[2])), $(esc(ex.args[1])), $(esc(ex.args[3])))))
-    elseif isa(ex, Expr) && ex.head == :comparison
+        ex = Expr(:comparison, ex.args[2], ex.args[1], ex.args[3])
+    end
+    if isa(ex, Expr) && ex.head == :comparison
         # pass all terms of the comparison to `eval_comparison`, as an Expr
-        terms = ex.args
-        for i = 1:length(terms)
-            terms[i] = esc(terms[i])
+        escaped_terms = [esc(arg) for arg in ex.args]
+        quoted_terms = [QuoteNode(arg) for arg in ex.args]
+        testret = :(eval_test(
+            Expr(:comparison, $(escaped_terms...)),
+            Expr(:comparison, $(quoted_terms...)),
+        ))
+    elseif isa(ex, Expr) && ex.head == :call && ex.args[1] in (:isequal, :isapprox)
+        escaped_func = esc(ex.args[1])
+        quoted_func = QuoteNode(ex.args[1])
+
+        escaped_args = []
+        escaped_kwargs = []
+
+        # Keywords that occur before `;`. Note that the keywords are being revised into
+        # a form we can splat.
+        for a in ex.args[2:end]
+            if isa(a, Expr) && a.head == :kw
+                push!(escaped_kwargs, Expr(:call, :(=>), QuoteNode(a.args[1]), esc(a.args[2])))
+            end
         end
-        testret = :(eval_comparison(Expr(:comparison, $(terms...))))
+
+        # Keywords that occur after ';'
+        parameters_expr = ex.args[2]
+        if isa(parameters_expr, Expr) && parameters_expr.head == :parameters
+            for a in parameters_expr.args
+                if isa(a, Expr) && a.head == :kw
+                    push!(escaped_kwargs, Expr(:call, :(=>), QuoteNode(a.args[1]), esc(a.args[2])))
+                elseif isa(a, Expr) && a.head == :...
+                    push!(escaped_kwargs, Expr(:..., esc(a.args[1])))
+                end
+            end
+        end
+
+        # Positional arguments
+        for a in ex.args[2:end]
+            isa(a, Expr) && a.head in (:kw, :parameters) && continue
+
+            if isa(a, Expr) && a.head == :...
+                push!(escaped_args, Expr(:..., esc(a)))
+            else
+                push!(escaped_args, esc(a))
+            end
+        end
+
+        testret = :(eval_test(
+            Expr(:call, $escaped_func, Expr(:parameters, $(escaped_kwargs...)), $(escaped_args...)),
+            Expr(:call, $quoted_func),
+        ))
     else
         testret = :(Returned($(esc(ex)), nothing))
     end
@@ -363,9 +433,11 @@ end
 #-----------------------------------------------------------------------
 
 """
-    @test_throws extype ex
+    @test_throws exception expr
 
-Tests that the expression `ex` throws an exception of type `extype`.
+Tests that the expression `expr` throws `exception`.
+The exception may specify either a type,
+or a value (which will be tested for equality by comparing fields).
 Note that `@test_throws` does not support a trailing keyword form.
 """
 macro test_throws(extype, ex)
@@ -383,13 +455,28 @@ 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)
+function do_test_throws(result::ExecutionResult, @nospecialize(orig_expr), @nospecialize(extype))
     if isa(result, Threw)
         # Check that the right type of exception was thrown
-        if isa(result.exception, extype)
-            testres = Pass(:test_throws, nothing, nothing, result.exception)
+        success = false
+        exc = result.exception
+        if isa(extype, Type)
+            success = isa(exc, extype)
         else
-            testres = Fail(:test_throws_wrong, orig_expr, extype, result.exception)
+            if isa(exc, typeof(extype))
+                success = true
+                for fld in 1:nfields(extype)
+                    if !(getfield(extype, fld) == getfield(exc, fld))
+                        success = false
+                        break
+                    end
+                end
+            end
+        end
+        if success
+            testres = Pass(:test_throws, nothing, nothing, exc)
+        else
+            testres = Fail(:test_throws_wrong, orig_expr, extype, exc)
         end
     else
         testres = Fail(:test_throws_nothing, orig_expr, extype, nothing)
@@ -426,7 +513,7 @@ macro test_warn(msg, expr)
                         $(esc(expr))
                     end
                 end
-                @test ismatch_warn($(esc(msg)), readstring(fname))
+                @test ismatch_warn($(esc(msg)), read(fname, String))
                 ret
             finally
                 eval(Base, Expr(:(=), :have_color, have_color))
@@ -793,7 +880,7 @@ 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
+`DefaultTestSet` records all the results 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.
 
@@ -848,6 +935,9 @@ function testset_beginend(args, tests)
     # action (such as reporting the results)
     quote
         ts = $(testsettype)($desc; $options...)
+        # this empty loop is here to force the block to be compiled,
+        # which is needed for backtrace scrubbing to work correctly.
+        while false; end
         push_testset(ts)
         try
             $(esc(tests))
@@ -1070,7 +1160,7 @@ macro inferred(ex)
                 kwargs = gensym()
                 quote
                     $(esc(args)), $(esc(kwargs)), result = $(esc(Expr(:call, _args_and_call, ex.args[2:end]..., ex.args[1])))
-                    inftypes = $(Base.gen_call_with_extracted_types(Base.return_types, :($(ex.args[1])($(args)...; $(kwargs)...))))
+                    inftypes = $(Base.gen_call_with_extracted_types(__module__, Base.return_types, :($(ex.args[1])($(args)...; $(kwargs)...))))
                 end
             else
                 # No keywords
@@ -1105,10 +1195,8 @@ end
 #
 # Raises an error if any columnwise vector norm exceeds err. Otherwise, returns
 # nothing.
-function test_approx_eq_modphase{S<:Real,T<:Real}(
-        a::StridedVecOrMat{S}, b::StridedVecOrMat{T},
-        err = length(indices(a,1))^3*(eps(S)+eps(T))
-    )
+function test_approx_eq_modphase(a::StridedVecOrMat{S}, b::StridedVecOrMat{T},
+                                 err = length(indices(a,1))^3*(eps(S)+eps(T))) where {S<:Real,T<:Real}
     @test indices(a,1) == indices(b,1) && indices(a,2) == indices(b,2)
     for i in indices(a,2)
         v1, v2 = a[:, i], b[:, i]
@@ -1117,14 +1205,25 @@ function test_approx_eq_modphase{S<:Real,T<:Real}(
 end
 
 """
-    detect_ambiguities(mod1, mod2...; imported=false)
+    detect_ambiguities(mod1, mod2...; imported=false, ambiguous_bottom=false)
 
 Returns a vector of `(Method,Method)` pairs of ambiguous methods
 defined in the specified modules. Use `imported=true` if you wish to
 also test functions that were imported into these modules from
 elsewhere.
+
+`ambiguous_bottom` controls whether ambiguities triggered only by
+`Union{}` type parameters are included; in most cases you probably
+want to set this to `false`. See [`Base.isambiguous`](@ref).
 """
-function detect_ambiguities(mods...; imported::Bool=false, allow_bottom::Bool=true)
+function detect_ambiguities(mods...;
+                            imported::Bool = false,
+                            ambiguous_bottom::Bool = false,
+                            allow_bottom::Union{Bool,Void} = nothing)
+    if allow_bottom !== nothing
+        Base.depwarn("the `allow_bottom` keyword to detect_ambiguities has been renamed to `ambiguous_bottom`", :detect_ambiguities)
+        ambiguous_bottom = allow_bottom
+    end
     function sortdefs(m1, m2)
         ord12 = m1.file < m2.file
         if !ord12 && (m1.file == m2.file)
@@ -1146,7 +1245,7 @@ function detect_ambiguities(mods...; imported::Bool=false, allow_bottom::Bool=tr
                 for m in mt
                     if m.ambig !== nothing
                         for m2 in m.ambig
-                            if Base.isambiguous(m, m2, allow_bottom)
+                            if Base.isambiguous(m, m2, ambiguous_bottom=ambiguous_bottom)
                                 push!(ambs, sortdefs(m, m2))
                             end
                         end
@@ -1170,4 +1269,57 @@ Base.convert(::Type{GenericString}, s::AbstractString) = GenericString(s)
 Base.endof(s::GenericString) = endof(s.string)
 Base.next(s::GenericString, i::Int) = next(s.string, i)
 
+"""
+The `GenericSet` can be used to test generic set APIs that program to
+the `AbstractSet` interface, in order to ensure that functions can work
+with set types besides the standard `Set` and `IntSet` types.
+"""
+struct GenericSet{T} <: AbstractSet{T}
+    s::AbstractSet{T}
+end
+
+"""
+The `GenericDict` can be used to test generic dict APIs that program to
+the `Associative` interface, in order to ensure that functions can work
+with associative types besides the standard `Dict` type.
+"""
+struct GenericDict{K,V} <: Associative{K,V}
+    s::Associative{K,V}
+end
+
+for (G, A) in ((GenericSet, AbstractSet),
+               (GenericDict, Associative))
+    @eval begin
+        Base.convert(::Type{$G}, s::$A) = $G(s)
+        Base.done(s::$G, state) = done(s.s, state)
+        Base.next(s::$G, state) = next(s.s, state)
+    end
+    for f in (:eltype, :isempty, :length, :start)
+        @eval begin
+            Base.$f(s::$G) = $f(s.s)
+        end
+    end
+end
+
+Base.get(s::GenericDict, x, y) = get(s.s, x, y)
+
+"""
+The `GenericArray` can be used to test generic array APIs that program to
+the `AbstractArray` interface, in order to ensure that functions can work
+with array types besides the standard `Array` type.
+"""
+struct GenericArray{T,N} <: AbstractArray{T,N}
+    a::Array{T,N}
+end
+
+GenericArray{T}(args...) where {T} = GenericArray(Array{T}(args...))
+GenericArray{T,N}(args...) where {T,N} = GenericArray(Array{T,N}(args...))
+
+Base.eachindex(a::GenericArray) = eachindex(a.a)
+Base.indices(a::GenericArray) = indices(a.a)
+Base.length(a::GenericArray) = length(a.a)
+Base.size(a::GenericArray) = size(a.a)
+Base.getindex(a::GenericArray, i...) = a.a[i...]
+Base.setindex!(a::GenericArray, x, i...) = a.a[i...] = x
+
 end # module
diff --git a/base/threadcall.jl b/base/threadcall.jl
index c6dcfaedef2ba8..fee9ef82227001 100644
--- a/base/threadcall.jl
+++ b/base/threadcall.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://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]
@@ -11,7 +11,7 @@ function notify_fun(idx)
 end
 
 function init_threadcall()
-    global c_notify_fun = cfunction(notify_fun, Void, (Cint,))
+    global c_notify_fun = cfunction(notify_fun, Void, Tuple{Cint})
 end
 
 """
@@ -64,12 +64,12 @@ end
 
 function do_threadcall(wrapper::Function, rettype::Type, argtypes::Vector, argvals::Vector)
     # generate function pointer
-    fun_ptr = cfunction(wrapper, Int, (Ptr{Void}, Ptr{Void}))
+    fun_ptr = cfunction(wrapper, Int, Tuple{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)
+    args_arr = Vector{UInt8}(args_size)
     ptr = pointer(args_arr)
     for (T, x) in zip(argtypes, argvals)
         y = cconvert(T, x)
@@ -79,7 +79,7 @@ function do_threadcall(wrapper::Function, rettype::Type, argtypes::Vector, argva
     end
 
     # create return buffer
-    ret_arr = Array{UInt8}(sizeof(rettype))
+    ret_arr = Vector{UInt8}(sizeof(rettype))
 
     # wait for a worker thread to be available
     acquire(threadcall_restrictor)
diff --git a/base/threadingconstructs.jl b/base/threadingconstructs.jl
index a9a3e3940507ce..740ddaf1ba9e7c 100644
--- a/base/threadingconstructs.jl
+++ b/base/threadingconstructs.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 export threadid, nthreads, @threads
 
@@ -18,16 +18,25 @@ on `threadid()`.
 """
 nthreads() = Int(unsafe_load(cglobal(:jl_n_threads, Cint)))
 
+# Only read/written by the main thread
+const in_threaded_loop = Ref(false)
+
 function _threadsfor(iter,lbody)
-    fun = gensym("_threadsfor")
     lidx = iter.args[1]         # index
     range = iter.args[2]
     quote
-        function $fun()
-            tid = threadid()
-            r = $(esc(range))
+        range = $(esc(range))
+        function threadsfor_fun(onethread=false)
+            r = range # Load into local variable
+            lenr = length(r)
             # divide loop iterations among threads
-            len, rem = divrem(length(r), nthreads())
+            if onethread
+                tid = 1
+                len, rem = lenr, 0
+            else
+                tid = threadid()
+                len, rem = divrem(lenr, nthreads())
+            end
             # not enough iterations for all the threads?
             if len == 0
                 if tid > rem
@@ -54,7 +63,17 @@ function _threadsfor(iter,lbody)
                 $(esc(lbody))
             end
         end
-        ccall(:jl_threading_run, Void, (Any,), Core.svec($fun))
+        # Hack to make nested threaded loops kinda work
+        if threadid() != 1 || in_threaded_loop[]
+            # We are in a nested threaded loop
+            threadsfor_fun(true)
+        else
+            in_threaded_loop[] = true
+            # the ccall is not expected to throw
+            ccall(:jl_threading_run, Ref{Void}, (Any,), threadsfor_fun)
+            in_threaded_loop[] = false
+        end
+        nothing
     end
 end
 """
@@ -80,4 +99,3 @@ macro threads(args...)
         throw(ArgumentError("unrecognized argument to @threads"))
     end
 end
-
diff --git a/base/threads.jl b/base/threads.jl
index ef9f6957fa3b76..d36cade0977353 100644
--- a/base/threads.jl
+++ b/base/threads.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module Threads
 
diff --git a/base/traits.jl b/base/traits.jl
index da5de84cf58c0c..3efad150e1ff8b 100644
--- a/base/traits.jl
+++ b/base/traits.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## numeric/object traits
 # trait for objects that have an ordering
@@ -6,9 +6,9 @@ abstract type TypeOrder end
 struct HasOrder <: TypeOrder end
 struct Unordered <: TypeOrder end
 
-(::Type{TypeOrder})(instance) = TypeOrder(typeof(instance))
-(::Type{TypeOrder})(::Type{<:Real}) = HasOrder()
-(::Type{TypeOrder})(::Type{<:Any}) = Unordered()
+TypeOrder(instance) = TypeOrder(typeof(instance))
+TypeOrder(::Type{<:Real}) = HasOrder()
+TypeOrder(::Type{<:Any}) = Unordered()
 
 # trait for objects that support arithmetic
 abstract type TypeArithmetic end
@@ -16,7 +16,7 @@ struct ArithmeticRounds <: TypeArithmetic end     # least significant bits can b
 struct ArithmeticOverflows <: TypeArithmetic end  #  most significant bits can be lost
 struct ArithmeticUnknown <: TypeArithmetic end
 
-(::Type{TypeArithmetic})(instance) = TypeArithmetic(typeof(instance))
-(::Type{TypeArithmetic})(::Type{<:AbstractFloat}) = ArithmeticRounds()
-(::Type{TypeArithmetic})(::Type{<:Integer}) = ArithmeticOverflows()
-(::Type{TypeArithmetic})(::Type{<:Any}) = ArithmeticUnknown()
+TypeArithmetic(instance) = TypeArithmetic(typeof(instance))
+TypeArithmetic(::Type{<:AbstractFloat}) = ArithmeticRounds()
+TypeArithmetic(::Type{<:Integer}) = ArithmeticOverflows()
+TypeArithmetic(::Type{<:Any}) = ArithmeticUnknown()
diff --git a/base/tuple.jl b/base/tuple.jl
index bc0d3c932b0c45..cce81f01518305 100644
--- a/base/tuple.jl
+++ b/base/tuple.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Document NTuple here where we have everything needed for the doc system
 """
@@ -20,16 +20,17 @@ endof(t::Tuple) = length(t)
 size(t::Tuple, d) = d==1 ? length(t) : throw(ArgumentError("invalid tuple dimension $d"))
 getindex(t::Tuple, i::Int) = getfield(t, i)
 getindex(t::Tuple, i::Real) = getfield(t, convert(Int, i))
-getindex(t::Tuple, r::AbstractArray{<:Any,1}) = tuple([t[ri] for ri in r]...)
+getindex(t::Tuple, r::AbstractArray{<:Any,1}) = ([t[ri] for ri in r]...)
 getindex(t::Tuple, b::AbstractArray{Bool,1}) = length(b) == length(t) ? getindex(t,find(b)) : throw(BoundsError(t, b))
 
 # returns new tuple; N.B.: becomes no-op if i is out-of-bounds
-setindex(x::Tuple, v, i::Integer) = _setindex((), x, v, i::Integer)
-function _setindex(y::Tuple, r::Tuple, v, i::Integer)
+setindex(x::Tuple, v, i::Integer) = (@_inline_meta; _setindex(v, i, x...))
+function _setindex(v, i::Integer, first, tail...)
     @_inline_meta
-    _setindex((y..., ifelse(length(y) + 1 == i, v, first(r))), tail(r), v, i)
+    return (ifelse(i == 1, v, first), _setindex(v, i - 1, tail...)...)
 end
-_setindex(y::Tuple, r::Tuple{}, v, i::Integer) = y
+_setindex(v, i::Integer) = ()
+
 
 ## iterating ##
 
@@ -63,6 +64,16 @@ first(t::Tuple) = t[1]
 
 eltype(::Type{Tuple{}}) = Bottom
 eltype(::Type{<:Tuple{Vararg{E}}}) where {E} = E
+function eltype(t::Type{<:Tuple})
+    @_pure_meta
+    t isa Union && return typejoin(eltype(t.a), eltype(t.b))
+    t´ = unwrap_unionall(t)
+    r = Union{}
+    for ti in t´.parameters
+        r = typejoin(r, rewrap_unionall(unwrapva(ti), t))
+    end
+    return r
+end
 
 # version of tail that doesn't throw on empty tuples (used in array indexing)
 safe_tail(t::Tuple) = tail(t)
@@ -72,13 +83,13 @@ safe_tail(t::Tuple{}) = ()
 
 function front(t::Tuple)
     @_inline_meta
-    _front((), t...)
+    _front(t...)
 end
-front(::Tuple{}) = throw(ArgumentError("Cannot call front on an empty tuple"))
-_front(out, v) = out
-function _front(out, v, t...)
+_front() = throw(ArgumentError("Cannot call front on an empty tuple"))
+_front(v) = ()
+function _front(v, t...)
     @_inline_meta
-    _front((out..., v), t...)
+    (v, _front(t...)...)
 end
 
 ## mapping ##
@@ -94,31 +105,34 @@ julia> ntuple(i -> 2*i, 4)
 (2, 4, 6, 8)
 ```
 """
-ntuple(f::Function, n::Integer) =
-    n <= 0 ? () :
-    n == 1 ? (f(1),) :
-    n == 2 ? (f(1),f(2),) :
-    n == 3 ? (f(1),f(2),f(3),) :
-    n == 4 ? (f(1),f(2),f(3),f(4),) :
-    n == 5 ? (f(1),f(2),f(3),f(4),f(5),) :
-    n < 16 ? (ntuple(f,n-5)..., f(n-4), f(n-3), f(n-2), f(n-1), f(n)) :
-    _ntuple(f, n)
-
-_ntuple(f::Function, n::Integer) = (@_noinline_meta; ((f(i) for i = 1:n)...))
-
-# inferrable ntuple
-function ntuple{F,N}(f::F, ::Type{Val{N}})
-    Core.typeassert(N, Int)
-    _ntuple((), f, Val{N})
+function ntuple(f::F, n::Integer) where F
+    t = n == 0  ? () :
+        n == 1  ? (f(1),) :
+        n == 2  ? (f(1), f(2)) :
+        n == 3  ? (f(1), f(2), f(3)) :
+        n == 4  ? (f(1), f(2), f(3), f(4)) :
+        n == 5  ? (f(1), f(2), f(3), f(4), f(5)) :
+        n == 6  ? (f(1), f(2), f(3), f(4), f(5), f(6)) :
+        n == 7  ? (f(1), f(2), f(3), f(4), f(5), f(6), f(7)) :
+        n == 8  ? (f(1), f(2), f(3), f(4), f(5), f(6), f(7), f(8)) :
+        n == 9  ? (f(1), f(2), f(3), f(4), f(5), f(6), f(7), f(8), f(9)) :
+        n == 10 ? (f(1), f(2), f(3), f(4), f(5), f(6), f(7), f(8), f(9), f(10)) :
+        _ntuple(f, n)
+    return t
 end
 
-# Build up the output until it has length N
-_ntuple{F,N}(out::NTuple{N,Any}, f::F, ::Type{Val{N}}) = out
-function _ntuple{F,N,M}(out::NTuple{M,Any}, f::F, ::Type{Val{N}})
-    @_inline_meta
-    _ntuple((out..., f(M+1)), f, Val{N})
+function _ntuple(f, n)
+    @_noinline_meta
+    (n >= 0) || throw(ArgumentError(string("tuple length should be ≥0, got ", n)))
+    ([f(i) for i = 1:n]...)
 end
 
+# inferrable ntuple (enough for bootstrapping)
+ntuple(f, ::Val{0}) = ()
+ntuple(f, ::Val{1}) = (@_inline_meta; (f(1),))
+ntuple(f, ::Val{2}) = (@_inline_meta; (f(1), f(2)))
+ntuple(f, ::Val{3}) = (@_inline_meta; (f(1), f(2), f(3)))
+
 # 1 argument function
 map(f, t::Tuple{})              = ()
 map(f, t::Tuple{Any,})          = (f(t[1]),)
@@ -126,17 +140,17 @@ map(f, t::Tuple{Any, Any})      = (f(t[1]), f(t[2]))
 map(f, t::Tuple{Any, Any, Any}) = (f(t[1]), f(t[2]), f(t[3]))
 map(f, t::Tuple)                = (@_inline_meta; (f(t[1]), map(f,tail(t))...))
 # stop inlining after some number of arguments to avoid code blowup
-Any16{N}   = Tuple{Any,Any,Any,Any,Any,Any,Any,Any,
-                   Any,Any,Any,Any,Any,Any,Any,Any,Vararg{Any,N}}
-All16{T,N} = Tuple{T,T,T,T,T,T,T,T,
-                   T,T,T,T,T,T,T,T,Vararg{T,N}}
+const Any16{N} = Tuple{Any,Any,Any,Any,Any,Any,Any,Any,
+                       Any,Any,Any,Any,Any,Any,Any,Any,Vararg{Any,N}}
+const All16{T,N} = Tuple{T,T,T,T,T,T,T,T,
+                         T,T,T,T,T,T,T,T,Vararg{T,N}}
 function map(f, t::Any16)
     n = length(t)
-    A = Array{Any}(n)
+    A = Array{Any,1}(n)
     for i=1:n
         A[i] = f(t[i])
     end
-    (A...,)
+    (A...)
 end
 # 2 argument function
 map(f, t::Tuple{},        s::Tuple{})        = ()
@@ -148,45 +162,51 @@ function map(f, t::Tuple, s::Tuple)
 end
 function map(f, t::Any16, s::Any16)
     n = length(t)
-    A = Array{Any}(n)
+    A = Array{Any,1}(n)
     for i = 1:n
         A[i] = f(t[i], s[i])
     end
-    (A...,)
+    (A...)
 end
 # n argument function
-heads() = ()
-heads(t::Tuple, ts::Tuple...) = (t[1], heads(ts...)...)
-tails() = ()
-tails(t::Tuple, ts::Tuple...) = (tail(t), tails(ts...)...)
-map(f, ::Tuple{}, ts::Tuple...) = ()
-map(f, t1::Tuple, t2::Tuple, ts::Tuple...) = (f(heads(t1, t2, ts...)...), map(f, tails(t1, t2, ts...)...)...)
-
-
-# type-stable padding
-fill_to_length{N}(t::Tuple, val, ::Type{Val{N}}) = _ftl((), val, Val{N}, t...)
-_ftl{N}(out::NTuple{N,Any}, val, ::Type{Val{N}}) = out
-function _ftl{N}(out::NTuple{N,Any}, val, ::Type{Val{N}}, t...)
+heads(ts::Tuple...) = map(t -> t[1], ts)
+tails(ts::Tuple...) = map(tail, ts)
+map(f, ::Tuple{}...) = ()
+function map(f, t1::Tuple, t2::Tuple, ts::Tuple...)
     @_inline_meta
-    throw(ArgumentError("input tuple of length $(N+length(t)), requested $N"))
+    (f(heads(t1, t2, ts...)...), map(f, tails(t1, t2, ts...)...)...)
 end
-function _ftl{N}(out, val, ::Type{Val{N}}, t1, t...)
-    @_inline_meta
-    _ftl((out..., t1), val, Val{N}, t...)
-end
-function _ftl{N}(out, val, ::Type{Val{N}})
-    @_inline_meta
-    _ftl((out..., val), val, Val{N})
+function map(f, t1::Any16, t2::Any16, ts::Any16...)
+    n = length(t1)
+    A = Array{Any,1}(n)
+    for i = 1:n
+        A[i] = f(t1[i], t2[i], map(t -> t[i], ts)...)
+    end
+    (A...)
 end
 
+
+# type-stable padding
+fill_to_length(t::NTuple{N,Any}, val, ::Val{N}) where {N} = t
+fill_to_length(t::Tuple{}, val, ::Val{1}) = (val,)
+fill_to_length(t::Tuple{Any}, val, ::Val{2}) = (t..., val)
+fill_to_length(t::Tuple{}, val, ::Val{2}) = (val, val)
+#function fill_to_length(t::Tuple, val, ::Val{N}) where {N}
+#    @_inline_meta
+#    return (t..., ntuple(i -> val, N - length(t))...)
+#end
+
 # constructing from an iterator
 
 # only define these in Base, to avoid overwriting the constructors
 if isdefined(Main, :Base)
 
-(::Type{T}){T<:Tuple}(x::Tuple) = convert(T, x)  # still use `convert` for tuples
+(::Type{T})(x::Tuple) where {T<:Tuple} = convert(T, x)  # still use `convert` for tuples
+
+# resolve ambiguity between preceding and following methods
+All16{E,N}(x::Tuple) where {E,N} = convert(All16{E,N}, x)
 
-function (T::Type{All16{E,N}}){E,N}(itr)
+function (T::All16{E,N})(itr) where {E,N}
     len = N+16
     elts = collect(E, Iterators.take(itr,len))
     if length(elts) != len
@@ -195,11 +215,11 @@ function (T::Type{All16{E,N}}){E,N}(itr)
     (elts...,)
 end
 
-(::Type{T}){T<:Tuple}(itr) = _totuple(T, itr, start(itr))
+(::Type{T})(itr) where {T<:Tuple} = _totuple(T, itr, start(itr))
 
 _totuple(::Type{Tuple{}}, itr, s) = ()
 
-function _totuple_err(T::ANY)
+function _totuple_err(@nospecialize T)
     @_noinline_meta
     throw(ArgumentError("too few elements for tuple type $T"))
 end
@@ -211,7 +231,7 @@ function _totuple(T, itr, s)
     (convert(tuple_type_head(T), v), _totuple(tuple_type_tail(T), itr, s)...)
 end
 
-_totuple{E}(::Type{Tuple{Vararg{E}}}, itr, s) = (collect(E, Iterators.rest(itr,s))...,)
+_totuple(::Type{Tuple{Vararg{E}}}, itr, s) where {E} = (collect(E, Iterators.rest(itr,s))...,)
 
 _totuple(::Type{Tuple}, itr, s) = (collect(Iterators.rest(itr,s))...,)
 
diff --git a/base/twiceprecision.jl b/base/twiceprecision.jl
index ea92f6c44d2d1e..6607c12e1d1ce5 100644
--- a/base/twiceprecision.jl
+++ b/base/twiceprecision.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Twice-precision arithmetic.
 
@@ -35,21 +35,21 @@ struct TwicePrecision{T}
     lo::T    # least significant bits
 end
 
-function (::Type{TwicePrecision{T}}){T,I}(nd::Tuple{I,I})
+function TwicePrecision{T}(nd::Tuple{I,I}) where {T,I}
     n, d = nd
     TwicePrecision{T}(n, zero(T)) / d
 end
 
-function (::Type{TwicePrecision{T}}){T,I}(nd::Tuple{I,I}, nb::Integer)
+function TwicePrecision{T}(nd::Tuple{I,I}, nb::Integer) where {T,I}
     twiceprecision(TwicePrecision{T}(nd), nb)
 end
 
-function twiceprecision{T<:Number}(val::T, nb::Integer)
+function twiceprecision(val::T, nb::Integer) where T<:Number
     hi = truncbits(val, nb)
     TwicePrecision{T}(hi, val - hi)
 end
 
-function twiceprecision{T<:Number}(val::TwicePrecision{T}, nb::Integer)
+function twiceprecision(val::TwicePrecision{T}, nb::Integer) where T<:Number
     hi = truncbits(val.hi, nb)
     TwicePrecision{T}(hi, (val.hi - hi) + val.lo)
 end
@@ -60,19 +60,19 @@ nbitslen(::Type{Float32}, len, offset) = min(12, nbitslen(len, offset))
 nbitslen(::Type{Float16}, len, offset) = min(5,  nbitslen(len, offset))
 nbitslen(len, offset) = len < 2 ? 0 : ceil(Int, log2(max(offset-1, len-offset)))
 
-eltype{T}(::Type{TwicePrecision{T}}) = T
+eltype(::Type{TwicePrecision{T}}) where {T} = T
 
-promote_rule{R,S}(::Type{TwicePrecision{R}}, ::Type{TwicePrecision{S}}) =
+promote_rule(::Type{TwicePrecision{R}}, ::Type{TwicePrecision{S}}) where {R,S} =
     TwicePrecision{promote_type(R,S)}
-promote_rule{R,S}(::Type{TwicePrecision{R}}, ::Type{S}) =
+promote_rule(::Type{TwicePrecision{R}}, ::Type{S}) where {R,S} =
     TwicePrecision{promote_type(R,S)}
 
-convert{T}(::Type{TwicePrecision{T}}, x::TwicePrecision{T}) = x
-convert{T}(::Type{TwicePrecision{T}}, x::TwicePrecision) =
+convert(::Type{TwicePrecision{T}}, x::TwicePrecision{T}) where {T} = x
+convert(::Type{TwicePrecision{T}}, x::TwicePrecision) where {T} =
     TwicePrecision{T}(convert(T, x.hi), convert(T, x.lo))
 
-convert{T<:Number}(::Type{T}, x::TwicePrecision{T}) = convert(T, x.hi + x.lo)
-convert{T}(::Type{TwicePrecision{T}}, x::Number) = TwicePrecision{T}(convert(T, x), zero(T))
+convert(::Type{T}, x::TwicePrecision) where {T<:Number} = convert(T, x.hi + x.lo)
+convert(::Type{TwicePrecision{T}}, x::Number) where {T} = TwicePrecision{T}(convert(T, x), zero(T))
 
 float(x::TwicePrecision{<:AbstractFloat}) = x
 float(x::TwicePrecision) = TwicePrecision(float(x.hi), float(x.lo))
@@ -81,16 +81,16 @@ big(x::TwicePrecision) = big(x.hi) + big(x.lo)
 
 -(x::TwicePrecision) = TwicePrecision(-x.hi, -x.lo)
 
-zero{T}(::Type{TwicePrecision{T}}) = TwicePrecision{T}(0, 0)
+zero(::Type{TwicePrecision{T}}) where {T} = TwicePrecision{T}(0, 0)
 
 ## StepRangeLen
 
 # If using TwicePrecision numbers, deliberately force user to specify offset
-StepRangeLen{T}(ref::TwicePrecision{T}, step::TwicePrecision{T}, len::Integer, offset::Integer) =
+StepRangeLen(ref::TwicePrecision{T}, step::TwicePrecision{T}, len::Integer, offset::Integer) where {T} =
     StepRangeLen{T,TwicePrecision{T},TwicePrecision{T}}(ref, step, len, offset)
 
 # Construct range for rational start=start_n/den, step=step_n/den
-function floatrange{T}(::Type{T}, start_n::Integer, step_n::Integer, len::Integer, den::Integer)
+function floatrange(::Type{T}, start_n::Integer, step_n::Integer, len::Integer, den::Integer) where T
     if len < 2
         return StepRangeLen(TwicePrecision{T}((start_n, den)),
                             TwicePrecision{T}((step_n, den)), Int(len), 1)
@@ -106,7 +106,7 @@ end
 
 function floatrange(a::AbstractFloat, st::AbstractFloat, len::Real, divisor::AbstractFloat)
     T = promote_type(typeof(a), typeof(st), typeof(divisor))
-    m = maxintfloat(T)
+    m = maxintfloat(T, Int)
     if abs(a) <= m && abs(st) <= m && abs(divisor) <= m
         ia, ist, idivisor = round(Int, a), round(Int, st), round(Int, divisor)
         if ia == a && ist == st && idivisor == divisor
@@ -120,7 +120,7 @@ function floatrange(a::AbstractFloat, st::AbstractFloat, len::Real, divisor::Abs
                  TwicePrecision{T}((st,divisor), nbitslen(T, len, 1)), Int(len), 1)
 end
 
-function colon{T<:Union{Float16,Float32,Float64}}(start::T, step::T, stop::T)
+function colon(start::T, step::T, stop::T) where T<:Union{Float16,Float32,Float64}
     step == 0 && throw(ArgumentError("range step cannot be zero"))
     # see if the inputs have exact rational approximations (and if so,
     # perform all computations in terms of the rationals)
@@ -131,7 +131,7 @@ function colon{T<:Union{Float16,Float32,Float64}}(start::T, step::T, stop::T)
         if start_d != 0 && stop_d != 0 &&
                 T(start_n/start_d) == start && T(stop_n/stop_d) == stop
             den = lcm(start_d, step_d) # use same denominator for start and step
-            m = maxintfloat(T)
+            m = maxintfloat(T, Int)
             if den != 0 && abs(start*den) <= m && abs(step*den) <= m &&  # will round succeed?
                     rem(den, start_d) == 0 && rem(den, step_d) == 0      # check lcm overflow
                 start_n = round(Int, start*den)
@@ -161,13 +161,13 @@ function colon{T<:Union{Float16,Float32,Float64}}(start::T, step::T, stop::T)
     StepRangeLen(TwicePrecision(start, zero(T)), twiceprecision(step, nbitslen(T, len, 1)), len)
 end
 
-function range{T<:Union{Float16,Float32,Float64}}(a::T, st::T, len::Integer)
+function range(a::T, st::T, len::Integer) where T<:Union{Float16,Float32,Float64}
     start_n, start_d = rat(a)
     step_n, step_d = rat(st)
     if start_d != 0 && step_d != 0 &&
             T(start_n/start_d) == a && T(step_n/step_d) == st
         den = lcm(start_d, step_d)
-        m = maxintfloat(T)
+        m = maxintfloat(T, Int)
         if abs(den*a) <= m && abs(den*st) <= m &&
                 rem(den, start_d) == 0 && rem(den, step_d) == 0
             start_n = round(Int, den*a)
@@ -178,7 +178,7 @@ function range{T<:Union{Float16,Float32,Float64}}(a::T, st::T, len::Integer)
     StepRangeLen(TwicePrecision(a, zero(T)), TwicePrecision(st, zero(T)), len)
 end
 
-step{T,R,S<:TwicePrecision}(r::StepRangeLen{T,R,S}) = convert(eltype(S), r.step)
+step(r::StepRangeLen{T,R,S}) where {T,R,S<:TwicePrecision} = convert(eltype(S), r.step)
 
 start(r::StepRangeLen{<:Any,<:TwicePrecision,<:TwicePrecision}) = 1
 done(r::StepRangeLen{<:Any,<:TwicePrecision,<:TwicePrecision}, i::Int) = length(r) < i
@@ -188,7 +188,7 @@ function next(r::StepRangeLen{<:Any,<:TwicePrecision,<:TwicePrecision}, i::Int)
 end
 
 # This assumes that r.step has already been split so that (0:len-1)*r.step.hi is exact
-function unsafe_getindex{T}(r::StepRangeLen{T,<:TwicePrecision,<:TwicePrecision}, i::Integer)
+function unsafe_getindex(r::StepRangeLen{T,<:TwicePrecision,<:TwicePrecision}, i::Integer) where T
     # Very similar to _getindex_hiprec, but optimized to avoid a 2nd call to add2
     @_inline_meta
     u = i - r.offset
@@ -205,7 +205,7 @@ function _getindex_hiprec(r::StepRangeLen{<:Any,<:TwicePrecision,<:TwicePrecisio
     TwicePrecision(x_hi, x_lo)
 end
 
-function getindex{T}(r::StepRangeLen{T,<:TwicePrecision,<:TwicePrecision}, s::OrdinalRange{<:Integer})
+function getindex(r::StepRangeLen{T,<:TwicePrecision,<:TwicePrecision}, s::OrdinalRange{<:Integer}) where T
     @_inline_meta
     @boundscheck checkbounds(r, s)
     soffset = 1 + round(Int, (r.offset - first(s))/step(s))
@@ -229,26 +229,26 @@ end
 /(r::StepRangeLen{<:Real,<:TwicePrecision}, x::Real) =
     StepRangeLen(r.ref/x, twiceprecision(r.step/x, nbitslen(r)), length(r), r.offset)
 
-convert{T<:AbstractFloat,R<:TwicePrecision,S<:TwicePrecision}(::Type{StepRangeLen{T,R,S}}, r::StepRangeLen{T,R,S}) = r
+convert(::Type{StepRangeLen{T,R,S}}, r::StepRangeLen{T,R,S}) where {T<:AbstractFloat,R<:TwicePrecision,S<:TwicePrecision} = r
 
-convert{T<:AbstractFloat,R<:TwicePrecision,S<:TwicePrecision}(::Type{StepRangeLen{T,R,S}}, r::StepRangeLen) =
+convert(::Type{StepRangeLen{T,R,S}}, r::StepRangeLen) where {T<:AbstractFloat,R<:TwicePrecision,S<:TwicePrecision} =
     _convertSRL(StepRangeLen{T,R,S}, r)
 
-convert{T<:Union{Float16,Float32,Float64}}(::Type{StepRangeLen{T}}, r::StepRangeLen) =
+convert(::Type{StepRangeLen{T}}, r::StepRangeLen) where {T<:Union{Float16,Float32,Float64}} =
     _convertSRL(StepRangeLen{T,TwicePrecision{T},TwicePrecision{T}}, r)
 
-convert{T<:Union{Float16,Float32,Float64}}(::Type{StepRangeLen{T}}, r::Range) =
+convert(::Type{StepRangeLen{T}}, r::Range) where {T<:Union{Float16,Float32,Float64}} =
     _convertSRL(StepRangeLen{T,TwicePrecision{T},TwicePrecision{T}}, r)
 
-function _convertSRL{T,R,S}(::Type{StepRangeLen{T,R,S}}, r::StepRangeLen{<:Integer})
+function _convertSRL(::Type{StepRangeLen{T,R,S}}, r::StepRangeLen{<:Integer}) where {T,R,S}
     StepRangeLen{T,R,S}(R(r.ref), S(r.step), length(r), r.offset)
 end
 
-function _convertSRL{T,R,S}(::Type{StepRangeLen{T,R,S}}, r::Range{<:Integer})
+function _convertSRL(::Type{StepRangeLen{T,R,S}}, r::Range{<:Integer}) where {T,R,S}
     StepRangeLen{T,R,S}(R(first(r)), S(step(r)), length(r))
 end
 
-function _convertSRL{T,R,S,U}(::Type{StepRangeLen{T,R,S}}, r::Range{U})
+function _convertSRL(::Type{StepRangeLen{T,R,S}}, r::Range{U}) where {T,R,S,U}
     # if start and step have a rational approximation in the old type,
     # then we transfer that rational approximation to the new type
     f, s = first(r), step(r)
@@ -257,7 +257,7 @@ function _convertSRL{T,R,S,U}(::Type{StepRangeLen{T,R,S}}, r::Range{U})
     if start_d != 0 && step_d != 0 &&
             U(start_n/start_d) == f && U(step_n/step_d) == s
         den = lcm(start_d, step_d)
-        m = maxintfloat(T)
+        m = maxintfloat(T, Int)
         if den != 0 && abs(f*den) <= m && abs(s*den) <= m &&
                 rem(den, start_d) == 0 && rem(den, step_d) == 0
             start_n = round(Int, f*den)
@@ -268,10 +268,10 @@ function _convertSRL{T,R,S,U}(::Type{StepRangeLen{T,R,S}}, r::Range{U})
     __convertSRL(StepRangeLen{T,R,S}, r)
 end
 
-function __convertSRL{T,R,S,U}(::Type{StepRangeLen{T,R,S}}, r::StepRangeLen{U})
+function __convertSRL(::Type{StepRangeLen{T,R,S}}, r::StepRangeLen{U}) where {T,R,S,U}
     StepRangeLen{T,R,S}(R(r.ref), S(r.step), length(r), r.offset)
 end
-function __convertSRL{T,R,S,U}(::Type{StepRangeLen{T,R,S}}, r::Range{U})
+function __convertSRL(::Type{StepRangeLen{T,R,S}}, r::Range{U}) where {T,R,S,U}
     StepRangeLen{T,R,S}(R(first(r)), S(step(r)), length(r))
 end
 
@@ -296,7 +296,7 @@ end
 # sum(1:n) as a product of two integers
 sumpair(n::Integer) = iseven(n) ? (n+1, n>>1) : (n, (n+1)>>1)
 
-function +{T,R<:TwicePrecision}(r1::StepRangeLen{T,R}, r2::StepRangeLen{T,R})
+function +(r1::StepRangeLen{T,R}, r2::StepRangeLen{T,R}) where T where R<:TwicePrecision
     len = length(r1)
     (len == length(r2) ||
         throw(DimensionMismatch("argument dimensions must match")))
@@ -316,7 +316,7 @@ end
 ## LinSpace
 
 # For Float16, Float32, and Float64, linspace returns a StepRangeLen
-function linspace{T<:Union{Float16,Float32,Float64}}(start::T, stop::T, len::Integer)
+function linspace(start::T, stop::T, len::Integer) where T<:Union{Float16,Float32,Float64}
     len < 2 && return _linspace1(T, start, stop, len)
     if start == stop
         return StepRangeLen(TwicePrecision(start,zero(T)), TwicePrecision(zero(T),zero(T)), len)
@@ -326,7 +326,7 @@ function linspace{T<:Union{Float16,Float32,Float64}}(start::T, stop::T, len::Int
     stop_n, stop_d = rat(stop)
     if start_d != 0 && stop_d != 0
         den = lcm(start_d, stop_d)
-        m = maxintfloat(T)
+        m = maxintfloat(T, Int)
         if den != 0 && abs(den*start) <= m && abs(den*stop) <= m
             start_n = round(Int, den*start)
             stop_n = round(Int, den*stop)
@@ -338,7 +338,7 @@ function linspace{T<:Union{Float16,Float32,Float64}}(start::T, stop::T, len::Int
     _linspace(start, stop, len)
 end
 
-function _linspace{T<:Union{Float16,Float32,Float64}}(start::T, stop::T, len::Integer)
+function _linspace(start::T, stop::T, len::Integer) where T<:Union{Float16,Float32,Float64}
     (isfinite(start) && isfinite(stop)) || throw(ArgumentError("start and stop must be finite, got $start and $stop"))
     # Find the index that returns the smallest-magnitude element
     Δ, Δfac = stop-start, 1
@@ -383,7 +383,7 @@ end
 
 # linspace for rational numbers, start = start_n/den, stop = stop_n/den
 # Note this returns a StepRangeLen
-function linspace{T}(::Type{T}, start_n::Integer, stop_n::Integer, len::Integer, den::Integer)
+function linspace(::Type{T}, start_n::Integer, stop_n::Integer, len::Integer, den::Integer) where T
     len < 2 && return _linspace1(T, start_n/den, stop_n/den, len)
     start_n == stop_n && return StepRangeLen(TwicePrecision{T}((start_n, den)), zero(TwicePrecision{T}), len)
     tmin = -start_n/(Float64(stop_n) - Float64(start_n))
@@ -403,7 +403,7 @@ function linspace{T}(::Type{T}, start_n::Integer, stop_n::Integer, len::Integer,
 end
 
 # For len < 2
-function _linspace1{T}(::Type{T}, start, stop, len::Integer)
+function _linspace1(::Type{T}, start, stop, len::Integer) where T
     len >= 0 || throw(ArgumentError("linspace($start, $stop, $len): negative length"))
     if len <= 1
         len == 1 && (start == stop || throw(ArgumentError("linspace($start, $stop, $len): endpoints differ")))
@@ -439,7 +439,7 @@ narrow(::Type{Float64}) = Float32
 narrow(::Type{Float32}) = Float16
 narrow(::Type{Float16}) = Float16
 
-function add2{T<:Number}(u::T, v::T)
+function add2(u::T, v::T) where T<:Number
     @_inline_meta
     u, v = ifelse(abs(v) > abs(u), (v, u), (u, v))
     w = u + v
@@ -447,7 +447,7 @@ function add2{T<:Number}(u::T, v::T)
 end
 
 add2(u, v) = _add2(promote(u, v)...)
-_add2{T<:Number}(u::T, v::T) = add2(u, v)
+_add2(u::T, v::T) where {T<:Number} = add2(u, v)
 _add2(u, v) = error("$u::$(typeof(u)) and $v::$(typeof(v)) cannot be promoted to a common type")
 
 function +(x::TwicePrecision, y::Number)
@@ -456,13 +456,13 @@ function +(x::TwicePrecision, y::Number)
 end
 +(x::Number, y::TwicePrecision) = y+x
 
-function +{T}(x::TwicePrecision{T}, y::TwicePrecision{T})
+function +(x::TwicePrecision{T}, y::TwicePrecision{T}) where T
     r = x.hi + y.hi
     s = abs(x.hi) > abs(y.hi) ? (((x.hi - r) + y.hi) + y.lo) + x.lo : (((y.hi - r) + x.hi) + x.lo) + y.lo
     TwicePrecision(r, s)
 end
 +(x::TwicePrecision, y::TwicePrecision) = _add2(promote(x, y)...)
-_add2{T<:TwicePrecision}(x::T, y::T) = x + y
+_add2(x::T, y::T) where {T<:TwicePrecision} = x + y
 _add2(x::TwicePrecision, y::TwicePrecision) = TwicePrecision(x.hi+y.hi, x.lo+y.lo)
 
 function *(x::TwicePrecision, v::Integer)
@@ -473,7 +473,7 @@ function *(x::TwicePrecision, v::Integer)
     TwicePrecision(y_hi, y_lo)
 end
 
-function _mul2{T<:Union{Float16,Float32,Float64}}(x::TwicePrecision{T}, v::T)
+function _mul2(x::TwicePrecision{T}, v::T) where T<:Union{Float16,Float32,Float64}
     v == 0 && return TwicePrecision(T(0), T(0))
     xhh, xhl = splitprec(x.hi)
     vh, vl = splitprec(v)
@@ -483,7 +483,7 @@ end
 
 _mul2(x::TwicePrecision, v::Number) = TwicePrecision(x.hi*v, x.lo*v)
 
-function *{R,S<:Number}(x::TwicePrecision{R}, v::S)
+function *(x::TwicePrecision{R}, v::S) where R where S<:Number
     T = promote_type(R, S)
     _mul2(convert(TwicePrecision{T}, x), convert(T, v))
 end
diff --git a/base/util.jl b/base/util.jl
index 2e467e2a2de4f6..413b304fb0ab44 100644
--- a/base/util.jl
+++ b/base/util.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # timing
 
@@ -82,7 +82,7 @@ gc_bytes() = ccall(:jl_gc_total_bytes, Int64, ())
 Set a timer to be read by the next call to [`toc`](@ref) or [`toq`](@ref). The
 macro call `@time expr` can also be used to time evaluation.
 
-```julia
+```julia-repl
 julia> tic()
 0x0000c45bc7abac95
 
@@ -105,7 +105,7 @@ end
 Return, but do not print, the time elapsed since the last [`tic`](@ref). The
 macro calls `@timed expr` and `@elapsed expr` also return evaluation time.
 
-```julia
+```julia-repl
 julia> tic()
 0x0000c46477a9675d
 
@@ -132,7 +132,7 @@ end
 Print and return the time elapsed since the last [`tic`](@ref). The macro call
 `@time expr` can also be used to time evaluation.
 
-```julia
+```julia-repl
 julia> tic()
 0x0000c45bc7abac95
 
@@ -219,7 +219,7 @@ returning the value of the expression.
 See also [`@timev`](@ref), [`@timed`](@ref), [`@elapsed`](@ref), and
 [`@allocated`](@ref).
 
-```julia
+```julia-repl
 julia> @time rand(10^6);
   0.001525 seconds (7 allocations: 7.630 MiB)
 
@@ -228,6 +228,7 @@ julia> @time begin
            1+1
        end
   0.301395 seconds (8 allocations: 336 bytes)
+2
 ```
 """
 macro time(ex)
@@ -253,7 +254,7 @@ expression.
 See also [`@time`](@ref), [`@timed`](@ref), [`@elapsed`](@ref), and
 [`@allocated`](@ref).
 
-```julia
+```julia-repl
 julia> @timev rand(10^6);
   0.001006 seconds (7 allocations: 7.630 MiB)
 elapsed time (ns): 1005567
@@ -282,7 +283,7 @@ number of seconds it took to execute as a floating-point number.
 See also [`@time`](@ref), [`@timev`](@ref), [`@timed`](@ref),
 and [`@allocated`](@ref).
 
-```julia
+```julia-repl
 julia> @elapsed sleep(0.3)
 0.301391426
 ```
@@ -314,7 +315,7 @@ for the effects of compilation.
 See also [`@time`](@ref), [`@timev`](@ref), [`@timed`](@ref),
 and [`@elapsed`](@ref).
 
-```julia
+```julia-repl
 julia> @allocated rand(10^6)
 8000080
 ```
@@ -343,7 +344,7 @@ counters.
 See also [`@time`](@ref), [`@timev`](@ref), [`@elapsed`](@ref), and
 [`@allocated`](@ref).
 
-```julia
+```julia-repl
 julia> val, t, bytes, gctime, memallocs = @timed rand(10^6);
 
 julia> t
@@ -382,14 +383,6 @@ macro timed(ex)
     end
 end
 
-function fftw_vendor()
-    if Base.libfftw_name == "libmkl_rt"
-        return :mkl
-    else
-        return :fftw
-    end
-end
-
 
 ## printing with color ##
 
@@ -406,21 +399,21 @@ function with_output_color(f::Function, color::Union{Int, Symbol}, io::IO, args.
 end
 
 """
-    print_with_color(color::Union{Symbol, Int}, [io], strings...; bold::Bool = false)
+    print_with_color(color::Union{Symbol, Int}, [io], xs...; bold::Bool = false)
 
-Print strings in a color specified as a symbol.
+Print `xs` in a color specified as a symbol.
 
 `color` may take any of the values $(Base.available_text_colors_docstring)
 or an integer between 0 and 255 inclusive. Note that not all terminals support 256 colors.
 If the keyword `bold` is given as `true`, the result will be printed in bold.
 """
-print_with_color(color::Union{Int, Symbol}, io::IO, msg::AbstractString...; bold::Bool = false) =
+print_with_color(color::Union{Int, Symbol}, io::IO, msg...; bold::Bool = false) =
     with_output_color(print, color, io, msg...; bold = bold)
-print_with_color(color::Union{Int, Symbol}, msg::AbstractString...; bold::Bool = false) =
+print_with_color(color::Union{Int, Symbol}, msg...; bold::Bool = false) =
     print_with_color(color, STDOUT, msg...; bold = bold)
-println_with_color(color::Union{Int, Symbol}, io::IO, msg::AbstractString...; bold::Bool = false) =
+println_with_color(color::Union{Int, Symbol}, io::IO, msg...; bold::Bool = false) =
     with_output_color(println, color, io, msg...; bold = bold)
-println_with_color(color::Union{Int, Symbol}, msg::AbstractString...; bold::Bool = false) =
+println_with_color(color::Union{Int, Symbol}, msg...; bold::Bool = false) =
     println_with_color(color, STDOUT, msg...; bold = bold)
 
 ## warnings and messages ##
@@ -431,7 +424,8 @@ const log_error_to = Dict{Tuple{Union{Module,Void},Union{Symbol,Void}},IO}()
 
 function _redirect(io::IO, log_to::Dict, sf::StackTraces.StackFrame)
     isnull(sf.linfo) && return io
-    mod = get(sf.linfo).def.module
+    mod = get(sf.linfo).def
+    isa(mod, Method) && (mod = mod.module)
     fun = sf.func
     if haskey(log_to, (mod,fun))
         return log_to[(mod,fun)]
@@ -456,7 +450,9 @@ function _redirect(io::IO, log_to::Dict, fun::Symbol)
             isnull(frame.linfo) && continue
             sf = frame
             break_next_frame && (@goto skip)
-            get(frame.linfo).def.module == Base || continue
+            mod = get(frame.linfo).def
+            isa(mod, Method) && (mod = mod.module)
+            mod === Base || continue
             sff = string(frame.func)
             if frame.func == fun || startswith(sff, clos) || startswith(sff, kw)
                 break_next_frame = true
@@ -513,6 +509,7 @@ Argument `msg` is a string describing the information to be displayed.
 The `prefix` keyword argument can be used to override the default
 prepending of `msg`.
 
+# Examples
 ```jldoctest
 julia> info("hello world")
 INFO: hello world
@@ -577,6 +574,7 @@ end
 
 Display a warning. Argument `msg` is a string describing the warning to be displayed.
 
+# Examples
 ```jldoctest
 julia> warn("Beep Beep")
 WARNING: Beep Beep
@@ -619,7 +617,13 @@ function julia_cmd(julia=joinpath(JULIA_HOME, julia_exename()))
     `$julia -C$cpu_target -J$image_file --compile=$compile --depwarn=$depwarn`
 end
 
-julia_exename() = ccall(:jl_is_debugbuild,Cint,())==0 ? "julia" : "julia-debug"
+function julia_exename()
+    if ccall(:jl_is_debugbuild, Cint, ()) == 0
+        return @static Sys.iswindows() ? "julia.exe" : "julia"
+    else
+        return @static Sys.iswindows() ? "julia-debug.exe" : "julia-debug"
+    end
+end
 
 """
     securezero!(o)
@@ -632,15 +636,15 @@ will always be called.
 function securezero! end
 @noinline securezero!(a::AbstractArray{<:Number}) = fill!(a, 0)
 securezero!(s::String) = unsafe_securezero!(pointer(s), sizeof(s))
-@noinline unsafe_securezero!{T}(p::Ptr{T}, len::Integer=1) =
+@noinline unsafe_securezero!(p::Ptr{T}, len::Integer=1) where {T} =
     ccall(:memset, Ptr{T}, (Ptr{T}, Cint, Csize_t), p, 0, len*sizeof(T))
 unsafe_securezero!(p::Ptr{Void}, len::Integer=1) = Ptr{Void}(unsafe_securezero!(Ptr{UInt8}(p), len))
 
-if is_windows()
+if Sys.iswindows()
 function getpass(prompt::AbstractString)
     print(prompt)
     flush(STDOUT)
-    p = Array{UInt8}(128) # mimic Unix getpass in ignoring more than 128-char passwords
+    p = Vector{UInt8}(128) # mimic Unix getpass in ignoring more than 128-char passwords
                           # (also avoids any potential memory copies arising from push!)
     try
         plen = 0
@@ -669,7 +673,7 @@ getpass(prompt::AbstractString) = unsafe_string(ccall(:getpass, Cstring, (Cstrin
 end
 
 # Windows authentication prompt
-if is_windows()
+if Sys.iswindows()
     struct CREDUI_INFO
         cbSize::UInt32
         parent::Ptr{Void}
@@ -758,14 +762,56 @@ end
 
 """
     crc32c(data, crc::UInt32=0x00000000)
+
 Compute the CRC-32c checksum of the given `data`, which can be
-an `Array{UInt8}` or a `String`.  Optionally, you can pass
-a starting `crc` integer to be mixed in with the checksum.
+an `Array{UInt8}`, a contiguous subarray thereof, or a `String`.  Optionally, you can pass
+a starting `crc` integer to be mixed in with the checksum.  The `crc` parameter
+can be used to compute a checksum on data divided into chunks: performing
+`crc32c(data2, crc32c(data1))` is equivalent to the checksum of `[data1; data2]`.
 (Technically, a little-endian checksum is computed.)
+
+There is also a method `crc32c(io, nb, crc)` to checksum `nb` bytes from
+a stream `io`, or `crc32c(io, crc)` to checksum all the remaining bytes.
+Hence you can do [`open(crc32c, filename)`](@ref) to checksum an entire file,
+or `crc32c(seekstart(buf))` to checksum an [`IOBuffer`](@ref) without
+calling [`take!`](@ref).
+
+For a `String`, note that the result is specific to the UTF-8 encoding
+(a different checksum would be obtained from a different Unicode encoding).
+To checksum an `a::Array` of some other bitstype, you can do `crc32c(reinterpret(UInt8,a))`,
+but note that the result may be endian-dependent.
 """
 function crc32c end
-crc32c(a::Union{Array{UInt8},String}, crc::UInt32=0x00000000) =
-    ccall(:jl_crc32c, UInt32, (UInt32, Ptr{UInt8}, Csize_t), crc, a, sizeof(a))
+
+unsafe_crc32c(a, n, crc) = ccall(:jl_crc32c, UInt32, (UInt32, Ptr{UInt8}, Csize_t), crc, a, n)
+
+crc32c(a::Union{Array{UInt8},FastContiguousSubArray{UInt8,N,<:Array{UInt8}} where N}, crc::UInt32=0x00000000) =
+    unsafe_crc32c(a, length(a) % Csize_t, crc)
+
+crc32c(s::String, crc::UInt32=0x00000000) = unsafe_crc32c(s, sizeof(s) % Csize_t, crc)
+
+"""
+    crc32c(io::IO, [nb::Integer,] crc::UInt32=0x00000000)
+
+Read up to `nb` bytes from `io` and return the CRC-32c checksum, optionally
+mixed with a starting `crc` integer.  If `nb` is not supplied, then
+`io` will be read until the end of the stream.
+"""
+function crc32c(io::IO, nb::Integer, crc::UInt32=0x00000000)
+    nb < 0 && throw(ArgumentError("number of bytes to checksum must be ≥ 0"))
+    # use block size 24576=8192*3, since that is the threshold for
+    # 3-way parallel SIMD code in the underlying jl_crc32c C function.
+    buf = Array{UInt8}(min(nb, 24576))
+    while !eof(io) && nb > 24576
+        n = readbytes!(io, buf)
+        crc = unsafe_crc32c(buf, n, crc)
+        nb -= n
+    end
+    return unsafe_crc32c(buf, readbytes!(io, buf, min(nb, length(buf))), crc)
+end
+crc32c(io::IO, crc::UInt32=0x00000000) = crc32c(io, typemax(Int64), crc)
+crc32c(io::IOStream, crc::UInt32=0x00000000) = crc32c(io, filesize(io)-position(io), crc)
+
 
 """
     @kwdef typedef
@@ -776,17 +822,24 @@ expression. The default argument is supplied by declaring fields of the form `fi
 default`. If no default is provided then the default is provided by the `kwdef_val(T)`
 function.
 
-```julia
-@kwdef struct Foo
-    a::Cint            # implied default Cint(0)
-    b::Cint = 1        # specified default
-    z::Cstring         # implied default Cstring(C_NULL)
-    y::Bar             # implied default Bar()
-end
+# Examples
+```jldoctest
+julia> struct Bar end
+
+julia> Base.@kwdef struct Foo
+           a::Cint            # implied default Cint(0)
+           b::Cint = 1        # specified default
+           z::Cstring         # implied default Cstring(C_NULL)
+           y::Bar             # implied default Bar()
+       end
+Foo
+
+julia> Foo()
+Foo(0, 1, Cstring(0x0000000000000000), Bar())
 ```
 """
 macro kwdef(expr)
-    expr = macroexpand(expr) # to expand @static
+    expr = macroexpand(__module__, expr) # to expand @static
     T = expr.args[2]
     params_ex = Expr(:parameters)
     call_ex = Expr(:call, T)
@@ -835,13 +888,30 @@ The default value for a type for use with the `@kwdef` macro. Returns:
  - null pointer for pointer types (`Ptr{T}`, `Cstring`, `Cwstring`)
  - zero for integer types
  - no-argument constructor calls (e.g. `T()`) for all other types
+
+# Examples
+```jldoctest
+julia> struct Foo
+           i::Int
+       end
+
+julia> Base.kwdef_val(::Type{Foo}) = Foo(42)
+
+julia> Base.@kwdef struct Bar
+           y::Foo
+       end
+Bar
+
+julia> Bar()
+Bar(Foo(42))
+```
 """
 function kwdef_val end
 
-kwdef_val{T}(::Type{Ptr{T}}) = Ptr{T}(C_NULL)
+kwdef_val(::Type{Ptr{T}}) where {T} = Ptr{T}(C_NULL)
 kwdef_val(::Type{Cstring}) = Cstring(C_NULL)
 kwdef_val(::Type{Cwstring}) = Cwstring(C_NULL)
 
-kwdef_val{T<:Integer}(::Type{T}) = zero(T)
+kwdef_val(::Type{T}) where {T<:Integer} = zero(T)
 
-kwdef_val{T}(::Type{T}) = T()
+kwdef_val(::Type{T}) where {T} = T()
diff --git a/base/version.jl b/base/version.jl
index 956763ce273441..05019bb0eb34ff 100644
--- a/base/version.jl
+++ b/base/version.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## semantic version numbers (http://semver.org)
 
@@ -87,6 +87,7 @@ function split_idents(s::AbstractString)
 end
 
 function VersionNumber(v::AbstractString)
+    v == "∞" && return typemax(VersionNumber)
     m = match(VERSION_REGEX, v)
     m === nothing && throw(ArgumentError("invalid version string: $v"))
     major, minor, patch, minus, prerl, plus, build = m.captures
@@ -98,7 +99,7 @@ function VersionNumber(v::AbstractString)
     end
     prerl = prerl !== nothing ? split_idents(prerl) : minus !== nothing ? ("",) : ()
     build = build !== nothing ? split_idents(build) : plus  !== nothing ? ("",) : ()
-    VersionNumber(major, minor, patch, prerl, build)
+    return VersionNumber(major, minor, patch, prerl, build)
 end
 
 convert(::Type{VersionNumber}, v::AbstractString) = VersionNumber(v)
@@ -223,10 +224,12 @@ catch e
     VersionNumber(0)
 end
 
+const libllvm_version = convert(VersionNumber, libllvm_version_string)
+
 function banner(io::IO = STDOUT)
     if GIT_VERSION_INFO.tagged_commit
         commit_string = TAGGED_RELEASE_BANNER
-    elseif GIT_VERSION_INFO.commit == ""
+    elseif isempty(GIT_VERSION_INFO.commit)
         commit_string = ""
     else
         days = Int(floor((ccall(:jl_clock_now, Float64, ()) - GIT_VERSION_INFO.fork_master_timestamp) / (60 * 60 * 24)))
@@ -242,20 +245,20 @@ function banner(io::IO = STDOUT)
             commit_string = "$(branch)/$(commit) (fork: $(distance) commits, $(days) $(unit))"
         end
     end
-    commit_date = GIT_VERSION_INFO.date_string != "" ? " ($(GIT_VERSION_INFO.date_string))": ""
+    commit_date = !isempty(GIT_VERSION_INFO.date_string) ? " ($(GIT_VERSION_INFO.date_string))" : ""
 
     if have_color
         c = text_colors
         tx = c[:normal] # text
         jl = c[:normal] # julia
-        d1 = c[:bold] * c[:light_blue]    # first dot
-        d2 = c[:bold] * c[:light_red]     # second dot
-        d3 = c[:bold] * c[:light_green]   # third dot
-        d4 = c[:bold] * c[:light_magenta] # fourth dot
+        d1 = c[:bold] * c[:blue]    # first dot
+        d2 = c[:bold] * c[:red]     # second dot
+        d3 = c[:bold] * c[:green]   # third dot
+        d4 = c[:bold] * c[:magenta] # fourth dot
 
         print(io,"""               $(d3)_$(tx)
            $(d1)_$(tx)       $(jl)_$(tx) $(d2)_$(d3)(_)$(d4)_$(tx)     |  A fresh approach to technical computing
-          $(d1)(_)$(jl)     | $(d2)(_)$(tx) $(d4)(_)$(tx)    |  Documentation: http://docs.julialang.org
+          $(d1)(_)$(jl)     | $(d2)(_)$(tx) $(d4)(_)$(tx)    |  Documentation: https://docs.julialang.org
            $(jl)_ _   _| |_  __ _$(tx)   |  Type \"?help\" for help.
           $(jl)| | | | | | |/ _` |$(tx)  |
           $(jl)| | |_| | | | (_| |$(tx)  |  Version $(VERSION)$(commit_date)
@@ -267,7 +270,7 @@ function banner(io::IO = STDOUT)
         print(io,"""
                        _
            _       _ _(_)_     |  A fresh approach to technical computing
-          (_)     | (_) (_)    |  Documentation: http://docs.julialang.org
+          (_)     | (_) (_)    |  Documentation: https://docs.julialang.org
            _ _   _| |_  __ _   |  Type \"?help\" for help.
           | | | | | | |/ _` |  |
           | | |_| | | | (_| |  |  Version $(VERSION)$(commit_date)
diff --git a/base/version_git.sh b/base/version_git.sh
index 35f54e92bf1770..5335c8f8abed56 100644
--- a/base/version_git.sh
+++ b/base/version_git.sh
@@ -1,5 +1,5 @@
 #!/bin/sh
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # This file collects git info and create a julia file with the GIT_VERSION_INFO struct
 
diff --git a/base/weakkeydict.jl b/base/weakkeydict.jl
index a20be01394a265..17712ebc2f9f6d 100644
--- a/base/weakkeydict.jl
+++ b/base/weakkeydict.jl
@@ -1,3 +1,5 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
 # weak key dictionaries
 
 """
@@ -46,10 +48,10 @@ WeakKeyDict() = WeakKeyDict{Any,Any}()
 WeakKeyDict(kv::Tuple{}) = WeakKeyDict()
 copy(d::WeakKeyDict) = WeakKeyDict(d)
 
-WeakKeyDict{K,V}(ps::Pair{K,V}...)            = WeakKeyDict{K,V}(ps)
-WeakKeyDict{K  }(ps::Pair{K}...,)             = WeakKeyDict{K,Any}(ps)
-WeakKeyDict{V  }(ps::(Pair{K,V} where K)...,) = WeakKeyDict{Any,V}(ps)
-WeakKeyDict(     ps::Pair...)                 = WeakKeyDict{Any,Any}(ps)
+WeakKeyDict(ps::Pair{K,V}...)           where {K,V} = WeakKeyDict{K,V}(ps)
+WeakKeyDict(ps::Pair{K}...)             where {K}   = WeakKeyDict{K,Any}(ps)
+WeakKeyDict(ps::(Pair{K,V} where K)...) where {V}   = WeakKeyDict{Any,V}(ps)
+WeakKeyDict(ps::Pair...)                            = WeakKeyDict{Any,Any}(ps)
 
 function WeakKeyDict(kv)
     try
@@ -63,11 +65,11 @@ function WeakKeyDict(kv)
     end
 end
 
-similar{K,V}(d::WeakKeyDict{K,V}) = WeakKeyDict{K,V}()
-similar{K,V}(d::WeakKeyDict, ::Type{Pair{K,V}}) = WeakKeyDict{K,V}()
+similar(d::WeakKeyDict{K,V}) where {K,V} = WeakKeyDict{K,V}()
+similar(d::WeakKeyDict, ::Type{Pair{K,V}}) where {K,V} = WeakKeyDict{K,V}()
 
 # conversion between Dict types
-function convert{K,V}(::Type{WeakKeyDict{K,V}},d::Associative)
+function convert(::Type{WeakKeyDict{K,V}},d::Associative) where V where K
     h = WeakKeyDict{K,V}()
     for (k,v) in d
         ck = convert(K,k)
@@ -79,13 +81,13 @@ function convert{K,V}(::Type{WeakKeyDict{K,V}},d::Associative)
     end
     return h
 end
-convert{K,V}(::Type{WeakKeyDict{K,V}},d::WeakKeyDict{K,V}) = d
+convert(::Type{WeakKeyDict{K,V}},d::WeakKeyDict{K,V}) where {K,V} = d
 
 islocked(wkh::WeakKeyDict) = islocked(wkh.lock)
 lock(f, wkh::WeakKeyDict) = lock(f, wkh.lock)
 trylock(f, wkh::WeakKeyDict) = trylock(f, wkh.lock)
 
-function setindex!{K}(wkh::WeakKeyDict{K}, v, key)
+function setindex!(wkh::WeakKeyDict{K}, v, key) where K
     k = convert(K, key)
     finalizer(k, wkh.finalizer)
     lock(wkh) do
@@ -94,7 +96,7 @@ function setindex!{K}(wkh::WeakKeyDict{K}, v, key)
     return wkh
 end
 
-function getkey{K}(wkh::WeakKeyDict{K}, kk, default)
+function getkey(wkh::WeakKeyDict{K}, kk, default) where K
     return lock(wkh) do
         k = getkey(wkh.ht, kk, secret_table_token)
         k === secret_table_token && return default
@@ -102,20 +104,20 @@ function getkey{K}(wkh::WeakKeyDict{K}, kk, default)
     end
 end
 
-get{K}(wkh::WeakKeyDict{K}, key, default) = lock(() -> get(wkh.ht, key, default), wkh)
-get{K}(default::Callable, wkh::WeakKeyDict{K}, key) = lock(() -> get(default, wkh.ht, key), wkh)
-get!{K}(wkh::WeakKeyDict{K}, key, default) = lock(() -> get!(wkh.ht, key, default), wkh)
-get!{K}(default::Callable, wkh::WeakKeyDict{K}, key) = lock(() -> get!(default, wkh.ht, key), wkh)
-pop!{K}(wkh::WeakKeyDict{K}, key) = lock(() -> pop!(wkh.ht, key), wkh)
-pop!{K}(wkh::WeakKeyDict{K}, key, default) = lock(() -> pop!(wkh.ht, key, default), wkh)
-delete!{K}(wkh::WeakKeyDict{K}, key) = lock(() -> delete!(wkh.ht, key), wkh)
+get(wkh::WeakKeyDict{K}, key, default) where {K} = lock(() -> get(wkh.ht, key, default), wkh)
+get(default::Callable, wkh::WeakKeyDict{K}, key) where {K} = lock(() -> get(default, wkh.ht, key), wkh)
+get!(wkh::WeakKeyDict{K}, key, default) where {K} = lock(() -> get!(wkh.ht, key, default), wkh)
+get!(default::Callable, wkh::WeakKeyDict{K}, key) where {K} = lock(() -> get!(default, wkh.ht, key), wkh)
+pop!(wkh::WeakKeyDict{K}, key) where {K} = lock(() -> pop!(wkh.ht, key), wkh)
+pop!(wkh::WeakKeyDict{K}, key, default) where {K} = lock(() -> pop!(wkh.ht, key, default), wkh)
+delete!(wkh::WeakKeyDict, key) = lock(() -> delete!(wkh.ht, key), wkh)
 empty!(wkh::WeakKeyDict) = (lock(() -> empty!(wkh.ht), wkh); wkh)
-haskey{K}(wkh::WeakKeyDict{K}, key) = lock(() -> haskey(wkh.ht, key), wkh)
-getindex{K}(wkh::WeakKeyDict{K}, key) = lock(() -> getindex(wkh.ht, key), wkh)
+haskey(wkh::WeakKeyDict{K}, key) where {K} = lock(() -> haskey(wkh.ht, key), wkh)
+getindex(wkh::WeakKeyDict{K}, key) where {K} = lock(() -> getindex(wkh.ht, key), wkh)
 isempty(wkh::WeakKeyDict) = isempty(wkh.ht)
 length(t::WeakKeyDict) = length(t.ht)
 
-function start{K,V}(t::WeakKeyDict{K,V})
+function start(t::WeakKeyDict{K,V}) where V where K
     gc_token = Ref{Bool}(false) # no keys will be deleted via finalizers until this token is gc'd
     finalizer(gc_token, function(r)
         if r[]
@@ -128,7 +130,7 @@ function start{K,V}(t::WeakKeyDict{K,V})
     return (start(t.ht), gc_token)
 end
 done(t::WeakKeyDict, i) = done(t.ht, i[1])
-function next{K,V}(t::WeakKeyDict{K,V}, i)
+function next(t::WeakKeyDict{K,V}, i)  where V where K
     gc_token = i[2]
     wkv, i = next(t.ht, i[1])
     kv = Pair{K,V}(wkv[1].value::K, wkv[2])
diff --git a/contrib/add_license_to_files.jl b/contrib/add_license_to_files.jl
index 7cfaae2ab9f0aa..57ce6788e09308 100644
--- a/contrib/add_license_to_files.jl
+++ b/contrib/add_license_to_files.jl
@@ -34,7 +34,8 @@ const skipfiles = [
     # files to check - already copyright
     # see: https://github.com/JuliaLang/julia/pull/11073#issuecomment-98099389
     "../base/special/trig.jl",
-    "../base/special/exp.jl"
+    "../base/special/exp.jl",
+    "../base/special/rem_pio2.jl",
     "../base/linalg/givens.jl",
     #
     "../src/abi_llvm.cpp",
@@ -58,7 +59,8 @@ const skipfiles = [
     "../src/support/tzfile.h",
     "../src/support/utf8.c",
     "../test/perf/micro/randmtzig.c",
-    "../src/support/crc32c.c",
+    "../src/crc32c.c",
+    "../examples/quine.jl", # has license text in code
 ]
 
 const ext_prefix = Dict([
@@ -69,7 +71,7 @@ const ext_prefix = Dict([
 (".cpp", "\/\/ "),
 ])
 
-const new_license = "This file is a part of Julia. License is MIT: http://julialang.org/license"
+const new_license = "This file is a part of Julia. License is MIT: https://julialang.org/license"
 
 # Old License text if such should be first removed - or empty string
 const old_license = ""
diff --git a/contrib/build_sysimg.jl b/contrib/build_sysimg.jl
index e26195286f84ac..7b77af8908a071 100644
--- a/contrib/build_sysimg.jl
+++ b/contrib/build_sysimg.jl
@@ -1,19 +1,19 @@
 #!/usr/bin/env julia
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # 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.
+# unless force is set to true. Allow targeting of a CPU architecture via cpu_target.
 function default_sysimg_path(debug=false)
-    if is_unix()
+    if Sys.isunix()
         splitext(Libdl.dlpath(debug ? "sys-debug" : "sys"))[1]
     else
-        joinpath(JULIA_HOME, "..", "lib", "julia", debug ? "sys-debug" : "sys")
+        joinpath(dirname(JULIA_HOME), "lib", "julia", debug ? "sys-debug" : "sys")
     end
 end
 
 """
-    build_sysimg(sysimg_path=default_sysimg_path, cpu_target="native", userimg_path=nothing; force=false)
+    build_sysimg(sysimg_path=default_sysimg_path(), cpu_target="native", userimg_path=nothing; force=false)
 
 Rebuild the system image. Store it in `sysimg_path`, which defaults to a file named `sys.ji`
 that sits in the same folder as `libjulia.{so,dylib}`, except on Windows where it defaults
@@ -33,8 +33,8 @@ function build_sysimg(sysimg_path=nothing, cpu_target="native", userimg_path=not
     sysimg = Libdl.dlopen_e("sys")
     if sysimg != C_NULL
         if !force && Base.samefile(Libdl.dlpath(sysimg), "$(sysimg_path).$(Libdl.dlext)")
-            info("System image already loaded at $(Libdl.dlpath(sysimg)), set force=true to override")
-            return
+            info("System image already loaded at $(Libdl.dlpath(sysimg)), set force=true to override.")
+            return nothing
         end
     end
 
@@ -47,24 +47,24 @@ function build_sysimg(sysimg_path=nothing, cpu_target="native", userimg_path=not
     base_dir = dirname(Base.find_source_file("sysimg.jl"))
     cd(base_dir) do
         julia = joinpath(JULIA_HOME, debug ? "julia-debug" : "julia")
-        cc = find_system_compiler()
+        cc, warn_msg = find_system_compiler()
 
         # Ensure we have write-permissions to wherever we're trying to write to
         try
             touch("$sysimg_path.ji")
         catch
             err_msg =  "Unable to modify $sysimg_path.ji, ensure parent directory exists "
-            err_msg *= "and is writable. Absolute paths work best.)"
-            error( err_msg )
+            err_msg *= "and is writable; absolute paths work best.)"
+            error(err_msg)
         end
 
         # Copy in userimg.jl if it exists
         if userimg_path !== nothing
             if !isfile(userimg_path)
-                error("$userimg_path is not found, ensure it is an absolute 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.")
+                error("$(joinpath(base_dir, "userimg.jl")) already exists, delete manually to continue.")
             end
             cp(userimg_path, "userimg.jl")
         end
@@ -72,28 +72,30 @@ function build_sysimg(sysimg_path=nothing, cpu_target="native", userimg_path=not
             # Start by building inference.{ji,o}
             inference_path = joinpath(dirname(sysimg_path), "inference")
             info("Building inference.o")
-            println("$julia -C $cpu_target --output-ji $inference_path.ji --output-o $inference_path.o coreimg.jl")
+            info("$julia -C $cpu_target --output-ji $inference_path.ji --output-o $inference_path.o coreimg.jl")
             run(`$julia -C $cpu_target --output-ji $inference_path.ji --output-o $inference_path.o coreimg.jl`)
 
             # Bootstrap off of that to create sys.{ji,o}
             info("Building sys.o")
-            println("$julia -C $cpu_target --output-ji $sysimg_path.ji --output-o $sysimg_path.o -J $inference_path.ji --startup-file=no sysimg.jl")
+            info("$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 cc !== nothing
                 link_sysimg(sysimg_path, cc, debug)
+                !isempty(warn_msg) && foreach(warn, warn_msg)
             else
-                info("System image successfully built at $sysimg_path.ji")
+                !isempty(warn_msg) && foreach(warn, warn_msg)
+                info("System image successfully built at $sysimg_path.ji.")
             end
 
             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)")
+                if isfile("$sysimg_path.$(Libdl.dlext)")
+                    info("To run Julia with this image loaded, run: `julia -J $sysimg_path.$(Libdl.dlext)`.")
                 else
-                    info("To run Julia with this image loaded, run: julia -J $sysimg_path.ji")
+                    info("To run Julia with this image loaded, run: `julia -J $sysimg_path.ji`.")
                 end
             else
-                info("Julia will automatically load this system image at next startup")
+                info("Julia will automatically load this system image at next startup.")
             end
         finally
             # Cleanup userimg.jl
@@ -104,40 +106,46 @@ function build_sysimg(sysimg_path=nothing, cpu_target="native", userimg_path=not
     end
 end
 
-# Search for a compiler to link sys.o into sys.dl_ext.  Honor LD environment variable.
+# 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["CC"]
-    end
+    cc = nothing
+    warn_msg = String[] # save warning messages into an array
 
     # On Windows, check to see if WinRPM is installed, and if so, see if gcc is installed
-    if is_windows()
+    if Sys.iswindows()
         try
             eval(Main, :(using WinRPM))
-            winrpmgcc = joinpath(WinRPM.installdir,"usr","$(Sys.ARCH)-w64-mingw32",
-                "sys-root","mingw","bin","gcc.exe")
+            winrpmgcc = joinpath(WinRPM.installdir, "usr", "$(Sys.ARCH)-w64-mingw32",
+                "sys-root", "mingw", "bin", "gcc.exe")
             if success(`$winrpmgcc --version`)
-                return winrpmgcc
+                cc = winrpmgcc
             else
                 throw()
             end
         catch
-            warn("Install GCC via `Pkg.add(\"WinRPM\"); WinRPM.install(\"gcc\")` to generate sys.dll for faster startup times")
+            push!(warn_msg, "Install GCC via `Pkg.add(\"WinRPM\"); WinRPM.install(\"gcc\")` to generate sys.dll for faster startup times.")
         end
     end
 
+    if haskey(ENV, "CC")
+        if !success(`$(ENV["CC"]) -v`)
+            push!(warn_msg, "Using compiler override $(ENV["CC"]), but unable to run `$(ENV["CC"]) -v`.")
+        end
+        cc = ENV["CC"]
+    end
 
     # See if `cc` exists
     try
         if success(`cc -v`)
-            return "cc"
+            cc = "cc"
         end
     end
 
-    warn( "No supported compiler found; startup times will be longer" )
+    if cc === nothing
+        push!(warn_msg, "No supported compiler found; startup times will be longer.")
+    end
+
+    return cc, warn_msg
 end
 
 # Link sys.o into sys.$(dlext)
@@ -151,25 +159,28 @@ function link_sysimg(sysimg_path=nothing, cc=find_system_compiler(), debug=false
 
     push!(FLAGS, "-shared")
     push!(FLAGS, debug ? "-ljulia-debug" : "-ljulia")
-    if is_windows()
+    if Sys.iswindows()
         push!(FLAGS, "-lssp")
     end
 
     sysimg_file = "$sysimg_path.$(Libdl.dlext)"
     info("Linking sys.$(Libdl.dlext)")
-    # Windows has difficulties overwriting a file in use so we first rename it
-    if is_windows() && isfile(sysimg_file)
-        mv(sysimg_file, "$sysimg_file.old"; remove_destination=true)
-        run(`$cc $FLAGS -o $sysimg_file $sysimg_path.o`)
+    info("$cc $(join(FLAGS, ' ')) -o $sysimg_file $sysimg_path.o")
+    # Windows has difficulties overwriting a file in use so we first link to a temp file
+    if Sys.iswindows() && isfile(sysimg_file)
+        if success(pipeline(`$cc $FLAGS -o $sysimg_path.tmp $sysimg_path.o`; stdout=STDOUT, stderr=STDERR))
+            mv(sysimg_file, "$sysimg_file.old"; remove_destination=true)
+            mv("$sysimg_path.tmp", sysimg_file; remove_destination=true)
+        end
     else
         run(`$cc $FLAGS -o $sysimg_file $sysimg_path.o`)
     end
     info("System image successfully built at $sysimg_path.$(Libdl.dlext)")
+    return
 end
 
-# When running this file as a script, try to do so with default values.  If arguments are passed
+# 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.
-#
 # Also check whether we are running `genstdlib.jl`, in which case we don't want to build a
 # system image and instead only need `build_sysimg`'s docstring to be available.
 if !isdefined(Main, :GenStdLib) && !isinteractive()
diff --git a/contrib/check-whitespace.sh b/contrib/check-whitespace.sh
index fc085e935e7d91..c380d7bdd29691 100755
--- a/contrib/check-whitespace.sh
+++ b/contrib/check-whitespace.sh
@@ -1,5 +1,5 @@
 #!/bin/sh
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Check for trailing white space in source files;
 # report an error if so
diff --git a/contrib/commit-name.sh b/contrib/commit-name.sh
index 1b81c846b8a5e7..7a139eee276a51 100755
--- a/contrib/commit-name.sh
+++ b/contrib/commit-name.sh
@@ -1,5 +1,5 @@
 #!/bin/sh
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Needs to be run from a julia repo clone
 # First argument (optional) is a ref to the commit
diff --git a/contrib/download_cmake.sh b/contrib/download_cmake.sh
index 73105af6fb83e1..d122e1e0f07d45 100755
--- a/contrib/download_cmake.sh
+++ b/contrib/download_cmake.sh
@@ -1,5 +1,5 @@
 #!/bin/sh
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Script to download newest version of cmake on linux (or mac)
 # saves you the trouble of compiling it if you don't have root
diff --git a/contrib/filterArgs.sh b/contrib/filterArgs.sh
index 658a21d3d7eb99..823745e004e6ea 100755
--- a/contrib/filterArgs.sh
+++ b/contrib/filterArgs.sh
@@ -1,5 +1,5 @@
 #!/bin/sh
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Loop over all command line arguments
 for i in "$@"; do
diff --git a/contrib/fixup-libgfortran.sh b/contrib/fixup-libgfortran.sh
index a7ee7025b9a7f5..3d8579e7a6a551 100755
--- a/contrib/fixup-libgfortran.sh
+++ b/contrib/fixup-libgfortran.sh
@@ -1,7 +1,15 @@
 #!/bin/sh
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
-# Run as: fixup-libgfortran.sh <$private_libdir>
+# Run as: fixup-libgfortran.sh [--verbose] <$private_libdir>
+
+# If we're invoked with "--verbose", create a `debug` function that prints stuff out
+if [ "$1" == "--verbose" ] || [ "$1" == "-v" ]; then
+shift 1
+debug() { echo "$*"; }
+else
+debug() { :; }
+fi
 
 if [ -z "$1" ]; then
     echo "Usage: $0 <private_libdir>"
@@ -14,7 +22,7 @@ if [ "$UNAME" = "Linux" ]; then
 elif [ "$UNAME" = "Darwin" ]; then
     SHLIB_EXT="dylib"
 else
-    echo "WARNING: Could not autodetect platform type ('uname -s' == $UNAME); assuming Linux"
+    echo "WARNING: Could not autodetect platform type ('uname -s' == $UNAME); assuming Linux" >&2
     UNAME="Linux"
     SHLIB_EXT="so"
 fi
@@ -26,79 +34,110 @@ if [ ! -f "$private_libdir/libarpack.$SHLIB_EXT" ]; then
     exit 2
 fi
 
-find_shlib ()
+find_shlib()
 {
-    if [ -f "$private_libdir/lib$1.$SHLIB_EXT" ]; then
+    lib_path="$1"
+    if [ -f "$lib_path" ]; then
         if [ "$UNAME" = "Linux" ]; then
-            ldd "$private_libdir/lib$1.$SHLIB_EXT" | grep $2 | cut -d' ' -f3 | xargs
-        elif [ "$UNAME" = "Darwin" ]; then
-            otool -L "$private_libdir/lib$1.$SHLIB_EXT" | grep $2 | cut -d' ' -f1 | xargs
+            ldd "$lib_path" | grep $2 | cut -d' ' -f3 | xargs
+        else # $UNAME is "Darwin", we only have two options, see above
+            otool -L "$lib_path" | grep $2 | cut -d' ' -f1 | xargs
         fi
     fi
 }
 
+private_libname()
+{
+    echo "$private_libdir/lib$1.$SHLIB_EXT"
+}
+
 # First, discover all the places where libgfortran/libgcc is, as well as their true SONAMES
-for lib in arpack openlibm openspecfun lapack; do
+for lib in arpack openspecfun lapack; do
     if [ -f "$private_libdir/lib$lib.$SHLIB_EXT" ]; then
-        LIBGFORTRAN_DIRS="$LIBGFORTRAN_DIRS $(dirname $(find_shlib $lib libgfortran) 2>/dev/null)"
-        LIBGFORTRAN_DIRS="$LIBGFORTRAN_DIRS $(dirname $(find_shlib $lib libgcc_s) 2>/dev/null)"
-        LIBGFORTRAN_DIRS="$LIBGFORTRAN_DIRS $(dirname $(find_shlib $lib libquadmath) 2>/dev/null)"
+        # Find the paths to the libraries we're interested in.  These are almost
+        # always within the same directory, but we like to be general.
+        LIBGFORTRAN_PATH=$(find_shlib "$(private_libname $lib)" libgfortran)
+        LIBGCC_PATH=$(find_shlib "$(private_libname $lib)" libgcc_s)
+        LIBQUADMATH_PATH=$(find_shlib "$(private_libname $lib)" libquadmath)
+
+        # Take the directories, add them onto LIBGFORTRAN_DIRS, which we use to
+        # search for these libraries in the future.
+        LIBGFORTRAN_DIRS="$LIBGFORTRAN_DIRS $(dirname $LIBGFORTRAN_PATH)"
+        LIBGFORTRAN_DIRS="$LIBGFORTRAN_DIRS $(dirname $LIBGCC_PATH)"
+        LIBGFORTRAN_DIRS="$LIBGFORTRAN_DIRS $(dirname $LIBQUADMATH_PATH)"
+
+        # Save the SONAMES
+        LIBGFORTRAN_SONAMES="$LIBGFORTRAN_SONAMES $(basename "$LIBGFORTRAN_PATH")"
+        LIBGCC_SONAMES="$LIBGCC_SONAMES $(basename "$LIBGCC_PATH")"
+        LIBQUADMATH_SONAMES="$LIBQUADMATH_SONAMES $(basename "$LIBQUADMATH_PATH")"
     fi
 done
 
-LIBGFORTRAN_DIRS=$(echo "$LIBGFORTRAN_DIRS" | tr " " "\n" | sort | uniq | grep -v '^$' | tr "\n" " ")
+# Take in a list of space-separated tokens, return a deduplicated list of the same
+uniquify()
+{
+    echo "$1" | tr " " "\n" | sort | uniq | grep -v '^$' | tr "\n" " "
+}
 
-# If only we could agree on something
-if [ "$UNAME" = "Linux" ]; then
-    NAMEXTS="gcc_s.so.1 gfortran.so.3 quadmath.so.0"
-elif [ "$UNAME" = "Darwin" ]; then
-    NAMEXTS="gcc_s.1.dylib gfortran.3.dylib quadmath.0.dylib"
-fi
+LIBGFORTRAN_DIRS=$(uniquify "$LIBGFORTRAN_DIRS")
+SONAMES="$(uniquify "$LIBGFORTRAN_SONAMES $LIBGCC_SONAMES $LIBQUADMATH_SONAMES")"
+debug "Discovered traces of libgfortran within $LIBGFORTRAN_DIRS"
+debug "Got SONAMES of $SONAMES"
 
-for namext in $NAMEXTS; do
+# Copy the SONAMEs we identified above into our private_libdir
+for soname in $SONAMES; do
     for dir in $LIBGFORTRAN_DIRS; do
-        if [ ! -f "$private_libdir/lib$namext" ] && [ -f "$dir/lib$namext" ]; then
-            cp -v "$dir/lib$namext" "$private_libdir"
-            chmod 755 "$private_libdir/lib$namext"
+        if [ ! -f "$private_libdir/$soname" ] && [ -f "$dir/$soname" ]; then
+            cp -v "$dir/$soname" "$private_libdir"
+            chmod 755 "$private_libdir/$soname"
             if [ "$UNAME" = "Darwin" ]; then
-                install_name_tool -id @rpath/lib$namext "$private_libdir/lib$namext"
+                install_name_tool -id "@rpath/$soname" "$private_libdir/$soname"
             fi
         fi
     done
 done
 
-# Add possible internal directories to LIBGFORTRAN_DIRS
-for lib in gfortran.3 quadmath.0 gcc_s.1 ; do
-    if [ -f "$private_libdir/lib$lib.$SHLIB_EXT" ]; then
-        LIBGFORTRAN_DIRS="$LIBGFORTRAN_DIRS $(dirname $(find_shlib $lib libgfortran) 2>/dev/null)"
-        LIBGFORTRAN_DIRS="$LIBGFORTRAN_DIRS $(dirname $(find_shlib $lib libgcc_s) 2>/dev/null)"
-        LIBGFORTRAN_DIRS="$LIBGFORTRAN_DIRS $(dirname $(find_shlib $lib libquadmath) 2>/dev/null)"
+# On OSX, we need to change the old link (which is usually a full path)
+# to point to `@rpath/${soname}` explicitly, so we use `find_shlib()`
+# to dynamically find the full path we want to change.  On Linux, we
+# don't care about full paths, we just set the rpath to `$ORIGIN`.
+change_linkage()
+{
+    # This is the path of the library we want to edit
+    lib_path="$1"
+
+    # If it doesn't exist, exit quietly
+    if [ ! -f "$lib_path" ]; then
+        debug "  $lib_path doesn't exist, skipping"
+        return
     fi
-done
 
-LIBGFORTRAN_DIRS=$(echo "$LIBGFORTRAN_DIRS" | tr " " "\n" | sort | uniq | grep -v '^$' | tr "\n" " ")
-echo "Found traces of libgfortran/libgcc in $LIBGFORTRAN_DIRS"
+    # This is the soname of the dependency we want to swap out
+    soname="$2"
 
+    if [ "$UNAME" = "Darwin" ]; then
+        old_link=$(find_shlib "$lib_path" "$soname")
+        echo " $old_link"
+        install_name_tool -change "$old_link" "@rpath/$soname" "$lib_path"
+    else # $UNAME is "Linux", we only have two options, see above
+        patchelf --set-rpath \$ORIGIN "$lib_path"
+    fi
+}
 
-# Do the private_libdir libraries
-if [ "$UNAME" = "Darwin" ]; then
-    cd $private_libdir
-    for file in openlibm quadmath.0 gfortran.3 openblas arpack lapack openspecfun; do
-        for dylib in $(ls lib$file*.dylib* 2>/dev/null); do
-            for dir in $LIBGFORTRAN_DIRS; do
-                install_name_tool -change "$dir/libgfortran.3.dylib" @rpath/libgfortran.3.dylib $dylib
-                install_name_tool -change "$dir/libquadmath.0.dylib" @rpath/libquadmath.0.dylib $dylib
-                install_name_tool -change "$dir/libgcc_s.1.dylib" @rpath/libgcc_s.1.dylib $dylib
-            done
+# For every library that remotely touches libgfortran stuff (the libraries we
+# have copied in ourselves as well as arpack, openspecfun, etc...) we must
+# update the linkage to point to @rpath (on OSX) or $ORIGIN (on Linux) so
+# that direct links to the old libgfortran directories are instead directed
+# to the proper location, which is our $private_libdir.
+for lib in libopenblas libarpack libcholmod liblapack libopenspecfun $SONAMES; do
+    # Grab every incarnation of that library that exists within $private_libdir
+    # (e.g. "libopenspecfun.so", and "libopenspecfun.so.0", etc...)
+    for lib_path in $private_libdir/$lib*; do
+        # Iterate over dependency names that need to be changed
+        for soname in $SONAMES; do
+            debug "changing linkage of $lib_path to $soname"
+            change_linkage "$lib_path" "$soname"
         done
     done
-fi
+done
 
-if [ "$UNAME" = "Linux" ]; then
-    cd $private_libdir
-    for file in openlibm quadmath gfortran openblas arpack lapack openspecfun; do
-        for dylib in $(ls lib$file*.so* 2>/dev/null); do
-            patchelf --set-rpath \$ORIGIN $dylib
-        done
-    done
-fi
diff --git a/contrib/fixup-libstdc++.sh b/contrib/fixup-libstdc++.sh
index d1953bf09767e6..ee84094169b61c 100755
--- a/contrib/fixup-libstdc++.sh
+++ b/contrib/fixup-libstdc++.sh
@@ -1,5 +1,5 @@
 #!/bin/sh
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Run as: fixup-libstdc++.sh <libdir> <private_libdir>
 
diff --git a/contrib/install.sh b/contrib/install.sh
index 702b207fbb5aab..f4e11b6089efb9 100755
--- a/contrib/install.sh
+++ b/contrib/install.sh
@@ -1,5 +1,5 @@
 #!/bin/sh
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Usage: very similar to `install`
 #   install.sh 755 src1 src2 ... dest
diff --git a/contrib/julia-config.jl b/contrib/julia-config.jl
index ad7b038ca47c98..b6536c283f145c 100755
--- a/contrib/julia-config.jl
+++ b/contrib/julia-config.jl
@@ -1,8 +1,7 @@
 #!/usr/bin/env julia
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
-const options =
-[
+const options = [
     "--cflags",
     "--ldflags",
     "--ldlibs"
@@ -10,9 +9,14 @@ const options =
 
 threadingOn() = ccall(:jl_threading_enabled, Cint, ()) != 0
 
+function shell_escape(str)
+    str = replace(str, "'", "'\''")
+    return "'$str'"
+end
+
 function imagePath()
     opts = Base.JLOptions()
-    unsafe_string(opts.image_file)
+    return unsafe_string(opts.image_file)
 end
 
 function libDir()
@@ -23,33 +27,20 @@ function libDir()
     end
 end
 
-function includeDir()
-    joinpath(match(r"(.*)(bin)",JULIA_HOME).captures[1],"include","julia")
-end
-
-function unixInitDir()
-    filePart = split(imagePath(),"/")[end]
-    return match(Regex("(.*)(/julia/$filePart)"),imagePath()).captures[1]
-end
-
-function windowsInitDir()
-    if imagePath()[end-1:end] == "ji"
-        return match(r"(.*)(\\julia\\sys.ji)",imagePath()).captures[1]
-    else
-        return match(r"(.*)(\\julia\\sys.dll)",imagePath()).captures[1]
-    end
-end
+private_libDir() = abspath(JULIA_HOME, Base.PRIVATE_LIBDIR)
 
-function initDir()
-    if is_unix()
-        return unixInitDir()
-    else
-        return windowsInitDir()
-    end
+function includeDir()
+    return abspath(JULIA_HOME, Base.INCLUDEDIR, "julia")
 end
 
 function ldflags()
-    replace("""-L$(libDir())""","\\","\\\\")
+    fl = "-L$(shell_escape(libDir()))"
+    if Sys.iswindows()
+        fl = fl * " -Wl,--stack,8388608"
+    elseif Sys.islinux()
+        fl = fl * " -Wl,--export-dynamic"
+    end
+    return fl
 end
 
 function ldlibs()
@@ -58,28 +49,31 @@ function ldlibs()
     else
         "julia"
     end
-    if is_unix()
-        return replace("""-Wl,-rpath,$(libDir()) -l$libname""","\\","\\\\")
+    if Sys.isunix()
+        return "-Wl,-rpath,$(shell_escape(libDir())) -Wl,-rpath,$(shell_escape(private_libDir())) -l$libname"
     else
         return "-l$libname -lopenlibm"
     end
 end
 
 function cflags()
-    arg1 = replace(initDir(),"\\","\\\\\\\\")
-    arg2 = replace(includeDir(),"\\","\\\\")
-    threading_def = threadingOn() ? "-DJULIA_ENABLE_THREADING=1 " : ""
-    if is_unix()
-        return """$(threading_def)-fPIC -DJULIA_INIT_DIR=\\"$arg1\\" -I$arg2"""
-    else
-        return """$(threading_def)-DJULIA_INIT_DIR=\\"$arg1\\" -I$arg2"""
+    flags = IOBuffer()
+    print(flags, "-std=gnu99")
+    include = shell_escape(includeDir())
+    print(flags, " -I", include)
+    if threadingOn()
+        print(flags, " -DJULIA_ENABLE_THREADING=1")
+    end
+    if Sys.isunix()
+        print(flags, " -fPIC")
     end
+    return String(take!(flags))
 end
 
 function check_args(args)
-    checked = intersect(args,options)
+    checked = intersect(args, options)
     if length(checked) == 0 || length(checked) != length(args)
-        println(STDERR,"Usage: julia-config [",reduce((x,y)->"$x|$y",options),"]")
+        println(STDERR, "Usage: julia-config [", join(options, " | "), "]")
         exit(1)
     end
 end
diff --git a/contrib/julia.appdata.xml b/contrib/julia.appdata.xml
index aa36b84bf2a65c..576d88358ee7cd 100644
--- a/contrib/julia.appdata.xml
+++ b/contrib/julia.appdata.xml
@@ -21,8 +21,8 @@
   </p>
  </description>
  <screenshots>
-  <screenshot type="default">http://julialang.org/images/julia-gnome.png</screenshot>
+  <screenshot type="default">https://julialang.org/images/julia-gnome.png</screenshot>
  </screenshots>
- <url type="homepage">http://julialang.org/</url>
+ <url type="homepage">https://julialang.org/</url>
  <updatecontact>julia-dev@googlegroups.com</updatecontact>
 </application>
diff --git a/contrib/julia.lang b/contrib/julia.lang
index 95fed9c9c0fd5a..566685a1ebb3a6 100644
--- a/contrib/julia.lang
+++ b/contrib/julia.lang
@@ -104,7 +104,7 @@
 
     <context id="special-constant" style-ref="special-constant">
       <keyword>nothing</keyword>
-      <!-- http://docs.julialang.org/en/latest/stdlib/constants/ -->
+      <!-- https://docs.julialang.org/en/latest/stdlib/constants/ -->
       <keyword>ARGS</keyword>
       <keyword>LOAD_PATH</keyword>
       <keyword>CPU_CORES</keyword>
@@ -121,7 +121,7 @@
       <keyword>ANY</keyword>
     </context>
 
-    <!-- http://docs.julialang.org/en/latest/manual/mathematical-operations.html -->
+    <!-- https://docs.julialang.org/en/latest/manual/mathematical-operations.html -->
     <context id="operator">
       <include>
         <context ref="octave:operator" />
@@ -135,7 +135,7 @@
       </include>
     </context>
 
-    <!-- http://docs.julialang.org/en/latest/stdlib/punctuation.html -->
+    <!-- https://docs.julialang.org/en/latest/stdlib/punctuation.html -->
     <context id="punctuation" style-ref="operator">
       <match extended="true">
         \(|\)        |
@@ -185,7 +185,7 @@
       <keyword>using</keyword>
     </context>
 
-    <!-- See http://docs.julialang.org/en/latest/manual/running-external-programs/ -->
+    <!-- See https://docs.julialang.org/en/latest/manual/running-external-programs/ -->
     <context id="external-command" style-ref="external-command" >
       <start>`</start>
       <end>`</end>
@@ -197,7 +197,6 @@
     <context id="builtin-function" style-ref="builtin-function">
       <keyword>is</keyword>
       <keyword>typeof</keyword>
-      <keyword>issubtype</keyword>
       <keyword>isa</keyword>
       <keyword>typeassert</keyword>
       <keyword>apply</keyword>
@@ -214,12 +213,11 @@
     </context>
 
     <context id="module" style-ref="module">
-      <!-- http://docs.julialang.org/en/latest/manual/modules/#standard-modules -->
+      <!-- https://docs.julialang.org/en/latest/manual/modules/#standard-modules -->
       <keyword>Base</keyword>
       <keyword>Core</keyword>
       <keyword>Main</keyword>
       <!-- exports.jl -->
-      <keyword>FFTW</keyword>
       <keyword>Collections</keyword>
       <keyword>Test</keyword>
       <keyword>Pkg</keyword>
diff --git a/contrib/julia.xml b/contrib/julia.xml
index 978dc6e0b726e6..577fc37de5d627 100644
--- a/contrib/julia.xml
+++ b/contrib/julia.xml
@@ -263,7 +263,6 @@
       <item> TypeError </item>
 
       <item> Collections </item>
-      <item> FFTW </item>
       <item> Order </item>
       <item> Sys </item>
       <item> Test </item>
diff --git a/contrib/mac/juliarc.jl b/contrib/mac/juliarc.jl
index da5bc9a95dd4c9..066a50cda9e7a1 100644
--- a/contrib/mac/juliarc.jl
+++ b/contrib/mac/juliarc.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Set up environment for Julia OSX binary distribution
 let
diff --git a/contrib/mac/mac-gtk.sh b/contrib/mac/mac-gtk.sh
index f17f106c372d67..86be8aa8e16705 100644
--- a/contrib/mac/mac-gtk.sh
+++ b/contrib/mac/mac-gtk.sh
@@ -1,5 +1,5 @@
 #!/bin/sh
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # This script will attempt to download and build GTK+-3,
 # including dependencies, in ~/gtk (also puts stuff in
diff --git a/contrib/mac/macports.make b/contrib/mac/macports.make
index f99927ea90cfb8..c4b32b2157d1b0 100644
--- a/contrib/mac/macports.make
+++ b/contrib/mac/macports.make
@@ -22,7 +22,6 @@ JMAKEFLAGS = USE_SYSTEM_LLVM=1 LLVM_CONFIG=${LLVM_CONFIG} \
 		USE_SYSTEM_OPENLIBM=0 \
 		USE_SYSTEM_BLAS=1 USE_BLAS64=0\
 		USE_SYSTEM_LAPACK=1 \
-		USE_SYSTEM_FFTW=1 \
 		USE_SYSTEM_GMP=1 \
 		USE_SYSTEM_MPFR=1 \
 		USE_SYSTEM_ARPACK=1 \
diff --git a/contrib/prepare_release.sh b/contrib/prepare_release.sh
index 6a703733e03b39..cf12e7444c3b73 100755
--- a/contrib/prepare_release.sh
+++ b/contrib/prepare_release.sh
@@ -1,5 +1,5 @@
 #!/bin/sh
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # script to prepare binaries and source tarballs for a Julia release
 # aka "bucket dance" julianightlies -> julialang
@@ -33,7 +33,7 @@ cd ..
 rm -rf julia-$version
 
 # download and rename binaries, with -latest copies
-julianightlies="https://s3.amazonaws.com/julianightlies/bin"
+julianightlies="https://julialangnightlies-s3.julialang.org/bin"
 curl -L -o julia-$version-linux-x86_64.tar.gz \
   $julianightlies/linux/x64/$majmin/julia-$majminpatch-$shashort-linux64.tar.gz
 cp julia-$version-linux-x86_64.tar.gz julia-$majmin-latest-linux-x86_64.tar.gz
@@ -56,8 +56,11 @@ curl -L -o julia-$version-win32.exe \
   $julianightlies/winnt/x86/$majmin/julia-$majminpatch-$shashort-win32.exe
 cp julia-$version-win32.exe julia-$majmin-latest-win32.exe
 
-echo "Note: if windows code signing is not working on the buildbots, then the"
-echo "checksums need to be re-calculated after the binaries are manually signed!"
+if [ -e codesign.sh ]; then
+  # code signing needs to run on windows, script is not checked in since it
+  # hard-codes a few things. TODO: see if signtool.exe can run in wine
+  ./codesign.sh
+fi
 
 shasum -a 256 julia-$version* | grep -v -e sha256 -e md5 -e asc > julia-$version.sha256
 md5sum julia-$version* | grep -v -e sha256 -e md5 -e asc > julia-$version.md5
@@ -69,7 +72,36 @@ gpg -u julia --armor --detach-sig julia-$version-linux-i686.tar.gz
 gpg -u julia --armor --detach-sig julia-$version-linux-arm.tar.gz
 gpg -u julia --armor --detach-sig julia-$version-linux-ppc64le.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?
+aws configure
+aws s3 cp --acl public-read julia-$version.sha256 s3://julialang/bin/checksums/
+aws s3 cp --acl public-read julia-$version.md5 s3://julialang/bin/checksums/
+for plat in x86_64 i686 arm ppc64le; do
+  platshort=$(echo $plat | sed -e 's/x86_64/x64/' -e 's/i686/x86/')
+  aws s3 cp --acl public-read julia-$version-linux-$plat.tar.gz \
+    s3://julialang/bin/linux/$platshort/$majmin/
+  aws s3 cp --acl public-read julia-$version-linux-$plat.tar.gz.asc \
+    s3://julialang/bin/linux/$platshort/$majmin/
+  aws s3 cp --acl public-read julia-$majmin-latest-linux-$plat.tar.gz \
+    s3://julialang/bin/linux/$platshort/$majmin/
+  curl -X PURGE -L "https://julialang-s3.julialang.org/bin/linux/$platshort/$majmin/julia-$majmin-latest-linux-$plat.tar.gz"
+done
+aws s3 cp --acl public-read "julia-$version-osx10.7 .dmg" \
+  s3://julialang/bin/osx/x64/$majmin/
+aws s3 cp --acl public-read "julia-$majmin-latest-osx10.7 .dmg" \
+  s3://julialang/bin/osx/x64/$majmin/
+curl -X PURGE -L "https://julialang-s3.julialang.org/bin/osx/x64/$majmin/julia-$majmin-latest-osx10.7 .dmg"
+curl -X PURGE -L "https://julialang-s3.julialang.org/bin/osx/x64/$majmin/julia-$majmin-latest-osx10.7+.dmg"
+aws s3 cp --acl public-read "julia-$version-win64.exe" \
+  s3://julialang/bin/winnt/x64/$majmin/
+aws s3 cp --acl public-read "julia-$majmin-latest-win64.exe" \
+  s3://julialang/bin/winnt/x64/$majmin/
+curl -X PURGE -L "https://julialang-s3.julialang.org/bin/winnt/x64/$majmin/julia-$majmin-latest-win64.exe"
+aws s3 cp --acl public-read "julia-$version-win32.exe" \
+  s3://julialang/bin/winnt/x86/$majmin/
+aws s3 cp --acl public-read "julia-$majmin-latest-win32.exe" \
+  s3://julialang/bin/winnt/x86/$majmin/
+curl -X PURGE -L "https://julialang-s3.julialang.org/bin/winnt/x86/$majmin/julia-$majmin-latest-win32.exe"
+
+
+echo "All files prepared. Attach julia-$version.tar.gz"
+echo "and julia-$version-full.tar.gz to github releases."
diff --git a/contrib/relative_path.sh b/contrib/relative_path.sh
index 34e526b7f1e315..ebb3095a7e45f3 100755
--- a/contrib/relative_path.sh
+++ b/contrib/relative_path.sh
@@ -1,5 +1,5 @@
 #!/bin/sh
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # both $1 and $2 are absolute paths beginning with /
 # returns relative path to $2/$target from $1/$source
diff --git a/contrib/stringreplace.c b/contrib/stringreplace.c
index 8ebee3fac74304..80671328181511 100644
--- a/contrib/stringreplace.c
+++ b/contrib/stringreplace.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include <stdio.h>
 #include <stdlib.h>
diff --git a/contrib/travis_fastfail.sh b/contrib/travis_fastfail.sh
index 6eb349a49b1ffb..410cbe2bccafc6 100755
--- a/contrib/travis_fastfail.sh
+++ b/contrib/travis_fastfail.sh
@@ -1,5 +1,5 @@
 #!/bin/sh
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 curlhdr="Accept: application/vnd.travis-ci.2+json"
 endpoint="https://api.travis-ci.org/repos/$TRAVIS_REPO_SLUG"
diff --git a/contrib/vagrant/Vagrantfile b/contrib/vagrant/Vagrantfile
index 5ce593eb286557..d59ce3ee39a07c 100644
--- a/contrib/vagrant/Vagrantfile
+++ b/contrib/vagrant/Vagrantfile
@@ -5,7 +5,7 @@ $script = <<SCRIPT
 cat - > /home/vagrant/.bash_aliases <<"EOF"
 export JULIA_VAGRANT_BUILD=1
 BUILDOPTS="LLVM_CONFIG=llvm-config-3.3 USE_BLAS64=0"
-for lib in LLVM ZLIB SUITESPARSE ARPACK BLAS FFTW LAPACK GMP MPFR PCRE LIBUNWIND GRISU OPENLIBM; do
+for lib in LLVM ZLIB SUITESPARSE ARPACK BLAS LAPACK GMP MPFR PCRE LIBUNWIND GRISU OPENLIBM; do
     export BUILDOPTS="$BUILDOPTS USE_SYSTEM_$lib=1"
 done
 
@@ -16,7 +16,7 @@ apt-get update -qq -y
 apt-get install python-software-properties -y
 add-apt-repository ppa:staticfloat/julia-deps -y
 apt-get update -qq -y
-apt-get install g++ git make patchelf gfortran llvm-3.3 libsuitesparse-dev libopenblas-dev liblapack-dev libarpack2-dev libfftw3-dev libgmp-dev libpcre3-dev libunwind8-dev libmpfr-dev cmake -y
+apt-get install g++ git make patchelf gfortran llvm-3.3 libsuitesparse-dev libopenblas-dev liblapack-dev libarpack2-dev libgmp-dev libpcre3-dev libunwind8-dev libmpfr-dev cmake -y
 SCRIPT
 
 Vagrant.configure("2") do |config|
diff --git a/contrib/windows/Vagrantfile b/contrib/windows/Vagrantfile
index 6aff0481cf7098..246bb68f4aba08 100644
--- a/contrib/windows/Vagrantfile
+++ b/contrib/windows/Vagrantfile
@@ -1,15 +1,34 @@
 # Vagrantfile for building Windows Julia via MSYS2 or Cygwin
 
+$script_cygwin = <<SCRIPT
+# change the following to 32 for 32 bit Julia
+$bits = "64"
+$arch = "x86_$bits".Replace("x86_32", "i686")
+$setup = "setup-$arch.exe".Replace("i686", "x86")
+$cyginstall = "C:\\cygwin$bits"
+
+mkdir -Force $cyginstall | Out-Null
+(new-object net.webclient).DownloadFile(
+  "http://cygwin.com/$setup", "$cyginstall\\$setup")
+foreach ($pkg in @("git,make,curl,patch,python,gcc-g++,m4,cmake,p7zip",
+    "mingw64-$arch-gcc-g++,mingw64-$arch-gcc-fortran")) {
+  & "$cyginstall\\$setup" -q -n -R $cyginstall -l $cyginstall\\packages `
+    -s http://mirrors.mit.edu/cygwin -g -P $pkg | Where-Object `
+    -FilterScript {$_ -notlike "Installing file *"} | Write-Output
+}
+& "$cyginstall\\bin\\sh" -lc "if ! [ -e julia$bits ]; then git clone \\
+  git://github.com/JuliaLang/julia.git julia$bits; fi && cd julia$bits && git pull && \\
+  echo 'XC_HOST = $arch-w64-mingw32' > Make.user && make cleanall && \\
+  make -j2 testall && make win-extras binary-dist"
+SCRIPT
+
 $script_msys2 = <<SCRIPT
 # change the following to 32 for 32 bit Julia
 $bits = "64"
 $arch = "x86_$bits".Replace("x86_32", "i686")
 # change the date in the following for future msys2 releases
 $msys2tarball = "msys2-base-$arch-20150916.tar"
-
-# these environment variables need to be set, or Julia gets confused
-[Environment]::SetEnvironmentVariable("HOMEDRIVE", "C:")
-[Environment]::SetEnvironmentVariable("HOMEPATH", "\\Users\\vagrant")
+$msys2install = "C:\\msys$bits"
 
 # install chocolatey, cmake, and python2
 iex ((new-object net.webclient).DownloadString("https://chocolatey.org/install.ps1"))
@@ -18,27 +37,27 @@ choco install -y python2
 
 # pacman is picky, reinstall msys2 from scratch
 foreach ($dir in @("etc", "usr", "var")) {
-  if (Test-Path "C:\\msys$bits\\$dir") {
-    rm -Recurse -Force C:\\msys$bits\\$dir
+  if (Test-Path "$msys2install\\$dir") {
+    rm -Recurse -Force $msys2install\\$dir
   }
 }
-mkdir -Force C:\\msys$bits | Out-Null
+mkdir -Force $msys2install | Out-Null
 (new-object net.webclient).DownloadFile(
   "https://chocolatey.org/7za.exe",
-  "C:\\msys$bits\\7za.exe")
+  "$msys2install\\7za.exe")
 (new-object net.webclient).DownloadFile(
   "http://sourceforge.net/projects/msys2/files/Base/$arch/$msys2tarball.xz",
-  "C:\\msys$bits\\$msys2tarball.xz")
+  "$msys2install\\$msys2tarball.xz")
 cd C:\\
 & "msys$bits\\7za.exe" x -y msys$bits\\$msys2tarball.xz
 & "msys$bits\\7za.exe" x -y $msys2tarball | Out-Null
 rm $msys2tarball, msys$bits\\$msys2tarball.xz, msys$bits\\7za.exe
 
-& "C:\\msys$bits\\usr\\bin\\sh" -lc "pacman --noconfirm --force --needed -Sy \\
+& "$msys2install\\usr\\bin\\sh" -lc "pacman --noconfirm --force --needed -Sy \\
   bash pacman pacman-mirrors msys2-runtime"
-& "C:\\msys$bits\\usr\\bin\\sh" -lc "pacman --noconfirm -Syu && \\
+& "$msys2install\\usr\\bin\\sh" -lc "pacman --noconfirm -Syu && \\
   pacman --noconfirm -S diffutils git m4 make patch tar p7zip msys/openssh"
-& "C:\\msys$bits\\usr\\bin\\sh" -lc "if ! [ -e julia$bits ]; then
+& "$msys2install\\usr\\bin\\sh" -lc "if ! [ -e julia$bits ]; then
   git clone git://github.com/JuliaLang/julia.git julia$bits; fi && cd julia$bits && git pull && \\
   if ! [ -e usr/$arch-w64-mingw32 ]; then contrib/windows/get_toolchain.sh $bits; fi && \\
   export PATH=`$PWD/usr/$arch-w64-mingw32/sys-root/mingw/bin:`$PATH:/c/tools/python2 && \\
@@ -46,29 +65,6 @@ rm $msys2tarball, msys$bits\\$msys2tarball.xz, msys$bits\\7za.exe
   make cleanall && make -j2 testall && make win-extras binary-dist"
 SCRIPT
 
-$script_cygwin = <<SCRIPT
-# change the following to 32 for 32 bit Julia
-$bits = "64"
-$arch = "x86_$bits".Replace("x86_32", "i686")
-$setup = "setup-$arch.exe".Replace("i686", "x86")
-
-mkdir -Force C:\\cygwin$bits | Out-Null
-(new-object net.webclient).DownloadFile(
-  "http://cygwin.com/$setup", "C:\\cygwin$bits\\$setup")
-foreach ($pkg in @("git,make,curl,patch,python,gcc-g++,m4,cmake,p7zip",
-    "mingw64-$arch-gcc-g++,mingw64-$arch-gcc-fortran")) {
-  & "C:\\cygwin$bits\\$setup" -q -n -R C:\\cygwin$bits -l C:\\cygwin$bits\\packages `
-    -s http://mirrors.mit.edu/cygwin -g -P $pkg | Where-Object `
-    -FilterScript {$_ -notlike "Installing file *"} | Write-Output
-}
-[Environment]::SetEnvironmentVariable("HOMEDRIVE", "C:")
-[Environment]::SetEnvironmentVariable("HOMEPATH", "\\Users\\vagrant")
-& "C:\\cygwin$bits\\bin\\sh" -lc "if ! [ -e julia$bits ]; then git clone \\
-  git://github.com/JuliaLang/julia.git julia$bits; fi && cd julia$bits && git pull && \\
-  echo 'XC_HOST = $arch-w64-mingw32' > Make.user && make cleanall && \\
-  make -j2 testall && make win-extras binary-dist"
-SCRIPT
-
 Vagrant.configure("2") do |config|
   config.vm.box = "kensykora/windows_2012_r2_standard"
   config.vm.provider :virtualbox do |vb|
diff --git a/contrib/windows/msys_build.sh b/contrib/windows/appveyor_build.sh
similarity index 92%
rename from contrib/windows/msys_build.sh
rename to contrib/windows/appveyor_build.sh
index 715a1c858ad43a..ee42adab148a97 100755
--- a/contrib/windows/msys_build.sh
+++ b/contrib/windows/appveyor_build.sh
@@ -1,5 +1,5 @@
 #!/bin/sh
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Script to compile Windows Julia, using binary dependencies from nightlies.
 # Should work in MSYS assuming 7zip is installed and on the path,
@@ -67,8 +67,7 @@ case $(uname) in
     if [ -z "`which gcc 2>/dev/null`" ]; then
       echo 'override HOSTCC = $(CROSS_COMPILE)gcc' >> Make.user
     fi
-    make win-extras >> get-deps.log
-    SEVENZIP="dist-extras/7z"
+    SEVENZIP="7z"
     ;;
   Linux)
     if [ -z "$XC_HOST" ]; then
@@ -89,10 +88,11 @@ esac
 if ! [ -e julia-installer.exe ]; then
   f=julia-latest-win$bits.exe
   echo "Downloading $f"
-  $curlflags -O https://s3.amazonaws.com/julianightlies/bin/winnt/x$archsuffix/$f
+  $curlflags -O https://julialangnightlies-s3.julialang.org/bin/winnt/x$archsuffix/$f
   echo "Extracting $f"
   $SEVENZIP x -y $f >> get-deps.log
 fi
+mkdir -p usr
 for i in bin/*.dll; do
   $SEVENZIP e -y julia-installer.exe "$i" \
     -ousr\\`dirname $i | sed -e 's|/julia||' -e 's|/|\\\\|g'` >> get-deps.log
@@ -111,7 +111,7 @@ 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`" -o -n "$APPVEYOR" ]; then
+  if [ -z "`which ${CROSS_COMPILE}gcc 2>/dev/null`" ]; then
     f=$ARCH-4.9.2-release-win32-$exc-rt_v4-rev3.7z
     checksum_download \
         "$f" "https://bintray.com/artifact/download/tkelman/generic/$f"
@@ -123,7 +123,7 @@ if [ -z "$USEMSVC" ]; then
   fi
   export AR=${CROSS_COMPILE}ar
 
-  f=llvm-3.9.1-$ARCH-w64-mingw32-juliadeps-r04.7z
+  f=llvm-3.9.1-$ARCH-w64-mingw32-juliadeps-r07.7z
 else
   echo "override USEMSVC = 1" >> Make.user
   echo "override ARCH = $ARCH" >> Make.user
@@ -164,8 +164,9 @@ if ! [ -e usr/bin/busybox.exe ]; then
   echo "Downloading $f"
   $curlflags -o usr/bin/busybox.exe http://frippery.org/files/busybox/$f
 fi
+chmod +x usr/bin/* usr/tools/*
 
-for lib in SUITESPARSE ARPACK BLAS LAPACK FFTW \
+for lib in SUITESPARSE ARPACK BLAS LAPACK \
     GMP MPFR PCRE LIBUNWIND OPENSPECFUN; do
   echo "USE_SYSTEM_$lib = 1" >> Make.user
 done
@@ -203,6 +204,7 @@ fi
 echo 'FORCE_ASSERTIONS = 1' >> Make.user
 
 cat Make.user
-make -j3 VERBOSE=1
+make -j3 VERBOSE=1 install
+make VERBOSE=1 -C examples
+cp usr/bin/busybox.exe julia-*/bin
 make build-stats
-#make debug
diff --git a/contrib/windows/get_toolchain.sh b/contrib/windows/get_toolchain.sh
index 09155935fb1cb6..01e9ad973b2138 100755
--- a/contrib/windows/get_toolchain.sh
+++ b/contrib/windows/get_toolchain.sh
@@ -1,5 +1,5 @@
 #!/bin/sh
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # download mingw-w64 compilers from opensuse build service, usage:
 # ./get_toolchain.sh 64
@@ -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_42.2 \
+contrib/windows/winrpm.sh http://download.opensuse.org/repositories/windows:/mingw:/win$bits/openSUSE_Leap_42.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/install-cygwin.ps1 b/contrib/windows/install-cygwin.ps1
new file mode 100644
index 00000000000000..3e1a832537e348
--- /dev/null
+++ b/contrib/windows/install-cygwin.ps1
@@ -0,0 +1,9 @@
+$setup = "setup-$env:ARCH.exe".Replace("i686", "x86")
+
+mkdir -Force C:\cygdownloads | Out-Null
+(new-object net.webclient).DownloadFile(
+  "http://cygwin.com/$setup", "C:\cygdownloads\$setup")
+& "C:\cygdownloads\$setup" -q -n -R C:\cygwin-$env:ARCH `
+  -l C:\cygdownloads -s http://mirrors.mit.edu/cygwin -g -I `
+  -P "make,curl,time,p7zip,mingw64-$env:ARCH-gcc-g++,mingw64-$env:ARCH-gcc-fortran" | Where-Object `
+  -FilterScript {$_ -notlike "Installing file *"} | Write-Output
diff --git a/contrib/windows/winrpm.sh b/contrib/windows/winrpm.sh
index a329220c033703..ef5ae6e227b201 100755
--- a/contrib/windows/winrpm.sh
+++ b/contrib/windows/winrpm.sh
@@ -1,5 +1,5 @@
 #!/bin/sh
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # build-time mini version of WinRPM, usage:
 # ./winrpm.sh http://download.opensuse.org/repositories/windows:/mingw:/win64/openSUSE_13.2/ mingw64-zlib1
diff --git a/deps/Makefile b/deps/Makefile
index 53953d2c4cfbbb..c5bb3e607215e4 100644
--- a/deps/Makefile
+++ b/deps/Makefile
@@ -1,6 +1,7 @@
 ## high-level setup ##
 default: install
 SRCDIR := $(abspath $(dir $(lastword $(MAKEFILE_LIST))))
+SRCCACHE := $(abspath $(SRCDIR)/srccache)
 JULIAHOME := $(abspath $(SRCDIR)/..)
 ifeq ($(abspath .),$(abspath $(SRCDIR)))
 BUILDDIR := scratch
@@ -19,7 +20,7 @@ include $(SRCDIR)/tools/git-external.mk
 # 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 curl
+# autoconf configure-driven scripts: llvm pcre arpack unwind gmp mpfr patchelf libuv curl
 # custom Makefile rules: openlibm dsfmt suitesparse-wrapper suitesparse lapack openblas utf8proc objconv osxunwind
 # CMake libs: libgit2 libssh2 mbedtls
 #
@@ -48,6 +49,7 @@ ifeq ($(USE_SYSTEM_LIBUV), 0)
 DEP_LIBS += libuv
 endif
 
+ifeq ($(DISABLE_LIBUNWIND), 0)
 ifeq ($(USE_SYSTEM_LIBUNWIND), 0)
 ifeq ($(OS), Linux)
 DEP_LIBS += unwind
@@ -57,8 +59,9 @@ else ifeq ($(OS), Darwin)
 DEP_LIBS += osxunwind
 endif
 endif
+endif
 
-ifeq ($(OS), Linux)
+ifneq (,$(findstring $(OS),Linux FreeBSD))
 ifeq ($(USE_SYSTEM_PATCHELF), 0)
 DEP_LIBS += patchelf
 PATCHELF:=$(build_depsbindir)/patchelf
@@ -101,12 +104,6 @@ endif
 endif
 endif
 
-ifeq ($(USE_GPL_LIBS), 1)
-ifeq ($(USE_SYSTEM_FFTW), 0)
-DEP_LIBS += fftw
-endif
-endif
-
 ifeq ($(USE_SYSTEM_GMP), 0)
 DEP_LIBS += gmp
 endif
@@ -175,7 +172,7 @@ uninstall: $(addprefix uninstall-, $(DEP_LIBS_STAGED))
 cleanall: $(addprefix clean-, $(DEP_LIBS))
 distcleanall: $(addprefix distclean-, $(DEP_LIBS))
 	rm -rf $(build_prefix)
-getall: get-llvm get-libuv get-pcre get-openlibm get-openspecfun get-dsfmt get-openblas get-lapack get-fftw get-suitesparse get-arpack get-unwind get-osxunwind get-gmp get-mpfr get-patchelf get-utf8proc get-objconv get-mbedtls get-libssh2 get-curl get-libgit2
+getall: get-llvm get-libuv get-pcre get-openlibm get-openspecfun get-dsfmt get-openblas get-lapack get-suitesparse get-arpack get-unwind get-osxunwind get-gmp get-mpfr get-patchelf get-utf8proc get-objconv get-mbedtls get-libssh2 get-curl get-libgit2
 
 include $(SRCDIR)/llvm.mk
 include $(SRCDIR)/libuv.mk
@@ -186,7 +183,6 @@ include $(SRCDIR)/dsfmt.mk
 include $(SRCDIR)/objconv.mk
 include $(SRCDIR)/blas.mk
 include $(SRCDIR)/arpack.mk
-include $(SRCDIR)/fftw.mk
 include $(SRCDIR)/utf8proc.mk
 include $(SRCDIR)/suitesparse.mk
 include $(SRCDIR)/unwind.mk
diff --git a/deps/Versions.make b/deps/Versions.make
index 7e5a0486f99712..f7bdc70bb59a31 100644
--- a/deps/Versions.make
+++ b/deps/Versions.make
@@ -1,14 +1,13 @@
 LLVM_VER = 3.9.1
-PCRE_VER = 10.22
+PCRE_VER = 10.23
 DSFMT_VER = 2.2.3
 LAPACK_VER = 3.5.0
 ARPACK_VER = 3.3.0
-FFTW_VER = 3.3.5
 SUITESPARSE_VER = 4.4.5
 UNWIND_VER = 1.1-julia2
 OSXUNWIND_VER = 0.0.3
 GMP_VER = 6.1.2
 MPFR_VER = 3.1.5
 PATCHELF_VER = 0.9
-MBEDTLS_VER = 2.3.0
-CURL_VER = 7.52.1
+MBEDTLS_VER = 2.5.1
+CURL_VER = 7.54.1
diff --git a/deps/arpack.mk b/deps/arpack.mk
index a1fe376f8d609b..a246777171ea07 100644
--- a/deps/arpack.mk
+++ b/deps/arpack.mk
@@ -37,24 +37,24 @@ ARPACK_FLAGS := --with-blas="$(LIBBLAS)" --with-lapack="$(LIBLAPACK)" \
     CFLAGS="$(CFLAGS) $(ARPACK_CFLAGS)" LDFLAGS="$(LDFLAGS) $(RPATH_ESCAPED_ORIGIN)"
 
 # ARPACK-NG upstream keeps changing their download filenames
-$(SRCDIR)/srccache/arpack-ng-$(ARPACK_VER).tar.gz: | $(SRCDIR)/srccache
+$(SRCCACHE)/arpack-ng-$(ARPACK_VER).tar.gz: | $(SRCCACHE)
 	$(JLDOWNLOAD) $@ https://s3.amazonaws.com/julialang/src/arpack-ng-$(ARPACK_VER).tar.gz
 	touch -c $@
-$(SRCDIR)/srccache/arpack-ng-$(ARPACK_VER)-testA.mtx: | $(SRCDIR)/srccache
+$(SRCCACHE)/arpack-ng-$(ARPACK_VER)-testA.mtx: | $(SRCCACHE)
 	$(JLDOWNLOAD) $@ https://raw.githubusercontent.com/opencollab/arpack-ng/$(ARPACK_VER)/TESTS/testA.mtx
 	touch -c $@
 
-$(SRCDIR)/srccache/arpack-ng-$(ARPACK_VER)/source-extracted: $(SRCDIR)/srccache/arpack-ng-$(ARPACK_VER).tar.gz
+$(SRCCACHE)/arpack-ng-$(ARPACK_VER)/source-extracted: $(SRCCACHE)/arpack-ng-$(ARPACK_VER).tar.gz
 	$(JLCHECKSUM) $<
 	cd $(dir $<) && $(TAR) -zxf $<
-	touch -c $(SRCDIR)/srccache/arpack-ng-$(ARPACK_VER)/configure # old target
+	touch -c $(SRCCACHE)/arpack-ng-$(ARPACK_VER)/configure # old target
 	echo 1 > $@
 
-$(SRCDIR)/srccache/arpack-ng-$(ARPACK_VER)/arpack-tests-blasint.patch-applied: $(SRCDIR)/srccache/arpack-ng-$(ARPACK_VER)/source-extracted
+$(SRCCACHE)/arpack-ng-$(ARPACK_VER)/arpack-tests-blasint.patch-applied: $(SRCCACHE)/arpack-ng-$(ARPACK_VER)/source-extracted
 	cd $(dir $@) && patch -p1 < $(SRCDIR)/patches/arpack-tests-blasint.patch
 	echo 1 > $@
 
-$(BUILDDIR)/arpack-ng-$(ARPACK_VER)/build-configured: $(SRCDIR)/srccache/arpack-ng-$(ARPACK_VER)/source-extracted $(SRCDIR)/srccache/arpack-ng-$(ARPACK_VER)/arpack-tests-blasint.patch-applied
+$(BUILDDIR)/arpack-ng-$(ARPACK_VER)/build-configured: $(SRCCACHE)/arpack-ng-$(ARPACK_VER)/source-extracted $(SRCCACHE)/arpack-ng-$(ARPACK_VER)/arpack-tests-blasint.patch-applied
 	mkdir -p $(dir $@)
 	cd $(dir $@) && \
 	$(dir $<)/configure $(CONFIGURE_COMMON) $(ARPACK_FLAGS)
@@ -64,7 +64,7 @@ $(BUILDDIR)/arpack-ng-$(ARPACK_VER)/build-compiled: $(BUILDDIR)/arpack-ng-$(ARPA
 	$(MAKE) -C $(dir $<) $(ARPACK_MFLAGS)
 	echo 1 > $@
 
-$(BUILDDIR)/arpack-ng-$(ARPACK_VER)/build-checked: $(SRCDIR)/srccache/arpack-ng-$(ARPACK_VER)-testA.mtx $(BUILDDIR)/arpack-ng-$(ARPACK_VER)/build-compiled
+$(BUILDDIR)/arpack-ng-$(ARPACK_VER)/build-checked: $(SRCCACHE)/arpack-ng-$(ARPACK_VER)-testA.mtx $(BUILDDIR)/arpack-ng-$(ARPACK_VER)/build-compiled
 	$(JLCHECKSUM) $<
 	cp $< $(dir $@)/TESTS/testA.mtx
 ifeq ($(OS),$(BUILD_OS))
@@ -89,14 +89,14 @@ clean-arpack:
 	-$(MAKE) -C $(BUILDDIR)/arpack-ng-$(ARPACK_VER) clean
 
 distclean-arpack:
-	-rm -rf $(SRCDIR)/srccache/arpack-ng-$(ARPACK_VER).tar.gz \
-		$(SRCDIR)/srccache/arpack-ng-$(ARPACK_VER) \
-		$(SRCDIR)/srccache/arpack-ng-$(ARPACK_VER)-testA.mtx \
+	-rm -rf $(SRCCACHE)/arpack-ng-$(ARPACK_VER).tar.gz \
+		$(SRCCACHE)/arpack-ng-$(ARPACK_VER) \
+		$(SRCCACHE)/arpack-ng-$(ARPACK_VER)-testA.mtx \
 		$(BUILDDIR)/arpack-ng-$(ARPACK_VER)
 
 
-get-arpack: $(SRCDIR)/srccache/arpack-ng-$(ARPACK_VER).tar.gz $(SRCDIR)/srccache/arpack-ng-$(ARPACK_VER)-testA.mtx
-extract-arpack: $(SRCDIR)/srccache/arpack-ng-$(ARPACK_VER)/source-extracted
+get-arpack: $(SRCCACHE)/arpack-ng-$(ARPACK_VER).tar.gz $(SRCCACHE)/arpack-ng-$(ARPACK_VER)-testA.mtx
+extract-arpack: $(SRCCACHE)/arpack-ng-$(ARPACK_VER)/source-extracted
 configure-arpack: $(BUILDDIR)/arpack-ng-$(ARPACK_VER)/build-configured
 compile-arpack: $(BUILDDIR)/arpack-ng-$(ARPACK_VER)/build-compiled
 # XXX: bug_1315 ARPACK tests fail stochastically
diff --git a/deps/blas.mk b/deps/blas.mk
index a907b45d70e1f2..84ba60eff10e4b 100644
--- a/deps/blas.mk
+++ b/deps/blas.mk
@@ -4,7 +4,7 @@ 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,,,$(BUILDDIR)))
 
-OPENBLAS_BUILD_OPTS := CC="$(CC)" FC="$(FC)" RANLIB="$(RANLIB)" FFLAGS="$(FFLAGS) $(JFFLAGS)" TARGET=$(OPENBLAS_TARGET_ARCH) BINARY=$(BINARY)
+OPENBLAS_BUILD_OPTS := CC="$(CC)" FC="$(FC)" LD="$(LD)" RANLIB="$(RANLIB)" TARGET=$(OPENBLAS_TARGET_ARCH) BINARY=$(BINARY)
 
 # Thread support
 ifeq ($(OPENBLAS_USE_THREAD), 1)
@@ -46,6 +46,9 @@ $(BUILDDIR)/$(OPENBLAS_SRC_DIR)/build-compiled: | $(BUILDDIR)/objconv/build-comp
 endif
 endif
 
+OPENBLAS_FFLAGS := $(JFFLAGS)
+OPENBLAS_CFLAGS := -O2
+
 # Decide whether to build for 32-bit or 64-bit arch
 ifneq ($(BUILD_OS),$(OS))
 OPENBLAS_BUILD_OPTS += OSNAME=$(OS) CROSS=1 HOSTCC=$(HOSTCC) CROSS_SUFFIX=$(CROSS_COMPILE)
@@ -53,12 +56,15 @@ endif
 ifeq ($(OS),WINNT)
 ifneq ($(ARCH),x86_64)
 ifneq ($(USECLANG),1)
-OPENBLAS_BUILD_OPTS += CFLAGS="$(CFLAGS) -mincoming-stack-boundary=2"
+OPENBLAS_CFLAGS += -mincoming-stack-boundary=2
 endif
-OPENBLAS_BUILD_OPTS += FFLAGS="$(FFLAGS) -mincoming-stack-boundary=2"
+OPENBLAS_FFLAGS += -mincoming-stack-boundary=2
 endif
 endif
 
+OPENBLAS_BUILD_OPTS += CFLAGS="$(CFLAGS) $(OPENBLAS_CFLAGS)"
+OPENBLAS_BUILD_OPTS += FFLAGS="$(FFLAGS) $(OPENBLAS_FFLAGS)"
+
 # Debug OpenBLAS
 ifeq ($(OPENBLAS_DEBUG), 1)
 OPENBLAS_BUILD_OPTS += DEBUG=1
@@ -80,7 +86,24 @@ $(BUILDDIR)/$(OPENBLAS_SRC_DIR)/openblas-freebsd.patch-applied: $(BUILDDIR)/$(OP
 	cd $(BUILDDIR)/$(OPENBLAS_SRC_DIR) && patch -p0 -f < $(SRCDIR)/patches/openblas-freebsd.patch
 	echo 1 > $@
 
-$(BUILDDIR)/$(OPENBLAS_SRC_DIR)/build-configured: $(BUILDDIR)/$(OPENBLAS_SRC_DIR)/openblas-freebsd.patch-applied
+# Clang assembler bug workaround from https://github.com/xianyi/OpenBLAS/pull/982
+$(BUILDDIR)/$(OPENBLAS_SRC_DIR)/openblas-clangasmbug.patch-applied: $(BUILDDIR)/$(OPENBLAS_SRC_DIR)/openblas-freebsd.patch-applied
+	cd $(BUILDDIR)/$(OPENBLAS_SRC_DIR) && patch -p1 -f < $(SRCDIR)/patches/openblas-clangasmbug.patch
+	echo 1 > $@
+
+# Cross compiler autodetection workaround from https://github.com/xianyi/OpenBLAS/pull/968
+# Remove this when we upgrade beyond OpenBLAS v0.2.19
+$(BUILDDIR)/$(OPENBLAS_SRC_DIR)/openblas-cross-compile.patch-applied: $(BUILDDIR)/$(OPENBLAS_SRC_DIR)/openblas-clangasmbug.patch-applied
+	cd $(BUILDDIR)/$(OPENBLAS_SRC_DIR) && patch -p1 -f < $(SRCDIR)/patches/openblas-cross-compile.patch
+	echo 1 > $@
+
+# Power inline assembly fixes from https://github.com/xianyi/OpenBLAS/pull/1098
+# Remove this when we upgrade beyond OpenBLAS v0.2.19
+$(BUILDDIR)/$(OPENBLAS_SRC_DIR)/openblas-power-assembly-fixes.patch-applied: $(BUILDDIR)/$(OPENBLAS_SRC_DIR)/openblas-cross-compile.patch-applied
+	cd $(BUILDDIR)/$(OPENBLAS_SRC_DIR) && patch -p1 -f < $(SRCDIR)/patches/openblas-power-assembly-fixes.patch
+	echo 1 > $@
+
+$(BUILDDIR)/$(OPENBLAS_SRC_DIR)/build-configured: $(BUILDDIR)/$(OPENBLAS_SRC_DIR)/openblas-power-assembly-fixes.patch-applied
 	perl -i -ple 's/^\s*(EXTRALIB\s*\+=\s*-lSystemStubs)\s*$$/# $$1/g' $(dir $<)/Makefile.system
 	echo 1 > $@
 
@@ -131,10 +154,10 @@ LAPACK_MFLAGS := NOOPT="$(FFLAGS) $(JFFLAGS) $(USE_BLAS_FFLAGS) -O0" \
     OPTS="$(FFLAGS) $(JFFLAGS) $(USE_BLAS_FFLAGS)" FORTRAN="$(FC)" \
     LOADER="$(FC)" BLASLIB="$(RPATH_ESCAPED_ORIGIN) $(LIBBLAS)"
 
-$(SRCDIR)/srccache/lapack-$(LAPACK_VER).tgz: | $(SRCDIR)/srccache
+$(SRCCACHE)/lapack-$(LAPACK_VER).tgz: | $(SRCCACHE)
 	$(JLDOWNLOAD) $@ http://www.netlib.org/lapack/$(notdir $@)
 
-$(BUILDDIR)/lapack-$(LAPACK_VER)/source-extracted: $(SRCDIR)/srccache/lapack-$(LAPACK_VER).tgz
+$(BUILDDIR)/lapack-$(LAPACK_VER)/source-extracted: $(SRCCACHE)/lapack-$(LAPACK_VER).tgz
 	$(JLCHECKSUM) $<
 	mkdir -p $(BUILDDIR)
 	cd $(BUILDDIR) && $(TAR) -zxf $<
@@ -173,10 +196,10 @@ clean-lapack:
 	-$(MAKE) -C $(BUILDDIR)/lapack-$(LAPACK_VER) clean
 
 distclean-lapack:
-	-rm -rf $(SRCDIR)/srccache/lapack-$(LAPACK_VER).tgz $(BUILDDIR)/lapack-$(LAPACK_VER)
+	-rm -rf $(SRCCACHE)/lapack-$(LAPACK_VER).tgz $(BUILDDIR)/lapack-$(LAPACK_VER)
 
 
-get-lapack: $(SRCDIR)/srccache/lapack-$(LAPACK_VER).tgz
+get-lapack: $(SRCCACHE)/lapack-$(LAPACK_VER).tgz
 extract-lapack: $(BUILDDIR)/lapack-$(LAPACK_VER)/source-extracted
 configure-lapack: extract-lapack
 compile-lapack: $(BUILDDIR)/lapack-$(LAPACK_VER)/build-compiled
diff --git a/deps/checksums/curl-7.52.1.tar.bz2/md5 b/deps/checksums/curl-7.52.1.tar.bz2/md5
deleted file mode 100644
index 4e898c45ec9be1..00000000000000
--- a/deps/checksums/curl-7.52.1.tar.bz2/md5
+++ /dev/null
@@ -1 +0,0 @@
-dd014df06ff1d12e173de86873f9f77a
diff --git a/deps/checksums/curl-7.52.1.tar.bz2/sha512 b/deps/checksums/curl-7.52.1.tar.bz2/sha512
deleted file mode 100644
index b4af993ab5fef7..00000000000000
--- a/deps/checksums/curl-7.52.1.tar.bz2/sha512
+++ /dev/null
@@ -1 +0,0 @@
-cf36563c77d096f2c6084354ed6d45ccca7c557828ceab21204e4e8be0d4f0d287839c8cfac906174b86d51a1ee816c2769fc78ef88f039c9645bd2c27982a75
diff --git a/deps/checksums/curl-7.54.1.tar.bz2/md5 b/deps/checksums/curl-7.54.1.tar.bz2/md5
new file mode 100644
index 00000000000000..d06698526d3270
--- /dev/null
+++ b/deps/checksums/curl-7.54.1.tar.bz2/md5
@@ -0,0 +1 @@
+6b6eb722f512e7a24855ff084f54fe55
diff --git a/deps/checksums/curl-7.54.1.tar.bz2/sha512 b/deps/checksums/curl-7.54.1.tar.bz2/sha512
new file mode 100644
index 00000000000000..5a4942693612b4
--- /dev/null
+++ b/deps/checksums/curl-7.54.1.tar.bz2/sha512
@@ -0,0 +1 @@
+eb9639677f0ca1521ca631c520ab83ad071c52b31690e5e7f31546f6a44b2f11d1bb62282056cffb570eb290bf1e7830e87cb536295ac6a54a904663e795f2da
diff --git a/deps/checksums/fftw-3.3.5.tar.gz/md5 b/deps/checksums/fftw-3.3.5.tar.gz/md5
deleted file mode 100644
index c6a010259df7a5..00000000000000
--- a/deps/checksums/fftw-3.3.5.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-6cc08a3b9c7ee06fdd5b9eb02e06f569
diff --git a/deps/checksums/fftw-3.3.5.tar.gz/sha512 b/deps/checksums/fftw-3.3.5.tar.gz/sha512
deleted file mode 100644
index 947ef17fab6324..00000000000000
--- a/deps/checksums/fftw-3.3.5.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-a81f02d884cfe4171fab479b0e5ec76eceb9c5da6d4eda1f89281b7e1efa2d8176c9ba87051595c402889eb32172d216ce40eb2bef41289c646f01002fb4ba8e
diff --git a/deps/checksums/fftw-3.3.6-pl1.tar.gz/md5 b/deps/checksums/fftw-3.3.6-pl1.tar.gz/md5
new file mode 100644
index 00000000000000..d0f6e35fbb74f2
--- /dev/null
+++ b/deps/checksums/fftw-3.3.6-pl1.tar.gz/md5
@@ -0,0 +1 @@
+682a0e78d6966ca37c7446d4ab4cc2a1
diff --git a/deps/checksums/fftw-3.3.6-pl1.tar.gz/sha512 b/deps/checksums/fftw-3.3.6-pl1.tar.gz/sha512
new file mode 100644
index 00000000000000..ed286e18ccd6f9
--- /dev/null
+++ b/deps/checksums/fftw-3.3.6-pl1.tar.gz/sha512
@@ -0,0 +1 @@
+e2ed33fcb068a36a841bbd898d12ceec74f4e9a0a349e7c55959878b50224a69a0f87656347dad7d7e1448ebc50d28d8f34f6da7992c43072d26942fd97c0134
diff --git a/deps/checksums/libgit2-15e119375018fba121cf58e02a9f17fe22df0df8.tar.gz/md5 b/deps/checksums/libgit2-15e119375018fba121cf58e02a9f17fe22df0df8.tar.gz/md5
new file mode 100644
index 00000000000000..f148bce28a5c82
--- /dev/null
+++ b/deps/checksums/libgit2-15e119375018fba121cf58e02a9f17fe22df0df8.tar.gz/md5
@@ -0,0 +1 @@
+0d6fd3ed9265c6804349149b23ae6362
diff --git a/deps/checksums/libgit2-15e119375018fba121cf58e02a9f17fe22df0df8.tar.gz/sha512 b/deps/checksums/libgit2-15e119375018fba121cf58e02a9f17fe22df0df8.tar.gz/sha512
new file mode 100644
index 00000000000000..1e129704580c72
--- /dev/null
+++ b/deps/checksums/libgit2-15e119375018fba121cf58e02a9f17fe22df0df8.tar.gz/sha512
@@ -0,0 +1 @@
+88a8a42bb8d18a5a722938404e048266d0899362ac89fdfedfa9f71aeb90408d8d98b4d9b9ea2ff46755d0a2cd8686ff04d31e85827566e1290a9536b8b36ac8
diff --git a/deps/checksums/libgit2-75db289a041b1f1084768244e167b953ac7eeaa5.tar.gz/md5 b/deps/checksums/libgit2-75db289a041b1f1084768244e167b953ac7eeaa5.tar.gz/md5
deleted file mode 100644
index 5ece749b8ff068..00000000000000
--- a/deps/checksums/libgit2-75db289a041b1f1084768244e167b953ac7eeaa5.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-43f28f86c884c3c469ce4080de287ee7
diff --git a/deps/checksums/libgit2-75db289a041b1f1084768244e167b953ac7eeaa5.tar.gz/sha512 b/deps/checksums/libgit2-75db289a041b1f1084768244e167b953ac7eeaa5.tar.gz/sha512
deleted file mode 100644
index 3f7eed8a611dd0..00000000000000
--- a/deps/checksums/libgit2-75db289a041b1f1084768244e167b953ac7eeaa5.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-6d7c5a6fd0f6678944e0ae379f5b5fa628f7a6936db6fbff4442e98db7037fd3baf2010ffc7c45ed7a30c7ebff1973a0a9047d67dbac1dedf2df444a80bdf43b
diff --git a/deps/checksums/llvm-3.9.1-i686-w64-mingw32-juliadeps-r04.7z/md5 b/deps/checksums/llvm-3.9.1-i686-w64-mingw32-juliadeps-r04.7z/md5
deleted file mode 100644
index cb690525311e16..00000000000000
--- a/deps/checksums/llvm-3.9.1-i686-w64-mingw32-juliadeps-r04.7z/md5
+++ /dev/null
@@ -1 +0,0 @@
-912e986977539e14fccaac70229852cc
diff --git a/deps/checksums/llvm-3.9.1-i686-w64-mingw32-juliadeps-r04.7z/sha512 b/deps/checksums/llvm-3.9.1-i686-w64-mingw32-juliadeps-r04.7z/sha512
deleted file mode 100644
index c376e135898155..00000000000000
--- a/deps/checksums/llvm-3.9.1-i686-w64-mingw32-juliadeps-r04.7z/sha512
+++ /dev/null
@@ -1 +0,0 @@
-c2632222dc2662c0fe65372d74dbf65e9dcad638a9b668952b12ab270fc633c83b1a3a48342e488757a5ded1e0b633f04fb545fd0f5867c329524ca6b2881143
diff --git a/deps/checksums/llvm-3.9.1-i686-w64-mingw32-juliadeps-r07.7z/md5 b/deps/checksums/llvm-3.9.1-i686-w64-mingw32-juliadeps-r07.7z/md5
new file mode 100644
index 00000000000000..44f12c1d39dd88
--- /dev/null
+++ b/deps/checksums/llvm-3.9.1-i686-w64-mingw32-juliadeps-r07.7z/md5
@@ -0,0 +1 @@
+78a8751aab4333e636ab36d1bd56216a
diff --git a/deps/checksums/llvm-3.9.1-i686-w64-mingw32-juliadeps-r07.7z/sha512 b/deps/checksums/llvm-3.9.1-i686-w64-mingw32-juliadeps-r07.7z/sha512
new file mode 100644
index 00000000000000..4678e46d529adc
--- /dev/null
+++ b/deps/checksums/llvm-3.9.1-i686-w64-mingw32-juliadeps-r07.7z/sha512
@@ -0,0 +1 @@
+1a512d01f0751d184858de660cd69f1861af230f193522f6d94a61752caad32a5fa7af40f6abcfd153733107824eb3deaa6e6ef3d680eba3898af02d44a97d19
diff --git a/deps/checksums/llvm-3.9.1-x86_64-w64-mingw32-juliadeps-r04.7z/md5 b/deps/checksums/llvm-3.9.1-x86_64-w64-mingw32-juliadeps-r04.7z/md5
deleted file mode 100644
index 04b2fc7b4a2673..00000000000000
--- a/deps/checksums/llvm-3.9.1-x86_64-w64-mingw32-juliadeps-r04.7z/md5
+++ /dev/null
@@ -1 +0,0 @@
-a32011de56ca5146a601e9866d3b4619
diff --git a/deps/checksums/llvm-3.9.1-x86_64-w64-mingw32-juliadeps-r04.7z/sha512 b/deps/checksums/llvm-3.9.1-x86_64-w64-mingw32-juliadeps-r04.7z/sha512
deleted file mode 100644
index aef55552d55675..00000000000000
--- a/deps/checksums/llvm-3.9.1-x86_64-w64-mingw32-juliadeps-r04.7z/sha512
+++ /dev/null
@@ -1 +0,0 @@
-3c6010b1b59979d56b611201e824405fde14a11a56c45b6fb5007c6c38c2db41c2b2590b0ca81ad0d9dbaaad9d83fd7342653a2937806f04d9693fd9611f5be3
diff --git a/deps/checksums/llvm-3.9.1-x86_64-w64-mingw32-juliadeps-r07.7z/md5 b/deps/checksums/llvm-3.9.1-x86_64-w64-mingw32-juliadeps-r07.7z/md5
new file mode 100644
index 00000000000000..7b5e851e6f1965
--- /dev/null
+++ b/deps/checksums/llvm-3.9.1-x86_64-w64-mingw32-juliadeps-r07.7z/md5
@@ -0,0 +1 @@
+96af87df3140a00df866eda5b5a99d37
diff --git a/deps/checksums/llvm-3.9.1-x86_64-w64-mingw32-juliadeps-r07.7z/sha512 b/deps/checksums/llvm-3.9.1-x86_64-w64-mingw32-juliadeps-r07.7z/sha512
new file mode 100644
index 00000000000000..41605bb4c698c5
--- /dev/null
+++ b/deps/checksums/llvm-3.9.1-x86_64-w64-mingw32-juliadeps-r07.7z/sha512
@@ -0,0 +1 @@
+24697b575688fea8f2ca5f9bf3f8f96353c09efbe32923cedc111bf976d5480a82a4c4dec52fc9343715887dee98605c80c3323e4d1b2f245e239cf5604ea02d
diff --git a/deps/checksums/mbedtls-2.3.0-apache.tgz/md5 b/deps/checksums/mbedtls-2.3.0-apache.tgz/md5
deleted file mode 100644
index 0b072f92db44ba..00000000000000
--- a/deps/checksums/mbedtls-2.3.0-apache.tgz/md5
+++ /dev/null
@@ -1 +0,0 @@
-4dab982481441ed0a0235bc06d40eb17
diff --git a/deps/checksums/mbedtls-2.3.0-apache.tgz/sha512 b/deps/checksums/mbedtls-2.3.0-apache.tgz/sha512
deleted file mode 100644
index 902ec8bb91d07c..00000000000000
--- a/deps/checksums/mbedtls-2.3.0-apache.tgz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-96b55c0b159e5f2a0895670b2db693e52d2ee70198c4ff1f50c62d07a9f66e683b9862564059f2c0c955ebefefb98e02ad19c9df5ee18aebeff120bd15f43e27
diff --git a/deps/checksums/mbedtls-2.3.0-gpl.tgz/md5 b/deps/checksums/mbedtls-2.3.0-gpl.tgz/md5
deleted file mode 100644
index 665e79bab03578..00000000000000
--- a/deps/checksums/mbedtls-2.3.0-gpl.tgz/md5
+++ /dev/null
@@ -1 +0,0 @@
-3f396d21b9c86c0a11ac9ba0b6e6f999
diff --git a/deps/checksums/mbedtls-2.3.0-gpl.tgz/sha512 b/deps/checksums/mbedtls-2.3.0-gpl.tgz/sha512
deleted file mode 100644
index 3b04779fbc308d..00000000000000
--- a/deps/checksums/mbedtls-2.3.0-gpl.tgz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-f86ec87735b919e23ad7eb960a290013e7dfc2a5953d662ecee4eca7b990384c095aea74a313eaa0e1febb74e0c015879f4d680d51bc5eae811ab9e5063ba38a
diff --git a/deps/checksums/mbedtls-2.5.1-apache.tgz/md5 b/deps/checksums/mbedtls-2.5.1-apache.tgz/md5
new file mode 100644
index 00000000000000..63d6cb36d9fb90
--- /dev/null
+++ b/deps/checksums/mbedtls-2.5.1-apache.tgz/md5
@@ -0,0 +1 @@
+1299f38583cb4f93c78c99c14a8c913f
diff --git a/deps/checksums/mbedtls-2.5.1-apache.tgz/sha512 b/deps/checksums/mbedtls-2.5.1-apache.tgz/sha512
new file mode 100644
index 00000000000000..ac443c5cc2d35a
--- /dev/null
+++ b/deps/checksums/mbedtls-2.5.1-apache.tgz/sha512
@@ -0,0 +1 @@
+8bde8f3d1d025a13c2a20fa8d2a4b9711adf0bb32d2226f1dd898dda3f3337c929b3d60e53684fbcf8094142568dd1d780353a92b94cb15c28c31c6d0542e6fc
diff --git a/deps/checksums/mbedtls-2.5.1-gpl.tgz/md5 b/deps/checksums/mbedtls-2.5.1-gpl.tgz/md5
new file mode 100644
index 00000000000000..f02d4fc23affe2
--- /dev/null
+++ b/deps/checksums/mbedtls-2.5.1-gpl.tgz/md5
@@ -0,0 +1 @@
+313f637f65b5f6d74d45310482a9c84f
diff --git a/deps/checksums/mbedtls-2.5.1-gpl.tgz/sha512 b/deps/checksums/mbedtls-2.5.1-gpl.tgz/sha512
new file mode 100644
index 00000000000000..14d290278fb5b2
--- /dev/null
+++ b/deps/checksums/mbedtls-2.5.1-gpl.tgz/sha512
@@ -0,0 +1 @@
+fa05a5f61d9d79bc74e47badc89f68f8b6fd228537f10706cbdacc03b02455171b88121b3c1c5f56dff648c39ff88936413a9c5eea0dd0e046fb1f889e173c63
diff --git a/deps/checksums/pcre2-10.22.tar.bz2/md5 b/deps/checksums/pcre2-10.22.tar.bz2/md5
deleted file mode 100644
index 6d0daf513a2505..00000000000000
--- a/deps/checksums/pcre2-10.22.tar.bz2/md5
+++ /dev/null
@@ -1 +0,0 @@
-c0c02517938ee2b0d350d53edf450664
diff --git a/deps/checksums/pcre2-10.22.tar.bz2/sha512 b/deps/checksums/pcre2-10.22.tar.bz2/sha512
deleted file mode 100644
index f900dfbc648334..00000000000000
--- a/deps/checksums/pcre2-10.22.tar.bz2/sha512
+++ /dev/null
@@ -1 +0,0 @@
-dcf70b5e5b73f29188a56e4d9efb9afdf2b9ebe50e13a7640b80f543851235a289e476e1f517f49fac9628b456268bcdaf2b492237bc879ddff36f84ef4f32ea
diff --git a/deps/checksums/pcre2-10.23.tar.bz2/md5 b/deps/checksums/pcre2-10.23.tar.bz2/md5
new file mode 100644
index 00000000000000..a562ef4a269d35
--- /dev/null
+++ b/deps/checksums/pcre2-10.23.tar.bz2/md5
@@ -0,0 +1 @@
+b2cd00ca7e24049040099b0a46bb3649
diff --git a/deps/checksums/pcre2-10.23.tar.bz2/sha512 b/deps/checksums/pcre2-10.23.tar.bz2/sha512
new file mode 100644
index 00000000000000..61a5555f9b9505
--- /dev/null
+++ b/deps/checksums/pcre2-10.23.tar.bz2/sha512
@@ -0,0 +1 @@
+3e5910bd2405cc35934d91e4be760abe4f2e900202a20b6ba74adb7a3acb2b74b3bf9b0e97e8de10f8e8534133e0722e0bf0f5fb40d6c2c4520d1ed61749d456
diff --git a/deps/curl.mk b/deps/curl.mk
index 064b1f278507f2..56bd2c9f69ffe8 100644
--- a/deps/curl.mk
+++ b/deps/curl.mk
@@ -10,16 +10,16 @@ endif
 
 CURL_LDFLAGS := $(RPATH_ESCAPED_ORIGIN)
 
-$(SRCDIR)/srccache/curl-$(CURL_VER).tar.bz2: | $(SRCDIR)/srccache
+$(SRCCACHE)/curl-$(CURL_VER).tar.bz2: | $(SRCCACHE)
 	$(JLDOWNLOAD) $@ https://curl.haxx.se/download/curl-$(CURL_VER).tar.bz2
 
-$(SRCDIR)/srccache/curl-$(CURL_VER)/source-extracted: $(SRCDIR)/srccache/curl-$(CURL_VER).tar.bz2
+$(SRCCACHE)/curl-$(CURL_VER)/source-extracted: $(SRCCACHE)/curl-$(CURL_VER).tar.bz2
 	$(JLCHECKSUM) $<
 	cd $(dir $<) && $(TAR) jxf $(notdir $<)
-	touch -c $(SRCDIR)/srccache/curl-$(CURL_VER)/configure # old target
+	touch -c $(SRCCACHE)/curl-$(CURL_VER)/configure # old target
 	echo 1 > $@
 
-$(BUILDDIR)/curl-$(CURL_VER)/build-configured: $(SRCDIR)/srccache/curl-$(CURL_VER)/source-extracted
+$(BUILDDIR)/curl-$(CURL_VER)/build-configured: $(SRCCACHE)/curl-$(CURL_VER)/source-extracted
 	mkdir -p $(dir $@)
 	cd $(dir $@) && \
 	$(dir $<)/configure $(CONFIGURE_COMMON) --includedir=$(build_includedir) \
@@ -52,10 +52,10 @@ clean-curl:
 	-$(MAKE) -C $(BUILDDIR)/curl-$(CURL_VER) clean
 
 distclean-curl:
-	-rm -rf $(SRCDIR)/srccache/curl-$(CURL_VER).tar.bz2 $(SRCDIR)/srccache/curl-$(CURL_VER) $(BUILDDIR)/curl-$(CURL_VER)
+	-rm -rf $(SRCCACHE)/curl-$(CURL_VER).tar.bz2 $(SRCCACHE)/curl-$(CURL_VER) $(BUILDDIR)/curl-$(CURL_VER)
 
-get-curl: $(SRCDIR)/srccache/curl-$(CURL_VER).tar.bz2
-extract-curl: $(SRCDIR)/srccache/curl-$(CURL_VER)/source-extracted
+get-curl: $(SRCCACHE)/curl-$(CURL_VER).tar.bz2
+extract-curl: $(SRCCACHE)/curl-$(CURL_VER)/source-extracted
 configure-curl: $(BUILDDIR)/curl-$(CURL_VER)/build-configured
 compile-curl: $(BUILDDIR)/curl-$(CURL_VER)/build-compiled
 fastcheck-curl: #none
diff --git a/deps/dsfmt.mk b/deps/dsfmt.mk
index 1d494693ccdddb..a8880e57a6d104 100644
--- a/deps/dsfmt.mk
+++ b/deps/dsfmt.mk
@@ -11,11 +11,11 @@ ifeq ($(ARCH), x86_64)
 DSFMT_CFLAGS += -msse2 -DHAVE_SSE2
 endif
 
-$(SRCDIR)/srccache/dsfmt-$(DSFMT_VER).tar.gz: | $(SRCDIR)/srccache
+$(SRCCACHE)/dsfmt-$(DSFMT_VER).tar.gz: | $(SRCCACHE)
 	$(JLDOWNLOAD) $@ http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/SFMT/dSFMT-src-$(DSFMT_VER).tar.gz
 	touch -c $@
 
-$(BUILDDIR)/dsfmt-$(DSFMT_VER)/source-extracted: $(SRCDIR)/srccache/dsfmt-$(DSFMT_VER).tar.gz
+$(BUILDDIR)/dsfmt-$(DSFMT_VER)/source-extracted: $(SRCCACHE)/dsfmt-$(DSFMT_VER).tar.gz
 	$(JLCHECKSUM) $<
 	-rm -r $(dir $@)
 	mkdir -p $(dir $@)
@@ -52,9 +52,9 @@ clean-dsfmt:
 	-rm $(BUILDDIR)/dsfmt-$(DSFMT_VER)/libdSFMT.$(SHLIB_EXT)
 
 distclean-dsfmt:
-	-rm -rf $(SRCDIR)/srccache/dsfmt*.tar.gz $(SRCDIR)/srccache/dsfmt-$(DSFMT_VER) $(BUILDDIR)/dsfmt-$(DSFMT_VER)
+	-rm -rf $(SRCCACHE)/dsfmt*.tar.gz $(SRCCACHE)/dsfmt-$(DSFMT_VER) $(BUILDDIR)/dsfmt-$(DSFMT_VER)
 
-get-dsfmt: $(SRCDIR)/srccache/dsfmt-$(DSFMT_VER).tar.gz
+get-dsfmt: $(SRCCACHE)/dsfmt-$(DSFMT_VER).tar.gz
 extract-dsfmt: $(BUILDDIR)/dsfmt-$(DSFMT_VER)/source-extracted
 configure-dsfmt: extract-dsfmt
 compile-dsfmt: $(BUILDDIR)/dsfmt-$(DSFMT_VER)/build-compiled
diff --git a/deps/fftw.mk b/deps/fftw.mk
deleted file mode 100644
index 7a717d19b2045a..00000000000000
--- a/deps/fftw.mk
+++ /dev/null
@@ -1,120 +0,0 @@
-## FFTW ##
-
-ifneq ($(PATCHELF),patchelf)
-# actually required by the stage-fftw target, but there's no easy way to hook into that
-$(BUILDDIR)/fftw-$(FFTW_VER)-single/build-compiled: | $(build_prefix)/manifest/patchelf
-$(BUILDDIR)/fftw-$(FFTW_VER)-double/build-compiled: | $(build_prefix)/manifest/patchelf
-endif
-
-FFTW_CONFIG := --enable-shared --disable-fortran --disable-mpi --enable-threads
-ifneq (,$(findstring arm,$(ARCH)))
-  FFTW_CONFIG +=
-else ifeq ($(ARCH), ppc)
-  FFTW_CONFIG += --enable-altivec
-else ifeq ($(ARCH), x86_64)
-  FFTW_CONFIG += --enable-sse2 --enable-fma
-endif
-ifeq ($(OS),WINNT)
-FFTW_CONFIG += --with-our-malloc --with-combined-threads
-ifneq ($(ARCH),x86_64)
-FFTW_CONFIG += --with-incoming-stack-boundary=2
-endif
-endif
-FFTW_ENABLE_single := --enable-single
-FFTW_ENABLE_double :=
-
-$(SRCDIR)/srccache/fftw-$(FFTW_VER).tar.gz: | $(SRCDIR)/srccache
-	$(JLDOWNLOAD) $@ http://www.fftw.org/$(notdir $@)
-
-$(SRCDIR)/srccache/fftw-$(FFTW_VER)/source-extracted: $(SRCDIR)/srccache/fftw-$(FFTW_VER).tar.gz
-	$(JLCHECKSUM) $<
-	mkdir -p $(dir $@) && \
-	$(TAR) -C $(dir $@) --strip-components 1 -xf $<
-	touch -c $(SRCDIR)/srccache/fftw-$(FFTW_VER)/configure # old target
-	echo 1 > $@
-
-$(SRCDIR)/srccache/fftw-$(FFTW_VER)/fftw-win32-intrin-h.patch-applied: $(SRCDIR)/srccache/fftw-$(FFTW_VER)/source-extracted
-	cd $(SRCDIR)/srccache/fftw-$(FFTW_VER) && patch -p1 -f < $(SRCDIR)/patches/fftw-win32-intrin-h.patch
-	echo 1 > $@
-
-$(BUILDDIR)/fftw-$(FFTW_VER)-%/build-configured: $(SRCDIR)/srccache/fftw-$(FFTW_VER)/source-extracted $(SRCDIR)/srccache/fftw-$(FFTW_VER)/fftw-win32-intrin-h.patch-applied
-	mkdir -p $(dir $@)
-	@# try to configure with avx support. if that fails, try again without it
-	cd $(dir $@) && \
-	($(dir $<)/configure $(CONFIGURE_COMMON) $(FFTW_CONFIG) $(FFTW_ENABLE_$*) --enable-avx || \
-	  $(dir $<)/configure $(CONFIGURE_COMMON) $(FFTW_CONFIG) $(FFTW_ENABLE_$*))
-	$(MAKE) -C $(dir $@) clean
-	echo 1 > $@
-
-$(BUILDDIR)/fftw-$(FFTW_VER)-%/build-compiled: $(BUILDDIR)/fftw-$(FFTW_VER)-%/build-configured
-	$(MAKE) -C $(dir $<)
-	echo 1 > $@
-
-$(BUILDDIR)/fftw-$(FFTW_VER)-%/build-checked: $(BUILDDIR)/fftw-$(FFTW_VER)-%/build-compiled
-ifeq ($(OS),$(BUILD_OS))
-	$(MAKE) -C $(dir $@) check
-endif
-	echo 1 > $@
-
-define FFTW_INSTALL
-	$(call MAKE_INSTALL,$1,$2,)
-ifeq ($$(OS), WINNT)
-	mv $2/$$(build_shlibdir)/$3-3.dll $2/$$(build_shlibdir)/$3.dll
-endif
-ifeq ($$(OS), Linux)
-	for filename in $2/$$(build_shlibdir)/$3_threads.so* ; do \
-		[ -L $$$$filename ] || $$(PATCHELF_BIN) --set-rpath '$$$$ORIGIN' $$$$filename ;\
-	done
-endif
-endef
-
-$(eval $(call staged-install, \
-	fftw-single,fftw-$(FFTW_VER)-single, \
-	FFTW_INSTALL,libfftw3f,, \
-	$$(INSTALL_NAME_CMD)libfftw3f.$$(SHLIB_EXT) $$(build_shlibdir)/libfftw3f.$$(SHLIB_EXT) && \
-	$$(INSTALL_NAME_CMD)libfftw3f_threads.$$(SHLIB_EXT) $$(build_shlibdir)/libfftw3f_threads.$$(SHLIB_EXT) && \
-	$$(INSTALL_NAME_CHANGE_CMD) $$(build_shlibdir)/libfftw3f.3.$$(SHLIB_EXT) $$(INSTALL_NAME_ID_DIR)libfftw3f.$$(SHLIB_EXT) $$(build_shlibdir)/libfftw3f_threads.$$(SHLIB_EXT)))
-$(eval $(call staged-install, \
-	fftw-double,fftw-$(FFTW_VER)-double, \
-	FFTW_INSTALL,libfftw3,, \
-	$$(INSTALL_NAME_CMD)libfftw3.$$(SHLIB_EXT) $$(build_shlibdir)/libfftw3.$$(SHLIB_EXT) && \
-	$$(INSTALL_NAME_CMD)libfftw3_threads.$$(SHLIB_EXT) $$(build_shlibdir)/libfftw3_threads.$$(SHLIB_EXT) && \
-	$$(INSTALL_NAME_CHANGE_CMD) $$(build_shlibdir)/libfftw3.3.$$(SHLIB_EXT) $$(INSTALL_NAME_ID_DIR)libfftw3.$$(SHLIB_EXT) $$(build_shlibdir)/libfftw3_threads.$$(SHLIB_EXT)))
-
-clean-fftw: clean-fftw-single clean-fftw-double
-clean-fftw-%:
-	-rm $(BUILDDIR)/fftw-$(FFTW_VER)-$*/build-compiled $(BUILDDIR)/fftw-$(FFTW_VER)-$*/build-configured
-	-$(MAKE) -C $(BUILDDIR)/fftw-$(FFTW_VER)-$* clean
-
-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 $(BUILDDIR)/fftw-$(FFTW_VER)-single
-distclean-fftw-double:
-	-rm -rf $(BUILDDIR)/fftw-$(FFTW_VER)-double
-
-get-fftw: get-fftw-single get-fftw-double
-extract-fftw: extract-fftw-single extract-fftw-double
-configure-fftw: configure-fftw-single configure-fftw-double
-compile-fftw: compile-fftw-single compile-fftw-double
-fastcheck-fftw: fastcheck-fftw-single fastcheck-fftw-double
-check-fftw: check-fftw-single check-fftw-double
-stage-fftw: stage-fftw-single stage-fftw-double
-install-fftw: install-fftw-single install-fftw-double
-uninstall-fftw: uninstall-fftw-single uninstall-fftw-double
-reinstall-fftw: reinstall-fftw-single reinstall-fftw-double
-
-
-get-fftw-single: $(SRCDIR)/srccache/fftw-$(FFTW_VER).tar.gz
-extract-fftw-single: $(SRCDIR)/srccache/fftw-$(FFTW_VER)/source-extracted
-configure-fftw-single: $(BUILDDIR)/fftw-$(FFTW_VER)-single/build-configured
-compile-fftw-single: $(BUILDDIR)/fftw-$(FFTW_VER)-single/build-compiled
-fastcheck-fftw-single: #none
-check-fftw-single: $(BUILDDIR)/fftw-$(FFTW_VER)-single/build-checked
-
-get-fftw-double: $(SRCDIR)/srccache/fftw-$(FFTW_VER).tar.gz
-extract-fftw-double: $(SRCDIR)/srccache/fftw-$(FFTW_VER)/source-extracted
-configure-fftw-double: $(BUILDDIR)/fftw-$(FFTW_VER)-double/build-configured
-compile-fftw-double: $(BUILDDIR)/fftw-$(FFTW_VER)-double/build-compiled
-fastcheck-fftw-double: #none
-check-fftw-double: $(BUILDDIR)/fftw-$(FFTW_VER)-double/build-checked
diff --git a/deps/gmp.mk b/deps/gmp.mk
index bab94c7e5e826d..347d20df65ee31 100644
--- a/deps/gmp.mk
+++ b/deps/gmp.mk
@@ -5,23 +5,23 @@ GMP_CONFIGURE_OPTS += --disable-assembly
 endif
 
 ifeq ($(BUILD_OS),WINNT)
-GMP_CONFIGURE_OPTS += --srcdir="$(subst \,/,$(call mingw_to_dos,$(SRCDIR)/srccache/gmp-$(GMP_VER)))"
+GMP_CONFIGURE_OPTS += --srcdir="$(subst \,/,$(call mingw_to_dos,$(SRCCACHE)/gmp-$(GMP_VER)))"
 endif
 
-$(SRCDIR)/srccache/gmp-$(GMP_VER).tar.bz2: | $(SRCDIR)/srccache
+$(SRCCACHE)/gmp-$(GMP_VER).tar.bz2: | $(SRCCACHE)
 	$(JLDOWNLOAD) $@ https://gmplib.org/download/gmp/$(notdir $@)
 
-$(SRCDIR)/srccache/gmp-$(GMP_VER)/source-extracted: $(SRCDIR)/srccache/gmp-$(GMP_VER).tar.bz2
+$(SRCCACHE)/gmp-$(GMP_VER)/source-extracted: $(SRCCACHE)/gmp-$(GMP_VER).tar.bz2
 	$(JLCHECKSUM) $<
 	cd $(dir $<) && $(TAR) -jxf $<
-	touch -c $(SRCDIR)/srccache/gmp-$(GMP_VER)/configure # old target
+	touch -c $(SRCCACHE)/gmp-$(GMP_VER)/configure # old target
 	echo 1 > $@
 
-$(SRCDIR)/srccache/gmp-$(GMP_VER)/build-patched: $(SRCDIR)/srccache/gmp-$(GMP_VER)/source-extracted
+$(SRCCACHE)/gmp-$(GMP_VER)/build-patched: $(SRCCACHE)/gmp-$(GMP_VER)/source-extracted
 	cd $(dir $@) && patch < $(SRCDIR)/patches/gmp-exception.patch
 	echo 1 > $@
 
-$(BUILDDIR)/gmp-$(GMP_VER)/build-configured: $(SRCDIR)/srccache/gmp-$(GMP_VER)/source-extracted $(SRCDIR)/srccache/gmp-$(GMP_VER)/build-patched
+$(BUILDDIR)/gmp-$(GMP_VER)/build-configured: $(SRCCACHE)/gmp-$(GMP_VER)/source-extracted $(SRCCACHE)/gmp-$(GMP_VER)/build-patched
 	mkdir -p $(dir $@)
 	cd $(dir $@) && \
 	$(dir $<)/configure $(CONFIGURE_COMMON) F77= --enable-shared --disable-static $(GMP_CONFIGURE_OPTS)
@@ -55,12 +55,12 @@ clean-gmp:
 	-$(MAKE) -C $(BUILDDIR)/gmp-$(GMP_VER) clean
 
 distclean-gmp:
-	-rm -rf $(SRCDIR)/srccache/gmp-$(GMP_VER).tar.bz2 \
-		$(SRCDIR)/srccache/gmp-$(GMP_VER) \
+	-rm -rf $(SRCCACHE)/gmp-$(GMP_VER).tar.bz2 \
+		$(SRCCACHE)/gmp-$(GMP_VER) \
 		$(BUILDDIR)/gmp-$(GMP_VER)
 
-get-gmp: $(SRCDIR)/srccache/gmp-$(GMP_VER).tar.bz2
-extract-gmp: $(SRCDIR)/srccache/gmp-$(GMP_VER)/source-extracted
+get-gmp: $(SRCCACHE)/gmp-$(GMP_VER).tar.bz2
+extract-gmp: $(SRCCACHE)/gmp-$(GMP_VER)/source-extracted
 configure-gmp: $(BUILDDIR)/gmp-$(GMP_VER)/build-configured
 compile-gmp: $(BUILDDIR)/gmp-$(GMP_VER)/build-compiled
 fastcheck-gmp: check-gmp
diff --git a/deps/libgit2.mk b/deps/libgit2.mk
index 7ff18f7093d362..1196c0f6d0ac80 100644
--- a/deps/libgit2.mk
+++ b/deps/libgit2.mk
@@ -2,7 +2,7 @@
 
 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,,$(SRCDIR)/srccache))
+$(eval $(call git-external,libgit2,LIBGIT2,CMakeLists.txt,,$(SRCCACHE)))
 
 ifeq ($(USE_SYSTEM_LIBSSH2), 0)
 $(BUILDDIR)/$(LIBGIT2_SRC_DIR)/build-configured: | $(build_prefix)/manifest/libssh2
@@ -36,16 +36,12 @@ else
 LIBGIT2_OPTS += -DCURL_INCLUDE_DIRS=$(build_includedir) -DCURL_LIBRARIES="-L$(build_shlibdir) -lcurl"
 endif
 
-ifeq ($(OS),Linux)
-LIBGIT2_OPTS += -DUSE_OPENSSL=OFF -DUSE_MBEDTLS=ON -DCMAKE_INSTALL_RPATH="\$$ORIGIN"
-endif
-
-ifeq ($(OS),FreeBSD)
-LIBGIT2_OPTS += -DCMAKE_INSTALL_RPATH="\$$ORIGIN"
+ifneq (,$(findstring $(OS),Linux FreeBSD))
+LIBGIT2_OPTS += -DUSE_HTTPS=ON -DTLS_BACKEND="mbedTLS" -DCMAKE_INSTALL_RPATH="\$$ORIGIN"
 endif
 
 # We need to bundle ca certs on linux now that we're using libgit2 with ssl
-ifeq ($(OS),Linux)
+ifneq (,$(findstring $(OS),Linux FreeBSD))
 OPENSSL_DIR=$(shell openssl version -d | cut -d '"' -f 2)
 # This certfile location observed on Ubuntu 16.04
 ifeq ($(shell [ -e $(OPENSSL_DIR)/certs/ca-certificates.crt ] && echo exists),exists)
@@ -53,23 +49,23 @@ CERTFILE=$(OPENSSL_DIR)/certs/ca-certificates.crt
 # This certfile location observed on openSUSE Leap 42.1
 else ifeq ($(shell [ -e $(OPENSSL_DIR)/ca-bundle.pem ] && echo exists),exists)
 CERTFILE=$(OPENSSL_DIR)/ca-bundle.pem
-# This certfile location observed on Ubuntu 14.04
+# This certfile location observed on Ubuntu 14.04 and FreeBSD
 else ifeq ($(shell [ -e $(OPENSSL_DIR)/cert.pem ] && echo exists),exists)
 CERTFILE=$(OPENSSL_DIR)/cert.pem
 # This certfile location observed on Debian 7
 else ifeq ($(shell [ -e $(OPENSSL_DIR)/certs/ca.pem ] && echo exists),exists)
 CERTFILE=$(OPENSSL_DIR)/certs/ca.pem
 endif
-endif # Linux
+endif # Linux and FreeBSD
 
-LIBGIT2_SRC_PATH := $(SRCDIR)/srccache/$(LIBGIT2_SRC_DIR)
+LIBGIT2_SRC_PATH := $(SRCCACHE)/$(LIBGIT2_SRC_DIR)
 
 $(LIBGIT2_SRC_PATH)/libgit2-ssh.patch-applied: $(LIBGIT2_SRC_PATH)/source-extracted
 	cd $(LIBGIT2_SRC_PATH) && \
 		patch -p0 -f < $(SRCDIR)/patches/libgit2-ssh.patch
 	echo 1 > $@
 
-$(LIBGIT2_SRC_PATH)/libgit2-mbedtls.patch-applied: $(SRCDIR)/srccache/$(LIBGIT2_SRC_DIR)/source-extracted | $(LIBGIT2_SRC_PATH)/libgit2-ssh.patch-applied
+$(LIBGIT2_SRC_PATH)/libgit2-mbedtls.patch-applied: $(SRCCACHE)/$(LIBGIT2_SRC_DIR)/source-extracted | $(LIBGIT2_SRC_PATH)/libgit2-ssh.patch-applied
 	cd $(LIBGIT2_SRC_PATH) && \
 		patch -p1 -f < $(SRCDIR)/patches/libgit2-mbedtls.patch
 	echo 1 > $@
@@ -79,26 +75,26 @@ $(LIBGIT2_SRC_PATH)/libgit2-agent-nonfatal.patch-applied: $(LIBGIT2_SRC_PATH)/so
 		patch -p1 -f < $(SRCDIR)/patches/libgit2-agent-nonfatal.patch
 	echo 1 > $@
 
-$(LIBGIT2_SRC_PATH)/libgit2-mbedtls-writer-fix.patch-applied: $(LIBGIT2_SRC_PATH)/source-extracted | $(LIBGIT2_SRC_PATH)/libgit2-mbedtls.patch-applied
+$(LIBGIT2_SRC_PATH)/libgit2-mbedtls-verify.patch-applied: $(LIBGIT2_SRC_PATH)/source-extracted | $(LIBGIT2_SRC_PATH)/libgit2-agent-nonfatal.patch-applied
 	cd $(LIBGIT2_SRC_PATH) && \
-		patch -p1 -f < $(SRCDIR)/patches/libgit2-mbedtls-writer-fix.patch
+		patch -p1 -f < $(SRCDIR)/patches/libgit2-mbedtls-verify.patch
 	echo 1 > $@
 
-$(LIBGIT2_SRC_PATH)/libgit2-mbedtls-verify.patch-applied: $(LIBGIT2_SRC_PATH)/source-extracted | $(LIBGIT2_SRC_PATH)/libgit2-mbedtls-writer-fix.patch-applied
+$(LIBGIT2_SRC_PATH)/libgit2-mbedtls-fixup.patch-applied: $(LIBGIT2_SRC_PATH)/source-extracted | $(LIBGIT2_SRC_PATH)/libgit2-mbedtls-verify.patch-applied
 	cd $(LIBGIT2_SRC_PATH) && \
-		patch -p1 -f < $(SRCDIR)/patches/libgit2-mbedtls-verify.patch
+		patch -p1 -f < $(SRCDIR)/patches/libgit2-mbedtls-fixup.patch
 	echo 1 > $@
 
 $(build_datarootdir)/julia/cert.pem: $(CERTFILE)
 	mkdir -p $(build_datarootdir)/julia
-	-cp $(CERTFILE) $@
+	cp -f $(CERTFILE) $@
 
 $(BUILDDIR)/$(LIBGIT2_SRC_DIR)/build-configured: \
 	$(LIBGIT2_SRC_PATH)/libgit2-mbedtls.patch-applied \
 	$(LIBGIT2_SRC_PATH)/libgit2-ssh.patch-applied \
 	$(LIBGIT2_SRC_PATH)/libgit2-agent-nonfatal.patch-applied \
-	$(LIBGIT2_SRC_PATH)/libgit2-mbedtls-writer-fix.patch-applied \
-	$(LIBGIT2_SRC_PATH)/libgit2-mbedtls-verify.patch-applied
+	$(LIBGIT2_SRC_PATH)/libgit2-mbedtls-verify.patch-applied \
+	$(LIBGIT2_SRC_PATH)/libgit2-mbedtls-fixup.patch-applied
 
 ifneq ($(CERTFILE),)
 $(BUILDDIR)/$(LIBGIT2_SRC_DIR)/build-configured: $(build_datarootdir)/julia/cert.pem
@@ -139,7 +135,7 @@ clean-libgit2:
 	-$(MAKE) -C $(BUILDDIR)/$(LIBGIT2_SRC_DIR) clean
 
 get-libgit2: $(LIBGIT2_SRC_FILE)
-extract-libgit2: $(SRCDIR)/srccache/$(LIBGIT2_SRC_DIR)/source-extracted
+extract-libgit2: $(SRCCACHE)/$(LIBGIT2_SRC_DIR)/source-extracted
 configure-libgit2: $(BUILDDIR)/$(LIBGIT2_SRC_DIR)/build-configured
 compile-libgit2: $(BUILDDIR)/$(LIBGIT2_SRC_DIR)/build-compiled
 fastcheck-libgit2: #none
diff --git a/deps/libgit2.version b/deps/libgit2.version
index 76a3ffbbc16412..306384f5cd7683 100644
--- a/deps/libgit2.version
+++ b/deps/libgit2.version
@@ -1,2 +1,2 @@
-LIBGIT2_BRANCH=v0.25.0
-LIBGIT2_SHA1=75db289a041b1f1084768244e167b953ac7eeaa5
+LIBGIT2_BRANCH=v0.26.0
+LIBGIT2_SHA1=15e119375018fba121cf58e02a9f17fe22df0df8
diff --git a/deps/libssh2.mk b/deps/libssh2.mk
index 8bbe6dd310dacb..22f82bfd881edb 100644
--- a/deps/libssh2.mk
+++ b/deps/libssh2.mk
@@ -2,7 +2,7 @@
 
 LIBSSH2_GIT_URL := git://github.com/libssh2/libssh2.git
 LIBSSH2_TAR_URL = https://api.github.com/repos/libssh2/libssh2/tarball/$1
-$(eval $(call git-external,libssh2,LIBSSH2,CMakeLists.txt,,$(SRCDIR)/srccache))
+$(eval $(call git-external,libssh2,LIBSSH2,CMakeLists.txt,,$(SRCCACHE)))
 
 ifeq ($(USE_SYSTEM_MBEDTLS), 0)
 $(BUILDDIR)/$(LIBSSH2_SRC_DIR)/build-configured: | $(build_prefix)/manifest/mbedtls
@@ -20,25 +20,21 @@ else
 LIBSSH2_OPTS += -DCRYPTO_BACKEND=mbedTLS -DENABLE_ZLIB_COMPRESSION=OFF
 endif
 
-ifeq ($(OS),Linux)
+ifneq (,$(findstring $(OS),Linux FreeBSD))
 LIBSSH2_OPTS += -DCMAKE_INSTALL_RPATH="\$$ORIGIN"
 endif
 
-ifeq ($(OS),FreeBSD)
-LIBSSH2_OPTS += -DCMAKE_INSTALL_RPATH="\$$ORIGIN"
-endif
-
-$(SRCDIR)/srccache/$(LIBSSH2_SRC_DIR)/libssh2-encryptedpem.patch-applied: $(SRCDIR)/srccache/$(LIBSSH2_SRC_DIR)/source-extracted
-	cd $(SRCDIR)/srccache/$(LIBSSH2_SRC_DIR) && patch -p1 -f < $(SRCDIR)/patches/libssh2-encryptedpem.patch
+$(SRCCACHE)/$(LIBSSH2_SRC_DIR)/libssh2-encryptedpem.patch-applied: $(SRCCACHE)/$(LIBSSH2_SRC_DIR)/source-extracted
+	cd $(SRCCACHE)/$(LIBSSH2_SRC_DIR) && patch -p1 -f < $(SRCDIR)/patches/libssh2-encryptedpem.patch
 	echo 1 > $@
 
 # Patch submitted upstream: https://github.com/libssh2/libssh2/pull/148
 # Remove the patch here once we're using a version of libssh2 that includes the upstream patch
-$(SRCDIR)/srccache/$(LIBSSH2_SRC_DIR)/libssh2-netinet-in.patch-applied: $(SRCDIR)/srccache/$(LIBSSH2_SRC_DIR)/libssh2-encryptedpem.patch-applied
-	cd $(SRCDIR)/srccache/$(LIBSSH2_SRC_DIR) && patch -p0 -f < $(SRCDIR)/patches/libssh2-netinet-in.patch
+$(SRCCACHE)/$(LIBSSH2_SRC_DIR)/libssh2-netinet-in.patch-applied: $(SRCCACHE)/$(LIBSSH2_SRC_DIR)/libssh2-encryptedpem.patch-applied
+	cd $(SRCCACHE)/$(LIBSSH2_SRC_DIR) && patch -p0 -f < $(SRCDIR)/patches/libssh2-netinet-in.patch
 	echo 1 > $@
 
-$(BUILDDIR)/$(LIBSSH2_SRC_DIR)/build-configured: $(SRCDIR)/srccache/$(LIBSSH2_SRC_DIR)/source-extracted $(SRCDIR)/srccache/$(LIBSSH2_SRC_DIR)/libssh2-netinet-in.patch-applied
+$(BUILDDIR)/$(LIBSSH2_SRC_DIR)/build-configured: $(SRCCACHE)/$(LIBSSH2_SRC_DIR)/source-extracted $(SRCCACHE)/$(LIBSSH2_SRC_DIR)/libssh2-netinet-in.patch-applied
 	mkdir -p $(dir $@)
 	cd $(dir $@) && \
 	$(CMAKE) $(dir $<) $(LIBSSH2_OPTS)
@@ -65,7 +61,7 @@ clean-libssh2:
 
 
 get-libssh2: $(LIBSSH2_SRC_FILE)
-extract-libssh2: $(SRCDIR)/srccache/$(LIBSSH2_SRC_DIR)/source-extracted
+extract-libssh2: $(SRCCACHE)/$(LIBSSH2_SRC_DIR)/source-extracted
 configure-libssh2: $(BUILDDIR)/$(LIBSSH2_SRC_DIR)/build-configured
 compile-libssh2: $(BUILDDIR)/$(LIBSSH2_SRC_DIR)/build-compiled
 fastcheck-libssh2: check-libssh2
diff --git a/deps/libuv.mk b/deps/libuv.mk
index 9aa93a1b385139..d8c189fb33f036 100644
--- a/deps/libuv.mk
+++ b/deps/libuv.mk
@@ -1,7 +1,7 @@
 ## LIBUV ##
 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,,$(SRCDIR)/srccache))
+$(eval $(call git-external,libuv,LIBUV,configure,,$(SRCCACHE)))
 
 UV_CFLAGS := -D_GNU_SOURCE
 ifeq ($(USEMSVC), 1)
@@ -24,10 +24,10 @@ else
 UV_FLAGS := --disable-shared $(UV_MFLAGS)
 endif
 
-$(BUILDDIR)/$(LIBUV_SRC_DIR)/build-configured: $(SRCDIR)/srccache/$(LIBUV_SRC_DIR)/source-extracted
-	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
+$(BUILDDIR)/$(LIBUV_SRC_DIR)/build-configured: $(SRCCACHE)/$(LIBUV_SRC_DIR)/source-extracted
+	touch -c $(SRCCACHE)/$(LIBUV_SRC_DIR)/aclocal.m4 # touch a few files to prevent autogen from getting called
+	touch -c $(SRCCACHE)/$(LIBUV_SRC_DIR)/Makefile.in
+	touch -c $(SRCCACHE)/$(LIBUV_SRC_DIR)/configure
 	mkdir -p $(dir $@)
 	cd $(dir $@) && \
 	$(dir $<)/configure --with-pic $(CONFIGURE_COMMON) $(UV_FLAGS)
@@ -54,7 +54,7 @@ clean-libuv:
 
 
 get-libuv: $(LIBUV_SRC_FILE)
-extract-libuv: $(SRCDIR)/srccache/$(LIBUV_SRC_DIR)/source-extracted
+extract-libuv: $(SRCCACHE)/$(LIBUV_SRC_DIR)/source-extracted
 configure-libuv: $(BUILDDIR)/$(LIBUV_SRC_DIR)/build-configured
 compile-libuv: $(BUILDDIR)/$(LIBUV_SRC_DIR)/build-compiled
 fastcheck-libuv: #none
diff --git a/deps/llvm-options.mk b/deps/llvm-options.mk
new file mode 100644
index 00000000000000..3dbcf0b2199b3a
--- /dev/null
+++ b/deps/llvm-options.mk
@@ -0,0 +1,21 @@
+ifeq ($(LLVM_DEBUG),1)
+LLVM_BUILDTYPE := Debug
+else
+LLVM_BUILDTYPE := Release
+endif
+LLVM_CMAKE_BUILDTYPE := $(LLVM_BUILDTYPE)
+ifeq ($(LLVM_ASSERTIONS),1)
+LLVM_BUILDTYPE := $(LLVM_BUILDTYPE)+Asserts
+endif
+LLVM_FLAVOR := $(LLVM_BUILDTYPE)
+ifeq ($(LLVM_SANITIZE),1)
+ifeq ($(SANITIZE_MEMORY),1)
+LLVM_BUILDTYPE := $(LLVM_BUILDTYPE)+MSAN
+else
+LLVM_BUILDTYPE := $(LLVM_BUILDTYPE)+ASAN
+endif
+endif
+
+LLVM_SRC_DIR:=$(SRCCACHE)/llvm-$(LLVM_VER)
+LLVM_BUILD_DIR:=$(BUILDDIR)/llvm-$(LLVM_VER)
+LLVM_BUILDDIR_withtype := $(LLVM_BUILD_DIR)/build_$(LLVM_BUILDTYPE)
diff --git a/deps/llvm-ver.make b/deps/llvm-ver.make
index c0f595722dec30..c2c7f2bc56da77 100644
--- a/deps/llvm-ver.make
+++ b/deps/llvm-ver.make
@@ -10,9 +10,3 @@ LLVM_VER_PATCH:=$(word 3, $(subst ., ,$(LLVM_VER)))
 ifeq ($(LLVM_VER_PATCH),)
 LLVM_VER_PATCH := 0
 endif
-
-ifeq ($(LLVM_VER_SHORT),$(filter $(LLVM_VER_SHORT),3.3 3.4 3.5 3.6 3.7))
-LLVM_USE_CMAKE := 0
-else
-LLVM_USE_CMAKE := 1
-endif
diff --git a/deps/llvm.mk b/deps/llvm.mk
index 92e6a5e2f5236b..0b24f95abaa75f 100644
--- a/deps/llvm.mk
+++ b/deps/llvm.mk
@@ -23,45 +23,21 @@ endif
 endif
 endif
 
-ifeq ($(LLVM_DEBUG),1)
-LLVM_BUILDTYPE := Debug
-else
-LLVM_BUILDTYPE := Release
-endif
-LLVM_CMAKE_BUILDTYPE := $(LLVM_BUILDTYPE)
-ifeq ($(LLVM_ASSERTIONS),1)
-LLVM_BUILDTYPE := $(LLVM_BUILDTYPE)+Asserts
-endif
-LLVM_FLAVOR := $(LLVM_BUILDTYPE)
-ifeq ($(LLVM_SANITIZE),1)
-ifeq ($(SANITIZE_MEMORY),1)
-LLVM_BUILDTYPE := $(LLVM_BUILDTYPE)+MSAN
-else
-LLVM_BUILDTYPE := $(LLVM_BUILDTYPE)+ASAN
-endif
-endif
-
-LLVM_SRC_DIR:=$(SRCDIR)/srccache/llvm-$(LLVM_VER)
-LLVM_BUILD_DIR:=$(BUILDDIR)/llvm-$(LLVM_VER)
-LLVM_BUILDDIR_withtype := $(LLVM_BUILD_DIR)/build_$(LLVM_BUILDTYPE)
+include $(SRCDIR)/llvm-options.mk
 LLVM_LIB_FILE := libLLVMCodeGen.a
 
-ifeq ($(LLVM_VER), 3.3)
-LLVM_TAR_EXT:=$(LLVM_VER).src.tar.gz
-else
 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)
+LLVM_TAR:=$(SRCCACHE)/llvm-$(LLVM_TAR_EXT)
 
 ifeq ($(BUILD_LLDB),1)
-LLVM_LLDB_TAR:=$(SRCDIR)/srccache/lldb-$(LLVM_TAR_EXT)
+LLVM_LLDB_TAR:=$(SRCCACHE)/lldb-$(LLVM_TAR_EXT)
 endif # BUILD_LLDB
 
 ifeq ($(BUILD_LLVM_CLANG),1)
-LLVM_CLANG_TAR:=$(SRCDIR)/srccache/cfe-$(LLVM_TAR_EXT)
-LLVM_COMPILER_RT_TAR:=$(SRCDIR)/srccache/compiler-rt-$(LLVM_TAR_EXT)
+LLVM_CLANG_TAR:=$(SRCCACHE)/cfe-$(LLVM_TAR_EXT)
+LLVM_COMPILER_RT_TAR:=$(SRCCACHE)/compiler-rt-$(LLVM_TAR_EXT)
 else
 LLVM_CLANG_TAR:=
 LLVM_COMPILER_RT_TAR:=
@@ -69,16 +45,18 @@ LLVM_LIBCXX_TAR:=
 endif # BUILD_LLVM_CLANG
 
 ifeq ($(BUILD_CUSTOM_LIBCXX),1)
-LLVM_LIBCXX_TAR:=$(SRCDIR)/srccache/libcxx-$(LLVM_TAR_EXT)
+LLVM_LIBCXX_TAR:=$(SRCCACHE)/libcxx-$(LLVM_TAR_EXT)
 endif
 endif # LLVM_VER != svn
 
 # Figure out which targets to build
-ifeq ($(LLVM_VER_SHORT),$(filter $(LLVM_VER_SHORT),3.3 3.4 3.5 3.6 3.7 3.8))
-LLVM_TARGETS := host
-else
 LLVM_TARGETS := host;NVPTX
-endif
+
+LLVM_CFLAGS :=
+LLVM_CXXFLAGS :=
+LLVM_CPPFLAGS :=
+LLVM_LDFLAGS :=
+LLVM_CMAKE :=
 
 # Allow adding LLVM specific flags
 LLVM_CFLAGS += $(CFLAGS)
@@ -86,6 +64,9 @@ LLVM_CXXFLAGS += $(CXXFLAGS)
 LLVM_CPPFLAGS += $(CPPFLAGS)
 LLVM_LDFLAGS += $(LDFLAGS)
 LLVM_CMAKE += -DLLVM_TARGETS_TO_BUILD:STRING="$(LLVM_TARGETS)" -DCMAKE_BUILD_TYPE="$(LLVM_CMAKE_BUILDTYPE)"
+ifeq ($(USE_POLLY_ACC),1)
+LLVM_CMAKE += -DPOLLY_ENABLE_GPGPU_CODEGEN=ON
+endif
 LLVM_CMAKE += -DLLVM_TOOLS_INSTALL_DIR=$(shell $(JULIAHOME)/contrib/relative_path.sh $(build_prefix) $(build_depsbindir))
 LLVM_CMAKE += -DLLVM_BINDINGS_LIST="" -DLLVM_INCLUDE_DOCS=Off -DLLVM_ENABLE_TERMINFO=Off -DHAVE_HISTEDIT_H=Off -DHAVE_LIBEDIT=Off
 LLVM_FLAGS += --disable-profiling --enable-static --enable-targets=$(LLVM_TARGETS)
@@ -93,6 +74,7 @@ LLVM_FLAGS += --disable-bindings --disable-docs --disable-libedit --disable-term
 # 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_depsbindir) PROJ_includedir=$(build_includedir)
+LLVM_MFLAGS += LD="$(LD)"
 ifeq ($(LLVM_ASSERTIONS), 1)
 LLVM_FLAGS += --enable-assertions
 LLVM_CMAKE += -DLLVM_ENABLE_ASSERTIONS:BOOL=ON
@@ -124,11 +106,7 @@ 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
-# NOTE: starting with LLVM 3.8, all symbols are exported
-ifeq ($(LLVM_VER_SHORT),$(filter $(LLVM_VER_SHORT),3.3 3.4 3.5 3.6 3.7))
-LLVM_CMAKE += -DLLVM_DYLIB_EXPORT_ALL:BOOL=ON
-endif
+LLVM_CMAKE += -DLLVM_BUILD_LLVM_DYLIB:BOOL=ON -DLLVM_LINK_LLVM_DYLIB:BOOL=ON
 endif
 ifeq ($(USE_INTEL_JITEVENTS), 1)
 LLVM_FLAGS += --with-intel-jitevents
@@ -159,22 +137,7 @@ ifneq (,$(filter $(ARCH), powerpc64le ppc64le))
 LLVM_CXXFLAGS += -mminimal-toc
 endif
 
-# 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_CFLAGS += -fsanitize=memory -fsanitize-memory-track-origins
 LLVM_LDFLAGS += -fsanitize=memory -fsanitize-memory-track-origins
@@ -195,6 +158,19 @@ LLVM_CPPFLAGS += -flto
 LLVM_LDFLAGS += -flto
 endif # LLVM_LTO
 
+ifeq ($(BUILD_CUSTOM_LIBCXX),1)
+LLVM_LDFLAGS += -Wl,-rpath,$(build_libdir)
+LLVM_CPPFLAGS += -I$(build_includedir)
+# We don't want to link to libc++ while trying to build it, so we define these
+# flags separately so that we can still pass them to the main LLVM build
+LLVM_LIBCXX_LDFLAGS := -lc++ -lc++abi
+ifeq ($(USEICC),1)
+LLVM_LDFLAGS += -no_cpprt
+endif # USEICC
+else
+LLVM_LIBCXX_LDFLAGS :=
+endif # BUILD_CUSTOM_LIBCXX
+
 ifneq ($(LLVM_CXXFLAGS),)
 LLVM_FLAGS += CXXFLAGS="$(LLVM_CXXFLAGS)"
 LLVM_MFLAGS += CXXFLAGS="$(LLVM_CXXFLAGS)"
@@ -204,73 +180,55 @@ LLVM_FLAGS += CFLAGS="$(LLVM_CFLAGS)"
 LLVM_MFLAGS += CFLAGS="$(LLVM_CFLAGS)"
 endif # LLVM_CFLAGS
 
-ifeq ($(BUILD_CUSTOM_LIBCXX),1)
-LLVM_LDFLAGS += -Wl,-R$(build_libdir) -lc++ -lc++abi
-ifeq ($(USEICC),1)
-LLVM_LDFLAGS += -no_cpprt
-endif # USEICC
-endif # BUILD_CUSTOM_LIBCXX
-
 ifneq ($(LLVM_CPPFLAGS),)
 LLVM_FLAGS += CPPFLAGS="$(LLVM_CPPFLAGS)"
 LLVM_MFLAGS += CPPFLAGS="$(LLVM_CPPFLAGS)"
 endif
 ifneq ($(LLVM_LDFLAGS),)
-LLVM_FLAGS += LDFLAGS="$(LLVM_LDFLAGS)"
-LLVM_MFLAGS += LDFLAGS="$(LLVM_LDFLAGS)"
+LLVM_FLAGS += LDFLAGS="$(LLVM_LDFLAGS) $(LLVM_LIBCXX_LDFLAGS)"
+LLVM_MFLAGS += LDFLAGS="$(LLVM_LDFLAGS) $(LLVM_LIBCXX_LDFLAGS)"
 endif
 LLVM_CMAKE += -DCMAKE_C_FLAGS="$(LLVM_CPPFLAGS) $(LLVM_CFLAGS)" \
-	-DCMAKE_CXX_FLAGS="$(LLVM_CPPFLAGS) $(LLVM_CXXFLAGS)" \
-	-DCMAKE_EXE_LINKER_FLAGS="$(LLVM_LDFLAGS)" \
-	-DCMAKE_SHARED_LINKER_FLAGS="$(LLVM_LDFLAGS)"
+	-DCMAKE_CXX_FLAGS="$(LLVM_CPPFLAGS) $(LLVM_CXXFLAGS)"
 
 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))
-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))
-LLVM_CMAKE += -DLLVM_EXTERNAL_LLDB_BUILD=OFF
-else
 LLVM_CMAKE += -DLLVM_TOOL_LLDB_BUILD=OFF
 endif
-endif
 
 LLVM_SRC_URL := http://releases.llvm.org/$(LLVM_VER)
 
 ifneq ($(LLVM_CLANG_TAR),)
-$(LLVM_CLANG_TAR): | $(SRCDIR)/srccache
+$(LLVM_CLANG_TAR): | $(SRCCACHE)
 	$(JLDOWNLOAD) $@ $(LLVM_SRC_URL)/$(notdir $@)
 endif
 ifneq ($(LLVM_COMPILER_RT_TAR),)
-$(LLVM_COMPILER_RT_TAR): | $(SRCDIR)/srccache
+$(LLVM_COMPILER_RT_TAR): | $(SRCCACHE)
 	$(JLDOWNLOAD) $@ $(LLVM_SRC_URL)/$(notdir $@)
 endif
 
 ifneq ($(LLVM_LIBCXX_TAR),)
-$(LLVM_LIBCXX_TAR): | $(SRCDIR)/srccache
+$(LLVM_LIBCXX_TAR): | $(SRCCACHE)
 	$(JLDOWNLOAD) $@ $(LLVM_SRC_URL)/$(notdir $@)
 endif
 ifneq ($(LLVM_VER),svn)
-$(LLVM_TAR): | $(SRCDIR)/srccache
+$(LLVM_TAR): | $(SRCCACHE)
 	$(JLDOWNLOAD) $@ $(LLVM_SRC_URL)/$(notdir $@)
 endif
 
 ifneq ($(LLVM_LLDB_TAR),)
-$(LLVM_LLDB_TAR): | $(SRCDIR)/srccache
+$(LLVM_LLDB_TAR): | $(SRCCACHE)
 	$(JLDOWNLOAD) $@ $(LLVM_SRC_URL)/$(notdir $@)
 endif
 ifeq ($(BUILD_LLDB),1)
@@ -280,7 +238,7 @@ endif
 
 # LLDB still relies on plenty of python 2.x infrastructure, without checking
 llvm_python_location=$(shell /usr/bin/env python2 -c 'import sys; print(sys.executable)')
-llvm_python_workaround=$(SRCDIR)/srccache/python2_path
+llvm_python_workaround=$(SRCCACHE)/python2_path
 $(llvm_python_workaround):
 	mkdir -p $@
 	-python -c 'import sys; sys.exit(not sys.version_info > (3, 0))' && \
@@ -291,46 +249,83 @@ LLVM_FLAGS += --with-python="$(shell $(SRCDIR)/tools/find_python2)"
 
 ifeq ($(BUILD_CUSTOM_LIBCXX),1)
 
+# Take a snapshot of the CMake flags before linking to -lc++ and -lc++abi
+# These are added to the LLVM CMake flags further down
+LLVM_CMAKE_LIBCXX := $(LLVM_CMAKE) \
+	-DCMAKE_EXE_LINKER_FLAGS="$(LLVM_LDFLAGS)" \
+	-DCMAKE_SHARED_LINKER_FLAGS="$(LLVM_LDFLAGS)"
+
 ifeq ($(USEICC),1)
 LIBCXX_EXTRA_FLAGS := -Bstatic -lirc -Bdynamic
 endif
 
+# These libraries require unwind.h from the libunwind dependency
+ifeq ($(USE_SYSTEM_LIBUNWIND),0)
+ifeq ($(OS),Darwin)
+BUILT_UNWIND := $(build_prefix)/manifest/osxunwind
+else
+BUILT_UNWIND := $(build_prefix)/manifest/unwind
+endif # Darwin
+else
+BUILT_UNWIND :=
+endif # Building libunwind
+
 $(LLVM_SRC_DIR)/projects/libcxx: $(LLVM_LIBCXX_TAR) | $(LLVM_SRC_DIR)/source-extracted
 	([ ! -d $@ ] && \
 	git clone $(LLVM_GIT_URL_LIBCXX) $@  ) || \
 	(cd $@  && \
 	git pull --ff-only)
-$(LLVM_SRC_DIR)/projects/libcxx/.git/HEAD: | $(LLVM_SRC_DIR)/projects/libcxx/.git/HEAD
+$(LLVM_SRC_DIR)/projects/libcxx/.git/HEAD: | $(LLVM_SRC_DIR)/projects/libcxx
 $(LLVM_SRC_DIR)/projects/libcxxabi: $(LLVM_LIBCXXABI_TAR) | $(LLVM_SRC_DIR)/source-extracted
 	([ ! -d $@ ] && \
 	git clone $(LLVM_GIT_URL_LIBCXXABI) $@ ) || \
 	(cd $@ && \
 	git pull --ff-only)
 $(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
+$(LLVM_BUILD_DIR)/libcxx-build/Makefile: | $(LLVM_SRC_DIR)/projects/libcxx $(LLVM_SRC_DIR)/projects/libcxxabi $(BUILT_UNWIND)
 	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="$(LDFLAGS) -L$(build_libdir) $(LIBCXX_EXTRA_FLAGS)"
-$(LLVM_BUILD_DIR)/libcxxabi-build/Makefile: | $(LLVM_SRC_DIR)/projects/libcxxabi $(LLVM_SRC_DIR)/projects/libcxx
+		$(CMAKE) -G "Unix Makefiles" $(CMAKE_COMMON) $(LLVM_CMAKE_LIBCXX) -DLIBCXX_CXX_ABI=libcxxabi -DLIBCXX_CXX_ABI_INCLUDE_PATHS="$(LLVM_SRC_DIR)/projects/libcxxabi/include" $(LLVM_SRC_DIR)/projects/libcxx -DCMAKE_SHARED_LINKER_FLAGS="$(LDFLAGS) -L$(build_libdir) $(LIBCXX_EXTRA_FLAGS)"
+$(LLVM_BUILD_DIR)/libcxxabi-build/Makefile: | $(LLVM_SRC_DIR)/projects/libcxxabi $(LLVM_SRC_DIR)/projects/libcxx $(BUILT_UNWIND)
 	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="$(LLVM_CPPFLAGS) $(LLVM_CXXFLAGS) -std=c++11"
+		$(CMAKE) -G "Unix Makefiles" $(CMAKE_COMMON) $(LLVM_CMAKE_LIBCXX) -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="$(LLVM_CPPFLAGS) $(LLVM_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 $@
+	# Building this library installs these headers, which breaks other dependencies
+	-rm -rf $(build_includedir)/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 $@
+	# Building this library installs these headers, which breaks other dependencies
+	-rm -rf $(build_includedir)/c++
 get-libcxx: $(LLVM_SRC_DIR)/projects/libcxx
 get-libcxxabi: $(LLVM_SRC_DIR)/projects/libcxxabi
 install-libcxxabi: $(build_libdir)/libc++abi.so.1.0
 install-libcxx: $(build_libdir)/libc++.so.1.0
-endif
+endif # BUILD_CUSTOM_LIBCXX
+
+# We want to be able to clean without having to pass BUILD_CUSTOM_LIBCXX=1, so define these
+# outside of the conditional above
+clean-libcxx:
+	-$(MAKE) -C $(LLVM_BUILD_DIR)/libcxx-build clean
+clean-libcxxabi:
+	-$(MAKE) -C $(LLVM_BUILD_DIR)/libcxxabi-build clean
+distclean-libcxx:
+	-rm -rf $(LLVM_LIBCXX_TAR) $(LLVM_SRC_DIR)/projects/libcxx $(LLVM_BUILD_DIR)/libcxx-build
+distclean-libcxxabi:
+	-rm -rf $(LLVM_LIBCXXABI_TAR) $(LLVM_SRC_DIR)/projects/libcxxabi $(LLVM_BUILD_DIR)/libcxxabi-build
+
+# We want to ensure that the libcxx linking flags don't get passed to the libcxx build, since it will
+# error on a fresh build
+LLVM_CMAKE += -DCMAKE_EXE_LINKER_FLAGS="$(LLVM_LDFLAGS) $(LLVM_LIBCXX_LDFLAGS)" \
+	-DCMAKE_SHARED_LINKER_FLAGS="$(LLVM_LDFLAGS) $(LLVM_LIBCXX_LDFLAGS)"
 
 ifeq ($(BUILD_CUSTOM_LIBCXX),1)
 LIBCXX_DEPENDENCY := $(build_libdir)/libc++abi.so.1.0 $(build_libdir)/libc++.so.1.0
@@ -434,61 +429,9 @@ $$(LLVM_SRC_DIR)/$1.patch-applied: $$(LLVM_SRC_DIR)/source-extracted | $$(SRCDIR
 LLVM_PATCH_PREV := $$(LLVM_SRC_DIR)/$1.patch-applied
 endef
 
-ifeq ($(LLVM_VER),3.3)
-$(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_SHORT),3.7)
-ifeq ($(LLVM_VER),3.7.0)
-$(eval $(call LLVM_PATCH,llvm-3.7.0))
-endif
-$(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-3.7.1_symlinks))
-$(eval $(call LLVM_PATCH,llvm-3.8.0_bindir))
-$(eval $(call LLVM_PATCH,llvm-D14260))
-$(eval $(call LLVM_PATCH,llvm-nodllalias))
-$(eval $(call LLVM_PATCH,llvm-D21271-instcombine-tbaa-3.7))
-$(eval $(call LLVM_PATCH,llvm-win64-reloc-dwarf))
-$(eval $(call LLVM_PATCH,llvm-3.7.1_destsharedlibdir))
-$(eval $(call LLVM_PATCH,llvm-arm-fix-prel31))
-else ifeq ($(LLVM_VER_SHORT),3.8)
-ifeq ($(LLVM_VER),3.8.0)
-$(eval $(call LLVM_PATCH,llvm-D17326_unpack_load))
-endif
-ifeq ($(LLVM_VER),3.8.1)
-$(eval $(call LLVM_PATCH,llvm-3.8.1-version))
-endif
-$(eval $(call LLVM_PATCH,llvm-3.7.1_3)) # Remove for 3.9
-$(eval $(call LLVM_PATCH,llvm-D14260))
-$(eval $(call LLVM_PATCH,llvm-3.8.0_bindir)) # Remove for 3.9
-$(eval $(call LLVM_PATCH,llvm-3.8.0_winshlib)) # Remove for 3.9
-$(eval $(call LLVM_PATCH,llvm-D25865-cmakeshlib))
-$(eval $(call LLVM_PATCH,llvm-nodllalias)) # Remove for 3.9
-# Cygwin and openSUSE still use win32-threads mingw, https://llvm.org/bugs/show_bug.cgi?id=26365
-$(eval $(call LLVM_PATCH,llvm-3.8.0_threads))
-# fix replutil test on unix
-$(eval $(call LLVM_PATCH,llvm-D17165-D18583)) # Remove for 3.9
-# Segfault for aggregate load
-$(eval $(call LLVM_PATCH,llvm-D17712)) # Remove for 3.9
-$(eval $(call LLVM_PATCH,llvm-PR26180)) # Remove for 3.9
-$(eval $(call LLVM_PATCH,llvm-PR27046)) # Remove for 3.9
-$(eval $(call LLVM_PATCH,llvm-3.8.0_ppc64_SUBFC8)) # Remove for 3.9
-$(eval $(call LLVM_PATCH,llvm-D21271-instcombine-tbaa-3.8)) # Remove for 3.9
-$(eval $(call LLVM_PATCH,llvm-win64-reloc-dwarf))
-$(eval $(call LLVM_PATCH,llvm-arm-fix-prel31))
-else ifeq ($(LLVM_VER_SHORT),3.9)
-ifeq ($(LLVM_VER),3.9.0)
-# fix lowering for atomics on ppc
-$(eval $(call LLVM_PATCH,llvm-rL279933-ppc-atomicrmw-lowering)) # Remove for 4.0
-$(eval $(call LLVM_PATCH,llvm-r282182)) # Remove for 4.0
-$(eval $(call LLVM_PATCH,llvm-3.9.0_cygwin)) # R283427, Remove for 4.0
-endif
+ifeq ($(LLVM_VER_SHORT),3.9)
 $(eval $(call LLVM_PATCH,llvm-PR22923)) # Remove for 4.0
-$(eval $(call LLVM_PATCH,llvm-arm-fix-prel31))
+$(eval $(call LLVM_PATCH,llvm-arm-fix-prel31)) # Remove for 4.0
 $(eval $(call LLVM_PATCH,llvm-D25865-cmakeshlib)) # Remove for 4.0
 # Cygwin and openSUSE still use win32-threads mingw, https://llvm.org/bugs/show_bug.cgi?id=26365
 $(eval $(call LLVM_PATCH,llvm-3.9.0_threads))
@@ -505,82 +448,81 @@ $(eval $(call LLVM_PATCH,llvm-D27397)) # Julia issue #19792, Remove for 4.0
 $(eval $(call LLVM_PATCH,llvm-D28009)) # Julia issue #19792, Remove for 4.0
 $(eval $(call LLVM_PATCH,llvm-D28215_FreeBSD_shlib))
 $(eval $(call LLVM_PATCH,llvm-D28221-avx512)) # mentioned in issue #19797
+$(eval $(call LLVM_PATCH,llvm-PR276266)) # Issue #19976, Remove for 4.0
+$(eval $(call LLVM_PATCH,llvm-PR278088)) # Issue #19976, Remove for 4.0
+$(eval $(call LLVM_PATCH,llvm-PR277939)) # Issue #19976, Remove for 4.0
+$(eval $(call LLVM_PATCH,llvm-PR278321)) # Issue #19976, Remove for 4.0
+$(eval $(call LLVM_PATCH,llvm-PR278923)) # Issue #19976, Remove for 4.0
+$(eval $(call LLVM_PATCH,llvm-D28759-loopclearance))
+$(eval $(call LLVM_PATCH,llvm-D28786-callclearance))
 $(eval $(call LLVM_PATCH,llvm-rL293230-icc17-cmake)) # Remove for 4.0
+$(eval $(call LLVM_PATCH,llvm-D32593))
+$(eval $(call LLVM_PATCH,llvm-D33179))
+$(eval $(call LLVM_PATCH,llvm-PR29010-i386-xmm)) # Remove for 4.0
+else ifeq ($(LLVM_VER_SHORT),4.0)
+# Cygwin and openSUSE still use win32-threads mingw, https://llvm.org/bugs/show_bug.cgi?id=26365
+$(eval $(call LLVM_PATCH,llvm-4.0.0_threads))
+$(eval $(call LLVM_PATCH,llvm-3.9.0_D27296-libssp))
+$(eval $(call LLVM_PATCH,llvm-D27629-AArch64-large_model_4.0))
+$(eval $(call LLVM_PATCH,llvm-D28215_FreeBSD_shlib)) # Remove for 5.0
+$(eval $(call LLVM_PATCH,llvm-D28759-loopclearance)) # Remove for 5.0
+$(eval $(call LLVM_PATCH,llvm-D28786-callclearance_4.0)) # Remove for 5.0
+$(eval $(call LLVM_PATCH,llvm-D32593)) # Remove for 5.0
+$(eval $(call LLVM_PATCH,llvm-D33179)) # Remove for 5.0
+$(eval $(call LLVM_PATCH,llvm-D32203-SORA-non-integral)) # Remove for 5.0
+$(eval $(call LLVM_PATCH,llvm-D33110-codegen-prepare-inttoptr))
+$(eval $(call LLVM_PATCH,llvm-D30478-VNCoercion)) # Remove for 5.0
+$(eval $(call LLVM_PATCH,llvm-VNCoercion-signatures)) # Remove for 5.0
+$(eval $(call LLVM_PATCH,llvm-VNCoercion-template)) # Remove for 5.0
+$(eval $(call LLVM_PATCH,llvm-D32196-LIR-non-integral)) # Remove for 5.0
+$(eval $(call LLVM_PATCH,llvm-D32208-coerce-non-integral)) # Remove for 5.0
+$(eval $(call LLVM_PATCH,llvm-D32623-GVN-non-integral)) # Remove for 5.0
+$(eval $(call LLVM_PATCH,llvm-D33129-scevexpander-non-integral)) # Remove for 5.0
+$(eval $(call LLVM_PATCH,llvm-Yet-another-fix))
 endif # LLVM_VER
 
-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_withtype)/build-configured: $(LLVM_PATCH_PREV)
 
-ifeq ($(LLVM_USE_CMAKE),1)
-
 $(LLVM_BUILDDIR_withtype)/build-configured: $(LLVM_SRC_DIR)/source-extracted | $(llvm_python_workaround) $(LIBCXX_DEPENDENCY)
 	mkdir -p $(dir $@)
 	cd $(dir $@) && \
-		export PATH=$(llvm_python_workaround):$$PATH && \
+		export PATH=$(llvm_python_workaround):"$$PATH" && \
 		$(CMAKE) $(LLVM_SRC_DIR) $(CMAKE_GENERATOR_COMMAND) $(CMAKE_COMMON) $(LLVM_CMAKE) \
 		|| { echo '*** To install a newer version of cmake, run contrib/download_cmake.sh ***' && false; }
 	echo 1 > $@
 
 $(LLVM_BUILDDIR_withtype)/build-compiled: $(LLVM_BUILDDIR_withtype)/build-configured | $(llvm_python_workaround)
 	cd $(LLVM_BUILDDIR_withtype) && \
-		export PATH=$(llvm_python_workaround):$$PATH && \
+		export PATH=$(llvm_python_workaround):"$$PATH" && \
 		$(if $(filter $(CMAKE_GENERATOR),make), \
 		  $(MAKE), \
 		  $(CMAKE) --build .)
 	echo 1 > $@
 
-else
-
-$(LLVM_BUILDDIR_withtype)/build-configured: $(LLVM_SRC_DIR)/source-extracted | $(llvm_python_workaround) $(LIBCXX_DEPENDENCY)
-	mkdir -p $(dir $@)
-	cd $(dir $@) && \
-		export PATH=$(llvm_python_workaround):$$PATH && \
-		$(LLVM_SRC_DIR)/configure $(CONFIGURE_COMMON) $(LLVM_FLAGS)
-	echo 1 > $@
-
-$(LLVM_BUILDDIR_withtype)/build-compiled: $(LLVM_BUILDDIR_withtype)/build-configured | $(llvm_python_workaround)
-	cd $(LLVM_BUILDDIR_withtype) && \
-		export PATH=$(llvm_python_workaround):$$PATH && \
-		$(MAKE) $(LLVM_MFLAGS) $(MAKE_COMMON)
-	echo 1 > $@
-
-endif # LLVM_USE_CMAKE
-
 $(LLVM_BUILDDIR_withtype)/build-checked: $(LLVM_BUILDDIR_withtype)/build-compiled | $(llvm_python_workaround)
 ifeq ($(OS),$(BUILD_OS))
 	cd $(LLVM_BUILDDIR_withtype) && \
-		export PATH=$(llvm_python_workaround):$$PATH && \
-		$(if $(filter $(LLVM_USE_CMAKE),1), \
-		  $(CMAKE) --build . --target check, \
-		  $(MAKE) $(LLVM_MFLAGS) check)
+		export PATH=$(llvm_python_workaround):"$$PATH" && \
+		  $(CMAKE) --build . --target check
 endif
 	echo 1 > $@
 
 $(build_prefix)/manifest/llvm: | $(llvm_python_workaround)
 
-ifeq ($(LLVM_USE_CMAKE),1)
 LLVM_INSTALL = \
 	cd $1 && $$(CMAKE) -DCMAKE_INSTALL_PREFIX="$2$$(build_prefix)" -P cmake_install.cmake
-else
-LLVM_INSTALL = \
-	$(call MAKE_INSTALL,$1,$2,$3 $$(LLVM_MFLAGS) PATH="$$(llvm_python_workaround):$$$$PATH" DestSharedLibDir="$2$$(build_shlibdir)")
-endif # LLVM_USE_CMAKE
+ifeq ($(OS), WINNT)
+LLVM_INSTALL += && cp $2$$(build_shlibdir)/LLVM.dll $2$$(build_depsbindir)
+endif
 
 $(eval $(call staged-install,llvm,llvm-$$(LLVM_VER)/build_$$(LLVM_BUILDTYPE), \
 	LLVM_INSTALL,,,))
 
-clean-llvm:
+clean-llvm: clean-libcxx clean-libcxxabi
 	-rm $(LLVM_BUILDDIR_withtype)/build-configured $(LLVM_BUILDDIR_withtype)/build-compiled
 	-$(MAKE) -C $(LLVM_BUILDDIR_withtype) clean
 
-distclean-llvm:
+distclean-llvm: distclean-libcxx distclean-libcxxabi
 	-rm -rf $(LLVM_TAR) $(LLVM_CLANG_TAR) \
 		$(LLVM_COMPILER_RT_TAR) $(LLVM_LIBCXX_TAR) $(LLVM_LLDB_TAR) \
 		$(LLVM_SRC_DIR) $(LLVM_BUILDDIR_withtype)
diff --git a/deps/mbedtls.mk b/deps/mbedtls.mk
index f1f7b88d3ec3b6..dbe71b827c7efd 100644
--- a/deps/mbedtls.mk
+++ b/deps/mbedtls.mk
@@ -15,40 +15,31 @@ ifeq ($(BUILD_OS),WINNT)
 MBEDTLS_OPTS += -G"MSYS Makefiles"
 endif
 
-ifeq ($(OS),Linux)
+ifneq (,$(findstring $(OS),Linux FreeBSD))
 MBEDTLS_OPTS += -DCMAKE_INSTALL_RPATH="\$$ORIGIN"
 endif
 
-ifeq ($(OS),FreeBSD)
-MBEDTLS_OPTS += -DCMAKE_INSTALL_RPATH="\$$ORIGIN"
-endif
-
-$(SRCDIR)/srccache/$(MBEDTLS_SRC).tgz: | $(SRCDIR)/srccache
+$(SRCCACHE)/$(MBEDTLS_SRC).tgz: | $(SRCCACHE)
 	$(JLDOWNLOAD) $@ $(MBEDTLS_URL)
 
-$(SRCDIR)/srccache/$(MBEDTLS_SRC)/source-extracted: $(SRCDIR)/srccache/$(MBEDTLS_SRC).tgz
+$(SRCCACHE)/$(MBEDTLS_SRC)/source-extracted: $(SRCCACHE)/$(MBEDTLS_SRC).tgz
 	$(JLCHECKSUM) $<
 	mkdir -p $(dir $@) && \
 	$(TAR) -C $(dir $@) --strip-components 1 -xf $<
-	touch -c $(SRCDIR)/srccache/$(MBEDTLS_SRC)/CMakeLists.txt # old target
-	echo 1 > $@
-
-$(SRCDIR)/srccache/$(MBEDTLS_SRC)/mbedtls-ssl.h.patch-applied: $(SRCDIR)/srccache/$(MBEDTLS_SRC)/source-extracted
-	cd $(SRCDIR)/srccache/$(MBEDTLS_SRC)/include/mbedtls && patch -p0 -f < $(SRCDIR)/patches/mbedtls-ssl.h.patch
+	touch -c $(SRCCACHE)/$(MBEDTLS_SRC)/CMakeLists.txt # old target
 	echo 1 > $@
-$(BUILDDIR)/mbedtls-$(MBEDTLS_VER)/build-configured: $(SRCDIR)/srccache/$(MBEDTLS_SRC)/mbedtls-ssl.h.patch-applied
 
-$(BUILDDIR)/mbedtls-$(MBEDTLS_VER)/build-configured: $(SRCDIR)/srccache/$(MBEDTLS_SRC)/source-extracted
+$(BUILDDIR)/$(MBEDTLS_SRC)/build-configured: $(SRCCACHE)/$(MBEDTLS_SRC)/source-extracted
 	mkdir -p $(dir $@)
 	cd $(dir $@) && \
 	$(CMAKE) $(dir $<) $(MBEDTLS_OPTS)
 	echo 1 > $@
 
-$(BUILDDIR)/mbedtls-$(MBEDTLS_VER)/build-compiled: $(BUILDDIR)/mbedtls-$(MBEDTLS_VER)/build-configured
+$(BUILDDIR)/$(MBEDTLS_SRC)/build-compiled: $(BUILDDIR)/$(MBEDTLS_SRC)/build-configured
 	$(MAKE) -C $(dir $<)
 	echo 1 > $@
 
-$(BUILDDIR)/mbedtls-$(MBEDTLS_VER)/build-checked: $(BUILDDIR)/mbedtls-$(MBEDTLS_VER)/build-compiled
+$(BUILDDIR)/$(MBEDTLS_SRC)/build-checked: $(BUILDDIR)/$(MBEDTLS_SRC)/build-compiled
 ifeq ($(OS),$(BUILD_OS))
 	$(MAKE) -C $(dir $@) test
 endif
@@ -67,7 +58,7 @@ define MBEDTLS_INSTALL
 endef
 endif
 $(eval $(call staged-install, \
-	mbedtls,mbedtls-$(MBEDTLS_VER), \
+	mbedtls,$(MBEDTLS_SRC), \
 	MBEDTLS_INSTALL,,, \
 	$$(INSTALL_NAME_CMD)libmbedx509.$$(SHLIB_EXT) $$(build_shlibdir)/libmbedx509.$$(SHLIB_EXT) && \
 	$$(INSTALL_NAME_CMD)libmbedtls.$$(SHLIB_EXT) $$(build_shlibdir)/libmbedtls.$$(SHLIB_EXT) && \
@@ -78,20 +69,20 @@ $(eval $(call staged-install, \
 
 
 clean-mbedtls:
-	-rm $(BUILDDIR)/mbedtls-$(MBEDTLS_VER)/build-configured \
-		$(BUILDDIR)/mbedtls-$(MBEDTLS_VER)/build-compiled
-	-$(MAKE) -C $(BUILDDIR)/mbedtls-$(MBEDTLS_VER) clean
+	-rm $(BUILDDIR)/$(MBEDTLS_SRC)/build-configured \
+		$(BUILDDIR)/$(MBEDTLS_SRC)/build-compiled
+	-$(MAKE) -C $(BUILDDIR)/$(MBEDTLS_SRC) clean
 
 distclean-mbedtls:
-	-rm -rf $(SRCDIR)/srccache/$(MBEDTLS_SRC).tgz \
-		$(SRCDIR)/srccache/$(MBEDTLS_SRC) \
-		$(BUILDDIR)/mbedtls-$(MBEDTLS_VER)
+	-rm -rf $(SRCCACHE)/$(MBEDTLS_SRC).tgz \
+		$(SRCCACHE)/$(MBEDTLS_SRC) \
+		$(BUILDDIR)/$(MBEDTLS_SRC)
 
 
-get-mbedtls: $(SRCDIR)/srccache/$(MBEDTLS_SRC).tgz
-extract-mbedtls: $(SRCDIR)/srccache/$(MBEDTLS_SRC)/source-extracted
-configure-mbedtls: $(BUILDDIR)/mbedtls-$(MBEDTLS_VER)/build-configured
-compile-mbedtls: $(BUILDDIR)/mbedtls-$(MBEDTLS_VER)/build-compiled
+get-mbedtls: $(SRCCACHE)/$(MBEDTLS_SRC).tgz
+extract-mbedtls: $(SRCCACHE)/$(MBEDTLS_SRC)/source-extracted
+configure-mbedtls: $(BUILDDIR)/$(MBEDTLS_SRC)/build-configured
+compile-mbedtls: $(BUILDDIR)/$(MBEDTLS_SRC)/build-compiled
 # tests disabled since they are known to fail
 fastcheck-mbedtls: #check-mbedtls
-check-mbedtls: $(BUILDDIR)/mbedtls-$(MBEDTLS_VER)/build-checked
+check-mbedtls: $(BUILDDIR)/$(MBEDTLS_SRC)/build-checked
diff --git a/deps/mpfr.mk b/deps/mpfr.mk
index 1dfd65e56e8e99..f0cb2b89405954 100644
--- a/deps/mpfr.mk
+++ b/deps/mpfr.mk
@@ -25,15 +25,19 @@ ifeq ($(SANITIZE),1)
 MPFR_OPTS += --host=none-unknown-linux
 endif
 
-$(SRCDIR)/srccache/mpfr-$(MPFR_VER).tar.bz2: | $(SRCDIR)/srccache
+$(SRCCACHE)/mpfr-$(MPFR_VER).tar.bz2: | $(SRCCACHE)
 	$(JLDOWNLOAD) $@ http://www.mpfr.org/mpfr-$(MPFR_VER)/$(notdir $@)
-$(SRCDIR)/srccache/mpfr-$(MPFR_VER)/source-extracted: $(SRCDIR)/srccache/mpfr-$(MPFR_VER).tar.bz2
+$(SRCCACHE)/mpfr-$(MPFR_VER)/source-extracted: $(SRCCACHE)/mpfr-$(MPFR_VER).tar.bz2
 	$(JLCHECKSUM) $<
 	cd $(dir $<) && $(TAR) -jxf $<
-	touch -c $(SRCDIR)/srccache/mpfr-$(MPFR_VER)/configure # old target
+	touch -c $(SRCCACHE)/mpfr-$(MPFR_VER)/configure # old target
 	echo 1 > $@
 
-$(BUILDDIR)/mpfr-$(MPFR_VER)/build-configured: $(SRCDIR)/srccache/mpfr-$(MPFR_VER)/source-extracted
+$(SRCCACHE)/mpfr-$(MPFR_VER)/build-patched: $(SRCCACHE)/mpfr-$(MPFR_VER)/source-extracted
+	cd $(dir $@) && patch -p0 < $(SRCDIR)/patches/mpfr-sincos.patch
+	echo 1 > $@
+
+$(BUILDDIR)/mpfr-$(MPFR_VER)/build-configured: $(SRCCACHE)/mpfr-$(MPFR_VER)/source-extracted $(SRCCACHE)/mpfr-$(MPFR_VER)/build-patched
 	mkdir -p $(dir $@)
 	cd $(dir $@) && \
 	$(dir $<)/configure $(CONFIGURE_COMMON) $(MPFR_OPTS) F77= --enable-shared --disable-static
@@ -59,12 +63,12 @@ clean-mpfr:
 	-$(MAKE) -C $(BUILDDIR)/mpfr-$(MPFR_VER) clean
 
 distclean-mpfr:
-	-rm -rf $(SRCDIR)/srccache/mpfr-$(MPFR_VER).tar.bz2 \
-		$(SRCDIR)/srccache/mpfr-$(MPFR_VER) \
+	-rm -rf $(SRCCACHE)/mpfr-$(MPFR_VER).tar.bz2 \
+		$(SRCCACHE)/mpfr-$(MPFR_VER) \
 		$(BUILDDIR)/mpfr-$(MPFR_VER)
 
-get-mpfr: $(SRCDIR)/srccache/mpfr-$(MPFR_VER).tar.bz2
-extract-mpfr: $(SRCDIR)/srccache/mpfr-$(MPFR_VER)/source-extracted
+get-mpfr: $(SRCCACHE)/mpfr-$(MPFR_VER).tar.bz2
+extract-mpfr: $(SRCCACHE)/mpfr-$(MPFR_VER)/source-extracted
 configure-mpfr: $(BUILDDIR)/mpfr-$(MPFR_VER)/build-configured
 compile-mpfr: $(BUILDDIR)/mpfr-$(MPFR_VER)/build-compiled
 fastcheck-mpfr: check-mpfr
diff --git a/deps/objconv.mk b/deps/objconv.mk
index e651efe5d3ec97..d62bc55160e33b 100644
--- a/deps/objconv.mk
+++ b/deps/objconv.mk
@@ -1,9 +1,9 @@
 ## objconv ##
 
-$(SRCDIR)/srccache/objconv.zip: | $(SRCDIR)/srccache
+$(SRCCACHE)/objconv.zip: | $(SRCCACHE)
 	$(JLDOWNLOAD) $@ http://www.agner.org/optimize/objconv.zip
 
-$(BUILDDIR)/objconv/source-extracted: $(SRCDIR)/srccache/objconv.zip
+$(BUILDDIR)/objconv/source-extracted: $(SRCCACHE)/objconv.zip
 	-rm -r $(dir $@)
 	mkdir -p $(BUILDDIR)
 	unzip -d $(dir $@) $<
@@ -22,10 +22,10 @@ clean-objconv:
 	-rm $(BUILDDIR)/objconv/build-compiled $(build_depsbindir)/objconv
 
 distclean-objconv:
-	-rm -rf $(SRCDIR)/srccache/objconv.zip $(BUILDDIR)/objconv
+	-rm -rf $(SRCCACHE)/objconv.zip $(BUILDDIR)/objconv
 
 
-get-objconv: $(SRCDIR)/srccache/objconv.zip
+get-objconv: $(SRCCACHE)/objconv.zip
 extract-objconv: $(BUILDDIR)/objconv/source-extracted
 configure-objconv: extract-objconv
 compile-objconv: $(BUILDDIR)/objconv/build-compiled
diff --git a/deps/patchelf.mk b/deps/patchelf.mk
index 066fc2ebd8758c..552e48a941442e 100644
--- a/deps/patchelf.mk
+++ b/deps/patchelf.mk
@@ -1,15 +1,15 @@
 ## patchelf ##
 
-$(SRCDIR)/srccache/patchelf-$(PATCHELF_VER).tar.gz: | $(SRCDIR)/srccache
+$(SRCCACHE)/patchelf-$(PATCHELF_VER).tar.gz: | $(SRCCACHE)
 	$(JLDOWNLOAD) $@ http://nixos.org/releases/patchelf/patchelf-$(PATCHELF_VER)/patchelf-$(PATCHELF_VER).tar.gz
 
-$(SRCDIR)/srccache/patchelf-$(PATCHELF_VER)/source-extracted: $(SRCDIR)/srccache/patchelf-$(PATCHELF_VER).tar.gz
+$(SRCCACHE)/patchelf-$(PATCHELF_VER)/source-extracted: $(SRCCACHE)/patchelf-$(PATCHELF_VER).tar.gz
 	$(JLCHECKSUM) $<
 	cd $(dir $<) && $(TAR) zxf $<
-	touch -c $(SRCDIR)/srccache/patchelf-$(PATCHELF_VER)/configure # old target
+	touch -c $(SRCCACHE)/patchelf-$(PATCHELF_VER)/configure # old target
 	echo 1 > $@
 
-$(BUILDDIR)/patchelf-$(PATCHELF_VER)/build-configured: $(SRCDIR)/srccache/patchelf-$(PATCHELF_VER)/source-extracted | $(LIBCXX_DEPENDENCY)
+$(BUILDDIR)/patchelf-$(PATCHELF_VER)/build-configured: $(SRCCACHE)/patchelf-$(PATCHELF_VER)/source-extracted | $(LIBCXX_DEPENDENCY)
 	mkdir -p $(dir $@)
 	cd $(dir $@) && \
 	$(dir $<)/configure $(CONFIGURE_COMMON) LDFLAGS="$(CXXLDFLAGS)" CPPFLAGS="$(CPPFLAGS)"
@@ -36,13 +36,13 @@ clean-patchelf:
 	-$(MAKE) -C $(BUILDDIR)/patchelf-$(PATCHELF_VER) clean
 
 distclean-patchelf:
-	-rm -rf $(SRCDIR)/srccache/patchelf-$(PATCHELF_VER).tar.gz \
-		$(SRCDIR)/srccache/patchelf-$(PATCHELF_VER) \
+	-rm -rf $(SRCCACHE)/patchelf-$(PATCHELF_VER).tar.gz \
+		$(SRCCACHE)/patchelf-$(PATCHELF_VER) \
 		$(BUILDDIR)/patchelf-$(PATCHELF_VER)
 
 
-get-patchelf: $(SRCDIR)/srccache/patchelf-$(PATCHELF_VER).tar.gz
-extract-patchelf: $(SRCDIR)/srccache/patchelf-$(PATCHELF_VER)/source-extracted
+get-patchelf: $(SRCCACHE)/patchelf-$(PATCHELF_VER).tar.gz
+extract-patchelf: $(SRCCACHE)/patchelf-$(PATCHELF_VER)/source-extracted
 configure-patchelf: $(BUILDDIR)/patchelf-$(PATCHELF_VER)/build-configured
 compile-patchelf: $(BUILDDIR)/patchelf-$(PATCHELF_VER)/build-compiled
 check-patchelf: $(BUILDDIR)/patchelf-$(PATCHELF_VER)/build-checked
diff --git a/deps/patches/fftw-win32-intrin-h.patch b/deps/patches/fftw-win32-intrin-h.patch
deleted file mode 100644
index 5ca07881dc2d31..00000000000000
--- a/deps/patches/fftw-win32-intrin-h.patch
+++ /dev/null
@@ -1,42 +0,0 @@
-From cca0c6e5a8c717df10f380411709f3360ceea6e9 Mon Sep 17 00:00:00 2001
-From: Tony Kelman <tony@kelman.net>
-Date: Fri, 9 Sep 2016 03:24:30 -0700
-Subject: [PATCH] #include <intrin.h> in threads.c for windows build
-
-otherwise an i686-w64-mingw32 cross compile is giving
-```
-libtool: link: i686-w64-mingw32-gcc -march=pentium4 -m32  -std=gnu99 -shared  -Wl,--whole-archive kernel/.libs/libkernel.a dft/.libs/libdft.a dft/scalar/.libs/libdft_scalar.a dft/scalar/codelets/.libs/libdft_scalar_codelets.a rdft/.libs/librdft.a rdft/scalar/.libs/librdft_scalar.a rdft/scalar/r2cf/.libs/librdft_scalar_r2cf.a rdft/scalar/r2cb/.libs/librdft_scalar_r2cb.a rdft/scalar/r2r/.libs/librdft_scalar_r2r.a reodft/.libs/libreodft.a api/.libs/libapi.a simd-support/.libs/libsimd_support.a simd-support/.libs/libsimd_sse2_nonportable.a dft/simd/avx/.libs/libdft_avx_codelets.a rdft/simd/avx/.libs/librdft_avx_codelets.a threads/.libs/libfftw3f_threads.a -Wl,--no-whole-archive   -march=pentium4 -m32 -O3 -mtune=native -malign-double -Wl,--stack -Wl,8388608   -o .libs/libfftw3f-3.dll -Wl,--enable-auto-image-base -Xlinker --out-implib -Xlinker .libs/libfftw3f.dll.a
-libtool: link: i686-w64-mingw32-gcc -march=pentium4 -m32  -std=gnu99 -shared  -Wl,--whole-archive kernel/.libs/libkernel.a dft/.libs/libdft.a dft/scalar/.libs/libdft_scalar.a dft/scalar/codelets/.libs/libdft_scalar_codelets.a rdft/.libs/librdft.a rdft/scalar/.libs/librdft_scalar.a rdft/scalar/r2cf/.libs/librdft_scalar_r2cf.a rdft/scalar/r2cb/.libs/librdft_scalar_r2cb.a rdft/scalar/r2r/.libs/librdft_scalar_r2r.a reodft/.libs/libreodft.a api/.libs/libapi.a simd-support/.libs/libsimd_support.a simd-support/.libs/libsimd_sse2_nonportable.a dft/simd/avx/.libs/libdft_avx_codelets.a rdft/simd/avx/.libs/librdft_avx_codelets.a threads/.libs/libfftw3_threads.a -Wl,--no-whole-archive   -march=pentium4 -m32 -O3 -mtune=native -malign-double -Wl,--stack -Wl,8388608   -o .libs/libfftw3-3.dll -Wl,--enable-auto-image-base -Xlinker --out-implib -Xlinker .libs/libfftw3.dll.a
-threads/.libs/libfftw3_threads.a(libfftw3_threads_la-threads.o):threads.c:(.text+0x121): undefined reference to `_mm_pause'
-threads/.libs/libfftw3_threads.a(libfftw3_threads_la-threads.o):threads.c:(.text+0x581): undefined reference to `_mm_pause'
-collect2: error: ld returned 1 exit status
-threads/.libs/libfftw3f_threads.a(libfftw3f_threads_la-threads.o):threads.c:(.text+0x121): undefined reference to `_mm_pause'
-threads/.libs/libfftw3f_threads.a(libfftw3f_threads_la-threads.o):threads.c:(.text+0x581): undefined reference to `_mm_pause'
-collect2: error: ld returned 1 exit status
-make[4]: *** [Makefile:627: libfftw3f.la] Error 1
-make[4]: *** [Makefile:627: libfftw3.la] Error 1
-make[3]: *** [Makefile:672: all-recursive] Error 1
-make[2]: *** [Makefile:536: all] Error 2
-make[3]: *** [Makefile:672: all-recursive] Error 1
-make[1]: *** [/home/Tony/julia32/deps/fftw.mk:46: scratch/fftw-3.3.5-single/build-compiled] Error 2
-make[1]: *** Waiting for unfinished jobs....
-make[2]: *** [Makefile:536: all] Error 2
-make[1]: *** [/home/Tony/julia32/deps/fftw.mk:46: scratch/fftw-3.3.5-double/build-compiled] Error 2
-make: *** [Makefile:81: julia-deps] Error 2
-```
----
- threads/threads.c | 1 +
- 1 file changed, 1 insertion(+)
-
-diff --git a/threads/threads.c b/threads/threads.c
-index fd55ced..43fc3e1 100644
---- a/threads/threads.c
-+++ b/threads/threads.c
-@@ -163,6 +163,7 @@ static void os_static_mutex_unlock(os_static_mutex_t *s) { pthread_mutex_unlock(
- #define INT magnus_ab_INTegro_seclorum_nascitur_ordo
- #include <windows.h>
- #include <process.h>
-+#include <intrin.h>
- #undef INT
- 
- typedef HANDLE os_mutex_t;
diff --git a/deps/patches/instcombine-llvm-3.3.patch b/deps/patches/instcombine-llvm-3.3.patch
deleted file mode 100644
index d7f0edc21cab39..00000000000000
--- a/deps/patches/instcombine-llvm-3.3.patch
+++ /dev/null
@@ -1,12 +0,0 @@
-diff -u -r -N llvm-3.3.src/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp llvm-3.3/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp
---- llvm-3.3.src/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp	2013-01-02 06:36:10.000000000 -0500
-+++ llvm-3.3/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp	2014-06-18 23:11:49.000000000 -0400
-@@ -754,7 +754,7 @@
-       ComputeMaskedBits(I->getOperand(0), LHSKnownZero, LHSKnownOne, Depth+1);
-       // If it's known zero, our sign bit is also zero.
-       if (LHSKnownZero.isNegative())
--        KnownZero |= LHSKnownZero;
-+        KnownZero.setBit(KnownZero.getBitWidth() - 1);
-     }
-     break;
-   case Instruction::URem: {
diff --git a/deps/patches/int128-vector.llvm-3.3.patch b/deps/patches/int128-vector.llvm-3.3.patch
deleted file mode 100644
index e8d295d3cb64fc..00000000000000
--- a/deps/patches/int128-vector.llvm-3.3.patch
+++ /dev/null
@@ -1,86 +0,0 @@
-diff -u -r -N llvm-3.3.src/lib/CodeGen/SelectionDAG/LegalizeTypes.h llvm-3.3/lib/CodeGen/SelectionDAG/LegalizeTypes.h
---- llvm-3.3.src/lib/CodeGen/SelectionDAG/LegalizeTypes.h	2013-04-21 19:47:41.000000000 -0400
-+++ llvm-3.3/lib/CodeGen/SelectionDAG/LegalizeTypes.h	2014-08-08 01:48:48.000000000 -0400
-@@ -561,6 +561,7 @@
-   void SplitVecRes_BUILD_VECTOR(SDNode *N, SDValue &Lo, SDValue &Hi);
-   void SplitVecRes_CONCAT_VECTORS(SDNode *N, SDValue &Lo, SDValue &Hi);
-   void SplitVecRes_EXTRACT_SUBVECTOR(SDNode *N, SDValue &Lo, SDValue &Hi);
-+  void SplitVecRes_INSERT_SUBVECTOR(SDNode *N, SDValue &Lo, SDValue &Hi);
-   void SplitVecRes_FPOWI(SDNode *N, SDValue &Lo, SDValue &Hi);
-   void SplitVecRes_INSERT_VECTOR_ELT(SDNode *N, SDValue &Lo, SDValue &Hi);
-   void SplitVecRes_LOAD(LoadSDNode *N, SDValue &Lo, SDValue &Hi);
-diff -u -r -N llvm-3.3.src/lib/CodeGen/SelectionDAG/LegalizeTypes.h.rej llvm-3.3/lib/CodeGen/SelectionDAG/LegalizeTypes.h.rej
---- llvm-3.3.src/lib/CodeGen/SelectionDAG/LegalizeTypes.h.rej	1969-12-31 19:00:00.000000000 -0500
-+++ llvm-3.3/lib/CodeGen/SelectionDAG/LegalizeTypes.h.rej	2014-08-08 02:10:36.000000000 -0400
-@@ -0,0 +1,16 @@
-+***************
-+*** 561,566 ****
-+    void SplitVecRes_BUILD_VECTOR(SDNode *N, SDValue &Lo, SDValue &Hi);
-+    void SplitVecRes_CONCAT_VECTORS(SDNode *N, SDValue &Lo, SDValue &Hi);
-+    void SplitVecRes_EXTRACT_SUBVECTOR(SDNode *N, SDValue &Lo, SDValue &Hi);
-+    void SplitVecRes_FPOWI(SDNode *N, SDValue &Lo, SDValue &Hi);
-+    void SplitVecRes_INSERT_VECTOR_ELT(SDNode *N, SDValue &Lo, SDValue &Hi);
-+    void SplitVecRes_LOAD(LoadSDNode *N, SDValue &Lo, SDValue &Hi);
-+--- 561,567 ----
-+    void SplitVecRes_BUILD_VECTOR(SDNode *N, SDValue &Lo, SDValue &Hi);
-+    void SplitVecRes_CONCAT_VECTORS(SDNode *N, SDValue &Lo, SDValue &Hi);
-+    void SplitVecRes_EXTRACT_SUBVECTOR(SDNode *N, SDValue &Lo, SDValue &Hi);
-++   void SplitVecRes_INSERT_SUBVECTOR(SDNode *N, SDValue &Lo, SDValue &Hi);
-+    void SplitVecRes_FPOWI(SDNode *N, SDValue &Lo, SDValue &Hi);
-+    void SplitVecRes_INSERT_VECTOR_ELT(SDNode *N, SDValue &Lo, SDValue &Hi);
-+    void SplitVecRes_LOAD(LoadSDNode *N, SDValue &Lo, SDValue &Hi);
-diff -u -r -N llvm-3.3.src/lib/CodeGen/SelectionDAG/LegalizeVectorTypes.cpp llvm-3.3/lib/CodeGen/SelectionDAG/LegalizeVectorTypes.cpp
---- llvm-3.3.src/lib/CodeGen/SelectionDAG/LegalizeVectorTypes.cpp	2013-04-21 19:47:41.000000000 -0400
-+++ llvm-3.3/lib/CodeGen/SelectionDAG/LegalizeVectorTypes.cpp	2014-08-08 02:13:03.000000000 -0400
-@@ -501,6 +501,7 @@
-   case ISD::BUILD_VECTOR:      SplitVecRes_BUILD_VECTOR(N, Lo, Hi); break;
-   case ISD::CONCAT_VECTORS:    SplitVecRes_CONCAT_VECTORS(N, Lo, Hi); break;
-   case ISD::EXTRACT_SUBVECTOR: SplitVecRes_EXTRACT_SUBVECTOR(N, Lo, Hi); break;
-+  case ISD::INSERT_SUBVECTOR:  SplitVecRes_INSERT_SUBVECTOR(N, Lo, Hi); break;
-   case ISD::FP_ROUND_INREG:    SplitVecRes_InregOp(N, Lo, Hi); break;
-   case ISD::FPOWI:             SplitVecRes_FPOWI(N, Lo, Hi); break;
-   case ISD::INSERT_VECTOR_ELT: SplitVecRes_INSERT_VECTOR_ELT(N, Lo, Hi); break;
-@@ -714,6 +715,43 @@
-                    DAG.getIntPtrConstant(IdxVal + LoVT.getVectorNumElements()));
- }
- 
-+void DAGTypeLegalizer::SplitVecRes_INSERT_SUBVECTOR(SDNode *N, SDValue &Lo,
-+                                                    SDValue &Hi) {
-+  SDValue Vec = N->getOperand(0);
-+  SDValue SubVec = N->getOperand(1);
-+  SDValue Idx = N->getOperand(2);
-+  DebugLoc dl = N->getDebugLoc();
-+  GetSplitVector(Vec, Lo, Hi);
-+
-+  // Spill the vector to the stack.
-+  EVT VecVT = Vec.getValueType();
-+  EVT SubVecVT = VecVT.getVectorElementType();
-+  SDValue StackPtr = DAG.CreateStackTemporary(VecVT);
-+  SDValue Store = DAG.getStore(DAG.getEntryNode(), dl, Vec, StackPtr,
-+                               MachinePointerInfo(), false, false, 0);
-+
-+  // Store the new subvector into the specified index.
-+  SDValue SubVecPtr = GetVectorElementPointer(StackPtr, SubVecVT, Idx);
-+  Type *VecType = VecVT.getTypeForEVT(*DAG.getContext());
-+  unsigned Alignment = TLI.getDataLayout()->getPrefTypeAlignment(VecType);
-+  Store = DAG.getStore(Store, dl, SubVec, SubVecPtr, MachinePointerInfo(),
-+                       false, false, 0);
-+
-+  // Load the Lo part from the stack slot.
-+  Lo = DAG.getLoad(Lo.getValueType(), dl, Store, StackPtr, MachinePointerInfo(),
-+                   false, false, false, 0);
-+
-+  // Increment the pointer to the other part.
-+  unsigned IncrementSize = Lo.getValueType().getSizeInBits() / 8;
-+  StackPtr =
-+      DAG.getNode(ISD::ADD, dl, StackPtr.getValueType(), StackPtr,
-+                  DAG.getConstant(IncrementSize, StackPtr.getValueType()));
-+
-+  // Load the Hi part from the stack slot.
-+  Hi = DAG.getLoad(Hi.getValueType(), dl, Store, StackPtr, MachinePointerInfo(),
-+                   false, false, false, MinAlign(Alignment, IncrementSize));
-+}
-+
- void DAGTypeLegalizer::SplitVecRes_FPOWI(SDNode *N, SDValue &Lo,
-                                          SDValue &Hi) {
-   DebugLoc dl = N->getDebugLoc();
diff --git a/deps/patches/libgit2-mbedtls-fixup.patch b/deps/patches/libgit2-mbedtls-fixup.patch
new file mode 100644
index 00000000000000..2ec6fbd7167a0d
--- /dev/null
+++ b/deps/patches/libgit2-mbedtls-fixup.patch
@@ -0,0 +1,70 @@
+commit de8721ae70dfae529fdb50224a47eadf6d29c574
+Author: Curtis Vogt <curtis.vogt@gmail.com>
+Date:   Thu Jun 29 16:31:08 2017 -0500
+
+    Corrections to mbedtls support with LibGit2 0.26.0
+
+diff --git a/src/settings.c b/src/settings.c
+index 3a46f0d..4d976a0 100644
+--- a/src/settings.c
++++ b/src/settings.c
+@@ -179,14 +179,18 @@ int git_libgit2_opts(int key, ...)
+ 			const char *path = va_arg(ap, const char *);
+ 			error = git_openssl_set_cert_file(file, path);
+ 		}
+-#elif GIT_MBEDTLS
++#elif defined(GIT_MBEDTLS)
+ 		{
+ 			const char *file = va_arg(ap, const char *);
+ 			const char *path = va_arg(ap, const char *);
+-			if (file)
++			if (file) {
+ 				error = git_mbedtls_set_cert_file(file, 0);
+-			if (error && path)
+-				error = git_mbedtls_set_cert_file(path, 0);
++			} else if (path) {
++				error = git_mbedtls_set_cert_file(path, 1);
++			} else {
++				giterr_set(GITERR_NET, "cannot set certificate locations: no file or path given");
++				error = -1;
++			}
+ 		}
+ #else
+ 		giterr_set(GITERR_NET, "cannot set certificate locations: OpenSSL or mbedTLS is not enabled");
+diff --git a/src/streams/mbedtls.c b/src/streams/mbedtls.c
+index e456ea8..b4eb991 100644
+--- a/src/streams/mbedtls.c
++++ b/src/streams/mbedtls.c
+@@ -205,12 +205,12 @@ static int ssl_set_error(mbedtls_ssl_context *ssl, int error)
+ 		break;
+ 
+ 	case MBEDTLS_ERR_X509_CERT_VERIFY_FAILED:
+-		giterr_set(GITERR_SSL, "SSL error: %x[%x] - %s", error, ssl->session_negotiate->verify_result, errbuf);
++		giterr_set(GITERR_SSL, "SSL error: 0x%04x [%x] - %s", error, ssl->session_negotiate->verify_result, errbuf);
+ 		ret = GIT_ECERTIFICATE;
+ 		break;
+ 
+ 	default:
+-		giterr_set(GITERR_SSL, "SSL error: %x - %s", error, errbuf);
++		giterr_set(GITERR_SSL, "SSL error: 0x%04x - %s", error, errbuf);
+ 	}
+ 
+ 	return ret;
+@@ -236,7 +236,7 @@ static int verify_server_cert(mbedtls_ssl_context *ssl, const char *host)
+ 	if ((ret = mbedtls_ssl_get_verify_result(ssl)) != 0) {
+ 		char vrfy_buf[512];
+ 		mbedtls_x509_crt_verify_info(vrfy_buf, sizeof(vrfy_buf), "", ret);
+-		giterr_set(GITERR_SSL, "The SSL certificate is invalid: %x - %s", ret, vrfy_buf);
++		giterr_set(GITERR_SSL, "The SSL certificate is invalid: 0x%04x - %s", ret, vrfy_buf);
+ 		return GIT_ECERTIFICATE;
+ 	}
+ 
+@@ -430,7 +430,7 @@ int git_mbedtls_set_cert_file(const char *path, int is_dir)
+ 		ret = mbedtls_x509_crt_parse_file(cacert, path);
+ 	}
+ 	// mbedtls_x509_crt_parse_path returns the number of invalid certs on success
+-	if (ret <= 0) {
++	if (ret < 0) {
+ 		mbedtls_x509_crt_free(cacert);
+ 		git__free(cacert);
+ 		mbedtls_strerror( ret, errbuf, 512 );
diff --git a/deps/patches/libgit2-mbedtls-verify.patch b/deps/patches/libgit2-mbedtls-verify.patch
index 4c454c3adc4ba8..eb0b3854cbb05f 100644
--- a/deps/patches/libgit2-mbedtls-verify.patch
+++ b/deps/patches/libgit2-mbedtls-verify.patch
@@ -1,99 +1,100 @@
-diff --git a/src/mbedtls_stream.c b/src/mbedtls_stream.c
-index bcc2e8b..4706102 100644
---- a/src/mbedtls_stream.c
-+++ b/src/mbedtls_stream.c
-@@ -221,82 +221,34 @@ static int ssl_teardown(mbedtls_ssl_context *ssl)
-     return ret;
+commit eefe88eaf8c5c5b7c9a596da79e68dca3a3234d4
+Author: Curtis Vogt <curtis.vogt@gmail.com>
+Date:   Thu Jun 29 16:30:53 2017 -0500
+
+    Use mbedtls certificate verification
+    
+    Letting mbedtls handle all certficate verification and removed the
+    custom alternative names and common name checking.
+
+diff --git a/src/streams/mbedtls.c b/src/streams/mbedtls.c
+index 0376ee4..e456ea8 100644
+--- a/src/streams/mbedtls.c
++++ b/src/streams/mbedtls.c
+@@ -228,82 +228,19 @@ static int ssl_teardown(mbedtls_ssl_context *ssl)
+ 	return ret;
  }
  
 -static int check_host_name(const char *name, const char *host)
 -{
--    if (!strcasecmp(name, host))
--        return 0;
+-	if (!strcasecmp(name, host))
+-		return 0;
 -
--    if (gitno__match_host(name, host) < 0)
--        return -1;
+-	if (gitno__match_host(name, host) < 0)
+-		return -1;
 -
--    return 0;
+-	return 0;
 -}
 -
  static int verify_server_cert(mbedtls_ssl_context *ssl, const char *host)
  {
--    const mbedtls_x509_crt *cert;
--    const mbedtls_x509_sequence *alts;
--    int ret, matched = -1;
-+    mbedtls_x509_crt *cert;
-+    uint32_t flags;
-+    int ret = -1;
-     size_t sn_size = 512;
--    char subject_name[sn_size], alt_name[sn_size];
+-	const mbedtls_x509_crt *cert;
+-	const mbedtls_x509_sequence *alts;
+-	int ret, matched = -1;
+-	size_t sn_size = 512;
+-	char subject_name[sn_size], alt_name[sn_size];
 -
-+    char buf[sn_size];
++	int ret = -1;
++	(void)(host);  // Suppress unused parameter warning
  
-     if (( ret = mbedtls_ssl_get_verify_result(ssl) ) != 0) {
--        char vrfy_buf[512];
--        mbedtls_x509_crt_verify_info( vrfy_buf, sizeof( vrfy_buf ), "  ! ", ret );
--        giterr_set(GITERR_SSL, "The SSL certificate is invalid: %s", vrfy_buf);
-+        mbedtls_x509_crt_verify_info(buf, sn_size, "  ! ", ret);
-+        giterr_set(GITERR_SSL, "The SSL certificate is invalid: %s", buf);
-         return GIT_ECERTIFICATE;
-     }
+ 	if ((ret = mbedtls_ssl_get_verify_result(ssl)) != 0) {
+ 		char vrfy_buf[512];
+-		mbedtls_x509_crt_verify_info( vrfy_buf, sizeof( vrfy_buf ), "  ! ", ret );
+-		giterr_set(GITERR_SSL, "The SSL certificate is invalid: %s", vrfy_buf);
++		mbedtls_x509_crt_verify_info(vrfy_buf, sizeof(vrfy_buf), "", ret);
++		giterr_set(GITERR_SSL, "The SSL certificate is invalid: %x - %s", ret, vrfy_buf);
+ 		return GIT_ECERTIFICATE;
+ 	}
  
--    cert = mbedtls_ssl_get_peer_cert(ssl);
-+    cert = (mbedtls_x509_crt*) mbedtls_ssl_get_peer_cert(ssl);
-     if (!cert) {
-         giterr_set(GITERR_SSL, "the server did not provide a certificate");
-         return -1;
-     }
- 
--    /* Check the alternative names */
--    alts = &cert->subject_alt_names;
--    while (alts != NULL && matched != 1) {
--        // Buffer is too small
--        if( alts->buf.len >= sn_size )
--            goto on_error;
+-	cert = mbedtls_ssl_get_peer_cert(ssl);
+-	if (!cert) {
+-		giterr_set(GITERR_SSL, "the server did not provide a certificate");
+-		return -1;
+-	}
 -
--        memcpy(alt_name, alts->buf.p, alts->buf.len);
--        alt_name[alts->buf.len] = '\0';
+-	/* Check the alternative names */
+-	alts = &cert->subject_alt_names;
+-	while (alts != NULL && matched != 1) {
+-		// Buffer is too small
+-		if( alts->buf.len >= sn_size )
+-			goto on_error;
 -
--        if (!memchr(alt_name, '\0', alts->buf.len)) {
--            if (check_host_name(alt_name, host) < 0)
--                matched = 0;
--            else
--                matched = 1;
--        }
+-		memcpy(alt_name, alts->buf.p, alts->buf.len);
+-		alt_name[alts->buf.len] = '\0';
 -
--        alts = alts->next;
-+    if (mbedtls_x509_crt_verify(cert, git__ssl_conf->ca_chain, NULL, host, &flags, NULL, NULL) != 0) {
-+        mbedtls_x509_crt_verify_info(buf, sn_size, "", flags);
-+        buf[strlen(buf) - 1] = '\0';  // Remove trailing newline
-+        giterr_set(GITERR_SSL, buf);
-+        return GIT_ECERTIFICATE;
-     }
--    if (matched == 0)
--        goto cert_fail_name;
+-		if (!memchr(alt_name, '\0', alts->buf.len)) {
+-			if (check_host_name(alt_name, host) < 0)
+-				matched = 0;
+-			else
+-				matched = 1;
+-		}
 -
--    if (matched == 1)
--        return 0;
+-		alts = alts->next;
+-	}
+-	if (matched == 0)
+-		goto cert_fail_name;
 -
--    /* If no alternative names are available, check the common name */
--    ret = mbedtls_x509_dn_gets(subject_name, sn_size, &cert->subject);
--    if (ret == 0)
--        goto on_error;
--    if (memchr(subject_name, '\0', ret))
--        goto cert_fail_name;
+-	if (matched == 1)
+-		return 0;
 -
--    if (check_host_name(subject_name, host) < 0)
--        goto cert_fail_name;
- 
-     return 0;
+-	/* If no alternative names are available, check the common name */
+-	ret = mbedtls_x509_dn_gets(subject_name, sn_size, &cert->subject);
+-	if (ret == 0)
+-		goto on_error;
+-	if (memchr(subject_name, '\0', ret))
+-		goto cert_fail_name;
+-
+-	if (check_host_name(subject_name, host) < 0)
+-		goto cert_fail_name;
+-
+ 	return 0;
 -
 -on_error:
--    return ssl_set_error(ssl, 0);
+-	return ssl_set_error(ssl, 0);
 -
 -cert_fail_name:
--    giterr_set(GITERR_SSL, "hostname does not match certificate");
--    return GIT_ECERTIFICATE;
+-	giterr_set(GITERR_SSL, "hostname does not match certificate");
+-	return GIT_ECERTIFICATE;
  }
  
  typedef struct {
diff --git a/deps/patches/libgit2-mbedtls-writer-fix.patch b/deps/patches/libgit2-mbedtls-writer-fix.patch
deleted file mode 100644
index d80a637a3996fd..00000000000000
--- a/deps/patches/libgit2-mbedtls-writer-fix.patch
+++ /dev/null
@@ -1,30 +0,0 @@
-diff -rup libgit2-211e117a0590583a720c53172406f34186c543bd/src/mbedtls_stream.c libgit2-211e117a0590583a720c53172406f34186c543bd-fix-write/src/mbedtls_stream.c
---- libgit2-211e117a0590583a720c53172406f34186c543bd/src/mbedtls_stream.c   2016-10-24 17:10:21.000000000 -0400
-+++ libgit2-211e117a0590583a720c53172406f34186c543bd-fix-write/src/mbedtls_stream.c 2016-10-24 17:04:26.000000000 -0400
-@@ -368,16 +368,20 @@ static int mbedtls_set_proxy(git_stream 
- 
- ssize_t mbedtls_stream_write(git_stream *stream, const char *data, size_t len, int flags)
- {
-+    size_t read = 0;
-     mbedtls_stream *st = (mbedtls_stream *) stream;
--    int ret;
- 
-     GIT_UNUSED(flags);
- 
--    if ((ret = mbedtls_ssl_write(st->ssl, (const unsigned char *)data, len)) <= 0) {
--        return ssl_set_error(st->ssl, ret);
--    }
-+   do {
-+       int error = mbedtls_ssl_write(st->ssl, (const unsigned char *)data + read, len - read);
-+       if (error <= 0) {
-+           return ssl_set_error(st->ssl, error);
-+       }
-+       read += error;
-+   } while (read < len);
- 
--    return ret;
-+    return read;
- }
- 
- ssize_t mbedtls_stream_read(git_stream *stream, void *data, size_t len)
-
diff --git a/deps/patches/libgit2-mbedtls.patch b/deps/patches/libgit2-mbedtls.patch
index 955f165eab754e..af12728cf85553 100644
--- a/deps/patches/libgit2-mbedtls.patch
+++ b/deps/patches/libgit2-mbedtls.patch
@@ -1,66 +1,282 @@
+commit 4d69ea1172fec234e0f3c8cee8574e9e13bf825e
+Author: Etienne Samson <samson.etienne@gmail.com>
+Date:   Fri Jun 23 22:40:56 2017 +0000
+
+    mbedtls support for libgit2 v0.26.0
+    
+    See https://github.com/libgit2/libgit2/pull/4173
+    
+    cmake: simplify https support selection & tests
+    
+    Gather streams to src/streams
+    
+    Don't include OpenSSL from global.h so it doesn't namespace-leak
+    
+    Have clar exit immediately on initialization failure
+    
+    Generalize Travis' dependency installation
+    
+    Add USE_HTTPS as a CMake option
+    
+    It defaults to ON, e.g. "pick whatever default is appropriate for the platform".
+    It accepts one of SecureTransport, OpenSSL, WinHTTP, or OFF.
+    It errors if the backend library couldn't be found.
+    
+    mbedtls: initial support
+    
+    mbedtls: proper certificate verification
+    
+    mbedtls: use libmbedcrypto for hashing
+    
+    mbedtls: add global initialization
+    
+    mbedtls: default cipher list support
+    
+    mbedtls: load default CA certificates
+    
+    mbedtls: fix libgit2 hanging due to incomplete writes
+    
+    mbedtls: enable Travis CI tests
+    
+    mbedtls: use our own certificate validation
+    
+    Otherwise REQUIRED means that `git_stream_certificate` will always error.
+    We're doing the mbedtls check in verify_server_cert though.
+    
+    mbedtls: try all CA locations, stopping after any loaded
+    
+    WIP: distribution paths
+
+diff --git a/.travis.yml b/.travis.yml
+index af38252..e1be760 100644
+--- a/.travis.yml
++++ b/.travis.yml
+@@ -45,11 +45,21 @@ matrix:
+        - VALGRIND=1
+          OPTIONS="-DBUILD_CLAR=ON -DBUILD_EXAMPLES=OFF -DDEBUG_POOL=ON -DCMAKE_BUILD_TYPE=Debug"
+      os: linux
++   - compiler: gcc
++     env:
++         MBEDTLS=1
++         OPTIONS="-DTHREADSAFE=ON -DCMAKE_BUILD_TYPE=Release -DUSE_TLS=mbedTLS -DMBEDTLS_ROOT_DIR=../mbedtls"
++     os: linux
++   - compiler: gcc
++     env:
++         MBEDTLS=1
++         OPTIONS="-DTHREADSAFE=OFF -DBUILD_EXAMPLES=ON -DUSE_TLS=mbedTLS -DMBEDTLS_ROOT_DIR=../mbedtls"
++     os: linux
+  allow_failures:
+    - env: COVERITY=1
+ 
+ install:
+-  - if [ "$TRAVIS_OS_NAME" = "osx" ]; then ./script/install-deps-${TRAVIS_OS_NAME}.sh; fi
++  - if [ -x "./script/install-deps-${TRAVIS_OS_NAME}.sh" ]; then ./script/install-deps-${TRAVIS_OS_NAME}.sh; fi
+ 
+ # Run the Build script and tests
+ script:
 diff --git a/CMakeLists.txt b/CMakeLists.txt
-index 4e1104f..8110489 100644
+index 4783e3e..5d7dbe3 100644
 --- a/CMakeLists.txt
 +++ b/CMakeLists.txt
-@@ -113,6 +113,10 @@ IF (HAVE_STRUCT_STAT_NSEC OR WIN32)
- 	OPTION( USE_NSEC		"Care about sub-second file mtimes and ctimes"	ON  )
+@@ -40,6 +40,7 @@ OPTION( LIBGIT2_FILENAME	"Name of the produced binary"			OFF )
+ OPTION( USE_SHA1DC			"Use SHA-1 with collision detection"	OFF )
+ OPTION( USE_ICONV			"Link with and use iconv library" 		OFF )
+ OPTION( USE_SSH				"Link with libssh to enable SSH support" ON )
++OPTION( USE_HTTPS			"Enable HTTPS support"					ON )
+ OPTION( USE_GSSAPI			"Link with libgssapi for SPNEGO auth"   OFF )
+ OPTION( VALGRIND			"Configure build for valgrind"			OFF )
+ OPTION( CURL			"Use curl for HTTP if available" ON)
+@@ -89,10 +90,6 @@ IF(MSVC)
+ 	OPTION(MSVC_CRTDBG "Enable CRTDBG memory leak reporting" OFF)
  ENDIF()
  
-+IF (NOT USE_OPENSSL)
-+	OPTION( USE_MBEDTLS		"Link with and use mbedtls library"             OFF )
-+ENDIF()
-+
- # This variable will contain the libraries we need to put into
- # libgit2.pc's Requires.private. That is, what we're linking to or
- # what someone who's statically linking us needs to link to.
-@@ -283,6 +287,10 @@ ELSE ()
+-IF (NOT ${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+-	OPTION( USE_OPENSSL                     "Link with and use openssl library"             ON )
+-ENDIF()
+-
+ CHECK_STRUCT_HAS_MEMBER ("struct stat" st_mtim "sys/types.h;sys/stat.h"
+ 	HAVE_STRUCT_STAT_ST_MTIM LANGUAGE C)
+ CHECK_STRUCT_HAS_MEMBER ("struct stat" st_mtimespec "sys/types.h;sys/stat.h"
+@@ -208,21 +205,6 @@ STRING(REGEX REPLACE "^.*LIBGIT2_SOVERSION ([0-9]+)$" "\\1" LIBGIT2_SOVERSION "$
+ # Find required dependencies
+ INCLUDE_DIRECTORIES(src include)
+ 
+-IF (SECURITY_FOUND)
+-  # OS X 10.7 and older do not have some functions we use, fall back to OpenSSL there
+-  CHECK_LIBRARY_EXISTS("${SECURITY_DIRS}" SSLCreateContext "Security/SecureTransport.h" HAVE_NEWER_SECURITY)
+-  IF (HAVE_NEWER_SECURITY)
+-    MESSAGE("-- Found Security ${SECURITY_DIRS}")
+-    LIST(APPEND LIBGIT2_PC_LIBS "-framework Security")
+-  ELSE()
+-    MESSAGE("-- Security framework is too old, falling back to OpenSSL")
+-    SET(SECURITY_FOUND "NO")
+-    SET(SECURITY_DIRS "")
+-    SET(SECURITY_DIR "")
+-    SET(USE_OPENSSL "ON")
+-  ENDIF()
+-ENDIF()
+-
+ IF (COREFOUNDATION_FOUND)
+   MESSAGE("-- Found CoreFoundation ${COREFOUNDATION_DIRS}")
+   LIST(APPEND LIBGIT2_PC_LIBS "-framework CoreFoundation")
+@@ -280,10 +262,14 @@ ELSE ()
+ 		PKG_CHECK_MODULES(CURL libcurl)
+ 	ENDIF ()
+ 
+-	IF (NOT AMIGA AND USE_OPENSSL)
++	IF (NOT AMIGA AND (USE_HTTPS STREQUAL "OpenSSL" OR USE_HTTPS STREQUAL "ON"))
  		FIND_PACKAGE(OpenSSL)
  	ENDIF ()
  
-+	IF (NOT AMIGA AND USE_MBEDTLS)
++	IF (NOT AMIGA AND (USE_HTTPS STREQUAL "mbedTLS" OR USE_HTTPS STREQUAL "ON"))
 +		FIND_PACKAGE(mbedTLS)
 +	ENDIF ()
 +
  	IF (CURL_FOUND)
  		ADD_DEFINITIONS(-DGIT_CURL)
  		INCLUDE_DIRECTORIES(${CURL_INCLUDE_DIRS})
-@@ -316,6 +324,9 @@ ELSEIF (OPENSSL_FOUND AND NOT SHA1_TYPE STREQUAL "builtin")
+@@ -293,6 +279,69 @@ ELSE ()
+ 	ENDIF()
+ ENDIF()
+ 
++IF (USE_HTTPS STREQUAL "ON")
++	IF (SECURITY_FOUND)
++		# OS X 10.7 and older do not have some functions we use, fall back to OpenSSL there
++		CHECK_LIBRARY_EXISTS("${SECURITY_DIRS}" SSLCreateContext "Security/SecureTransport.h" HAVE_NEWER_SECURITY)
++		IF (HAVE_NEWER_SECURITY)
++			MESSAGE("-- Found Security ${SECURITY_DIRS}")
++			LIST(APPEND LIBGIT2_PC_LIBS "-framework Security")
++			SET(HTTPS_BACKEND "SecureTransport")
++		ELSE()
++			MESSAGE("-- Security framework is too old, falling back to OpenSSL")
++			SET(SECURITY_FOUND "NO")
++			SET(SECURITY_DIRS "")
++			SET(SECURITY_DIR "")
++			SET(HTTPS_BACKEND "OpenSSL")
++		ENDIF()
++	ELSEIF(WINHTTP)
++		SET(HTTPS_BACKEND "WinHTTP")
++	ELSEIF(MBEDTLS_FOUND)
++		SET(HTTPS_BACKEND "mbedTLS")
++	ELSE()
++		SET(HTTPS_BACKEND "OpenSSL")
++	ENDIF()
++ELSE()
++	SET(HTTPS_BACKEND ${USE_HTTPS})
++ENDIF()
++
++MESSAGE(STATUS "Using HTTPS backend ${HTTPS_BACKEND}")
++
++IF (HTTPS_BACKEND STREQUAL "SecureTransport")
++	IF (NOT SECURITY_FOUND)
++		MESSAGE(FATAL_ERROR "Asked for SecureTransport HTTPS backend, but it wasn't found")
++	ENDIF()
++
++	ADD_DEFINITIONS(-DGIT_SECURE_TRANSPORT)
++	INCLUDE_DIRECTORIES(${SECURITY_INCLUDE_DIR})
++ELSEIF (HTTPS_BACKEND STREQUAL "OpenSSL")
++	IF (NOT OPENSSL_FOUND)
++		MESSAGE(FATAL_ERROR "Asked for OpenSSL HTTPS backend, but it wasn't found")
++	ENDIF()
++
++	ADD_DEFINITIONS(-DGIT_OPENSSL)
++	INCLUDE_DIRECTORIES(${OPENSSL_INCLUDE_DIR})
++	SET(SSL_LIBRARIES ${OPENSSL_LIBRARIES})
++ELSEIF (TLS_BACKEND STREQUAL "mbedTLS")
++	IF (NOT MBEDTLS_FOUND)
++		MESSAGE(FATAL_ERROR "Asked for mbedTLS backend, but it wasn't found")
++	ENDIF()
++
++	ADD_DEFINITIONS(-DGIT_MBEDTLS)
++	INCLUDE_DIRECTORIES(${MBEDTLS_INCLUDE_DIR})
++	LINK_DIRECTORIES(${MBEDTLS_LIBRARY_DIR})
++	SET(SSL_LIBRARIES ${MBEDTLS_LIBRARIES})
++ELSEIF(HTTPS_BACKEND STREQUAL "WinHTTP")
++ENDIF()
++
++IF (USE_HTTPS AND NOT HTTPS_BACKEND)
++	MESSAGE(FATAL_ERROR "Asked for backend " ${HTTPS_BACKEND} " but it wasn't found")
++ENDIF()
++
++IF (HTTPS_BACKEND)
++	ADD_DEFINITIONS(-DGIT_HTTPS)
++ENDIF()
++
+ # Specify sha1 implementation
+ IF (USE_SHA1DC)
+ 	ADD_DEFINITIONS(-DGIT_SHA1_COLLISIONDETECT)
+@@ -303,15 +352,18 @@ IF (USE_SHA1DC)
+ ELSEIF (WIN32 AND NOT MINGW)
+ 	ADD_DEFINITIONS(-DGIT_SHA1_WIN32)
+ 	FILE(GLOB SRC_SHA1 src/hash/hash_win32.c)
+-ELSEIF (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
++ELSEIF (TLS_BACKEND MATCHES "SecureTransport")
+ 	ADD_DEFINITIONS(-DGIT_SHA1_COMMON_CRYPTO)
+-ELSEIF (OPENSSL_FOUND)
++ELSEIF (TLS_BACKEND MATCHES "OpenSSL")
+ 	ADD_DEFINITIONS(-DGIT_SHA1_OPENSSL)
+ 	IF (CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
+ 		LIST(APPEND LIBGIT2_PC_LIBS "-lssl")
  	ELSE()
  		SET(LIBGIT2_PC_REQUIRES "${LIBGIT2_PC_REQUIRES} openssl")
  	ENDIF ()
-+ELSEIF (MBEDTLS_FOUND AND NOT SHA1_TYPE STREQUAL "builtin")
++ELSEIF (TLS_BACKEND STREQUAL "mbedTLS")
 +	ADD_DEFINITIONS(-DMBEDTLS_SHA1)
 +	FILE(GLOB SRC_SHA1 src/hash/hash_mbedtls.c)
  ELSE()
  	FILE(GLOB SRC_SHA1 src/hash/hash_generic.c)
  ENDIF()
-@@ -543,6 +554,11 @@ IF (OPENSSL_FOUND)
-   SET(SSL_LIBRARIES ${OPENSSL_LIBRARIES})
+@@ -543,21 +595,6 @@ ELSE()
+ 	# that uses CMAKE_CONFIGURATION_TYPES and not CMAKE_BUILD_TYPE
  ENDIF()
  
-+IF (MBEDTLS_FOUND)
-+  ADD_DEFINITIONS(-DGIT_MBEDTLS)
-+  INCLUDE_DIRECTORIES(${MBEDTLS_INCLUDE_DIR})
-+  SET(SSL_LIBRARIES ${MBEDTLS_LIBRARIES})
-+ENDIF()
- 
- 
+-IF (SECURITY_FOUND)
+-  ADD_DEFINITIONS(-DGIT_SECURE_TRANSPORT)
+-  ADD_DEFINITIONS(-DGIT_HTTPS)
+-  INCLUDE_DIRECTORIES(${SECURITY_INCLUDE_DIR})
+-ENDIF ()
+-
+-IF (OPENSSL_FOUND)
+-  ADD_DEFINITIONS(-DGIT_OPENSSL)
+-  ADD_DEFINITIONS(-DGIT_HTTPS)
+-  INCLUDE_DIRECTORIES(${OPENSSL_INCLUDE_DIR})
+-  SET(SSL_LIBRARIES ${OPENSSL_LIBRARIES})
+-ENDIF()
+-
+-
+-
  IF (THREADSAFE)
-@@ -688,7 +704,7 @@ IF (BUILD_CLAR)
+ 	IF (NOT WIN32)
+ 		FIND_PACKAGE(Threads REQUIRED)
+@@ -595,7 +632,12 @@ ELSE()
+ 	ENDIF()
+ 	FILE(GLOB SRC_OS src/unix/*.c src/unix/*.h)
+ ENDIF()
+-FILE(GLOB SRC_GIT2 src/*.c src/*.h src/transports/*.c src/transports/*.h src/xdiff/*.c src/xdiff/*.h)
++FILE(GLOB SRC_GIT2
++	src/*.c src/*.h
++	src/streams/*.c src/streams/*.h
++	src/transports/*.c src/transports/*.h
++	src/xdiff/*.c src/xdiff/*.h
++)
+ 
+ # Determine architecture of the machine
+ IF (CMAKE_SIZEOF_VOID_P EQUAL 8)
+@@ -703,7 +745,7 @@ IF (BUILD_CLAR)
  	ENDIF ()
  
  	ENABLE_TESTING()
 -	IF (WINHTTP OR OPENSSL_FOUND OR SECURITY_FOUND)
-+	IF (WINHTTP OR OPENSSL_FOUND OR SECURITY_FOUND OR MBEDTLS_FOUND)
- 		ADD_TEST(libgit2_clar libgit2_clar -ionline)
++	IF (HAS_HTTPS_SUPPORT)
+ 		ADD_TEST(libgit2_clar libgit2_clar -ionline -xclone::local::git_style_unc_paths -xclone::local::standard_unc_paths_are_written_git_style)
  	ELSE ()
- 		ADD_TEST(libgit2_clar libgit2_clar -v)
+ 		ADD_TEST(libgit2_clar libgit2_clar -v -xclone::local::git_style_unc_paths -xclone::local::standard_unc_paths_are_written_git_style)
 diff --git a/cmake/Modules/FindmbedTLS.cmake b/cmake/Modules/FindmbedTLS.cmake
 new file mode 100644
-index 0000000..2f4adbc
+index 0000000..9329755
 --- /dev/null
 +++ b/cmake/Modules/FindmbedTLS.cmake
-@@ -0,0 +1,64 @@
+@@ -0,0 +1,93 @@
 +# - Try to find mbedTLS
 +# Once done this will define
 +#
@@ -72,17 +288,46 @@ index 0000000..2f4adbc
 +#  MBEDTLS_LIBRARY - path to mbedTLS library
 +#  MBEDX509_LIBRARY - path to mbedTLS X.509 library
 +#  MBEDCRYPTO_LIBRARY - path to mbedTLS Crypto library
++#
++# Hint
++#  MBEDTLS_ROOT_DIR can be pointed to a local mbedTLS installation.
++
++SET(_MBEDTLS_ROOT_HINTS
++    ${MBEDTLS_ROOT_DIR}
++    ENV MBEDTLS_ROOT_DIR
++)
++
++SET(_MBEDTLS_ROOT_HINTS_AND_PATHS
++    HINTS ${_MBEDTLS_ROOT_HINTS}
++    PATHS ${_MBEDTLS_ROOT_PATHS}
++)
 +
-+FIND_PATH(MBEDTLS_INCLUDE_DIR mbedtls/version.h)
++FIND_PATH(MBEDTLS_INCLUDE_DIR
++    NAMES mbedtls/version.h
++    ${_MBEDTLS_ROOT_HINTS_AND_PATHS}
++    PATH_SUFFIXES include
++)
 +
 +IF(MBEDTLS_INCLUDE_DIR AND MBEDTLS_LIBRARIES)
 +    # Already in cache, be silent
 +    SET(MBEDTLS_FIND_QUIETLY TRUE)
 +ENDIF()
 +
-+FIND_LIBRARY(MBEDTLS_LIBRARY NAMES mbedtls libmbedtls libmbedx509)
-+FIND_LIBRARY(MBEDX509_LIBRARY NAMES mbedx509 libmbedx509)
-+FIND_LIBRARY(MBEDCRYPTO_LIBRARY NAMES mbedcrypto libmbedcrypto)
++FIND_LIBRARY(MBEDTLS_LIBRARY
++    NAMES mbedtls libmbedtls
++    ${_MBEDTLS_ROOT_HINTS_AND_PATHS}
++    PATH_SUFFIXES library
++)
++FIND_LIBRARY(MBEDX509_LIBRARY
++    NAMES mbedx509 libmbedx509
++    ${_MBEDTLS_ROOT_HINTS_AND_PATHS}
++    PATH_SUFFIXES library
++)
++FIND_LIBRARY(MBEDCRYPTO_LIBRARY
++    NAMES mbedcrypto libmbedcrypto
++    ${_MBEDTLS_ROOT_HINTS_AND_PATHS}
++    PATH_SUFFIXES library
++)
 +
 +IF(MBEDTLS_INCLUDE_DIR AND MBEDTLS_LIBRARY AND MBEDX509_LIBRARY AND MBEDCRYPTO_LIBRARY)
 +     SET(MBEDTLS_FOUND TRUE)
@@ -125,68 +370,465 @@ index 0000000..2f4adbc
 +    MBEDX509_LIBRARY
 +    MBEDCRYPTO_LIBRARY
 +)
+diff --git a/script/install-deps-linux.sh b/script/install-deps-linux.sh
+new file mode 100755
+index 0000000..94309b0
+--- /dev/null
++++ b/script/install-deps-linux.sh
+@@ -0,0 +1,12 @@
++#!/bin/sh
++
++echo "Installing dependencies"
++if [ "$MBEDTLS" ]; then
++  git clone https://github.com/ARMmbed/mbedtls.git ../mbedtls
++  cd ../mbedtls
++  git checkout mbedtls-2.4.2
++  cmake -DENABLE_PROGRAMS=OFF -DENABLE_TESTING=OFF -DUSE_SHARED_MBEDTLS_LIBRARY=ON -DUSE_STATIC_MBEDTLS_LIBRARY=OFF .
++  cmake --build .
++
++  echo "mbedTLS built in `pwd`"
++fi
+diff --git a/src/curl_stream.c b/src/curl_stream.c
+deleted file mode 100644
+index 4e0455c..0000000
+--- a/src/curl_stream.c
++++ /dev/null
+@@ -1,362 +0,0 @@
+-/*
+- * Copyright (C) the libgit2 contributors. All rights reserved.
+- *
+- * This file is part of libgit2, distributed under the GNU GPL v2 with
+- * a Linking Exception. For full terms see the included COPYING file.
+- */
+-
+-#ifdef GIT_CURL
+-
+-#include <curl/curl.h>
+-
+-#include "stream.h"
+-#include "git2/transport.h"
+-#include "buffer.h"
+-#include "vector.h"
+-#include "proxy.h"
+-
+-/* This is for backwards compatibility with curl<7.45.0. */
+-#ifndef CURLINFO_ACTIVESOCKET
+-# define CURLINFO_ACTIVESOCKET CURLINFO_LASTSOCKET
+-# define GIT_CURL_BADSOCKET -1
+-# define git_activesocket_t long
+-#else
+-# define GIT_CURL_BADSOCKET CURL_SOCKET_BAD
+-# define git_activesocket_t curl_socket_t
+-#endif
+-
+-typedef struct {
+-	git_stream parent;
+-	CURL *handle;
+-	curl_socket_t socket;
+-	char curl_error[CURL_ERROR_SIZE + 1];
+-	git_cert_x509 cert_info;
+-	git_strarray cert_info_strings;
+-	git_proxy_options proxy;
+-	git_cred *proxy_cred;
+-} curl_stream;
+-
+-static int seterr_curl(curl_stream *s)
+-{
+-	giterr_set(GITERR_NET, "curl error: %s\n", s->curl_error);
+-	return -1;
+-}
+-
+-GIT_INLINE(int) error_no_credentials(void)
+-{
+-	giterr_set(GITERR_NET, "proxy authentication required, but no callback provided");
+-	return GIT_EAUTH;
+-}
+-
+-static int apply_proxy_creds(curl_stream *s)
+-{
+-	CURLcode res;
+-	git_cred_userpass_plaintext *userpass;
+-
+-	if (!s->proxy_cred)
+-		return GIT_ENOTFOUND;
+-
+-	userpass = (git_cred_userpass_plaintext *) s->proxy_cred;
+-	if ((res = curl_easy_setopt(s->handle, CURLOPT_PROXYUSERNAME, userpass->username)) != CURLE_OK)
+-		return seterr_curl(s);
+-	if ((res = curl_easy_setopt(s->handle, CURLOPT_PROXYPASSWORD, userpass->password)) != CURLE_OK)
+-		return seterr_curl(s);
+-
+-	return 0;
+-}
+-
+-static int ask_and_apply_proxy_creds(curl_stream *s)
+-{
+-	int error;
+-	git_proxy_options *opts = &s->proxy;
+-
+-	if (!opts->credentials)
+-		return error_no_credentials();
+-
+-	/* TODO: see if PROXYAUTH_AVAIL helps us here */
+-	git_cred_free(s->proxy_cred);
+-	s->proxy_cred = NULL;
+-	giterr_clear();
+-	error = opts->credentials(&s->proxy_cred, opts->url, NULL, GIT_CREDTYPE_USERPASS_PLAINTEXT, opts->payload);
+-	if (error == GIT_PASSTHROUGH)
+-		return error_no_credentials();
+-	if (error < 0) {
+-		if (!giterr_last())
+-			giterr_set(GITERR_NET, "proxy authentication was aborted by the user");
+-		return error;
+-	}
+-
+-	if (s->proxy_cred->credtype != GIT_CREDTYPE_USERPASS_PLAINTEXT) {
+-		giterr_set(GITERR_NET, "credentials callback returned invalid credential type");
+-		return -1;
+-	}
+-
+-	return apply_proxy_creds(s);
+-}
+-
+-static int curls_connect(git_stream *stream)
+-{
+-	curl_stream *s = (curl_stream *) stream;
+-	git_activesocket_t sockextr;
+-	long connect_last = 0;
+-	int failed_cert = 0, error;
+-	bool retry_connect;
+-	CURLcode res;
+-
+-	/* Apply any credentials we've already established */
+-	error = apply_proxy_creds(s);
+-	if (error < 0 && error != GIT_ENOTFOUND)
+-		return seterr_curl(s);
+-
+-	do {
+-		retry_connect = 0;
+-		res = curl_easy_perform(s->handle);
+-
+-		curl_easy_getinfo(s->handle, CURLINFO_HTTP_CONNECTCODE, &connect_last);
+-
+-		/* HTTP 407 Proxy Authentication Required */
+-		if (connect_last == 407) {
+-			if ((error = ask_and_apply_proxy_creds(s)) < 0)
+-				return error;
+-
+-			retry_connect = true;
+-		}
+-	} while (retry_connect);
+-
+-	if (res != CURLE_OK && res != CURLE_PEER_FAILED_VERIFICATION)
+-		return seterr_curl(s);
+-	if (res == CURLE_PEER_FAILED_VERIFICATION)
+-		failed_cert = 1;
+-
+-	if ((res = curl_easy_getinfo(s->handle, CURLINFO_ACTIVESOCKET, &sockextr)) != CURLE_OK) {
+-		return seterr_curl(s);
+-	}
+-
+-	if (sockextr == GIT_CURL_BADSOCKET) {
+-		giterr_set(GITERR_NET, "curl socket is no longer valid");
+-		return -1;
+-	}
+-
+-	s->socket = sockextr;
+-
+-	if (s->parent.encrypted && failed_cert)
+-		return GIT_ECERTIFICATE;
+-
+-	return 0;
+-}
+-
+-static int curls_certificate(git_cert **out, git_stream *stream)
+-{
+-	int error;
+-	CURLcode res;
+-	struct curl_slist *slist;
+-	struct curl_certinfo *certinfo;
+-	git_vector strings = GIT_VECTOR_INIT;
+-	curl_stream *s = (curl_stream *) stream;
+-
+-	if ((res = curl_easy_getinfo(s->handle, CURLINFO_CERTINFO, &certinfo)) != CURLE_OK)
+-		return seterr_curl(s);
+-
+-	/* No information is available, can happen with SecureTransport */
+-	if (certinfo->num_of_certs == 0) {
+-		s->cert_info.parent.cert_type = GIT_CERT_NONE;
+-		s->cert_info.data             = NULL;
+-		s->cert_info.len              = 0;
+-		return 0;
+-	}
+-
+-	if ((error = git_vector_init(&strings, 8, NULL)) < 0)
+-		return error;
+-
+-	for (slist = certinfo->certinfo[0]; slist; slist = slist->next) {
+-		char *str = git__strdup(slist->data);
+-		GITERR_CHECK_ALLOC(str);
+-		git_vector_insert(&strings, str);
+-	}
+-
+-	/* Copy the contents of the vector into a strarray so we can expose them */
+-	s->cert_info_strings.strings = (char **) strings.contents;
+-	s->cert_info_strings.count   = strings.length;
+-
+-	s->cert_info.parent.cert_type = GIT_CERT_STRARRAY;
+-	s->cert_info.data             = &s->cert_info_strings;
+-	s->cert_info.len              = strings.length;
+-
+-	*out = &s->cert_info.parent;
+-
+-	return 0;
+-}
+-
+-static int curls_set_proxy(git_stream *stream, const git_proxy_options *proxy_opts)
+-{
+-	int error;
+-	CURLcode res;
+-	curl_stream *s = (curl_stream *) stream;
+-
+-	if ((error = git_proxy_options_dup(&s->proxy, proxy_opts)) < 0)
+-		return error;
+-
+-	if ((res = curl_easy_setopt(s->handle, CURLOPT_PROXY, s->proxy.url)) != CURLE_OK)
+-		return seterr_curl(s);
+-
+-	if ((res = curl_easy_setopt(s->handle, CURLOPT_PROXYAUTH, CURLAUTH_ANY)) != CURLE_OK)
+-		return seterr_curl(s);
+-
+-	return 0;
+-}
+-
+-static int wait_for(curl_socket_t fd, bool reading)
+-{
+-	int ret;
+-	fd_set infd, outfd, errfd;
+-
+-	FD_ZERO(&infd);
+-	FD_ZERO(&outfd);
+-	FD_ZERO(&errfd);
+-
+-	assert(fd >= 0);
+-	FD_SET(fd, &errfd);
+-	if (reading)
+-		FD_SET(fd, &infd);
+-	else
+-		FD_SET(fd, &outfd);
+-
+-	if ((ret = select(fd + 1, &infd, &outfd, &errfd, NULL)) < 0) {
+-		giterr_set(GITERR_OS, "error in select");
+-		return -1;
+-	}
+-
+-	return 0;
+-}
+-
+-static ssize_t curls_write(git_stream *stream, const char *data, size_t len, int flags)
+-{
+-	int error;
+-	size_t off = 0, sent;
+-	CURLcode res;
+-	curl_stream *s = (curl_stream *) stream;
+-
+-	GIT_UNUSED(flags);
+-
+-	do {
+-		if ((error = wait_for(s->socket, false)) < 0)
+-			return error;
+-
+-		res = curl_easy_send(s->handle, data + off, len - off, &sent);
+-		if (res == CURLE_OK)
+-			off += sent;
+-	} while ((res == CURLE_OK || res == CURLE_AGAIN) && off < len);
+-
+-	if (res != CURLE_OK)
+-		return seterr_curl(s);
+-
+-	return len;
+-}
+-
+-static ssize_t curls_read(git_stream *stream, void *data, size_t len)
+-{
+-	int error;
+-	size_t read;
+-	CURLcode res;
+-	curl_stream *s = (curl_stream *) stream;
+-
+-	do {
+-		if ((error = wait_for(s->socket, true)) < 0)
+-			return error;
+-
+-		res = curl_easy_recv(s->handle, data, len, &read);
+-	} while (res == CURLE_AGAIN);
+-
+-	if (res != CURLE_OK)
+-		return seterr_curl(s);
+-
+-	return read;
+-}
+-
+-static int curls_close(git_stream *stream)
+-{
+-	curl_stream *s = (curl_stream *) stream;
+-
+-	if (!s->handle)
+-		return 0;
+-
+-	curl_easy_cleanup(s->handle);
+-	s->handle = NULL;
+-	s->socket = 0;
+-
+-	return 0;
+-}
+-
+-static void curls_free(git_stream *stream)
+-{
+-	curl_stream *s = (curl_stream *) stream;
+-
+-	curls_close(stream);
+-	git_strarray_free(&s->cert_info_strings);
+-	git__free(s);
+-}
+-
+-int git_curl_stream_new(git_stream **out, const char *host, const char *port)
+-{
+-	curl_stream *st;
+-	CURL *handle;
+-	int iport = 0, error;
+-
+-	st = git__calloc(1, sizeof(curl_stream));
+-	GITERR_CHECK_ALLOC(st);
+-
+-	handle = curl_easy_init();
+-	if (handle == NULL) {
+-		giterr_set(GITERR_NET, "failed to create curl handle");
+-		git__free(st);
+-		return -1;
+-	}
+-
+-	if ((error = git__strtol32(&iport, port, NULL, 10)) < 0) {
+-		git__free(st);
+-		return error;
+-	}
+-
+-	curl_easy_setopt(handle, CURLOPT_URL, host);
+-	curl_easy_setopt(handle, CURLOPT_ERRORBUFFER, st->curl_error);
+-	curl_easy_setopt(handle, CURLOPT_PORT, iport);
+-	curl_easy_setopt(handle, CURLOPT_CONNECT_ONLY, 1);
+-	curl_easy_setopt(handle, CURLOPT_SSL_VERIFYPEER, 1);
+-	curl_easy_setopt(handle, CURLOPT_CERTINFO, 1);
+-	curl_easy_setopt(handle, CURLOPT_HTTPPROXYTUNNEL, 1);
+-	curl_easy_setopt(handle, CURLOPT_PROXYAUTH, CURLAUTH_ANY);
+-
+-	/* curl_easy_setopt(handle, CURLOPT_VERBOSE, 1); */
+-
+-	st->parent.version = GIT_STREAM_VERSION;
+-	st->parent.encrypted = 0; /* we don't encrypt ourselves */
+-	st->parent.proxy_support = 1;
+-	st->parent.connect = curls_connect;
+-	st->parent.certificate = curls_certificate;
+-	st->parent.set_proxy = curls_set_proxy;
+-	st->parent.read = curls_read;
+-	st->parent.write = curls_write;
+-	st->parent.close = curls_close;
+-	st->parent.free = curls_free;
+-	st->handle = handle;
+-
+-	*out = (git_stream *) st;
+-	return 0;
+-}
+-
+-#else
+-
+-#include "stream.h"
+-
+-int git_curl_stream_new(git_stream **out, const char *host, const char *port)
+-{
+-	GIT_UNUSED(out);
+-	GIT_UNUSED(host);
+-	GIT_UNUSED(port);
+-
+-	giterr_set(GITERR_NET, "curl is not supported in this version");
+-	return -1;
+-}
+-
+-
+-#endif
+diff --git a/src/curl_stream.h b/src/curl_stream.h
+deleted file mode 100644
+index 283f0fe..0000000
+--- a/src/curl_stream.h
++++ /dev/null
+@@ -1,14 +0,0 @@
+-/*
+- * Copyright (C) the libgit2 contributors. All rights reserved.
+- *
+- * This file is part of libgit2, distributed under the GNU GPL v2 with
+- * a Linking Exception. For full terms see the included COPYING file.
+- */
+-#ifndef INCLUDE_curl_stream_h__
+-#define INCLUDE_curl_stream_h__
+-
+-#include "git2/sys/stream.h"
+-
+-extern int git_curl_stream_new(git_stream **out, const char *host, const char *port);
+-
+-#endif
 diff --git a/src/global.c b/src/global.c
-index e2ad8fe..c5b4269 100644
+index afa57e1..66f1d44 100644
 --- a/src/global.c
 +++ b/src/global.c
-@@ -10,7 +10,11 @@
+@@ -10,7 +10,8 @@
  #include "sysdir.h"
  #include "filter.h"
  #include "merge_driver.h"
-+#ifdef GIT_OPENSSL
- #include "openssl_stream.h"
-+#elif GIT_MBEDTLS
-+#include "mbedtls_stream.h"
-+#endif
+-#include "openssl_stream.h"
++#include "streams/mbedtls.h"
++#include "streams/openssl.h"
  #include "thread-utils.h"
  #include "git2/global.h"
  #include "transports/ssh.h"
-@@ -61,8 +65,13 @@ static int init_common(void)
- 		(ret = git_sysdir_global_init()) == 0 &&
+@@ -62,7 +63,8 @@ static int init_common(void)
  		(ret = git_filter_global_init()) == 0 &&
  		(ret = git_merge_driver_global_init()) == 0 &&
--		(ret = git_transport_ssh_global_init()) == 0 &&
+ 		(ret = git_transport_ssh_global_init()) == 0 &&
 -		(ret = git_openssl_stream_global_init()) == 0)
-+		(ret = git_transport_ssh_global_init()) == 0
-+#ifdef GIT_OPENSSL
-+		&& (ret = git_openssl_stream_global_init()) == 0
-+#elif GIT_MBEDTLS
-+		&& (ret = git_mbedtls_stream_global_init()) == 0
-+#endif
-+		)
++		(ret = git_openssl_stream_global_init()) == 0 &&
++		(ret = git_mbedtls_stream_global_init()) == 0)
  		ret = git_mwindow_global_init();
  
  	GIT_MEMORY_BARRIER;
 diff --git a/src/global.h b/src/global.h
-index 2199515..adadcd9 100644
+index 88f40aa..e4bbabf 100644
 --- a/src/global.h
 +++ b/src/global.h
-@@ -23,6 +23,12 @@ typedef struct {
- extern SSL_CTX *git__ssl_ctx;
- #endif
+@@ -24,11 +24,6 @@ typedef struct {
+ 	git_thread *current_thread;
+ } git_global_st;
  
-+#ifdef GIT_MBEDTLS
-+# include "mbedtls/platform.h"
-+# include "mbedtls/ssl.h"
-+extern mbedtls_ssl_config *git__ssl_conf;
-+#endif
-+
+-#ifdef GIT_OPENSSL
+-# include <openssl/ssl.h>
+-extern SSL_CTX *git__ssl_ctx;
+-#endif
+-
  git_global_st *git__global_state(void);
  
  extern git_mutex git__mwindow_mutex;
 diff --git a/src/hash.h b/src/hash.h
-index 0bc02a8..958d23b 100644
+index 0db0339..cba4462 100644
 --- a/src/hash.h
 +++ b/src/hash.h
-@@ -20,6 +20,8 @@ void git_hash_ctx_cleanup(git_hash_ctx *ctx);
- # include "hash/hash_common_crypto.h"
- #elif defined(OPENSSL_SHA1)
+@@ -24,6 +24,8 @@ void git_hash_ctx_cleanup(git_hash_ctx *ctx);
  # include "hash/hash_openssl.h"
+ #elif defined(GIT_SHA1_WIN32)
+ # include "hash/hash_win32.h"
 +#elif defined(MBEDTLS_SHA1)
 +# include "hash/hash_mbedtls.h"
- #elif defined(WIN32_SHA1)
- # include "hash/hash_win32.h"
  #else
+ # include "hash/hash_generic.h"
+ #endif
 diff --git a/src/hash/hash_mbedtls.c b/src/hash/hash_mbedtls.c
 new file mode 100644
 index 0000000..a19d763
@@ -233,7 +875,7 @@ index 0000000..a19d763
 +}
 diff --git a/src/hash/hash_mbedtls.h b/src/hash/hash_mbedtls.h
 new file mode 100644
-index 0000000..e50d295
+index 0000000..24196c5
 --- /dev/null
 +++ b/src/hash/hash_mbedtls.h
 @@ -0,0 +1,20 @@
@@ -257,13 +899,1803 @@ index 0000000..e50d295
 +#define git_hash_ctx_init(ctx) git_hash_init(ctx)
 +
 +#endif /* INCLUDE_hash_mbedtld_h__ */
-\ No newline at end of file
-diff --git a/src/mbedtls_stream.c b/src/mbedtls_stream.c
+diff --git a/src/openssl_stream.c b/src/openssl_stream.c
+deleted file mode 100644
+index 759c501..0000000
+--- a/src/openssl_stream.c
++++ /dev/null
+@@ -1,656 +0,0 @@
+-/*
+- * Copyright (C) the libgit2 contributors. All rights reserved.
+- *
+- * This file is part of libgit2, distributed under the GNU GPL v2 with
+- * a Linking Exception. For full terms see the included COPYING file.
+- */
+-
+-#ifdef GIT_OPENSSL
+-
+-#include <ctype.h>
+-
+-#include "global.h"
+-#include "posix.h"
+-#include "stream.h"
+-#include "socket_stream.h"
+-#include "openssl_stream.h"
+-#include "netops.h"
+-#include "git2/transport.h"
+-#include "git2/sys/openssl.h"
+-
+-#ifdef GIT_CURL
+-# include "curl_stream.h"
+-#endif
+-
+-#ifndef GIT_WIN32
+-# include <sys/types.h>
+-# include <sys/socket.h>
+-# include <netinet/in.h>
+-#endif
+-
+-#include <openssl/ssl.h>
+-#include <openssl/err.h>
+-#include <openssl/x509v3.h>
+-#include <openssl/bio.h>
+-
+-SSL_CTX *git__ssl_ctx;
+-
+-#define GIT_SSL_DEFAULT_CIPHERS "ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-DSS-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:DHE-DSS-AES256-GCM-SHA384:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA:ECDHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA:DHE-DSS-AES128-SHA256:DHE-DSS-AES256-SHA256:DHE-DSS-AES128-SHA:DHE-DSS-AES256-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA"
+-
+-#if defined(GIT_THREADS) && OPENSSL_VERSION_NUMBER < 0x10100000L
+-
+-static git_mutex *openssl_locks;
+-
+-static void openssl_locking_function(
+-	int mode, int n, const char *file, int line)
+-{
+-	int lock;
+-
+-	GIT_UNUSED(file);
+-	GIT_UNUSED(line);
+-
+-	lock = mode & CRYPTO_LOCK;
+-
+-	if (lock) {
+-		git_mutex_lock(&openssl_locks[n]);
+-	} else {
+-		git_mutex_unlock(&openssl_locks[n]);
+-	}
+-}
+-
+-static void shutdown_ssl_locking(void)
+-{
+-	int num_locks, i;
+-
+-	num_locks = CRYPTO_num_locks();
+-	CRYPTO_set_locking_callback(NULL);
+-
+-	for (i = 0; i < num_locks; ++i)
+-		git_mutex_free(&openssl_locks[i]);
+-	git__free(openssl_locks);
+-}
+-
+-#endif /* GIT_THREADS && OPENSSL_VERSION_NUMBER < 0x10100000L */
+-
+-static BIO_METHOD *git_stream_bio_method;
+-static int init_bio_method(void);
+-
+-/**
+- * This function aims to clean-up the SSL context which
+- * we allocated.
+- */
+-static void shutdown_ssl(void)
+-{
+-	if (git_stream_bio_method) {
+-		BIO_meth_free(git_stream_bio_method);
+-		git_stream_bio_method = NULL;
+-	}
+-
+-	if (git__ssl_ctx) {
+-		SSL_CTX_free(git__ssl_ctx);
+-		git__ssl_ctx = NULL;
+-	}
+-}
+-
+-int git_openssl_stream_global_init(void)
+-{
+-#ifdef GIT_OPENSSL
+-	long ssl_opts = SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3;
+-	const char *ciphers = git_libgit2__ssl_ciphers();
+-
+-	/* Older OpenSSL and MacOS OpenSSL doesn't have this */
+-#ifdef SSL_OP_NO_COMPRESSION
+-	ssl_opts |= SSL_OP_NO_COMPRESSION;
+-#endif
+-
+-#if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
+-	SSL_load_error_strings();
+-	OpenSSL_add_ssl_algorithms();
+-#else
+-	OPENSSL_init_ssl(0, NULL);
+-#endif
+-
+-	/*
+-	 * Load SSLv{2,3} and TLSv1 so that we can talk with servers
+-	 * which use the SSL hellos, which are often used for
+-	 * compatibility. We then disable SSL so we only allow OpenSSL
+-	 * to speak TLSv1 to perform the encryption itself.
+-	 */
+-	git__ssl_ctx = SSL_CTX_new(SSLv23_method());
+-	SSL_CTX_set_options(git__ssl_ctx, ssl_opts);
+-	SSL_CTX_set_mode(git__ssl_ctx, SSL_MODE_AUTO_RETRY);
+-	SSL_CTX_set_verify(git__ssl_ctx, SSL_VERIFY_NONE, NULL);
+-	if (!SSL_CTX_set_default_verify_paths(git__ssl_ctx)) {
+-		SSL_CTX_free(git__ssl_ctx);
+-		git__ssl_ctx = NULL;
+-		return -1;
+-	}
+-
+-	if (!ciphers) {
+-		ciphers = GIT_SSL_DEFAULT_CIPHERS;
+-	}
+-
+-	if(!SSL_CTX_set_cipher_list(git__ssl_ctx, ciphers)) {
+-		SSL_CTX_free(git__ssl_ctx);
+-		git__ssl_ctx = NULL;
+-		return -1;
+-	}
+-
+-	if (init_bio_method() < 0) {
+-		SSL_CTX_free(git__ssl_ctx);
+-		git__ssl_ctx = NULL;
+-		return -1;
+-	}
+-
+-#endif
+-
+-	git__on_shutdown(shutdown_ssl);
+-
+-	return 0;
+-}
+-
+-int git_openssl_set_locking(void)
+-{
+-#if defined(GIT_THREADS) && OPENSSL_VERSION_NUMBER < 0x10100000L
+-	int num_locks, i;
+-
+-	num_locks = CRYPTO_num_locks();
+-	openssl_locks = git__calloc(num_locks, sizeof(git_mutex));
+-	GITERR_CHECK_ALLOC(openssl_locks);
+-
+-	for (i = 0; i < num_locks; i++) {
+-		if (git_mutex_init(&openssl_locks[i]) != 0) {
+-			giterr_set(GITERR_SSL, "failed to initialize openssl locks");
+-			return -1;
+-		}
+-	}
+-
+-	CRYPTO_set_locking_callback(openssl_locking_function);
+-	git__on_shutdown(shutdown_ssl_locking);
+-	return 0;
+-#elif OPENSSL_VERSION_NUMBER >= 0x10100000L
+-	return 0;
+-#else
+-	giterr_set(GITERR_THREAD, "libgit2 was not built with threads");
+-	return -1;
+-#endif
+-}
+-
+-
+-static int bio_create(BIO *b)
+-{
+-	BIO_set_init(b, 1);
+-	BIO_set_data(b, NULL);
+-
+-	return 1;
+-}
+-
+-static int bio_destroy(BIO *b)
+-{
+-	if (!b)
+-		return 0;
+-
+-	BIO_set_data(b, NULL);
+-
+-	return 1;
+-}
+-
+-static int bio_read(BIO *b, char *buf, int len)
+-{
+-	git_stream *io = (git_stream *) BIO_get_data(b);
+-
+-	return (int) git_stream_read(io, buf, len);
+-}
+-
+-static int bio_write(BIO *b, const char *buf, int len)
+-{
+-	git_stream *io = (git_stream *) BIO_get_data(b);
+-
+-	return (int) git_stream_write(io, buf, len, 0);
+-}
+-
+-static long bio_ctrl(BIO *b, int cmd, long num, void *ptr)
+-{
+-	GIT_UNUSED(b);
+-	GIT_UNUSED(num);
+-	GIT_UNUSED(ptr);
+-
+-	if (cmd == BIO_CTRL_FLUSH)
+-		return 1;
+-
+-	return 0;
+-}
+-
+-static int bio_gets(BIO *b, char *buf, int len)
+-{
+-	GIT_UNUSED(b);
+-	GIT_UNUSED(buf);
+-	GIT_UNUSED(len);
+-	return -1;
+-}
+-
+-static int bio_puts(BIO *b, const char *str)
+-{
+-	return bio_write(b, str, strlen(str));
+-}
+-
+-static int init_bio_method(void)
+-{
+-	/* Set up the BIO_METHOD we use for wrapping our own stream implementations */
+-	git_stream_bio_method = BIO_meth_new(BIO_TYPE_SOURCE_SINK | BIO_get_new_index(), "git_stream");
+-	GITERR_CHECK_ALLOC(git_stream_bio_method);
+-
+-	BIO_meth_set_write(git_stream_bio_method, bio_write);
+-	BIO_meth_set_read(git_stream_bio_method, bio_read);
+-	BIO_meth_set_puts(git_stream_bio_method, bio_puts);
+-	BIO_meth_set_gets(git_stream_bio_method, bio_gets);
+-	BIO_meth_set_ctrl(git_stream_bio_method, bio_ctrl);
+-	BIO_meth_set_create(git_stream_bio_method, bio_create);
+-	BIO_meth_set_destroy(git_stream_bio_method, bio_destroy);
+-
+-	return 0;
+-}
+-
+-static int ssl_set_error(SSL *ssl, int error)
+-{
+-	int err;
+-	unsigned long e;
+-
+-	err = SSL_get_error(ssl, error);
+-
+-	assert(err != SSL_ERROR_WANT_READ);
+-	assert(err != SSL_ERROR_WANT_WRITE);
+-
+-	switch (err) {
+-	case SSL_ERROR_WANT_CONNECT:
+-	case SSL_ERROR_WANT_ACCEPT:
+-		giterr_set(GITERR_NET, "SSL error: connection failure");
+-		break;
+-	case SSL_ERROR_WANT_X509_LOOKUP:
+-		giterr_set(GITERR_NET, "SSL error: x509 error");
+-		break;
+-	case SSL_ERROR_SYSCALL:
+-		e = ERR_get_error();
+-		if (e > 0) {
+-			giterr_set(GITERR_NET, "SSL error: %s",
+-					ERR_error_string(e, NULL));
+-			break;
+-		} else if (error < 0) {
+-			giterr_set(GITERR_OS, "SSL error: syscall failure");
+-			break;
+-		}
+-		giterr_set(GITERR_NET, "SSL error: received early EOF");
+-		return GIT_EEOF;
+-		break;
+-	case SSL_ERROR_SSL:
+-		e = ERR_get_error();
+-		giterr_set(GITERR_NET, "SSL error: %s",
+-				ERR_error_string(e, NULL));
+-		break;
+-	case SSL_ERROR_NONE:
+-	case SSL_ERROR_ZERO_RETURN:
+-	default:
+-		giterr_set(GITERR_NET, "SSL error: unknown error");
+-		break;
+-	}
+-	return -1;
+-}
+-
+-static int ssl_teardown(SSL *ssl)
+-{
+-	int ret;
+-
+-	ret = SSL_shutdown(ssl);
+-	if (ret < 0)
+-		ret = ssl_set_error(ssl, ret);
+-	else
+-		ret = 0;
+-
+-	return ret;
+-}
+-
+-static int check_host_name(const char *name, const char *host)
+-{
+-	if (!strcasecmp(name, host))
+-		return 0;
+-
+-	if (gitno__match_host(name, host) < 0)
+-		return -1;
+-
+-	return 0;
+-}
+-
+-static int verify_server_cert(SSL *ssl, const char *host)
+-{
+-	X509 *cert;
+-	X509_NAME *peer_name;
+-	ASN1_STRING *str;
+-	unsigned char *peer_cn = NULL;
+-	int matched = -1, type = GEN_DNS;
+-	GENERAL_NAMES *alts;
+-	struct in6_addr addr6;
+-	struct in_addr addr4;
+-	void *addr;
+-	int i = -1,j;
+-
+-	if (SSL_get_verify_result(ssl) != X509_V_OK) {
+-		giterr_set(GITERR_SSL, "the SSL certificate is invalid");
+-		return GIT_ECERTIFICATE;
+-	}
+-
+-	/* Try to parse the host as an IP address to see if it is */
+-	if (p_inet_pton(AF_INET, host, &addr4)) {
+-		type = GEN_IPADD;
+-		addr = &addr4;
+-	} else {
+-		if(p_inet_pton(AF_INET6, host, &addr6)) {
+-			type = GEN_IPADD;
+-			addr = &addr6;
+-		}
+-	}
+-
+-
+-	cert = SSL_get_peer_certificate(ssl);
+-	if (!cert) {
+-		giterr_set(GITERR_SSL, "the server did not provide a certificate");
+-		return -1;
+-	}
+-
+-	/* Check the alternative names */
+-	alts = X509_get_ext_d2i(cert, NID_subject_alt_name, NULL, NULL);
+-	if (alts) {
+-		int num;
+-
+-		num = sk_GENERAL_NAME_num(alts);
+-		for (i = 0; i < num && matched != 1; i++) {
+-			const GENERAL_NAME *gn = sk_GENERAL_NAME_value(alts, i);
+-			const char *name = (char *) ASN1_STRING_get0_data(gn->d.ia5);
+-			size_t namelen = (size_t) ASN1_STRING_length(gn->d.ia5);
+-
+-			/* Skip any names of a type we're not looking for */
+-			if (gn->type != type)
+-				continue;
+-
+-			if (type == GEN_DNS) {
+-				/* If it contains embedded NULs, don't even try */
+-				if (memchr(name, '\0', namelen))
+-					continue;
+-
+-				if (check_host_name(name, host) < 0)
+-					matched = 0;
+-				else
+-					matched = 1;
+-			} else if (type == GEN_IPADD) {
+-				/* Here name isn't so much a name but a binary representation of the IP */
+-				matched = !!memcmp(name, addr, namelen);
+-			}
+-		}
+-	}
+-	GENERAL_NAMES_free(alts);
+-
+-	if (matched == 0)
+-		goto cert_fail_name;
+-
+-	if (matched == 1)
+-		return 0;
+-
+-	/* If no alternative names are available, check the common name */
+-	peer_name = X509_get_subject_name(cert);
+-	if (peer_name == NULL)
+-		goto on_error;
+-
+-	if (peer_name) {
+-		/* Get the index of the last CN entry */
+-		while ((j = X509_NAME_get_index_by_NID(peer_name, NID_commonName, i)) >= 0)
+-			i = j;
+-	}
+-
+-	if (i < 0)
+-		goto on_error;
+-
+-	str = X509_NAME_ENTRY_get_data(X509_NAME_get_entry(peer_name, i));
+-	if (str == NULL)
+-		goto on_error;
+-
+-	/* Work around a bug in OpenSSL whereby ASN1_STRING_to_UTF8 fails if it's already in utf-8 */
+-	if (ASN1_STRING_type(str) == V_ASN1_UTF8STRING) {
+-		int size = ASN1_STRING_length(str);
+-
+-		if (size > 0) {
+-			peer_cn = OPENSSL_malloc(size + 1);
+-			GITERR_CHECK_ALLOC(peer_cn);
+-			memcpy(peer_cn, ASN1_STRING_get0_data(str), size);
+-			peer_cn[size] = '\0';
+-		} else {
+-			goto cert_fail_name;
+-		}
+-	} else {
+-		int size = ASN1_STRING_to_UTF8(&peer_cn, str);
+-		GITERR_CHECK_ALLOC(peer_cn);
+-		if (memchr(peer_cn, '\0', size))
+-			goto cert_fail_name;
+-	}
+-
+-	if (check_host_name((char *)peer_cn, host) < 0)
+-		goto cert_fail_name;
+-
+-	OPENSSL_free(peer_cn);
+-
+-	return 0;
+-
+-on_error:
+-	OPENSSL_free(peer_cn);
+-	return ssl_set_error(ssl, 0);
+-
+-cert_fail_name:
+-	OPENSSL_free(peer_cn);
+-	giterr_set(GITERR_SSL, "hostname does not match certificate");
+-	return GIT_ECERTIFICATE;
+-}
+-
+-typedef struct {
+-	git_stream parent;
+-	git_stream *io;
+-	bool connected;
+-	char *host;
+-	SSL *ssl;
+-	git_cert_x509 cert_info;
+-} openssl_stream;
+-
+-int openssl_close(git_stream *stream);
+-
+-int openssl_connect(git_stream *stream)
+-{
+-	int ret;
+-	BIO *bio;
+-	openssl_stream *st = (openssl_stream *) stream;
+-
+-	if ((ret = git_stream_connect(st->io)) < 0)
+-		return ret;
+-
+-	st->connected = true;
+-
+-	bio = BIO_new(git_stream_bio_method);
+-	GITERR_CHECK_ALLOC(bio);
+-
+-	BIO_set_data(bio, st->io);
+-	SSL_set_bio(st->ssl, bio, bio);
+-
+-	/* specify the host in case SNI is needed */
+-#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
+-	SSL_set_tlsext_host_name(st->ssl, st->host);
+-#endif
+-
+-	if ((ret = SSL_connect(st->ssl)) <= 0)
+-		return ssl_set_error(st->ssl, ret);
+-
+-	return verify_server_cert(st->ssl, st->host);
+-}
+-
+-int openssl_certificate(git_cert **out, git_stream *stream)
+-{
+-	openssl_stream *st = (openssl_stream *) stream;
+-	int len;
+-	X509 *cert = SSL_get_peer_certificate(st->ssl);
+-	unsigned char *guard, *encoded_cert;
+-
+-	/* Retrieve the length of the certificate first */
+-	len = i2d_X509(cert, NULL);
+-	if (len < 0) {
+-		giterr_set(GITERR_NET, "failed to retrieve certificate information");
+-		return -1;
+-	}
+-
+-	encoded_cert = git__malloc(len);
+-	GITERR_CHECK_ALLOC(encoded_cert);
+-	/* i2d_X509 makes 'guard' point to just after the data */
+-	guard = encoded_cert;
+-
+-	len = i2d_X509(cert, &guard);
+-	if (len < 0) {
+-		git__free(encoded_cert);
+-		giterr_set(GITERR_NET, "failed to retrieve certificate information");
+-		return -1;
+-	}
+-
+-	st->cert_info.parent.cert_type = GIT_CERT_X509;
+-	st->cert_info.data = encoded_cert;
+-	st->cert_info.len = len;
+-
+-	*out = &st->cert_info.parent;
+-
+-	return 0;
+-}
+-
+-static int openssl_set_proxy(git_stream *stream, const git_proxy_options *proxy_opts)
+-{
+-	openssl_stream *st = (openssl_stream *) stream;
+-
+-	return git_stream_set_proxy(st->io, proxy_opts);
+-}
+-
+-ssize_t openssl_write(git_stream *stream, const char *data, size_t len, int flags)
+-{
+-	openssl_stream *st = (openssl_stream *) stream;
+-	int ret;
+-
+-	GIT_UNUSED(flags);
+-
+-	if ((ret = SSL_write(st->ssl, data, len)) <= 0) {
+-		return ssl_set_error(st->ssl, ret);
+-	}
+-
+-	return ret;
+-}
+-
+-ssize_t openssl_read(git_stream *stream, void *data, size_t len)
+-{
+-	openssl_stream *st = (openssl_stream *) stream;
+-	int ret;
+-
+-	if ((ret = SSL_read(st->ssl, data, len)) <= 0)
+-		return ssl_set_error(st->ssl, ret);
+-
+-	return ret;
+-}
+-
+-int openssl_close(git_stream *stream)
+-{
+-	openssl_stream *st = (openssl_stream *) stream;
+-	int ret;
+-
+-	if (st->connected && (ret = ssl_teardown(st->ssl)) < 0)
+-		return -1;
+-
+-	st->connected = false;
+-
+-	return git_stream_close(st->io);
+-}
+-
+-void openssl_free(git_stream *stream)
+-{
+-	openssl_stream *st = (openssl_stream *) stream;
+-
+-	SSL_free(st->ssl);
+-	git__free(st->host);
+-	git__free(st->cert_info.data);
+-	git_stream_free(st->io);
+-	git__free(st);
+-}
+-
+-int git_openssl_stream_new(git_stream **out, const char *host, const char *port)
+-{
+-	int error;
+-	openssl_stream *st;
+-
+-	st = git__calloc(1, sizeof(openssl_stream));
+-	GITERR_CHECK_ALLOC(st);
+-
+-	st->io = NULL;
+-#ifdef GIT_CURL
+-	error = git_curl_stream_new(&st->io, host, port);
+-#else
+-	error = git_socket_stream_new(&st->io, host, port);
+-#endif
+-
+-	if (error < 0)
+-		goto out_err;
+-
+-	st->ssl = SSL_new(git__ssl_ctx);
+-	if (st->ssl == NULL) {
+-		giterr_set(GITERR_SSL, "failed to create ssl object");
+-		error = -1;
+-		goto out_err;
+-	}
+-
+-	st->host = git__strdup(host);
+-	GITERR_CHECK_ALLOC(st->host);
+-
+-	st->parent.version = GIT_STREAM_VERSION;
+-	st->parent.encrypted = 1;
+-	st->parent.proxy_support = git_stream_supports_proxy(st->io);
+-	st->parent.connect = openssl_connect;
+-	st->parent.certificate = openssl_certificate;
+-	st->parent.set_proxy = openssl_set_proxy;
+-	st->parent.read = openssl_read;
+-	st->parent.write = openssl_write;
+-	st->parent.close = openssl_close;
+-	st->parent.free = openssl_free;
+-
+-	*out = (git_stream *) st;
+-	return 0;
+-
+-out_err:
+-	git_stream_free(st->io);
+-	git__free(st);
+-
+-	return error;
+-}
+-
+-#else
+-
+-#include "stream.h"
+-#include "git2/sys/openssl.h"
+-
+-int git_openssl_stream_global_init(void)
+-{
+-	return 0;
+-}
+-
+-int git_openssl_set_locking(void)
+-{
+-	giterr_set(GITERR_SSL, "libgit2 was not built with OpenSSL support");
+-	return -1;
+-}
+-
+-int git_openssl_stream_new(git_stream **out, const char *host, const char *port)
+-{
+-	GIT_UNUSED(out);
+-	GIT_UNUSED(host);
+-	GIT_UNUSED(port);
+-
+-	giterr_set(GITERR_SSL, "openssl is not supported in this version");
+-	return -1;
+-}
+-
+-#endif
+diff --git a/src/openssl_stream.h b/src/openssl_stream.h
+deleted file mode 100644
+index f5e59da..0000000
+--- a/src/openssl_stream.h
++++ /dev/null
+@@ -1,122 +0,0 @@
+-/*
+- * Copyright (C) the libgit2 contributors. All rights reserved.
+- *
+- * This file is part of libgit2, distributed under the GNU GPL v2 with
+- * a Linking Exception. For full terms see the included COPYING file.
+- */
+-#ifndef INCLUDE_openssl_stream_h__
+-#define INCLUDE_openssl_stream_h__
+-
+-#include "git2/sys/stream.h"
+-
+-extern int git_openssl_stream_global_init(void);
+-
+-extern int git_openssl_stream_new(git_stream **out, const char *host, const char *port);
+-
+-/*
+- * OpenSSL 1.1 made BIO opaque so we have to use functions to interact with it
+- * which do not exist in previous versions. We define these inline functions so
+- * we can program against the interface instead of littering the implementation
+- * with ifdefs.
+- */
+-#ifdef GIT_OPENSSL
+-# include <openssl/ssl.h>
+-# include <openssl/err.h>
+-# include <openssl/x509v3.h>
+-# include <openssl/bio.h>
+-
+-
+-
+-# if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
+-
+-GIT_INLINE(BIO_METHOD*) BIO_meth_new(int type, const char *name)
+-{
+-	BIO_METHOD *meth = git__calloc(1, sizeof(BIO_METHOD));
+-	if (!meth) {
+-		return NULL;
+-	}
+-
+-	meth->type = type;
+-	meth->name = name;
+-
+-	return meth;
+-}
+-
+-GIT_INLINE(void) BIO_meth_free(BIO_METHOD *biom)
+-{
+-	git__free(biom);
+-}
+-
+-GIT_INLINE(int) BIO_meth_set_write(BIO_METHOD *biom, int (*write) (BIO *, const char *, int))
+-{
+-	biom->bwrite = write;
+-	return 1;
+-}
+-
+-GIT_INLINE(int) BIO_meth_set_read(BIO_METHOD *biom, int (*read) (BIO *, char *, int))
+-{
+-	biom->bread = read;
+-	return 1;
+-}
+-
+-GIT_INLINE(int) BIO_meth_set_puts(BIO_METHOD *biom, int (*puts) (BIO *, const char *))
+-{
+-	biom->bputs = puts;
+-	return 1;
+-}
+-
+-GIT_INLINE(int) BIO_meth_set_gets(BIO_METHOD *biom, int (*gets) (BIO *, char *, int))
+-
+-{
+-	biom->bgets = gets;
+-	return 1;
+-}
+-
+-GIT_INLINE(int) BIO_meth_set_ctrl(BIO_METHOD *biom, long (*ctrl) (BIO *, int, long, void *))
+-{
+-	biom->ctrl = ctrl;
+-	return 1;
+-}
+-
+-GIT_INLINE(int) BIO_meth_set_create(BIO_METHOD *biom, int (*create) (BIO *))
+-{
+-	biom->create = create;
+-	return 1;
+-}
+-
+-GIT_INLINE(int) BIO_meth_set_destroy(BIO_METHOD *biom, int (*destroy) (BIO *))
+-{
+-	biom->destroy = destroy;
+-	return 1;
+-}
+-
+-GIT_INLINE(int) BIO_get_new_index(void)
+-{
+-	/* This exists as of 1.1 so before we'd just have 0 */
+-	return 0;
+-}
+-
+-GIT_INLINE(void) BIO_set_init(BIO *b, int init)
+-{
+-	b->init = init;
+-}
+-
+-GIT_INLINE(void) BIO_set_data(BIO *a, void *ptr)
+-{
+-	a->ptr = ptr;
+-}
+-
+-GIT_INLINE(void*) BIO_get_data(BIO *a)
+-{
+-	return a->ptr;
+-}
+-
+-GIT_INLINE(const unsigned char *) ASN1_STRING_get0_data(const ASN1_STRING *x)
+-{
+-	return ASN1_STRING_data((ASN1_STRING *)x);
+-}
+-
+-# endif // OpenSSL < 1.1
+-#endif // GIT_OPENSSL
+-
+-#endif
+diff --git a/src/settings.c b/src/settings.c
+index 52b861b..3a46f0d 100644
+--- a/src/settings.c
++++ b/src/settings.c
+@@ -9,6 +9,10 @@
+ # include <openssl/err.h>
+ #endif
+ 
++#ifdef GIT_MBEDTLS
++# include <mbedtls/error.h>
++#endif
++
+ #include <git2.h>
+ #include "common.h"
+ #include "sysdir.h"
+@@ -18,6 +22,8 @@
+ #include "odb.h"
+ #include "refs.h"
+ #include "transports/smart.h"
++#include "streams/openssl.h"
++#include "streams/mbedtls.h"
+ 
+ void git_libgit2_version(int *major, int *minor, int *rev)
+ {
+@@ -171,14 +177,19 @@ int git_libgit2_opts(int key, ...)
+ 		{
+ 			const char *file = va_arg(ap, const char *);
+ 			const char *path = va_arg(ap, const char *);
+-			if (!SSL_CTX_load_verify_locations(git__ssl_ctx, file, path)) {
+-				giterr_set(GITERR_NET, "SSL error: %s",
+-					ERR_error_string(ERR_get_error(), NULL));
+-				error = -1;
+-			}
++			error = git_openssl_set_cert_file(file, path);
++		}
++#elif GIT_MBEDTLS
++		{
++			const char *file = va_arg(ap, const char *);
++			const char *path = va_arg(ap, const char *);
++			if (file)
++				error = git_mbedtls_set_cert_file(file, 0);
++			if (error && path)
++				error = git_mbedtls_set_cert_file(path, 0);
+ 		}
+ #else
+-		giterr_set(GITERR_NET, "cannot set certificate locations: OpenSSL is not enabled");
++		giterr_set(GITERR_NET, "cannot set certificate locations: OpenSSL or mbedTLS is not enabled");
+ 		error = -1;
+ #endif
+ 		break;
+diff --git a/src/socket_stream.c b/src/socket_stream.c
+deleted file mode 100644
+index c0a1684..0000000
+--- a/src/socket_stream.c
++++ /dev/null
+@@ -1,210 +0,0 @@
+-/*
+- * Copyright (C) the libgit2 contributors. All rights reserved.
+- *
+- * This file is part of libgit2, distributed under the GNU GPL v2 with
+- * a Linking Exception. For full terms see the included COPYING file.
+- */
+-
+-#include "common.h"
+-#include "posix.h"
+-#include "netops.h"
+-#include "stream.h"
+-#include "socket_stream.h"
+-
+-#ifndef _WIN32
+-#	include <sys/types.h>
+-#	include <sys/socket.h>
+-#	include <sys/select.h>
+-#	include <sys/time.h>
+-#	include <netdb.h>
+-#	include <netinet/in.h>
+-#       include <arpa/inet.h>
+-#else
+-#	include <winsock2.h>
+-#	include <ws2tcpip.h>
+-#	ifdef _MSC_VER
+-#		pragma comment(lib, "ws2_32")
+-#	endif
+-#endif
+-
+-#ifdef GIT_WIN32
+-static void net_set_error(const char *str)
+-{
+-	int error = WSAGetLastError();
+-	char * win32_error = git_win32_get_error_message(error);
+-
+-	if (win32_error) {
+-		giterr_set(GITERR_NET, "%s: %s", str, win32_error);
+-		git__free(win32_error);
+-	} else {
+-		giterr_set(GITERR_NET, str);
+-	}
+-}
+-#else
+-static void net_set_error(const char *str)
+-{
+-	giterr_set(GITERR_NET, "%s: %s", str, strerror(errno));
+-}
+-#endif
+-
+-static int close_socket(GIT_SOCKET s)
+-{
+-	if (s == INVALID_SOCKET)
+-		return 0;
+-
+-#ifdef GIT_WIN32
+-	if (SOCKET_ERROR == closesocket(s))
+-		return -1;
+-
+-	if (0 != WSACleanup()) {
+-		giterr_set(GITERR_OS, "winsock cleanup failed");
+-		return -1;
+-	}
+-
+-	return 0;
+-#else
+-	return close(s);
+-#endif
+-
+-}
+-
+-int socket_connect(git_stream *stream)
+-{
+-	struct addrinfo *info = NULL, *p;
+-	struct addrinfo hints;
+-	git_socket_stream *st = (git_socket_stream *) stream;
+-	GIT_SOCKET s = INVALID_SOCKET;
+-	int ret;
+-
+-#ifdef GIT_WIN32
+-	/* on win32, the WSA context needs to be initialized
+-	 * before any socket calls can be performed */
+-	WSADATA wsd;
+-
+-	if (WSAStartup(MAKEWORD(2,2), &wsd) != 0) {
+-		giterr_set(GITERR_OS, "winsock init failed");
+-		return -1;
+-	}
+-
+-	if (LOBYTE(wsd.wVersion) != 2 || HIBYTE(wsd.wVersion) != 2) {
+-		WSACleanup();
+-		giterr_set(GITERR_OS, "winsock init failed");
+-		return -1;
+-	}
+-#endif
+-
+-	memset(&hints, 0x0, sizeof(struct addrinfo));
+-	hints.ai_socktype = SOCK_STREAM;
+-	hints.ai_family = AF_UNSPEC;
+-
+-	if ((ret = p_getaddrinfo(st->host, st->port, &hints, &info)) != 0) {
+-		giterr_set(GITERR_NET,
+-			   "failed to resolve address for %s: %s", st->host, p_gai_strerror(ret));
+-		return -1;
+-	}
+-
+-	for (p = info; p != NULL; p = p->ai_next) {
+-		s = socket(p->ai_family, p->ai_socktype, p->ai_protocol);
+-
+-		if (s == INVALID_SOCKET)
+-			continue;
+-
+-		if (connect(s, p->ai_addr, (socklen_t)p->ai_addrlen) == 0)
+-			break;
+-
+-		/* If we can't connect, try the next one */
+-		close_socket(s);
+-		s = INVALID_SOCKET;
+-	}
+-
+-	/* Oops, we couldn't connect to any address */
+-	if (s == INVALID_SOCKET && p == NULL) {
+-		giterr_set(GITERR_OS, "failed to connect to %s", st->host);
+-		p_freeaddrinfo(info);
+-		return -1;
+-	}
+-
+-	st->s = s;
+-	p_freeaddrinfo(info);
+-	return 0;
+-}
+-
+-ssize_t socket_write(git_stream *stream, const char *data, size_t len, int flags)
+-{
+-	ssize_t ret;
+-	size_t off = 0;
+-	git_socket_stream *st = (git_socket_stream *) stream;
+-
+-	while (off < len) {
+-		errno = 0;
+-		ret = p_send(st->s, data + off, len - off, flags);
+-		if (ret < 0) {
+-			net_set_error("Error sending data");
+-			return -1;
+-		}
+-
+-		off += ret;
+-	}
+-
+-	return off;
+-}
+-
+-ssize_t socket_read(git_stream *stream, void *data, size_t len)
+-{
+-	ssize_t ret;
+-	git_socket_stream *st = (git_socket_stream *) stream;
+-
+-	if ((ret = p_recv(st->s, data, len, 0)) < 0)
+-		net_set_error("Error receiving socket data");
+-
+-	return ret;
+-}
+-
+-int socket_close(git_stream *stream)
+-{
+-	git_socket_stream *st = (git_socket_stream *) stream;
+-	int error;
+-
+-	error = close_socket(st->s);
+-	st->s = INVALID_SOCKET;
+-
+-	return error;
+-}
+-
+-void socket_free(git_stream *stream)
+-{
+-	git_socket_stream *st = (git_socket_stream *) stream;
+-
+-	git__free(st->host);
+-	git__free(st->port);
+-	git__free(st);
+-}
+-
+-int git_socket_stream_new(git_stream **out, const char *host, const char *port)
+-{
+-	git_socket_stream *st;
+-
+-	assert(out && host);
+-
+-	st = git__calloc(1, sizeof(git_socket_stream));
+-	GITERR_CHECK_ALLOC(st);
+-
+-	st->host = git__strdup(host);
+-	GITERR_CHECK_ALLOC(st->host);
+-
+-	if (port) {
+-		st->port = git__strdup(port);
+-		GITERR_CHECK_ALLOC(st->port);
+-	}
+-
+-	st->parent.version = GIT_STREAM_VERSION;
+-	st->parent.connect = socket_connect;
+-	st->parent.write = socket_write;
+-	st->parent.read = socket_read;
+-	st->parent.close = socket_close;
+-	st->parent.free = socket_free;
+-	st->s = INVALID_SOCKET;
+-
+-	*out = (git_stream *) st;
+-	return 0;
+-}
+diff --git a/src/socket_stream.h b/src/socket_stream.h
+deleted file mode 100644
+index 8e9949f..0000000
+--- a/src/socket_stream.h
++++ /dev/null
+@@ -1,21 +0,0 @@
+-/*
+- * Copyright (C) the libgit2 contributors. All rights reserved.
+- *
+- * This file is part of libgit2, distributed under the GNU GPL v2 with
+- * a Linking Exception. For full terms see the included COPYING file.
+- */
+-#ifndef INCLUDE_socket_stream_h__
+-#define INCLUDE_socket_stream_h__
+-
+-#include "netops.h"
+-
+-typedef struct {
+-	git_stream parent;
+-	char *host;
+-	char *port;
+-	GIT_SOCKET s;
+-} git_socket_stream;
+-
+-extern int git_socket_stream_new(git_stream **out, const char *host, const char *port);
+-
+-#endif
+diff --git a/src/stransport_stream.c b/src/stransport_stream.c
+deleted file mode 100644
+index 50ed945..0000000
+--- a/src/stransport_stream.c
++++ /dev/null
+@@ -1,294 +0,0 @@
+-/*
+- * Copyright (C) the libgit2 contributors. All rights reserved.
+- *
+- * This file is part of libgit2, distributed under the GNU GPL v2 with
+- * a Linking Exception. For full terms see the included COPYING file.
+- */
+-
+-#ifdef GIT_SECURE_TRANSPORT
+-
+-#include <CoreFoundation/CoreFoundation.h>
+-#include <Security/SecureTransport.h>
+-#include <Security/SecCertificate.h>
+-
+-#include "git2/transport.h"
+-
+-#include "socket_stream.h"
+-#include "curl_stream.h"
+-
+-static int stransport_error(OSStatus ret)
+-{
+-	CFStringRef message;
+-
+-	if (ret == noErr || ret == errSSLClosedGraceful) {
+-		giterr_clear();
+-		return 0;
+-	}
+-
+-#if !TARGET_OS_IPHONE
+-	message = SecCopyErrorMessageString(ret, NULL);
+-	GITERR_CHECK_ALLOC(message);
+-
+-	giterr_set(GITERR_NET, "SecureTransport error: %s", CFStringGetCStringPtr(message, kCFStringEncodingUTF8));
+-	CFRelease(message);
+-#else
+-    giterr_set(GITERR_NET, "SecureTransport error: OSStatus %d", (unsigned int)ret);
+-    GIT_UNUSED(message);
+-#endif
+-
+-	return -1;
+-}
+-
+-typedef struct {
+-	git_stream parent;
+-	git_stream *io;
+-	SSLContextRef ctx;
+-	CFDataRef der_data;
+-	git_cert_x509 cert_info;
+-} stransport_stream;
+-
+-static int stransport_connect(git_stream *stream)
+-{
+-	stransport_stream *st = (stransport_stream *) stream;
+-	int error;
+-	SecTrustRef trust = NULL;
+-	SecTrustResultType sec_res;
+-	OSStatus ret;
+-
+-	if ((error = git_stream_connect(st->io)) < 0)
+-		return error;
+-
+-	ret = SSLHandshake(st->ctx);
+-	if (ret != errSSLServerAuthCompleted) {
+-		giterr_set(GITERR_SSL, "unexpected return value from ssl handshake %d", ret);
+-		return -1;
+-	}
+-
+-	if ((ret = SSLCopyPeerTrust(st->ctx, &trust)) != noErr)
+-		goto on_error;
+-
+-	if (!trust)
+-		return GIT_ECERTIFICATE;
+-
+-	if ((ret = SecTrustEvaluate(trust, &sec_res)) != noErr)
+-		goto on_error;
+-
+-	CFRelease(trust);
+-
+-	if (sec_res == kSecTrustResultInvalid || sec_res == kSecTrustResultOtherError) {
+-		giterr_set(GITERR_SSL, "internal security trust error");
+-		return -1;
+-	}
+-
+-	if (sec_res == kSecTrustResultDeny || sec_res == kSecTrustResultRecoverableTrustFailure ||
+-	    sec_res == kSecTrustResultFatalTrustFailure)
+-		return GIT_ECERTIFICATE;
+-
+-	return 0;
+-
+-on_error:
+-	if (trust)
+-		CFRelease(trust);
+-
+-	return stransport_error(ret);
+-}
+-
+-static int stransport_certificate(git_cert **out, git_stream *stream)
+-{
+-	stransport_stream *st = (stransport_stream *) stream;
+-	SecTrustRef trust = NULL;
+-	SecCertificateRef sec_cert;
+-	OSStatus ret;
+-
+-	if ((ret = SSLCopyPeerTrust(st->ctx, &trust)) != noErr)
+-		return stransport_error(ret);
+-
+-	sec_cert = SecTrustGetCertificateAtIndex(trust, 0);
+-	st->der_data = SecCertificateCopyData(sec_cert);
+-	CFRelease(trust);
+-
+-	if (st->der_data == NULL) {
+-		giterr_set(GITERR_SSL, "retrieved invalid certificate data");
+-		return -1;
+-	}
+-
+-	st->cert_info.parent.cert_type = GIT_CERT_X509;
+-	st->cert_info.data = (void *) CFDataGetBytePtr(st->der_data);
+-	st->cert_info.len = CFDataGetLength(st->der_data);
+-
+-	*out = (git_cert *)&st->cert_info;
+-	return 0;
+-}
+-
+-static int stransport_set_proxy(
+-	git_stream *stream,
+-	const git_proxy_options *proxy_opts)
+-{
+-	stransport_stream *st = (stransport_stream *) stream;
+-
+-	return git_stream_set_proxy(st->io, proxy_opts);
+-}
+-
+-/*
+- * Contrary to typical network IO callbacks, Secure Transport write callback is
+- * expected to write *all* passed data, not just as much as it can, and any
+- * other case would be considered a failure.
+- *
+- * This behavior is actually not specified in the Apple documentation, but is
+- * required for things to work correctly (and incidentally, that's also how
+- * Apple implements it in its projects at opensource.apple.com).
+- *
+- * Libgit2 streams happen to already have this very behavior so this is just
+- * passthrough.
+- */
+-static OSStatus write_cb(SSLConnectionRef conn, const void *data, size_t *len)
+-{
+-	git_stream *io = (git_stream *) conn;
+-
+-	if (git_stream_write(io, data, *len, 0) < 0) {
+-		return -36; /* "ioErr" from MacErrors.h which is not available on iOS */
+-	}
+-
+-	return noErr;
+-}
+-
+-static ssize_t stransport_write(git_stream *stream, const char *data, size_t len, int flags)
+-{
+-	stransport_stream *st = (stransport_stream *) stream;
+-	size_t data_len, processed;
+-	OSStatus ret;
+-
+-	GIT_UNUSED(flags);
+-
+-	data_len = len;
+-	if ((ret = SSLWrite(st->ctx, data, data_len, &processed)) != noErr)
+-		return stransport_error(ret);
+-
+-	return processed;
+-}
+-
+-/*
+- * Contrary to typical network IO callbacks, Secure Transport read callback is
+- * expected to read *exactly* the requested number of bytes, not just as much
+- * as it can, and any other case would be considered a failure.
+- *
+- * This behavior is actually not specified in the Apple documentation, but is
+- * required for things to work correctly (and incidentally, that's also how
+- * Apple implements it in its projects at opensource.apple.com).
+- */
+-static OSStatus read_cb(SSLConnectionRef conn, void *data, size_t *len)
+-{
+-	git_stream *io = (git_stream *) conn;
+-	OSStatus error = noErr;
+-	size_t off = 0;
+-	ssize_t ret;
+-
+-	do {
+-		ret = git_stream_read(io, data + off, *len - off);
+-		if (ret < 0) {
+-			error = -36; /* "ioErr" from MacErrors.h which is not available on iOS */
+-			break;
+-		}
+-		if (ret == 0) {
+-			error = errSSLClosedGraceful;
+-			break;
+-		}
+-
+-		off += ret;
+-	} while (off < *len);
+-
+-	*len = off;
+-	return error;
+-}
+-
+-static ssize_t stransport_read(git_stream *stream, void *data, size_t len)
+-{
+-	stransport_stream *st = (stransport_stream *) stream;
+-	size_t processed;
+-	OSStatus ret;
+-
+-	if ((ret = SSLRead(st->ctx, data, len, &processed)) != noErr)
+-		return stransport_error(ret);
+-
+-	return processed;
+-}
+-
+-static int stransport_close(git_stream *stream)
+-{
+-	stransport_stream *st = (stransport_stream *) stream;
+-	OSStatus ret;
+-
+-	ret = SSLClose(st->ctx);
+-	if (ret != noErr && ret != errSSLClosedGraceful)
+-		return stransport_error(ret);
+-
+-	return git_stream_close(st->io);
+-}
+-
+-static void stransport_free(git_stream *stream)
+-{
+-	stransport_stream *st = (stransport_stream *) stream;
+-
+-	git_stream_free(st->io);
+-	CFRelease(st->ctx);
+-	if (st->der_data)
+-		CFRelease(st->der_data);
+-	git__free(st);
+-}
+-
+-int git_stransport_stream_new(git_stream **out, const char *host, const char *port)
+-{
+-	stransport_stream *st;
+-	int error;
+-	OSStatus ret;
+-
+-	assert(out && host);
+-
+-	st = git__calloc(1, sizeof(stransport_stream));
+-	GITERR_CHECK_ALLOC(st);
+-
+-#ifdef GIT_CURL
+-	error = git_curl_stream_new(&st->io, host, port);
+-#else
+-	error = git_socket_stream_new(&st->io, host, port);
+-#endif
+-
+-	if (error < 0){
+-		git__free(st);
+-		return error;
+-	}
+-
+-	st->ctx = SSLCreateContext(NULL, kSSLClientSide, kSSLStreamType);
+-	if (!st->ctx) {
+-		giterr_set(GITERR_NET, "failed to create SSL context");
+-		git__free(st);
+-		return -1;
+-	}
+-
+-	if ((ret = SSLSetIOFuncs(st->ctx, read_cb, write_cb)) != noErr ||
+-	    (ret = SSLSetConnection(st->ctx, st->io)) != noErr ||
+-	    (ret = SSLSetSessionOption(st->ctx, kSSLSessionOptionBreakOnServerAuth, true)) != noErr ||
+-	    (ret = SSLSetProtocolVersionMin(st->ctx, kTLSProtocol1)) != noErr ||
+-	    (ret = SSLSetProtocolVersionMax(st->ctx, kTLSProtocol12)) != noErr ||
+-	    (ret = SSLSetPeerDomainName(st->ctx, host, strlen(host))) != noErr) {
+-		CFRelease(st->ctx);
+-		git__free(st);
+-		return stransport_error(ret);
+-	}
+-
+-	st->parent.version = GIT_STREAM_VERSION;
+-	st->parent.encrypted = 1;
+-	st->parent.proxy_support = git_stream_supports_proxy(st->io);
+-	st->parent.connect = stransport_connect;
+-	st->parent.certificate = stransport_certificate;
+-	st->parent.set_proxy = stransport_set_proxy;
+-	st->parent.read = stransport_read;
+-	st->parent.write = stransport_write;
+-	st->parent.close = stransport_close;
+-	st->parent.free = stransport_free;
+-
+-	*out = (git_stream *) st;
+-	return 0;
+-}
+-
+-#endif
+diff --git a/src/stransport_stream.h b/src/stransport_stream.h
+deleted file mode 100644
+index 714f902..0000000
+--- a/src/stransport_stream.h
++++ /dev/null
+@@ -1,14 +0,0 @@
+-/*
+- * Copyright (C) the libgit2 contributors. All rights reserved.
+- *
+- * This file is part of libgit2, distributed under the GNU GPL v2 with
+- * a Linking Exception. For full terms see the included COPYING file.
+- */
+-#ifndef INCLUDE_stransport_stream_h__
+-#define INCLUDE_stransport_stream_h__
+-
+-#include "git2/sys/stream.h"
+-
+-extern int git_stransport_stream_new(git_stream **out, const char *host, const char *port);
+-
+-#endif
+diff --git a/src/streams/curl.c b/src/streams/curl.c
+new file mode 100644
+index 0000000..4e0455c
+--- /dev/null
++++ b/src/streams/curl.c
+@@ -0,0 +1,362 @@
++/*
++ * Copyright (C) the libgit2 contributors. All rights reserved.
++ *
++ * This file is part of libgit2, distributed under the GNU GPL v2 with
++ * a Linking Exception. For full terms see the included COPYING file.
++ */
++
++#ifdef GIT_CURL
++
++#include <curl/curl.h>
++
++#include "stream.h"
++#include "git2/transport.h"
++#include "buffer.h"
++#include "vector.h"
++#include "proxy.h"
++
++/* This is for backwards compatibility with curl<7.45.0. */
++#ifndef CURLINFO_ACTIVESOCKET
++# define CURLINFO_ACTIVESOCKET CURLINFO_LASTSOCKET
++# define GIT_CURL_BADSOCKET -1
++# define git_activesocket_t long
++#else
++# define GIT_CURL_BADSOCKET CURL_SOCKET_BAD
++# define git_activesocket_t curl_socket_t
++#endif
++
++typedef struct {
++	git_stream parent;
++	CURL *handle;
++	curl_socket_t socket;
++	char curl_error[CURL_ERROR_SIZE + 1];
++	git_cert_x509 cert_info;
++	git_strarray cert_info_strings;
++	git_proxy_options proxy;
++	git_cred *proxy_cred;
++} curl_stream;
++
++static int seterr_curl(curl_stream *s)
++{
++	giterr_set(GITERR_NET, "curl error: %s\n", s->curl_error);
++	return -1;
++}
++
++GIT_INLINE(int) error_no_credentials(void)
++{
++	giterr_set(GITERR_NET, "proxy authentication required, but no callback provided");
++	return GIT_EAUTH;
++}
++
++static int apply_proxy_creds(curl_stream *s)
++{
++	CURLcode res;
++	git_cred_userpass_plaintext *userpass;
++
++	if (!s->proxy_cred)
++		return GIT_ENOTFOUND;
++
++	userpass = (git_cred_userpass_plaintext *) s->proxy_cred;
++	if ((res = curl_easy_setopt(s->handle, CURLOPT_PROXYUSERNAME, userpass->username)) != CURLE_OK)
++		return seterr_curl(s);
++	if ((res = curl_easy_setopt(s->handle, CURLOPT_PROXYPASSWORD, userpass->password)) != CURLE_OK)
++		return seterr_curl(s);
++
++	return 0;
++}
++
++static int ask_and_apply_proxy_creds(curl_stream *s)
++{
++	int error;
++	git_proxy_options *opts = &s->proxy;
++
++	if (!opts->credentials)
++		return error_no_credentials();
++
++	/* TODO: see if PROXYAUTH_AVAIL helps us here */
++	git_cred_free(s->proxy_cred);
++	s->proxy_cred = NULL;
++	giterr_clear();
++	error = opts->credentials(&s->proxy_cred, opts->url, NULL, GIT_CREDTYPE_USERPASS_PLAINTEXT, opts->payload);
++	if (error == GIT_PASSTHROUGH)
++		return error_no_credentials();
++	if (error < 0) {
++		if (!giterr_last())
++			giterr_set(GITERR_NET, "proxy authentication was aborted by the user");
++		return error;
++	}
++
++	if (s->proxy_cred->credtype != GIT_CREDTYPE_USERPASS_PLAINTEXT) {
++		giterr_set(GITERR_NET, "credentials callback returned invalid credential type");
++		return -1;
++	}
++
++	return apply_proxy_creds(s);
++}
++
++static int curls_connect(git_stream *stream)
++{
++	curl_stream *s = (curl_stream *) stream;
++	git_activesocket_t sockextr;
++	long connect_last = 0;
++	int failed_cert = 0, error;
++	bool retry_connect;
++	CURLcode res;
++
++	/* Apply any credentials we've already established */
++	error = apply_proxy_creds(s);
++	if (error < 0 && error != GIT_ENOTFOUND)
++		return seterr_curl(s);
++
++	do {
++		retry_connect = 0;
++		res = curl_easy_perform(s->handle);
++
++		curl_easy_getinfo(s->handle, CURLINFO_HTTP_CONNECTCODE, &connect_last);
++
++		/* HTTP 407 Proxy Authentication Required */
++		if (connect_last == 407) {
++			if ((error = ask_and_apply_proxy_creds(s)) < 0)
++				return error;
++
++			retry_connect = true;
++		}
++	} while (retry_connect);
++
++	if (res != CURLE_OK && res != CURLE_PEER_FAILED_VERIFICATION)
++		return seterr_curl(s);
++	if (res == CURLE_PEER_FAILED_VERIFICATION)
++		failed_cert = 1;
++
++	if ((res = curl_easy_getinfo(s->handle, CURLINFO_ACTIVESOCKET, &sockextr)) != CURLE_OK) {
++		return seterr_curl(s);
++	}
++
++	if (sockextr == GIT_CURL_BADSOCKET) {
++		giterr_set(GITERR_NET, "curl socket is no longer valid");
++		return -1;
++	}
++
++	s->socket = sockextr;
++
++	if (s->parent.encrypted && failed_cert)
++		return GIT_ECERTIFICATE;
++
++	return 0;
++}
++
++static int curls_certificate(git_cert **out, git_stream *stream)
++{
++	int error;
++	CURLcode res;
++	struct curl_slist *slist;
++	struct curl_certinfo *certinfo;
++	git_vector strings = GIT_VECTOR_INIT;
++	curl_stream *s = (curl_stream *) stream;
++
++	if ((res = curl_easy_getinfo(s->handle, CURLINFO_CERTINFO, &certinfo)) != CURLE_OK)
++		return seterr_curl(s);
++
++	/* No information is available, can happen with SecureTransport */
++	if (certinfo->num_of_certs == 0) {
++		s->cert_info.parent.cert_type = GIT_CERT_NONE;
++		s->cert_info.data             = NULL;
++		s->cert_info.len              = 0;
++		return 0;
++	}
++
++	if ((error = git_vector_init(&strings, 8, NULL)) < 0)
++		return error;
++
++	for (slist = certinfo->certinfo[0]; slist; slist = slist->next) {
++		char *str = git__strdup(slist->data);
++		GITERR_CHECK_ALLOC(str);
++		git_vector_insert(&strings, str);
++	}
++
++	/* Copy the contents of the vector into a strarray so we can expose them */
++	s->cert_info_strings.strings = (char **) strings.contents;
++	s->cert_info_strings.count   = strings.length;
++
++	s->cert_info.parent.cert_type = GIT_CERT_STRARRAY;
++	s->cert_info.data             = &s->cert_info_strings;
++	s->cert_info.len              = strings.length;
++
++	*out = &s->cert_info.parent;
++
++	return 0;
++}
++
++static int curls_set_proxy(git_stream *stream, const git_proxy_options *proxy_opts)
++{
++	int error;
++	CURLcode res;
++	curl_stream *s = (curl_stream *) stream;
++
++	if ((error = git_proxy_options_dup(&s->proxy, proxy_opts)) < 0)
++		return error;
++
++	if ((res = curl_easy_setopt(s->handle, CURLOPT_PROXY, s->proxy.url)) != CURLE_OK)
++		return seterr_curl(s);
++
++	if ((res = curl_easy_setopt(s->handle, CURLOPT_PROXYAUTH, CURLAUTH_ANY)) != CURLE_OK)
++		return seterr_curl(s);
++
++	return 0;
++}
++
++static int wait_for(curl_socket_t fd, bool reading)
++{
++	int ret;
++	fd_set infd, outfd, errfd;
++
++	FD_ZERO(&infd);
++	FD_ZERO(&outfd);
++	FD_ZERO(&errfd);
++
++	assert(fd >= 0);
++	FD_SET(fd, &errfd);
++	if (reading)
++		FD_SET(fd, &infd);
++	else
++		FD_SET(fd, &outfd);
++
++	if ((ret = select(fd + 1, &infd, &outfd, &errfd, NULL)) < 0) {
++		giterr_set(GITERR_OS, "error in select");
++		return -1;
++	}
++
++	return 0;
++}
++
++static ssize_t curls_write(git_stream *stream, const char *data, size_t len, int flags)
++{
++	int error;
++	size_t off = 0, sent;
++	CURLcode res;
++	curl_stream *s = (curl_stream *) stream;
++
++	GIT_UNUSED(flags);
++
++	do {
++		if ((error = wait_for(s->socket, false)) < 0)
++			return error;
++
++		res = curl_easy_send(s->handle, data + off, len - off, &sent);
++		if (res == CURLE_OK)
++			off += sent;
++	} while ((res == CURLE_OK || res == CURLE_AGAIN) && off < len);
++
++	if (res != CURLE_OK)
++		return seterr_curl(s);
++
++	return len;
++}
++
++static ssize_t curls_read(git_stream *stream, void *data, size_t len)
++{
++	int error;
++	size_t read;
++	CURLcode res;
++	curl_stream *s = (curl_stream *) stream;
++
++	do {
++		if ((error = wait_for(s->socket, true)) < 0)
++			return error;
++
++		res = curl_easy_recv(s->handle, data, len, &read);
++	} while (res == CURLE_AGAIN);
++
++	if (res != CURLE_OK)
++		return seterr_curl(s);
++
++	return read;
++}
++
++static int curls_close(git_stream *stream)
++{
++	curl_stream *s = (curl_stream *) stream;
++
++	if (!s->handle)
++		return 0;
++
++	curl_easy_cleanup(s->handle);
++	s->handle = NULL;
++	s->socket = 0;
++
++	return 0;
++}
++
++static void curls_free(git_stream *stream)
++{
++	curl_stream *s = (curl_stream *) stream;
++
++	curls_close(stream);
++	git_strarray_free(&s->cert_info_strings);
++	git__free(s);
++}
++
++int git_curl_stream_new(git_stream **out, const char *host, const char *port)
++{
++	curl_stream *st;
++	CURL *handle;
++	int iport = 0, error;
++
++	st = git__calloc(1, sizeof(curl_stream));
++	GITERR_CHECK_ALLOC(st);
++
++	handle = curl_easy_init();
++	if (handle == NULL) {
++		giterr_set(GITERR_NET, "failed to create curl handle");
++		git__free(st);
++		return -1;
++	}
++
++	if ((error = git__strtol32(&iport, port, NULL, 10)) < 0) {
++		git__free(st);
++		return error;
++	}
++
++	curl_easy_setopt(handle, CURLOPT_URL, host);
++	curl_easy_setopt(handle, CURLOPT_ERRORBUFFER, st->curl_error);
++	curl_easy_setopt(handle, CURLOPT_PORT, iport);
++	curl_easy_setopt(handle, CURLOPT_CONNECT_ONLY, 1);
++	curl_easy_setopt(handle, CURLOPT_SSL_VERIFYPEER, 1);
++	curl_easy_setopt(handle, CURLOPT_CERTINFO, 1);
++	curl_easy_setopt(handle, CURLOPT_HTTPPROXYTUNNEL, 1);
++	curl_easy_setopt(handle, CURLOPT_PROXYAUTH, CURLAUTH_ANY);
++
++	/* curl_easy_setopt(handle, CURLOPT_VERBOSE, 1); */
++
++	st->parent.version = GIT_STREAM_VERSION;
++	st->parent.encrypted = 0; /* we don't encrypt ourselves */
++	st->parent.proxy_support = 1;
++	st->parent.connect = curls_connect;
++	st->parent.certificate = curls_certificate;
++	st->parent.set_proxy = curls_set_proxy;
++	st->parent.read = curls_read;
++	st->parent.write = curls_write;
++	st->parent.close = curls_close;
++	st->parent.free = curls_free;
++	st->handle = handle;
++
++	*out = (git_stream *) st;
++	return 0;
++}
++
++#else
++
++#include "stream.h"
++
++int git_curl_stream_new(git_stream **out, const char *host, const char *port)
++{
++	GIT_UNUSED(out);
++	GIT_UNUSED(host);
++	GIT_UNUSED(port);
++
++	giterr_set(GITERR_NET, "curl is not supported in this version");
++	return -1;
++}
++
++
++#endif
+diff --git a/src/streams/curl.h b/src/streams/curl.h
+new file mode 100644
+index 0000000..283f0fe
+--- /dev/null
++++ b/src/streams/curl.h
+@@ -0,0 +1,14 @@
++/*
++ * Copyright (C) the libgit2 contributors. All rights reserved.
++ *
++ * This file is part of libgit2, distributed under the GNU GPL v2 with
++ * a Linking Exception. For full terms see the included COPYING file.
++ */
++#ifndef INCLUDE_curl_stream_h__
++#define INCLUDE_curl_stream_h__
++
++#include "git2/sys/stream.h"
++
++extern int git_curl_stream_new(git_stream **out, const char *host, const char *port);
++
++#endif
+diff --git a/src/streams/mbedtls.c b/src/streams/mbedtls.c
 new file mode 100644
-index 0000000..98ff808
+index 0000000..0376ee4
 --- /dev/null
-+++ b/src/mbedtls_stream.c
-@@ -0,0 +1,483 @@
++++ b/src/streams/mbedtls.c
+@@ -0,0 +1,538 @@
 +/*
 + * Copyright (C) the libgit2 contributors. All rights reserved.
 + *
@@ -277,26 +2709,26 @@ index 0000000..98ff808
 +
 +#include "global.h"
 +#include "stream.h"
-+#include "socket_stream.h"
++#include "streams/socket.h"
++#include "netops.h"
 +#include "git2/transport.h"
++#include "util.h"
 +
 +#ifdef GIT_CURL
-+# include "curl_stream.h"
++# include "streams/curl.h"
 +#endif
 +
-+#include "mbedtls/config.h"
-+#include <mbedtls/x509.h>
-+#include <mbedtls/x509_crt.h>
++#include <mbedtls/config.h>
++#include <mbedtls/ssl.h>
 +#include <mbedtls/error.h>
-+#include "mbedtls/net.h"
-+#include "mbedtls/debug.h"
-+#include "mbedtls/entropy.h"
-+#include "mbedtls/ctr_drbg.h"
-+#include "mbedtls/error.h"
-+#include "mbedtls/certs.h"
++#include <mbedtls/entropy.h>
++#include <mbedtls/ctr_drbg.h>
 +
 +#ifndef OPENSSLDIR
-+# define OPENSSLDIR              "/usr/lib/ssl"
++//# define OPENSSLDIR
++# define OPENSSLDIR              "/etc/ssl" // Debian
++//# define OPENSSLDIR              "/usr/lib/ssl" //Ubuntu
++//# define OPENSSLDIR              "/usr/local/etc/openssl" // mostly-Darwin
 +#endif
 +#define X509_CERT_DIR            OPENSSLDIR "/certs"
 +#define X509_CERT_FILE           OPENSSLDIR "/cert.pem"
@@ -306,7 +2738,8 @@ index 0000000..98ff808
 +mbedtls_ssl_config *git__ssl_conf;
 +mbedtls_entropy_context *mbedtls_entropy;
 +
-+#define GIT_SSL_DEFAULT_CIPHERS "ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-DSS-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:DHE-DSS-AES256-GCM-SHA384:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA:ECDHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA:DHE-DSS-AES128-SHA256:DHE-DSS-AES256-SHA256:DHE-DSS-AES128-SHA:DHE-DSS-AES256-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA"
++#define GIT_SSL_DEFAULT_CIPHERS "TLS-ECDHE-ECDSA-WITH-AES-128-GCM-SHA256:TLS-ECDHE-RSA-WITH-AES-128-GCM-SHA256:TLS-ECDHE-ECDSA-WITH-AES-256-GCM-SHA384:TLS-ECDHE-RSA-WITH-AES-256-GCM-SHA384:TLS-DHE-RSA-WITH-AES-128-GCM-SHA256:TLS-DHE-DSS-WITH-AES-128-GCM-SHA256:TLS-DHE-RSA-WITH-AES-256-GCM-SHA384:TLS-DHE-DSS-WITH-AES-256-GCM-SHA384:TLS-ECDHE-ECDSA-WITH-AES-128-CBC-SHA256:TLS-ECDHE-RSA-WITH-AES-128-CBC-SHA256:TLS-ECDHE-ECDSA-WITH-AES-128-CBC-SHA:TLS-ECDHE-RSA-WITH-AES-128-CBC-SHA:TLS-ECDHE-ECDSA-WITH-AES-256-CBC-SHA384:TLS-ECDHE-RSA-WITH-AES-256-CBC-SHA384:TLS-ECDHE-ECDSA-WITH-AES-256-CBC-SHA:TLS-ECDHE-RSA-WITH-AES-256-CBC-SHA:TLS-DHE-RSA-WITH-AES-128-CBC-SHA256:TLS-DHE-RSA-WITH-AES-256-CBC-SHA256:TLS-DHE-RSA-WITH-AES-128-CBC-SHA:TLS-DHE-RSA-WITH-AES-256-CBC-SHA:TLS-DHE-DSS-WITH-AES-128-CBC-SHA256:TLS-DHE-DSS-WITH-AES-256-CBC-SHA256:TLS-DHE-DSS-WITH-AES-128-CBC-SHA:TLS-DHE-DSS-WITH-AES-256-CBC-SHA:TLS-RSA-WITH-AES-128-GCM-SHA256:TLS-RSA-WITH-AES-256-GCM-SHA384:TLS-RSA-WITH-AES-128-CBC-SHA256:TLS-RSA-WITH-AES-256-CBC-SHA256:TLS-RSA-WITH-AES-128-CBC-SHA:TLS-RSA-WITH-AES-256-CBC-SHA"
++#define GIT_SSL_DEFAULT_CIPHERS_COUNT 30
 +
 +/**
 + * This function aims to clean-up the SSL context which
@@ -314,565 +2747,1985 @@ index 0000000..98ff808
 + */
 +static void shutdown_ssl(void)
 +{
-+    if (git__ssl_conf) {
-+        mbedtls_x509_crt_free(git__ssl_conf->ca_chain);
-+        git__free(git__ssl_conf->ca_chain);
-+        mbedtls_ctr_drbg_free(git__ssl_conf->p_rng);
-+        git__free(git__ssl_conf->p_rng);
-+        mbedtls_ssl_config_free(git__ssl_conf);
-+        git__free(git__ssl_conf);
-+        git__ssl_conf = NULL;
-+    }
-+    if (mbedtls_entropy) {
-+        mbedtls_entropy_free(mbedtls_entropy);
-+        git__free(mbedtls_entropy);
-+        mbedtls_entropy = NULL;
-+    }
++	if (git__ssl_conf) {
++		mbedtls_x509_crt_free(git__ssl_conf->ca_chain);
++		git__free(git__ssl_conf->ca_chain);
++		mbedtls_ctr_drbg_free(git__ssl_conf->p_rng);
++		git__free(git__ssl_conf->p_rng);
++		mbedtls_ssl_config_free(git__ssl_conf);
++		git__free(git__ssl_conf);
++		git__ssl_conf = NULL;
++	}
++	if (mbedtls_entropy) {
++		mbedtls_entropy_free(mbedtls_entropy);
++		git__free(mbedtls_entropy);
++		mbedtls_entropy = NULL;
++	}
 +}
 +
++int git_mbedtls_set_cert_file(const char *path, int is_dir);
++
 +int git_mbedtls_stream_global_init(void)
 +{
-+    int ret, isdir;
-+    char *crtpath;
-+    struct stat statbuf;
-+    // const int *cipherids;
-+    // const char *ciphers = git_libgit2__ssl_ciphers();
-+
-+    mbedtls_ctr_drbg_context *ctr_drbg;
-+
-+    mbedtls_entropy = git__malloc(sizeof(mbedtls_entropy_context));
-+    mbedtls_entropy_init(mbedtls_entropy);
-+
-+    // Seeding the random number generator
-+    ctr_drbg = git__malloc(sizeof(mbedtls_ctr_drbg_context));
-+    mbedtls_ctr_drbg_init(ctr_drbg);
-+    if (mbedtls_ctr_drbg_seed(ctr_drbg,
-+                mbedtls_entropy_func,
-+                mbedtls_entropy, NULL, 0) != 0) {
-+        mbedtls_ctr_drbg_free(ctr_drbg);
-+        mbedtls_entropy_free(mbedtls_entropy);
-+        git__free(ctr_drbg);
-+        git__free(mbedtls_entropy);
-+        return -1;
-+    }
-+
-+    // configure TLSv1
-+    git__ssl_conf = git__malloc(sizeof(mbedtls_ssl_config));
-+    mbedtls_ssl_config_init(git__ssl_conf);
-+    if ( mbedtls_ssl_config_defaults(git__ssl_conf,
-+                MBEDTLS_SSL_IS_CLIENT,
-+                MBEDTLS_SSL_TRANSPORT_STREAM,
-+                MBEDTLS_SSL_PRESET_DEFAULT ) != 0) {
-+        mbedtls_ctr_drbg_free(ctr_drbg);
-+        git__free(ctr_drbg);
-+        mbedtls_ssl_config_free(git__ssl_conf);
-+        git__free(git__ssl_conf);
-+        git__ssl_conf = NULL;
-+        return -1;
-+    }
-+
-+    mbedtls_ssl_conf_authmode(git__ssl_conf, MBEDTLS_SSL_VERIFY_REQUIRED);
-+    mbedtls_ssl_conf_rng(git__ssl_conf, mbedtls_ctr_drbg_random, ctr_drbg);
-+
-+    // find locations for which CA certificates
-+    isdir = 0;
-+    crtpath = getenv(X509_CERT_FILE_EVP);
-+    ret = crtpath != NULL && stat(crtpath, &statbuf) == 0 && S_ISREG(statbuf.st_mode) ? 0 : 1;
-+    if (ret) {
-+        isdir = 1;
-+        crtpath = getenv(X509_CERT_DIR_EVP);
-+        ret = crtpath != NULL && stat(crtpath, &statbuf) == 0 && S_ISDIR(statbuf.st_mode) ? 0 : 1;
-+    }
-+    if (ret) {
-+        isdir = 0;
-+        crtpath = X509_CERT_FILE;
-+        ret = crtpath != NULL && stat(crtpath, &statbuf) == 0 && S_ISREG(statbuf.st_mode) ? 0 : 1;
-+    }
-+    if (ret) {
-+        isdir = 1;
-+        crtpath = X509_CERT_DIR;
-+        ret = crtpath != NULL && stat(crtpath, &statbuf) == 0 && S_ISDIR(statbuf.st_mode) ? 0 : 1;
-+    }
-+
-+    // cannot find CA certificates
-+    if (ret) {
-+        mbedtls_ctr_drbg_free(ctr_drbg);
-+        git__free(ctr_drbg);
-+        mbedtls_ssl_config_free(git__ssl_conf);
-+        git__free(git__ssl_conf);
-+        git__ssl_conf = NULL;
-+        return -1;
-+    } else {
-+        // set root certificates
-+        mbedtls_x509_crt *cacert = git__malloc(sizeof(mbedtls_x509_crt));
-+        mbedtls_x509_crt_init(cacert);
-+        if (isdir)
-+            ret = mbedtls_x509_crt_parse_path(cacert, crtpath);
-+        else
-+            ret = mbedtls_x509_crt_parse_file(cacert, crtpath);
-+
-+        if (ret) {
-+            giterr_set(GITERR_SSL, "failed to load CA certificates: %d", ret);
-+            mbedtls_x509_crt_free(cacert);
-+            git__free(cacert);
-+            mbedtls_ctr_drbg_free(ctr_drbg);
-+            git__free(ctr_drbg);
-+            mbedtls_ssl_config_free(git__ssl_conf);
-+            git__free(git__ssl_conf);
-+            git__ssl_conf = NULL;
-+            return -1;
-+        } else {
-+            mbedtls_ssl_conf_ca_chain(git__ssl_conf, cacert, NULL);
-+        }
-+    }
-+
-+    // set the list of allowed ciphersuites
-+    // if (!ciphers) {
-+    //     cipherids = mbedtls_ssl_list_ciphersuites();
-+    // }
-+    // mbedtls_ssl_conf_ciphersuites(git__ssl_conf, cipherids);
-+
-+    git__on_shutdown(shutdown_ssl);
++	int found = -1, loaded = 0;
++	char *crtpath;
++	struct stat statbuf;
++	mbedtls_ctr_drbg_context *ctr_drbg = NULL;
 +
-+    return 0;
++	int *ciphers_list = NULL;
++	int ciphers_known = 0;
++	char *cipher_name = NULL;
++	char *cipher_string = NULL;
++	char *cipher_string_tmp = NULL;
++
++	mbedtls_x509_crt *cacert = NULL;
++
++	git__ssl_conf = git__malloc(sizeof(mbedtls_ssl_config));
++	mbedtls_ssl_config_init(git__ssl_conf);
++	if (mbedtls_ssl_config_defaults(git__ssl_conf,
++									MBEDTLS_SSL_IS_CLIENT,
++									MBEDTLS_SSL_TRANSPORT_STREAM,
++									MBEDTLS_SSL_PRESET_DEFAULT) != 0) {
++		giterr_set(GITERR_SSL, "failed to initialize mbedTLS");
++		goto cleanup;
++	}
++
++	// configure TLSv1
++	mbedtls_ssl_conf_min_version(git__ssl_conf, MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0);
++	// verify_server_cert is responsible for making the check.
++	// OPTIONAL because REQUIRED drops the certificate as soon as the check
++	// is made, so we can never see the certificate and override it.
++	mbedtls_ssl_conf_authmode(git__ssl_conf, MBEDTLS_SSL_VERIFY_OPTIONAL);
++
++	// set the list of allowed ciphersuites
++	ciphers_list = calloc(GIT_SSL_DEFAULT_CIPHERS_COUNT, sizeof(int));
++	ciphers_known = 0;
++	cipher_string = cipher_string_tmp = git__strdup(GIT_SSL_DEFAULT_CIPHERS);
++	while ((cipher_name = git__strtok(&cipher_string_tmp, ":")) != NULL) {
++		int cipherid = mbedtls_ssl_get_ciphersuite_id(cipher_name);
++		if (cipherid == 0) continue;
++
++		ciphers_list[ciphers_known++] = cipherid;
++	}
++	git__free(cipher_string);
++
++	if (!ciphers_known) {
++		giterr_set(GITERR_SSL, "no cipher could be enabled");
++		goto cleanup;
++	}
++	mbedtls_ssl_conf_ciphersuites(git__ssl_conf, ciphers_list);
++
++	// Seeding the random number generator
++	mbedtls_entropy = git__malloc(sizeof(mbedtls_entropy_context));
++	mbedtls_entropy_init(mbedtls_entropy);
++
++	ctr_drbg = git__malloc(sizeof(mbedtls_ctr_drbg_context));
++	mbedtls_ctr_drbg_init(ctr_drbg);
++	if (mbedtls_ctr_drbg_seed(ctr_drbg,
++							  mbedtls_entropy_func,
++							  mbedtls_entropy, NULL, 0) != 0) {
++		giterr_set(GITERR_SSL, "failed to initialize mbedTLS entropy pool");
++		goto cleanup;
++	}
++
++	mbedtls_ssl_conf_rng(git__ssl_conf, mbedtls_ctr_drbg_random, ctr_drbg);
++
++	// find locations for which CA certificates
++	{
++		crtpath = getenv(X509_CERT_FILE_EVP);
++		found = crtpath != NULL && stat(crtpath, &statbuf) == 0 && S_ISREG(statbuf.st_mode);
++		if (found)
++			loaded = (git_mbedtls_set_cert_file(crtpath, 0) == 0);
++	}
++	if (!loaded) {
++		crtpath = getenv(X509_CERT_DIR_EVP);
++		found = crtpath != NULL && stat(crtpath, &statbuf) == 0 && S_ISDIR(statbuf.st_mode);
++		if (found)
++			loaded = (git_mbedtls_set_cert_file(crtpath, 1) == 0);
++	}
++	if (!loaded) {
++		crtpath = X509_CERT_FILE;
++		found = crtpath != NULL && stat(crtpath, &statbuf) == 0 && S_ISREG(statbuf.st_mode);
++		if (found)
++			loaded = (git_mbedtls_set_cert_file(crtpath, 0) == 0);
++	}
++	if (!loaded) {
++		crtpath = X509_CERT_DIR;
++		found = crtpath != NULL && stat(crtpath, &statbuf) == 0 && S_ISDIR(statbuf.st_mode);
++		if (found)
++			loaded = (git_mbedtls_set_cert_file(crtpath, 1) == 0);
++	}
++
++	git__on_shutdown(shutdown_ssl);
++
++	return 0;
++
++cleanup:
++	mbedtls_x509_crt_free(cacert);
++	git__free(cacert);
++	mbedtls_ctr_drbg_free(ctr_drbg);
++	git__free(ctr_drbg);
++	mbedtls_ssl_config_free(git__ssl_conf);
++	git__free(git__ssl_conf);
++	git__ssl_conf = NULL;
++
++	return -1;
 +}
 +
++mbedtls_ssl_config *git__ssl_conf;
++
 +static int bio_read(void *b, unsigned char *buf, size_t len)
 +{
-+    git_stream *io = (git_stream *) b;
-+    return (int) git_stream_read(io, buf, len);
++	git_stream *io = (git_stream *) b;
++	return (int) git_stream_read(io, buf, len);
 +}
 +
 +static int bio_write(void *b, const unsigned char *buf, size_t len)
 +{
-+    git_stream *io = (git_stream *) b;
-+    return (int) git_stream_write(io, (const char *)buf, len, 0);
++	git_stream *io = (git_stream *) b;
++	return (int) git_stream_write(io, (const char *)buf, len, 0);
 +}
 +
 +static int ssl_set_error(mbedtls_ssl_context *ssl, int error)
 +{
-+    char errbuf[512];
-+    int ret = -1;
++	char errbuf[512];
++	int ret = -1;
++
++	assert(error != MBEDTLS_ERR_SSL_WANT_READ);
++	assert(error != MBEDTLS_ERR_SSL_WANT_WRITE);
++
++	if (error != 0)
++		mbedtls_strerror( error, errbuf, 512 );
 +
-+    assert(error != MBEDTLS_ERR_SSL_WANT_READ);
-+    assert(error != MBEDTLS_ERR_SSL_WANT_WRITE);
++	switch(error){
++		case 0:
++		giterr_set(GITERR_SSL, "SSL error: unknown error");
++		break;
 +
-+    if (error != 0)
-+        mbedtls_strerror( error, errbuf, 512 );
++	case MBEDTLS_ERR_X509_CERT_VERIFY_FAILED:
++		giterr_set(GITERR_SSL, "SSL error: %x[%x] - %s", error, ssl->session_negotiate->verify_result, errbuf);
++		ret = GIT_ECERTIFICATE;
++		break;
 +
-+    switch(error){
-+    case 0:
-+        giterr_set(GITERR_SSL, "SSL error: unknown error");
-+        break;
-+    case MBEDTLS_ERR_X509_CERT_VERIFY_FAILED:
-+        giterr_set(GITERR_SSL, "SSL error: %x[%x] - %s", error, ssl->session_negotiate->verify_result, errbuf);
-+        ret = GIT_ECERTIFICATE;
-+        break;
-+    default:
-+        giterr_set(GITERR_SSL, "SSL error: %x - %s", error, errbuf);
-+    }
++	default:
++		giterr_set(GITERR_SSL, "SSL error: %x - %s", error, errbuf);
++	}
 +
-+    return ret;
++	return ret;
 +}
 +
 +static int ssl_teardown(mbedtls_ssl_context *ssl)
 +{
-+    int ret = 0;
++	int ret = 0;
 +
-+    ret = mbedtls_ssl_close_notify(ssl);
-+    if (ret < 0)
-+        ret = ssl_set_error(ssl, ret);
++	ret = mbedtls_ssl_close_notify(ssl);
++	if (ret < 0)
++		ret = ssl_set_error(ssl, ret);
 +
-+    mbedtls_ssl_free(ssl);
-+    return ret;
++	mbedtls_ssl_free(ssl);
++	return ret;
 +}
 +
 +static int check_host_name(const char *name, const char *host)
 +{
-+    if (!strcasecmp(name, host))
-+        return 0;
++	if (!strcasecmp(name, host))
++		return 0;
 +
-+    if (gitno__match_host(name, host) < 0)
-+        return -1;
++	if (gitno__match_host(name, host) < 0)
++		return -1;
 +
-+    return 0;
++	return 0;
 +}
 +
 +static int verify_server_cert(mbedtls_ssl_context *ssl, const char *host)
 +{
-+    const mbedtls_x509_crt *cert;
-+    const mbedtls_x509_sequence *alts;
-+    int ret, matched = -1;
-+    size_t sn_size = 512;
-+    char subject_name[sn_size], alt_name[sn_size];
-+
-+
-+    if (( ret = mbedtls_ssl_get_verify_result(ssl) ) != 0) {
-+        char vrfy_buf[512];
-+        mbedtls_x509_crt_verify_info( vrfy_buf, sizeof( vrfy_buf ), "  ! ", ret );
-+        giterr_set(GITERR_SSL, "The SSL certificate is invalid: %s", vrfy_buf);
-+        return GIT_ECERTIFICATE;
-+    }
-+
-+    cert = mbedtls_ssl_get_peer_cert(ssl);
-+    if (!cert) {
-+        giterr_set(GITERR_SSL, "the server did not provide a certificate");
-+        return -1;
-+    }
-+
-+    /* Check the alternative names */
-+    alts = &cert->subject_alt_names;
-+    while (alts != NULL && matched != 1) {
-+        // Buffer is too small
-+        if( alts->buf.len >= sn_size )
-+            goto on_error;
-+
-+        memcpy(alt_name, alts->buf.p, alts->buf.len);
-+        alt_name[alts->buf.len] = '\0';
-+
-+        if (!memchr(alt_name, '\0', alts->buf.len)) {
-+            if (check_host_name(alt_name, host) < 0)
-+                matched = 0;
-+            else
-+                matched = 1;
-+        }
-+
-+        alts = alts->next;
-+    }
-+    if (matched == 0)
-+        goto cert_fail_name;
-+
-+    if (matched == 1)
-+        return 0;
-+
-+    /* If no alternative names are available, check the common name */
-+    ret = mbedtls_x509_dn_gets(subject_name, sn_size, &cert->subject);
-+    if (ret == 0)
-+        goto on_error;
-+    if (memchr(subject_name, '\0', ret))
-+        goto cert_fail_name;
-+
-+    if (check_host_name(subject_name, host) < 0)
-+        goto cert_fail_name;
++	const mbedtls_x509_crt *cert;
++	const mbedtls_x509_sequence *alts;
++	int ret, matched = -1;
++	size_t sn_size = 512;
++	char subject_name[sn_size], alt_name[sn_size];
 +
-+    return 0;
++
++	if ((ret = mbedtls_ssl_get_verify_result(ssl)) != 0) {
++		char vrfy_buf[512];
++		mbedtls_x509_crt_verify_info( vrfy_buf, sizeof( vrfy_buf ), "  ! ", ret );
++		giterr_set(GITERR_SSL, "The SSL certificate is invalid: %s", vrfy_buf);
++		return GIT_ECERTIFICATE;
++	}
++
++	cert = mbedtls_ssl_get_peer_cert(ssl);
++	if (!cert) {
++		giterr_set(GITERR_SSL, "the server did not provide a certificate");
++		return -1;
++	}
++
++	/* Check the alternative names */
++	alts = &cert->subject_alt_names;
++	while (alts != NULL && matched != 1) {
++		// Buffer is too small
++		if( alts->buf.len >= sn_size )
++			goto on_error;
++
++		memcpy(alt_name, alts->buf.p, alts->buf.len);
++		alt_name[alts->buf.len] = '\0';
++
++		if (!memchr(alt_name, '\0', alts->buf.len)) {
++			if (check_host_name(alt_name, host) < 0)
++				matched = 0;
++			else
++				matched = 1;
++		}
++
++		alts = alts->next;
++	}
++	if (matched == 0)
++		goto cert_fail_name;
++
++	if (matched == 1)
++		return 0;
++
++	/* If no alternative names are available, check the common name */
++	ret = mbedtls_x509_dn_gets(subject_name, sn_size, &cert->subject);
++	if (ret == 0)
++		goto on_error;
++	if (memchr(subject_name, '\0', ret))
++		goto cert_fail_name;
++
++	if (check_host_name(subject_name, host) < 0)
++		goto cert_fail_name;
++
++	return 0;
 +
 +on_error:
-+    return ssl_set_error(ssl, 0);
++	return ssl_set_error(ssl, 0);
 +
 +cert_fail_name:
-+    giterr_set(GITERR_SSL, "hostname does not match certificate");
-+    return GIT_ECERTIFICATE;
++	giterr_set(GITERR_SSL, "hostname does not match certificate");
++	return GIT_ECERTIFICATE;
 +}
 +
 +typedef struct {
-+    git_stream parent;
-+    git_stream *io;
-+    bool connected;
-+    char *host;
-+    mbedtls_ssl_context *ssl;
-+    git_cert_x509 cert_info;
++	git_stream parent;
++	git_stream *io;
++	bool connected;
++	char *host;
++	mbedtls_ssl_context *ssl;
++	git_cert_x509 cert_info;
 +} mbedtls_stream;
 +
 +
 +int mbedtls_connect(git_stream *stream)
 +{
-+    int ret;
-+    mbedtls_stream *st = (mbedtls_stream *) stream;
++	int ret;
++	mbedtls_stream *st = (mbedtls_stream *) stream;
 +
-+    if ((ret = git_stream_connect(st->io)) < 0)
-+        return ret;
++	if ((ret = git_stream_connect(st->io)) < 0)
++		return ret;
 +
-+    st->connected = true;
++	st->connected = true;
 +
-+    mbedtls_ssl_set_hostname(st->ssl, st->host);
++	mbedtls_ssl_set_hostname(st->ssl, st->host);
 +
-+    mbedtls_ssl_set_bio(st->ssl, st->io, bio_write, bio_read, NULL);
++	mbedtls_ssl_set_bio(st->ssl, st->io, bio_write, bio_read, NULL);
 +
-+    if ((ret = mbedtls_ssl_handshake(st->ssl)) != 0)
-+        return ssl_set_error(st->ssl, ret);
++	if ((ret = mbedtls_ssl_handshake(st->ssl)) != 0)
++		return ssl_set_error(st->ssl, ret);
 +
-+    return verify_server_cert(st->ssl, st->host);
++	return verify_server_cert(st->ssl, st->host);
 +}
 +
 +int mbedtls_certificate(git_cert **out, git_stream *stream)
 +{
-+    unsigned char *encoded_cert;
-+    mbedtls_stream *st = (mbedtls_stream *) stream;
++	unsigned char *encoded_cert;
++	mbedtls_stream *st = (mbedtls_stream *) stream;
 +
-+    const mbedtls_x509_crt *cert = mbedtls_ssl_get_peer_cert(st->ssl);
-+    if (!cert) {
-+        giterr_set(GITERR_SSL, "the server did not provide a certificate");
-+        return -1;
-+    }
++	const mbedtls_x509_crt *cert = mbedtls_ssl_get_peer_cert(st->ssl);
++	if (!cert) {
++		giterr_set(GITERR_SSL, "the server did not provide a certificate");
++		return -1;
++	}
 +
-+    /* Retrieve the length of the certificate first */
-+    if (cert->raw.len == 0) {
-+        giterr_set(GITERR_NET, "failed to retrieve certificate information");
-+        return -1;
-+    }
++	/* Retrieve the length of the certificate first */
++	if (cert->raw.len == 0) {
++		giterr_set(GITERR_NET, "failed to retrieve certificate information");
++		return -1;
++	}
 +
-+    encoded_cert = git__malloc(cert->raw.len);
-+    GITERR_CHECK_ALLOC(encoded_cert);
-+    memcpy(encoded_cert, cert->raw.p, cert->raw.len);
++	encoded_cert = git__malloc(cert->raw.len);
++	GITERR_CHECK_ALLOC(encoded_cert);
++	memcpy(encoded_cert, cert->raw.p, cert->raw.len);
 +
-+    st->cert_info.parent.cert_type = GIT_CERT_X509;
-+    st->cert_info.data = encoded_cert;
-+    st->cert_info.len = cert->raw.len;
++	st->cert_info.parent.cert_type = GIT_CERT_X509;
++	st->cert_info.data = encoded_cert;
++	st->cert_info.len = cert->raw.len;
 +
-+    *out = &st->cert_info.parent;
++	*out = &st->cert_info.parent;
 +
-+    return 0;
++	return 0;
 +}
 +
-+static int mbedtls_set_proxy(git_stream *stream, const char *proxy_url)
++static int mbedtls_set_proxy(git_stream *stream, const git_proxy_options *proxy_options)
 +{
-+    mbedtls_stream *st = (mbedtls_stream *) stream;
++	mbedtls_stream *st = (mbedtls_stream *) stream;
 +
-+    return git_stream_set_proxy(st->io, proxy_url);
++	return git_stream_set_proxy(st->io, proxy_options);
 +}
 +
 +ssize_t mbedtls_stream_write(git_stream *stream, const char *data, size_t len, int flags)
 +{
-+    mbedtls_stream *st = (mbedtls_stream *) stream;
-+    int ret;
++	size_t read = 0;
++	mbedtls_stream *st = (mbedtls_stream *) stream;
 +
-+    GIT_UNUSED(flags);
++	GIT_UNUSED(flags);
 +
-+    if ((ret = mbedtls_ssl_write(st->ssl, (const unsigned char *)data, len)) <= 0) {
-+        return ssl_set_error(st->ssl, ret);
-+    }
++	do {
++		int error = mbedtls_ssl_write(st->ssl, (const unsigned char *)data + read, len - read);
++		if (error <= 0) {
++			return ssl_set_error(st->ssl, error);
++		}
++		read += error;
++	} while (read < len);
 +
-+    return ret;
++	return read;
 +}
 +
 +ssize_t mbedtls_stream_read(git_stream *stream, void *data, size_t len)
 +{
-+    mbedtls_stream *st = (mbedtls_stream *) stream;
-+    int ret;
++	mbedtls_stream *st = (mbedtls_stream *) stream;
++	int ret;
 +
-+    if ((ret = mbedtls_ssl_read(st->ssl, (unsigned char *)data, len)) <= 0)
-+        ssl_set_error(st->ssl, ret);
++	if ((ret = mbedtls_ssl_read(st->ssl, (unsigned char *)data, len)) <= 0)
++		ssl_set_error(st->ssl, ret);
 +
-+    return ret;
++	return ret;
 +}
 +
 +int mbedtls_stream_close(git_stream *stream)
 +{
-+    mbedtls_stream *st = (mbedtls_stream *) stream;
-+    int ret = 0;
++	mbedtls_stream *st = (mbedtls_stream *) stream;
++	int ret = 0;
 +
-+    if (st->connected && (ret = ssl_teardown(st->ssl)) != 0)
-+        return -1;
++	if (st->connected && (ret = ssl_teardown(st->ssl)) != 0)
++		return -1;
 +
-+    st->connected = false;
++	st->connected = false;
 +
-+    return git_stream_close(st->io);
++	return git_stream_close(st->io);
 +}
 +
 +void mbedtls_stream_free(git_stream *stream)
 +{
-+    mbedtls_stream *st = (mbedtls_stream *) stream;
++	mbedtls_stream *st = (mbedtls_stream *) stream;
 +
-+    git__free(st->host);
-+    git__free(st->cert_info.data);
-+    git_stream_free(st->io);
-+    git__free(st->ssl);
-+    git__free(st);
++	git__free(st->host);
++	git__free(st->cert_info.data);
++	git_stream_free(st->io);
++	git__free(st->ssl);
++	git__free(st);
 +}
 +
 +int git_mbedtls_stream_new(git_stream **out, const char *host, const char *port)
 +{
-+    int error;
-+    mbedtls_stream *st;
++	int error;
++	mbedtls_stream *st;
 +
-+    st = git__calloc(1, sizeof(mbedtls_stream));
-+    GITERR_CHECK_ALLOC(st);
++	st = git__calloc(1, sizeof(mbedtls_stream));
++	GITERR_CHECK_ALLOC(st);
 +
 +#ifdef GIT_CURL
-+    error = git_curl_stream_new(&st->io, host, port);
++	error = git_curl_stream_new(&st->io, host, port);
 +#else
-+    error = git_socket_stream_new(&st->io, host, port);
++	error = git_socket_stream_new(&st->io, host, port);
 +#endif
 +
-+    if (error < 0)
-+        return error;
-+
-+    st->ssl = git__malloc(sizeof(mbedtls_ssl_context));
-+    GITERR_CHECK_ALLOC(st->ssl);
-+    mbedtls_ssl_init(st->ssl);
-+    if( (error = mbedtls_ssl_setup(st->ssl, git__ssl_conf)) != 0 ) {
-+        mbedtls_ssl_free(st->ssl);
-+        giterr_set(GITERR_SSL, "failed to create ssl object");
-+        return -1;
-+    }
-+
-+    st->host = git__strdup(host);
-+    GITERR_CHECK_ALLOC(st->host);
-+
-+    st->parent.version = GIT_STREAM_VERSION;
-+    st->parent.encrypted = 1;
-+    st->parent.proxy_support = git_stream_supports_proxy(st->io);
-+    st->parent.connect = mbedtls_connect;
-+    st->parent.certificate = mbedtls_certificate;
-+    st->parent.set_proxy = mbedtls_set_proxy;
-+    st->parent.read = mbedtls_stream_read;
-+    st->parent.write = mbedtls_stream_write;
-+    st->parent.close = mbedtls_stream_close;
-+    st->parent.free = mbedtls_stream_free;
-+
-+    *out = (git_stream *) st;
-+    return 0;
-+}
++	if (error < 0)
++		goto out_err;
 +
-+#else
++	st->ssl = git__malloc(sizeof(mbedtls_ssl_context));
++	GITERR_CHECK_ALLOC(st->ssl);
++	mbedtls_ssl_init(st->ssl);
++	if (mbedtls_ssl_setup(st->ssl, git__ssl_conf)) {
++		giterr_set(GITERR_SSL, "failed to create ssl object");
++		error = -1;
++		goto out_err;
++	}
 +
-+#include "stream.h"
-+#include "git2/sys/openssl.h"
++	st->host = git__strdup(host);
++	GITERR_CHECK_ALLOC(st->host);
++
++	st->parent.version = GIT_STREAM_VERSION;
++	st->parent.encrypted = 1;
++	st->parent.proxy_support = git_stream_supports_proxy(st->io);
++	st->parent.connect = mbedtls_connect;
++	st->parent.certificate = mbedtls_certificate;
++	st->parent.set_proxy = mbedtls_set_proxy;
++	st->parent.read = mbedtls_stream_read;
++	st->parent.write = mbedtls_stream_write;
++	st->parent.close = mbedtls_stream_close;
++	st->parent.free = mbedtls_stream_free;
++
++	*out = (git_stream *) st;
++	return 0;
++
++out_err:
++	mbedtls_ssl_free(st->ssl);
++	git_stream_free(st->io);
++	git__free(st);
++
++	return error;
++}
++
++int git_mbedtls_set_cert_file(const char *path, int is_dir)
++{
++	int ret = 0;
++	char errbuf[512];
++	mbedtls_x509_crt *cacert;
++
++	assert(path != NULL);
++
++	cacert = git__malloc(sizeof(mbedtls_x509_crt));
++	mbedtls_x509_crt_init(cacert);
++	if (is_dir) {
++		ret = mbedtls_x509_crt_parse_path(cacert, path);
++	} else {
++		ret = mbedtls_x509_crt_parse_file(cacert, path);
++	}
++	// mbedtls_x509_crt_parse_path returns the number of invalid certs on success
++	if (ret <= 0) {
++		mbedtls_x509_crt_free(cacert);
++		git__free(cacert);
++		mbedtls_strerror( ret, errbuf, 512 );
++		giterr_set(GITERR_SSL, "failed to load CA certificates : %s (%d)", errbuf, ret);
++		return -1;
++	}
++
++	mbedtls_x509_crt_free(git__ssl_conf->ca_chain);
++	git__free(git__ssl_conf->ca_chain);
++	mbedtls_ssl_conf_ca_chain(git__ssl_conf, cacert, NULL);
++
++	return 0;
++}
++
++#else
++
++#include "stream.h"
 +
 +int git_mbedtls_stream_global_init(void)
 +{
-+    return 0;
++	return 0;
++}
++
++int git_mbedtls_stream_new(git_stream **out, const char *host, const char *port)
++{
++	GIT_UNUSED(out);
++	GIT_UNUSED(host);
++	GIT_UNUSED(port);
++
++	giterr_set(GITERR_SSL, "mbedTLS is not supported in this version");
++	return -1;
++}
++
++int git_mbedtls_set_cert_file(const char *path, int is_dir)
++{
++	GIT_UNUSED(is_dir);
++
++	giterr_set(GITERR_SSL, "mbedTLS is not supported in this version");
++	return -1;
++}
++
++#endif
+diff --git a/src/streams/mbedtls.h b/src/streams/mbedtls.h
+new file mode 100644
+index 0000000..7501397
+--- /dev/null
++++ b/src/streams/mbedtls.h
+@@ -0,0 +1,18 @@
++/*
++ * Copyright (C) the libgit2 contributors. All rights reserved.
++ *
++ * This file is part of libgit2, distributed under the GNU GPL v2 with
++ * a Linking Exception. For full terms see the included COPYING file.
++ */
++#ifndef INCLUDE_mbedtls_stream_h__
++#define INCLUDE_mbedtls_stream_h__
++
++#include "git2/sys/stream.h"
++
++extern int git_mbedtls_stream_global_init(void);
++
++extern int git_mbedtls_stream_new(git_stream **out, const char *host, const char *port);
++
++extern int git_mbedtls_set_cert_file(const char *path, int is_dir);
++
++#endif
+diff --git a/src/streams/openssl.c b/src/streams/openssl.c
+new file mode 100644
+index 0000000..8668b78
+--- /dev/null
++++ b/src/streams/openssl.c
+@@ -0,0 +1,675 @@
++/*
++ * Copyright (C) the libgit2 contributors. All rights reserved.
++ *
++ * This file is part of libgit2, distributed under the GNU GPL v2 with
++ * a Linking Exception. For full terms see the included COPYING file.
++ */
++
++#ifdef GIT_OPENSSL
++
++#include <ctype.h>
++
++#include "global.h"
++#include "posix.h"
++#include "stream.h"
++#include "streams/socket.h"
++#include "streams/openssl.h"
++#include "netops.h"
++#include "git2/transport.h"
++#include "git2/sys/openssl.h"
++
++#ifdef GIT_CURL
++# include "streams/curl.h"
++#endif
++
++#ifndef GIT_WIN32
++# include <sys/types.h>
++# include <sys/socket.h>
++# include <netinet/in.h>
++#endif
++
++#include <openssl/ssl.h>
++#include <openssl/err.h>
++#include <openssl/x509v3.h>
++#include <openssl/bio.h>
++
++SSL_CTX *git__ssl_ctx;
++
++#define GIT_SSL_DEFAULT_CIPHERS "ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-DSS-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:DHE-DSS-AES256-GCM-SHA384:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA:ECDHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA:DHE-DSS-AES128-SHA256:DHE-DSS-AES256-SHA256:DHE-DSS-AES128-SHA:DHE-DSS-AES256-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA"
++
++#if defined(GIT_THREADS) && OPENSSL_VERSION_NUMBER < 0x10100000L
++
++static git_mutex *openssl_locks;
++
++static void openssl_locking_function(
++	int mode, int n, const char *file, int line)
++{
++	int lock;
++
++	GIT_UNUSED(file);
++	GIT_UNUSED(line);
++
++	lock = mode & CRYPTO_LOCK;
++
++	if (lock) {
++		git_mutex_lock(&openssl_locks[n]);
++	} else {
++		git_mutex_unlock(&openssl_locks[n]);
++	}
++}
++
++static void shutdown_ssl_locking(void)
++{
++	int num_locks, i;
++
++	num_locks = CRYPTO_num_locks();
++	CRYPTO_set_locking_callback(NULL);
++
++	for (i = 0; i < num_locks; ++i)
++		git_mutex_free(&openssl_locks[i]);
++	git__free(openssl_locks);
++}
++
++#endif /* GIT_THREADS && OPENSSL_VERSION_NUMBER < 0x10100000L */
++
++static BIO_METHOD *git_stream_bio_method;
++static int init_bio_method(void);
++
++/**
++ * This function aims to clean-up the SSL context which
++ * we allocated.
++ */
++static void shutdown_ssl(void)
++{
++	if (git_stream_bio_method) {
++		BIO_meth_free(git_stream_bio_method);
++		git_stream_bio_method = NULL;
++	}
++
++	if (git__ssl_ctx) {
++		SSL_CTX_free(git__ssl_ctx);
++		git__ssl_ctx = NULL;
++	}
++}
++
++int git_openssl_stream_global_init(void)
++{
++#ifdef GIT_OPENSSL
++	long ssl_opts = SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3;
++	const char *ciphers = git_libgit2__ssl_ciphers();
++
++	/* Older OpenSSL and MacOS OpenSSL doesn't have this */
++#ifdef SSL_OP_NO_COMPRESSION
++	ssl_opts |= SSL_OP_NO_COMPRESSION;
++#endif
++
++#if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
++	SSL_load_error_strings();
++	OpenSSL_add_ssl_algorithms();
++#else
++	OPENSSL_init_ssl(0, NULL);
++#endif
++
++	/*
++	 * Load SSLv{2,3} and TLSv1 so that we can talk with servers
++	 * which use the SSL hellos, which are often used for
++	 * compatibility. We then disable SSL so we only allow OpenSSL
++	 * to speak TLSv1 to perform the encryption itself.
++	 */
++	git__ssl_ctx = SSL_CTX_new(SSLv23_method());
++	SSL_CTX_set_options(git__ssl_ctx, ssl_opts);
++	SSL_CTX_set_mode(git__ssl_ctx, SSL_MODE_AUTO_RETRY);
++	SSL_CTX_set_verify(git__ssl_ctx, SSL_VERIFY_NONE, NULL);
++	if (!SSL_CTX_set_default_verify_paths(git__ssl_ctx)) {
++		SSL_CTX_free(git__ssl_ctx);
++		git__ssl_ctx = NULL;
++		return -1;
++	}
++
++	if (!ciphers) {
++		ciphers = GIT_SSL_DEFAULT_CIPHERS;
++	}
++
++	if(!SSL_CTX_set_cipher_list(git__ssl_ctx, ciphers)) {
++		SSL_CTX_free(git__ssl_ctx);
++		git__ssl_ctx = NULL;
++		return -1;
++	}
++
++	if (init_bio_method() < 0) {
++		SSL_CTX_free(git__ssl_ctx);
++		git__ssl_ctx = NULL;
++		return -1;
++	}
++
++#endif
++
++	git__on_shutdown(shutdown_ssl);
++
++	return 0;
++}
++
++int git_openssl_set_locking(void)
++{
++#if defined(GIT_THREADS) && OPENSSL_VERSION_NUMBER < 0x10100000L
++	int num_locks, i;
++
++	num_locks = CRYPTO_num_locks();
++	openssl_locks = git__calloc(num_locks, sizeof(git_mutex));
++	GITERR_CHECK_ALLOC(openssl_locks);
++
++	for (i = 0; i < num_locks; i++) {
++		if (git_mutex_init(&openssl_locks[i]) != 0) {
++			giterr_set(GITERR_SSL, "failed to initialize openssl locks");
++			return -1;
++		}
++	}
++
++	CRYPTO_set_locking_callback(openssl_locking_function);
++	git__on_shutdown(shutdown_ssl_locking);
++	return 0;
++#elif OPENSSL_VERSION_NUMBER >= 0x10100000L
++	return 0;
++#else
++	giterr_set(GITERR_THREAD, "libgit2 was not built with threads");
++	return -1;
++#endif
++}
++
++
++static int bio_create(BIO *b)
++{
++	BIO_set_init(b, 1);
++	BIO_set_data(b, NULL);
++
++	return 1;
++}
++
++static int bio_destroy(BIO *b)
++{
++	if (!b)
++		return 0;
++
++	BIO_set_data(b, NULL);
++
++	return 1;
++}
++
++static int bio_read(BIO *b, char *buf, int len)
++{
++	git_stream *io = (git_stream *) BIO_get_data(b);
++
++	return (int) git_stream_read(io, buf, len);
++}
++
++static int bio_write(BIO *b, const char *buf, int len)
++{
++	git_stream *io = (git_stream *) BIO_get_data(b);
++
++	return (int) git_stream_write(io, buf, len, 0);
++}
++
++static long bio_ctrl(BIO *b, int cmd, long num, void *ptr)
++{
++	GIT_UNUSED(b);
++	GIT_UNUSED(num);
++	GIT_UNUSED(ptr);
++
++	if (cmd == BIO_CTRL_FLUSH)
++		return 1;
++
++	return 0;
++}
++
++static int bio_gets(BIO *b, char *buf, int len)
++{
++	GIT_UNUSED(b);
++	GIT_UNUSED(buf);
++	GIT_UNUSED(len);
++	return -1;
++}
++
++static int bio_puts(BIO *b, const char *str)
++{
++	return bio_write(b, str, strlen(str));
++}
++
++static int init_bio_method(void)
++{
++	/* Set up the BIO_METHOD we use for wrapping our own stream implementations */
++	git_stream_bio_method = BIO_meth_new(BIO_TYPE_SOURCE_SINK | BIO_get_new_index(), "git_stream");
++	GITERR_CHECK_ALLOC(git_stream_bio_method);
++
++	BIO_meth_set_write(git_stream_bio_method, bio_write);
++	BIO_meth_set_read(git_stream_bio_method, bio_read);
++	BIO_meth_set_puts(git_stream_bio_method, bio_puts);
++	BIO_meth_set_gets(git_stream_bio_method, bio_gets);
++	BIO_meth_set_ctrl(git_stream_bio_method, bio_ctrl);
++	BIO_meth_set_create(git_stream_bio_method, bio_create);
++	BIO_meth_set_destroy(git_stream_bio_method, bio_destroy);
++
++	return 0;
++}
++
++static int ssl_set_error(SSL *ssl, int error)
++{
++	int err;
++	unsigned long e;
++
++	err = SSL_get_error(ssl, error);
++
++	assert(err != SSL_ERROR_WANT_READ);
++	assert(err != SSL_ERROR_WANT_WRITE);
++
++	switch (err) {
++	case SSL_ERROR_WANT_CONNECT:
++	case SSL_ERROR_WANT_ACCEPT:
++		giterr_set(GITERR_NET, "SSL error: connection failure");
++		break;
++	case SSL_ERROR_WANT_X509_LOOKUP:
++		giterr_set(GITERR_NET, "SSL error: x509 error");
++		break;
++	case SSL_ERROR_SYSCALL:
++		e = ERR_get_error();
++		if (e > 0) {
++			giterr_set(GITERR_NET, "SSL error: %s",
++					ERR_error_string(e, NULL));
++			break;
++		} else if (error < 0) {
++			giterr_set(GITERR_OS, "SSL error: syscall failure");
++			break;
++		}
++		giterr_set(GITERR_NET, "SSL error: received early EOF");
++		return GIT_EEOF;
++		break;
++	case SSL_ERROR_SSL:
++		e = ERR_get_error();
++		giterr_set(GITERR_NET, "SSL error: %s",
++				ERR_error_string(e, NULL));
++		break;
++	case SSL_ERROR_NONE:
++	case SSL_ERROR_ZERO_RETURN:
++	default:
++		giterr_set(GITERR_NET, "SSL error: unknown error");
++		break;
++	}
++	return -1;
++}
++
++static int ssl_teardown(SSL *ssl)
++{
++	int ret;
++
++	ret = SSL_shutdown(ssl);
++	if (ret < 0)
++		ret = ssl_set_error(ssl, ret);
++	else
++		ret = 0;
++
++	return ret;
++}
++
++static int check_host_name(const char *name, const char *host)
++{
++	if (!strcasecmp(name, host))
++		return 0;
++
++	if (gitno__match_host(name, host) < 0)
++		return -1;
++
++	return 0;
++}
++
++static int verify_server_cert(SSL *ssl, const char *host)
++{
++	X509 *cert;
++	X509_NAME *peer_name;
++	ASN1_STRING *str;
++	unsigned char *peer_cn = NULL;
++	int matched = -1, type = GEN_DNS;
++	GENERAL_NAMES *alts;
++	struct in6_addr addr6;
++	struct in_addr addr4;
++	void *addr;
++	int i = -1,j;
++
++	if (SSL_get_verify_result(ssl) != X509_V_OK) {
++		giterr_set(GITERR_SSL, "the SSL certificate is invalid");
++		return GIT_ECERTIFICATE;
++	}
++
++	/* Try to parse the host as an IP address to see if it is */
++	if (p_inet_pton(AF_INET, host, &addr4)) {
++		type = GEN_IPADD;
++		addr = &addr4;
++	} else {
++		if(p_inet_pton(AF_INET6, host, &addr6)) {
++			type = GEN_IPADD;
++			addr = &addr6;
++		}
++	}
++
++
++	cert = SSL_get_peer_certificate(ssl);
++	if (!cert) {
++		giterr_set(GITERR_SSL, "the server did not provide a certificate");
++		return -1;
++	}
++
++	/* Check the alternative names */
++	alts = X509_get_ext_d2i(cert, NID_subject_alt_name, NULL, NULL);
++	if (alts) {
++		int num;
++
++		num = sk_GENERAL_NAME_num(alts);
++		for (i = 0; i < num && matched != 1; i++) {
++			const GENERAL_NAME *gn = sk_GENERAL_NAME_value(alts, i);
++			const char *name = (char *) ASN1_STRING_get0_data(gn->d.ia5);
++			size_t namelen = (size_t) ASN1_STRING_length(gn->d.ia5);
++
++			/* Skip any names of a type we're not looking for */
++			if (gn->type != type)
++				continue;
++
++			if (type == GEN_DNS) {
++				/* If it contains embedded NULs, don't even try */
++				if (memchr(name, '\0', namelen))
++					continue;
++
++				if (check_host_name(name, host) < 0)
++					matched = 0;
++				else
++					matched = 1;
++			} else if (type == GEN_IPADD) {
++				/* Here name isn't so much a name but a binary representation of the IP */
++				matched = !!memcmp(name, addr, namelen);
++			}
++		}
++	}
++	GENERAL_NAMES_free(alts);
++
++	if (matched == 0)
++		goto cert_fail_name;
++
++	if (matched == 1)
++		return 0;
++
++	/* If no alternative names are available, check the common name */
++	peer_name = X509_get_subject_name(cert);
++	if (peer_name == NULL)
++		goto on_error;
++
++	if (peer_name) {
++		/* Get the index of the last CN entry */
++		while ((j = X509_NAME_get_index_by_NID(peer_name, NID_commonName, i)) >= 0)
++			i = j;
++	}
++
++	if (i < 0)
++		goto on_error;
++
++	str = X509_NAME_ENTRY_get_data(X509_NAME_get_entry(peer_name, i));
++	if (str == NULL)
++		goto on_error;
++
++	/* Work around a bug in OpenSSL whereby ASN1_STRING_to_UTF8 fails if it's already in utf-8 */
++	if (ASN1_STRING_type(str) == V_ASN1_UTF8STRING) {
++		int size = ASN1_STRING_length(str);
++
++		if (size > 0) {
++			peer_cn = OPENSSL_malloc(size + 1);
++			GITERR_CHECK_ALLOC(peer_cn);
++			memcpy(peer_cn, ASN1_STRING_get0_data(str), size);
++			peer_cn[size] = '\0';
++		} else {
++			goto cert_fail_name;
++		}
++	} else {
++		int size = ASN1_STRING_to_UTF8(&peer_cn, str);
++		GITERR_CHECK_ALLOC(peer_cn);
++		if (memchr(peer_cn, '\0', size))
++			goto cert_fail_name;
++	}
++
++	if (check_host_name((char *)peer_cn, host) < 0)
++		goto cert_fail_name;
++
++	OPENSSL_free(peer_cn);
++
++	return 0;
++
++on_error:
++	OPENSSL_free(peer_cn);
++	return ssl_set_error(ssl, 0);
++
++cert_fail_name:
++	OPENSSL_free(peer_cn);
++	giterr_set(GITERR_SSL, "hostname does not match certificate");
++	return GIT_ECERTIFICATE;
++}
++
++typedef struct {
++	git_stream parent;
++	git_stream *io;
++	bool connected;
++	char *host;
++	SSL *ssl;
++	git_cert_x509 cert_info;
++} openssl_stream;
++
++int openssl_close(git_stream *stream);
++
++int openssl_connect(git_stream *stream)
++{
++	int ret;
++	BIO *bio;
++	openssl_stream *st = (openssl_stream *) stream;
++
++	if ((ret = git_stream_connect(st->io)) < 0)
++		return ret;
++
++	st->connected = true;
++
++	bio = BIO_new(git_stream_bio_method);
++	GITERR_CHECK_ALLOC(bio);
++
++	BIO_set_data(bio, st->io);
++	SSL_set_bio(st->ssl, bio, bio);
++
++	/* specify the host in case SNI is needed */
++#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
++	SSL_set_tlsext_host_name(st->ssl, st->host);
++#endif
++
++	if ((ret = SSL_connect(st->ssl)) <= 0)
++		return ssl_set_error(st->ssl, ret);
++
++	return verify_server_cert(st->ssl, st->host);
++}
++
++int openssl_certificate(git_cert **out, git_stream *stream)
++{
++	openssl_stream *st = (openssl_stream *) stream;
++	int len;
++	X509 *cert = SSL_get_peer_certificate(st->ssl);
++	unsigned char *guard, *encoded_cert;
++
++	/* Retrieve the length of the certificate first */
++	len = i2d_X509(cert, NULL);
++	if (len < 0) {
++		giterr_set(GITERR_NET, "failed to retrieve certificate information");
++		return -1;
++	}
++
++	encoded_cert = git__malloc(len);
++	GITERR_CHECK_ALLOC(encoded_cert);
++	/* i2d_X509 makes 'guard' point to just after the data */
++	guard = encoded_cert;
++
++	len = i2d_X509(cert, &guard);
++	if (len < 0) {
++		git__free(encoded_cert);
++		giterr_set(GITERR_NET, "failed to retrieve certificate information");
++		return -1;
++	}
++
++	st->cert_info.parent.cert_type = GIT_CERT_X509;
++	st->cert_info.data = encoded_cert;
++	st->cert_info.len = len;
++
++	*out = &st->cert_info.parent;
++
++	return 0;
++}
++
++static int openssl_set_proxy(git_stream *stream, const git_proxy_options *proxy_opts)
++{
++	openssl_stream *st = (openssl_stream *) stream;
++
++	return git_stream_set_proxy(st->io, proxy_opts);
++}
++
++ssize_t openssl_write(git_stream *stream, const char *data, size_t len, int flags)
++{
++	openssl_stream *st = (openssl_stream *) stream;
++	int ret;
++
++	GIT_UNUSED(flags);
++
++	if ((ret = SSL_write(st->ssl, data, len)) <= 0) {
++		return ssl_set_error(st->ssl, ret);
++	}
++
++	return ret;
++}
++
++ssize_t openssl_read(git_stream *stream, void *data, size_t len)
++{
++	openssl_stream *st = (openssl_stream *) stream;
++	int ret;
++
++	if ((ret = SSL_read(st->ssl, data, len)) <= 0)
++		return ssl_set_error(st->ssl, ret);
++
++	return ret;
++}
++
++int openssl_close(git_stream *stream)
++{
++	openssl_stream *st = (openssl_stream *) stream;
++	int ret;
++
++	if (st->connected && (ret = ssl_teardown(st->ssl)) < 0)
++		return -1;
++
++	st->connected = false;
++
++	return git_stream_close(st->io);
++}
++
++void openssl_free(git_stream *stream)
++{
++	openssl_stream *st = (openssl_stream *) stream;
++
++	SSL_free(st->ssl);
++	git__free(st->host);
++	git__free(st->cert_info.data);
++	git_stream_free(st->io);
++	git__free(st);
++}
++
++int git_openssl_stream_new(git_stream **out, const char *host, const char *port)
++{
++	int error;
++	openssl_stream *st;
++
++	st = git__calloc(1, sizeof(openssl_stream));
++	GITERR_CHECK_ALLOC(st);
++
++	st->io = NULL;
++#ifdef GIT_CURL
++	error = git_curl_stream_new(&st->io, host, port);
++#else
++	error = git_socket_stream_new(&st->io, host, port);
++#endif
++
++	if (error < 0)
++		goto out_err;
++
++	st->ssl = SSL_new(git__ssl_ctx);
++	if (st->ssl == NULL) {
++		giterr_set(GITERR_SSL, "failed to create ssl object");
++		error = -1;
++		goto out_err;
++	}
++
++	st->host = git__strdup(host);
++	GITERR_CHECK_ALLOC(st->host);
++
++	st->parent.version = GIT_STREAM_VERSION;
++	st->parent.encrypted = 1;
++	st->parent.proxy_support = git_stream_supports_proxy(st->io);
++	st->parent.connect = openssl_connect;
++	st->parent.certificate = openssl_certificate;
++	st->parent.set_proxy = openssl_set_proxy;
++	st->parent.read = openssl_read;
++	st->parent.write = openssl_write;
++	st->parent.close = openssl_close;
++	st->parent.free = openssl_free;
++
++	*out = (git_stream *) st;
++	return 0;
++
++out_err:
++	git_stream_free(st->io);
++	git__free(st);
++
++	return error;
++}
++
++int git_openssl_set_cert_file(const char *file, const char *path)
++{
++	if (SSL_CTX_load_verify_locations(git__ssl_ctx, file, path) == 0) {
++		giterr_set(GITERR_SSL, "SSL error: %s",
++				   ERR_error_string(ERR_get_error(), NULL));
++		return -1;
++	}
++	return 0;
++}
++
++#else
++
++#include "stream.h"
++#include "git2/sys/openssl.h"
++
++int git_openssl_stream_global_init(void)
++{
++	return 0;
++}
++
++int git_openssl_set_locking(void)
++{
++	giterr_set(GITERR_SSL, "libgit2 was not built with OpenSSL support");
++	return -1;
++}
++
++int git_openssl_stream_new(git_stream **out, const char *host, const char *port)
++{
++	GIT_UNUSED(out);
++	GIT_UNUSED(host);
++	GIT_UNUSED(port);
++
++	giterr_set(GITERR_SSL, "openssl is not supported in this version");
++	return -1;
++}
++
++int git_openssl_set_ca_location(const char *file, const char *path)
++{
++	GIT_UNUSED(file);
++	GIT_UNUSED(path);
++
++	giterr_set(GITERR_SSL, "openssl is not supported in this version");
++	return -1;
++}
++
++#endif
+diff --git a/src/streams/openssl.h b/src/streams/openssl.h
+new file mode 100644
+index 0000000..8c7a84d
+--- /dev/null
++++ b/src/streams/openssl.h
+@@ -0,0 +1,124 @@
++/*
++ * Copyright (C) the libgit2 contributors. All rights reserved.
++ *
++ * This file is part of libgit2, distributed under the GNU GPL v2 with
++ * a Linking Exception. For full terms see the included COPYING file.
++ */
++#ifndef INCLUDE_openssl_stream_h__
++#define INCLUDE_openssl_stream_h__
++
++#include "git2/sys/stream.h"
++
++extern int git_openssl_stream_global_init(void);
++
++extern int git_openssl_stream_new(git_stream **out, const char *host, const char *port);
++
++extern int git_openssl_set_cert_file(const char *file, const char *path);
++
++/*
++ * OpenSSL 1.1 made BIO opaque so we have to use functions to interact with it
++ * which do not exist in previous versions. We define these inline functions so
++ * we can program against the interface instead of littering the implementation
++ * with ifdefs.
++ */
++#ifdef GIT_OPENSSL
++# include <openssl/ssl.h>
++# include <openssl/err.h>
++# include <openssl/x509v3.h>
++# include <openssl/bio.h>
++
++
++
++# if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
++
++GIT_INLINE(BIO_METHOD*) BIO_meth_new(int type, const char *name)
++{
++	BIO_METHOD *meth = git__calloc(1, sizeof(BIO_METHOD));
++	if (!meth) {
++		return NULL;
++	}
++
++	meth->type = type;
++	meth->name = name;
++
++	return meth;
++}
++
++GIT_INLINE(void) BIO_meth_free(BIO_METHOD *biom)
++{
++	git__free(biom);
++}
++
++GIT_INLINE(int) BIO_meth_set_write(BIO_METHOD *biom, int (*write) (BIO *, const char *, int))
++{
++	biom->bwrite = write;
++	return 1;
++}
++
++GIT_INLINE(int) BIO_meth_set_read(BIO_METHOD *biom, int (*read) (BIO *, char *, int))
++{
++	biom->bread = read;
++	return 1;
++}
++
++GIT_INLINE(int) BIO_meth_set_puts(BIO_METHOD *biom, int (*puts) (BIO *, const char *))
++{
++	biom->bputs = puts;
++	return 1;
++}
++
++GIT_INLINE(int) BIO_meth_set_gets(BIO_METHOD *biom, int (*gets) (BIO *, char *, int))
++
++{
++	biom->bgets = gets;
++	return 1;
 +}
 +
-+int git_mbedtls_stream_new(git_stream **out, const char *host, const char *port)
++GIT_INLINE(int) BIO_meth_set_ctrl(BIO_METHOD *biom, long (*ctrl) (BIO *, int, long, void *))
++{
++	biom->ctrl = ctrl;
++	return 1;
++}
++
++GIT_INLINE(int) BIO_meth_set_create(BIO_METHOD *biom, int (*create) (BIO *))
++{
++	biom->create = create;
++	return 1;
++}
++
++GIT_INLINE(int) BIO_meth_set_destroy(BIO_METHOD *biom, int (*destroy) (BIO *))
++{
++	biom->destroy = destroy;
++	return 1;
++}
++
++GIT_INLINE(int) BIO_get_new_index(void)
++{
++	/* This exists as of 1.1 so before we'd just have 0 */
++	return 0;
++}
++
++GIT_INLINE(void) BIO_set_init(BIO *b, int init)
++{
++	b->init = init;
++}
++
++GIT_INLINE(void) BIO_set_data(BIO *a, void *ptr)
++{
++	a->ptr = ptr;
++}
++
++GIT_INLINE(void*) BIO_get_data(BIO *a)
++{
++	return a->ptr;
++}
++
++GIT_INLINE(const unsigned char *) ASN1_STRING_get0_data(const ASN1_STRING *x)
++{
++	return ASN1_STRING_data((ASN1_STRING *)x);
++}
++
++# endif // OpenSSL < 1.1
++#endif // GIT_OPENSSL
++
++#endif
+diff --git a/src/streams/socket.c b/src/streams/socket.c
+new file mode 100644
+index 0000000..1150b40
+--- /dev/null
++++ b/src/streams/socket.c
+@@ -0,0 +1,210 @@
++/*
++ * Copyright (C) the libgit2 contributors. All rights reserved.
++ *
++ * This file is part of libgit2, distributed under the GNU GPL v2 with
++ * a Linking Exception. For full terms see the included COPYING file.
++ */
++
++#include "common.h"
++#include "posix.h"
++#include "netops.h"
++#include "stream.h"
++#include "streams/socket.h"
++
++#ifndef _WIN32
++#	include <sys/types.h>
++#	include <sys/socket.h>
++#	include <sys/select.h>
++#	include <sys/time.h>
++#	include <netdb.h>
++#	include <netinet/in.h>
++#       include <arpa/inet.h>
++#else
++#	include <winsock2.h>
++#	include <ws2tcpip.h>
++#	ifdef _MSC_VER
++#		pragma comment(lib, "ws2_32")
++#	endif
++#endif
++
++#ifdef GIT_WIN32
++static void net_set_error(const char *str)
++{
++	int error = WSAGetLastError();
++	char * win32_error = git_win32_get_error_message(error);
++
++	if (win32_error) {
++		giterr_set(GITERR_NET, "%s: %s", str, win32_error);
++		git__free(win32_error);
++	} else {
++		giterr_set(GITERR_NET, str);
++	}
++}
++#else
++static void net_set_error(const char *str)
 +{
-+    GIT_UNUSED(out);
-+    GIT_UNUSED(host);
-+    GIT_UNUSED(port);
++	giterr_set(GITERR_NET, "%s: %s", str, strerror(errno));
++}
++#endif
++
++static int close_socket(GIT_SOCKET s)
++{
++	if (s == INVALID_SOCKET)
++		return 0;
++
++#ifdef GIT_WIN32
++	if (SOCKET_ERROR == closesocket(s))
++		return -1;
++
++	if (0 != WSACleanup()) {
++		giterr_set(GITERR_OS, "winsock cleanup failed");
++		return -1;
++	}
++
++	return 0;
++#else
++	return close(s);
++#endif
 +
-+    giterr_set(GITERR_SSL, "mbedTLS is not supported in this version");
-+    return -1;
 +}
 +
++int socket_connect(git_stream *stream)
++{
++	struct addrinfo *info = NULL, *p;
++	struct addrinfo hints;
++	git_socket_stream *st = (git_socket_stream *) stream;
++	GIT_SOCKET s = INVALID_SOCKET;
++	int ret;
++
++#ifdef GIT_WIN32
++	/* on win32, the WSA context needs to be initialized
++	 * before any socket calls can be performed */
++	WSADATA wsd;
++
++	if (WSAStartup(MAKEWORD(2,2), &wsd) != 0) {
++		giterr_set(GITERR_OS, "winsock init failed");
++		return -1;
++	}
++
++	if (LOBYTE(wsd.wVersion) != 2 || HIBYTE(wsd.wVersion) != 2) {
++		WSACleanup();
++		giterr_set(GITERR_OS, "winsock init failed");
++		return -1;
++	}
 +#endif
 +
-diff --git a/src/mbedtls_stream.h b/src/mbedtls_stream.h
++	memset(&hints, 0x0, sizeof(struct addrinfo));
++	hints.ai_socktype = SOCK_STREAM;
++	hints.ai_family = AF_UNSPEC;
++
++	if ((ret = p_getaddrinfo(st->host, st->port, &hints, &info)) != 0) {
++		giterr_set(GITERR_NET,
++			   "failed to resolve address for %s: %s", st->host, p_gai_strerror(ret));
++		return -1;
++	}
++
++	for (p = info; p != NULL; p = p->ai_next) {
++		s = socket(p->ai_family, p->ai_socktype, p->ai_protocol);
++
++		if (s == INVALID_SOCKET)
++			continue;
++
++		if (connect(s, p->ai_addr, (socklen_t)p->ai_addrlen) == 0)
++			break;
++
++		/* If we can't connect, try the next one */
++		close_socket(s);
++		s = INVALID_SOCKET;
++	}
++
++	/* Oops, we couldn't connect to any address */
++	if (s == INVALID_SOCKET && p == NULL) {
++		giterr_set(GITERR_OS, "failed to connect to %s", st->host);
++		p_freeaddrinfo(info);
++		return -1;
++	}
++
++	st->s = s;
++	p_freeaddrinfo(info);
++	return 0;
++}
++
++ssize_t socket_write(git_stream *stream, const char *data, size_t len, int flags)
++{
++	ssize_t ret;
++	size_t off = 0;
++	git_socket_stream *st = (git_socket_stream *) stream;
++
++	while (off < len) {
++		errno = 0;
++		ret = p_send(st->s, data + off, len - off, flags);
++		if (ret < 0) {
++			net_set_error("Error sending data");
++			return -1;
++		}
++
++		off += ret;
++	}
++
++	return off;
++}
++
++ssize_t socket_read(git_stream *stream, void *data, size_t len)
++{
++	ssize_t ret;
++	git_socket_stream *st = (git_socket_stream *) stream;
++
++	if ((ret = p_recv(st->s, data, len, 0)) < 0)
++		net_set_error("Error receiving socket data");
++
++	return ret;
++}
++
++int socket_close(git_stream *stream)
++{
++	git_socket_stream *st = (git_socket_stream *) stream;
++	int error;
++
++	error = close_socket(st->s);
++	st->s = INVALID_SOCKET;
++
++	return error;
++}
++
++void socket_free(git_stream *stream)
++{
++	git_socket_stream *st = (git_socket_stream *) stream;
++
++	git__free(st->host);
++	git__free(st->port);
++	git__free(st);
++}
++
++int git_socket_stream_new(git_stream **out, const char *host, const char *port)
++{
++	git_socket_stream *st;
++
++	assert(out && host);
++
++	st = git__calloc(1, sizeof(git_socket_stream));
++	GITERR_CHECK_ALLOC(st);
++
++	st->host = git__strdup(host);
++	GITERR_CHECK_ALLOC(st->host);
++
++	if (port) {
++		st->port = git__strdup(port);
++		GITERR_CHECK_ALLOC(st->port);
++	}
++
++	st->parent.version = GIT_STREAM_VERSION;
++	st->parent.connect = socket_connect;
++	st->parent.write = socket_write;
++	st->parent.read = socket_read;
++	st->parent.close = socket_close;
++	st->parent.free = socket_free;
++	st->s = INVALID_SOCKET;
++
++	*out = (git_stream *) st;
++	return 0;
++}
+diff --git a/src/streams/socket.h b/src/streams/socket.h
 new file mode 100644
-index 0000000..5cb1071
+index 0000000..8e9949f
 --- /dev/null
-+++ b/src/mbedtls_stream.h
-@@ -0,0 +1,16 @@
++++ b/src/streams/socket.h
+@@ -0,0 +1,21 @@
 +/*
 + * Copyright (C) the libgit2 contributors. All rights reserved.
 + *
 + * This file is part of libgit2, distributed under the GNU GPL v2 with
 + * a Linking Exception. For full terms see the included COPYING file.
 + */
-+#ifndef INCLUDE_mbedtls_stream_h__
-+#define INCLUDE_mbedtls_stream_h__
++#ifndef INCLUDE_socket_stream_h__
++#define INCLUDE_socket_stream_h__
 +
-+#include "git2/sys/stream.h"
++#include "netops.h"
 +
-+extern int git_mbedtls_stream_global_init(void);
++typedef struct {
++	git_stream parent;
++	char *host;
++	char *port;
++	GIT_SOCKET s;
++} git_socket_stream;
 +
-+extern int git_mbedtls_stream_new(git_stream **out, const char *host, const char *port);
++extern int git_socket_stream_new(git_stream **out, const char *host, const char *port);
 +
 +#endif
-diff --git a/src/settings.c b/src/settings.c
-index 0da19ea..65bbb41 100644
---- a/src/settings.c
-+++ b/src/settings.c
-@@ -9,6 +9,10 @@
- # include <openssl/err.h>
- #endif
- 
-+#ifdef GIT_MBEDTLS
-+# include <mbedtls/error.h>
+diff --git a/src/streams/stransport.c b/src/streams/stransport.c
+new file mode 100644
+index 0000000..4c099f9
+--- /dev/null
++++ b/src/streams/stransport.c
+@@ -0,0 +1,294 @@
++/*
++ * Copyright (C) the libgit2 contributors. All rights reserved.
++ *
++ * This file is part of libgit2, distributed under the GNU GPL v2 with
++ * a Linking Exception. For full terms see the included COPYING file.
++ */
++
++#ifdef GIT_SECURE_TRANSPORT
++
++#include <CoreFoundation/CoreFoundation.h>
++#include <Security/SecureTransport.h>
++#include <Security/SecCertificate.h>
++
++#include "git2/transport.h"
++
++#include "streams/socket.h"
++#include "streams/curl.h"
++
++static int stransport_error(OSStatus ret)
++{
++	CFStringRef message;
++
++	if (ret == noErr || ret == errSSLClosedGraceful) {
++		giterr_clear();
++		return 0;
++	}
++
++#if !TARGET_OS_IPHONE
++	message = SecCopyErrorMessageString(ret, NULL);
++	GITERR_CHECK_ALLOC(message);
++
++	giterr_set(GITERR_NET, "SecureTransport error: %s", CFStringGetCStringPtr(message, kCFStringEncodingUTF8));
++	CFRelease(message);
++#else
++    giterr_set(GITERR_NET, "SecureTransport error: OSStatus %d", (unsigned int)ret);
++    GIT_UNUSED(message);
 +#endif
 +
- #include <git2.h>
- #include "common.h"
- #include "sysdir.h"
-@@ -29,7 +33,7 @@ int git_libgit2_features()
- #ifdef GIT_THREADS
- 		| GIT_FEATURE_THREADS
- #endif
--#if defined(GIT_OPENSSL) || defined(GIT_WINHTTP) || defined(GIT_SECURE_TRANSPORT)
-+#if defined(GIT_OPENSSL) || defined(GIT_WINHTTP) || defined(GIT_SECURE_TRANSPORT) || defined(GIT_MBEDTLS)
- 		| GIT_FEATURE_HTTPS
- #endif
- #if defined(GIT_SSH)
-@@ -174,8 +178,34 @@ int git_libgit2_opts(int key, ...)
- 				error = -1;
- 			}
- 		}
-+#elif GIT_MBEDTLS
-+		{
-+			const char *file = va_arg(ap, const char *);
-+			const char *path = va_arg(ap, const char *);
-+			int ret = 0;
-+			char errbuf[512];
-+			mbedtls_x509_crt *cacert;
-+			cacert = git__malloc(sizeof(mbedtls_x509_crt));
-+			mbedtls_x509_crt_init(cacert);
-+			if (file) {
-+				ret = mbedtls_x509_crt_parse_file(cacert, file);
-+			} else if (path) {
-+				ret = mbedtls_x509_crt_parse_path(cacert, path);
-+			}
-+			if (!ret) {
-+				mbedtls_x509_crt_free(cacert);
-+				git__free(cacert);
-+				mbedtls_strerror( ret, errbuf, 512 );
-+				giterr_set(GITERR_SSL, "SSL error: failed to load CA certificates : %s (%d)", ret, errbuf);
-+				error = -1;
-+			} else {
-+				mbedtls_x509_crt_free(git__ssl_conf->ca_chain);
-+				git__free(git__ssl_conf->ca_chain);
-+				mbedtls_ssl_conf_ca_chain(git__ssl_conf, cacert, NULL);
-+			}
++	return -1;
++}
++
++typedef struct {
++	git_stream parent;
++	git_stream *io;
++	SSLContextRef ctx;
++	CFDataRef der_data;
++	git_cert_x509 cert_info;
++} stransport_stream;
++
++static int stransport_connect(git_stream *stream)
++{
++	stransport_stream *st = (stransport_stream *) stream;
++	int error;
++	SecTrustRef trust = NULL;
++	SecTrustResultType sec_res;
++	OSStatus ret;
++
++	if ((error = git_stream_connect(st->io)) < 0)
++		return error;
++
++	ret = SSLHandshake(st->ctx);
++	if (ret != errSSLServerAuthCompleted) {
++		giterr_set(GITERR_SSL, "unexpected return value from ssl handshake %d", ret);
++		return -1;
++	}
++
++	if ((ret = SSLCopyPeerTrust(st->ctx, &trust)) != noErr)
++		goto on_error;
++
++	if (!trust)
++		return GIT_ECERTIFICATE;
++
++	if ((ret = SecTrustEvaluate(trust, &sec_res)) != noErr)
++		goto on_error;
++
++	CFRelease(trust);
++
++	if (sec_res == kSecTrustResultInvalid || sec_res == kSecTrustResultOtherError) {
++		giterr_set(GITERR_SSL, "internal security trust error");
++		return -1;
++	}
++
++	if (sec_res == kSecTrustResultDeny || sec_res == kSecTrustResultRecoverableTrustFailure ||
++	    sec_res == kSecTrustResultFatalTrustFailure)
++		return GIT_ECERTIFICATE;
++
++	return 0;
++
++on_error:
++	if (trust)
++		CFRelease(trust);
++
++	return stransport_error(ret);
++}
++
++static int stransport_certificate(git_cert **out, git_stream *stream)
++{
++	stransport_stream *st = (stransport_stream *) stream;
++	SecTrustRef trust = NULL;
++	SecCertificateRef sec_cert;
++	OSStatus ret;
++
++	if ((ret = SSLCopyPeerTrust(st->ctx, &trust)) != noErr)
++		return stransport_error(ret);
++
++	sec_cert = SecTrustGetCertificateAtIndex(trust, 0);
++	st->der_data = SecCertificateCopyData(sec_cert);
++	CFRelease(trust);
++
++	if (st->der_data == NULL) {
++		giterr_set(GITERR_SSL, "retrieved invalid certificate data");
++		return -1;
++	}
++
++	st->cert_info.parent.cert_type = GIT_CERT_X509;
++	st->cert_info.data = (void *) CFDataGetBytePtr(st->der_data);
++	st->cert_info.len = CFDataGetLength(st->der_data);
++
++	*out = (git_cert *)&st->cert_info;
++	return 0;
++}
++
++static int stransport_set_proxy(
++	git_stream *stream,
++	const git_proxy_options *proxy_opts)
++{
++	stransport_stream *st = (stransport_stream *) stream;
++
++	return git_stream_set_proxy(st->io, proxy_opts);
++}
++
++/*
++ * Contrary to typical network IO callbacks, Secure Transport write callback is
++ * expected to write *all* passed data, not just as much as it can, and any
++ * other case would be considered a failure.
++ *
++ * This behavior is actually not specified in the Apple documentation, but is
++ * required for things to work correctly (and incidentally, that's also how
++ * Apple implements it in its projects at opensource.apple.com).
++ *
++ * Libgit2 streams happen to already have this very behavior so this is just
++ * passthrough.
++ */
++static OSStatus write_cb(SSLConnectionRef conn, const void *data, size_t *len)
++{
++	git_stream *io = (git_stream *) conn;
++
++	if (git_stream_write(io, data, *len, 0) < 0) {
++		return -36; /* "ioErr" from MacErrors.h which is not available on iOS */
++	}
++
++	return noErr;
++}
++
++static ssize_t stransport_write(git_stream *stream, const char *data, size_t len, int flags)
++{
++	stransport_stream *st = (stransport_stream *) stream;
++	size_t data_len, processed;
++	OSStatus ret;
++
++	GIT_UNUSED(flags);
++
++	data_len = len;
++	if ((ret = SSLWrite(st->ctx, data, data_len, &processed)) != noErr)
++		return stransport_error(ret);
++
++	return processed;
++}
++
++/*
++ * Contrary to typical network IO callbacks, Secure Transport read callback is
++ * expected to read *exactly* the requested number of bytes, not just as much
++ * as it can, and any other case would be considered a failure.
++ *
++ * This behavior is actually not specified in the Apple documentation, but is
++ * required for things to work correctly (and incidentally, that's also how
++ * Apple implements it in its projects at opensource.apple.com).
++ */
++static OSStatus read_cb(SSLConnectionRef conn, void *data, size_t *len)
++{
++	git_stream *io = (git_stream *) conn;
++	OSStatus error = noErr;
++	size_t off = 0;
++	ssize_t ret;
++
++	do {
++		ret = git_stream_read(io, data + off, *len - off);
++		if (ret < 0) {
++			error = -36; /* "ioErr" from MacErrors.h which is not available on iOS */
++			break;
 +		}
- #else
--		giterr_set(GITERR_NET, "cannot set certificate locations: OpenSSL is not enabled");
-+		giterr_set(GITERR_NET, "Cannot set certificate locations: OpenSSL or mbedTLS is not enabled");
- 		error = -1;
- #endif
- 		break;
++		if (ret == 0) {
++			error = errSSLClosedGraceful;
++			break;
++		}
++
++		off += ret;
++	} while (off < *len);
++
++	*len = off;
++	return error;
++}
++
++static ssize_t stransport_read(git_stream *stream, void *data, size_t len)
++{
++	stransport_stream *st = (stransport_stream *) stream;
++	size_t processed;
++	OSStatus ret;
++
++	if ((ret = SSLRead(st->ctx, data, len, &processed)) != noErr)
++		return stransport_error(ret);
++
++	return processed;
++}
++
++static int stransport_close(git_stream *stream)
++{
++	stransport_stream *st = (stransport_stream *) stream;
++	OSStatus ret;
++
++	ret = SSLClose(st->ctx);
++	if (ret != noErr && ret != errSSLClosedGraceful)
++		return stransport_error(ret);
++
++	return git_stream_close(st->io);
++}
++
++static void stransport_free(git_stream *stream)
++{
++	stransport_stream *st = (stransport_stream *) stream;
++
++	git_stream_free(st->io);
++	CFRelease(st->ctx);
++	if (st->der_data)
++		CFRelease(st->der_data);
++	git__free(st);
++}
++
++int git_stransport_stream_new(git_stream **out, const char *host, const char *port)
++{
++	stransport_stream *st;
++	int error;
++	OSStatus ret;
++
++	assert(out && host);
++
++	st = git__calloc(1, sizeof(stransport_stream));
++	GITERR_CHECK_ALLOC(st);
++
++#ifdef GIT_CURL
++	error = git_curl_stream_new(&st->io, host, port);
++#else
++	error = git_socket_stream_new(&st->io, host, port);
++#endif
++
++	if (error < 0){
++		git__free(st);
++		return error;
++	}
++
++	st->ctx = SSLCreateContext(NULL, kSSLClientSide, kSSLStreamType);
++	if (!st->ctx) {
++		giterr_set(GITERR_NET, "failed to create SSL context");
++		git__free(st);
++		return -1;
++	}
++
++	if ((ret = SSLSetIOFuncs(st->ctx, read_cb, write_cb)) != noErr ||
++	    (ret = SSLSetConnection(st->ctx, st->io)) != noErr ||
++	    (ret = SSLSetSessionOption(st->ctx, kSSLSessionOptionBreakOnServerAuth, true)) != noErr ||
++	    (ret = SSLSetProtocolVersionMin(st->ctx, kTLSProtocol1)) != noErr ||
++	    (ret = SSLSetProtocolVersionMax(st->ctx, kTLSProtocol12)) != noErr ||
++	    (ret = SSLSetPeerDomainName(st->ctx, host, strlen(host))) != noErr) {
++		CFRelease(st->ctx);
++		git__free(st);
++		return stransport_error(ret);
++	}
++
++	st->parent.version = GIT_STREAM_VERSION;
++	st->parent.encrypted = 1;
++	st->parent.proxy_support = git_stream_supports_proxy(st->io);
++	st->parent.connect = stransport_connect;
++	st->parent.certificate = stransport_certificate;
++	st->parent.set_proxy = stransport_set_proxy;
++	st->parent.read = stransport_read;
++	st->parent.write = stransport_write;
++	st->parent.close = stransport_close;
++	st->parent.free = stransport_free;
++
++	*out = (git_stream *) st;
++	return 0;
++}
++
++#endif
+diff --git a/src/streams/stransport.h b/src/streams/stransport.h
+new file mode 100644
+index 0000000..714f902
+--- /dev/null
++++ b/src/streams/stransport.h
+@@ -0,0 +1,14 @@
++/*
++ * Copyright (C) the libgit2 contributors. All rights reserved.
++ *
++ * This file is part of libgit2, distributed under the GNU GPL v2 with
++ * a Linking Exception. For full terms see the included COPYING file.
++ */
++#ifndef INCLUDE_stransport_stream_h__
++#define INCLUDE_stransport_stream_h__
++
++#include "git2/sys/stream.h"
++
++extern int git_stransport_stream_new(git_stream **out, const char *host, const char *port);
++
++#endif
 diff --git a/src/tls_stream.c b/src/tls_stream.c
-index 83e2d06..6fb538f 100644
+index 83e2d06..27e5cc2 100644
 --- a/src/tls_stream.c
 +++ b/src/tls_stream.c
-@@ -9,6 +9,7 @@
+@@ -8,8 +8,9 @@
+ #include "git2/errors.h"
  #include "common.h"
  
- #include "openssl_stream.h"
-+#include "mbedtls_stream.h"
- #include "stransport_stream.h"
+-#include "openssl_stream.h"
+-#include "stransport_stream.h"
++#include "streams/mbedtls.h"
++#include "streams/openssl.h"
++#include "streams/stransport.h"
  
  static git_stream_cb tls_ctor;
+ 
 @@ -30,6 +31,8 @@ int git_tls_stream_new(git_stream **out, const char *host, const char *port)
  	return git_stransport_stream_new(out, host, port);
  #elif defined(GIT_OPENSSL)
  	return git_openssl_stream_new(out, host, port);
 +#elif defined(GIT_MBEDTLS)
-+    return git_mbedtls_stream_new(out, host, port);
++	return git_mbedtls_stream_new(out, host, port);
  #else
  	GIT_UNUSED(out);
  	GIT_UNUSED(host);
+diff --git a/src/transports/git.c b/src/transports/git.c
+index 01edfdc..cae10c3 100644
+--- a/src/transports/git.c
++++ b/src/transports/git.c
+@@ -10,7 +10,7 @@
+ #include "netops.h"
+ #include "git2/sys/transport.h"
+ #include "stream.h"
+-#include "socket_stream.h"
++#include "streams/socket.h"
+ 
+ #define OWNING_SUBTRANSPORT(s) ((git_subtransport *)(s)->parent.subtransport)
+ 
+diff --git a/src/transports/http.c b/src/transports/http.c
+index cb4a6d0..b602adf 100644
+--- a/src/transports/http.c
++++ b/src/transports/http.c
+@@ -16,8 +16,8 @@
+ #include "auth.h"
+ #include "auth_negotiate.h"
+ #include "tls_stream.h"
+-#include "socket_stream.h"
+-#include "curl_stream.h"
++#include "streams/socket.h"
++#include "streams/curl.h"
+ 
+ git_http_auth_scheme auth_schemes[] = {
+ 	{ GIT_AUTHTYPE_NEGOTIATE, "Negotiate", GIT_CREDTYPE_DEFAULT, git_http_auth_negotiate },
+diff --git a/src/transports/ssh.c b/src/transports/ssh.c
+index 4c55e3f..3cb5655 100644
+--- a/src/transports/ssh.c
++++ b/src/transports/ssh.c
+@@ -15,7 +15,7 @@
+ #include "netops.h"
+ #include "smart.h"
+ #include "cred.h"
+-#include "socket_stream.h"
++#include "streams/socket.h"
+ #include "ssh.h"
+ 
+ #ifdef GIT_SSH
 diff --git a/tests/core/stream.c b/tests/core/stream.c
-index 0cbf442..a4fa2b4 100644
+index 0cbf442..2da4b2f 100644
 --- a/tests/core/stream.c
 +++ b/tests/core/stream.c
-@@ -38,7 +38,7 @@ void test_core_stream__register_tls(void)
+@@ -37,8 +37,7 @@ void test_core_stream__register_tls(void)
+ 	 * or when openssl support is disabled (except on OSX
  	 * with Security framework).
  	 */
- #if defined(GIT_WIN32) || \
+-#if defined(GIT_WIN32) || \
 -	(!defined(GIT_SECURE_TRANSPORT) && !defined(GIT_OPENSSL))
-+	(!defined(GIT_SECURE_TRANSPORT) && !(defined(GIT_OPENSSL) || defined(GIT_MBEDTLS)))
++#if defined(GIT_WIN32) || !defined(GIT_HTTPS)
  	cl_git_fail_with(-1, error);
  #else
  	cl_git_pass(error);
-diff --git a/tests/online/badssl.c b/tests/online/badssl.c
-index 66b090d..bba31cc 100644
---- a/tests/online/badssl.c
-+++ b/tests/online/badssl.c
-@@ -4,7 +4,7 @@
+diff --git a/tests/main.c b/tests/main.c
+index f67c8ff..3dadc5d 100644
+--- a/tests/main.c
++++ b/tests/main.c
+@@ -11,7 +11,11 @@ int main(int argc, char *argv[])
  
- static git_repository *g_repo;
+ 	clar_test_init(argc, argv);
+ 
+-	git_libgit2_init();
++	res = git_libgit2_init();
++	if (res < 0) {
++		return res;
++	}
++
+ 	cl_global_trace_register();
+ 	cl_sandbox_set_search_path_defaults();
  
--#if defined(GIT_OPENSSL) || defined(GIT_WINHTTP) || defined(GIT_SECURE_TRANSPORT)
-+#if defined(GIT_OPENSSL) || defined(GIT_WINHTTP) || defined(GIT_SECURE_TRANSPORT) || defined(GIT_MBEDTLS)
- static bool g_has_ssl = true;
- #else
- static bool g_has_ssl = false;
diff --git a/deps/patches/llvm-3.3.patch b/deps/patches/llvm-3.3.patch
deleted file mode 100644
index d46b6e6f266820..00000000000000
--- a/deps/patches/llvm-3.3.patch
+++ /dev/null
@@ -1,597 +0,0 @@
-diff -u -r -N llvm-3.3.src/lib/Support/Host.cpp llvm-3.3/lib/Support/Host.cpp
---- llvm-3.3.src/lib/Support/Host.cpp	2013-05-04 02:36:23.000000000 -0500
-+++ llvm-3.3/lib/Support/Host.cpp	2014-06-05 15:08:41.975312974 -0500
-@@ -52,8 +52,54 @@
- 
- /// GetX86CpuIDAndInfo - Execute the specified cpuid and return the 4 values in the
- /// specified arguments.  If we can't run cpuid on the host, return true.
--static bool GetX86CpuIDAndInfo(unsigned value, unsigned *rEAX,
--                            unsigned *rEBX, unsigned *rECX, unsigned *rEDX) {
-+static bool GetX86CpuIDAndInfo(unsigned value, unsigned *rEAX, unsigned *rEBX,
-+                               unsigned *rECX, unsigned *rEDX) {
-+#if defined(__GNUC__) || defined(__clang__)
-+  #if defined(__x86_64__) || defined(_M_AMD64) || defined (_M_X64)
-+    // gcc doesn't know cpuid would clobber ebx/rbx. Preseve it manually.
-+    asm ("movq\t%%rbx, %%rsi\n\t"
-+         "cpuid\n\t"
-+         "xchgq\t%%rbx, %%rsi\n\t"
-+         : "=a" (*rEAX),
-+           "=S" (*rEBX),
-+           "=c" (*rECX),
-+           "=d" (*rEDX)
-+         :  "a" (value));
-+    return false;
-+  #elif defined(i386) || defined(__i386__) || defined(__x86__) || defined(_M_IX86)
-+    asm ("movl\t%%ebx, %%esi\n\t"
-+         "cpuid\n\t"
-+         "xchgl\t%%ebx, %%esi\n\t"
-+         : "=a" (*rEAX),
-+           "=S" (*rEBX),
-+           "=c" (*rECX),
-+           "=d" (*rEDX)
-+         :  "a" (value));
-+    return false;
-+// pedantic #else returns to appease -Wunreachable-code (so we don't generate
-+// postprocessed code that looks like "return true; return false;")
-+  #else
-+    return true;
-+  #endif
-+#elif defined(_MSC_VER)
-+  // The MSVC intrinsic is portable across x86 and x64.
-+  int registers[4];
-+  __cpuid(registers, value);
-+  *rEAX = registers[0];
-+  *rEBX = registers[1];
-+  *rECX = registers[2];
-+  *rEDX = registers[3];
-+  return false;
-+#else
-+  return true;
-+#endif
-+}
-+
-+/// GetX86CpuIDAndInfoEx - Execute the specified cpuid with subleaf and return the
-+/// 4 values in the specified arguments.  If we can't run cpuid on the host,
-+/// return true.
-+bool GetX86CpuIDAndInfoEx(unsigned value, unsigned subleaf, unsigned *rEAX,
-+                          unsigned *rEBX, unsigned *rECX, unsigned *rEDX) {
- #if defined(__x86_64__) || defined(_M_AMD64) || defined (_M_X64)
-   #if defined(__GNUC__)
-     // gcc doesn't know cpuid would clobber ebx/rbx. Preseve it manually.
-@@ -64,16 +110,22 @@
-            "=S" (*rEBX),
-            "=c" (*rECX),
-            "=d" (*rEDX)
--         :  "a" (value));
-+         :  "a" (value),
-+            "c" (subleaf));
-     return false;
-   #elif defined(_MSC_VER)
--    int registers[4];
--    __cpuid(registers, value);
--    *rEAX = registers[0];
--    *rEBX = registers[1];
--    *rECX = registers[2];
--    *rEDX = registers[3];
--    return false;
-+    // __cpuidex was added in MSVC++ 9.0 SP1
-+    #if (_MSC_VER > 1500) || (_MSC_VER == 1500 && _MSC_FULL_VER >= 150030729)
-+      int registers[4];
-+      __cpuidex(registers, value, subleaf);
-+      *rEAX = registers[0];
-+      *rEBX = registers[1];
-+      *rECX = registers[2];
-+      *rEDX = registers[3];
-+      return false;
-+    #else
-+      return true;
-+    #endif
-   #else
-     return true;
-   #endif
-@@ -86,11 +138,13 @@
-            "=S" (*rEBX),
-            "=c" (*rECX),
-            "=d" (*rEDX)
--         :  "a" (value));
-+         :  "a" (value),
-+            "c" (subleaf));
-     return false;
-   #elif defined(_MSC_VER)
-     __asm {
-       mov   eax,value
-+      mov   ecx,subleaf
-       cpuid
-       mov   esi,rEAX
-       mov   dword ptr [esi],eax
-@@ -102,8 +156,6 @@
-       mov   dword ptr [esi],edx
-     }
-     return false;
--// pedantic #else returns to appease -Wunreachable-code (so we don't generate
--// postprocessed code that looks like "return true; return false;")
-   #else
-     return true;
-   #endif
-@@ -148,21 +200,27 @@
-   unsigned Model  = 0;
-   DetectX86FamilyModel(EAX, Family, Model);
- 
-+  union {
-+    unsigned u[3];
-+    char     c[12];
-+  } text;
-+
-+  GetX86CpuIDAndInfo(0, &EAX, text.u+0, text.u+2, text.u+1);
-+
-+  unsigned MaxLeaf = EAX;
-   bool HasSSE3 = (ECX & 0x1);
-+  bool HasSSE41 = (ECX & 0x80000);
-   // If CPUID indicates support for XSAVE, XRESTORE and AVX, and XGETBV 
-   // indicates that the AVX registers will be saved and restored on context
-   // switch, then we have full AVX support.
-   const unsigned AVXBits = (1 << 27) | (1 << 28);
-   bool HasAVX = ((ECX & AVXBits) == AVXBits) && OSHasAVXSupport();
-+  bool HasAVX2 = HasAVX && MaxLeaf >= 0x7 &&
-+                 !GetX86CpuIDAndInfoEx(0x7, 0x0, &EAX, &EBX, &ECX, &EDX) &&
-+                 (EBX & 0x20);
-   GetX86CpuIDAndInfo(0x80000001, &EAX, &EBX, &ECX, &EDX);
-   bool Em64T = (EDX >> 29) & 0x1;
- 
--  union {
--    unsigned u[3];
--    char     c[12];
--  } text;
--
--  GetX86CpuIDAndInfo(0, &EAX, text.u+0, text.u+2, text.u+1);
-   if (memcmp(text.c, "GenuineIntel", 12) == 0) {
-     switch (Family) {
-     case 3:
-@@ -244,7 +302,8 @@
-                // 17h. All processors are manufactured using the 45 nm process.
-                //
-                // 45nm: Penryn , Wolfdale, Yorkfield (XE)
--        return "penryn";
-+        // Not all Penryn processors support SSE 4.1 (such as the Pentium brand)
-+        return HasSSE41 ? "penryn" : "core2";
- 
-       case 26: // Intel Core i7 processor and Intel Xeon processor. All
-                // processors are manufactured using the 45 nm process.
-@@ -269,10 +328,20 @@
- 
-       // Ivy Bridge:
-       case 58:
-+      case 62: // Ivy Bridge EP
-         // Not all Ivy Bridge processors support AVX (such as the Pentium
-         // versions instead of the i7 versions).
-         return HasAVX ? "core-avx-i" : "corei7";
- 
-+      // Haswell:
-+      case 60:
-+      case 63:
-+      case 69:
-+      case 70:
-+        // Not all Haswell processors support AVX too (such as the Pentium
-+        // versions instead of the i7 versions).
-+        return HasAVX2 ? "core-avx2" : "corei7";
-+
-       case 28: // Most 45 nm Intel Atom processors
-       case 38: // 45 nm Atom Lincroft
-       case 39: // 32 nm Atom Medfield
-diff -u -r -N llvm-3.3.src/lib/Transforms/Vectorize/SLPVectorizer.cpp llvm-3.3/lib/Transforms/Vectorize/SLPVectorizer.cpp
---- llvm-3.3.src/lib/Transforms/Vectorize/SLPVectorizer.cpp	2013-04-30 16:04:51.000000000 -0500
-+++ llvm-3.3/lib/Transforms/Vectorize/SLPVectorizer.cpp	2014-04-15 16:26:12.200527154 -0500
-@@ -19,6 +19,7 @@
- #define DEBUG_TYPE SV_NAME
- 
- #include "VecUtils.h"
-+#include "llvm/ADT/SmallSet.h"
- #include "llvm/Transforms/Vectorize.h"
- #include "llvm/Analysis/AliasAnalysis.h"
- #include "llvm/Analysis/ScalarEvolution.h"
-@@ -128,7 +129,7 @@
-   bool tryToVectorizePair(Value *A, Value *B,  BoUpSLP &R);
- 
-   /// \brief Try to vectorize a list of operands.
--  bool tryToVectorizeList(ArrayRef<Value *> VL, BoUpSLP &R);
-+  bool tryToVectorizeList(ArrayRef<Value *> VL, BoUpSLP &R, InsertElementInst *IE = 0);
- 
-   /// \brief Try to vectorize a chain that may start at the operands of \V;
-   bool tryToVectorize(BinaryOperator *V,  BoUpSLP &R);
-@@ -179,7 +180,7 @@
-   return tryToVectorizeList(VL, R);
- }
- 
--bool SLPVectorizer::tryToVectorizeList(ArrayRef<Value *> VL, BoUpSLP &R) {
-+bool SLPVectorizer::tryToVectorizeList(ArrayRef<Value *> VL, BoUpSLP &R, InsertElementInst *IE) {
-   DEBUG(dbgs()<<"SLP: Vectorizing a list of length = " << VL.size() << ".\n");
- 
-   // Check that all of the parts are scalar.
-@@ -191,10 +192,12 @@
- 
-   int Cost = R.getTreeCost(VL);
-   int ExtrCost = R.getScalarizationCost(VL);
--  DEBUG(dbgs()<<"SLP: Cost of pair:" << Cost <<
-+  DEBUG(dbgs()<<"SLP: Cost of list:" << Cost <<
-         " Cost of extract:" << ExtrCost << ".\n");
-   if ((Cost+ExtrCost) >= -SLPCostThreshold) return false;
--  DEBUG(dbgs()<<"SLP: Vectorizing pair.\n");
-+  DEBUG(dbgs()<<"SLP: Vectorizing list.\n");
-+  if (IE)
-+    R.movePrematureInserts(VL,IE);
-   R.vectorizeArith(VL);
-   return true;
- }
-@@ -237,9 +240,49 @@
-   return 0;
- }
- 
-+/// \brief Recognize construction of vectors like
-+///  %ra = insertelement <4 x float> undef, float %s0, i32 0
-+///  %rb = insertelement <4 x float> %ra, float %s1, i32 1
-+///  %rc = insertelement <4 x float> %rb, float %s2, i32 2
-+///  %rd = insertelement <4 x float> %rc, float %s3, i32 3
-+///
-+/// Returns true if it matches.  Sets \p Ops to the values inserted
-+/// and \p Inserts to the insertelement instructions.
-+///
-+static bool findBuildVector(InsertElementInst *IE,
-+                            SmallVectorImpl<Value *> &Ops) {
-+  if (!isa<UndefValue>(IE->getOperand(0)))
-+    return false;
-+
-+  while (true) {
-+    Ops.push_back(IE->getOperand(1));
-+
-+    if (IE->use_empty())
-+      return false;
-+
-+    InsertElementInst *NextUse = dyn_cast<InsertElementInst>(IE->use_back());
-+    if (!NextUse)
-+      return true;
-+
-+    // If this isn't the final use, make sure the next insertelement is the only
-+    // use. It's OK if the final constructed vector is used multiple times
-+    if (!IE->hasOneUse())
-+      return false;
-+
-+    IE = NextUse;
-+  }
-+
-+  return false;
-+}
-+
- bool SLPVectorizer::vectorizeReductions(BasicBlock *BB, BoUpSLP &R) {
-   bool Changed = false;
-+  SmallSet<Value *, 16> VisitedInstrs;
-   for (BasicBlock::iterator it = BB->begin(), e = BB->end(); it != e; ++it) {
-+    // We may go through BB multiple times so skip the one we have checked.
-+    if (!VisitedInstrs.insert(it))
-+      continue;
-+
-     if (isa<DbgInfoIntrinsic>(it)) continue;
- 
-     // Try to vectorize reductions that use PHINodes.
-@@ -271,6 +314,21 @@
-           Changed |= tryToVectorizePair(BI->getOperand(0), BI->getOperand(1), R);
-       continue;
-     }
-+
-+    // Try to vectorize trees that start at insertelement instructions.
-+    if (InsertElementInst *IE = dyn_cast<InsertElementInst>(it)) {
-+      SmallVector<Value *, 8> Ops;
-+      if (!findBuildVector(IE, Ops))
-+        continue;
-+
-+      if (tryToVectorizeList(Ops, R, IE)) {
-+        Changed = true;
-+        it = BB->begin();
-+        e = BB->end();
-+      }
-+
-+      continue;
-+    }
-   }
- 
-   return Changed;
-diff -u -r -N llvm-3.3.src/lib/Transforms/Vectorize/VecUtils.cpp llvm-3.3/lib/Transforms/Vectorize/VecUtils.cpp
---- llvm-3.3.src/lib/Transforms/Vectorize/VecUtils.cpp	2013-04-21 03:05:59.000000000 -0500
-+++ llvm-3.3/lib/Transforms/Vectorize/VecUtils.cpp	2014-04-15 17:44:02.710904964 -0500
-@@ -243,7 +243,8 @@
-   LaneMap.clear();
-   MultiUserVals.clear();
-   MustScalarize.clear();
--
-+  AllScalarized = true;
-+ 
-   // Scan the tree and find which value is used by which lane, and which values
-   // must be scalarized.
-   getTreeUses_rec(VL, 0);
-@@ -275,7 +276,8 @@
-   }
- 
-   // Now calculate the cost of vectorizing the tree.
--  return getTreeCost_rec(VL, 0);
-+  int treeCost = getTreeCost_rec(VL, 0);
-+  return AllScalarized ? max_cost : treeCost;
- }
- 
- void BoUpSLP::getTreeUses_rec(ArrayRef<Value *> VL, unsigned Depth) {
-@@ -380,6 +382,55 @@
-   }
- }
- 
-+#ifndef NDEBUG
-+/// \returns The opcode if all of the Instructions in \p VL have the same
-+/// opcode, or zero.
-+static unsigned getSameOpcode(ArrayRef<Value *> VL) {
-+  Instruction *I0 = dyn_cast<Instruction>(VL[0]);
-+  if (!I0)
-+    return 0;
-+  unsigned Opcode = I0->getOpcode();
-+  for (int i = 1, e = VL.size(); i < e; i++) {
-+    Instruction *I = dyn_cast<Instruction>(VL[i]);
-+    if (!I || Opcode != I->getOpcode())
-+      return 0;
-+  }
-+  return Opcode;
-+}
-+#endif /*NDEBUG*/
-+
-+/// \returns True if the ExtractElement instructions in VL can be vectorized
-+/// to use the original vector.
-+static bool CanReuseExtract(ArrayRef<Value *> VL) {
-+  assert(Instruction::ExtractElement == getSameOpcode(VL) && "Invalid opcode");
-+  // Check if all of the extracts come from the same vector and from the
-+  // correct offset.
-+  Value *VL0 = VL[0];
-+  ExtractElementInst *E0 = cast<ExtractElementInst>(VL0);
-+  Value *Vec = E0->getOperand(0);
-+
-+  // We have to extract from the same vector type.
-+  unsigned NElts = Vec->getType()->getVectorNumElements();
-+
-+  if (NElts != VL.size())
-+    return false;
-+
-+  // Check that all of the indices extract from the correct offset.
-+  ConstantInt *CI = dyn_cast<ConstantInt>(E0->getOperand(1));
-+  if (!CI || CI->getZExtValue())
-+    return false;
-+
-+  for (unsigned i = 1, e = VL.size(); i < e; ++i) {
-+    ExtractElementInst *E = cast<ExtractElementInst>(VL[i]);
-+    ConstantInt *CI = dyn_cast<ConstantInt>(E->getOperand(1));
-+
-+    if (!CI || CI->getZExtValue() != i || E->getOperand(0) != Vec)
-+      return false;
-+  }
-+
-+  return true;
-+}
-+
- int BoUpSLP::getTreeCost_rec(ArrayRef<Value *> VL, unsigned Depth) {
-   Type *ScalarTy = VL[0]->getType();
- 
-@@ -457,6 +508,20 @@
-   }
- 
-   switch (Opcode) {
-+  case Instruction::ExtractElement: { 
-+    if (CanReuseExtract(VL)) {
-+      int DeadCost = 0;
-+      for (unsigned i = 0, e = VL.size(); i < e; ++i) {
-+        ExtractElementInst *E = cast<ExtractElementInst>(VL[i]);
-+        if (E->hasOneUse())
-+          // Take credit for instruction that will become dead.
-+          DeadCost += TTI->getVectorInstrCost(Instruction::ExtractElement, VecTy, i);
-+      }
-+      DEBUG(dbgs() << "SLP: taking credit of " << -DeadCost << "\n");
-+      return -DeadCost;
-+    }
-+    return getScalarizationCost(VecTy);
-+  }
-   case Instruction::ZExt:
-   case Instruction::SExt:
-   case Instruction::FPToUI:
-@@ -490,6 +555,7 @@
-     VectorType *SrcVecTy = VectorType::get(SrcTy, VL.size());
-     int VecCost = TTI->getCastInstrCost(VL0->getOpcode(), VecTy, SrcVecTy);
-     Cost += (VecCost - ScalarCost);
-+    AllScalarized = false;
-     return Cost;
-   }
-   case Instruction::Add:
-@@ -528,6 +594,7 @@
- 
-     int VecCost = TTI->getArithmeticInstrCost(Opcode, VecTy);
-     Cost += (VecCost - ScalarCost);
-+    AllScalarized = false;
-     return Cost;
-   }
-   case Instruction::Load: {
-@@ -540,6 +607,7 @@
-     int ScalarLdCost = VecTy->getNumElements() *
-       TTI->getMemoryOpCost(Instruction::Load, ScalarTy, 1, 0);
-     int VecLdCost = TTI->getMemoryOpCost(Instruction::Load, ScalarTy, 1, 0);
-+    AllScalarized = false;
-     return VecLdCost - ScalarLdCost;
-   }
-   case Instruction::Store: {
-@@ -556,6 +624,7 @@
-     }
- 
-     int TotalCost = StoreCost + getTreeCost_rec(Operands, Depth + 1);
-+    AllScalarized = false;
-     return TotalCost;
-   }
-   default:
-@@ -630,6 +699,16 @@
-   }
- 
-   switch (Opcode) {
-+  case Instruction::ExtractElement: {
-+    Value *S;
-+    if (CanReuseExtract(VL) ) {
-+      S = VL0->getOperand(0);
-+    } else {
-+      S = Scalarize(VL, VecTy);
-+    }
-+    VectorizedValues[VL0] = S;
-+    return S;
-+  }
-   case Instruction::ZExt:
-   case Instruction::SExt:
-   case Instruction::FPToUI:
-@@ -727,4 +806,32 @@
-   }
- }
- 
-+void BoUpSLP::movePrematureInserts(ArrayRef<Value *> VL, InsertElementInst *IE) {
-+  Instruction *VL0 = cast<Instruction>(VL[0]);
-+  int MyLastIndex = InstrIdx[VL0];
-+  for (unsigned i = 1, e = VL.size(); i < e; ++i )
-+    MyLastIndex = std::max(MyLastIndex, InstrIdx[VL[i]]);
-+  BasicBlock *BB = cast<Instruction>(VL0)->getParent();
-+  bool moved = false;
-+  DEBUG(dbgs() << "SLP: Moving premature inserts\n");
-+  Instruction* x = InstrVec[MyLastIndex];
-+  while (IE->getParent()==BB) {
-+    int UserIndex = InstrIdx[IE];
-+    if (UserIndex >= MyLastIndex) {
-+      // Walked past transformed region
-+      break;
-+    }
-+    IE->removeFromParent();
-+    IE->insertAfter(x);
-+    DEBUG(dbgs() << "SLP:    Rescheduled: " << *IE << ".\n");
-+    moved = true;  
-+    x = IE;
-+    IE = dyn_cast<InsertElementInst>(IE->use_back());
-+    if (!IE) 
-+      break;
-+  } 
-+  if (moved) 
-+    numberInstructions(); 
-+}
-+
- } // end of namespace
-diff -u -r -N llvm-3.3.src/lib/Transforms/Vectorize/VecUtils.h llvm-3.3/lib/Transforms/Vectorize/VecUtils.h
---- llvm-3.3.src/lib/Transforms/Vectorize/VecUtils.h	2013-04-20 04:49:10.000000000 -0500
-+++ llvm-3.3/lib/Transforms/Vectorize/VecUtils.h	2014-04-15 17:38:41.549776444 -0500
-@@ -77,6 +77,9 @@
-   /// sequences.
-   ValueList &getGatherSeqInstructions() {return GatherInstructions; }
- 
-+  /// \brief Move InsertElement instructions with indices preceding LastIndex
-+  /// \p IE is the root of a chain identified by findBuildVector. 
-+  void movePrematureInserts(ArrayRef<Value *> VL, InsertElementInst *IE);
- private:
-   /// \brief This method contains the recursive part of getTreeCost.
-   int getTreeCost_rec(ArrayRef<Value *> VL, unsigned Depth);
-@@ -126,6 +129,8 @@
-   /// by multiple lanes, or by users outside the tree.
-   /// NOTICE: The vectorization methods also use this set.
-   ValueSet MustScalarize;
-+  /// True if all values must be scalarized, i.e. vectorization is worthless.
-+  bool AllScalarized;
- 
-   /// Contains a list of values that are used outside the current tree. This
-   /// set must be reset between runs.
-diff -u -r -N llvm-3.3.src/test/Transforms/SLPVectorizer/X86/insert-element-build-vector.ll llvm-3.3/test/Transforms/SLPVectorizer/X86/insert-element-build-vector.ll
---- llvm-3.3.src/test/Transforms/SLPVectorizer/X86/insert-element-build-vector.ll	1969-12-31 18:00:00.000000000 -0600
-+++ llvm-3.3/test/Transforms/SLPVectorizer/X86/insert-element-build-vector.ll	2014-04-15 14:13:12.738690168 -0500
-@@ -0,0 +1,53 @@
-+target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-n8:16:32:64-S128"
-+
-+target triple = "x86_64-apple-macosx10.8.0"
-+
-+; RUN: opt -S -slp-vectorizer -slp-threshold=0 < %s | FileCheck %s 
-+
-+; Check that cost model for vectorization takes credit for
-+; instructions that are erased.
-+define <4 x float> @take_credit(<4 x float> %a, <4 x float> %b) {
-+; CHECK-LABEL: @take_credit(
-+; CHECK: %1 = fadd <4 x float> %a, %b
-+  %a0 = extractelement <4 x float> %a, i32 0
-+  %b0 = extractelement <4 x float> %b, i32 0
-+  %c0 = fadd float %a0, %b0
-+  %a1 = extractelement <4 x float> %a, i32 1
-+  %b1 = extractelement <4 x float> %b, i32 1
-+  %c1 = fadd float %a1, %b1
-+  %a2 = extractelement <4 x float> %a, i32 2
-+  %b2 = extractelement <4 x float> %b, i32 2
-+  %c2 = fadd float %a2, %b2
-+  %a3 = extractelement <4 x float> %a, i32 3
-+  %b3 = extractelement <4 x float> %b, i32 3
-+  %c3 = fadd float %a3, %b3
-+  %v0 = insertelement <4 x float> undef, float %c0, i32 0
-+  %v1 = insertelement <4 x float> %v0, float %c1, i32 1
-+  %v2 = insertelement <4 x float> %v1, float %c2, i32 2
-+  %v3 = insertelement <4 x float> %v2, float %c3, i32 3
-+  ret <4 x float> %v3
-+}
-+
-+; Make sure that vectorization happens even if extractelement operations
-+; must be rescheduled.  The case here is from compiling Julia.
-+define <4 x float> @reschedule_extract(<4 x float> %a, <4 x float> %b) {
-+; CHECK-LABEL: @reschedule_extract(
-+; CHECK: %1 = fadd <4 x float> %a, %b
-+  %a0 = extractelement <4 x float> %a, i32 0
-+  %b0 = extractelement <4 x float> %b, i32 0
-+  %c0 = fadd float %a0, %b0
-+  %v0 = insertelement <4 x float> undef, float %c0, i32 0
-+  %a1 = extractelement <4 x float> %a, i32 1
-+  %b1 = extractelement <4 x float> %b, i32 1
-+  %c1 = fadd float %a1, %b1
-+  %v1 = insertelement <4 x float> %v0, float %c1, i32 1
-+  %a2 = extractelement <4 x float> %a, i32 2
-+  %b2 = extractelement <4 x float> %b, i32 2
-+  %c2 = fadd float %a2, %b2
-+  %v2 = insertelement <4 x float> %v1, float %c2, i32 2
-+  %a3 = extractelement <4 x float> %a, i32 3
-+  %b3 = extractelement <4 x float> %b, i32 3
-+  %c3 = fadd float %a3, %b3
-+  %v3 = insertelement <4 x float> %v2, float %c3, i32 3
-+  ret <4 x float> %v3
-+}
-diff -u -r -N llvm-3.3.src/test/Transforms/SLPVectorizer/X86/non-vectorizable-intrinsic.ll llvm-3.3/test/Transforms/SLPVectorizer/X86/non-vectorizable-intrinsic.ll
---- llvm-3.3.src/test/Transforms/SLPVectorizer/X86/non-vectorizable-intrinsic.ll	1969-12-31 18:00:00.000000000 -0600
-+++ llvm-3.3/test/Transforms/SLPVectorizer/X86/non-vectorizable-intrinsic.ll	2014-04-15 15:42:30.448560440 -0500
-@@ -0,0 +1,36 @@
-+; RUN: opt < %s -slp-vectorizer -o - -S -slp-threshold=-1000
-+
-+target datalayout = "e-p:32:32-i64:64-v16:16-v32:32-n16:32:64"
-+target triple = "nvptx--nvidiacl"
-+
-+; CTLZ cannot be vectorized currently because the second argument is a scalar
-+; for both the scalar and vector forms of the intrinsic. In the future it
-+; should be possible to vectorize such functions.
-+; Test causes an assert if LLVM tries to vectorize CTLZ.
-+
-+define <2 x i8> @cltz_test(<2 x i8> %x) #0 {
-+entry:
-+  %0 = extractelement <2 x i8> %x, i32 0
-+  %call.i = call i8 @llvm.ctlz.i8(i8 %0, i1 false)
-+  %vecinit = insertelement <2 x i8> undef, i8 %call.i, i32 0
-+  %1 = extractelement <2 x i8> %x, i32 1
-+  %call.i4 = call i8 @llvm.ctlz.i8(i8 %1, i1 false)
-+  %vecinit2 = insertelement <2 x i8> %vecinit, i8 %call.i4, i32 1
-+  ret <2 x i8> %vecinit2
-+}
-+
-+define <2 x i8> @cltz_test2(<2 x i8> %x) #1 {
-+entry:
-+  %0 = extractelement <2 x i8> %x, i32 0
-+  %1 = extractelement <2 x i8> %x, i32 1
-+  %call.i = call i8 @llvm.ctlz.i8(i8 %0, i1 false)
-+  %call.i4 = call i8 @llvm.ctlz.i8(i8 %1, i1 false)
-+  %vecinit = insertelement <2 x i8> undef, i8 %call.i, i32 0
-+  %vecinit2 = insertelement <2 x i8> %vecinit, i8 %call.i4, i32 1
-+  ret <2 x i8> %vecinit2
-+}
-+
-+declare i8 @llvm.ctlz.i8(i8, i1) #3
-+
-+attributes #0 = { alwaysinline nounwind "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
-+attributes #1 = { nounwind readnone }
diff --git a/deps/patches/llvm-3.7.0.patch b/deps/patches/llvm-3.7.0.patch
deleted file mode 100644
index 6ae438393a22a1..00000000000000
--- a/deps/patches/llvm-3.7.0.patch
+++ /dev/null
@@ -1,29 +0,0 @@
-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/patches/llvm-3.7.1.patch b/deps/patches/llvm-3.7.1.patch
deleted file mode 100644
index 2291b72a5a71e7..00000000000000
--- a/deps/patches/llvm-3.7.1.patch
+++ /dev/null
@@ -1,550 +0,0 @@
-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/patches/llvm-3.7.1_2.patch b/deps/patches/llvm-3.7.1_2.patch
deleted file mode 100644
index 5e7a7ee03588ba..00000000000000
--- a/deps/patches/llvm-3.7.1_2.patch
+++ /dev/null
@@ -1,220 +0,0 @@
-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/patches/llvm-3.7.1_3.patch b/deps/patches/llvm-3.7.1_3.patch
deleted file mode 100644
index c955da9a0e26b1..00000000000000
--- a/deps/patches/llvm-3.7.1_3.patch
+++ /dev/null
@@ -1,16 +0,0 @@
-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/patches/llvm-3.7.1_destsharedlibdir.patch b/deps/patches/llvm-3.7.1_destsharedlibdir.patch
deleted file mode 100644
index 91cbb352325218..00000000000000
--- a/deps/patches/llvm-3.7.1_destsharedlibdir.patch
+++ /dev/null
@@ -1,14 +0,0 @@
-diff --git a/Makefile.rules b/Makefile.rules
-index 24cac3b..4f52dbb 100644
---- a/Makefile.rules
-+++ b/Makefile.rules
-@@ -1234,6 +1234,9 @@ endif
- DestSharedLib := $(DestSharedLibDir)/$(BaseLibName.SO)
- DestSharedAlias := $(DestSharedLibDir)/$(BaseAliasName.SO)
- 
-+$(DestSharedLibDir)::
-+	$(MKDIR) $(DestSharedLibDir)
-+
- install-local:: $(DestSharedLib)
- 
- $(DestSharedLib): $(LibName.SO) $(DestSharedLibDir)
diff --git a/deps/patches/llvm-3.7.1_symlinks.patch b/deps/patches/llvm-3.7.1_symlinks.patch
deleted file mode 100644
index 8bcf5af0895a44..00000000000000
--- a/deps/patches/llvm-3.7.1_symlinks.patch
+++ /dev/null
@@ -1,213 +0,0 @@
-commit f4dd81db3c617f22881446eb0ed6bfdc7d69e81e
-Author: Chris Bieneman <beanz@apple.com>
-Date:   Mon Sep 14 23:09:06 2015 +0000
-
-    [CMake] Refactor and cleanup generating and installing symlinks to tools.
-    
-    Summary: This change generalizes symlink generation and makes symlinks to tools obey LLVM_TOOLCHAIN_TOOLS. It makes it so that if you exclude llvm-ar from LLVM_TOOLCHAIN_TOOLS you don't end up with broken symlinks to llvm-lib and llvm-ranlib in your install.
-    
-    Reviewers: bogner, chapuni, rafael
-    
-    Subscribers: llvm-commits
-    
-    Differential Revision: http://reviews.llvm.org/D12864
-    
-    git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@247632 91177308-0d34-0410-b5e6-96231b3b80d8
-    (cherry picked from commit 2ec309f7d116b6f10cf7dc4ca481aa69ddbe1e5b)
-    
-    Conflicts:
-    	cmake/modules/AddLLVM.cmake
-    
-    [CMake] Rename target->dest as per feedback from Chapuni on http://reviews.llvm.org/D12864
-    
-    git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@247658 91177308-0d34-0410-b5e6-96231b3b80d8
-    (cherry picked from commit 5d1cac1aa28e02fda6be52b5ddf4940085df64d9)
-    
-    [CMake] More refactoring of symlink creation.
-    
-    This refactoring is to enable clang to re-use this code.
-    
-    git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@247850 91177308-0d34-0410-b5e6-96231b3b80d8
-    (cherry picked from commit 2334ac1e4cc684bf1f68ac47b4486cf5d4dc8528)
-    
-    [CMake] More cleanup of installing symlinks.
-    
-    In order to support building clang out-of-tree the install_symlink script needs to be installed, and it needs to be found by searching the CMAKE_MODULE_PATH.
-    
-    This change renames install_symlink -> LLVMInstallSymlink so it doesn't conflict with naming from other projects, and adds searching behavior in AddLLVM.cmake
-    
-    git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@248009 91177308-0d34-0410-b5e6-96231b3b80d8
-    (cherry picked from commit f8d6e92d57aacf9388e8ed87cc43b22bd3367c4f)
-    
-    [CMake] Adding ALWAYS_GENERATE option to symlink utility functions.
-    
-    This implements the behavior required for clang symlinks which should be always generated.
-    
-    git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@248039 91177308-0d34-0410-b5e6-96231b3b80d8
-    (cherry picked from commit 907451c6d653f5d0f4efa55fb42a84dae67a37cc)
-    
-    [CMake] Cleaning up and generalizing the LLVMInstallSymlink script so that it can be used for libraries too.
-    
-    In order to resolve PR25059, we're going to need to be able to generate symlinks to libraries manually, so I need this code to be reusable.
-    
-    git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@250573 91177308-0d34-0410-b5e6-96231b3b80d8
-    (cherry picked from commit 26751e15750dbb733946c940e8a3bdfc5c446d8e)
-
-diff --git a/cmake/modules/AddLLVM.cmake b/cmake/modules/AddLLVM.cmake
-index 45f6746..7f711ce 100644
---- a/cmake/modules/AddLLVM.cmake
-+++ b/cmake/modules/AddLLVM.cmake
-@@ -602,9 +602,10 @@ function(export_executable_symbols target)
-   endif()
- endfunction()
- 
--
- set (LLVM_TOOLCHAIN_TOOLS
-   llvm-ar
-+  llvm-ranlib
-+  llvm-lib
-   llvm-objdump
-   )
- 
-@@ -939,3 +940,77 @@ function(add_lit_testsuites project directory)
-     endforeach()
-   endif()
- endfunction()
-+
-+function(llvm_install_symlink name dest)
-+  cmake_parse_arguments(ARG "ALWAYS_GENERATE" "" "" ${ARGN})
-+  foreach(path ${CMAKE_MODULE_PATH})
-+    if(EXISTS ${path}/LLVMInstallSymlink.cmake)
-+      set(INSTALL_SYMLINK ${path}/LLVMInstallSymlink.cmake)
-+      break()
-+    endif()
-+  endforeach()
-+  
-+  if(ARG_ALWAYS_GENERATE)
-+    set(component ${dest})
-+  else()
-+    set(component ${name})
-+  endif()
-+
-+  set(full_name ${name}${CMAKE_EXECUTABLE_SUFFIX})
-+  set(full_dest ${dest}${CMAKE_EXECUTABLE_SUFFIX})
-+
-+  install(SCRIPT ${INSTALL_SYMLINK}
-+          CODE "install_symlink(${full_name} ${full_dest} bin)"
-+          COMPONENT ${component})
-+
-+  if (NOT CMAKE_CONFIGURATION_TYPES AND NOT ARG_ALWAYS_GENERATE)
-+    add_custom_target(install-${name}
-+                      DEPENDS ${name} ${dest} install-${dest}
-+                      COMMAND "${CMAKE_COMMAND}"
-+                              -DCMAKE_INSTALL_COMPONENT=${name}
-+                              -P "${CMAKE_BINARY_DIR}/cmake_install.cmake")
-+  endif()
-+endfunction()
-+
-+function(add_llvm_tool_symlink name dest)
-+  cmake_parse_arguments(ARG "ALWAYS_GENERATE" "" "" ${ARGN})
-+  if(UNIX)
-+    set(LLVM_LINK_OR_COPY create_symlink)
-+    set(dest_binary "${dest}${CMAKE_EXECUTABLE_SUFFIX}")
-+  else()
-+    set(LLVM_LINK_OR_COPY copy)
-+    set(dest_binary "${LLVM_RUNTIME_OUTPUT_INTDIR}/${dest}${CMAKE_EXECUTABLE_SUFFIX}")
-+  endif()
-+
-+  set(output_path "${LLVM_RUNTIME_OUTPUT_INTDIR}/${name}${CMAKE_EXECUTABLE_SUFFIX}")
-+
-+  if(ARG_ALWAYS_GENERATE)
-+    set_property(DIRECTORY APPEND PROPERTY
-+      ADDITIONAL_MAKE_CLEAN_FILES ${dest_binary})
-+    add_custom_command(TARGET ${dest} POST_BUILD
-+      COMMAND ${CMAKE_COMMAND} -E ${LLVM_LINK_OR_COPY} "${dest_binary}" "${output_path}")
-+  else()
-+    add_custom_command(OUTPUT ${output_path}
-+                     COMMAND ${CMAKE_COMMAND} -E ${LLVM_LINK_OR_COPY} "${dest_binary}" "${output_path}"
-+                     DEPENDS ${dest})
-+    add_custom_target(${name} ALL DEPENDS ${output_path})
-+    set_target_properties(${name} PROPERTIES FOLDER Tools)
-+
-+    # Make sure the parent tool is a toolchain tool, otherwise exclude this tool
-+    list(FIND LLVM_TOOLCHAIN_TOOLS ${dest} LLVM_IS_${dest}_TOOLCHAIN_TOOL)
-+    if (NOT LLVM_IS_${dest}_TOOLCHAIN_TOOL GREATER -1)
-+      set(LLVM_IS_${name}_TOOLCHAIN_TOOL ${LLVM_IS_${dest}_TOOLCHAIN_TOOL})
-+    else()
-+      list(FIND LLVM_TOOLCHAIN_TOOLS ${name} LLVM_IS_${name}_TOOLCHAIN_TOOL)
-+    endif()
-+
-+    # LLVM_IS_${name}_TOOLCHAIN_TOOL will only be greater than -1 if both this
-+    # tool and its parent tool are in LLVM_TOOLCHAIN_TOOLS
-+    if (LLVM_IS_${name}_TOOLCHAIN_TOOL GREATER -1 OR NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
-+      if( LLVM_BUILD_TOOLS )
-+        llvm_install_symlink(${name} ${dest})
-+      endif()
-+    endif()
-+  endif()
-+endfunction()
-+
-diff --git a/cmake/modules/LLVMInstallSymlink.cmake b/cmake/modules/LLVMInstallSymlink.cmake
-new file mode 100644
-index 0000000..482697b
---- /dev/null
-+++ b/cmake/modules/LLVMInstallSymlink.cmake
-@@ -0,0 +1,21 @@
-+# We need to execute this script at installation time because the
-+# DESTDIR environment variable may be unset at configuration time.
-+# See PR8397.
-+
-+function(install_symlink name target outdir)
-+  if(UNIX)
-+    set(LINK_OR_COPY create_symlink)
-+    set(DESTDIR $ENV{DESTDIR})
-+  else()
-+    set(LINK_OR_COPY copy)
-+  endif()
-+
-+  set(bindir "${DESTDIR}${CMAKE_INSTALL_PREFIX}/${outdir}/")
-+
-+  message("Creating ${name}")
-+
-+  execute_process(
-+    COMMAND "${CMAKE_COMMAND}" -E ${LINK_OR_COPY} "${target}" "${name}"
-+    WORKING_DIRECTORY "${bindir}")
-+
-+endfunction()
-diff --git a/tools/llvm-ar/CMakeLists.txt b/tools/llvm-ar/CMakeLists.txt
-index 05ffe36..86233df 100644
---- a/tools/llvm-ar/CMakeLists.txt
-+++ b/tools/llvm-ar/CMakeLists.txt
-@@ -10,30 +10,5 @@ add_llvm_tool(llvm-ar
-   llvm-ar.cpp
-   )
- 
--if(UNIX)
--  set(LLVM_LINK_OR_COPY create_symlink)
--  set(llvm_ar_binary "llvm-ar${CMAKE_EXECUTABLE_SUFFIX}")
--else()
--  set(LLVM_LINK_OR_COPY copy)
--  set(llvm_ar_binary "${LLVM_RUNTIME_OUTPUT_INTDIR}/llvm-ar${CMAKE_EXECUTABLE_SUFFIX}")
--endif()
--
--set(llvm_ranlib "${LLVM_RUNTIME_OUTPUT_INTDIR}/llvm-ranlib${CMAKE_EXECUTABLE_SUFFIX}")
--
--add_custom_command(OUTPUT ${llvm_ranlib}
--                   COMMAND ${CMAKE_COMMAND} -E ${LLVM_LINK_OR_COPY} "${llvm_ar_binary}" "${llvm_ranlib}"
--                   DEPENDS llvm-ar)
--
--add_custom_target(llvm-ranlib ALL DEPENDS ${llvm_ranlib})
--set_target_properties(llvm-ranlib PROPERTIES FOLDER Tools)
--
--set(llvm_lib "${LLVM_RUNTIME_OUTPUT_INTDIR}/llvm-lib${CMAKE_EXECUTABLE_SUFFIX}")
--
--add_custom_command(OUTPUT ${llvm_lib}
--                   COMMAND ${CMAKE_COMMAND} -E ${LLVM_LINK_OR_COPY} "${llvm_ar_binary}" "${llvm_lib}"
--                   DEPENDS llvm-ar)
--
--add_custom_target(llvm-lib ALL DEPENDS ${llvm_lib})
--set_target_properties(llvm-lib PROPERTIES FOLDER Tools)
--
--install(SCRIPT install_symlink.cmake -DCMAKE_INSTALL_PREFIX=\"${CMAKE_INSTALL_PREFIX}\")
-+add_llvm_tool_symlink(llvm-ranlib llvm-ar)
-+add_llvm_tool_symlink(llvm-lib llvm-ar)
diff --git a/deps/patches/llvm-3.8.0_bindir.patch b/deps/patches/llvm-3.8.0_bindir.patch
deleted file mode 100644
index aaffd159480a52..00000000000000
--- a/deps/patches/llvm-3.8.0_bindir.patch
+++ /dev/null
@@ -1,50 +0,0 @@
-difft a/CMakeLists.txt b/CMakeLists.txt
-index 46ca944..83cd3ba 100644
---- a/CMakeLists.txt
-+++ b/CMakeLists.txt
-@@ -201,6 +201,9 @@ endif()
- 
- set(LLVM_LIBDIR_SUFFIX "" CACHE STRING "Define suffix of library directory name (32/64)" )
- 
-+set(LLVM_TOOLS_INSTALL_DIR "bin" CACHE STRING "Path for binary subdirectroy (defaults to 'bin')")
-+mark_as_advanced(LLVM_TOOLS_INSTALL_DIR)
-+
- # They are used as destination of target generators.
- set(LLVM_RUNTIME_OUTPUT_INTDIR ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/bin)
- set(LLVM_LIBRARY_OUTPUT_INTDIR ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/lib${LLVM_LIBDIR_SUFFIX})
-diff --git a/cmake/modules/AddLLVM.cmake b/cmake/modules/AddLLVM.cmake
-index cc7445f..789555a 100644
---- a/cmake/modules/AddLLVM.cmake
-+++ b/cmake/modules/AddLLVM.cmake
-@@ -771,7 +771,7 @@ macro(add_llvm_tool name)
-     if( LLVM_BUILD_TOOLS )
-       install(TARGETS ${name}
-               EXPORT LLVMExports
--              RUNTIME DESTINATION bin
-+              RUNTIME DESTINATION ${LLVM_TOOLS_INSTALL_DIR}
-               COMPONENT ${name})
- 
-       if (NOT CMAKE_CONFIGURATION_TYPES)
-@@ -1211,7 +1211,7 @@ function(llvm_install_symlink name dest)
-   set(full_dest ${dest}${CMAKE_EXECUTABLE_SUFFIX})
- 
-   install(SCRIPT ${INSTALL_SYMLINK}
--          CODE "install_symlink(${full_name} ${full_dest} bin)"
-+          CODE "install_symlink(${full_name} ${full_dest} ${LLVM_TOOLS_INSTALL_DIR})"
-           COMPONENT ${component})
- 
-   if (NOT CMAKE_CONFIGURATION_TYPES AND NOT ARG_ALWAYS_GENERATE)
-diff --git a/cmake/modules/TableGen.cmake b/cmake/modules/TableGen.cmake
-index fca7d1b..c88ee3fc 100644
---- a/cmake/modules/TableGen.cmake
-+++ b/cmake/modules/TableGen.cmake
-@@ -141,7 +141,7 @@ macro(add_tablegen target project)
-   if (${project} STREQUAL LLVM AND NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
-     install(TARGETS ${target}
-             EXPORT LLVMExports
--            RUNTIME DESTINATION bin)
-+            RUNTIME DESTINATION ${LLVM_TOOLS_INSTALL_DIR})
-   endif()
-   set_property(GLOBAL APPEND PROPERTY LLVM_EXPORTS ${target})
- endmacro()
- --git a/CMakeLists.txt b/CMakeLists.txt
diff --git a/deps/patches/llvm-3.8.0_ppc64_SUBFC8.patch b/deps/patches/llvm-3.8.0_ppc64_SUBFC8.patch
deleted file mode 100644
index 1103d9a5f961e3..00000000000000
--- a/deps/patches/llvm-3.8.0_ppc64_SUBFC8.patch
+++ /dev/null
@@ -1,31 +0,0 @@
-diff --git a/lib/Target/PowerPC/PPCInstr64Bit.td b/lib/Target/PowerPC/PPCInstr64Bit.td
-index 52af293..e7eb8a1 100644
---- a/lib/Target/PowerPC/PPCInstr64Bit.td
-+++ b/lib/Target/PowerPC/PPCInstr64Bit.td
-@@ -514,11 +514,11 @@ let Defs = [CARRY] in {
- def SUBFIC8: DForm_2< 8, (outs g8rc:$rD), (ins g8rc:$rA, s16imm64:$imm),
-                      "subfic $rD, $rA, $imm", IIC_IntGeneral,
-                      [(set i64:$rD, (subc imm64SExt16:$imm, i64:$rA))]>;
--defm SUBFC8 : XOForm_1r<31, 8, 0, (outs g8rc:$rT), (ins g8rc:$rA, g8rc:$rB),
-+}
-+defm SUBFC8 : XOForm_1rc<31, 8, 0, (outs g8rc:$rT), (ins g8rc:$rA, g8rc:$rB),
-                         "subfc", "$rT, $rA, $rB", IIC_IntGeneral,
-                         [(set i64:$rT, (subc i64:$rB, i64:$rA))]>,
-                         PPC970_DGroup_Cracked;
--}
- defm SUBF8 : XOForm_1r<31, 40, 0, (outs g8rc:$rT), (ins g8rc:$rA, g8rc:$rB),
-                        "subf", "$rT, $rA, $rB", IIC_IntGeneral,
-                        [(set i64:$rT, (sub i64:$rB, i64:$rA))]>;
-diff --git a/lib/Target/PowerPC/PPCInstrInfo.cpp b/lib/Target/PowerPC/PPCInstrInfo.cpp
-index 313ab88..8dca286 100644
---- a/lib/Target/PowerPC/PPCInstrInfo.cpp
-+++ b/lib/Target/PowerPC/PPCInstrInfo.cpp
-@@ -1795,6 +1795,7 @@ bool PPCInstrInfo::optimizeCompareInstr(MachineInstr *CmpInstr,
-           MI->addOperand(*MI->getParent()->getParent(),
-                          MachineOperand::CreateReg(*ImpUses, false, true));
-   }
-+  assert(MI->definesRegister(PPC::CR0));
-
-   // Modify the condition code of operands in OperandsToUpdate.
-   // Since we have SUB(r1, r2) and CMP(r2, r1), the condition code needs to
-
diff --git a/deps/patches/llvm-3.8.0_threads.patch b/deps/patches/llvm-3.8.0_threads.patch
deleted file mode 100644
index 9e52e2291045e3..00000000000000
--- a/deps/patches/llvm-3.8.0_threads.patch
+++ /dev/null
@@ -1,184 +0,0 @@
-From 69ef168544e4f15b793dd35d272008fde9a6e835 Mon Sep 17 00:00:00 2001
-From: Alex Crichton <alex@alexcrichton.com>
-Date: Thu, 28 Jan 2016 20:44:50 -0800
-Subject: [PATCH] Don't compile usage of std::thread
-
-As of the time of this writing it's not actually used anywhere meaningfullly
-throughout the LLVM repo that we need, and it unfortunately uses `std::thread`
-which isn't available in mingw-w64 toolchains with the win32 threading model
-(the one that we use).
-
-Two major changes were made to achieve this:
-
-1. The `ThreadPool.cpp` file was just entirely commented out. This isn't used
-   anywhere in the LLVM repo nor in Rust itself.
-2. The `ParallelCG.cpp` file was mostly deleted. Unfortunately it's used a few
-   places in LLVM and is needed to link correctly, but we in Rust don't use it
-   at all. For now it's just a stub implementation that hopefully compiles
-   everywhere, but perhaps we can find a less invasive (aka doesn't have rebase
-   conflicts in the future) change to apply soon.
-
-For reference, the upstream LLVM bug has been reported [1]
-
-[1]: https://llvm.org/bugs/show_bug.cgi?id=26365
----
- include/llvm/Support/ThreadPool.h |  4 +++
- include/llvm/Support/thread.h     |  4 +++
- lib/CodeGen/ParallelCG.cpp        | 63 +--------------------------------------
- lib/Support/ThreadPool.cpp        |  4 +++
- 4 files changed, 13 insertions(+), 62 deletions(-)
-
-diff --git a/include/llvm/Support/ThreadPool.h b/include/llvm/Support/ThreadPool.h
-index 745334d..4564615 100644
---- a/include/llvm/Support/ThreadPool.h
-+++ b/include/llvm/Support/ThreadPool.h
-@@ -11,6 +11,8 @@
- //
- //===----------------------------------------------------------------------===//
- 
-+#if 0
-+
- #ifndef LLVM_SUPPORT_THREAD_POOL_H
- #define LLVM_SUPPORT_THREAD_POOL_H
- 
-@@ -134,3 +136,5 @@ class ThreadPool {
- }
- 
- #endif // LLVM_SUPPORT_THREAD_POOL_H
-+
-+#endif
-diff --git a/include/llvm/Support/thread.h b/include/llvm/Support/thread.h
-index 2d13041..80340e6 100644
---- a/include/llvm/Support/thread.h
-+++ b/include/llvm/Support/thread.h
-@@ -14,6 +14,8 @@
- //
- //===----------------------------------------------------------------------===//
- 
-+#if 0
-+
- #ifndef LLVM_SUPPORT_THREAD_H
- #define LLVM_SUPPORT_THREAD_H
- 
-@@ -64,3 +66,5 @@ struct thread {
- #endif // LLVM_ENABLE_THREADS
- 
- #endif
-+
-+#endif
-diff --git a/lib/CodeGen/ParallelCG.cpp b/lib/CodeGen/ParallelCG.cpp
-index e73ba02..7362cda 100644
---- a/lib/CodeGen/ParallelCG.cpp
-+++ b/lib/CodeGen/ParallelCG.cpp
-@@ -25,72 +25,11 @@
- 
- using namespace llvm;
- 
--static void codegen(Module *M, llvm::raw_pwrite_stream &OS,
--                    const Target *TheTarget, StringRef CPU, StringRef Features,
--                    const TargetOptions &Options, Reloc::Model RM,
--                    CodeModel::Model CM, CodeGenOpt::Level OL,
--                    TargetMachine::CodeGenFileType FileType) {
--  std::unique_ptr<TargetMachine> TM(TheTarget->createTargetMachine(
--      M->getTargetTriple(), CPU, Features, Options, RM, CM, OL));
--
--  legacy::PassManager CodeGenPasses;
--  if (TM->addPassesToEmitFile(CodeGenPasses, OS, FileType))
--    report_fatal_error("Failed to setup codegen");
--  CodeGenPasses.run(*M);
--}
--
- std::unique_ptr<Module>
- llvm::splitCodeGen(std::unique_ptr<Module> M,
-                    ArrayRef<llvm::raw_pwrite_stream *> OSs, StringRef CPU,
-                    StringRef Features, const TargetOptions &Options,
-                    Reloc::Model RM, CodeModel::Model CM, CodeGenOpt::Level OL,
-                    TargetMachine::CodeGenFileType FileType) {
--  StringRef TripleStr = M->getTargetTriple();
--  std::string ErrMsg;
--  const Target *TheTarget = TargetRegistry::lookupTarget(TripleStr, ErrMsg);
--  if (!TheTarget)
--    report_fatal_error(Twine("Target not found: ") + ErrMsg);
--
--  if (OSs.size() == 1) {
--    codegen(M.get(), *OSs[0], TheTarget, CPU, Features, Options, RM, CM,
--            OL, FileType);
--    return M;
--  }
--
--  std::vector<thread> Threads;
--  SplitModule(std::move(M), OSs.size(), [&](std::unique_ptr<Module> MPart) {
--    // We want to clone the module in a new context to multi-thread the codegen.
--    // We do it by serializing partition modules to bitcode (while still on the
--    // main thread, in order to avoid data races) and spinning up new threads
--    // which deserialize the partitions into separate contexts.
--    // FIXME: Provide a more direct way to do this in LLVM.
--    SmallVector<char, 0> BC;
--    raw_svector_ostream BCOS(BC);
--    WriteBitcodeToFile(MPart.get(), BCOS);
--
--    llvm::raw_pwrite_stream *ThreadOS = OSs[Threads.size()];
--    Threads.emplace_back(
--        [TheTarget, CPU, Features, Options, RM, CM, OL, FileType,
--         ThreadOS](const SmallVector<char, 0> &BC) {
--          LLVMContext Ctx;
--          ErrorOr<std::unique_ptr<Module>> MOrErr =
--              parseBitcodeFile(MemoryBufferRef(StringRef(BC.data(), BC.size()),
--                                               "<split-module>"),
--                               Ctx);
--          if (!MOrErr)
--            report_fatal_error("Failed to read bitcode");
--          std::unique_ptr<Module> MPartInCtx = std::move(MOrErr.get());
--
--          codegen(MPartInCtx.get(), *ThreadOS, TheTarget, CPU, Features,
--                  Options, RM, CM, OL, FileType);
--        },
--        // Pass BC using std::move to ensure that it get moved rather than
--        // copied into the thread's context.
--        std::move(BC));
--  });
--
--  for (thread &T : Threads)
--    T.join();
--
--  return {};
-+  return M;
- }
-diff --git a/lib/Support/ThreadPool.cpp b/lib/Support/ThreadPool.cpp
-index d4dcb2e..bc25c59 100644
---- a/lib/Support/ThreadPool.cpp
-+++ b/lib/Support/ThreadPool.cpp
-@@ -11,6 +11,8 @@
- //
- //===----------------------------------------------------------------------===//
- 
-+#if 0
-+
- #include "llvm/Support/ThreadPool.h"
- 
- #include "llvm/Config/llvm-config.h"
-@@ -153,3 +155,5 @@ ThreadPool::~ThreadPool() {
- }
- 
- #endif
-+
-+#endif
-diff --git a/unittests/Support/ThreadPool.cpp b/unittests/Support/ThreadPool.cpp
-index 0f36c38..32f4eab 100644
---- a/unittests/Support/ThreadPool.cpp
-+++ b/unittests/Support/ThreadPool.cpp
-@@ -7,6 +7,8 @@
- //
- //===----------------------------------------------------------------------===//
- 
-+#if 0
-+
- #include "llvm/Support/ThreadPool.h"
- 
- #include "llvm/ADT/STLExtras.h"
-@@ -166,3 +168,5 @@ TEST_F(ThreadPoolTest, PoolDestruction) {
-   }
-   ASSERT_EQ(5, checked_in);
- }
-+
-+#endif
diff --git a/deps/patches/llvm-3.8.0_winshlib.patch b/deps/patches/llvm-3.8.0_winshlib.patch
deleted file mode 100644
index 5aea42869827fd..00000000000000
--- a/deps/patches/llvm-3.8.0_winshlib.patch
+++ /dev/null
@@ -1,26 +0,0 @@
-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/patches/llvm-3.8.1-version.patch b/deps/patches/llvm-3.8.1-version.patch
deleted file mode 100644
index 3bc365a596d9b6..00000000000000
--- a/deps/patches/llvm-3.8.1-version.patch
+++ /dev/null
@@ -1,77 +0,0 @@
-diff --git a/configure b/configure
-index c94fb13..f146f2f 100755
---- a/configure
-+++ b/configure
-@@ -1,6 +1,6 @@
- #! /bin/sh
- # Guess values for system-dependent variables and create Makefiles.
--# Generated by GNU Autoconf 2.60 for LLVM 3.8.0.
-+# Generated by GNU Autoconf 2.60 for LLVM 3.8.1.
- #
- # Report bugs to <http://llvm.org/bugs/>.
- #
-@@ -561,8 +561,8 @@ SHELL=${CONFIG_SHELL-/bin/sh}
- # Identity of this package.
- PACKAGE_NAME='LLVM'
- PACKAGE_TARNAME='llvm'
--PACKAGE_VERSION='3.8.0'
--PACKAGE_STRING='LLVM 3.8.0'
-+PACKAGE_VERSION='3.8.1'
-+PACKAGE_STRING='LLVM 3.8.1'
- PACKAGE_BUGREPORT='http://llvm.org/bugs/'
- 
- ac_unique_file="lib/IR/Module.cpp"
-@@ -1334,7 +1334,7 @@ if test "$ac_init_help" = "long"; then
-   # Omit some internal or obsolete options to make the list less imposing.
-   # This message is too long to be a string in the A/UX 3.1 sh.
-   cat <<_ACEOF
--\`configure' configures LLVM 3.8.0 to adapt to many kinds of systems.
-+\`configure' configures LLVM 3.8.1 to adapt to many kinds of systems.
- 
- Usage: $0 [OPTION]... [VAR=VALUE]...
- 
-@@ -1400,7 +1400,7 @@ fi
- 
- if test -n "$ac_init_help"; then
-   case $ac_init_help in
--     short | recursive ) echo "Configuration of LLVM 3.8.0:";;
-+     short | recursive ) echo "Configuration of LLVM 3.8.1:";;
-    esac
-   cat <<\_ACEOF
- 
-@@ -1584,7 +1584,7 @@ fi
- test -n "$ac_init_help" && exit $ac_status
- if $ac_init_version; then
-   cat <<\_ACEOF
--LLVM configure 3.8.0
-+LLVM configure 3.8.1
- generated by GNU Autoconf 2.60
- 
- Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
-@@ -1600,7 +1600,7 @@ cat >config.log <<_ACEOF
- This file contains any messages produced by compilers while
- running configure, to aid debugging if configure makes a mistake.
- 
--It was created by LLVM $as_me 3.8.0, which was
-+It was created by LLVM $as_me 3.8.1, which was
- generated by GNU Autoconf 2.60.  Invocation command line was
- 
-   $ $0 $@
-@@ -18279,7 +18279,7 @@ exec 6>&1
- # report actual input values of CONFIG_FILES etc. instead of their
- # values after options handling.
- ac_log="
--This file was extended by LLVM $as_me 3.8.0, which was
-+This file was extended by LLVM $as_me 3.8.1, which was
- generated by GNU Autoconf 2.60.  Invocation command line was
- 
-   CONFIG_FILES    = $CONFIG_FILES
-@@ -18332,7 +18332,7 @@ Report bugs to <bug-autoconf@gnu.org>."
- _ACEOF
- cat >>$CONFIG_STATUS <<_ACEOF
- ac_cs_version="\\
--LLVM config.status 3.8.0
-+LLVM config.status 3.8.1
- configured by $0, generated by GNU Autoconf 2.60,
-   with options \\"`echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`\\"
- 
diff --git a/deps/patches/llvm-3.9.0_cygwin.patch b/deps/patches/llvm-3.9.0_cygwin.patch
deleted file mode 100644
index e225199619d138..00000000000000
--- a/deps/patches/llvm-3.9.0_cygwin.patch
+++ /dev/null
@@ -1,23 +0,0 @@
-From 9f7957830512dbcddd9cb5542080eb2d1cdd705b Mon Sep 17 00:00:00 2001
-From: Nuno Lopes <nunoplopes@sapo.pt>
-Date: Thu, 6 Oct 2016 09:32:16 +0000
-Subject: [PATCH] fix build on cygwin Cygwin has dlfcn.h, but no Dl_info
-
-git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@283427 91177308-0d34-0410-b5e6-96231b3b80d8
----
- lib/Support/Unix/Signals.inc | 2 +-
- 1 file changed, 1 insertion(+), 1 deletion(-)
-
-diff --git a/lib/Support/Unix/Signals.inc b/lib/Support/Unix/Signals.inc
-index 46b640a..9752b70 100644
---- a/lib/Support/Unix/Signals.inc
-+++ b/lib/Support/Unix/Signals.inc
-@@ -412,7 +412,7 @@ void llvm::sys::PrintStackTrace(raw_ostream &OS) {
- 
-   if (printSymbolizedStackTrace(Argv0, StackTrace, depth, OS))
-     return;
--#if HAVE_DLFCN_H && __GNUG__
-+#if HAVE_DLFCN_H && __GNUG__ && !defined(__CYGWIN__)
-   int width = 0;
-   for (int i = 0; i < depth; ++i) {
-     Dl_info dlinfo;
diff --git a/deps/patches/llvm-4.0.0_threads.patch b/deps/patches/llvm-4.0.0_threads.patch
new file mode 100644
index 00000000000000..d3ed7ee7931b94
--- /dev/null
+++ b/deps/patches/llvm-4.0.0_threads.patch
@@ -0,0 +1,2032 @@
+From dfead72dc82a76a62433c4f0ed2262407ef51bf0 Mon Sep 17 00:00:00 2001
+From: Alex Crichton <alex@alexcrichton.com>
+Date: Thu, 28 Jan 2016 20:44:50 -0800
+Subject: [PATCH] Don't compile usage of std::thread
+
+As of the time of this writing it's not actually used anywhere meaningfullly
+throughout the LLVM repo that we need, and it unfortunately uses `std::thread`
+which isn't available in mingw-w64 toolchains with the win32 threading model
+(the one that we use).
+
+The change made to achive this was to just always use the single-threaded
+support in `include/llvm/Support/thread.h`, and hopefuly that'll be enough...
+
+For reference, the upstream LLVM bug has been reported [1]
+
+[1]: https://llvm.org/bugs/show_bug.cgi?id=26365
+---
+ include/llvm/Support/ThreadPool.h         |   4 +
+ include/llvm/Support/thread.h             |   2 +-
+ lib/CodeGen/ParallelCG.cpp                |   2 +
+ lib/LTO/LTO.cpp                           |   6 +-
+ lib/LTO/LTOBackend.cpp                    |   2 +
+ lib/LTO/ThinLTOCodeGenerator.cpp          |   6 +-
+ lib/Support/ThreadPool.cpp                |   6 +-
+ test/CMakeLists.txt                       |   1 -
+ tools/lli/CMakeLists.txt                  |   4 -
+ tools/lli/ChildTarget/CMakeLists.txt      |  13 --
+ tools/lli/ChildTarget/ChildTarget.cpp     |  67 -------
+ tools/lli/ChildTarget/LLVMBuild.txt       |  21 ---
+ tools/lli/LLVMBuild.txt                   |   3 -
+ tools/lli/OrcLazyJIT.cpp                  |   3 +-
+ tools/lli/OrcLazyJIT.h                    | 175 ------------------
+ tools/lli/RemoteJITUtils.h                | 153 ----------------
+ tools/lli/lli.cpp                         |   7 +
+ tools/llvm-cov/CodeCoverage.cpp           |   4 +
+ tools/llvm-cov/CoverageExporterJson.cpp   |   2 +
+ tools/llvm-cov/CoverageFilters.cpp        |   2 +
+ tools/llvm-cov/CoverageFilters.h          | 127 -------------
+ tools/llvm-cov/CoverageReport.cpp         |   2 +
+ tools/llvm-cov/CoverageReport.h           |  51 ------
+ tools/llvm-cov/CoverageSummaryInfo.cpp    |   2 +
+ tools/llvm-cov/CoverageSummaryInfo.h      | 165 -----------------
+ tools/llvm-cov/CoverageViewOptions.h      |  68 -------
+ tools/llvm-cov/RenderingSupport.h         |  61 -------
+ tools/llvm-cov/SourceCoverageView.cpp     |   2 +
+ tools/llvm-cov/SourceCoverageView.h       | 289 ------------------------------
+ tools/llvm-cov/SourceCoverageViewHTML.cpp |   3 +
+ tools/llvm-cov/SourceCoverageViewHTML.h   |  96 ----------
+ tools/llvm-cov/SourceCoverageViewText.cpp |   3 +
+ tools/llvm-cov/SourceCoverageViewText.h   |  89 ---------
+ tools/llvm-cov/TestingSupport.cpp         |   2 +
+ tools/llvm-cov/gcov.cpp                   |   2 +
+ tools/llvm-cov/llvm-cov.cpp               |   4 +
+ tools/llvm-profdata/llvm-profdata.cpp     |   5 +
+ tools/sancov/sancov.cc                    |   5 +
+ unittests/Support/ThreadPool.cpp          |   4 +
+ 39 files changed, 73 insertions(+), 1390 deletions(-)
+ delete mode 100644 tools/lli/ChildTarget/CMakeLists.txt
+ delete mode 100644 tools/lli/ChildTarget/ChildTarget.cpp
+ delete mode 100644 tools/lli/ChildTarget/LLVMBuild.txt
+ delete mode 100644 tools/lli/OrcLazyJIT.h
+ delete mode 100644 tools/lli/RemoteJITUtils.h
+ delete mode 100644 tools/llvm-cov/CoverageFilters.h
+ delete mode 100644 tools/llvm-cov/CoverageReport.h
+ delete mode 100644 tools/llvm-cov/CoverageSummaryInfo.h
+ delete mode 100644 tools/llvm-cov/CoverageViewOptions.h
+ delete mode 100644 tools/llvm-cov/RenderingSupport.h
+ delete mode 100644 tools/llvm-cov/SourceCoverageView.h
+ delete mode 100644 tools/llvm-cov/SourceCoverageViewHTML.h
+ delete mode 100644 tools/llvm-cov/SourceCoverageViewText.h
+
+diff --git a/include/llvm/Support/ThreadPool.h b/include/llvm/Support/ThreadPool.h
+index 665cec2465b..c3aa64de8cc 100644
+--- a/include/llvm/Support/ThreadPool.h
++++ b/include/llvm/Support/ThreadPool.h
+@@ -16,6 +16,8 @@
+ 
+ #include "llvm/Support/thread.h"
+ 
++# if 0
++
+ #ifdef _MSC_VER
+ // concrt.h depends on eh.h for __uncaught_exception declaration
+ // even if we disable exceptions.
+@@ -134,4 +136,6 @@ private:
+ };
+ }
+ 
++# endif
++
+ #endif // LLVM_SUPPORT_THREAD_POOL_H
+diff --git a/include/llvm/Support/thread.h b/include/llvm/Support/thread.h
+index 9c45418df55..27d42d23f61 100644
+--- a/include/llvm/Support/thread.h
++++ b/include/llvm/Support/thread.h
+@@ -19,7 +19,7 @@
+ 
+ #include "llvm/Config/llvm-config.h"
+ 
+-#if LLVM_ENABLE_THREADS
++#if LLVM_ENABLE_THREADS && 0
+ 
+ #ifdef _MSC_VER
+ // concrt.h depends on eh.h for __uncaught_exception declaration
+diff --git a/lib/CodeGen/ParallelCG.cpp b/lib/CodeGen/ParallelCG.cpp
+index 50dd44fa659..e91898e0fa7 100644
+--- a/lib/CodeGen/ParallelCG.cpp
++++ b/lib/CodeGen/ParallelCG.cpp
+@@ -50,6 +50,7 @@ std::unique_ptr<Module> llvm::splitCodeGen(
+     return M;
+   }
+ 
++#if 0
+   // Create ThreadPool in nested scope so that threads will be joined
+   // on destruction.
+   {
+@@ -96,5 +97,6 @@ std::unique_ptr<Module> llvm::splitCodeGen(
+         PreserveLocals);
+   }
+ 
++#endif
+   return {};
+ }
+diff --git a/lib/LTO/LTO.cpp b/lib/LTO/LTO.cpp
+index e3e2f9f806c..530946c03bb 100644
+--- a/lib/LTO/LTO.cpp
++++ b/lib/LTO/LTO.cpp
+@@ -630,7 +630,6 @@ public:
+ 
+ namespace {
+ class InProcessThinBackend : public ThinBackendProc {
+-  ThreadPool BackendThreadPool;
+   AddStreamFn AddStream;
+   NativeObjectCache Cache;
+ 
+@@ -644,7 +643,6 @@ public:
+       const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
+       AddStreamFn AddStream, NativeObjectCache Cache)
+       : ThinBackendProc(Conf, CombinedIndex, ModuleToDefinedGVSummaries),
+-        BackendThreadPool(ThinLTOParallelismLevel),
+         AddStream(std::move(AddStream)), Cache(std::move(Cache)) {}
+ 
+   Error runThinLTOBackendThread(
+@@ -690,6 +688,7 @@ public:
+       const FunctionImporter::ExportSetTy &ExportList,
+       const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
+       MapVector<StringRef, BitcodeModule> &ModuleMap) override {
++#if 0
+     StringRef ModulePath = BM.getModuleIdentifier();
+     assert(ModuleToDefinedGVSummaries.count(ModulePath));
+     const GVSummaryMapTy &DefinedGlobals =
+@@ -716,11 +715,14 @@ public:
+         BM, std::ref(CombinedIndex), std::ref(ImportList),
+         std::ref(ExportList), std::ref(ResolvedODR), std::ref(DefinedGlobals),
+         std::ref(ModuleMap));
++#endif
+     return Error::success();
+   }
+ 
+   Error wait() override {
++#if 0
+     BackendThreadPool.wait();
++#endif
+     if (Err)
+       return std::move(*Err);
+     else
+diff --git a/lib/LTO/LTOBackend.cpp b/lib/LTO/LTOBackend.cpp
+index 809db80bc91..73a355ecf1a 100644
+--- a/lib/LTO/LTOBackend.cpp
++++ b/lib/LTO/LTOBackend.cpp
+@@ -216,6 +216,7 @@ void codegen(Config &Conf, TargetMachine *TM, AddStreamFn AddStream,
+ void splitCodeGen(Config &C, TargetMachine *TM, AddStreamFn AddStream,
+                   unsigned ParallelCodeGenParallelismLevel,
+                   std::unique_ptr<Module> Mod) {
++#if 0
+   ThreadPool CodegenThreadPool(ParallelCodeGenParallelismLevel);
+   unsigned ThreadCount = 0;
+   const Target *T = &TM->getTarget();
+@@ -259,6 +260,7 @@ void splitCodeGen(Config &C, TargetMachine *TM, AddStreamFn AddStream,
+   // variables, we need to wait for the worker threads to terminate before we
+   // can leave the function scope.
+   CodegenThreadPool.wait();
++#endif
+ }
+ 
+ Expected<const Target *> initAndLookupTarget(Config &C, Module &Mod) {
+diff --git a/lib/LTO/ThinLTOCodeGenerator.cpp b/lib/LTO/ThinLTOCodeGenerator.cpp
+index 40537e4fa78..470e9e57df5 100644
+--- a/lib/LTO/ThinLTOCodeGenerator.cpp
++++ b/lib/LTO/ThinLTOCodeGenerator.cpp
+@@ -70,8 +70,8 @@ extern cl::opt<bool> LTOPassRemarksWithHotness;
+ 
+ namespace {
+ 
+-static cl::opt<int>
+-    ThreadCount("threads", cl::init(llvm::heavyweight_hardware_concurrency()));
++static cl::opt<int> ThreadCount("threads",
++                                cl::init(1));
+ 
+ Expected<std::unique_ptr<tool_output_file>>
+ setupOptimizationRemarks(LLVMContext &Ctx, int Count) {
+@@ -830,6 +830,7 @@ static std::string writeGeneratedObject(int count, StringRef CacheEntryPath,
+ 
+ // Main entry point for the ThinLTO processing
+ void ThinLTOCodeGenerator::run() {
++#if 0
+   // Prepare the resulting object vector
+   assert(ProducedBinaries.empty() && "The generator should not be reused");
+   if (SavedObjectsDirectoryPath.empty())
+@@ -1052,4 +1053,5 @@ void ThinLTOCodeGenerator::run() {
+   // If statistics were requested, print them out now.
+   if (llvm::AreStatisticsEnabled())
+     llvm::PrintStatistics();
++#endif
+ }
+diff --git a/lib/Support/ThreadPool.cpp b/lib/Support/ThreadPool.cpp
+index db03a4d6240..71f49330f91 100644
+--- a/lib/Support/ThreadPool.cpp
++++ b/lib/Support/ThreadPool.cpp
+@@ -11,6 +11,8 @@
+ //
+ //===----------------------------------------------------------------------===//
+ 
++#if 0
++
+ #include "llvm/Support/ThreadPool.h"
+ 
+ #include "llvm/Config/llvm-config.h"
+@@ -18,7 +20,7 @@
+ 
+ using namespace llvm;
+ 
+-#if LLVM_ENABLE_THREADS
++#if LLVM_ENABLE_THREADS && 0
+ 
+ // Default to std::thread::hardware_concurrency
+ ThreadPool::ThreadPool() : ThreadPool(std::thread::hardware_concurrency()) {}
+@@ -156,3 +158,5 @@ ThreadPool::~ThreadPool() {
+ }
+ 
+ #endif
++
++#endif
+diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
+index c1667049f80..aa7d7f105b2 100644
+--- a/test/CMakeLists.txt
++++ b/test/CMakeLists.txt
+@@ -35,7 +35,6 @@ set(LLVM_TEST_DEPENDS
+           count
+           llc
+           lli
+-          lli-child-target
+           llvm-ar
+           llvm-as
+           llvm-bcanalyzer
+diff --git a/tools/lli/CMakeLists.txt b/tools/lli/CMakeLists.txt
+index f02e19313b7..ca2e82abcd0 100644
+--- a/tools/lli/CMakeLists.txt
++++ b/tools/lli/CMakeLists.txt
+@@ -1,7 +1,3 @@
+-if ( LLVM_INCLUDE_UTILS )
+-  add_subdirectory(ChildTarget)
+-endif()
+-
+ set(LLVM_LINK_COMPONENTS
+   CodeGen
+   Core
+diff --git a/tools/lli/ChildTarget/CMakeLists.txt b/tools/lli/ChildTarget/CMakeLists.txt
+deleted file mode 100644
+index f08ce57c295..00000000000
+--- a/tools/lli/ChildTarget/CMakeLists.txt
++++ /dev/null
+@@ -1,13 +0,0 @@
+-set(LLVM_LINK_COMPONENTS
+-  OrcJIT
+-  RuntimeDyld
+-  Support
+-  )
+-
+-add_llvm_utility(lli-child-target
+-  ChildTarget.cpp
+-
+-  DEPENDS
+-  intrinsics_gen
+-)
+-
+diff --git a/tools/lli/ChildTarget/ChildTarget.cpp b/tools/lli/ChildTarget/ChildTarget.cpp
+deleted file mode 100644
+index 77b1d47a946..00000000000
+--- a/tools/lli/ChildTarget/ChildTarget.cpp
++++ /dev/null
+@@ -1,67 +0,0 @@
+-#include "llvm/ExecutionEngine/Orc/OrcABISupport.h"
+-#include "llvm/ExecutionEngine/Orc/OrcRemoteTargetServer.h"
+-#include "llvm/Support/Debug.h"
+-#include "llvm/Support/DynamicLibrary.h"
+-#include "llvm/Support/Process.h"
+-#include <sstream>
+-
+-#include "../RemoteJITUtils.h"
+-
+-using namespace llvm;
+-using namespace llvm::orc;
+-using namespace llvm::sys;
+-
+-#ifdef __x86_64__
+-typedef OrcX86_64_SysV HostOrcArch;
+-#else
+-typedef OrcGenericABI HostOrcArch;
+-#endif
+-
+-ExitOnError ExitOnErr;
+-
+-int main(int argc, char *argv[]) {
+-
+-  if (argc != 3) {
+-    errs() << "Usage: " << argv[0] << " <input fd> <output fd>\n";
+-    return 1;
+-  }
+-
+-  ExitOnErr.setBanner(std::string(argv[0]) + ":");
+-
+-  int InFD;
+-  int OutFD;
+-  {
+-    std::istringstream InFDStream(argv[1]), OutFDStream(argv[2]);
+-    InFDStream >> InFD;
+-    OutFDStream >> OutFD;
+-  }
+-
+-  if (sys::DynamicLibrary::LoadLibraryPermanently(nullptr)) {
+-    errs() << "Error loading program symbols.\n";
+-    return 1;
+-  }
+-
+-  auto SymbolLookup = [](const std::string &Name) {
+-    return RTDyldMemoryManager::getSymbolAddressInProcess(Name);
+-  };
+-
+-  auto RegisterEHFrames = [](uint8_t *Addr, uint32_t Size) {
+-    RTDyldMemoryManager::registerEHFramesInProcess(Addr, Size);
+-  };
+-
+-  auto DeregisterEHFrames = [](uint8_t *Addr, uint32_t Size) {
+-    RTDyldMemoryManager::deregisterEHFramesInProcess(Addr, Size);
+-  };
+-
+-  FDRawChannel Channel(InFD, OutFD);
+-  typedef remote::OrcRemoteTargetServer<FDRawChannel, HostOrcArch> JITServer;
+-  JITServer Server(Channel, SymbolLookup, RegisterEHFrames, DeregisterEHFrames);
+-
+-  while (!Server.receivedTerminate())
+-    ExitOnErr(Server.handleOne());
+-
+-  close(InFD);
+-  close(OutFD);
+-
+-  return 0;
+-}
+diff --git a/tools/lli/ChildTarget/LLVMBuild.txt b/tools/lli/ChildTarget/LLVMBuild.txt
+deleted file mode 100644
+index daf6df11324..00000000000
+--- a/tools/lli/ChildTarget/LLVMBuild.txt
++++ /dev/null
+@@ -1,21 +0,0 @@
+-;===- ./tools/lli/ChildTarget/LLVMBuild.txt --------------------*- Conf -*--===;
+-;
+-;                     The LLVM Compiler Infrastructure
+-;
+-; This file is distributed under the University of Illinois Open Source
+-; License. See LICENSE.TXT for details.
+-;
+-;===------------------------------------------------------------------------===;
+-;
+-; This is an LLVMBuild description file for the components in this subdirectory.
+-;
+-; For more information on the LLVMBuild system, please see:
+-;
+-;   http://llvm.org/docs/LLVMBuild.html
+-;
+-;===------------------------------------------------------------------------===;
+-
+-[component_0]
+-type = Tool
+-name = lli-child-target
+-parent = lli
+diff --git a/tools/lli/LLVMBuild.txt b/tools/lli/LLVMBuild.txt
+index 9d889bf4c2e..47385048e08 100644
+--- a/tools/lli/LLVMBuild.txt
++++ b/tools/lli/LLVMBuild.txt
+@@ -15,9 +15,6 @@
+ ;
+ ;===------------------------------------------------------------------------===;
+ 
+-[common]
+-subdirectories = ChildTarget
+-
+ [component_0]
+ type = Tool
+ name = lli
+diff --git a/tools/lli/OrcLazyJIT.cpp b/tools/lli/OrcLazyJIT.cpp
+index ec61ce5e154..640cfd9b6ef 100644
+--- a/tools/lli/OrcLazyJIT.cpp
++++ b/tools/lli/OrcLazyJIT.cpp
+@@ -1,3 +1,4 @@
++#if 0
+ //===------ OrcLazyJIT.cpp - Basic Orc-based JIT for lazy execution -------===//
+ //
+ //                     The LLVM Compiler Infrastructure
+@@ -158,4 +159,4 @@ int llvm::runOrcLazyJIT(std::vector<std::unique_ptr<Module>> Ms,
+   auto Main = fromTargetAddress<MainFnPtr>(MainSym.getAddress());
+   return Main(ArgV.size(), (const char**)ArgV.data());
+ }
+-
++#endif
+diff --git a/tools/lli/OrcLazyJIT.h b/tools/lli/OrcLazyJIT.h
+deleted file mode 100644
+index 05319c34548..00000000000
+--- a/tools/lli/OrcLazyJIT.h
++++ /dev/null
+@@ -1,175 +0,0 @@
+-//===--- OrcLazyJIT.h - Basic Orc-based JIT for lazy execution --*- C++ -*-===//
+-//
+-//                     The LLVM Compiler Infrastructure
+-//
+-// This file is distributed under the University of Illinois Open Source
+-// License. See LICENSE.TXT for details.
+-//
+-//===----------------------------------------------------------------------===//
+-//
+-// Simple Orc-based JIT. Uses the compile-on-demand layer to break up and
+-// lazily compile modules.
+-//
+-//===----------------------------------------------------------------------===//
+-
+-#ifndef LLVM_TOOLS_LLI_ORCLAZYJIT_H
+-#define LLVM_TOOLS_LLI_ORCLAZYJIT_H
+-
+-#include "llvm/ADT/Triple.h"
+-#include "llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h"
+-#include "llvm/ExecutionEngine/Orc/CompileUtils.h"
+-#include "llvm/ExecutionEngine/Orc/ExecutionUtils.h"
+-#include "llvm/ExecutionEngine/Orc/IRCompileLayer.h"
+-#include "llvm/ExecutionEngine/Orc/IRTransformLayer.h"
+-#include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h"
+-#include "llvm/ExecutionEngine/RTDyldMemoryManager.h"
+-
+-namespace llvm {
+-
+-class OrcLazyJIT {
+-public:
+-
+-  typedef orc::JITCompileCallbackManager CompileCallbackMgr;
+-  typedef orc::ObjectLinkingLayer<> ObjLayerT;
+-  typedef orc::IRCompileLayer<ObjLayerT> CompileLayerT;
+-  typedef std::function<std::unique_ptr<Module>(std::unique_ptr<Module>)>
+-    TransformFtor;
+-  typedef orc::IRTransformLayer<CompileLayerT, TransformFtor> IRDumpLayerT;
+-  typedef orc::CompileOnDemandLayer<IRDumpLayerT, CompileCallbackMgr> CODLayerT;
+-  typedef CODLayerT::IndirectStubsManagerBuilderT
+-    IndirectStubsManagerBuilder;
+-  typedef CODLayerT::ModuleSetHandleT ModuleSetHandleT;
+-
+-  OrcLazyJIT(std::unique_ptr<TargetMachine> TM,
+-             std::unique_ptr<CompileCallbackMgr> CCMgr,
+-             IndirectStubsManagerBuilder IndirectStubsMgrBuilder,
+-             bool InlineStubs)
+-      : TM(std::move(TM)), DL(this->TM->createDataLayout()),
+-	CCMgr(std::move(CCMgr)),
+-	ObjectLayer(),
+-        CompileLayer(ObjectLayer, orc::SimpleCompiler(*this->TM)),
+-        IRDumpLayer(CompileLayer, createDebugDumper()),
+-        CODLayer(IRDumpLayer, extractSingleFunction, *this->CCMgr,
+-                 std::move(IndirectStubsMgrBuilder), InlineStubs),
+-        CXXRuntimeOverrides(
+-            [this](const std::string &S) { return mangle(S); }) {}
+-
+-  ~OrcLazyJIT() {
+-    // Run any destructors registered with __cxa_atexit.
+-    CXXRuntimeOverrides.runDestructors();
+-    // Run any IR destructors.
+-    for (auto &DtorRunner : IRStaticDestructorRunners)
+-      DtorRunner.runViaLayer(CODLayer);
+-  }
+-
+-  ModuleSetHandleT addModuleSet(std::vector<std::unique_ptr<Module>> Ms) {
+-    // Attach a data-layouts if they aren't already present.
+-    for (auto &M : Ms)
+-      if (M->getDataLayout().isDefault())
+-        M->setDataLayout(DL);
+-
+-    // Rename, bump linkage and record static constructors and destructors.
+-    // We have to do this before we hand over ownership of the module to the
+-    // JIT.
+-    std::vector<std::string> CtorNames, DtorNames;
+-    {
+-      unsigned CtorId = 0, DtorId = 0;
+-      for (auto &M : Ms) {
+-        for (auto Ctor : orc::getConstructors(*M)) {
+-          std::string NewCtorName = ("$static_ctor." + Twine(CtorId++)).str();
+-          Ctor.Func->setName(NewCtorName);
+-          Ctor.Func->setLinkage(GlobalValue::ExternalLinkage);
+-          Ctor.Func->setVisibility(GlobalValue::HiddenVisibility);
+-          CtorNames.push_back(mangle(NewCtorName));
+-        }
+-        for (auto Dtor : orc::getDestructors(*M)) {
+-          std::string NewDtorName = ("$static_dtor." + Twine(DtorId++)).str();
+-          Dtor.Func->setLinkage(GlobalValue::ExternalLinkage);
+-          Dtor.Func->setVisibility(GlobalValue::HiddenVisibility);
+-          DtorNames.push_back(mangle(Dtor.Func->getName()));
+-          Dtor.Func->setName(NewDtorName);
+-        }
+-      }
+-    }
+-
+-    // Symbol resolution order:
+-    //   1) Search the JIT symbols.
+-    //   2) Check for C++ runtime overrides.
+-    //   3) Search the host process (LLI)'s symbol table.
+-    auto Resolver =
+-      orc::createLambdaResolver(
+-        [this](const std::string &Name) -> JITSymbol {
+-          if (auto Sym = CODLayer.findSymbol(Name, true))
+-            return Sym;
+-          return CXXRuntimeOverrides.searchOverrides(Name);
+-        },
+-        [](const std::string &Name) {
+-          if (auto Addr =
+-              RTDyldMemoryManager::getSymbolAddressInProcess(Name))
+-            return JITSymbol(Addr, JITSymbolFlags::Exported);
+-          return JITSymbol(nullptr);
+-        }
+-      );
+-
+-    // Add the module to the JIT.
+-    auto H = CODLayer.addModuleSet(std::move(Ms),
+-				   llvm::make_unique<SectionMemoryManager>(),
+-				   std::move(Resolver));
+-
+-    // Run the static constructors, and save the static destructor runner for
+-    // execution when the JIT is torn down.
+-    orc::CtorDtorRunner<CODLayerT> CtorRunner(std::move(CtorNames), H);
+-    CtorRunner.runViaLayer(CODLayer);
+-
+-    IRStaticDestructorRunners.emplace_back(std::move(DtorNames), H);
+-
+-    return H;
+-  }
+-
+-  JITSymbol findSymbol(const std::string &Name) {
+-    return CODLayer.findSymbol(mangle(Name), true);
+-  }
+-
+-  JITSymbol findSymbolIn(ModuleSetHandleT H, const std::string &Name) {
+-    return CODLayer.findSymbolIn(H, mangle(Name), true);
+-  }
+-
+-private:
+-
+-  std::string mangle(const std::string &Name) {
+-    std::string MangledName;
+-    {
+-      raw_string_ostream MangledNameStream(MangledName);
+-      Mangler::getNameWithPrefix(MangledNameStream, Name, DL);
+-    }
+-    return MangledName;
+-  }
+-
+-  static std::set<Function*> extractSingleFunction(Function &F) {
+-    std::set<Function*> Partition;
+-    Partition.insert(&F);
+-    return Partition;
+-  }
+-
+-  static TransformFtor createDebugDumper();
+-
+-  std::unique_ptr<TargetMachine> TM;
+-  DataLayout DL;
+-  SectionMemoryManager CCMgrMemMgr;
+-
+-  std::unique_ptr<CompileCallbackMgr> CCMgr;
+-  ObjLayerT ObjectLayer;
+-  CompileLayerT CompileLayer;
+-  IRDumpLayerT IRDumpLayer;
+-  CODLayerT CODLayer;
+-
+-  orc::LocalCXXRuntimeOverrides CXXRuntimeOverrides;
+-  std::vector<orc::CtorDtorRunner<CODLayerT>> IRStaticDestructorRunners;
+-};
+-
+-int runOrcLazyJIT(std::vector<std::unique_ptr<Module>> Ms,
+-                  const std::vector<std::string> &Args);
+-
+-} // end namespace llvm
+-
+-#endif
+diff --git a/tools/lli/RemoteJITUtils.h b/tools/lli/RemoteJITUtils.h
+deleted file mode 100644
+index 89a51420256..00000000000
+--- a/tools/lli/RemoteJITUtils.h
++++ /dev/null
+@@ -1,153 +0,0 @@
+-//===-- RemoteJITUtils.h - Utilities for remote-JITing with LLI -*- C++ -*-===//
+-//
+-//                     The LLVM Compiler Infrastructure
+-//
+-// This file is distributed under the University of Illinois Open Source
+-// License. See LICENSE.TXT for details.
+-//
+-//===----------------------------------------------------------------------===//
+-//
+-// Utilities for remote-JITing with LLI.
+-//
+-//===----------------------------------------------------------------------===//
+-
+-#ifndef LLVM_TOOLS_LLI_REMOTEJITUTILS_H
+-#define LLVM_TOOLS_LLI_REMOTEJITUTILS_H
+-
+-#include "llvm/ExecutionEngine/Orc/RawByteChannel.h"
+-#include "llvm/ExecutionEngine/RTDyldMemoryManager.h"
+-#include <mutex>
+-
+-#if !defined(_MSC_VER) && !defined(__MINGW32__)
+-#include <unistd.h>
+-#else
+-#include <io.h>
+-#endif
+-
+-/// RPC channel that reads from and writes from file descriptors.
+-class FDRawChannel final : public llvm::orc::rpc::RawByteChannel {
+-public:
+-  FDRawChannel(int InFD, int OutFD) : InFD(InFD), OutFD(OutFD) {}
+-
+-  llvm::Error readBytes(char *Dst, unsigned Size) override {
+-    assert(Dst && "Attempt to read into null.");
+-    ssize_t Completed = 0;
+-    while (Completed < static_cast<ssize_t>(Size)) {
+-      ssize_t Read = ::read(InFD, Dst + Completed, Size - Completed);
+-      if (Read <= 0) {
+-        auto ErrNo = errno;
+-        if (ErrNo == EAGAIN || ErrNo == EINTR)
+-          continue;
+-        else
+-          return llvm::errorCodeToError(
+-                   std::error_code(errno, std::generic_category()));
+-      }
+-      Completed += Read;
+-    }
+-    return llvm::Error::success();
+-  }
+-
+-  llvm::Error appendBytes(const char *Src, unsigned Size) override {
+-    assert(Src && "Attempt to append from null.");
+-    ssize_t Completed = 0;
+-    while (Completed < static_cast<ssize_t>(Size)) {
+-      ssize_t Written = ::write(OutFD, Src + Completed, Size - Completed);
+-      if (Written < 0) {
+-        auto ErrNo = errno;
+-        if (ErrNo == EAGAIN || ErrNo == EINTR)
+-          continue;
+-        else
+-          return llvm::errorCodeToError(
+-                   std::error_code(errno, std::generic_category()));
+-      }
+-      Completed += Written;
+-    }
+-    return llvm::Error::success();
+-  }
+-
+-  llvm::Error send() override { return llvm::Error::success(); }
+-
+-private:
+-  int InFD, OutFD;
+-};
+-
+-// launch the remote process (see lli.cpp) and return a channel to it.
+-std::unique_ptr<FDRawChannel> launchRemote();
+-
+-namespace llvm {
+-
+-// ForwardingMM - Adapter to connect MCJIT to Orc's Remote8
+-// memory manager.
+-class ForwardingMemoryManager : public llvm::RTDyldMemoryManager {
+-public:
+-  void setMemMgr(std::unique_ptr<RuntimeDyld::MemoryManager> MemMgr) {
+-    this->MemMgr = std::move(MemMgr);
+-  }
+-
+-  void setResolver(std::unique_ptr<JITSymbolResolver> Resolver) {
+-    this->Resolver = std::move(Resolver);
+-  }
+-
+-  uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
+-                               unsigned SectionID,
+-                               StringRef SectionName) override {
+-    return MemMgr->allocateCodeSection(Size, Alignment, SectionID, SectionName);
+-  }
+-
+-  uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
+-                               unsigned SectionID, StringRef SectionName,
+-                               bool IsReadOnly) override {
+-    return MemMgr->allocateDataSection(Size, Alignment, SectionID, SectionName,
+-                                       IsReadOnly);
+-  }
+-
+-  void reserveAllocationSpace(uintptr_t CodeSize, uint32_t CodeAlign,
+-                              uintptr_t RODataSize, uint32_t RODataAlign,
+-                              uintptr_t RWDataSize,
+-                              uint32_t RWDataAlign) override {
+-    MemMgr->reserveAllocationSpace(CodeSize, CodeAlign, RODataSize, RODataAlign,
+-                                   RWDataSize, RWDataAlign);
+-  }
+-
+-  bool needsToReserveAllocationSpace() override {
+-    return MemMgr->needsToReserveAllocationSpace();
+-  }
+-
+-  void registerEHFrames(uint8_t *Addr, uint64_t LoadAddr,
+-                        size_t Size) override {
+-    MemMgr->registerEHFrames(Addr, LoadAddr, Size);
+-  }
+-
+-  void deregisterEHFrames(uint8_t *Addr, uint64_t LoadAddr,
+-                          size_t Size) override {
+-    MemMgr->deregisterEHFrames(Addr, LoadAddr, Size);
+-  }
+-
+-  bool finalizeMemory(std::string *ErrMsg = nullptr) override {
+-    return MemMgr->finalizeMemory(ErrMsg);
+-  }
+-
+-  void notifyObjectLoaded(RuntimeDyld &RTDyld,
+-                          const object::ObjectFile &Obj) override {
+-    MemMgr->notifyObjectLoaded(RTDyld, Obj);
+-  }
+-
+-  // Don't hide the sibling notifyObjectLoaded from RTDyldMemoryManager.
+-  using RTDyldMemoryManager::notifyObjectLoaded;
+-
+-  JITSymbol findSymbol(const std::string &Name) override {
+-    return Resolver->findSymbol(Name);
+-  }
+-
+-  JITSymbol
+-  findSymbolInLogicalDylib(const std::string &Name) override {
+-    return Resolver->findSymbolInLogicalDylib(Name);
+-  }
+-
+-private:
+-  std::unique_ptr<RuntimeDyld::MemoryManager> MemMgr;
+-  std::unique_ptr<JITSymbolResolver> Resolver;
+-};
+-}
+-
+-#endif
+diff --git a/tools/lli/lli.cpp b/tools/lli/lli.cpp
+index 0823ff469de..8e9b9f87577 100644
+--- a/tools/lli/lli.cpp
++++ b/tools/lli/lli.cpp
+@@ -13,6 +13,8 @@
+ //
+ //===----------------------------------------------------------------------===//
+ 
++#if 0
++
+ #include "OrcLazyJIT.h"
+ #include "RemoteJITUtils.h"
+ #include "llvm/IR/LLVMContext.h"
+@@ -758,3 +760,8 @@ std::unique_ptr<FDRawChannel> launchRemote() {
+   return llvm::make_unique<FDRawChannel>(PipeFD[1][0], PipeFD[0][1]);
+ #endif
+ }
++#endif
++
++int main(int argc, char **argv, char * const *envp) {
++  return 0;
++}
+diff --git a/tools/llvm-cov/CodeCoverage.cpp b/tools/llvm-cov/CodeCoverage.cpp
+index 0a9807ab003..0b7ffd366b9 100644
+--- a/tools/llvm-cov/CodeCoverage.cpp
++++ b/tools/llvm-cov/CodeCoverage.cpp
+@@ -1,3 +1,4 @@
++#if 0
+ //===- CodeCoverage.cpp - Coverage tool based on profiling instrumentation-===//
+ //
+ //                     The LLVM Compiler Infrastructure
+@@ -864,7 +865,10 @@ int reportMain(int argc, const char *argv[]) {
+   return Tool.run(CodeCoverageTool::Report, argc, argv);
+ }
+ 
++
+ int exportMain(int argc, const char *argv[]) {
+   CodeCoverageTool Tool;
+   return Tool.run(CodeCoverageTool::Export, argc, argv);
+ }
++
++#endif
+diff --git a/tools/llvm-cov/CoverageExporterJson.cpp b/tools/llvm-cov/CoverageExporterJson.cpp
+index ef50bba2123..d3d0a8f5f01 100644
+--- a/tools/llvm-cov/CoverageExporterJson.cpp
++++ b/tools/llvm-cov/CoverageExporterJson.cpp
+@@ -1,3 +1,4 @@
++#if 0
+ //===- CoverageExporterJson.cpp - Code coverage export --------------------===//
+ //
+ //                     The LLVM Compiler Infrastructure
+@@ -419,3 +420,4 @@ void exportCoverageDataToJson(const CoverageMapping &CoverageMapping,
+ 
+   Exporter.print();
+ }
++#endif
+diff --git a/tools/llvm-cov/CoverageFilters.cpp b/tools/llvm-cov/CoverageFilters.cpp
+index 325dd723578..8a41ba8c1d8 100644
+--- a/tools/llvm-cov/CoverageFilters.cpp
++++ b/tools/llvm-cov/CoverageFilters.cpp
+@@ -1,3 +1,4 @@
++#if 0
+ //===- CoverageFilters.cpp - Function coverage mapping filters ------------===//
+ //
+ //                     The LLVM Compiler Infrastructure
+@@ -57,3 +58,4 @@ CoverageFiltersMatchAll::matches(const coverage::FunctionRecord &Function) {
+   }
+   return true;
+ }
++#endif
+diff --git a/tools/llvm-cov/CoverageFilters.h b/tools/llvm-cov/CoverageFilters.h
+deleted file mode 100644
+index 756c4b47872..00000000000
+--- a/tools/llvm-cov/CoverageFilters.h
++++ /dev/null
+@@ -1,127 +0,0 @@
+-//===- CoverageFilters.h - Function coverage mapping filters --------------===//
+-//
+-//                     The LLVM Compiler Infrastructure
+-//
+-// This file is distributed under the University of Illinois Open Source
+-// License. See LICENSE.TXT for details.
+-//
+-//===----------------------------------------------------------------------===//
+-//
+-// These classes provide filtering for function coverage mapping records.
+-//
+-//===----------------------------------------------------------------------===//
+-
+-#ifndef LLVM_COV_COVERAGEFILTERS_H
+-#define LLVM_COV_COVERAGEFILTERS_H
+-
+-#include "llvm/ProfileData/Coverage/CoverageMapping.h"
+-#include <memory>
+-#include <vector>
+-
+-namespace llvm {
+-
+-/// \brief Matches specific functions that pass the requirement of this filter.
+-class CoverageFilter {
+-public:
+-  virtual ~CoverageFilter() {}
+-
+-  /// \brief Return true if the function passes the requirements of this filter.
+-  virtual bool matches(const coverage::FunctionRecord &Function) {
+-    return true;
+-  }
+-};
+-
+-/// \brief Matches functions that contain a specific string in their name.
+-class NameCoverageFilter : public CoverageFilter {
+-  StringRef Name;
+-
+-public:
+-  NameCoverageFilter(StringRef Name) : Name(Name) {}
+-
+-  bool matches(const coverage::FunctionRecord &Function) override;
+-};
+-
+-/// \brief Matches functions whose name matches a certain regular expression.
+-class NameRegexCoverageFilter : public CoverageFilter {
+-  StringRef Regex;
+-
+-public:
+-  NameRegexCoverageFilter(StringRef Regex) : Regex(Regex) {}
+-
+-  bool matches(const coverage::FunctionRecord &Function) override;
+-};
+-
+-/// \brief Matches numbers that pass a certain threshold.
+-template <typename T> class StatisticThresholdFilter {
+-public:
+-  enum Operation { LessThan, GreaterThan };
+-
+-protected:
+-  Operation Op;
+-  T Threshold;
+-
+-  StatisticThresholdFilter(Operation Op, T Threshold)
+-      : Op(Op), Threshold(Threshold) {}
+-
+-  /// \brief Return true if the given number is less than
+-  /// or greater than the certain threshold.
+-  bool PassesThreshold(T Value) const {
+-    switch (Op) {
+-    case LessThan:
+-      return Value < Threshold;
+-    case GreaterThan:
+-      return Value > Threshold;
+-    }
+-    return false;
+-  }
+-};
+-
+-/// \brief Matches functions whose region coverage percentage
+-/// is above/below a certain percentage.
+-class RegionCoverageFilter : public CoverageFilter,
+-                             public StatisticThresholdFilter<double> {
+-public:
+-  RegionCoverageFilter(Operation Op, double Threshold)
+-      : StatisticThresholdFilter(Op, Threshold) {}
+-
+-  bool matches(const coverage::FunctionRecord &Function) override;
+-};
+-
+-/// \brief Matches functions whose line coverage percentage
+-/// is above/below a certain percentage.
+-class LineCoverageFilter : public CoverageFilter,
+-                           public StatisticThresholdFilter<double> {
+-public:
+-  LineCoverageFilter(Operation Op, double Threshold)
+-      : StatisticThresholdFilter(Op, Threshold) {}
+-
+-  bool matches(const coverage::FunctionRecord &Function) override;
+-};
+-
+-/// \brief A collection of filters.
+-/// Matches functions that match any filters contained
+-/// in an instance of this class.
+-class CoverageFilters : public CoverageFilter {
+-protected:
+-  std::vector<std::unique_ptr<CoverageFilter>> Filters;
+-
+-public:
+-  /// \brief Append a filter to this collection.
+-  void push_back(std::unique_ptr<CoverageFilter> Filter);
+-
+-  bool empty() const { return Filters.empty(); }
+-
+-  bool matches(const coverage::FunctionRecord &Function) override;
+-};
+-
+-/// \brief A collection of filters.
+-/// Matches functions that match all of the filters contained
+-/// in an instance of this class.
+-class CoverageFiltersMatchAll : public CoverageFilters {
+-public:
+-  bool matches(const coverage::FunctionRecord &Function) override;
+-};
+-
+-} // namespace llvm
+-
+-#endif // LLVM_COV_COVERAGEFILTERS_H
+diff --git a/tools/llvm-cov/CoverageReport.cpp b/tools/llvm-cov/CoverageReport.cpp
+index e88cb186acd..67fdaa6f57e 100644
+--- a/tools/llvm-cov/CoverageReport.cpp
++++ b/tools/llvm-cov/CoverageReport.cpp
+@@ -1,3 +1,4 @@
++#if 0
+ //===- CoverageReport.cpp - Code coverage report -------------------------===//
+ //
+ //                     The LLVM Compiler Infrastructure
+@@ -353,3 +354,4 @@ void CoverageReport::renderFileReports(raw_ostream &OS,
+ }
+ 
+ } // end namespace llvm
++#endif
+diff --git a/tools/llvm-cov/CoverageReport.h b/tools/llvm-cov/CoverageReport.h
+deleted file mode 100644
+index 7a416497e25..00000000000
+--- a/tools/llvm-cov/CoverageReport.h
++++ /dev/null
+@@ -1,51 +0,0 @@
+-//===- CoverageReport.h - Code coverage report ---------------------------===//
+-//
+-//                     The LLVM Compiler Infrastructure
+-//
+-// This file is distributed under the University of Illinois Open Source
+-// License. See LICENSE.TXT for details.
+-//
+-//===----------------------------------------------------------------------===//
+-//
+-// This class implements rendering of a code coverage report.
+-//
+-//===----------------------------------------------------------------------===//
+-
+-#ifndef LLVM_COV_COVERAGEREPORT_H
+-#define LLVM_COV_COVERAGEREPORT_H
+-
+-#include "CoverageSummaryInfo.h"
+-#include "CoverageViewOptions.h"
+-
+-namespace llvm {
+-
+-/// \brief Displays the code coverage report.
+-class CoverageReport {
+-  const CoverageViewOptions &Options;
+-  const coverage::CoverageMapping &Coverage;
+-
+-  void render(const FileCoverageSummary &File, raw_ostream &OS) const;
+-  void render(const FunctionCoverageSummary &Function, raw_ostream &OS) const;
+-
+-public:
+-  CoverageReport(const CoverageViewOptions &Options,
+-                 const coverage::CoverageMapping &Coverage)
+-      : Options(Options), Coverage(Coverage) {}
+-
+-  void renderFunctionReports(ArrayRef<std::string> Files, raw_ostream &OS);
+-
+-  /// Prepare file reports for the files specified in \p Files.
+-  static std::vector<FileCoverageSummary>
+-  prepareFileReports(const coverage::CoverageMapping &Coverage,
+-                     FileCoverageSummary &Totals, ArrayRef<std::string> Files);
+-
+-  /// Render file reports for every unique file in the coverage mapping.
+-  void renderFileReports(raw_ostream &OS) const;
+-
+-  /// Render file reports for the files specified in \p Files.
+-  void renderFileReports(raw_ostream &OS, ArrayRef<std::string> Files) const;
+-};
+-
+-} // end namespace llvm
+-
+-#endif // LLVM_COV_COVERAGEREPORT_H
+diff --git a/tools/llvm-cov/CoverageSummaryInfo.cpp b/tools/llvm-cov/CoverageSummaryInfo.cpp
+index 21aa7ff73a0..5a325b40cf8 100644
+--- a/tools/llvm-cov/CoverageSummaryInfo.cpp
++++ b/tools/llvm-cov/CoverageSummaryInfo.cpp
+@@ -1,3 +1,4 @@
++#if 0
+ //===- CoverageSummaryInfo.cpp - Coverage summary for function/file -------===//
+ //
+ //                     The LLVM Compiler Infrastructure
+@@ -81,3 +82,4 @@ void FunctionCoverageSummary::update(const FunctionCoverageSummary &Summary) {
+   LineCoverage.NotCovered =
+       std::min(LineCoverage.NotCovered, Summary.LineCoverage.NotCovered);
+ }
++#endif
+diff --git a/tools/llvm-cov/CoverageSummaryInfo.h b/tools/llvm-cov/CoverageSummaryInfo.h
+deleted file mode 100644
+index c04a4d42ccd..00000000000
+--- a/tools/llvm-cov/CoverageSummaryInfo.h
++++ /dev/null
+@@ -1,165 +0,0 @@
+-//===- CoverageSummaryInfo.h - Coverage summary for function/file ---------===//
+-//
+-//                     The LLVM Compiler Infrastructure
+-//
+-// This file is distributed under the University of Illinois Open Source
+-// License. See LICENSE.TXT for details.
+-//
+-//===----------------------------------------------------------------------===//
+-//
+-// These structures are used to represent code coverage metrics
+-// for functions/files.
+-//
+-//===----------------------------------------------------------------------===//
+-
+-#ifndef LLVM_COV_COVERAGESUMMARYINFO_H
+-#define LLVM_COV_COVERAGESUMMARYINFO_H
+-
+-#include "llvm/ProfileData/Coverage/CoverageMapping.h"
+-#include "llvm/Support/raw_ostream.h"
+-
+-namespace llvm {
+-
+-/// \brief Provides information about region coverage for a function/file.
+-struct RegionCoverageInfo {
+-  /// \brief The number of regions that were executed at least once.
+-  size_t Covered;
+-
+-  /// \brief The number of regions that weren't executed.
+-  size_t NotCovered;
+-
+-  /// \brief The total number of regions in a function/file.
+-  size_t NumRegions;
+-
+-  RegionCoverageInfo() : Covered(0), NotCovered(0), NumRegions(0) {}
+-
+-  RegionCoverageInfo(size_t Covered, size_t NumRegions)
+-      : Covered(Covered), NotCovered(NumRegions - Covered),
+-        NumRegions(NumRegions) {}
+-
+-  RegionCoverageInfo &operator+=(const RegionCoverageInfo &RHS) {
+-    Covered += RHS.Covered;
+-    NotCovered += RHS.NotCovered;
+-    NumRegions += RHS.NumRegions;
+-    return *this;
+-  }
+-
+-  bool isFullyCovered() const { return Covered == NumRegions; }
+-
+-  double getPercentCovered() const {
+-    if (NumRegions == 0)
+-      return 0.0;
+-    return double(Covered) / double(NumRegions) * 100.0;
+-  }
+-};
+-
+-/// \brief Provides information about line coverage for a function/file.
+-struct LineCoverageInfo {
+-  /// \brief The number of lines that were executed at least once.
+-  size_t Covered;
+-
+-  /// \brief The number of lines that weren't executed.
+-  size_t NotCovered;
+-
+-  /// \brief The total number of lines in a function/file.
+-  size_t NumLines;
+-
+-  LineCoverageInfo() : Covered(0), NotCovered(0), NumLines(0) {}
+-
+-  LineCoverageInfo(size_t Covered, size_t NumLines)
+-      : Covered(Covered), NotCovered(NumLines - Covered), NumLines(NumLines) {}
+-
+-  LineCoverageInfo &operator+=(const LineCoverageInfo &RHS) {
+-    Covered += RHS.Covered;
+-    NotCovered += RHS.NotCovered;
+-    NumLines += RHS.NumLines;
+-    return *this;
+-  }
+-
+-  bool isFullyCovered() const { return Covered == NumLines; }
+-
+-  double getPercentCovered() const {
+-    if (NumLines == 0)
+-      return 0.0;
+-    return double(Covered) / double(NumLines) * 100.0;
+-  }
+-};
+-
+-/// \brief Provides information about function coverage for a file.
+-struct FunctionCoverageInfo {
+-  /// \brief The number of functions that were executed.
+-  size_t Executed;
+-
+-  /// \brief The total number of functions in this file.
+-  size_t NumFunctions;
+-
+-  FunctionCoverageInfo() : Executed(0), NumFunctions(0) {}
+-
+-  FunctionCoverageInfo(size_t Executed, size_t NumFunctions)
+-      : Executed(Executed), NumFunctions(NumFunctions) {}
+-
+-  void addFunction(bool Covered) {
+-    if (Covered)
+-      ++Executed;
+-    ++NumFunctions;
+-  }
+-
+-  bool isFullyCovered() const { return Executed == NumFunctions; }
+-
+-  double getPercentCovered() const {
+-    if (NumFunctions == 0)
+-      return 0.0;
+-    return double(Executed) / double(NumFunctions) * 100.0;
+-  }
+-};
+-
+-/// \brief A summary of function's code coverage.
+-struct FunctionCoverageSummary {
+-  StringRef Name;
+-  uint64_t ExecutionCount;
+-  RegionCoverageInfo RegionCoverage;
+-  LineCoverageInfo LineCoverage;
+-
+-  FunctionCoverageSummary(StringRef Name) : Name(Name), ExecutionCount(0) {}
+-
+-  FunctionCoverageSummary(StringRef Name, uint64_t ExecutionCount,
+-                          const RegionCoverageInfo &RegionCoverage,
+-                          const LineCoverageInfo &LineCoverage)
+-      : Name(Name), ExecutionCount(ExecutionCount),
+-        RegionCoverage(RegionCoverage), LineCoverage(LineCoverage) {
+-  }
+-
+-  /// \brief Compute the code coverage summary for the given function coverage
+-  /// mapping record.
+-  static FunctionCoverageSummary
+-  get(const coverage::FunctionRecord &Function);
+-
+-  /// \brief Update the summary with information from another instantiation
+-  /// of this function.
+-  void update(const FunctionCoverageSummary &Summary);
+-};
+-
+-/// \brief A summary of file's code coverage.
+-struct FileCoverageSummary {
+-  StringRef Name;
+-  RegionCoverageInfo RegionCoverage;
+-  LineCoverageInfo LineCoverage;
+-  FunctionCoverageInfo FunctionCoverage;
+-  FunctionCoverageInfo InstantiationCoverage;
+-
+-  FileCoverageSummary(StringRef Name) : Name(Name) {}
+-
+-  void addFunction(const FunctionCoverageSummary &Function) {
+-    RegionCoverage += Function.RegionCoverage;
+-    LineCoverage += Function.LineCoverage;
+-    FunctionCoverage.addFunction(/*Covered=*/Function.ExecutionCount > 0);
+-  }
+-
+-  void addInstantiation(const FunctionCoverageSummary &Function) {
+-    InstantiationCoverage.addFunction(/*Covered=*/Function.ExecutionCount > 0);
+-  }
+-};
+-
+-} // namespace llvm
+-
+-#endif // LLVM_COV_COVERAGESUMMARYINFO_H
+diff --git a/tools/llvm-cov/CoverageViewOptions.h b/tools/llvm-cov/CoverageViewOptions.h
+deleted file mode 100644
+index 266b380b7d3..00000000000
+--- a/tools/llvm-cov/CoverageViewOptions.h
++++ /dev/null
+@@ -1,68 +0,0 @@
+-//===- CoverageViewOptions.h - Code coverage display options -------------===//
+-//
+-//                     The LLVM Compiler Infrastructure
+-//
+-// This file is distributed under the University of Illinois Open Source
+-// License. See LICENSE.TXT for details.
+-//
+-//===----------------------------------------------------------------------===//
+-
+-#ifndef LLVM_COV_COVERAGEVIEWOPTIONS_H
+-#define LLVM_COV_COVERAGEVIEWOPTIONS_H
+-
+-#include "RenderingSupport.h"
+-#include <vector>
+-
+-namespace llvm {
+-
+-/// \brief The options for displaying the code coverage information.
+-struct CoverageViewOptions {
+-  enum class OutputFormat {
+-    Text,
+-    HTML
+-  };
+-
+-  bool Debug;
+-  bool Colors;
+-  bool ShowLineNumbers;
+-  bool ShowLineStats;
+-  bool ShowRegionMarkers;
+-  bool ShowLineStatsOrRegionMarkers;
+-  bool ShowExpandedRegions;
+-  bool ShowFunctionInstantiations;
+-  bool ShowFullFilenames;
+-  OutputFormat Format;
+-  std::string ShowOutputDirectory;
+-  std::vector<std::string> DemanglerOpts;
+-  uint32_t TabSize;
+-  std::string ProjectTitle;
+-  std::string CreatedTimeStr;
+-
+-  /// \brief Change the output's stream color if the colors are enabled.
+-  ColoredRawOstream colored_ostream(raw_ostream &OS,
+-                                    raw_ostream::Colors Color) const {
+-    return llvm::colored_ostream(OS, Color, Colors);
+-  }
+-
+-  /// \brief Check if an output directory has been specified.
+-  bool hasOutputDirectory() const { return !ShowOutputDirectory.empty(); }
+-
+-  /// \brief Check if a demangler has been specified.
+-  bool hasDemangler() const { return !DemanglerOpts.empty(); }
+-
+-  /// \brief Check if a project title has been specified.
+-  bool hasProjectTitle() const { return !ProjectTitle.empty(); }
+-
+-  /// \brief Check if the created time of the profile data file is available.
+-  bool hasCreatedTime() const { return !CreatedTimeStr.empty(); }
+-
+-  /// \brief Get the LLVM version string.
+-  std::string getLLVMVersionString() const {
+-    std::string VersionString = "Generated by llvm-cov -- llvm version ";
+-    VersionString += LLVM_VERSION_STRING;
+-    return VersionString;
+-  }
+-};
+-}
+-
+-#endif // LLVM_COV_COVERAGEVIEWOPTIONS_H
+diff --git a/tools/llvm-cov/RenderingSupport.h b/tools/llvm-cov/RenderingSupport.h
+deleted file mode 100644
+index aa70fbc23e3..00000000000
+--- a/tools/llvm-cov/RenderingSupport.h
++++ /dev/null
+@@ -1,61 +0,0 @@
+-//===- RenderingSupport.h - output stream rendering support functions  ----===//
+-//
+-//                     The LLVM Compiler Infrastructure
+-//
+-// This file is distributed under the University of Illinois Open Source
+-// License. See LICENSE.TXT for details.
+-//
+-//===----------------------------------------------------------------------===//
+-
+-#ifndef LLVM_COV_RENDERINGSUPPORT_H
+-#define LLVM_COV_RENDERINGSUPPORT_H
+-
+-#include "llvm/Support/raw_ostream.h"
+-#include <utility>
+-
+-namespace llvm {
+-
+-/// \brief A helper class that resets the output stream's color if needed
+-/// when destroyed.
+-class ColoredRawOstream {
+-  ColoredRawOstream(const ColoredRawOstream &OS) = delete;
+-
+-public:
+-  raw_ostream &OS;
+-  bool IsColorUsed;
+-
+-  ColoredRawOstream(raw_ostream &OS, bool IsColorUsed)
+-      : OS(OS), IsColorUsed(IsColorUsed) {}
+-
+-  ColoredRawOstream(ColoredRawOstream &&Other)
+-      : OS(Other.OS), IsColorUsed(Other.IsColorUsed) {
+-    // Reset the other IsColorUsed so that the other object won't reset the
+-    // color when destroyed.
+-    Other.IsColorUsed = false;
+-  }
+-
+-  ~ColoredRawOstream() {
+-    if (IsColorUsed)
+-      OS.resetColor();
+-  }
+-};
+-
+-template <typename T>
+-inline raw_ostream &operator<<(const ColoredRawOstream &OS, T &&Value) {
+-  return OS.OS << std::forward<T>(Value);
+-}
+-
+-/// \brief Change the color of the output stream if the `IsColorUsed` flag
+-/// is true. Returns an object that resets the color when destroyed.
+-inline ColoredRawOstream colored_ostream(raw_ostream &OS,
+-                                         raw_ostream::Colors Color,
+-                                         bool IsColorUsed = true,
+-                                         bool Bold = false, bool BG = false) {
+-  if (IsColorUsed)
+-    OS.changeColor(Color, Bold, BG);
+-  return ColoredRawOstream(OS, IsColorUsed);
+-}
+-
+-} // namespace llvm
+-
+-#endif // LLVM_COV_RENDERINGSUPPORT_H
+diff --git a/tools/llvm-cov/SourceCoverageView.cpp b/tools/llvm-cov/SourceCoverageView.cpp
+index 52b8ff1747f..84c2cb7e8d6 100644
+--- a/tools/llvm-cov/SourceCoverageView.cpp
++++ b/tools/llvm-cov/SourceCoverageView.cpp
+@@ -1,3 +1,4 @@
++#if 0
+ //===- SourceCoverageView.cpp - Code coverage view for source code --------===//
+ //
+ //                     The LLVM Compiler Infrastructure
+@@ -265,3 +266,4 @@ void SourceCoverageView::print(raw_ostream &OS, bool WholeFile,
+ 
+   renderViewFooter(OS);
+ }
++#endif
+diff --git a/tools/llvm-cov/SourceCoverageView.h b/tools/llvm-cov/SourceCoverageView.h
+deleted file mode 100644
+index 9cb608fed60..00000000000
+--- a/tools/llvm-cov/SourceCoverageView.h
++++ /dev/null
+@@ -1,289 +0,0 @@
+-//===- SourceCoverageView.h - Code coverage view for source code ----------===//
+-//
+-//                     The LLVM Compiler Infrastructure
+-//
+-// This file is distributed under the University of Illinois Open Source
+-// License. See LICENSE.TXT for details.
+-//
+-//===----------------------------------------------------------------------===//
+-///
+-/// \file This class implements rendering for code coverage of source code.
+-///
+-//===----------------------------------------------------------------------===//
+-
+-#ifndef LLVM_COV_SOURCECOVERAGEVIEW_H
+-#define LLVM_COV_SOURCECOVERAGEVIEW_H
+-
+-#include "CoverageViewOptions.h"
+-#include "llvm/ProfileData/Coverage/CoverageMapping.h"
+-#include "llvm/Support/MemoryBuffer.h"
+-#include <vector>
+-
+-namespace llvm {
+-
+-class SourceCoverageView;
+-
+-/// \brief A view that represents a macro or include expansion.
+-struct ExpansionView {
+-  coverage::CounterMappingRegion Region;
+-  std::unique_ptr<SourceCoverageView> View;
+-
+-  ExpansionView(const coverage::CounterMappingRegion &Region,
+-                std::unique_ptr<SourceCoverageView> View)
+-      : Region(Region), View(std::move(View)) {}
+-  ExpansionView(ExpansionView &&RHS)
+-      : Region(std::move(RHS.Region)), View(std::move(RHS.View)) {}
+-  ExpansionView &operator=(ExpansionView &&RHS) {
+-    Region = std::move(RHS.Region);
+-    View = std::move(RHS.View);
+-    return *this;
+-  }
+-
+-  unsigned getLine() const { return Region.LineStart; }
+-  unsigned getStartCol() const { return Region.ColumnStart; }
+-  unsigned getEndCol() const { return Region.ColumnEnd; }
+-
+-  friend bool operator<(const ExpansionView &LHS, const ExpansionView &RHS) {
+-    return LHS.Region.startLoc() < RHS.Region.startLoc();
+-  }
+-};
+-
+-/// \brief A view that represents a function instantiation.
+-struct InstantiationView {
+-  StringRef FunctionName;
+-  unsigned Line;
+-  std::unique_ptr<SourceCoverageView> View;
+-
+-  InstantiationView(StringRef FunctionName, unsigned Line,
+-                    std::unique_ptr<SourceCoverageView> View)
+-      : FunctionName(FunctionName), Line(Line), View(std::move(View)) {}
+-
+-  friend bool operator<(const InstantiationView &LHS,
+-                        const InstantiationView &RHS) {
+-    return LHS.Line < RHS.Line;
+-  }
+-};
+-
+-/// \brief Coverage statistics for a single line.
+-struct LineCoverageStats {
+-  uint64_t ExecutionCount;
+-  unsigned RegionCount;
+-  bool Mapped;
+-
+-  LineCoverageStats() : ExecutionCount(0), RegionCount(0), Mapped(false) {}
+-
+-  bool isMapped() const { return Mapped; }
+-
+-  bool hasMultipleRegions() const { return RegionCount > 1; }
+-
+-  void addRegionStartCount(uint64_t Count) {
+-    // The max of all region starts is the most interesting value.
+-    addRegionCount(RegionCount ? std::max(ExecutionCount, Count) : Count);
+-    ++RegionCount;
+-  }
+-
+-  void addRegionCount(uint64_t Count) {
+-    Mapped = true;
+-    ExecutionCount = Count;
+-  }
+-};
+-
+-/// \brief A file manager that handles format-aware file creation.
+-class CoveragePrinter {
+-public:
+-  struct StreamDestructor {
+-    void operator()(raw_ostream *OS) const;
+-  };
+-
+-  using OwnedStream = std::unique_ptr<raw_ostream, StreamDestructor>;
+-
+-protected:
+-  const CoverageViewOptions &Opts;
+-
+-  CoveragePrinter(const CoverageViewOptions &Opts) : Opts(Opts) {}
+-
+-  /// \brief Return `OutputDir/ToplevelDir/Path.Extension`. If \p InToplevel is
+-  /// false, skip the ToplevelDir component. If \p Relative is false, skip the
+-  /// OutputDir component.
+-  std::string getOutputPath(StringRef Path, StringRef Extension,
+-                            bool InToplevel, bool Relative = true) const;
+-
+-  /// \brief If directory output is enabled, create a file in that directory
+-  /// at the path given by getOutputPath(). Otherwise, return stdout.
+-  Expected<OwnedStream> createOutputStream(StringRef Path, StringRef Extension,
+-                                           bool InToplevel) const;
+-
+-  /// \brief Return the sub-directory name for file coverage reports.
+-  static StringRef getCoverageDir() { return "coverage"; }
+-
+-public:
+-  static std::unique_ptr<CoveragePrinter>
+-  create(const CoverageViewOptions &Opts);
+-
+-  virtual ~CoveragePrinter() {}
+-
+-  /// @name File Creation Interface
+-  /// @{
+-
+-  /// \brief Create a file to print a coverage view into.
+-  virtual Expected<OwnedStream> createViewFile(StringRef Path,
+-                                               bool InToplevel) = 0;
+-
+-  /// \brief Close a file which has been used to print a coverage view.
+-  virtual void closeViewFile(OwnedStream OS) = 0;
+-
+-  /// \brief Create an index which lists reports for the given source files.
+-  virtual Error createIndexFile(ArrayRef<std::string> SourceFiles,
+-                                const coverage::CoverageMapping &Coverage) = 0;
+-
+-  /// @}
+-};
+-
+-/// \brief A code coverage view of a source file or function.
+-///
+-/// A source coverage view and its nested sub-views form a file-oriented
+-/// representation of code coverage data. This view can be printed out by a
+-/// renderer which implements the Rendering Interface.
+-class SourceCoverageView {
+-  /// A function or file name.
+-  StringRef SourceName;
+-
+-  /// A memory buffer backing the source on display.
+-  const MemoryBuffer &File;
+-
+-  /// Various options to guide the coverage renderer.
+-  const CoverageViewOptions &Options;
+-
+-  /// Complete coverage information about the source on display.
+-  coverage::CoverageData CoverageInfo;
+-
+-  /// A container for all expansions (e.g macros) in the source on display.
+-  std::vector<ExpansionView> ExpansionSubViews;
+-
+-  /// A container for all instantiations (e.g template functions) in the source
+-  /// on display.
+-  std::vector<InstantiationView> InstantiationSubViews;
+-
+-  /// Get the first uncovered line number for the source file.
+-  unsigned getFirstUncoveredLineNo();
+-
+-protected:
+-  struct LineRef {
+-    StringRef Line;
+-    int64_t LineNo;
+-
+-    LineRef(StringRef Line, int64_t LineNo) : Line(Line), LineNo(LineNo) {}
+-  };
+-
+-  using CoverageSegmentArray = ArrayRef<const coverage::CoverageSegment *>;
+-
+-  /// @name Rendering Interface
+-  /// @{
+-
+-  /// \brief Render a header for the view.
+-  virtual void renderViewHeader(raw_ostream &OS) = 0;
+-
+-  /// \brief Render a footer for the view.
+-  virtual void renderViewFooter(raw_ostream &OS) = 0;
+-
+-  /// \brief Render the source name for the view.
+-  virtual void renderSourceName(raw_ostream &OS, bool WholeFile) = 0;
+-
+-  /// \brief Render the line prefix at the given \p ViewDepth.
+-  virtual void renderLinePrefix(raw_ostream &OS, unsigned ViewDepth) = 0;
+-
+-  /// \brief Render the line suffix at the given \p ViewDepth.
+-  virtual void renderLineSuffix(raw_ostream &OS, unsigned ViewDepth) = 0;
+-
+-  /// \brief Render a view divider at the given \p ViewDepth.
+-  virtual void renderViewDivider(raw_ostream &OS, unsigned ViewDepth) = 0;
+-
+-  /// \brief Render a source line with highlighting.
+-  virtual void renderLine(raw_ostream &OS, LineRef L,
+-                          const coverage::CoverageSegment *WrappedSegment,
+-                          CoverageSegmentArray Segments, unsigned ExpansionCol,
+-                          unsigned ViewDepth) = 0;
+-
+-  /// \brief Render the line's execution count column.
+-  virtual void renderLineCoverageColumn(raw_ostream &OS,
+-                                        const LineCoverageStats &Line) = 0;
+-
+-  /// \brief Render the line number column.
+-  virtual void renderLineNumberColumn(raw_ostream &OS, unsigned LineNo) = 0;
+-
+-  /// \brief Render all the region's execution counts on a line.
+-  virtual void renderRegionMarkers(raw_ostream &OS,
+-                                   CoverageSegmentArray Segments,
+-                                   unsigned ViewDepth) = 0;
+-
+-  /// \brief Render the site of an expansion.
+-  virtual void
+-  renderExpansionSite(raw_ostream &OS, LineRef L,
+-                      const coverage::CoverageSegment *WrappedSegment,
+-                      CoverageSegmentArray Segments, unsigned ExpansionCol,
+-                      unsigned ViewDepth) = 0;
+-
+-  /// \brief Render an expansion view and any nested views.
+-  virtual void renderExpansionView(raw_ostream &OS, ExpansionView &ESV,
+-                                   unsigned ViewDepth) = 0;
+-
+-  /// \brief Render an instantiation view and any nested views.
+-  virtual void renderInstantiationView(raw_ostream &OS, InstantiationView &ISV,
+-                                       unsigned ViewDepth) = 0;
+-
+-  /// \brief Render \p Title, a project title if one is available, and the
+-  /// created time.
+-  virtual void renderTitle(raw_ostream &OS, StringRef CellText) = 0;
+-
+-  /// \brief Render the table header for a given source file.
+-  virtual void renderTableHeader(raw_ostream &OS, unsigned FirstUncoveredLineNo,
+-                                 unsigned IndentLevel) = 0;
+-
+-  /// @}
+-
+-  /// \brief Format a count using engineering notation with 3 significant
+-  /// digits.
+-  static std::string formatCount(uint64_t N);
+-
+-  /// \brief Check if region marker output is expected for a line.
+-  bool shouldRenderRegionMarkers(bool LineHasMultipleRegions) const;
+-
+-  /// \brief Check if there are any sub-views attached to this view.
+-  bool hasSubViews() const;
+-
+-  SourceCoverageView(StringRef SourceName, const MemoryBuffer &File,
+-                     const CoverageViewOptions &Options,
+-                     coverage::CoverageData &&CoverageInfo)
+-      : SourceName(SourceName), File(File), Options(Options),
+-        CoverageInfo(std::move(CoverageInfo)) {}
+-
+-public:
+-  static std::unique_ptr<SourceCoverageView>
+-  create(StringRef SourceName, const MemoryBuffer &File,
+-         const CoverageViewOptions &Options,
+-         coverage::CoverageData &&CoverageInfo);
+-
+-  virtual ~SourceCoverageView() {}
+-
+-  /// \brief Return the source name formatted for the host OS.
+-  std::string getSourceName() const;
+-
+-  const CoverageViewOptions &getOptions() const { return Options; }
+-
+-  /// \brief Add an expansion subview to this view.
+-  void addExpansion(const coverage::CounterMappingRegion &Region,
+-                    std::unique_ptr<SourceCoverageView> View);
+-
+-  /// \brief Add a function instantiation subview to this view.
+-  void addInstantiation(StringRef FunctionName, unsigned Line,
+-                        std::unique_ptr<SourceCoverageView> View);
+-
+-  /// \brief Print the code coverage information for a specific portion of a
+-  /// source file to the output stream.
+-  void print(raw_ostream &OS, bool WholeFile, bool ShowSourceName,
+-             unsigned ViewDepth = 0);
+-};
+-
+-} // namespace llvm
+-
+-#endif // LLVM_COV_SOURCECOVERAGEVIEW_H
+diff --git a/tools/llvm-cov/SourceCoverageViewHTML.cpp b/tools/llvm-cov/SourceCoverageViewHTML.cpp
+index 64b888e89d7..929b224b66b 100644
+--- a/tools/llvm-cov/SourceCoverageViewHTML.cpp
++++ b/tools/llvm-cov/SourceCoverageViewHTML.cpp
+@@ -1,3 +1,4 @@
++#if 0
+ //===- SourceCoverageViewHTML.cpp - A html code coverage view -------------===//
+ //
+ //                     The LLVM Compiler Infrastructure
+@@ -636,3 +637,5 @@ void SourceCoverageViewHTML::renderTableHeader(raw_ostream &OS,
+      << SourceLabel;
+   renderLineSuffix(OS, ViewDepth);
+ }
++
++#endif
+diff --git a/tools/llvm-cov/SourceCoverageViewHTML.h b/tools/llvm-cov/SourceCoverageViewHTML.h
+deleted file mode 100644
+index 94b08a5e7fc..00000000000
+--- a/tools/llvm-cov/SourceCoverageViewHTML.h
++++ /dev/null
+@@ -1,96 +0,0 @@
+-//===- SourceCoverageViewHTML.h - A html code coverage view ---------------===//
+-//
+-//                     The LLVM Compiler Infrastructure
+-//
+-// This file is distributed under the University of Illinois Open Source
+-// License. See LICENSE.TXT for details.
+-//
+-//===----------------------------------------------------------------------===//
+-///
+-/// \file This file defines the interface to the html coverage renderer.
+-///
+-//===----------------------------------------------------------------------===//
+-
+-#ifndef LLVM_COV_SOURCECOVERAGEVIEWHTML_H
+-#define LLVM_COV_SOURCECOVERAGEVIEWHTML_H
+-
+-#include "SourceCoverageView.h"
+-
+-namespace llvm {
+-
+-struct FileCoverageSummary;
+-
+-/// \brief A coverage printer for html output.
+-class CoveragePrinterHTML : public CoveragePrinter {
+-public:
+-  Expected<OwnedStream> createViewFile(StringRef Path,
+-                                       bool InToplevel) override;
+-
+-  void closeViewFile(OwnedStream OS) override;
+-
+-  Error createIndexFile(ArrayRef<std::string> SourceFiles,
+-                        const coverage::CoverageMapping &Coverage) override;
+-
+-  CoveragePrinterHTML(const CoverageViewOptions &Opts)
+-      : CoveragePrinter(Opts) {}
+-
+-private:
+-  void emitFileSummary(raw_ostream &OS, StringRef SF,
+-                       const FileCoverageSummary &FCS,
+-                       bool IsTotals = false) const;
+-};
+-
+-/// \brief A code coverage view which supports html-based rendering.
+-class SourceCoverageViewHTML : public SourceCoverageView {
+-  void renderViewHeader(raw_ostream &OS) override;
+-
+-  void renderViewFooter(raw_ostream &OS) override;
+-
+-  void renderSourceName(raw_ostream &OS, bool WholeFile) override;
+-
+-  void renderLinePrefix(raw_ostream &OS, unsigned ViewDepth) override;
+-
+-  void renderLineSuffix(raw_ostream &OS, unsigned ViewDepth) override;
+-
+-  void renderViewDivider(raw_ostream &OS, unsigned ViewDepth) override;
+-
+-  void renderLine(raw_ostream &OS, LineRef L,
+-                  const coverage::CoverageSegment *WrappedSegment,
+-                  CoverageSegmentArray Segments, unsigned ExpansionCol,
+-                  unsigned ViewDepth) override;
+-
+-  void renderExpansionSite(raw_ostream &OS, LineRef L,
+-                           const coverage::CoverageSegment *WrappedSegment,
+-                           CoverageSegmentArray Segments, unsigned ExpansionCol,
+-                           unsigned ViewDepth) override;
+-
+-  void renderExpansionView(raw_ostream &OS, ExpansionView &ESV,
+-                           unsigned ViewDepth) override;
+-
+-  void renderInstantiationView(raw_ostream &OS, InstantiationView &ISV,
+-                               unsigned ViewDepth) override;
+-
+-  void renderLineCoverageColumn(raw_ostream &OS,
+-                                const LineCoverageStats &Line) override;
+-
+-  void renderLineNumberColumn(raw_ostream &OS, unsigned LineNo) override;
+-
+-  void renderRegionMarkers(raw_ostream &OS, CoverageSegmentArray Segments,
+-                           unsigned ViewDepth) override;
+-
+-  void renderTitle(raw_ostream &OS, StringRef Title) override;
+-
+-  void renderTableHeader(raw_ostream &OS, unsigned FirstUncoveredLineNo,
+-                         unsigned IndentLevel) override;
+-
+-public:
+-  SourceCoverageViewHTML(StringRef SourceName, const MemoryBuffer &File,
+-                         const CoverageViewOptions &Options,
+-                         coverage::CoverageData &&CoverageInfo)
+-      : SourceCoverageView(SourceName, File, Options, std::move(CoverageInfo)) {
+-  }
+-};
+-
+-} // namespace llvm
+-
+-#endif // LLVM_COV_SOURCECOVERAGEVIEWHTML_H
+diff --git a/tools/llvm-cov/SourceCoverageViewText.cpp b/tools/llvm-cov/SourceCoverageViewText.cpp
+index 4ad120f642e..03422a36a37 100644
+--- a/tools/llvm-cov/SourceCoverageViewText.cpp
++++ b/tools/llvm-cov/SourceCoverageViewText.cpp
+@@ -1,3 +1,4 @@
++#if 0
+ //===- SourceCoverageViewText.cpp - A text-based code coverage view -------===//
+ //
+ //                     The LLVM Compiler Infrastructure
+@@ -237,3 +238,5 @@ void SourceCoverageViewText::renderTitle(raw_ostream &OS, StringRef Title) {
+ 
+ void SourceCoverageViewText::renderTableHeader(raw_ostream &, unsigned,
+                                                unsigned) {}
++
++#endif
+diff --git a/tools/llvm-cov/SourceCoverageViewText.h b/tools/llvm-cov/SourceCoverageViewText.h
+deleted file mode 100644
+index c3f20de9297..00000000000
+--- a/tools/llvm-cov/SourceCoverageViewText.h
++++ /dev/null
+@@ -1,89 +0,0 @@
+-//===- SourceCoverageViewText.h - A text-based code coverage view ---------===//
+-//
+-//                     The LLVM Compiler Infrastructure
+-//
+-// This file is distributed under the University of Illinois Open Source
+-// License. See LICENSE.TXT for details.
+-//
+-//===----------------------------------------------------------------------===//
+-///
+-/// \file This file defines the interface to the text-based coverage renderer.
+-///
+-//===----------------------------------------------------------------------===//
+-
+-#ifndef LLVM_COV_SOURCECOVERAGEVIEWTEXT_H
+-#define LLVM_COV_SOURCECOVERAGEVIEWTEXT_H
+-
+-#include "SourceCoverageView.h"
+-
+-namespace llvm {
+-
+-/// \brief A coverage printer for text output.
+-class CoveragePrinterText : public CoveragePrinter {
+-public:
+-  Expected<OwnedStream> createViewFile(StringRef Path,
+-                                       bool InToplevel) override;
+-
+-  void closeViewFile(OwnedStream OS) override;
+-
+-  Error createIndexFile(ArrayRef<std::string> SourceFiles,
+-                        const coverage::CoverageMapping &Coverage) override;
+-
+-  CoveragePrinterText(const CoverageViewOptions &Opts)
+-      : CoveragePrinter(Opts) {}
+-};
+-
+-/// \brief A code coverage view which supports text-based rendering.
+-class SourceCoverageViewText : public SourceCoverageView {
+-  void renderViewHeader(raw_ostream &OS) override;
+-
+-  void renderViewFooter(raw_ostream &OS) override;
+-
+-  void renderSourceName(raw_ostream &OS, bool WholeFile) override;
+-
+-  void renderLinePrefix(raw_ostream &OS, unsigned ViewDepth) override;
+-
+-  void renderLineSuffix(raw_ostream &OS, unsigned ViewDepth) override;
+-
+-  void renderViewDivider(raw_ostream &OS, unsigned ViewDepth) override;
+-
+-  void renderLine(raw_ostream &OS, LineRef L,
+-                  const coverage::CoverageSegment *WrappedSegment,
+-                  CoverageSegmentArray Segments, unsigned ExpansionCol,
+-                  unsigned ViewDepth) override;
+-
+-  void renderExpansionSite(raw_ostream &OS, LineRef L,
+-                           const coverage::CoverageSegment *WrappedSegment,
+-                           CoverageSegmentArray Segments, unsigned ExpansionCol,
+-                           unsigned ViewDepth) override;
+-
+-  void renderExpansionView(raw_ostream &OS, ExpansionView &ESV,
+-                           unsigned ViewDepth) override;
+-
+-  void renderInstantiationView(raw_ostream &OS, InstantiationView &ISV,
+-                               unsigned ViewDepth) override;
+-
+-  void renderLineCoverageColumn(raw_ostream &OS,
+-                                const LineCoverageStats &Line) override;
+-
+-  void renderLineNumberColumn(raw_ostream &OS, unsigned LineNo) override;
+-
+-  void renderRegionMarkers(raw_ostream &OS, CoverageSegmentArray Segments,
+-                           unsigned ViewDepth) override;
+-
+-  void renderTitle(raw_ostream &OS, StringRef Title) override;
+-
+-  void renderTableHeader(raw_ostream &OS, unsigned FirstUncoveredLineNo,
+-                         unsigned IndentLevel) override;
+-
+-public:
+-  SourceCoverageViewText(StringRef SourceName, const MemoryBuffer &File,
+-                         const CoverageViewOptions &Options,
+-                         coverage::CoverageData &&CoverageInfo)
+-      : SourceCoverageView(SourceName, File, Options, std::move(CoverageInfo)) {
+-  }
+-};
+-
+-} // namespace llvm
+-
+-#endif // LLVM_COV_SOURCECOVERAGEVIEWTEXT_H
+diff --git a/tools/llvm-cov/TestingSupport.cpp b/tools/llvm-cov/TestingSupport.cpp
+index 72768f4fd58..89111d87b6e 100644
+--- a/tools/llvm-cov/TestingSupport.cpp
++++ b/tools/llvm-cov/TestingSupport.cpp
+@@ -1,3 +1,4 @@
++#if 0
+ //===- TestingSupport.cpp - Convert objects files into test files --------===//
+ //
+ //                     The LLVM Compiler Infrastructure
+@@ -90,3 +91,4 @@ int convertForTestingMain(int argc, const char *argv[]) {
+ 
+   return 0;
+ }
++#endif
+diff --git a/tools/llvm-cov/gcov.cpp b/tools/llvm-cov/gcov.cpp
+index 4652fed2a38..ee742efdc15 100644
+--- a/tools/llvm-cov/gcov.cpp
++++ b/tools/llvm-cov/gcov.cpp
+@@ -1,3 +1,4 @@
++#if 0
+ //===- gcov.cpp - GCOV compatible LLVM coverage tool ----------------------===//
+ //
+ //                     The LLVM Compiler Infrastructure
+@@ -143,3 +144,4 @@ int gcovMain(int argc, const char *argv[]) {
+                    Options);
+   return 0;
+ }
++#endif
+diff --git a/tools/llvm-cov/llvm-cov.cpp b/tools/llvm-cov/llvm-cov.cpp
+index 15841587025..5103688cd7c 100644
+--- a/tools/llvm-cov/llvm-cov.cpp
++++ b/tools/llvm-cov/llvm-cov.cpp
+@@ -11,6 +11,7 @@
+ //
+ //===----------------------------------------------------------------------===//
+ 
++#if 0
+ #include "llvm/ADT/StringRef.h"
+ #include "llvm/ADT/StringSwitch.h"
+ #include "llvm/Support/CommandLine.h"
+@@ -57,8 +58,10 @@ static int versionMain(int argc, const char *argv[]) {
+   cl::PrintVersionMessage();
+   return 0;
+ }
++#endif
+ 
+ int main(int argc, const char **argv) {
++#if 0
+   // Print a stack trace if we signal out.
+   sys::PrintStackTraceOnErrorSignal(argv[0]);
+   PrettyStackTraceProgram X(argc, argv);
+@@ -96,5 +99,6 @@ int main(int argc, const char **argv) {
+       errs().resetColor();
+   }
+   helpMain(argc, argv);
++#endif
+   return 1;
+ }
+diff --git a/tools/llvm-profdata/llvm-profdata.cpp b/tools/llvm-profdata/llvm-profdata.cpp
+index 6715566a166..cfcebbbb082 100644
+--- a/tools/llvm-profdata/llvm-profdata.cpp
++++ b/tools/llvm-profdata/llvm-profdata.cpp
+@@ -11,6 +11,8 @@
+ //
+ //===----------------------------------------------------------------------===//
+ 
++#if 0
++
+ #include "llvm/ADT/SmallSet.h"
+ #include "llvm/ADT/SmallVector.h"
+ #include "llvm/ADT/StringRef.h"
+@@ -652,8 +654,10 @@ static int show_main(int argc, const char *argv[]) {
+     return showSampleProfile(Filename, ShowCounts, ShowAllFunctions,
+                              ShowFunction, OS);
+ }
++#endif
+ 
+ int main(int argc, const char *argv[]) {
++#if 0
+   // Print a stack trace if we signal out.
+   sys::PrintStackTraceOnErrorSignal(argv[0]);
+   PrettyStackTraceProgram X(argc, argv);
+@@ -692,5 +696,6 @@ int main(int argc, const char *argv[]) {
+     errs() << ProgName << ": Unknown command!\n";
+ 
+   errs() << "USAGE: " << ProgName << " <merge|show> [args...]\n";
++#endif
+   return 1;
+ }
+diff --git a/tools/sancov/sancov.cc b/tools/sancov/sancov.cc
+index ff2039de35e..abb924c3644 100644
+--- a/tools/sancov/sancov.cc
++++ b/tools/sancov/sancov.cc
+@@ -10,6 +10,7 @@
+ // This file is a command-line tool for reading and analyzing sanitizer
+ // coverage.
+ //===----------------------------------------------------------------------===//
++#if 0
+ #include "llvm/ADT/STLExtras.h"
+ #include "llvm/ADT/StringExtras.h"
+ #include "llvm/ADT/Twine.h"
+@@ -1181,8 +1182,10 @@ readSymbolizeAndMergeCmdArguments(std::vector<std::string> FileNames) {
+ }
+ 
+ } // namespace
++#endif
+ 
+ int main(int Argc, char **Argv) {
++#if 0
+   // Print stack trace if we signal out.
+   sys::PrintStackTraceOnErrorSignal(Argv[0]);
+   PrettyStackTraceProgram X(Argc, Argv);
+@@ -1236,4 +1239,6 @@ int main(int Argc, char **Argv) {
+   case PrintCovPointsAction:
+     llvm_unreachable("unsupported action");
+   }
++#endif
++  return 1;
+ }
+diff --git a/unittests/Support/ThreadPool.cpp b/unittests/Support/ThreadPool.cpp
+index 8e03aacfb1e..6ee0055c1ff 100644
+--- a/unittests/Support/ThreadPool.cpp
++++ b/unittests/Support/ThreadPool.cpp
+@@ -7,6 +7,8 @@
+ //
+ //===----------------------------------------------------------------------===//
+ 
++#if 0
++
+ #include "llvm/Support/ThreadPool.h"
+ 
+ #include "llvm/ADT/STLExtras.h"
+@@ -164,3 +166,5 @@ TEST_F(ThreadPoolTest, PoolDestruction) {
+   }
+   ASSERT_EQ(5, checked_in);
+ }
++
++#endif
+-- 
+2.13.1
+
diff --git a/deps/patches/llvm-D14260.patch b/deps/patches/llvm-D14260.patch
deleted file mode 100644
index a930ce9ac8227f..00000000000000
--- a/deps/patches/llvm-D14260.patch
+++ /dev/null
@@ -1,136 +0,0 @@
-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/patches/llvm-D17165-D18583.patch b/deps/patches/llvm-D17165-D18583.patch
deleted file mode 100644
index 0af0ebbc56bd3f..00000000000000
--- a/deps/patches/llvm-D17165-D18583.patch
+++ /dev/null
@@ -1,225 +0,0 @@
-From 11adcc4de0797c83e61ae0240927f0bafcf041a9 Mon Sep 17 00:00:00 2001
-From: Keno Fischer <kfischer@college.harvard.edu>
-Date: Sat, 13 Feb 2016 02:04:29 +0000
-Subject: [PATCH] [Cloning] Clone every Function's Debug Info
-
-Summary:
-Export the CloneDebugInfoMetadata utility, which clones all debug info
-associated with a function into the first module. Also use this function
-in CloneModule on each function we clone (the CloneFunction entrypoint
-already does this).
-
-Without this, cloning a module will lead to DI quality regressions,
-especially since r252219 reversed the Function <-> DISubprogram edge
-(before we could get lucky and have this edge preserved if the
-DISubprogram itself was, e.g. due to location metadata).
-
-This was verified to fix missing debug information in julia and
-a unittest to verify the new behavior is included.
-
-Patch by Yichao Yu! Thanks!
-
-Reviewers: loladiro, pcc
-Differential Revision: http://reviews.llvm.org/D17165
-
-git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@260791 91177308-0d34-0410-b5e6-96231b3b80d8
----
- include/llvm/Transforms/Utils/Cloning.h |  5 +++++
- lib/Transforms/Utils/CloneFunction.cpp  |  4 ++--
- lib/Transforms/Utils/CloneModule.cpp    |  1 +
- unittests/Transforms/Utils/Cloning.cpp  | 25 +++++++++++++++++++++++++
- 4 files changed, 33 insertions(+), 2 deletions(-)
-
-diff --git a/include/llvm/Transforms/Utils/Cloning.h b/include/llvm/Transforms/Utils/Cloning.h
-index 4f006f2..0bae2bd 100644
---- a/include/llvm/Transforms/Utils/Cloning.h
-+++ b/include/llvm/Transforms/Utils/Cloning.h
-@@ -130,6 +130,11 @@ Function *CloneFunction(const Function *F, ValueToValueMapTy &VMap,
-                         bool ModuleLevelChanges,
-                         ClonedCodeInfo *CodeInfo = nullptr);
- 
-+/// Clone the module-level debug info associated with OldFunc. The cloned data
-+/// will point to NewFunc instead.
-+void CloneDebugInfoMetadata(Function *NewFunc, const Function *OldFunc,
-+                            ValueToValueMapTy &VMap);
-+
- /// Clone OldFunc into NewFunc, transforming the old arguments into references
- /// to VMap values.  Note that if NewFunc already has basic blocks, the ones
- /// cloned into it will be added to the end of the function.  This function
-diff --git a/lib/Transforms/Utils/CloneFunction.cpp b/lib/Transforms/Utils/CloneFunction.cpp
-index 6454afb..8b5692a 100644
---- a/lib/Transforms/Utils/CloneFunction.cpp
-+++ b/lib/Transforms/Utils/CloneFunction.cpp
-@@ -187,8 +187,8 @@ static void AddOperand(DICompileUnit *CU, DISubprogramArray SPs,
- 
- // Clone the module-level debug info associated with OldFunc. The cloned data
- // will point to NewFunc instead.
--static void CloneDebugInfoMetadata(Function *NewFunc, const Function *OldFunc,
--                            ValueToValueMapTy &VMap) {
-+void llvm::CloneDebugInfoMetadata(Function *NewFunc, const Function *OldFunc,
-+                                  ValueToValueMapTy &VMap) {
-   DebugInfoFinder Finder;
-   Finder.processModule(*OldFunc->getParent());
- 
-diff --git a/lib/Transforms/Utils/CloneModule.cpp b/lib/Transforms/Utils/CloneModule.cpp
-index 53de62a..b16a02a 100644
---- a/lib/Transforms/Utils/CloneModule.cpp
-+++ b/lib/Transforms/Utils/CloneModule.cpp
-@@ -136,6 +136,7 @@ std::unique_ptr<Module> llvm::CloneModule(
-         VMap[&*J] = &*DestI++;
-       }
- 
-+      CloneDebugInfoMetadata(F, &*I, VMap);
-       SmallVector<ReturnInst*, 8> Returns;  // Ignore returns cloned.
-       CloneFunctionInto(F, &*I, VMap, /*ModuleLevelChanges=*/true, Returns);
-     }
-diff --git a/unittests/Transforms/Utils/Cloning.cpp b/unittests/Transforms/Utils/Cloning.cpp
-index 25e322e..b761e4e 100644
---- a/unittests/Transforms/Utils/Cloning.cpp
-+++ b/unittests/Transforms/Utils/Cloning.cpp
-@@ -423,6 +423,7 @@ class CloneModule : public ::testing::Test {
-   void SetupModule() { OldM = new Module("", C); }
- 
-   void CreateOldModule() {
-+    DIBuilder DBuilder(*OldM);
-     IRBuilder<> IBuilder(C);
- 
-     auto *FuncType = FunctionType::get(Type::getVoidTy(C), false);
-@@ -431,9 +432,25 @@ class CloneModule : public ::testing::Test {
-     auto *F =
-         Function::Create(FuncType, GlobalValue::PrivateLinkage, "f", OldM);
-     F->setPersonalityFn(PersFn);
-+
-+    // Create debug info
-+    auto *File = DBuilder.createFile("filename.c", "/file/dir/");
-+    DITypeRefArray ParamTypes = DBuilder.getOrCreateTypeArray(None);
-+    DISubroutineType *DFuncType = DBuilder.createSubroutineType(ParamTypes);
-+    auto *CU =
-+        DBuilder.createCompileUnit(dwarf::DW_LANG_C99, "filename.c",
-+                                   "/file/dir", "CloneModule", false, "", 0);
-+    // Function DI
-+    auto *Subprogram = DBuilder.createFunction(CU, "f", "f", File, 4, DFuncType,
-+                                               true, true, 3, 0, false);
-+    F->setSubprogram(Subprogram);
-+
-     auto *Entry = BasicBlock::Create(C, "", F);
-     IBuilder.SetInsertPoint(Entry);
-     IBuilder.CreateRetVoid();
-+
-+    // Finalize the debug info
-+    DBuilder.finalize();
-   }
- 
-   void CreateNewModule() { NewM = llvm::CloneModule(OldM).release(); }
-@@ -447,4 +464,12 @@ TEST_F(CloneModule, Verify) {
-   EXPECT_FALSE(verifyModule(*NewM));
- }
- 
-+TEST_F(CloneModule, Subprogram) {
-+  Function *NewF = NewM->getFunction("f");
-+  DISubprogram *SP = NewF->getSubprogram();
-+  EXPECT_TRUE(SP != nullptr);
-+  EXPECT_EQ(SP->getName(), "f");
-+  EXPECT_EQ(SP->getFile()->getFilename(), "filename.c");
-+  EXPECT_EQ(SP->getLine(), (unsigned)4);
-+}
- }
-From af289e04413504c3bdc252e08c3fe17bf7ea6dc8 Mon Sep 17 00:00:00 2001
-From: Peter Collingbourne <peter@pcc.me.uk>
-Date: Wed, 30 Mar 2016 22:05:13 +0000
-Subject: [PATCH] Cloning: Reduce complexity of debug info cloning and fix
- correctness issue.
-
-Commit r260791 contained an error in that it would introduce a cross-module
-reference in the old module. It also introduced O(N^2) complexity in the
-module cloner by requiring the entire module to be visited for each function.
-Fix both of these problems by avoiding use of the CloneDebugInfoMetadata
-function (which is only designed to do intra-module cloning) and cloning
-function-attached metadata in the same way that we clone all other metadata.
-
-Differential Revision: http://reviews.llvm.org/D18583
-
-git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@264935 91177308-0d34-0410-b5e6-96231b3b80d8
----
- include/llvm/Transforms/Utils/Cloning.h |  5 -----
- lib/Transforms/Utils/CloneFunction.cpp  | 13 +++++++++++--
- lib/Transforms/Utils/CloneModule.cpp    |  1 -
- unittests/Transforms/Utils/Cloning.cpp  |  6 ++++++
- 4 files changed, 17 insertions(+), 8 deletions(-)
-
-diff --git a/include/llvm/Transforms/Utils/Cloning.h b/include/llvm/Transforms/Utils/Cloning.h
-index 0bae2bd..4f006f2 100644
---- a/include/llvm/Transforms/Utils/Cloning.h
-+++ b/include/llvm/Transforms/Utils/Cloning.h
-@@ -130,11 +130,6 @@ Function *CloneFunction(const Function *F, ValueToValueMapTy &VMap,
-                         bool ModuleLevelChanges,
-                         ClonedCodeInfo *CodeInfo = nullptr);
- 
--/// Clone the module-level debug info associated with OldFunc. The cloned data
--/// will point to NewFunc instead.
--void CloneDebugInfoMetadata(Function *NewFunc, const Function *OldFunc,
--                            ValueToValueMapTy &VMap);
--
- /// Clone OldFunc into NewFunc, transforming the old arguments into references
- /// to VMap values.  Note that if NewFunc already has basic blocks, the ones
- /// cloned into it will be added to the end of the function.  This function
-diff --git a/lib/Transforms/Utils/CloneFunction.cpp b/lib/Transforms/Utils/CloneFunction.cpp
-index 05b0a17..8e1715a 100644
---- a/lib/Transforms/Utils/CloneFunction.cpp
-+++ b/lib/Transforms/Utils/CloneFunction.cpp
-@@ -119,6 +119,15 @@ void llvm::CloneFunctionInto(Function *NewFunc, const Function *OldFunc,
-           .addAttributes(NewFunc->getContext(), AttributeSet::FunctionIndex,
-                          OldAttrs.getFnAttributes()));
- 
-+  SmallVector<std::pair<unsigned, MDNode *>, 1> MDs;
-+  OldFunc->getAllMetadata(MDs);
-+  for (auto MD : MDs)
-+    NewFunc->setMetadata(
-+        MD.first,
-+        MapMetadata(MD.second, VMap,
-+                    ModuleLevelChanges ? RF_None : RF_NoModuleLevelChanges,
-+                    TypeMapper, Materializer));
-+
-   // Loop over all of the basic blocks in the function, cloning them as
-   // appropriate.  Note that we save BE this way in order to handle cloning of
-   // recursive functions into themselves.
-@@ -187,8 +196,8 @@ static void AddOperand(DICompileUnit *CU, DISubprogramArray SPs,
- 
- // Clone the module-level debug info associated with OldFunc. The cloned data
- // will point to NewFunc instead.
--void llvm::CloneDebugInfoMetadata(Function *NewFunc, const Function *OldFunc,
--                                  ValueToValueMapTy &VMap) {
-+static void CloneDebugInfoMetadata(Function *NewFunc, const Function *OldFunc,
-+                                   ValueToValueMapTy &VMap) {
-   DebugInfoFinder Finder;
-   Finder.processModule(*OldFunc->getParent());
- 
-diff --git a/lib/Transforms/Utils/CloneModule.cpp b/lib/Transforms/Utils/CloneModule.cpp
-index 494e275..929f51b 100644
---- a/lib/Transforms/Utils/CloneModule.cpp
-+++ b/lib/Transforms/Utils/CloneModule.cpp
-@@ -138,7 +138,6 @@ std::unique_ptr<Module> llvm::CloneModule(
-         VMap[&*J] = &*DestI++;
-       }
- 
--      CloneDebugInfoMetadata(F, &*I, VMap);
-       SmallVector<ReturnInst*, 8> Returns;  // Ignore returns cloned.
-       CloneFunctionInto(F, &*I, VMap, /*ModuleLevelChanges=*/true, Returns);
-     }
-diff --git a/unittests/Transforms/Utils/Cloning.cpp b/unittests/Transforms/Utils/Cloning.cpp
-index b761e4e..f06a20f 100644
---- a/unittests/Transforms/Utils/Cloning.cpp
-+++ b/unittests/Transforms/Utils/Cloning.cpp
-@@ -464,6 +464,12 @@ TEST_F(CloneModule, Verify) {
-   EXPECT_FALSE(verifyModule(*NewM));
- }
- 
-+TEST_F(CloneModule, OldModuleUnchanged) {
-+  DebugInfoFinder Finder;
-+  Finder.processModule(*OldM);
-+  EXPECT_EQ(1U, Finder.subprogram_count());
-+}
-+
- TEST_F(CloneModule, Subprogram) {
-   Function *NewF = NewM->getFunction("f");
-   DISubprogram *SP = NewF->getSubprogram();
diff --git a/deps/patches/llvm-D17326_unpack_load.patch b/deps/patches/llvm-D17326_unpack_load.patch
deleted file mode 100644
index 8fcc54bcbbb80d..00000000000000
--- a/deps/patches/llvm-D17326_unpack_load.patch
+++ /dev/null
@@ -1,150 +0,0 @@
-From 92c0b571a3a7420bdc3dfad72b4c75dde725d9a9 Mon Sep 17 00:00:00 2001
-From: Amaury Sechet <deadalnix@gmail.com>
-Date: Wed, 17 Feb 2016 19:21:28 +0000
-Subject: [PATCH] Fix load alignement when unpacking aggregates structs
-
-Summary: Store and loads unpacked by instcombine do not always have the right alignement. This explicitely compute the alignement and set it.
-
-Reviewers: dblaikie, majnemer, reames, hfinkel, joker.eph
-
-Subscribers: llvm-commits
-
-Differential Revision: http://reviews.llvm.org/D17326
-
-git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@261139 91177308-0d34-0410-b5e6-96231b3b80d8
----
- .../InstCombine/InstCombineLoadStoreAlloca.cpp     | 38 +++++++++++++++-------
- test/Transforms/InstCombine/unpack-fca.ll          | 27 +++++++++++++++
- 2 files changed, 53 insertions(+), 12 deletions(-)
-
-diff --git a/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp b/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp
-index dd2889d..4d42658 100644
---- a/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp
-+++ b/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp
-@@ -523,16 +523,17 @@ static Instruction *unpackLoadToAggregate(InstCombiner &IC, LoadInst &LI) {
-   if (!T->isAggregateType())
-     return nullptr;
- 
-+  auto Name = LI.getName();
-   assert(LI.getAlignment() && "Alignment must be set at this point");
- 
-   if (auto *ST = dyn_cast<StructType>(T)) {
-     // If the struct only have one element, we unpack.
--    unsigned Count = ST->getNumElements();
--    if (Count == 1) {
-+    auto NumElements = ST->getNumElements();
-+    if (NumElements == 1) {
-       LoadInst *NewLoad = combineLoadToNewType(IC, LI, ST->getTypeAtIndex(0U),
-                                                ".unpack");
-       return IC.ReplaceInstUsesWith(LI, IC.Builder->CreateInsertValue(
--        UndefValue::get(T), NewLoad, 0, LI.getName()));
-+        UndefValue::get(T), NewLoad, 0, Name));
-     }
- 
-     // We don't want to break loads with padding here as we'd loose
-@@ -542,23 +543,29 @@ static Instruction *unpackLoadToAggregate(InstCombiner &IC, LoadInst &LI) {
-     if (SL->hasPadding())
-       return nullptr;
- 
--    auto Name = LI.getName();
-+    auto Align = LI.getAlignment();
-+    if (!Align)
-+      Align = DL.getABITypeAlignment(ST);
-+
-     SmallString<16> LoadName = Name;
-     LoadName += ".unpack";
-     SmallString<16> EltName = Name;
-     EltName += ".elt";
-+
-     auto *Addr = LI.getPointerOperand();
--    Value *V = UndefValue::get(T);
--    auto *IdxType = Type::getInt32Ty(ST->getContext());
-+    auto *IdxType = Type::getInt32Ty(T->getContext());
-     auto *Zero = ConstantInt::get(IdxType, 0);
--    for (unsigned i = 0; i < Count; i++) {
-+
-+    Value *V = UndefValue::get(T);
-+    for (unsigned i = 0; i < NumElements; i++) {
-       Value *Indices[2] = {
-         Zero,
-         ConstantInt::get(IdxType, i),
-       };
--      auto *Ptr = IC.Builder->CreateInBoundsGEP(ST, Addr, makeArrayRef(Indices), EltName);
--      auto *L = IC.Builder->CreateAlignedLoad(Ptr, LI.getAlignment(),
--                                              LoadName);
-+      auto *Ptr = IC.Builder->CreateInBoundsGEP(ST, Addr,
-+                                            makeArrayRef(Indices), EltName);
-+      auto EltAlign = MinAlign(Align, SL->getElementOffset(i));
-+      auto *L = IC.Builder->CreateAlignedLoad(Ptr, EltAlign, LoadName);
-       V = IC.Builder->CreateInsertValue(V, L, i);
-     }
- 
-@@ -950,11 +957,16 @@ static bool unpackStoreToAggregate(InstCombiner &IC, StoreInst &SI) {
-     if (SL->hasPadding())
-       return false;
- 
-+    auto Align = SI.getAlignment();
-+    if (!Align)
-+      Align = DL.getABITypeAlignment(ST);
-+
-     SmallString<16> EltName = V->getName();
-     EltName += ".elt";
-     auto *Addr = SI.getPointerOperand();
-     SmallString<16> AddrName = Addr->getName();
-     AddrName += ".repack";
-+
-     auto *IdxType = Type::getInt32Ty(ST->getContext());
-     auto *Zero = ConstantInt::get(IdxType, 0);
-     for (unsigned i = 0; i < Count; i++) {
-@@ -962,9 +974,11 @@ static bool unpackStoreToAggregate(InstCombiner &IC, StoreInst &SI) {
-         Zero,
-         ConstantInt::get(IdxType, i),
-       };
--      auto *Ptr = IC.Builder->CreateInBoundsGEP(ST, Addr, makeArrayRef(Indices), AddrName);
-+      auto *Ptr = IC.Builder->CreateInBoundsGEP(ST, Addr,
-+                                            makeArrayRef(Indices), AddrName);
-       auto *Val = IC.Builder->CreateExtractValue(V, i, EltName);
--      IC.Builder->CreateStore(Val, Ptr);
-+      auto EltAlign = MinAlign(Align, SL->getElementOffset(i));
-+      IC.Builder->CreateAlignedStore(Val, Ptr, EltAlign);
-     }
- 
-     return true;
-diff --git a/test/Transforms/InstCombine/unpack-fca.ll b/test/Transforms/InstCombine/unpack-fca.ll
-index 4359839..bed3b61 100644
---- a/test/Transforms/InstCombine/unpack-fca.ll
-+++ b/test/Transforms/InstCombine/unpack-fca.ll
-@@ -151,3 +151,30 @@ define i32 @packed_alignment(%struct.S* dereferenceable(9) %s) {
-   %v = extractvalue %struct.T %tv, 1
-   ret i32 %v
- }
-+
-+%struct.U = type {i8, i8, i8, i8, i8, i8, i8, i8, i64}
-+
-+define void @check_alignment(%struct.U* %u, %struct.U* %v) {
-+; CHECK-LABEL: check_alignment
-+; CHECK: load i8, i8* {{.*}}, align 8
-+; CHECK: load i8, i8* {{.*}}, align 1
-+; CHECK: load i8, i8* {{.*}}, align 2
-+; CHECK: load i8, i8* {{.*}}, align 1
-+; CHECK: load i8, i8* {{.*}}, align 4
-+; CHECK: load i8, i8* {{.*}}, align 1
-+; CHECK: load i8, i8* {{.*}}, align 2
-+; CHECK: load i8, i8* {{.*}}, align 1
-+; CHECK: load i64, i64* {{.*}}, align 8
-+; CHECK: store i8 {{.*}}, i8* {{.*}}, align 8
-+; CHECK: store i8 {{.*}}, i8* {{.*}}, align 1
-+; CHECK: store i8 {{.*}}, i8* {{.*}}, align 2
-+; CHECK: store i8 {{.*}}, i8* {{.*}}, align 1
-+; CHECK: store i8 {{.*}}, i8* {{.*}}, align 4
-+; CHECK: store i8 {{.*}}, i8* {{.*}}, align 1
-+; CHECK: store i8 {{.*}}, i8* {{.*}}, align 2
-+; CHECK: store i8 {{.*}}, i8* {{.*}}, align 1
-+; CHECK: store i64 {{.*}}, i64* {{.*}}, align 8
-+  %1 = load %struct.U, %struct.U* %u
-+  store %struct.U %1, %struct.U* %v
-+  ret void
-+}
--- 
-2.8.2
-
diff --git a/deps/patches/llvm-D17712.patch b/deps/patches/llvm-D17712.patch
deleted file mode 100644
index 4488be41f3d36e..00000000000000
--- a/deps/patches/llvm-D17712.patch
+++ /dev/null
@@ -1,52 +0,0 @@
-From 6f20310e9eede9ab68fea1ffdfba9881b8b80684 Mon Sep 17 00:00:00 2001
-From: Nemanja Ivanovic <nemanja.i.ibm@gmail.com>
-Date: Sat, 12 Mar 2016 10:23:07 +0000
-Subject: [PATCH] Fix for PR 26378
-
-This patch corresponds to review:
-http://reviews.llvm.org/D17712
-
-We were not clearing the TOC vector in PPCAsmPrinter when initializing it. This
-caused duplicate definition asserts when the pass is reused on the module
-(i.e. with -compile-twice or in JIT contexts).
-
-
-git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@263338 91177308-0d34-0410-b5e6-96231b3b80d8
----
- lib/Target/PowerPC/PPCAsmPrinter.cpp | 6 ++++++
- test/CodeGen/PowerPC/pr26378.ll      | 6 ++++++
- 2 files changed, 12 insertions(+)
- create mode 100644 test/CodeGen/PowerPC/pr26378.ll
-
-diff --git a/lib/Target/PowerPC/PPCAsmPrinter.cpp b/lib/Target/PowerPC/PPCAsmPrinter.cpp
-index ec354c2..f206652 100644
---- a/lib/Target/PowerPC/PPCAsmPrinter.cpp
-+++ b/lib/Target/PowerPC/PPCAsmPrinter.cpp
-@@ -82,6 +82,12 @@ public:
- 
-     MCSymbol *lookUpOrCreateTOCEntry(MCSymbol *Sym);
- 
-+    virtual bool doInitialization(Module &M) override {
-+      if (!TOC.empty())
-+        TOC.clear();
-+      return AsmPrinter::doInitialization(M);
-+    }
-+
-     void EmitInstruction(const MachineInstr *MI) override;
- 
-     void printOperand(const MachineInstr *MI, unsigned OpNo, raw_ostream &O);
-diff --git a/test/CodeGen/PowerPC/pr26378.ll b/test/CodeGen/PowerPC/pr26378.ll
-new file mode 100644
-index 0000000..e5e2055
---- /dev/null
-+++ b/test/CodeGen/PowerPC/pr26378.ll
-@@ -0,0 +1,6 @@
-+; RUN: llc -compile-twice -filetype obj \
-+; RUN:   -mtriple=powerpc64le-unknown-unknown -mcpu=pwr8 < %s
-+@foo = common global i32 0, align 4
-+define i8* @blah() #0 {
-+  ret i8* bitcast (i32* @foo to i8*)
-+}  
--- 
-2.7.4
-
diff --git a/deps/patches/llvm-D21271-instcombine-tbaa-3.7.patch b/deps/patches/llvm-D21271-instcombine-tbaa-3.7.patch
deleted file mode 100644
index 1da6845dddc6ca..00000000000000
--- a/deps/patches/llvm-D21271-instcombine-tbaa-3.7.patch
+++ /dev/null
@@ -1,97 +0,0 @@
-From a3c3e1bd22fef6de6d31b3a80d773d1176b4ca8c Mon Sep 17 00:00:00 2001
-From: Yichao Yu <yyc1992@gmail.com>
-Date: Sun, 12 Jun 2016 17:14:38 -0400
-Subject: [PATCH] Fix `InstCombine` to not widen metadata on store-to-load
- forwarding.
-
-The original check for load CSE or store-to-load forwarding is wrong
-when the forwarded stored value happened to be a load.
----
- include/llvm/Analysis/Loads.h                           |  3 ++-
- lib/Analysis/Loads.cpp                                  |  5 ++++-
- .../InstCombine/InstCombineLoadStoreAlloca.cpp          |  6 ++++--
- test/Transforms/InstCombine/tbaa-store-to-load.ll       | 17 +++++++++++++++++
- 4 files changed, 27 insertions(+), 4 deletions(-)
- create mode 100644 test/Transforms/InstCombine/tbaa-store-to-load.ll
-
-diff --git a/include/llvm/Analysis/Loads.h b/include/llvm/Analysis/Loads.h
-index 42667d2..5db3c2f 100644
---- a/include/llvm/Analysis/Loads.h
-+++ b/include/llvm/Analysis/Loads.h
-@@ -50,7 +50,8 @@ Value *FindAvailableLoadedValue(Value *Ptr, BasicBlock *ScanBB,
-                                 BasicBlock::iterator &ScanFrom,
-                                 unsigned MaxInstsToScan = 6,
-                                 AliasAnalysis *AA = nullptr,
--                                AAMDNodes *AATags = nullptr);
-+                                AAMDNodes *AATags = nullptr,
-+                                bool *IsLoadCSE = nullptr);
- 
- }
- 
-diff --git a/lib/Analysis/Loads.cpp b/lib/Analysis/Loads.cpp
-index 624c5a1..baecd3f 100644
---- a/lib/Analysis/Loads.cpp
-+++ b/lib/Analysis/Loads.cpp
-@@ -183,7 +183,8 @@ bool llvm::isSafeToLoadUnconditionally(Value *V, Instruction *ScanFrom,
- Value *llvm::FindAvailableLoadedValue(Value *Ptr, BasicBlock *ScanBB,
-                                       BasicBlock::iterator &ScanFrom,
-                                       unsigned MaxInstsToScan,
--                                      AliasAnalysis *AA, AAMDNodes *AATags) {
-+                                      AliasAnalysis *AA, AAMDNodes *AATags,
-+                                      bool *IsLoadCSE) {
-   if (MaxInstsToScan == 0)
-     MaxInstsToScan = ~0U;
- 
-@@ -220,6 +221,8 @@ Value *llvm::FindAvailableLoadedValue(Value *Ptr, BasicBlock *ScanBB,
-           CastInst::isBitOrNoopPointerCastable(LI->getType(), AccessTy, DL)) {
-         if (AATags)
-           LI->getAAMetadata(*AATags);
-+        if (IsLoadCSE)
-+            *IsLoadCSE = true;
-         return LI;
-       }
- 
-diff --git a/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp b/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp
-index e3179db..f1af1f7 100644
---- a/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp
-+++ b/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp
-@@ -750,9 +750,11 @@ Instruction *InstCombiner::visitLoadInst(LoadInst &LI) {
-   // separated by a few arithmetic operations.
-   BasicBlock::iterator BBI = &LI;
-   AAMDNodes AATags;
-+  bool IsLoadCSE = false;
-   if (Value *AvailableVal = FindAvailableLoadedValue(Op, LI.getParent(), BBI,
--                                                     6, AA, &AATags)) {
--    if (LoadInst *NLI = dyn_cast<LoadInst>(AvailableVal)) {
-+                                                     6, AA, &AATags, &IsLoadCSE)) {
-+    if (IsLoadCSE) {
-+      LoadInst *NLI = cast<LoadInst>(AvailableVal);
-       unsigned KnownIDs[] = {
-         LLVMContext::MD_tbaa,
-         LLVMContext::MD_alias_scope,
-diff --git a/test/Transforms/InstCombine/tbaa-store-to-load.ll b/test/Transforms/InstCombine/tbaa-store-to-load.ll
-new file mode 100644
-index 0000000..707be73
---- /dev/null
-+++ b/test/Transforms/InstCombine/tbaa-store-to-load.ll
-@@ -0,0 +1,17 @@
-+; RUN: opt -S -instcombine < %s 2>&1 | FileCheck %s
-+
-+define i64 @f(i64* %p1, i64* %p2) {
-+top:
-+  ; check that the tbaa is preserved
-+  ; CHECK-LABEL: @f(
-+  ; CHECK: %v1 = load i64, i64* %p1, align 8, !tbaa !0
-+  ; CHECK: store i64 %v1, i64* %p2, align 8
-+  ; CHECK: ret i64 %v1
-+  %v1 = load i64, i64* %p1, align 8, !tbaa !0
-+  store i64 %v1, i64* %p2, align 8
-+  %v2 = load i64, i64* %p2, align 8
-+  ret i64 %v2
-+}
-+
-+!0 = !{!1, !1, i64 0}
-+!1 = !{!"load_tbaa"}
--- 
-2.8.3
-
diff --git a/deps/patches/llvm-D21271-instcombine-tbaa-3.8.patch b/deps/patches/llvm-D21271-instcombine-tbaa-3.8.patch
deleted file mode 100644
index 3792446ffd1b4b..00000000000000
--- a/deps/patches/llvm-D21271-instcombine-tbaa-3.8.patch
+++ /dev/null
@@ -1,98 +0,0 @@
-From 3dc2f7e69ec0a65af503bb6264fa6674ecfeaf84 Mon Sep 17 00:00:00 2001
-From: Yichao Yu <yyc1992@gmail.com>
-Date: Sun, 12 Jun 2016 17:14:38 -0400
-Subject: [PATCH] Fix `InstCombine` to not widen metadata on store-to-load
- forwarding.
-
-The original check for load CSE or store-to-load forwarding is wrong
-when the forwarded stored value happened to be a load.
----
- include/llvm/Analysis/Loads.h                           |  3 ++-
- lib/Analysis/Loads.cpp                                  |  5 ++++-
- .../InstCombine/InstCombineLoadStoreAlloca.cpp          |  6 ++++--
- test/Transforms/InstCombine/tbaa-store-to-load.ll       | 17 +++++++++++++++++
- 4 files changed, 27 insertions(+), 4 deletions(-)
- create mode 100644 test/Transforms/InstCombine/tbaa-store-to-load.ll
-
-diff --git a/include/llvm/Analysis/Loads.h b/include/llvm/Analysis/Loads.h
-index 939663b..a7fc035 100644
---- a/include/llvm/Analysis/Loads.h
-+++ b/include/llvm/Analysis/Loads.h
-@@ -55,7 +55,8 @@ Value *FindAvailableLoadedValue(Value *Ptr, BasicBlock *ScanBB,
-                                 BasicBlock::iterator &ScanFrom,
-                                 unsigned MaxInstsToScan = DefMaxInstsToScan,
-                                 AliasAnalysis *AA = nullptr,
--                                AAMDNodes *AATags = nullptr);
-+                                AAMDNodes *AATags = nullptr,
-+                                bool *IsLoadCSE = nullptr);
- 
- }
- 
-diff --git a/lib/Analysis/Loads.cpp b/lib/Analysis/Loads.cpp
-index 4b2fa3c..f5705fa 100644
---- a/lib/Analysis/Loads.cpp
-+++ b/lib/Analysis/Loads.cpp
-@@ -196,7 +196,8 @@ llvm::DefMaxInstsToScan("available-load-scan-limit", cl::init(6), cl::Hidden,
- Value *llvm::FindAvailableLoadedValue(Value *Ptr, BasicBlock *ScanBB,
-                                       BasicBlock::iterator &ScanFrom,
-                                       unsigned MaxInstsToScan,
--                                      AliasAnalysis *AA, AAMDNodes *AATags) {
-+                                      AliasAnalysis *AA, AAMDNodes *AATags,
-+                                      bool *IsLoadCSE) {
-   if (MaxInstsToScan == 0)
-     MaxInstsToScan = ~0U;
- 
-@@ -233,6 +234,8 @@ Value *llvm::FindAvailableLoadedValue(Value *Ptr, BasicBlock *ScanBB,
-           CastInst::isBitOrNoopPointerCastable(LI->getType(), AccessTy, DL)) {
-         if (AATags)
-           LI->getAAMetadata(*AATags);
-+        if (IsLoadCSE)
-+            *IsLoadCSE = true;
-         return LI;
-       }
- 
-diff --git a/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp b/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp
-index 4d42658..8302ef8 100644
---- a/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp
-+++ b/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp
-@@ -800,10 +800,12 @@ Instruction *InstCombiner::visitLoadInst(LoadInst &LI) {
-   // separated by a few arithmetic operations.
-   BasicBlock::iterator BBI(LI);
-   AAMDNodes AATags;
-+  bool IsLoadCSE = false;
-   if (Value *AvailableVal =
-       FindAvailableLoadedValue(Op, LI.getParent(), BBI,
--                               DefMaxInstsToScan, AA, &AATags)) {
--    if (LoadInst *NLI = dyn_cast<LoadInst>(AvailableVal)) {
-+                               DefMaxInstsToScan, AA, &AATags, &IsLoadCSE)) {
-+    if (IsLoadCSE) {
-+      LoadInst *NLI = cast<LoadInst>(AvailableVal);
-       unsigned KnownIDs[] = {
-           LLVMContext::MD_tbaa,            LLVMContext::MD_alias_scope,
-           LLVMContext::MD_noalias,         LLVMContext::MD_range,
-diff --git a/test/Transforms/InstCombine/tbaa-store-to-load.ll b/test/Transforms/InstCombine/tbaa-store-to-load.ll
-new file mode 100644
-index 0000000..707be73
---- /dev/null
-+++ b/test/Transforms/InstCombine/tbaa-store-to-load.ll
-@@ -0,0 +1,17 @@
-+; RUN: opt -S -instcombine < %s 2>&1 | FileCheck %s
-+
-+define i64 @f(i64* %p1, i64* %p2) {
-+top:
-+  ; check that the tbaa is preserved
-+  ; CHECK-LABEL: @f(
-+  ; CHECK: %v1 = load i64, i64* %p1, align 8, !tbaa !0
-+  ; CHECK: store i64 %v1, i64* %p2, align 8
-+  ; CHECK: ret i64 %v1
-+  %v1 = load i64, i64* %p1, align 8, !tbaa !0
-+  store i64 %v1, i64* %p2, align 8
-+  %v2 = load i64, i64* %p2, align 8
-+  ret i64 %v2
-+}
-+
-+!0 = !{!1, !1, i64 0}
-+!1 = !{!"load_tbaa"}
--- 
-2.8.3
-
diff --git a/deps/patches/llvm-D27629-AArch64-large_model_4.0.patch b/deps/patches/llvm-D27629-AArch64-large_model_4.0.patch
new file mode 100644
index 00000000000000..3e4ae2e076c700
--- /dev/null
+++ b/deps/patches/llvm-D27629-AArch64-large_model_4.0.patch
@@ -0,0 +1,77 @@
+From 6e7b660ee185445640110c80d80aafd436682fca Mon Sep 17 00:00:00 2001
+From: Yichao Yu <yyc1992@gmail.com>
+Date: Fri, 9 Dec 2016 15:59:46 -0500
+Subject: [PATCH] Fix unwind info relocation with large code model on AArch64
+
+---
+ lib/MC/MCObjectFileInfo.cpp                            |  2 ++
+ .../AArch64/ELF_ARM64_BE-large-relocations.s           | 18 ++++++++++++++++++
+ .../RuntimeDyld/AArch64/ELF_ARM64_large-relocations.s  | 18 ++++++++++++++++++
+ 3 files changed, 38 insertions(+)
+ create mode 100644 test/ExecutionEngine/RuntimeDyld/AArch64/ELF_ARM64_BE-large-relocations.s
+ create mode 100644 test/ExecutionEngine/RuntimeDyld/AArch64/ELF_ARM64_large-relocations.s
+
+diff --git a/lib/MC/MCObjectFileInfo.cpp b/lib/MC/MCObjectFileInfo.cpp
+index 687ad3dc83a..da51f4e26d9 100644
+--- a/lib/MC/MCObjectFileInfo.cpp
++++ b/lib/MC/MCObjectFileInfo.cpp
+@@ -281,6 +281,8 @@ void MCObjectFileInfo::initELFMCObjectFileInfo(const Triple &T) {
+   case Triple::mips64el:
+     FDECFIEncoding = dwarf::DW_EH_PE_sdata8;
+     break;
++  case Triple::aarch64:
++  case Triple::aarch64_be:
+   case Triple::x86_64:
+     FDECFIEncoding = dwarf::DW_EH_PE_pcrel |
+                      ((CMModel == CodeModel::Large) ? dwarf::DW_EH_PE_sdata8
+diff --git a/test/ExecutionEngine/RuntimeDyld/AArch64/ELF_ARM64_BE-large-relocations.s b/test/ExecutionEngine/RuntimeDyld/AArch64/ELF_ARM64_BE-large-relocations.s
+new file mode 100644
+index 00000000000..e3eeb02ff01
+--- /dev/null
++++ b/test/ExecutionEngine/RuntimeDyld/AArch64/ELF_ARM64_BE-large-relocations.s
+@@ -0,0 +1,18 @@
++# RUN: llvm-mc -triple=aarch64_be-none-linux-gnu -code-model=large -filetype=obj -o %T/be-large-reloc.o %s
++# RUN: llvm-rtdyld -triple=aarch64_be-none-linux-gnu -verify -map-section be-large-reloc.o,.eh_frame=0x10000 -map-section be-large-reloc.o,.text=0xffff000000000000 -check=%s %T/be-large-reloc.o
++
++        .text
++        .globl  g
++        .p2align        2
++        .type   g,@function
++g:
++        .cfi_startproc
++        mov      x0, xzr
++        ret
++        .Lfunc_end0:
++        .size   g, .Lfunc_end0-g
++        .cfi_endproc
++
++# Skip the CIE and load the 8 bytes PC begin pointer.
++# Assuming the CIE and the FDE length are both 4 bytes.
++# rtdyld-check: *{8}(section_addr(be-large-reloc.o, .eh_frame) + (*{4}(section_addr(be-large-reloc.o, .eh_frame))) + 0xc) = g - (section_addr(be-large-reloc.o, .eh_frame) + (*{4}(section_addr(be-large-reloc.o, .eh_frame))) + 0xc)
+diff --git a/test/ExecutionEngine/RuntimeDyld/AArch64/ELF_ARM64_large-relocations.s b/test/ExecutionEngine/RuntimeDyld/AArch64/ELF_ARM64_large-relocations.s
+new file mode 100644
+index 00000000000..ec30f19c476
+--- /dev/null
++++ b/test/ExecutionEngine/RuntimeDyld/AArch64/ELF_ARM64_large-relocations.s
+@@ -0,0 +1,18 @@
++# RUN: llvm-mc -triple=arm64-none-linux-gnu -code-model=large -filetype=obj -o %T/large-reloc.o %s
++# RUN: llvm-rtdyld -triple=arm64-none-linux-gnu -verify -map-section large-reloc.o,.eh_frame=0x10000 -map-section large-reloc.o,.text=0xffff000000000000 -check=%s %T/large-reloc.o
++
++        .text
++        .globl  g
++        .p2align        2
++        .type   g,@function
++g:
++        .cfi_startproc
++        mov      x0, xzr
++        ret
++        .Lfunc_end0:
++        .size   g, .Lfunc_end0-g
++        .cfi_endproc
++
++# Skip the CIE and load the 8 bytes PC begin pointer.
++# Assuming the CIE and the FDE length are both 4 bytes.
++# rtdyld-check: *{8}(section_addr(large-reloc.o, .eh_frame) + (*{4}(section_addr(large-reloc.o, .eh_frame))) + 0xc) = g - (section_addr(large-reloc.o, .eh_frame) + (*{4}(section_addr(large-reloc.o, .eh_frame))) + 0xc)
+-- 
+2.12.2
+
diff --git a/deps/patches/llvm-D28759-loopclearance.patch b/deps/patches/llvm-D28759-loopclearance.patch
new file mode 100644
index 00000000000000..036ca4d83103c5
--- /dev/null
+++ b/deps/patches/llvm-D28759-loopclearance.patch
@@ -0,0 +1,480 @@
+From e3621af0115a851d0ed02f0b436deec62ec3e99c Mon Sep 17 00:00:00 2001
+From: Keno Fischer <keno@juliacomputing.com>
+Date: Sun, 15 Jan 2017 23:59:07 -0500
+Subject: [PATCH] [ExecutionDepsFix] Improve clearance calculation for loops
+
+In revision rL278321, ExecutionDepsFix learned how to pick a better
+register for undef register reads, e.g. for instructions such as
+`vcvtsi2sdq`. While this revision improved performance on a good number
+of our benchmarks, it unfortunately also caused significant regressions
+(up to 3x) on others. This regression turned out to be caused by loops
+such as:
+
+PH -> A -> B (xmm<Undef> -> xmm<Def>) -> C -> D -> EXIT
+      ^                                  |
+      +----------------------------------+
+
+In the previous version of the clearance calculation, we would visit
+the blocks in order, remembering for each whether there were any
+incoming backedges from blocks that we hadn't processed yet and if
+so queuing up the block to be re-processed. However, for loop structures
+such as the above, this is clearly insufficient, since the block B
+does not have any unknown backedges, so we do not see the false
+dependency from the previous interation's Def of xmm registers in B.
+
+To fix this, we need to consider all blocks that are part of the loop
+and reprocess them one the correct clearance values are known. As
+an optimization, we also want to avoid reprocessing any later blocks
+that are not part of the loop.
+
+In summary, the iteration order is as follows:
+Before: PH A B C D A'
+Corrected (Naive): PH A B C D A' B' C' D'
+Corrected (w/ optimization): PH A B C A' B' C' D
+
+To facilitate this optimization we introduce two new counters for each
+basic block. The first counts how many of it's predecssors have
+completed primary processing. The second counts how many of its
+predecessors have completed all processing (we will call such a block
+*done*. Now, the criteria to reprocess a block is as follows:
+    - All Predecessors have completed primary processing
+    - For x the number of predecessors that have completed primary
+      processing *at the time of primary processing of this block*,
+      the number of predecessors that are done has reached x.
+
+The intuition behind this criterion is as follows:
+We need to perform primary processing on all predecessors in order to
+find out any direct defs in those predecessors. When predecessors are
+done, we also know that we have information about indirect defs (e.g.
+in block B though that were inherited through B->C->A->B). However,
+we can't wait for all predecessors to be done, since that would
+cause cyclic dependencies. However, it is guaranteed that all those
+predecessors that are prior to us in reverse postorder will be done
+before us. Since we iterate of the basic blocks in reverse postorder,
+the number x above, is precisely the count of the number of predecessors
+prior to us in reverse postorder.
+---
+ lib/CodeGen/ExecutionDepsFix.cpp    | 223 ++++++++++++++++++++++--------------
+ test/CodeGen/X86/break-false-dep.ll |  57 +++++++++
+ 2 files changed, 197 insertions(+), 83 deletions(-)
+
+diff --git a/lib/CodeGen/ExecutionDepsFix.cpp b/lib/CodeGen/ExecutionDepsFix.cpp
+index e7c6b03..6ac1db4 100644
+--- a/lib/CodeGen/ExecutionDepsFix.cpp
++++ b/lib/CodeGen/ExecutionDepsFix.cpp
+@@ -142,8 +142,26 @@ class ExeDepsFix : public MachineFunctionPass {
+   std::vector<SmallVector<int, 1>> AliasMap;
+   const unsigned NumRegs;
+   LiveReg *LiveRegs;
+-  typedef DenseMap<MachineBasicBlock*, LiveReg*> LiveOutMap;
+-  LiveOutMap LiveOuts;
++  struct MBBInfo {
++    // Keeps clearance and domain information for all registers. Not that this
++    // is different from the usual definition notion of liveness. The CPU
++    // doesn't care whether or not we consider a register killed.
++    LiveReg *OutRegs;
++
++    // Whether we have gotten to this block in primary processing yet.
++    bool PrimaryCompleted;
++
++    // The number of predecessors for which primary processing has completed
++    unsigned IncomingProcessed;
++
++    // The value of `IncomingProcessed` at the start of primary processing
++    unsigned PrimaryIncoming;
++
++    // The number of predecessors for which all processing steps are done.
++    unsigned IncomingCompleted;
++  };
++  typedef DenseMap<MachineBasicBlock *, MBBInfo> MBBInfoMap;
++  MBBInfoMap MBBInfos;
+ 
+   /// List of undefined register reads in this block in forward order.
+   std::vector<std::pair<MachineInstr*, unsigned> > UndefReads;
+@@ -154,11 +172,6 @@ class ExeDepsFix : public MachineFunctionPass {
+   /// Current instruction number.
+   /// The first instruction in each basic block is 0.
+   int CurInstr;
+-
+-  /// True when the current block has a predecessor that hasn't been visited
+-  /// yet.
+-  bool SeenUnknownBackEdge;
+-
+ public:
+   ExeDepsFix(const TargetRegisterClass *rc)
+     : MachineFunctionPass(ID), RC(rc), NumRegs(RC->getNumRegs()) {}
+@@ -180,7 +193,6 @@ public:
+ private:
+   iterator_range<SmallVectorImpl<int>::const_iterator>
+   regIndices(unsigned Reg) const;
+-
+   // DomainValue allocation.
+   DomainValue *alloc(int domain = -1);
+   DomainValue *retain(DomainValue *DV) {
+@@ -199,8 +211,11 @@ private:
+ 
+   void enterBasicBlock(MachineBasicBlock*);
+   void leaveBasicBlock(MachineBasicBlock*);
+-  void visitInstr(MachineInstr*);
+-  void processDefs(MachineInstr*, bool Kill);
++  bool isBlockDone(MachineBasicBlock *);
++  void processBasicBlock(MachineBasicBlock *MBB, bool PrimaryPass, bool Done);
++  void updateSuccessors(MachineBasicBlock *MBB, bool Primary, bool Done);
++  bool visitInstr(MachineInstr *);
++  void processDefs(MachineInstr *, bool BlockDone, bool Kill);
+   void visitSoftInstr(MachineInstr*, unsigned mask);
+   void visitHardInstr(MachineInstr*, unsigned domain);
+   void pickBestRegisterForUndef(MachineInstr *MI, unsigned OpIdx,
+@@ -360,9 +375,6 @@ bool ExeDepsFix::merge(DomainValue *A, DomainValue *B) {
+ 
+ /// Set up LiveRegs by merging predecessor live-out values.
+ void ExeDepsFix::enterBasicBlock(MachineBasicBlock *MBB) {
+-  // Detect back-edges from predecessors we haven't processed yet.
+-  SeenUnknownBackEdge = false;
+-
+   // Reset instruction counter in each basic block.
+   CurInstr = 0;
+ 
+@@ -397,18 +409,18 @@ void ExeDepsFix::enterBasicBlock(MachineBasicBlock *MBB) {
+   // Try to coalesce live-out registers from predecessors.
+   for (MachineBasicBlock::const_pred_iterator pi = MBB->pred_begin(),
+        pe = MBB->pred_end(); pi != pe; ++pi) {
+-    LiveOutMap::const_iterator fi = LiveOuts.find(*pi);
+-    if (fi == LiveOuts.end()) {
+-      SeenUnknownBackEdge = true;
++    auto fi = MBBInfos.find(*pi);
++    assert(fi != MBBInfos.end());
++    LiveReg *Incoming = fi->second.OutRegs;
++    if (Incoming == nullptr) {
+       continue;
+     }
+-    assert(fi->second && "Can't have NULL entries");
+ 
+     for (unsigned rx = 0; rx != NumRegs; ++rx) {
+       // Use the most recent predecessor def for each register.
+-      LiveRegs[rx].Def = std::max(LiveRegs[rx].Def, fi->second[rx].Def);
++      LiveRegs[rx].Def = std::max(LiveRegs[rx].Def, Incoming[rx].Def);
+ 
+-      DomainValue *pdv = resolve(fi->second[rx].Value);
++      DomainValue *pdv = resolve(Incoming[rx].Value);
+       if (!pdv)
+         continue;
+       if (!LiveRegs[rx].Value) {
+@@ -432,35 +444,33 @@ void ExeDepsFix::enterBasicBlock(MachineBasicBlock *MBB) {
+         force(rx, pdv->getFirstDomain());
+     }
+   }
+-  DEBUG(dbgs() << "BB#" << MBB->getNumber()
+-        << (SeenUnknownBackEdge ? ": incomplete\n" : ": all preds known\n"));
++  DEBUG(
++      dbgs() << "BB#" << MBB->getNumber()
++             << (!isBlockDone(MBB) ? ": incomplete\n" : ": all preds known\n"));
+ }
+ 
+ void ExeDepsFix::leaveBasicBlock(MachineBasicBlock *MBB) {
+   assert(LiveRegs && "Must enter basic block first.");
++  LiveReg *OldOutRegs = MBBInfos[MBB].OutRegs;
+   // Save live registers at end of MBB - used by enterBasicBlock().
+   // Also use LiveOuts as a visited set to detect back-edges.
+-  bool First = LiveOuts.insert(std::make_pair(MBB, LiveRegs)).second;
+-
+-  if (First) {
+-    // LiveRegs was inserted in LiveOuts.  Adjust all defs to be relative to
+-    // the end of this block instead of the beginning.
+-    for (unsigned i = 0, e = NumRegs; i != e; ++i)
+-      LiveRegs[i].Def -= CurInstr;
+-  } else {
+-    // Insertion failed, this must be the second pass.
++  MBBInfos[MBB].OutRegs = LiveRegs;
++
++  // LiveRegs was inserted in LiveOuts.  Adjust all defs to be relative to
++  // the end of this block instead of the beginning.
++  for (unsigned i = 0, e = NumRegs; i != e; ++i)
++    LiveRegs[i].Def -= CurInstr;
++  if (OldOutRegs) {
++    // This must be the second pass.
+     // Release all the DomainValues instead of keeping them.
+     for (unsigned i = 0, e = NumRegs; i != e; ++i)
+-      release(LiveRegs[i].Value);
+-    delete[] LiveRegs;
++      release(OldOutRegs[i].Value);
++    delete[] OldOutRegs;
+   }
+   LiveRegs = nullptr;
+ }
+ 
+-void ExeDepsFix::visitInstr(MachineInstr *MI) {
+-  if (MI->isDebugValue())
+-    return;
+-
++bool ExeDepsFix::visitInstr(MachineInstr *MI) {
+   // Update instructions with explicit execution domains.
+   std::pair<uint16_t, uint16_t> DomP = TII->getExecutionDomain(*MI);
+   if (DomP.first) {
+@@ -470,9 +480,7 @@ void ExeDepsFix::visitInstr(MachineInstr *MI) {
+       visitHardInstr(MI, DomP.first);
+   }
+ 
+-  // Process defs to track register ages, and kill values clobbered by generic
+-  // instructions.
+-  processDefs(MI, !DomP.first);
++  return !DomP.first;
+ }
+ 
+ /// \brief Helps avoid false dependencies on undef registers by updating the
+@@ -542,14 +550,7 @@ bool ExeDepsFix::shouldBreakDependence(MachineInstr *MI, unsigned OpIdx,
+       DEBUG(dbgs() << ": Break dependency.\n");
+       continue;
+     }
+-    // The current clearance seems OK, but we may be ignoring a def from a
+-    // back-edge.
+-    if (!SeenUnknownBackEdge || Pref <= unsigned(CurInstr)) {
+-      DEBUG(dbgs() << ": OK .\n");
+-      return false;
+-    }
+-    // A def from an unprocessed back-edge may make us break this dependency.
+-    DEBUG(dbgs() << ": Wait for back-edge to resolve.\n");
++    DEBUG(dbgs() << ": OK .\n");
+     return false;
+   }
+   return true;
+@@ -559,16 +560,21 @@ bool ExeDepsFix::shouldBreakDependence(MachineInstr *MI, unsigned OpIdx,
+ // If Kill is set, also kill off DomainValues clobbered by the defs.
+ //
+ // Also break dependencies on partial defs and undef uses.
+-void ExeDepsFix::processDefs(MachineInstr *MI, bool Kill) {
++void ExeDepsFix::processDefs(MachineInstr *MI, bool BlockDone, bool Kill) {
+   assert(!MI->isDebugValue() && "Won't process debug values");
+ 
+   // Break dependence on undef uses. Do this before updating LiveRegs below.
+   unsigned OpNum;
+-  unsigned Pref = TII->getUndefRegClearance(*MI, OpNum, TRI);
+-  if (Pref) {
+-    pickBestRegisterForUndef(MI, OpNum, Pref);
+-    if (shouldBreakDependence(MI, OpNum, Pref))
+-      UndefReads.push_back(std::make_pair(MI, OpNum));
++  // If this block is not done, it makes little sense to make any decisions
++  // based on clearance information. We need to make a second pass anyway,
++  // and by then we'll have better information, so we can avoid this work now.
++  if (BlockDone) {
++    unsigned Pref = TII->getUndefRegClearance(*MI, OpNum, TRI);
++    if (Pref) {
++      pickBestRegisterForUndef(MI, OpNum, Pref);
++      if (shouldBreakDependence(MI, OpNum, Pref))
++        UndefReads.push_back(std::make_pair(MI, OpNum));
++    }
+   }
+   const MCInstrDesc &MCID = MI->getDesc();
+   for (unsigned i = 0,
+@@ -584,11 +590,13 @@ void ExeDepsFix::processDefs(MachineInstr *MI, bool Kill) {
+       DEBUG(dbgs() << TRI->getName(RC->getRegister(rx)) << ":\t" << CurInstr
+                    << '\t' << *MI);
+ 
+-      // Check clearance before partial register updates.
+-      // Call breakDependence before setting LiveRegs[rx].Def.
+-      unsigned Pref = TII->getPartialRegUpdateClearance(*MI, i, TRI);
+-      if (Pref && shouldBreakDependence(MI, i, Pref))
+-        TII->breakPartialRegDependency(*MI, i, TRI);
++      if (BlockDone) {
++        // Check clearance before partial register updates.
++        // Call breakDependence before setting LiveRegs[rx].Def.
++        unsigned Pref = TII->getPartialRegUpdateClearance(*MI, i, TRI);
++        if (Pref && shouldBreakDependence(MI, i, Pref))
++          TII->breakPartialRegDependency(*MI, i, TRI);
++      }
+ 
+       // How many instructions since rx was last written?
+       LiveRegs[rx].Def = CurInstr;
+@@ -780,6 +788,45 @@ void ExeDepsFix::visitSoftInstr(MachineInstr *mi, unsigned mask) {
+   }
+ }
+ 
++void ExeDepsFix::processBasicBlock(MachineBasicBlock *MBB, bool PrimaryPass,
++                                   bool Done) {
++  enterBasicBlock(MBB);
++  for (MachineInstr &MI : *MBB) {
++    if (!MI.isDebugValue()) {
++      bool Kill = false;
++      if (PrimaryPass)
++        Kill = visitInstr(&MI);
++      processDefs(&MI, isBlockDone(MBB), Kill);
++    }
++  }
++  processUndefReads(MBB);
++  leaveBasicBlock(MBB);
++}
++
++bool ExeDepsFix::isBlockDone(MachineBasicBlock *MBB) {
++  return MBBInfos[MBB].PrimaryCompleted &&
++         MBBInfos[MBB].IncomingCompleted == MBBInfos[MBB].PrimaryIncoming &&
++         MBBInfos[MBB].IncomingProcessed == MBB->pred_size();
++}
++
++void ExeDepsFix::updateSuccessors(MachineBasicBlock *MBB, bool Primary,
++                                  bool Done) {
++  for (auto *Succ : MBB->successors()) {
++    if (!isBlockDone(Succ)) {
++      if (Primary) {
++        MBBInfos[Succ].IncomingProcessed++;
++      }
++      if (Done) {
++        MBBInfos[Succ].IncomingCompleted++;
++      }
++      if (isBlockDone(Succ)) {
++        processBasicBlock(Succ, false, true);
++        updateSuccessors(Succ, false, true);
++      }
++    }
++  }
++}
++
+ bool ExeDepsFix::runOnMachineFunction(MachineFunction &mf) {
+   if (skipFunction(*mf.getFunction()))
+     return false;
+@@ -816,44 +863,54 @@ bool ExeDepsFix::runOnMachineFunction(MachineFunction &mf) {
+         AliasMap[*AI].push_back(i);
+   }
+ 
++  // Initialize the MMBInfos
++  for (auto &MBB : mf) {
++    MBBInfo InitialInfo{nullptr, false, 0, 0, 0};
++    MBBInfos.insert(std::make_pair(&MBB, InitialInfo));
++  }
++
+   MachineBasicBlock *Entry = &*MF->begin();
+   ReversePostOrderTraversal<MachineBasicBlock*> RPOT(Entry);
+-  SmallVector<MachineBasicBlock*, 16> Loops;
+   for (ReversePostOrderTraversal<MachineBasicBlock*>::rpo_iterator
+          MBBI = RPOT.begin(), MBBE = RPOT.end(); MBBI != MBBE; ++MBBI) {
+     MachineBasicBlock *MBB = *MBBI;
+-    enterBasicBlock(MBB);
+-    if (SeenUnknownBackEdge)
+-      Loops.push_back(MBB);
+-    for (MachineInstr &MI : *MBB)
+-      visitInstr(&MI);
+-    processUndefReads(MBB);
+-    leaveBasicBlock(MBB);
+-  }
+-
+-  // Visit all the loop blocks again in order to merge DomainValues from
+-  // back-edges.
+-  for (MachineBasicBlock *MBB : Loops) {
+-    enterBasicBlock(MBB);
+-    for (MachineInstr &MI : *MBB)
+-      if (!MI.isDebugValue())
+-        processDefs(&MI, false);
+-    processUndefReads(MBB);
+-    leaveBasicBlock(MBB);
++    MBBInfos[MBB].PrimaryCompleted = true;
++    MBBInfos[MBB].PrimaryIncoming = MBBInfos[MBB].IncomingProcessed;
++    bool PrimaryDone = isBlockDone(MBB);
++    processBasicBlock(MBB, true, PrimaryDone);
++    updateSuccessors(MBB, true, PrimaryDone);
++  }
++
++  // We need to go through again and finalize any blocks that are not done yet.
++  // This is possible if blocks have dead predecessors, so we didn't visit them
++  // above. N.B.: The reason we update succesors immidately above, rather than
++  // doing everything in one go here, is to avoid having to do two passes on
++  // basic block between loops (with the scheme above, the whole loop will be
++  // completed before moving on to the blocks after it).
++  for (ReversePostOrderTraversal<MachineBasicBlock *>::rpo_iterator
++           MBBI = RPOT.begin(),
++           MBBE = RPOT.end();
++       MBBI != MBBE; ++MBBI) {
++    MachineBasicBlock *MBB = *MBBI;
++    if (!isBlockDone(MBB)) {
++      processBasicBlock(MBB, false, true);
++      // Don't update successors here. We'll get to them anyway through this
++      // loop.
++    }
+   }
+ 
+   // Clear the LiveOuts vectors and collapse any remaining DomainValues.
+   for (ReversePostOrderTraversal<MachineBasicBlock*>::rpo_iterator
+          MBBI = RPOT.begin(), MBBE = RPOT.end(); MBBI != MBBE; ++MBBI) {
+-    LiveOutMap::const_iterator FI = LiveOuts.find(*MBBI);
+-    if (FI == LiveOuts.end() || !FI->second)
++    auto FI = MBBInfos.find(*MBBI);
++    if (FI == MBBInfos.end() || !FI->second.OutRegs)
+       continue;
+     for (unsigned i = 0, e = NumRegs; i != e; ++i)
+-      if (FI->second[i].Value)
+-        release(FI->second[i].Value);
+-    delete[] FI->second;
++      if (FI->second.OutRegs[i].Value)
++        release(FI->second.OutRegs[i].Value);
++    delete[] FI->second.OutRegs;
+   }
+-  LiveOuts.clear();
++  MBBInfos.clear();
+   UndefReads.clear();
+   Avail.clear();
+   Allocator.DestroyAll();
+diff --git a/test/CodeGen/X86/break-false-dep.ll b/test/CodeGen/X86/break-false-dep.ll
+index 4c5e747..0ba1825 100644
+--- a/test/CodeGen/X86/break-false-dep.ll
++++ b/test/CodeGen/X86/break-false-dep.ll
+@@ -277,3 +277,60 @@ ret:
+ ;AVX: vcvtsi2sdq {{.*}}, [[XMM4_7:%xmm[4-7]]], {{%xmm[0-9]+}}
+ ;AVX-NOT: [[XMM4_7]]
+ }
++
++; Make sure we are making a smart choice regarding undef registers even for more
++; complicated loop structures. This example is the inner loop from
++; julia> a = falses(10000); a[1:4:end] = true
++; julia> linspace(1.0,2.0,10000)[a]
++define void @loopclearance2(double* nocapture %y, i64* %x, double %c1, double %c2, double %c3, double %c4, i64 %size) {
++entry:
++  tail call void asm sideeffect "", "~{xmm7},~{dirflag},~{fpsr},~{flags}"()
++  tail call void asm sideeffect "", "~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{dirflag},~{fpsr},~{flags}"()
++  tail call void asm sideeffect "", "~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{dirflag},~{fpsr},~{flags}"()
++  br label %loop
++
++loop:
++  %phi_i = phi i64 [ 1, %entry ], [ %nexti, %loop_end ]
++  %phi_j = phi i64 [ 1, %entry ], [ %nextj, %loop_end ]
++  %phi_k = phi i64 [ 0, %entry ], [ %nextk, %loop_end ]
++  br label %inner_loop
++
++inner_loop:
++  %phi = phi i64 [ %phi_k, %loop ], [ %nextk, %inner_loop ]
++  %idx = lshr i64 %phi, 6
++  %inputptr = getelementptr i64, i64* %x, i64 %idx
++  %input = load i64, i64* %inputptr, align 8
++  %masked = and i64 %phi, 63
++  %shiftedmasked = shl i64 1, %masked
++  %maskedinput = and i64 %input, %shiftedmasked
++  %cmp = icmp eq i64 %maskedinput, 0
++  %nextk = add i64 %phi, 1
++  br i1 %cmp, label %inner_loop, label %loop_end
++
++loop_end:
++  %nexti = add i64 %phi_i, 1
++  %nextj = add i64 %phi_j, 1
++  ; Register use, plus us clobbering 7-15 above, basically forces xmm7 here as
++  ; the only reasonable choice. The primary thing we care about is that it's
++  ; not one of the registers used in the loop (e.g. not the output reg here)
++;AVX-NOT: %xmm6
++;AVX: vcvtsi2sdq {{.*}}, %xmm6, {{%xmm[0-9]+}}
++;AVX-NOT: %xmm6
++  %nexti_f = sitofp i64 %nexti to double
++  %sub = fsub double %c1, %nexti_f
++  %mul = fmul double %sub, %c2
++;AVX: vcvtsi2sdq {{.*}}, %xmm6, {{%xmm[0-9]+}}
++;AVX-NOT: %xmm6
++  %phi_f = sitofp i64 %phi to double
++  %mul2 = fmul double %phi_f, %c3
++  %add2 = fadd double %mul, %mul2
++  %div = fdiv double %add2, %c4
++  %prev_j = add i64 %phi_j, -1
++  %outptr = getelementptr double, double* %y, i64 %prev_j
++  store double %div, double* %outptr, align 8
++  %done = icmp slt i64 %size, %nexti
++  br i1 %done, label %loopdone, label %loop
++
++loopdone:
++  ret void
++}
+-- 
+2.9.3
diff --git a/deps/patches/llvm-D28786-callclearance.patch b/deps/patches/llvm-D28786-callclearance.patch
new file mode 100644
index 00000000000000..fa7dfd3f22d38c
--- /dev/null
+++ b/deps/patches/llvm-D28786-callclearance.patch
@@ -0,0 +1,344 @@
+diff --git a/include/llvm/Target/TargetInstrInfo.h b/include/llvm/Target/TargetInstrInfo.h
+index 83515bc..65b435a 100644
+--- a/include/llvm/Target/TargetInstrInfo.h
++++ b/include/llvm/Target/TargetInstrInfo.h
+@@ -1440,6 +1440,17 @@ public:
+   virtual void breakPartialRegDependency(MachineInstr &MI, unsigned OpNum,
+                                          const TargetRegisterInfo *TRI) const {}
+ 
++  /// May return true if the instruction in question is a dependency breaking
++  /// instruction. If so, the register number for which it is dependency
++  /// breaking should be returned in `OutReg`. It is prefereable to return
++  /// false if the result cannot be determined. This would at worst result
++  /// in the insertion of an unnecessary instruction, while the other
++  /// alternative could result in significant false-dependency penalties.
++  virtual bool isDependencyBreak(MachineInstr &MI,
++                                 unsigned *OutReg = nullptr) const {
++    return false;
++  }
++
+   /// Create machine specific model for scheduling.
+   virtual DFAPacketizer *
+   CreateTargetScheduleState(const TargetSubtargetInfo &) const {
+diff --git a/lib/CodeGen/ExecutionDepsFix.cpp b/lib/CodeGen/ExecutionDepsFix.cpp
+index 6ac1db4..63065ea 100644
+--- a/lib/CodeGen/ExecutionDepsFix.cpp
++++ b/lib/CodeGen/ExecutionDepsFix.cpp
+@@ -214,13 +214,18 @@ private:
+   bool isBlockDone(MachineBasicBlock *);
+   void processBasicBlock(MachineBasicBlock *MBB, bool PrimaryPass, bool Done);
+   void updateSuccessors(MachineBasicBlock *MBB, bool Primary, bool Done);
+-  bool visitInstr(MachineInstr *);
++  bool visitInstr(MachineInstr *, bool PrimaryPass);
+   void processDefs(MachineInstr *, bool BlockDone, bool Kill);
+   void visitSoftInstr(MachineInstr*, unsigned mask);
+   void visitHardInstr(MachineInstr*, unsigned domain);
+-  void pickBestRegisterForUndef(MachineInstr *MI, unsigned OpIdx,
+-                                unsigned Pref);
++  void pickBestRegisterForUndef(MachineInstr *MI, unsigned OpIdx, unsigned Pref,
++                                bool &TrueDependency);
+   bool shouldBreakDependence(MachineInstr*, unsigned OpIdx, unsigned Pref);
++
++  // Undef Reads
++  void collapseUndefReads(unsigned from, unsigned to, unsigned Reg);
++  unsigned updateChooseableRegs(SparseSet<unsigned> &,
++                                const TargetRegisterClass *, bool);
+   void processUndefReads(MachineBasicBlock*);
+ };
+ }
+@@ -394,11 +399,19 @@ void ExeDepsFix::enterBasicBlock(MachineBasicBlock *MBB) {
+ 
+   // This is the entry block.
+   if (MBB->pred_empty()) {
++    // Treat all registers as being defined just before the first instruction.
++    // Howver, we want the logic later to prefer non live-ins over live-ins,
++    // so pretend the live-ins were defined slightly later.
++    // We used to only do this for live-ins, but that's a bit of a gamble.
++    // If our caller does arithmetic with these registers is is quite likely
++    // that it will have used registers beyond the ones that are live here.
++    // Given the immense penalty for getting this wrong, being conservative
++    // here seems worth it.
++    for (unsigned rx = 0; rx != NumRegs; ++rx) {
++      LiveRegs[rx].Def = -2;
++    }
+     for (const auto &LI : MBB->liveins()) {
+       for (int rx : regIndices(LI.PhysReg)) {
+-        // Treat function live-ins as if they were defined just before the first
+-        // instruction.  Usually, function arguments are set up immediately
+-        // before the call.
+         LiveRegs[rx].Def = -1;
+       }
+     }
+@@ -470,24 +483,36 @@ void ExeDepsFix::leaveBasicBlock(MachineBasicBlock *MBB) {
+   LiveRegs = nullptr;
+ }
+ 
+-bool ExeDepsFix::visitInstr(MachineInstr *MI) {
+-  // Update instructions with explicit execution domains.
+-  std::pair<uint16_t, uint16_t> DomP = TII->getExecutionDomain(*MI);
+-  if (DomP.first) {
+-    if (DomP.second)
+-      visitSoftInstr(MI, DomP.second);
+-    else
+-      visitHardInstr(MI, DomP.first);
++bool ExeDepsFix::visitInstr(MachineInstr *MI, bool PrimaryPass) {
++  bool Kill = false;
++
++  if (PrimaryPass) {
++    // Update instructions with explicit execution domains.
++    std::pair<uint16_t, uint16_t> DomP = TII->getExecutionDomain(*MI);
++    if (DomP.first) {
++      if (DomP.second)
++        visitSoftInstr(MI, DomP.second);
++      else
++        visitHardInstr(MI, DomP.first);
++    }
++    Kill = !DomP.first;
+   }
+ 
+-  return !DomP.first;
++  // If this is a call, pretend all registers we are considering are def'd here.
++  // We have no idea which registers the callee may use.
++  if (MI->isCall()) {
++    for (unsigned i = 0, e = NumRegs; i != e; ++i)
++      LiveRegs[i].Def = CurInstr;
++  }
++
++  return Kill;
+ }
+ 
+ /// \brief Helps avoid false dependencies on undef registers by updating the
+ /// machine instructions' undef operand to use a register that the instruction
+ /// is truly dependent on, or use a register with clearance higher than Pref.
+ void ExeDepsFix::pickBestRegisterForUndef(MachineInstr *MI, unsigned OpIdx,
+-                                          unsigned Pref) {
++                                          unsigned Pref, bool &TrueDependency) {
+   MachineOperand &MO = MI->getOperand(OpIdx);
+   assert(MO.isUndef() && "Expected undef machine operand");
+ 
+@@ -510,6 +535,7 @@ void ExeDepsFix::pickBestRegisterForUndef(MachineInstr *MI, unsigned OpIdx,
+     // We found a true dependency - replace the undef register with the true
+     // dependency.
+     MO.setReg(CurrMO.getReg());
++    TrueDependency = true;
+     return;
+   }
+ 
+@@ -571,9 +597,14 @@ void ExeDepsFix::processDefs(MachineInstr *MI, bool BlockDone, bool Kill) {
+   if (BlockDone) {
+     unsigned Pref = TII->getUndefRegClearance(*MI, OpNum, TRI);
+     if (Pref) {
+-      pickBestRegisterForUndef(MI, OpNum, Pref);
+-      if (shouldBreakDependence(MI, OpNum, Pref))
++      bool TrueDependency = false;
++      pickBestRegisterForUndef(MI, OpNum, Pref, TrueDependency);
++      // Don't bother adding true dependencies to UndefReads. All we'd find out
++      // is that the register is live (since this very instruction depends on
++      // it), so we can't do anything.
++      if (!TrueDependency && shouldBreakDependence(MI, OpNum, Pref)) {
+         UndefReads.push_back(std::make_pair(MI, OpNum));
++      }
+     }
+   }
+   const MCInstrDesc &MCID = MI->getDesc();
+@@ -606,9 +637,52 @@ void ExeDepsFix::processDefs(MachineInstr *MI, bool BlockDone, bool Kill) {
+         kill(rx);
+     }
+   }
++  unsigned DepReg = 0;
++  if (TII->isDependencyBreak(*MI, &DepReg)) {
++    for (int rx : regIndices(DepReg)) {
++      // This instruction is a dependency break, so there are no clearance
++      // issues, reset the counter.
++      LiveRegs[rx].Def = -(1 << 20);
++    }
++  }
+   ++CurInstr;
+ }
+ 
++// Set the undef read register to `Reg` for all UndefReads in the range
++// [from,to).
++void ExeDepsFix::collapseUndefReads(unsigned from, unsigned to, unsigned Reg) {
++  if (from >= to)
++    return;
++  for (unsigned i = from; i < to; ++i) {
++    MachineInstr *MI = std::get<0>(UndefReads[i]);
++    unsigned OpIdx = std::get<1>(UndefReads[i]);
++    MachineOperand &MO = MI->getOperand(OpIdx);
++    MO.setReg(Reg);
++  }
++  TII->breakPartialRegDependency(*std::get<0>(UndefReads[from]),
++                                 std::get<1>(UndefReads[from]), TRI);
++}
++
++unsigned ExeDepsFix::updateChooseableRegs(SparseSet<unsigned> &ChoosableRegs,
++                                          const TargetRegisterClass *OpRC,
++                                          bool add) {
++  unsigned LowestValid = (unsigned)-1;
++
++  for (auto Reg : OpRC->getRegisters()) {
++    if (LiveRegSet.contains(Reg))
++      ChoosableRegs.erase(Reg);
++    else if (add) {
++      ChoosableRegs.insert(Reg);
++      if (LowestValid == (unsigned)-1)
++        LowestValid = Reg;
++    } else if (ChoosableRegs.count(Reg) == 1) {
++      if (LowestValid == (unsigned)-1)
++        LowestValid = Reg;
++    }
++  }
++  return LowestValid;
++}
++
+ /// \break Break false dependencies on undefined register reads.
+ ///
+ /// Walk the block backward computing precise liveness. This is expensive, so we
+@@ -619,31 +693,87 @@ void ExeDepsFix::processUndefReads(MachineBasicBlock *MBB) {
+   if (UndefReads.empty())
+     return;
+ 
++  // We want to be slightly clever here, to avoid the following common pattern:
++  // Suppose we have some instruction `vrandom %in, %out` and the following code
++  //    vrandom %xmm0<undef>, %xmm0<def>
++  //    vrandom %xmm1<undef>, %xmm1<def>
++  //    vrandom %xmm2<undef>, %xmm2<def>
++  //    vrandom %xmm3<undef>, %xmm3<def>
++  // The earlier logic likes to produce these, because it picks the first
++  // register
++  // to break ties in clearance. However, most register allocators pick the dest
++  // register the same way. Naively, we'd have to insert a dependency break,
++  // before every instruction above. However, what we really want is
++  //    vxorps %xmm3, %xmm3, %xmm3
++  //    vrandom %xmm3<undef>, %xmm0<def>
++  //    vrandom %xmm3<undef>, %xmm1<def>
++  //    vrandom %xmm3<undef>, %xmm2<def>
++  //    vrandom %xmm3<undef>, %xmm3<def>
++  // To do so, we walk backwards and cumulatively keep track of which registers
++  // we can use to break the dependency. Then, once the set has collapsed, we
++  // reset the undef read register for all following instructions.
++
+   // Collect this block's live out register units.
+   LiveRegSet.init(TRI);
+   // We do not need to care about pristine registers as they are just preserved
+   // but not actually used in the function.
+   LiveRegSet.addLiveOutsNoPristines(*MBB);
+ 
+-  MachineInstr *UndefMI = UndefReads.back().first;
+-  unsigned OpIdx = UndefReads.back().second;
++  SparseSet<unsigned> ChoosableRegs;
++  ChoosableRegs.setUniverse(TRI->getNumRegs());
++
++  unsigned LastValid = (unsigned)-1;
++  const TargetRegisterClass *LastOpRC = nullptr;
++  size_t i, LastInit;
++  i = LastInit = UndefReads.size() - 1;
++  MachineInstr *UndefMI = std::get<0>(UndefReads[i]);
+ 
+   for (MachineInstr &I : make_range(MBB->rbegin(), MBB->rend())) {
+     // Update liveness, including the current instruction's defs.
+     LiveRegSet.stepBackward(I);
+ 
++    // This ensures that we don't accidentally pick a register whose live region
++    // lies entirely between two undef reads (since that would defeat the
++    // purpose of breaking the dependency).
++    for (auto LiveReg : LiveRegSet)
++      ChoosableRegs.erase(LiveReg);
++
+     if (UndefMI == &I) {
+-      if (!LiveRegSet.contains(UndefMI->getOperand(OpIdx).getReg()))
+-        TII->breakPartialRegDependency(*UndefMI, OpIdx, TRI);
++      unsigned OpIdx = std::get<1>(UndefReads[i]);
++      // Get the undef operand's register class
++      const TargetRegisterClass *OpRC =
++          TII->getRegClass(UndefMI->getDesc(), OpIdx, TRI, *MF);
++      if (OpRC != LastOpRC || ChoosableRegs.size() == 0) {
++        if (LastInit != i) {
++          if (LastValid != (unsigned)-1)
++            collapseUndefReads(i + 1, LastInit + 1, LastValid);
++          ChoosableRegs.clear();
++          LastInit = i;
++        }
++      }
++
++      unsigned LowestValid =
++          updateChooseableRegs(ChoosableRegs, OpRC, LastInit == i);
++
++      if (ChoosableRegs.size() == 0) {
++        if (LastInit != i) {
++          if (LastValid != (unsigned)-1)
++            collapseUndefReads(i + 1, LastInit + 1, LastValid);
++          LowestValid = updateChooseableRegs(ChoosableRegs, OpRC, true);
++          LastInit = i;
++        }
++      }
++      LastValid = LowestValid;
++      LastOpRC = OpRC;
+ 
+-      UndefReads.pop_back();
+-      if (UndefReads.empty())
+-        return;
++      if (i == 0)
++        break;
+ 
+-      UndefMI = UndefReads.back().first;
+-      OpIdx = UndefReads.back().second;
++      UndefMI = std::get<0>(UndefReads[--i]);
+     }
+   }
++  if (LastValid != (unsigned)-1)
++    collapseUndefReads(0, LastInit + 1, LastValid);
+ }
+ 
+ // A hard instruction only works in one domain. All input registers will be
+@@ -793,9 +923,7 @@ void ExeDepsFix::processBasicBlock(MachineBasicBlock *MBB, bool PrimaryPass,
+   enterBasicBlock(MBB);
+   for (MachineInstr &MI : *MBB) {
+     if (!MI.isDebugValue()) {
+-      bool Kill = false;
+-      if (PrimaryPass)
+-        Kill = visitInstr(&MI);
++      bool Kill = visitInstr(&MI, PrimaryPass);
+       processDefs(&MI, isBlockDone(MBB), Kill);
+     }
+   }
+diff --git a/lib/Target/X86/X86InstrInfo.cpp b/lib/Target/X86/X86InstrInfo.cpp
+index 5793597..f31c97e 100644
+--- a/lib/Target/X86/X86InstrInfo.cpp
++++ b/lib/Target/X86/X86InstrInfo.cpp
+@@ -7496,6 +7496,23 @@ void X86InstrInfo::breakPartialRegDependency(
+   }
+ }
+ 
++bool X86InstrInfo::isDependencyBreak(MachineInstr &MI, unsigned *OutReg) const {
++  unsigned Opc = MI.getOpcode();
++  if (!(Opc == X86::VXORPSrr || Opc == X86::VXORPDrr || Opc == X86::XORPSrr ||
++        Opc == X86::XORPDrr))
++    return false;
++  unsigned Reg = 0;
++  for (unsigned i = 0; i < MI.getNumOperands(); ++i) {
++    const MachineOperand &MO = MI.getOperand(i);
++    if (!MO.isReg() || (Reg != 0 && MO.getReg() != Reg))
++      return false;
++    Reg = MO.getReg();
++  }
++  if (OutReg)
++    *OutReg = Reg;
++  return true;
++}
++
+ MachineInstr *
+ X86InstrInfo::foldMemoryOperandImpl(MachineFunction &MF, MachineInstr &MI,
+                                     ArrayRef<unsigned> Ops,
+diff --git a/lib/Target/X86/X86InstrInfo.h b/lib/Target/X86/X86InstrInfo.h
+index 8d74617..fa86882 100644
+--- a/lib/Target/X86/X86InstrInfo.h
++++ b/lib/Target/X86/X86InstrInfo.h
+@@ -484,6 +484,7 @@ public:
+                                 const TargetRegisterInfo *TRI) const override;
+   void breakPartialRegDependency(MachineInstr &MI, unsigned OpNum,
+                                  const TargetRegisterInfo *TRI) const override;
++  bool isDependencyBreak(MachineInstr &MI, unsigned *OutReg) const override;
+ 
+   MachineInstr *foldMemoryOperandImpl(MachineFunction &MF, MachineInstr &MI,
+                                       unsigned OpNum,
diff --git a/deps/patches/llvm-D28786-callclearance_4.0.patch b/deps/patches/llvm-D28786-callclearance_4.0.patch
new file mode 100644
index 00000000000000..2735c7f5b3e947
--- /dev/null
+++ b/deps/patches/llvm-D28786-callclearance_4.0.patch
@@ -0,0 +1,344 @@
+diff --git a/include/llvm/Target/TargetInstrInfo.h b/include/llvm/Target/TargetInstrInfo.h
+index 247d694f2e4..e455549cdc6 100644
+--- a/include/llvm/Target/TargetInstrInfo.h
++++ b/include/llvm/Target/TargetInstrInfo.h
+@@ -1421,6 +1421,17 @@ public:
+   virtual void breakPartialRegDependency(MachineInstr &MI, unsigned OpNum,
+                                          const TargetRegisterInfo *TRI) const {}
+ 
++  /// May return true if the instruction in question is a dependency breaking
++  /// instruction. If so, the register number for which it is dependency
++  /// breaking should be returned in `OutReg`. It is prefereable to return
++  /// false if the result cannot be determined. This would at worst result
++  /// in the insertion of an unnecessary instruction, while the other
++  /// alternative could result in significant false-dependency penalties.
++  virtual bool isDependencyBreak(MachineInstr &MI,
++                                 unsigned *OutReg = nullptr) const {
++    return false;
++  }
++
+   /// Create machine specific model for scheduling.
+   virtual DFAPacketizer *
+   CreateTargetScheduleState(const TargetSubtargetInfo &) const {
+diff --git a/lib/CodeGen/ExecutionDepsFix.cpp b/lib/CodeGen/ExecutionDepsFix.cpp
+index 64aed533a9d..9f3bd634622 100644
+--- a/lib/CodeGen/ExecutionDepsFix.cpp
++++ b/lib/CodeGen/ExecutionDepsFix.cpp
+@@ -214,13 +214,18 @@ private:
+   bool isBlockDone(MachineBasicBlock *);
+   void processBasicBlock(MachineBasicBlock *MBB, bool PrimaryPass, bool Done);
+   void updateSuccessors(MachineBasicBlock *MBB, bool Primary, bool Done);
+-  bool visitInstr(MachineInstr *);
++  bool visitInstr(MachineInstr *, bool PrimaryPass);
+   void processDefs(MachineInstr *, bool BlockDone, bool Kill);
+   void visitSoftInstr(MachineInstr*, unsigned mask);
+   void visitHardInstr(MachineInstr*, unsigned domain);
+-  void pickBestRegisterForUndef(MachineInstr *MI, unsigned OpIdx,
+-                                unsigned Pref);
++  void pickBestRegisterForUndef(MachineInstr *MI, unsigned OpIdx, unsigned Pref,
++                                bool &TrueDependency);
+   bool shouldBreakDependence(MachineInstr*, unsigned OpIdx, unsigned Pref);
++
++  // Undef Reads
++  void collapseUndefReads(unsigned from, unsigned to, unsigned Reg);
++  unsigned updateChooseableRegs(SparseSet<unsigned> &,
++                                const TargetRegisterClass *, bool);
+   void processUndefReads(MachineBasicBlock*);
+ };
+ }
+@@ -394,11 +399,19 @@ void ExeDepsFix::enterBasicBlock(MachineBasicBlock *MBB) {
+ 
+   // This is the entry block.
+   if (MBB->pred_empty()) {
++    // Treat all registers as being defined just before the first instruction.
++    // Howver, we want the logic later to prefer non live-ins over live-ins,
++    // so pretend the live-ins were defined slightly later.
++    // We used to only do this for live-ins, but that's a bit of a gamble.
++    // If our caller does arithmetic with these registers is is quite likely
++    // that it will have used registers beyond the ones that are live here.
++    // Given the immense penalty for getting this wrong, being conservative
++    // here seems worth it.
++    for (unsigned rx = 0; rx != NumRegs; ++rx) {
++      LiveRegs[rx].Def = -2;
++    }
+     for (const auto &LI : MBB->liveins()) {
+       for (int rx : regIndices(LI.PhysReg)) {
+-        // Treat function live-ins as if they were defined just before the first
+-        // instruction.  Usually, function arguments are set up immediately
+-        // before the call.
+         LiveRegs[rx].Def = -1;
+       }
+     }
+@@ -470,24 +483,36 @@ void ExeDepsFix::leaveBasicBlock(MachineBasicBlock *MBB) {
+   LiveRegs = nullptr;
+ }
+ 
+-bool ExeDepsFix::visitInstr(MachineInstr *MI) {
+-  // Update instructions with explicit execution domains.
+-  std::pair<uint16_t, uint16_t> DomP = TII->getExecutionDomain(*MI);
+-  if (DomP.first) {
+-    if (DomP.second)
+-      visitSoftInstr(MI, DomP.second);
+-    else
+-      visitHardInstr(MI, DomP.first);
++bool ExeDepsFix::visitInstr(MachineInstr *MI, bool PrimaryPass) {
++  bool Kill = false;
++
++  if (PrimaryPass) {
++    // Update instructions with explicit execution domains.
++    std::pair<uint16_t, uint16_t> DomP = TII->getExecutionDomain(*MI);
++    if (DomP.first) {
++      if (DomP.second)
++        visitSoftInstr(MI, DomP.second);
++      else
++        visitHardInstr(MI, DomP.first);
++    }
++    Kill = !DomP.first;
++  }
++
++  // If this is a call, pretend all registers we are considering are def'd here.
++  // We have no idea which registers the callee may use.
++  if (MI->isCall()) {
++    for (unsigned i = 0, e = NumRegs; i != e; ++i)
++      LiveRegs[i].Def = CurInstr;
+   }
+ 
+-  return !DomP.first;
++  return Kill;
+ }
+ 
+ /// \brief Helps avoid false dependencies on undef registers by updating the
+ /// machine instructions' undef operand to use a register that the instruction
+ /// is truly dependent on, or use a register with clearance higher than Pref.
+ void ExeDepsFix::pickBestRegisterForUndef(MachineInstr *MI, unsigned OpIdx,
+-                                          unsigned Pref) {
++                                          unsigned Pref, bool &TrueDependency) {
+   MachineOperand &MO = MI->getOperand(OpIdx);
+   assert(MO.isUndef() && "Expected undef machine operand");
+ 
+@@ -510,6 +535,7 @@ void ExeDepsFix::pickBestRegisterForUndef(MachineInstr *MI, unsigned OpIdx,
+     // We found a true dependency - replace the undef register with the true
+     // dependency.
+     MO.setReg(CurrMO.getReg());
++    TrueDependency = true;
+     return;
+   }
+ 
+@@ -571,9 +597,14 @@ void ExeDepsFix::processDefs(MachineInstr *MI, bool BlockDone, bool Kill) {
+   if (BlockDone) {
+     unsigned Pref = TII->getUndefRegClearance(*MI, OpNum, TRI);
+     if (Pref) {
+-      pickBestRegisterForUndef(MI, OpNum, Pref);
+-      if (shouldBreakDependence(MI, OpNum, Pref))
++      bool TrueDependency = false;
++      pickBestRegisterForUndef(MI, OpNum, Pref, TrueDependency);
++      // Don't bother adding true dependencies to UndefReads. All we'd find out
++      // is that the register is live (since this very instruction depends on
++      // it), so we can't do anything.
++      if (!TrueDependency && shouldBreakDependence(MI, OpNum, Pref)) {
+         UndefReads.push_back(std::make_pair(MI, OpNum));
++      }
+     }
+   }
+   const MCInstrDesc &MCID = MI->getDesc();
+@@ -606,9 +637,52 @@ void ExeDepsFix::processDefs(MachineInstr *MI, bool BlockDone, bool Kill) {
+         kill(rx);
+     }
+   }
++  unsigned DepReg = 0;
++  if (TII->isDependencyBreak(*MI, &DepReg)) {
++    for (int rx : regIndices(DepReg)) {
++      // This instruction is a dependency break, so there are no clearance
++      // issues, reset the counter.
++      LiveRegs[rx].Def = -(1 << 20);
++    }
++  }
+   ++CurInstr;
+ }
+ 
++// Set the undef read register to `Reg` for all UndefReads in the range
++// [from,to).
++void ExeDepsFix::collapseUndefReads(unsigned from, unsigned to, unsigned Reg) {
++  if (from >= to)
++    return;
++  for (unsigned i = from; i < to; ++i) {
++    MachineInstr *MI = std::get<0>(UndefReads[i]);
++    unsigned OpIdx = std::get<1>(UndefReads[i]);
++    MachineOperand &MO = MI->getOperand(OpIdx);
++    MO.setReg(Reg);
++  }
++  TII->breakPartialRegDependency(*std::get<0>(UndefReads[from]),
++                                 std::get<1>(UndefReads[from]), TRI);
++}
++
++unsigned ExeDepsFix::updateChooseableRegs(SparseSet<unsigned> &ChoosableRegs,
++                                          const TargetRegisterClass *OpRC,
++                                          bool add) {
++  unsigned LowestValid = (unsigned)-1;
++
++  for (auto Reg : OpRC->getRegisters()) {
++    if (LiveRegSet.contains(Reg))
++      ChoosableRegs.erase(Reg);
++    else if (add) {
++      ChoosableRegs.insert(Reg);
++      if (LowestValid == (unsigned)-1)
++        LowestValid = Reg;
++    } else if (ChoosableRegs.count(Reg) == 1) {
++      if (LowestValid == (unsigned)-1)
++        LowestValid = Reg;
++    }
++  }
++  return LowestValid;
++}
++
+ /// \break Break false dependencies on undefined register reads.
+ ///
+ /// Walk the block backward computing precise liveness. This is expensive, so we
+@@ -619,31 +693,87 @@ void ExeDepsFix::processUndefReads(MachineBasicBlock *MBB) {
+   if (UndefReads.empty())
+     return;
+ 
++  // We want to be slightly clever here, to avoid the following common pattern:
++  // Suppose we have some instruction `vrandom %in, %out` and the following code
++  //    vrandom %xmm0<undef>, %xmm0<def>
++  //    vrandom %xmm1<undef>, %xmm1<def>
++  //    vrandom %xmm2<undef>, %xmm2<def>
++  //    vrandom %xmm3<undef>, %xmm3<def>
++  // The earlier logic likes to produce these, because it picks the first
++  // register
++  // to break ties in clearance. However, most register allocators pick the dest
++  // register the same way. Naively, we'd have to insert a dependency break,
++  // before every instruction above. However, what we really want is
++  //    vxorps %xmm3, %xmm3, %xmm3
++  //    vrandom %xmm3<undef>, %xmm0<def>
++  //    vrandom %xmm3<undef>, %xmm1<def>
++  //    vrandom %xmm3<undef>, %xmm2<def>
++  //    vrandom %xmm3<undef>, %xmm3<def>
++  // To do so, we walk backwards and cumulatively keep track of which registers
++  // we can use to break the dependency. Then, once the set has collapsed, we
++  // reset the undef read register for all following instructions.
++
+   // Collect this block's live out register units.
+   LiveRegSet.init(*TRI);
+   // We do not need to care about pristine registers as they are just preserved
+   // but not actually used in the function.
+   LiveRegSet.addLiveOutsNoPristines(*MBB);
+ 
+-  MachineInstr *UndefMI = UndefReads.back().first;
+-  unsigned OpIdx = UndefReads.back().second;
++  SparseSet<unsigned> ChoosableRegs;
++  ChoosableRegs.setUniverse(TRI->getNumRegs());
++
++  unsigned LastValid = (unsigned)-1;
++  const TargetRegisterClass *LastOpRC = nullptr;
++  size_t i, LastInit;
++  i = LastInit = UndefReads.size() - 1;
++  MachineInstr *UndefMI = std::get<0>(UndefReads[i]);
+ 
+   for (MachineInstr &I : make_range(MBB->rbegin(), MBB->rend())) {
+     // Update liveness, including the current instruction's defs.
+     LiveRegSet.stepBackward(I);
+ 
++    // This ensures that we don't accidentally pick a register whose live region
++    // lies entirely between two undef reads (since that would defeat the
++    // purpose of breaking the dependency).
++    for (auto LiveReg : LiveRegSet)
++      ChoosableRegs.erase(LiveReg);
++
+     if (UndefMI == &I) {
+-      if (!LiveRegSet.contains(UndefMI->getOperand(OpIdx).getReg()))
+-        TII->breakPartialRegDependency(*UndefMI, OpIdx, TRI);
++      unsigned OpIdx = std::get<1>(UndefReads[i]);
++      // Get the undef operand's register class
++      const TargetRegisterClass *OpRC =
++          TII->getRegClass(UndefMI->getDesc(), OpIdx, TRI, *MF);
++      if (OpRC != LastOpRC || ChoosableRegs.size() == 0) {
++        if (LastInit != i) {
++          if (LastValid != (unsigned)-1)
++            collapseUndefReads(i + 1, LastInit + 1, LastValid);
++          ChoosableRegs.clear();
++          LastInit = i;
++        }
++      }
++
++      unsigned LowestValid =
++          updateChooseableRegs(ChoosableRegs, OpRC, LastInit == i);
++
++      if (ChoosableRegs.size() == 0) {
++        if (LastInit != i) {
++          if (LastValid != (unsigned)-1)
++            collapseUndefReads(i + 1, LastInit + 1, LastValid);
++          LowestValid = updateChooseableRegs(ChoosableRegs, OpRC, true);
++          LastInit = i;
++        }
++      }
++      LastValid = LowestValid;
++      LastOpRC = OpRC;
+ 
+-      UndefReads.pop_back();
+-      if (UndefReads.empty())
+-        return;
++      if (i == 0)
++        break;
+ 
+-      UndefMI = UndefReads.back().first;
+-      OpIdx = UndefReads.back().second;
++      UndefMI = std::get<0>(UndefReads[--i]);
+     }
+   }
++  if (LastValid != (unsigned)-1)
++    collapseUndefReads(0, LastInit + 1, LastValid);
+ }
+ 
+ // A hard instruction only works in one domain. All input registers will be
+@@ -787,9 +917,7 @@ void ExeDepsFix::processBasicBlock(MachineBasicBlock *MBB, bool PrimaryPass,
+   enterBasicBlock(MBB);
+   for (MachineInstr &MI : *MBB) {
+     if (!MI.isDebugValue()) {
+-      bool Kill = false;
+-      if (PrimaryPass)
+-        Kill = visitInstr(&MI);
++      bool Kill = visitInstr(&MI, PrimaryPass);
+       processDefs(&MI, isBlockDone(MBB), Kill);
+     }
+   }
+diff --git a/lib/Target/X86/X86InstrInfo.cpp b/lib/Target/X86/X86InstrInfo.cpp
+index 627b6120b04..26665b2a15d 100644
+--- a/lib/Target/X86/X86InstrInfo.cpp
++++ b/lib/Target/X86/X86InstrInfo.cpp
+@@ -7432,6 +7432,23 @@ void X86InstrInfo::breakPartialRegDependency(
+   }
+ }
+ 
++bool X86InstrInfo::isDependencyBreak(MachineInstr &MI, unsigned *OutReg) const {
++  unsigned Opc = MI.getOpcode();
++  if (!(Opc == X86::VXORPSrr || Opc == X86::VXORPDrr || Opc == X86::XORPSrr ||
++        Opc == X86::XORPDrr))
++    return false;
++  unsigned Reg = 0;
++  for (unsigned i = 0; i < MI.getNumOperands(); ++i) {
++    const MachineOperand &MO = MI.getOperand(i);
++    if (!MO.isReg() || (Reg != 0 && MO.getReg() != Reg))
++      return false;
++    Reg = MO.getReg();
++  }
++  if (OutReg)
++    *OutReg = Reg;
++  return true;
++}
++
+ MachineInstr *
+ X86InstrInfo::foldMemoryOperandImpl(MachineFunction &MF, MachineInstr &MI,
+                                     ArrayRef<unsigned> Ops,
+diff --git a/lib/Target/X86/X86InstrInfo.h b/lib/Target/X86/X86InstrInfo.h
+index acfdef4da7a..4ea9ddfc863 100644
+--- a/lib/Target/X86/X86InstrInfo.h
++++ b/lib/Target/X86/X86InstrInfo.h
+@@ -477,6 +477,7 @@ public:
+                                 const TargetRegisterInfo *TRI) const override;
+   void breakPartialRegDependency(MachineInstr &MI, unsigned OpNum,
+                                  const TargetRegisterInfo *TRI) const override;
++  bool isDependencyBreak(MachineInstr &MI, unsigned *OutReg) const override;
+ 
+   MachineInstr *foldMemoryOperandImpl(MachineFunction &MF, MachineInstr &MI,
+                                       unsigned OpNum,
diff --git a/deps/patches/llvm-D30478-VNCoercion.patch b/deps/patches/llvm-D30478-VNCoercion.patch
new file mode 100644
index 00000000000000..99ba3d9739bf46
--- /dev/null
+++ b/deps/patches/llvm-D30478-VNCoercion.patch
@@ -0,0 +1,1139 @@
+From 6a7ec8843d08cb2cb8d4f55353c67d879ceacb92 Mon Sep 17 00:00:00 2001
+From: Daniel Berlin <dberlin@dberlin.org>
+Date: Fri, 10 Mar 2017 04:54:10 +0000
+Subject: [PATCH 1/5] Move memory coercion functions from GVN.cpp to
+ VNCoercion.cpp so they can be shared between GVN and NewGVN.
+
+Summary:
+These are the functions used to determine when values of loads can be
+extracted from stores, etc, and to perform the necessary insertions to
+do this.  There are no changes to the functions themselves except
+reformatting, and one case where memdep was informed of a removed load
+(which was pushed into the caller).
+
+Reviewers: davide
+
+Subscribers: mgorny, llvm-commits, Prazek
+
+Differential Revision: https://reviews.llvm.org/D30478
+
+git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@297438 91177308-0d34-0410-b5e6-96231b3b80d8
+---
+ include/llvm/Transforms/Utils/VNCoercion.h |  96 ++++++
+ lib/Transforms/Scalar/GVN.cpp              | 466 ++---------------------------
+ lib/Transforms/Utils/CMakeLists.txt        |   1 +
+ lib/Transforms/Utils/VNCoercion.cpp        | 440 +++++++++++++++++++++++++++
+ 4 files changed, 556 insertions(+), 447 deletions(-)
+ create mode 100644 include/llvm/Transforms/Utils/VNCoercion.h
+ create mode 100644 lib/Transforms/Utils/VNCoercion.cpp
+
+diff --git a/include/llvm/Transforms/Utils/VNCoercion.h b/include/llvm/Transforms/Utils/VNCoercion.h
+new file mode 100644
+index 00000000000..d3c998fa8a8
+--- /dev/null
++++ b/include/llvm/Transforms/Utils/VNCoercion.h
+@@ -0,0 +1,96 @@
++//===- VNCoercion.h - Value Numbering Coercion Utilities --------*- C++ -*-===//
++//
++//                     The LLVM Compiler Infrastructure
++//
++// This file is distributed under the University of Illinois Open Source
++// License. See LICENSE.TXT for details.
++//
++//===----------------------------------------------------------------------===//
++/// \file / This file provides routines used by LLVM's value numbering passes to
++/// perform various forms of value extraction from memory when the types are not
++/// identical.  For example, given
++///
++/// store i32 8, i32 *%foo
++/// %a = bitcast i32 *%foo to i16
++/// %val = load i16, i16 *%a
++///
++/// It possible to extract the value of the load of %a from the store to %foo.
++/// These routines know how to tell whether they can do that (the analyze*
++/// routines), and can also insert the necessary IR to do it (the get*
++/// routines).
++
++#ifndef LLVM_TRANSFORMS_UTILS_VNCOERCION_H
++#define LLVM_TRANSFORMS_UTILS_VNCOERCION_H
++#include "llvm/IR/IRBuilder.h"
++
++namespace llvm {
++class Function;
++class StoreInst;
++class LoadInst;
++class MemIntrinsic;
++class Instruction;
++class Value;
++class Type;
++class DataLayout;
++namespace VNCoercion {
++/// Return true if CoerceAvailableValueToLoadType would succeed if it was
++/// called.
++bool canCoerceMustAliasedValueToLoad(Value *StoredVal, Type *LoadTy,
++                                     const DataLayout &DL);
++
++/// If we saw a store of a value to memory, and then a load from a must-aliased
++/// pointer of a different type, try to coerce the stored value to the loaded
++/// type.  LoadedTy is the type of the load we want to replace.  IRB is
++/// IRBuilder used to insert new instructions.
++///
++/// If we can't do it, return null.
++Value *coerceAvailableValueToLoadType(Value *StoredVal, Type *LoadedTy,
++                                      IRBuilder<> &IRB, const DataLayout &DL);
++
++/// This function determines whether a value for the pointer LoadPtr can be
++/// extracted from the store at DepSI.
++///
++/// On success, it returns the offset into DepSI that extraction would start.
++/// On failure, it returns -1.
++int analyzeLoadFromClobberingStore(Type *LoadTy, Value *LoadPtr,
++                                   StoreInst *DepSI);
++
++/// This function determines whether a value for the pointer LoadPtr can be
++/// extracted from the load at DepLI.
++///
++/// On success, it returns the offset into DepLI that extraction would start.
++/// On failure, it returns -1.
++int analyzeLoadFromClobberingLoad(Type *LoadTy, Value *LoadPtr, LoadInst *DepLI,
++                                  const DataLayout &DL);
++
++/// This function determines whether a value for the pointer LoadPtr can be
++/// extracted from the memory intrinsic at DepMI.
++///
++/// On success, it returns the offset into DepMI that extraction would start.
++/// On failure, it returns -1.
++int analyzeLoadFromClobberingMemInst(Type *LoadTy, Value *LoadPtr,
++                                     MemIntrinsic *DepMI, const DataLayout &DL);
++
++/// If analyzeLoadFromClobberingStore returned an offset, this function can be
++/// used to actually perform the extraction of the bits from the store. It
++/// inserts instructions to do so at InsertPt, and returns the extracted value.
++Value *getStoreValueForLoad(Value *SrcVal, unsigned Offset, Type *LoadTy,
++                            Instruction *InsertPt, const DataLayout &DL);
++
++/// If analyzeLoadFromClobberingLoad returned an offset, this function can be
++/// used to actually perform the extraction of the bits from the load, including
++/// any necessary load widening.  It inserts instructions to do so at InsertPt,
++/// and returns the extracted value.
++Value *getLoadValueForLoad(LoadInst *SrcVal, unsigned Offset, Type *LoadTy,
++                           Instruction *InsertPt);
++
++/// If analyzeLoadFromClobberingMemInst returned an offset, this function can be
++/// used to actually perform the extraction of the bits from the memory
++/// intrinsic.  It inserts instructions to do so at InsertPt, and returns the
++/// extracted value.
++Value *getMemInstValueForLoad(MemIntrinsic *SrcInst, unsigned Offset,
++                              Type *LoadTy, Instruction *InsertPt,
++                              const DataLayout &DL);
++}
++}
++#endif
+diff --git a/lib/Transforms/Scalar/GVN.cpp b/lib/Transforms/Scalar/GVN.cpp
+index 0137378b828..132c7297d77 100644
+--- a/lib/Transforms/Scalar/GVN.cpp
++++ b/lib/Transforms/Scalar/GVN.cpp
+@@ -36,7 +36,6 @@
+ #include "llvm/Analysis/OptimizationDiagnosticInfo.h"
+ #include "llvm/Analysis/PHITransAddr.h"
+ #include "llvm/Analysis/TargetLibraryInfo.h"
+-#include "llvm/Analysis/ValueTracking.h"
+ #include "llvm/IR/DataLayout.h"
+ #include "llvm/IR/Dominators.h"
+ #include "llvm/IR/GlobalVariable.h"
+@@ -51,9 +50,12 @@
+ #include "llvm/Transforms/Utils/BasicBlockUtils.h"
+ #include "llvm/Transforms/Utils/Local.h"
+ #include "llvm/Transforms/Utils/SSAUpdater.h"
++#include "llvm/Transforms/Utils/VNCoercion.h"
++
+ #include <vector>
+ using namespace llvm;
+ using namespace llvm::gvn;
++using namespace llvm::VNCoercion;
+ using namespace PatternMatch;
+ 
+ #define DEBUG_TYPE "gvn"
+@@ -690,442 +692,6 @@ SpeculationFailure:
+ }
+ 
+ 
+-/// Return true if CoerceAvailableValueToLoadType will succeed.
+-static bool CanCoerceMustAliasedValueToLoad(Value *StoredVal,
+-                                            Type *LoadTy,
+-                                            const DataLayout &DL) {
+-  // If the loaded or stored value is an first class array or struct, don't try
+-  // to transform them.  We need to be able to bitcast to integer.
+-  if (LoadTy->isStructTy() || LoadTy->isArrayTy() ||
+-      StoredVal->getType()->isStructTy() ||
+-      StoredVal->getType()->isArrayTy())
+-    return false;
+-
+-  // The store has to be at least as big as the load.
+-  if (DL.getTypeSizeInBits(StoredVal->getType()) <
+-        DL.getTypeSizeInBits(LoadTy))
+-    return false;
+-
+-  return true;
+-}
+-
+-/// If we saw a store of a value to memory, and
+-/// then a load from a must-aliased pointer of a different type, try to coerce
+-/// the stored value.  LoadedTy is the type of the load we want to replace.
+-/// IRB is IRBuilder used to insert new instructions.
+-///
+-/// If we can't do it, return null.
+-static Value *CoerceAvailableValueToLoadType(Value *StoredVal, Type *LoadedTy,
+-                                             IRBuilder<> &IRB,
+-                                             const DataLayout &DL) {
+-  assert(CanCoerceMustAliasedValueToLoad(StoredVal, LoadedTy, DL) &&
+-         "precondition violation - materialization can't fail");
+-
+-  if (auto *C = dyn_cast<Constant>(StoredVal))
+-    if (auto *FoldedStoredVal = ConstantFoldConstant(C, DL))
+-      StoredVal = FoldedStoredVal;
+-
+-  // If this is already the right type, just return it.
+-  Type *StoredValTy = StoredVal->getType();
+-
+-  uint64_t StoredValSize = DL.getTypeSizeInBits(StoredValTy);
+-  uint64_t LoadedValSize = DL.getTypeSizeInBits(LoadedTy);
+-
+-  // If the store and reload are the same size, we can always reuse it.
+-  if (StoredValSize == LoadedValSize) {
+-    // Pointer to Pointer -> use bitcast.
+-    if (StoredValTy->getScalarType()->isPointerTy() &&
+-        LoadedTy->getScalarType()->isPointerTy()) {
+-      StoredVal = IRB.CreateBitCast(StoredVal, LoadedTy);
+-    } else {
+-      // Convert source pointers to integers, which can be bitcast.
+-      if (StoredValTy->getScalarType()->isPointerTy()) {
+-        StoredValTy = DL.getIntPtrType(StoredValTy);
+-        StoredVal = IRB.CreatePtrToInt(StoredVal, StoredValTy);
+-      }
+-
+-      Type *TypeToCastTo = LoadedTy;
+-      if (TypeToCastTo->getScalarType()->isPointerTy())
+-        TypeToCastTo = DL.getIntPtrType(TypeToCastTo);
+-
+-      if (StoredValTy != TypeToCastTo)
+-        StoredVal = IRB.CreateBitCast(StoredVal, TypeToCastTo);
+-
+-      // Cast to pointer if the load needs a pointer type.
+-      if (LoadedTy->getScalarType()->isPointerTy())
+-        StoredVal = IRB.CreateIntToPtr(StoredVal, LoadedTy);
+-    }
+-
+-    if (auto *C = dyn_cast<ConstantExpr>(StoredVal))
+-      if (auto *FoldedStoredVal = ConstantFoldConstant(C, DL))
+-        StoredVal = FoldedStoredVal;
+-
+-    return StoredVal;
+-  }
+-
+-  // If the loaded value is smaller than the available value, then we can
+-  // extract out a piece from it.  If the available value is too small, then we
+-  // can't do anything.
+-  assert(StoredValSize >= LoadedValSize &&
+-         "CanCoerceMustAliasedValueToLoad fail");
+-
+-  // Convert source pointers to integers, which can be manipulated.
+-  if (StoredValTy->getScalarType()->isPointerTy()) {
+-    StoredValTy = DL.getIntPtrType(StoredValTy);
+-    StoredVal = IRB.CreatePtrToInt(StoredVal, StoredValTy);
+-  }
+-
+-  // Convert vectors and fp to integer, which can be manipulated.
+-  if (!StoredValTy->isIntegerTy()) {
+-    StoredValTy = IntegerType::get(StoredValTy->getContext(), StoredValSize);
+-    StoredVal = IRB.CreateBitCast(StoredVal, StoredValTy);
+-  }
+-
+-  // If this is a big-endian system, we need to shift the value down to the low
+-  // bits so that a truncate will work.
+-  if (DL.isBigEndian()) {
+-    uint64_t ShiftAmt = DL.getTypeStoreSizeInBits(StoredValTy) -
+-                        DL.getTypeStoreSizeInBits(LoadedTy);
+-    StoredVal = IRB.CreateLShr(StoredVal, ShiftAmt, "tmp");
+-  }
+-
+-  // Truncate the integer to the right size now.
+-  Type *NewIntTy = IntegerType::get(StoredValTy->getContext(), LoadedValSize);
+-  StoredVal  = IRB.CreateTrunc(StoredVal, NewIntTy, "trunc");
+-
+-  if (LoadedTy != NewIntTy) {
+-    // If the result is a pointer, inttoptr.
+-    if (LoadedTy->getScalarType()->isPointerTy())
+-      StoredVal = IRB.CreateIntToPtr(StoredVal, LoadedTy, "inttoptr");
+-    else
+-      // Otherwise, bitcast.
+-      StoredVal = IRB.CreateBitCast(StoredVal, LoadedTy, "bitcast");
+-  }
+-
+-  if (auto *C = dyn_cast<Constant>(StoredVal))
+-    if (auto *FoldedStoredVal = ConstantFoldConstant(C, DL))
+-      StoredVal = FoldedStoredVal;
+-
+-  return StoredVal;
+-}
+-
+-/// This function is called when we have a
+-/// memdep query of a load that ends up being a clobbering memory write (store,
+-/// memset, memcpy, memmove).  This means that the write *may* provide bits used
+-/// by the load but we can't be sure because the pointers don't mustalias.
+-///
+-/// Check this case to see if there is anything more we can do before we give
+-/// up.  This returns -1 if we have to give up, or a byte number in the stored
+-/// value of the piece that feeds the load.
+-static int AnalyzeLoadFromClobberingWrite(Type *LoadTy, Value *LoadPtr,
+-                                          Value *WritePtr,
+-                                          uint64_t WriteSizeInBits,
+-                                          const DataLayout &DL) {
+-  // If the loaded or stored value is a first class array or struct, don't try
+-  // to transform them.  We need to be able to bitcast to integer.
+-  if (LoadTy->isStructTy() || LoadTy->isArrayTy())
+-    return -1;
+-
+-  int64_t StoreOffset = 0, LoadOffset = 0;
+-  Value *StoreBase =
+-      GetPointerBaseWithConstantOffset(WritePtr, StoreOffset, DL);
+-  Value *LoadBase = GetPointerBaseWithConstantOffset(LoadPtr, LoadOffset, DL);
+-  if (StoreBase != LoadBase)
+-    return -1;
+-
+-  // If the load and store are to the exact same address, they should have been
+-  // a must alias.  AA must have gotten confused.
+-  // FIXME: Study to see if/when this happens.  One case is forwarding a memset
+-  // to a load from the base of the memset.
+-
+-  // If the load and store don't overlap at all, the store doesn't provide
+-  // anything to the load.  In this case, they really don't alias at all, AA
+-  // must have gotten confused.
+-  uint64_t LoadSize = DL.getTypeSizeInBits(LoadTy);
+-
+-  if ((WriteSizeInBits & 7) | (LoadSize & 7))
+-    return -1;
+-  uint64_t StoreSize = WriteSizeInBits / 8;  // Convert to bytes.
+-  LoadSize /= 8;
+-
+-
+-  bool isAAFailure = false;
+-  if (StoreOffset < LoadOffset)
+-    isAAFailure = StoreOffset+int64_t(StoreSize) <= LoadOffset;
+-  else
+-    isAAFailure = LoadOffset+int64_t(LoadSize) <= StoreOffset;
+-
+-  if (isAAFailure)
+-    return -1;
+-
+-  // If the Load isn't completely contained within the stored bits, we don't
+-  // have all the bits to feed it.  We could do something crazy in the future
+-  // (issue a smaller load then merge the bits in) but this seems unlikely to be
+-  // valuable.
+-  if (StoreOffset > LoadOffset ||
+-      StoreOffset+StoreSize < LoadOffset+LoadSize)
+-    return -1;
+-
+-  // Okay, we can do this transformation.  Return the number of bytes into the
+-  // store that the load is.
+-  return LoadOffset-StoreOffset;
+-}
+-
+-/// This function is called when we have a
+-/// memdep query of a load that ends up being a clobbering store.
+-static int AnalyzeLoadFromClobberingStore(Type *LoadTy, Value *LoadPtr,
+-                                          StoreInst *DepSI) {
+-  // Cannot handle reading from store of first-class aggregate yet.
+-  if (DepSI->getValueOperand()->getType()->isStructTy() ||
+-      DepSI->getValueOperand()->getType()->isArrayTy())
+-    return -1;
+-
+-  const DataLayout &DL = DepSI->getModule()->getDataLayout();
+-  Value *StorePtr = DepSI->getPointerOperand();
+-  uint64_t StoreSize =DL.getTypeSizeInBits(DepSI->getValueOperand()->getType());
+-  return AnalyzeLoadFromClobberingWrite(LoadTy, LoadPtr,
+-                                        StorePtr, StoreSize, DL);
+-}
+-
+-/// This function is called when we have a
+-/// memdep query of a load that ends up being clobbered by another load.  See if
+-/// the other load can feed into the second load.
+-static int AnalyzeLoadFromClobberingLoad(Type *LoadTy, Value *LoadPtr,
+-                                         LoadInst *DepLI, const DataLayout &DL){
+-  // Cannot handle reading from store of first-class aggregate yet.
+-  if (DepLI->getType()->isStructTy() || DepLI->getType()->isArrayTy())
+-    return -1;
+-
+-  Value *DepPtr = DepLI->getPointerOperand();
+-  uint64_t DepSize = DL.getTypeSizeInBits(DepLI->getType());
+-  int R = AnalyzeLoadFromClobberingWrite(LoadTy, LoadPtr, DepPtr, DepSize, DL);
+-  if (R != -1) return R;
+-
+-  // If we have a load/load clobber an DepLI can be widened to cover this load,
+-  // then we should widen it!
+-  int64_t LoadOffs = 0;
+-  const Value *LoadBase =
+-      GetPointerBaseWithConstantOffset(LoadPtr, LoadOffs, DL);
+-  unsigned LoadSize = DL.getTypeStoreSize(LoadTy);
+-
+-  unsigned Size = MemoryDependenceResults::getLoadLoadClobberFullWidthSize(
+-      LoadBase, LoadOffs, LoadSize, DepLI);
+-  if (Size == 0) return -1;
+-
+-  // Check non-obvious conditions enforced by MDA which we rely on for being
+-  // able to materialize this potentially available value
+-  assert(DepLI->isSimple() && "Cannot widen volatile/atomic load!");
+-  assert(DepLI->getType()->isIntegerTy() && "Can't widen non-integer load");
+-
+-  return AnalyzeLoadFromClobberingWrite(LoadTy, LoadPtr, DepPtr, Size*8, DL);
+-}
+-
+-
+-
+-static int AnalyzeLoadFromClobberingMemInst(Type *LoadTy, Value *LoadPtr,
+-                                            MemIntrinsic *MI,
+-                                            const DataLayout &DL) {
+-  // If the mem operation is a non-constant size, we can't handle it.
+-  ConstantInt *SizeCst = dyn_cast<ConstantInt>(MI->getLength());
+-  if (!SizeCst) return -1;
+-  uint64_t MemSizeInBits = SizeCst->getZExtValue()*8;
+-
+-  // If this is memset, we just need to see if the offset is valid in the size
+-  // of the memset..
+-  if (MI->getIntrinsicID() == Intrinsic::memset)
+-    return AnalyzeLoadFromClobberingWrite(LoadTy, LoadPtr, MI->getDest(),
+-                                          MemSizeInBits, DL);
+-
+-  // If we have a memcpy/memmove, the only case we can handle is if this is a
+-  // copy from constant memory.  In that case, we can read directly from the
+-  // constant memory.
+-  MemTransferInst *MTI = cast<MemTransferInst>(MI);
+-
+-  Constant *Src = dyn_cast<Constant>(MTI->getSource());
+-  if (!Src) return -1;
+-
+-  GlobalVariable *GV = dyn_cast<GlobalVariable>(GetUnderlyingObject(Src, DL));
+-  if (!GV || !GV->isConstant()) return -1;
+-
+-  // See if the access is within the bounds of the transfer.
+-  int Offset = AnalyzeLoadFromClobberingWrite(LoadTy, LoadPtr,
+-                                              MI->getDest(), MemSizeInBits, DL);
+-  if (Offset == -1)
+-    return Offset;
+-
+-  unsigned AS = Src->getType()->getPointerAddressSpace();
+-  // Otherwise, see if we can constant fold a load from the constant with the
+-  // offset applied as appropriate.
+-  Src = ConstantExpr::getBitCast(Src,
+-                                 Type::getInt8PtrTy(Src->getContext(), AS));
+-  Constant *OffsetCst =
+-    ConstantInt::get(Type::getInt64Ty(Src->getContext()), (unsigned)Offset);
+-  Src = ConstantExpr::getGetElementPtr(Type::getInt8Ty(Src->getContext()), Src,
+-                                       OffsetCst);
+-  Src = ConstantExpr::getBitCast(Src, PointerType::get(LoadTy, AS));
+-  if (ConstantFoldLoadFromConstPtr(Src, LoadTy, DL))
+-    return Offset;
+-  return -1;
+-}
+-
+-
+-/// This function is called when we have a
+-/// memdep query of a load that ends up being a clobbering store.  This means
+-/// that the store provides bits used by the load but we the pointers don't
+-/// mustalias.  Check this case to see if there is anything more we can do
+-/// before we give up.
+-static Value *GetStoreValueForLoad(Value *SrcVal, unsigned Offset,
+-                                   Type *LoadTy,
+-                                   Instruction *InsertPt, const DataLayout &DL){
+-  LLVMContext &Ctx = SrcVal->getType()->getContext();
+-
+-  uint64_t StoreSize = (DL.getTypeSizeInBits(SrcVal->getType()) + 7) / 8;
+-  uint64_t LoadSize = (DL.getTypeSizeInBits(LoadTy) + 7) / 8;
+-
+-  IRBuilder<> Builder(InsertPt);
+-
+-  // Compute which bits of the stored value are being used by the load.  Convert
+-  // to an integer type to start with.
+-  if (SrcVal->getType()->getScalarType()->isPointerTy())
+-    SrcVal = Builder.CreatePtrToInt(SrcVal,
+-        DL.getIntPtrType(SrcVal->getType()));
+-  if (!SrcVal->getType()->isIntegerTy())
+-    SrcVal = Builder.CreateBitCast(SrcVal, IntegerType::get(Ctx, StoreSize*8));
+-
+-  // Shift the bits to the least significant depending on endianness.
+-  unsigned ShiftAmt;
+-  if (DL.isLittleEndian())
+-    ShiftAmt = Offset*8;
+-  else
+-    ShiftAmt = (StoreSize-LoadSize-Offset)*8;
+-
+-  if (ShiftAmt)
+-    SrcVal = Builder.CreateLShr(SrcVal, ShiftAmt);
+-
+-  if (LoadSize != StoreSize)
+-    SrcVal = Builder.CreateTrunc(SrcVal, IntegerType::get(Ctx, LoadSize*8));
+-
+-  return CoerceAvailableValueToLoadType(SrcVal, LoadTy, Builder, DL);
+-}
+-
+-/// This function is called when we have a
+-/// memdep query of a load that ends up being a clobbering load.  This means
+-/// that the load *may* provide bits used by the load but we can't be sure
+-/// because the pointers don't mustalias.  Check this case to see if there is
+-/// anything more we can do before we give up.
+-static Value *GetLoadValueForLoad(LoadInst *SrcVal, unsigned Offset,
+-                                  Type *LoadTy, Instruction *InsertPt,
+-                                  GVN &gvn) {
+-  const DataLayout &DL = SrcVal->getModule()->getDataLayout();
+-  // If Offset+LoadTy exceeds the size of SrcVal, then we must be wanting to
+-  // widen SrcVal out to a larger load.
+-  unsigned SrcValStoreSize = DL.getTypeStoreSize(SrcVal->getType());
+-  unsigned LoadSize = DL.getTypeStoreSize(LoadTy);
+-  if (Offset+LoadSize > SrcValStoreSize) {
+-    assert(SrcVal->isSimple() && "Cannot widen volatile/atomic load!");
+-    assert(SrcVal->getType()->isIntegerTy() && "Can't widen non-integer load");
+-    // If we have a load/load clobber an DepLI can be widened to cover this
+-    // load, then we should widen it to the next power of 2 size big enough!
+-    unsigned NewLoadSize = Offset+LoadSize;
+-    if (!isPowerOf2_32(NewLoadSize))
+-      NewLoadSize = NextPowerOf2(NewLoadSize);
+-
+-    Value *PtrVal = SrcVal->getPointerOperand();
+-
+-    // Insert the new load after the old load.  This ensures that subsequent
+-    // memdep queries will find the new load.  We can't easily remove the old
+-    // load completely because it is already in the value numbering table.
+-    IRBuilder<> Builder(SrcVal->getParent(), ++BasicBlock::iterator(SrcVal));
+-    Type *DestPTy =
+-      IntegerType::get(LoadTy->getContext(), NewLoadSize*8);
+-    DestPTy = PointerType::get(DestPTy,
+-                               PtrVal->getType()->getPointerAddressSpace());
+-    Builder.SetCurrentDebugLocation(SrcVal->getDebugLoc());
+-    PtrVal = Builder.CreateBitCast(PtrVal, DestPTy);
+-    LoadInst *NewLoad = Builder.CreateLoad(PtrVal);
+-    NewLoad->takeName(SrcVal);
+-    NewLoad->setAlignment(SrcVal->getAlignment());
+-
+-    DEBUG(dbgs() << "GVN WIDENED LOAD: " << *SrcVal << "\n");
+-    DEBUG(dbgs() << "TO: " << *NewLoad << "\n");
+-
+-    // Replace uses of the original load with the wider load.  On a big endian
+-    // system, we need to shift down to get the relevant bits.
+-    Value *RV = NewLoad;
+-    if (DL.isBigEndian())
+-      RV = Builder.CreateLShr(RV, (NewLoadSize - SrcValStoreSize) * 8);
+-    RV = Builder.CreateTrunc(RV, SrcVal->getType());
+-    SrcVal->replaceAllUsesWith(RV);
+-
+-    // We would like to use gvn.markInstructionForDeletion here, but we can't
+-    // because the load is already memoized into the leader map table that GVN
+-    // tracks.  It is potentially possible to remove the load from the table,
+-    // but then there all of the operations based on it would need to be
+-    // rehashed.  Just leave the dead load around.
+-    gvn.getMemDep().removeInstruction(SrcVal);
+-    SrcVal = NewLoad;
+-  }
+-
+-  return GetStoreValueForLoad(SrcVal, Offset, LoadTy, InsertPt, DL);
+-}
+-
+-
+-/// This function is called when we have a
+-/// memdep query of a load that ends up being a clobbering mem intrinsic.
+-static Value *GetMemInstValueForLoad(MemIntrinsic *SrcInst, unsigned Offset,
+-                                     Type *LoadTy, Instruction *InsertPt,
+-                                     const DataLayout &DL){
+-  LLVMContext &Ctx = LoadTy->getContext();
+-  uint64_t LoadSize = DL.getTypeSizeInBits(LoadTy)/8;
+-
+-  IRBuilder<> Builder(InsertPt);
+-
+-  // We know that this method is only called when the mem transfer fully
+-  // provides the bits for the load.
+-  if (MemSetInst *MSI = dyn_cast<MemSetInst>(SrcInst)) {
+-    // memset(P, 'x', 1234) -> splat('x'), even if x is a variable, and
+-    // independently of what the offset is.
+-    Value *Val = MSI->getValue();
+-    if (LoadSize != 1)
+-      Val = Builder.CreateZExt(Val, IntegerType::get(Ctx, LoadSize*8));
+-
+-    Value *OneElt = Val;
+-
+-    // Splat the value out to the right number of bits.
+-    for (unsigned NumBytesSet = 1; NumBytesSet != LoadSize; ) {
+-      // If we can double the number of bytes set, do it.
+-      if (NumBytesSet*2 <= LoadSize) {
+-        Value *ShVal = Builder.CreateShl(Val, NumBytesSet*8);
+-        Val = Builder.CreateOr(Val, ShVal);
+-        NumBytesSet <<= 1;
+-        continue;
+-      }
+-
+-      // Otherwise insert one byte at a time.
+-      Value *ShVal = Builder.CreateShl(Val, 1*8);
+-      Val = Builder.CreateOr(OneElt, ShVal);
+-      ++NumBytesSet;
+-    }
+-
+-    return CoerceAvailableValueToLoadType(Val, LoadTy, Builder, DL);
+-  }
+-
+-  // Otherwise, this is a memcpy/memmove from a constant global.
+-  MemTransferInst *MTI = cast<MemTransferInst>(SrcInst);
+-  Constant *Src = cast<Constant>(MTI->getSource());
+-  unsigned AS = Src->getType()->getPointerAddressSpace();
+-
+-  // Otherwise, see if we can constant fold a load from the constant with the
+-  // offset applied as appropriate.
+-  Src = ConstantExpr::getBitCast(Src,
+-                                 Type::getInt8PtrTy(Src->getContext(), AS));
+-  Constant *OffsetCst =
+-    ConstantInt::get(Type::getInt64Ty(Src->getContext()), (unsigned)Offset);
+-  Src = ConstantExpr::getGetElementPtr(Type::getInt8Ty(Src->getContext()), Src,
+-                                       OffsetCst);
+-  Src = ConstantExpr::getBitCast(Src, PointerType::get(LoadTy, AS));
+-  return ConstantFoldLoadFromConstPtr(Src, LoadTy, DL);
+-}
+ 
+ 
+ /// Given a set of loads specified by ValuesPerBlock,
+@@ -1171,7 +737,7 @@ Value *AvailableValue::MaterializeAdjustedValue(LoadInst *LI,
+   if (isSimpleValue()) {
+     Res = getSimpleValue();
+     if (Res->getType() != LoadTy) {
+-      Res = GetStoreValueForLoad(Res, Offset, LoadTy, InsertPt, DL);
++      Res = getStoreValueForLoad(Res, Offset, LoadTy, InsertPt, DL);
+ 
+       DEBUG(dbgs() << "GVN COERCED NONLOCAL VAL:\nOffset: " << Offset << "  "
+                    << *getSimpleValue() << '\n'
+@@ -1182,14 +748,20 @@ Value *AvailableValue::MaterializeAdjustedValue(LoadInst *LI,
+     if (Load->getType() == LoadTy && Offset == 0) {
+       Res = Load;
+     } else {
+-      Res = GetLoadValueForLoad(Load, Offset, LoadTy, InsertPt, gvn);
+-
++      Res = getLoadValueForLoad(Load, Offset, LoadTy, InsertPt);
++      // We would like to use gvn.markInstructionForDeletion here, but we can't
++      // because the load is already memoized into the leader map table that GVN
++      // tracks.  It is potentially possible to remove the load from the table,
++      // but then there all of the operations based on it would need to be
++      // rehashed.  Just leave the dead load around.
++      gvn.getMemDep().removeInstruction(Load);
+       DEBUG(dbgs() << "GVN COERCED NONLOCAL LOAD:\nOffset: " << Offset << "  "
+                    << *getCoercedLoadValue() << '\n'
+-                   << *Res << '\n' << "\n\n\n");
++                   << *Res << '\n'
++                   << "\n\n\n");
+     }
+   } else if (isMemIntrinValue()) {
+-    Res = GetMemInstValueForLoad(getMemIntrinValue(), Offset, LoadTy,
++    Res = getMemInstValueForLoad(getMemIntrinValue(), Offset, LoadTy,
+                                  InsertPt, DL);
+     DEBUG(dbgs() << "GVN COERCED NONLOCAL MEM INTRIN:\nOffset: " << Offset
+                  << "  " << *getMemIntrinValue() << '\n'
+@@ -1258,7 +830,7 @@ bool GVN::AnalyzeLoadAvailability(LoadInst *LI, MemDepResult DepInfo,
+       // Can't forward from non-atomic to atomic without violating memory model.
+       if (Address && LI->isAtomic() <= DepSI->isAtomic()) {
+         int Offset =
+-          AnalyzeLoadFromClobberingStore(LI->getType(), Address, DepSI);
++          analyzeLoadFromClobberingStore(LI->getType(), Address, DepSI);
+         if (Offset != -1) {
+           Res = AvailableValue::get(DepSI->getValueOperand(), Offset);
+           return true;
+@@ -1276,7 +848,7 @@ bool GVN::AnalyzeLoadAvailability(LoadInst *LI, MemDepResult DepInfo,
+       // Can't forward from non-atomic to atomic without violating memory model.
+       if (DepLI != LI && Address && LI->isAtomic() <= DepLI->isAtomic()) {
+         int Offset =
+-          AnalyzeLoadFromClobberingLoad(LI->getType(), Address, DepLI, DL);
++          analyzeLoadFromClobberingLoad(LI->getType(), Address, DepLI, DL);
+ 
+         if (Offset != -1) {
+           Res = AvailableValue::getLoad(DepLI, Offset);
+@@ -1289,7 +861,7 @@ bool GVN::AnalyzeLoadAvailability(LoadInst *LI, MemDepResult DepInfo,
+     // forward a value on from it.
+     if (MemIntrinsic *DepMI = dyn_cast<MemIntrinsic>(DepInfo.getInst())) {
+       if (Address && !LI->isAtomic()) {
+-        int Offset = AnalyzeLoadFromClobberingMemInst(LI->getType(), Address,
++        int Offset = analyzeLoadFromClobberingMemInst(LI->getType(), Address,
+                                                       DepMI, DL);
+         if (Offset != -1) {
+           Res = AvailableValue::getMI(DepMI, Offset);
+@@ -1334,7 +906,7 @@ bool GVN::AnalyzeLoadAvailability(LoadInst *LI, MemDepResult DepInfo,
+     // different types if we have to. If the stored value is larger or equal to
+     // the loaded value, we can reuse it.
+     if (S->getValueOperand()->getType() != LI->getType() &&
+-        !CanCoerceMustAliasedValueToLoad(S->getValueOperand(),
++        !canCoerceMustAliasedValueToLoad(S->getValueOperand(),
+                                          LI->getType(), DL))
+       return false;
+ 
+@@ -1351,7 +923,7 @@ bool GVN::AnalyzeLoadAvailability(LoadInst *LI, MemDepResult DepInfo,
+     // If the stored value is larger or equal to the loaded value, we can reuse
+     // it.
+     if (LD->getType() != LI->getType() &&
+-        !CanCoerceMustAliasedValueToLoad(LD, LI->getType(), DL))
++        !canCoerceMustAliasedValueToLoad(LD, LI->getType(), DL))
+       return false;
+ 
+     // Can't forward from non-atomic to atomic without violating memory model.
+diff --git a/lib/Transforms/Utils/CMakeLists.txt b/lib/Transforms/Utils/CMakeLists.txt
+index 69889ec72f9..838761fd71d 100644
+--- a/lib/Transforms/Utils/CMakeLists.txt
++++ b/lib/Transforms/Utils/CMakeLists.txt
+@@ -51,6 +51,7 @@ add_llvm_library(LLVMTransformUtils
+   UnifyFunctionExitNodes.cpp
+   Utils.cpp
+   ValueMapper.cpp
++  VNCoercion.cpp
+ 
+   ADDITIONAL_HEADER_DIRS
+   ${LLVM_MAIN_INCLUDE_DIR}/llvm/Transforms
+diff --git a/lib/Transforms/Utils/VNCoercion.cpp b/lib/Transforms/Utils/VNCoercion.cpp
+new file mode 100644
+index 00000000000..38d26e922c3
+--- /dev/null
++++ b/lib/Transforms/Utils/VNCoercion.cpp
+@@ -0,0 +1,440 @@
++#include "llvm/Transforms/Utils/VNCoercion.h"
++#include "llvm/Analysis/AliasAnalysis.h"
++#include "llvm/Analysis/ConstantFolding.h"
++#include "llvm/Analysis/MemoryDependenceAnalysis.h"
++#include "llvm/Analysis/ValueTracking.h"
++#include "llvm/IR/IRBuilder.h"
++#include "llvm/IR/IntrinsicInst.h"
++#include "llvm/Support/Debug.h"
++
++#define DEBUG_TYPE "vncoerce"
++namespace llvm {
++namespace VNCoercion {
++
++/// Return true if coerceAvailableValueToLoadType will succeed.
++bool canCoerceMustAliasedValueToLoad(Value *StoredVal, Type *LoadTy,
++                                     const DataLayout &DL) {
++  // If the loaded or stored value is an first class array or struct, don't try
++  // to transform them.  We need to be able to bitcast to integer.
++  if (LoadTy->isStructTy() || LoadTy->isArrayTy() ||
++      StoredVal->getType()->isStructTy() || StoredVal->getType()->isArrayTy())
++    return false;
++
++  // The store has to be at least as big as the load.
++  if (DL.getTypeSizeInBits(StoredVal->getType()) < DL.getTypeSizeInBits(LoadTy))
++    return false;
++
++  return true;
++}
++
++/// If we saw a store of a value to memory, and
++/// then a load from a must-aliased pointer of a different type, try to coerce
++/// the stored value.  LoadedTy is the type of the load we want to replace.
++/// IRB is IRBuilder used to insert new instructions.
++///
++/// If we can't do it, return null.
++Value *coerceAvailableValueToLoadType(Value *StoredVal, Type *LoadedTy,
++                                      IRBuilder<> &IRB, const DataLayout &DL) {
++  assert(canCoerceMustAliasedValueToLoad(StoredVal, LoadedTy, DL) &&
++         "precondition violation - materialization can't fail");
++
++  if (auto *C = dyn_cast<Constant>(StoredVal))
++    if (auto *FoldedStoredVal = ConstantFoldConstant(C, DL))
++      StoredVal = FoldedStoredVal;
++
++  // If this is already the right type, just return it.
++  Type *StoredValTy = StoredVal->getType();
++
++  uint64_t StoredValSize = DL.getTypeSizeInBits(StoredValTy);
++  uint64_t LoadedValSize = DL.getTypeSizeInBits(LoadedTy);
++
++  // If the store and reload are the same size, we can always reuse it.
++  if (StoredValSize == LoadedValSize) {
++    // Pointer to Pointer -> use bitcast.
++    if (StoredValTy->getScalarType()->isPointerTy() &&
++        LoadedTy->getScalarType()->isPointerTy()) {
++      StoredVal = IRB.CreateBitCast(StoredVal, LoadedTy);
++    } else {
++      // Convert source pointers to integers, which can be bitcast.
++      if (StoredValTy->getScalarType()->isPointerTy()) {
++        StoredValTy = DL.getIntPtrType(StoredValTy);
++        StoredVal = IRB.CreatePtrToInt(StoredVal, StoredValTy);
++      }
++
++      Type *TypeToCastTo = LoadedTy;
++      if (TypeToCastTo->getScalarType()->isPointerTy())
++        TypeToCastTo = DL.getIntPtrType(TypeToCastTo);
++
++      if (StoredValTy != TypeToCastTo)
++        StoredVal = IRB.CreateBitCast(StoredVal, TypeToCastTo);
++
++      // Cast to pointer if the load needs a pointer type.
++      if (LoadedTy->getScalarType()->isPointerTy())
++        StoredVal = IRB.CreateIntToPtr(StoredVal, LoadedTy);
++    }
++
++    if (auto *C = dyn_cast<ConstantExpr>(StoredVal))
++      if (auto *FoldedStoredVal = ConstantFoldConstant(C, DL))
++        StoredVal = FoldedStoredVal;
++
++    return StoredVal;
++  }
++
++  // If the loaded value is smaller than the available value, then we can
++  // extract out a piece from it.  If the available value is too small, then we
++  // can't do anything.
++  assert(StoredValSize >= LoadedValSize &&
++         "canCoerceMustAliasedValueToLoad fail");
++
++  // Convert source pointers to integers, which can be manipulated.
++  if (StoredValTy->getScalarType()->isPointerTy()) {
++    StoredValTy = DL.getIntPtrType(StoredValTy);
++    StoredVal = IRB.CreatePtrToInt(StoredVal, StoredValTy);
++  }
++
++  // Convert vectors and fp to integer, which can be manipulated.
++  if (!StoredValTy->isIntegerTy()) {
++    StoredValTy = IntegerType::get(StoredValTy->getContext(), StoredValSize);
++    StoredVal = IRB.CreateBitCast(StoredVal, StoredValTy);
++  }
++
++  // If this is a big-endian system, we need to shift the value down to the low
++  // bits so that a truncate will work.
++  if (DL.isBigEndian()) {
++    uint64_t ShiftAmt = DL.getTypeStoreSizeInBits(StoredValTy) -
++                        DL.getTypeStoreSizeInBits(LoadedTy);
++    StoredVal = IRB.CreateLShr(StoredVal, ShiftAmt, "tmp");
++  }
++
++  // Truncate the integer to the right size now.
++  Type *NewIntTy = IntegerType::get(StoredValTy->getContext(), LoadedValSize);
++  StoredVal = IRB.CreateTrunc(StoredVal, NewIntTy, "trunc");
++
++  if (LoadedTy != NewIntTy) {
++    // If the result is a pointer, inttoptr.
++    if (LoadedTy->getScalarType()->isPointerTy())
++      StoredVal = IRB.CreateIntToPtr(StoredVal, LoadedTy, "inttoptr");
++    else
++      // Otherwise, bitcast.
++      StoredVal = IRB.CreateBitCast(StoredVal, LoadedTy, "bitcast");
++  }
++
++  if (auto *C = dyn_cast<Constant>(StoredVal))
++    if (auto *FoldedStoredVal = ConstantFoldConstant(C, DL))
++      StoredVal = FoldedStoredVal;
++
++  return StoredVal;
++}
++
++/// This function is called when we have a
++/// memdep query of a load that ends up being a clobbering memory write (store,
++/// memset, memcpy, memmove).  This means that the write *may* provide bits used
++/// by the load but we can't be sure because the pointers don't mustalias.
++///
++/// Check this case to see if there is anything more we can do before we give
++/// up.  This returns -1 if we have to give up, or a byte number in the stored
++/// value of the piece that feeds the load.
++static int analyzeLoadFromClobberingWrite(Type *LoadTy, Value *LoadPtr,
++                                          Value *WritePtr,
++                                          uint64_t WriteSizeInBits,
++                                          const DataLayout &DL) {
++  // If the loaded or stored value is a first class array or struct, don't try
++  // to transform them.  We need to be able to bitcast to integer.
++  if (LoadTy->isStructTy() || LoadTy->isArrayTy())
++    return -1;
++
++  int64_t StoreOffset = 0, LoadOffset = 0;
++  Value *StoreBase =
++      GetPointerBaseWithConstantOffset(WritePtr, StoreOffset, DL);
++  Value *LoadBase = GetPointerBaseWithConstantOffset(LoadPtr, LoadOffset, DL);
++  if (StoreBase != LoadBase)
++    return -1;
++
++  // If the load and store are to the exact same address, they should have been
++  // a must alias.  AA must have gotten confused.
++  // FIXME: Study to see if/when this happens.  One case is forwarding a memset
++  // to a load from the base of the memset.
++
++  // If the load and store don't overlap at all, the store doesn't provide
++  // anything to the load.  In this case, they really don't alias at all, AA
++  // must have gotten confused.
++  uint64_t LoadSize = DL.getTypeSizeInBits(LoadTy);
++
++  if ((WriteSizeInBits & 7) | (LoadSize & 7))
++    return -1;
++  uint64_t StoreSize = WriteSizeInBits / 8; // Convert to bytes.
++  LoadSize /= 8;
++
++  bool isAAFailure = false;
++  if (StoreOffset < LoadOffset)
++    isAAFailure = StoreOffset + int64_t(StoreSize) <= LoadOffset;
++  else
++    isAAFailure = LoadOffset + int64_t(LoadSize) <= StoreOffset;
++
++  if (isAAFailure)
++    return -1;
++
++  // If the Load isn't completely contained within the stored bits, we don't
++  // have all the bits to feed it.  We could do something crazy in the future
++  // (issue a smaller load then merge the bits in) but this seems unlikely to be
++  // valuable.
++  if (StoreOffset > LoadOffset ||
++      StoreOffset + StoreSize < LoadOffset + LoadSize)
++    return -1;
++
++  // Okay, we can do this transformation.  Return the number of bytes into the
++  // store that the load is.
++  return LoadOffset - StoreOffset;
++}
++
++/// This function is called when we have a
++/// memdep query of a load that ends up being a clobbering store.
++int analyzeLoadFromClobberingStore(Type *LoadTy, Value *LoadPtr,
++                                   StoreInst *DepSI) {
++  // Cannot handle reading from store of first-class aggregate yet.
++  if (DepSI->getValueOperand()->getType()->isStructTy() ||
++      DepSI->getValueOperand()->getType()->isArrayTy())
++    return -1;
++
++  const DataLayout &DL = DepSI->getModule()->getDataLayout();
++  Value *StorePtr = DepSI->getPointerOperand();
++  uint64_t StoreSize =
++      DL.getTypeSizeInBits(DepSI->getValueOperand()->getType());
++  return analyzeLoadFromClobberingWrite(LoadTy, LoadPtr, StorePtr, StoreSize,
++                                        DL);
++}
++
++/// This function is called when we have a
++/// memdep query of a load that ends up being clobbered by another load.  See if
++/// the other load can feed into the second load.
++int analyzeLoadFromClobberingLoad(Type *LoadTy, Value *LoadPtr, LoadInst *DepLI,
++                                  const DataLayout &DL) {
++  // Cannot handle reading from store of first-class aggregate yet.
++  if (DepLI->getType()->isStructTy() || DepLI->getType()->isArrayTy())
++    return -1;
++
++  Value *DepPtr = DepLI->getPointerOperand();
++  uint64_t DepSize = DL.getTypeSizeInBits(DepLI->getType());
++  int R = analyzeLoadFromClobberingWrite(LoadTy, LoadPtr, DepPtr, DepSize, DL);
++  if (R != -1)
++    return R;
++
++  // If we have a load/load clobber an DepLI can be widened to cover this load,
++  // then we should widen it!
++  int64_t LoadOffs = 0;
++  const Value *LoadBase =
++      GetPointerBaseWithConstantOffset(LoadPtr, LoadOffs, DL);
++  unsigned LoadSize = DL.getTypeStoreSize(LoadTy);
++
++  unsigned Size = MemoryDependenceResults::getLoadLoadClobberFullWidthSize(
++      LoadBase, LoadOffs, LoadSize, DepLI);
++  if (Size == 0)
++    return -1;
++
++  // Check non-obvious conditions enforced by MDA which we rely on for being
++  // able to materialize this potentially available value
++  assert(DepLI->isSimple() && "Cannot widen volatile/atomic load!");
++  assert(DepLI->getType()->isIntegerTy() && "Can't widen non-integer load");
++
++  return analyzeLoadFromClobberingWrite(LoadTy, LoadPtr, DepPtr, Size * 8, DL);
++}
++
++int analyzeLoadFromClobberingMemInst(Type *LoadTy, Value *LoadPtr,
++                                     MemIntrinsic *MI, const DataLayout &DL) {
++  // If the mem operation is a non-constant size, we can't handle it.
++  ConstantInt *SizeCst = dyn_cast<ConstantInt>(MI->getLength());
++  if (!SizeCst)
++    return -1;
++  uint64_t MemSizeInBits = SizeCst->getZExtValue() * 8;
++
++  // If this is memset, we just need to see if the offset is valid in the size
++  // of the memset..
++  if (MI->getIntrinsicID() == Intrinsic::memset)
++    return analyzeLoadFromClobberingWrite(LoadTy, LoadPtr, MI->getDest(),
++                                          MemSizeInBits, DL);
++
++  // If we have a memcpy/memmove, the only case we can handle is if this is a
++  // copy from constant memory.  In that case, we can read directly from the
++  // constant memory.
++  MemTransferInst *MTI = cast<MemTransferInst>(MI);
++
++  Constant *Src = dyn_cast<Constant>(MTI->getSource());
++  if (!Src)
++    return -1;
++
++  GlobalVariable *GV = dyn_cast<GlobalVariable>(GetUnderlyingObject(Src, DL));
++  if (!GV || !GV->isConstant())
++    return -1;
++
++  // See if the access is within the bounds of the transfer.
++  int Offset = analyzeLoadFromClobberingWrite(LoadTy, LoadPtr, MI->getDest(),
++                                              MemSizeInBits, DL);
++  if (Offset == -1)
++    return Offset;
++
++  unsigned AS = Src->getType()->getPointerAddressSpace();
++  // Otherwise, see if we can constant fold a load from the constant with the
++  // offset applied as appropriate.
++  Src =
++      ConstantExpr::getBitCast(Src, Type::getInt8PtrTy(Src->getContext(), AS));
++  Constant *OffsetCst =
++      ConstantInt::get(Type::getInt64Ty(Src->getContext()), (unsigned)Offset);
++  Src = ConstantExpr::getGetElementPtr(Type::getInt8Ty(Src->getContext()), Src,
++                                       OffsetCst);
++  Src = ConstantExpr::getBitCast(Src, PointerType::get(LoadTy, AS));
++  if (ConstantFoldLoadFromConstPtr(Src, LoadTy, DL))
++    return Offset;
++  return -1;
++}
++
++/// This function is called when we have a
++/// memdep query of a load that ends up being a clobbering store.  This means
++/// that the store provides bits used by the load but we the pointers don't
++/// mustalias.  Check this case to see if there is anything more we can do
++/// before we give up.
++Value *getStoreValueForLoad(Value *SrcVal, unsigned Offset, Type *LoadTy,
++                            Instruction *InsertPt, const DataLayout &DL) {
++  LLVMContext &Ctx = SrcVal->getType()->getContext();
++
++  uint64_t StoreSize = (DL.getTypeSizeInBits(SrcVal->getType()) + 7) / 8;
++  uint64_t LoadSize = (DL.getTypeSizeInBits(LoadTy) + 7) / 8;
++
++  IRBuilder<> Builder(InsertPt);
++
++  // Compute which bits of the stored value are being used by the load.  Convert
++  // to an integer type to start with.
++  if (SrcVal->getType()->getScalarType()->isPointerTy())
++    SrcVal =
++        Builder.CreatePtrToInt(SrcVal, DL.getIntPtrType(SrcVal->getType()));
++  if (!SrcVal->getType()->isIntegerTy())
++    SrcVal =
++        Builder.CreateBitCast(SrcVal, IntegerType::get(Ctx, StoreSize * 8));
++
++  // Shift the bits to the least significant depending on endianness.
++  unsigned ShiftAmt;
++  if (DL.isLittleEndian())
++    ShiftAmt = Offset * 8;
++  else
++    ShiftAmt = (StoreSize - LoadSize - Offset) * 8;
++
++  if (ShiftAmt)
++    SrcVal = Builder.CreateLShr(SrcVal, ShiftAmt);
++
++  if (LoadSize != StoreSize)
++    SrcVal = Builder.CreateTrunc(SrcVal, IntegerType::get(Ctx, LoadSize * 8));
++
++  return coerceAvailableValueToLoadType(SrcVal, LoadTy, Builder, DL);
++}
++
++/// This function is called when we have a
++/// memdep query of a load that ends up being a clobbering load.  This means
++/// that the load *may* provide bits used by the load but we can't be sure
++/// because the pointers don't mustalias.  Check this case to see if there is
++/// anything more we can do before we give up.
++Value *getLoadValueForLoad(LoadInst *SrcVal, unsigned Offset, Type *LoadTy,
++                           Instruction *InsertPt) {
++
++  const DataLayout &DL = SrcVal->getModule()->getDataLayout();
++  // If Offset+LoadTy exceeds the size of SrcVal, then we must be wanting to
++  // widen SrcVal out to a larger load.
++  unsigned SrcValStoreSize = DL.getTypeStoreSize(SrcVal->getType());
++  unsigned LoadSize = DL.getTypeStoreSize(LoadTy);
++  if (Offset + LoadSize > SrcValStoreSize) {
++    assert(SrcVal->isSimple() && "Cannot widen volatile/atomic load!");
++    assert(SrcVal->getType()->isIntegerTy() && "Can't widen non-integer load");
++    // If we have a load/load clobber an DepLI can be widened to cover this
++    // load, then we should widen it to the next power of 2 size big enough!
++    unsigned NewLoadSize = Offset + LoadSize;
++    if (!isPowerOf2_32(NewLoadSize))
++      NewLoadSize = NextPowerOf2(NewLoadSize);
++
++    Value *PtrVal = SrcVal->getPointerOperand();
++
++    // Insert the new load after the old load.  This ensures that subsequent
++    // memdep queries will find the new load.  We can't easily remove the old
++    // load completely because it is already in the value numbering table.
++    IRBuilder<> Builder(SrcVal->getParent(), ++BasicBlock::iterator(SrcVal));
++    Type *DestPTy = IntegerType::get(LoadTy->getContext(), NewLoadSize * 8);
++    DestPTy =
++        PointerType::get(DestPTy, PtrVal->getType()->getPointerAddressSpace());
++    Builder.SetCurrentDebugLocation(SrcVal->getDebugLoc());
++    PtrVal = Builder.CreateBitCast(PtrVal, DestPTy);
++    LoadInst *NewLoad = Builder.CreateLoad(PtrVal);
++    NewLoad->takeName(SrcVal);
++    NewLoad->setAlignment(SrcVal->getAlignment());
++
++    DEBUG(dbgs() << "GVN WIDENED LOAD: " << *SrcVal << "\n");
++    DEBUG(dbgs() << "TO: " << *NewLoad << "\n");
++
++    // Replace uses of the original load with the wider load.  On a big endian
++    // system, we need to shift down to get the relevant bits.
++    Value *RV = NewLoad;
++    if (DL.isBigEndian())
++      RV = Builder.CreateLShr(RV, (NewLoadSize - SrcValStoreSize) * 8);
++    RV = Builder.CreateTrunc(RV, SrcVal->getType());
++    SrcVal->replaceAllUsesWith(RV);
++
++    SrcVal = NewLoad;
++  }
++
++  return getStoreValueForLoad(SrcVal, Offset, LoadTy, InsertPt, DL);
++}
++
++/// This function is called when we have a
++/// memdep query of a load that ends up being a clobbering mem intrinsic.
++Value *getMemInstValueForLoad(MemIntrinsic *SrcInst, unsigned Offset,
++                              Type *LoadTy, Instruction *InsertPt,
++                              const DataLayout &DL) {
++  LLVMContext &Ctx = LoadTy->getContext();
++  uint64_t LoadSize = DL.getTypeSizeInBits(LoadTy) / 8;
++
++  IRBuilder<> Builder(InsertPt);
++
++  // We know that this method is only called when the mem transfer fully
++  // provides the bits for the load.
++  if (MemSetInst *MSI = dyn_cast<MemSetInst>(SrcInst)) {
++    // memset(P, 'x', 1234) -> splat('x'), even if x is a variable, and
++    // independently of what the offset is.
++    Value *Val = MSI->getValue();
++    if (LoadSize != 1)
++      Val = Builder.CreateZExt(Val, IntegerType::get(Ctx, LoadSize * 8));
++
++    Value *OneElt = Val;
++
++    // Splat the value out to the right number of bits.
++    for (unsigned NumBytesSet = 1; NumBytesSet != LoadSize;) {
++      // If we can double the number of bytes set, do it.
++      if (NumBytesSet * 2 <= LoadSize) {
++        Value *ShVal = Builder.CreateShl(Val, NumBytesSet * 8);
++        Val = Builder.CreateOr(Val, ShVal);
++        NumBytesSet <<= 1;
++        continue;
++      }
++
++      // Otherwise insert one byte at a time.
++      Value *ShVal = Builder.CreateShl(Val, 1 * 8);
++      Val = Builder.CreateOr(OneElt, ShVal);
++      ++NumBytesSet;
++    }
++
++    return coerceAvailableValueToLoadType(Val, LoadTy, Builder, DL);
++  }
++
++  // Otherwise, this is a memcpy/memmove from a constant global.
++  MemTransferInst *MTI = cast<MemTransferInst>(SrcInst);
++  Constant *Src = cast<Constant>(MTI->getSource());
++  unsigned AS = Src->getType()->getPointerAddressSpace();
++
++  // Otherwise, see if we can constant fold a load from the constant with the
++  // offset applied as appropriate.
++  Src =
++      ConstantExpr::getBitCast(Src, Type::getInt8PtrTy(Src->getContext(), AS));
++  Constant *OffsetCst =
++      ConstantInt::get(Type::getInt64Ty(Src->getContext()), (unsigned)Offset);
++  Src = ConstantExpr::getGetElementPtr(Type::getInt8Ty(Src->getContext()), Src,
++                                       OffsetCst);
++  Src = ConstantExpr::getBitCast(Src, PointerType::get(LoadTy, AS));
++  return ConstantFoldLoadFromConstPtr(Src, LoadTy, DL);
++}
++} // namespace VNCoercion
++} // namespace llvm
+-- 
+2.13.1
+
diff --git a/deps/patches/llvm-D32196-LIR-non-integral.patch b/deps/patches/llvm-D32196-LIR-non-integral.patch
new file mode 100644
index 00000000000000..28b4abdafa2259
--- /dev/null
+++ b/deps/patches/llvm-D32196-LIR-non-integral.patch
@@ -0,0 +1,95 @@
+From aebd138996c29589d44d6eccea659757c6184b44 Mon Sep 17 00:00:00 2001
+From: Sanjoy Das <sanjoy@playingwithpointers.com>
+Date: Mon, 24 Apr 2017 20:12:10 +0000
+Subject: [PATCH 3/5] [LIR] Obey non-integral pointer semantics
+
+Summary: See http://llvm.org/docs/LangRef.html#non-integral-pointer-type
+
+Reviewers: haicheng
+
+Reviewed By: haicheng
+
+Subscribers: mcrosier, mzolotukhin, llvm-commits
+
+Differential Revision: https://reviews.llvm.org/D32196
+
+git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@301238 91177308-0d34-0410-b5e6-96231b3b80d8
+---
+ lib/Transforms/Scalar/LoopIdiomRecognize.cpp       |  5 +++
+ test/Transforms/LoopIdiom/non-integral-pointers.ll | 48 ++++++++++++++++++++++
+ 2 files changed, 53 insertions(+)
+ create mode 100644 test/Transforms/LoopIdiom/non-integral-pointers.ll
+
+diff --git a/lib/Transforms/Scalar/LoopIdiomRecognize.cpp b/lib/Transforms/Scalar/LoopIdiomRecognize.cpp
+index 5fec51c095d..570c55a3e76 100644
+--- a/lib/Transforms/Scalar/LoopIdiomRecognize.cpp
++++ b/lib/Transforms/Scalar/LoopIdiomRecognize.cpp
+@@ -345,6 +345,11 @@ bool LoopIdiomRecognize::isLegalStore(StoreInst *SI, bool &ForMemset,
+   if (!SI->isSimple())
+     return false;
+ 
++  // Don't convert stores of non-integral pointer types to memsets (which stores
++  // integers).
++  if (DL->isNonIntegralPointerType(SI->getValueOperand()->getType()))
++    return false;
++
+   // Avoid merging nontemporal stores.
+   if (SI->getMetadata(LLVMContext::MD_nontemporal))
+     return false;
+diff --git a/test/Transforms/LoopIdiom/non-integral-pointers.ll b/test/Transforms/LoopIdiom/non-integral-pointers.ll
+new file mode 100644
+index 00000000000..7646d5ac72d
+--- /dev/null
++++ b/test/Transforms/LoopIdiom/non-integral-pointers.ll
+@@ -0,0 +1,48 @@
++; RUN: opt -S -basicaa -loop-idiom < %s | FileCheck %s
++
++target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128-ni:4"
++target triple = "x86_64-unknown-linux-gnu"
++
++define void @f_0(i8 addrspace(3)** %ptr) {
++; CHECK-LABEL: @f_0(
++; CHECK: call{{.*}}memset
++
++; LIR'ing stores of pointers with address space 3 is fine, since
++; they're integral pointers.
++
++entry:
++  br label %for.body
++
++for.body:
++  %indvar = phi i64 [ 0, %entry ], [ %indvar.next, %for.body ]
++  %arrayidx = getelementptr i8 addrspace(3)*, i8 addrspace(3)** %ptr, i64 %indvar
++  store i8 addrspace(3)* null, i8 addrspace(3)** %arrayidx, align 4
++  %indvar.next = add i64 %indvar, 1
++  %exitcond = icmp eq i64 %indvar.next, 10000
++  br i1 %exitcond, label %for.end, label %for.body
++
++for.end:
++  ret void
++}
++
++define void @f_1(i8 addrspace(4)** %ptr) {
++; CHECK-LABEL: @f_1(
++; CHECK-NOT: call{{.*}}memset
++
++; LIR'ing stores of pointers with address space 4 is not ok, since
++; they're non-integral pointers.
++
++entry:
++  br label %for.body
++
++for.body:
++  %indvar = phi i64 [ 0, %entry ], [ %indvar.next, %for.body ]
++  %arrayidx = getelementptr i8 addrspace(4)*, i8 addrspace(4)** %ptr, i64 %indvar
++  store i8 addrspace(4)* null, i8 addrspace(4)** %arrayidx, align 4
++  %indvar.next = add i64 %indvar, 1
++  %exitcond = icmp eq i64 %indvar.next, 10000
++  br i1 %exitcond, label %for.end, label %for.body
++
++for.end:
++  ret void
++}
+-- 
+2.13.1
+
diff --git a/deps/patches/llvm-D32203-SORA-non-integral.patch b/deps/patches/llvm-D32203-SORA-non-integral.patch
new file mode 100644
index 00000000000000..6c9b75b1ca0da5
--- /dev/null
+++ b/deps/patches/llvm-D32203-SORA-non-integral.patch
@@ -0,0 +1,99 @@
+From 2fe2c1173e286203309e5bb9b034fd55dc9fc8fc Mon Sep 17 00:00:00 2001
+From: Sanjoy Das <sanjoy@azulsystems.com>
+Date: Sat, 17 Jun 2017 11:06:25 -0400
+Subject: [PATCH 1/2] [SROA] Add support for non-integral pointers
+
+Summary: C.f. http://llvm.org/docs/LangRef.html#non-integral-pointer-type
+
+Reviewers: chandlerc, loladiro
+
+Reviewed By: loladiro
+
+Subscribers: reames, loladiro, mcrosier, llvm-commits
+
+Differential Revision: https://reviews.llvm.org/D32203
+---
+ lib/Transforms/Scalar/SROA.cpp                | 13 ++++++--
+ test/Transforms/SROA/non-integral-pointers.ll | 46 +++++++++++++++++++++++++++
+ 2 files changed, 57 insertions(+), 2 deletions(-)
+ create mode 100644 test/Transforms/SROA/non-integral-pointers.ll
+
+diff --git a/lib/Transforms/Scalar/SROA.cpp b/lib/Transforms/Scalar/SROA.cpp
+index d28490f3a50..ec8636fe25a 100644
+--- a/lib/Transforms/Scalar/SROA.cpp
++++ b/lib/Transforms/Scalar/SROA.cpp
+@@ -1636,8 +1636,17 @@ static bool canConvertValue(const DataLayout &DL, Type *OldTy, Type *NewTy) {
+       return cast<PointerType>(NewTy)->getPointerAddressSpace() ==
+         cast<PointerType>(OldTy)->getPointerAddressSpace();
+     }
+-    if (NewTy->isIntegerTy() || OldTy->isIntegerTy())
+-      return true;
++
++    // We can convert integers to integral pointers, but not to non-integral
++    // pointers.
++    if (OldTy->isIntegerTy())
++      return !DL.isNonIntegralPointerType(NewTy);
++
++    // We can convert integral pointers to integers, but non-integral pointers
++    // need to remain pointers.
++    if (!DL.isNonIntegralPointerType(OldTy))
++      return NewTy->isIntegerTy();
++
+     return false;
+   }
+ 
+diff --git a/test/Transforms/SROA/non-integral-pointers.ll b/test/Transforms/SROA/non-integral-pointers.ll
+new file mode 100644
+index 00000000000..63286309f6f
+--- /dev/null
++++ b/test/Transforms/SROA/non-integral-pointers.ll
+@@ -0,0 +1,46 @@
++; RUN: opt -sroa -S < %s | FileCheck %s
++
++; This test checks that SROA does not introduce ptrtoint and inttoptr
++; casts from and to non-integral pointers.  The "ni:4" bit in the
++; datalayout states that pointers of address space 4 are to be
++; considered "non-integral".
++
++target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128-ni:4"
++target triple = "x86_64-unknown-linux-gnu"
++
++define void @f0(i1 %alwaysFalse, i64 %val) {
++; CHECK-LABEL: @f0(
++; CHECK-NOT: inttoptr
++; CHECK-NOT: ptrtoint
++entry:
++  %loc = alloca i64
++  store i64 %val, i64* %loc
++  br i1 %alwaysFalse, label %neverTaken, label %alwaysTaken
++
++neverTaken:
++  %loc.bc = bitcast i64* %loc to i8 addrspace(4)**
++  %ptr = load i8 addrspace(4)*, i8 addrspace(4)** %loc.bc
++  store i8 5, i8 addrspace(4)* %ptr
++  ret void
++
++alwaysTaken:
++  ret void
++}
++
++define i64 @f1(i1 %alwaysFalse, i8 addrspace(4)* %val) {
++; CHECK-LABEL: @f1(
++; CHECK-NOT: inttoptr
++; CHECK-NOT: ptrtoint
++entry:
++  %loc = alloca i8 addrspace(4)*
++  store i8 addrspace(4)* %val, i8 addrspace(4)** %loc
++  br i1 %alwaysFalse, label %neverTaken, label %alwaysTaken
++
++neverTaken:
++  %loc.bc = bitcast i8 addrspace(4)** %loc to i64*
++  %int = load i64, i64* %loc.bc
++  ret i64 %int
++
++alwaysTaken:
++  ret i64 42
++}
+-- 
+2.13.1
+
diff --git a/deps/patches/llvm-D32208-coerce-non-integral.patch b/deps/patches/llvm-D32208-coerce-non-integral.patch
new file mode 100644
index 00000000000000..bc0ec8a594e727
--- /dev/null
+++ b/deps/patches/llvm-D32208-coerce-non-integral.patch
@@ -0,0 +1,137 @@
+From 2a7ef55ed78bb5f147900af862fed32103257839 Mon Sep 17 00:00:00 2001
+From: Sanjoy Das <sanjoy@playingwithpointers.com>
+Date: Wed, 19 Apr 2017 18:21:09 +0000
+Subject: [PATCH 2/5] [GVN] Don't coerce non-integral pointers to integers or
+ vice versa
+
+Summary:
+See http://llvm.org/docs/LangRef.html#non-integral-pointer-type
+
+The NewGVN test does not fail without these changes (perhaps it does
+try to coerce pointers <-> integers to begin with?), but I added the
+test case anyway.
+
+Reviewers: dberlin
+
+Subscribers: mcrosier, llvm-commits, Prazek
+
+Differential Revision: https://reviews.llvm.org/D32208
+
+git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@300730 91177308-0d34-0410-b5e6-96231b3b80d8
+---
+ lib/Transforms/Utils/VNCoercion.cpp             |  5 ++++
+ test/Transforms/GVN/non-integral-pointers.ll    | 39 +++++++++++++++++++++++++
+ test/Transforms/NewGVN/non-integral-pointers.ll | 39 +++++++++++++++++++++++++
+ 3 files changed, 83 insertions(+)
+ create mode 100644 test/Transforms/GVN/non-integral-pointers.ll
+ create mode 100644 test/Transforms/NewGVN/non-integral-pointers.ll
+
+diff --git a/lib/Transforms/Utils/VNCoercion.cpp b/lib/Transforms/Utils/VNCoercion.cpp
+index 38d26e922c3..80762ccc0d4 100644
+--- a/lib/Transforms/Utils/VNCoercion.cpp
++++ b/lib/Transforms/Utils/VNCoercion.cpp
+@@ -24,6 +24,11 @@ bool canCoerceMustAliasedValueToLoad(Value *StoredVal, Type *LoadTy,
+   if (DL.getTypeSizeInBits(StoredVal->getType()) < DL.getTypeSizeInBits(LoadTy))
+     return false;
+ 
++  // Don't coerce non-integral pointers to integers or vice versa.
++  if (DL.isNonIntegralPointerType(StoredVal->getType()) !=
++      DL.isNonIntegralPointerType(LoadTy))
++    return false;
++
+   return true;
+ }
+ 
+diff --git a/test/Transforms/GVN/non-integral-pointers.ll b/test/Transforms/GVN/non-integral-pointers.ll
+new file mode 100644
+index 00000000000..9ae4132231d
+--- /dev/null
++++ b/test/Transforms/GVN/non-integral-pointers.ll
+@@ -0,0 +1,39 @@
++; RUN: opt -gvn -S < %s | FileCheck %s
++
++target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128-ni:4"
++target triple = "x86_64-unknown-linux-gnu"
++
++define void @f0(i1 %alwaysFalse, i64 %val, i64* %loc) {
++; CHECK-LABEL: @f0(
++; CHECK-NOT: inttoptr
++; CHECK-NOT: ptrtoint
++ entry:
++  store i64 %val, i64* %loc
++  br i1 %alwaysFalse, label %neverTaken, label %alwaysTaken
++
++ neverTaken:
++  %loc.bc = bitcast i64* %loc to i8 addrspace(4)**
++  %ptr = load i8 addrspace(4)*, i8 addrspace(4)** %loc.bc
++  store i8 5, i8 addrspace(4)* %ptr
++  ret void
++
++ alwaysTaken:
++  ret void
++}
++
++define i64 @f1(i1 %alwaysFalse, i8 addrspace(4)* %val, i8 addrspace(4)** %loc) {
++; CHECK-LABEL: @f1(
++; CHECK-NOT: inttoptr
++; CHECK-NOT: ptrtoint
++ entry:
++  store i8 addrspace(4)* %val, i8 addrspace(4)** %loc
++  br i1 %alwaysFalse, label %neverTaken, label %alwaysTaken
++
++ neverTaken:
++  %loc.bc = bitcast i8 addrspace(4)** %loc to i64*
++  %int = load i64, i64* %loc.bc
++  ret i64 %int
++
++ alwaysTaken:
++  ret i64 42
++}
+diff --git a/test/Transforms/NewGVN/non-integral-pointers.ll b/test/Transforms/NewGVN/non-integral-pointers.ll
+new file mode 100644
+index 00000000000..75b8285d51f
+--- /dev/null
++++ b/test/Transforms/NewGVN/non-integral-pointers.ll
+@@ -0,0 +1,39 @@
++; RUN: opt -newgvn -S < %s | FileCheck %s
++
++target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128-ni:4"
++target triple = "x86_64-unknown-linux-gnu"
++
++define void @f0(i1 %alwaysFalse, i64 %val, i64* %loc) {
++; CHECK-LABEL: @f0(
++; CHECK-NOT: inttoptr
++; CHECK-NOT: ptrtoint
++ entry:
++  store i64 %val, i64* %loc
++  br i1 %alwaysFalse, label %neverTaken, label %alwaysTaken
++
++ neverTaken:
++  %loc.bc = bitcast i64* %loc to i8 addrspace(4)**
++  %ptr = load i8 addrspace(4)*, i8 addrspace(4)** %loc.bc
++  store i8 5, i8 addrspace(4)* %ptr
++  ret void
++
++ alwaysTaken:
++  ret void
++}
++
++define i64 @f1(i1 %alwaysFalse, i8 addrspace(4)* %val, i8 addrspace(4)** %loc) {
++; CHECK-LABEL: @f1(
++; CHECK-NOT: inttoptr
++; CHECK-NOT: ptrtoint
++ entry:
++  store i8 addrspace(4)* %val, i8 addrspace(4)** %loc
++  br i1 %alwaysFalse, label %neverTaken, label %alwaysTaken
++
++ neverTaken:
++  %loc.bc = bitcast i8 addrspace(4)** %loc to i64*
++  %int = load i64, i64* %loc.bc
++  ret i64 %int
++
++ alwaysTaken:
++  ret i64 42
++}
+-- 
+2.13.1
+
diff --git a/deps/patches/llvm-D32593.patch b/deps/patches/llvm-D32593.patch
new file mode 100644
index 00000000000000..19c4acb960f97e
--- /dev/null
+++ b/deps/patches/llvm-D32593.patch
@@ -0,0 +1,83 @@
+From 5eeab81d22e07b6e12821067fced590f534c251a Mon Sep 17 00:00:00 2001
+From: Keno Fischer <keno@juliacomputing.com>
+Date: Thu, 27 Apr 2017 14:33:33 -0400
+Subject: [PATCH] [SROA] Fix crash due to bad bitcast
+
+Summary:
+As shown in the test case, SROA was crashing when trying to split
+stores (to the alloca) of loads (from anywhere), because it assumed
+the pointer operand to the loads and stores had to have the same
+address space. This isn't the case. Make sure to use the correct
+pointer type for both the load and the store.
+
+Reviewers: chandlerc, majnemer, sanjoy
+
+Subscribers: arsenm, llvm-commits
+
+Differential Revision: https://reviews.llvm.org/D32593
+---
+ lib/Transforms/Scalar/SROA.cpp         |  7 ++++---
+ test/Transforms/SROA/address-spaces.ll | 18 ++++++++++++++++++
+ 2 files changed, 22 insertions(+), 3 deletions(-)
+
+diff --git a/lib/Transforms/Scalar/SROA.cpp b/lib/Transforms/Scalar/SROA.cpp
+index d01e91a..610d5a8 100644
+--- a/lib/Transforms/Scalar/SROA.cpp
++++ b/lib/Transforms/Scalar/SROA.cpp
+@@ -3697,7 +3697,8 @@ bool SROA::presplitLoadsAndStores(AllocaInst &AI, AllocaSlices &AS) {
+     int Idx = 0, Size = Offsets.Splits.size();
+     for (;;) {
+       auto *PartTy = Type::getIntNTy(Ty->getContext(), PartSize * 8);
+-      auto *PartPtrTy = PartTy->getPointerTo(SI->getPointerAddressSpace());
++      auto *LoadPartPtrTy = PartTy->getPointerTo(LI->getPointerAddressSpace());
++      auto *StorePartPtrTy = PartTy->getPointerTo(SI->getPointerAddressSpace());
+ 
+       // Either lookup a split load or create one.
+       LoadInst *PLoad;
+@@ -3708,7 +3709,7 @@ bool SROA::presplitLoadsAndStores(AllocaInst &AI, AllocaSlices &AS) {
+         PLoad = IRB.CreateAlignedLoad(
+             getAdjustedPtr(IRB, DL, LoadBasePtr,
+                            APInt(DL.getPointerSizeInBits(), PartOffset),
+-                           PartPtrTy, LoadBasePtr->getName() + "."),
++                           LoadPartPtrTy, LoadBasePtr->getName() + "."),
+             getAdjustedAlignment(LI, PartOffset, DL), /*IsVolatile*/ false,
+             LI->getName());
+       }
+@@ -3718,7 +3719,7 @@ bool SROA::presplitLoadsAndStores(AllocaInst &AI, AllocaSlices &AS) {
+       StoreInst *PStore = IRB.CreateAlignedStore(
+           PLoad, getAdjustedPtr(IRB, DL, StoreBasePtr,
+                                 APInt(DL.getPointerSizeInBits(), PartOffset),
+-                                PartPtrTy, StoreBasePtr->getName() + "."),
++                                StorePartPtrTy, StoreBasePtr->getName() + "."),
+           getAdjustedAlignment(SI, PartOffset, DL), /*IsVolatile*/ false);
+ 
+       // Now build a new slice for the alloca.
+diff --git a/test/Transforms/SROA/address-spaces.ll b/test/Transforms/SROA/address-spaces.ll
+index 119f225..8fba30c 100644
+--- a/test/Transforms/SROA/address-spaces.ll
++++ b/test/Transforms/SROA/address-spaces.ll
+@@ -83,3 +83,21 @@ define void @pr27557() {
+   store i32 addrspace(3)* @l, i32 addrspace(3)** %3, align 8
+   ret void
+ }
++
++; Make sure pre-splitting doesn't try to introduce an illegal bitcast
++define float @presplit(i64 addrspace(1)* %p) {
++entry:
++; CHECK-LABEL: @presplit(
++; CHECK: %[[CAST:.*]] = bitcast i64 addrspace(1)* {{.*}} to i32 addrspace(1)*
++; CHECK: load i32, i32 addrspace(1)* %[[CAST]]
++   %b = alloca i64
++   %b.cast = bitcast i64* %b to [2 x float]*
++   %b.gep1 = getelementptr [2 x float], [2 x float]* %b.cast, i32 0, i32 0
++   %b.gep2 = getelementptr [2 x float], [2 x float]* %b.cast, i32 0, i32 1
++   %l = load i64, i64 addrspace(1)* %p
++   store i64 %l, i64* %b
++   %f1 = load float, float* %b.gep1
++   %f2 = load float, float* %b.gep2
++   %ret = fadd float %f1, %f2
++   ret float %ret
++}
+-- 
+2.9.3
+
diff --git a/deps/patches/llvm-D32623-GVN-non-integral.patch b/deps/patches/llvm-D32623-GVN-non-integral.patch
new file mode 100644
index 00000000000000..5ddc76bc046d58
--- /dev/null
+++ b/deps/patches/llvm-D32623-GVN-non-integral.patch
@@ -0,0 +1,94 @@
+From ad3b6cad4fcd66aab2ef2e93566d5868505c03bb Mon Sep 17 00:00:00 2001
+From: Keno Fischer <keno@alumni.harvard.edu>
+Date: Tue, 9 May 2017 21:07:20 +0000
+Subject: [PATCH 4/5] [GVN] Fix a crash on encountering non-integral pointers
+
+Summary:
+This fixes the immediate crash caused by introducing an incorrect inttoptr
+before attempting the conversion. There may still be a legality
+check missing somewhere earlier for non-integral pointers, but this change
+seems necessary in any case.
+
+Reviewers: sanjoy, dberlin
+
+Reviewed By: dberlin
+
+Subscribers: llvm-commits
+
+Differential Revision: https://reviews.llvm.org/D32623
+
+git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@302587 91177308-0d34-0410-b5e6-96231b3b80d8
+---
+ lib/Transforms/Utils/VNCoercion.cpp    |  9 ++++++++
+ test/Transforms/GVN/PRE/nonintegral.ll | 39 ++++++++++++++++++++++++++++++++++
+ 2 files changed, 48 insertions(+)
+ create mode 100644 test/Transforms/GVN/PRE/nonintegral.ll
+
+diff --git a/lib/Transforms/Utils/VNCoercion.cpp b/lib/Transforms/Utils/VNCoercion.cpp
+index 80762ccc0d4..9d2eab19ded 100644
+--- a/lib/Transforms/Utils/VNCoercion.cpp
++++ b/lib/Transforms/Utils/VNCoercion.cpp
+@@ -301,6 +301,15 @@ Value *getStoreValueForLoad(Value *SrcVal, unsigned Offset, Type *LoadTy,
+                             Instruction *InsertPt, const DataLayout &DL) {
+   LLVMContext &Ctx = SrcVal->getType()->getContext();
+ 
++  // If two pointers are in the same address space, they have the same size,
++  // so we don't need to do any truncation, etc. This avoids introducing
++  // ptrtoint instructions for pointers that may be non-integral.
++  if (SrcVal->getType()->isPointerTy() && LoadTy->isPointerTy() &&
++      cast<PointerType>(SrcVal->getType())->getAddressSpace() ==
++          cast<PointerType>(LoadTy)->getAddressSpace()) {
++    return SrcVal;
++  }
++
+   uint64_t StoreSize = (DL.getTypeSizeInBits(SrcVal->getType()) + 7) / 8;
+   uint64_t LoadSize = (DL.getTypeSizeInBits(LoadTy) + 7) / 8;
+ 
+diff --git a/test/Transforms/GVN/PRE/nonintegral.ll b/test/Transforms/GVN/PRE/nonintegral.ll
+new file mode 100644
+index 00000000000..75a756e8af8
+--- /dev/null
++++ b/test/Transforms/GVN/PRE/nonintegral.ll
+@@ -0,0 +1,39 @@
++; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
++; RUN: opt -gvn -S < %s | FileCheck %s
++
++target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128-ni:4"
++target triple = "x86_64-unknown-linux-gnu"
++
++define void @nipre(double addrspace(4)** noalias %p, i64 addrspace(4)** noalias %p2, i8 %jmp) {
++
++; CHECK-LABEL: @nipre(
++; CHECK:    [[PCAST:%.*]] = bitcast double addrspace(4)** [[P:%.*]] to i64 addrspace(4)**
++; CHECK:       a:
++; CHECK:    [[L1:%.*]] = load i64 addrspace(4)*, i64 addrspace(4)** [[PCAST]]
++; CHECK:    [[TMP0:%.*]] = bitcast i64 addrspace(4)* [[L1]] to double addrspace(4)*
++; CHECK:       b:
++; CHECK:    [[L2:%.*]] = load i64 addrspace(4)*, i64 addrspace(4)** [[PCAST]]
++; CHECK:    [[TMP1:%.*]] = bitcast i64 addrspace(4)* [[L2]] to double addrspace(4)*
++; CHECK:       c:
++; CHECK-NEXT:    [[L3_PRE:%.*]] = load double addrspace(4)*, double addrspace(4)** %p
++
++entry:
++  %pcast = bitcast double addrspace(4)** %p to i64 addrspace(4)**
++  switch i8 %jmp, label %c [ i8 0, label %a
++  i8 1, label %b]
++a:
++  %l1 = load i64 addrspace(4)*, i64 addrspace(4)** %pcast
++  store i64 addrspace(4)* %l1, i64 addrspace(4)** %p2
++  br label %tail
++b:
++  %l2 = load i64 addrspace(4)*, i64 addrspace(4)** %pcast
++  store i64 addrspace(4)* %l2, i64 addrspace(4)** %p2
++  br label %tail
++c:
++  br label %tail
++tail:
++  %l3 = load double addrspace(4)*, double addrspace(4)** %p
++  %l3cast = bitcast double addrspace(4)* %l3 to i64 addrspace(4)*
++  store i64 addrspace(4)* %l3cast, i64 addrspace(4)** %p2
++  ret void
++}
+-- 
+2.13.1
+
diff --git a/deps/patches/llvm-D33110-codegen-prepare-inttoptr.patch b/deps/patches/llvm-D33110-codegen-prepare-inttoptr.patch
new file mode 100644
index 00000000000000..5f1f874c3db83c
--- /dev/null
+++ b/deps/patches/llvm-D33110-codegen-prepare-inttoptr.patch
@@ -0,0 +1,119 @@
+From 8a2f775df3c8548bedd8437c0b96b54e9e71549d Mon Sep 17 00:00:00 2001
+From: Keno Fischer <keno@juliacomputing.com>
+Date: Sat, 17 Jun 2017 11:07:26 -0400
+Subject: [PATCH 2/2] [CodeGenPrepare] Don't create inttoptr for ni ptrs
+
+Summary:
+Arguably non-integral pointers probably shouldn't show up here at all,
+but since the backend doesn't complain and this takes valid (according
+to the Verifier) IR and makes it invalid, make sure not to introduce
+any inttoptr instructions if we're dealing with non-integral pointers.
+
+Reviewers: sanjoy
+
+Subscribers: llvm-commits
+
+Differential Revision: https://reviews.llvm.org/D33110
+---
+ lib/CodeGen/CodeGenPrepare.cpp                | 23 ++++++++-----
+ test/Transforms/CodeGenPrepare/nonintegral.ll | 47 +++++++++++++++++++++++++++
+ 2 files changed, 62 insertions(+), 8 deletions(-)
+ create mode 100644 test/Transforms/CodeGenPrepare/nonintegral.ll
+
+diff --git a/lib/CodeGen/CodeGenPrepare.cpp b/lib/CodeGen/CodeGenPrepare.cpp
+index 934b470f13b..44d6b3e264c 100644
+--- a/lib/CodeGen/CodeGenPrepare.cpp
++++ b/lib/CodeGen/CodeGenPrepare.cpp
+@@ -3973,14 +3973,16 @@ bool CodeGenPrepare::optimizeMemoryInst(Instruction *MemoryInst, Value *Addr,
+     // If the real base value actually came from an inttoptr, then the matcher
+     // will look through it and provide only the integer value. In that case,
+     // use it here.
+-    if (!ResultPtr && AddrMode.BaseReg) {
+-      ResultPtr =
+-        Builder.CreateIntToPtr(AddrMode.BaseReg, Addr->getType(), "sunkaddr");
+-      AddrMode.BaseReg = nullptr;
+-    } else if (!ResultPtr && AddrMode.Scale == 1) {
+-      ResultPtr =
+-        Builder.CreateIntToPtr(AddrMode.ScaledReg, Addr->getType(), "sunkaddr");
+-      AddrMode.Scale = 0;
++    if (!DL->isNonIntegralPointerType(Addr->getType())) {
++      if (!ResultPtr && AddrMode.BaseReg) {
++        ResultPtr = Builder.CreateIntToPtr(AddrMode.BaseReg, Addr->getType(),
++                                           "sunkaddr");
++        AddrMode.BaseReg = nullptr;
++      } else if (!ResultPtr && AddrMode.Scale == 1) {
++        ResultPtr = Builder.CreateIntToPtr(AddrMode.ScaledReg, Addr->getType(),
++                                           "sunkaddr");
++        AddrMode.Scale = 0;
++      }
+     }
+ 
+     if (!ResultPtr &&
+@@ -4061,6 +4063,11 @@ bool CodeGenPrepare::optimizeMemoryInst(Instruction *MemoryInst, Value *Addr,
+         SunkAddr = Builder.CreateBitCast(SunkAddr, Addr->getType());
+     }
+   } else {
++    // We'd require an inttoptr down the line, which we can't do for
++    // non-integral pointers, so in that case bail out now.
++    if (DL->isNonIntegralPointerType(Addr->getType()))
++      return false;
++
+     DEBUG(dbgs() << "CGP: SINKING nonlocal addrmode: " << AddrMode << " for "
+                  << *MemoryInst << "\n");
+     Type *IntPtrTy = DL->getIntPtrType(Addr->getType());
+diff --git a/test/Transforms/CodeGenPrepare/nonintegral.ll b/test/Transforms/CodeGenPrepare/nonintegral.ll
+new file mode 100644
+index 00000000000..e49977bc940
+--- /dev/null
++++ b/test/Transforms/CodeGenPrepare/nonintegral.ll
+@@ -0,0 +1,47 @@
++; RUN: opt -S -codegenprepare < %s | FileCheck %s
++; RUN: opt -S -codegenprepare -addr-sink-using-gep=false < %s | FileCheck %s
++
++; This target data layout is modified to have a non-integral addrspace(1),
++; in order to verify that codegenprepare does not try to introduce illegal
++; inttoptrs.
++target datalayout =
++"e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-ni:1"
++target triple = "x86_64-unknown-linux-gnu"
++
++define void @test_simple(i1 %cond, i64 addrspace(1)* %base) {
++; CHECK-LABEL: @test_simple
++; CHECK-NOT: inttoptr {{.*}} to i64 addrspace(1)*
++entry:
++  %addr = getelementptr inbounds i64, i64 addrspace(1)* %base, i64 5
++  %casted = bitcast i64 addrspace(1)* %addr to i32 addrspace(1)*
++  br i1 %cond, label %if.then, label %fallthrough
++
++if.then:
++  %v = load i32, i32 addrspace(1)* %casted, align 4
++  br label %fallthrough
++
++fallthrough:
++  ret void
++}
++
++
++define void @test_inttoptr_base(i1 %cond, i64 %base) {
++; CHECK-LABEL: @test_inttoptr_base
++; CHECK-NOT: inttoptr {{.*}} to i64 addrspace(1)*
++entry:
++; Doing the inttoptr in the integral addrspace(0) followed by an explicit
++; (frontend-introduced) addrspacecast is fine. We cannot however introduce
++; a direct inttoptr to addrspace(1)
++  %baseptr = inttoptr i64 %base to i64*
++  %baseptrni = addrspacecast i64 *%baseptr to i64 addrspace(1)*
++  %addr = getelementptr inbounds i64, i64 addrspace(1)* %baseptrni, i64 5
++  %casted = bitcast i64 addrspace(1)* %addr to i32 addrspace(1)*
++  br i1 %cond, label %if.then, label %fallthrough
++
++if.then:
++  %v = load i32, i32 addrspace(1)* %casted, align 4
++  br label %fallthrough
++
++fallthrough:
++  ret void
++}
+-- 
+2.13.1
+
diff --git a/deps/patches/llvm-D33129-scevexpander-non-integral.patch b/deps/patches/llvm-D33129-scevexpander-non-integral.patch
new file mode 100644
index 00000000000000..1dab29f94c041d
--- /dev/null
+++ b/deps/patches/llvm-D33129-scevexpander-non-integral.patch
@@ -0,0 +1,153 @@
+From d551af32da5fd6654e7804848a7a409e9444aeea Mon Sep 17 00:00:00 2001
+From: Keno Fischer <keno@alumni.harvard.edu>
+Date: Sat, 27 May 2017 03:22:55 +0000
+Subject: [PATCH 5/5] [SCEVExpander] Try harder to avoid introducing inttoptr
+
+Summary:
+This fixes introduction of an incorrect inttoptr/ptrtoint pair in
+the included test case which makes use of non-integral pointers. I
+suspect there are more cases like this left, but this takes care of
+the one I was seeing at the moment.
+
+Reviewers: sanjoy
+
+Subscribers: mzolotukhin, llvm-commits
+
+Differential Revision: https://reviews.llvm.org/D33129
+
+git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@304058 91177308-0d34-0410-b5e6-96231b3b80d8
+---
+ lib/Analysis/ScalarEvolutionExpander.cpp          | 20 ++++++++--
+ test/Transforms/LoopStrengthReduce/nonintegral.ll | 45 +++++++++++++++++++++++
+ unittests/Analysis/ScalarEvolutionTest.cpp        | 11 +++---
+ 3 files changed, 67 insertions(+), 9 deletions(-)
+ create mode 100644 test/Transforms/LoopStrengthReduce/nonintegral.ll
+
+diff --git a/lib/Analysis/ScalarEvolutionExpander.cpp b/lib/Analysis/ScalarEvolutionExpander.cpp
+index d15a7dbd20e..e7d9e9a633e 100644
+--- a/lib/Analysis/ScalarEvolutionExpander.cpp
++++ b/lib/Analysis/ScalarEvolutionExpander.cpp
+@@ -1306,12 +1306,17 @@ Value *SCEVExpander::expandAddRecExprLiterally(const SCEVAddRecExpr *S) {
+   // Expand the core addrec. If we need post-loop scaling, force it to
+   // expand to an integer type to avoid the need for additional casting.
+   Type *ExpandTy = PostLoopScale ? IntTy : STy;
++  // We can't use a pointer type for the addrec if the pointer type is
++  // non-integral.
++  Type *AddRecPHIExpandTy =
++      DL.isNonIntegralPointerType(STy) ? Normalized->getType() : ExpandTy;
++
+   // In some cases, we decide to reuse an existing phi node but need to truncate
+   // it and/or invert the step.
+   Type *TruncTy = nullptr;
+   bool InvertStep = false;
+-  PHINode *PN = getAddRecExprPHILiterally(Normalized, L, ExpandTy, IntTy,
+-                                          TruncTy, InvertStep);
++  PHINode *PN = getAddRecExprPHILiterally(Normalized, L, AddRecPHIExpandTy,
++                                          IntTy, TruncTy, InvertStep);
+ 
+   // Accommodate post-inc mode, if necessary.
+   Value *Result;
+@@ -1384,8 +1389,15 @@ Value *SCEVExpander::expandAddRecExprLiterally(const SCEVAddRecExpr *S) {
+   // Re-apply any non-loop-dominating offset.
+   if (PostLoopOffset) {
+     if (PointerType *PTy = dyn_cast<PointerType>(ExpandTy)) {
+-      const SCEV *const OffsetArray[1] = { PostLoopOffset };
+-      Result = expandAddToGEP(OffsetArray, OffsetArray+1, PTy, IntTy, Result);
++      if (Result->getType()->isIntegerTy()) {
++        Value *Base = expandCodeFor(PostLoopOffset, ExpandTy);
++        const SCEV *const OffsetArray[1] = {SE.getUnknown(Result)};
++        Result = expandAddToGEP(OffsetArray, OffsetArray + 1, PTy, IntTy, Base);
++      } else {
++        const SCEV *const OffsetArray[1] = {PostLoopOffset};
++        Result =
++            expandAddToGEP(OffsetArray, OffsetArray + 1, PTy, IntTy, Result);
++      }
+     } else {
+       Result = InsertNoopCastOfTo(Result, IntTy);
+       Result = Builder.CreateAdd(Result,
+diff --git a/test/Transforms/LoopStrengthReduce/nonintegral.ll b/test/Transforms/LoopStrengthReduce/nonintegral.ll
+new file mode 100644
+index 00000000000..5648e3aa74a
+--- /dev/null
++++ b/test/Transforms/LoopStrengthReduce/nonintegral.ll
+@@ -0,0 +1,45 @@
++; RUN: opt -S -loop-reduce < %s | FileCheck %s
++
++; Address Space 10 is non-integral. The optimizer is not allowed to use
++; ptrtoint/inttoptr instructions. Make sure that this doesn't happen
++target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128-ni:10:11:12"
++target triple = "x86_64-unknown-linux-gnu"
++
++define void @japi1__unsafe_getindex_65028(i64 addrspace(10)* %arg) {
++; CHECK-NOT: inttoptr
++; CHECK-NOT: ptrtoint
++; How exactly SCEV chooses to materialize isn't all that important, as
++; long as it doesn't try to round-trip through integers. As of this writing,
++; it emits a byte-wise gep, which is fine.
++; CHECK: getelementptr i64, i64 addrspace(10)* {{.*}}, i64 {{.*}}
++top:
++  br label %L86
++
++L86:                                              ; preds = %L86, %top
++  %i.0 = phi i64 [ 0, %top ], [ %tmp, %L86 ]
++  %tmp = add i64 %i.0, 1
++  br i1 undef, label %L86, label %if29
++
++if29:                                             ; preds = %L86
++  %tmp1 = shl i64 %tmp, 1
++  %tmp2 = add i64 %tmp1, -2
++  br label %if31
++
++if31:                                             ; preds = %if38, %if29
++  %"#temp#1.sroa.0.022" = phi i64 [ 0, %if29 ], [ %tmp3, %if38 ]
++  br label %L119
++
++L119:                                             ; preds = %L119, %if31
++  %i5.0 = phi i64 [ %"#temp#1.sroa.0.022", %if31 ], [ %tmp3, %L119 ]
++  %tmp3 = add i64 %i5.0, 1
++  br i1 undef, label %L119, label %if38
++
++if38:                                             ; preds = %L119
++  %tmp4 = add i64 %tmp2, %i5.0
++  %tmp5 = getelementptr i64, i64 addrspace(10)* %arg, i64 %tmp4
++  %tmp6 = load i64, i64 addrspace(10)* %tmp5
++  br i1 undef, label %done, label %if31
++
++done:                                             ; preds = %if38
++  ret void
++}
+diff --git a/unittests/Analysis/ScalarEvolutionTest.cpp b/unittests/Analysis/ScalarEvolutionTest.cpp
+index f4370842edb..1af241fdfbe 100644
+--- a/unittests/Analysis/ScalarEvolutionTest.cpp
++++ b/unittests/Analysis/ScalarEvolutionTest.cpp
+@@ -7,21 +7,22 @@
+ //
+ //===----------------------------------------------------------------------===//
+ 
+-#include "llvm/Analysis/ScalarEvolutionExpander.h"
+-#include "llvm/Analysis/ScalarEvolutionExpressions.h"
++#include "llvm/ADT/SmallVector.h"
+ #include "llvm/Analysis/AssumptionCache.h"
+ #include "llvm/Analysis/LoopInfo.h"
+-#include "llvm/Analysis/TargetLibraryInfo.h"
+-#include "llvm/ADT/SmallVector.h"
+ #include "llvm/Analysis/LoopInfo.h"
++#include "llvm/Analysis/ScalarEvolutionExpander.h"
++#include "llvm/Analysis/ScalarEvolutionExpressions.h"
++#include "llvm/Analysis/TargetLibraryInfo.h"
+ #include "llvm/AsmParser/Parser.h"
+ #include "llvm/IR/Constants.h"
+ #include "llvm/IR/Dominators.h"
+ #include "llvm/IR/GlobalVariable.h"
++#include "llvm/IR/IRBuilder.h"
+ #include "llvm/IR/InstIterator.h"
+ #include "llvm/IR/LLVMContext.h"
+-#include "llvm/IR/Module.h"
+ #include "llvm/IR/LegacyPassManager.h"
++#include "llvm/IR/Module.h"
+ #include "llvm/IR/Verifier.h"
+ #include "llvm/Support/SourceMgr.h"
+ #include "gtest/gtest.h"
+-- 
+2.13.1
+
diff --git a/deps/patches/llvm-D33179.patch b/deps/patches/llvm-D33179.patch
new file mode 100644
index 00000000000000..2be915018de240
--- /dev/null
+++ b/deps/patches/llvm-D33179.patch
@@ -0,0 +1,64 @@
+From b1a005ba688397ca360e89cd6c6f51f232d6c25e Mon Sep 17 00:00:00 2001
+From: Keno Fischer <keno@juliacomputing.com>
+Date: Fri, 19 May 2017 18:42:20 -0400
+Subject: [PATCH] [Sink] Fix predicate in legality check
+
+Summary:
+isSafeToSpeculativelyExecute is the wrong predicate to use here.
+All that checks for is whether it is safe to hoist a value due to
+unaligned/un-dereferencable accesses. However, not only are we doing
+sinking rather than hoisting, our concern is that the location
+we're loading from may have been modified. Instead forbid sinking
+any load across a critical edge.
+
+Reviewers: majnemer
+
+Subscribers: llvm-commits
+
+Differential Revision: https://reviews.llvm.org/D33179
+---
+ lib/Transforms/Scalar/Sink.cpp      |  2 +-
+ test/Transforms/Sink/badloadsink.ll | 18 ++++++++++++++++++
+ 2 files changed, 19 insertions(+), 1 deletion(-)
+ create mode 100644 test/Transforms/Sink/badloadsink.ll
+
+diff --git a/lib/Transforms/Scalar/Sink.cpp b/lib/Transforms/Scalar/Sink.cpp
+index 102e9ea..5210f16 100644
+--- a/lib/Transforms/Scalar/Sink.cpp
++++ b/lib/Transforms/Scalar/Sink.cpp
+@@ -114,7 +114,7 @@ static bool IsAcceptableTarget(Instruction *Inst, BasicBlock *SuccToSinkTo,
+   if (SuccToSinkTo->getUniquePredecessor() != Inst->getParent()) {
+     // We cannot sink a load across a critical edge - there may be stores in
+     // other code paths.
+-    if (!isSafeToSpeculativelyExecute(Inst))
++    if (isa<LoadInst>(Inst))
+       return false;
+ 
+     // We don't want to sink across a critical edge if we don't dominate the
+diff --git a/test/Transforms/Sink/badloadsink.ll b/test/Transforms/Sink/badloadsink.ll
+new file mode 100644
+index 0000000..e3f4884
+--- /dev/null
++++ b/test/Transforms/Sink/badloadsink.ll
+@@ -0,0 +1,18 @@
++; RUN: opt < %s -basicaa -sink -S | FileCheck %s
++declare void @foo(i64 *)
++define i64 @sinkload(i1 %cmp) {
++; CHECK-LABEL: @sinkload
++top:
++    %a = alloca i64
++; CHECK: call void @foo(i64* %a)
++; CHECK-NEXT: %x = load i64, i64* %a
++    call void @foo(i64* %a)
++    %x = load i64, i64* %a
++    br i1 %cmp, label %A, label %B
++A:
++    store i64 0, i64 *%a
++    br label %B
++B:
++; CHECK-NOT: load i64, i64 *%a
++    ret i64 %x
++}
+-- 
+2.9.3
+
diff --git a/deps/patches/llvm-PR26180.patch b/deps/patches/llvm-PR26180.patch
deleted file mode 100644
index 69c545fd40a716..00000000000000
--- a/deps/patches/llvm-PR26180.patch
+++ /dev/null
@@ -1,93 +0,0 @@
-From 9411e53a301704bc48271641c0388b022006e0c7 Mon Sep 17 00:00:00 2001
-From: Nemanja Ivanovic <nemanja.i.ibm@gmail.com>
-Date: Mon, 29 Feb 2016 16:42:27 +0000
-Subject: [PATCH] Fix for PR26180
-
-Corresponds to Phabricator review:
-http://reviews.llvm.org/D16592
-
-This fix includes both an update to how we handle the "generic" CPU on LE
-systems as well as Anton's fix for the Fast Isel issue.
-
-
-git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@262233 91177308-0d34-0410-b5e6-96231b3b80d8
----
- lib/Target/PowerPC/PPCFastISel.cpp     |  6 +++---
- lib/Target/PowerPC/PPCISelLowering.cpp |  4 ++--
- lib/Target/PowerPC/PPCSubtarget.cpp    |  2 +-
- test/CodeGen/PowerPC/pr26180.ll        | 14 ++++++++++++++
- 4 files changed, 20 insertions(+), 6 deletions(-)
- create mode 100644 test/CodeGen/PowerPC/pr26180.ll
-
-diff --git a/lib/Target/PowerPC/PPCFastISel.cpp b/lib/Target/PowerPC/PPCFastISel.cpp
-index 3980ecf..1de2679 100644
---- a/lib/Target/PowerPC/PPCFastISel.cpp
-+++ b/lib/Target/PowerPC/PPCFastISel.cpp
-@@ -1068,10 +1068,10 @@ unsigned PPCFastISel::PPCMoveToIntReg(const Instruction *I, MVT VT,
-   if (!PPCEmitStore(MVT::f64, SrcReg, Addr))
-     return 0;
- 
--  // Reload it into a GPR.  If we want an i32, modify the address
--  // to have a 4-byte offset so we load from the right place.
-+  // Reload it into a GPR.  If we want an i32 on big endian, modify the
-+  // address to have a 4-byte offset so we load from the right place.
-   if (VT == MVT::i32)
--    Addr.Offset = 4;
-+    Addr.Offset = (PPCSubTarget->isLittleEndian()) ? 0 : 4;
- 
-   // Look at the currently assigned register for this instruction
-   // to determine the required register class.
-diff --git a/lib/Target/PowerPC/PPCISelLowering.cpp b/lib/Target/PowerPC/PPCISelLowering.cpp
-index 59086f1..3fe7cf3 100644
---- a/lib/Target/PowerPC/PPCISelLowering.cpp
-+++ b/lib/Target/PowerPC/PPCISelLowering.cpp
-@@ -6163,11 +6163,11 @@ void PPCTargetLowering::LowerFP_TO_INTForReuse(SDValue Op, ReuseLoadInfo &RLI,
-                          MPI, false, false, 0);
- 
-   // Result is a load from the stack slot.  If loading 4 bytes, make sure to
--  // add in a bias.
-+  // add in a bias on big endian.
-   if (Op.getValueType() == MVT::i32 && !i32Stack) {
-     FIPtr = DAG.getNode(ISD::ADD, dl, FIPtr.getValueType(), FIPtr,
-                         DAG.getConstant(4, dl, FIPtr.getValueType()));
--    MPI = MPI.getWithOffset(4);
-+    MPI = MPI.getWithOffset(Subtarget.isLittleEndian() ? 0 : 4);
-   }
- 
-   RLI.Chain = Chain;
-diff --git a/lib/Target/PowerPC/PPCSubtarget.cpp b/lib/Target/PowerPC/PPCSubtarget.cpp
-index c357c75..359c2eb 100644
---- a/lib/Target/PowerPC/PPCSubtarget.cpp
-+++ b/lib/Target/PowerPC/PPCSubtarget.cpp
-@@ -110,7 +110,7 @@ void PPCSubtarget::initializeEnvironment() {
- void PPCSubtarget::initSubtargetFeatures(StringRef CPU, StringRef FS) {
-   // Determine default and user specified characteristics
-   std::string CPUName = CPU;
--  if (CPUName.empty()) {
-+  if (CPUName.empty() || CPU == "generic") {
-     // If cross-compiling with -march=ppc64le without -mcpu
-     if (TargetTriple.getArch() == Triple::ppc64le)
-       CPUName = "ppc64le";
-diff --git a/test/CodeGen/PowerPC/pr26180.ll b/test/CodeGen/PowerPC/pr26180.ll
-new file mode 100644
-index 0000000..e4cbcb8
---- /dev/null
-+++ b/test/CodeGen/PowerPC/pr26180.ll
-@@ -0,0 +1,14 @@
-+; RUN: llc -mcpu=generic -mtriple=powerpc64le-unknown-unknown -O0 < %s | FileCheck %s --check-prefix=GENERIC
-+; RUN: llc -mcpu=ppc -mtriple=powerpc64le-unknown-unknown -O0 < %s | FileCheck %s
-+
-+define i32 @bad(double %x) {
-+  %1 = fptoui double %x to i32
-+  ret i32 %1
-+}
-+
-+; CHECK: fctidz 1, 1
-+; CHECK: stfd 1, [[OFF:.*]](1)
-+; CHECK: lwz {{[0-9]*}}, [[OFF]](1)
-+; GENERIC: fctiwuz 1, 1
-+; GENERIC: stfd 1, [[OFF:.*]](1)
-+; GENERIC: lwz {{[0-9]*}}, [[OFF]](1)
--- 
-2.7.4
-
diff --git a/deps/patches/llvm-PR27046.patch b/deps/patches/llvm-PR27046.patch
deleted file mode 100644
index f59556ffd0bbb9..00000000000000
--- a/deps/patches/llvm-PR27046.patch
+++ /dev/null
@@ -1,70 +0,0 @@
-From 18569e85b3d63024d522b732f3a5694eda5f9110 Mon Sep 17 00:00:00 2001
-From: Chuang-Yu Cheng <cycheng@multicorewareinc.com>
-Date: Tue, 12 Apr 2016 03:10:52 +0000
-Subject: [PATCH] [PPC64] Mark CR0 Live if PPCInstrInfo::optimizeCompareInstr
- Creates a Use of CR0
-
-Resolve Bug 27046 (https://llvm.org/bugs/show_bug.cgi?id=27046).
-The PPCInstrInfo::optimizeCompareInstr function could create a new use of
-CR0, even if CR0 were previously dead. This patch marks CR0 live if a use of
-CR0 is created.
-
-Author: Tom Jablin (tjablin)
-Reviewers: hfinkel kbarton cycheng
-
-http://reviews.llvm.org/D18884
-
-git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@266040 91177308-0d34-0410-b5e6-96231b3b80d8
----
- lib/Target/PowerPC/PPCInstrInfo.cpp           |  4 ++++
- test/CodeGen/PowerPC/opt-cmp-inst-cr0-live.ll | 23 +++++++++++++++++++++++
- 2 files changed, 27 insertions(+)
- create mode 100644 test/CodeGen/PowerPC/opt-cmp-inst-cr0-live.ll
-
-diff --git a/lib/Target/PowerPC/PPCInstrInfo.cpp b/lib/Target/PowerPC/PPCInstrInfo.cpp
-index 76f97b1..b6dc00f 100644
---- a/lib/Target/PowerPC/PPCInstrInfo.cpp
-+++ b/lib/Target/PowerPC/PPCInstrInfo.cpp
-@@ -1763,6 +1763,10 @@ bool PPCInstrInfo::optimizeCompareInstr(MachineInstr *CmpInstr,
-           get(TargetOpcode::COPY), CRReg)
-     .addReg(PPC::CR0, MIOpC != NewOpC ? RegState::Kill : 0);
- 
-+  // Even if CR0 register were dead before, it is alive now since the
-+  // instruction we just built uses it.
-+  MI->clearRegisterDeads(PPC::CR0);
-+
-   if (MIOpC != NewOpC) {
-     // We need to be careful here: we're replacing one instruction with
-     // another, and we need to make sure that we get all of the right
-diff --git a/test/CodeGen/PowerPC/opt-cmp-inst-cr0-live.ll b/test/CodeGen/PowerPC/opt-cmp-inst-cr0-live.ll
-new file mode 100644
-index 0000000..3c38209
---- /dev/null
-+++ b/test/CodeGen/PowerPC/opt-cmp-inst-cr0-live.ll
-@@ -0,0 +1,23 @@
-+; RUN: llc -print-before=peephole-opts -print-after=peephole-opts -mtriple=powerpc64-unknown-linux-gnu -o /dev/null 2>&1 < %s | FileCheck %s
-+
-+define signext i32 @fn1(i32 %baz) {
-+  %1 = mul nsw i32 %baz, 208
-+  %2 = zext i32 %1 to i64
-+  %3 = shl i64 %2, 48
-+  %4 = ashr exact i64 %3, 48
-+; CHECK: ANDIo8 {{[^,]+}}, 65520, %CR0<imp-def,dead>;
-+; CHECK: CMPLDI
-+; CHECK: BCC
-+
-+; CHECK: ANDIo8 {{[^,]+}}, 65520, %CR0<imp-def>;
-+; CHECK: COPY %CR0
-+; CHECK: BCC
-+  %5 = icmp eq i64 %4, 0
-+  br i1 %5, label %foo, label %bar
-+
-+foo:
-+  ret i32 1
-+
-+bar:
-+  ret i32 0
-+}
--- 
-2.7.4
-
diff --git a/deps/patches/llvm-PR276266.patch b/deps/patches/llvm-PR276266.patch
new file mode 100644
index 00000000000000..576e96e5836d36
--- /dev/null
+++ b/deps/patches/llvm-PR276266.patch
@@ -0,0 +1,51 @@
+From 64d1e8b748bca22ce205eab7634cc5418c827f18 Mon Sep 17 00:00:00 2001
+From: Marina Yatsina <marina.yatsina@intel.com>
+Date: Thu, 21 Jul 2016 12:37:07 +0000
+Subject: [PATCH 3/5] ExecutionDepsFix - Fix bug in clearance calculation
+
+The clearance calculation did not take into account registers defined as outputs or clobbers in inline assembly machine instructions because these register defs are implicit.
+
+Differential Revision: http://reviews.llvm.org/D22580
+
+
+
+git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@276266 91177308-0d34-0410-b5e6-96231b3b80d8
+---
+ lib/CodeGen/ExecutionDepsFix.cpp    |  2 --
+ test/CodeGen/X86/break-false-dep.ll | 10 ++++++++++
+ 2 files changed, 10 insertions(+), 2 deletions(-)
+
+diff --git a/lib/CodeGen/ExecutionDepsFix.cpp b/lib/CodeGen/ExecutionDepsFix.cpp
+index 566b8d507b2..1fe5f459b69 100644
+--- a/lib/CodeGen/ExecutionDepsFix.cpp
++++ b/lib/CodeGen/ExecutionDepsFix.cpp
+@@ -520,8 +520,6 @@ void ExeDepsFix::processDefs(MachineInstr *MI, bool Kill) {
+     MachineOperand &MO = MI->getOperand(i);
+     if (!MO.isReg())
+       continue;
+-    if (MO.isImplicit())
+-      break;
+     if (MO.isUse())
+       continue;
+     for (int rx : regIndices(MO.getReg())) {
+diff --git a/test/CodeGen/X86/break-false-dep.ll b/test/CodeGen/X86/break-false-dep.ll
+index 74a0728f918..a7cda499dab 100644
+--- a/test/CodeGen/X86/break-false-dep.ll
++++ b/test/CodeGen/X86/break-false-dep.ll
+@@ -199,3 +199,13 @@ for.end16:                                        ; preds = %for.inc14
+ ;AVX-NEXT: vmulsd {{.*}}, [[XMM0]], [[XMM0]]
+ ;AVX-NEXT: vmovsd [[XMM0]],
+ }
++
++define double @inlineasmdep(i64 %arg) {
++top:
++  tail call void asm sideeffect "", "~{xmm0},~{dirflag},~{fpsr},~{flags}"()
++  %tmp1 = sitofp i64 %arg to double
++  ret double %tmp1
++;AVX-LABEL:@inlineasmdep
++;AVX: vxorps  [[XMM0:%xmm[0-9]+]], [[XMM0]], [[XMM0]]
++;AVX-NEXT: vcvtsi2sdq {{.*}}, [[XMM0]], {{%xmm[0-9]+}}
++}
+-- 
+2.11.0
+
diff --git a/deps/patches/llvm-PR277939.patch b/deps/patches/llvm-PR277939.patch
new file mode 100644
index 00000000000000..65e46c32b4848e
--- /dev/null
+++ b/deps/patches/llvm-PR277939.patch
@@ -0,0 +1,169 @@
+From 9790ab8bccdbc71dfcc166860ab6ce9c369bf686 Mon Sep 17 00:00:00 2001
+From: Simon Pilgrim <llvm-dev@redking.me.uk>
+Date: Sat, 6 Aug 2016 21:21:12 +0000
+Subject: [PATCH 1/5] [X86][AVX2] Improve sign/zero extension on AVX2 targets
+
+Split extensions to large vectors into 256-bit chunks - the equivalent of what we do with pre-AVX2 into 128-bit chunks
+
+git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@277939 91177308-0d34-0410-b5e6-96231b3b80d8
+---
+ lib/Target/X86/X86ISelLowering.cpp | 22 +++++++++++++++-------
+ test/CodeGen/X86/vec_int_to_fp.ll  | 24 ++++++++----------------
+ test/CodeGen/X86/vector-sext.ll    | 10 ++--------
+ 3 files changed, 25 insertions(+), 31 deletions(-)
+
+diff --git a/lib/Target/X86/X86ISelLowering.cpp b/lib/Target/X86/X86ISelLowering.cpp
+index ca205335013..2bbedd4bd97 100644
+--- a/lib/Target/X86/X86ISelLowering.cpp
++++ b/lib/Target/X86/X86ISelLowering.cpp
+@@ -30164,11 +30164,9 @@ static SDValue combineToExtendVectorInReg(SDNode *N, SelectionDAG &DAG,
+                : DAG.getZeroExtendVectorInReg(ExOp, DL, VT);
+   }
+ 
+-  // On pre-AVX2 targets, split into 128-bit nodes of
+-  // ISD::*_EXTEND_VECTOR_INREG.
+-  if (!Subtarget.hasInt256() && !(VT.getSizeInBits() % 128)) {
+-    unsigned NumVecs = VT.getSizeInBits() / 128;
+-    unsigned NumSubElts = 128 / SVT.getSizeInBits();
++  auto SplitAndExtendInReg = [&](unsigned SplitSize) {
++    unsigned NumVecs = VT.getSizeInBits() / SplitSize;
++    unsigned NumSubElts = SplitSize / SVT.getSizeInBits();
+     EVT SubVT = EVT::getVectorVT(*DAG.getContext(), SVT, NumSubElts);
+     EVT InSubVT = EVT::getVectorVT(*DAG.getContext(), InSVT, NumSubElts);
+ 
+@@ -30176,14 +30174,24 @@ static SDValue combineToExtendVectorInReg(SDNode *N, SelectionDAG &DAG,
+     for (unsigned i = 0, Offset = 0; i != NumVecs; ++i, Offset += NumSubElts) {
+       SDValue SrcVec = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, InSubVT, N0,
+                                    DAG.getIntPtrConstant(Offset, DL));
+-      SrcVec = ExtendVecSize(DL, SrcVec, 128);
++      SrcVec = ExtendVecSize(DL, SrcVec, SplitSize);
+       SrcVec = Opcode == ISD::SIGN_EXTEND
+                    ? DAG.getSignExtendVectorInReg(SrcVec, DL, SubVT)
+                    : DAG.getZeroExtendVectorInReg(SrcVec, DL, SubVT);
+       Opnds.push_back(SrcVec);
+     }
+     return DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, Opnds);
+-  }
++  };
++
++  // On pre-AVX2 targets, split into 128-bit nodes of
++  // ISD::*_EXTEND_VECTOR_INREG.
++  if (!Subtarget.hasInt256() && !(VT.getSizeInBits() % 128))
++    return SplitAndExtendInReg(128);
++
++  // On pre-AVX512 targets, split into 256-bit nodes of
++  // ISD::*_EXTEND_VECTOR_INREG.
++  if (!Subtarget.hasAVX512() && !(VT.getSizeInBits() % 256))
++    return SplitAndExtendInReg(256);
+ 
+   return SDValue();
+ }
+diff --git a/test/CodeGen/X86/vec_int_to_fp.ll b/test/CodeGen/X86/vec_int_to_fp.ll
+index 43f5318a607..5d8f91385c7 100644
+--- a/test/CodeGen/X86/vec_int_to_fp.ll
++++ b/test/CodeGen/X86/vec_int_to_fp.ll
+@@ -153,8 +153,7 @@ define <2 x double> @sitofp_16i8_to_2f64(<16 x i8> %a) {
+ ;
+ ; AVX2-LABEL: sitofp_16i8_to_2f64:
+ ; AVX2:       # BB#0:
+-; AVX2-NEXT:    vpmovsxbw %xmm0, %ymm0
+-; AVX2-NEXT:    vpmovsxwd %xmm0, %ymm0
++; AVX2-NEXT:    vpmovsxbd %xmm0, %ymm0
+ ; AVX2-NEXT:    vcvtdq2pd %xmm0, %ymm0
+ ; AVX2-NEXT:    # kill
+ ; AVX2-NEXT:    vzeroupper
+@@ -325,8 +324,7 @@ define <4 x double> @sitofp_16i8_to_4f64(<16 x i8> %a) {
+ ;
+ ; AVX2-LABEL: sitofp_16i8_to_4f64:
+ ; AVX2:       # BB#0:
+-; AVX2-NEXT:    vpmovsxbw %xmm0, %ymm0
+-; AVX2-NEXT:    vpmovsxwd %xmm0, %ymm0
++; AVX2-NEXT:    vpmovsxbd %xmm0, %ymm0
+ ; AVX2-NEXT:    vcvtdq2pd %xmm0, %ymm0
+ ; AVX2-NEXT:    retq
+   %cvt = sitofp <16 x i8> %a to <16 x double>
+@@ -543,8 +541,7 @@ define <2 x double> @uitofp_16i8_to_2f64(<16 x i8> %a) {
+ ;
+ ; AVX2-LABEL: uitofp_16i8_to_2f64:
+ ; AVX2:       # BB#0:
+-; AVX2-NEXT:    vpmovzxbw {{.*#+}} ymm0 = xmm0[0],zero,xmm0[1],zero,xmm0[2],zero,xmm0[3],zero,xmm0[4],zero,xmm0[5],zero,xmm0[6],zero,xmm0[7],zero,xmm0[8],zero,xmm0[9],zero,xmm0[10],zero,xmm0[11],zero,xmm0[12],zero,xmm0[13],zero,xmm0[14],zero,xmm0[15],zero
+-; AVX2-NEXT:    vpmovzxwd {{.*#+}} ymm0 = xmm0[0],zero,xmm0[1],zero,xmm0[2],zero,xmm0[3],zero,xmm0[4],zero,xmm0[5],zero,xmm0[6],zero,xmm0[7],zero
++; AVX2-NEXT:    vpmovzxbd {{.*#+}} ymm0 = xmm0[0],zero,zero,zero,xmm0[1],zero,zero,zero,xmm0[2],zero,zero,zero,xmm0[3],zero,zero,zero,xmm0[4],zero,zero,zero,xmm0[5],zero,zero,zero,xmm0[6],zero,zero,zero,xmm0[7],zero,zero,zero
+ ; AVX2-NEXT:    vcvtdq2pd %xmm0, %ymm0
+ ; AVX2-NEXT:    # kill
+ ; AVX2-NEXT:    vzeroupper
+@@ -778,8 +775,7 @@ define <4 x double> @uitofp_16i8_to_4f64(<16 x i8> %a) {
+ ;
+ ; AVX2-LABEL: uitofp_16i8_to_4f64:
+ ; AVX2:       # BB#0:
+-; AVX2-NEXT:    vpmovzxbw {{.*#+}} ymm0 = xmm0[0],zero,xmm0[1],zero,xmm0[2],zero,xmm0[3],zero,xmm0[4],zero,xmm0[5],zero,xmm0[6],zero,xmm0[7],zero,xmm0[8],zero,xmm0[9],zero,xmm0[10],zero,xmm0[11],zero,xmm0[12],zero,xmm0[13],zero,xmm0[14],zero,xmm0[15],zero
+-; AVX2-NEXT:    vpmovzxwd {{.*#+}} ymm0 = xmm0[0],zero,xmm0[1],zero,xmm0[2],zero,xmm0[3],zero,xmm0[4],zero,xmm0[5],zero,xmm0[6],zero,xmm0[7],zero
++; AVX2-NEXT:    vpmovzxbd {{.*#+}} ymm0 = xmm0[0],zero,zero,zero,xmm0[1],zero,zero,zero,xmm0[2],zero,zero,zero,xmm0[3],zero,zero,zero,xmm0[4],zero,zero,zero,xmm0[5],zero,zero,zero,xmm0[6],zero,zero,zero,xmm0[7],zero,zero,zero
+ ; AVX2-NEXT:    vcvtdq2pd %xmm0, %ymm0
+ ; AVX2-NEXT:    retq
+   %cvt = uitofp <16 x i8> %a to <16 x double>
+@@ -958,8 +954,7 @@ define <4 x float> @sitofp_16i8_to_4f32(<16 x i8> %a) {
+ ;
+ ; AVX2-LABEL: sitofp_16i8_to_4f32:
+ ; AVX2:       # BB#0:
+-; AVX2-NEXT:    vpmovsxbw %xmm0, %ymm0
+-; AVX2-NEXT:    vpmovsxwd %xmm0, %ymm0
++; AVX2-NEXT:    vpmovsxbd %xmm0, %ymm0
+ ; AVX2-NEXT:    vcvtdq2ps %ymm0, %ymm0
+ ; AVX2-NEXT:    # kill
+ ; AVX2-NEXT:    vzeroupper
+@@ -1134,8 +1129,7 @@ define <8 x float> @sitofp_16i8_to_8f32(<16 x i8> %a) {
+ ;
+ ; AVX2-LABEL: sitofp_16i8_to_8f32:
+ ; AVX2:       # BB#0:
+-; AVX2-NEXT:    vpmovsxbw %xmm0, %ymm0
+-; AVX2-NEXT:    vpmovsxwd %xmm0, %ymm0
++; AVX2-NEXT:    vpmovsxbd %xmm0, %ymm0
+ ; AVX2-NEXT:    vcvtdq2ps %ymm0, %ymm0
+ ; AVX2-NEXT:    retq
+   %cvt = sitofp <16 x i8> %a to <16 x float>
+@@ -1456,8 +1450,7 @@ define <4 x float> @uitofp_16i8_to_4f32(<16 x i8> %a) {
+ ;
+ ; AVX2-LABEL: uitofp_16i8_to_4f32:
+ ; AVX2:       # BB#0:
+-; AVX2-NEXT:    vpmovzxbw {{.*#+}} ymm0 = xmm0[0],zero,xmm0[1],zero,xmm0[2],zero,xmm0[3],zero,xmm0[4],zero,xmm0[5],zero,xmm0[6],zero,xmm0[7],zero,xmm0[8],zero,xmm0[9],zero,xmm0[10],zero,xmm0[11],zero,xmm0[12],zero,xmm0[13],zero,xmm0[14],zero,xmm0[15],zero
+-; AVX2-NEXT:    vpmovzxwd {{.*#+}} ymm0 = xmm0[0],zero,xmm0[1],zero,xmm0[2],zero,xmm0[3],zero,xmm0[4],zero,xmm0[5],zero,xmm0[6],zero,xmm0[7],zero
++; AVX2-NEXT:    vpmovzxbd {{.*#+}} ymm0 = xmm0[0],zero,zero,zero,xmm0[1],zero,zero,zero,xmm0[2],zero,zero,zero,xmm0[3],zero,zero,zero,xmm0[4],zero,zero,zero,xmm0[5],zero,zero,zero,xmm0[6],zero,zero,zero,xmm0[7],zero,zero,zero
+ ; AVX2-NEXT:    vcvtdq2ps %ymm0, %ymm0
+ ; AVX2-NEXT:    # kill
+ ; AVX2-NEXT:    vzeroupper
+@@ -1813,8 +1806,7 @@ define <8 x float> @uitofp_16i8_to_8f32(<16 x i8> %a) {
+ ;
+ ; AVX2-LABEL: uitofp_16i8_to_8f32:
+ ; AVX2:       # BB#0:
+-; AVX2-NEXT:    vpmovzxbw {{.*#+}} ymm0 = xmm0[0],zero,xmm0[1],zero,xmm0[2],zero,xmm0[3],zero,xmm0[4],zero,xmm0[5],zero,xmm0[6],zero,xmm0[7],zero,xmm0[8],zero,xmm0[9],zero,xmm0[10],zero,xmm0[11],zero,xmm0[12],zero,xmm0[13],zero,xmm0[14],zero,xmm0[15],zero
+-; AVX2-NEXT:    vpmovzxwd {{.*#+}} ymm0 = xmm0[0],zero,xmm0[1],zero,xmm0[2],zero,xmm0[3],zero,xmm0[4],zero,xmm0[5],zero,xmm0[6],zero,xmm0[7],zero
++; AVX2-NEXT:    vpmovzxbd {{.*#+}} ymm0 = xmm0[0],zero,zero,zero,xmm0[1],zero,zero,zero,xmm0[2],zero,zero,zero,xmm0[3],zero,zero,zero,xmm0[4],zero,zero,zero,xmm0[5],zero,zero,zero,xmm0[6],zero,zero,zero,xmm0[7],zero,zero,zero
+ ; AVX2-NEXT:    vcvtdq2ps %ymm0, %ymm0
+ ; AVX2-NEXT:    retq
+   %cvt = uitofp <16 x i8> %a to <16 x float>
+diff --git a/test/CodeGen/X86/vector-sext.ll b/test/CodeGen/X86/vector-sext.ll
+index 018c5922a43..e29f3e5f91f 100644
+--- a/test/CodeGen/X86/vector-sext.ll
++++ b/test/CodeGen/X86/vector-sext.ll
+@@ -407,15 +407,9 @@ define <8 x i64> @sext_16i8_to_8i64(<16 x i8> %A) nounwind uwtable readnone ssp
+ ;
+ ; AVX2-LABEL: sext_16i8_to_8i64:
+ ; AVX2:       # BB#0: # %entry
+-; AVX2-NEXT:    vpmovzxbd {{.*#+}} xmm1 = xmm0[0],zero,zero,zero,xmm0[1],zero,zero,zero,xmm0[2],zero,zero,zero,xmm0[3],zero,zero,zero
+-; AVX2-NEXT:    vpslld $24, %xmm1, %xmm1
+-; AVX2-NEXT:    vpsrad $24, %xmm1, %xmm1
+-; AVX2-NEXT:    vpmovsxdq %xmm1, %ymm2
++; AVX2-NEXT:    vpmovsxbq %xmm0, %ymm2
+ ; AVX2-NEXT:    vpshufd {{.*#+}} xmm0 = xmm0[1,1,2,3]
+-; AVX2-NEXT:    vpmovzxbd {{.*#+}} xmm0 = xmm0[0],zero,zero,zero,xmm0[1],zero,zero,zero,xmm0[2],zero,zero,zero,xmm0[3],zero,zero,zero
+-; AVX2-NEXT:    vpslld $24, %xmm0, %xmm0
+-; AVX2-NEXT:    vpsrad $24, %xmm0, %xmm0
+-; AVX2-NEXT:    vpmovsxdq %xmm0, %ymm1
++; AVX2-NEXT:    vpmovsxbq %xmm0, %ymm1
+ ; AVX2-NEXT:    vmovdqa %ymm2, %ymm0
+ ; AVX2-NEXT:    retq
+ ;
+-- 
+2.11.0
+
diff --git a/deps/patches/llvm-PR278088.patch b/deps/patches/llvm-PR278088.patch
new file mode 100644
index 00000000000000..325069326b3edf
--- /dev/null
+++ b/deps/patches/llvm-PR278088.patch
@@ -0,0 +1,224 @@
+From b01ff685400365f55c5333c29c2227842d61e984 Mon Sep 17 00:00:00 2001
+From: Craig Topper <craig.topper@gmail.com>
+Date: Tue, 9 Aug 2016 03:06:26 +0000
+Subject: [PATCH 2/5] [X86] Remove unnecessary bitcast from the front of
+ AVX1Only 256-bit logical operation patterns.
+
+git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@278088 91177308-0d34-0410-b5e6-96231b3b80d8
+---
+ lib/Target/X86/X86InstrSSE.td                   |  8 +++----
+ test/CodeGen/X86/WidenArith.ll                  |  2 +-
+ test/CodeGen/X86/merge-consecutive-loads-256.ll | 26 ++++++---------------
+ test/CodeGen/X86/v8i1-masks.ll                  |  4 ++--
+ test/CodeGen/X86/vec_int_to_fp.ll               | 30 ++++++++++++-------------
+ test/CodeGen/X86/vec_uint_to_fp-fastmath.ll     | 26 ++++++++++-----------
+ 6 files changed, 42 insertions(+), 54 deletions(-)
+
+diff --git a/lib/Target/X86/X86InstrSSE.td b/lib/Target/X86/X86InstrSSE.td
+index f91764a67d1..77da22de4d3 100644
+--- a/lib/Target/X86/X86InstrSSE.td
++++ b/lib/Target/X86/X86InstrSSE.td
+@@ -2950,13 +2950,13 @@ let isCommutable = 0 in
+ // AVX1 requires type coercions in order to fold loads directly into logical
+ // operations.
+ let Predicates = [HasAVX1Only] in {
+-  def : Pat<(bc_v8f32 (and VR256:$src1, (loadv4i64 addr:$src2))),
++  def : Pat<(and VR256:$src1, (loadv4i64 addr:$src2)),
+             (VANDPSYrm VR256:$src1, addr:$src2)>;
+-  def : Pat<(bc_v8f32 (or VR256:$src1, (loadv4i64 addr:$src2))),
++  def : Pat<(or VR256:$src1, (loadv4i64 addr:$src2)),
+             (VORPSYrm VR256:$src1, addr:$src2)>;
+-  def : Pat<(bc_v8f32 (xor VR256:$src1, (loadv4i64 addr:$src2))),
++  def : Pat<(xor VR256:$src1, (loadv4i64 addr:$src2)),
+             (VXORPSYrm VR256:$src1, addr:$src2)>;
+-  def : Pat<(bc_v8f32 (X86andnp VR256:$src1, (loadv4i64 addr:$src2))),
++  def : Pat<(X86andnp VR256:$src1, (loadv4i64 addr:$src2)),
+             (VANDNPSYrm VR256:$src1, addr:$src2)>;
+ }
+ 
+diff --git a/test/CodeGen/X86/WidenArith.ll b/test/CodeGen/X86/WidenArith.ll
+index cdd1a2818b2..cc5fcba6670 100644
+--- a/test/CodeGen/X86/WidenArith.ll
++++ b/test/CodeGen/X86/WidenArith.ll
+@@ -9,8 +9,8 @@ define <8 x i32> @test(<8 x float> %a, <8 x float> %b) {
+ ; CHECK-NEXT:    vsubps %ymm2, %ymm1, %ymm3
+ ; CHECK-NEXT:    vcmpltps %ymm1, %ymm0, %ymm0
+ ; CHECK-NEXT:    vcmpltps %ymm3, %ymm2, %ymm1
+-; CHECK-NEXT:    vandps {{.*}}(%rip), %ymm1, %ymm1
+ ; CHECK-NEXT:    vandps %ymm1, %ymm0, %ymm0
++; CHECK-NEXT:    vandps {{.*}}(%rip), %ymm0, %ymm0
+ ; CHECK-NEXT:    retq
+  %c1 = fadd <8 x float> %a, %b
+  %b1 = fmul <8 x float> %b, %a
+diff --git a/test/CodeGen/X86/merge-consecutive-loads-256.ll b/test/CodeGen/X86/merge-consecutive-loads-256.ll
+index 8c2e9372900..dc268d9bdf8 100644
+--- a/test/CodeGen/X86/merge-consecutive-loads-256.ll
++++ b/test/CodeGen/X86/merge-consecutive-loads-256.ll
+@@ -547,29 +547,17 @@ define <16 x i16> @merge_16i16_i16_0uu3uuuuuuuuCuEF(i16* %ptr) nounwind uwtable
+ }
+ 
+ define <16 x i16> @merge_16i16_i16_0uu3zzuuuuuzCuEF(i16* %ptr) nounwind uwtable noinline ssp {
+-; AVX1-LABEL: merge_16i16_i16_0uu3zzuuuuuzCuEF:
+-; AVX1:       # BB#0:
+-; AVX1-NEXT:    vmovaps {{.*#+}} ymm0 = [65535,0,0,65535,0,0,0,0,0,0,0,0,65535,0,65535,65535]
+-; AVX1-NEXT:    vandps (%rdi), %ymm0, %ymm0
+-; AVX1-NEXT:    retq
+-;
+-; AVX2-LABEL: merge_16i16_i16_0uu3zzuuuuuzCuEF:
+-; AVX2:       # BB#0:
+-; AVX2-NEXT:    vmovups (%rdi), %ymm0
+-; AVX2-NEXT:    vandps {{.*}}(%rip), %ymm0, %ymm0
+-; AVX2-NEXT:    retq
+-;
+-; AVX512F-LABEL: merge_16i16_i16_0uu3zzuuuuuzCuEF:
+-; AVX512F:       # BB#0:
+-; AVX512F-NEXT:    vmovups (%rdi), %ymm0
+-; AVX512F-NEXT:    vandps {{.*}}(%rip), %ymm0, %ymm0
+-; AVX512F-NEXT:    retq
++; AVX-LABEL: merge_16i16_i16_0uu3zzuuuuuzCuEF:
++; AVX:       # BB#0:
++; AVX-NEXT:    vmovups (%rdi), %ymm0
++; AVX-NEXT:    vandps {{.*}}(%rip), %ymm0, %ymm0
++; AVX-NEXT:    retq
+ ;
+ ; X32-AVX-LABEL: merge_16i16_i16_0uu3zzuuuuuzCuEF:
+ ; X32-AVX:       # BB#0:
+ ; X32-AVX-NEXT:    movl {{[0-9]+}}(%esp), %eax
+-; X32-AVX-NEXT:    vmovaps {{.*#+}} ymm0 = [65535,0,0,65535,0,0,0,0,0,0,0,0,65535,0,65535,65535]
+-; X32-AVX-NEXT:    vandps (%eax), %ymm0, %ymm0
++; X32-AVX-NEXT:    vmovups (%eax), %ymm0
++; X32-AVX-NEXT:    vandps {{\.LCPI.*}}, %ymm0, %ymm0
+ ; X32-AVX-NEXT:    retl
+   %ptr0 = getelementptr inbounds i16, i16* %ptr, i64 0
+   %ptr3 = getelementptr inbounds i16, i16* %ptr, i64 3
+diff --git a/test/CodeGen/X86/v8i1-masks.ll b/test/CodeGen/X86/v8i1-masks.ll
+index 0135832ad92..d5c31506e98 100644
+--- a/test/CodeGen/X86/v8i1-masks.ll
++++ b/test/CodeGen/X86/v8i1-masks.ll
+@@ -13,8 +13,8 @@ define void @and_masks(<8 x float>* %a, <8 x float>* %b, <8 x float>* %c) nounwi
+ ; X32-NEXT:    vcmpltps %ymm0, %ymm1, %ymm1
+ ; X32-NEXT:    vmovups (%eax), %ymm2
+ ; X32-NEXT:    vcmpltps %ymm0, %ymm2, %ymm0
+-; X32-NEXT:    vandps LCPI0_0, %ymm1, %ymm1
+ ; X32-NEXT:    vandps %ymm1, %ymm0, %ymm0
++; X32-NEXT:    vandps LCPI0_0, %ymm0, %ymm0
+ ; X32-NEXT:    vmovaps %ymm0, (%eax)
+ ; X32-NEXT:    vzeroupper
+ ; X32-NEXT:    retl
+@@ -26,8 +26,8 @@ define void @and_masks(<8 x float>* %a, <8 x float>* %b, <8 x float>* %c) nounwi
+ ; X64-NEXT:    vcmpltps %ymm0, %ymm1, %ymm1
+ ; X64-NEXT:    vmovups (%rdx), %ymm2
+ ; X64-NEXT:    vcmpltps %ymm0, %ymm2, %ymm0
+-; X64-NEXT:    vandps {{.*}}(%rip), %ymm1, %ymm1
+ ; X64-NEXT:    vandps %ymm1, %ymm0, %ymm0
++; X64-NEXT:    vandps {{.*}}(%rip), %ymm0, %ymm0
+ ; X64-NEXT:    vmovaps %ymm0, (%rax)
+ ; X64-NEXT:    vzeroupper
+ ; X64-NEXT:    retq
+diff --git a/test/CodeGen/X86/vec_int_to_fp.ll b/test/CodeGen/X86/vec_int_to_fp.ll
+index 5d8f91385c7..8ea7243664a 100644
+--- a/test/CodeGen/X86/vec_int_to_fp.ll
++++ b/test/CodeGen/X86/vec_int_to_fp.ll
+@@ -1694,15 +1694,15 @@ define <8 x float> @uitofp_8i32_to_8f32(<8 x i32> %a) {
+ ;
+ ; AVX1-LABEL: uitofp_8i32_to_8f32:
+ ; AVX1:       # BB#0:
+-; AVX1-NEXT:    vandps {{.*}}(%rip), %ymm0, %ymm1
++; AVX1-NEXT:    vpsrld $16, %xmm0, %xmm1
++; AVX1-NEXT:    vextractf128 $1, %ymm0, %xmm2
++; AVX1-NEXT:    vpsrld $16, %xmm2, %xmm2
++; AVX1-NEXT:    vinsertf128 $1, %xmm2, %ymm1, %ymm1
+ ; AVX1-NEXT:    vcvtdq2ps %ymm1, %ymm1
+-; AVX1-NEXT:    vpsrld $16, %xmm0, %xmm2
+-; AVX1-NEXT:    vextractf128 $1, %ymm0, %xmm0
+-; AVX1-NEXT:    vpsrld $16, %xmm0, %xmm0
+-; AVX1-NEXT:    vinsertf128 $1, %xmm0, %ymm2, %ymm0
++; AVX1-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm1
++; AVX1-NEXT:    vandps {{.*}}(%rip), %ymm0, %ymm0
+ ; AVX1-NEXT:    vcvtdq2ps %ymm0, %ymm0
+-; AVX1-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0
+-; AVX1-NEXT:    vaddps %ymm1, %ymm0, %ymm0
++; AVX1-NEXT:    vaddps %ymm0, %ymm1, %ymm0
+ ; AVX1-NEXT:    retq
+ ;
+ ; AVX2-LABEL: uitofp_8i32_to_8f32:
+@@ -3372,16 +3372,16 @@ define <8 x float> @uitofp_load_8i32_to_8f32(<8 x i32> *%a) {
+ ;
+ ; AVX1-LABEL: uitofp_load_8i32_to_8f32:
+ ; AVX1:       # BB#0:
+-; AVX1-NEXT:    vmovaps (%rdi), %ymm0
+-; AVX1-NEXT:    vandps {{.*}}(%rip), %ymm0, %ymm1
++; AVX1-NEXT:    vmovdqa (%rdi), %ymm0
++; AVX1-NEXT:    vpsrld $16, %xmm0, %xmm1
++; AVX1-NEXT:    vextractf128 $1, %ymm0, %xmm2
++; AVX1-NEXT:    vpsrld $16, %xmm2, %xmm2
++; AVX1-NEXT:    vinsertf128 $1, %xmm2, %ymm1, %ymm1
+ ; AVX1-NEXT:    vcvtdq2ps %ymm1, %ymm1
+-; AVX1-NEXT:    vpsrld $16, %xmm0, %xmm2
+-; AVX1-NEXT:    vextractf128 $1, %ymm0, %xmm0
+-; AVX1-NEXT:    vpsrld $16, %xmm0, %xmm0
+-; AVX1-NEXT:    vinsertf128 $1, %xmm0, %ymm2, %ymm0
++; AVX1-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm1
++; AVX1-NEXT:    vandps {{.*}}(%rip), %ymm0, %ymm0
+ ; AVX1-NEXT:    vcvtdq2ps %ymm0, %ymm0
+-; AVX1-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0
+-; AVX1-NEXT:    vaddps %ymm1, %ymm0, %ymm0
++; AVX1-NEXT:    vaddps %ymm0, %ymm1, %ymm0
+ ; AVX1-NEXT:    retq
+ ;
+ ; AVX2-LABEL: uitofp_load_8i32_to_8f32:
+diff --git a/test/CodeGen/X86/vec_uint_to_fp-fastmath.ll b/test/CodeGen/X86/vec_uint_to_fp-fastmath.ll
+index c0e02bd1599..cb8e2096585 100644
+--- a/test/CodeGen/X86/vec_uint_to_fp-fastmath.ll
++++ b/test/CodeGen/X86/vec_uint_to_fp-fastmath.ll
+@@ -78,18 +78,18 @@ define <4 x float> @test_uitofp_v4i32_to_v4f32(<4 x i32> %arg) {
+   ret <4 x float> %tmp
+ }
+ 
+-; AVX: [[MASKCSTADDR_v8:.LCPI[0-9_]+]]:
+-; AVX-NEXT: .long 65535 # 0xffff
+-; AVX-NEXT: .long 65535 # 0xffff
+-; AVX-NEXT: .long 65535 # 0xffff
+-; AVX-NEXT: .long 65535 # 0xffff
+-
+ ; AVX: [[FPMASKCSTADDR_v8:.LCPI[0-9_]+]]:
+ ; AVX-NEXT: .long 1199570944 # float 65536
+ ; AVX-NEXT: .long 1199570944 # float 65536
+ ; AVX-NEXT: .long 1199570944 # float 65536
+ ; AVX-NEXT: .long 1199570944 # float 65536
+ 
++; AVX: [[MASKCSTADDR_v8:.LCPI[0-9_]+]]:
++; AVX-NEXT: .long 65535 # 0xffff
++; AVX-NEXT: .long 65535 # 0xffff
++; AVX-NEXT: .long 65535 # 0xffff
++; AVX-NEXT: .long 65535 # 0xffff
++
+ ; AVX2: [[FPMASKCSTADDR_v8:.LCPI[0-9_]+]]:
+ ; AVX2-NEXT: .long 1199570944 # float 65536
+ 
+@@ -119,15 +119,15 @@ define <8 x float> @test_uitofp_v8i32_to_v8f32(<8 x i32> %arg) {
+ ;
+ ; AVX-LABEL: test_uitofp_v8i32_to_v8f32:
+ ; AVX:       # BB#0:
+-; AVX-NEXT:    vandps [[MASKCSTADDR_v8]](%rip), %ymm0, %ymm1
++; AVX-NEXT:    vpsrld $16, %xmm0, %xmm1
++; AVX-NEXT:    vextractf128 $1, %ymm0, %xmm2
++; AVX-NEXT:    vpsrld $16, %xmm2, %xmm2
++; AVX-NEXT:    vinsertf128 $1, %xmm2, %ymm1, %ymm1
+ ; AVX-NEXT:    vcvtdq2ps %ymm1, %ymm1
+-; AVX-NEXT:    vpsrld $16, %xmm0, %xmm2
+-; AVX-NEXT:    vextractf128 $1, %ymm0, %xmm0
+-; AVX-NEXT:    vpsrld $16, %xmm0, %xmm0
+-; AVX-NEXT:    vinsertf128 $1, %xmm0, %ymm2, %ymm0
++; AVX-NEXT:    vmulps [[FPMASKCSTADDR_v8]](%rip), %ymm1, %ymm1
++; AVX-NEXT:    vandps [[MASKCSTADDR_v8]](%rip), %ymm0, %ymm0
+ ; AVX-NEXT:    vcvtdq2ps %ymm0, %ymm0
+-; AVX-NEXT:    vmulps [[FPMASKCSTADDR_v8]](%rip), %ymm0, %ymm0
+-; AVX-NEXT:    vaddps %ymm1, %ymm0, %ymm0
++; AVX-NEXT:    vaddps %ymm0, %ymm1, %ymm0
+ ; AVX-NEXT:    retq
+ ;
+ ; AVX2-LABEL: test_uitofp_v8i32_to_v8f32:
+-- 
+2.11.0
+
diff --git a/deps/patches/llvm-PR278321.patch b/deps/patches/llvm-PR278321.patch
new file mode 100644
index 00000000000000..709436536f01ad
--- /dev/null
+++ b/deps/patches/llvm-PR278321.patch
@@ -0,0 +1,1409 @@
+From a4ec9b3d6c2c53eb463284db0aa54158fad32701 Mon Sep 17 00:00:00 2001
+From: Marina Yatsina <marina.yatsina@intel.com>
+Date: Thu, 11 Aug 2016 07:32:08 +0000
+Subject: [PATCH 4/5] Avoid false dependencies of undef machine operands
+
+This patch helps avoid false dependencies on undef registers by updating the machine instructions' undef operand to use a register that the instruction is truly dependent on, or use a register with clearance higher than Pref.
+
+Pseudo example:
+
+loop:
+xmm0 = ...
+xmm1 = vcvtsi2sdl eax, xmm0<undef>
+... = inst xmm0
+jmp loop
+
+In this example, selecting xmm0 as the undef register creates false dependency between loop iterations.
+This false dependency cannot be solved by inserting an xor before vcvtsi2sdl because xmm0 is alive at the point of the vcvtsi2sdl instruction.
+Selecting a different register instead of xmm0, especially a register that is not used in the loop, will eliminate this problem.
+
+Differential Revision: https://reviews.llvm.org/D22466
+
+git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@278321 91177308-0d34-0410-b5e6-96231b3b80d8
+---
+ lib/CodeGen/ExecutionDepsFix.cpp     |  53 ++++
+ lib/Target/X86/X86InstrInfo.cpp      |   2 +-
+ test/CodeGen/X86/break-false-dep.ll  |  72 ++++-
+ test/CodeGen/X86/copy-propagation.ll |   3 +-
+ test/CodeGen/X86/half.ll             |   2 +-
+ test/CodeGen/X86/vec_int_to_fp.ll    | 579 ++++++++++++++++++++---------------
+ 6 files changed, 467 insertions(+), 244 deletions(-)
+
+diff --git a/lib/CodeGen/ExecutionDepsFix.cpp b/lib/CodeGen/ExecutionDepsFix.cpp
+index 1fe5f459b69..5f91db9251c 100644
+--- a/lib/CodeGen/ExecutionDepsFix.cpp
++++ b/lib/CodeGen/ExecutionDepsFix.cpp
+@@ -203,6 +203,8 @@ private:
+   void processDefs(MachineInstr*, bool Kill);
+   void visitSoftInstr(MachineInstr*, unsigned mask);
+   void visitHardInstr(MachineInstr*, unsigned domain);
++  void pickBestRegisterForUndef(MachineInstr *MI, unsigned OpIdx,
++                                unsigned Pref);
+   bool shouldBreakDependence(MachineInstr*, unsigned OpIdx, unsigned Pref);
+   void processUndefReads(MachineBasicBlock*);
+ };
+@@ -473,6 +475,56 @@ void ExeDepsFix::visitInstr(MachineInstr *MI) {
+   processDefs(MI, !DomP.first);
+ }
+ 
++/// \brief Helps avoid false dependencies on undef registers by updating the
++/// machine instructions' undef operand to use a register that the instruction
++/// is truly dependent on, or use a register with clearance higher than Pref.
++void ExeDepsFix::pickBestRegisterForUndef(MachineInstr *MI, unsigned OpIdx,
++                                          unsigned Pref) {
++  MachineOperand &MO = MI->getOperand(OpIdx);
++  assert(MO.isUndef() && "Expected undef machine operand");
++
++  unsigned OriginalReg = MO.getReg();
++
++  // Update only undef operands that are mapped to one register.
++  if (AliasMap[OriginalReg].size() != 1)
++    return;
++
++  // Get the undef operand's register class
++  const TargetRegisterClass *OpRC =
++      TII->getRegClass(MI->getDesc(), OpIdx, TRI, *MF);
++
++  // If the instruction has a true dependency, we can hide the false depdency
++  // behind it.
++  for (MachineOperand &CurrMO : MI->operands()) {
++    if (!CurrMO.isReg() || CurrMO.isDef() || CurrMO.isUndef() ||
++        !OpRC->contains(CurrMO.getReg()))
++      continue;
++    // We found a true dependency - replace the undef register with the true
++    // dependency.
++    MO.setReg(CurrMO.getReg());
++    return;
++  }
++
++  // Go over all registers in the register class and find the register with
++  // max clearance or clearance higher than Pref.
++  unsigned MaxClearance = 0;
++  unsigned MaxClearanceReg = OriginalReg;
++  for (unsigned rx = 0; rx < OpRC->getNumRegs(); ++rx) {
++    unsigned Clearance = CurInstr - LiveRegs[rx].Def;
++    if (Clearance <= MaxClearance)
++      continue;
++    MaxClearance = Clearance;
++    MaxClearanceReg = OpRC->getRegister(rx);
++
++    if (MaxClearance > Pref)
++      break;
++  }
++
++  // Update the operand if we found a register with better clearance.
++  if (MaxClearanceReg != OriginalReg)
++    MO.setReg(MaxClearanceReg);
++}
++
+ /// \brief Return true to if it makes sense to break dependence on a partial def
+ /// or undef use.
+ bool ExeDepsFix::shouldBreakDependence(MachineInstr *MI, unsigned OpIdx,
+@@ -510,6 +562,7 @@ void ExeDepsFix::processDefs(MachineInstr *MI, bool Kill) {
+   unsigned OpNum;
+   unsigned Pref = TII->getUndefRegClearance(*MI, OpNum, TRI);
+   if (Pref) {
++    pickBestRegisterForUndef(MI, OpNum, Pref);
+     if (shouldBreakDependence(MI, OpNum, Pref))
+       UndefReads.push_back(std::make_pair(MI, OpNum));
+   }
+diff --git a/lib/Target/X86/X86InstrInfo.cpp b/lib/Target/X86/X86InstrInfo.cpp
+index 5f0aab9ddc6..9bfe25973ae 100644
+--- a/lib/Target/X86/X86InstrInfo.cpp
++++ b/lib/Target/X86/X86InstrInfo.cpp
+@@ -68,7 +68,7 @@ static cl::opt<unsigned>
+ UndefRegClearance("undef-reg-clearance",
+                   cl::desc("How many idle instructions we would like before "
+                            "certain undef register reads"),
+-                  cl::init(64), cl::Hidden);
++                  cl::init(128), cl::Hidden);
+ 
+ enum {
+   // Select which memory operand is being unfolded.
+diff --git a/test/CodeGen/X86/break-false-dep.ll b/test/CodeGen/X86/break-false-dep.ll
+index a7cda499dab..4c5e747f9ca 100644
+--- a/test/CodeGen/X86/break-false-dep.ll
++++ b/test/CodeGen/X86/break-false-dep.ll
+@@ -126,6 +126,7 @@ loop:
+   %i = phi i64 [ 1, %entry ], [ %inc, %loop ]
+   %s1 = phi i64 [ %vx, %entry ], [ %s2, %loop ]
+   %fi = sitofp i64 %i to double
++  tail call void asm sideeffect "", "~{xmm0},~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{dirflag},~{fpsr},~{flags}"()
+   %vy = load double, double* %y
+   %fipy = fadd double %fi, %vy
+   %iipy = fptosi double %fipy to i64
+@@ -174,6 +175,7 @@ for.body3:
+   store double %mul11, double* %arrayidx13, align 8
+   %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
+   %exitcond = icmp eq i64 %indvars.iv.next, 1024
++  tail call void asm sideeffect "", "~{xmm0},~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{dirflag},~{fpsr},~{flags}"()
+   br i1 %exitcond, label %for.inc14, label %for.body3
+ 
+ for.inc14:                                        ; preds = %for.body3
+@@ -193,7 +195,7 @@ for.end16:                                        ; preds = %for.inc14
+ ;SSE-NEXT: movsd [[XMM0]],
+ ;AVX-LABEL:@loopdep3
+ ;AVX: vxorps [[XMM0:%xmm[0-9]+]], [[XMM0]]
+-;AVX-NEXT: vcvtsi2sdl {{.*}}, [[XMM0]], [[XMM0]]
++;AVX-NEXT: vcvtsi2sdl {{.*}}, [[XMM0]], {{%xmm[0-9]+}}
+ ;AVX-NEXT: vmulsd {{.*}}, [[XMM0]], [[XMM0]]
+ ;AVX-NEXT: vmulsd {{.*}}, [[XMM0]], [[XMM0]]
+ ;AVX-NEXT: vmulsd {{.*}}, [[XMM0]], [[XMM0]]
+@@ -202,10 +204,76 @@ for.end16:                                        ; preds = %for.inc14
+ 
+ define double @inlineasmdep(i64 %arg) {
+ top:
+-  tail call void asm sideeffect "", "~{xmm0},~{dirflag},~{fpsr},~{flags}"()
++  tail call void asm sideeffect "", "~{xmm0},~{xmm1},~{xmm2},~{xmm3},~{dirflag},~{fpsr},~{flags}"()
++  tail call void asm sideeffect "", "~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{dirflag},~{fpsr},~{flags}"()
++  tail call void asm sideeffect "", "~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{dirflag},~{fpsr},~{flags}"()
++  tail call void asm sideeffect "", "~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{dirflag},~{fpsr},~{flags}"()
+   %tmp1 = sitofp i64 %arg to double
+   ret double %tmp1
+ ;AVX-LABEL:@inlineasmdep
+ ;AVX: vxorps  [[XMM0:%xmm[0-9]+]], [[XMM0]], [[XMM0]]
+ ;AVX-NEXT: vcvtsi2sdq {{.*}}, [[XMM0]], {{%xmm[0-9]+}}
+ }
++
++; Make sure we are making a smart choice regarding undef registers and
++; hiding the false dependency behind a true dependency
++define double @truedeps(float %arg) {
++top:
++  tail call void asm sideeffect "", "~{xmm6},~{dirflag},~{fpsr},~{flags}"()
++  tail call void asm sideeffect "", "~{xmm0},~{xmm1},~{xmm2},~{xmm3},~{dirflag},~{fpsr},~{flags}"()
++  tail call void asm sideeffect "", "~{xmm4},~{xmm5},~{xmm7},~{dirflag},~{fpsr},~{flags}"()
++  tail call void asm sideeffect "", "~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{dirflag},~{fpsr},~{flags}"()
++  tail call void asm sideeffect "", "~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{dirflag},~{fpsr},~{flags}"()
++  %tmp1 = fpext float %arg to double
++  ret double %tmp1
++;AVX-LABEL:@truedeps
++;AVX-NOT: vxorps
++;AVX: vcvtss2sd [[XMM0:%xmm[0-9]+]], [[XMM0]], {{%xmm[0-9]+}}
++}
++
++; Make sure we are making a smart choice regarding undef registers and
++; choosing the register with the highest clearence
++define double @clearence(i64 %arg) {
++top:
++  tail call void asm sideeffect "", "~{xmm6},~{dirflag},~{fpsr},~{flags}"()
++  tail call void asm sideeffect "", "~{xmm0},~{xmm1},~{xmm2},~{xmm3},~{dirflag},~{fpsr},~{flags}"()
++  tail call void asm sideeffect "", "~{xmm4},~{xmm5},~{xmm7},~{dirflag},~{fpsr},~{flags}"()
++  tail call void asm sideeffect "", "~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{dirflag},~{fpsr},~{flags}"()
++  tail call void asm sideeffect "", "~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{dirflag},~{fpsr},~{flags}"()
++  %tmp1 = sitofp i64 %arg to double
++  ret double %tmp1
++;AVX-LABEL:@clearence
++;AVX: vxorps  [[XMM6:%xmm6]], [[XMM6]], [[XMM6]]
++;AVX-NEXT: vcvtsi2sdq {{.*}}, [[XMM6]], {{%xmm[0-9]+}}
++}
++
++; Make sure we are making a smart choice regarding undef registers in order to
++; avoid a cyclic dependence on a write to the same register in a previous
++; iteration, especially when we cannot zero out the undef register because it
++; is alive.
++define i64 @loopclearence(i64* nocapture %x, double* nocapture %y) nounwind {
++entry:
++  %vx = load i64, i64* %x
++  br label %loop
++loop:
++  %i = phi i64 [ 1, %entry ], [ %inc, %loop ]
++  %s1 = phi i64 [ %vx, %entry ], [ %s2, %loop ]
++  %fi = sitofp i64 %i to double
++  tail call void asm sideeffect "", "~{xmm0},~{xmm1},~{xmm2},~{xmm3},~{dirflag},~{fpsr},~{flags}"()
++  tail call void asm sideeffect "", "~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{dirflag},~{fpsr},~{flags}"()
++  tail call void asm sideeffect "", "~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{dirflag},~{fpsr},~{flags}"()
++  %vy = load double, double* %y
++  %fipy = fadd double %fi, %vy
++  %iipy = fptosi double %fipy to i64
++  %s2 = add i64 %s1, %iipy
++  %inc = add nsw i64 %i, 1
++  %exitcond = icmp eq i64 %inc, 156250000
++  br i1 %exitcond, label %ret, label %loop
++ret:
++  ret i64 %s2
++;AVX-LABEL:@loopclearence
++;Registers 4-7 are not used and therefore one of them should be chosen
++;AVX-NOT: {{%xmm[4-7]}}
++;AVX: vcvtsi2sdq {{.*}}, [[XMM4_7:%xmm[4-7]]], {{%xmm[0-9]+}}
++;AVX-NOT: [[XMM4_7]]
++}
+diff --git a/test/CodeGen/X86/copy-propagation.ll b/test/CodeGen/X86/copy-propagation.ll
+index 19421a06fa8..dac46c17382 100644
+--- a/test/CodeGen/X86/copy-propagation.ll
++++ b/test/CodeGen/X86/copy-propagation.ll
+@@ -26,7 +26,7 @@ target triple = "x86_64-pc-win32-elf"
+ ; Copy the result in a temporary.
+ ; Note: Technically the regalloc could have been smarter and this move not required,
+ ; which would have hidden the bug.
+-; CHECK-NEXT: vmovapd	%xmm0, [[TMP:%xmm[0-9]+]]
++; CHECK: vmovapd	%xmm0, [[TMP:%xmm[0-9]+]]
+ ; Crush xmm0.
+ ; CHECK-NEXT: vxorps %xmm0, %xmm0, %xmm0
+ ; CHECK: movl	$339772768, %e[[INDIRECT_CALL2:[a-z]+]]
+@@ -37,6 +37,7 @@ target triple = "x86_64-pc-win32-elf"
+ define double @foo(i64 %arg) {
+ top:
+   %tmp = call double inttoptr (i64 339752784 to double (double, double)*)(double 1.000000e+00, double 0.000000e+00)
++  tail call void asm sideeffect "", "x,~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{dirflag},~{fpsr},~{flags}"(double %tmp)
+   %tmp1 = sitofp i64 %arg to double
+   call void inttoptr (i64 339772768 to void (double, double)*)(double %tmp, double %tmp1)
+   %tmp3 = fadd double %tmp1, %tmp
+diff --git a/test/CodeGen/X86/half.ll b/test/CodeGen/X86/half.ll
+index 717ddbfa6fd..739bb146e3a 100644
+--- a/test/CodeGen/X86/half.ll
++++ b/test/CodeGen/X86/half.ll
+@@ -299,7 +299,7 @@ define half @test_f80trunc_nodagcombine() #0 {
+ ; CHECK-F16C-NEXT: movswl (%rsi), %eax
+ ; CHECK-F16C-NEXT: vmovd %eax, %xmm0
+ ; CHECK-F16C-NEXT: vcvtph2ps %xmm0, %xmm0
+-; CHECK-F16C-NEXT: vcvtsi2ssl %edi, %xmm0, %xmm1
++; CHECK-F16C-NEXT: vcvtsi2ssl %edi, %xmm1, %xmm1
+ ; CHECK-F16C-NEXT: vcvtps2ph $4, %xmm1, %xmm1
+ ; CHECK-F16C-NEXT: vcvtph2ps %xmm1, %xmm1
+ ; CHECK-F16C-NEXT: vaddss %xmm1, %xmm0, %xmm0
+diff --git a/test/CodeGen/X86/vec_int_to_fp.ll b/test/CodeGen/X86/vec_int_to_fp.ll
+index 8ea7243664a..bb0a93dc848 100644
+--- a/test/CodeGen/X86/vec_int_to_fp.ll
++++ b/test/CodeGen/X86/vec_int_to_fp.ll
+@@ -27,10 +27,9 @@ define <2 x double> @sitofp_2i64_to_2f64(<2 x i64> %a) {
+ ; AVX-LABEL: sitofp_2i64_to_2f64:
+ ; AVX:       # BB#0:
+ ; AVX-NEXT:    vpextrq $1, %xmm0, %rax
+-; AVX-NEXT:    vcvtsi2sdq %rax, %xmm0, %xmm1
++; AVX-NEXT:    vcvtsi2sdq %rax, %xmm1, %xmm1
+ ; AVX-NEXT:    vmovq %xmm0, %rax
+-; AVX-NEXT:    vxorps %xmm0, %xmm0, %xmm0
+-; AVX-NEXT:    vcvtsi2sdq %rax, %xmm0, %xmm0
++; AVX-NEXT:    vcvtsi2sdq %rax, %xmm2, %xmm0
+ ; AVX-NEXT:    vunpcklpd {{.*#+}} xmm0 = xmm0[0],xmm1[0]
+ ; AVX-NEXT:    retq
+   %cvt = sitofp <2 x i64> %a to <2 x double>
+@@ -188,15 +187,14 @@ define <4 x double> @sitofp_4i64_to_4f64(<4 x i64> %a) {
+ ; AVX1:       # BB#0:
+ ; AVX1-NEXT:    vextractf128 $1, %ymm0, %xmm1
+ ; AVX1-NEXT:    vpextrq $1, %xmm1, %rax
+-; AVX1-NEXT:    vcvtsi2sdq %rax, %xmm0, %xmm2
++; AVX1-NEXT:    vcvtsi2sdq %rax, %xmm2, %xmm2
+ ; AVX1-NEXT:    vmovq %xmm1, %rax
+-; AVX1-NEXT:    vcvtsi2sdq %rax, %xmm0, %xmm1
++; AVX1-NEXT:    vcvtsi2sdq %rax, %xmm3, %xmm1
+ ; AVX1-NEXT:    vunpcklpd {{.*#+}} xmm1 = xmm1[0],xmm2[0]
+ ; AVX1-NEXT:    vpextrq $1, %xmm0, %rax
+-; AVX1-NEXT:    vcvtsi2sdq %rax, %xmm0, %xmm2
++; AVX1-NEXT:    vcvtsi2sdq %rax, %xmm3, %xmm2
+ ; AVX1-NEXT:    vmovq %xmm0, %rax
+-; AVX1-NEXT:    vxorps %xmm0, %xmm0, %xmm0
+-; AVX1-NEXT:    vcvtsi2sdq %rax, %xmm0, %xmm0
++; AVX1-NEXT:    vcvtsi2sdq %rax, %xmm3, %xmm0
+ ; AVX1-NEXT:    vunpcklpd {{.*#+}} xmm0 = xmm0[0],xmm2[0]
+ ; AVX1-NEXT:    vinsertf128 $1, %xmm1, %ymm0, %ymm0
+ ; AVX1-NEXT:    retq
+@@ -205,18 +203,33 @@ define <4 x double> @sitofp_4i64_to_4f64(<4 x i64> %a) {
+ ; AVX2:       # BB#0:
+ ; AVX2-NEXT:    vextracti128 $1, %ymm0, %xmm1
+ ; AVX2-NEXT:    vpextrq $1, %xmm1, %rax
+-; AVX2-NEXT:    vcvtsi2sdq %rax, %xmm0, %xmm2
++; AVX2-NEXT:    vcvtsi2sdq %rax, %xmm2, %xmm2
+ ; AVX2-NEXT:    vmovq %xmm1, %rax
+-; AVX2-NEXT:    vcvtsi2sdq %rax, %xmm0, %xmm1
++; AVX2-NEXT:    vcvtsi2sdq %rax, %xmm3, %xmm1
+ ; AVX2-NEXT:    vunpcklpd {{.*#+}} xmm1 = xmm1[0],xmm2[0]
+ ; AVX2-NEXT:    vpextrq $1, %xmm0, %rax
+-; AVX2-NEXT:    vcvtsi2sdq %rax, %xmm0, %xmm2
++; AVX2-NEXT:    vcvtsi2sdq %rax, %xmm3, %xmm2
+ ; AVX2-NEXT:    vmovq %xmm0, %rax
+-; AVX2-NEXT:    vxorps %xmm0, %xmm0, %xmm0
+-; AVX2-NEXT:    vcvtsi2sdq %rax, %xmm0, %xmm0
++; AVX2-NEXT:    vcvtsi2sdq %rax, %xmm3, %xmm0
+ ; AVX2-NEXT:    vunpcklpd {{.*#+}} xmm0 = xmm0[0],xmm2[0]
+ ; AVX2-NEXT:    vinsertf128 $1, %xmm1, %ymm0, %ymm0
+ ; AVX2-NEXT:    retq
++;
++; AVX512-LABEL: sitofp_4i64_to_4f64:
++; AVX512:       # BB#0:
++; AVX512-NEXT:    vextracti32x4 $1, %ymm0, %xmm1
++; AVX512-NEXT:    vpextrq $1, %xmm1, %rax
++; AVX512-NEXT:    vcvtsi2sdq %rax, %xmm2, %xmm2
++; AVX512-NEXT:    vmovq %xmm1, %rax
++; AVX512-NEXT:    vcvtsi2sdq %rax, %xmm3, %xmm1
++; AVX512-NEXT:    vunpcklpd {{.*#+}} xmm1 = xmm1[0],xmm2[0]
++; AVX512-NEXT:    vpextrq $1, %xmm0, %rax
++; AVX512-NEXT:    vcvtsi2sdq %rax, %xmm3, %xmm2
++; AVX512-NEXT:    vmovq %xmm0, %rax
++; AVX512-NEXT:    vcvtsi2sdq %rax, %xmm3, %xmm0
++; AVX512-NEXT:    vunpcklpd {{.*#+}} xmm0 = xmm0[0],xmm2[0]
++; AVX512-NEXT:    vinsertf32x4 $1, %xmm1, %ymm0, %ymm0
++; AVX512-NEXT:    retq
+   %cvt = sitofp <4 x i64> %a to <4 x double>
+   ret <4 x double> %cvt
+ }
+@@ -803,12 +816,11 @@ define <4 x float> @sitofp_2i64_to_4f32(<2 x i64> %a) {
+ ; AVX-LABEL: sitofp_2i64_to_4f32:
+ ; AVX:       # BB#0:
+ ; AVX-NEXT:    vpextrq $1, %xmm0, %rax
+-; AVX-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm1
++; AVX-NEXT:    vcvtsi2ssq %rax, %xmm1, %xmm1
+ ; AVX-NEXT:    vmovq %xmm0, %rax
+-; AVX-NEXT:    vxorps %xmm0, %xmm0, %xmm0
+-; AVX-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm0
++; AVX-NEXT:    vcvtsi2ssq %rax, %xmm2, %xmm0
+ ; AVX-NEXT:    vinsertps {{.*#+}} xmm0 = xmm0[0],xmm1[0],xmm0[2,3]
+-; AVX-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm1
++; AVX-NEXT:    vcvtsi2ssq %rax, %xmm2, %xmm1
+ ; AVX-NEXT:    vinsertps {{.*#+}} xmm0 = xmm0[0,1],xmm1[0],xmm0[3]
+ ; AVX-NEXT:    vinsertps {{.*#+}} xmm0 = xmm0[0,1,2],xmm1[0]
+ ; AVX-NEXT:    retq
+@@ -836,12 +848,11 @@ define <4 x float> @sitofp_4i64_to_4f32_undef(<2 x i64> %a) {
+ ; AVX-LABEL: sitofp_4i64_to_4f32_undef:
+ ; AVX:       # BB#0:
+ ; AVX-NEXT:    vpextrq $1, %xmm0, %rax
+-; AVX-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm1
++; AVX-NEXT:    vcvtsi2ssq %rax, %xmm1, %xmm1
+ ; AVX-NEXT:    vmovq %xmm0, %rax
+-; AVX-NEXT:    vxorps %xmm0, %xmm0, %xmm0
+-; AVX-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm0
++; AVX-NEXT:    vcvtsi2ssq %rax, %xmm2, %xmm0
+ ; AVX-NEXT:    vinsertps {{.*#+}} xmm0 = xmm0[0],xmm1[0],xmm0[2,3]
+-; AVX-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm1
++; AVX-NEXT:    vcvtsi2ssq %rax, %xmm2, %xmm1
+ ; AVX-NEXT:    vinsertps {{.*#+}} xmm0 = xmm0[0,1],xmm1[0],xmm0[3]
+ ; AVX-NEXT:    vinsertps {{.*#+}} xmm0 = xmm0[0,1,2],xmm1[0]
+ ; AVX-NEXT:    retq
+@@ -988,17 +999,16 @@ define <4 x float> @sitofp_4i64_to_4f32(<4 x i64> %a) {
+ ; AVX1-LABEL: sitofp_4i64_to_4f32:
+ ; AVX1:       # BB#0:
+ ; AVX1-NEXT:    vpextrq $1, %xmm0, %rax
+-; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm1
++; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm1, %xmm1
+ ; AVX1-NEXT:    vmovq %xmm0, %rax
+-; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm2
++; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm2, %xmm2
+ ; AVX1-NEXT:    vinsertps {{.*#+}} xmm1 = xmm2[0],xmm1[0],xmm2[2,3]
+ ; AVX1-NEXT:    vextractf128 $1, %ymm0, %xmm0
+ ; AVX1-NEXT:    vmovq %xmm0, %rax
+-; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm2
++; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm3, %xmm2
+ ; AVX1-NEXT:    vinsertps {{.*#+}} xmm1 = xmm1[0,1],xmm2[0],xmm1[3]
+ ; AVX1-NEXT:    vpextrq $1, %xmm0, %rax
+-; AVX1-NEXT:    vxorps %xmm0, %xmm0, %xmm0
+-; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm0
++; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm3, %xmm0
+ ; AVX1-NEXT:    vinsertps {{.*#+}} xmm0 = xmm1[0,1,2],xmm0[0]
+ ; AVX1-NEXT:    vzeroupper
+ ; AVX1-NEXT:    retq
+@@ -1006,20 +1016,35 @@ define <4 x float> @sitofp_4i64_to_4f32(<4 x i64> %a) {
+ ; AVX2-LABEL: sitofp_4i64_to_4f32:
+ ; AVX2:       # BB#0:
+ ; AVX2-NEXT:    vpextrq $1, %xmm0, %rax
+-; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm1
++; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm1, %xmm1
+ ; AVX2-NEXT:    vmovq %xmm0, %rax
+-; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm2
++; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm2, %xmm2
+ ; AVX2-NEXT:    vinsertps {{.*#+}} xmm1 = xmm2[0],xmm1[0],xmm2[2,3]
+ ; AVX2-NEXT:    vextracti128 $1, %ymm0, %xmm0
+ ; AVX2-NEXT:    vmovq %xmm0, %rax
+-; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm2
++; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm3, %xmm2
+ ; AVX2-NEXT:    vinsertps {{.*#+}} xmm1 = xmm1[0,1],xmm2[0],xmm1[3]
+ ; AVX2-NEXT:    vpextrq $1, %xmm0, %rax
+-; AVX2-NEXT:    vxorps %xmm0, %xmm0, %xmm0
+-; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm0
++; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm3, %xmm0
+ ; AVX2-NEXT:    vinsertps {{.*#+}} xmm0 = xmm1[0,1,2],xmm0[0]
+ ; AVX2-NEXT:    vzeroupper
+ ; AVX2-NEXT:    retq
++;
++; AVX512-LABEL: sitofp_4i64_to_4f32:
++; AVX512:       # BB#0:
++; AVX512-NEXT:    vpextrq $1, %xmm0, %rax
++; AVX512-NEXT:    vcvtsi2ssq %rax, %xmm1, %xmm1
++; AVX512-NEXT:    vmovq %xmm0, %rax
++; AVX512-NEXT:    vcvtsi2ssq %rax, %xmm2, %xmm2
++; AVX512-NEXT:    vinsertps {{.*#+}} xmm1 = xmm2[0],xmm1[0],xmm2[2,3]
++; AVX512-NEXT:    vextracti32x4 $1, %ymm0, %xmm0
++; AVX512-NEXT:    vmovq %xmm0, %rax
++; AVX512-NEXT:    vcvtsi2ssq %rax, %xmm3, %xmm2
++; AVX512-NEXT:    vinsertps {{.*#+}} xmm1 = xmm1[0,1],xmm2[0],xmm1[3]
++; AVX512-NEXT:    vpextrq $1, %xmm0, %rax
++; AVX512-NEXT:    vcvtsi2ssq %rax, %xmm3, %xmm0
++; AVX512-NEXT:    vinsertps {{.*#+}} xmm0 = xmm1[0,1,2],xmm0[0]
++; AVX512-NEXT:    retq
+   %cvt = sitofp <4 x i64> %a to <4 x float>
+   ret <4 x float> %cvt
+ }
+@@ -1181,48 +1206,58 @@ define <4 x float> @uitofp_2i64_to_4f32(<2 x i64> %a) {
+ ; SSE-NEXT:    unpcklps {{.*#+}} xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
+ ; SSE-NEXT:    retq
+ ;
+-; AVX-LABEL: uitofp_2i64_to_4f32:
+-; AVX:       # BB#0:
+-; AVX-NEXT:    vpextrq $1, %xmm0, %rax
+-; AVX-NEXT:    movl %eax, %ecx
+-; AVX-NEXT:    andl $1, %ecx
+-; AVX-NEXT:    testq %rax, %rax
+-; AVX-NEXT:    js .LBB38_1
+-; AVX-NEXT:  # BB#2:
+-; AVX-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm1
+-; AVX-NEXT:    jmp .LBB38_3
+-; AVX-NEXT:  .LBB38_1:
+-; AVX-NEXT:    shrq %rax
+-; AVX-NEXT:    orq %rax, %rcx
+-; AVX-NEXT:    vcvtsi2ssq %rcx, %xmm0, %xmm1
+-; AVX-NEXT:    vaddss %xmm1, %xmm1, %xmm1
+-; AVX-NEXT:  .LBB38_3:
+-; AVX-NEXT:    vmovq %xmm0, %rax
+-; AVX-NEXT:    movl %eax, %ecx
+-; AVX-NEXT:    andl $1, %ecx
+-; AVX-NEXT:    testq %rax, %rax
+-; AVX-NEXT:    js .LBB38_4
+-; AVX-NEXT:  # BB#5:
+-; AVX-NEXT:    vxorps %xmm0, %xmm0, %xmm0
+-; AVX-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm0
+-; AVX-NEXT:    jmp .LBB38_6
+-; AVX-NEXT:  .LBB38_4:
+-; AVX-NEXT:    shrq %rax
+-; AVX-NEXT:    orq %rax, %rcx
+-; AVX-NEXT:    vxorps %xmm0, %xmm0, %xmm0
+-; AVX-NEXT:    vcvtsi2ssq %rcx, %xmm0, %xmm0
+-; AVX-NEXT:    vaddss %xmm0, %xmm0, %xmm0
+-; AVX-NEXT:  .LBB38_6:
+-; AVX-NEXT:    vinsertps {{.*#+}} xmm0 = xmm0[0],xmm1[0],xmm0[2,3]
+-; AVX-NEXT:    vxorps %xmm1, %xmm1, %xmm1
+-; AVX-NEXT:    testq %rax, %rax
+-; AVX-NEXT:    js .LBB38_8
+-; AVX-NEXT:  # BB#7:
+-; AVX-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm1
+-; AVX-NEXT:  .LBB38_8:
+-; AVX-NEXT:    vinsertps {{.*#+}} xmm0 = xmm0[0,1],xmm1[0],xmm0[3]
+-; AVX-NEXT:    vinsertps {{.*#+}} xmm0 = xmm0[0,1,2],xmm1[0]
+-; AVX-NEXT:    retq
++; AVX1-LABEL: uitofp_2i64_to_4f32:
++; AVX1:       # BB#0:
++; AVX1-NEXT:    vpextrq $1, %xmm0, %rax
++; AVX1-NEXT:    movl %eax, %ecx
++; AVX1-NEXT:    andl $1, %ecx
++; AVX1-NEXT:    testq %rax, %rax
++; AVX1-NEXT:    js .LBB38_1
++; AVX1-NEXT:  # BB#2:
++; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm1, %xmm1
++; AVX1-NEXT:    jmp .LBB38_3
++; AVX1-NEXT:  .LBB38_1:
++; AVX1-NEXT:    shrq %rax
++; AVX1-NEXT:    orq %rax, %rcx
++; AVX1-NEXT:    vcvtsi2ssq %rcx, %xmm1, %xmm1
++; AVX1-NEXT:    vaddss %xmm1, %xmm1, %xmm1
++; AVX1-NEXT:  .LBB38_3:
++; AVX1-NEXT:    vmovq %xmm0, %rax
++; AVX1-NEXT:    movl %eax, %ecx
++; AVX1-NEXT:    andl $1, %ecx
++; AVX1-NEXT:    testq %rax, %rax
++; AVX1-NEXT:    js .LBB38_4
++; AVX1-NEXT:  # BB#5:
++; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm2, %xmm0
++; AVX1-NEXT:    jmp .LBB38_6
++; AVX1-NEXT:  .LBB38_4:
++; AVX1-NEXT:    shrq %rax
++; AVX1-NEXT:    orq %rax, %rcx
++; AVX1-NEXT:    vcvtsi2ssq %rcx, %xmm2, %xmm0
++; AVX1-NEXT:    vaddss %xmm0, %xmm0, %xmm0
++; AVX1-NEXT:  .LBB38_6:
++; AVX1-NEXT:    vinsertps {{.*#+}} xmm0 = xmm0[0],xmm1[0],xmm0[2,3]
++; AVX1-NEXT:    vxorps %xmm1, %xmm1, %xmm1
++; AVX1-NEXT:    testq %rax, %rax
++; AVX1-NEXT:    js .LBB38_8
++; AVX1-NEXT:  # BB#7:
++; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm2, %xmm1
++; AVX1-NEXT:  .LBB38_8:
++; AVX1-NEXT:    vinsertps {{.*#+}} xmm0 = xmm0[0,1],xmm1[0],xmm0[3]
++; AVX1-NEXT:    vinsertps {{.*#+}} xmm0 = xmm0[0,1,2],xmm1[0]
++; AVX1-NEXT:    retq
++;
++; AVX512-LABEL: uitofp_2i64_to_4f32:
++; AVX512:       # BB#0:
++; AVX512-NEXT:    vpextrq $1, %xmm0, %rax
++; AVX512-NEXT:    vcvtusi2ssq %rax, %xmm0, %xmm1
++; AVX512-NEXT:    vmovq %xmm0, %rax
++; AVX512-NEXT:    vcvtusi2ssq %rax, %xmm0, %xmm0
++; AVX512-NEXT:    vinsertps {{.*#+}} xmm0 = xmm0[0],xmm1[0],xmm0[2,3]
++; AVX512-NEXT:    vcvtusi2ssq %rax, %xmm0, %xmm1
++; AVX512-NEXT:    vinsertps {{.*#+}} xmm0 = xmm0[0,1],xmm1[0],xmm0[3]
++; AVX512-NEXT:    vinsertps {{.*#+}} xmm0 = xmm0[0,1,2],xmm1[0]
++; AVX512-NEXT:    retq
+   %cvt = uitofp <2 x i64> %a to <2 x float>
+   %ext = shufflevector <2 x float> %cvt, <2 x float> undef, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
+   ret <4 x float> %ext
+@@ -1277,48 +1312,58 @@ define <4 x float> @uitofp_4i64_to_4f32_undef(<2 x i64> %a) {
+ ; SSE-NEXT:    unpcklps {{.*#+}} xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
+ ; SSE-NEXT:    retq
+ ;
+-; AVX-LABEL: uitofp_4i64_to_4f32_undef:
+-; AVX:       # BB#0:
+-; AVX-NEXT:    vpextrq $1, %xmm0, %rax
+-; AVX-NEXT:    movl %eax, %ecx
+-; AVX-NEXT:    andl $1, %ecx
+-; AVX-NEXT:    testq %rax, %rax
+-; AVX-NEXT:    js .LBB39_1
+-; AVX-NEXT:  # BB#2:
+-; AVX-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm1
+-; AVX-NEXT:    jmp .LBB39_3
+-; AVX-NEXT:  .LBB39_1:
+-; AVX-NEXT:    shrq %rax
+-; AVX-NEXT:    orq %rax, %rcx
+-; AVX-NEXT:    vcvtsi2ssq %rcx, %xmm0, %xmm1
+-; AVX-NEXT:    vaddss %xmm1, %xmm1, %xmm1
+-; AVX-NEXT:  .LBB39_3:
+-; AVX-NEXT:    vmovq %xmm0, %rax
+-; AVX-NEXT:    movl %eax, %ecx
+-; AVX-NEXT:    andl $1, %ecx
+-; AVX-NEXT:    testq %rax, %rax
+-; AVX-NEXT:    js .LBB39_4
+-; AVX-NEXT:  # BB#5:
+-; AVX-NEXT:    vxorps %xmm0, %xmm0, %xmm0
+-; AVX-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm0
+-; AVX-NEXT:    jmp .LBB39_6
+-; AVX-NEXT:  .LBB39_4:
+-; AVX-NEXT:    shrq %rax
+-; AVX-NEXT:    orq %rax, %rcx
+-; AVX-NEXT:    vxorps %xmm0, %xmm0, %xmm0
+-; AVX-NEXT:    vcvtsi2ssq %rcx, %xmm0, %xmm0
+-; AVX-NEXT:    vaddss %xmm0, %xmm0, %xmm0
+-; AVX-NEXT:  .LBB39_6:
+-; AVX-NEXT:    vinsertps {{.*#+}} xmm0 = xmm0[0],xmm1[0],xmm0[2,3]
+-; AVX-NEXT:    vxorps %xmm1, %xmm1, %xmm1
+-; AVX-NEXT:    testq %rax, %rax
+-; AVX-NEXT:    js .LBB39_8
+-; AVX-NEXT:  # BB#7:
+-; AVX-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm1
+-; AVX-NEXT:  .LBB39_8:
+-; AVX-NEXT:    vinsertps {{.*#+}} xmm0 = xmm0[0,1],xmm1[0],xmm0[3]
+-; AVX-NEXT:    vinsertps {{.*#+}} xmm0 = xmm0[0,1,2],xmm1[0]
+-; AVX-NEXT:    retq
++; AVX1-LABEL: uitofp_4i64_to_4f32_undef:
++; AVX1:       # BB#0:
++; AVX1-NEXT:    vpextrq $1, %xmm0, %rax
++; AVX1-NEXT:    movl %eax, %ecx
++; AVX1-NEXT:    andl $1, %ecx
++; AVX1-NEXT:    testq %rax, %rax
++; AVX1-NEXT:    js .LBB39_1
++; AVX1-NEXT:  # BB#2:
++; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm1, %xmm1
++; AVX1-NEXT:    jmp .LBB39_3
++; AVX1-NEXT:  .LBB39_1:
++; AVX1-NEXT:    shrq %rax
++; AVX1-NEXT:    orq %rax, %rcx
++; AVX1-NEXT:    vcvtsi2ssq %rcx, %xmm1, %xmm1
++; AVX1-NEXT:    vaddss %xmm1, %xmm1, %xmm1
++; AVX1-NEXT:  .LBB39_3:
++; AVX1-NEXT:    vmovq %xmm0, %rax
++; AVX1-NEXT:    movl %eax, %ecx
++; AVX1-NEXT:    andl $1, %ecx
++; AVX1-NEXT:    testq %rax, %rax
++; AVX1-NEXT:    js .LBB39_4
++; AVX1-NEXT:  # BB#5:
++; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm2, %xmm0
++; AVX1-NEXT:    jmp .LBB39_6
++; AVX1-NEXT:  .LBB39_4:
++; AVX1-NEXT:    shrq %rax
++; AVX1-NEXT:    orq %rax, %rcx
++; AVX1-NEXT:    vcvtsi2ssq %rcx, %xmm2, %xmm0
++; AVX1-NEXT:    vaddss %xmm0, %xmm0, %xmm0
++; AVX1-NEXT:  .LBB39_6:
++; AVX1-NEXT:    vinsertps {{.*#+}} xmm0 = xmm0[0],xmm1[0],xmm0[2,3]
++; AVX1-NEXT:    vxorps %xmm1, %xmm1, %xmm1
++; AVX1-NEXT:    testq %rax, %rax
++; AVX1-NEXT:    js .LBB39_8
++; AVX1-NEXT:  # BB#7:
++; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm2, %xmm1
++; AVX1-NEXT:  .LBB39_8:
++; AVX1-NEXT:    vinsertps {{.*#+}} xmm0 = xmm0[0,1],xmm1[0],xmm0[3]
++; AVX1-NEXT:    vinsertps {{.*#+}} xmm0 = xmm0[0,1,2],xmm1[0]
++; AVX1-NEXT:    retq
++;
++; AVX512-LABEL: uitofp_4i64_to_4f32_undef:
++; AVX512:       # BB#0:
++; AVX512-NEXT:    vpextrq $1, %xmm0, %rax
++; AVX512-NEXT:    vcvtusi2ssq %rax, %xmm0, %xmm1
++; AVX512-NEXT:    vmovq %xmm0, %rax
++; AVX512-NEXT:    vcvtusi2ssq %rax, %xmm0, %xmm0
++; AVX512-NEXT:    vinsertps {{.*#+}} xmm0 = xmm0[0],xmm1[0],xmm0[2,3]
++; AVX512-NEXT:    vcvtusi2ssq %rax, %xmm0, %xmm1
++; AVX512-NEXT:    vinsertps {{.*#+}} xmm0 = xmm0[0,1],xmm1[0],xmm0[3]
++; AVX512-NEXT:    vinsertps {{.*#+}} xmm0 = xmm0[0,1,2],xmm1[0]
++; AVX512-NEXT:    retq
+   %ext = shufflevector <2 x i64> %a, <2 x i64> undef, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
+   %cvt = uitofp <4 x i64> %ext to <4 x float>
+   ret <4 x float> %cvt
+@@ -1539,12 +1584,12 @@ define <4 x float> @uitofp_4i64_to_4f32(<4 x i64> %a) {
+ ; AVX1-NEXT:    testq %rax, %rax
+ ; AVX1-NEXT:    js .LBB45_1
+ ; AVX1-NEXT:  # BB#2:
+-; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm1
++; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm1, %xmm1
+ ; AVX1-NEXT:    jmp .LBB45_3
+ ; AVX1-NEXT:  .LBB45_1:
+ ; AVX1-NEXT:    shrq %rax
+ ; AVX1-NEXT:    orq %rax, %rcx
+-; AVX1-NEXT:    vcvtsi2ssq %rcx, %xmm0, %xmm1
++; AVX1-NEXT:    vcvtsi2ssq %rcx, %xmm1, %xmm1
+ ; AVX1-NEXT:    vaddss %xmm1, %xmm1, %xmm1
+ ; AVX1-NEXT:  .LBB45_3:
+ ; AVX1-NEXT:    vmovq %xmm0, %rax
+@@ -1553,12 +1598,12 @@ define <4 x float> @uitofp_4i64_to_4f32(<4 x i64> %a) {
+ ; AVX1-NEXT:    testq %rax, %rax
+ ; AVX1-NEXT:    js .LBB45_4
+ ; AVX1-NEXT:  # BB#5:
+-; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm2
++; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm2, %xmm2
+ ; AVX1-NEXT:    jmp .LBB45_6
+ ; AVX1-NEXT:  .LBB45_4:
+ ; AVX1-NEXT:    shrq %rax
+ ; AVX1-NEXT:    orq %rax, %rcx
+-; AVX1-NEXT:    vcvtsi2ssq %rcx, %xmm0, %xmm2
++; AVX1-NEXT:    vcvtsi2ssq %rcx, %xmm2, %xmm2
+ ; AVX1-NEXT:    vaddss %xmm2, %xmm2, %xmm2
+ ; AVX1-NEXT:  .LBB45_6:
+ ; AVX1-NEXT:    vinsertps {{.*#+}} xmm1 = xmm2[0],xmm1[0],xmm2[2,3]
+@@ -1569,12 +1614,12 @@ define <4 x float> @uitofp_4i64_to_4f32(<4 x i64> %a) {
+ ; AVX1-NEXT:    testq %rax, %rax
+ ; AVX1-NEXT:    js .LBB45_7
+ ; AVX1-NEXT:  # BB#8:
+-; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm2
++; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm3, %xmm2
+ ; AVX1-NEXT:    jmp .LBB45_9
+ ; AVX1-NEXT:  .LBB45_7:
+ ; AVX1-NEXT:    shrq %rax
+ ; AVX1-NEXT:    orq %rax, %rcx
+-; AVX1-NEXT:    vcvtsi2ssq %rcx, %xmm0, %xmm2
++; AVX1-NEXT:    vcvtsi2ssq %rcx, %xmm3, %xmm2
+ ; AVX1-NEXT:    vaddss %xmm2, %xmm2, %xmm2
+ ; AVX1-NEXT:  .LBB45_9:
+ ; AVX1-NEXT:    vinsertps {{.*#+}} xmm1 = xmm1[0,1],xmm2[0],xmm1[3]
+@@ -1584,16 +1629,14 @@ define <4 x float> @uitofp_4i64_to_4f32(<4 x i64> %a) {
+ ; AVX1-NEXT:    testq %rax, %rax
+ ; AVX1-NEXT:    js .LBB45_10
+ ; AVX1-NEXT:  # BB#11:
+-; AVX1-NEXT:    vxorps %xmm0, %xmm0, %xmm0
+-; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm0
++; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm3, %xmm0
+ ; AVX1-NEXT:    vinsertps {{.*#+}} xmm0 = xmm1[0,1,2],xmm0[0]
+ ; AVX1-NEXT:    vzeroupper
+ ; AVX1-NEXT:    retq
+ ; AVX1-NEXT:  .LBB45_10:
+ ; AVX1-NEXT:    shrq %rax
+ ; AVX1-NEXT:    orq %rax, %rcx
+-; AVX1-NEXT:    vxorps %xmm0, %xmm0, %xmm0
+-; AVX1-NEXT:    vcvtsi2ssq %rcx, %xmm0, %xmm0
++; AVX1-NEXT:    vcvtsi2ssq %rcx, %xmm3, %xmm0
+ ; AVX1-NEXT:    vaddss %xmm0, %xmm0, %xmm0
+ ; AVX1-NEXT:    vinsertps {{.*#+}} xmm0 = xmm1[0,1,2],xmm0[0]
+ ; AVX1-NEXT:    vzeroupper
+@@ -1607,12 +1650,12 @@ define <4 x float> @uitofp_4i64_to_4f32(<4 x i64> %a) {
+ ; AVX2-NEXT:    testq %rax, %rax
+ ; AVX2-NEXT:    js .LBB45_1
+ ; AVX2-NEXT:  # BB#2:
+-; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm1
++; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm1, %xmm1
+ ; AVX2-NEXT:    jmp .LBB45_3
+ ; AVX2-NEXT:  .LBB45_1:
+ ; AVX2-NEXT:    shrq %rax
+ ; AVX2-NEXT:    orq %rax, %rcx
+-; AVX2-NEXT:    vcvtsi2ssq %rcx, %xmm0, %xmm1
++; AVX2-NEXT:    vcvtsi2ssq %rcx, %xmm1, %xmm1
+ ; AVX2-NEXT:    vaddss %xmm1, %xmm1, %xmm1
+ ; AVX2-NEXT:  .LBB45_3:
+ ; AVX2-NEXT:    vmovq %xmm0, %rax
+@@ -1621,12 +1664,12 @@ define <4 x float> @uitofp_4i64_to_4f32(<4 x i64> %a) {
+ ; AVX2-NEXT:    testq %rax, %rax
+ ; AVX2-NEXT:    js .LBB45_4
+ ; AVX2-NEXT:  # BB#5:
+-; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm2
++; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm2, %xmm2
+ ; AVX2-NEXT:    jmp .LBB45_6
+ ; AVX2-NEXT:  .LBB45_4:
+ ; AVX2-NEXT:    shrq %rax
+ ; AVX2-NEXT:    orq %rax, %rcx
+-; AVX2-NEXT:    vcvtsi2ssq %rcx, %xmm0, %xmm2
++; AVX2-NEXT:    vcvtsi2ssq %rcx, %xmm2, %xmm2
+ ; AVX2-NEXT:    vaddss %xmm2, %xmm2, %xmm2
+ ; AVX2-NEXT:  .LBB45_6:
+ ; AVX2-NEXT:    vinsertps {{.*#+}} xmm1 = xmm2[0],xmm1[0],xmm2[2,3]
+@@ -1637,12 +1680,12 @@ define <4 x float> @uitofp_4i64_to_4f32(<4 x i64> %a) {
+ ; AVX2-NEXT:    testq %rax, %rax
+ ; AVX2-NEXT:    js .LBB45_7
+ ; AVX2-NEXT:  # BB#8:
+-; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm2
++; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm3, %xmm2
+ ; AVX2-NEXT:    jmp .LBB45_9
+ ; AVX2-NEXT:  .LBB45_7:
+ ; AVX2-NEXT:    shrq %rax
+ ; AVX2-NEXT:    orq %rax, %rcx
+-; AVX2-NEXT:    vcvtsi2ssq %rcx, %xmm0, %xmm2
++; AVX2-NEXT:    vcvtsi2ssq %rcx, %xmm3, %xmm2
+ ; AVX2-NEXT:    vaddss %xmm2, %xmm2, %xmm2
+ ; AVX2-NEXT:  .LBB45_9:
+ ; AVX2-NEXT:    vinsertps {{.*#+}} xmm1 = xmm1[0,1],xmm2[0],xmm1[3]
+@@ -1652,16 +1695,14 @@ define <4 x float> @uitofp_4i64_to_4f32(<4 x i64> %a) {
+ ; AVX2-NEXT:    testq %rax, %rax
+ ; AVX2-NEXT:    js .LBB45_10
+ ; AVX2-NEXT:  # BB#11:
+-; AVX2-NEXT:    vxorps %xmm0, %xmm0, %xmm0
+-; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm0
++; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm3, %xmm0
+ ; AVX2-NEXT:    vinsertps {{.*#+}} xmm0 = xmm1[0,1,2],xmm0[0]
+ ; AVX2-NEXT:    vzeroupper
+ ; AVX2-NEXT:    retq
+ ; AVX2-NEXT:  .LBB45_10:
+ ; AVX2-NEXT:    shrq %rax
+ ; AVX2-NEXT:    orq %rax, %rcx
+-; AVX2-NEXT:    vxorps %xmm0, %xmm0, %xmm0
+-; AVX2-NEXT:    vcvtsi2ssq %rcx, %xmm0, %xmm0
++; AVX2-NEXT:    vcvtsi2ssq %rcx, %xmm3, %xmm0
+ ; AVX2-NEXT:    vaddss %xmm0, %xmm0, %xmm0
+ ; AVX2-NEXT:    vinsertps {{.*#+}} xmm0 = xmm1[0,1,2],xmm0[0]
+ ; AVX2-NEXT:    vzeroupper
+@@ -1831,16 +1872,25 @@ define <2 x double> @sitofp_load_2i64_to_2f64(<2 x i64> *%a) {
+ ; SSE-NEXT:    unpcklpd {{.*#+}} xmm0 = xmm0[0],xmm1[0]
+ ; SSE-NEXT:    retq
+ ;
+-; AVX-LABEL: sitofp_load_2i64_to_2f64:
+-; AVX:       # BB#0:
+-; AVX-NEXT:    vmovdqa (%rdi), %xmm0
+-; AVX-NEXT:    vpextrq $1, %xmm0, %rax
+-; AVX-NEXT:    vcvtsi2sdq %rax, %xmm0, %xmm1
+-; AVX-NEXT:    vmovq %xmm0, %rax
+-; AVX-NEXT:    vxorps %xmm0, %xmm0, %xmm0
+-; AVX-NEXT:    vcvtsi2sdq %rax, %xmm0, %xmm0
+-; AVX-NEXT:    vunpcklpd {{.*#+}} xmm0 = xmm0[0],xmm1[0]
+-; AVX-NEXT:    retq
++; AVX1-LABEL: sitofp_load_2i64_to_2f64:
++; AVX1:       # BB#0:
++; AVX1-NEXT:    vmovdqa (%rdi), %xmm0
++; AVX1-NEXT:    vpextrq $1, %xmm0, %rax
++; AVX1-NEXT:    vcvtsi2sdq %rax, %xmm1, %xmm1
++; AVX1-NEXT:    vmovq %xmm0, %rax
++; AVX1-NEXT:    vcvtsi2sdq %rax, %xmm2, %xmm0
++; AVX1-NEXT:    vunpcklpd {{.*#+}} xmm0 = xmm0[0],xmm1[0]
++; AVX1-NEXT:    retq
++;
++; AVX512-LABEL: sitofp_load_2i64_to_2f64:
++; AVX512:       # BB#0:
++; AVX512-NEXT:    vmovdqa64 (%rdi), %xmm0
++; AVX512-NEXT:    vpextrq $1, %xmm0, %rax
++; AVX512-NEXT:    vcvtsi2sdq %rax, %xmm1, %xmm1
++; AVX512-NEXT:    vmovq %xmm0, %rax
++; AVX512-NEXT:    vcvtsi2sdq %rax, %xmm2, %xmm0
++; AVX512-NEXT:    vunpcklpd {{.*#+}} xmm0 = xmm0[0],xmm1[0]
++; AVX512-NEXT:    retq
+   %ld = load <2 x i64>, <2 x i64> *%a
+   %cvt = sitofp <2 x i64> %ld to <2 x double>
+   ret <2 x double> %cvt
+@@ -1930,15 +1980,14 @@ define <4 x double> @sitofp_load_4i64_to_4f64(<4 x i64> *%a) {
+ ; AVX1-NEXT:    vmovaps (%rdi), %ymm0
+ ; AVX1-NEXT:    vextractf128 $1, %ymm0, %xmm1
+ ; AVX1-NEXT:    vpextrq $1, %xmm1, %rax
+-; AVX1-NEXT:    vcvtsi2sdq %rax, %xmm0, %xmm2
++; AVX1-NEXT:    vcvtsi2sdq %rax, %xmm2, %xmm2
+ ; AVX1-NEXT:    vmovq %xmm1, %rax
+-; AVX1-NEXT:    vcvtsi2sdq %rax, %xmm0, %xmm1
++; AVX1-NEXT:    vcvtsi2sdq %rax, %xmm3, %xmm1
+ ; AVX1-NEXT:    vunpcklpd {{.*#+}} xmm1 = xmm1[0],xmm2[0]
+ ; AVX1-NEXT:    vpextrq $1, %xmm0, %rax
+-; AVX1-NEXT:    vcvtsi2sdq %rax, %xmm0, %xmm2
++; AVX1-NEXT:    vcvtsi2sdq %rax, %xmm3, %xmm2
+ ; AVX1-NEXT:    vmovq %xmm0, %rax
+-; AVX1-NEXT:    vxorps %xmm0, %xmm0, %xmm0
+-; AVX1-NEXT:    vcvtsi2sdq %rax, %xmm0, %xmm0
++; AVX1-NEXT:    vcvtsi2sdq %rax, %xmm3, %xmm0
+ ; AVX1-NEXT:    vunpcklpd {{.*#+}} xmm0 = xmm0[0],xmm2[0]
+ ; AVX1-NEXT:    vinsertf128 $1, %xmm1, %ymm0, %ymm0
+ ; AVX1-NEXT:    retq
+@@ -1948,18 +1997,34 @@ define <4 x double> @sitofp_load_4i64_to_4f64(<4 x i64> *%a) {
+ ; AVX2-NEXT:    vmovdqa (%rdi), %ymm0
+ ; AVX2-NEXT:    vextracti128 $1, %ymm0, %xmm1
+ ; AVX2-NEXT:    vpextrq $1, %xmm1, %rax
+-; AVX2-NEXT:    vcvtsi2sdq %rax, %xmm0, %xmm2
++; AVX2-NEXT:    vcvtsi2sdq %rax, %xmm2, %xmm2
+ ; AVX2-NEXT:    vmovq %xmm1, %rax
+-; AVX2-NEXT:    vcvtsi2sdq %rax, %xmm0, %xmm1
++; AVX2-NEXT:    vcvtsi2sdq %rax, %xmm3, %xmm1
+ ; AVX2-NEXT:    vunpcklpd {{.*#+}} xmm1 = xmm1[0],xmm2[0]
+ ; AVX2-NEXT:    vpextrq $1, %xmm0, %rax
+-; AVX2-NEXT:    vcvtsi2sdq %rax, %xmm0, %xmm2
++; AVX2-NEXT:    vcvtsi2sdq %rax, %xmm3, %xmm2
+ ; AVX2-NEXT:    vmovq %xmm0, %rax
+-; AVX2-NEXT:    vxorps %xmm0, %xmm0, %xmm0
+-; AVX2-NEXT:    vcvtsi2sdq %rax, %xmm0, %xmm0
++; AVX2-NEXT:    vcvtsi2sdq %rax, %xmm3, %xmm0
+ ; AVX2-NEXT:    vunpcklpd {{.*#+}} xmm0 = xmm0[0],xmm2[0]
+ ; AVX2-NEXT:    vinsertf128 $1, %xmm1, %ymm0, %ymm0
+ ; AVX2-NEXT:    retq
++;
++; AVX512-LABEL: sitofp_load_4i64_to_4f64:
++; AVX512:       # BB#0:
++; AVX512-NEXT:    vmovdqa64 (%rdi), %ymm0
++; AVX512-NEXT:    vextracti32x4 $1, %ymm0, %xmm1
++; AVX512-NEXT:    vpextrq $1, %xmm1, %rax
++; AVX512-NEXT:    vcvtsi2sdq %rax, %xmm2, %xmm2
++; AVX512-NEXT:    vmovq %xmm1, %rax
++; AVX512-NEXT:    vcvtsi2sdq %rax, %xmm3, %xmm1
++; AVX512-NEXT:    vunpcklpd {{.*#+}} xmm1 = xmm1[0],xmm2[0]
++; AVX512-NEXT:    vpextrq $1, %xmm0, %rax
++; AVX512-NEXT:    vcvtsi2sdq %rax, %xmm3, %xmm2
++; AVX512-NEXT:    vmovq %xmm0, %rax
++; AVX512-NEXT:    vcvtsi2sdq %rax, %xmm3, %xmm0
++; AVX512-NEXT:    vunpcklpd {{.*#+}} xmm0 = xmm0[0],xmm2[0]
++; AVX512-NEXT:    vinsertf32x4 $1, %xmm1, %ymm0, %ymm0
++; AVX512-NEXT:    retq
+   %ld = load <4 x i64>, <4 x i64> *%a
+   %cvt = sitofp <4 x i64> %ld to <4 x double>
+   ret <4 x double> %cvt
+@@ -2365,17 +2430,16 @@ define <4 x float> @sitofp_load_4i64_to_4f32(<4 x i64> *%a) {
+ ; AVX1:       # BB#0:
+ ; AVX1-NEXT:    vmovdqa (%rdi), %ymm0
+ ; AVX1-NEXT:    vpextrq $1, %xmm0, %rax
+-; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm1
++; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm1, %xmm1
+ ; AVX1-NEXT:    vmovq %xmm0, %rax
+-; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm2
++; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm2, %xmm2
+ ; AVX1-NEXT:    vinsertps {{.*#+}} xmm1 = xmm2[0],xmm1[0],xmm2[2,3]
+ ; AVX1-NEXT:    vextractf128 $1, %ymm0, %xmm0
+ ; AVX1-NEXT:    vmovq %xmm0, %rax
+-; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm2
++; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm3, %xmm2
+ ; AVX1-NEXT:    vinsertps {{.*#+}} xmm1 = xmm1[0,1],xmm2[0],xmm1[3]
+ ; AVX1-NEXT:    vpextrq $1, %xmm0, %rax
+-; AVX1-NEXT:    vxorps %xmm0, %xmm0, %xmm0
+-; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm0
++; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm3, %xmm0
+ ; AVX1-NEXT:    vinsertps {{.*#+}} xmm0 = xmm1[0,1,2],xmm0[0]
+ ; AVX1-NEXT:    vzeroupper
+ ; AVX1-NEXT:    retq
+@@ -2384,20 +2448,36 @@ define <4 x float> @sitofp_load_4i64_to_4f32(<4 x i64> *%a) {
+ ; AVX2:       # BB#0:
+ ; AVX2-NEXT:    vmovdqa (%rdi), %ymm0
+ ; AVX2-NEXT:    vpextrq $1, %xmm0, %rax
+-; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm1
++; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm1, %xmm1
+ ; AVX2-NEXT:    vmovq %xmm0, %rax
+-; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm2
++; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm2, %xmm2
+ ; AVX2-NEXT:    vinsertps {{.*#+}} xmm1 = xmm2[0],xmm1[0],xmm2[2,3]
+ ; AVX2-NEXT:    vextracti128 $1, %ymm0, %xmm0
+ ; AVX2-NEXT:    vmovq %xmm0, %rax
+-; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm2
++; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm3, %xmm2
+ ; AVX2-NEXT:    vinsertps {{.*#+}} xmm1 = xmm1[0,1],xmm2[0],xmm1[3]
+ ; AVX2-NEXT:    vpextrq $1, %xmm0, %rax
+-; AVX2-NEXT:    vxorps %xmm0, %xmm0, %xmm0
+-; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm0
++; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm3, %xmm0
+ ; AVX2-NEXT:    vinsertps {{.*#+}} xmm0 = xmm1[0,1,2],xmm0[0]
+ ; AVX2-NEXT:    vzeroupper
+ ; AVX2-NEXT:    retq
++;
++; AVX512-LABEL: sitofp_load_4i64_to_4f32:
++; AVX512:       # BB#0:
++; AVX512-NEXT:    vmovdqa64 (%rdi), %ymm0
++; AVX512-NEXT:    vpextrq $1, %xmm0, %rax
++; AVX512-NEXT:    vcvtsi2ssq %rax, %xmm1, %xmm1
++; AVX512-NEXT:    vmovq %xmm0, %rax
++; AVX512-NEXT:    vcvtsi2ssq %rax, %xmm2, %xmm2
++; AVX512-NEXT:    vinsertps {{.*#+}} xmm1 = xmm2[0],xmm1[0],xmm2[2,3]
++; AVX512-NEXT:    vextracti32x4 $1, %ymm0, %xmm0
++; AVX512-NEXT:    vmovq %xmm0, %rax
++; AVX512-NEXT:    vcvtsi2ssq %rax, %xmm3, %xmm2
++; AVX512-NEXT:    vinsertps {{.*#+}} xmm1 = xmm1[0,1],xmm2[0],xmm1[3]
++; AVX512-NEXT:    vpextrq $1, %xmm0, %rax
++; AVX512-NEXT:    vcvtsi2ssq %rax, %xmm3, %xmm0
++; AVX512-NEXT:    vinsertps {{.*#+}} xmm0 = xmm1[0,1,2],xmm0[0]
++; AVX512-NEXT:    retq
+   %ld = load <4 x i64>, <4 x i64> *%a
+   %cvt = sitofp <4 x i64> %ld to <4 x float>
+   ret <4 x float> %cvt
+@@ -2503,29 +2583,28 @@ define <8 x float> @sitofp_load_8i64_to_8f32(<8 x i64> *%a) {
+ ; AVX1-NEXT:    vmovdqa (%rdi), %ymm0
+ ; AVX1-NEXT:    vmovdqa 32(%rdi), %ymm1
+ ; AVX1-NEXT:    vpextrq $1, %xmm1, %rax
+-; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm2
++; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm2, %xmm2
+ ; AVX1-NEXT:    vmovq %xmm1, %rax
+-; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm3
++; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm3, %xmm3
+ ; AVX1-NEXT:    vinsertps {{.*#+}} xmm2 = xmm3[0],xmm2[0],xmm3[2,3]
+ ; AVX1-NEXT:    vextractf128 $1, %ymm1, %xmm1
+ ; AVX1-NEXT:    vmovq %xmm1, %rax
+-; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm3
++; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm4, %xmm3
+ ; AVX1-NEXT:    vinsertps {{.*#+}} xmm2 = xmm2[0,1],xmm3[0],xmm2[3]
+ ; AVX1-NEXT:    vpextrq $1, %xmm1, %rax
+-; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm1
++; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm4, %xmm1
+ ; AVX1-NEXT:    vinsertps {{.*#+}} xmm1 = xmm2[0,1,2],xmm1[0]
+ ; AVX1-NEXT:    vpextrq $1, %xmm0, %rax
+-; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm2
++; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm4, %xmm2
+ ; AVX1-NEXT:    vmovq %xmm0, %rax
+-; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm3
++; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm4, %xmm3
+ ; AVX1-NEXT:    vinsertps {{.*#+}} xmm2 = xmm3[0],xmm2[0],xmm3[2,3]
+ ; AVX1-NEXT:    vextractf128 $1, %ymm0, %xmm0
+ ; AVX1-NEXT:    vmovq %xmm0, %rax
+-; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm3
++; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm4, %xmm3
+ ; AVX1-NEXT:    vinsertps {{.*#+}} xmm2 = xmm2[0,1],xmm3[0],xmm2[3]
+ ; AVX1-NEXT:    vpextrq $1, %xmm0, %rax
+-; AVX1-NEXT:    vxorps %xmm0, %xmm0, %xmm0
+-; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm0
++; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm4, %xmm0
+ ; AVX1-NEXT:    vinsertps {{.*#+}} xmm0 = xmm2[0,1,2],xmm0[0]
+ ; AVX1-NEXT:    vinsertf128 $1, %xmm1, %ymm0, %ymm0
+ ; AVX1-NEXT:    retq
+@@ -2535,32 +2614,62 @@ define <8 x float> @sitofp_load_8i64_to_8f32(<8 x i64> *%a) {
+ ; AVX2-NEXT:    vmovdqa (%rdi), %ymm0
+ ; AVX2-NEXT:    vmovdqa 32(%rdi), %ymm1
+ ; AVX2-NEXT:    vpextrq $1, %xmm1, %rax
+-; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm2
++; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm2, %xmm2
+ ; AVX2-NEXT:    vmovq %xmm1, %rax
+-; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm3
++; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm3, %xmm3
+ ; AVX2-NEXT:    vinsertps {{.*#+}} xmm2 = xmm3[0],xmm2[0],xmm3[2,3]
+ ; AVX2-NEXT:    vextracti128 $1, %ymm1, %xmm1
+ ; AVX2-NEXT:    vmovq %xmm1, %rax
+-; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm3
++; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm4, %xmm3
+ ; AVX2-NEXT:    vinsertps {{.*#+}} xmm2 = xmm2[0,1],xmm3[0],xmm2[3]
+ ; AVX2-NEXT:    vpextrq $1, %xmm1, %rax
+-; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm1
++; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm4, %xmm1
+ ; AVX2-NEXT:    vinsertps {{.*#+}} xmm1 = xmm2[0,1,2],xmm1[0]
+ ; AVX2-NEXT:    vpextrq $1, %xmm0, %rax
+-; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm2
++; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm4, %xmm2
+ ; AVX2-NEXT:    vmovq %xmm0, %rax
+-; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm3
++; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm4, %xmm3
+ ; AVX2-NEXT:    vinsertps {{.*#+}} xmm2 = xmm3[0],xmm2[0],xmm3[2,3]
+ ; AVX2-NEXT:    vextracti128 $1, %ymm0, %xmm0
+ ; AVX2-NEXT:    vmovq %xmm0, %rax
+-; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm3
++; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm4, %xmm3
+ ; AVX2-NEXT:    vinsertps {{.*#+}} xmm2 = xmm2[0,1],xmm3[0],xmm2[3]
+ ; AVX2-NEXT:    vpextrq $1, %xmm0, %rax
+-; AVX2-NEXT:    vxorps %xmm0, %xmm0, %xmm0
+-; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm0
++; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm4, %xmm0
+ ; AVX2-NEXT:    vinsertps {{.*#+}} xmm0 = xmm2[0,1,2],xmm0[0]
+ ; AVX2-NEXT:    vinsertf128 $1, %xmm1, %ymm0, %ymm0
+ ; AVX2-NEXT:    retq
++;
++; AVX512-LABEL: sitofp_load_8i64_to_8f32:
++; AVX512:       # BB#0:
++; AVX512-NEXT:    vmovdqa64 (%rdi), %zmm0
++; AVX512-NEXT:    vextracti32x4 $2, %zmm0, %xmm1
++; AVX512-NEXT:    vpextrq $1, %xmm1, %rax
++; AVX512-NEXT:    vcvtsi2ssq %rax, %xmm2, %xmm2
++; AVX512-NEXT:    vmovq %xmm1, %rax
++; AVX512-NEXT:    vcvtsi2ssq %rax, %xmm3, %xmm1
++; AVX512-NEXT:    vinsertps {{.*#+}} xmm1 = xmm1[0],xmm2[0],xmm1[2,3]
++; AVX512-NEXT:    vextracti32x4 $3, %zmm0, %xmm2
++; AVX512-NEXT:    vmovq %xmm2, %rax
++; AVX512-NEXT:    vcvtsi2ssq %rax, %xmm3, %xmm3
++; AVX512-NEXT:    vinsertps {{.*#+}} xmm1 = xmm1[0,1],xmm3[0],xmm1[3]
++; AVX512-NEXT:    vpextrq $1, %xmm2, %rax
++; AVX512-NEXT:    vcvtsi2ssq %rax, %xmm4, %xmm2
++; AVX512-NEXT:    vinsertps {{.*#+}} xmm1 = xmm1[0,1,2],xmm2[0]
++; AVX512-NEXT:    vpextrq $1, %xmm0, %rax
++; AVX512-NEXT:    vcvtsi2ssq %rax, %xmm4, %xmm2
++; AVX512-NEXT:    vmovq %xmm0, %rax
++; AVX512-NEXT:    vcvtsi2ssq %rax, %xmm4, %xmm3
++; AVX512-NEXT:    vinsertps {{.*#+}} xmm2 = xmm3[0],xmm2[0],xmm3[2,3]
++; AVX512-NEXT:    vextracti32x4 $1, %zmm0, %xmm0
++; AVX512-NEXT:    vmovq %xmm0, %rax
++; AVX512-NEXT:    vcvtsi2ssq %rax, %xmm4, %xmm3
++; AVX512-NEXT:    vinsertps {{.*#+}} xmm2 = xmm2[0,1],xmm3[0],xmm2[3]
++; AVX512-NEXT:    vpextrq $1, %xmm0, %rax
++; AVX512-NEXT:    vcvtsi2ssq %rax, %xmm4, %xmm0
++; AVX512-NEXT:    vinsertps {{.*#+}} xmm0 = xmm2[0,1,2],xmm0[0]
++; AVX512-NEXT:    vinsertf32x4 $1, %xmm1, %ymm0, %ymm0
++; AVX512-NEXT:    retq
+   %ld = load <8 x i64>, <8 x i64> *%a
+   %cvt = sitofp <8 x i64> %ld to <8 x float>
+   ret <8 x float> %cvt
+@@ -2733,12 +2842,12 @@ define <4 x float> @uitofp_load_4i64_to_4f32(<4 x i64> *%a) {
+ ; AVX1-NEXT:    testq %rax, %rax
+ ; AVX1-NEXT:    js .LBB74_1
+ ; AVX1-NEXT:  # BB#2:
+-; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm1
++; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm1, %xmm1
+ ; AVX1-NEXT:    jmp .LBB74_3
+ ; AVX1-NEXT:  .LBB74_1:
+ ; AVX1-NEXT:    shrq %rax
+ ; AVX1-NEXT:    orq %rax, %rcx
+-; AVX1-NEXT:    vcvtsi2ssq %rcx, %xmm0, %xmm1
++; AVX1-NEXT:    vcvtsi2ssq %rcx, %xmm1, %xmm1
+ ; AVX1-NEXT:    vaddss %xmm1, %xmm1, %xmm1
+ ; AVX1-NEXT:  .LBB74_3:
+ ; AVX1-NEXT:    vmovq %xmm0, %rax
+@@ -2747,12 +2856,12 @@ define <4 x float> @uitofp_load_4i64_to_4f32(<4 x i64> *%a) {
+ ; AVX1-NEXT:    testq %rax, %rax
+ ; AVX1-NEXT:    js .LBB74_4
+ ; AVX1-NEXT:  # BB#5:
+-; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm2
++; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm2, %xmm2
+ ; AVX1-NEXT:    jmp .LBB74_6
+ ; AVX1-NEXT:  .LBB74_4:
+ ; AVX1-NEXT:    shrq %rax
+ ; AVX1-NEXT:    orq %rax, %rcx
+-; AVX1-NEXT:    vcvtsi2ssq %rcx, %xmm0, %xmm2
++; AVX1-NEXT:    vcvtsi2ssq %rcx, %xmm2, %xmm2
+ ; AVX1-NEXT:    vaddss %xmm2, %xmm2, %xmm2
+ ; AVX1-NEXT:  .LBB74_6:
+ ; AVX1-NEXT:    vinsertps {{.*#+}} xmm1 = xmm2[0],xmm1[0],xmm2[2,3]
+@@ -2763,12 +2872,12 @@ define <4 x float> @uitofp_load_4i64_to_4f32(<4 x i64> *%a) {
+ ; AVX1-NEXT:    testq %rax, %rax
+ ; AVX1-NEXT:    js .LBB74_7
+ ; AVX1-NEXT:  # BB#8:
+-; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm2
++; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm3, %xmm2
+ ; AVX1-NEXT:    jmp .LBB74_9
+ ; AVX1-NEXT:  .LBB74_7:
+ ; AVX1-NEXT:    shrq %rax
+ ; AVX1-NEXT:    orq %rax, %rcx
+-; AVX1-NEXT:    vcvtsi2ssq %rcx, %xmm0, %xmm2
++; AVX1-NEXT:    vcvtsi2ssq %rcx, %xmm3, %xmm2
+ ; AVX1-NEXT:    vaddss %xmm2, %xmm2, %xmm2
+ ; AVX1-NEXT:  .LBB74_9:
+ ; AVX1-NEXT:    vinsertps {{.*#+}} xmm1 = xmm1[0,1],xmm2[0],xmm1[3]
+@@ -2778,16 +2887,14 @@ define <4 x float> @uitofp_load_4i64_to_4f32(<4 x i64> *%a) {
+ ; AVX1-NEXT:    testq %rax, %rax
+ ; AVX1-NEXT:    js .LBB74_10
+ ; AVX1-NEXT:  # BB#11:
+-; AVX1-NEXT:    vxorps %xmm0, %xmm0, %xmm0
+-; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm0
++; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm3, %xmm0
+ ; AVX1-NEXT:    vinsertps {{.*#+}} xmm0 = xmm1[0,1,2],xmm0[0]
+ ; AVX1-NEXT:    vzeroupper
+ ; AVX1-NEXT:    retq
+ ; AVX1-NEXT:  .LBB74_10:
+ ; AVX1-NEXT:    shrq %rax
+ ; AVX1-NEXT:    orq %rax, %rcx
+-; AVX1-NEXT:    vxorps %xmm0, %xmm0, %xmm0
+-; AVX1-NEXT:    vcvtsi2ssq %rcx, %xmm0, %xmm0
++; AVX1-NEXT:    vcvtsi2ssq %rcx, %xmm3, %xmm0
+ ; AVX1-NEXT:    vaddss %xmm0, %xmm0, %xmm0
+ ; AVX1-NEXT:    vinsertps {{.*#+}} xmm0 = xmm1[0,1,2],xmm0[0]
+ ; AVX1-NEXT:    vzeroupper
+@@ -2802,12 +2909,12 @@ define <4 x float> @uitofp_load_4i64_to_4f32(<4 x i64> *%a) {
+ ; AVX2-NEXT:    testq %rax, %rax
+ ; AVX2-NEXT:    js .LBB74_1
+ ; AVX2-NEXT:  # BB#2:
+-; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm1
++; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm1, %xmm1
+ ; AVX2-NEXT:    jmp .LBB74_3
+ ; AVX2-NEXT:  .LBB74_1:
+ ; AVX2-NEXT:    shrq %rax
+ ; AVX2-NEXT:    orq %rax, %rcx
+-; AVX2-NEXT:    vcvtsi2ssq %rcx, %xmm0, %xmm1
++; AVX2-NEXT:    vcvtsi2ssq %rcx, %xmm1, %xmm1
+ ; AVX2-NEXT:    vaddss %xmm1, %xmm1, %xmm1
+ ; AVX2-NEXT:  .LBB74_3:
+ ; AVX2-NEXT:    vmovq %xmm0, %rax
+@@ -2816,12 +2923,12 @@ define <4 x float> @uitofp_load_4i64_to_4f32(<4 x i64> *%a) {
+ ; AVX2-NEXT:    testq %rax, %rax
+ ; AVX2-NEXT:    js .LBB74_4
+ ; AVX2-NEXT:  # BB#5:
+-; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm2
++; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm2, %xmm2
+ ; AVX2-NEXT:    jmp .LBB74_6
+ ; AVX2-NEXT:  .LBB74_4:
+ ; AVX2-NEXT:    shrq %rax
+ ; AVX2-NEXT:    orq %rax, %rcx
+-; AVX2-NEXT:    vcvtsi2ssq %rcx, %xmm0, %xmm2
++; AVX2-NEXT:    vcvtsi2ssq %rcx, %xmm2, %xmm2
+ ; AVX2-NEXT:    vaddss %xmm2, %xmm2, %xmm2
+ ; AVX2-NEXT:  .LBB74_6:
+ ; AVX2-NEXT:    vinsertps {{.*#+}} xmm1 = xmm2[0],xmm1[0],xmm2[2,3]
+@@ -2832,12 +2939,12 @@ define <4 x float> @uitofp_load_4i64_to_4f32(<4 x i64> *%a) {
+ ; AVX2-NEXT:    testq %rax, %rax
+ ; AVX2-NEXT:    js .LBB74_7
+ ; AVX2-NEXT:  # BB#8:
+-; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm2
++; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm3, %xmm2
+ ; AVX2-NEXT:    jmp .LBB74_9
+ ; AVX2-NEXT:  .LBB74_7:
+ ; AVX2-NEXT:    shrq %rax
+ ; AVX2-NEXT:    orq %rax, %rcx
+-; AVX2-NEXT:    vcvtsi2ssq %rcx, %xmm0, %xmm2
++; AVX2-NEXT:    vcvtsi2ssq %rcx, %xmm3, %xmm2
+ ; AVX2-NEXT:    vaddss %xmm2, %xmm2, %xmm2
+ ; AVX2-NEXT:  .LBB74_9:
+ ; AVX2-NEXT:    vinsertps {{.*#+}} xmm1 = xmm1[0,1],xmm2[0],xmm1[3]
+@@ -2847,16 +2954,14 @@ define <4 x float> @uitofp_load_4i64_to_4f32(<4 x i64> *%a) {
+ ; AVX2-NEXT:    testq %rax, %rax
+ ; AVX2-NEXT:    js .LBB74_10
+ ; AVX2-NEXT:  # BB#11:
+-; AVX2-NEXT:    vxorps %xmm0, %xmm0, %xmm0
+-; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm0
++; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm3, %xmm0
+ ; AVX2-NEXT:    vinsertps {{.*#+}} xmm0 = xmm1[0,1,2],xmm0[0]
+ ; AVX2-NEXT:    vzeroupper
+ ; AVX2-NEXT:    retq
+ ; AVX2-NEXT:  .LBB74_10:
+ ; AVX2-NEXT:    shrq %rax
+ ; AVX2-NEXT:    orq %rax, %rcx
+-; AVX2-NEXT:    vxorps %xmm0, %xmm0, %xmm0
+-; AVX2-NEXT:    vcvtsi2ssq %rcx, %xmm0, %xmm0
++; AVX2-NEXT:    vcvtsi2ssq %rcx, %xmm3, %xmm0
+ ; AVX2-NEXT:    vaddss %xmm0, %xmm0, %xmm0
+ ; AVX2-NEXT:    vinsertps {{.*#+}} xmm0 = xmm1[0,1,2],xmm0[0]
+ ; AVX2-NEXT:    vzeroupper
+@@ -3094,12 +3199,12 @@ define <8 x float> @uitofp_load_8i64_to_8f32(<8 x i64> *%a) {
+ ; AVX1-NEXT:    testq %rax, %rax
+ ; AVX1-NEXT:    js .LBB78_1
+ ; AVX1-NEXT:  # BB#2:
+-; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm1
++; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm1, %xmm1
+ ; AVX1-NEXT:    jmp .LBB78_3
+ ; AVX1-NEXT:  .LBB78_1:
+ ; AVX1-NEXT:    shrq %rax
+ ; AVX1-NEXT:    orq %rax, %rcx
+-; AVX1-NEXT:    vcvtsi2ssq %rcx, %xmm0, %xmm1
++; AVX1-NEXT:    vcvtsi2ssq %rcx, %xmm1, %xmm1
+ ; AVX1-NEXT:    vaddss %xmm1, %xmm1, %xmm1
+ ; AVX1-NEXT:  .LBB78_3:
+ ; AVX1-NEXT:    vmovq %xmm2, %rax
+@@ -3108,12 +3213,12 @@ define <8 x float> @uitofp_load_8i64_to_8f32(<8 x i64> *%a) {
+ ; AVX1-NEXT:    testq %rax, %rax
+ ; AVX1-NEXT:    js .LBB78_4
+ ; AVX1-NEXT:  # BB#5:
+-; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm3
++; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm3, %xmm3
+ ; AVX1-NEXT:    jmp .LBB78_6
+ ; AVX1-NEXT:  .LBB78_4:
+ ; AVX1-NEXT:    shrq %rax
+ ; AVX1-NEXT:    orq %rax, %rcx
+-; AVX1-NEXT:    vcvtsi2ssq %rcx, %xmm0, %xmm3
++; AVX1-NEXT:    vcvtsi2ssq %rcx, %xmm3, %xmm3
+ ; AVX1-NEXT:    vaddss %xmm3, %xmm3, %xmm3
+ ; AVX1-NEXT:  .LBB78_6:
+ ; AVX1-NEXT:    vextractf128 $1, %ymm2, %xmm2
+@@ -3123,12 +3228,12 @@ define <8 x float> @uitofp_load_8i64_to_8f32(<8 x i64> *%a) {
+ ; AVX1-NEXT:    testq %rax, %rax
+ ; AVX1-NEXT:    js .LBB78_7
+ ; AVX1-NEXT:  # BB#8:
+-; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm4
++; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm4, %xmm4
+ ; AVX1-NEXT:    jmp .LBB78_9
+ ; AVX1-NEXT:  .LBB78_7:
+ ; AVX1-NEXT:    shrq %rax
+ ; AVX1-NEXT:    orq %rax, %rcx
+-; AVX1-NEXT:    vcvtsi2ssq %rcx, %xmm0, %xmm4
++; AVX1-NEXT:    vcvtsi2ssq %rcx, %xmm4, %xmm4
+ ; AVX1-NEXT:    vaddss %xmm4, %xmm4, %xmm4
+ ; AVX1-NEXT:  .LBB78_9:
+ ; AVX1-NEXT:    vpextrq $1, %xmm2, %rax
+@@ -3137,12 +3242,12 @@ define <8 x float> @uitofp_load_8i64_to_8f32(<8 x i64> *%a) {
+ ; AVX1-NEXT:    testq %rax, %rax
+ ; AVX1-NEXT:    js .LBB78_10
+ ; AVX1-NEXT:  # BB#11:
+-; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm2
++; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm5, %xmm2
+ ; AVX1-NEXT:    jmp .LBB78_12
+ ; AVX1-NEXT:  .LBB78_10:
+ ; AVX1-NEXT:    shrq %rax
+ ; AVX1-NEXT:    orq %rax, %rcx
+-; AVX1-NEXT:    vcvtsi2ssq %rcx, %xmm0, %xmm2
++; AVX1-NEXT:    vcvtsi2ssq %rcx, %xmm5, %xmm2
+ ; AVX1-NEXT:    vaddss %xmm2, %xmm2, %xmm2
+ ; AVX1-NEXT:  .LBB78_12:
+ ; AVX1-NEXT:    vpextrq $1, %xmm0, %rax
+@@ -3151,12 +3256,12 @@ define <8 x float> @uitofp_load_8i64_to_8f32(<8 x i64> *%a) {
+ ; AVX1-NEXT:    testq %rax, %rax
+ ; AVX1-NEXT:    js .LBB78_13
+ ; AVX1-NEXT:  # BB#14:
+-; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm5
++; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm5, %xmm5
+ ; AVX1-NEXT:    jmp .LBB78_15
+ ; AVX1-NEXT:  .LBB78_13:
+ ; AVX1-NEXT:    shrq %rax
+ ; AVX1-NEXT:    orq %rax, %rcx
+-; AVX1-NEXT:    vcvtsi2ssq %rcx, %xmm0, %xmm5
++; AVX1-NEXT:    vcvtsi2ssq %rcx, %xmm5, %xmm5
+ ; AVX1-NEXT:    vaddss %xmm5, %xmm5, %xmm5
+ ; AVX1-NEXT:  .LBB78_15:
+ ; AVX1-NEXT:    vinsertps {{.*#+}} xmm1 = xmm3[0],xmm1[0],xmm3[2,3]
+@@ -3166,12 +3271,12 @@ define <8 x float> @uitofp_load_8i64_to_8f32(<8 x i64> *%a) {
+ ; AVX1-NEXT:    testq %rax, %rax
+ ; AVX1-NEXT:    js .LBB78_16
+ ; AVX1-NEXT:  # BB#17:
+-; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm3
++; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm6, %xmm3
+ ; AVX1-NEXT:    jmp .LBB78_18
+ ; AVX1-NEXT:  .LBB78_16:
+ ; AVX1-NEXT:    shrq %rax
+ ; AVX1-NEXT:    orq %rax, %rcx
+-; AVX1-NEXT:    vcvtsi2ssq %rcx, %xmm0, %xmm3
++; AVX1-NEXT:    vcvtsi2ssq %rcx, %xmm6, %xmm3
+ ; AVX1-NEXT:    vaddss %xmm3, %xmm3, %xmm3
+ ; AVX1-NEXT:  .LBB78_18:
+ ; AVX1-NEXT:    vinsertps {{.*#+}} xmm1 = xmm1[0,1],xmm4[0],xmm1[3]
+@@ -3183,14 +3288,12 @@ define <8 x float> @uitofp_load_8i64_to_8f32(<8 x i64> *%a) {
+ ; AVX1-NEXT:    testq %rax, %rax
+ ; AVX1-NEXT:    js .LBB78_19
+ ; AVX1-NEXT:  # BB#20:
+-; AVX1-NEXT:    vxorps %xmm0, %xmm0, %xmm0
+-; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm5
++; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm6, %xmm5
+ ; AVX1-NEXT:    jmp .LBB78_21
+ ; AVX1-NEXT:  .LBB78_19:
+ ; AVX1-NEXT:    shrq %rax
+ ; AVX1-NEXT:    orq %rax, %rcx
+-; AVX1-NEXT:    vxorps %xmm0, %xmm0, %xmm0
+-; AVX1-NEXT:    vcvtsi2ssq %rcx, %xmm0, %xmm0
++; AVX1-NEXT:    vcvtsi2ssq %rcx, %xmm6, %xmm0
+ ; AVX1-NEXT:    vaddss %xmm0, %xmm0, %xmm5
+ ; AVX1-NEXT:  .LBB78_21:
+ ; AVX1-NEXT:    vinsertps {{.*#+}} xmm0 = xmm1[0,1,2],xmm2[0]
+@@ -3201,12 +3304,12 @@ define <8 x float> @uitofp_load_8i64_to_8f32(<8 x i64> *%a) {
+ ; AVX1-NEXT:    testq %rax, %rax
+ ; AVX1-NEXT:    js .LBB78_22
+ ; AVX1-NEXT:  # BB#23:
+-; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm2
++; AVX1-NEXT:    vcvtsi2ssq %rax, %xmm6, %xmm2
+ ; AVX1-NEXT:    jmp .LBB78_24
+ ; AVX1-NEXT:  .LBB78_22:
+ ; AVX1-NEXT:    shrq %rax
+ ; AVX1-NEXT:    orq %rax, %rcx
+-; AVX1-NEXT:    vcvtsi2ssq %rcx, %xmm0, %xmm2
++; AVX1-NEXT:    vcvtsi2ssq %rcx, %xmm6, %xmm2
+ ; AVX1-NEXT:    vaddss %xmm2, %xmm2, %xmm2
+ ; AVX1-NEXT:  .LBB78_24:
+ ; AVX1-NEXT:    vinsertps {{.*#+}} xmm1 = xmm1[0,1,2],xmm2[0]
+@@ -3223,12 +3326,12 @@ define <8 x float> @uitofp_load_8i64_to_8f32(<8 x i64> *%a) {
+ ; AVX2-NEXT:    testq %rax, %rax
+ ; AVX2-NEXT:    js .LBB78_1
+ ; AVX2-NEXT:  # BB#2:
+-; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm1
++; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm1, %xmm1
+ ; AVX2-NEXT:    jmp .LBB78_3
+ ; AVX2-NEXT:  .LBB78_1:
+ ; AVX2-NEXT:    shrq %rax
+ ; AVX2-NEXT:    orq %rax, %rcx
+-; AVX2-NEXT:    vcvtsi2ssq %rcx, %xmm0, %xmm1
++; AVX2-NEXT:    vcvtsi2ssq %rcx, %xmm1, %xmm1
+ ; AVX2-NEXT:    vaddss %xmm1, %xmm1, %xmm1
+ ; AVX2-NEXT:  .LBB78_3:
+ ; AVX2-NEXT:    vmovq %xmm2, %rax
+@@ -3237,12 +3340,12 @@ define <8 x float> @uitofp_load_8i64_to_8f32(<8 x i64> *%a) {
+ ; AVX2-NEXT:    testq %rax, %rax
+ ; AVX2-NEXT:    js .LBB78_4
+ ; AVX2-NEXT:  # BB#5:
+-; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm3
++; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm3, %xmm3
+ ; AVX2-NEXT:    jmp .LBB78_6
+ ; AVX2-NEXT:  .LBB78_4:
+ ; AVX2-NEXT:    shrq %rax
+ ; AVX2-NEXT:    orq %rax, %rcx
+-; AVX2-NEXT:    vcvtsi2ssq %rcx, %xmm0, %xmm3
++; AVX2-NEXT:    vcvtsi2ssq %rcx, %xmm3, %xmm3
+ ; AVX2-NEXT:    vaddss %xmm3, %xmm3, %xmm3
+ ; AVX2-NEXT:  .LBB78_6:
+ ; AVX2-NEXT:    vextracti128 $1, %ymm2, %xmm2
+@@ -3252,12 +3355,12 @@ define <8 x float> @uitofp_load_8i64_to_8f32(<8 x i64> *%a) {
+ ; AVX2-NEXT:    testq %rax, %rax
+ ; AVX2-NEXT:    js .LBB78_7
+ ; AVX2-NEXT:  # BB#8:
+-; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm4
++; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm4, %xmm4
+ ; AVX2-NEXT:    jmp .LBB78_9
+ ; AVX2-NEXT:  .LBB78_7:
+ ; AVX2-NEXT:    shrq %rax
+ ; AVX2-NEXT:    orq %rax, %rcx
+-; AVX2-NEXT:    vcvtsi2ssq %rcx, %xmm0, %xmm4
++; AVX2-NEXT:    vcvtsi2ssq %rcx, %xmm4, %xmm4
+ ; AVX2-NEXT:    vaddss %xmm4, %xmm4, %xmm4
+ ; AVX2-NEXT:  .LBB78_9:
+ ; AVX2-NEXT:    vpextrq $1, %xmm2, %rax
+@@ -3266,12 +3369,12 @@ define <8 x float> @uitofp_load_8i64_to_8f32(<8 x i64> *%a) {
+ ; AVX2-NEXT:    testq %rax, %rax
+ ; AVX2-NEXT:    js .LBB78_10
+ ; AVX2-NEXT:  # BB#11:
+-; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm2
++; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm5, %xmm2
+ ; AVX2-NEXT:    jmp .LBB78_12
+ ; AVX2-NEXT:  .LBB78_10:
+ ; AVX2-NEXT:    shrq %rax
+ ; AVX2-NEXT:    orq %rax, %rcx
+-; AVX2-NEXT:    vcvtsi2ssq %rcx, %xmm0, %xmm2
++; AVX2-NEXT:    vcvtsi2ssq %rcx, %xmm5, %xmm2
+ ; AVX2-NEXT:    vaddss %xmm2, %xmm2, %xmm2
+ ; AVX2-NEXT:  .LBB78_12:
+ ; AVX2-NEXT:    vpextrq $1, %xmm0, %rax
+@@ -3280,12 +3383,12 @@ define <8 x float> @uitofp_load_8i64_to_8f32(<8 x i64> *%a) {
+ ; AVX2-NEXT:    testq %rax, %rax
+ ; AVX2-NEXT:    js .LBB78_13
+ ; AVX2-NEXT:  # BB#14:
+-; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm5
++; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm5, %xmm5
+ ; AVX2-NEXT:    jmp .LBB78_15
+ ; AVX2-NEXT:  .LBB78_13:
+ ; AVX2-NEXT:    shrq %rax
+ ; AVX2-NEXT:    orq %rax, %rcx
+-; AVX2-NEXT:    vcvtsi2ssq %rcx, %xmm0, %xmm5
++; AVX2-NEXT:    vcvtsi2ssq %rcx, %xmm5, %xmm5
+ ; AVX2-NEXT:    vaddss %xmm5, %xmm5, %xmm5
+ ; AVX2-NEXT:  .LBB78_15:
+ ; AVX2-NEXT:    vinsertps {{.*#+}} xmm1 = xmm3[0],xmm1[0],xmm3[2,3]
+@@ -3295,12 +3398,12 @@ define <8 x float> @uitofp_load_8i64_to_8f32(<8 x i64> *%a) {
+ ; AVX2-NEXT:    testq %rax, %rax
+ ; AVX2-NEXT:    js .LBB78_16
+ ; AVX2-NEXT:  # BB#17:
+-; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm3
++; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm6, %xmm3
+ ; AVX2-NEXT:    jmp .LBB78_18
+ ; AVX2-NEXT:  .LBB78_16:
+ ; AVX2-NEXT:    shrq %rax
+ ; AVX2-NEXT:    orq %rax, %rcx
+-; AVX2-NEXT:    vcvtsi2ssq %rcx, %xmm0, %xmm3
++; AVX2-NEXT:    vcvtsi2ssq %rcx, %xmm6, %xmm3
+ ; AVX2-NEXT:    vaddss %xmm3, %xmm3, %xmm3
+ ; AVX2-NEXT:  .LBB78_18:
+ ; AVX2-NEXT:    vinsertps {{.*#+}} xmm1 = xmm1[0,1],xmm4[0],xmm1[3]
+@@ -3312,14 +3415,12 @@ define <8 x float> @uitofp_load_8i64_to_8f32(<8 x i64> *%a) {
+ ; AVX2-NEXT:    testq %rax, %rax
+ ; AVX2-NEXT:    js .LBB78_19
+ ; AVX2-NEXT:  # BB#20:
+-; AVX2-NEXT:    vxorps %xmm0, %xmm0, %xmm0
+-; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm5
++; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm6, %xmm5
+ ; AVX2-NEXT:    jmp .LBB78_21
+ ; AVX2-NEXT:  .LBB78_19:
+ ; AVX2-NEXT:    shrq %rax
+ ; AVX2-NEXT:    orq %rax, %rcx
+-; AVX2-NEXT:    vxorps %xmm0, %xmm0, %xmm0
+-; AVX2-NEXT:    vcvtsi2ssq %rcx, %xmm0, %xmm0
++; AVX2-NEXT:    vcvtsi2ssq %rcx, %xmm6, %xmm0
+ ; AVX2-NEXT:    vaddss %xmm0, %xmm0, %xmm5
+ ; AVX2-NEXT:  .LBB78_21:
+ ; AVX2-NEXT:    vinsertps {{.*#+}} xmm0 = xmm1[0,1,2],xmm2[0]
+@@ -3330,12 +3431,12 @@ define <8 x float> @uitofp_load_8i64_to_8f32(<8 x i64> *%a) {
+ ; AVX2-NEXT:    testq %rax, %rax
+ ; AVX2-NEXT:    js .LBB78_22
+ ; AVX2-NEXT:  # BB#23:
+-; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm0, %xmm2
++; AVX2-NEXT:    vcvtsi2ssq %rax, %xmm6, %xmm2
+ ; AVX2-NEXT:    jmp .LBB78_24
+ ; AVX2-NEXT:  .LBB78_22:
+ ; AVX2-NEXT:    shrq %rax
+ ; AVX2-NEXT:    orq %rax, %rcx
+-; AVX2-NEXT:    vcvtsi2ssq %rcx, %xmm0, %xmm2
++; AVX2-NEXT:    vcvtsi2ssq %rcx, %xmm6, %xmm2
+ ; AVX2-NEXT:    vaddss %xmm2, %xmm2, %xmm2
+ ; AVX2-NEXT:  .LBB78_24:
+ ; AVX2-NEXT:    vinsertps {{.*#+}} xmm1 = xmm1[0,1,2],xmm2[0]
+-- 
+2.11.0
+
diff --git a/deps/patches/llvm-PR278923.patch b/deps/patches/llvm-PR278923.patch
new file mode 100644
index 00000000000000..486777711193af
--- /dev/null
+++ b/deps/patches/llvm-PR278923.patch
@@ -0,0 +1,69 @@
+From 77eee1c0f05c587e7fb8a9a2064908d7333dcfb9 Mon Sep 17 00:00:00 2001
+From: Marina Yatsina <marina.yatsina@intel.com>
+Date: Wed, 17 Aug 2016 11:40:21 +0000
+Subject: [PATCH 5/5] Fixing bug committed in rev. 278321
+
+In theory the indices of RC (and thus the index used for LiveRegs) may differ from the indices of OpRC.
+Fixed the code to extract the correct RC index.
+OpRC contains the first X consecutive elements of RC, and thus their indices are currently de facto the same, therefore a test cannot be added at this point.
+
+Differential Revision: https://reviews.llvm.org/D23491
+
+
+
+git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@278923 91177308-0d34-0410-b5e6-96231b3b80d8
+---
+ include/llvm/Target/TargetRegisterInfo.h | 6 ++++++
+ lib/CodeGen/ExecutionDepsFix.cpp         | 9 ++++++---
+ 2 files changed, 12 insertions(+), 3 deletions(-)
+
+diff --git a/include/llvm/Target/TargetRegisterInfo.h b/include/llvm/Target/TargetRegisterInfo.h
+index e5a6c8ed2f2..e5642493928 100644
+--- a/include/llvm/Target/TargetRegisterInfo.h
++++ b/include/llvm/Target/TargetRegisterInfo.h
+@@ -17,6 +17,7 @@
+ #define LLVM_TARGET_TARGETREGISTERINFO_H
+ 
+ #include "llvm/ADT/ArrayRef.h"
++#include "llvm/ADT/iterator_range.h"
+ #include "llvm/CodeGen/MachineBasicBlock.h"
+ #include "llvm/CodeGen/MachineValueType.h"
+ #include "llvm/IR/CallingConv.h"
+@@ -86,6 +87,11 @@ public:
+ 
+   /// Return the number of registers in this class.
+   unsigned getNumRegs() const { return MC->getNumRegs(); }
++  
++  iterator_range<SmallVectorImpl<MCPhysReg>::const_iterator>
++  getRegisters() const {
++    return make_range(MC->begin(), MC->end());
++  }
+ 
+   /// Return the specified register in the class.
+   unsigned getRegister(unsigned i) const {
+diff --git a/lib/CodeGen/ExecutionDepsFix.cpp b/lib/CodeGen/ExecutionDepsFix.cpp
+index 5f91db9251c..213dd58a31d 100644
+--- a/lib/CodeGen/ExecutionDepsFix.cpp
++++ b/lib/CodeGen/ExecutionDepsFix.cpp
+@@ -509,12 +509,15 @@ void ExeDepsFix::pickBestRegisterForUndef(MachineInstr *MI, unsigned OpIdx,
+   // max clearance or clearance higher than Pref.
+   unsigned MaxClearance = 0;
+   unsigned MaxClearanceReg = OriginalReg;
+-  for (unsigned rx = 0; rx < OpRC->getNumRegs(); ++rx) {
+-    unsigned Clearance = CurInstr - LiveRegs[rx].Def;
++  for (auto Reg : OpRC->getRegisters()) {
++    assert(AliasMap[Reg].size() == 1 &&
++           "Reg is expected to be mapped to a single index");
++    int RCrx = *regIndices(Reg).begin();
++    unsigned Clearance = CurInstr - LiveRegs[RCrx].Def;
+     if (Clearance <= MaxClearance)
+       continue;
+     MaxClearance = Clearance;
+-    MaxClearanceReg = OpRC->getRegister(rx);
++    MaxClearanceReg = Reg;
+ 
+     if (MaxClearance > Pref)
+       break;
+-- 
+2.11.0
+
diff --git a/deps/patches/llvm-PR29010-i386-xmm.patch b/deps/patches/llvm-PR29010-i386-xmm.patch
new file mode 100644
index 00000000000000..b31f70d365cf03
--- /dev/null
+++ b/deps/patches/llvm-PR29010-i386-xmm.patch
@@ -0,0 +1,80 @@
+From 83260f239481dfb40d325cf35005c20eeb767b6c Mon Sep 17 00:00:00 2001
+From: Marina Yatsina <marina.yatsina@intel.com>
+Date: Wed, 17 Aug 2016 19:07:40 +0000
+Subject: [PATCH] Fix for PR29010
+
+This is a fix for https://llvm.org/bugs/show_bug.cgi?id=29010
+Root cause of the bug is that the register class of the machine instruction operand does not fully reflect if this registers that can be allocated.
+Both for i386 and x86_64 the operand's register class is VR128RegClass and thus contains xmm0-xmm15, though in i386 we can only use xmm0-xmm8.
+In order to get the actual allocable registers of the class we need to use RegisterClassInfo.
+
+Differential Revision: https://reviews.llvm.org/D23613
+
+
+
+git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@278954 91177308-0d34-0410-b5e6-96231b3b80d8
+---
+ lib/CodeGen/ExecutionDepsFix.cpp |  6 +++++-
+ test/CodeGen/X86/pr29010.ll      | 12 ++++++++++++
+ 2 files changed, 17 insertions(+), 1 deletion(-)
+ create mode 100644 test/CodeGen/X86/pr29010.ll
+
+diff --git a/lib/CodeGen/ExecutionDepsFix.cpp b/lib/CodeGen/ExecutionDepsFix.cpp
+index 213dd58a31d..2f173f84d73 100644
+--- a/lib/CodeGen/ExecutionDepsFix.cpp
++++ b/lib/CodeGen/ExecutionDepsFix.cpp
+@@ -26,6 +26,7 @@
+ #include "llvm/CodeGen/LivePhysRegs.h"
+ #include "llvm/CodeGen/MachineFunctionPass.h"
+ #include "llvm/CodeGen/MachineRegisterInfo.h"
++#include "llvm/CodeGen/RegisterClassInfo.h"
+ #include "llvm/Support/Allocator.h"
+ #include "llvm/Support/Debug.h"
+ #include "llvm/Support/raw_ostream.h"
+@@ -137,6 +138,7 @@ class ExeDepsFix : public MachineFunctionPass {
+   MachineFunction *MF;
+   const TargetInstrInfo *TII;
+   const TargetRegisterInfo *TRI;
++  RegisterClassInfo RegClassInfo;
+   std::vector<SmallVector<int, 1>> AliasMap;
+   const unsigned NumRegs;
+   LiveReg *LiveRegs;
+@@ -509,7 +511,8 @@ void ExeDepsFix::pickBestRegisterForUndef(MachineInstr *MI, unsigned OpIdx,
+   // max clearance or clearance higher than Pref.
+   unsigned MaxClearance = 0;
+   unsigned MaxClearanceReg = OriginalReg;
+-  for (auto Reg : OpRC->getRegisters()) {
++  ArrayRef<MCPhysReg> Order = RegClassInfo.getOrder(OpRC);
++  for (auto Reg : Order) {
+     assert(AliasMap[Reg].size() == 1 &&
+            "Reg is expected to be mapped to a single index");
+     int RCrx = *regIndices(Reg).begin();
+@@ -785,6 +788,7 @@ bool ExeDepsFix::runOnMachineFunction(MachineFunction &mf) {
+   MF = &mf;
+   TII = MF->getSubtarget().getInstrInfo();
+   TRI = MF->getSubtarget().getRegisterInfo();
++  RegClassInfo.runOnMachineFunction(mf);
+   LiveRegs = nullptr;
+   assert(NumRegs == RC->getNumRegs() && "Bad regclass");
+ 
+diff --git a/test/CodeGen/X86/pr29010.ll b/test/CodeGen/X86/pr29010.ll
+new file mode 100644
+index 00000000000..a2d5ff69a35
+--- /dev/null
++++ b/test/CodeGen/X86/pr29010.ll
+@@ -0,0 +1,12 @@
++; RUN: llc < %s -mtriple=i386-linux -mattr=+avx | FileCheck %s
++
++; In i386 there are only 8 XMMs (xmm0-xmm7), make sure we we are not creating illegal XMM
++define float @only_xmm0_7(i32 %arg) {
++top:
++  tail call void asm sideeffect "", "~{xmm0},~{xmm1},~{xmm2},~{xmm3},~{dirflag},~{fpsr},~{flags}"()
++  tail call void asm sideeffect "", "~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{dirflag},~{fpsr},~{flags}"()
++  %tmp1 = sitofp i32 %arg to float
++  ret float %tmp1
++;CHECK-LABEL:@only_xmm0_7
++;CHECK: vcvtsi2ssl {{.*}}, {{%xmm[0-7]+}}, {{%xmm[0-7]+}}
++}
+-- 
+2.13.0
+
diff --git a/deps/patches/llvm-VNCoercion-signatures.patch b/deps/patches/llvm-VNCoercion-signatures.patch
new file mode 100644
index 00000000000000..5b8923ee476781
--- /dev/null
+++ b/deps/patches/llvm-VNCoercion-signatures.patch
@@ -0,0 +1,60 @@
+From a0946a413f7ee14ed26c48a249b2a326ade70a42 Mon Sep 17 00:00:00 2001
+From: Daniel Berlin <dberlin@dberlin.org>
+Date: Sat, 11 Mar 2017 00:51:01 +0000
+Subject: [PATCH 6/7] VNCoercion: Make the function signatures all consistent
+
+git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@297537 91177308-0d34-0410-b5e6-96231b3b80d8
+---
+ include/llvm/Transforms/Utils/VNCoercion.h | 2 +-
+ lib/Transforms/Scalar/GVN.cpp              | 2 +-
+ lib/Transforms/Utils/VNCoercion.cpp        | 3 +--
+ 3 files changed, 3 insertions(+), 4 deletions(-)
+
+diff --git a/include/llvm/Transforms/Utils/VNCoercion.h b/include/llvm/Transforms/Utils/VNCoercion.h
+index d3c998fa8a8..edc63ca38db 100644
+--- a/include/llvm/Transforms/Utils/VNCoercion.h
++++ b/include/llvm/Transforms/Utils/VNCoercion.h
+@@ -53,7 +53,7 @@ Value *coerceAvailableValueToLoadType(Value *StoredVal, Type *LoadedTy,
+ /// On success, it returns the offset into DepSI that extraction would start.
+ /// On failure, it returns -1.
+ int analyzeLoadFromClobberingStore(Type *LoadTy, Value *LoadPtr,
+-                                   StoreInst *DepSI);
++                                   StoreInst *DepSI, const DataLayout &DL);
+ 
+ /// This function determines whether a value for the pointer LoadPtr can be
+ /// extracted from the load at DepLI.
+diff --git a/lib/Transforms/Scalar/GVN.cpp b/lib/Transforms/Scalar/GVN.cpp
+index 132c7297d77..7b8948c065b 100644
+--- a/lib/Transforms/Scalar/GVN.cpp
++++ b/lib/Transforms/Scalar/GVN.cpp
+@@ -830,7 +830,7 @@ bool GVN::AnalyzeLoadAvailability(LoadInst *LI, MemDepResult DepInfo,
+       // Can't forward from non-atomic to atomic without violating memory model.
+       if (Address && LI->isAtomic() <= DepSI->isAtomic()) {
+         int Offset =
+-          analyzeLoadFromClobberingStore(LI->getType(), Address, DepSI);
++          analyzeLoadFromClobberingStore(LI->getType(), Address, DepSI, DL);
+         if (Offset != -1) {
+           Res = AvailableValue::get(DepSI->getValueOperand(), Offset);
+           return true;
+diff --git a/lib/Transforms/Utils/VNCoercion.cpp b/lib/Transforms/Utils/VNCoercion.cpp
+index 9d2eab19ded..6fa9aca8436 100644
+--- a/lib/Transforms/Utils/VNCoercion.cpp
++++ b/lib/Transforms/Utils/VNCoercion.cpp
+@@ -195,13 +195,12 @@ static int analyzeLoadFromClobberingWrite(Type *LoadTy, Value *LoadPtr,
+ /// This function is called when we have a
+ /// memdep query of a load that ends up being a clobbering store.
+ int analyzeLoadFromClobberingStore(Type *LoadTy, Value *LoadPtr,
+-                                   StoreInst *DepSI) {
++                                   StoreInst *DepSI, const DataLayout &DL) {
+   // Cannot handle reading from store of first-class aggregate yet.
+   if (DepSI->getValueOperand()->getType()->isStructTy() ||
+       DepSI->getValueOperand()->getType()->isArrayTy())
+     return -1;
+ 
+-  const DataLayout &DL = DepSI->getModule()->getDataLayout();
+   Value *StorePtr = DepSI->getPointerOperand();
+   uint64_t StoreSize =
+       DL.getTypeSizeInBits(DepSI->getValueOperand()->getType());
+-- 
+2.13.1
+
diff --git a/deps/patches/llvm-VNCoercion-template.patch b/deps/patches/llvm-VNCoercion-template.patch
new file mode 100644
index 00000000000000..6aa87a1cf3a33c
--- /dev/null
+++ b/deps/patches/llvm-VNCoercion-template.patch
@@ -0,0 +1,410 @@
+From 67cb3073f40c0d02334e161a1c9c749be777f411 Mon Sep 17 00:00:00 2001
+From: Daniel Berlin <dberlin@dberlin.org>
+Date: Mon, 20 Mar 2017 16:08:29 +0000
+Subject: [PATCH 7/7] Templatize parts of VNCoercion, and add constant-only
+ versions of the functions to be used in NewGVN. NFCI.
+
+Summary:
+This is ground work for the changes to enable coercion in NewGVN.
+GVN doesn't care if they end up constant because it eliminates as it goes.
+NewGVN cares.
+
+IRBuilder and ConstantFolder deliberately present the same interface,
+so we use this to our advantage to templatize our functions to make
+them either constant only or not.
+
+Reviewers: davide
+
+Subscribers: llvm-commits, Prazek
+
+Differential Revision: https://reviews.llvm.org/D30928
+
+git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@298262 91177308-0d34-0410-b5e6-96231b3b80d8
+---
+ include/llvm/Transforms/Utils/VNCoercion.h |  14 ++-
+ lib/Transforms/Scalar/GVN.cpp              |   2 +-
+ lib/Transforms/Utils/VNCoercion.cpp        | 177 ++++++++++++++++++-----------
+ 3 files changed, 124 insertions(+), 69 deletions(-)
+
+diff --git a/include/llvm/Transforms/Utils/VNCoercion.h b/include/llvm/Transforms/Utils/VNCoercion.h
+index edc63ca38db..1baa9b66e49 100644
+--- a/include/llvm/Transforms/Utils/VNCoercion.h
++++ b/include/llvm/Transforms/Utils/VNCoercion.h
+@@ -76,13 +76,21 @@ int analyzeLoadFromClobberingMemInst(Type *LoadTy, Value *LoadPtr,
+ /// inserts instructions to do so at InsertPt, and returns the extracted value.
+ Value *getStoreValueForLoad(Value *SrcVal, unsigned Offset, Type *LoadTy,
+                             Instruction *InsertPt, const DataLayout &DL);
++// This is the same as getStoreValueForLoad, except it performs no insertion
++// It only allows constant inputs.
++Constant *getConstantStoreValueForLoad(Constant *SrcVal, unsigned Offset,
++                                       Type *LoadTy, const DataLayout &DL);
+ 
+ /// If analyzeLoadFromClobberingLoad returned an offset, this function can be
+ /// used to actually perform the extraction of the bits from the load, including
+ /// any necessary load widening.  It inserts instructions to do so at InsertPt,
+ /// and returns the extracted value.
+ Value *getLoadValueForLoad(LoadInst *SrcVal, unsigned Offset, Type *LoadTy,
+-                           Instruction *InsertPt);
++                           Instruction *InsertPt, const DataLayout &DL);
++// This is the same as getLoadValueForLoad, except it is given the load value as
++// a constant. It returns nullptr if it would require widening the load.
++Constant *getConstantLoadValueForLoad(Constant *SrcVal, unsigned Offset,
++                                      Type *LoadTy, const DataLayout &DL);
+ 
+ /// If analyzeLoadFromClobberingMemInst returned an offset, this function can be
+ /// used to actually perform the extraction of the bits from the memory
+@@ -91,6 +99,10 @@ Value *getLoadValueForLoad(LoadInst *SrcVal, unsigned Offset, Type *LoadTy,
+ Value *getMemInstValueForLoad(MemIntrinsic *SrcInst, unsigned Offset,
+                               Type *LoadTy, Instruction *InsertPt,
+                               const DataLayout &DL);
++// This is the same as getStoreValueForLoad, except it performs no insertion.
++// It returns nullptr if it cannot produce a constant.
++Constant *getConstantMemInstValueForLoad(MemIntrinsic *SrcInst, unsigned Offset,
++                                         Type *LoadTy, const DataLayout &DL);
+ }
+ }
+ #endif
+diff --git a/lib/Transforms/Scalar/GVN.cpp b/lib/Transforms/Scalar/GVN.cpp
+index 7b8948c065b..91118ee7e39 100644
+--- a/lib/Transforms/Scalar/GVN.cpp
++++ b/lib/Transforms/Scalar/GVN.cpp
+@@ -748,7 +748,7 @@ Value *AvailableValue::MaterializeAdjustedValue(LoadInst *LI,
+     if (Load->getType() == LoadTy && Offset == 0) {
+       Res = Load;
+     } else {
+-      Res = getLoadValueForLoad(Load, Offset, LoadTy, InsertPt);
++      Res = getLoadValueForLoad(Load, Offset, LoadTy, InsertPt, DL);
+       // We would like to use gvn.markInstructionForDeletion here, but we can't
+       // because the load is already memoized into the leader map table that GVN
+       // tracks.  It is potentially possible to remove the load from the table,
+diff --git a/lib/Transforms/Utils/VNCoercion.cpp b/lib/Transforms/Utils/VNCoercion.cpp
+index 6fa9aca8436..60d9ede2c48 100644
+--- a/lib/Transforms/Utils/VNCoercion.cpp
++++ b/lib/Transforms/Utils/VNCoercion.cpp
+@@ -32,17 +32,12 @@ bool canCoerceMustAliasedValueToLoad(Value *StoredVal, Type *LoadTy,
+   return true;
+ }
+ 
+-/// If we saw a store of a value to memory, and
+-/// then a load from a must-aliased pointer of a different type, try to coerce
+-/// the stored value.  LoadedTy is the type of the load we want to replace.
+-/// IRB is IRBuilder used to insert new instructions.
+-///
+-/// If we can't do it, return null.
+-Value *coerceAvailableValueToLoadType(Value *StoredVal, Type *LoadedTy,
+-                                      IRBuilder<> &IRB, const DataLayout &DL) {
++template <class T, class HelperClass>
++static T *coerceAvailableValueToLoadTypeHelper(T *StoredVal, Type *LoadedTy,
++                                               HelperClass &Helper,
++                                               const DataLayout &DL) {
+   assert(canCoerceMustAliasedValueToLoad(StoredVal, LoadedTy, DL) &&
+          "precondition violation - materialization can't fail");
+-
+   if (auto *C = dyn_cast<Constant>(StoredVal))
+     if (auto *FoldedStoredVal = ConstantFoldConstant(C, DL))
+       StoredVal = FoldedStoredVal;
+@@ -58,12 +53,12 @@ Value *coerceAvailableValueToLoadType(Value *StoredVal, Type *LoadedTy,
+     // Pointer to Pointer -> use bitcast.
+     if (StoredValTy->getScalarType()->isPointerTy() &&
+         LoadedTy->getScalarType()->isPointerTy()) {
+-      StoredVal = IRB.CreateBitCast(StoredVal, LoadedTy);
++      StoredVal = Helper.CreateBitCast(StoredVal, LoadedTy);
+     } else {
+       // Convert source pointers to integers, which can be bitcast.
+       if (StoredValTy->getScalarType()->isPointerTy()) {
+         StoredValTy = DL.getIntPtrType(StoredValTy);
+-        StoredVal = IRB.CreatePtrToInt(StoredVal, StoredValTy);
++        StoredVal = Helper.CreatePtrToInt(StoredVal, StoredValTy);
+       }
+ 
+       Type *TypeToCastTo = LoadedTy;
+@@ -71,11 +66,11 @@ Value *coerceAvailableValueToLoadType(Value *StoredVal, Type *LoadedTy,
+         TypeToCastTo = DL.getIntPtrType(TypeToCastTo);
+ 
+       if (StoredValTy != TypeToCastTo)
+-        StoredVal = IRB.CreateBitCast(StoredVal, TypeToCastTo);
++        StoredVal = Helper.CreateBitCast(StoredVal, TypeToCastTo);
+ 
+       // Cast to pointer if the load needs a pointer type.
+       if (LoadedTy->getScalarType()->isPointerTy())
+-        StoredVal = IRB.CreateIntToPtr(StoredVal, LoadedTy);
++        StoredVal = Helper.CreateIntToPtr(StoredVal, LoadedTy);
+     }
+ 
+     if (auto *C = dyn_cast<ConstantExpr>(StoredVal))
+@@ -84,7 +79,6 @@ Value *coerceAvailableValueToLoadType(Value *StoredVal, Type *LoadedTy,
+ 
+     return StoredVal;
+   }
+-
+   // If the loaded value is smaller than the available value, then we can
+   // extract out a piece from it.  If the available value is too small, then we
+   // can't do anything.
+@@ -94,13 +88,13 @@ Value *coerceAvailableValueToLoadType(Value *StoredVal, Type *LoadedTy,
+   // Convert source pointers to integers, which can be manipulated.
+   if (StoredValTy->getScalarType()->isPointerTy()) {
+     StoredValTy = DL.getIntPtrType(StoredValTy);
+-    StoredVal = IRB.CreatePtrToInt(StoredVal, StoredValTy);
++    StoredVal = Helper.CreatePtrToInt(StoredVal, StoredValTy);
+   }
+ 
+   // Convert vectors and fp to integer, which can be manipulated.
+   if (!StoredValTy->isIntegerTy()) {
+     StoredValTy = IntegerType::get(StoredValTy->getContext(), StoredValSize);
+-    StoredVal = IRB.CreateBitCast(StoredVal, StoredValTy);
++    StoredVal = Helper.CreateBitCast(StoredVal, StoredValTy);
+   }
+ 
+   // If this is a big-endian system, we need to shift the value down to the low
+@@ -108,20 +102,21 @@ Value *coerceAvailableValueToLoadType(Value *StoredVal, Type *LoadedTy,
+   if (DL.isBigEndian()) {
+     uint64_t ShiftAmt = DL.getTypeStoreSizeInBits(StoredValTy) -
+                         DL.getTypeStoreSizeInBits(LoadedTy);
+-    StoredVal = IRB.CreateLShr(StoredVal, ShiftAmt, "tmp");
++    StoredVal = Helper.CreateLShr(
++        StoredVal, ConstantInt::get(StoredVal->getType(), ShiftAmt));
+   }
+ 
+   // Truncate the integer to the right size now.
+   Type *NewIntTy = IntegerType::get(StoredValTy->getContext(), LoadedValSize);
+-  StoredVal = IRB.CreateTrunc(StoredVal, NewIntTy, "trunc");
++  StoredVal = Helper.CreateTruncOrBitCast(StoredVal, NewIntTy);
+ 
+   if (LoadedTy != NewIntTy) {
+     // If the result is a pointer, inttoptr.
+     if (LoadedTy->getScalarType()->isPointerTy())
+-      StoredVal = IRB.CreateIntToPtr(StoredVal, LoadedTy, "inttoptr");
++      StoredVal = Helper.CreateIntToPtr(StoredVal, LoadedTy);
+     else
+       // Otherwise, bitcast.
+-      StoredVal = IRB.CreateBitCast(StoredVal, LoadedTy, "bitcast");
++      StoredVal = Helper.CreateBitCast(StoredVal, LoadedTy);
+   }
+ 
+   if (auto *C = dyn_cast<Constant>(StoredVal))
+@@ -131,10 +126,21 @@ Value *coerceAvailableValueToLoadType(Value *StoredVal, Type *LoadedTy,
+   return StoredVal;
+ }
+ 
+-/// This function is called when we have a
+-/// memdep query of a load that ends up being a clobbering memory write (store,
+-/// memset, memcpy, memmove).  This means that the write *may* provide bits used
+-/// by the load but we can't be sure because the pointers don't mustalias.
++/// If we saw a store of a value to memory, and
++/// then a load from a must-aliased pointer of a different type, try to coerce
++/// the stored value.  LoadedTy is the type of the load we want to replace.
++/// IRB is IRBuilder used to insert new instructions.
++///
++/// If we can't do it, return null.
++Value *coerceAvailableValueToLoadType(Value *StoredVal, Type *LoadedTy,
++                                      IRBuilder<> &IRB, const DataLayout &DL) {
++  return coerceAvailableValueToLoadTypeHelper(StoredVal, LoadedTy, IRB, DL);
++}
++
++/// This function is called when we have a memdep query of a load that ends up
++/// being a clobbering memory write (store, memset, memcpy, memmove).  This
++/// means that the write *may* provide bits used by the load but we can't be
++/// sure because the pointers don't must-alias.
+ ///
+ /// Check this case to see if there is anything more we can do before we give
+ /// up.  This returns -1 if we have to give up, or a byte number in the stored
+@@ -291,13 +297,10 @@ int analyzeLoadFromClobberingMemInst(Type *LoadTy, Value *LoadPtr,
+   return -1;
+ }
+ 
+-/// This function is called when we have a
+-/// memdep query of a load that ends up being a clobbering store.  This means
+-/// that the store provides bits used by the load but we the pointers don't
+-/// mustalias.  Check this case to see if there is anything more we can do
+-/// before we give up.
+-Value *getStoreValueForLoad(Value *SrcVal, unsigned Offset, Type *LoadTy,
+-                            Instruction *InsertPt, const DataLayout &DL) {
++template <class T, class HelperClass>
++static T *getStoreValueForLoadHelper(T *SrcVal, unsigned Offset, Type *LoadTy,
++                                     HelperClass &Helper,
++                                     const DataLayout &DL) {
+   LLVMContext &Ctx = SrcVal->getType()->getContext();
+ 
+   // If two pointers are in the same address space, they have the same size,
+@@ -311,17 +314,12 @@ Value *getStoreValueForLoad(Value *SrcVal, unsigned Offset, Type *LoadTy,
+ 
+   uint64_t StoreSize = (DL.getTypeSizeInBits(SrcVal->getType()) + 7) / 8;
+   uint64_t LoadSize = (DL.getTypeSizeInBits(LoadTy) + 7) / 8;
+-
+-  IRBuilder<> Builder(InsertPt);
+-
+   // Compute which bits of the stored value are being used by the load.  Convert
+   // to an integer type to start with.
+   if (SrcVal->getType()->getScalarType()->isPointerTy())
+-    SrcVal =
+-        Builder.CreatePtrToInt(SrcVal, DL.getIntPtrType(SrcVal->getType()));
++    SrcVal = Helper.CreatePtrToInt(SrcVal, DL.getIntPtrType(SrcVal->getType()));
+   if (!SrcVal->getType()->isIntegerTy())
+-    SrcVal =
+-        Builder.CreateBitCast(SrcVal, IntegerType::get(Ctx, StoreSize * 8));
++    SrcVal = Helper.CreateBitCast(SrcVal, IntegerType::get(Ctx, StoreSize * 8));
+ 
+   // Shift the bits to the least significant depending on endianness.
+   unsigned ShiftAmt;
+@@ -329,25 +327,42 @@ Value *getStoreValueForLoad(Value *SrcVal, unsigned Offset, Type *LoadTy,
+     ShiftAmt = Offset * 8;
+   else
+     ShiftAmt = (StoreSize - LoadSize - Offset) * 8;
+-
+   if (ShiftAmt)
+-    SrcVal = Builder.CreateLShr(SrcVal, ShiftAmt);
++    SrcVal = Helper.CreateLShr(SrcVal,
++                               ConstantInt::get(SrcVal->getType(), ShiftAmt));
+ 
+   if (LoadSize != StoreSize)
+-    SrcVal = Builder.CreateTrunc(SrcVal, IntegerType::get(Ctx, LoadSize * 8));
++    SrcVal = Helper.CreateTruncOrBitCast(SrcVal,
++                                         IntegerType::get(Ctx, LoadSize * 8));
++  return SrcVal;
++}
++
++/// This function is called when we have a memdep query of a load that ends up
++/// being a clobbering store.  This means that the store provides bits used by
++/// the load but the pointers don't must-alias.  Check this case to see if
++/// there is anything more we can do before we give up.
++Value *getStoreValueForLoad(Value *SrcVal, unsigned Offset, Type *LoadTy,
++                            Instruction *InsertPt, const DataLayout &DL) {
+ 
+-  return coerceAvailableValueToLoadType(SrcVal, LoadTy, Builder, DL);
++  IRBuilder<> Builder(InsertPt);
++  SrcVal = getStoreValueForLoadHelper(SrcVal, Offset, LoadTy, Builder, DL);
++  return coerceAvailableValueToLoadTypeHelper(SrcVal, LoadTy, Builder, DL);
+ }
+ 
+-/// This function is called when we have a
+-/// memdep query of a load that ends up being a clobbering load.  This means
+-/// that the load *may* provide bits used by the load but we can't be sure
+-/// because the pointers don't mustalias.  Check this case to see if there is
+-/// anything more we can do before we give up.
+-Value *getLoadValueForLoad(LoadInst *SrcVal, unsigned Offset, Type *LoadTy,
+-                           Instruction *InsertPt) {
++Constant *getConstantStoreValueForLoad(Constant *SrcVal, unsigned Offset,
++                                       Type *LoadTy, const DataLayout &DL) {
++  ConstantFolder F;
++  SrcVal = getStoreValueForLoadHelper(SrcVal, Offset, LoadTy, F, DL);
++  return coerceAvailableValueToLoadTypeHelper(SrcVal, LoadTy, F, DL);
++}
+ 
+-  const DataLayout &DL = SrcVal->getModule()->getDataLayout();
++/// This function is called when we have a memdep query of a load that ends up
++/// being a clobbering load.  This means that the load *may* provide bits used
++/// by the load but we can't be sure because the pointers don't must-alias.
++/// Check this case to see if there is anything more we can do before we give
++/// up.
++Value *getLoadValueForLoad(LoadInst *SrcVal, unsigned Offset, Type *LoadTy,
++                           Instruction *InsertPt, const DataLayout &DL) {
+   // If Offset+LoadTy exceeds the size of SrcVal, then we must be wanting to
+   // widen SrcVal out to a larger load.
+   unsigned SrcValStoreSize = DL.getTypeStoreSize(SrcVal->getType());
+@@ -362,7 +377,6 @@ Value *getLoadValueForLoad(LoadInst *SrcVal, unsigned Offset, Type *LoadTy,
+       NewLoadSize = NextPowerOf2(NewLoadSize);
+ 
+     Value *PtrVal = SrcVal->getPointerOperand();
+-
+     // Insert the new load after the old load.  This ensures that subsequent
+     // memdep queries will find the new load.  We can't easily remove the old
+     // load completely because it is already in the value numbering table.
+@@ -393,44 +407,51 @@ Value *getLoadValueForLoad(LoadInst *SrcVal, unsigned Offset, Type *LoadTy,
+   return getStoreValueForLoad(SrcVal, Offset, LoadTy, InsertPt, DL);
+ }
+ 
+-/// This function is called when we have a
+-/// memdep query of a load that ends up being a clobbering mem intrinsic.
+-Value *getMemInstValueForLoad(MemIntrinsic *SrcInst, unsigned Offset,
+-                              Type *LoadTy, Instruction *InsertPt,
+-                              const DataLayout &DL) {
++Constant *getConstantLoadValueForLoad(Constant *SrcVal, unsigned Offset,
++                                      Type *LoadTy, const DataLayout &DL) {
++  unsigned SrcValStoreSize = DL.getTypeStoreSize(SrcVal->getType());
++  unsigned LoadSize = DL.getTypeStoreSize(LoadTy);
++  if (Offset + LoadSize > SrcValStoreSize)
++    return nullptr;
++  return getConstantStoreValueForLoad(SrcVal, Offset, LoadTy, DL);
++}
++
++template <class T, class HelperClass>
++T *getMemInstValueForLoadHelper(MemIntrinsic *SrcInst, unsigned Offset,
++                                Type *LoadTy, HelperClass &Helper,
++                                const DataLayout &DL) {
+   LLVMContext &Ctx = LoadTy->getContext();
+   uint64_t LoadSize = DL.getTypeSizeInBits(LoadTy) / 8;
+ 
+-  IRBuilder<> Builder(InsertPt);
+-
+   // We know that this method is only called when the mem transfer fully
+   // provides the bits for the load.
+   if (MemSetInst *MSI = dyn_cast<MemSetInst>(SrcInst)) {
+     // memset(P, 'x', 1234) -> splat('x'), even if x is a variable, and
+     // independently of what the offset is.
+-    Value *Val = MSI->getValue();
++    T *Val = cast<T>(MSI->getValue());
+     if (LoadSize != 1)
+-      Val = Builder.CreateZExt(Val, IntegerType::get(Ctx, LoadSize * 8));
+-
+-    Value *OneElt = Val;
++      Val =
++          Helper.CreateZExtOrBitCast(Val, IntegerType::get(Ctx, LoadSize * 8));
++    T *OneElt = Val;
+ 
+     // Splat the value out to the right number of bits.
+     for (unsigned NumBytesSet = 1; NumBytesSet != LoadSize;) {
+       // If we can double the number of bytes set, do it.
+       if (NumBytesSet * 2 <= LoadSize) {
+-        Value *ShVal = Builder.CreateShl(Val, NumBytesSet * 8);
+-        Val = Builder.CreateOr(Val, ShVal);
++        T *ShVal = Helper.CreateShl(
++            Val, ConstantInt::get(Val->getType(), NumBytesSet * 8));
++        Val = Helper.CreateOr(Val, ShVal);
+         NumBytesSet <<= 1;
+         continue;
+       }
+ 
+       // Otherwise insert one byte at a time.
+-      Value *ShVal = Builder.CreateShl(Val, 1 * 8);
+-      Val = Builder.CreateOr(OneElt, ShVal);
++      T *ShVal = Helper.CreateShl(Val, ConstantInt::get(Val->getType(), 1 * 8));
++      Val = Helper.CreateOr(OneElt, ShVal);
+       ++NumBytesSet;
+     }
+ 
+-    return coerceAvailableValueToLoadType(Val, LoadTy, Builder, DL);
++    return coerceAvailableValueToLoadTypeHelper(Val, LoadTy, Helper, DL);
+   }
+ 
+   // Otherwise, this is a memcpy/memmove from a constant global.
+@@ -449,5 +470,27 @@ Value *getMemInstValueForLoad(MemIntrinsic *SrcInst, unsigned Offset,
+   Src = ConstantExpr::getBitCast(Src, PointerType::get(LoadTy, AS));
+   return ConstantFoldLoadFromConstPtr(Src, LoadTy, DL);
+ }
++
++/// This function is called when we have a
++/// memdep query of a load that ends up being a clobbering mem intrinsic.
++Value *getMemInstValueForLoad(MemIntrinsic *SrcInst, unsigned Offset,
++                              Type *LoadTy, Instruction *InsertPt,
++                              const DataLayout &DL) {
++  IRBuilder<> Builder(InsertPt);
++  return getMemInstValueForLoadHelper<Value, IRBuilder<>>(SrcInst, Offset,
++                                                          LoadTy, Builder, DL);
++}
++
++Constant *getConstantMemInstValueForLoad(MemIntrinsic *SrcInst, unsigned Offset,
++                                         Type *LoadTy, const DataLayout &DL) {
++  // The only case analyzeLoadFromClobberingMemInst cannot be converted to a
++  // constant is when it's a memset of a non-constant.
++  if (auto *MSI = dyn_cast<MemSetInst>(SrcInst))
++    if (!isa<Constant>(MSI->getValue()))
++      return nullptr;
++  ConstantFolder F;
++  return getMemInstValueForLoadHelper<Constant, ConstantFolder>(SrcInst, Offset,
++                                                                LoadTy, F, DL);
++}
+ } // namespace VNCoercion
+ } // namespace llvm
+-- 
+2.13.1
+
diff --git a/deps/patches/llvm-Yet-another-fix.patch b/deps/patches/llvm-Yet-another-fix.patch
new file mode 100644
index 00000000000000..39823be1cd9189
--- /dev/null
+++ b/deps/patches/llvm-Yet-another-fix.patch
@@ -0,0 +1,40 @@
+From e92be5eb5c60dfdeb5d41d81c82f0aca0c1e4aa9 Mon Sep 17 00:00:00 2001
+From: Yichao Yu <yyc1992@gmail.com>
+Date: Sat, 17 Jun 2017 17:29:53 -0400
+Subject: [PATCH] 4.0 fix
+
+---
+ lib/CodeGen/CodeGenPrepare.cpp | 17 +++++++++++++++++
+ 1 file changed, 17 insertions(+)
+
+diff --git a/lib/CodeGen/CodeGenPrepare.cpp b/lib/CodeGen/CodeGenPrepare.cpp
+index 44d6b3e264c..4177819e989 100644
+--- a/lib/CodeGen/CodeGenPrepare.cpp
++++ b/lib/CodeGen/CodeGenPrepare.cpp
+@@ -4067,6 +4067,23 @@ bool CodeGenPrepare::optimizeMemoryInst(Instruction *MemoryInst, Value *Addr,
+     // non-integral pointers, so in that case bail out now.
+     if (DL->isNonIntegralPointerType(Addr->getType()))
+       return false;
++    if (AddrMode.BaseReg) {
++      Type *BaseTy = AddrMode.BaseReg->getType();
++      if (BaseTy->isPointerTy() && DL->isNonIntegralPointerType(BaseTy)) {
++        return false;
++      }
++    }
++    if (AddrMode.Scale) {
++      Type *ScaleTy = AddrMode.ScaledReg->getType();
++      if (ScaleTy->isPointerTy() && DL->isNonIntegralPointerType(ScaleTy)) {
++        return false;
++      }
++    }
++    if (AddrMode.BaseGV) {
++      if (DL->isNonIntegralPointerType(AddrMode.BaseGV->getType())) {
++        return false;
++      }
++    }
+ 
+     DEBUG(dbgs() << "CGP: SINKING nonlocal addrmode: " << AddrMode << " for "
+                  << *MemoryInst << "\n");
+-- 
+2.13.1
+
diff --git a/deps/patches/llvm-nodllalias.patch b/deps/patches/llvm-nodllalias.patch
deleted file mode 100644
index cf1ac3a276794d..00000000000000
--- a/deps/patches/llvm-nodllalias.patch
+++ /dev/null
@@ -1,32 +0,0 @@
-diff --git a/tools/llvm-c-test/Makefile b/tools/llvm-c-test/Makefile
-index 08be7c3..f56e83c 100644
---- a/tools/llvm-c-test/Makefile
-+++ b/tools/llvm-c-test/Makefile
-@@ -25,5 +25,5 @@ CFLAGS += -std=c99 -Wall -Wstrict-prototypes
- 
- # ...but if it is built - use it
- ifeq ($(ENABLE_SHARED),1)
--LIBS = -lLLVM-$(LLVMVersion)
-+LIBS = -lLLVM-$(LLVM_VERSION_MAJOR).$(LLVM_VERSION_MINOR)$(LLVM_VERSION_SUFFIX)
- endif
-diff --git a/tools/llvm-shlib/Makefile b/tools/llvm-shlib/Makefile
-index 2bc81da..3f7652f 100644
---- a/tools/llvm-shlib/Makefile
-+++ b/tools/llvm-shlib/Makefile
-@@ -15,7 +15,6 @@ LIBRARYALIASNAME = LLVM-$(LLVMVersion)
- NO_BUILD_ARCHIVE := 1
- LINK_LIBS_IN_SHARED := 1
- SHARED_LIBRARY := 1
--SHARED_ALIAS := 1
- 
- include $(LEVEL)/Makefile.config
- 
-@@ -27,6 +26,8 @@ ifeq ($(HOST_OS), $(filter $(HOST_OS), Cygwin MingW))
-     SHLIB_FRAG_NAMES += stdc++.a.o
-   endif
- 
-+else
-+  SHARED_ALIAS := 1
- endif
- 
- include $(LEVEL)/Makefile.common
diff --git a/deps/patches/llvm-r282182.patch b/deps/patches/llvm-r282182.patch
deleted file mode 100644
index cd49830a4a1d44..00000000000000
--- a/deps/patches/llvm-r282182.patch
+++ /dev/null
@@ -1,116 +0,0 @@
-From f2f9e2bcc5e9dd33c5c74e1aa615bf9f28f7d316 Mon Sep 17 00:00:00 2001
-From: Nemanja Ivanovic <nemanja.i.ibm@gmail.com>
-Date: Thu, 22 Sep 2016 19:06:38 +0000
-Subject: [PATCH] [PowerPC] Sign extend sub-word values for atomic comparisons
-
-Atomic comparison instructions use the sub-word load instruction on
-Power8 and up but the value is not sign extended prior to the signed word
-compare instruction. This patch adds that sign extension.
-
-
-git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@282182 91177308-0d34-0410-b5e6-96231b3b80d8
----
- lib/Target/PowerPC/PPCISelLowering.cpp | 13 ++++++-
- test/CodeGen/PowerPC/pr30451.ll        | 69 ++++++++++++++++++++++++++++++++++
- 2 files changed, 80 insertions(+), 2 deletions(-)
- create mode 100644 test/CodeGen/PowerPC/pr30451.ll
-
-diff --git a/lib/Target/PowerPC/PPCISelLowering.cpp b/lib/Target/PowerPC/PPCISelLowering.cpp
-index 1d9181b..c414a15 100644
---- a/lib/Target/PowerPC/PPCISelLowering.cpp
-+++ b/lib/Target/PowerPC/PPCISelLowering.cpp
-@@ -8507,8 +8507,17 @@ PPCTargetLowering::EmitAtomicBinary(MachineInstr &MI, MachineBasicBlock *BB,
-   if (BinOpcode)
-     BuildMI(BB, dl, TII->get(BinOpcode), TmpReg).addReg(incr).addReg(dest);
-   if (CmpOpcode) {
--    BuildMI(BB, dl, TII->get(CmpOpcode), PPC::CR0)
--      .addReg(incr).addReg(dest);
-+    // Signed comparisons of byte or halfword values must be sign-extended.
-+    if (CmpOpcode == PPC::CMPW && AtomicSize < 4) {
-+      unsigned ExtReg =  RegInfo.createVirtualRegister(&PPC::GPRCRegClass);
-+      BuildMI(BB, dl, TII->get(AtomicSize == 1 ? PPC::EXTSB : PPC::EXTSH),
-+              ExtReg).addReg(dest);
-+      BuildMI(BB, dl, TII->get(CmpOpcode), PPC::CR0)
-+        .addReg(incr).addReg(ExtReg);
-+    } else
-+      BuildMI(BB, dl, TII->get(CmpOpcode), PPC::CR0)
-+        .addReg(incr).addReg(dest);
-+
-     BuildMI(BB, dl, TII->get(PPC::BCC))
-       .addImm(CmpPred).addReg(PPC::CR0).addMBB(exitMBB);
-     BB->addSuccessor(loop2MBB);
-diff --git a/test/CodeGen/PowerPC/pr30451.ll b/test/CodeGen/PowerPC/pr30451.ll
-new file mode 100644
-index 0000000..9305534
---- /dev/null
-+++ b/test/CodeGen/PowerPC/pr30451.ll
-@@ -0,0 +1,69 @@
-+; RUN: llc < %s -mcpu=pwr8 -mtriple=powerpc64le-unknown-unknown | FileCheck %s
-+define i8 @atomic_min_i8() {
-+    top:
-+      %0 = alloca i8, align 2
-+      %1 = bitcast i8* %0 to i8*
-+      call void @llvm.lifetime.start(i64 2, i8* %1)
-+      store i8 -1, i8* %0, align 2
-+      %2 = atomicrmw min i8* %0, i8 0 acq_rel
-+      %3 = load atomic i8, i8* %0 acquire, align 8
-+      call void @llvm.lifetime.end(i64 2, i8* %1)
-+      ret i8 %3
-+; CHECK-LABEL: atomic_min_i8
-+; CHECK: lbarx [[DST:[0-9]+]],
-+; CHECK-NEXT: extsb [[EXT:[0-9]+]], [[DST]]
-+; CHECK-NEXT: cmpw {{[0-9]+}}, [[EXT]]
-+; CHECK-NEXT: bge 0
-+}
-+define i16 @atomic_min_i16() {
-+    top:
-+      %0 = alloca i16, align 2
-+      %1 = bitcast i16* %0 to i8*
-+      call void @llvm.lifetime.start(i64 2, i8* %1)
-+      store i16 -1, i16* %0, align 2
-+      %2 = atomicrmw min i16* %0, i16 0 acq_rel
-+      %3 = load atomic i16, i16* %0 acquire, align 8
-+      call void @llvm.lifetime.end(i64 2, i8* %1)
-+      ret i16 %3
-+; CHECK-LABEL: atomic_min_i16
-+; CHECK: lharx [[DST:[0-9]+]],
-+; CHECK-NEXT: extsh [[EXT:[0-9]+]], [[DST]]
-+; CHECK-NEXT: cmpw {{[0-9]+}}, [[EXT]]
-+; CHECK-NEXT: bge 0
-+}
-+
-+define i8 @atomic_max_i8() {
-+    top:
-+      %0 = alloca i8, align 2
-+      %1 = bitcast i8* %0 to i8*
-+      call void @llvm.lifetime.start(i64 2, i8* %1)
-+      store i8 -1, i8* %0, align 2
-+      %2 = atomicrmw max i8* %0, i8 0 acq_rel
-+      %3 = load atomic i8, i8* %0 acquire, align 8
-+      call void @llvm.lifetime.end(i64 2, i8* %1)
-+      ret i8 %3
-+; CHECK-LABEL: atomic_max_i8
-+; CHECK: lbarx [[DST:[0-9]+]],
-+; CHECK-NEXT: extsb [[EXT:[0-9]+]], [[DST]]
-+; CHECK-NEXT: cmpw {{[0-9]+}}, [[EXT]]
-+; CHECK-NEXT: ble 0
-+}
-+define i16 @atomic_max_i16() {
-+    top:
-+      %0 = alloca i16, align 2
-+      %1 = bitcast i16* %0 to i8*
-+      call void @llvm.lifetime.start(i64 2, i8* %1)
-+      store i16 -1, i16* %0, align 2
-+      %2 = atomicrmw max i16* %0, i16 0 acq_rel
-+      %3 = load atomic i16, i16* %0 acquire, align 8
-+      call void @llvm.lifetime.end(i64 2, i8* %1)
-+      ret i16 %3
-+; CHECK-LABEL: atomic_max_i16
-+; CHECK: lharx [[DST:[0-9]+]],
-+; CHECK-NEXT: extsh [[EXT:[0-9]+]], [[DST]]
-+; CHECK-NEXT: cmpw {{[0-9]+}}, [[EXT]]
-+; CHECK-NEXT: ble 0
-+}
-+
-+declare void @llvm.lifetime.start(i64, i8*)
-+declare void @llvm.lifetime.end(i64, i8*)
diff --git a/deps/patches/llvm-rL279933-ppc-atomicrmw-lowering.patch b/deps/patches/llvm-rL279933-ppc-atomicrmw-lowering.patch
deleted file mode 100644
index 5bfdd7559c2a17..00000000000000
--- a/deps/patches/llvm-rL279933-ppc-atomicrmw-lowering.patch
+++ /dev/null
@@ -1,732 +0,0 @@
-From afa0d1049b60d7cba63bf3d27872dda96db44ac9 Mon Sep 17 00:00:00 2001
-From: Hal Finkel <hfinkel@anl.gov>
-Date: Sun, 28 Aug 2016 16:17:58 +0000
-Subject: [PATCH] [PowerPC] Implement lowering for atomicrmw min/max/umin/umax
-
-Implement lowering for atomicrmw min/max/umin/umax. Fixes PR28818.
-
-git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@279933 91177308-0d34-0410-b5e6-96231b3b80d8
----
- lib/Target/PowerPC/PPCISelLowering.cpp | 101 +++++++-
- lib/Target/PowerPC/PPCISelLowering.h   |   8 +-
- lib/Target/PowerPC/PPCInstr64Bit.td    |  12 +
- lib/Target/PowerPC/PPCInstrInfo.td     |  36 +++
- test/CodeGen/PowerPC/atomic-minmax.ll  | 435 +++++++++++++++++++++++++++++++++
- 5 files changed, 587 insertions(+), 5 deletions(-)
- create mode 100644 test/CodeGen/PowerPC/atomic-minmax.ll
-
-diff --git a/lib/Target/PowerPC/PPCISelLowering.cpp b/lib/Target/PowerPC/PPCISelLowering.cpp
-index bbbc51a..e89b6ca 100644
---- a/lib/Target/PowerPC/PPCISelLowering.cpp
-+++ b/lib/Target/PowerPC/PPCISelLowering.cpp
-@@ -8387,7 +8387,9 @@ Instruction* PPCTargetLowering::emitTrailingFence(IRBuilder<> &Builder,
- MachineBasicBlock *
- PPCTargetLowering::EmitAtomicBinary(MachineInstr &MI, MachineBasicBlock *BB,
-                                     unsigned AtomicSize,
--                                    unsigned BinOpcode) const {
-+                                    unsigned BinOpcode,
-+                                    unsigned CmpOpcode,
-+                                    unsigned CmpPred) const {
-   // This also handles ATOMIC_SWAP, indicated by BinOpcode==0.
-   const TargetInstrInfo *TII = Subtarget.getInstrInfo();
- 
-@@ -8427,8 +8429,12 @@ PPCTargetLowering::EmitAtomicBinary(MachineInstr &MI, MachineBasicBlock *BB,
-   DebugLoc dl = MI.getDebugLoc();
- 
-   MachineBasicBlock *loopMBB = F->CreateMachineBasicBlock(LLVM_BB);
-+  MachineBasicBlock *loop2MBB =
-+    CmpOpcode ? F->CreateMachineBasicBlock(LLVM_BB) : nullptr;
-   MachineBasicBlock *exitMBB = F->CreateMachineBasicBlock(LLVM_BB);
-   F->insert(It, loopMBB);
-+  if (CmpOpcode)
-+    F->insert(It, loop2MBB);
-   F->insert(It, exitMBB);
-   exitMBB->splice(exitMBB->begin(), BB,
-                   std::next(MachineBasicBlock::iterator(MI)), BB->end());
-@@ -8450,11 +8456,31 @@ PPCTargetLowering::EmitAtomicBinary(MachineInstr &MI, MachineBasicBlock *BB,
-   //   st[wd]cx. r0, ptr
-   //   bne- loopMBB
-   //   fallthrough --> exitMBB
-+
-+  // For max/min...
-+  //  loopMBB:
-+  //   l[wd]arx dest, ptr
-+  //   cmpl?[wd] incr, dest
-+  //   bgt exitMBB
-+  //  loop2MBB:
-+  //   st[wd]cx. dest, ptr
-+  //   bne- loopMBB
-+  //   fallthrough --> exitMBB
-+
-   BB = loopMBB;
-   BuildMI(BB, dl, TII->get(LoadMnemonic), dest)
-     .addReg(ptrA).addReg(ptrB);
-   if (BinOpcode)
-     BuildMI(BB, dl, TII->get(BinOpcode), TmpReg).addReg(incr).addReg(dest);
-+  if (CmpOpcode) {
-+    BuildMI(BB, dl, TII->get(CmpOpcode), PPC::CR0)
-+      .addReg(incr).addReg(dest);
-+    BuildMI(BB, dl, TII->get(PPC::BCC))
-+      .addImm(CmpPred).addReg(PPC::CR0).addMBB(exitMBB);
-+    BB->addSuccessor(loop2MBB);
-+    BB->addSuccessor(exitMBB);
-+    BB = loop2MBB;
-+  }
-   BuildMI(BB, dl, TII->get(StoreMnemonic))
-     .addReg(TmpReg).addReg(ptrA).addReg(ptrB);
-   BuildMI(BB, dl, TII->get(PPC::BCC))
-@@ -8472,10 +8498,13 @@ MachineBasicBlock *
- PPCTargetLowering::EmitPartwordAtomicBinary(MachineInstr &MI,
-                                             MachineBasicBlock *BB,
-                                             bool is8bit, // operation
--                                            unsigned BinOpcode) const {
-+                                            unsigned BinOpcode,
-+                                            unsigned CmpOpcode,
-+                                            unsigned CmpPred) const {
-   // If we support part-word atomic mnemonics, just use them
-   if (Subtarget.hasPartwordAtomics())
--    return EmitAtomicBinary(MI, BB, is8bit ? 1 : 2, BinOpcode);
-+    return EmitAtomicBinary(MI, BB, is8bit ? 1 : 2, BinOpcode,
-+                            CmpOpcode, CmpPred);
- 
-   // This also handles ATOMIC_SWAP, indicated by BinOpcode==0.
-   const TargetInstrInfo *TII = Subtarget.getInstrInfo();
-@@ -8497,8 +8526,12 @@ PPCTargetLowering::EmitPartwordAtomicBinary(MachineInstr &MI,
-   DebugLoc dl = MI.getDebugLoc();
- 
-   MachineBasicBlock *loopMBB = F->CreateMachineBasicBlock(LLVM_BB);
-+  MachineBasicBlock *loop2MBB =
-+    CmpOpcode ? F->CreateMachineBasicBlock(LLVM_BB) : nullptr;
-   MachineBasicBlock *exitMBB = F->CreateMachineBasicBlock(LLVM_BB);
-   F->insert(It, loopMBB);
-+  if (CmpOpcode)
-+    F->insert(It, loop2MBB);
-   F->insert(It, exitMBB);
-   exitMBB->splice(exitMBB->begin(), BB,
-                   std::next(MachineBasicBlock::iterator(MI)), BB->end());
-@@ -8583,6 +8616,32 @@ PPCTargetLowering::EmitPartwordAtomicBinary(MachineInstr &MI,
-     .addReg(TmpDestReg).addReg(MaskReg);
-   BuildMI(BB, dl, TII->get(is64bit ? PPC::AND8 : PPC::AND), Tmp3Reg)
-     .addReg(TmpReg).addReg(MaskReg);
-+  if (CmpOpcode) {
-+    // For unsigned comparisons, we can directly compare the shifted values.
-+    // For signed comparisons we shift and sign extend.
-+    unsigned SReg = RegInfo.createVirtualRegister(RC);
-+    BuildMI(BB, dl, TII->get(is64bit ? PPC::AND8 : PPC::AND), SReg)
-+      .addReg(TmpDestReg).addReg(MaskReg);
-+    unsigned ValueReg = SReg;
-+    unsigned CmpReg = Incr2Reg;
-+    if (CmpOpcode == PPC::CMPW) {
-+      ValueReg = RegInfo.createVirtualRegister(RC);
-+      BuildMI(BB, dl, TII->get(PPC::SRW), ValueReg)
-+        .addReg(SReg).addReg(ShiftReg);
-+      unsigned ValueSReg = RegInfo.createVirtualRegister(RC);
-+      BuildMI(BB, dl, TII->get(is8bit ? PPC::EXTSB : PPC::EXTSH), ValueSReg)
-+        .addReg(ValueReg);
-+      ValueReg = ValueSReg;
-+      CmpReg = incr;
-+    }
-+    BuildMI(BB, dl, TII->get(CmpOpcode), PPC::CR0)
-+      .addReg(CmpReg).addReg(ValueReg);
-+    BuildMI(BB, dl, TII->get(PPC::BCC))
-+      .addImm(CmpPred).addReg(PPC::CR0).addMBB(exitMBB);
-+    BB->addSuccessor(loop2MBB);
-+    BB->addSuccessor(exitMBB);
-+    BB = loop2MBB;
-+  }
-   BuildMI(BB, dl, TII->get(is64bit ? PPC::OR8 : PPC::OR), Tmp4Reg)
-     .addReg(Tmp3Reg).addReg(Tmp2Reg);
-   BuildMI(BB, dl, TII->get(PPC::STWCX))
-@@ -9089,6 +9148,42 @@ PPCTargetLowering::EmitInstrWithCustomInserter(MachineInstr &MI,
-   else if (MI.getOpcode() == PPC::ATOMIC_LOAD_SUB_I64)
-     BB = EmitAtomicBinary(MI, BB, 8, PPC::SUBF8);
- 
-+  else if (MI.getOpcode() == PPC::ATOMIC_LOAD_MIN_I8)
-+    BB = EmitPartwordAtomicBinary(MI, BB, true, 0, PPC::CMPW, PPC::PRED_GE);
-+  else if (MI.getOpcode() == PPC::ATOMIC_LOAD_MIN_I16)
-+    BB = EmitPartwordAtomicBinary(MI, BB, false, 0, PPC::CMPW, PPC::PRED_GE);
-+  else if (MI.getOpcode() == PPC::ATOMIC_LOAD_MIN_I32)
-+    BB = EmitAtomicBinary(MI, BB, 4, 0, PPC::CMPW, PPC::PRED_GE);
-+  else if (MI.getOpcode() == PPC::ATOMIC_LOAD_MIN_I64)
-+    BB = EmitAtomicBinary(MI, BB, 8, 0, PPC::CMPD, PPC::PRED_GE);
-+
-+  else if (MI.getOpcode() == PPC::ATOMIC_LOAD_MAX_I8)
-+    BB = EmitPartwordAtomicBinary(MI, BB, true, 0, PPC::CMPW, PPC::PRED_LE);
-+  else if (MI.getOpcode() == PPC::ATOMIC_LOAD_MAX_I16)
-+    BB = EmitPartwordAtomicBinary(MI, BB, false, 0, PPC::CMPW, PPC::PRED_LE);
-+  else if (MI.getOpcode() == PPC::ATOMIC_LOAD_MAX_I32)
-+    BB = EmitAtomicBinary(MI, BB, 4, 0, PPC::CMPW, PPC::PRED_LE);
-+  else if (MI.getOpcode() == PPC::ATOMIC_LOAD_MAX_I64)
-+    BB = EmitAtomicBinary(MI, BB, 8, 0, PPC::CMPD, PPC::PRED_LE);
-+
-+  else if (MI.getOpcode() == PPC::ATOMIC_LOAD_UMIN_I8)
-+    BB = EmitPartwordAtomicBinary(MI, BB, true, 0, PPC::CMPLW, PPC::PRED_GE);
-+  else if (MI.getOpcode() == PPC::ATOMIC_LOAD_UMIN_I16)
-+    BB = EmitPartwordAtomicBinary(MI, BB, false, 0, PPC::CMPLW, PPC::PRED_GE);
-+  else if (MI.getOpcode() == PPC::ATOMIC_LOAD_UMIN_I32)
-+    BB = EmitAtomicBinary(MI, BB, 4, 0, PPC::CMPLW, PPC::PRED_GE);
-+  else if (MI.getOpcode() == PPC::ATOMIC_LOAD_UMIN_I64)
-+    BB = EmitAtomicBinary(MI, BB, 8, 0, PPC::CMPLD, PPC::PRED_GE);
-+
-+  else if (MI.getOpcode() == PPC::ATOMIC_LOAD_UMAX_I8)
-+    BB = EmitPartwordAtomicBinary(MI, BB, true, 0, PPC::CMPLW, PPC::PRED_LE);
-+  else if (MI.getOpcode() == PPC::ATOMIC_LOAD_UMAX_I16)
-+    BB = EmitPartwordAtomicBinary(MI, BB, false, 0, PPC::CMPLW, PPC::PRED_LE);
-+  else if (MI.getOpcode() == PPC::ATOMIC_LOAD_UMAX_I32)
-+    BB = EmitAtomicBinary(MI, BB, 4, 0, PPC::CMPLW, PPC::PRED_LE);
-+  else if (MI.getOpcode() == PPC::ATOMIC_LOAD_UMAX_I64)
-+    BB = EmitAtomicBinary(MI, BB, 8, 0, PPC::CMPLD, PPC::PRED_LE);
-+
-   else if (MI.getOpcode() == PPC::ATOMIC_SWAP_I8)
-     BB = EmitPartwordAtomicBinary(MI, BB, true, 0);
-   else if (MI.getOpcode() == PPC::ATOMIC_SWAP_I16)
-diff --git a/lib/Target/PowerPC/PPCISelLowering.h b/lib/Target/PowerPC/PPCISelLowering.h
-index 13b8637..1175ccd 100644
---- a/lib/Target/PowerPC/PPCISelLowering.h
-+++ b/lib/Target/PowerPC/PPCISelLowering.h
-@@ -589,11 +589,15 @@ namespace llvm {
-     MachineBasicBlock *EmitAtomicBinary(MachineInstr &MI,
-                                         MachineBasicBlock *MBB,
-                                         unsigned AtomicSize,
--                                        unsigned BinOpcode) const;
-+                                        unsigned BinOpcode,
-+                                        unsigned CmpOpcode = 0,
-+                                        unsigned CmpPred = 0) const;
-     MachineBasicBlock *EmitPartwordAtomicBinary(MachineInstr &MI,
-                                                 MachineBasicBlock *MBB,
-                                                 bool is8bit,
--                                                unsigned Opcode) const;
-+                                                unsigned Opcode,
-+                                                unsigned CmpOpcode = 0,
-+                                                unsigned CmpPred = 0) const;
- 
-     MachineBasicBlock *emitEHSjLjSetJmp(MachineInstr &MI,
-                                         MachineBasicBlock *MBB) const;
-diff --git a/lib/Target/PowerPC/PPCInstr64Bit.td b/lib/Target/PowerPC/PPCInstr64Bit.td
-index e7eb8a1..5e514c8 100644
---- a/lib/Target/PowerPC/PPCInstr64Bit.td
-+++ b/lib/Target/PowerPC/PPCInstr64Bit.td
-@@ -224,6 +224,18 @@ let usesCustomInserter = 1 in {
-     def ATOMIC_LOAD_NAND_I64 : Pseudo<
-       (outs g8rc:$dst), (ins memrr:$ptr, g8rc:$incr), "#ATOMIC_LOAD_NAND_I64",
-       [(set i64:$dst, (atomic_load_nand_64 xoaddr:$ptr, i64:$incr))]>;
-+    def ATOMIC_LOAD_MIN_I64 : Pseudo<
-+      (outs g8rc:$dst), (ins memrr:$ptr, g8rc:$incr), "#ATOMIC_LOAD_MIN_I64",
-+      [(set i64:$dst, (atomic_load_min_64 xoaddr:$ptr, i64:$incr))]>;
-+    def ATOMIC_LOAD_MAX_I64 : Pseudo<
-+      (outs g8rc:$dst), (ins memrr:$ptr, g8rc:$incr), "#ATOMIC_LOAD_MAX_I64",
-+      [(set i64:$dst, (atomic_load_max_64 xoaddr:$ptr, i64:$incr))]>;
-+    def ATOMIC_LOAD_UMIN_I64 : Pseudo<
-+      (outs g8rc:$dst), (ins memrr:$ptr, g8rc:$incr), "#ATOMIC_LOAD_UMIN_I64",
-+      [(set i64:$dst, (atomic_load_umin_64 xoaddr:$ptr, i64:$incr))]>;
-+    def ATOMIC_LOAD_UMAX_I64 : Pseudo<
-+      (outs g8rc:$dst), (ins memrr:$ptr, g8rc:$incr), "#ATOMIC_LOAD_UMAX_I64",
-+      [(set i64:$dst, (atomic_load_umax_64 xoaddr:$ptr, i64:$incr))]>;
- 
-     def ATOMIC_CMP_SWAP_I64 : Pseudo<
-       (outs g8rc:$dst), (ins memrr:$ptr, g8rc:$old, g8rc:$new), "#ATOMIC_CMP_SWAP_I64",
-diff --git a/lib/Target/PowerPC/PPCInstrInfo.td b/lib/Target/PowerPC/PPCInstrInfo.td
-index 876e066..f0476fb 100644
---- a/lib/Target/PowerPC/PPCInstrInfo.td
-+++ b/lib/Target/PowerPC/PPCInstrInfo.td
-@@ -1509,6 +1509,18 @@ let usesCustomInserter = 1 in {
-     def ATOMIC_LOAD_NAND_I8 : Pseudo<
-       (outs gprc:$dst), (ins memrr:$ptr, gprc:$incr), "#ATOMIC_LOAD_NAND_I8",
-       [(set i32:$dst, (atomic_load_nand_8 xoaddr:$ptr, i32:$incr))]>;
-+    def ATOMIC_LOAD_MIN_I8 : Pseudo<
-+      (outs gprc:$dst), (ins memrr:$ptr, gprc:$incr), "#ATOMIC_LOAD_MIN_I8",
-+      [(set i32:$dst, (atomic_load_min_8 xoaddr:$ptr, i32:$incr))]>;
-+    def ATOMIC_LOAD_MAX_I8 : Pseudo<
-+      (outs gprc:$dst), (ins memrr:$ptr, gprc:$incr), "#ATOMIC_LOAD_MAX_I8",
-+      [(set i32:$dst, (atomic_load_max_8 xoaddr:$ptr, i32:$incr))]>;
-+    def ATOMIC_LOAD_UMIN_I8 : Pseudo<
-+      (outs gprc:$dst), (ins memrr:$ptr, gprc:$incr), "#ATOMIC_LOAD_UMIN_I8",
-+      [(set i32:$dst, (atomic_load_umin_8 xoaddr:$ptr, i32:$incr))]>;
-+    def ATOMIC_LOAD_UMAX_I8 : Pseudo<
-+      (outs gprc:$dst), (ins memrr:$ptr, gprc:$incr), "#ATOMIC_LOAD_UMAX_I8",
-+      [(set i32:$dst, (atomic_load_umax_8 xoaddr:$ptr, i32:$incr))]>;
-     def ATOMIC_LOAD_ADD_I16 : Pseudo<
-       (outs gprc:$dst), (ins memrr:$ptr, gprc:$incr), "#ATOMIC_LOAD_ADD_I16",
-       [(set i32:$dst, (atomic_load_add_16 xoaddr:$ptr, i32:$incr))]>;
-@@ -1527,6 +1539,18 @@ let usesCustomInserter = 1 in {
-     def ATOMIC_LOAD_NAND_I16 : Pseudo<
-       (outs gprc:$dst), (ins memrr:$ptr, gprc:$incr), "#ATOMIC_LOAD_NAND_I16",
-       [(set i32:$dst, (atomic_load_nand_16 xoaddr:$ptr, i32:$incr))]>;
-+    def ATOMIC_LOAD_MIN_I16 : Pseudo<
-+      (outs gprc:$dst), (ins memrr:$ptr, gprc:$incr), "#ATOMIC_LOAD_MIN_I16",
-+      [(set i32:$dst, (atomic_load_min_16 xoaddr:$ptr, i32:$incr))]>;
-+    def ATOMIC_LOAD_MAX_I16 : Pseudo<
-+      (outs gprc:$dst), (ins memrr:$ptr, gprc:$incr), "#ATOMIC_LOAD_MAX_I16",
-+      [(set i32:$dst, (atomic_load_max_16 xoaddr:$ptr, i32:$incr))]>;
-+    def ATOMIC_LOAD_UMIN_I16 : Pseudo<
-+      (outs gprc:$dst), (ins memrr:$ptr, gprc:$incr), "#ATOMIC_LOAD_UMIN_I16",
-+      [(set i32:$dst, (atomic_load_umin_16 xoaddr:$ptr, i32:$incr))]>;
-+    def ATOMIC_LOAD_UMAX_I16 : Pseudo<
-+      (outs gprc:$dst), (ins memrr:$ptr, gprc:$incr), "#ATOMIC_LOAD_UMAX_I16",
-+      [(set i32:$dst, (atomic_load_umax_16 xoaddr:$ptr, i32:$incr))]>;
-     def ATOMIC_LOAD_ADD_I32 : Pseudo<
-       (outs gprc:$dst), (ins memrr:$ptr, gprc:$incr), "#ATOMIC_LOAD_ADD_I32",
-       [(set i32:$dst, (atomic_load_add_32 xoaddr:$ptr, i32:$incr))]>;
-@@ -1545,6 +1569,18 @@ let usesCustomInserter = 1 in {
-     def ATOMIC_LOAD_NAND_I32 : Pseudo<
-       (outs gprc:$dst), (ins memrr:$ptr, gprc:$incr), "#ATOMIC_LOAD_NAND_I32",
-       [(set i32:$dst, (atomic_load_nand_32 xoaddr:$ptr, i32:$incr))]>;
-+    def ATOMIC_LOAD_MIN_I32 : Pseudo<
-+      (outs gprc:$dst), (ins memrr:$ptr, gprc:$incr), "#ATOMIC_LOAD_MIN_I32",
-+      [(set i32:$dst, (atomic_load_min_32 xoaddr:$ptr, i32:$incr))]>;
-+    def ATOMIC_LOAD_MAX_I32 : Pseudo<
-+      (outs gprc:$dst), (ins memrr:$ptr, gprc:$incr), "#ATOMIC_LOAD_MAX_I32",
-+      [(set i32:$dst, (atomic_load_max_32 xoaddr:$ptr, i32:$incr))]>;
-+    def ATOMIC_LOAD_UMIN_I32 : Pseudo<
-+      (outs gprc:$dst), (ins memrr:$ptr, gprc:$incr), "#ATOMIC_LOAD_UMIN_I32",
-+      [(set i32:$dst, (atomic_load_umin_32 xoaddr:$ptr, i32:$incr))]>;
-+    def ATOMIC_LOAD_UMAX_I32 : Pseudo<
-+      (outs gprc:$dst), (ins memrr:$ptr, gprc:$incr), "#ATOMIC_LOAD_UMAX_I32",
-+      [(set i32:$dst, (atomic_load_umax_32 xoaddr:$ptr, i32:$incr))]>;
- 
-     def ATOMIC_CMP_SWAP_I8 : Pseudo<
-       (outs gprc:$dst), (ins memrr:$ptr, gprc:$old, gprc:$new), "#ATOMIC_CMP_SWAP_I8",
-diff --git a/test/CodeGen/PowerPC/atomic-minmax.ll b/test/CodeGen/PowerPC/atomic-minmax.ll
-new file mode 100644
-index 0000000..5b9a153
---- /dev/null
-+++ b/test/CodeGen/PowerPC/atomic-minmax.ll
-@@ -0,0 +1,435 @@
-+; RUN: llc < %s | FileCheck %s
-+target datalayout = "E-m:e-i64:64-n32:64"
-+target triple = "powerpc64-unknown-linux-gnu"
-+
-+define void @a32min(i32* nocapture dereferenceable(4) %minimum, i32 %val) #0 {
-+entry:
-+  %0 = atomicrmw min i32* %minimum, i32 %val monotonic
-+  ret void
-+
-+; CHECK-LABEL: @a32min
-+; CHECK: lwarx [[OLDV:[0-9]+]], 0, 3
-+; CHECK: cmpw 4, [[OLDV]]
-+; CHECK: bgelr 0
-+; CHECK: stwcx. 4, 0, 3
-+; CHECK: bne 0,
-+; CHECK: blr
-+}
-+
-+define void @a32max(i32* nocapture dereferenceable(4) %minimum, i32 %val) #0 {
-+entry:
-+  %0 = atomicrmw max i32* %minimum, i32 %val monotonic
-+  ret void
-+
-+; CHECK-LABEL: @a32max
-+; CHECK: lwarx [[OLDV:[0-9]+]], 0, 3
-+; CHECK: cmpw 4, [[OLDV]]
-+; CHECK: blelr 0
-+; CHECK: stwcx. 4, 0, 3
-+; CHECK: bne 0,
-+; CHECK: blr
-+}
-+
-+define void @a32umin(i32* nocapture dereferenceable(4) %minimum, i32 %val) #0 {
-+entry:
-+  %0 = atomicrmw umin i32* %minimum, i32 %val monotonic
-+  ret void
-+
-+; CHECK-LABEL: @a32umin
-+; CHECK: lwarx [[OLDV:[0-9]+]], 0, 3
-+; CHECK: cmplw 4, [[OLDV]]
-+; CHECK: bgelr 0
-+; CHECK: stwcx. 4, 0, 3
-+; CHECK: bne 0,
-+; CHECK: blr
-+}
-+
-+define void @a32umax(i32* nocapture dereferenceable(4) %minimum, i32 %val) #0 {
-+entry:
-+  %0 = atomicrmw umax i32* %minimum, i32 %val monotonic
-+  ret void
-+
-+; CHECK-LABEL: @a32umax
-+; CHECK: lwarx [[OLDV:[0-9]+]], 0, 3
-+; CHECK: cmplw 4, [[OLDV]]
-+; CHECK: blelr 0
-+; CHECK: stwcx. 4, 0, 3
-+; CHECK: bne 0,
-+; CHECK: blr
-+}
-+
-+define void @a16min(i16* nocapture dereferenceable(4) %minimum, i16 %val) #1 {
-+entry:
-+  %0 = atomicrmw min i16* %minimum, i16 %val monotonic
-+  ret void
-+
-+; CHECK-LABEL: @a16min
-+; CHECK: lharx [[OLDV:[0-9]+]], 0, 3
-+; CHECK: cmpw 4, [[OLDV]]
-+; CHECK: bgelr 0
-+; CHECK: sthcx. 4, 0, 3
-+; CHECK: bne 0,
-+; CHECK: blr
-+}
-+
-+define void @a16max(i16* nocapture dereferenceable(4) %minimum, i16 %val) #1 {
-+entry:
-+  %0 = atomicrmw max i16* %minimum, i16 %val monotonic
-+  ret void
-+
-+; CHECK-LABEL: @a16max
-+; CHECK: lharx [[OLDV:[0-9]+]], 0, 3
-+; CHECK: cmpw 4, [[OLDV]]
-+; CHECK: blelr 0
-+; CHECK: sthcx. 4, 0, 3
-+; CHECK: bne 0,
-+; CHECK: blr
-+}
-+
-+define void @a16umin(i16* nocapture dereferenceable(4) %minimum, i16 %val) #1 {
-+entry:
-+  %0 = atomicrmw umin i16* %minimum, i16 %val monotonic
-+  ret void
-+
-+; CHECK-LABEL: @a16umin
-+; CHECK: lharx [[OLDV:[0-9]+]], 0, 3
-+; CHECK: cmplw 4, [[OLDV]]
-+; CHECK: bgelr 0
-+; CHECK: sthcx. 4, 0, 3
-+; CHECK: bne 0,
-+; CHECK: blr
-+}
-+
-+define void @a16umax(i16* nocapture dereferenceable(4) %minimum, i16 %val) #1 {
-+entry:
-+  %0 = atomicrmw umax i16* %minimum, i16 %val monotonic
-+  ret void
-+
-+; CHECK-LABEL: @a16umax
-+; CHECK: lharx [[OLDV:[0-9]+]], 0, 3
-+; CHECK: cmplw 4, [[OLDV]]
-+; CHECK: blelr 0
-+; CHECK: sthcx. 4, 0, 3
-+; CHECK: bne 0,
-+; CHECK: blr
-+}
-+
-+define void @a8min(i8* nocapture dereferenceable(4) %minimum, i8 %val) #1 {
-+entry:
-+  %0 = atomicrmw min i8* %minimum, i8 %val monotonic
-+  ret void
-+
-+; CHECK-LABEL: @a8min
-+; CHECK: lbarx [[OLDV:[0-9]+]], 0, 3
-+; CHECK: cmpw 4, [[OLDV]]
-+; CHECK: bgelr 0
-+; CHECK: stbcx. 4, 0, 3
-+; CHECK: bne 0,
-+; CHECK: blr
-+}
-+
-+define void @a8max(i8* nocapture dereferenceable(4) %minimum, i8 %val) #1 {
-+entry:
-+  %0 = atomicrmw max i8* %minimum, i8 %val monotonic
-+  ret void
-+
-+; CHECK-LABEL: @a8max
-+; CHECK: lbarx [[OLDV:[0-9]+]], 0, 3
-+; CHECK: cmpw 4, [[OLDV]]
-+; CHECK: blelr 0
-+; CHECK: stbcx. 4, 0, 3
-+; CHECK: bne 0,
-+; CHECK: blr
-+}
-+
-+define void @a8umin(i8* nocapture dereferenceable(4) %minimum, i8 %val) #1 {
-+entry:
-+  %0 = atomicrmw umin i8* %minimum, i8 %val monotonic
-+  ret void
-+
-+; CHECK-LABEL: @a8umin
-+; CHECK: lbarx [[OLDV:[0-9]+]], 0, 3
-+; CHECK: cmplw 4, [[OLDV]]
-+; CHECK: bgelr 0
-+; CHECK: stbcx. 4, 0, 3
-+; CHECK: bne 0,
-+; CHECK: blr
-+}
-+
-+define void @a8umax(i8* nocapture dereferenceable(4) %minimum, i8 %val) #1 {
-+entry:
-+  %0 = atomicrmw umax i8* %minimum, i8 %val monotonic
-+  ret void
-+
-+; CHECK-LABEL: @a8umax
-+; CHECK: lbarx [[OLDV:[0-9]+]], 0, 3
-+; CHECK: cmplw 4, [[OLDV]]
-+; CHECK: blelr 0
-+; CHECK: stbcx. 4, 0, 3
-+; CHECK: bne 0,
-+; CHECK: blr
-+}
-+
-+define void @a64min(i64* nocapture dereferenceable(4) %minimum, i64 %val) #0 {
-+entry:
-+  %0 = atomicrmw min i64* %minimum, i64 %val monotonic
-+  ret void
-+
-+; CHECK-LABEL: @a64min
-+; CHECK: ldarx [[OLDV:[0-9]+]], 0, 3
-+; CHECK: cmpd 4, [[OLDV]]
-+; CHECK: bgelr 0
-+; CHECK: stdcx. 4, 0, 3
-+; CHECK: bne 0,
-+; CHECK: blr
-+}
-+
-+define void @a64max(i64* nocapture dereferenceable(4) %minimum, i64 %val) #0 {
-+entry:
-+  %0 = atomicrmw max i64* %minimum, i64 %val monotonic
-+  ret void
-+
-+; CHECK-LABEL: @a64max
-+; CHECK: ldarx [[OLDV:[0-9]+]], 0, 3
-+; CHECK: cmpd 4, [[OLDV]]
-+; CHECK: blelr 0
-+; CHECK: stdcx. 4, 0, 3
-+; CHECK: bne 0,
-+; CHECK: blr
-+}
-+
-+define void @a64umin(i64* nocapture dereferenceable(4) %minimum, i64 %val) #0 {
-+entry:
-+  %0 = atomicrmw umin i64* %minimum, i64 %val monotonic
-+  ret void
-+
-+; CHECK-LABEL: @a64umin
-+; CHECK: ldarx [[OLDV:[0-9]+]], 0, 3
-+; CHECK: cmpld 4, [[OLDV]]
-+; CHECK: bgelr 0
-+; CHECK: stdcx. 4, 0, 3
-+; CHECK: bne 0,
-+; CHECK: blr
-+}
-+
-+define void @a64umax(i64* nocapture dereferenceable(4) %minimum, i64 %val) #0 {
-+entry:
-+  %0 = atomicrmw umax i64* %minimum, i64 %val monotonic
-+  ret void
-+
-+; CHECK-LABEL: @a64umax
-+; CHECK: ldarx [[OLDV:[0-9]+]], 0, 3
-+; CHECK: cmpld 4, [[OLDV]]
-+; CHECK: blelr 0
-+; CHECK: stdcx. 4, 0, 3
-+; CHECK: bne 0,
-+; CHECK: blr
-+}
-+
-+define void @ae16min(i16* nocapture dereferenceable(4) %minimum, i16 %val) #0 {
-+entry:
-+  %0 = atomicrmw min i16* %minimum, i16 %val monotonic
-+  ret void
-+
-+; CHECK-LABEL: @ae16min
-+; CHECK-DAG: rlwinm [[SA1:[0-9]+]], 3, 3, 27, 27
-+; CHECK-DAG: li [[M1:[0-9]+]], 0
-+; CHECK-DAG: rldicr 3, 3, 0, 61
-+; CHECK-DAG: xori [[SA:[0-9]+]], [[SA1]], 16
-+; CHECK-DAG: ori [[M2:[0-9]+]], [[M1]], 65535
-+; CHECK-DAG: slw [[SV:[0-9]+]], 4, [[SA]]
-+; CHECK-DAG: slw [[M:[0-9]+]], [[M2]], [[SA]]
-+; CHECK-DAG: and [[SMV:[0-9]+]], [[SV]], [[M]]
-+; CHECK: lwarx [[OLDV:[0-9]+]], 0, 3
-+; CHECK: and [[MOLDV:[0-9]+]], [[OLDV]], [[M]]
-+; CHECK: srw [[SMOLDV:[0-9]+]], [[MOLDV]], [[SA]]
-+; CHECK: extsh [[SESMOLDV:[0-9]+]], [[SMOLDV]]
-+; CHECK: cmpw 0, 4, [[SESMOLDV]]
-+; CHECK: bgelr 0
-+; CHECK: andc [[NOLDV:[0-9]+]], [[OLDV]], [[M]]
-+; CHECK: or [[NEWV:[0-9]+]], [[SMV]], [[NOLDV]]
-+; CHECK: stwcx. [[NEWV]], 0, 3
-+; CHECK: bne  0,
-+; CHECK: blr
-+}
-+
-+define void @ae16max(i16* nocapture dereferenceable(4) %minimum, i16 %val) #0 {
-+entry:
-+  %0 = atomicrmw max i16* %minimum, i16 %val monotonic
-+  ret void
-+
-+; CHECK-LABEL: @ae16max
-+; CHECK-DAG: rlwinm [[SA1:[0-9]+]], 3, 3, 27, 27
-+; CHECK-DAG: li [[M1:[0-9]+]], 0
-+; CHECK-DAG: rldicr 3, 3, 0, 61
-+; CHECK-DAG: xori [[SA:[0-9]+]], [[SA1]], 16
-+; CHECK-DAG: ori [[M2:[0-9]+]], [[M1]], 65535
-+; CHECK-DAG: slw [[SV:[0-9]+]], 4, [[SA]]
-+; CHECK-DAG: slw [[M:[0-9]+]], [[M2]], [[SA]]
-+; CHECK-DAG: and [[SMV:[0-9]+]], [[SV]], [[M]]
-+; CHECK: lwarx [[OLDV:[0-9]+]], 0, 3
-+; CHECK: and [[MOLDV:[0-9]+]], [[OLDV]], [[M]]
-+; CHECK: srw [[SMOLDV:[0-9]+]], [[MOLDV]], [[SA]]
-+; CHECK: extsh [[SESMOLDV:[0-9]+]], [[SMOLDV]]
-+; CHECK: cmpw 0, 4, [[SESMOLDV]]
-+; CHECK: blelr 0
-+; CHECK: andc [[NOLDV:[0-9]+]], [[OLDV]], [[M]]
-+; CHECK: or [[NEWV:[0-9]+]], [[SMV]], [[NOLDV]]
-+; CHECK: stwcx. [[NEWV]], 0, 3
-+; CHECK: bne  0,
-+; CHECK: blr
-+}
-+
-+define void @ae16umin(i16* nocapture dereferenceable(4) %minimum, i16 %val) #0 {
-+entry:
-+  %0 = atomicrmw umin i16* %minimum, i16 %val monotonic
-+  ret void
-+
-+; CHECK-LABEL: @ae16umin
-+; CHECK-DAG: rlwinm [[SA1:[0-9]+]], 3, 3, 27, 27
-+; CHECK-DAG: li [[M1:[0-9]+]], 0
-+; CHECK-DAG: rldicr 3, 3, 0, 61
-+; CHECK-DAG: xori [[SA:[0-9]+]], [[SA1]], 16
-+; CHECK-DAG: ori [[M2:[0-9]+]], [[M1]], 65535
-+; CHECK-DAG: slw [[SV:[0-9]+]], 4, [[SA]]
-+; CHECK-DAG: slw [[M:[0-9]+]], [[M2]], [[SA]]
-+; CHECK-DAG: and [[SMV:[0-9]+]], [[SV]], [[M]]
-+; CHECK: lwarx [[OLDV:[0-9]+]], 0, 3
-+; CHECK: and [[MOLDV:[0-9]+]], [[OLDV]], [[M]]
-+; CHECK: cmplw 0, 4, [[MOLDV]]
-+; CHECK: bgelr 0
-+; CHECK: andc [[NOLDV:[0-9]+]], [[OLDV]], [[M]]
-+; CHECK: or [[NEWV:[0-9]+]], [[SMV]], [[NOLDV]]
-+; CHECK: stwcx. [[NEWV]], 0, 3
-+; CHECK: bne  0,
-+; CHECK: blr
-+}
-+
-+define void @ae16umax(i16* nocapture dereferenceable(4) %minimum, i16 %val) #0 {
-+entry:
-+  %0 = atomicrmw umax i16* %minimum, i16 %val monotonic
-+  ret void
-+
-+; CHECK-LABEL: @ae16umax
-+; CHECK-DAG: rlwinm [[SA1:[0-9]+]], 3, 3, 27, 27
-+; CHECK-DAG: li [[M1:[0-9]+]], 0
-+; CHECK-DAG: rldicr 3, 3, 0, 61
-+; CHECK-DAG: xori [[SA:[0-9]+]], [[SA1]], 16
-+; CHECK-DAG: ori [[M2:[0-9]+]], [[M1]], 65535
-+; CHECK-DAG: slw [[SV:[0-9]+]], 4, [[SA]]
-+; CHECK-DAG: slw [[M:[0-9]+]], [[M2]], [[SA]]
-+; CHECK-DAG: and [[SMV:[0-9]+]], [[SV]], [[M]]
-+; CHECK: lwarx [[OLDV:[0-9]+]], 0, 3
-+; CHECK: and [[MOLDV:[0-9]+]], [[OLDV]], [[M]]
-+; CHECK: cmplw 0, 4, [[MOLDV]]
-+; CHECK: blelr 0
-+; CHECK: andc [[NOLDV:[0-9]+]], [[OLDV]], [[M]]
-+; CHECK: or [[NEWV:[0-9]+]], [[SMV]], [[NOLDV]]
-+; CHECK: stwcx. [[NEWV]], 0, 3
-+; CHECK: bne  0,
-+; CHECK: blr
-+}
-+
-+define void @ae8min(i8* nocapture dereferenceable(4) %minimum, i8 %val) #0 {
-+entry:
-+  %0 = atomicrmw min i8* %minimum, i8 %val monotonic
-+  ret void
-+
-+; CHECK-LABEL: @ae8min
-+; CHECK-DAG: rlwinm [[SA1:[0-9]+]], 3, 3, 27, 28
-+; CHECK-DAG: li [[M1:[0-9]+]], 255
-+; CHECK-DAG: rldicr 3, 3, 0, 61
-+; CHECK-DAG: xori [[SA:[0-9]+]], [[SA1]], 24
-+; CHECK-DAG: slw [[SV:[0-9]+]], 4, [[SA]]
-+; CHECK-DAG: slw [[M:[0-9]+]], [[M1]], [[SA]]
-+; CHECK-DAG: and [[SMV:[0-9]+]], [[SV]], [[M]]
-+; CHECK: lwarx [[OLDV:[0-9]+]], 0, 3
-+; CHECK: and [[MOLDV:[0-9]+]], [[OLDV]], [[M]]
-+; CHECK: srw [[SMOLDV:[0-9]+]], [[MOLDV]], [[SA]]
-+; CHECK: extsb [[SESMOLDV:[0-9]+]], [[SMOLDV]]
-+; CHECK: cmpw 0, 4, [[SESMOLDV]]
-+; CHECK: bgelr 0
-+; CHECK: andc [[NOLDV:[0-9]+]], [[OLDV]], [[M]]
-+; CHECK: or [[NEWV:[0-9]+]], [[SMV]], [[NOLDV]]
-+; CHECK: stwcx. [[NEWV]], 0, 3
-+; CHECK: bne  0,
-+; CHECK: blr
-+}
-+
-+define void @ae8max(i8* nocapture dereferenceable(4) %minimum, i8 %val) #0 {
-+entry:
-+  %0 = atomicrmw max i8* %minimum, i8 %val monotonic
-+  ret void
-+
-+; CHECK-LABEL: @ae8max
-+; CHECK-DAG: rlwinm [[SA1:[0-9]+]], 3, 3, 27, 28
-+; CHECK-DAG: li [[M1:[0-9]+]], 255
-+; CHECK-DAG: rldicr 3, 3, 0, 61
-+; CHECK-DAG: xori [[SA:[0-9]+]], [[SA1]], 24
-+; CHECK-DAG: slw [[SV:[0-9]+]], 4, [[SA]]
-+; CHECK-DAG: slw [[M:[0-9]+]], [[M1]], [[SA]]
-+; CHECK-DAG: and [[SMV:[0-9]+]], [[SV]], [[M]]
-+; CHECK: lwarx [[OLDV:[0-9]+]], 0, 3
-+; CHECK: and [[MOLDV:[0-9]+]], [[OLDV]], [[M]]
-+; CHECK: srw [[SMOLDV:[0-9]+]], [[MOLDV]], [[SA]]
-+; CHECK: extsb [[SESMOLDV:[0-9]+]], [[SMOLDV]]
-+; CHECK: cmpw 0, 4, [[SESMOLDV]]
-+; CHECK: blelr 0
-+; CHECK: andc [[NOLDV:[0-9]+]], [[OLDV]], [[M]]
-+; CHECK: or [[NEWV:[0-9]+]], [[SMV]], [[NOLDV]]
-+; CHECK: stwcx. [[NEWV]], 0, 3
-+; CHECK: bne  0,
-+; CHECK: blr
-+}
-+
-+define void @ae8umin(i8* nocapture dereferenceable(4) %minimum, i8 %val) #0 {
-+entry:
-+  %0 = atomicrmw umin i8* %minimum, i8 %val monotonic
-+  ret void
-+
-+; CHECK-LABEL: @ae8umin
-+; CHECK-DAG: rlwinm [[SA1:[0-9]+]], 3, 3, 27, 28
-+; CHECK-DAG: li [[M1:[0-9]+]], 255
-+; CHECK-DAG: rldicr 3, 3, 0, 61
-+; CHECK-DAG: xori [[SA:[0-9]+]], [[SA1]], 24
-+; CHECK-DAG: slw [[SV:[0-9]+]], 4, [[SA]]
-+; CHECK-DAG: slw [[M:[0-9]+]], [[M1]], [[SA]]
-+; CHECK-DAG: and [[SMV:[0-9]+]], [[SV]], [[M]]
-+; CHECK: lwarx [[OLDV:[0-9]+]], 0, 3
-+; CHECK: and [[MOLDV:[0-9]+]], [[OLDV]], [[M]]
-+; CHECK: cmplw 0, 4, [[MOLDV]]
-+; CHECK: bgelr 0
-+; CHECK: andc [[NOLDV:[0-9]+]], [[OLDV]], [[M]]
-+; CHECK: or [[NEWV:[0-9]+]], [[SMV]], [[NOLDV]]
-+; CHECK: stwcx. [[NEWV]], 0, 3
-+; CHECK: bne  0,
-+; CHECK: blr
-+}
-+
-+define void @ae8umax(i8* nocapture dereferenceable(4) %minimum, i8 %val) #0 {
-+entry:
-+  %0 = atomicrmw umax i8* %minimum, i8 %val monotonic
-+  ret void
-+
-+; CHECK-LABEL: @ae8umax
-+; CHECK-DAG: rlwinm [[SA1:[0-9]+]], 3, 3, 27, 28
-+; CHECK-DAG: li [[M1:[0-9]+]], 255
-+; CHECK-DAG: rldicr 3, 3, 0, 61
-+; CHECK-DAG: xori [[SA:[0-9]+]], [[SA1]], 24
-+; CHECK-DAG: slw [[SV:[0-9]+]], 4, [[SA]]
-+; CHECK-DAG: slw [[M:[0-9]+]], [[M1]], [[SA]]
-+; CHECK-DAG: and [[SMV:[0-9]+]], [[SV]], [[M]]
-+; CHECK: lwarx [[OLDV:[0-9]+]], 0, 3
-+; CHECK: and [[MOLDV:[0-9]+]], [[OLDV]], [[M]]
-+; CHECK: cmplw 0, 4, [[MOLDV]]
-+; CHECK: blelr 0
-+; CHECK: andc [[NOLDV:[0-9]+]], [[OLDV]], [[M]]
-+; CHECK: or [[NEWV:[0-9]+]], [[SMV]], [[NOLDV]]
-+; CHECK: stwcx. [[NEWV]], 0, 3
-+; CHECK: bne  0,
-+; CHECK: blr
-+}
-+
-+attributes #0 = { nounwind "target-cpu"="ppc64" }
-+attributes #1 = { nounwind "target-cpu"="pwr8" }
-+
--- 
-2.9.3
-
diff --git a/deps/patches/llvm-win64-reloc-dwarf.patch b/deps/patches/llvm-win64-reloc-dwarf.patch
deleted file mode 100644
index 7cd5564950b07e..00000000000000
--- a/deps/patches/llvm-win64-reloc-dwarf.patch
+++ /dev/null
@@ -1,170 +0,0 @@
-diff --git a/include/llvm/MC/MCStreamer.h b/include/llvm/MC/MCStreamer.h
-index 6b9b8a1..0113664 100644
---- a/include/llvm/MC/MCStreamer.h
-+++ b/include/llvm/MC/MCStreamer.h
-@@ -452,7 +452,7 @@ public:
-   /// \brief Emits a COFF section relative relocation.
-   ///
-   /// \param Symbol - Symbol the section relative relocation should point to.
--  virtual void EmitCOFFSecRel32(MCSymbol const *Symbol);
-+  virtual void EmitCOFFSecRel32(MCSymbol const *Symbol, uint64_t Offset);
- 
-   /// \brief Emit an ELF .size directive.
-   ///
-diff --git a/include/llvm/MC/MCWinCOFFStreamer.h b/include/llvm/MC/MCWinCOFFStreamer.h
-index 6fbc754..500b1c0 100644
---- a/include/llvm/MC/MCWinCOFFStreamer.h
-+++ b/include/llvm/MC/MCWinCOFFStreamer.h
-@@ -52,7 +52,7 @@ public:
-   void EndCOFFSymbolDef() override;
-   void EmitCOFFSafeSEH(MCSymbol const *Symbol) override;
-   void EmitCOFFSectionIndex(MCSymbol const *Symbol) override;
--  void EmitCOFFSecRel32(MCSymbol const *Symbol) override;
-+  void EmitCOFFSecRel32(MCSymbol const *Symbol, uint64_t Offset) override;
-   void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
-                         unsigned ByteAlignment) override;
-   void EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
-diff --git a/lib/CodeGen/AsmPrinter/AsmPrinter.cpp b/lib/CodeGen/AsmPrinter/AsmPrinter.cpp
-index 125047e..3483412 100644
---- a/lib/CodeGen/AsmPrinter/AsmPrinter.cpp
-+++ b/lib/CodeGen/AsmPrinter/AsmPrinter.cpp
-@@ -1598,7 +1598,7 @@ void AsmPrinter::EmitLabelPlusOffset(const MCSymbol *Label, uint64_t Offset,
-                                      unsigned Size,
-                                      bool IsSectionRelative) const {
-   if (MAI->needsDwarfSectionOffsetDirective() && IsSectionRelative) {
--    OutStreamer->EmitCOFFSecRel32(Label);
-+    OutStreamer->EmitCOFFSecRel32(Label, Offset);
-     return;
-   }
- 
-diff --git a/lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp b/lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp
-index ad180b6..6bd7dfb 100644
---- a/lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp
-+++ b/lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp
-@@ -162,7 +162,7 @@ void AsmPrinter::emitDwarfSymbolReference(const MCSymbol *Label,
-   if (!ForceOffset) {
-     // On COFF targets, we have to emit the special .secrel32 directive.
-     if (MAI->needsDwarfSectionOffsetDirective()) {
--      OutStreamer->EmitCOFFSecRel32(Label);
-+      OutStreamer->EmitCOFFSecRel32(Label, /*offset*/0);
-       return;
-     }
- 
-diff --git a/lib/CodeGen/AsmPrinter/DIE.cpp b/lib/CodeGen/AsmPrinter/DIE.cpp
-index 46dbc76..70b2014 100644
---- a/lib/CodeGen/AsmPrinter/DIE.cpp
-+++ b/lib/CodeGen/AsmPrinter/DIE.cpp
-@@ -457,7 +457,7 @@ void DIEEntry::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const {
-     Addr += CU->getDebugInfoOffset();
-     if (AP->MAI->doesDwarfUseRelocationsAcrossSections())
-       AP->EmitLabelPlusOffset(CU->getSectionSym(), Addr,
--                              DIEEntry::getRefAddrSize(AP));
-+                              DIEEntry::getRefAddrSize(AP), true);
-     else
-       AP->OutStreamer->EmitIntValue(Addr, DIEEntry::getRefAddrSize(AP));
-   } else
-diff --git a/lib/CodeGen/AsmPrinter/WinCodeViewLineTables.cpp b/lib/CodeGen/AsmPrinter/WinCodeViewLineTables.cpp
-index 6610ac7..3b2188a 100644
---- a/lib/CodeGen/AsmPrinter/WinCodeViewLineTables.cpp
-+++ b/lib/CodeGen/AsmPrinter/WinCodeViewLineTables.cpp
-@@ -221,7 +221,7 @@ void WinCodeViewLineTables::emitDebugInfoForFunction(const Function *GV) {
-     // code is located and what's its size:
-     EmitLabelDiff(*Asm->OutStreamer, Fn, FI.End);
-     Asm->OutStreamer->EmitFill(12, 0);
--    Asm->OutStreamer->EmitCOFFSecRel32(Fn);
-+    Asm->OutStreamer->EmitCOFFSecRel32(Fn, /*offset*/0);
-     Asm->OutStreamer->EmitCOFFSectionIndex(Fn);
-     Asm->EmitInt8(0);
-     // Emit the function display name as a null-terminated string.
-@@ -262,7 +262,7 @@ void WinCodeViewLineTables::emitDebugInfoForFunction(const Function *GV) {
-   Asm->OutStreamer->EmitLabel(LineTableBegin);
- 
-   // Identify the function this subsection is for.
--  Asm->OutStreamer->EmitCOFFSecRel32(Fn);
-+  Asm->OutStreamer->EmitCOFFSecRel32(Fn, /*offset*/0);
-   Asm->OutStreamer->EmitCOFFSectionIndex(Fn);
-   // Insert flags after a 16-bit section index.
-   Asm->EmitInt16(COFF::DEBUG_LINE_TABLES_HAVE_COLUMN_RECORDS);
-diff --git a/lib/MC/MCAsmStreamer.cpp b/lib/MC/MCAsmStreamer.cpp
-index 227c937..c2f3e6e 100644
---- a/lib/MC/MCAsmStreamer.cpp
-+++ b/lib/MC/MCAsmStreamer.cpp
-@@ -138,7 +138,7 @@ public:
-   void EndCOFFSymbolDef() override;
-   void EmitCOFFSafeSEH(MCSymbol const *Symbol) override;
-   void EmitCOFFSectionIndex(MCSymbol const *Symbol) override;
--  void EmitCOFFSecRel32(MCSymbol const *Symbol) override;
-+  void EmitCOFFSecRel32(MCSymbol const *Symbol, uint64_t Offset) override;
-   void emitELFSize(MCSymbolELF *Symbol, const MCExpr *Value) override;
-   void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
-                         unsigned ByteAlignment) override;
-@@ -514,7 +514,7 @@ void MCAsmStreamer::EmitCOFFSectionIndex(MCSymbol const *Symbol) {
-   EmitEOL();
- }
- 
--void MCAsmStreamer::EmitCOFFSecRel32(MCSymbol const *Symbol) {
-+void MCAsmStreamer::EmitCOFFSecRel32(MCSymbol const *Symbol, uint64_t Offset) {
-   OS << "\t.secrel32\t";
-   Symbol->print(OS, MAI);
-   EmitEOL();
-diff --git a/lib/MC/MCParser/COFFAsmParser.cpp b/lib/MC/MCParser/COFFAsmParser.cpp
-index f09bce0..39a9ad7 100644
---- a/lib/MC/MCParser/COFFAsmParser.cpp
-+++ b/lib/MC/MCParser/COFFAsmParser.cpp
-@@ -451,7 +451,7 @@ bool COFFAsmParser::ParseDirectiveSecRel32(StringRef, SMLoc) {
-   MCSymbol *Symbol = getContext().getOrCreateSymbol(SymbolID);
- 
-   Lex();
--  getStreamer().EmitCOFFSecRel32(Symbol);
-+  getStreamer().EmitCOFFSecRel32(Symbol, /*Offset=*/0);
-   return false;
- }
- 
-diff --git a/lib/MC/MCStreamer.cpp b/lib/MC/MCStreamer.cpp
-index 7fbbbd9..c9e8958 100644
---- a/lib/MC/MCStreamer.cpp
-+++ b/lib/MC/MCStreamer.cpp
-@@ -120,7 +120,7 @@ void MCStreamer::EmitSymbolValue(const MCSymbol *Sym, unsigned Size,
-   if (!IsSectionRelative)
-     EmitValueImpl(MCSymbolRefExpr::create(Sym, getContext()), Size);
-   else
--    EmitCOFFSecRel32(Sym);
-+    EmitCOFFSecRel32(Sym, /*Offset=*/0);
- }
- 
- void MCStreamer::EmitGPRel64Value(const MCExpr *Value) {
-@@ -562,7 +562,7 @@ void MCStreamer::EmitCOFFSafeSEH(MCSymbol const *Symbol) {
- void MCStreamer::EmitCOFFSectionIndex(MCSymbol const *Symbol) {
- }
- 
--void MCStreamer::EmitCOFFSecRel32(MCSymbol const *Symbol) {
-+void MCStreamer::EmitCOFFSecRel32(MCSymbol const *Symbol, uint64_t Offset) {
- }
- 
- /// EmitRawText - If this file is backed by an assembly streamer, this dumps
-diff --git a/lib/MC/WinCOFFStreamer.cpp b/lib/MC/WinCOFFStreamer.cpp
-index 36dd691..d6c91db 100644
---- a/lib/MC/WinCOFFStreamer.cpp
-+++ b/lib/MC/WinCOFFStreamer.cpp
-@@ -192,11 +192,18 @@ void MCWinCOFFStreamer::EmitCOFFSectionIndex(MCSymbol const *Symbol) {
-   DF->getContents().resize(DF->getContents().size() + 2, 0);
- }
- 
--void MCWinCOFFStreamer::EmitCOFFSecRel32(MCSymbol const *Symbol) {
-+void MCWinCOFFStreamer::EmitCOFFSecRel32(MCSymbol const *Symbol, uint64_t Offset) {
-   MCDataFragment *DF = getOrCreateDataFragment();
--  const MCSymbolRefExpr *SRE = MCSymbolRefExpr::create(Symbol, getContext());
--  MCFixup Fixup = MCFixup::create(DF->getContents().size(), SRE, FK_SecRel_4);
-+  // Create Symbol A for the relocation relative reference.
-+  const MCExpr *MCE = MCSymbolRefExpr::create(Symbol, getContext());
-+  // Add the constant offset, if given
-+  if (Offset)
-+      MCE = MCBinaryExpr::createAdd(MCE, MCConstantExpr::create(Offset, getContext()), getContext());
-+  // Build the secrel32 relocation.
-+  MCFixup Fixup = MCFixup::create(DF->getContents().size(), MCE, FK_SecRel_4);
-+  // Record the relocation.
-   DF->getFixups().push_back(Fixup);
-+  // Emit 4 bytes (zeros) to the object file.
-   DF->getContents().resize(DF->getContents().size() + 4, 0);
- }
- 
diff --git a/deps/patches/mbedtls-ssl.h.patch b/deps/patches/mbedtls-ssl.h.patch
deleted file mode 100644
index 11785c5d88c607..00000000000000
--- a/deps/patches/mbedtls-ssl.h.patch
+++ /dev/null
@@ -1,12 +0,0 @@
---- ssl.h.old	2016-06-28 18:12:06.000000000 +0530
-+++ ssl.h	2016-08-03 18:51:34.000000000 +0530
-@@ -54,7 +54,8 @@
- #endif
- 
- #if defined(MBEDTLS_HAVE_TIME)
--#include <time.h>
-+//#include <time.h>
-+#include "platform.h"
- #endif
- 
- /*
diff --git a/deps/patches/mpfr-sincos.patch b/deps/patches/mpfr-sincos.patch
new file mode 100644
index 00000000000000..ad2d44674b88b4
--- /dev/null
+++ b/deps/patches/mpfr-sincos.patch
@@ -0,0 +1,23 @@
+https://github.com/JuliaLang/julia/issues/22758
+svn diff -r 11589:11590 https://scm.gforge.inria.fr/anonscm/svn/mpfr/trunk
+--- src/sin_cos.c	(revision 11589)
++++ src/sin_cos.c	(revision 11590)
+@@ -354,10 +354,12 @@
+          which reduces to T[k] = (2*i+2)*(2*i+3)*2^r-pp,
+          Q[k] = (2*i)*(2*i+1)*(2*i+2)*(2*i+3). */
+       log2_nb_terms[k] = 1;
+-      mpz_set_ui (Q[k], (2 * i + 2) * (2 * i + 3));
++      mpz_set_ui (Q[k], 2 * i + 2);
++      mpz_mul_ui (Q[k], Q[k], 2 * i + 3);
+       mpz_mul_2exp (T[k], Q[k], r);
+       mpz_sub (T[k], T[k], pp);
+-      mpz_mul_ui (Q[k], Q[k], (2 * i) * (2 * i + 1));
++      mpz_mul_ui (Q[k], Q[k], 2 * i);
++      mpz_mul_ui (Q[k], Q[k], 2 * i + 1);
+       /* the next term of the series is divided by Q[k] and multiplied
+          by pp^2/2^(2r), thus the mult. factor < 1/2^mult[k] */
+       MPFR_MPZ_SIZEINBASE2(mult[k], Q[k]);
+--- PATCHES	2017-07-18 15:55:44.000000000 -0700
++++ PATCHES	2017-07-18 15:55:57.000000000 -0700
+@@ -0,0 +1 @@
++r11590
diff --git a/deps/patches/openblas-clangasmbug.patch b/deps/patches/openblas-clangasmbug.patch
new file mode 100644
index 00000000000000..11c85f68f02473
--- /dev/null
+++ b/deps/patches/openblas-clangasmbug.patch
@@ -0,0 +1,856 @@
+commit 3705f5675ae45f3cc662927db1955701cf73d95b (from ef52a9266ba8900774a1f3e77561c5c8a75c5828)
+Merge: ef52a92 bce2b34
+Author: Zhang Xianyi <traits.zhang@gmail.com>
+Date:   Mon Oct 17 11:32:20 2016 +0800
+
+    Merge pull request #982 from martin-frbg/develop
+    
+    Change file comments to work around clang 3.9 assembler bug; add support for Bay Trail atom
+
+diff --git a/cpuid_x86.c b/cpuid_x86.c
+index bbd377f..dff1507 100644
+--- a/cpuid_x86.c
++++ b/cpuid_x86.c
+@@ -1110,6 +1110,9 @@ int get_cpuname(void){
+ 	break;
+       case 3:
+ 	switch (model) {
++	case  7:
++	    // Bay Trail
++	    return CPUTYPE_ATOM;
+ 	case 10:
+         case 14:
+ 	  // Ivy Bridge
+diff --git a/driver/others/dynamic.c b/driver/others/dynamic.c
+index 18f85c3..a09660f 100644
+--- a/driver/others/dynamic.c
++++ b/driver/others/dynamic.c
+@@ -232,6 +232,7 @@ static gotoblas_t *get_coretype(void){
+ 	    return &gotoblas_NEHALEM; //OS doesn't support AVX. Use old kernels.
+ 	  }
+ 	}
++	if (model == 7) return &gotoblas_ATOM; //Bay Trail
+ 	return NULL;
+       case 4:
+ 		//Intel Haswell
+diff --git a/kernel/x86_64/dgemm_kernel_4x8_sandy.S b/kernel/x86_64/dgemm_kernel_4x8_sandy.S
+index a52bb07..926395c 100644
+--- a/kernel/x86_64/dgemm_kernel_4x8_sandy.S
++++ b/kernel/x86_64/dgemm_kernel_4x8_sandy.S
+@@ -277,7 +277,7 @@ LEAQ (, %rax, SIZE), %rax;
+ LEAQ (ptrba, %rax, 8), ptrba;
+ LEAQ (ptrbb, %rax, 4), ptrbb;
+ #endif
+-#### Initial Results Register ####
++//#### Initial Results Register ####
+ PREFETCH2	0*SIZE(prebb);
+ XOR_DY yvec15, yvec15, yvec15;
+ PREFETCH2	8*SIZE(prebb);
+@@ -317,7 +317,7 @@ ALIGN_5;
+ .L2_bodyB:;
+ # Computing kernel
+ 
+-#### Unroll times 1 ####
++//#### Unroll times 1 ####
+ LD_DY	4*SIZE(ptrba), yvec1;
+ MUL_DY	yvec0, yvec2, yvec6;
+ SHUF_DY	$0x03, yvec2, yvec2, yvec4;
+@@ -345,7 +345,7 @@ MUL_DY	yvec1, yvec5, yvec7;
+ ADD_DY	yvec10, yvec6, yvec10;
+ ADD_DY	yvec8, yvec7, yvec8;
+ 
+-#### Unroll times 2 ####
++//#### Unroll times 2 ####
+ LD_DY	12*SIZE(ptrba), yvec1;
+ MUL_DY	yvec0, yvec2, yvec6;
+ SHUF_DY	$0x03, yvec2, yvec2, yvec4;
+@@ -373,7 +373,7 @@ MUL_DY	yvec1, yvec5, yvec7;
+ ADD_DY	yvec10, yvec6, yvec10;
+ ADD_DY	yvec8, yvec7, yvec8;
+ 
+-#### Unroll times 3 ####
++//#### Unroll times 3 ####
+ LD_DY	20*SIZE(ptrba), yvec1;
+ MUL_DY	yvec0, yvec2, yvec6;
+ SHUF_DY	$0x03, yvec2, yvec2, yvec4;
+@@ -402,7 +402,7 @@ MUL_DY	yvec1, yvec5, yvec7;
+ ADD_DY	yvec10, yvec6, yvec10;
+ ADD_DY	yvec8, yvec7, yvec8;
+ 
+-#### Unroll times 4 ####
++//#### Unroll times 4 ####
+ LD_DY	28*SIZE(ptrba), yvec1;
+ MUL_DY	yvec0, yvec2, yvec6;
+ SHUF_DY	$0x03, yvec2, yvec2, yvec4;
+@@ -446,7 +446,7 @@ TEST 	$2, %rax;
+ JLE		.L3_loopE;
+ ALIGN_5
+ .L3_bodyB:
+-#### Unroll times 1 ####
++//#### Unroll times 1 ####
+ PREFETCH0	64*SIZE(ptrba)
+ LD_DY	4*SIZE(ptrba), yvec1;
+ MUL_DY	yvec0, yvec2, yvec6;
+@@ -475,7 +475,7 @@ MUL_DY	yvec1, yvec5, yvec7;
+ ADD_DY	yvec10, yvec6, yvec10;
+ ADD_DY	yvec8, yvec7, yvec8;
+ 
+-#### Unroll times 2 ####
++//#### Unroll times 2 ####
+ PREFETCH0	72*SIZE(ptrba)
+ LD_DY	12*SIZE(ptrba), yvec1;
+ MUL_DY	yvec0, yvec2, yvec6;
+@@ -516,7 +516,7 @@ TEST 	$1, %rax;
+ JLE		.L4_loopE;
+ ALIGN_5
+ .L4_bodyB:;
+-#### Unroll times 1 ####
++//#### Unroll times 1 ####
+ PREFETCH0	64*SIZE(ptrba)
+ LD_DY	4*SIZE(ptrba), yvec1;
+ MUL_DY	yvec0, yvec2, yvec6;
+@@ -544,9 +544,9 @@ ADD_DY	yvec10, yvec6, yvec10;
+ ADD_DY	yvec8, yvec7, yvec8;
+ 
+ .L4_loopE:;
+-#### Load Alpha ####
++//#### Load Alpha ####
+ BROAD_DY MEMALPHA,yvec7;
+-#### Multiply Alpha ####
++//#### Multiply Alpha ####
+ MUL_DY yvec7,yvec15,yvec15;
+ MUL_DY yvec7,yvec14,yvec14;
+ MUL_DY yvec7,yvec13,yvec13;
+@@ -555,7 +555,7 @@ MUL_DY yvec7,yvec11,yvec11;
+ MUL_DY yvec7,yvec10,yvec10;
+ MUL_DY yvec7,yvec9,yvec9;
+ MUL_DY yvec7,yvec8,yvec8;
+-#### Reverse the Results ####
++//#### Reverse the Results ####
+ MOV_DY yvec15,yvec7;
+ REVS_DY $0x0a,yvec13,yvec15,yvec15;
+ REVS_DY $0x0a,yvec7,yvec13,yvec13;
+@@ -568,13 +568,13 @@ REVS_DY $0x0a,yvec7,yvec9,yvec9;
+ MOV_DY yvec10,yvec7;
+ REVS_DY $0x0a,yvec8,yvec10,yvec10;
+ REVS_DY $0x0a,yvec7,yvec8,yvec8;
+-#### Testing alignment ####
++//#### Testing alignment ####
+ MOVQ	C0, %rax;
+ OR		ldc, %rax;
+ TEST	$15, %rax;
+ JNE		.L4_loopEx;					# Unalign part write back
+ ALIGN_5
+-#### Writing Back ####
++//#### Writing Back ####
+ EXTRA_DY $1,yvec15,xvec7;
+ EXTRA_DY $1,yvec14,xvec6;
+ EXTRA_DY $1,yvec13,xvec5;
+@@ -776,7 +776,7 @@ LEAQ (, %rax, SIZE), %rax;
+ LEAQ (ptrba, %rax, 4), ptrba;
+ LEAQ (ptrbb, %rax, 4), ptrbb;
+ #endif
+-#### Initial Results Register ####
++//#### Initial Results Register ####
+ XOR_DY	yvec15, yvec15, yvec15;
+ XOR_DY 	yvec13, yvec13, yvec13;
+ LD_DY	0*SIZE(ptrbb), yvec2;
+@@ -805,7 +805,7 @@ ALIGN_5;
+ .L6_bodyB:;
+ # Computing kernel
+ 
+-#### Untoll time 1 ####
++//#### Untoll time 1 ####
+ LD_DY	4*SIZE(ptrba), yvec1;
+ MUL_DY	yvec0, yvec2, yvec6;
+ ADD_DY	yvec15, yvec6, yvec15;
+@@ -821,7 +821,7 @@ VPERMILP_DY	$0x05, yvec2, yvec3;
+ MUL_DY	yvec0, yvec5, yvec7;
+ ADD_DY	yvec9, yvec7, yvec9;
+ 
+-#### Untoll time 2 ####
++//#### Untoll time 2 ####
+ LD_DY	8*SIZE(ptrba), yvec0;
+ MUL_DY	yvec1, yvec2, yvec6;
+ ADD_DY	yvec15, yvec6, yvec15;
+@@ -837,7 +837,7 @@ VPERMILP_DY	$0x05, yvec2, yvec3;
+ MUL_DY	yvec1, yvec5, yvec7;
+ ADD_DY	yvec9, yvec7, yvec9;
+ 
+-#### Untoll time 3 ####
++//#### Untoll time 3 ####
+ LD_DY	12*SIZE(ptrba), yvec1;
+ MUL_DY	yvec0, yvec2, yvec6;
+ ADD_DY	yvec15, yvec6, yvec15;
+@@ -855,7 +855,7 @@ ADDQ	$16*SIZE, ptrbb;
+ MUL_DY	yvec0, yvec5, yvec7;
+ ADD_DY	yvec9, yvec7, yvec9;
+ 
+-#### Untoll time 4 ####
++//#### Untoll time 4 ####
+ LD_DY	0*SIZE(ptrba), yvec0;
+ MUL_DY	yvec1, yvec2, yvec6;
+ ADD_DY	yvec15, yvec6, yvec15;
+@@ -883,7 +883,7 @@ TEST $2, %rax;
+ JLE .L7_loopE;
+ ALIGN_5
+ .L7_bodyB:;
+-#### Untoll time 1 ####
++//#### Untoll time 1 ####
+ LD_DY	4*SIZE(ptrba), yvec1;
+ MUL_DY	yvec0, yvec2, yvec6;
+ ADD_DY	yvec15, yvec6, yvec15;
+@@ -901,7 +901,7 @@ ADDQ	$8*SIZE, ptrbb;
+ MUL_DY	yvec0, yvec5, yvec7;
+ ADD_DY	yvec9, yvec7, yvec9;
+ 
+-#### Untoll time 2 ####
++//#### Untoll time 2 ####
+ LD_DY	0*SIZE(ptrba), yvec0;
+ MUL_DY	yvec1, yvec2, yvec6;
+ ADD_DY	yvec15, yvec6, yvec15;
+@@ -927,7 +927,7 @@ TEST $1, %rax;
+ JLE .L8_loopE;
+ ALIGN_5
+ .L8_bodyB:;
+-#### Untoll time 1 ####
++//#### Untoll time 1 ####
+ MUL_DY	yvec0, yvec2, yvec6;
+ ADD_DY	yvec15, yvec6, yvec15;
+ SHUF_DY	$0x03, yvec2, yvec2, yvec4;
+@@ -943,27 +943,27 @@ MUL_DY	yvec0, yvec5, yvec7;
+ ADD_DY	yvec9, yvec7, yvec9;
+ 
+ .L8_loopE:;
+-#### Load Alpha ####
++//#### Load Alpha ####
+ BROAD_DY	MEMALPHA, yvec7;
+-#### Multiply Alpha ####
++//#### Multiply Alpha ####
+ MUL_DY yvec7,yvec15,yvec15;
+ MUL_DY yvec7,yvec13,yvec13;
+ MUL_DY yvec7,yvec11,yvec11;
+ MUL_DY yvec7,yvec9,yvec9;
+-#### Reverse the Results ####
++//#### Reverse the Results ####
+ MOV_DY	yvec15, yvec7;
+ REVS_DY $0x0a,yvec13,yvec15,yvec15;
+ REVS_DY $0x0a,yvec7,yvec13,yvec13;
+ MOV_DY yvec11,yvec7;
+ REVS_DY $0x0a,yvec9,yvec11,yvec11;
+ REVS_DY $0x0a,yvec7,yvec9,yvec9;
+-#### Testing alignment ####
++//#### Testing alignment ####
+ MOVQ	C0, %rax;
+ OR		ldc, %rax;
+ TEST	$15, %rax;
+ JNE		.L8_loopEx;					# Unalign part write back
+ ALIGN_5
+-#### Writing Back ####
++//#### Writing Back ####
+ EXTRA_DY $1,yvec15,xvec7;
+ EXTRA_DY $1,yvec13,xvec5;
+ EXTRA_DY $1,yvec11,xvec3;
+@@ -1076,7 +1076,7 @@ LEAQ (, %rax, SIZE), %rax;
+ LEAQ (ptrba, %rax, 2), ptrba;
+ LEAQ (ptrbb, %rax, 4), ptrbb
+ #endif
+-#### Initial Results Register ####
++//#### Initial Results Register ####
+ LD_DX	0*SIZE(ptrbb), xvec2;
+ XOR_DY yvec15, yvec15, yvec15;
+ LD_DX	2*SIZE(ptrbb), xvec3;
+@@ -1106,7 +1106,7 @@ ALIGN_5;
+ .L10_bodyB:;
+ # Computing kernel
+ 
+-##### Unroll time 1 ####
++//#### Unroll time 1 ####
+ LD_DX	4*SIZE(ptrbb), xvec6;
+ SHUF_DX	$0x4e, xvec3, xvec5;
+ MUL_DX xvec0, xvec2, xvec2;
+@@ -1123,7 +1123,7 @@ SHUF_DX	$0x4e, xvec6, xvec4;
+ MUL_DX xvec0, xvec5, xvec5;
+ ADD_DX xvec5, xvec9, xvec9;
+ 
+-#### Unroll time 2 ####
++//#### Unroll time 2 ####
+ LD_DX	8*SIZE(ptrbb), xvec2;
+ SHUF_DX	$0x4e, xvec7, xvec5;
+ MUL_DX xvec1, xvec6, xvec6;
+@@ -1140,7 +1140,7 @@ SHUF_DX	$0x4e, xvec2, xvec4;
+ MUL_DX xvec1, xvec5, xvec5;
+ ADD_DX xvec5, xvec9, xvec9;
+ 
+-##### Unroll time 3 ####
++//#### Unroll time 3 ####
+ LD_DX	12*SIZE(ptrbb), xvec6;
+ SHUF_DX	$0x4e, xvec3, xvec5;
+ MUL_DX xvec0, xvec2, xvec2;
+@@ -1159,7 +1159,7 @@ ADDQ	$8*SIZE, ptrba;
+ MUL_DX xvec0, xvec5, xvec5;
+ ADD_DX xvec5, xvec9, xvec9;
+ 
+-#### Unroll time 4 ####
++//#### Unroll time 4 ####
+ LD_DX	0*SIZE(ptrbb), xvec2;
+ SHUF_DX	$0x4e, xvec7, xvec5;
+ MUL_DX xvec1, xvec6, xvec6;
+@@ -1188,7 +1188,7 @@ TEST $2, %rax;
+ JLE .L11_loopE;
+ ALIGN_5
+ .L11_bodyB:;
+-##### Unroll time 1 ####
++//#### Unroll time 1 ####
+ LD_DX	4*SIZE(ptrbb), xvec6;
+ SHUF_DX	$0x4e, xvec3, xvec5;
+ MUL_DX xvec0, xvec2, xvec2;
+@@ -1208,7 +1208,7 @@ ADDQ	$4*SIZE, ptrba;
+ MUL_DX xvec0, xvec5, xvec5;
+ ADD_DX xvec5, xvec9, xvec9;
+ 
+-#### Unroll time 2 ####
++//#### Unroll time 2 ####
+ LD_DX	0*SIZE(ptrbb), xvec2;
+ SHUF_DX	$0x4e, xvec7, xvec5;
+ MUL_DX xvec1, xvec6, xvec6;
+@@ -1251,27 +1251,27 @@ MUL_DX xvec0, xvec5, xvec5;
+ ADD_DX xvec5, xvec9, xvec9;
+ 
+ .L12_loopE:;
+-#### Load Alpha ####
++//#### Load Alpha ####
+ BROAD_DX MEMALPHA, xvec7;
+-#### Multiply Alpha ####
++//#### Multiply Alpha ####
+ MUL_DX xvec7, xvec15, xvec15;
+ MUL_DX xvec7, xvec13, xvec13;
+ MUL_DX xvec7, xvec11, xvec11;
+ MUL_DX xvec7, xvec9, xvec9;
+-#### Reverse the Results ####
++//#### Reverse the Results ####
+ MOV_DX	xvec15, xvec6;
+ REVS_DX xvec13, xvec15, xvec15;
+ REVS_DX xvec6, xvec13, xvec13;
+ MOV_DX	xvec11, xvec6;
+ REVS_DX xvec9, xvec11, xvec11;
+ REVS_DX xvec6, xvec9, xvec9;
+-#### Testing Alignment ####
++//#### Testing Alignment ####
+ MOVQ	C0, %rax;
+ OR		ldc, %rax;
+ TEST	$15, %rax;
+ JNE		.L12_loopEx;
+ ALIGN_5
+-#### Writing Back ####
++//#### Writing Back ####
+ #ifndef	TRMMKERNEL
+ ADD_DX 0*SIZE(C0), xvec13, xvec13;
+ ADD_DX 0*SIZE(C0, ldc, 1), xvec15, xvec15;
+@@ -1345,7 +1345,7 @@ LEAQ (,%rax, SIZE), %rax;
+ ADDQ	%rax, ptrba;
+ LEAQ (ptrbb, %rax, 4), ptrbb;
+ #endif
+-#### Initial Results Register ####
++//#### Initial Results Register ####
+ XOR_DY	yvec15, yvec15, yvec15;
+ #ifndef	TRMMKERNEL
+ MOVQ bk, k;
+@@ -1429,11 +1429,11 @@ ADDQ	$1*SIZE, ptrba;
+ ADDQ	$4*SIZE, ptrbb;
+ 
+ .L16_loopE:
+-#### Load Alpha ####
++//#### Load Alpha ####
+ BROAD_DY MEMALPHA, yvec7;
+-#### Multiply Alpha ####
++//#### Multiply Alpha ####
+ MUL_DY	yvec15, yvec7, yvec15;
+-#### Writing Back ####
++//#### Writing Back ####
+ EXTRA_DY $1, yvec15, xvec7;
+ #ifndef	TRMMKERNEL
+ LDL_DX 0*SIZE(C0), xvec0, xvec0;
+@@ -1497,7 +1497,7 @@ LEAQ (, %rax, SIZE), %rax;
+ LEAQ (ptrba, %rax, 8), ptrba;
+ LEAQ (ptrbb, %rax, 2), ptrbb;
+ #endif
+-#### Initial Results Register ####
++//#### Initial Results Register ####
+ XOR_DY yvec15, yvec15, yvec15;
+ XOR_DY yvec14, yvec14, yvec14;
+ XOR_DY yvec13, yvec13, yvec13;
+@@ -1526,7 +1526,7 @@ JLE .L211_loopE;
+ ALIGN_5;
+ .L211_bodyB:
+ # Computing kernel
+-#### Unroll time 1 ####
++//#### Unroll time 1 ####
+ LD_DX	0*SIZE(ptrba), xvec0;
+ LD_DX	0*SIZE(ptrbb), xvec4;
+ MOV_DX	xvec4, xvec5;
+@@ -1563,7 +1563,7 @@ ADD_DX xvec6, xvec9, xvec9;
+ MUL_DX xvec3, xvec7, xvec7;
+ ADD_DX xvec7, xvec8, xvec8;
+ 
+-#### Unroll time 2 ####
++//#### Unroll time 2 ####
+ LD_DX	8*SIZE(ptrba), xvec0;
+ LD_DX	2*SIZE(ptrbb), xvec4;
+ MOV_DX	xvec4, xvec5;
+@@ -1600,7 +1600,7 @@ ADD_DX xvec6, xvec9, xvec9;
+ MUL_DX xvec3, xvec7, xvec7;
+ ADD_DX xvec7, xvec8, xvec8;
+ 
+-#### Unroll time 3 ####
++//#### Unroll time 3 ####
+ LD_DX	16*SIZE(ptrba), xvec0;
+ LD_DX	4*SIZE(ptrbb), xvec4;
+ MOV_DX	xvec4, xvec5;
+@@ -1637,7 +1637,7 @@ ADD_DX xvec6, xvec9, xvec9;
+ MUL_DX xvec3, xvec7, xvec7;
+ ADD_DX xvec7, xvec8, xvec8;
+ 
+-#### Unroll time 4 ####
++//#### Unroll time 4 ####
+ LD_DX	24*SIZE(ptrba), xvec0;
+ LD_DX	6*SIZE(ptrbb), xvec4;
+ MOV_DX	xvec4, xvec5;
+@@ -1689,7 +1689,7 @@ JLE .L212_loopE;
+ ALIGN_5;
+ .L212_bodyB:
+ # Computing kernel
+-#### Unroll time 1 ####
++//#### Unroll time 1 ####
+ LD_DX	0*SIZE(ptrba), xvec0;
+ LD_DX	0*SIZE(ptrbb), xvec4;
+ MOV_DX	xvec4, xvec5;
+@@ -1726,7 +1726,7 @@ ADD_DX xvec6, xvec9, xvec9;
+ MUL_DX xvec3, xvec7, xvec7;
+ ADD_DX xvec7, xvec8, xvec8;
+ 
+-#### Unroll time 2 ####
++//#### Unroll time 2 ####
+ LD_DX	8*SIZE(ptrba), xvec0;
+ LD_DX	2*SIZE(ptrbb), xvec4;
+ MOV_DX	xvec4, xvec5;
+@@ -1775,7 +1775,7 @@ TEST $1, %rax;
+ JLE .L213_loopE;
+ ALIGN_5
+ .L213_bodyB:
+-#### Unroll time 1 ####
++//#### Unroll time 1 ####
+ LD_DX	0*SIZE(ptrba), xvec0;
+ LD_DX	0*SIZE(ptrbb), xvec4;
+ MOV_DX	xvec4, xvec5;
+@@ -1815,7 +1815,7 @@ MUL_DX xvec3, xvec7, xvec7;
+ ADD_DX xvec7, xvec8, xvec8;
+ 
+ .L213_loopE:
+-#### Multiply Alpha ####
++//#### Multiply Alpha ####
+ BROAD_DX MEMALPHA, xvec7;
+ MUL_DX xvec7, xvec15, xvec15;
+ MUL_DX xvec7, xvec14, xvec14;
+@@ -1825,7 +1825,7 @@ MUL_DX xvec7, xvec11, xvec11;
+ MUL_DX xvec7, xvec10, xvec10;
+ MUL_DX xvec7, xvec9, xvec9;
+ MUL_DX xvec7, xvec8, xvec8;
+-#### Reverse #####
++//#### Reverse ####
+ MOV_DX	xvec15, xvec6;
+ REVS_DX xvec11, xvec15, xvec15;
+ REVS_DX xvec6, xvec11, xvec11;
+@@ -1838,13 +1838,13 @@ REVS_DX xvec6, xvec9, xvec9;
+ MOV_DX	xvec12, xvec6;
+ REVS_DX xvec8, xvec12, xvec12;
+ REVS_DX xvec6, xvec8, xvec8;
+-#### Testing Alignment ####
++//#### Testing Alignment ####
+ MOVQ	C0, %rax;
+ OR		ldc, %rax;
+ TEST	$15, %rax;
+ JNE		.L213_loopEx;
+ ALIGN_5
+-#### Writing Back ####
++//#### Writing Back ####
+ #ifndef	TRMMKERNEL
+ ADD_DX 0*SIZE(C0), xvec11, xvec11;
+ ADD_DX 2*SIZE(C0), xvec10, xvec10;
+@@ -1952,7 +1952,7 @@ LEAQ	(,%rax, SIZE), %rax;
+ LEAQ	(ptrba, %rax, 4), ptrba;
+ LEAQ	(ptrbb, %rax, 2), ptrbb;
+ #endif
+-#### Initial Results Register ####
++//#### Initial Results Register ####
+ XOR_DY yvec15, yvec15, yvec15;
+ XOR_DY yvec14, yvec14, yvec14;
+ XOR_DY yvec11, yvec11, yvec11;
+@@ -1977,7 +1977,7 @@ JLE	.L221_loopE;
+ ALIGN_5
+ .L221_bodyB:;
+ # Computing kernel
+-#### Unroll time 1 ####
++//#### Unroll time 1 ####
+ LD_DX	0*SIZE(ptrba), xvec0;
+ LD_DX	0*SIZE(ptrbb), xvec4;
+ MOV_DX	xvec4, xvec5;
+@@ -1996,7 +1996,7 @@ ADD_DX xvec4, xvec11, xvec11;
+ MUL_DX xvec1, xvec5, xvec5;
+ ADD_DX xvec5, xvec10, xvec10;
+ 
+-#### Unroll time 2 ####
++//#### Unroll time 2 ####
+ LD_DX	4*SIZE(ptrba), xvec0;
+ LD_DX	2*SIZE(ptrbb), xvec4;
+ MOV_DX	xvec4, xvec5;
+@@ -2015,7 +2015,7 @@ ADD_DX xvec4, xvec11, xvec11;
+ MUL_DX xvec1, xvec5, xvec5;
+ ADD_DX xvec5, xvec10, xvec10;
+ 
+-#### Unroll time 3 ####
++//#### Unroll time 3 ####
+ LD_DX	8*SIZE(ptrba), xvec0;
+ LD_DX	4*SIZE(ptrbb), xvec4;
+ MOV_DX	xvec4, xvec5;
+@@ -2034,7 +2034,7 @@ ADD_DX xvec4, xvec11, xvec11;
+ MUL_DX xvec1, xvec5, xvec5;
+ ADD_DX xvec5, xvec10, xvec10;
+ 
+-#### Unroll time 4 ####
++//#### Unroll time 4 ####
+ LD_DX	12*SIZE(ptrba), xvec0;
+ LD_DX	6*SIZE(ptrbb), xvec4;
+ MOV_DX	xvec4, xvec5;
+@@ -2067,7 +2067,7 @@ TEST $2, %rax;
+ JLE .L222_loopE;
+ ALIGN_5
+ .L222_bodyB:
+-#### Unroll time 1 ####
++//#### Unroll time 1 ####
+ LD_DX	0*SIZE(ptrba), xvec0;
+ LD_DX	0*SIZE(ptrbb), xvec4;
+ MOV_DX	xvec4, xvec5;
+@@ -2086,7 +2086,7 @@ ADD_DX xvec4, xvec11, xvec11;
+ MUL_DX xvec1, xvec5, xvec5;
+ ADD_DX xvec5, xvec10, xvec10;
+ 
+-#### Unroll time 2 ####
++//#### Unroll time 2 ####
+ LD_DX	4*SIZE(ptrba), xvec0;
+ LD_DX	2*SIZE(ptrbb), xvec4;
+ MOV_DX	xvec4, xvec5;
+@@ -2116,7 +2116,7 @@ TEST $1, %rax;
+ JLE .L223_loopE;
+ ALIGN_5
+ .L223_bodyB:
+-#### Unroll time 1 ####
++//#### Unroll time 1 ####
+ LD_DX	0*SIZE(ptrba), xvec0;
+ LD_DX	0*SIZE(ptrbb), xvec4;
+ MOV_DX	xvec4, xvec5;
+@@ -2138,26 +2138,26 @@ MUL_DX xvec1, xvec5, xvec5;
+ ADD_DX xvec5, xvec10, xvec10;
+ 
+ .L223_loopE:
+-#### Multiply Alpha ####
++//#### Multiply Alpha ####
+ BROAD_DX MEMALPHA, xvec7;
+ MUL_DX xvec7, xvec15, xvec15;
+ MUL_DX xvec7, xvec14, xvec14;
+ MUL_DX xvec7, xvec11, xvec11;
+ MUL_DX xvec7, xvec10, xvec10;
+-#### Reverse #####
++//#### Reverse ####
+ MOV_DX	xvec15, xvec6;
+ REVS_DX xvec11, xvec15, xvec15;
+ REVS_DX xvec6, xvec11, xvec11;
+ MOV_DX	xvec14, xvec6;
+ REVS_DX xvec10, xvec14, xvec14;
+ REVS_DX xvec6, xvec10, xvec10;
+-#### Testing Alignment ####
++//#### Testing Alignment ####
+ MOVQ	C0, %rax;
+ OR		ldc, %rax;
+ TEST	$15, %rax;
+ JNE		.L223_loopEx;
+ ALIGN_5
+-#### Writing Back ####
++//#### Writing Back ####
+ #ifndef	TRMMKERNEL
+ ADD_DX 0*SIZE(C0), xvec11, xvec11;
+ ADD_DX 2*SIZE(C0), xvec10, xvec10;
+@@ -2220,7 +2220,7 @@ ADDQ	$4, kk
+ ADDQ	$4*SIZE, C0;
+ ADDQ	$4*SIZE, C1;
+ .L22_loopE:;
+-TEST $2, bm;				# Rm = 2
++TEST $2, bm;				// Rm = 2
+ JLE .L23_loopE;
+ ALIGN_5;
+ .L23_bodyB:
+@@ -2255,7 +2255,7 @@ JLE .L231_loopE;
+ ALIGN_5
+ .L231_bodyB:
+ # Computing kernel
+-#### Unroll time 1 ####
++//#### Unroll time 1 ####
+ LD_DX	0*SIZE(ptrba), xvec0;
+ LD_DX	0*SIZE(ptrbb), xvec4;
+ SHUF_DX $0x4e, xvec4, xvec5;
+@@ -2264,7 +2264,7 @@ ADD_DX xvec4, xvec15, xvec15;
+ 
+ MUL_DX xvec0, xvec5, xvec5;
+ ADD_DX xvec5, xvec11, xvec11;
+-#### Unroll time 2 ####
++//#### Unroll time 2 ####
+ LD_DX	2*SIZE(ptrba), xvec0;
+ LD_DX	2*SIZE(ptrbb), xvec4;
+ SHUF_DX $0x4e, xvec4, xvec5;
+@@ -2273,7 +2273,7 @@ ADD_DX xvec4, xvec15, xvec15;
+ 
+ MUL_DX xvec0, xvec5, xvec5;
+ ADD_DX xvec5, xvec11, xvec11;
+-#### Unroll time 3 ####
++//#### Unroll time 3 ####
+ LD_DX	4*SIZE(ptrba), xvec0;
+ LD_DX	4*SIZE(ptrbb), xvec4;
+ SHUF_DX $0x4e, xvec4, xvec5;
+@@ -2282,7 +2282,7 @@ ADD_DX xvec4, xvec15, xvec15;
+ 
+ MUL_DX xvec0, xvec5, xvec5;
+ ADD_DX xvec5, xvec11, xvec11;
+-#### Unroll time 4 ####
++//#### Unroll time 4 ####
+ LD_DX	6*SIZE(ptrba), xvec0;
+ LD_DX	6*SIZE(ptrbb), xvec4;
+ SHUF_DX $0x4e, xvec4, xvec5;
+@@ -2305,7 +2305,7 @@ TEST $2, %rax;
+ JLE .L232_loopE;
+ ALIGN_5
+ .L232_bodyB:
+-#### Unroll time 1 ####
++//#### Unroll time 1 ####
+ LD_DX	0*SIZE(ptrba), xvec0;
+ LD_DX	0*SIZE(ptrbb), xvec4;
+ SHUF_DX $0x4e, xvec4, xvec5;
+@@ -2314,7 +2314,7 @@ ADD_DX xvec4, xvec15, xvec15;
+ 
+ MUL_DX xvec0, xvec5, xvec5;
+ ADD_DX xvec5, xvec11, xvec11;
+-#### Unroll time 2 ####
++//#### Unroll time 2 ####
+ LD_DX	2*SIZE(ptrba), xvec0;
+ LD_DX	2*SIZE(ptrbb), xvec4;
+ SHUF_DX $0x4e, xvec4, xvec5;
+@@ -2334,7 +2334,7 @@ TEST $1, %rax;
+ JLE .L233_loopE;
+ ALIGN_5
+ .L233_bodyB:
+-#### Unroll time 1 ####
++//#### Unroll time 1 ####
+ LD_DX	0*SIZE(ptrba), xvec0;
+ LD_DX	0*SIZE(ptrbb), xvec4;
+ SHUF_DX $0x4e, xvec4, xvec5;
+@@ -2345,21 +2345,21 @@ MUL_DX xvec0, xvec5, xvec5;
+ ADD_DX xvec5, xvec11, xvec11;
+ ADDQ	$2*SIZE, ptrbb;
+ .L233_loopE:
+-#### Multiply Alpha ####
++//#### Multiply Alpha ####
+ BROAD_DX MEMALPHA, xvec7;
+ MUL_DX xvec7, xvec15, xvec15;
+ MUL_DX xvec7, xvec11, xvec11;
+-#### Reverse #####
++//#### Reverse ####
+ MOV_DX	xvec15, xvec6;
+ REVS_DX xvec11, xvec15, xvec15;
+ REVS_DX xvec6, xvec11, xvec11;
+-#### Testing Alignment ####
++//#### Testing Alignment ####
+ MOVQ	C0, %rax;
+ OR		ldc, %rax;
+ TEST	$15, %rax;
+ JNE		.L233_loopEx;
+ ALIGN_5
+-#### Writing Back ####
++//#### Writing Back ####
+ #ifndef	TRMMKERNEL
+ ADD_DX 0*SIZE(C0), xvec11, xvec11;
+ ADD_DX 0*SIZE(C1), xvec15, xvec15;
+@@ -2408,7 +2408,7 @@ ADDQ	$2, kk;
+ ADDQ	$2*SIZE, C0;
+ ADDQ	$2*SIZE, C1;
+ .L23_loopE:
+-TEST $1, bm;				# Rm = 1
++TEST $1, bm;				// Rm = 1
+ JLE .L24_loopE;
+ ALIGN_5;
+ .L24_bodyB:
+@@ -2534,7 +2534,7 @@ SALQ $4, k;
+ ADDQ k, bb;
+ LEAQ (C, ldc, 2), C;
+ .L20_loopE:;
+-TEST $1, bn;					# Rn = 1
++TEST $1, bn;					// Rn = 1
+ JLE .L30_loopE;
+ ALIGN_5
+ .L30_bodyB:
+@@ -2558,7 +2558,7 @@ LEAQ (, %rax, SIZE), %rax;
+ LEAQ (ptrba, %rax, 8), ptrba;
+ ADDQ	%rax, ptrbb;
+ #endif
+-#### Initial Results Register ####
++//#### Initial Results Register ####
+ XOR_DY	yvec15, yvec15, yvec15;
+ XOR_DY	yvec14, yvec14, yvec14;
+ #ifndef	TRMMKERNEL
+@@ -2580,7 +2580,7 @@ SARQ $2, k;
+ JLE .L311_loopE;
+ ALIGN_5
+ .L311_bodyB:
+-#### Unroll time 1 ####
++//#### Unroll time 1 ####
+ LD_DY	0*SIZE(ptrba), yvec0;
+ LD_DY	4*SIZE(ptrba), yvec1;
+ BROAD_DY 0*SIZE(ptrbb), yvec2;
+@@ -2589,7 +2589,7 @@ ADD_DY	yvec0, yvec15, yvec15;
+ MUL_DY	yvec2, yvec1, yvec1;
+ ADD_DY	yvec1, yvec14, yvec14;
+ 
+-#### Unroll time 2 ####
++//#### Unroll time 2 ####
+ LD_DY	8*SIZE(ptrba), yvec3;
+ LD_DY	12*SIZE(ptrba), yvec4;
+ BROAD_DY 1*SIZE(ptrbb), yvec5;
+@@ -2598,7 +2598,7 @@ ADD_DY	yvec3, yvec15, yvec15;
+ MUL_DY	yvec5, yvec4, yvec4
+ ADD_DY	yvec4, yvec14, yvec14;
+ 
+-#### Unroll time 3 ####
++//#### Unroll time 3 ####
+ LD_DY	16*SIZE(ptrba), yvec0;
+ LD_DY	20*SIZE(ptrba), yvec1;
+ BROAD_DY 2*SIZE(ptrbb), yvec2;
+@@ -2607,7 +2607,7 @@ ADD_DY	yvec0, yvec15, yvec15;
+ MUL_DY	yvec2, yvec1, yvec1;
+ ADD_DY	yvec1, yvec14, yvec14;
+ 
+-#### Unroll time 2 ####
++//#### Unroll time 2 ####
+ LD_DY	24*SIZE(ptrba), yvec3;
+ LD_DY	28*SIZE(ptrba), yvec4;
+ BROAD_DY 3*SIZE(ptrbb), yvec5;
+@@ -2630,7 +2630,7 @@ TEST $2, %rax;
+ JLE .L312_loopE;
+ ALIGN_5
+ .L312_bodyB:
+-#### Unroll time 1 ####
++//#### Unroll time 1 ####
+ LD_DY	0*SIZE(ptrba), yvec0;
+ LD_DY	4*SIZE(ptrba), yvec1;
+ BROAD_DY 0*SIZE(ptrbb), yvec2;
+@@ -2639,7 +2639,7 @@ ADD_DY	yvec0, yvec15, yvec15;
+ MUL_DY	yvec2, yvec1, yvec1;
+ ADD_DY	yvec1, yvec14, yvec14;
+ 
+-#### Unroll time 2 ####
++//#### Unroll time 2 ####
+ LD_DY	8*SIZE(ptrba), yvec3;
+ LD_DY	12*SIZE(ptrba), yvec4;
+ BROAD_DY 1*SIZE(ptrbb), yvec5;
+@@ -2660,7 +2660,7 @@ TEST $1, %rax;
+ JLE .L313_loopE;
+ ALIGN_5
+ .L313_bodyB:
+-#### Unroll time 1 ####
++//#### Unroll time 1 ####
+ LD_DY	0*SIZE(ptrba), yvec0;
+ LD_DY	4*SIZE(ptrba), yvec1;
+ BROAD_DY 0*SIZE(ptrbb), yvec2;
+@@ -2672,17 +2672,17 @@ ADD_DY	yvec1, yvec14, yvec14;
+ ADDQ	$1*SIZE, ptrbb;
+ 
+ .L313_loopE:
+-#### Multiply Alpha ####
++//#### Multiply Alpha ####
+ BROAD_DY MEMALPHA, yvec7;
+ MUL_DY	yvec7, yvec15, yvec15;
+ MUL_DY	yvec7, yvec14, yvec14;
+-#### Testing Alignment ####
++//#### Testing Alignment ####
+ MOVQ	C0, %rax;
+ OR		ldc, %rax;
+ TEST 	$15, %rax;
+ JNE		.L313_loopEx;
+ ALIGN_5
+-#### Writing Back ####
++//#### Writing Back ####
+ EXTRA_DY $1, yvec15, xvec13;
+ EXTRA_DY $1, yvec14, xvec12;
+ #ifndef	TRMMKERNEL
+@@ -2762,7 +2762,7 @@ LEAQ (,%rax, SIZE), %rax;
+ LEAQ (ptrba, %rax, 4), ptrba;
+ ADDQ	%rax, ptrbb;
+ #endif
+-#### Initial Results Register ####
++//#### Initial Results Register ####
+ XOR_DY	yvec15, yvec15, yvec15;
+ #ifndef	TRMMKERNEL
+ MOVQ bk, k;
+@@ -2847,16 +2847,16 @@ ADDQ	$4*SIZE, ptrba;
+ ADDQ	$1*SIZE, ptrbb;
+ 
+ .L323_loopE:
+-#### Multiply Alpha ####
++//#### Multiply Alpha ####
+ BROAD_DY MEMALPHA, yvec7;
+ MUL_DY	yvec7, yvec15, yvec15;
+-#### Testing Alignment ####
++//#### Testing Alignment ####
+ MOVQ	C0, %rax;
+ OR		ldc, %rax;
+ TEST	$15, %rax;
+ JNE	.L323_loopEx;
+ ALIGN_5
+-#### Writing Back ####
++//#### Writing Back ####
+ EXTRA_DY $1, yvec15, xvec14;
+ #ifndef	TRMMKERNEL
+ ADD_DX 0*SIZE(C0), xvec15, xvec15;
+@@ -2878,7 +2878,7 @@ ADDQ	$4*SIZE, C0;
+ JMP .L32_loopE;
+ ALIGN_5
+ .L323_loopEx:
+-#### Writing Back ####
++//#### Writing Back ####
+ EXTRA_DY $1, yvec15, xvec14;
+ #ifndef	TRMMKERNEL
+ LDL_DX 0*SIZE(C0), xvec13, xvec13;
+@@ -2917,7 +2917,7 @@ LEAQ (, %rax, SIZE), %rax
+ LEAQ (ptrba, %rax, 2), ptrba
+ ADDQ %rax, ptrbb;
+ #endif
+-#### Initial Result ####
++//#### Initial Result ####
+ XOR_DY	yvec15, yvec15, yvec15;
+ #ifndef	TRMMKERNEL
+ MOVQ bk, k;
+@@ -3000,7 +3000,7 @@ ADD_DX xvec2, xvec15, xvec15;
+ ADDQ	$2*SIZE, ptrba;
+ ADDQ	$1*SIZE, ptrbb;
+ .L333_loopE:
+-#### Multiply Alpha ####
++//#### Multiply Alpha ####
+ BROAD_DX MEMALPHA, xvec7;
+ MUL_DX xvec7, xvec15, xvec15;
+ #ifndef	TRMMKERNEL
+@@ -3119,7 +3119,7 @@ addq	$1*SIZE, ptrba;
+ addq	$1*SIZE, ptrbb;
+ 
+ .L343_loopE:
+-#### Writing Back ####
++//#### Writing Back ####
+ vmovsd	MEMALPHA, xvec7;
+ vmulsd	xvec7, xvec15, xvec15;
+ #ifndef	TRMMKERNEL
diff --git a/deps/patches/openblas-cross-compile.patch b/deps/patches/openblas-cross-compile.patch
new file mode 100644
index 00000000000000..a71b30cc19b129
--- /dev/null
+++ b/deps/patches/openblas-cross-compile.patch
@@ -0,0 +1,13 @@
+diff --git a/c_check b/c_check
+index 2ec9fc48..371dbf61 100644
+--- a/c_check
++++ b/c_check
+@@ -34,7 +34,7 @@ if (dirname($compiler_name) ne ".") {
+     $cross_suffix .= dirname($compiler_name) . "/";
+ }
+ 
+-if (basename($compiler_name) =~ /(.*-)(.*)/) {
++if (basename($compiler_name) =~ /([^\s]*-)(.*)/) {
+     $cross_suffix .= $1;
+ }
+ 
diff --git a/deps/patches/openblas-power-assembly-fixes.patch b/deps/patches/openblas-power-assembly-fixes.patch
new file mode 100644
index 00000000000000..2031a131422ad3
--- /dev/null
+++ b/deps/patches/openblas-power-assembly-fixes.patch
@@ -0,0 +1,7834 @@
+commit 9e2f316ede9ee12441e9eb30784ceb653295b80a
+Author: Martin Kroeker <martin@ruby.chemie.uni-freiburg.de>
+Date:   Mon Feb 13 23:38:50 2017 +0100
+
+    Power8 inline assembly fixes
+    
+    Quoting patch author amodra from #1078
+    Lots of issues here.
+    - The vsx regs weren't listed as clobbered.
+    - Poor choice of vsx regs, which along with the lack of clobbers led to
+      trashing v0..v21 and fr14..fr23.  Ideally you'd let gcc choose all
+      temp vsx regs, but asms currently have a limit of 30 i/o parms.
+    - Other regs were clobbered unnecessarily, seemingly in an attempt to
+      clobber inputs, with gcc-7 complaining about the clobber of r2.
+      (Changed inputs should be also listed as outputs or as an i/o.)
+    - "r" constraint used instead of "b" for gprs used in insns where the
+      r0 encoding means zero rather than r0.
+    - There were unused asm inputs too.
+    - All memory was clobbered rather than hooking up memory outputs with
+      proper memory constraints, and that and the lack of proper memory
+      input constraints meant the asms needed to be volatile and their
+      containing function noinline.
+    - Some parameters were being passed unnecessarily via memory.
+    - When a copy of a
+
+diff --git a/kernel/power/casum.c b/kernel/power/casum.c
+index aeed0ca..d110858 100644
+--- a/kernel/power/casum.c
++++ b/kernel/power/casum.c
+@@ -53,7 +53,7 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+ #ifndef HAVE_KERNEL_16
+ 
+-static void casum_kernel_16(BLASLONG n, FLOAT *x1, FLOAT *svec)
++static FLOAT casum_kernel_16(BLASLONG n, FLOAT *x1)
+ {
+ 
+ 	BLASLONG i=0;
+@@ -92,11 +92,7 @@ static void casum_kernel_16(BLASLONG n, FLOAT *x1, FLOAT *svec)
+ 
+ 	}
+ 
+-	svec[0] = sum0+sum1+sum2+sum3;
+-	svec[1] = 0.0;
+-	svec[2] = 0.0;
+-	svec[3] = 0.0;
+-
++	return sum0+sum1+sum2+sum3;
+ }
+ 
+ #endif
+@@ -106,7 +102,6 @@ FLOAT CNAME(BLASLONG n, FLOAT *x, BLASLONG inc_x)
+ 	BLASLONG i=0;
+ 	BLASLONG ip=0;
+ 	FLOAT sumf = 0.0;
+-	FLOAT svec[4] __attribute__ ((aligned (16)));;
+ 	BLASLONG n1;
+ 	BLASLONG inc_x2;
+ 
+@@ -119,8 +114,7 @@ FLOAT CNAME(BLASLONG n, FLOAT *x, BLASLONG inc_x)
+ 		if ( n1 > 0 )
+ 		{
+ 
+-			casum_kernel_16(n1, x, svec);
+-			sumf = svec[0] + svec[1]+svec[2]+svec[3];
++			sumf = casum_kernel_16(n1, x);
+ 			i=n1;
+ 			ip = 2 * n1;
+ 		}
+diff --git a/kernel/power/casum_microk_power8.c b/kernel/power/casum_microk_power8.c
+index cb50234..38a1143 100644
+--- a/kernel/power/casum_microk_power8.c
++++ b/kernel/power/casum_microk_power8.c
+@@ -34,144 +34,145 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ **************************************************************************************/
+ 
+ #define HAVE_KERNEL_16 1
+-static void casum_kernel_16( BLASLONG n, FLOAT *x, FLOAT *svec) __attribute__ ((noinline));
+ 
+-static void casum_kernel_16( BLASLONG n, FLOAT *x, FLOAT *svec)
++static float casum_kernel_16 (long n, float *x)
+ {
+-
+-
+-	BLASLONG i = n;
+-	BLASLONG o16 = 16;
+-	BLASLONG o32 = 32;
+-	BLASLONG o48 = 48;
+-	BLASLONG o64 = 64;
+-	BLASLONG o80 = 80;
+-	BLASLONG o96 = 96;
+-	BLASLONG o112 = 112;
+-	FLOAT *x1=x;
+-	BLASLONG pre = 384;
+-
+-	__asm__  __volatile__
+-	(
+-
+-	"dcbt		%2 , %4				    \n\t"
+-
+-	"xxlxor		32,32,32			    \n\t"
+-	"xxlxor		33,33,33			    \n\t"
+-	"xxlxor		34,34,34			    \n\t"
+-	"xxlxor		35,35,35			    \n\t"
+-	"xxlxor		36,36,36			    \n\t"
+-	"xxlxor		37,37,37			    \n\t"
+-	"xxlxor		38,38,38			    \n\t"
+-	"xxlxor		39,39,39			    \n\t"
+-
+-	"lxvw4x		40, 0, %2			    \n\t"
+-	"lxvw4x		41, %5, %2			    \n\t"
+-	"lxvw4x		42, %6, %2			    \n\t"
+-	"lxvw4x		43, %7, %2			    \n\t"
+-	"lxvw4x		44, %8, %2			    \n\t"
+-	"lxvw4x		45, %9, %2			    \n\t"
+-	"lxvw4x		46, %10, %2			    \n\t"
+-	"lxvw4x		47, %11, %2			    \n\t"
+-
+-	"addi		%2, %2, 128			    \n\t"
+-
+-	"addic.		%0 , %0	, -16  	 	             \n\t"
+-	"ble		2f		             	     \n\t"
+-
+-	".align 5				            \n\t"
+-	"1:				                    \n\t"
+-
+-	"dcbt		%2 , %4				    \n\t"
+-
+-	"xvabssp	48, 40				    \n\t"
+-	"xvabssp	49, 41				    \n\t"
+-	"xvabssp	50, 42				    \n\t"
+-	"xvabssp	51, 43				    \n\t"
+-
+-	"lxvw4x		40, 0, %2			    \n\t"
+-	"lxvw4x		41, %5, %2			    \n\t"
+-
+-	"xvabssp	52, 44				    \n\t"
+-	"xvabssp	53, 45				    \n\t"
+-
+-	"lxvw4x		42, %6, %2			    \n\t"
+-	"lxvw4x		43, %7, %2			    \n\t"
+-
+-	"xvabssp	54, 46				    \n\t"
+-	"xvabssp	55, 47				    \n\t"
+-
+-	"lxvw4x		44, %8, %2			    \n\t"
+-	"lxvw4x		45, %9, %2			    \n\t"
+-
+-	"xvaddsp	32, 32, 48		    \n\t"
+-	"xvaddsp	33, 33, 49		    \n\t"
+-
+-	"lxvw4x		46, %10, %2			    \n\t"
+-	"lxvw4x		47, %11, %2			    \n\t"
+-
+-	"xvaddsp	34, 34, 50		    \n\t"
+-	"xvaddsp	35, 35, 51		    \n\t"
+-	"addi		%2, %2, 128			    \n\t"
+-	"xvaddsp	36, 36, 52		    \n\t"
+-	"xvaddsp	37, 37, 53		    \n\t"
+-	"addic.		%0 , %0	, -16  	 	             \n\t"
+-	"xvaddsp	38, 38, 54		    \n\t"
+-	"xvaddsp	39, 39, 55		    \n\t"
+-
+-	"bgt		1b		             	     \n\t"
+-
+-	"2:						     \n\t"
+-
+-
+-	"xvabssp	48, 40				    \n\t"
+-	"xvabssp	49, 41				    \n\t"
+-	"xvabssp	50, 42				    \n\t"
+-	"xvabssp	51, 43				    \n\t"
+-	"xvabssp	52, 44				    \n\t"
+-	"xvabssp	53, 45				    \n\t"
+-	"xvabssp	54, 46				    \n\t"
+-	"xvabssp	55, 47				    \n\t"
+-
+-	"xvaddsp	32, 32, 48		    \n\t"
+-	"xvaddsp	33, 33, 49		    \n\t"
+-	"xvaddsp	34, 34, 50		    \n\t"
+-	"xvaddsp	35, 35, 51		    \n\t"
+-	"xvaddsp	36, 36, 52		    \n\t"
+-	"xvaddsp	37, 37, 53		    \n\t"
+-	"xvaddsp	38, 38, 54		    \n\t"
+-	"xvaddsp	39, 39, 55		    \n\t"
+-
+-	"xvaddsp	32, 32, 33		     \n\t"
+-	"xvaddsp	34, 34, 35		     \n\t"
+-	"xvaddsp	36, 36, 37		     \n\t"
+-	"xvaddsp	38, 38, 39		     \n\t"
+-
+-	"xvaddsp	32, 32, 34		     \n\t"
+-	"xvaddsp	36, 36, 38		     \n\t"
+-
+-	"xvaddsp	32, 32, 36		     \n\t"
+-
+-
+-	"stxvw4x	32, 0, %3		     \n\t"
+-
+-	:
+-        : 
+-          "r" (i),	// 0	
+-	  "r" (n),  	// 1
+-          "r" (x1),     // 2
+-          "r" (svec),   // 3
+-          "r" (pre),    // 4
+-	  "r" (o16),	// 5
+-	  "r" (o32),	// 6
+-	  "r" (o48),    // 7
+-          "r" (o64),    // 8
+-          "r" (o80),    // 9
+-          "r" (o96),    // 10
+-          "r" (o112)   // 11
+-	: "cr0", "%0", "%2",  "memory"
+-	);
+-
+-} 
+-
+-
++  float sum;
++  __vector float t0;
++  __vector float t1;
++  __vector float t2;
++  __vector float t3;
++
++  __asm__
++    (
++       "dcbt		0, %2		\n\t"
++
++       "xxlxor		32, 32,	32	\n\t"
++       "xxlxor		33, 33,	33	\n\t"
++       "xxlxor		34, 34,	34	\n\t"
++       "xxlxor		35, 35,	35	\n\t"
++       "xxlxor		36, 36,	36	\n\t"
++       "xxlxor		37, 37,	37	\n\t"
++       "xxlxor		38, 38,	38	\n\t"
++       "xxlxor		39, 39,	39	\n\t"
++
++       "lxvw4x		40, 0, %2	\n\t"
++       "lxvw4x		41, %8, %2	\n\t"
++       "lxvw4x		42, %9, %2	\n\t"
++       "lxvw4x		43, %10, %2	\n\t"
++       "lxvw4x		44, %11, %2	\n\t"
++       "lxvw4x		45, %12, %2	\n\t"
++       "lxvw4x		46, %13, %2	\n\t"
++       "lxvw4x		47, %14, %2	\n\t"
++
++       "addi		%2, %2, 128	\n\t"
++
++       "addic.		%1, %1, -16	\n\t"
++       "ble		2f		\n\t"
++
++       ".p2align	5		\n"
++     "1:				\n\t"
++
++       "xvabssp		48, 40		\n\t"
++       "xvabssp		49, 41		\n\t"
++       "xvabssp		50, 42		\n\t"
++       "xvabssp		51, 43		\n\t"
++
++       "lxvw4x		40, 0, %2	\n\t"
++       "lxvw4x		41, %8, %2	\n\t"
++
++       "xvabssp		%x3, 44		\n\t"
++       "xvabssp		%x4, 45		\n\t"
++
++       "lxvw4x		42, %9, %2	\n\t"
++       "lxvw4x		43, %10, %2	\n\t"
++
++       "xvabssp		%x5, 46		\n\t"
++       "xvabssp		%x6, 47		\n\t"
++
++       "lxvw4x		44, %11, %2	\n\t"
++       "lxvw4x		45, %12, %2	\n\t"
++
++       "xvaddsp		32, 32, 48	\n\t"
++       "xvaddsp		33, 33, 49	\n\t"
++
++       "lxvw4x		46, %13, %2	\n\t"
++       "lxvw4x		47, %14, %2	\n\t"
++
++       "xvaddsp		34, 34, 50	\n\t"
++       "xvaddsp		35, 35, 51	\n\t"
++       "addi		%2, %2, 128	\n\t"
++       "xvaddsp		36, 36, %x3	\n\t"
++       "xvaddsp		37, 37, %x4	\n\t"
++       "addic.		%1, %1, -16	\n\t"
++       "xvaddsp		38, 38, %x5	\n\t"
++       "xvaddsp		39, 39, %x6	\n\t"
++
++       "bgt		1b		\n"
++
++     "2:				\n\t"
++
++       "xvabssp		48, 40		\n\t"
++       "xvabssp		49, 41		\n\t"
++       "xvabssp		50, 42		\n\t"
++       "xvabssp		51, 43		\n\t"
++       "xvabssp		%x3, 44		\n\t"
++       "xvabssp		%x4, 45		\n\t"
++       "xvabssp		%x5, 46		\n\t"
++       "xvabssp		%x6, 47		\n\t"
++
++       "xvaddsp		32, 32, 48	\n\t"
++       "xvaddsp		33, 33, 49	\n\t"
++       "xvaddsp		34, 34, 50	\n\t"
++       "xvaddsp		35, 35, 51	\n\t"
++       "xvaddsp		36, 36, %x3	\n\t"
++       "xvaddsp		37, 37, %x4	\n\t"
++       "xvaddsp		38, 38, %x5	\n\t"
++       "xvaddsp		39, 39, %x6	\n\t"
++
++       "xvaddsp		32, 32, 33	\n\t"
++       "xvaddsp		34, 34, 35	\n\t"
++       "xvaddsp		36, 36, 37	\n\t"
++       "xvaddsp		38, 38, 39	\n\t"
++
++       "xvaddsp		32, 32, 34	\n\t"
++       "xvaddsp		36, 36, 38	\n\t"
++
++       "xvaddsp		32, 32, 36	\n\t"
++
++       "xxsldwi		33, 32, 32, 2	\n\t"
++       "xvaddsp		32, 32, 33	\n\t"
++
++       "xxsldwi		33, 32, 32, 1	\n\t"
++       "xvaddsp		32, 32, 33	\n\t"
++
++       "xscvspdp	%0, 32		\n"
++
++     "#n=%1 x=%3=%2 sum=%0 o16=%8 o32=%9 o48=%10 o64=%11 o80=%12 o96=%13 o112=%14\n"
++     "#t0=%x3 t1=%x4 t2=%x5 t3=%x6"
++     :
++       "=f" (sum),	// 0
++       "+r" (n),	// 1
++       "+b" (x),	// 2
++       "=wa" (t0),	// 3
++       "=wa" (t1),	// 4
++       "=wa" (t2),	// 5
++       "=wa" (t3)	// 6
++     :
++       "m" (*x),
++       "b" (16),	// 8
++       "b" (32),	// 9
++       "b" (48),	// 10
++       "b" (64),	// 11
++       "b" (80),	// 12
++       "b" (96),	// 13
++       "b" (112)	// 14
++     :
++       "cr0",
++       "vs32","vs33","vs34","vs35","vs36","vs37","vs38","vs39",
++       "vs40","vs41","vs42","vs43","vs44","vs45","vs46","vs47",
++       "vs48","vs49","vs50","vs51"
++     );
++
++  return sum;
++}
+diff --git a/kernel/power/ccopy_microk_power8.c b/kernel/power/ccopy_microk_power8.c
+index 95b3559..b2b1bea 100644
+--- a/kernel/power/ccopy_microk_power8.c
++++ b/kernel/power/ccopy_microk_power8.c
+@@ -35,140 +35,121 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+ #define HAVE_KERNEL_32 1
+ 
+-static void ccopy_kernel_32( BLASLONG n, FLOAT *x, FLOAT *y) __attribute__ ((noinline));
+-
+-static void ccopy_kernel_32( BLASLONG n, FLOAT *x, FLOAT *y)
++static void ccopy_kernel_32 (long n, float *x, float *y)
+ {
+-
+-
+-	BLASLONG i = n;
+-	BLASLONG o16 = 16;
+-	BLASLONG o32 = 32;
+-	BLASLONG o48 = 48;
+-	BLASLONG o64 = 64;
+-	BLASLONG o80 = 80;
+-	BLASLONG o96 = 96;
+-	BLASLONG o112 = 112;
+-	FLOAT *x1=x;
+-	FLOAT *y1=y;
+-	BLASLONG pre = 384;
+-	BLASLONG alpha=0;
+-
+-	__asm__  __volatile__
+-	(
+-
+-	"lxvw4x		40, 0, %2			    \n\t"
+-	"lxvw4x		41, %5, %2			    \n\t"
+-	"lxvw4x		42, %6, %2			    \n\t"
+-	"lxvw4x		43, %7, %2			    \n\t"
+-	"lxvw4x		44, %8, %2			    \n\t"
+-	"lxvw4x		45, %9, %2			    \n\t"
+-	"lxvw4x		46, %10, %2			    \n\t"
+-	"lxvw4x		47, %11, %2			    \n\t"
+-
+-	"addi		%2, %2, 128			    \n\t"
+-
+-	"lxvw4x		50, 0, %2			    \n\t"
+-	"lxvw4x		51, %5, %2			    \n\t"
+-	"lxvw4x		52, %6, %2			    \n\t"
+-	"lxvw4x		53, %7, %2			    \n\t"
+-	"lxvw4x		54, %8, %2			    \n\t"
+-	"lxvw4x		55, %9, %2			    \n\t"
+-	"lxvw4x		56, %10, %2			    \n\t"
+-	"lxvw4x		57, %11, %2			    \n\t"
+-
+-	"addi		%2, %2, 128			    \n\t"
+-
+-	"addic.		%0 , %0	, -32  	 	             \n\t"
+-	"ble		2f		             	     \n\t"
+-
+-	".align 5				            \n\t"
+-	"1:				                    \n\t"
+-
+-	"stxvw4x		40, 0, %1			    \n\t"
+-	"stxvw4x		41, %5, %1			    \n\t"
+-	"lxvw4x		40, 0, %2			    \n\t"
+-	"lxvw4x		41, %5, %2			    \n\t"
+-	"stxvw4x		42, %6, %1			    \n\t"
+-	"stxvw4x		43, %7, %1			    \n\t"
+-	"lxvw4x		42, %6, %2			    \n\t"
+-	"lxvw4x		43, %7, %2			    \n\t"
+-	"stxvw4x		44, %8, %1			    \n\t"
+-	"stxvw4x		45, %9, %1			    \n\t"
+-	"lxvw4x		44, %8, %2			    \n\t"
+-	"lxvw4x		45, %9, %2			    \n\t"
+-	"stxvw4x		46, %10, %1			    \n\t"
+-	"stxvw4x		47, %11, %1			    \n\t"
+-	"lxvw4x		46, %10, %2			    \n\t"
+-	"lxvw4x		47, %11, %2			    \n\t"
+-
+-
+-	"addi		%1, %1, 128			    \n\t"
+-	"addi		%2, %2, 128			    \n\t"
+-
+-	"stxvw4x		50, 0, %1			    \n\t"
+-	"stxvw4x		51, %5, %1			    \n\t"
+-	"lxvw4x		50, 0, %2			    \n\t"
+-	"lxvw4x		51, %5, %2			    \n\t"
+-	"stxvw4x		52, %6, %1			    \n\t"
+-	"stxvw4x		53, %7, %1			    \n\t"
+-	"lxvw4x		52, %6, %2			    \n\t"
+-	"lxvw4x		53, %7, %2			    \n\t"
+-	"stxvw4x		54, %8, %1			    \n\t"
+-	"stxvw4x		55, %9, %1			    \n\t"
+-	"lxvw4x		54, %8, %2			    \n\t"
+-	"lxvw4x		55, %9, %2			    \n\t"
+-	"stxvw4x		56, %10, %1			    \n\t"
+-	"stxvw4x		57, %11, %1			    \n\t"
+-	"lxvw4x		56, %10, %2			    \n\t"
+-	"lxvw4x		57, %11, %2			    \n\t"
+-
+-	"addi		%1, %1, 128			    \n\t"
+-	"addi		%2, %2, 128			    \n\t"
+-
+-	"addic.		%0 , %0	, -32  	 	             \n\t"
+-	"bgt		1b		             	     \n\t"
+-
+-	"2:						     \n\t"
+-
+-	"stxvw4x		40, 0, %1			    \n\t"
+-	"stxvw4x		41, %5, %1			    \n\t"
+-	"stxvw4x		42, %6, %1			    \n\t"
+-	"stxvw4x		43, %7, %1			    \n\t"
+-	"stxvw4x		44, %8, %1			    \n\t"
+-	"stxvw4x		45, %9, %1			    \n\t"
+-	"stxvw4x		46, %10, %1			    \n\t"
+-	"stxvw4x		47, %11, %1			    \n\t"
+-
+-	"addi		%1, %1, 128			    \n\t"
+-
+-	"stxvw4x		50, 0, %1			    \n\t"
+-	"stxvw4x		51, %5, %1			    \n\t"
+-	"stxvw4x		52, %6, %1			    \n\t"
+-	"stxvw4x		53, %7, %1			    \n\t"
+-	"stxvw4x		54, %8, %1			    \n\t"
+-	"stxvw4x		55, %9, %1			    \n\t"
+-	"stxvw4x		56, %10, %1			    \n\t"
+-	"stxvw4x		57, %11, %1			    \n\t"
+-
+-
+-	:
+-        : 
+-          "r" (i),	// 0	
+-	  "r" (y1),  	// 1
+-          "r" (x1),     // 2
+-          "r" (alpha),  // 3
+-          "r" (pre),    // 4
+-	  "r" (o16),	// 5
+-	  "r" (o32),	// 6
+-	  "r" (o48),    // 7
+-          "r" (o64),    // 8
+-          "r" (o80),    // 9
+-          "r" (o96),    // 10
+-          "r" (o112)    // 11
+-	: "cr0", "%0", "%2" , "%1", "memory"
+-	);
+-
+-} 
+-
+-
++  __asm__
++    (
++       "lxvw4x		32, 0, %2	\n\t"
++       "lxvw4x		33, %5, %2	\n\t"
++       "lxvw4x		34, %6, %2	\n\t"
++       "lxvw4x		35, %7, %2	\n\t"
++       "lxvw4x		36, %8, %2	\n\t"
++       "lxvw4x		37, %9, %2	\n\t"
++       "lxvw4x		38, %10, %2	\n\t"
++       "lxvw4x		39, %11, %2	\n\t"
++
++       "addi		%2, %2, 128	\n\t"
++
++       "lxvw4x		40, 0, %2	\n\t"
++       "lxvw4x		41, %5, %2	\n\t"
++       "lxvw4x		42, %6, %2	\n\t"
++       "lxvw4x		43, %7, %2	\n\t"
++       "lxvw4x		44, %8, %2	\n\t"
++       "lxvw4x		45, %9, %2	\n\t"
++       "lxvw4x		46, %10, %2	\n\t"
++       "lxvw4x		47, %11, %2	\n\t"
++
++       "addi		%2, %2, 128	\n\t"
++
++       "addic.		%1, %1, -32	\n\t"
++       "ble		2f		\n\t"
++
++       ".p2align	5		\n"
++     "1:				\n\t"
++
++       "stxvw4x		32, 0, %3	\n\t"
++       "stxvw4x		33, %5, %3	\n\t"
++       "lxvw4x		32, 0, %2	\n\t"
++       "lxvw4x		33, %5, %2	\n\t"
++       "stxvw4x		34, %6, %3	\n\t"
++       "stxvw4x		35, %7, %3	\n\t"
++       "lxvw4x		34, %6, %2	\n\t"
++       "lxvw4x		35, %7, %2	\n\t"
++       "stxvw4x		36, %8, %3	\n\t"
++       "stxvw4x		37, %9, %3	\n\t"
++       "lxvw4x		36, %8, %2	\n\t"
++       "lxvw4x		37, %9, %2	\n\t"
++       "stxvw4x		38, %10, %3	\n\t"
++       "stxvw4x		39, %11, %3	\n\t"
++       "lxvw4x		38, %10, %2	\n\t"
++       "lxvw4x		39, %11, %2	\n\t"
++
++       "addi		%3, %3, 128	\n\t"
++       "addi		%2, %2, 128	\n\t"
++
++       "stxvw4x		40, 0, %3	\n\t"
++       "stxvw4x		41, %5, %3	\n\t"
++       "lxvw4x		40, 0, %2	\n\t"
++       "lxvw4x		41, %5, %2	\n\t"
++       "stxvw4x		42, %6, %3	\n\t"
++       "stxvw4x		43, %7, %3	\n\t"
++       "lxvw4x		42, %6, %2	\n\t"
++       "lxvw4x		43, %7, %2	\n\t"
++       "stxvw4x		44, %8, %3	\n\t"
++       "stxvw4x		45, %9, %3	\n\t"
++       "lxvw4x		44, %8, %2	\n\t"
++       "lxvw4x		45, %9, %2	\n\t"
++       "stxvw4x		46, %10, %3	\n\t"
++       "stxvw4x		47, %11, %3	\n\t"
++       "lxvw4x		46, %10, %2	\n\t"
++       "lxvw4x		47, %11, %2	\n\t"
++
++       "addi		%3, %3, 128	\n\t"
++       "addi		%2, %2, 128	\n\t"
++
++       "addic.		%1, %1, -32	\n\t"
++       "bgt		1b		\n"
++
++     "2:				\n\t"
++
++       "stxvw4x		32, 0, %3	\n\t"
++       "stxvw4x		33, %5, %3	\n\t"
++       "stxvw4x		34, %6, %3	\n\t"
++       "stxvw4x		35, %7, %3	\n\t"
++       "stxvw4x		36, %8, %3	\n\t"
++       "stxvw4x		37, %9, %3	\n\t"
++       "stxvw4x		38, %10, %3	\n\t"
++       "stxvw4x		39, %11, %3	\n\t"
++
++       "addi		%3, %3, 128	\n\t"
++
++       "stxvw4x		40, 0, %3	\n\t"
++       "stxvw4x		41, %5, %3	\n\t"
++       "stxvw4x		42, %6, %3	\n\t"
++       "stxvw4x		43, %7, %3	\n\t"
++       "stxvw4x		44, %8, %3	\n\t"
++       "stxvw4x		45, %9, %3	\n\t"
++       "stxvw4x		46, %10, %3	\n\t"
++       "stxvw4x		47, %11, %3	\n"
++
++     "#n=%1 x=%4=%2 y=%0=%3 o16=%5 o32=%6 o48=%7 o64=%8 o80=%9 o96=%10 o112=%11"
++     :
++       "=m" (*y),
++       "+r" (n),	// 1
++       "+b" (x),	// 2
++       "+b" (y)		// 3
++     :
++       "m" (*x),
++       "b" (16),	// 5
++       "b" (32),	// 6
++       "b" (48),	// 7
++       "b" (64),	// 8
++       "b" (80),	// 9
++       "b" (96),	// 10
++       "b" (112)	// 11
++     :
++       "cr0",
++       "vs32","vs33","vs34","vs35","vs36","vs37","vs38","vs39",
++       "vs40","vs41","vs42","vs43","vs44","vs45","vs46","vs47"
++     );
++}
+diff --git a/kernel/power/cswap_microk_power8.c b/kernel/power/cswap_microk_power8.c
+index 90ab59c..1dd03dc 100644
+--- a/kernel/power/cswap_microk_power8.c
++++ b/kernel/power/cswap_microk_power8.c
+@@ -35,146 +35,124 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+ #define HAVE_KERNEL_32 1
+ 
+-static void cswap_kernel_32( BLASLONG n, FLOAT *x, FLOAT *y) __attribute__ ((noinline));
+-
+-static void cswap_kernel_32( BLASLONG n, FLOAT *x, FLOAT *y)
++static void cswap_kernel_32 (long n, float *x, float *y)
+ {
+-
+-
+-	BLASLONG i = n;
+-	BLASLONG o16 = 16;
+-	BLASLONG o32 = 32;
+-	BLASLONG o48 = 48;
+-	BLASLONG o64 = 64;
+-	BLASLONG o80 = 80;
+-	BLASLONG o96 = 96;
+-	BLASLONG o112 = 112;
+-	FLOAT *x1=x;
+-	FLOAT *y1=y;
+-	FLOAT *x2=x+1;
+-	FLOAT *y2=y+1;
+-	BLASLONG pre = 384;
+-	BLASLONG alpha=0;
+-
+-	__asm__  __volatile__
+-	(
+-
+-	"addi		%3, %3, -4			    \n\t"	
+-	"addi		%4, %4, -4			    \n\t"	
+-
+-	".align 5				            \n\t"
+-	"1:				                    \n\t"
+-
+-	"lxvw4x		32, 0, %2			    \n\t"
+-	"lxvw4x		33, %5, %2			    \n\t"
+-	"lxvw4x		34, %6, %2			    \n\t"
+-	"lxvw4x		35, %7, %2			    \n\t"
+-	"lxvw4x		36, %8, %2			    \n\t"
+-	"lxvw4x		37, %9, %2			    \n\t"
+-	"lxvw4x		38, %10, %2			    \n\t"
+-	"lxvw4x		39, %11, %2			    \n\t"
+-
+-	"addi		%2, %2, 128			    \n\t"
+-
+-	"lxvw4x		40, 0, %2			    \n\t"
+-	"lxvw4x		41, %5, %2			    \n\t"
+-	"lxvw4x		42, %6, %2			    \n\t"
+-	"lxvw4x		43, %7, %2			    \n\t"
+-	"lxvw4x		44, %8, %2			    \n\t"
+-	"lxvw4x		45, %9, %2			    \n\t"
+-	"lxvw4x		46, %10, %2			    \n\t"
+-	"lxvw4x		47, %11, %2			    \n\t"
+-
+-	"addi		%2, %2, 128			    \n\t"
+-
+-	"lxvw4x		48, 0, %1			    \n\t"
+-	"lxvw4x		49, %5, %1			    \n\t"
+-	"lxvw4x		50, %6, %1			    \n\t"
+-	"lxvw4x		51, %7, %1			    \n\t"
+-	"lxvw4x		52, %8, %1			    \n\t"
+-	"lxvw4x		53, %9, %1			    \n\t"
+-	"lxvw4x		54, %10, %1			    \n\t"
+-	"lxvw4x		55, %11, %1			    \n\t"
+-
+-	"addi		%1, %1, 128			    \n\t"
+-
+-	"lxvw4x		56, 0, %1			    \n\t"
+-	"lxvw4x		57, %5, %1			    \n\t"
+-	"lxvw4x		58, %6, %1			    \n\t"
+-	"lxvw4x		59, %7, %1			    \n\t"
+-	"lxvw4x		60, %8, %1			    \n\t"
+-	"lxvw4x		61, %9, %1			    \n\t"
+-	"lxvw4x		62, %10, %1			    \n\t"
+-	"lxvw4x		63, %11, %1			    \n\t"
+-
+-	"addi		%1, %1, 128			    \n\t"
+-
+-	"stxvw4x		32, 0, %3			    \n\t"
+-	"stxvw4x		33, %5, %3			    \n\t"
+-	"stxvw4x		34, %6, %3			    \n\t"
+-	"stxvw4x		35, %7, %3			    \n\t"
+-	"stxvw4x		36, %8, %3			    \n\t"
+-	"stxvw4x		37, %9, %3			    \n\t"
+-	"stxvw4x		38, %10, %3			    \n\t"
+-	"stxvw4x		39, %11, %3			    \n\t"
+-
+-	"addi		%3, %3, 128			    \n\t"
+-
+-	"stxvw4x		40, 0, %3			    \n\t"
+-	"stxvw4x		41, %5, %3			    \n\t"
+-	"stxvw4x		42, %6, %3			    \n\t"
+-	"stxvw4x		43, %7, %3			    \n\t"
+-	"stxvw4x		44, %8, %3			    \n\t"
+-	"stxvw4x		45, %9, %3			    \n\t"
+-	"stxvw4x		46, %10, %3			    \n\t"
+-	"stxvw4x		47, %11, %3			    \n\t"
+-
+-	"addi		%3, %3, 128			    \n\t"
+-
+-	"stxvw4x		48, 0, %4			    \n\t"
+-	"stxvw4x		49, %5, %4			    \n\t"
+-	"stxvw4x		50, %6, %4			    \n\t"
+-	"stxvw4x		51, %7, %4			    \n\t"
+-	"stxvw4x		52, %8, %4			    \n\t"
+-	"stxvw4x		53, %9, %4			    \n\t"
+-	"stxvw4x		54, %10, %4			    \n\t"
+-	"stxvw4x		55, %11, %4			    \n\t"
+-
+-	"addi		%4, %4, 128			    \n\t"
+-
+-	"stxvw4x		56, 0, %4			    \n\t"
+-	"stxvw4x		57, %5, %4			    \n\t"
+-	"stxvw4x		58, %6, %4			    \n\t"
+-	"stxvw4x		59, %7, %4			    \n\t"
+-	"stxvw4x		60, %8, %4			    \n\t"
+-	"stxvw4x		61, %9, %4			    \n\t"
+-	"stxvw4x		62, %10, %4			    \n\t"
+-	"stxvw4x		63, %11, %4			    \n\t"
+-
+-	"addi		%4, %4, 128			    \n\t"
+-
+-	"addic.		%0 , %0	, -32  	 	             \n\t"
+-	"bgt		1b		             	     \n\t"
+-
+-	"2:						     \n\t"
+-
+-	:
+-        : 
+-          "r" (i),	// 0	
+-	  "r" (y1),  	// 1
+-          "r" (x1),     // 2
+-          "r" (y2),     // 3
+-          "r" (x2),     // 4
+-	  "r" (o16),	// 5
+-	  "r" (o32),	// 6
+-	  "r" (o48),    // 7
+-          "r" (o64),    // 8
+-          "r" (o80),    // 9
+-          "r" (o96),    // 10
+-          "r" (o112)    // 11
+-	: "cr0", "%0", "%2" , "%1", "%3", "%4", "memory"
+-	);
+-
+-} 
+-
+-
++  __asm__
++    (
++       ".p2align	5		\n"
++     "1:				\n\t"
++
++       "lxvw4x		32, 0, %4	\n\t"
++       "lxvw4x		33, %5, %4	\n\t"
++       "lxvw4x		34, %6, %4	\n\t"
++       "lxvw4x		35, %7, %4	\n\t"
++       "lxvw4x		36, %8, %4	\n\t"
++       "lxvw4x		37, %9, %4	\n\t"
++       "lxvw4x		38, %10, %4	\n\t"
++       "lxvw4x		39, %11, %4	\n\t"
++
++       "addi		%4, %4, 128	\n\t"
++
++       "lxvw4x		40, 0, %4	\n\t"
++       "lxvw4x		41, %5, %4	\n\t"
++       "lxvw4x		42, %6, %4	\n\t"
++       "lxvw4x		43, %7, %4	\n\t"
++       "lxvw4x		44, %8, %4	\n\t"
++       "lxvw4x		45, %9, %4	\n\t"
++       "lxvw4x		46, %10, %4	\n\t"
++       "lxvw4x		47, %11, %4	\n\t"
++
++       "addi		%4, %4, -128	\n\t"
++
++       "lxvw4x		48, 0, %3	\n\t"
++       "lxvw4x		49, %5, %3	\n\t"
++       "lxvw4x		50, %6, %3	\n\t"
++       "lxvw4x		51, %7, %3	\n\t"
++       "lxvw4x		0, %8, %3	\n\t"
++       "lxvw4x		1, %9, %3	\n\t"
++       "lxvw4x		2, %10, %3	\n\t"
++       "lxvw4x		3, %11, %3	\n\t"
++
++       "addi		%3, %3, 128	\n\t"
++
++       "lxvw4x		4, 0, %3	\n\t"
++       "lxvw4x		5, %5, %3	\n\t"
++       "lxvw4x		6, %6, %3	\n\t"
++       "lxvw4x		7, %7, %3	\n\t"
++       "lxvw4x		8, %8, %3	\n\t"
++       "lxvw4x		9, %9, %3	\n\t"
++       "lxvw4x		10, %10, %3	\n\t"
++       "lxvw4x		11, %11, %3	\n\t"
++
++       "addi		%3, %3, -128	\n\t"
++
++       "stxvw4x		32, 0, %3	\n\t"
++       "stxvw4x		33, %5, %3	\n\t"
++       "stxvw4x		34, %6, %3	\n\t"
++       "stxvw4x		35, %7, %3	\n\t"
++       "stxvw4x		36, %8, %3	\n\t"
++       "stxvw4x		37, %9, %3	\n\t"
++       "stxvw4x		38, %10, %3	\n\t"
++       "stxvw4x		39, %11, %3	\n\t"
++
++       "addi		%3, %3, 128	\n\t"
++
++       "stxvw4x		40, 0, %3	\n\t"
++       "stxvw4x		41, %5, %3	\n\t"
++       "stxvw4x		42, %6, %3	\n\t"
++       "stxvw4x		43, %7, %3	\n\t"
++       "stxvw4x		44, %8, %3	\n\t"
++       "stxvw4x		45, %9, %3	\n\t"
++       "stxvw4x		46, %10, %3	\n\t"
++       "stxvw4x		47, %11, %3	\n\t"
++
++       "addi		%3, %3, 128	\n\t"
++
++       "stxvw4x		48, 0, %4	\n\t"
++       "stxvw4x		49, %5, %4	\n\t"
++       "stxvw4x		50, %6, %4	\n\t"
++       "stxvw4x		51, %7, %4	\n\t"
++       "stxvw4x		0, %8, %4	\n\t"
++       "stxvw4x		1, %9, %4	\n\t"
++       "stxvw4x		2, %10, %4	\n\t"
++       "stxvw4x		3, %11, %4	\n\t"
++
++       "addi		%4, %4, 128	\n\t"
++
++       "stxvw4x		4, 0, %4	\n\t"
++       "stxvw4x		5, %5, %4	\n\t"
++       "stxvw4x		6, %6, %4	\n\t"
++       "stxvw4x		7, %7, %4	\n\t"
++       "stxvw4x		8, %8, %4	\n\t"
++       "stxvw4x		9, %9, %4	\n\t"
++       "stxvw4x		10, %10, %4	\n\t"
++       "stxvw4x		11, %11, %4	\n\t"
++
++       "addi		%4, %4, 128	\n\t"
++
++       "addic.		%2, %2, -32	\n\t"
++       "bgt		1b		\n"
++
++     "#n=%2 x=%0=%3 y=%1=%4 o16=%5 o32=%6 o48=%7 o64=%8 o80=%9 o96=%10 o112=%11"
++     :
++       "+m" (*x),
++       "+m" (*y),
++       "+r" (n),	// 2
++       "+b" (x),	// 3
++       "+b" (y)		// 4
++     :
++       "b" (16),	// 5
++       "b" (32),	// 6
++       "b" (48),	// 7
++       "b" (64),	// 8
++       "b" (80),	// 9
++       "b" (96),	// 10
++       "b" (112)	// 11
++     :
++       "cr0",
++       "vs32","vs33","vs34","vs35","vs36","vs37","vs38","vs39",
++       "vs40","vs41","vs42","vs43","vs44","vs45","vs46","vs47",
++       "vs48","vs49","vs50","vs51","vs0","vs1","vs2","vs3",
++       "vs4","vs5","vs6","vs7","vs8","vs9","vs10","vs11"
++     );
++}
+diff --git a/kernel/power/dasum.c b/kernel/power/dasum.c
+index 77f5345..73962c2 100644
+--- a/kernel/power/dasum.c
++++ b/kernel/power/dasum.c
+@@ -42,7 +42,7 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+ #else
+ 
+-#define ABS fabsf
++#error supports double only
+ 
+ #endif
+ 
+@@ -53,7 +53,7 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+ #ifndef HAVE_KERNEL_16
+ 
+-static void dasum_kernel_16(BLASLONG n, FLOAT *x1, FLOAT *svec)
++static FLOAT dasum_kernel_16(BLASLONG n, FLOAT *x1)
+ {
+ 
+ 	BLASLONG i=0;
+@@ -92,9 +92,7 @@ static void dasum_kernel_16(BLASLONG n, FLOAT *x1, FLOAT *svec)
+ 
+ 	}
+ 
+-	svec[0] = sum0+sum1+sum2+sum3;
+-	svec[1] = 0.0;
+-
++	return sum0+sum1+sum2+sum3;
+ }
+ 
+ #endif
+@@ -103,7 +101,6 @@ FLOAT CNAME(BLASLONG n, FLOAT *x, BLASLONG inc_x)
+ {
+ 	BLASLONG i=0;
+ 	FLOAT sumf = 0.0;
+-	FLOAT svec[2] __attribute__ ((aligned (16)));;
+ 	BLASLONG n1;
+ 
+ 	if (n <= 0 || inc_x <= 0) return(sumf);
+@@ -115,8 +112,7 @@ FLOAT CNAME(BLASLONG n, FLOAT *x, BLASLONG inc_x)
+ 		if ( n1 > 0 )
+ 		{
+ 
+-			dasum_kernel_16(n1, x, svec);
+-			sumf = svec[0] + svec[1];
++			sumf = dasum_kernel_16(n1, x);
+ 			i=n1;
+ 		}
+ 
+diff --git a/kernel/power/dasum_microk_power8.c b/kernel/power/dasum_microk_power8.c
+index cc38c4f..880d7d2 100644
+--- a/kernel/power/dasum_microk_power8.c
++++ b/kernel/power/dasum_microk_power8.c
+@@ -34,144 +34,142 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ **************************************************************************************/
+ 
+ #define HAVE_KERNEL_16 1
+-static void dasum_kernel_16( BLASLONG n, FLOAT *x, FLOAT *svec) __attribute__ ((noinline));
+ 
+-static void dasum_kernel_16( BLASLONG n, FLOAT *x, FLOAT *svec)
++static double dasum_kernel_16 (long n, double *x)
+ {
+-
+-
+-	BLASLONG i = n;
+-	BLASLONG o16 = 16;
+-	BLASLONG o32 = 32;
+-	BLASLONG o48 = 48;
+-	BLASLONG o64 = 64;
+-	BLASLONG o80 = 80;
+-	BLASLONG o96 = 96;
+-	BLASLONG o112 = 112;
+-	FLOAT *x1=x;
+-	BLASLONG pre = 384;
+-
+-	__asm__  __volatile__
+-	(
+-
+-	"dcbt		%2 , %4				    \n\t"
+-
+-	"xxlxor		32,32,32			    \n\t"
+-	"xxlxor		33,33,33			    \n\t"
+-	"xxlxor		34,34,34			    \n\t"
+-	"xxlxor		35,35,35			    \n\t"
+-	"xxlxor		36,36,36			    \n\t"
+-	"xxlxor		37,37,37			    \n\t"
+-	"xxlxor		38,38,38			    \n\t"
+-	"xxlxor		39,39,39			    \n\t"
+-
+-	"lxvd2x		40, 0, %2			    \n\t"
+-	"lxvd2x		41, %5, %2			    \n\t"
+-	"lxvd2x		42, %6, %2			    \n\t"
+-	"lxvd2x		43, %7, %2			    \n\t"
+-	"lxvd2x		44, %8, %2			    \n\t"
+-	"lxvd2x		45, %9, %2			    \n\t"
+-	"lxvd2x		46, %10, %2			    \n\t"
+-	"lxvd2x		47, %11, %2			    \n\t"
+-
+-	"addi		%2, %2, 128			    \n\t"
+-
+-	"addic.		%0 , %0	, -16  	 	             \n\t"
+-	"ble		2f		             	     \n\t"
+-
+-	".align 5				            \n\t"
+-	"1:				                    \n\t"
+-
+-	"dcbt		%2 , %4				    \n\t"
+-
+-	"xvabsdp	48, 40				    \n\t"
+-	"xvabsdp	49, 41				    \n\t"
+-	"xvabsdp	50, 42				    \n\t"
+-	"xvabsdp	51, 43				    \n\t"
+-
+-	"lxvd2x		40, 0, %2			    \n\t"
+-	"lxvd2x		41, %5, %2			    \n\t"
+-
+-	"xvabsdp	52, 44				    \n\t"
+-	"xvabsdp	53, 45				    \n\t"
+-
+-	"lxvd2x		42, %6, %2			    \n\t"
+-	"lxvd2x		43, %7, %2			    \n\t"
+-
+-	"xvabsdp	54, 46				    \n\t"
+-	"xvabsdp	55, 47				    \n\t"
+-
+-	"lxvd2x		44, %8, %2			    \n\t"
+-	"lxvd2x		45, %9, %2			    \n\t"
+-
+-	"xvadddp	32, 32, 48		    \n\t"
+-	"xvadddp	33, 33, 49		    \n\t"
+-
+-	"lxvd2x		46, %10, %2			    \n\t"
+-	"lxvd2x		47, %11, %2			    \n\t"
+-
+-	"xvadddp	34, 34, 50		    \n\t"
+-	"xvadddp	35, 35, 51		    \n\t"
+-	"addi		%2, %2, 128			    \n\t"
+-	"xvadddp	36, 36, 52		    \n\t"
+-	"xvadddp	37, 37, 53		    \n\t"
+-	"addic.		%0 , %0	, -16  	 	             \n\t"
+-	"xvadddp	38, 38, 54		    \n\t"
+-	"xvadddp	39, 39, 55		    \n\t"
+-
+-	"bgt		1b		             	     \n\t"
+-
+-	"2:						     \n\t"
+-
+-
+-	"xvabsdp	48, 40				    \n\t"
+-	"xvabsdp	49, 41				    \n\t"
+-	"xvabsdp	50, 42				    \n\t"
+-	"xvabsdp	51, 43				    \n\t"
+-	"xvabsdp	52, 44				    \n\t"
+-	"xvabsdp	53, 45				    \n\t"
+-	"xvabsdp	54, 46				    \n\t"
+-	"xvabsdp	55, 47				    \n\t"
+-
+-	"xvadddp	32, 32, 48		    \n\t"
+-	"xvadddp	33, 33, 49		    \n\t"
+-	"xvadddp	34, 34, 50		    \n\t"
+-	"xvadddp	35, 35, 51		    \n\t"
+-	"xvadddp	36, 36, 52		    \n\t"
+-	"xvadddp	37, 37, 53		    \n\t"
+-	"xvadddp	38, 38, 54		    \n\t"
+-	"xvadddp	39, 39, 55		    \n\t"
+-
+-	"xvadddp	32, 32, 33		     \n\t"
+-	"xvadddp	34, 34, 35		     \n\t"
+-	"xvadddp	36, 36, 37		     \n\t"
+-	"xvadddp	38, 38, 39		     \n\t"
+-
+-	"xvadddp	32, 32, 34		     \n\t"
+-	"xvadddp	36, 36, 38		     \n\t"
+-
+-	"xvadddp	32, 32, 36		     \n\t"
+-
+-
+-	"stxvd2x	32, 0, %3		     \n\t"
+-
+-	:
+-        : 
+-          "r" (i),	// 0	
+-	  "r" (n),  	// 1
+-          "r" (x1),     // 2
+-          "r" (svec),   // 3
+-          "r" (pre),    // 4
+-	  "r" (o16),	// 5
+-	  "r" (o32),	// 6
+-	  "r" (o48),    // 7
+-          "r" (o64),    // 8
+-          "r" (o80),    // 9
+-          "r" (o96),    // 10
+-          "r" (o112)   // 11
+-	: "cr0", "%0", "%2",  "memory"
+-	);
+-
+-} 
++  double sum;
++  __vector double t0;
++  __vector double t1;
++  __vector double t2;
++  __vector double t3;
++
++  __asm__
++    (
++       "dcbt		0, %2		\n\t"
++
++       "xxlxor		32, 32,	32	\n\t"
++       "xxlxor		33, 33,	33	\n\t"
++       "xxlxor		34, 34,	34	\n\t"
++       "xxlxor		35, 35,	35	\n\t"
++       "xxlxor		36, 36,	36	\n\t"
++       "xxlxor		37, 37,	37	\n\t"
++       "xxlxor		38, 38,	38	\n\t"
++       "xxlxor		39, 39,	39	\n\t"
++
++       "lxvd2x		40, 0, %2	\n\t"
++       "lxvd2x		41, %8, %2	\n\t"
++       "lxvd2x		42, %9, %2	\n\t"
++       "lxvd2x		43, %10, %2	\n\t"
++       "lxvd2x		44, %11, %2	\n\t"
++       "lxvd2x		45, %12, %2	\n\t"
++       "lxvd2x		46, %13, %2	\n\t"
++       "lxvd2x		47, %14, %2	\n\t"
++
++       "addi		%2, %2, 128	\n\t"
++
++       "addic.		%1, %1, -16	\n\t"
++       "ble		2f		\n\t"
++
++       ".p2align	5		\n"
++     "1:				\n\t"
++
++       "xvabsdp		48, 40		\n\t"
++       "xvabsdp		49, 41		\n\t"
++       "xvabsdp		50, 42		\n\t"
++       "xvabsdp		51, 43		\n\t"
++
++       "lxvd2x		40, 0, %2	\n\t"
++       "lxvd2x		41, %8, %2	\n\t"
++
++       "xvabsdp		%x3, 44		\n\t"
++       "xvabsdp		%x4, 45		\n\t"
++
++       "lxvd2x		42, %9, %2	\n\t"
++       "lxvd2x		43, %10, %2	\n\t"
++
++       "xvabsdp		%x5, 46		\n\t"
++       "xvabsdp		%x6, 47		\n\t"
++
++       "lxvd2x		44, %11, %2	\n\t"
++       "lxvd2x		45, %12, %2	\n\t"
++
++       "xvadddp		32, 32, 48	\n\t"
++       "xvadddp		33, 33, 49	\n\t"
++
++       "lxvd2x		46, %13, %2	\n\t"
++       "lxvd2x		47, %14, %2	\n\t"
++
++       "xvadddp		34, 34, 50	\n\t"
++       "xvadddp		35, 35, 51	\n\t"
++       "addi		%2, %2, 128	\n\t"
++       "xvadddp		36, 36, %x3	\n\t"
++       "xvadddp		37, 37, %x4	\n\t"
++       "addic.		%1, %1, -16	\n\t"
++       "xvadddp		38, 38, %x5	\n\t"
++       "xvadddp		39, 39, %x6	\n\t"
++
++       "bgt		1b		\n"
++
++     "2:				\n\t"
++
++       "xvabsdp		48, 40		\n\t"
++       "xvabsdp		49, 41		\n\t"
++       "xvabsdp		50, 42		\n\t"
++       "xvabsdp		51, 43		\n\t"
++       "xvabsdp		%x3, 44		\n\t"
++       "xvabsdp		%x4, 45		\n\t"
++       "xvabsdp		%x5, 46		\n\t"
++       "xvabsdp		%x6, 47		\n\t"
++
++       "xvadddp		32, 32, 48	\n\t"
++       "xvadddp		33, 33, 49	\n\t"
++       "xvadddp		34, 34, 50	\n\t"
++       "xvadddp		35, 35, 51	\n\t"
++       "xvadddp		36, 36, %x3	\n\t"
++       "xvadddp		37, 37, %x4	\n\t"
++       "xvadddp		38, 38, %x5	\n\t"
++       "xvadddp		39, 39, %x6	\n\t"
++
++       "xvadddp		32, 32, 33	\n\t"
++       "xvadddp		34, 34, 35	\n\t"
++       "xvadddp		36, 36, 37	\n\t"
++       "xvadddp		38, 38, 39	\n\t"
++
++       "xvadddp		32, 32, 34	\n\t"
++       "xvadddp		36, 36, 38	\n\t"
++
++       "xvadddp		32, 32, 36	\n\t"
++
++       "xxswapd		33, 32		\n\t"
++       "xsadddp		%x0, 32, 33	\n"
++
++     "#n=%1 x=%3=%2 sum=%0 o16=%8 o32=%9 o48=%10 o64=%11 o80=%12 o96=%13 o112=%14\n"
++     "#t0=%x3 t1=%x4 t2=%x5 t3=%x6"
++     :
++       "=d" (sum),	// 0
++       "+r" (n),	// 1
++       "+b" (x),	// 2
++       "=wa" (t0),	// 3
++       "=wa" (t1),	// 4
++       "=wa" (t2),	// 5
++       "=wa" (t3)	// 6
++     :
++       "m" (*x),
++       "b" (16),	// 8
++       "b" (32),	// 9
++       "b" (48),	// 10
++       "b" (64),	// 11
++       "b" (80),	// 12
++       "b" (96),	// 13
++       "b" (112)	// 14
++     :
++       "cr0",
++       "vs32","vs33","vs34","vs35","vs36","vs37","vs38","vs39",
++       "vs40","vs41","vs42","vs43","vs44","vs45","vs46","vs47",
++       "vs48","vs49","vs50","vs51"
++     );
++
++  return sum;
++}
+ 
+ 
+diff --git a/kernel/power/daxpy.c b/kernel/power/daxpy.c
+index 4365bd8..df0572e 100644
+--- a/kernel/power/daxpy.c
++++ b/kernel/power/daxpy.c
+@@ -43,21 +43,20 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+ #ifndef HAVE_KERNEL_8
+ 
+-static void daxpy_kernel_8(BLASLONG n, FLOAT *x, FLOAT *y, FLOAT *alpha)
++static void daxpy_kernel_8(BLASLONG n, FLOAT *x, FLOAT *y, FLOAT alpha)
+ {
+ 	BLASLONG register i = 0;
+-	FLOAT a = *alpha;
+ 
+ 	while(i < n)
+         {
+-              y[i]   += a * x[i];
+-              y[i+1] += a * x[i+1];
+-              y[i+2] += a * x[i+2];
+-              y[i+3] += a * x[i+3];
+-              y[i+4] += a * x[i+4];
+-              y[i+5] += a * x[i+5];
+-              y[i+6] += a * x[i+6];
+-              y[i+7] += a * x[i+7];
++              y[i]   += alpha * x[i];
++              y[i+1] += alpha * x[i+1];
++              y[i+2] += alpha * x[i+2];
++              y[i+3] += alpha * x[i+3];
++              y[i+4] += alpha * x[i+4];
++              y[i+5] += alpha * x[i+5];
++              y[i+6] += alpha * x[i+6];
++              y[i+7] += alpha * x[i+7];
+               i+=8 ;
+ 
+        }
+@@ -70,11 +69,6 @@ int CNAME(BLASLONG n, BLASLONG dummy0, BLASLONG dummy1, FLOAT da, FLOAT *x, BLAS
+ {
+ 	BLASLONG i=0;
+ 	BLASLONG ix=0,iy=0;
+-	FLOAT a2[4];
+-	a2[0]=da;
+-	a2[1]=da;
+-	a2[2]=da;
+-	a2[3]=da;
+ 
+ 	if ( n <= 0 )  return(0);
+ 
+@@ -84,7 +78,7 @@ int CNAME(BLASLONG n, BLASLONG dummy0, BLASLONG dummy1, FLOAT da, FLOAT *x, BLAS
+ 		BLASLONG n1 = n & -16;
+ 
+ 		if ( n1 )
+-			daxpy_kernel_8(n1, x, y , a2 );
++			daxpy_kernel_8(n1, x, y, da);
+ 
+ 		i = n1;
+ 		while(i < n)
+diff --git a/kernel/power/daxpy_microk_power8.c b/kernel/power/daxpy_microk_power8.c
+index bb3f73a..fb714a3 100644
+--- a/kernel/power/daxpy_microk_power8.c
++++ b/kernel/power/daxpy_microk_power8.c
+@@ -35,167 +35,183 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+ 
+ #define HAVE_KERNEL_8 1
+-static void daxpy_kernel_8( BLASLONG n, FLOAT *x, FLOAT *y , FLOAT *alpha) __attribute__ ((noinline));
+ 
+-static void daxpy_kernel_8( BLASLONG n, FLOAT *x, FLOAT *y, FLOAT *alpha)
++static void daxpy_kernel_8 (long n, double *x, double *y, double alpha)
+ {
++  __vector double t0;
++  __vector double t1;
++  __vector double t2;
++  __vector double t3;
++  __vector double t4;
++  __vector double t5;
++  __vector double t6;
++  __vector double t7;
++  __vector double t8;
++  __vector double t9;
++  __vector double t10;
++  __vector double t11;
++  __vector double t12;
++  __vector double t13;
++  __vector double t14;
++  __vector double t15;
++  __vector double t16;
+ 
++  __asm__
++    (
++       "xxspltd		%x4, %x22, 0	\n\t"
+ 
+-	BLASLONG i = n;
+-	BLASLONG o16 = 16;
+-	BLASLONG o32 = 32;
+-	BLASLONG o48 = 48;
+-	FLOAT *x1=x;
+-	FLOAT *y1=y;
+-	FLOAT *y2=y+1;
+-	BLASLONG pre = 384;
++       "dcbt		0, %2		\n\t"
++       "dcbt		0, %3		\n\t"
+ 
+-	__asm__  __volatile__
+-	(
++       "lxvd2x		%x5, 0, %2	\n\t"
++       "lxvd2x		%x6, %23, %2	\n\t"
++       "lxvd2x		%x7, %24, %2	\n\t"
++       "lxvd2x		%x8, %25, %2	\n\t"
+ 
+-	"lxsdx		33, %5, %4			    \n\t"
+-	"xxspltd	32, 33, 0			    \n\t"
+-	"addi		%8, %8, -8			    \n\t"
++       "lxvd2x		%x13, 0, %3	\n\t"
++       "lxvd2x		%x14, %23, %3	\n\t"
++       "lxvd2x		%x15, %24, %3	\n\t"
++       "lxvd2x		%x16, %25, %3	\n\t"
+ 
+-	"dcbt		%2, %9				    \n\t"
+-	"dcbt		%3, %9				    \n\t"
++       "addi		%2, %2, 64	\n\t"
++       "addi		%3, %3, 64	\n\t"
+ 
+-	"lxvd2x		40, 0, %2			    \n\t"
+-	"lxvd2x		41, %5, %2			    \n\t"
+-	"lxvd2x		42, %6, %2			    \n\t"
+-	"lxvd2x		43, %7, %2			    \n\t"
++       "lxvd2x		%x9, 0, %2	\n\t"
++       "lxvd2x		%x10, %23, %2	\n\t"
++       "lxvd2x		%x11, %24, %2	\n\t"
++       "lxvd2x		%x12, %25, %2	\n\t"
+ 
+-	"lxvd2x		48, 0, %3			    \n\t"
+-	"lxvd2x		49, %5, %3			    \n\t"
+-	"lxvd2x		50, %6, %3			    \n\t"
+-	"lxvd2x		51, %7, %3			    \n\t"
+-
+-	"addi		%2, %2, 64			    \n\t"
+-	"addi		%3, %3, 64			    \n\t"
+-
+-	"lxvd2x		44, 0, %2			    \n\t"
+-	"lxvd2x		45, %5, %2			    \n\t"
+-	"lxvd2x		46, %6, %2			    \n\t"
+-	"lxvd2x		47, %7, %2			    \n\t"
+-
+-	"lxvd2x		52, 0, %3			    \n\t"
+-	"lxvd2x		53, %5, %3			    \n\t"
+-	"lxvd2x		54, %6, %3			    \n\t"
+-	"lxvd2x		55, %7, %3			    \n\t"
+-
+-	"addi		%2, %2, 64			    \n\t"
+-	"addi		%3, %3, 64			    \n\t"
+-
+-	"addic.		%0 , %0	, -16  	 	             \n\t"
+-	"ble		2f		             	     \n\t"
+-
+-	".align 5				            \n\t"
+-	"1:				                    \n\t"
+-
+-	"dcbt		%2, %9				    \n\t"
+-	"dcbt		%3, %9				    \n\t"
+-
+-	"xvmaddadp	48, 40, 32		    	    \n\t"
+-	"xvmaddadp	49, 41, 32		    	    \n\t"
+-
+-	"lxvd2x		40, 0, %2			    \n\t"
+-	"lxvd2x		41, %5, %2			    \n\t"
+-
+-	"stxvd2x	48,  0, %8			    \n\t"
+-	"stxvd2x	49, %5, %8			    \n\t"
+-
+-	"xvmaddadp	50, 42, 32		    	    \n\t"
+-	"xvmaddadp	51, 43, 32		    	    \n\t"
+-
+-	"lxvd2x		42, %6, %2			    \n\t"
+-	"lxvd2x		43, %7, %2			    \n\t"
+-
+-	"stxvd2x	50, %6, %8			    \n\t"
+-	"stxvd2x	51, %7, %8			    \n\t"
+-
+-	"lxvd2x		48, 0, %3			    \n\t"
+-	"lxvd2x		49, %5, %3			    \n\t"
+-	"lxvd2x		50, %6, %3			    \n\t"
+-	"lxvd2x		51, %7, %3			    \n\t"
+-
+-	"addi		%2, %2, 64			    \n\t"
+-	"addi		%8, %8, 64			    \n\t"
+-
+-	"xvmaddadp	52, 44, 32		    	    \n\t"
+-	"addi		%3, %3, 64			    \n\t"
+-	"xvmaddadp	53, 45, 32		    	    \n\t"
+-
+-	"lxvd2x		44, 0, %2			    \n\t"
+-	"lxvd2x		45, %5, %2			    \n\t"
+-
+-	"stxvd2x	52,  0, %8			    \n\t"
+-	"stxvd2x	53, %5, %8			    \n\t"
+-
+-	"xvmaddadp	54, 46, 32		    	    \n\t"
+-	"xvmaddadp	55, 47, 32		    	    \n\t"
+-
+-	"lxvd2x		46, %6, %2			    \n\t"
+-	"lxvd2x		47, %7, %2			    \n\t"
+-
+-	"stxvd2x	54, %6, %8			    \n\t"
+-	"stxvd2x	55, %7, %8			    \n\t"
+-
+-	"addi		%2, %2, 64			    \n\t"
+-	"addi		%8, %8, 64			    \n\t"
+-
+-	"lxvd2x		52, 0, %3			    \n\t"
+-	"lxvd2x		53, %5, %3			    \n\t"
+-	"lxvd2x		54, %6, %3			    \n\t"
+-	"lxvd2x		55, %7, %3			    \n\t"
+-
+-	"addi		%3, %3, 64			    \n\t"
+-
+-
+-	"addic.		%0 , %0	, -16  	 	             \n\t"
+-	"bgt		1b		             	     \n\t"
+-
+-	"2:						     \n\t"
+-
+-	
+-	"xvmaddadp	48, 40, 32		    	    \n\t"
+-	"xvmaddadp	49, 41, 32		    	    \n\t"
+-	"xvmaddadp	50, 42, 32		    	    \n\t"
+-	"xvmaddadp	51, 43, 32		    	    \n\t"
+-
+-	"xvmaddadp	52, 44, 32		    	    \n\t"
+-	"xvmaddadp	53, 45, 32		    	    \n\t"
+-	"xvmaddadp	54, 46, 32		    	    \n\t"
+-	"xvmaddadp	55, 47, 32		    	    \n\t"
+-
+-	"stxvd2x	48,  0, %8			    \n\t"
+-	"stxvd2x	49, %5, %8			    \n\t"
+-	"stxvd2x	50, %6, %8			    \n\t"
+-	"stxvd2x	51, %7, %8			    \n\t"
+-
+-	"addi		%8, %8, 64			    \n\t"
+-
+-	"stxvd2x	52,  0, %8			    \n\t"
+-	"stxvd2x	53, %5, %8			    \n\t"
+-	"stxvd2x	54, %6, %8			    \n\t"
+-	"stxvd2x	55, %7, %8			    \n\t"
+-
+-	"addi		%8, %8, 64			    \n\t"
+-
+-	:
+-        : 
+-          "r" (i),	// 0	
+-	  "r" (n),  	// 1
+-          "r" (x1),     // 2
+-          "r" (y1),     // 3
+-          "r" (alpha),    // 4
+-	  "r" (o16),	// 5
+-	  "r" (o32),	// 6
+-	  "r" (o48),    // 7
+-	  "r" (y2),     // 8
+-	  "r" (pre)	// 9
+-	: "cr0", "%0", "%2" , "%3", "%8", "memory"
+-	);
+-
+-} 
++       "lxvd2x		%x17, 0, %3	\n\t"
++       "lxvd2x		%x18, %23, %3	\n\t"
++       "lxvd2x		%x19, %24, %3	\n\t"
++       "lxvd2x		%x20, %25, %3	\n\t"
++
++       "addi		%2, %2, 64	\n\t"
++       "addi		%3, %3, -64	\n\t"
++
++       "addic.		%1, %1, -16	\n\t"
++       "ble		2f		\n\t"
++
++       ".align 5			\n"
++     "1:				\n\t"
++
++       "xvmaddadp	%x13, %x5, %x4	\n\t"
++       "xvmaddadp	%x14, %x6, %x4	\n\t"
++
++       "lxvd2x		%x5, 0, %2	\n\t"
++       "lxvd2x		%x6, %23, %2	\n\t"
++
++       "stxvd2x		%x13, 0, %3	\n\t"
++       "stxvd2x		%x14, %23, %3	\n\t"
++
++       "xvmaddadp	%x15, %x7, %x4	\n\t"
++       "xvmaddadp	%x16, %x8, %x4	\n\t"
++
++       "lxvd2x		%x7, %24, %2	\n\t"
++       "lxvd2x		%x8, %25, %2	\n\t"
++
++       "stxvd2x		%x15, %24, %3	\n\t"
++       "stxvd2x		%x16, %25, %3	\n\t"
++
++       "addi		%2, %2, 64	\n\t"
++       "addi		%3, %3, 128	\n\t"
++
++       "lxvd2x		%x13, 0, %3	\n\t"
++       "lxvd2x		%x14, %23, %3	\n\t"
++       "lxvd2x		%x15, %24, %3	\n\t"
++       "lxvd2x		%x16, %25, %3	\n\t"
++
++       "addi		%3, %3, -64	\n\t"
++
++       "xvmaddadp	%x17, %x9, %x4	\n\t"
++       "xvmaddadp	%x18, %x10, %x4	\n\t"
++
++       "lxvd2x		%x9, 0, %2	\n\t"
++       "lxvd2x		%x10, %23, %2	\n\t"
++
++       "stxvd2x		%x17, 0, %3	\n\t"
++       "stxvd2x		%x18, %23, %3	\n\t"
++
++       "xvmaddadp	%x19, %x11, %x4	\n\t"
++       "xvmaddadp	%x20, %x12, %x4	\n\t"
++
++       "lxvd2x		%x11, %24, %2	\n\t"
++       "lxvd2x		%x12, %25, %2	\n\t"
++
++       "stxvd2x		%x19, %24, %3	\n\t"
++       "stxvd2x		%x20, %25, %3	\n\t"
++
++       "addi		%2, %2, 64	\n\t"
++       "addi		%3, %3, 128	\n\t"
++
++       "lxvd2x		%x17, 0, %3	\n\t"
++       "lxvd2x		%x18, %23, %3	\n\t"
++       "lxvd2x		%x19, %24, %3	\n\t"
++       "lxvd2x		%x20, %25, %3	\n\t"
++
++       "addi		%3, %3, -64	\n\t"
++
++       "addic.		%1, %1, -16	\n\t"
++       "bgt		1b		\n"
++
++     "2:				\n\t"
++
++       "xvmaddadp	%x13, %x5, %x4	\n\t"
++       "xvmaddadp	%x14, %x6, %x4	\n\t"
++       "xvmaddadp	%x15, %x7, %x4	\n\t"
++       "xvmaddadp	%x16, %x8, %x4	\n\t"
++
++       "xvmaddadp	%x17, %x9, %x4	\n\t"
++       "xvmaddadp	%x18, %x10, %x4	\n\t"
++       "xvmaddadp	%x19, %x11, %x4	\n\t"
++       "xvmaddadp	%x20, %x12, %x4	\n\t"
++
++       "stxvd2x		%x13, 0, %3	\n\t"
++       "stxvd2x		%x14, %23, %3	\n\t"
++       "stxvd2x		%x15, %24, %3	\n\t"
++       "stxvd2x		%x16, %25, %3	\n\t"
++
++       "addi		%3, %3, 64	\n\t"
++
++       "stxvd2x		%x17, 0, %3	\n\t"
++       "stxvd2x		%x18, %23, %3	\n\t"
++       "stxvd2x		%x19, %24, %3	\n\t"
++       "stxvd2x		%x20, %25, %3	\n"
++
++     "#n=%1 x=%21=%2 y=%0=%3 alpha=%22 o16=%23 o32=%24 o48=%25\n"
++     "#t0=%x4 t1=%x5 t2=%x6 t3=%x7 t4=%x8 t5=%x9 t6=%x10 t7=%x11 t8=%x12 t9=%x13 t10=%x14 t11=%x15 t12=%x16 t13=%x17 t14=%x18 t15=%x19 t16=%x20"
++     :
++       "+m" (*y),
++       "+r" (n),	// 1
++       "+b" (x),	// 2
++       "+b" (y),	// 3
++       "=wa" (t0),	// 4
++       "=wa" (t1),	// 5
++       "=wa" (t2),	// 6
++       "=wa" (t3),	// 7
++       "=wa" (t4),	// 8
++       "=wa" (t5),	// 9
++       "=wa" (t6),	// 10
++       "=wa" (t7),	// 11
++       "=wa" (t8),	// 12
++       "=wa" (t9),	// 13
++       "=wa" (t10),	// 14
++       "=wa" (t11),	// 15
++       "=wa" (t12),	// 16
++       "=wa" (t13),	// 17
++       "=wa" (t14),	// 18
++       "=wa" (t15),	// 19
++       "=wa" (t16)	// 20
++     :
++       "m" (*x),
++       "d" (alpha),	// 22
++       "b" (16),	// 23
++       "b" (32),	// 24
++       "b" (48)		// 25
++     :
++       "cr0"
++     );
++
++}
+ 
+ 
+diff --git a/kernel/power/dcopy_microk_power8.c b/kernel/power/dcopy_microk_power8.c
+index 04f7db5..261dc04 100644
+--- a/kernel/power/dcopy_microk_power8.c
++++ b/kernel/power/dcopy_microk_power8.c
+@@ -35,140 +35,121 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+ #define HAVE_KERNEL_32 1
+ 
+-static void dcopy_kernel_32( BLASLONG n, FLOAT *x, FLOAT *y) __attribute__ ((noinline));
+-
+-static void dcopy_kernel_32( BLASLONG n, FLOAT *x, FLOAT *y)
++static void dcopy_kernel_32 (long n, double *x, double *y)
+ {
+-
+-
+-	BLASLONG i = n;
+-	BLASLONG o16 = 16;
+-	BLASLONG o32 = 32;
+-	BLASLONG o48 = 48;
+-	BLASLONG o64 = 64;
+-	BLASLONG o80 = 80;
+-	BLASLONG o96 = 96;
+-	BLASLONG o112 = 112;
+-	FLOAT *x1=x;
+-	FLOAT *y1=y;
+-	BLASLONG pre = 384;
+-	BLASLONG alpha=0;
+-
+-	__asm__  __volatile__
+-	(
+-
+-	"lxvd2x		40, 0, %2			    \n\t"
+-	"lxvd2x		41, %5, %2			    \n\t"
+-	"lxvd2x		42, %6, %2			    \n\t"
+-	"lxvd2x		43, %7, %2			    \n\t"
+-	"lxvd2x		44, %8, %2			    \n\t"
+-	"lxvd2x		45, %9, %2			    \n\t"
+-	"lxvd2x		46, %10, %2			    \n\t"
+-	"lxvd2x		47, %11, %2			    \n\t"
+-
+-	"addi		%2, %2, 128			    \n\t"
+-
+-	"lxvd2x		50, 0, %2			    \n\t"
+-	"lxvd2x		51, %5, %2			    \n\t"
+-	"lxvd2x		52, %6, %2			    \n\t"
+-	"lxvd2x		53, %7, %2			    \n\t"
+-	"lxvd2x		54, %8, %2			    \n\t"
+-	"lxvd2x		55, %9, %2			    \n\t"
+-	"lxvd2x		56, %10, %2			    \n\t"
+-	"lxvd2x		57, %11, %2			    \n\t"
+-
+-	"addi		%2, %2, 128			    \n\t"
+-
+-	"addic.		%0 , %0	, -32  	 	             \n\t"
+-	"ble		2f		             	     \n\t"
+-
+-	".align 5				            \n\t"
+-	"1:				                    \n\t"
+-
+-	"stxvd2x		40, 0, %1			    \n\t"
+-	"stxvd2x		41, %5, %1			    \n\t"
+-	"lxvd2x		40, 0, %2			    \n\t"
+-	"lxvd2x		41, %5, %2			    \n\t"
+-	"stxvd2x		42, %6, %1			    \n\t"
+-	"stxvd2x		43, %7, %1			    \n\t"
+-	"lxvd2x		42, %6, %2			    \n\t"
+-	"lxvd2x		43, %7, %2			    \n\t"
+-	"stxvd2x		44, %8, %1			    \n\t"
+-	"stxvd2x		45, %9, %1			    \n\t"
+-	"lxvd2x		44, %8, %2			    \n\t"
+-	"lxvd2x		45, %9, %2			    \n\t"
+-	"stxvd2x		46, %10, %1			    \n\t"
+-	"stxvd2x		47, %11, %1			    \n\t"
+-	"lxvd2x		46, %10, %2			    \n\t"
+-	"lxvd2x		47, %11, %2			    \n\t"
+-
+-
+-	"addi		%1, %1, 128			    \n\t"
+-	"addi		%2, %2, 128			    \n\t"
+-
+-	"stxvd2x		50, 0, %1			    \n\t"
+-	"stxvd2x		51, %5, %1			    \n\t"
+-	"lxvd2x		50, 0, %2			    \n\t"
+-	"lxvd2x		51, %5, %2			    \n\t"
+-	"stxvd2x		52, %6, %1			    \n\t"
+-	"stxvd2x		53, %7, %1			    \n\t"
+-	"lxvd2x		52, %6, %2			    \n\t"
+-	"lxvd2x		53, %7, %2			    \n\t"
+-	"stxvd2x		54, %8, %1			    \n\t"
+-	"stxvd2x		55, %9, %1			    \n\t"
+-	"lxvd2x		54, %8, %2			    \n\t"
+-	"lxvd2x		55, %9, %2			    \n\t"
+-	"stxvd2x		56, %10, %1			    \n\t"
+-	"stxvd2x		57, %11, %1			    \n\t"
+-	"lxvd2x		56, %10, %2			    \n\t"
+-	"lxvd2x		57, %11, %2			    \n\t"
+-
+-	"addi		%1, %1, 128			    \n\t"
+-	"addi		%2, %2, 128			    \n\t"
+-
+-	"addic.		%0 , %0	, -32  	 	             \n\t"
+-	"bgt		1b		             	     \n\t"
+-
+-	"2:						     \n\t"
+-
+-	"stxvd2x		40, 0, %1			    \n\t"
+-	"stxvd2x		41, %5, %1			    \n\t"
+-	"stxvd2x		42, %6, %1			    \n\t"
+-	"stxvd2x		43, %7, %1			    \n\t"
+-	"stxvd2x		44, %8, %1			    \n\t"
+-	"stxvd2x		45, %9, %1			    \n\t"
+-	"stxvd2x		46, %10, %1			    \n\t"
+-	"stxvd2x		47, %11, %1			    \n\t"
+-
+-	"addi		%1, %1, 128			    \n\t"
+-
+-	"stxvd2x		50, 0, %1			    \n\t"
+-	"stxvd2x		51, %5, %1			    \n\t"
+-	"stxvd2x		52, %6, %1			    \n\t"
+-	"stxvd2x		53, %7, %1			    \n\t"
+-	"stxvd2x		54, %8, %1			    \n\t"
+-	"stxvd2x		55, %9, %1			    \n\t"
+-	"stxvd2x		56, %10, %1			    \n\t"
+-	"stxvd2x		57, %11, %1			    \n\t"
+-
+-
+-	:
+-        : 
+-          "r" (i),	// 0	
+-	  "r" (y1),  	// 1
+-          "r" (x1),     // 2
+-          "r" (alpha),  // 3
+-          "r" (pre),    // 4
+-	  "r" (o16),	// 5
+-	  "r" (o32),	// 6
+-	  "r" (o48),    // 7
+-          "r" (o64),    // 8
+-          "r" (o80),    // 9
+-          "r" (o96),    // 10
+-          "r" (o112)    // 11
+-	: "cr0", "%0", "%2" , "%1", "memory"
+-	);
+-
+-} 
+-
+-
++  __asm__
++    (
++       "lxvd2x		32, 0, %2	\n\t"
++       "lxvd2x		33, %5, %2	\n\t"
++       "lxvd2x		34, %6, %2	\n\t"
++       "lxvd2x		35, %7, %2	\n\t"
++       "lxvd2x		36, %8, %2	\n\t"
++       "lxvd2x		37, %9, %2	\n\t"
++       "lxvd2x		38, %10, %2	\n\t"
++       "lxvd2x		39, %11, %2	\n\t"
++
++       "addi		%2, %2, 128	\n\t"
++
++       "lxvd2x		40, 0, %2	\n\t"
++       "lxvd2x		41, %5, %2	\n\t"
++       "lxvd2x		42, %6, %2	\n\t"
++       "lxvd2x		43, %7, %2	\n\t"
++       "lxvd2x		44, %8, %2	\n\t"
++       "lxvd2x		45, %9, %2	\n\t"
++       "lxvd2x		46, %10, %2	\n\t"
++       "lxvd2x		47, %11, %2	\n\t"
++
++       "addi		%2, %2, 128	\n\t"
++
++       "addic.		%1, %1, -32	\n\t"
++       "ble		2f		\n\t"
++
++       ".p2align	5		\n"
++     "1:				\n\t"
++
++       "stxvd2x		32, 0, %3	\n\t"
++       "stxvd2x		33, %5, %3	\n\t"
++       "lxvd2x		32, 0, %2	\n\t"
++       "lxvd2x		33, %5, %2	\n\t"
++       "stxvd2x		34, %6, %3	\n\t"
++       "stxvd2x		35, %7, %3	\n\t"
++       "lxvd2x		34, %6, %2	\n\t"
++       "lxvd2x		35, %7, %2	\n\t"
++       "stxvd2x		36, %8, %3	\n\t"
++       "stxvd2x		37, %9, %3	\n\t"
++       "lxvd2x		36, %8, %2	\n\t"
++       "lxvd2x		37, %9, %2	\n\t"
++       "stxvd2x		38, %10, %3	\n\t"
++       "stxvd2x		39, %11, %3	\n\t"
++       "lxvd2x		38, %10, %2	\n\t"
++       "lxvd2x		39, %11, %2	\n\t"
++
++       "addi		%3, %3, 128	\n\t"
++       "addi		%2, %2, 128	\n\t"
++
++       "stxvd2x		40, 0, %3	\n\t"
++       "stxvd2x		41, %5, %3	\n\t"
++       "lxvd2x		40, 0, %2	\n\t"
++       "lxvd2x		41, %5, %2	\n\t"
++       "stxvd2x		42, %6, %3	\n\t"
++       "stxvd2x		43, %7, %3	\n\t"
++       "lxvd2x		42, %6, %2	\n\t"
++       "lxvd2x		43, %7, %2	\n\t"
++       "stxvd2x		44, %8, %3	\n\t"
++       "stxvd2x		45, %9, %3	\n\t"
++       "lxvd2x		44, %8, %2	\n\t"
++       "lxvd2x		45, %9, %2	\n\t"
++       "stxvd2x		46, %10, %3	\n\t"
++       "stxvd2x		47, %11, %3	\n\t"
++       "lxvd2x		46, %10, %2	\n\t"
++       "lxvd2x		47, %11, %2	\n\t"
++
++       "addi		%3, %3, 128	\n\t"
++       "addi		%2, %2, 128	\n\t"
++
++       "addic.		%1, %1, -32	\n\t"
++       "bgt		1b		\n"
++
++     "2:				\n\t"
++
++       "stxvd2x		32, 0, %3	\n\t"
++       "stxvd2x		33, %5, %3	\n\t"
++       "stxvd2x		34, %6, %3	\n\t"
++       "stxvd2x		35, %7, %3	\n\t"
++       "stxvd2x		36, %8, %3	\n\t"
++       "stxvd2x		37, %9, %3	\n\t"
++       "stxvd2x		38, %10, %3	\n\t"
++       "stxvd2x		39, %11, %3	\n\t"
++
++       "addi		%3, %3, 128	\n\t"
++
++       "stxvd2x		40, 0, %3	\n\t"
++       "stxvd2x		41, %5, %3	\n\t"
++       "stxvd2x		42, %6, %3	\n\t"
++       "stxvd2x		43, %7, %3	\n\t"
++       "stxvd2x		44, %8, %3	\n\t"
++       "stxvd2x		45, %9, %3	\n\t"
++       "stxvd2x		46, %10, %3	\n\t"
++       "stxvd2x		47, %11, %3	\n"
++
++     "#n=%1 x=%4=%2 y=%0=%3 o16=%5 o32=%6 o48=%7 o64=%8 o80=%9 o96=%10 o112=%11"
++     :
++       "=m" (*y),
++       "+r" (n),	// 1
++       "+b" (x),	// 2
++       "+b" (y)		// 3
++     :
++       "m" (*x),
++       "b" (16),	// 5
++       "b" (32),	// 6
++       "b" (48),	// 7
++       "b" (64),	// 8
++       "b" (80),	// 9
++       "b" (96),	// 10
++       "b" (112)	// 11
++     :
++       "cr0",
++       "vs32","vs33","vs34","vs35","vs36","vs37","vs38","vs39",
++       "vs40","vs41","vs42","vs43","vs44","vs45","vs46","vs47"
++     );
++}
+diff --git a/kernel/power/ddot.c b/kernel/power/ddot.c
+index cef60a2..e43470e 100644
+--- a/kernel/power/ddot.c
++++ b/kernel/power/ddot.c
+@@ -43,7 +43,7 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+ #ifndef HAVE_KERNEL_8
+ 
+-static void ddot_kernel_8(BLASLONG n, FLOAT *x, FLOAT *y, FLOAT *d)
++static FLOAT ddot_kernel_8 (BLASLONG n, FLOAT *x, FLOAT *y)
+ {
+ 	BLASLONG register i = 0;
+ 	FLOAT dot = 0.0;
+@@ -62,8 +62,7 @@ static void ddot_kernel_8(BLASLONG n, FLOAT *x, FLOAT *y, FLOAT *d)
+               i+=8 ;
+ 
+        }
+-       *d += dot;
+-
++       return dot;
+ }
+ 
+ #endif
+@@ -83,7 +82,7 @@ FLOAT CNAME(BLASLONG n, FLOAT *x, BLASLONG inc_x, FLOAT *y, BLASLONG inc_y)
+ 		BLASLONG n1 = n & -16;
+ 
+ 		if ( n1 )
+-			ddot_kernel_8(n1, x, y , &dot );
++			dot = ddot_kernel_8(n1, x, y);
+ 
+ 		i = n1;
+ 		while(i < n)
+diff --git a/kernel/power/ddot_microk_power8.c b/kernel/power/ddot_microk_power8.c
+index b880492..4e6bc29 100644
+--- a/kernel/power/ddot_microk_power8.c
++++ b/kernel/power/ddot_microk_power8.c
+@@ -34,145 +34,138 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ **************************************************************************************/
+ 
+ #define HAVE_KERNEL_8 1
+-static void ddot_kernel_8( BLASLONG n, FLOAT *x, FLOAT *y , FLOAT *dot) __attribute__ ((noinline));
+ 
+-static void ddot_kernel_8( BLASLONG n, FLOAT *x, FLOAT *y, FLOAT *dot)
++static double ddot_kernel_8 (long n, double *x, double *y)
+ {
+-
+-
+-	BLASLONG i = n;
+-	BLASLONG o16 = 16;
+-	BLASLONG o32 = 32;
+-	BLASLONG o48 = 48;
+-	BLASLONG o64 = 64;
+-	BLASLONG o80 = 80;
+-	BLASLONG o96 = 96;
+-	BLASLONG o112 = 112;
+-	FLOAT *x1=x;
+-	FLOAT *y1=y;
+-	BLASLONG pre = 384;
+-
+-	__asm__  __volatile__
+-	(
+-	"xxlxor		32,32,32			    \n\t"
+-	"xxlxor		33,33,33			    \n\t"
+-	"xxlxor		34,34,34			    \n\t"
+-	"xxlxor		35,35,35			    \n\t"
+-	"xxlxor		36,36,36			    \n\t"
+-	"xxlxor		37,37,37			    \n\t"
+-	"xxlxor		38,38,38			    \n\t"
+-	"xxlxor		39,39,39			    \n\t"
+-
+-	"dcbt		%2, %12				    \n\t"
+-	"dcbt		%3, %12				    \n\t"
+-
+-	"lxvd2x		40, 0, %2			    \n\t"
+-	"lxvd2x		48, 0, %3			    \n\t"
+-	"lxvd2x		41, %5, %2			    \n\t"
+-	"lxvd2x		49, %5, %3			    \n\t"
+-	"lxvd2x		42, %6, %2			    \n\t"
+-	"lxvd2x		50, %6, %3			    \n\t"
+-	"lxvd2x		43, %7, %2			    \n\t"
+-	"lxvd2x		51, %7, %3			    \n\t"
+-	"lxvd2x		44, %8, %2			    \n\t"
+-	"lxvd2x		52, %8, %3			    \n\t"
+-	"lxvd2x		45, %9, %2			    \n\t"
+-	"lxvd2x		53, %9, %3			    \n\t"
+-	"lxvd2x		46, %10, %2			    \n\t"
+-	"lxvd2x		54, %10, %3			    \n\t"
+-	"lxvd2x		47, %11, %2			    \n\t"
+-	"lxvd2x		55, %11, %3			    \n\t"
+-
+-	"addi		%2, %2, 128			    \n\t"
+-	"addi		%3, %3, 128			    \n\t"
+-
+-	"addic.		%0 , %0	, -16  	 	             \n\t"
+-	"ble		2f		             	     \n\t"
+-
+-	".align 5				            \n\t"
+-	"1:				                    \n\t"
+-
+-	"dcbt		%2, %12				    \n\t"
+-	"dcbt		%3, %12				    \n\t"
+-
+-	"xvmaddadp	32, 40, 48		    \n\t"
+-	"lxvd2x		40, 0, %2			    \n\t"
+-	"lxvd2x		48, 0, %3			    \n\t"
+-	"xvmaddadp	33, 41, 49		    \n\t"
+-	"lxvd2x		41, %5, %2			    \n\t"
+-	"lxvd2x		49, %5, %3			    \n\t"
+-	"xvmaddadp	34, 42, 50		    \n\t"
+-	"lxvd2x		42, %6, %2			    \n\t"
+-	"lxvd2x		50, %6, %3			    \n\t"
+-	"xvmaddadp	35, 43, 51		    \n\t"
+-	"lxvd2x		43, %7, %2			    \n\t"
+-	"lxvd2x		51, %7, %3			    \n\t"
+-	"xvmaddadp	36, 44, 52		    \n\t"
+-	"lxvd2x		44, %8, %2			    \n\t"
+-	"lxvd2x		52, %8, %3			    \n\t"
+-	"xvmaddadp	37, 45, 53		    \n\t"
+-	"lxvd2x		45, %9, %2			    \n\t"
+-	"lxvd2x		53, %9, %3			    \n\t"
+-	"xvmaddadp	38, 46, 54		    \n\t"
+-	"lxvd2x		46, %10, %2			    \n\t"
+-	"lxvd2x		54, %10, %3			    \n\t"
+-	"xvmaddadp	39, 47, 55		    \n\t"
+-
+-	"lxvd2x		47, %11, %2			    \n\t"
+-	"lxvd2x		55, %11, %3			    \n\t"
+-
+-
+-	"addi		%2, %2, 128			    \n\t"
+-	"addi		%3, %3, 128			    \n\t"
+-
+-	"addic.		%0 , %0	, -16  	 	             \n\t"
+-	"bgt		1b		             	     \n\t"
+-
+-	"2:						     \n\t"
+-
+-	"xvmaddadp	32, 40, 48		    \n\t"
+-	"xvmaddadp	33, 41, 49		    \n\t"
+-	"xvmaddadp	34, 42, 50		    \n\t"
+-	"xvmaddadp	35, 43, 51		    \n\t"
+-	"xvmaddadp	36, 44, 52		    \n\t"
+-	"xvmaddadp	37, 45, 53		    \n\t"
+-	"xvmaddadp	38, 46, 54		    \n\t"
+-	"xvmaddadp	39, 47, 55		    \n\t"
+-
+-	"xvadddp	32, 32, 33		     \n\t"
+-	"xvadddp	34, 34, 35		     \n\t"
+-	"xvadddp	36, 36, 37		     \n\t"
+-	"xvadddp	38, 38, 39		     \n\t"
+-
+-	"xvadddp	32, 32, 34		     \n\t"
+-	"xvadddp	36, 36, 38		     \n\t"
+-
+-	"xvadddp	32, 32, 36		     \n\t"
+-
+-	"xxswapd	33, 32			     \n\t"
+-
+-	"xsadddp	32, 32, 33		     \n\t"
+-
+-	"stxsdx		32, 0, %4			     \n\t"
+-
+-	:
+-        : 
+-          "r" (i),	// 0	
+-	  "r" (n),  	// 1
+-          "r" (x1),     // 2
+-          "r" (y1),     // 3
+-          "r" (dot),    // 4
+-	  "r" (o16),	// 5
+-	  "r" (o32),	// 6
+-	  "r" (o48),    // 7
+-          "r" (o64),    // 8
+-          "r" (o80),    // 9
+-          "r" (o96),    // 10
+-          "r" (o112),   // 11
+-	  "r" (pre)	// 12
+-	: "cr0", "%0", "%2" , "%3", "memory"
+-	);
+-
+-} 
+-
+-
++  double dot;
++  __vector double t0;
++  __vector double t1;
++  __vector double t2;
++  __vector double t3;
++
++  __asm__
++    (
++       "dcbt		0, %2		\n\t"
++       "dcbt		0, %3		\n\t"
++
++       "xxlxor		32, 32,	32	\n\t"
++       "xxlxor		33, 33,	33	\n\t"
++       "xxlxor		34, 34,	34	\n\t"
++       "xxlxor		35, 35,	35	\n\t"
++       "xxlxor		36, 36,	36	\n\t"
++       "xxlxor		37, 37,	37	\n\t"
++       "xxlxor		38, 38,	38	\n\t"
++       "xxlxor		39, 39,	39	\n\t"
++
++       "lxvd2x		40, 0, %2	\n\t"
++       "lxvd2x		48, 0, %3	\n\t"
++       "lxvd2x		41, %10, %2	\n\t"
++       "lxvd2x		49, %10, %3	\n\t"
++       "lxvd2x		42, %11, %2	\n\t"
++       "lxvd2x		50, %11, %3	\n\t"
++       "lxvd2x		43, %12, %2	\n\t"
++       "lxvd2x		51, %12, %3	\n\t"
++       "lxvd2x		44, %13, %2	\n\t"
++       "lxvd2x		%x4, %13, %3	\n\t"
++       "lxvd2x		45, %14, %2	\n\t"
++       "lxvd2x		%x5, %14, %3	\n\t"
++       "lxvd2x		46, %15, %2	\n\t"
++       "lxvd2x		%x6, %15, %3	\n\t"
++       "lxvd2x		47, %16, %2	\n\t"
++       "lxvd2x		%x7, %16, %3	\n\t"
++
++       "addi		%2, %2, 128	\n\t"
++       "addi		%3, %3, 128	\n\t"
++
++       "addic.		%1, %1, -16	\n\t"
++       "ble		2f		\n\t"
++
++       ".p2align	5		\n"
++     "1:				\n\t"
++
++       "xvmaddadp	32, 40, 48	\n\t"
++       "lxvd2x		40, 0, %2	\n\t"
++       "lxvd2x		48, 0, %3	\n\t"
++       "xvmaddadp	33, 41, 49	\n\t"
++       "lxvd2x		41, %10, %2	\n\t"
++       "lxvd2x		49, %10, %3	\n\t"
++       "xvmaddadp	34, 42, 50	\n\t"
++       "lxvd2x		42, %11, %2	\n\t"
++       "lxvd2x		50, %11, %3	\n\t"
++       "xvmaddadp	35, 43, 51	\n\t"
++       "lxvd2x		43, %12, %2	\n\t"
++       "lxvd2x		51, %12, %3	\n\t"
++       "xvmaddadp	36, 44, %x4	\n\t"
++       "lxvd2x		44, %13, %2	\n\t"
++       "lxvd2x		%x4, %13, %3	\n\t"
++       "xvmaddadp	37, 45, %x5	\n\t"
++       "lxvd2x		45, %14, %2	\n\t"
++       "lxvd2x		%x5, %14, %3	\n\t"
++       "xvmaddadp	38, 46, %x6	\n\t"
++       "lxvd2x		46, %15, %2	\n\t"
++       "lxvd2x		%x6, %15, %3	\n\t"
++       "xvmaddadp	39, 47, %x7	\n\t"
++       "lxvd2x		47, %16, %2	\n\t"
++       "lxvd2x		%x7, %16, %3	\n\t"
++
++       "addi		%2, %2, 128	\n\t"
++       "addi		%3, %3, 128	\n\t"
++
++       "addic.		%1, %1, -16	\n\t"
++       "bgt		1b		\n"
++
++     "2:				\n\t"
++
++       "xvmaddadp	32, 40, 48	\n\t"
++       "xvmaddadp	33, 41, 49	\n\t"
++       "xvmaddadp	34, 42, 50	\n\t"
++       "xvmaddadp	35, 43, 51	\n\t"
++       "xvmaddadp	36, 44, %x4	\n\t"
++       "xvmaddadp	37, 45, %x5	\n\t"
++       "xvmaddadp	38, 46, %x6	\n\t"
++       "xvmaddadp	39, 47, %x7	\n\t"
++
++       "xvadddp		32, 32, 33	\n\t"
++       "xvadddp		34, 34, 35	\n\t"
++       "xvadddp		36, 36, 37	\n\t"
++       "xvadddp		38, 38, 39	\n\t"
++
++       "xvadddp		32, 32, 34	\n\t"
++       "xvadddp		36, 36, 38	\n\t"
++
++       "xvadddp		32, 32, 36	\n\t"
++
++       "xxswapd		33, 32		\n\t"
++
++       "xsadddp		%x0, 32, 33	\n"
++
++     "#dot=%0 n=%1 x=%8=%2 y=%9=%3 o16=%10 o32=%11 o48=%12 o64=%13 o80=%14 o96=%15 o122=%16\n"
++     "#t0=%x4 t1=%x5 t2=%x6 t3=%x7"
++     :
++       "=d" (dot),	// 0
++       "+r" (n),	// 1
++       "+b" (x),	// 2
++       "+b" (y),	// 3
++       "=wa" (t0),	// 4
++       "=wa" (t1),	// 5
++       "=wa" (t2),	// 6
++       "=wa" (t3)	// 7
++     :
++       "m" (*x),
++       "m" (*y),
++       "b" (16),	// 10
++       "b" (32),	// 11
++       "b" (48),	// 12
++       "b" (64),	// 13
++       "b" (80),	// 14
++       "b" (96),	// 15
++       "b" (112)	// 16
++     :
++       "cr0",
++       "vs32","vs33","vs34","vs35","vs36","vs37","vs38","vs39",
++       "vs40","vs41","vs42","vs43","vs44","vs45","vs46","vs47",
++       "vs48","vs49","vs50","vs51"
++     );
++
++  return dot;
++}
+diff --git a/kernel/power/dgemv_n.c b/kernel/power/dgemv_n.c
+index 812d09d..57f9f9e 100644
+--- a/kernel/power/dgemv_n.c
++++ b/kernel/power/dgemv_n.c
+@@ -47,18 +47,18 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+ #ifndef HAVE_KERNEL_4x4
+ 
+-static void dgemv_kernel_4x4(BLASLONG n, FLOAT **ap, FLOAT *xo, FLOAT *y, FLOAT *alpha)
++static void dgemv_kernel_4x4(BLASLONG n, FLOAT *a_ptr, BLASLONG lda, FLOAT *xo, FLOAT *y, FLOAT alpha)
+ {
+ 	BLASLONG i;
+-	FLOAT *a0,*a1,*a2,*a3;
+ 	FLOAT x[4]  __attribute__ ((aligned (16)));;
+-	a0 = ap[0];
+-	a1 = ap[1];
+-	a2 = ap[2];
+-	a3 = ap[3];
++	FLOAT *a0 = a_ptr;
++	FLOAT *a1 = a0 + lda;
++	FLOAT *a2 = a1 + lda;
++	FLOAT *a3 = a2 + lda;
++
+ 
+ 	for ( i=0; i<4; i++)
+-		x[i] = xo[i] * *alpha;
++		x[i] = xo[i] * alpha;
+ 
+ 	for ( i=0; i< n; i+=4 )
+ 	{
+@@ -73,16 +73,13 @@ static void dgemv_kernel_4x4(BLASLONG n, FLOAT **ap, FLOAT *xo, FLOAT *y, FLOAT
+ 
+ #ifndef HAVE_KERNEL_4x2
+ 
+-static void dgemv_kernel_4x2(BLASLONG n, FLOAT **ap, FLOAT *xo, FLOAT *y, FLOAT *alpha)
++static void dgemv_kernel_4x2(BLASLONG n, FLOAT *a0, FLOAT *a1, FLOAT *xo, FLOAT *y, FLOAT alpha)
+ {
+ 	BLASLONG i;
+-	FLOAT *a0,*a1;
+ 	FLOAT x[4]  __attribute__ ((aligned (16)));;
+-	a0 = ap[0];
+-	a1 = ap[1];
+ 
+ 	for ( i=0; i<2; i++)
+-		x[i] = xo[i] * *alpha;
++		x[i] = xo[i] * alpha;
+ 
+ 	for ( i=0; i< n; i+=4 )
+ 	{
+@@ -98,15 +95,13 @@ static void dgemv_kernel_4x2(BLASLONG n, FLOAT **ap, FLOAT *xo, FLOAT *y, FLOAT
+ 
+ #ifndef HAVE_KERNEL_4x1
+ 
+-static void dgemv_kernel_4x1(BLASLONG n, FLOAT *ap, FLOAT *xo, FLOAT *y, FLOAT *alpha)
++static void dgemv_kernel_4x1(BLASLONG n, FLOAT *a0, FLOAT *xo, FLOAT *y, FLOAT alpha)
+ {
+ 	BLASLONG i;
+-	FLOAT *a0;
+ 	FLOAT x[4]  __attribute__ ((aligned (16)));;
+-	a0 = ap;
+ 
+ 	for ( i=0; i<1; i++)
+-		x[i] = xo[i] * *alpha;
++		x[i] = xo[i] * alpha;
+ 
+ 	for ( i=0; i< n; i+=4 )
+ 	{
+@@ -141,7 +136,6 @@ int CNAME(BLASLONG m, BLASLONG n, BLASLONG dummy1, FLOAT alpha, FLOAT *a, BLASLO
+ {
+ 
+ 	BLASLONG i;
+-	BLASLONG j;
+ 	FLOAT *a_ptr;
+ 	FLOAT *x_ptr;
+ 	FLOAT *y_ptr;
+@@ -151,13 +145,9 @@ int CNAME(BLASLONG m, BLASLONG n, BLASLONG dummy1, FLOAT alpha, FLOAT *a, BLASLO
+ 	BLASLONG m3;
+ 	BLASLONG n2;
+ 	BLASLONG lda4 =  lda << 2;
+-	FLOAT *ap[4] __attribute__ ((aligned (16)));;
+ 	FLOAT xbuffer[8] __attribute__ ((aligned (16)));;
+-	FLOAT alpha_r[4] __attribute__ ((aligned (16)));;
+ 	FLOAT *ybuffer;
+ 
+-	alpha_r[0] = alpha;
+-
+         if ( m < 1 ) return(0);
+         if ( n < 1 ) return(0);
+ 
+@@ -187,11 +177,6 @@ int CNAME(BLASLONG m, BLASLONG n, BLASLONG dummy1, FLOAT alpha, FLOAT *a, BLASLO
+ 		a_ptr = a;
+ 		x_ptr = x;
+ 		
+-		ap[0] = a_ptr;
+-		ap[1] = a_ptr + lda;
+-		ap[2] = ap[1] + lda;
+-		ap[3] = ap[2] + lda;
+-
+ 		if ( inc_y != 1 )
+ 			memset(ybuffer,0,NB*8);
+ 		else
+@@ -203,18 +188,14 @@ int CNAME(BLASLONG m, BLASLONG n, BLASLONG dummy1, FLOAT alpha, FLOAT *a, BLASLO
+ 
+ 			for( i = 0; i < n1 ; i++)
+ 			{
+-				dgemv_kernel_4x4(NB,ap,x_ptr,ybuffer,alpha_r);
+-				ap[0] += lda4; 
+-				ap[1] += lda4; 
+-				ap[2] += lda4; 
+-				ap[3] += lda4; 
++				dgemv_kernel_4x4(NB,a_ptr,lda,x_ptr,ybuffer,alpha);
+ 				a_ptr += lda4;
+ 				x_ptr += 4;	
+ 			}
+ 
+ 			if ( n2 & 2 )
+ 			{
+-				dgemv_kernel_4x2(NB,ap,x_ptr,ybuffer,alpha_r);
++				dgemv_kernel_4x2(NB,a_ptr,a_ptr+lda,x_ptr,ybuffer,alpha);
+ 				a_ptr += lda*2;
+ 				x_ptr += 2;	
+ 			}
+@@ -222,7 +203,7 @@ int CNAME(BLASLONG m, BLASLONG n, BLASLONG dummy1, FLOAT alpha, FLOAT *a, BLASLO
+ 
+ 			if ( n2 & 1 )
+ 			{
+-				dgemv_kernel_4x1(NB,a_ptr,x_ptr,ybuffer,alpha_r);
++				dgemv_kernel_4x1(NB,a_ptr,x_ptr,ybuffer,alpha);
+ 				a_ptr += lda;
+ 				x_ptr += 1;	
+ 
+@@ -243,11 +224,7 @@ int CNAME(BLASLONG m, BLASLONG n, BLASLONG dummy1, FLOAT alpha, FLOAT *a, BLASLO
+ 				x_ptr += inc_x;	
+ 				xbuffer[3] = x_ptr[0];
+ 				x_ptr += inc_x;	
+-				dgemv_kernel_4x4(NB,ap,xbuffer,ybuffer,alpha_r);
+-				ap[0] += lda4; 
+-				ap[1] += lda4; 
+-				ap[2] += lda4; 
+-				ap[3] += lda4; 
++				dgemv_kernel_4x4(NB,a_ptr,lda,xbuffer,ybuffer,alpha);
+ 				a_ptr += lda4;
+ 			}
+ 
+@@ -255,7 +232,7 @@ int CNAME(BLASLONG m, BLASLONG n, BLASLONG dummy1, FLOAT alpha, FLOAT *a, BLASLO
+ 			{
+ 				xbuffer[0] = x_ptr[0];
+ 				x_ptr += inc_x;	
+-				dgemv_kernel_4x1(NB,a_ptr,xbuffer,ybuffer,alpha_r);
++				dgemv_kernel_4x1(NB,a_ptr,xbuffer,ybuffer,alpha);
+ 				a_ptr += lda;
+ 
+ 			}
+diff --git a/kernel/power/dgemv_n_microk_power8.c b/kernel/power/dgemv_n_microk_power8.c
+index 9eabe55..5b42bbb 100644
+--- a/kernel/power/dgemv_n_microk_power8.c
++++ b/kernel/power/dgemv_n_microk_power8.c
+@@ -35,267 +35,264 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+ #define HAVE_KERNEL_4x4 1
+ 
+-static void dgemv_kernel_4x4(BLASLONG n, FLOAT **ap, FLOAT *xo, FLOAT *y, FLOAT *alpha) __attribute__ ((noinline));
+-
+-static void dgemv_kernel_4x4(BLASLONG n, FLOAT **ap, FLOAT *xo, FLOAT *y, FLOAT *alpha)
++static void dgemv_kernel_4x4 (long n, double *ap, long lda, double *x, double *y, double alpha)
+ {
+-        BLASLONG i=n;
+-	BLASLONG o8  = 8;
+-	BLASLONG o16 = 16;
+-	BLASLONG o24 = 24;
+-	BLASLONG pre = 384;
+-
+-        FLOAT *a0,*a1,*a2,*a3;
+-	FLOAT *y1=y+1;
+-        FLOAT x[4]  __attribute__ ((aligned (16)));;
+-        a0 = ap[0]+1;
+-        a1 = ap[1]+1;
+-        a2 = ap[2]+1;
+-        a3 = ap[3]+1;
+-
+-	x[0]=xo[0] * *alpha;
+-	x[1]=xo[1] * *alpha;
+-	x[2]=xo[2] * *alpha;
+-	x[3]=xo[3] * *alpha;
++  double *a0;
++  double *a1;
++  double *a2;
++  double *a3;
++
++  __asm__
++    (
++       "lxvd2x		34, 0, %9	\n\t"	// x0, x1
++       "lxvd2x		35, %10, %9	\n\t"	// x2, x3
++       "xxspltd		32, %x8, 0	\n\t"	// alpha, alpha
++
++       "sldi		%6, %4, 3	\n\t"	// lda * sizeof (double)
++
++       "xvmuldp		34, 34, 32	\n\t"	// x0 * alpha, x1 * alpha
++       "xvmuldp		35, 35, 32	\n\t"	// x2 * alpha, x3 * alpha
++
++       "add		%4, %3, %6	\n\t"	// a1 = a0 + lda
++       "add		%6, %6, %6	\n\t"	// 2 * lda
++
++       "xxspltd		32, 34, 0	\n\t"	// x0 * alpha, x0 * alpha
++       "xxspltd		33, 34, 1	\n\t"	// x1 * alpha, x1 * alpha
++       "xxspltd		34, 35, 0	\n\t"	// x2 * alpha, x2 * alpha
++       "xxspltd		35, 35, 1	\n\t"	// x3 * alpha, x3 * alpha
++
++       "add		%5, %3, %6	\n\t"	// a2 = a0 + 2 * lda
++       "add		%6, %4, %6	\n\t"	// a3 = a1 + 2 * lda
++
++       "dcbt		0, %3		\n\t"
++       "dcbt		0, %4		\n\t"
++       "dcbt		0, %5		\n\t"
++       "dcbt		0, %6		\n\t"
+ 
++       "lxvd2x		40, 0, %3	\n\t"	// a0[0], a0[1]
++       "lxvd2x		41, %10, %3	\n\t"	// a0[2], a0[3]
+ 
+-	__asm__  __volatile__
+-	(
+-	"lxvdsx		32, 0 , %1			    \n\t"	// x0
+-	"lxvdsx		33,%3 , %1			    \n\t"	// x1
+-	"lxvdsx		34,%4 , %1			    \n\t"	// x2
+-	"lxvdsx		35,%5 , %1			    \n\t"	// x3
+-	"addi		%2 , %2 , -8			    \n\t"
+-	"addi		%6 , %6 , -8			    \n\t"
+-	"addi		%7 , %7 , -8			    \n\t"
+-	"addi		%8 , %8 , -8			    \n\t"
+-	"addi		%9 , %9 , -8			    \n\t"
+-	
+-	"lxvd2x		48, 0, %6			    \n\t"	// a0[0], a0[1] 
+-	"lxvd2x		49,%4, %6			    \n\t"	// a0[2], a0[3] 
+-
+-	"lxvd2x		50, 0, %7			    \n\t"	// a1[0], a1[1] 
+-	"lxvd2x		51,%4, %7			    \n\t"	// a1[2], a1[3] 
++       "lxvd2x		42, 0, %4	\n\t"	// a1[0], a1[1]
++       "lxvd2x		43, %10, %4	\n\t"	// a1[2], a1[3]
+ 
+-	"lxvd2x		52, 0, %8			    \n\t"	// a2[0], a2[1] 
+-	"lxvd2x		53,%4, %8			    \n\t"	// a2[2], a2[3] 
++       "lxvd2x		44, 0, %5	\n\t"	// a2[0], a2[1]
++       "lxvd2x		45, %10, %5	\n\t"	// a2[2], a2[3]
+ 
+-	"lxvd2x		54, 0, %9			    \n\t"	// a3[0], a3[1] 
+-	"lxvd2x		55,%4, %9			    \n\t"	// a3[2], a3[3] 
++       "lxvd2x		46, 0, %6	\n\t"	// a3[0], a3[1]
++       "lxvd2x		47, %10, %6	\n\t"	// a3[2], a3[3]
+ 
+-	"addi		%6, %6, 32			    \n\t"
+-	"addi		%7, %7, 32			    \n\t"
+-	"addi		%8, %8, 32			    \n\t"
+-	"addi		%9, %9, 32			    \n\t"
++       "dcbt		0, %2		\n\t"
+ 
+-	"addic.		%0 , %0	, -4  	 	             \n\t"
+-	"ble		2f		             	     \n\t"
++       "addi		%3, %3, 32	\n\t"
++       "addi		%4, %4, 32	\n\t"
++       "addi		%5, %5, 32	\n\t"
++       "addi		%6, %6, 32	\n\t"
+ 
+-	".align 5				            \n\t"
+-	"1:				                    \n\t"
++       "addic.		%1, %1, -4	\n\t"
++       "ble		2f		\n\t"
+ 
+-	"dcbt		%2, %10				    \n\t"
++       ".p2align	5		\n"
++     "1:				\n\t"
+ 
+-	"lxvd2x		40, 0, %2			    \n\t"	// y0, y1
+-	"lxvd2x		41,%4, %2			    \n\t"	// y2, y3
+-	
+-	"dcbt		%6, %10				    \n\t"
+-	"dcbt		%7, %10				    \n\t"
+-	"dcbt		%8, %10				    \n\t"
+-	"dcbt		%9, %10				    \n\t"
++       "lxvd2x		36, 0, %2	\n\t"	// y0, y1
++       "lxvd2x		37, %10, %2	\n\t"	// y2, y3
+ 
+-	"xvmaddadp	40, 48, 32			    \n\t"
+-	"xvmaddadp	41, 49, 32			    \n\t"
++       "xvmaddadp 	36, 40, 32	\n\t"
++       "xvmaddadp 	37, 41, 32	\n\t"
+ 
+-	"lxvd2x		48, 0, %6			    \n\t"	// a0[0], a0[1] 
+-	"lxvd2x		49,%4, %6			    \n\t"	// a0[2], a0[3] 
++       "lxvd2x		40, 0, %3	\n\t"	// a0[0], a0[1]
++       "lxvd2x		41, %10, %3	\n\t"	// a0[2], a0[3]
+ 
+-	"xvmaddadp	40, 50, 33			    \n\t"
+-	"addi		%6, %6, 32			    \n\t"
+-	"xvmaddadp	41, 51, 33			    \n\t"
++       "xvmaddadp 	36, 42, 33	\n\t"
++       "addi		%3, %3, 32	\n\t"
++       "xvmaddadp 	37, 43, 33	\n\t"
+ 
+-	"lxvd2x		50, 0, %7			    \n\t"	// a1[0], a1[1] 
+-	"lxvd2x		51,%4, %7			    \n\t"	// a1[2], a1[3] 
++       "lxvd2x		42, 0, %4	\n\t"	// a1[0], a1[1]
++       "lxvd2x		43, %10, %4	\n\t"	// a1[2], a1[3]
+ 
+-	"xvmaddadp	40, 52, 34			    \n\t"
+-	"addi		%7, %7, 32			    \n\t"
+-	"xvmaddadp	41, 53, 34			    \n\t"
++       "xvmaddadp 	36, 44, 34	\n\t"
++       "addi		%4, %4, 32	\n\t"
++       "xvmaddadp 	37, 45, 34	\n\t"
+ 
+-	"lxvd2x		52, 0, %8			    \n\t"	// a2[0], a2[1] 
+-	"lxvd2x		53,%4, %8			    \n\t"	// a2[2], a2[3] 
++       "lxvd2x		44, 0, %5	\n\t"	// a2[0], a2[1]
++       "lxvd2x		45, %10, %5	\n\t"	// a2[2], a2[3]
+ 
+-	"xvmaddadp	40, 54, 35			    \n\t"
+-	"addi		%8, %8, 32			    \n\t"
+-	"xvmaddadp	41, 55, 35			    \n\t"
++       "xvmaddadp 	36, 46, 35	\n\t"
++       "addi		%5, %5, 32	\n\t"
++       "xvmaddadp 	37, 47, 35	\n\t"
+ 
+-	"stxvd2x	40, 0, %2			    \n\t"	// y0, y1
+-	"stxvd2x	41,%4, %2			    \n\t"	// y2, y3
++       "stxvd2x		36, 0, %2	\n\t"	// y0, y1
++       "stxvd2x		37, %10, %2	\n\t"	// y2, y3
+ 
+-	"lxvd2x		54, 0, %9			    \n\t"	// a3[0], a3[1] 
+-	"lxvd2x		55,%4, %9			    \n\t"	// a3[2], a3[3] 
++       "lxvd2x		46, 0, %6	\n\t"	// a3[0], a3[1]
++       "lxvd2x		47, %10, %6	\n\t"	// a3[2], a3[3]
+ 
+-	"addi		%9, %9, 32			    \n\t"
+-	"addi		%2, %2, 32			    \n\t"
++       "addi		%6, %6, 32	\n\t"
++       "addi		%2, %2, 32	\n\t"
+ 
+-	"addic.		%0 , %0	, -4  	 	             \n\t"
+-	"ble		2f		             	     \n\t"
++       "addic.		%1, %1, -4	\n\t"
++       "ble		2f		\n\t"
+ 
+ 
+-	"lxvd2x		40, 0, %2			    \n\t"	// y0, y1
+-	"lxvd2x		41,%4, %2			    \n\t"	// y2, y3
+-	
+-	"xvmaddadp	40, 48, 32			    \n\t"
+-	"xvmaddadp	41, 49, 32			    \n\t"
++       "lxvd2x		36, 0, %2	\n\t"	// y0, y1
++       "lxvd2x		37, %10, %2	\n\t"	// y2, y3
+ 
+-	"lxvd2x		48, 0, %6			    \n\t"	// a0[0], a0[1] 
+-	"lxvd2x		49,%4, %6			    \n\t"	// a0[2], a0[3] 
++       "xvmaddadp 	36, 40, 32	\n\t"
++       "xvmaddadp 	37, 41, 32	\n\t"
+ 
+-	"xvmaddadp	40, 50, 33			    \n\t"
+-	"addi		%6, %6, 32			    \n\t"
+-	"xvmaddadp	41, 51, 33			    \n\t"
++       "lxvd2x		40, 0, %3	\n\t"	// a0[0], a0[1]
++       "lxvd2x		41, %10, %3	\n\t"	// a0[2], a0[3]
+ 
+-	"lxvd2x		50, 0, %7			    \n\t"	// a1[0], a1[1] 
+-	"lxvd2x		51,%4, %7			    \n\t"	// a1[2], a1[3] 
++       "xvmaddadp 	36, 42, 33	\n\t"
++       "addi		%3, %3, 32	\n\t"
++       "xvmaddadp 	37, 43, 33	\n\t"
+ 
+-	"xvmaddadp	40, 52, 34			    \n\t"
+-	"addi		%7, %7, 32			    \n\t"
+-	"xvmaddadp	41, 53, 34			    \n\t"
++       "lxvd2x		42, 0, %4	\n\t"	// a1[0], a1[1]
++       "lxvd2x		43, %10, %4	\n\t"	// a1[2], a1[3]
+ 
+-	"lxvd2x		52, 0, %8			    \n\t"	// a2[0], a2[1] 
+-	"lxvd2x		53,%4, %8			    \n\t"	// a2[2], a2[3] 
++       "xvmaddadp 	36, 44, 34	\n\t"
++       "addi		%4, %4, 32	\n\t"
++       "xvmaddadp 	37, 45, 34	\n\t"
+ 
+-	"xvmaddadp	40, 54, 35			    \n\t"
+-	"addi		%8, %8, 32			    \n\t"
+-	"xvmaddadp	41, 55, 35			    \n\t"
++       "lxvd2x		44, 0, %5	\n\t"	// a2[0], a2[1]
++       "lxvd2x		45, %10, %5	\n\t"	// a2[2], a2[3]
+ 
+-	"stxvd2x	40, 0, %2			    \n\t"	// y0, y1
+-	"stxvd2x	41,%4, %2			    \n\t"	// y2, y3
++       "xvmaddadp 	36, 46, 35	\n\t"
++       "addi		%5, %5, 32	\n\t"
++       "xvmaddadp 	37, 47, 35	\n\t"
+ 
+-	"lxvd2x		54, 0, %9			    \n\t"	// a3[0], a3[1] 
+-	"lxvd2x		55,%4, %9			    \n\t"	// a3[2], a3[3] 
++       "stxvd2x		36, 0, %2	\n\t"	// y0, y1
++       "stxvd2x		37, %10, %2	\n\t"	// y2, y3
+ 
+-	"addi		%9, %9, 32			    \n\t"
+-	"addi		%2, %2, 32			    \n\t"
++       "lxvd2x		46, 0, %6	\n\t"	// a3[0], a3[1]
++       "lxvd2x		47, %10, %6	\n\t"	// a3[2], a3[3]
+ 
+-	"addic.		%0 , %0	, -4  	 	             \n\t"
+-	"ble		2f		             	     \n\t"
++       "addi		%6, %6, 32	\n\t"
++       "addi		%2, %2, 32	\n\t"
+ 
++       "addic.		%1, %1, -4	\n\t"
++       "ble		2f		\n\t"
+ 
+-	"lxvd2x		40, 0, %2			    \n\t"	// y0, y1
+-	"lxvd2x		41,%4, %2			    \n\t"	// y2, y3
+-	
+-	"xvmaddadp	40, 48, 32			    \n\t"
+-	"xvmaddadp	41, 49, 32			    \n\t"
+ 
+-	"lxvd2x		48, 0, %6			    \n\t"	// a0[0], a0[1] 
+-	"lxvd2x		49,%4, %6			    \n\t"	// a0[2], a0[3] 
++       "lxvd2x		36, 0, %2	\n\t"	// y0, y1
++       "lxvd2x		37, %10, %2	\n\t"	// y2, y3
+ 
+-	"xvmaddadp	40, 50, 33			    \n\t"
+-	"addi		%6, %6, 32			    \n\t"
+-	"xvmaddadp	41, 51, 33			    \n\t"
++       "xvmaddadp 	36, 40, 32	\n\t"
++       "xvmaddadp 	37, 41, 32	\n\t"
+ 
+-	"lxvd2x		50, 0, %7			    \n\t"	// a1[0], a1[1] 
+-	"lxvd2x		51,%4, %7			    \n\t"	// a1[2], a1[3] 
++       "lxvd2x		40, 0, %3	\n\t"	// a0[0], a0[1]
++       "lxvd2x		41, %10, %3	\n\t"	// a0[2], a0[3]
+ 
+-	"xvmaddadp	40, 52, 34			    \n\t"
+-	"addi		%7, %7, 32			    \n\t"
+-	"xvmaddadp	41, 53, 34			    \n\t"
++       "xvmaddadp 	36, 42, 33	\n\t"
++       "addi		%3, %3, 32	\n\t"
++       "xvmaddadp 	37, 43, 33	\n\t"
+ 
+-	"lxvd2x		52, 0, %8			    \n\t"	// a2[0], a2[1] 
+-	"lxvd2x		53,%4, %8			    \n\t"	// a2[2], a2[3] 
++       "lxvd2x		42, 0, %4	\n\t"	// a1[0], a1[1]
++       "lxvd2x		43, %10, %4	\n\t"	// a1[2], a1[3]
+ 
+-	"xvmaddadp	40, 54, 35			    \n\t"
+-	"addi		%8, %8, 32			    \n\t"
+-	"xvmaddadp	41, 55, 35			    \n\t"
++       "xvmaddadp 	36, 44, 34	\n\t"
++       "addi		%4, %4, 32	\n\t"
++       "xvmaddadp 	37, 45, 34	\n\t"
+ 
+-	"stxvd2x	40, 0, %2			    \n\t"	// y0, y1
+-	"stxvd2x	41,%4, %2			    \n\t"	// y2, y3
++       "lxvd2x		44, 0, %5	\n\t"	// a2[0], a2[1]
++       "lxvd2x		45, %10, %5	\n\t"	// a2[2], a2[3]
+ 
+-	"lxvd2x		54, 0, %9			    \n\t"	// a3[0], a3[1] 
+-	"lxvd2x		55,%4, %9			    \n\t"	// a3[2], a3[3] 
++       "xvmaddadp 	36, 46, 35	\n\t"
++       "addi		%5, %5, 32	\n\t"
++       "xvmaddadp 	37, 47, 35	\n\t"
+ 
+-	"addi		%9, %9, 32			    \n\t"
+-	"addi		%2, %2, 32			    \n\t"
++       "stxvd2x		36, 0, %2	\n\t"	// y0, y1
++       "stxvd2x		37, %10, %2	\n\t"	// y2, y3
+ 
+-	"addic.		%0 , %0	, -4  	 	             \n\t"
+-	"ble		2f		             	     \n\t"
++       "lxvd2x		46, 0, %6	\n\t"	// a3[0], a3[1]
++       "lxvd2x		47, %10, %6	\n\t"	// a3[2], a3[3]
+ 
++       "addi		%6, %6, 32	\n\t"
++       "addi		%2, %2, 32	\n\t"
+ 
+-	"lxvd2x		40, 0, %2			    \n\t"	// y0, y1
+-	"lxvd2x		41,%4, %2			    \n\t"	// y2, y3
+-	
+-	"xvmaddadp	40, 48, 32			    \n\t"
+-	"xvmaddadp	41, 49, 32			    \n\t"
++       "addic.		%1, %1, -4	\n\t"
++       "ble		2f		\n\t"
+ 
+-	"lxvd2x		48, 0, %6			    \n\t"	// a0[0], a0[1] 
+-	"lxvd2x		49,%4, %6			    \n\t"	// a0[2], a0[3] 
+ 
+-	"xvmaddadp	40, 50, 33			    \n\t"
+-	"addi		%6, %6, 32			    \n\t"
+-	"xvmaddadp	41, 51, 33			    \n\t"
++       "lxvd2x		36, 0, %2	\n\t"	// y0, y1
++       "lxvd2x		37, %10, %2	\n\t"	// y2, y3
+ 
+-	"lxvd2x		50, 0, %7			    \n\t"	// a1[0], a1[1] 
+-	"lxvd2x		51,%4, %7			    \n\t"	// a1[2], a1[3] 
++       "xvmaddadp 	36, 40, 32	\n\t"
++       "xvmaddadp 	37, 41, 32	\n\t"
+ 
+-	"xvmaddadp	40, 52, 34			    \n\t"
+-	"addi		%7, %7, 32			    \n\t"
+-	"xvmaddadp	41, 53, 34			    \n\t"
++       "lxvd2x		40, 0, %3	\n\t"	// a0[0], a0[1]
++       "lxvd2x		41, %10, %3	\n\t"	// a0[2], a0[3]
+ 
+-	"lxvd2x		52, 0, %8			    \n\t"	// a2[0], a2[1] 
+-	"lxvd2x		53,%4, %8			    \n\t"	// a2[2], a2[3] 
++       "xvmaddadp 	36, 42, 33	\n\t"
++       "addi		%3, %3, 32	\n\t"
++       "xvmaddadp 	37, 43, 33	\n\t"
+ 
+-	"xvmaddadp	40, 54, 35			    \n\t"
+-	"addi		%8, %8, 32			    \n\t"
+-	"xvmaddadp	41, 55, 35			    \n\t"
++       "lxvd2x		42, 0, %4	\n\t"	// a1[0], a1[1]
++       "lxvd2x		43, %10, %4	\n\t"	// a1[2], a1[3]
+ 
+-	"stxvd2x	40, 0, %2			    \n\t"	// y0, y1
+-	"stxvd2x	41,%4, %2			    \n\t"	// y2, y3
++       "xvmaddadp 	36, 44, 34	\n\t"
++       "addi		%4, %4, 32	\n\t"
++       "xvmaddadp 	37, 45, 34	\n\t"
+ 
+-	"lxvd2x		54, 0, %9			    \n\t"	// a3[0], a3[1] 
+-	"lxvd2x		55,%4, %9			    \n\t"	// a3[2], a3[3] 
++       "lxvd2x		44, 0, %5	\n\t"	// a2[0], a2[1]
++       "lxvd2x		45, %10, %5	\n\t"	// a2[2], a2[3]
+ 
+-	"addi		%9, %9, 32			    \n\t"
+-	"addi		%2, %2, 32			    \n\t"
++       "xvmaddadp 	36, 46, 35	\n\t"
++       "addi		%5, %5, 32	\n\t"
++       "xvmaddadp 	37, 47, 35	\n\t"
+ 
+-	"addic.		%0 , %0	, -4  	 	             \n\t"
+-	"bgt		1b		             	     \n\t"
++       "stxvd2x		36, 0, %2	\n\t"	// y0, y1
++       "stxvd2x		37, %10, %2	\n\t"	// y2, y3
+ 
+-	"2:						     \n\t"
++       "lxvd2x		46, 0, %6	\n\t"	// a3[0], a3[1]
++       "lxvd2x		47, %10, %6	\n\t"	// a3[2], a3[3]
+ 
+-	"lxvd2x		40, 0, %2			    \n\t"	// y0, y1
+-	"lxvd2x		41,%4, %2			    \n\t"	// y2, y3
++       "addi		%6, %6, 32	\n\t"
++       "addi		%2, %2, 32	\n\t"
+ 
+-	"xvmaddadp	40, 48, 32			    \n\t"
+-	"xvmaddadp	41, 49, 32			    \n\t"
++       "addic.		%1, %1, -4	\n\t"
++       "bgt		1b		\n"
+ 
+-	"xvmaddadp	40, 50, 33			    \n\t"
+-	"xvmaddadp	41, 51, 33			    \n\t"
++     "2:				\n\t"
+ 
+-	"xvmaddadp	40, 52, 34			    \n\t"
+-	"xvmaddadp	41, 53, 34			    \n\t"
++       "lxvd2x		36, 0, %2	\n\t"	// y0, y1
++       "lxvd2x		37, %10, %2	\n\t"	// y2, y3
+ 
+-	"xvmaddadp	40, 54, 35			    \n\t"
+-	"xvmaddadp	41, 55, 35			    \n\t"
++       "xvmaddadp 	36, 40, 32	\n\t"
++       "xvmaddadp 	37, 41, 32	\n\t"
+ 
+-	"stxvd2x	40, 0, %2			    \n\t"	// y0, y1
+-	"stxvd2x	41,%4, %2			    \n\t"	// y2, y3
++       "xvmaddadp 	36, 42, 33	\n\t"
++       "xvmaddadp 	37, 43, 33	\n\t"
+ 
+-	:
+-        : 
+-          "r" (i),	// 0	
+-          "r" (x),      // 1
+-          "r" (y1),     // 2
+-	  "r" (o8),	// 3
+-	  "r" (o16),	// 4
+-	  "r" (o24),	// 5
+-	  "r" (a0),	// 6
+-	  "r" (a1),	// 7
+-	  "r" (a2),	// 8
+-	  "r" (a3),	// 9
+-	  "r" (pre)	// 10
+-	: "cr0", "%0", "%2" , "%6", "%7", "%8", "%9", "memory"
+-	);
++       "xvmaddadp 	36, 44, 34	\n\t"
++       "xvmaddadp 	37, 45, 34	\n\t"
+ 
+-} 
++       "xvmaddadp 	36, 46, 35	\n\t"
++       "xvmaddadp 	37, 47, 35	\n\t"
+ 
++       "stxvd2x		36, 0, %2	\n\t"	// y0, y1
++       "stxvd2x		37, %10, %2	\n"	// y2, y3
+ 
++     "#n=%1 ap=%11 lda=%12 x=%7=%9 y=%0=%2 alpha=%8 o16=%10\n"
++     "#a0=%3 a1=%4 a2=%5 a3=%6"
++     :
++       "=m" (*y),
++       "+r" (n),	// 1
++       "+b" (y),	// 2
++       "=b" (a0),	// 3
++       "=b" (a1),	// 4
++       "=&b" (a2),	// 5
++       "=&b" (a3)	// 6
++     :
++       "m" (*x),
++       "d" (alpha),	// 8
++       "r" (x),		// 9
++       "b" (16),	// 10
++       "3" (ap),	// 11
++       "4" (lda)	// 12
++     :
++       "cr0",
++       "vs32","vs33","vs34","vs35","vs36","vs37",
++       "vs40","vs41","vs42","vs43","vs44","vs45","vs46","vs47"
++     );
++}
+diff --git a/kernel/power/drot.c b/kernel/power/drot.c
+index c93f69b..3e10748 100644
+--- a/kernel/power/drot.c
++++ b/kernel/power/drot.c
+@@ -46,7 +46,7 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+ #ifndef HAVE_KERNEL_16
+ 
+-static void drot_kernel_16(BLASLONG n, FLOAT *x, FLOAT *y, FLOAT *c, FLOAT *s)
++static void drot_kernel_16(BLASLONG n, FLOAT *x, FLOAT *y, FLOAT c, FLOAT s)
+ {
+ 
+ 	BLASLONG i=0;
+@@ -56,8 +56,6 @@ static void drot_kernel_16(BLASLONG n, FLOAT *x, FLOAT *y, FLOAT *c, FLOAT *s)
+ 	FLOAT y00, y01, y02, y03;
+ 	FLOAT *x1=x;
+ 	FLOAT *y1=y;
+-	FLOAT c1=*c;
+-	FLOAT s1=*s;
+ 
+ 	while ( i<n )
+ 	{
+@@ -71,14 +69,14 @@ static void drot_kernel_16(BLASLONG n, FLOAT *x, FLOAT *y, FLOAT *c, FLOAT *s)
+ 		x03 = x1[3];
+ 		y03 = y1[3];
+ 
+-		f0 = c1*x00 + s1*y00;
+-		g0 = c1*y00 - s1*x00;
+-		f1 = c1*x01 + s1*y01;
+-		g1 = c1*y01 - s1*x01;
+-		f2 = c1*x02 + s1*y02;
+-		g2 = c1*y02 - s1*x02;
+-		f3 = c1*x03 + s1*y03;
+-		g3 = c1*y03 - s1*x03;
++		f0 = c*x00 + s*y00;
++		g0 = c*y00 - s*x00;
++		f1 = c*x01 + s*y01;
++		g1 = c*y01 - s*x01;
++		f2 = c*x02 + s*y02;
++		g2 = c*y02 - s*x02;
++		f3 = c*x03 + s*y03;
++		g3 = c*y03 - s*x03;
+ 
+ 		x1[0] = f0;
+ 		y1[0] = g0;
+@@ -106,8 +104,6 @@ int CNAME(BLASLONG n, FLOAT *x, BLASLONG inc_x, FLOAT *y, BLASLONG inc_y, FLOAT
+ {
+ 	BLASLONG i=0;
+ 	BLASLONG ix=0,iy=0;
+-	FLOAT c1[4] __attribute__ ((aligned (16)));;
+-	FLOAT s1[4] __attribute__ ((aligned (16)));;
+ 	FLOAT *x1=x;
+ 	FLOAT *y1=y;
+ 	FLOAT temp;
+@@ -120,15 +116,7 @@ int CNAME(BLASLONG n, FLOAT *x, BLASLONG inc_x, FLOAT *y, BLASLONG inc_y, FLOAT
+ 		BLASLONG n1 = n & -16;
+ 		if ( n1 > 0 )
+ 		{
+-			c1[0]=c;
+-			c1[1]=c;
+-			c1[2]=c;
+-			c1[3]=c;
+-			s1[0]=s;
+-			s1[1]=s;
+-			s1[2]=s;
+-			s1[3]=s;
+-			drot_kernel_16(n1, x1, y1, c1, s1);
++			drot_kernel_16(n1, x1, y1, c, s);
+ 			i=n1;
+ 		}
+ 
+diff --git a/kernel/power/drot_microk_power8.c b/kernel/power/drot_microk_power8.c
+index 4444ac7..016b776 100644
+--- a/kernel/power/drot_microk_power8.c
++++ b/kernel/power/drot_microk_power8.c
+@@ -38,174 +38,176 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+ #define HAVE_KERNEL_16 1
+ 
+-static void drot_kernel_16( BLASLONG n, FLOAT *x, FLOAT *y, FLOAT *c, FLOAT *s) __attribute__ ((noinline));
+-
+-static void drot_kernel_16( BLASLONG n, FLOAT *x, FLOAT *y, FLOAT *c, FLOAT *s)
++static void drot_kernel_16 (long n, double *x, double *y, double c, double s)
+ {
++  __vector double t0;
++  __vector double t1;
++  __vector double t2;
++  __vector double t3;
++  __vector double t4;
++  __vector double t5;
++  __vector double t6;
++  __vector double t7;
+ 
++  __asm__
++    (
++       "xxspltd		36, %x13, 0	\n\t"	// load c to both dwords
++       "xxspltd		37, %x14, 0	\n\t"	// load s to both dwords
+ 
+-	BLASLONG i = n;
+-	BLASLONG o16 = 16;
+-	BLASLONG o32 = 32;
+-	BLASLONG o48 = 48;
+-	FLOAT *x1=x;
+-	FLOAT *y1=y;
+-	FLOAT *x2=x+1;
+-	FLOAT *y2=y+1;
+-
+-	__asm__  __volatile__
+-	(
+-
+-        "lxsdx          36 , %5, %3                          \n\t"	// load c
+-        "lxsdx          37 , %5, %4                          \n\t"	// load s
+-	"addi		%8 , %8, -8			     \n\t"
+-	"addi		%9 , %9, -8			     \n\t"
+-
+-        "xxspltd        36 , 36, 0                           \n\t"
+-        "xxspltd        37 , 37, 0                           \n\t"
+-
+-	"lxvd2x		32, 0, %1			    \n\t"	// load x
+-	"lxvd2x		33, %5, %1			    \n\t"
+-	"lxvd2x		34, %6, %1			    \n\t"
+-	"lxvd2x		35, %7, %1			    \n\t"
+-
+-	"lxvd2x		40, 0, %2			    \n\t"	// load y
+-	"lxvd2x		41, %5, %2			    \n\t"
+-	"lxvd2x		42, %6, %2			    \n\t"
+-	"lxvd2x		43, %7, %2			    \n\t"
+-
+-	"addi		%1, %1, 64			    \n\t"
+-	"addi		%2, %2, 64			    \n\t"
+-
+-	"addic.		%0 , %0	, -8  	 	             \n\t"
+-	"ble		2f		             	     \n\t"
+-
+-	".align 5				            \n\t"
+-	"1:				                    \n\t"
+-
+-	"xvmuldp	48, 32, 36		    	    \n\t"	// c * x
+-	"xvmuldp	49, 33, 36		    	    \n\t"
+-	"xvmuldp	50, 34, 36		    	    \n\t"
+-	"xvmuldp	51, 35, 36		    	    \n\t"
+-
+-	"xvmuldp	56, 40, 36		    	    \n\t"	// c * y
+-	"xvmuldp	57, 41, 36		    	    \n\t"
+-	"xvmuldp	58, 42, 36		    	    \n\t"
+-	"xvmuldp	59, 43, 36		    	    \n\t"
+-
+-	"xvmuldp	52, 32, 37		    	    \n\t"	// s * x
+-	"xvmuldp	53, 33, 37		    	    \n\t"
+-
+-	"lxvd2x		32, 0, %1			    \n\t"	// load x
+-	"lxvd2x		33, %5, %1			    \n\t"
+-
+-	"xvmuldp	54, 34, 37		    	    \n\t"
+-	"xvmuldp	55, 35, 37		    	    \n\t"
+-
+-	"lxvd2x		34, %6, %1			    \n\t"
+-	"lxvd2x		35, %7, %1			    \n\t"
+-
+-	"xvmuldp	60, 40, 37		    	    \n\t"	// s * y
+-	"xvmuldp	61, 41, 37		    	    \n\t"
+-
+-	"lxvd2x		40, 0, %2			    \n\t"	// load y
+-	"lxvd2x		41, %5, %2			    \n\t"
+-
+-	"xvmuldp	62, 42, 37		    	    \n\t"
+-	"xvmuldp	63, 43, 37		    	    \n\t"
+-
+-	"lxvd2x		42, %6, %2			    \n\t"
+-	"lxvd2x		43, %7, %2			    \n\t"
+-
+-	"xvadddp	48, 48 , 60			    \n\t"	// c * x + s * y 
+-	"xvadddp	49, 49 , 61			    \n\t"	// c * x + s * y 
+-
+-	"addi		%1, %1, 64			    \n\t"
+-	"addi		%2, %2, 64			    \n\t"
+-
+-	"xvadddp	50, 50 , 62			    \n\t"	// c * x + s * y 
+-	"xvadddp	51, 51 , 63			    \n\t"	// c * x + s * y 
+-
+-	"xvsubdp	56, 56 , 52			    \n\t"	// c * y - s * x
+-	"xvsubdp	57, 57 , 53			    \n\t"	// c * y - s * x
+-	"xvsubdp	58, 58 , 54			    \n\t"	// c * y - s * x
+-	"xvsubdp	59, 59 , 55			    \n\t"	// c * y - s * x
+-
+-	"stxvd2x	48, 0, %8			    \n\t"	// store x
+-	"stxvd2x	49, %5, %8			    \n\t"
+-	"stxvd2x	50, %6, %8			    \n\t"
+-	"stxvd2x	51, %7, %8			    \n\t"
+-
+-	"stxvd2x	56, 0, %9			    \n\t"	// store y
+-	"stxvd2x	57, %5, %9			    \n\t"
+-	"stxvd2x	58, %6, %9			    \n\t"
+-	"stxvd2x	59, %7, %9			    \n\t"
+-
+-	"addi		%8, %8, 64			    \n\t"
+-	"addi		%9, %9, 64			    \n\t"
+-
+-	"addic.		%0 , %0	, -8  	 	             \n\t"
+-	"bgt		1b		             	     \n\t"
+-
+-	"2:						     \n\t"
+-
+-	"xvmuldp	48, 32, 36		    	    \n\t"	// c * x
+-	"xvmuldp	49, 33, 36		    	    \n\t"
+-	"xvmuldp	50, 34, 36		    	    \n\t"
+-	"xvmuldp	51, 35, 36		    	    \n\t"
+-
+-	"xvmuldp	56, 40, 36		    	    \n\t"	// c * y
+-	"xvmuldp	57, 41, 36		    	    \n\t"
+-	"xvmuldp	58, 42, 36		    	    \n\t"
+-	"xvmuldp	59, 43, 36		    	    \n\t"
+-
+-	"xvmuldp	52, 32, 37		    	    \n\t"	// s * x
+-	"xvmuldp	53, 33, 37		    	    \n\t"
+-	"xvmuldp	54, 34, 37		    	    \n\t"
+-	"xvmuldp	55, 35, 37		    	    \n\t"
+-
+-	"xvmuldp	60, 40, 37		    	    \n\t"	// s * y
+-	"xvmuldp	61, 41, 37		    	    \n\t"
+-	"xvmuldp	62, 42, 37		    	    \n\t"
+-	"xvmuldp	63, 43, 37		    	    \n\t"
+-
+-	"xvadddp	48, 48 , 60			    \n\t"	// c * x + s * y 
+-	"xvadddp	49, 49 , 61			    \n\t"	// c * x + s * y 
+-	"xvadddp	50, 50 , 62			    \n\t"	// c * x + s * y 
+-	"xvadddp	51, 51 , 63			    \n\t"	// c * x + s * y 
+-
+-	"xvsubdp	56, 56 , 52			    \n\t"	// c * y - s * x
+-	"xvsubdp	57, 57 , 53			    \n\t"	// c * y - s * x
+-	"xvsubdp	58, 58 , 54			    \n\t"	// c * y - s * x
+-	"xvsubdp	59, 59 , 55			    \n\t"	// c * y - s * x
+-
+-	"stxvd2x	48, 0, %8			    \n\t"	// store x
+-	"stxvd2x	49, %5, %8			    \n\t"
+-	"stxvd2x	50, %6, %8			    \n\t"
+-	"stxvd2x	51, %7, %8			    \n\t"
++       "lxvd2x		32, 0, %3	\n\t"	// load x
++       "lxvd2x		33, %15, %3	\n\t"
++       "lxvd2x		34, %16, %3	\n\t"
++       "lxvd2x		35, %17, %3	\n\t"
+ 
+-	"stxvd2x	56, 0, %9			    \n\t"	// store y
+-	"stxvd2x	57, %5, %9			    \n\t"
+-	"stxvd2x	58, %6, %9			    \n\t"
+-	"stxvd2x	59, %7, %9			    \n\t"
++       "lxvd2x		48, 0, %4	\n\t"	// load y
++       "lxvd2x		49, %15, %4	\n\t"
++       "lxvd2x		50, %16, %4	\n\t"
++       "lxvd2x		51, %17, %4	\n\t"
+ 
++       "addi		%3, %3, 64	\n\t"
++       "addi		%4, %4, 64	\n\t"
+ 
++       "addic.		%2, %2, -8	\n\t"
++       "ble		2f		\n\t"
+ 
+-	:
+-        : 
+-          "r" (i),	// 0	
+-	  "r" (x1),  	// 1
+-          "r" (y1),     // 2
+-          "r" (c),      // 3
+-          "r" (s),      // 4
+-	  "r" (o16),	// 5
+-	  "r" (o32),	// 6
+-	  "r" (o48),    // 7
+-	  "r" (x2),     // 8
+-	  "r" (y2)      // 9
+-	: "cr0", "%0", "%1" , "%2", "%8", "%9", "memory"
+-	);
++       ".p2align	5		\n"
++     "1:				\n\t"
+ 
+-} 
++       "xvmuldp		40, 32, 36	\n\t"	// c * x
++       "xvmuldp		41, 33, 36	\n\t"
++       "xvmuldp		42, 34, 36	\n\t"
++       "xvmuldp		43, 35, 36	\n\t"
+ 
++       "xvmuldp		%x5, 48, 36	\n\t"	// c * y
++       "xvmuldp		%x6, 49, 36	\n\t"
++       "xvmuldp		%x7, 50, 36	\n\t"
++       "xvmuldp		%x8, 51, 36	\n\t"
+ 
++       "xvmuldp		44, 32, 37	\n\t"	// s * x
++       "xvmuldp		45, 33, 37	\n\t"
++
++       "lxvd2x		32, 0, %3	\n\t"	// load x
++       "lxvd2x		33, %15, %3	\n\t"
++
++       "xvmuldp		46, 34, 37	\n\t"
++       "xvmuldp		47, 35, 37	\n\t"
++
++       "lxvd2x		34, %16, %3	\n\t"
++       "lxvd2x		35, %17, %3	\n\t"
++
++       "xvmuldp		%x9, 48, 37	\n\t"	// s * y
++       "xvmuldp		%x10, 49, 37	\n\t"
++
++       "lxvd2x		48, 0, %4	\n\t"	// load y
++       "lxvd2x		49, %15, %4	\n\t"
++
++       "xvmuldp		%x11, 50, 37	\n\t"
++       "xvmuldp		%x12, 51, 37	\n\t"
++
++       "lxvd2x		50, %16, %4	\n\t"
++       "lxvd2x		51, %17, %4	\n\t"
++
++       "xvadddp		40, 40, %x9	\n\t"	// c * x + s * y
++       "xvadddp		41, 41, %x10	\n\t"	// c * x + s * y
++
++       "addi		%3, %3, -64	\n\t"
++       "addi		%4, %4, -64	\n\t"
++
++       "xvadddp		42, 42, %x11	\n\t"	// c * x + s * y
++       "xvadddp		43, 43, %x12	\n\t"	// c * x + s * y
++
++       "xvsubdp		%x5, %x5, 44	\n\t"	// c * y - s * x
++       "xvsubdp		%x6, %x6, 45	\n\t"	// c * y - s * x
++       "xvsubdp		%x7, %x7, 46	\n\t"	// c * y - s * x
++       "xvsubdp		%x8, %x8, 47	\n\t"	// c * y - s * x
++
++       "stxvd2x		40, 0, %3	\n\t"	// store x
++       "stxvd2x		41, %15, %3	\n\t"
++       "stxvd2x		42, %16, %3	\n\t"
++       "stxvd2x		43, %17, %3	\n\t"
++
++       "stxvd2x		%x5, 0, %4	\n\t"	// store y
++       "stxvd2x		%x6, %15, %4	\n\t"
++       "stxvd2x		%x7, %16, %4	\n\t"
++       "stxvd2x		%x8, %17, %4	\n\t"
++
++       "addi		%3, %3, 128	\n\t"
++       "addi		%4, %4, 128	\n\t"
++
++       "addic.		%2, %2, -8	\n\t"
++       "bgt		1b		\n"
++
++     "2:				\n\t"
++
++       "xvmuldp		40, 32, 36	\n\t"	// c * x
++       "xvmuldp		41, 33, 36	\n\t"
++       "xvmuldp		42, 34, 36	\n\t"
++       "xvmuldp		43, 35, 36	\n\t"
++
++       "xvmuldp		%x5, 48, 36	\n\t"	// c * y
++       "xvmuldp		%x6, 49, 36	\n\t"
++       "xvmuldp		%x7, 50, 36	\n\t"
++       "xvmuldp		%x8, 51, 36	\n\t"
++
++       "xvmuldp		44, 32, 37	\n\t"	// s * x
++       "xvmuldp		45, 33, 37	\n\t"
++       "xvmuldp		46, 34, 37	\n\t"
++       "xvmuldp		47, 35, 37	\n\t"
++
++       "xvmuldp		%x9, 48, 37	\n\t"	// s * y
++       "xvmuldp		%x10, 49, 37	\n\t"
++       "xvmuldp		%x11, 50, 37	\n\t"
++       "xvmuldp		%x12, 51, 37	\n\t"
++
++       "addi		%3, %3, -64	\n\t"
++       "addi		%4, %4, -64	\n\t"
++
++       "xvadddp		40, 40, %x9	\n\t"	// c * x + s * y
++       "xvadddp		41, 41, %x10	\n\t"	// c * x + s * y
++       "xvadddp		42, 42, %x11	\n\t"	// c * x + s * y
++       "xvadddp		43, 43, %x12	\n\t"	// c * x + s * y
++
++       "xvsubdp		%x5, %x5, 44	\n\t"	// c * y - s * x
++       "xvsubdp		%x6, %x6, 45	\n\t"	// c * y - s * x
++       "xvsubdp		%x7, %x7, 46	\n\t"	// c * y - s * x
++       "xvsubdp		%x8, %x8, 47	\n\t"	// c * y - s * x
++
++       "stxvd2x		40, 0, %3	\n\t"	// store x
++       "stxvd2x		41, %15, %3	\n\t"
++       "stxvd2x		42, %16, %3	\n\t"
++       "stxvd2x		43, %17, %3	\n\t"
++
++       "stxvd2x		%x5, 0, %4	\n\t"	// store y
++       "stxvd2x		%x6, %15, %4	\n\t"
++       "stxvd2x		%x7, %16, %4	\n\t"
++       "stxvd2x		%x8, %17, %4	\n"
++
++     "#n=%2 x=%0=%3 y=%1=%4 c=%13 s=%14 o16=%15 o32=%16 o48=%17\n"
++     "#t0=%x5 t1=%x6 t2=%x7 t3=%x8 t4=%x9 t5=%x10 t6=%x11 t7=%x12"
++     :
++       "+m" (*x),
++       "+m" (*y),
++       "+r" (n),	// 2
++       "+b" (x),	// 3
++       "+b" (y),	// 4
++       "=wa" (t0),	// 5
++       "=wa" (t1),	// 6
++       "=wa" (t2),	// 7
++       "=wa" (t3),	// 8
++       "=wa" (t4),	// 9
++       "=wa" (t5),	// 10
++       "=wa" (t6),	// 11
++       "=wa" (t7)	// 12
++     :
++       "d" (c),		// 13
++       "d" (s),		// 14
++       "b" (16),	// 15
++       "b" (32),	// 16
++       "b" (48)		// 17
++     :
++       "cr0",
++       "vs32","vs33","vs34","vs35","vs36","vs37",
++       "vs40","vs41","vs42","vs43","vs44","vs45","vs46","vs47",
++       "vs48","vs49","vs50","vs51"
++     );
++}
+diff --git a/kernel/power/dscal.c b/kernel/power/dscal.c
+index c62a563..f32dc4b 100644
+--- a/kernel/power/dscal.c
++++ b/kernel/power/dscal.c
+@@ -41,11 +41,10 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+ #if !defined(HAVE_KERNEL_8)
+ 
+-static void dscal_kernel_8( BLASLONG n, FLOAT *da , FLOAT *x )
++static void dscal_kernel_8 (BLASLONG n, FLOAT *x, FLOAT alpha)
+ {
+ 
+         BLASLONG i;
+-        FLOAT alpha = *da;
+ 
+         for( i=0; i<n; i+=8 )
+         {
+@@ -62,7 +61,7 @@ static void dscal_kernel_8( BLASLONG n, FLOAT *da , FLOAT *x )
+ 
+ }
+ 
+-static void dscal_kernel_8_zero( BLASLONG n, FLOAT *da , FLOAT *x )
++static void dscal_kernel_8_zero (BLASLONG n, FLOAT *x)
+ {
+ 
+         BLASLONG i;
+@@ -102,10 +101,7 @@ int CNAME(BLASLONG n, BLASLONG dummy0, BLASLONG dummy1, FLOAT da, FLOAT *x, BLAS
+ 			BLASLONG n1 = n & -16;
+ 			if ( n1 > 0 )
+ 			{
+-				FLOAT alpha[2];
+-				alpha[0]=da;
+-				alpha[1]=da;
+-				dscal_kernel_8_zero(n1 , alpha , x);
++				dscal_kernel_8_zero(n1, x);
+ 				j=n1;
+ 			}
+ 
+@@ -123,10 +119,7 @@ int CNAME(BLASLONG n, BLASLONG dummy0, BLASLONG dummy1, FLOAT da, FLOAT *x, BLAS
+ 			BLASLONG n1 = n & -16;
+ 			if ( n1 > 0 )
+ 			{
+-				FLOAT alpha[2];
+-				alpha[0]=da;
+-				alpha[1]=da;
+-				dscal_kernel_8(n1 , alpha , x);
++				dscal_kernel_8(n1, x, da);
+ 				j=n1;
+ 			}
+ 			while(j < n)
+diff --git a/kernel/power/dscal_microk_power8.c b/kernel/power/dscal_microk_power8.c
+index d90c3d8..04898eb 100644
+--- a/kernel/power/dscal_microk_power8.c
++++ b/kernel/power/dscal_microk_power8.c
+@@ -35,185 +35,149 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+ #define HAVE_KERNEL_8 1
+ 
+-static void dscal_kernel_8( BLASLONG n, FLOAT *alpha, FLOAT *x) __attribute__ ((noinline));
+-
+-static void dscal_kernel_8( BLASLONG n, FLOAT *alpha, FLOAT *x)
++static void dscal_kernel_8 (long n, double *x, double alpha)
+ {
+-
+-
+-	BLASLONG i = n;
+-	BLASLONG o16 = 16;
+-	BLASLONG o32 = 32;
+-	BLASLONG o48 = 48;
+-	BLASLONG o64 = 64;
+-	BLASLONG o80 = 80;
+-	BLASLONG o96 = 96;
+-	BLASLONG o112 = 112;
+-	FLOAT *x1=x;
+-	FLOAT *x2=x+1;
+-	BLASLONG pre = 384;
+-
+-	__asm__  __volatile__
+-	(
+-
+-        "lxsdx          33, 0, %3                           \n\t"
+-        "xxspltd        32, 33, 0                           \n\t"
+-        "addi           %1, %1, -8                          \n\t"
+-
+-	"dcbt		%2, %4				    \n\t"
+-
+-	"lxvd2x		40, 0, %2			    \n\t"
+-	"lxvd2x		41, %5, %2			    \n\t"
+-	"lxvd2x		42, %6, %2			    \n\t"
+-	"lxvd2x		43, %7, %2			    \n\t"
+-	"lxvd2x		44, %8, %2			    \n\t"
+-	"lxvd2x		45, %9, %2			    \n\t"
+-	"lxvd2x		46, %10, %2			    \n\t"
+-	"lxvd2x		47, %11, %2			    \n\t"
+-
+-	"addi		%2, %2, 128			    \n\t"
+-
+-	"addic.		%0 , %0	, -16  	 	             \n\t"
+-	"ble		2f		             	     \n\t"
+-
+-	".align 5				            \n\t"
+-	"1:				                    \n\t"
+-
+-	"dcbt		%2, %4				    \n\t"
+-
+-	"xvmuldp	48, 40, 32		    	    \n\t"
+-	"xvmuldp	49, 41, 32		    	    \n\t"
+-	"lxvd2x		40, 0, %2			    \n\t"
+-	"lxvd2x		41, %5, %2			    \n\t"
+-	"xvmuldp	50, 42, 32		    	    \n\t"
+-	"xvmuldp	51, 43, 32		    	    \n\t"
+-	"lxvd2x		42, %6, %2			    \n\t"
+-	"lxvd2x		43, %7, %2			    \n\t"
+-	"xvmuldp	52, 44, 32		    	    \n\t"
+-	"xvmuldp	53, 45, 32		    	    \n\t"
+-	"lxvd2x		44, %8, %2			    \n\t"
+-	"lxvd2x		45, %9, %2			    \n\t"
+-	"xvmuldp	54, 46, 32		    	    \n\t"
+-	"xvmuldp	55, 47, 32		    	    \n\t"
+-	"lxvd2x		46, %10, %2			    \n\t"
+-	"lxvd2x		47, %11, %2			    \n\t"
+-
+-	"stxvd2x	48, 0, %1			    \n\t"
+-	"stxvd2x	49, %5, %1			    \n\t"
+-	"stxvd2x	50, %6, %1			    \n\t"
+-	"stxvd2x	51, %7, %1			    \n\t"
+-	"stxvd2x	52, %8, %1			    \n\t"
+-	"stxvd2x	53, %9, %1			    \n\t"
+-	"stxvd2x	54, %10, %1			    \n\t"
+-	"stxvd2x	55, %11, %1			    \n\t"
+-
+-	"addi		%1, %1, 128			    \n\t"
+-	"addi		%2, %2, 128			    \n\t"
+-
+-	"addic.		%0 , %0	, -16  	 	             \n\t"
+-	"bgt		1b		             	     \n\t"
+-
+-	"2:						     \n\t"
+-
+-	"xvmuldp	48, 40, 32		    	    \n\t"
+-	"xvmuldp	49, 41, 32		    	    \n\t"
+-	"xvmuldp	50, 42, 32		    	    \n\t"
+-	"xvmuldp	51, 43, 32		    	    \n\t"
+-	"xvmuldp	52, 44, 32		    	    \n\t"
+-	"xvmuldp	53, 45, 32		    	    \n\t"
+-	"xvmuldp	54, 46, 32		    	    \n\t"
+-	"xvmuldp	55, 47, 32		    	    \n\t"
+-
+-	"stxvd2x	48, 0, %1			    \n\t"
+-	"stxvd2x	49, %5, %1			    \n\t"
+-	"stxvd2x	50, %6, %1			    \n\t"
+-	"stxvd2x	51, %7, %1			    \n\t"
+-	"stxvd2x	52, %8, %1			    \n\t"
+-	"stxvd2x	53, %9, %1			    \n\t"
+-	"stxvd2x	54, %10, %1			    \n\t"
+-	"stxvd2x	55, %11, %1			    \n\t"
+-
+-	:
+-        : 
+-          "r" (i),	// 0	
+-	  "r" (x2),  	// 1
+-          "r" (x1),     // 2
+-          "r" (alpha),  // 3
+-          "r" (pre),    // 4
+-	  "r" (o16),	// 5
+-	  "r" (o32),	// 6
+-	  "r" (o48),    // 7
+-          "r" (o64),    // 8
+-          "r" (o80),    // 9
+-          "r" (o96),    // 10
+-          "r" (o112)    // 11
+-	: "cr0", "%0", "%2" , "%1", "memory"
+-	);
+-
+-} 
+-
+-
+-static void dscal_kernel_8_zero( BLASLONG n, FLOAT *alpha, FLOAT *x) __attribute__ ((noinline));
+-
+-static void dscal_kernel_8_zero( BLASLONG n, FLOAT *alpha, FLOAT *x)
++  __asm__
++    (
++       "dcbt		0, %2		\n\t"
++
++       "xxspltd		%x3, %x3, 0	\n\t"
++
++       "lxvd2x		32, 0, %2	\n\t"
++       "lxvd2x		33, %4, %2	\n\t"
++       "lxvd2x		34, %5, %2	\n\t"
++       "lxvd2x		35, %6, %2	\n\t"
++       "lxvd2x		36, %7, %2	\n\t"
++       "lxvd2x		37, %8, %2	\n\t"
++       "lxvd2x		38, %9, %2	\n\t"
++       "lxvd2x		39, %10, %2	\n\t"
++
++       "addi		%2, %2, 128	\n\t"
++
++       "addic.		%1, %1, -16	\n\t"
++       "ble		2f		\n\t"
++
++       ".p2align	5		\n"
++     "1:				\n\t"
++
++       "xvmuldp		40, 32, %x3	\n\t"
++       "xvmuldp		41, 33, %x3	\n\t"
++       "lxvd2x		32, 0, %2	\n\t"
++       "lxvd2x		33, %4, %2	\n\t"
++       "xvmuldp		42, 34, %x3	\n\t"
++       "xvmuldp		43, 35, %x3	\n\t"
++       "lxvd2x		34, %5, %2	\n\t"
++       "lxvd2x		35, %6, %2	\n\t"
++       "xvmuldp		44, 36, %x3	\n\t"
++       "xvmuldp		45, 37, %x3	\n\t"
++       "lxvd2x		36, %7, %2	\n\t"
++       "lxvd2x		37, %8, %2	\n\t"
++       "xvmuldp		46, 38, %x3	\n\t"
++       "xvmuldp		47, 39, %x3	\n\t"
++       "lxvd2x		38, %9, %2	\n\t"
++       "lxvd2x		39, %10, %2	\n\t"
++
++       "addi		%2, %2, -128	\n\t"
++
++       "stxvd2x		40, 0, %2	\n\t"
++       "stxvd2x		41, %4, %2	\n\t"
++       "stxvd2x		42, %5, %2	\n\t"
++       "stxvd2x		43, %6, %2	\n\t"
++       "stxvd2x		44, %7, %2	\n\t"
++       "stxvd2x		45, %8, %2	\n\t"
++       "stxvd2x		46, %9, %2	\n\t"
++       "stxvd2x		47, %10, %2	\n\t"
++
++       "addi		%2, %2, 256	\n\t"
++
++       "addic.		%1, %1, -16	\n\t"
++       "bgt		1b		\n"
++
++     "2:				\n\t"
++
++       "xvmuldp		40, 32, %x3	\n\t"
++       "xvmuldp		41, 33, %x3	\n\t"
++       "xvmuldp		42, 34, %x3	\n\t"
++       "xvmuldp		43, 35, %x3	\n\t"
++
++       "addi		%2, %2, -128	\n\t"
++
++       "xvmuldp		44, 36, %x3	\n\t"
++       "xvmuldp		45, 37, %x3	\n\t"
++       "xvmuldp		46, 38, %x3	\n\t"
++       "xvmuldp		47, 39, %x3	\n\t"
++
++       "stxvd2x		40, 0, %2	\n\t"
++       "stxvd2x		41, %4, %2	\n\t"
++       "stxvd2x		42, %5, %2	\n\t"
++       "stxvd2x		43, %6, %2	\n\t"
++       "stxvd2x		44, %7, %2	\n\t"
++       "stxvd2x		45, %8, %2	\n\t"
++       "stxvd2x		46, %9, %2	\n\t"
++       "stxvd2x		47, %10, %2	\n"
++
++     "#n=%1 alpha=%3 x=%0=%2 o16=%4 o32=%5 o48=%6 o64=%7 o80=%8 o96=%9 o112=%10"
++     :
++       "+m" (*x),
++       "+r" (n),	// 1
++       "+b" (x)		// 2
++     :
++       "d" (alpha),	// 3
++       "b" (16),	// 4
++       "b" (32),	// 5
++       "b" (48),	// 6
++       "b" (64),	// 7
++       "b" (80),	// 8
++       "b" (96),	// 9
++       "b" (112)	// 10
++     :
++       "cr0",
++       "vs32","vs33","vs34","vs35","vs36","vs37","vs38","vs39",
++       "vs40","vs41","vs42","vs43","vs44","vs45","vs46","vs47"
++     );
++}
++
++
++static void dscal_kernel_8_zero (long n, double *x)
+ {
+-
+-
+-	BLASLONG i = n;
+-	BLASLONG o16 = 16;
+-	BLASLONG o32 = 32;
+-	BLASLONG o48 = 48;
+-	BLASLONG o64 = 64;
+-	BLASLONG o80 = 80;
+-	BLASLONG o96 = 96;
+-	BLASLONG o112 = 112;
+-	FLOAT *x1=x;
+-	FLOAT *x2=x+1;
+-	BLASLONG pre = 384;
+-
+-	__asm__  __volatile__
+-	(
+-
+-	"xxlxor		32 , 32 , 32			    \n\t"
+-        "addi           %1, %1, -8                          \n\t"
+-
+-
+-	".align 5				            \n\t"
+-	"1:				                    \n\t"
+-
+-	"stxvd2x	32, 0, %1			    \n\t"
+-	"stxvd2x	32, %5, %1			    \n\t"
+-	"stxvd2x	32, %6, %1			    \n\t"
+-	"stxvd2x	32, %7, %1			    \n\t"
+-	"stxvd2x	32, %8, %1			    \n\t"
+-	"stxvd2x	32, %9, %1			    \n\t"
+-	"stxvd2x	32, %10, %1			    \n\t"
+-	"stxvd2x	32, %11, %1			    \n\t"
+-
+-	"addi		%1, %1, 128			    \n\t"
+-
+-	"addic.		%0 , %0	, -16  	 	             \n\t"
+-	"bgt		1b		             	     \n\t"
+-
+-	"2:						     \n\t"
+-
+-	:
+-        : 
+-          "r" (i),	// 0	
+-	  "r" (x2),  	// 1
+-          "r" (x1),     // 2
+-          "r" (alpha),  // 3
+-          "r" (pre),    // 4
+-	  "r" (o16),	// 5
+-	  "r" (o32),	// 6
+-	  "r" (o48),    // 7
+-          "r" (o64),    // 8
+-          "r" (o80),    // 9
+-          "r" (o96),    // 10
+-          "r" (o112)    // 11
+-	: "cr0", "%0", "%2" , "%1", "memory"
+-	);
+-
+-} 
+-
+-
++  __vector double t0;
++
++  __asm__
++    (
++       "xxlxor		%x3, %x3, %x3	\n\t"
++
++       ".p2align	5		\n"
++     "1:				\n\t"
++
++       "stxvd2x		%x3, 0, %2	\n\t"
++       "stxvd2x		%x3, %4, %2	\n\t"
++       "stxvd2x		%x3, %5, %2	\n\t"
++       "stxvd2x		%x3, %6, %2	\n\t"
++       "stxvd2x		%x3, %7, %2	\n\t"
++       "stxvd2x		%x3, %8, %2	\n\t"
++       "stxvd2x		%x3, %9, %2	\n\t"
++       "stxvd2x		%x3, %10, %2	\n\t"
++
++       "addi		%2, %2, 128	\n\t"
++
++       "addic.		%1, %1, -16	\n\t"
++       "bgt		1b		\n"
++
++     "#n=%1 x=%0=%2 t0=%x3 o16=%4 o32=%5 o48=%6 o64=%7 o80=%8 o96=%9 o112=%10"
++     :
++       "=m" (*x),
++       "+r" (n),	// 1
++       "+b" (x),	// 2
++       "=wa" (t0)	// 3
++     :
++       "b" (16),	// 4
++       "b" (32),	// 5
++       "b" (48),	// 6
++       "b" (64),	// 7
++       "b" (80),	// 8
++       "b" (96),	// 9
++       "b" (112)	// 10
++     :
++       "cr0"
++     );
++}
+diff --git a/kernel/power/dswap_microk_power8.c b/kernel/power/dswap_microk_power8.c
+index 77747c3..31eff34 100644
+--- a/kernel/power/dswap_microk_power8.c
++++ b/kernel/power/dswap_microk_power8.c
+@@ -35,146 +35,124 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+ #define HAVE_KERNEL_32 1
+ 
+-static void dswap_kernel_32( BLASLONG n, FLOAT *x, FLOAT *y) __attribute__ ((noinline));
+-
+-static void dswap_kernel_32( BLASLONG n, FLOAT *x, FLOAT *y)
++static void dswap_kernel_32 (long n, double *x, double *y)
+ {
+-
+-
+-	BLASLONG i = n;
+-	BLASLONG o16 = 16;
+-	BLASLONG o32 = 32;
+-	BLASLONG o48 = 48;
+-	BLASLONG o64 = 64;
+-	BLASLONG o80 = 80;
+-	BLASLONG o96 = 96;
+-	BLASLONG o112 = 112;
+-	FLOAT *x1=x;
+-	FLOAT *y1=y;
+-	FLOAT *x2=x+1;
+-	FLOAT *y2=y+1;
+-	BLASLONG pre = 384;
+-	BLASLONG alpha=0;
+-
+-	__asm__  __volatile__
+-	(
+-
+-	"addi		%3, %3, -8			    \n\t"	
+-	"addi		%4, %4, -8			    \n\t"	
+-
+-	".align 5				            \n\t"
+-	"1:				                    \n\t"
+-
+-	"lxvd2x		32, 0, %2			    \n\t"
+-	"lxvd2x		33, %5, %2			    \n\t"
+-	"lxvd2x		34, %6, %2			    \n\t"
+-	"lxvd2x		35, %7, %2			    \n\t"
+-	"lxvd2x		36, %8, %2			    \n\t"
+-	"lxvd2x		37, %9, %2			    \n\t"
+-	"lxvd2x		38, %10, %2			    \n\t"
+-	"lxvd2x		39, %11, %2			    \n\t"
+-
+-	"addi		%2, %2, 128			    \n\t"
+-
+-	"lxvd2x		40, 0, %2			    \n\t"
+-	"lxvd2x		41, %5, %2			    \n\t"
+-	"lxvd2x		42, %6, %2			    \n\t"
+-	"lxvd2x		43, %7, %2			    \n\t"
+-	"lxvd2x		44, %8, %2			    \n\t"
+-	"lxvd2x		45, %9, %2			    \n\t"
+-	"lxvd2x		46, %10, %2			    \n\t"
+-	"lxvd2x		47, %11, %2			    \n\t"
+-
+-	"addi		%2, %2, 128			    \n\t"
+-
+-	"lxvd2x		48, 0, %1			    \n\t"
+-	"lxvd2x		49, %5, %1			    \n\t"
+-	"lxvd2x		50, %6, %1			    \n\t"
+-	"lxvd2x		51, %7, %1			    \n\t"
+-	"lxvd2x		52, %8, %1			    \n\t"
+-	"lxvd2x		53, %9, %1			    \n\t"
+-	"lxvd2x		54, %10, %1			    \n\t"
+-	"lxvd2x		55, %11, %1			    \n\t"
+-
+-	"addi		%1, %1, 128			    \n\t"
+-
+-	"lxvd2x		56, 0, %1			    \n\t"
+-	"lxvd2x		57, %5, %1			    \n\t"
+-	"lxvd2x		58, %6, %1			    \n\t"
+-	"lxvd2x		59, %7, %1			    \n\t"
+-	"lxvd2x		60, %8, %1			    \n\t"
+-	"lxvd2x		61, %9, %1			    \n\t"
+-	"lxvd2x		62, %10, %1			    \n\t"
+-	"lxvd2x		63, %11, %1			    \n\t"
+-
+-	"addi		%1, %1, 128			    \n\t"
+-
+-	"stxvd2x		32, 0, %3			    \n\t"
+-	"stxvd2x		33, %5, %3			    \n\t"
+-	"stxvd2x		34, %6, %3			    \n\t"
+-	"stxvd2x		35, %7, %3			    \n\t"
+-	"stxvd2x		36, %8, %3			    \n\t"
+-	"stxvd2x		37, %9, %3			    \n\t"
+-	"stxvd2x		38, %10, %3			    \n\t"
+-	"stxvd2x		39, %11, %3			    \n\t"
+-
+-	"addi		%3, %3, 128			    \n\t"
+-
+-	"stxvd2x		40, 0, %3			    \n\t"
+-	"stxvd2x		41, %5, %3			    \n\t"
+-	"stxvd2x		42, %6, %3			    \n\t"
+-	"stxvd2x		43, %7, %3			    \n\t"
+-	"stxvd2x		44, %8, %3			    \n\t"
+-	"stxvd2x		45, %9, %3			    \n\t"
+-	"stxvd2x		46, %10, %3			    \n\t"
+-	"stxvd2x		47, %11, %3			    \n\t"
+-
+-	"addi		%3, %3, 128			    \n\t"
+-
+-	"stxvd2x		48, 0, %4			    \n\t"
+-	"stxvd2x		49, %5, %4			    \n\t"
+-	"stxvd2x		50, %6, %4			    \n\t"
+-	"stxvd2x		51, %7, %4			    \n\t"
+-	"stxvd2x		52, %8, %4			    \n\t"
+-	"stxvd2x		53, %9, %4			    \n\t"
+-	"stxvd2x		54, %10, %4			    \n\t"
+-	"stxvd2x		55, %11, %4			    \n\t"
+-
+-	"addi		%4, %4, 128			    \n\t"
+-
+-	"stxvd2x		56, 0, %4			    \n\t"
+-	"stxvd2x		57, %5, %4			    \n\t"
+-	"stxvd2x		58, %6, %4			    \n\t"
+-	"stxvd2x		59, %7, %4			    \n\t"
+-	"stxvd2x		60, %8, %4			    \n\t"
+-	"stxvd2x		61, %9, %4			    \n\t"
+-	"stxvd2x		62, %10, %4			    \n\t"
+-	"stxvd2x		63, %11, %4			    \n\t"
+-
+-	"addi		%4, %4, 128			    \n\t"
+-
+-	"addic.		%0 , %0	, -32  	 	             \n\t"
+-	"bgt		1b		             	     \n\t"
+-
+-	"2:						     \n\t"
+-
+-	:
+-        : 
+-          "r" (i),	// 0	
+-	  "r" (y1),  	// 1
+-          "r" (x1),     // 2
+-          "r" (y2),     // 3
+-          "r" (x2),     // 4
+-	  "r" (o16),	// 5
+-	  "r" (o32),	// 6
+-	  "r" (o48),    // 7
+-          "r" (o64),    // 8
+-          "r" (o80),    // 9
+-          "r" (o96),    // 10
+-          "r" (o112)    // 11
+-	: "cr0", "%0", "%2" , "%1", "%3", "%4", "memory"
+-	);
+-
+-} 
+-
+-
++  __asm__
++    (
++       ".p2align	5		\n"
++     "1:				\n\t"
++
++       "lxvd2x		32, 0, %4	\n\t"
++       "lxvd2x		33, %5, %4	\n\t"
++       "lxvd2x		34, %6, %4	\n\t"
++       "lxvd2x		35, %7, %4	\n\t"
++       "lxvd2x		36, %8, %4	\n\t"
++       "lxvd2x		37, %9, %4	\n\t"
++       "lxvd2x		38, %10, %4	\n\t"
++       "lxvd2x		39, %11, %4	\n\t"
++
++       "addi		%4, %4, 128	\n\t"
++
++       "lxvd2x		40, 0, %4	\n\t"
++       "lxvd2x		41, %5, %4	\n\t"
++       "lxvd2x		42, %6, %4	\n\t"
++       "lxvd2x		43, %7, %4	\n\t"
++       "lxvd2x		44, %8, %4	\n\t"
++       "lxvd2x		45, %9, %4	\n\t"
++       "lxvd2x		46, %10, %4	\n\t"
++       "lxvd2x		47, %11, %4	\n\t"
++
++       "addi		%4, %4, -128	\n\t"
++
++       "lxvd2x		48, 0, %3	\n\t"
++       "lxvd2x		49, %5, %3	\n\t"
++       "lxvd2x		50, %6, %3	\n\t"
++       "lxvd2x		51, %7, %3	\n\t"
++       "lxvd2x		0, %8, %3	\n\t"
++       "lxvd2x		1, %9, %3	\n\t"
++       "lxvd2x		2, %10, %3	\n\t"
++       "lxvd2x		3, %11, %3	\n\t"
++
++       "addi		%3, %3, 128	\n\t"
++
++       "lxvd2x		4, 0, %3	\n\t"
++       "lxvd2x		5, %5, %3	\n\t"
++       "lxvd2x		6, %6, %3	\n\t"
++       "lxvd2x		7, %7, %3	\n\t"
++       "lxvd2x		8, %8, %3	\n\t"
++       "lxvd2x		9, %9, %3	\n\t"
++       "lxvd2x		10, %10, %3	\n\t"
++       "lxvd2x		11, %11, %3	\n\t"
++
++       "addi		%3, %3, -128	\n\t"
++
++       "stxvd2x		32, 0, %3	\n\t"
++       "stxvd2x		33, %5, %3	\n\t"
++       "stxvd2x		34, %6, %3	\n\t"
++       "stxvd2x		35, %7, %3	\n\t"
++       "stxvd2x		36, %8, %3	\n\t"
++       "stxvd2x		37, %9, %3	\n\t"
++       "stxvd2x		38, %10, %3	\n\t"
++       "stxvd2x		39, %11, %3	\n\t"
++
++       "addi		%3, %3, 128	\n\t"
++
++       "stxvd2x		40, 0, %3	\n\t"
++       "stxvd2x		41, %5, %3	\n\t"
++       "stxvd2x		42, %6, %3	\n\t"
++       "stxvd2x		43, %7, %3	\n\t"
++       "stxvd2x		44, %8, %3	\n\t"
++       "stxvd2x		45, %9, %3	\n\t"
++       "stxvd2x		46, %10, %3	\n\t"
++       "stxvd2x		47, %11, %3	\n\t"
++
++       "addi		%3, %3, 128	\n\t"
++
++       "stxvd2x		48, 0, %4	\n\t"
++       "stxvd2x		49, %5, %4	\n\t"
++       "stxvd2x		50, %6, %4	\n\t"
++       "stxvd2x		51, %7, %4	\n\t"
++       "stxvd2x		0, %8, %4	\n\t"
++       "stxvd2x		1, %9, %4	\n\t"
++       "stxvd2x		2, %10, %4	\n\t"
++       "stxvd2x		3, %11, %4	\n\t"
++
++       "addi		%4, %4, 128	\n\t"
++
++       "stxvd2x		4, 0, %4	\n\t"
++       "stxvd2x		5, %5, %4	\n\t"
++       "stxvd2x		6, %6, %4	\n\t"
++       "stxvd2x		7, %7, %4	\n\t"
++       "stxvd2x		8, %8, %4	\n\t"
++       "stxvd2x		9, %9, %4	\n\t"
++       "stxvd2x		10, %10, %4	\n\t"
++       "stxvd2x		11, %11, %4	\n\t"
++
++       "addi		%4, %4, 128	\n\t"
++
++       "addic.		%2, %2, -32	\n\t"
++       "bgt		1b		\n"
++
++     "#n=%2 x=%0=%3 y=%1=%4 o16=%5 o32=%6 o48=%7 o64=%8 o80=%9 o96=%10 o112=%11"
++     :
++       "+m" (*x),
++       "+m" (*y),
++       "+r" (n),	// 2
++       "+b" (x),	// 3
++       "+b" (y)		// 4
++     :
++       "b" (16),	// 5
++       "b" (32),	// 6
++       "b" (48),	// 7
++       "b" (64),	// 8
++       "b" (80),	// 9
++       "b" (96),	// 10
++       "b" (112)	// 11
++     :
++       "cr0",
++       "vs32","vs33","vs34","vs35","vs36","vs37","vs38","vs39",
++       "vs40","vs41","vs42","vs43","vs44","vs45","vs46","vs47",
++       "vs48","vs49","vs50","vs51","vs0","vs1","vs2","vs3",
++       "vs4","vs5","vs6","vs7","vs8","vs9","vs10","vs11"
++     );
++}
+diff --git a/kernel/power/sasum.c b/kernel/power/sasum.c
+index 43311f2..fb10b1d 100644
+--- a/kernel/power/sasum.c
++++ b/kernel/power/sasum.c
+@@ -38,7 +38,7 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+ #if defined(DOUBLE)
+ 
+-#define ABS fabs
++#error supports float only
+ 
+ #else
+ 
+@@ -53,7 +53,7 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+ #ifndef HAVE_KERNEL_32
+ 
+-static void sasum_kernel_32(BLASLONG n, FLOAT *x1, FLOAT *svec)
++static FLOAT sasum_kernel_32(BLASLONG n, FLOAT *x1)
+ {
+ 
+ 	BLASLONG i=0;
+@@ -92,11 +92,7 @@ static void sasum_kernel_32(BLASLONG n, FLOAT *x1, FLOAT *svec)
+ 
+ 	}
+ 
+-	svec[0] = sum0+sum1+sum2+sum3;
+-	svec[1] = 0.0;
+-	svec[2] = 0.0;
+-	svec[3] = 0.0;
+-
++	return sum0+sum1+sum2+sum3;
+ }
+ 
+ #endif
+@@ -105,7 +101,6 @@ FLOAT CNAME(BLASLONG n, FLOAT *x, BLASLONG inc_x)
+ {
+ 	BLASLONG i=0;
+ 	FLOAT sumf = 0.0;
+-	FLOAT svec[4] __attribute__ ((aligned (16)));;
+ 	BLASLONG n1;
+ 
+ 	if (n <= 0 || inc_x <= 0) return(sumf);
+@@ -117,8 +112,7 @@ FLOAT CNAME(BLASLONG n, FLOAT *x, BLASLONG inc_x)
+ 		if ( n1 > 0 )
+ 		{
+ 
+-			sasum_kernel_32(n1, x, svec);
+-			sumf = svec[0] + svec[1]+svec[2]+svec[3];
++			sumf = sasum_kernel_32(n1, x);
+ 			i=n1;
+ 		}
+ 
+diff --git a/kernel/power/sasum_microk_power8.c b/kernel/power/sasum_microk_power8.c
+index 847fffe..25a969d 100644
+--- a/kernel/power/sasum_microk_power8.c
++++ b/kernel/power/sasum_microk_power8.c
+@@ -34,144 +34,145 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ **************************************************************************************/
+ 
+ #define HAVE_KERNEL_32 1
+-static void sasum_kernel_32( BLASLONG n, FLOAT *x, FLOAT *svec) __attribute__ ((noinline));
+ 
+-static void sasum_kernel_32( BLASLONG n, FLOAT *x, FLOAT *svec)
++static float sasum_kernel_32 (long n, float *x)
+ {
+-
+-
+-	BLASLONG i = n;
+-	BLASLONG o16 = 16;
+-	BLASLONG o32 = 32;
+-	BLASLONG o48 = 48;
+-	BLASLONG o64 = 64;
+-	BLASLONG o80 = 80;
+-	BLASLONG o96 = 96;
+-	BLASLONG o112 = 112;
+-	FLOAT *x1=x;
+-	BLASLONG pre = 384;
+-
+-	__asm__  __volatile__
+-	(
+-
+-	"dcbt		%2 , %4				    \n\t"
+-
+-	"xxlxor		32,32,32			    \n\t"
+-	"xxlxor		33,33,33			    \n\t"
+-	"xxlxor		34,34,34			    \n\t"
+-	"xxlxor		35,35,35			    \n\t"
+-	"xxlxor		36,36,36			    \n\t"
+-	"xxlxor		37,37,37			    \n\t"
+-	"xxlxor		38,38,38			    \n\t"
+-	"xxlxor		39,39,39			    \n\t"
+-
+-	"lxvw4x		40, 0, %2			    \n\t"
+-	"lxvw4x		41, %5, %2			    \n\t"
+-	"lxvw4x		42, %6, %2			    \n\t"
+-	"lxvw4x		43, %7, %2			    \n\t"
+-	"lxvw4x		44, %8, %2			    \n\t"
+-	"lxvw4x		45, %9, %2			    \n\t"
+-	"lxvw4x		46, %10, %2			    \n\t"
+-	"lxvw4x		47, %11, %2			    \n\t"
+-
+-	"addi		%2, %2, 128			    \n\t"
+-
+-	"addic.		%0 , %0	, -32  	 	             \n\t"
+-	"ble		2f		             	     \n\t"
+-
+-	".align 5				            \n\t"
+-	"1:				                    \n\t"
+-
+-	"dcbt		%2 , %4				    \n\t"
+-
+-	"xvabssp	48, 40				    \n\t"
+-	"xvabssp	49, 41				    \n\t"
+-	"xvabssp	50, 42				    \n\t"
+-	"xvabssp	51, 43				    \n\t"
+-
+-	"lxvw4x		40, 0, %2			    \n\t"
+-	"lxvw4x		41, %5, %2			    \n\t"
+-
+-	"xvabssp	52, 44				    \n\t"
+-	"xvabssp	53, 45				    \n\t"
+-
+-	"lxvw4x		42, %6, %2			    \n\t"
+-	"lxvw4x		43, %7, %2			    \n\t"
+-
+-	"xvabssp	54, 46				    \n\t"
+-	"xvabssp	55, 47				    \n\t"
+-
+-	"lxvw4x		44, %8, %2			    \n\t"
+-	"lxvw4x		45, %9, %2			    \n\t"
+-
+-	"xvaddsp	32, 32, 48		    \n\t"
+-	"xvaddsp	33, 33, 49		    \n\t"
+-
+-	"lxvw4x		46, %10, %2			    \n\t"
+-	"lxvw4x		47, %11, %2			    \n\t"
+-
+-	"xvaddsp	34, 34, 50		    \n\t"
+-	"xvaddsp	35, 35, 51		    \n\t"
+-	"addi		%2, %2, 128			    \n\t"
+-	"xvaddsp	36, 36, 52		    \n\t"
+-	"xvaddsp	37, 37, 53		    \n\t"
+-	"addic.		%0 , %0	, -32  	 	             \n\t"
+-	"xvaddsp	38, 38, 54		    \n\t"
+-	"xvaddsp	39, 39, 55		    \n\t"
+-
+-	"bgt		1b		             	     \n\t"
+-
+-	"2:						     \n\t"
+-
+-
+-	"xvabssp	48, 40				    \n\t"
+-	"xvabssp	49, 41				    \n\t"
+-	"xvabssp	50, 42				    \n\t"
+-	"xvabssp	51, 43				    \n\t"
+-	"xvabssp	52, 44				    \n\t"
+-	"xvabssp	53, 45				    \n\t"
+-	"xvabssp	54, 46				    \n\t"
+-	"xvabssp	55, 47				    \n\t"
+-
+-	"xvaddsp	32, 32, 48		    \n\t"
+-	"xvaddsp	33, 33, 49		    \n\t"
+-	"xvaddsp	34, 34, 50		    \n\t"
+-	"xvaddsp	35, 35, 51		    \n\t"
+-	"xvaddsp	36, 36, 52		    \n\t"
+-	"xvaddsp	37, 37, 53		    \n\t"
+-	"xvaddsp	38, 38, 54		    \n\t"
+-	"xvaddsp	39, 39, 55		    \n\t"
+-
+-	"xvaddsp	32, 32, 33		     \n\t"
+-	"xvaddsp	34, 34, 35		     \n\t"
+-	"xvaddsp	36, 36, 37		     \n\t"
+-	"xvaddsp	38, 38, 39		     \n\t"
+-
+-	"xvaddsp	32, 32, 34		     \n\t"
+-	"xvaddsp	36, 36, 38		     \n\t"
+-
+-	"xvaddsp	32, 32, 36		     \n\t"
+-
+-
+-	"stxvw4x	32, 0, %3		     \n\t"
+-
+-	:
+-        : 
+-          "r" (i),	// 0	
+-	  "r" (n),  	// 1
+-          "r" (x1),     // 2
+-          "r" (svec),   // 3
+-          "r" (pre),    // 4
+-	  "r" (o16),	// 5
+-	  "r" (o32),	// 6
+-	  "r" (o48),    // 7
+-          "r" (o64),    // 8
+-          "r" (o80),    // 9
+-          "r" (o96),    // 10
+-          "r" (o112)   // 11
+-	: "cr0", "%0", "%2",  "memory"
+-	);
+-
+-} 
+-
+-
++  float sum;
++  __vector float t0;
++  __vector float t1;
++  __vector float t2;
++  __vector float t3;
++
++  __asm__
++    (
++       "dcbt		0, %2		\n\t"
++
++       "xxlxor		32, 32,	32	\n\t"
++       "xxlxor		33, 33,	33	\n\t"
++       "xxlxor		34, 34,	34	\n\t"
++       "xxlxor		35, 35,	35	\n\t"
++       "xxlxor		36, 36,	36	\n\t"
++       "xxlxor		37, 37,	37	\n\t"
++       "xxlxor		38, 38,	38	\n\t"
++       "xxlxor		39, 39,	39	\n\t"
++
++       "lxvw4x		40, 0, %2	\n\t"
++       "lxvw4x		41, %8, %2	\n\t"
++       "lxvw4x		42, %9, %2	\n\t"
++       "lxvw4x		43, %10, %2	\n\t"
++       "lxvw4x		44, %11, %2	\n\t"
++       "lxvw4x		45, %12, %2	\n\t"
++       "lxvw4x		46, %13, %2	\n\t"
++       "lxvw4x		47, %14, %2	\n\t"
++
++       "addi		%2, %2, 128	\n\t"
++
++       "addic.		%1, %1, -32	\n\t"
++       "ble		2f		\n\t"
++
++       ".p2align	5		\n"
++     "1:				\n\t"
++
++       "xvabssp		48, 40		\n\t"
++       "xvabssp		49, 41		\n\t"
++       "xvabssp		50, 42		\n\t"
++       "xvabssp		51, 43		\n\t"
++
++       "lxvw4x		40, 0, %2	\n\t"
++       "lxvw4x		41, %8, %2	\n\t"
++
++       "xvabssp		%x3, 44		\n\t"
++       "xvabssp		%x4, 45		\n\t"
++
++       "lxvw4x		42, %9, %2	\n\t"
++       "lxvw4x		43, %10, %2	\n\t"
++
++       "xvabssp		%x5, 46		\n\t"
++       "xvabssp		%x6, 47		\n\t"
++
++       "lxvw4x		44, %11, %2	\n\t"
++       "lxvw4x		45, %12, %2	\n\t"
++
++       "xvaddsp		32, 32, 48	\n\t"
++       "xvaddsp		33, 33, 49	\n\t"
++
++       "lxvw4x		46, %13, %2	\n\t"
++       "lxvw4x		47, %14, %2	\n\t"
++
++       "xvaddsp		34, 34, 50	\n\t"
++       "xvaddsp		35, 35, 51	\n\t"
++       "addi		%2, %2, 128	\n\t"
++       "xvaddsp		36, 36, %x3	\n\t"
++       "xvaddsp		37, 37, %x4	\n\t"
++       "addic.		%1, %1, -32	\n\t"
++       "xvaddsp		38, 38, %x5	\n\t"
++       "xvaddsp		39, 39, %x6	\n\t"
++
++       "bgt		1b		\n"
++
++     "2:				\n\t"
++
++       "xvabssp		48, 40		\n\t"
++       "xvabssp		49, 41		\n\t"
++       "xvabssp		50, 42		\n\t"
++       "xvabssp		51, 43		\n\t"
++       "xvabssp		%x3, 44		\n\t"
++       "xvabssp		%x4, 45		\n\t"
++       "xvabssp		%x5, 46		\n\t"
++       "xvabssp		%x6, 47		\n\t"
++
++       "xvaddsp		32, 32, 48	\n\t"
++       "xvaddsp		33, 33, 49	\n\t"
++       "xvaddsp		34, 34, 50	\n\t"
++       "xvaddsp		35, 35, 51	\n\t"
++       "xvaddsp		36, 36, %x3	\n\t"
++       "xvaddsp		37, 37, %x4	\n\t"
++       "xvaddsp		38, 38, %x5	\n\t"
++       "xvaddsp		39, 39, %x6	\n\t"
++
++       "xvaddsp		32, 32, 33	\n\t"
++       "xvaddsp		34, 34, 35	\n\t"
++       "xvaddsp		36, 36, 37	\n\t"
++       "xvaddsp		38, 38, 39	\n\t"
++
++       "xvaddsp		32, 32, 34	\n\t"
++       "xvaddsp		36, 36, 38	\n\t"
++
++       "xvaddsp		32, 32, 36	\n\t"
++
++       "xxsldwi		33, 32, 32, 2	\n\t"
++       "xvaddsp		32, 32, 33	\n\t"
++
++       "xxsldwi		33, 32, 32, 1	\n\t"
++       "xvaddsp		32, 32, 33	\n\t"
++
++       "xscvspdp	%0, 32		\n"
++
++     "#n=%1 x=%3=%2 sum=%0 o16=%8 o32=%9 o48=%10 o64=%11 o80=%12 o96=%13 o112=%14\n"
++     "#t0=%x3 t1=%x4 t2=%x5 t3=%x6"
++     :
++       "=f" (sum),	// 0
++       "+r" (n),	// 1
++       "+b" (x),	// 2
++       "=wa" (t0),	// 3
++       "=wa" (t1),	// 4
++       "=wa" (t2),	// 5
++       "=wa" (t3)	// 6
++     :
++       "m" (*x),
++       "b" (16),	// 8
++       "b" (32),	// 9
++       "b" (48),	// 10
++       "b" (64),	// 11
++       "b" (80),	// 12
++       "b" (96),	// 13
++       "b" (112)	// 14
++     :
++       "cr0",
++       "vs32","vs33","vs34","vs35","vs36","vs37","vs38","vs39",
++       "vs40","vs41","vs42","vs43","vs44","vs45","vs46","vs47",
++       "vs48","vs49","vs50","vs51"
++     );
++
++  return sum;
++}
+diff --git a/kernel/power/scopy_microk_power8.c b/kernel/power/scopy_microk_power8.c
+index 2e08e35..444a6d4 100644
+--- a/kernel/power/scopy_microk_power8.c
++++ b/kernel/power/scopy_microk_power8.c
+@@ -35,97 +35,78 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+ #define HAVE_KERNEL_32 1
+ 
+-static void scopy_kernel_32( BLASLONG n, FLOAT *x, FLOAT *y) __attribute__ ((noinline));
+-
+-static void scopy_kernel_32( BLASLONG n, FLOAT *x, FLOAT *y)
++static void scopy_kernel_32 (long n, float *x, float *y)
+ {
+-
+-
+-	BLASLONG i = n;
+-	BLASLONG o16 = 16;
+-	BLASLONG o32 = 32;
+-	BLASLONG o48 = 48;
+-	BLASLONG o64 = 64;
+-	BLASLONG o80 = 80;
+-	BLASLONG o96 = 96;
+-	BLASLONG o112 = 112;
+-	FLOAT *x1=x;
+-	FLOAT *y1=y;
+-	BLASLONG pre = 384;
+-	BLASLONG alpha=0;
+-
+-	__asm__  __volatile__
+-	(
+-
+-	"lxvw4x		40, 0, %2			    \n\t"
+-	"lxvw4x		41, %5, %2			    \n\t"
+-	"lxvw4x		42, %6, %2			    \n\t"
+-	"lxvw4x		43, %7, %2			    \n\t"
+-	"lxvw4x		44, %8, %2			    \n\t"
+-	"lxvw4x		45, %9, %2			    \n\t"
+-	"lxvw4x		46, %10, %2			    \n\t"
+-	"lxvw4x		47, %11, %2			    \n\t"
+-
+-	"addi		%2, %2, 128			    \n\t"
+-
+-	"addic.		%0 , %0	, -32  	 	             \n\t"
+-	"ble		2f		             	     \n\t"
+-
+-	".align 5				            \n\t"
+-	"1:				                    \n\t"
+-
+-	"stxvw4x		40, 0, %1			    \n\t"
+-	"stxvw4x		41, %5, %1			    \n\t"
+-	"lxvw4x		40, 0, %2			    \n\t"
+-	"lxvw4x		41, %5, %2			    \n\t"
+-	"stxvw4x		42, %6, %1			    \n\t"
+-	"stxvw4x		43, %7, %1			    \n\t"
+-	"lxvw4x		42, %6, %2			    \n\t"
+-	"lxvw4x		43, %7, %2			    \n\t"
+-	"stxvw4x		44, %8, %1			    \n\t"
+-	"stxvw4x		45, %9, %1			    \n\t"
+-	"lxvw4x		44, %8, %2			    \n\t"
+-	"lxvw4x		45, %9, %2			    \n\t"
+-	"stxvw4x		46, %10, %1			    \n\t"
+-	"stxvw4x		47, %11, %1			    \n\t"
+-	"lxvw4x		46, %10, %2			    \n\t"
+-	"lxvw4x		47, %11, %2			    \n\t"
+-
+-
+-	"addi		%1, %1, 128			    \n\t"
+-	"addi		%2, %2, 128			    \n\t"
+-
+-	"addic.		%0 , %0	, -32  	 	             \n\t"
+-	"bgt		1b		             	     \n\t"
+-
+-	"2:						     \n\t"
+-
+-	"stxvw4x		40, 0, %1			    \n\t"
+-	"stxvw4x		41, %5, %1			    \n\t"
+-	"stxvw4x		42, %6, %1			    \n\t"
+-	"stxvw4x		43, %7, %1			    \n\t"
+-	"stxvw4x		44, %8, %1			    \n\t"
+-	"stxvw4x		45, %9, %1			    \n\t"
+-	"stxvw4x		46, %10, %1			    \n\t"
+-	"stxvw4x		47, %11, %1			    \n\t"
+-
+-	:
+-        : 
+-          "r" (i),	// 0	
+-	  "r" (y1),  	// 1
+-          "r" (x1),     // 2
+-          "r" (alpha),  // 3
+-          "r" (pre),    // 4
+-	  "r" (o16),	// 5
+-	  "r" (o32),	// 6
+-	  "r" (o48),    // 7
+-          "r" (o64),    // 8
+-          "r" (o80),    // 9
+-          "r" (o96),    // 10
+-          "r" (o112)    // 11
+-	: "cr0", "%0", "%2" , "%1", "memory"
+-	);
+-
+-} 
+-
+-
++  __asm__
++    (
++       "lxvw4x		40, 0, %2	\n\t"
++       "lxvw4x		41, %5, %2	\n\t"
++       "lxvw4x		42, %6, %2	\n\t"
++       "lxvw4x		43, %7, %2	\n\t"
++       "lxvw4x		44, %8, %2	\n\t"
++       "lxvw4x		45, %9, %2	\n\t"
++       "lxvw4x		46, %10, %2	\n\t"
++       "lxvw4x		47, %11, %2	\n\t"
++
++       "addi		%2, %2, 128	\n\t"
++
++       "addic.		%1, %1, -32	\n\t"
++       "ble		2f		\n\t"
++
++       ".p2align	5		\n"
++     "1:				\n\t"
++
++       "stxvw4x		40, 0, %3	\n\t"
++       "stxvw4x		41, %5, %3	\n\t"
++       "lxvw4x		40, 0, %2	\n\t"
++       "lxvw4x		41, %5, %2	\n\t"
++       "stxvw4x		42, %6, %3	\n\t"
++       "stxvw4x		43, %7, %3	\n\t"
++       "lxvw4x		42, %6, %2	\n\t"
++       "lxvw4x		43, %7, %2	\n\t"
++       "stxvw4x		44, %8, %3	\n\t"
++       "stxvw4x		45, %9, %3	\n\t"
++       "lxvw4x		44, %8, %2	\n\t"
++       "lxvw4x		45, %9, %2	\n\t"
++       "stxvw4x		46, %10, %3	\n\t"
++       "stxvw4x		47, %11, %3	\n\t"
++       "lxvw4x		46, %10, %2	\n\t"
++       "lxvw4x		47, %11, %2	\n\t"
++
++       "addi		%3, %3, 128	\n\t"
++       "addi		%2, %2, 128	\n\t"
++
++       "addic.		%1, %1, -32	\n\t"
++       "bgt		1b		\n"
++
++     "2:				\n\t"
++
++       "stxvw4x		40, 0, %3	\n\t"
++       "stxvw4x		41, %5, %3	\n\t"
++       "stxvw4x		42, %6, %3	\n\t"
++       "stxvw4x		43, %7, %3	\n\t"
++       "stxvw4x		44, %8, %3	\n\t"
++       "stxvw4x		45, %9, %3	\n\t"
++       "stxvw4x		46, %10, %3	\n\t"
++       "stxvw4x		47, %11, %3	\n"
++
++     "#n=%1 x=%4=%2 y=%0=%3 o16=%5 o32=%6 o48=%7 o64=%8 o80=%9 o96=%10 o112=%11"
++     :
++       "=m" (*y),
++       "+r" (n),	// 1
++       "+b" (x),	// 2
++       "+b" (y)		// 3
++     :
++       "m" (*x),
++       "b" (16),	// 5
++       "b" (32),	// 6
++       "b" (48),	// 7
++       "b" (64),	// 8
++       "b" (80),	// 9
++       "b" (96),	// 10
++       "b" (112)	// 11
++     :
++       "cr0",
++       "vs40","vs41","vs42","vs43","vs44","vs45","vs46","vs47"
++     );
++}
+diff --git a/kernel/power/sdot.c b/kernel/power/sdot.c
+index 52fb1fe..31f4734 100644
+--- a/kernel/power/sdot.c
++++ b/kernel/power/sdot.c
+@@ -42,7 +42,7 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+ #ifndef HAVE_KERNEL_16
+ 
+-static void sdot_kernel_16(BLASLONG n, FLOAT *x, FLOAT *y, FLOAT *d)
++static FLOAT sdot_kernel_16(BLASLONG n, FLOAT *x, FLOAT *y)
+ {
+ 	BLASLONG register i = 0;
+ 	FLOAT dot = 0.0;
+@@ -61,8 +61,7 @@ static void sdot_kernel_16(BLASLONG n, FLOAT *x, FLOAT *y, FLOAT *d)
+               i+=8 ;
+ 
+        }
+-       *d += dot;
+-
++       return dot;
+ }
+ 
+ #endif
+@@ -82,8 +81,7 @@ FLOAT CNAME(BLASLONG n, FLOAT *x, BLASLONG inc_x, FLOAT *y, BLASLONG inc_y)
+ 		BLASLONG n1 = n & -32;
+ 
+ 		if ( n1 )
+-			sdot_kernel_16(n1, x, y , &dot );
+-
++			dot = sdot_kernel_16(n1, x, y);
+ 
+ 		i = n1;
+ 		while(i < n)
+diff --git a/kernel/power/sdot_microk_power8.c b/kernel/power/sdot_microk_power8.c
+index 6dd588a..7f7ccfa 100644
+--- a/kernel/power/sdot_microk_power8.c
++++ b/kernel/power/sdot_microk_power8.c
+@@ -34,146 +34,142 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ **************************************************************************************/
+ 
+ #define HAVE_KERNEL_16 1
+-static void sdot_kernel_16( BLASLONG n, FLOAT *x, FLOAT *y , FLOAT *dot) __attribute__ ((noinline));
+ 
+-static void sdot_kernel_16( BLASLONG n, FLOAT *x, FLOAT *y, FLOAT *dot)
++static float sdot_kernel_16 (long n, float *x, float *y)
+ {
+-
+-
+-	BLASLONG i = n;
+-	BLASLONG o16 = 16;
+-	BLASLONG o32 = 32;
+-	BLASLONG o48 = 48;
+-	BLASLONG o64 = 64;
+-	BLASLONG o80 = 80;
+-	BLASLONG o96 = 96;
+-	BLASLONG o112 = 112;
+-	FLOAT *x1=x;
+-	FLOAT *y1=y;
+-	BLASLONG pre = 384;
+-	FLOAT tempdot[4];
+-
+-
+-	__asm__  __volatile__
+-	(
+-	"xxlxor		32,32,32			    \n\t"
+-	"xxlxor		33,33,33			    \n\t"
+-	"xxlxor		34,34,34			    \n\t"
+-	"xxlxor		35,35,35			    \n\t"
+-	"xxlxor		36,36,36			    \n\t"
+-	"xxlxor		37,37,37			    \n\t"
+-	"xxlxor		38,38,38			    \n\t"
+-	"xxlxor		39,39,39			    \n\t"
+-
+-	"dcbt		%2, %12				    \n\t"
+-	"dcbt		%3, %12				    \n\t"
+-
+-	"lxvw4x		40, 0, %2			    \n\t"
+-	"lxvw4x		48, 0, %3			    \n\t"
+-	"lxvw4x		41, %5, %2			    \n\t"
+-	"lxvw4x		49, %5, %3			    \n\t"
+-	"lxvw4x		42, %6, %2			    \n\t"
+-	"lxvw4x		50, %6, %3			    \n\t"
+-	"lxvw4x		43, %7, %2			    \n\t"
+-	"lxvw4x		51, %7, %3			    \n\t"
+-	"lxvw4x		44, %8, %2			    \n\t"
+-	"lxvw4x		52, %8, %3			    \n\t"
+-	"lxvw4x		45, %9, %2			    \n\t"
+-	"lxvw4x		53, %9, %3			    \n\t"
+-	"lxvw4x		46, %10, %2			    \n\t"
+-	"lxvw4x		54, %10, %3			    \n\t"
+-	"lxvw4x		47, %11, %2			    \n\t"
+-	"lxvw4x		55, %11, %3			    \n\t"
+-
+-	"addi		%2, %2, 128			    \n\t"
+-	"addi		%3, %3, 128			    \n\t"
+-
+-	"addic.		%0 , %0	, -32  	 	             \n\t"
+-	"ble		2f		             	     \n\t"
+-
+-	".align 5				            \n\t"
+-	"1:				                    \n\t"
+-
+-	"dcbt		%2, %12				    \n\t"
+-	"dcbt		%3, %12				    \n\t"
+-
+-	"xvmaddasp	32, 40, 48		    \n\t"
+-	"lxvw4x		40, 0, %2			    \n\t"
+-	"lxvw4x		48, 0, %3			    \n\t"
+-	"xvmaddasp	33, 41, 49		    \n\t"
+-	"lxvw4x		41, %5, %2			    \n\t"
+-	"lxvw4x		49, %5, %3			    \n\t"
+-	"xvmaddasp	34, 42, 50		    \n\t"
+-	"lxvw4x		42, %6, %2			    \n\t"
+-	"lxvw4x		50, %6, %3			    \n\t"
+-	"xvmaddasp	35, 43, 51		    \n\t"
+-	"lxvw4x		43, %7, %2			    \n\t"
+-	"lxvw4x		51, %7, %3			    \n\t"
+-	"xvmaddasp	36, 44, 52		    \n\t"
+-	"lxvw4x		44, %8, %2			    \n\t"
+-	"lxvw4x		52, %8, %3			    \n\t"
+-	"xvmaddasp	37, 45, 53		    \n\t"
+-	"lxvw4x		45, %9, %2			    \n\t"
+-	"lxvw4x		53, %9, %3			    \n\t"
+-	"xvmaddasp	38, 46, 54		    \n\t"
+-	"lxvw4x		46, %10, %2			    \n\t"
+-	"lxvw4x		54, %10, %3			    \n\t"
+-	"xvmaddasp	39, 47, 55		    \n\t"
+-
+-	"lxvw4x		47, %11, %2			    \n\t"
+-	"lxvw4x		55, %11, %3			    \n\t"
+-
+-
+-	"addi		%2, %2, 128			    \n\t"
+-	"addi		%3, %3, 128			    \n\t"
+-
+-	"addic.		%0 , %0	, -32  	 	             \n\t"
+-	"bgt		1b		             	     \n\t"
+-
+-	"2:						     \n\t"
+-
+-	"xvmaddasp	32, 40, 48		    \n\t"
+-	"xvmaddasp	33, 41, 49		    \n\t"
+-	"xvmaddasp	34, 42, 50		    \n\t"
+-	"xvmaddasp	35, 43, 51		    \n\t"
+-	"xvmaddasp	36, 44, 52		    \n\t"
+-	"xvmaddasp	37, 45, 53		    \n\t"
+-	"xvmaddasp	38, 46, 54		    \n\t"
+-	"xvmaddasp	39, 47, 55		    \n\t"
+-
+-	"xvaddsp	32, 32 , 33		    \n\t"
+-	"xvaddsp	34, 34 , 35		    \n\t"
+-	"xvaddsp	36, 36 , 37		    \n\t"
+-	"xvaddsp	38, 38 , 39		    \n\t"
+-
+-	"xvaddsp	32, 32 , 34		    \n\t"
+-	"xvaddsp	36, 36 , 38		    \n\t"
+-
+-	"xvaddsp	32, 32 , 36		    \n\t"
+-
+-	"stxvw4x	32, 0 , %4		    \n\t"
+-
+-	:
+-        : 
+-          "r" (i),	// 0	
+-	  "r" (n),  	// 1
+-          "r" (x1),     // 2
+-          "r" (y1),     // 3
+-          "r" (tempdot),    // 4
+-	  "r" (o16),	// 5
+-	  "r" (o32),	// 6
+-	  "r" (o48),    // 7
+-          "r" (o64),    // 8
+-          "r" (o80),    // 9
+-          "r" (o96),    // 10
+-          "r" (o112),   // 11
+-	  "r" (pre)	// 12
+-	: "cr0", "%0", "%2" , "%3", "memory"
+-	);
+-
+-	*dot = tempdot[0] + tempdot[1] + tempdot[2] + tempdot[3];
+-
+-
+-} 
+-
+-
++  float dot;
++  __vector float t0;
++  __vector float t1;
++  __vector float t2;
++  __vector float t3;
++
++  __asm__
++    (
++       "dcbt		0, %2		\n\t"
++       "dcbt		0, %3		\n\t"
++
++       "xxlxor		32, 32,	32	\n\t"
++       "xxlxor		33, 33,	33	\n\t"
++       "xxlxor		34, 34,	34	\n\t"
++       "xxlxor		35, 35,	35	\n\t"
++       "xxlxor		36, 36,	36	\n\t"
++       "xxlxor		37, 37,	37	\n\t"
++       "xxlxor		38, 38,	38	\n\t"
++       "xxlxor		39, 39,	39	\n\t"
++
++       "lxvw4x		40, 0, %2	\n\t"
++       "lxvw4x		48, 0, %3	\n\t"
++       "lxvw4x		41, %10, %2	\n\t"
++       "lxvw4x		49, %10, %3	\n\t"
++       "lxvw4x		42, %11, %2	\n\t"
++       "lxvw4x		50, %11, %3	\n\t"
++       "lxvw4x		43, %12, %2	\n\t"
++       "lxvw4x		51, %12, %3	\n\t"
++       "lxvw4x		44, %13, %2	\n\t"
++       "lxvw4x		%x4, %13, %3	\n\t"
++       "lxvw4x		45, %14, %2	\n\t"
++       "lxvw4x		%x5, %14, %3	\n\t"
++       "lxvw4x		46, %15, %2	\n\t"
++       "lxvw4x		%x6, %15, %3	\n\t"
++       "lxvw4x		47, %16, %2	\n\t"
++       "lxvw4x		%x7, %16, %3	\n\t"
++
++       "addi		%2, %2, 128	\n\t"
++       "addi		%3, %3, 128	\n\t"
++
++       "addic.		%1, %1, -32	\n\t"
++       "ble		2f		\n\t"
++
++       ".p2align	5		\n"
++     "1:				\n\t"
++
++       "xvmaddasp	32, 40, 48	\n\t"
++       "lxvw4x		40, 0, %2	\n\t"
++       "lxvw4x		48, 0, %3	\n\t"
++       "xvmaddasp	33, 41, 49	\n\t"
++       "lxvw4x		41, %10, %2	\n\t"
++       "lxvw4x		49, %10, %3	\n\t"
++       "xvmaddasp	34, 42, 50	\n\t"
++       "lxvw4x		42, %11, %2	\n\t"
++       "lxvw4x		50, %11, %3	\n\t"
++       "xvmaddasp	35, 43, 51	\n\t"
++       "lxvw4x		43, %12, %2	\n\t"
++       "lxvw4x		51, %12, %3	\n\t"
++       "xvmaddasp	36, 44, %x4	\n\t"
++       "lxvw4x		44, %13, %2	\n\t"
++       "lxvw4x		%x4, %13, %3	\n\t"
++       "xvmaddasp	37, 45, %x5	\n\t"
++       "lxvw4x		45, %14, %2	\n\t"
++       "lxvw4x		%x5, %14, %3	\n\t"
++       "xvmaddasp	38, 46, %x6	\n\t"
++       "lxvw4x		46, %15, %2	\n\t"
++       "lxvw4x		%x6, %15, %3	\n\t"
++       "xvmaddasp	39, 47, %x7	\n\t"
++       "lxvw4x		47, %16, %2	\n\t"
++       "lxvw4x		%x7, %16, %3	\n\t"
++
++       "addi		%2, %2, 128	\n\t"
++       "addi		%3, %3, 128	\n\t"
++
++       "addic.		%1, %1, -32	\n\t"
++       "bgt		1b		\n"
++
++     "2:				\n\t"
++
++       "xvmaddasp	32, 40, 48	\n\t"
++       "xvmaddasp	33, 41, 49	\n\t"
++       "xvmaddasp	34, 42, 50	\n\t"
++       "xvmaddasp	35, 43, 51	\n\t"
++       "xvmaddasp	36, 44, %x4	\n\t"
++       "xvmaddasp	37, 45, %x5	\n\t"
++       "xvmaddasp	38, 46, %x6	\n\t"
++       "xvmaddasp	39, 47, %x7	\n\t"
++
++       "xvaddsp		32, 32, 33	\n\t"
++       "xvaddsp		34, 34, 35	\n\t"
++       "xvaddsp		36, 36, 37	\n\t"
++       "xvaddsp		38, 38, 39	\n\t"
++
++       "xvaddsp		32, 32, 34	\n\t"
++       "xvaddsp		36, 36, 38	\n\t"
++
++       "xvaddsp		32, 32, 36	\n\t"
++
++       "xxsldwi		33, 32, 32, 2	\n\t"
++       "xvaddsp		32, 32, 33	\n\t"
++
++       "xxsldwi		33, 32, 32, 1	\n\t"
++       "xvaddsp		32, 32, 33	\n\t"
++
++       "xscvspdp	%x0, 32		\n"
++
++     "#dot=%0 n=%1 x=%8=%2 y=%9=%3 o16=%10 o32=%11 o48=%12 o64=%13 o80=%14 o96=%15 o122=%16\n"
++     "#t0=%x4 t1=%x5 t2=%x6 t3=%x7"
++     :
++       "=f" (dot),	// 0
++       "+r" (n),	// 1
++       "+b" (x),	// 2
++       "+b" (y),	// 3
++       "=wa" (t0),	// 4
++       "=wa" (t1),	// 5
++       "=wa" (t2),	// 6
++       "=wa" (t3)	// 7
++     :
++       "m" (*x),
++       "m" (*y),
++       "b" (16),	// 10
++       "b" (32),	// 11
++       "b" (48),	// 12
++       "b" (64),	// 13
++       "b" (80),	// 14
++       "b" (96),	// 15
++       "b" (112)	// 16
++     :
++       "cr0",
++       "vs32","vs33","vs34","vs35","vs36","vs37","vs38","vs39",
++       "vs40","vs41","vs42","vs43","vs44","vs45","vs46","vs47",
++       "vs48","vs49","vs50","vs51"
++     );
++
++  return dot;
++}
+diff --git a/kernel/power/srot.c b/kernel/power/srot.c
+index d464846..d2910ff 100644
+--- a/kernel/power/srot.c
++++ b/kernel/power/srot.c
+@@ -46,7 +46,7 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+ #ifndef HAVE_KERNEL_16
+ 
+-static void srot_kernel_16(BLASLONG n, FLOAT *x, FLOAT *y, FLOAT *c, FLOAT *s)
++static void srot_kernel_16(BLASLONG n, FLOAT *x, FLOAT *y, FLOAT c, FLOAT s)
+ {
+ 
+ 	BLASLONG i=0;
+@@ -56,8 +56,6 @@ static void srot_kernel_16(BLASLONG n, FLOAT *x, FLOAT *y, FLOAT *c, FLOAT *s)
+ 	FLOAT y00, y01, y02, y03;
+ 	FLOAT *x1=x;
+ 	FLOAT *y1=y;
+-	FLOAT c1=*c;
+-	FLOAT s1=*s;
+ 
+ 	while ( i<n )
+ 	{
+@@ -71,14 +69,14 @@ static void srot_kernel_16(BLASLONG n, FLOAT *x, FLOAT *y, FLOAT *c, FLOAT *s)
+ 		x03 = x1[3];
+ 		y03 = y1[3];
+ 
+-		f0 = c1*x00 + s1*y00;
+-		g0 = c1*y00 - s1*x00;
+-		f1 = c1*x01 + s1*y01;
+-		g1 = c1*y01 - s1*x01;
+-		f2 = c1*x02 + s1*y02;
+-		g2 = c1*y02 - s1*x02;
+-		f3 = c1*x03 + s1*y03;
+-		g3 = c1*y03 - s1*x03;
++		f0 = c*x00 + s*y00;
++		g0 = c*y00 - s*x00;
++		f1 = c*x01 + s*y01;
++		g1 = c*y01 - s*x01;
++		f2 = c*x02 + s*y02;
++		g2 = c*y02 - s*x02;
++		f3 = c*x03 + s*y03;
++		g3 = c*y03 - s*x03;
+ 
+ 		x1[0] = f0;
+ 		y1[0] = g0;
+@@ -106,8 +104,6 @@ int CNAME(BLASLONG n, FLOAT *x, BLASLONG inc_x, FLOAT *y, BLASLONG inc_y, FLOAT
+ {
+ 	BLASLONG i=0;
+ 	BLASLONG ix=0,iy=0;
+-	FLOAT c1[4] __attribute__ ((aligned (16)));;
+-	FLOAT s1[4] __attribute__ ((aligned (16)));;
+ 	FLOAT *x1=x;
+ 	FLOAT *y1=y;
+ 	FLOAT temp;
+@@ -120,15 +116,7 @@ int CNAME(BLASLONG n, FLOAT *x, BLASLONG inc_x, FLOAT *y, BLASLONG inc_y, FLOAT
+ 		BLASLONG n1 = n & -16;
+ 		if ( n1 > 0 )
+ 		{
+-			c1[0]=c;
+-			c1[1]=c;
+-			c1[2]=c;
+-			c1[3]=c;
+-			s1[0]=s;
+-			s1[1]=s;
+-			s1[2]=s;
+-			s1[3]=s;
+-			srot_kernel_16(n1, x1, y1, c1, s1);
++			srot_kernel_16(n1, x1, y1, c, s);
+ 			i=n1;
+ 		}
+ 
+diff --git a/kernel/power/srot_microk_power8.c b/kernel/power/srot_microk_power8.c
+index ade6550..0a18c16 100644
+--- a/kernel/power/srot_microk_power8.c
++++ b/kernel/power/srot_microk_power8.c
+@@ -38,171 +38,179 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+ #define HAVE_KERNEL_16 1
+ 
+-static void srot_kernel_16( BLASLONG n, FLOAT *x, FLOAT *y, FLOAT *c, FLOAT *s) __attribute__ ((noinline));
+-
+-static void srot_kernel_16( BLASLONG n, FLOAT *x, FLOAT *y, FLOAT *c, FLOAT *s)
++static void srot_kernel_16 (long n, float *x, float *y, float c, float s)
+ {
++  __vector float t0;
++  __vector float t1;
++  __vector float t2;
++  __vector float t3;
++  __vector float t4;
++  __vector float t5;
++  __vector float t6;
++  __vector float t7;
+ 
++  __asm__
++    (
++       "xscvdpspn	36, %x13	\n\t"	// load c to all words
++       "xxspltw		36, 36, 0	\n\t"
+ 
+-	BLASLONG i = n;
+-	BLASLONG o16 = 16;
+-	BLASLONG o32 = 32;
+-	BLASLONG o48 = 48;
+-	FLOAT *x1=x;
+-	FLOAT *y1=y;
+-	FLOAT *x2=x+1;
+-	FLOAT *y2=y+1;
+-
+-	__asm__  __volatile__
+-	(
+-
+-        "lxvw4x         36 , 0, %3                          \n\t"	// load c
+-        "lxvw4x         37 , 0, %4                          \n\t"	// load s
+-	"addi		%8 , %8, -4			     \n\t"
+-	"addi		%9 , %9, -4			     \n\t"
+-
+-	"lxvw4x		32, 0, %1			    \n\t"	// load x
+-	"lxvw4x		33, %5, %1			    \n\t"
+-	"lxvw4x		34, %6, %1			    \n\t"
+-	"lxvw4x		35, %7, %1			    \n\t"
+-
+-	"lxvw4x		40, 0, %2			    \n\t"	// load y
+-	"lxvw4x		41, %5, %2			    \n\t"
+-	"lxvw4x		42, %6, %2			    \n\t"
+-	"lxvw4x		43, %7, %2			    \n\t"
+-
+-	"addi		%1, %1, 64			    \n\t"
+-	"addi		%2, %2, 64			    \n\t"
+-
+-	"addic.		%0 , %0	, -16  	 	             \n\t"
+-	"ble		2f		             	     \n\t"
+-
+-	".align 5				            \n\t"
+-	"1:				                    \n\t"
+-
+-	"xvmulsp	48, 32, 36		    	    \n\t"	// c * x
+-	"xvmulsp	49, 33, 36		    	    \n\t"
+-	"xvmulsp	50, 34, 36		    	    \n\t"
+-	"xvmulsp	51, 35, 36		    	    \n\t"
+-
+-	"xvmulsp	56, 40, 36		    	    \n\t"	// c * y
+-	"xvmulsp	57, 41, 36		    	    \n\t"
+-	"xvmulsp	58, 42, 36		    	    \n\t"
+-	"xvmulsp	59, 43, 36		    	    \n\t"
+-
+-	"xvmulsp	52, 32, 37		    	    \n\t"	// s * x
+-	"xvmulsp	53, 33, 37		    	    \n\t"
+-
+-	"lxvw4x		32, 0, %1			    \n\t"	// load x
+-	"lxvw4x		33, %5, %1			    \n\t"
+-
+-	"xvmulsp	54, 34, 37		    	    \n\t"
+-	"xvmulsp	55, 35, 37		    	    \n\t"
+-
+-	"lxvw4x		34, %6, %1			    \n\t"
+-	"lxvw4x		35, %7, %1			    \n\t"
+-
+-	"xvmulsp	60, 40, 37		    	    \n\t"	// s * y
+-	"xvmulsp	61, 41, 37		    	    \n\t"
+-
+-	"lxvw4x		40, 0, %2			    \n\t"	// load y
+-	"lxvw4x		41, %5, %2			    \n\t"
+-
+-	"xvmulsp	62, 42, 37		    	    \n\t"
+-	"xvmulsp	63, 43, 37		    	    \n\t"
+-
+-	"lxvw4x		42, %6, %2			    \n\t"
+-	"lxvw4x		43, %7, %2			    \n\t"
+-
+-	"xvaddsp	48, 48 , 60			    \n\t"	// c * x + s * y 
+-	"xvaddsp	49, 49 , 61			    \n\t"	// c * x + s * y 
+-
+-	"addi		%1, %1, 64			    \n\t"
+-	"addi		%2, %2, 64			    \n\t"
+-
+-	"xvaddsp	50, 50 , 62			    \n\t"	// c * x + s * y 
+-	"xvaddsp	51, 51 , 63			    \n\t"	// c * x + s * y 
+-
+-	"xvsubsp	56, 56 , 52			    \n\t"	// c * y - s * x
+-	"xvsubsp	57, 57 , 53			    \n\t"	// c * y - s * x
+-	"xvsubsp	58, 58 , 54			    \n\t"	// c * y - s * x
+-	"xvsubsp	59, 59 , 55			    \n\t"	// c * y - s * x
+-
+-	"stxvw4x	48, 0, %8			    \n\t"	// store x
+-	"stxvw4x	49, %5, %8			    \n\t"
+-	"stxvw4x	50, %6, %8			    \n\t"
+-	"stxvw4x	51, %7, %8			    \n\t"
+-
+-	"stxvw4x	56, 0, %9			    \n\t"	// store y
+-	"stxvw4x	57, %5, %9			    \n\t"
+-	"stxvw4x	58, %6, %9			    \n\t"
+-	"stxvw4x	59, %7, %9			    \n\t"
+-
+-	"addi		%8, %8, 64			    \n\t"
+-	"addi		%9, %9, 64			    \n\t"
+-
+-	"addic.		%0 , %0	, -16  	 	             \n\t"
+-	"bgt		1b		             	     \n\t"
+-
+-	"2:						     \n\t"
+-
+-	"xvmulsp	48, 32, 36		    	    \n\t"	// c * x
+-	"xvmulsp	49, 33, 36		    	    \n\t"
+-	"xvmulsp	50, 34, 36		    	    \n\t"
+-	"xvmulsp	51, 35, 36		    	    \n\t"
+-
+-	"xvmulsp	56, 40, 36		    	    \n\t"	// c * y
+-	"xvmulsp	57, 41, 36		    	    \n\t"
+-	"xvmulsp	58, 42, 36		    	    \n\t"
+-	"xvmulsp	59, 43, 36		    	    \n\t"
+-
+-	"xvmulsp	52, 32, 37		    	    \n\t"	// s * x
+-	"xvmulsp	53, 33, 37		    	    \n\t"
+-	"xvmulsp	54, 34, 37		    	    \n\t"
+-	"xvmulsp	55, 35, 37		    	    \n\t"
+-
+-	"xvmulsp	60, 40, 37		    	    \n\t"	// s * y
+-	"xvmulsp	61, 41, 37		    	    \n\t"
+-	"xvmulsp	62, 42, 37		    	    \n\t"
+-	"xvmulsp	63, 43, 37		    	    \n\t"
+-
+-	"xvaddsp	48, 48 , 60			    \n\t"	// c * x + s * y 
+-	"xvaddsp	49, 49 , 61			    \n\t"	// c * x + s * y 
+-	"xvaddsp	50, 50 , 62			    \n\t"	// c * x + s * y 
+-	"xvaddsp	51, 51 , 63			    \n\t"	// c * x + s * y 
+-
+-	"xvsubsp	56, 56 , 52			    \n\t"	// c * y - s * x
+-	"xvsubsp	57, 57 , 53			    \n\t"	// c * y - s * x
+-	"xvsubsp	58, 58 , 54			    \n\t"	// c * y - s * x
+-	"xvsubsp	59, 59 , 55			    \n\t"	// c * y - s * x
++       "xscvdpspn	37, %x14	\n\t"	// load s to all words
++       "xxspltw		37, 37, 0	\n\t"
+ 
+-	"stxvw4x	48, 0, %8			    \n\t"	// store x
+-	"stxvw4x	49, %5, %8			    \n\t"
+-	"stxvw4x	50, %6, %8			    \n\t"
+-	"stxvw4x	51, %7, %8			    \n\t"
++       "lxvw4x		32, 0, %3	\n\t"	// load x
++       "lxvw4x		33, %15, %3	\n\t"
++       "lxvw4x		34, %16, %3	\n\t"
++       "lxvw4x		35, %17, %3	\n\t"
+ 
+-	"stxvw4x	56, 0, %9			    \n\t"	// store y
+-	"stxvw4x	57, %5, %9			    \n\t"
+-	"stxvw4x	58, %6, %9			    \n\t"
+-	"stxvw4x	59, %7, %9			    \n\t"
++       "lxvw4x		48, 0, %4	\n\t"	// load y
++       "lxvw4x		49, %15, %4	\n\t"
++       "lxvw4x		50, %16, %4	\n\t"
++       "lxvw4x		51, %17, %4	\n\t"
+ 
++       "addi		%3, %3, 64	\n\t"
++       "addi		%4, %4, 64	\n\t"
+ 
++       "addic.		%2, %2, -16	\n\t"
++       "ble		2f		\n\t"
+ 
+-	:
+-        : 
+-          "r" (i),	// 0	
+-	  "r" (x1),  	// 1
+-          "r" (y1),     // 2
+-          "r" (c),      // 3
+-          "r" (s),      // 4
+-	  "r" (o16),	// 5
+-	  "r" (o32),	// 6
+-	  "r" (o48),    // 7
+-	  "r" (x2),     // 8
+-	  "r" (y2)      // 9
+-	: "cr0", "%0", "%1" , "%2", "%8", "%9", "memory"
+-	);
++       ".p2align	5		\n"
++     "1:				\n\t"
+ 
+-} 
++       "xvmulsp		40, 32, 36	\n\t"	// c * x
++       "xvmulsp		41, 33, 36	\n\t"
++       "xvmulsp		42, 34, 36	\n\t"
++       "xvmulsp		43, 35, 36	\n\t"
+ 
++       "xvmulsp		%x5, 48, 36	\n\t"	// c * y
++       "xvmulsp		%x6, 49, 36	\n\t"
++       "xvmulsp		%x7, 50, 36	\n\t"
++       "xvmulsp		%x8, 51, 36	\n\t"
+ 
++       "xvmulsp		44, 32, 37	\n\t"	// s * x
++       "xvmulsp		45, 33, 37	\n\t"
++
++       "lxvw4x		32, 0, %3	\n\t"	// load x
++       "lxvw4x		33, %15, %3	\n\t"
++
++       "xvmulsp		46, 34, 37	\n\t"
++       "xvmulsp		47, 35, 37	\n\t"
++
++       "lxvw4x		34, %16, %3	\n\t"
++       "lxvw4x		35, %17, %3	\n\t"
++
++       "xvmulsp		%x9, 48, 37	\n\t"	// s * y
++       "xvmulsp		%x10, 49, 37	\n\t"
++
++       "lxvw4x		48, 0, %4	\n\t"	// load y
++       "lxvw4x		49, %15, %4	\n\t"
++
++       "xvmulsp		%x11, 50, 37	\n\t"
++       "xvmulsp		%x12, 51, 37	\n\t"
++
++       "lxvw4x		50, %16, %4	\n\t"
++       "lxvw4x		51, %17, %4	\n\t"
++
++       "xvaddsp		40, 40, %x9	\n\t"	// c * x + s * y
++       "xvaddsp		41, 41, %x10	\n\t"	// c * x + s * y
++
++       "addi		%3, %3, -64	\n\t"
++       "addi		%4, %4, -64	\n\t"
++
++       "xvaddsp		42, 42, %x11	\n\t"	// c * x + s * y
++       "xvaddsp		43, 43, %x12	\n\t"	// c * x + s * y
++
++       "xvsubsp		%x5, %x5, 44	\n\t"	// c * y - s * x
++       "xvsubsp		%x6, %x6, 45	\n\t"	// c * y - s * x
++       "xvsubsp		%x7, %x7, 46	\n\t"	// c * y - s * x
++       "xvsubsp		%x8, %x8, 47	\n\t"	// c * y - s * x
++
++       "stxvw4x		40, 0, %3	\n\t"	// store x
++       "stxvw4x		41, %15, %3	\n\t"
++       "stxvw4x		42, %16, %3	\n\t"
++       "stxvw4x		43, %17, %3	\n\t"
++
++       "stxvw4x		%x5, 0, %4	\n\t"	// store y
++       "stxvw4x		%x6, %15, %4	\n\t"
++       "stxvw4x		%x7, %16, %4	\n\t"
++       "stxvw4x		%x8, %17, %4	\n\t"
++
++       "addi		%3, %3, 128	\n\t"
++       "addi		%4, %4, 128	\n\t"
++
++       "addic.		%2, %2, -16	\n\t"
++       "bgt		1b		\n"
++
++     "2:				\n\t"
++
++       "xvmulsp		40, 32, 36	\n\t"	// c * x
++       "xvmulsp		41, 33, 36	\n\t"
++       "xvmulsp		42, 34, 36	\n\t"
++       "xvmulsp		43, 35, 36	\n\t"
++
++       "xvmulsp		%x5, 48, 36	\n\t"	// c * y
++       "xvmulsp		%x6, 49, 36	\n\t"
++       "xvmulsp		%x7, 50, 36	\n\t"
++       "xvmulsp		%x8, 51, 36	\n\t"
++
++       "xvmulsp		44, 32, 37	\n\t"	// s * x
++       "xvmulsp		45, 33, 37	\n\t"
++       "xvmulsp		46, 34, 37	\n\t"
++       "xvmulsp		47, 35, 37	\n\t"
++
++       "xvmulsp		%x9, 48, 37	\n\t"	// s * y
++       "xvmulsp		%x10, 49, 37	\n\t"
++       "xvmulsp		%x11, 50, 37	\n\t"
++       "xvmulsp		%x12, 51, 37	\n\t"
++
++       "addi		%3, %3, -64	\n\t"
++       "addi		%4, %4, -64	\n\t"
++
++       "xvaddsp		40, 40, %x9	\n\t"	// c * x + s * y
++       "xvaddsp		41, 41, %x10	\n\t"	// c * x + s * y
++       "xvaddsp		42, 42, %x11	\n\t"	// c * x + s * y
++       "xvaddsp		43, 43, %x12	\n\t"	// c * x + s * y
++
++       "xvsubsp		%x5, %x5, 44	\n\t"	// c * y - s * x
++       "xvsubsp		%x6, %x6, 45	\n\t"	// c * y - s * x
++       "xvsubsp		%x7, %x7, 46	\n\t"	// c * y - s * x
++       "xvsubsp		%x8, %x8, 47	\n\t"	// c * y - s * x
++
++       "stxvw4x		40, 0, %3	\n\t"	// store x
++       "stxvw4x		41, %15, %3	\n\t"
++       "stxvw4x		42, %16, %3	\n\t"
++       "stxvw4x		43, %17, %3	\n\t"
++
++       "stxvw4x		%x5, 0, %4	\n\t"	// store y
++       "stxvw4x		%x6, %15, %4	\n\t"
++       "stxvw4x		%x7, %16, %4	\n\t"
++       "stxvw4x		%x8, %17, %4	\n"
++
++     "#n=%2 x=%0=%3 y=%1=%4 c=%13 s=%14 o16=%15 o32=%16 o48=%17\n"
++     "#t0=%x5 t1=%x6 t2=%x7 t3=%x8 t4=%x9 t5=%x10 t6=%x11 t7=%x12"
++     :
++       "+m" (*x),
++       "+m" (*y),
++       "+r" (n),	// 2
++       "+b" (x),	// 3
++       "+b" (y),	// 4
++       "=wa" (t0),	// 5
++       "=wa" (t1),	// 6
++       "=wa" (t2),	// 7
++       "=wa" (t3),	// 8
++       "=wa" (t4),	// 9
++       "=wa" (t5),	// 10
++       "=wa" (t6),	// 11
++       "=wa" (t7)	// 12
++     :
++       "f" (c),		// 13
++       "f" (s),		// 14
++       "b" (16),	// 15
++       "b" (32),	// 16
++       "b" (48)		// 17
++     :
++       "cr0",
++       "vs32","vs33","vs34","vs35","vs36","vs37",
++       "vs40","vs41","vs42","vs43","vs44","vs45","vs46","vs47",
++       "vs48","vs49","vs50","vs51"
++     );
++}
+diff --git a/kernel/power/sscal.c b/kernel/power/sscal.c
+index c6ef5e9..bd5cdc4 100644
+--- a/kernel/power/sscal.c
++++ b/kernel/power/sscal.c
+@@ -42,11 +42,10 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+ #if !defined(HAVE_KERNEL_16)
+ 
+-static void sscal_kernel_16( BLASLONG n, FLOAT *da , FLOAT *x )
++static void sscal_kernel_16 (BLASLONG n, FLOAT *x, FLOAT alpha)
+ {
+ 
+         BLASLONG i;
+-        FLOAT alpha = *da;
+ 
+         for( i=0; i<n; i+=8 )
+         {
+@@ -63,7 +62,7 @@ static void sscal_kernel_16( BLASLONG n, FLOAT *da , FLOAT *x )
+ 
+ }
+ 
+-static void sscal_kernel_16_zero( BLASLONG n, FLOAT *da , FLOAT *x )
++static void sscal_kernel_16_zero( BLASLONG n, FLOAT *x )
+ {
+ 
+         BLASLONG i;
+@@ -90,7 +89,6 @@ static void sscal_kernel_16_zero( BLASLONG n, FLOAT *da , FLOAT *x )
+ int CNAME(BLASLONG n, BLASLONG dummy0, BLASLONG dummy1, FLOAT da, FLOAT *x, BLASLONG inc_x, FLOAT *y, BLASLONG inc_y, FLOAT *dummy, BLASLONG dummy2)
+ {
+ 	BLASLONG i=0,j=0;
+-	FLOAT alpha[4] __attribute__ ((aligned (16)));;
+ 
+ 	if ( n <= 0 || inc_x <=0 )
+ 		return(0);
+@@ -105,11 +103,7 @@ int CNAME(BLASLONG n, BLASLONG dummy0, BLASLONG dummy1, FLOAT da, FLOAT *x, BLAS
+ 			BLASLONG n1 = n & -32;
+ 			if ( n1 > 0 )
+ 			{
+-				alpha[0]=da;
+-				alpha[1]=da;
+-				alpha[2]=da;
+-				alpha[3]=da;
+-				sscal_kernel_16_zero(n1 , alpha , x);
++				sscal_kernel_16_zero(n1, x);
+ 				j=n1;
+ 			}
+ 
+@@ -127,11 +121,7 @@ int CNAME(BLASLONG n, BLASLONG dummy0, BLASLONG dummy1, FLOAT da, FLOAT *x, BLAS
+ 			BLASLONG n1 = n & -32;
+ 			if ( n1 > 0 )
+ 			{
+-				alpha[0]=da;
+-				alpha[1]=da;
+-				alpha[2]=da;
+-				alpha[3]=da;
+-				sscal_kernel_16(n1 , alpha , x);
++				sscal_kernel_16(n1, x, da);
+ 				j=n1;
+ 			}
+ 			while(j < n)
+diff --git a/kernel/power/sscal_microk_power8.c b/kernel/power/sscal_microk_power8.c
+index 963cec7..49862a3 100644
+--- a/kernel/power/sscal_microk_power8.c
++++ b/kernel/power/sscal_microk_power8.c
+@@ -35,184 +35,150 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+ #define HAVE_KERNEL_16 1
+ 
+-static void sscal_kernel_16( BLASLONG n, FLOAT *alpha, FLOAT *x) __attribute__ ((noinline));
+-
+-static void sscal_kernel_16( BLASLONG n, FLOAT *alpha, FLOAT *x)
++static void sscal_kernel_16 (long n, float *x, float alpha)
+ {
+-
+-
+-	BLASLONG i = n;
+-	BLASLONG o16 = 16;
+-	BLASLONG o32 = 32;
+-	BLASLONG o48 = 48;
+-	BLASLONG o64 = 64;
+-	BLASLONG o80 = 80;
+-	BLASLONG o96 = 96;
+-	BLASLONG o112 = 112;
+-	FLOAT *x1=x;
+-	FLOAT *x2=x+1;
+-	BLASLONG pre = 384;
+-
+-	__asm__  __volatile__
+-	(
+-
+-        "lxvw4x         32, 0, %3                           \n\t"
+-        "addi           %1, %1, -4                          \n\t"
+-
+-	"dcbt		%2, %4				    \n\t"
+-
+-	"lxvw4x		40, 0, %2			    \n\t"
+-	"lxvw4x		41, %5, %2			    \n\t"
+-	"lxvw4x		42, %6, %2			    \n\t"
+-	"lxvw4x		43, %7, %2			    \n\t"
+-	"lxvw4x		44, %8, %2			    \n\t"
+-	"lxvw4x		45, %9, %2			    \n\t"
+-	"lxvw4x		46, %10, %2			    \n\t"
+-	"lxvw4x		47, %11, %2			    \n\t"
+-
+-	"addi		%2, %2, 128			    \n\t"
+-
+-	"addic.		%0 , %0	, -32  	 	             \n\t"
+-	"ble		2f		             	     \n\t"
+-
+-	".align 5				            \n\t"
+-	"1:				                    \n\t"
+-
+-	"dcbt		%2, %4				    \n\t"
+-
+-	"xvmulsp	48, 40, 32		    	    \n\t"
+-	"xvmulsp	49, 41, 32		    	    \n\t"
+-	"lxvw4x		40, 0, %2			    \n\t"
+-	"lxvw4x		41, %5, %2			    \n\t"
+-	"xvmulsp	50, 42, 32		    	    \n\t"
+-	"xvmulsp	51, 43, 32		    	    \n\t"
+-	"lxvw4x		42, %6, %2			    \n\t"
+-	"lxvw4x		43, %7, %2			    \n\t"
+-	"xvmulsp	52, 44, 32		    	    \n\t"
+-	"xvmulsp	53, 45, 32		    	    \n\t"
+-	"lxvw4x		44, %8, %2			    \n\t"
+-	"lxvw4x		45, %9, %2			    \n\t"
+-	"xvmulsp	54, 46, 32		    	    \n\t"
+-	"xvmulsp	55, 47, 32		    	    \n\t"
+-	"lxvw4x		46, %10, %2			    \n\t"
+-	"lxvw4x		47, %11, %2			    \n\t"
+-
+-	"stxvw4x	48, 0, %1			    \n\t"
+-	"stxvw4x	49, %5, %1			    \n\t"
+-	"stxvw4x	50, %6, %1			    \n\t"
+-	"stxvw4x	51, %7, %1			    \n\t"
+-	"stxvw4x	52, %8, %1			    \n\t"
+-	"stxvw4x	53, %9, %1			    \n\t"
+-	"stxvw4x	54, %10, %1			    \n\t"
+-	"stxvw4x	55, %11, %1			    \n\t"
+-
+-	"addi		%1, %1, 128			    \n\t"
+-	"addi		%2, %2, 128			    \n\t"
+-
+-	"addic.		%0 , %0	, -32  	 	             \n\t"
+-	"bgt		1b		             	     \n\t"
+-
+-	"2:						     \n\t"
+-
+-	"xvmulsp	48, 40, 32		    	    \n\t"
+-	"xvmulsp	49, 41, 32		    	    \n\t"
+-	"xvmulsp	50, 42, 32		    	    \n\t"
+-	"xvmulsp	51, 43, 32		    	    \n\t"
+-	"xvmulsp	52, 44, 32		    	    \n\t"
+-	"xvmulsp	53, 45, 32		    	    \n\t"
+-	"xvmulsp	54, 46, 32		    	    \n\t"
+-	"xvmulsp	55, 47, 32		    	    \n\t"
+-
+-	"stxvw4x	48, 0, %1			    \n\t"
+-	"stxvw4x	49, %5, %1			    \n\t"
+-	"stxvw4x	50, %6, %1			    \n\t"
+-	"stxvw4x	51, %7, %1			    \n\t"
+-	"stxvw4x	52, %8, %1			    \n\t"
+-	"stxvw4x	53, %9, %1			    \n\t"
+-	"stxvw4x	54, %10, %1			    \n\t"
+-	"stxvw4x	55, %11, %1			    \n\t"
+-
+-	:
+-        : 
+-          "r" (i),	// 0	
+-	  "r" (x2),  	// 1
+-          "r" (x1),     // 2
+-          "r" (alpha),  // 3
+-          "r" (pre),    // 4
+-	  "r" (o16),	// 5
+-	  "r" (o32),	// 6
+-	  "r" (o48),    // 7
+-          "r" (o64),    // 8
+-          "r" (o80),    // 9
+-          "r" (o96),    // 10
+-          "r" (o112)    // 11
+-	: "cr0", "%0", "%2" , "%1", "memory"
+-	);
+-
+-} 
+-
+-
+-static void sscal_kernel_16_zero( BLASLONG n, FLOAT *alpha, FLOAT *x) __attribute__ ((noinline));
+-
+-static void sscal_kernel_16_zero( BLASLONG n, FLOAT *alpha, FLOAT *x)
++  __asm__
++    (
++       "dcbt		0, %2		\n\t"
++
++       "xscvdpspn	%x3, %x3	\n\t"
++       "xxspltw		%x3, %x3, 0	\n\t"
++
++       "lxvw4x		32, 0, %2	\n\t"
++       "lxvw4x		33, %4, %2	\n\t"
++       "lxvw4x		34, %5, %2	\n\t"
++       "lxvw4x		35, %6, %2	\n\t"
++       "lxvw4x		36, %7, %2	\n\t"
++       "lxvw4x		37, %8, %2	\n\t"
++       "lxvw4x		38, %9, %2	\n\t"
++       "lxvw4x		39, %10, %2	\n\t"
++
++       "addi		%2, %2, 128	\n\t"
++
++       "addic.		%1, %1, -32	\n\t"
++       "ble		2f		\n\t"
++
++       ".p2align	5		\n"
++     "1:				\n\t"
++
++       "xvmulsp		40, 32, %x3	\n\t"
++       "xvmulsp		41, 33, %x3	\n\t"
++       "lxvw4x		32, 0, %2	\n\t"
++       "lxvw4x		33, %4, %2	\n\t"
++       "xvmulsp		42, 34, %x3	\n\t"
++       "xvmulsp		43, 35, %x3	\n\t"
++       "lxvw4x		34, %5, %2	\n\t"
++       "lxvw4x		35, %6, %2	\n\t"
++       "xvmulsp		44, 36, %x3	\n\t"
++       "xvmulsp		45, 37, %x3	\n\t"
++       "lxvw4x		36, %7, %2	\n\t"
++       "lxvw4x		37, %8, %2	\n\t"
++       "xvmulsp		46, 38, %x3	\n\t"
++       "xvmulsp		47, 39, %x3	\n\t"
++       "lxvw4x		38, %9, %2	\n\t"
++       "lxvw4x		39, %10, %2	\n\t"
++
++       "addi		%2, %2, -128	\n\t"
++
++       "stxvw4x		40, 0, %2	\n\t"
++       "stxvw4x		41, %4, %2	\n\t"
++       "stxvw4x		42, %5, %2	\n\t"
++       "stxvw4x		43, %6, %2	\n\t"
++       "stxvw4x		44, %7, %2	\n\t"
++       "stxvw4x		45, %8, %2	\n\t"
++       "stxvw4x		46, %9, %2	\n\t"
++       "stxvw4x		47, %10, %2	\n\t"
++
++       "addi		%2, %2, 256	\n\t"
++
++       "addic.		%1, %1, -32	\n\t"
++       "bgt		1b		\n"
++
++     "2:				\n\t"
++
++       "xvmulsp		40, 32, %x3	\n\t"
++       "xvmulsp		41, 33, %x3	\n\t"
++       "xvmulsp		42, 34, %x3	\n\t"
++       "xvmulsp		43, 35, %x3	\n\t"
++
++       "addi		%2, %2, -128	\n\t"
++
++       "xvmulsp		44, 36, %x3	\n\t"
++       "xvmulsp		45, 37, %x3	\n\t"
++       "xvmulsp		46, 38, %x3	\n\t"
++       "xvmulsp		47, 39, %x3	\n\t"
++
++       "stxvw4x		40, 0, %2	\n\t"
++       "stxvw4x		41, %4, %2	\n\t"
++       "stxvw4x		42, %5, %2	\n\t"
++       "stxvw4x		43, %6, %2	\n\t"
++       "stxvw4x		44, %7, %2	\n\t"
++       "stxvw4x		45, %8, %2	\n\t"
++       "stxvw4x		46, %9, %2	\n\t"
++       "stxvw4x		47, %10, %2	\n"
++
++     "#n=%1 alpha=%3 x=%0=%2 o16=%4 o32=%5 o48=%6 o64=%7 o80=%8 o96=%9 o112=%10"
++     :
++       "+m" (*x),
++       "+r" (n),	// 1
++       "+b" (x),	// 2
++       "+f" (alpha)	// 3
++     :
++       "b" (16),	// 4
++       "b" (32),	// 5
++       "b" (48),	// 6
++       "b" (64),	// 7
++       "b" (80),	// 8
++       "b" (96),	// 9
++       "b" (112)	// 10
++     :
++       "cr0",
++       "vs32","vs33","vs34","vs35","vs36","vs37","vs38","vs39",
++       "vs40","vs41","vs42","vs43","vs44","vs45","vs46","vs47"
++     );
++}
++
++
++static void sscal_kernel_16_zero (long n, float *x)
+ {
+-
+-
+-	BLASLONG i = n;
+-	BLASLONG o16 = 16;
+-	BLASLONG o32 = 32;
+-	BLASLONG o48 = 48;
+-	BLASLONG o64 = 64;
+-	BLASLONG o80 = 80;
+-	BLASLONG o96 = 96;
+-	BLASLONG o112 = 112;
+-	FLOAT *x1=x;
+-	FLOAT *x2=x+1;
+-	BLASLONG pre = 384;
+-
+-	__asm__  __volatile__
+-	(
+-
+-	"xxlxor		32 , 32 , 32			    \n\t"
+-        "addi           %1, %1, -4                          \n\t"
+-
+-
+-	".align 5				            \n\t"
+-	"1:				                    \n\t"
+-
+-	"stxvw4x	32, 0, %1			    \n\t"
+-	"stxvw4x	32, %5, %1			    \n\t"
+-	"stxvw4x	32, %6, %1			    \n\t"
+-	"stxvw4x	32, %7, %1			    \n\t"
+-	"stxvw4x	32, %8, %1			    \n\t"
+-	"stxvw4x	32, %9, %1			    \n\t"
+-	"stxvw4x	32, %10, %1			    \n\t"
+-	"stxvw4x	32, %11, %1			    \n\t"
+-
+-	"addi		%1, %1, 128			    \n\t"
+-
+-	"addic.		%0 , %0	, -32  	 	             \n\t"
+-	"bgt		1b		             	     \n\t"
+-
+-	"2:						     \n\t"
+-
+-	:
+-        : 
+-          "r" (i),	// 0	
+-	  "r" (x2),  	// 1
+-          "r" (x1),     // 2
+-          "r" (alpha),  // 3
+-          "r" (pre),    // 4
+-	  "r" (o16),	// 5
+-	  "r" (o32),	// 6
+-	  "r" (o48),    // 7
+-          "r" (o64),    // 8
+-          "r" (o80),    // 9
+-          "r" (o96),    // 10
+-          "r" (o112)    // 11
+-	: "cr0", "%0", "%2" , "%1", "memory"
+-	);
+-
+-} 
+-
+-
++  __vector float t0;
++
++  __asm__
++    (
++       "xxlxor		%x3, %x3, %x3	\n\t"
++
++       ".p2align	5		\n"
++     "1:				\n\t"
++
++       "stxvw4x		%x3, 0, %2	\n\t"
++       "stxvw4x		%x3, %4, %2	\n\t"
++       "stxvw4x		%x3, %5, %2	\n\t"
++       "stxvw4x		%x3, %6, %2	\n\t"
++       "stxvw4x		%x3, %7, %2	\n\t"
++       "stxvw4x		%x3, %8, %2	\n\t"
++       "stxvw4x		%x3, %9, %2	\n\t"
++       "stxvw4x		%x3, %10, %2	\n\t"
++
++       "addi		%2, %2, 128	\n\t"
++
++       "addic.		%1, %1, -32	\n\t"
++       "bgt		1b		\n"
++
++     "#n=%1 x=%0=%2 t0=%x3 o16=%4 o32=%5 o48=%6 o64=%7 o80=%8 o96=%9 o112=%10"
++     :
++       "=m" (*x),
++       "+r" (n),	// 1
++       "+b" (x),	// 2
++       "=wa" (t0)	// 3
++     :
++       "b" (16),	// 4
++       "b" (32),	// 5
++       "b" (48),	// 6
++       "b" (64),	// 7
++       "b" (80),	// 8
++       "b" (96),	// 9
++       "b" (112)	// 10
++     :
++       "cr0"
++     );
++}
+diff --git a/kernel/power/sswap_microk_power8.c b/kernel/power/sswap_microk_power8.c
+index c48e743..d44f167 100644
+--- a/kernel/power/sswap_microk_power8.c
++++ b/kernel/power/sswap_microk_power8.c
+@@ -35,102 +35,74 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+ #define HAVE_KERNEL_32 1
+ 
+-static void sswap_kernel_32( BLASLONG n, FLOAT *x, FLOAT *y) __attribute__ ((noinline));
+-
+-static void sswap_kernel_32( BLASLONG n, FLOAT *x, FLOAT *y)
++static void sswap_kernel_32 (long n, float *x, float *y)
+ {
+-
+-
+-	BLASLONG i = n;
+-	BLASLONG o16 = 16;
+-	BLASLONG o32 = 32;
+-	BLASLONG o48 = 48;
+-	BLASLONG o64 = 64;
+-	BLASLONG o80 = 80;
+-	BLASLONG o96 = 96;
+-	BLASLONG o112 = 112;
+-	FLOAT *x1=x;
+-	FLOAT *y1=y;
+-	FLOAT *x2=x+1;
+-	FLOAT *y2=y+1;
+-	BLASLONG pre = 384;
+-	BLASLONG alpha=0;
+-
+-	__asm__  __volatile__
+-	(
+-
+-	"addi		%3, %3, -4			    \n\t"	
+-	"addi		%4, %4, -4			    \n\t"	
+-
+-	".align 5				            \n\t"
+-	"1:				                    \n\t"
+-
+-	"lxvw4x		32, 0, %2			    \n\t"
+-	"lxvw4x		33, %5, %2			    \n\t"
+-	"lxvw4x		34, %6, %2			    \n\t"
+-	"lxvw4x		35, %7, %2			    \n\t"
+-	"lxvw4x		36, %8, %2			    \n\t"
+-	"lxvw4x		37, %9, %2			    \n\t"
+-	"lxvw4x		38, %10, %2			    \n\t"
+-	"lxvw4x		39, %11, %2			    \n\t"
+-
+-	"addi		%2, %2, 128			    \n\t"
+-
+-	"lxvw4x		48, 0, %1			    \n\t"
+-	"lxvw4x		49, %5, %1			    \n\t"
+-	"lxvw4x		50, %6, %1			    \n\t"
+-	"lxvw4x		51, %7, %1			    \n\t"
+-	"lxvw4x		52, %8, %1			    \n\t"
+-	"lxvw4x		53, %9, %1			    \n\t"
+-	"lxvw4x		54, %10, %1			    \n\t"
+-	"lxvw4x		55, %11, %1			    \n\t"
+-
+-	"addi		%1, %1, 128			    \n\t"
+-
+-	"stxvw4x		32, 0, %3			    \n\t"
+-	"stxvw4x		33, %5, %3			    \n\t"
+-	"stxvw4x		34, %6, %3			    \n\t"
+-	"stxvw4x		35, %7, %3			    \n\t"
+-	"stxvw4x		36, %8, %3			    \n\t"
+-	"stxvw4x		37, %9, %3			    \n\t"
+-	"stxvw4x		38, %10, %3			    \n\t"
+-	"stxvw4x		39, %11, %3			    \n\t"
+-
+-	"addi		%3, %3, 128			    \n\t"
+-
+-	"stxvw4x		48, 0, %4			    \n\t"
+-	"stxvw4x		49, %5, %4			    \n\t"
+-	"stxvw4x		50, %6, %4			    \n\t"
+-	"stxvw4x		51, %7, %4			    \n\t"
+-	"stxvw4x		52, %8, %4			    \n\t"
+-	"stxvw4x		53, %9, %4			    \n\t"
+-	"stxvw4x		54, %10, %4			    \n\t"
+-	"stxvw4x		55, %11, %4			    \n\t"
+-
+-	"addi		%4, %4, 128			    \n\t"
+-
+-	"addic.		%0 , %0	, -32  	 	             \n\t"
+-	"bgt		1b		             	     \n\t"
+-
+-	"2:						     \n\t"
+-
+-	:
+-        : 
+-          "r" (i),	// 0	
+-	  "r" (y1),  	// 1
+-          "r" (x1),     // 2
+-          "r" (y2),     // 3
+-          "r" (x2),     // 4
+-	  "r" (o16),	// 5
+-	  "r" (o32),	// 6
+-	  "r" (o48),    // 7
+-          "r" (o64),    // 8
+-          "r" (o80),    // 9
+-          "r" (o96),    // 10
+-          "r" (o112)    // 11
+-	: "cr0", "%0", "%2" , "%1", "%3", "%4", "memory"
+-	);
+-
+-} 
+-
+-
++  __asm__
++    (
++       ".p2align	5		\n"
++     "1:				\n\t"
++
++       "lxvw4x		32, 0, %4	\n\t"
++       "lxvw4x		33, %5, %4	\n\t"
++       "lxvw4x		34, %6, %4	\n\t"
++       "lxvw4x		35, %7, %4	\n\t"
++       "lxvw4x		36, %8, %4	\n\t"
++       "lxvw4x		37, %9, %4	\n\t"
++       "lxvw4x		38, %10, %4	\n\t"
++       "lxvw4x		39, %11, %4	\n\t"
++
++       "lxvw4x		40, 0, %3	\n\t"
++       "lxvw4x		41, %5, %3	\n\t"
++       "lxvw4x		42, %6, %3	\n\t"
++       "lxvw4x		43, %7, %3	\n\t"
++       "lxvw4x		44, %8, %3	\n\t"
++       "lxvw4x		45, %9, %3	\n\t"
++       "lxvw4x		46, %10, %3	\n\t"
++       "lxvw4x		47, %11, %3	\n\t"
++
++       "stxvw4x		32, 0, %3	\n\t"
++       "stxvw4x		33, %5, %3	\n\t"
++       "stxvw4x		34, %6, %3	\n\t"
++       "stxvw4x		35, %7, %3	\n\t"
++       "stxvw4x		36, %8, %3	\n\t"
++       "stxvw4x		37, %9, %3	\n\t"
++       "stxvw4x		38, %10, %3	\n\t"
++       "stxvw4x		39, %11, %3	\n\t"
++
++       "addi		%3, %3, 128	\n\t"
++
++       "stxvw4x		40, 0, %4	\n\t"
++       "stxvw4x		41, %5, %4	\n\t"
++       "stxvw4x		42, %6, %4	\n\t"
++       "stxvw4x		43, %7, %4	\n\t"
++       "stxvw4x		44, %8, %4	\n\t"
++       "stxvw4x		45, %9, %4	\n\t"
++       "stxvw4x		46, %10, %4	\n\t"
++       "stxvw4x		47, %11, %4	\n\t"
++
++       "addi		%4, %4, 128	\n\t"
++
++       "addic.		%2, %2, -32	\n\t"
++       "bgt		1b		\n"
++
++     "#n=%2 x=%0=%3 y=%1=%4 o16=%5 o32=%6 o48=%7 o64=%8 o80=%9 o96=%10 o112=%11"
++     :
++       "+m" (*x),
++       "+m" (*y),
++       "+r" (n),	// 2
++       "+b" (x),	// 3
++       "+b" (y)		// 4
++     :
++       "b" (16),	// 5
++       "b" (32),	// 6
++       "b" (48),	// 7
++       "b" (64),	// 8
++       "b" (80),	// 9
++       "b" (96),	// 10
++       "b" (112)	// 11
++     :
++       "cr0",
++       "vs32","vs33","vs34","vs35","vs36","vs37","vs38","vs39",
++       "vs40","vs41","vs42","vs43","vs44","vs45","vs46","vs47"
++     );
++}
+diff --git a/kernel/power/zasum.c b/kernel/power/zasum.c
+index abd6ec0..0b6b87d 100644
+--- a/kernel/power/zasum.c
++++ b/kernel/power/zasum.c
+@@ -53,7 +53,7 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+ #ifndef HAVE_KERNEL_8
+ 
+-static void zasum_kernel_8(BLASLONG n, FLOAT *x1, FLOAT *svec)
++static FLOAT zasum_kernel_8(BLASLONG n, FLOAT *x1)
+ {
+ 
+ 	BLASLONG i=0;
+@@ -92,9 +92,7 @@ static void zasum_kernel_8(BLASLONG n, FLOAT *x1, FLOAT *svec)
+ 
+ 	}
+ 
+-	svec[0] = sum0+sum1+sum2+sum3;
+-	svec[1] = 0.0;
+-
++	return sum0+sum1+sum2+sum3;
+ }
+ 
+ #endif
+@@ -104,7 +102,6 @@ FLOAT CNAME(BLASLONG n, FLOAT *x, BLASLONG inc_x)
+ 	BLASLONG i=0;
+ 	BLASLONG ip=0;
+ 	FLOAT sumf = 0.0;
+-	FLOAT svec[2] __attribute__ ((aligned (16)));;
+ 	BLASLONG n1;
+ 	BLASLONG inc_x2;
+ 
+@@ -117,8 +114,7 @@ FLOAT CNAME(BLASLONG n, FLOAT *x, BLASLONG inc_x)
+ 		if ( n1 > 0 )
+ 		{
+ 
+-			zasum_kernel_8(n1, x, svec);
+-			sumf = svec[0] + svec[1];
++			sumf = zasum_kernel_8(n1, x);
+ 			i=n1;
+ 			ip=2*n1;
+ 		}
+diff --git a/kernel/power/zasum_microk_power8.c b/kernel/power/zasum_microk_power8.c
+index b9f6c0a..8236690 100644
+--- a/kernel/power/zasum_microk_power8.c
++++ b/kernel/power/zasum_microk_power8.c
+@@ -34,144 +34,140 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ **************************************************************************************/
+ 
+ #define HAVE_KERNEL_8 1
+-static void zasum_kernel_8( BLASLONG n, FLOAT *x, FLOAT *svec) __attribute__ ((noinline));
+ 
+-static void zasum_kernel_8( BLASLONG n, FLOAT *x, FLOAT *svec)
++static double zasum_kernel_8 (long n, double *x)
+ {
+-
+-
+-	BLASLONG i = n;
+-	BLASLONG o16 = 16;
+-	BLASLONG o32 = 32;
+-	BLASLONG o48 = 48;
+-	BLASLONG o64 = 64;
+-	BLASLONG o80 = 80;
+-	BLASLONG o96 = 96;
+-	BLASLONG o112 = 112;
+-	FLOAT *x1=x;
+-	BLASLONG pre = 384;
+-
+-	__asm__  __volatile__
+-	(
+-
+-	"dcbt		%2 , %4				    \n\t"
+-
+-	"xxlxor		32,32,32			    \n\t"
+-	"xxlxor		33,33,33			    \n\t"
+-	"xxlxor		34,34,34			    \n\t"
+-	"xxlxor		35,35,35			    \n\t"
+-	"xxlxor		36,36,36			    \n\t"
+-	"xxlxor		37,37,37			    \n\t"
+-	"xxlxor		38,38,38			    \n\t"
+-	"xxlxor		39,39,39			    \n\t"
+-
+-	"lxvd2x		40, 0, %2			    \n\t"
+-	"lxvd2x		41, %5, %2			    \n\t"
+-	"lxvd2x		42, %6, %2			    \n\t"
+-	"lxvd2x		43, %7, %2			    \n\t"
+-	"lxvd2x		44, %8, %2			    \n\t"
+-	"lxvd2x		45, %9, %2			    \n\t"
+-	"lxvd2x		46, %10, %2			    \n\t"
+-	"lxvd2x		47, %11, %2			    \n\t"
+-
+-	"addi		%2, %2, 128			    \n\t"
+-
+-	"addic.		%0 , %0	, -8  	 	             \n\t"
+-	"ble		2f		             	     \n\t"
+-
+-	".align 5				            \n\t"
+-	"1:				                    \n\t"
+-
+-	"dcbt		%2 , %4				    \n\t"
+-
+-	"xvabsdp	48, 40				    \n\t"
+-	"xvabsdp	49, 41				    \n\t"
+-	"xvabsdp	50, 42				    \n\t"
+-	"xvabsdp	51, 43				    \n\t"
+-
+-	"lxvd2x		40, 0, %2			    \n\t"
+-	"lxvd2x		41, %5, %2			    \n\t"
+-
+-	"xvabsdp	52, 44				    \n\t"
+-	"xvabsdp	53, 45				    \n\t"
+-
+-	"lxvd2x		42, %6, %2			    \n\t"
+-	"lxvd2x		43, %7, %2			    \n\t"
+-
+-	"xvabsdp	54, 46				    \n\t"
+-	"xvabsdp	55, 47				    \n\t"
+-
+-	"lxvd2x		44, %8, %2			    \n\t"
+-	"lxvd2x		45, %9, %2			    \n\t"
+-
+-	"xvadddp	32, 32, 48		    \n\t"
+-	"xvadddp	33, 33, 49		    \n\t"
+-
+-	"lxvd2x		46, %10, %2			    \n\t"
+-	"lxvd2x		47, %11, %2			    \n\t"
+-
+-	"xvadddp	34, 34, 50		    \n\t"
+-	"xvadddp	35, 35, 51		    \n\t"
+-	"addi		%2, %2, 128			    \n\t"
+-	"xvadddp	36, 36, 52		    \n\t"
+-	"xvadddp	37, 37, 53		    \n\t"
+-	"addic.		%0 , %0	, -8  	 	             \n\t"
+-	"xvadddp	38, 38, 54		    \n\t"
+-	"xvadddp	39, 39, 55		    \n\t"
+-
+-	"bgt		1b		             	     \n\t"
+-
+-	"2:						     \n\t"
+-
+-
+-	"xvabsdp	48, 40				    \n\t"
+-	"xvabsdp	49, 41				    \n\t"
+-	"xvabsdp	50, 42				    \n\t"
+-	"xvabsdp	51, 43				    \n\t"
+-	"xvabsdp	52, 44				    \n\t"
+-	"xvabsdp	53, 45				    \n\t"
+-	"xvabsdp	54, 46				    \n\t"
+-	"xvabsdp	55, 47				    \n\t"
+-
+-	"xvadddp	32, 32, 48		    \n\t"
+-	"xvadddp	33, 33, 49		    \n\t"
+-	"xvadddp	34, 34, 50		    \n\t"
+-	"xvadddp	35, 35, 51		    \n\t"
+-	"xvadddp	36, 36, 52		    \n\t"
+-	"xvadddp	37, 37, 53		    \n\t"
+-	"xvadddp	38, 38, 54		    \n\t"
+-	"xvadddp	39, 39, 55		    \n\t"
+-
+-	"xvadddp	32, 32, 33		     \n\t"
+-	"xvadddp	34, 34, 35		     \n\t"
+-	"xvadddp	36, 36, 37		     \n\t"
+-	"xvadddp	38, 38, 39		     \n\t"
+-
+-	"xvadddp	32, 32, 34		     \n\t"
+-	"xvadddp	36, 36, 38		     \n\t"
+-
+-	"xvadddp	32, 32, 36		     \n\t"
+-
+-
+-	"stxvd2x	32, 0, %3		     \n\t"
+-
+-	:
+-        : 
+-          "r" (i),	// 0	
+-	  "r" (n),  	// 1
+-          "r" (x1),     // 2
+-          "r" (svec),   // 3
+-          "r" (pre),    // 4
+-	  "r" (o16),	// 5
+-	  "r" (o32),	// 6
+-	  "r" (o48),    // 7
+-          "r" (o64),    // 8
+-          "r" (o80),    // 9
+-          "r" (o96),    // 10
+-          "r" (o112)   // 11
+-	: "cr0", "%0", "%2",  "memory"
+-	);
+-
+-} 
+-
+-
++  double sum;
++  __vector double t0;
++  __vector double t1;
++  __vector double t2;
++  __vector double t3;
++
++  __asm__
++    (
++       "dcbt		0, %2		\n\t"
++
++       "xxlxor		32, 32,	32	\n\t"
++       "xxlxor		33, 33,	33	\n\t"
++       "xxlxor		34, 34,	34	\n\t"
++       "xxlxor		35, 35,	35	\n\t"
++       "xxlxor		36, 36,	36	\n\t"
++       "xxlxor		37, 37,	37	\n\t"
++       "xxlxor		38, 38,	38	\n\t"
++       "xxlxor		39, 39,	39	\n\t"
++
++       "lxvd2x		40, 0, %2	\n\t"
++       "lxvd2x		41, %8, %2	\n\t"
++       "lxvd2x		42, %9, %2	\n\t"
++       "lxvd2x		43, %10, %2	\n\t"
++       "lxvd2x		44, %11, %2	\n\t"
++       "lxvd2x		45, %12, %2	\n\t"
++       "lxvd2x		46, %13, %2	\n\t"
++       "lxvd2x		47, %14, %2	\n\t"
++
++       "addi		%2, %2, 128	\n\t"
++
++       "addic.		%1, %1, -8	\n\t"
++       "ble		2f		\n\t"
++
++       ".p2align	5		\n"
++     "1:				\n\t"
++
++       "xvabsdp		48, 40		\n\t"
++       "xvabsdp		49, 41		\n\t"
++       "xvabsdp		50, 42		\n\t"
++       "xvabsdp		51, 43		\n\t"
++
++       "lxvd2x		40, 0, %2	\n\t"
++       "lxvd2x		41, %8, %2	\n\t"
++
++       "xvabsdp		%x3, 44		\n\t"
++       "xvabsdp		%x4, 45		\n\t"
++
++       "lxvd2x		42, %9, %2	\n\t"
++       "lxvd2x		43, %10, %2	\n\t"
++
++       "xvabsdp		%x5, 46		\n\t"
++       "xvabsdp		%x6, 47		\n\t"
++
++       "lxvd2x		44, %11, %2	\n\t"
++       "lxvd2x		45, %12, %2	\n\t"
++
++       "xvadddp		32, 32, 48	\n\t"
++       "xvadddp		33, 33, 49	\n\t"
++
++       "lxvd2x		46, %13, %2	\n\t"
++       "lxvd2x		47, %14, %2	\n\t"
++
++       "xvadddp		34, 34, 50	\n\t"
++       "xvadddp		35, 35, 51	\n\t"
++       "addi		%2, %2, 128	\n\t"
++       "xvadddp		36, 36, %x3	\n\t"
++       "xvadddp		37, 37, %x4	\n\t"
++       "addic.		%1, %1, -8	\n\t"
++       "xvadddp		38, 38, %x5	\n\t"
++       "xvadddp		39, 39, %x6	\n\t"
++
++       "bgt		1b		\n"
++
++     "2:				\n\t"
++
++       "xvabsdp		48, 40		\n\t"
++       "xvabsdp		49, 41		\n\t"
++       "xvabsdp		50, 42		\n\t"
++       "xvabsdp		51, 43		\n\t"
++       "xvabsdp		%x3, 44		\n\t"
++       "xvabsdp		%x4, 45		\n\t"
++       "xvabsdp		%x5, 46		\n\t"
++       "xvabsdp		%x6, 47		\n\t"
++
++       "xvadddp		32, 32, 48	\n\t"
++       "xvadddp		33, 33, 49	\n\t"
++       "xvadddp		34, 34, 50	\n\t"
++       "xvadddp		35, 35, 51	\n\t"
++       "xvadddp		36, 36, %x3	\n\t"
++       "xvadddp		37, 37, %x4	\n\t"
++       "xvadddp		38, 38, %x5	\n\t"
++       "xvadddp		39, 39, %x6	\n\t"
++
++       "xvadddp		32, 32, 33	\n\t"
++       "xvadddp		34, 34, 35	\n\t"
++       "xvadddp		36, 36, 37	\n\t"
++       "xvadddp		38, 38, 39	\n\t"
++
++       "xvadddp		32, 32, 34	\n\t"
++       "xvadddp		36, 36, 38	\n\t"
++
++       "xvadddp		32, 32, 36	\n\t"
++
++       "xxswapd		33, 32		\n\t"
++       "xsadddp		%x0, 32, 33	\n"
++
++     "#n=%1 x=%3=%2 sum=%0 o16=%8 o32=%9 o48=%10 o64=%11 o80=%12 o96=%13 o112=%14\n"
++     "#t0=%x3 t1=%x4 t2=%x5 t3=%x6"
++     :
++       "=d" (sum),	// 0
++       "+r" (n),	// 1
++       "+b" (x),	// 2
++       "=wa" (t0),	// 3
++       "=wa" (t1),	// 4
++       "=wa" (t2),	// 5
++       "=wa" (t3)	// 6
++     :
++       "m" (*x),
++       "b" (16),	// 8
++       "b" (32),	// 9
++       "b" (48),	// 10
++       "b" (64),	// 11
++       "b" (80),	// 12
++       "b" (96),	// 13
++       "b" (112)	// 14
++     :
++       "cr0",
++       "vs32","vs33","vs34","vs35","vs36","vs37","vs38","vs39",
++       "vs40","vs41","vs42","vs43","vs44","vs45","vs46","vs47",
++       "vs48","vs49","vs50","vs51"
++     );
++
++  return sum;
++}
+diff --git a/kernel/power/zaxpy.c b/kernel/power/zaxpy.c
+index 0ee0c1b..dd7ab6c 100644
+--- a/kernel/power/zaxpy.c
++++ b/kernel/power/zaxpy.c
+@@ -78,7 +78,6 @@ int CNAME(BLASLONG n, BLASLONG dummy0, BLASLONG dummy1, FLOAT da_r, FLOAT da_i,
+ {
+ 	BLASLONG i=0;
+ 	BLASLONG ix=0,iy=0;
+-	FLOAT da[4];
+ 
+ 	if ( n <= 0 )  return(0);
+ 
+@@ -89,11 +88,7 @@ int CNAME(BLASLONG n, BLASLONG dummy0, BLASLONG dummy1, FLOAT da_r, FLOAT da_i,
+ 
+ 		if ( n1 )
+ 		{
+-			da[0] = da_r;
+-			da[1] = da_r;
+-			da[2] = da_i;
+-			da[3] = da_i;
+-			zaxpy_kernel_4(n1, x, y , da );
++			zaxpy_kernel_4 (n1, x, y, da_r, da_i);
+ 			ix = 2 * n1;
+ 		}
+ 		i = n1;
+diff --git a/kernel/power/zaxpy_microk_power8.c b/kernel/power/zaxpy_microk_power8.c
+index c8a529f..124614f 100644
+--- a/kernel/power/zaxpy_microk_power8.c
++++ b/kernel/power/zaxpy_microk_power8.c
+@@ -35,216 +35,225 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+ 
+ #define HAVE_KERNEL_4 1
+-static void zaxpy_kernel_4( BLASLONG n, FLOAT *x, FLOAT *y , FLOAT *alpha) __attribute__ ((noinline));
+-
+-static void zaxpy_kernel_4( BLASLONG n, FLOAT *x, FLOAT *y, FLOAT *alpha)
++static void zaxpy_kernel_4 (long n, double *x, double *y,
++			    double alpha_r, double alpha_i)
+ {
+-
+-
+-	BLASLONG i = n;
+-	BLASLONG o16 = 16;
+-	BLASLONG o32 = 32;
+-	BLASLONG o48 = 48;
+-	FLOAT *x1=x;
+-	FLOAT *y1=y;
+-	FLOAT *y2=y+1;
+-	BLASLONG pre = 384;
+-
+ #if !defined(CONJ)
+-        FLOAT mvec[2] = { -1.0, 1.0 };
++  static const double mvec[2] = { -1.0, 1.0 };
+ #else
+-        FLOAT mvec[2] = { 1.0, -1.0 };
++  static const double mvec[2] = { 1.0, -1.0 };
+ #endif
+-
+-
+-	__asm__  __volatile__
+-	(
+-
+-	"lxsdx		34, 0 , %4			    \n\t"	// alpha_r
+-	"lxsdx		35, %5, %4			    \n\t"	// alpha_i
+-	"xxspltd	32, 34, 0			    \n\t"
+-	"xxspltd	33, 35, 0			    \n\t"
+-
+-	"lxvd2x		36, 0,	%9			    \n\t"	// mvec
++  const double *mvecp = mvec;
++
++  __vector double t0;
++  __vector double t1;
++  __vector double t2;
++  __vector double t3;
++  __vector double t4;
++  __vector double t5;
++  __vector double t6;
++  __vector double t7;
++  __vector double t8;
++  __vector double t9;
++  __vector double t10;
++  __vector double t11;
++  long ytmp;
++
++  __asm__
++    (
++       "xxspltd		32, %x19, 0	\n\t"	// alpha_r
++       "xxspltd		33, %x20, 0	\n\t"	// alpha_i
++
++       "lxvd2x		36, 0, %21	\n\t"	// mvec
+ 
+ #if !defined(CONJ)
+-        "xvmuldp         33, 33  , 36               	    \n\t"	// alpha_i * mvec
++       "xvmuldp		33, 33, 36	\n\t"	// alpha_i * mvec
+ #else
+-        "xvmuldp         32, 32  , 36               	    \n\t"	// alpha_r * mvec
++       "xvmuldp		32, 32, 36	\n\t"	// alpha_r * mvec
+ #endif
+ 
+-	"addi		%8, %8, -8			    \n\t"
+-
+-	"dcbt		%2, %10				    \n\t"
+-	"dcbt		%3, %10				    \n\t"
+-
+-
+-	"lxvd2x		40, 0, %2			    \n\t"       // x0
+-	"lxvd2x		41, %5, %2			    \n\t"	// x1
+-	"lxvd2x		42, %6, %2			    \n\t"	// x2
+-	"lxvd2x		43, %7, %2			    \n\t"	// x3
+-
+-	"lxvd2x		48, 0, %3			    \n\t"	// y0
+-	"lxvd2x		49, %5, %3			    \n\t"	// y1
+-	"lxvd2x		50, %6, %3			    \n\t"	// y2
+-	"lxvd2x		51, %7, %3			    \n\t"	// y3
+-
+-	"xxswapd	56, 40				    \n\t"	// exchange real and imag part
+-	"xxswapd	57, 41				    \n\t"	// exchange real and imag part
+-	"xxswapd	58, 42				    \n\t"	// exchange real and imag part
+-	"xxswapd	59, 43				    \n\t"	// exchange real and imag part
+-
+-	"addi		%2, %2, 64			    \n\t"
+-	"addi		%3, %3, 64			    \n\t"
+-
+-	"lxvd2x		44, 0, %2			    \n\t"	// x4
+-	"lxvd2x		45, %5, %2			    \n\t"	// x5
+-	"lxvd2x		46, %6, %2			    \n\t"	// x6
+-	"lxvd2x		47, %7, %2			    \n\t"	// x7
+-
+-	"lxvd2x		52, 0, %3			    \n\t"	// y4
+-	"lxvd2x		53, %5, %3			    \n\t"	// y5
+-	"lxvd2x		54, %6, %3			    \n\t"	// y6
+-	"lxvd2x		55, %7, %3			    \n\t"	// y7
+-
+-	"xxswapd	60, 44				    \n\t"	// exchange real and imag part
+-	"xxswapd	61, 45				    \n\t"	// exchange real and imag part
+-	"xxswapd	62, 46				    \n\t"	// exchange real and imag part
+-	"xxswapd	63, 47				    \n\t"	// exchange real and imag part
+-
+-	"addi		%2, %2, 64			    \n\t"
+-	"addi		%3, %3, 64			    \n\t"
+-
+-	"addic.		%0 , %0	, -8  	 	             \n\t"
+-	"ble		2f		             	     \n\t"
+-
+-	".align 5				            \n\t"
+-	"1:				                    \n\t"
+-
+-	"dcbt		%2, %10				    \n\t"
+-	"dcbt		%3, %10				    \n\t"
+-
+-	"xvmaddadp	48, 40, 32		    	    \n\t"	// alpha_r * x0_r , alpha_r * x0_i
+-	"xvmaddadp	49, 41, 32		    	    \n\t"
+-	"lxvd2x		40, 0, %2			    \n\t"       // x0
+-	"lxvd2x		41, %5, %2			    \n\t"	// x1
+-	"xvmaddadp	50, 42, 32		    	    \n\t"
+-	"xvmaddadp	51, 43, 32		    	    \n\t"
+-	"lxvd2x		42, %6, %2			    \n\t"	// x2
+-	"lxvd2x		43, %7, %2			    \n\t"	// x3
+-
+-	"xvmaddadp	52, 44, 32		    	    \n\t"
+-	"addi		%2, %2, 64			    \n\t"
+-	"xvmaddadp	53, 45, 32		    	    \n\t"
+-	"lxvd2x		44, 0, %2			    \n\t"	// x4
+-	"lxvd2x		45, %5, %2			    \n\t"	// x5
+-	"xvmaddadp	54, 46, 32		    	    \n\t"
+-	"xvmaddadp	55, 47, 32		    	    \n\t"
+-	"lxvd2x		46, %6, %2			    \n\t"	// x6
+-	"lxvd2x		47, %7, %2			    \n\t"	// x7
+-
+-	"xvmaddadp	48, 56, 33		    	    \n\t"	// alpha_i * x0_i , alpha_i * x0_r
+-	"addi		%2, %2, 64			    \n\t"
+-	"xvmaddadp	49, 57, 33		    	    \n\t"
+-	"xvmaddadp	50, 58, 33		    	    \n\t"
+-	"xvmaddadp	51, 59, 33		    	    \n\t"
+-
+-	"xvmaddadp	52, 60, 33		    	    \n\t"
+-	"xvmaddadp	53, 61, 33		    	    \n\t"
+-	"xvmaddadp	54, 62, 33		    	    \n\t"
+-	"xvmaddadp	55, 63, 33		    	    \n\t"
+-
+-	"stxvd2x	48,  0, %8			    \n\t"
+-	"stxvd2x	49, %5, %8			    \n\t"
+-	"stxvd2x	50, %6, %8			    \n\t"
+-	"stxvd2x	51, %7, %8			    \n\t"
+-
+-	"addi		%8, %8, 64			    \n\t"
+-
+-	"stxvd2x	52,  0, %8			    \n\t"
+-	"stxvd2x	53, %5, %8			    \n\t"
+-	"stxvd2x	54, %6, %8			    \n\t"
+-	"stxvd2x	55, %7, %8			    \n\t"
+-
+-	"addi		%8, %8, 64			    \n\t"
+-
+-	"xxswapd	56, 40				    \n\t"	// exchange real and imag part
+-	"xxswapd	57, 41				    \n\t"	// exchange real and imag part
+-	"lxvd2x		48, 0, %3			    \n\t"	// y0
+-	"lxvd2x		49, %5, %3			    \n\t"	// y1
+-	"xxswapd	58, 42				    \n\t"	// exchange real and imag part
+-	"xxswapd	59, 43				    \n\t"	// exchange real and imag part
+-	"lxvd2x		50, %6, %3			    \n\t"	// y2
+-	"lxvd2x		51, %7, %3			    \n\t"	// y3
+-
+-	"xxswapd	60, 44				    \n\t"	// exchange real and imag part
+-	"addi		%3, %3, 64			    \n\t"
+-	"xxswapd	61, 45				    \n\t"	// exchange real and imag part
+-	"lxvd2x		52, 0, %3			    \n\t"	// y4
+-	"lxvd2x		53, %5, %3			    \n\t"	// y5
+-	"xxswapd	62, 46				    \n\t"	// exchange real and imag part
+-	"xxswapd	63, 47				    \n\t"	// exchange real and imag part
+-	"lxvd2x		54, %6, %3			    \n\t"	// y6
+-	"lxvd2x		55, %7, %3			    \n\t"	// y7
+-
+-	"addi		%3, %3, 64			    \n\t"
+-
+-	"addic.		%0 , %0	, -8  	 	             \n\t"
+-	"bgt		1b		             	     \n\t"
+-
+-	"2:						     \n\t"
+-
+-	"xvmaddadp	48, 40, 32		    	    \n\t"	// alpha_r * x0_r , alpha_r * x0_i
+-	"xvmaddadp	49, 41, 32		    	    \n\t"
+-	"xvmaddadp	50, 42, 32		    	    \n\t"
+-	"xvmaddadp	51, 43, 32		    	    \n\t"
+-
+-	"xvmaddadp	52, 44, 32		    	    \n\t"
+-	"xvmaddadp	53, 45, 32		    	    \n\t"
+-	"xvmaddadp	54, 46, 32		    	    \n\t"
+-	"xvmaddadp	55, 47, 32		    	    \n\t"
+-
+-	"xvmaddadp	48, 56, 33		    	    \n\t"	// alpha_i * x0_i , alpha_i * x0_r
+-	"xvmaddadp	49, 57, 33		    	    \n\t"
+-	"xvmaddadp	50, 58, 33		    	    \n\t"
+-	"xvmaddadp	51, 59, 33		    	    \n\t"
+-
+-	"xvmaddadp	52, 60, 33		    	    \n\t"
+-	"xvmaddadp	53, 61, 33		    	    \n\t"
+-	"xvmaddadp	54, 62, 33		    	    \n\t"
+-	"xvmaddadp	55, 63, 33		    	    \n\t"
+-
+-
+-	"stxvd2x	48,  0, %8			    \n\t"
+-	"stxvd2x	49, %5, %8			    \n\t"
+-	"stxvd2x	50, %6, %8			    \n\t"
+-	"stxvd2x	51, %7, %8			    \n\t"
+-
+-	"addi		%8, %8, 64			    \n\t"
+-
+-	"stxvd2x	52,  0, %8			    \n\t"
+-	"stxvd2x	53, %5, %8			    \n\t"
+-	"stxvd2x	54, %6, %8			    \n\t"
+-	"stxvd2x	55, %7, %8			    \n\t"
+-
+-	"addi		%8, %8, 64			    \n\t"
+-
+-	:
+-        : 
+-          "r" (i),	// 0	
+-	  "r" (n),  	// 1
+-          "r" (x1),     // 2
+-          "r" (y1),     // 3
+-          "r" (alpha),  // 4
+-	  "r" (o16),	// 5
+-	  "r" (o32),	// 6
+-	  "r" (o48),    // 7
+-	  "r" (y2),     // 8
+-	  "r" (mvec),   // 9
+-	  "r" (pre)	// 10
+-	: "cr0", "%0", "%2" , "%3", "%8", "memory"
+-	);
+-
+-} 
+-
+-
++       "mr		%16, %3		\n\t"
++       "dcbt		0, %2		\n\t"
++       "dcbt		0, %3		\n\t"
++
++
++       "lxvd2x		40, 0, %2	\n\t"	// x0
++       "lxvd2x		41, %22, %2	\n\t"	// x1
++       "lxvd2x		42, %23, %2	\n\t"	// x2
++       "lxvd2x		43, %24, %2	\n\t"	// x3
++
++       "lxvd2x		48, 0, %3	\n\t"	// y0
++       "lxvd2x		49, %22, %3	\n\t"	// y1
++       "lxvd2x		50, %23, %3	\n\t"	// y2
++       "lxvd2x		51, %24, %3	\n\t"	// y3
++
++       "xxswapd		%x8, 40		\n\t"	// exchange real and imag part
++       "xxswapd		%x9, 41		\n\t"	// exchange real and imag part
++       "xxswapd		%x10, 42	\n\t"	// exchange real and imag part
++       "xxswapd		%x11, 43	\n\t"	// exchange real and imag part
++
++       "addi		%2, %2, 64	\n\t"
++       "addi		%3, %3, 64	\n\t"
++
++       "lxvd2x		44, 0, %2	\n\t"	// x4
++       "lxvd2x		45, %22, %2	\n\t"	// x5
++       "lxvd2x		46, %23, %2	\n\t"	// x6
++       "lxvd2x		47, %24, %2	\n\t"	// x7
++
++       "lxvd2x		%x4, 0, %3	\n\t"	// y4
++       "lxvd2x		%x5, %22, %3	\n\t"	// y5
++       "lxvd2x		%x6, %23, %3	\n\t"	// y6
++       "lxvd2x		%x7, %24, %3	\n\t"	// y7
++
++       "xxswapd		%x12, 44	\n\t"	// exchange real and imag part
++       "xxswapd		%x13, 45	\n\t"	// exchange real and imag part
++       "xxswapd		%x14, 46	\n\t"	// exchange real and imag part
++       "xxswapd		%x15, 47	\n\t"	// exchange real and imag part
++
++       "addi		%2, %2, 64	\n\t"
++       "addi		%3, %3, 64	\n\t"
++
++       "addic.		%1, %1, -8	\n\t"
++       "ble		2f		\n\t"
++
++       ".p2align	5		\n"
++       "1:				\n\t"
++
++       "xvmaddadp	48, 40, 32	\n\t"	// alpha_r * x0_r , alpha_r * x0_i
++       "xvmaddadp	49, 41, 32	\n\t"
++       "lxvd2x		40, 0, %2	\n\t"	// x0
++       "lxvd2x		41, %22, %2	\n\t"	// x1
++       "xvmaddadp	50, 42, 32	\n\t"
++       "xvmaddadp	51, 43, 32	\n\t"
++       "lxvd2x		42, %23, %2	\n\t"	// x2
++       "lxvd2x		43, %24, %2	\n\t"	// x3
++
++       "xvmaddadp	%x4, 44, 32	\n\t"
++       "addi		%2, %2, 64	\n\t"
++       "xvmaddadp	%x5, 45, 32	\n\t"
++       "lxvd2x		44, 0, %2	\n\t"	// x4
++       "lxvd2x		45, %22, %2	\n\t"	// x5
++       "xvmaddadp	%x6, 46, 32	\n\t"
++       "xvmaddadp	%x7, 47, 32	\n\t"
++       "lxvd2x		46, %23, %2	\n\t"	// x6
++       "lxvd2x		47, %24, %2	\n\t"	// x7
++
++       "xvmaddadp	48, %x8, 33	\n\t"	// alpha_i * x0_i , alpha_i * x0_r
++       "addi		%2, %2, 64	\n\t"
++       "xvmaddadp	49, %x9, 33	\n\t"
++       "xvmaddadp	50, %x10, 33	\n\t"
++       "xvmaddadp	51, %x11, 33	\n\t"
++
++       "xvmaddadp	%x4, %x12, 33	\n\t"
++       "xvmaddadp	%x5, %x13, 33	\n\t"
++       "xvmaddadp	%x6, %x14, 33	\n\t"
++       "xvmaddadp	%x7, %x15, 33	\n\t"
++
++       "stxvd2x		48, 0, %16	\n\t"
++       "stxvd2x		49, %22, %16	\n\t"
++       "stxvd2x		50, %23, %16	\n\t"
++       "stxvd2x		51, %24, %16	\n\t"
++
++       "addi		%16, %16, 64	\n\t"
++
++       "stxvd2x		%x4, 0, %16	\n\t"
++       "stxvd2x		%x5, %22, %16	\n\t"
++       "stxvd2x		%x6, %23, %16	\n\t"
++       "stxvd2x		%x7, %24, %16	\n\t"
++
++       "addi		%16, %16, 64	\n\t"
++
++       "xxswapd		%x8, 40		\n\t"	// exchange real and imag part
++       "xxswapd		%x9, 41		\n\t"	// exchange real and imag part
++       "lxvd2x		48, 0, %3	\n\t"	// y0
++       "lxvd2x		49, %22, %3	\n\t"	// y1
++       "xxswapd		%x10, 42	\n\t"	// exchange real and imag part
++       "xxswapd		%x11, 43	\n\t"	// exchange real and imag part
++       "lxvd2x		50, %23, %3	\n\t"	// y2
++       "lxvd2x		51, %24, %3	\n\t"	// y3
++
++       "xxswapd		%x12, 44	\n\t"	// exchange real and imag part
++       "addi		%3, %3, 64	\n\t"
++       "xxswapd		%x13, 45	\n\t"	// exchange real and imag part
++       "lxvd2x		%x4, 0, %3	\n\t"	// y4
++       "lxvd2x		%x5, %22, %3	\n\t"	// y5
++       "xxswapd		%x14, 46	\n\t"	// exchange real and imag part
++       "xxswapd		%x15, 47	\n\t"	// exchange real and imag part
++       "lxvd2x		%x6, %23, %3	\n\t"	// y6
++       "lxvd2x		%x7, %24, %3	\n\t"	// y7
++
++       "addi		%3, %3, 64	\n\t"
++
++       "addic.		%1, %1, -8	\n\t"
++       "bgt		1b		\n"
++
++       "2:				\n\t"
++
++       "xvmaddadp	48, 40, 32	\n\t"	// alpha_r * x0_r , alpha_r * x0_i
++       "xvmaddadp	49, 41, 32	\n\t"
++       "xvmaddadp	50, 42, 32	\n\t"
++       "xvmaddadp	51, 43, 32	\n\t"
++
++       "xvmaddadp	%x4, 44, 32	\n\t"
++       "xvmaddadp	%x5, 45, 32	\n\t"
++       "xvmaddadp	%x6, 46, 32	\n\t"
++       "xvmaddadp	%x7, 47, 32	\n\t"
++
++       "xvmaddadp	48, %x8, 33	\n\t"	// alpha_i * x0_i , alpha_i * x0_r
++       "xvmaddadp	49, %x9, 33	\n\t"
++       "xvmaddadp	50, %x10, 33	\n\t"
++       "xvmaddadp	51, %x11, 33	\n\t"
++
++       "xvmaddadp	%x4, %x12, 33	\n\t"
++       "xvmaddadp	%x5, %x13, 33	\n\t"
++       "xvmaddadp	%x6, %x14, 33	\n\t"
++       "xvmaddadp	%x7, %x15, 33	\n\t"
++
++       "stxvd2x		48, 0, %16	\n\t"
++       "stxvd2x		49, %22, %16	\n\t"
++       "stxvd2x		50, %23, %16	\n\t"
++       "stxvd2x		51, %24, %16	\n\t"
++
++       "addi		%16, %16, 64	\n\t"
++
++       "stxvd2x		%x4, 0, %16	\n\t"
++       "stxvd2x		%x5, %22, %16	\n\t"
++       "stxvd2x		%x6, %23, %16	\n\t"
++       "stxvd2x		%x7, %24, %16	\n"
++
++     "#n=%1 x=%17=%2 y=%0=%3 alpha=(%19,%20) mvecp=%18=%16 o16=%22 o32=%23 o48=%24 ytmp=%16\n"
++     "#t0=%x4 t1=%x5 t2=%x6 t3=%x7 t4=%x8 t5=%x9 t6=%x10 t7=%x11 t8=%x12 t9=%x13 t10=%x14 t11=%x15"
++     :
++       "+m" (*y),
++       "+r" (n),	// 1
++       "+b" (x),	// 2
++       "+b" (y),	// 3
++       "=wa" (t0),	// 4
++       "=wa" (t1),	// 5
++       "=wa" (t2),	// 6
++       "=wa" (t3),	// 7
++       "=wa" (t4),	// 8
++       "=wa" (t5),	// 9
++       "=wa" (t6),	// 10
++       "=wa" (t7),	// 11
++       "=wa" (t8),	// 12
++       "=wa" (t9),	// 13
++       "=wa" (t10),	// 14
++       "=wa" (t11),	// 15
++       "=b" (ytmp)	// 16
++     :
++       "m" (*x),
++       "m" (*mvecp),
++       "d" (alpha_r),	// 19
++       "d" (alpha_i),	// 20
++       "16" (mvecp),	// 21
++       "b" (16),	// 22
++       "b" (32),	// 23
++       "b" (48)		// 24
++     :
++       "cr0",
++       "vs32","vs33","vs34","vs35","vs36","vs37","vs38","vs39",
++       "vs40","vs41","vs42","vs43","vs44","vs45","vs46","vs47",
++       "vs48","vs49","vs50","vs51"
++     );
++}
+diff --git a/kernel/power/zcopy_microk_power8.c b/kernel/power/zcopy_microk_power8.c
+index 73abe08..5ca34b6 100644
+--- a/kernel/power/zcopy_microk_power8.c
++++ b/kernel/power/zcopy_microk_power8.c
+@@ -35,140 +35,121 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+ #define HAVE_KERNEL_16 1
+ 
+-static void zcopy_kernel_16( BLASLONG n, FLOAT *x, FLOAT *y) __attribute__ ((noinline));
+-
+-static void zcopy_kernel_16( BLASLONG n, FLOAT *x, FLOAT *y)
++static void zcopy_kernel_16 (long n, FLOAT *x, FLOAT *y)
+ {
+-
+-
+-	BLASLONG i = n;
+-	BLASLONG o16 = 16;
+-	BLASLONG o32 = 32;
+-	BLASLONG o48 = 48;
+-	BLASLONG o64 = 64;
+-	BLASLONG o80 = 80;
+-	BLASLONG o96 = 96;
+-	BLASLONG o112 = 112;
+-	FLOAT *x1=x;
+-	FLOAT *y1=y;
+-	BLASLONG pre = 384;
+-	BLASLONG alpha=0;
+-
+-	__asm__  __volatile__
+-	(
+-
+-	"lxvd2x		40, 0, %2			    \n\t"
+-	"lxvd2x		41, %5, %2			    \n\t"
+-	"lxvd2x		42, %6, %2			    \n\t"
+-	"lxvd2x		43, %7, %2			    \n\t"
+-	"lxvd2x		44, %8, %2			    \n\t"
+-	"lxvd2x		45, %9, %2			    \n\t"
+-	"lxvd2x		46, %10, %2			    \n\t"
+-	"lxvd2x		47, %11, %2			    \n\t"
+-
+-	"addi		%2, %2, 128			    \n\t"
+-
+-	"lxvd2x		50, 0, %2			    \n\t"
+-	"lxvd2x		51, %5, %2			    \n\t"
+-	"lxvd2x		52, %6, %2			    \n\t"
+-	"lxvd2x		53, %7, %2			    \n\t"
+-	"lxvd2x		54, %8, %2			    \n\t"
+-	"lxvd2x		55, %9, %2			    \n\t"
+-	"lxvd2x		56, %10, %2			    \n\t"
+-	"lxvd2x		57, %11, %2			    \n\t"
+-
+-	"addi		%2, %2, 128			    \n\t"
+-
+-	"addic.		%0 , %0	, -16  	 	             \n\t"
+-	"ble		2f		             	     \n\t"
+-
+-	".align 5				            \n\t"
+-	"1:				                    \n\t"
+-
+-	"stxvd2x		40, 0, %1			    \n\t"
+-	"stxvd2x		41, %5, %1			    \n\t"
+-	"lxvd2x		40, 0, %2			    \n\t"
+-	"lxvd2x		41, %5, %2			    \n\t"
+-	"stxvd2x		42, %6, %1			    \n\t"
+-	"stxvd2x		43, %7, %1			    \n\t"
+-	"lxvd2x		42, %6, %2			    \n\t"
+-	"lxvd2x		43, %7, %2			    \n\t"
+-	"stxvd2x		44, %8, %1			    \n\t"
+-	"stxvd2x		45, %9, %1			    \n\t"
+-	"lxvd2x		44, %8, %2			    \n\t"
+-	"lxvd2x		45, %9, %2			    \n\t"
+-	"stxvd2x		46, %10, %1			    \n\t"
+-	"stxvd2x		47, %11, %1			    \n\t"
+-	"lxvd2x		46, %10, %2			    \n\t"
+-	"lxvd2x		47, %11, %2			    \n\t"
+-
+-
+-	"addi		%1, %1, 128			    \n\t"
+-	"addi		%2, %2, 128			    \n\t"
+-
+-	"stxvd2x		50, 0, %1			    \n\t"
+-	"stxvd2x		51, %5, %1			    \n\t"
+-	"lxvd2x		50, 0, %2			    \n\t"
+-	"lxvd2x		51, %5, %2			    \n\t"
+-	"stxvd2x		52, %6, %1			    \n\t"
+-	"stxvd2x		53, %7, %1			    \n\t"
+-	"lxvd2x		52, %6, %2			    \n\t"
+-	"lxvd2x		53, %7, %2			    \n\t"
+-	"stxvd2x		54, %8, %1			    \n\t"
+-	"stxvd2x		55, %9, %1			    \n\t"
+-	"lxvd2x		54, %8, %2			    \n\t"
+-	"lxvd2x		55, %9, %2			    \n\t"
+-	"stxvd2x		56, %10, %1			    \n\t"
+-	"stxvd2x		57, %11, %1			    \n\t"
+-	"lxvd2x		56, %10, %2			    \n\t"
+-	"lxvd2x		57, %11, %2			    \n\t"
+-
+-	"addi		%1, %1, 128			    \n\t"
+-	"addi		%2, %2, 128			    \n\t"
+-
+-	"addic.		%0 , %0	, -16  	 	             \n\t"
+-	"bgt		1b		             	     \n\t"
+-
+-	"2:						     \n\t"
+-
+-	"stxvd2x		40, 0, %1			    \n\t"
+-	"stxvd2x		41, %5, %1			    \n\t"
+-	"stxvd2x		42, %6, %1			    \n\t"
+-	"stxvd2x		43, %7, %1			    \n\t"
+-	"stxvd2x		44, %8, %1			    \n\t"
+-	"stxvd2x		45, %9, %1			    \n\t"
+-	"stxvd2x		46, %10, %1			    \n\t"
+-	"stxvd2x		47, %11, %1			    \n\t"
+-
+-	"addi		%1, %1, 128			    \n\t"
+-
+-	"stxvd2x		50, 0, %1			    \n\t"
+-	"stxvd2x		51, %5, %1			    \n\t"
+-	"stxvd2x		52, %6, %1			    \n\t"
+-	"stxvd2x		53, %7, %1			    \n\t"
+-	"stxvd2x		54, %8, %1			    \n\t"
+-	"stxvd2x		55, %9, %1			    \n\t"
+-	"stxvd2x		56, %10, %1			    \n\t"
+-	"stxvd2x		57, %11, %1			    \n\t"
+-
+-
+-	:
+-        : 
+-          "r" (i),	// 0	
+-	  "r" (y1),  	// 1
+-          "r" (x1),     // 2
+-          "r" (alpha),  // 3
+-          "r" (pre),    // 4
+-	  "r" (o16),	// 5
+-	  "r" (o32),	// 6
+-	  "r" (o48),    // 7
+-          "r" (o64),    // 8
+-          "r" (o80),    // 9
+-          "r" (o96),    // 10
+-          "r" (o112)    // 11
+-	: "cr0", "%0", "%2" , "%1", "memory"
+-	);
+-
+-} 
+-
+-
++  __asm__
++    (
++       "lxvd2x		32, 0, %2	\n\t"
++       "lxvd2x		33, %5, %2	\n\t"
++       "lxvd2x		34, %6, %2	\n\t"
++       "lxvd2x		35, %7, %2	\n\t"
++       "lxvd2x		36, %8, %2	\n\t"
++       "lxvd2x		37, %9, %2	\n\t"
++       "lxvd2x		38, %10, %2	\n\t"
++       "lxvd2x		39, %11, %2	\n\t"
++
++       "addi		%2, %2, 128	\n\t"
++
++       "lxvd2x		40, 0, %2	\n\t"
++       "lxvd2x		41, %5, %2	\n\t"
++       "lxvd2x		42, %6, %2	\n\t"
++       "lxvd2x		43, %7, %2	\n\t"
++       "lxvd2x		44, %8, %2	\n\t"
++       "lxvd2x		45, %9, %2	\n\t"
++       "lxvd2x		46, %10, %2	\n\t"
++       "lxvd2x		47, %11, %2	\n\t"
++
++       "addi		%2, %2, 128	\n\t"
++
++       "addic.		%1, %1, -16	\n\t"
++       "ble		2f		\n\t"
++
++       ".p2align	5		\n"
++     "1:				\n\t"
++
++       "stxvd2x		32, 0, %3	\n\t"
++       "stxvd2x		33, %5, %3	\n\t"
++       "lxvd2x		32, 0, %2	\n\t"
++       "lxvd2x		33, %5, %2	\n\t"
++       "stxvd2x		34, %6, %3	\n\t"
++       "stxvd2x		35, %7, %3	\n\t"
++       "lxvd2x		34, %6, %2	\n\t"
++       "lxvd2x		35, %7, %2	\n\t"
++       "stxvd2x		36, %8, %3	\n\t"
++       "stxvd2x		37, %9, %3	\n\t"
++       "lxvd2x		36, %8, %2	\n\t"
++       "lxvd2x		37, %9, %2	\n\t"
++       "stxvd2x		38, %10, %3	\n\t"
++       "stxvd2x		39, %11, %3	\n\t"
++       "lxvd2x		38, %10, %2	\n\t"
++       "lxvd2x		39, %11, %2	\n\t"
++
++       "addi		%3, %3, 128	\n\t"
++       "addi		%2, %2, 128	\n\t"
++
++       "stxvd2x		40, 0, %3	\n\t"
++       "stxvd2x		41, %5, %3	\n\t"
++       "lxvd2x		40, 0, %2	\n\t"
++       "lxvd2x		41, %5, %2	\n\t"
++       "stxvd2x		42, %6, %3	\n\t"
++       "stxvd2x		43, %7, %3	\n\t"
++       "lxvd2x		42, %6, %2	\n\t"
++       "lxvd2x		43, %7, %2	\n\t"
++       "stxvd2x		44, %8, %3	\n\t"
++       "stxvd2x		45, %9, %3	\n\t"
++       "lxvd2x		44, %8, %2	\n\t"
++       "lxvd2x		45, %9, %2	\n\t"
++       "stxvd2x		46, %10, %3	\n\t"
++       "stxvd2x		47, %11, %3	\n\t"
++       "lxvd2x		46, %10, %2	\n\t"
++       "lxvd2x		47, %11, %2	\n\t"
++
++       "addi		%3, %3, 128	\n\t"
++       "addi		%2, %2, 128	\n\t"
++
++       "addic.		%1, %1, -16	\n\t"
++       "bgt		1b		\n"
++
++     "2:				\n\t"
++
++       "stxvd2x		32, 0, %3	\n\t"
++       "stxvd2x		33, %5, %3	\n\t"
++       "stxvd2x		34, %6, %3	\n\t"
++       "stxvd2x		35, %7, %3	\n\t"
++       "stxvd2x		36, %8, %3	\n\t"
++       "stxvd2x		37, %9, %3	\n\t"
++       "stxvd2x		38, %10, %3	\n\t"
++       "stxvd2x		39, %11, %3	\n\t"
++
++       "addi		%3, %3, 128	\n\t"
++
++       "stxvd2x		40, 0, %3	\n\t"
++       "stxvd2x		41, %5, %3	\n\t"
++       "stxvd2x		42, %6, %3	\n\t"
++       "stxvd2x		43, %7, %3	\n\t"
++       "stxvd2x		44, %8, %3	\n\t"
++       "stxvd2x		45, %9, %3	\n\t"
++       "stxvd2x		46, %10, %3	\n\t"
++       "stxvd2x		47, %11, %3	\n"
++
++     "#n=%1 x=%4=%2 y=%0=%3 o16=%5 o32=%6 o48=%7 o64=%8 o80=%9 o96=%10 o112=%11"
++     :
++       "=m" (*y),
++       "+r" (n),	// 1
++       "+b" (x),	// 2
++       "+b" (y)		// 3
++     :
++       "m" (*x),
++       "b" (16),	// 5
++       "b" (32),	// 6
++       "b" (48),	// 7
++       "b" (64),	// 8
++       "b" (80),	// 9
++       "b" (96),	// 10
++       "b" (112)	// 11
++     :
++       "cr0",
++       "vs32","vs33","vs34","vs35","vs36","vs37","vs38","vs39",
++       "vs40","vs41","vs42","vs43","vs44","vs45","vs46","vs47"
++     );
++}
+diff --git a/kernel/power/zdot.c b/kernel/power/zdot.c
+index bc1a95e..b83f832 100644
+--- a/kernel/power/zdot.c
++++ b/kernel/power/zdot.c
+@@ -43,8 +43,6 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+ #ifndef HAVE_KERNEL_8
+ 
+-static void zdot_kernel_8(BLASLONG n, FLOAT *x, FLOAT *y, FLOAT *d) __attribute__ ((noinline));
+-
+ static void zdot_kernel_8(BLASLONG n, FLOAT *x, FLOAT *y, FLOAT *d)
+ {
+ 	BLASLONG register i = 0;
+diff --git a/kernel/power/zdot_microk_power8.c b/kernel/power/zdot_microk_power8.c
+index 296d3d4..71078b6 100644
+--- a/kernel/power/zdot_microk_power8.c
++++ b/kernel/power/zdot_microk_power8.c
+@@ -34,186 +34,174 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ **************************************************************************************/
+ 
+ #define HAVE_KERNEL_8 1
+-static void zdot_kernel_8( BLASLONG n, FLOAT *x, FLOAT *y , FLOAT *dot) __attribute__ ((noinline));
+ 
+-static void zdot_kernel_8( BLASLONG n, FLOAT *x, FLOAT *y, FLOAT *dot)
++static void zdot_kernel_8 (long n, double *x, double *y, double *dot)
+ {
+-
+-
+-	BLASLONG i = n;
+-	BLASLONG o16 = 16;
+-	BLASLONG o32 = 32;
+-	BLASLONG o48 = 48;
+-	FLOAT *x1=x;
+-	FLOAT *y1=y;
+-	BLASLONG pre = 384;
+-
+-	__asm__  __volatile__
+-	(
+-	"xxlxor		32,32,32			    \n\t"
+-	"xxlxor		33,33,33			    \n\t"
+-	"xxlxor		34,34,34			    \n\t"
+-	"xxlxor		35,35,35			    \n\t"
+-	"xxlxor		36,36,36			    \n\t"
+-	"xxlxor		37,37,37			    \n\t"
+-	"xxlxor		38,38,38			    \n\t"
+-	"xxlxor		39,39,39			    \n\t"
+-
+-	"dcbt		%2, %8				    \n\t"
+-	"dcbt		%3, %8				    \n\t"
+-
+-	"lxvd2x		40, 0, %2			    \n\t"	// x0_r, x0_i
+-	"lxvd2x		48, 0, %3			    \n\t"	// y0_r, y0_i
+-	"lxvd2x		41, %5, %2			    \n\t"	// x1_r, x1_i
+-	"lxvd2x		49, %5, %3			    \n\t"	// y1_r, y1_i
+-	"lxvd2x		42, %6, %2			    \n\t"	// x2_r, x2_i
+-	"lxvd2x		50, %6, %3			    \n\t"	// y2_r, y2_i
+-	"lxvd2x		43, %7, %2			    \n\t"	// x3_r, x3_i
+-	"lxvd2x		51, %7, %3			    \n\t"	// y3_r, y3_i
+-
+-	"xxswapd	52,48				    \n\t"	// y0_i, y0_r
+-	"xxswapd	53,49				    \n\t"	// y1_i, y1_r
+-	"xxswapd	54,50				    \n\t"	// y2_i, y2_r
+-	"xxswapd	55,51				    \n\t"	// y3_i, y3_r
+-
+-	"addi		%2, %2, 64			    \n\t"
+-	"addi		%3, %3, 64			    \n\t"
+-
+-
+-	"lxvd2x		44, 0, %2			    \n\t"	// x0_r, x0_i
+-	"lxvd2x		56, 0, %3			    \n\t"	// y0_r, y0_i
+-	"lxvd2x		45, %5, %2			    \n\t"	// x1_r, x1_i
+-	"lxvd2x		57, %5, %3			    \n\t"	// y1_r, y1_i
+-	"lxvd2x		46, %6, %2			    \n\t"	// x2_r, x2_i
+-	"lxvd2x		58, %6, %3			    \n\t"	// y2_r, y2_i
+-	"lxvd2x		47, %7, %2			    \n\t"	// x3_r, x3_i
+-	"lxvd2x		59, %7, %3			    \n\t"	// y3_r, y3_i
+-
+-	"xxswapd	60,56				    \n\t"	// y0_i, y0_r
+-	"xxswapd	61,57				    \n\t"	// y1_i, y1_r
+-	"xxswapd	62,58				    \n\t"	// y2_i, y2_r
+-	"xxswapd	63,59				    \n\t"	// y3_i, y3_r
+-
+-	"addi		%2, %2, 64			    \n\t"
+-	"addi		%3, %3, 64			    \n\t"
+-
+-	"addic.		%0 , %0	, -8  	 	             \n\t"
+-	"ble		2f		             	     \n\t"
+-
+-	".align 5				            \n\t"
+-	"1:				                    \n\t"
+-
+-	"dcbt		%2, %8				    \n\t"
+-	"dcbt		%3, %8				    \n\t"
+-
+-	"xvmaddadp	32, 40, 48		    	    \n\t"	// x0_r * y0_r , x0_i * y0_i
+-	"lxvd2x		48, 0, %3			    \n\t"	// y0_r, y0_i
+-	"xvmaddadp	34, 41, 49		    	    \n\t"	// x1_r * y1_r , x1_i * y1_i
+-	"lxvd2x		49, %5, %3			    \n\t"	// y1_r, y1_i
+-
+-	"xvmaddadp	36, 42, 50		    	    \n\t"	// x2_r * y2_r , x2_i * y2_i
+-	"lxvd2x		50, %6, %3			    \n\t"	// y2_r, y2_i
+-	"xvmaddadp	38, 43, 51		    	    \n\t"	// x3_r * y3_r , x3_i * y3_i
+-	"lxvd2x		51, %7, %3			    \n\t"	// y3_r, y3_i
+-
+-	"xvmaddadp	33, 40, 52		    	    \n\t"	// x0_r * y0_i , x0_i * y0_r
+-	"lxvd2x		40, 0, %2			    \n\t"	// x0_r, x0_i
+-	"xvmaddadp	35, 41, 53		    	    \n\t"	// x1_r * y1_i , x1_i * y1_r
+-	"lxvd2x		41, %5, %2			    \n\t"	// x1_r, x1_i
+-
+-	"xvmaddadp	37, 42, 54		    	    \n\t"	// x2_r * y2_i , x2_i * y2_r
+-	"lxvd2x		42, %6, %2			    \n\t"	// x2_r, x2_i
+-	"xvmaddadp	39, 43, 55		    	    \n\t"	// x3_r * y3_i , x3_i * y3_r
+-	"lxvd2x		43, %7, %2			    \n\t"	// x3_r, x3_i
+-
+-	"xxswapd	52,48				    \n\t"	// y0_i, y0_r
+-	"xxswapd	53,49				    \n\t"	// y1_i, y1_r
+-
+-	"addi		%2, %2, 64			    \n\t"
+-	"addi		%3, %3, 64			    \n\t"
+-
+-	"xxswapd	54,50				    \n\t"	// y2_i, y2_r
+-	"xxswapd	55,51				    \n\t"	// y3_i, y3_r
+-
+-	"xvmaddadp	32, 44, 56		    	    \n\t"	// x0_r * y0_r , x0_i * y0_i
+-	"lxvd2x		56, 0, %3			    \n\t"	// y0_r, y0_i
+-	"xvmaddadp	34, 45, 57		    	    \n\t"	// x1_r * y1_r , x1_i * y1_i
+-	"lxvd2x		57, %5, %3			    \n\t"	// y1_r, y1_i
+-	"xvmaddadp	36, 46, 58		    	    \n\t"	// x2_r * y2_r , x2_i * y2_i
+-	"lxvd2x		58, %6, %3			    \n\t"	// y2_r, y2_i
+-	"xvmaddadp	38, 47, 59		    	    \n\t"	// x3_r * y3_r , x3_i * y3_i
+-	"lxvd2x		59, %7, %3			    \n\t"	// y3_r, y3_i
+-
+-	"xvmaddadp	33, 44, 60		    	    \n\t"	// x0_r * y0_i , x0_i * y0_r
+-	"lxvd2x		44, 0, %2			    \n\t"	// x0_r, x0_i
+-	"xvmaddadp	35, 45, 61		    	    \n\t"	// x1_r * y1_i , x1_i * y1_r
+-	"lxvd2x		45, %5, %2			    \n\t"	// x1_r, x1_i
+-	"xvmaddadp	37, 46, 62		    	    \n\t"	// x2_r * y2_i , x2_i * y2_r
+-	"lxvd2x		46, %6, %2			    \n\t"	// x2_r, x2_i
+-	"xvmaddadp	39, 47, 63		    	    \n\t"	// x3_r * y3_i , x3_i * y3_r
+-	"lxvd2x		47, %7, %2			    \n\t"	// x3_r, x3_i
+-
+-	"xxswapd	60,56				    \n\t"	// y0_i, y0_r
+-	"xxswapd	61,57				    \n\t"	// y1_i, y1_r
+-
+-	"addi		%2, %2, 64			    \n\t"
+-	"addi		%3, %3, 64			    \n\t"
+-
+-	"xxswapd	62,58				    \n\t"	// y2_i, y2_r
+-	"xxswapd	63,59				    \n\t"	// y3_i, y3_r
+-
+-	"addic.		%0 , %0	, -8  	 	             \n\t"
+-	"bgt		1b		             	     \n\t"
+-
+-	"2:						     \n\t"
+-
+-	"xvmaddadp	32, 40, 48		    	    \n\t"	// x0_r * y0_r , x0_i * y0_i
+-	"xvmaddadp	34, 41, 49		    	    \n\t"	// x1_r * y1_r , x1_i * y1_i
+-	"xvmaddadp	36, 42, 50		    	    \n\t"	// x2_r * y2_r , x2_i * y2_i
+-	"xvmaddadp	38, 43, 51		    	    \n\t"	// x3_r * y3_r , x3_i * y3_i
+-
+-	"xvmaddadp	33, 40, 52		    	    \n\t"	// x0_r * y0_i , x0_i * y0_r
+-	"xvmaddadp	35, 41, 53		    	    \n\t"	// x1_r * y1_i , x1_i * y1_r
+-	"xvmaddadp	37, 42, 54		    	    \n\t"	// x2_r * y2_i , x2_i * y2_r
+-	"xvmaddadp	39, 43, 55		    	    \n\t"	// x3_r * y3_i , x3_i * y3_r
+-
+-	"xvmaddadp	32, 44, 56		    	    \n\t"	// x0_r * y0_r , x0_i * y0_i
+-	"xvmaddadp	34, 45, 57		    	    \n\t"	// x1_r * y1_r , x1_i * y1_i
+-	"xvmaddadp	36, 46, 58		    	    \n\t"	// x2_r * y2_r , x2_i * y2_i
+-	"xvmaddadp	38, 47, 59		    	    \n\t"	// x3_r * y3_r , x3_i * y3_i
+-
+-	"xvmaddadp	33, 44, 60		    	    \n\t"	// x0_r * y0_i , x0_i * y0_r
+-	"xvmaddadp	35, 45, 61		    	    \n\t"	// x1_r * y1_i , x1_i * y1_r
+-	"xvmaddadp	37, 46, 62		    	    \n\t"	// x2_r * y2_i , x2_i * y2_r
+-	"xvmaddadp	39, 47, 63		    	    \n\t"	// x3_r * y3_i , x3_i * y3_r
+-
+-
+-	"xvadddp	32, 32, 34		     \n\t"
+-	"xvadddp	36, 36, 38		     \n\t"
+-
+-	"xvadddp	33, 33, 35		     \n\t"
+-	"xvadddp	37, 37, 39		     \n\t"
+-
+-	"xvadddp	32, 32, 36		     \n\t"
+-	"xvadddp	33, 33, 37		     \n\t"
+-
+-	"stxvd2x	32, 0, %4		     \n\t"
+-	"stxvd2x	33, %5, %4		     \n\t"
+-
+-	:
+-        : 
+-          "r" (i),	// 0	
+-	  "r" (n),  	// 1
+-          "r" (x1),     // 2
+-          "r" (y1),     // 3
+-          "r" (dot),    // 4
+-	  "r" (o16),	// 5
+-	  "r" (o32),	// 6
+-	  "r" (o48),    // 7
+-	  "r" (pre)	// 8
+-	: "cr0", "%0", "%2" , "%3", "memory"
+-	);
+-
+-} 
+-
+-
++  __asm__
++    (
++       "dcbt		0, %2		\n\t"
++       "dcbt		0, %3		\n\t"
++
++       "xxlxor		32, 32,	32	\n\t"
++       "xxlxor		33, 33,	33	\n\t"
++       "xxlxor		34, 34,	34	\n\t"
++       "xxlxor		35, 35,	35	\n\t"
++       "xxlxor		36, 36,	36	\n\t"
++       "xxlxor		37, 37,	37	\n\t"
++       "xxlxor		38, 38,	38	\n\t"
++       "xxlxor		39, 39,	39	\n\t"
++
++       "lxvd2x		40, 0, %2	\n\t"	// x0_r, x0_i
++       "lxvd2x		48, 0, %3	\n\t"	// y0_r, y0_i
++       "lxvd2x		41, %7, %2	\n\t"	// x1_r, x1_i
++       "lxvd2x		49, %7, %3	\n\t"	// y1_r, y1_i
++       "lxvd2x		42, %8, %2	\n\t"	// x2_r, x2_i
++       "lxvd2x		50, %8, %3	\n\t"	// y2_r, y2_i
++       "lxvd2x		43, %9, %2	\n\t"	// x3_r, x3_i
++       "lxvd2x		51, %9, %3	\n\t"	// y3_r, y3_i
++
++       "xxswapd		0, 48		\n\t"	// y0_i, y0_r
++       "xxswapd		1, 49		\n\t"	// y1_i, y1_r
++       "xxswapd		2, 50		\n\t"	// y2_i, y2_r
++       "xxswapd		3, 51		\n\t"	// y3_i, y3_r
++
++       "addi		%2, %2, 64	\n\t"
++       "addi		%3, %3, 64	\n\t"
++
++       "lxvd2x		44, 0, %2	\n\t"	// x0_r, x0_i
++       "lxvd2x		4, 0, %3	\n\t"	// y0_r, y0_i
++       "lxvd2x		45, %7, %2	\n\t"	// x1_r, x1_i
++       "lxvd2x		5, %7, %3	\n\t"	// y1_r, y1_i
++       "lxvd2x		46, %8, %2	\n\t"	// x2_r, x2_i
++       "lxvd2x		6, %8, %3	\n\t"	// y2_r, y2_i
++       "lxvd2x		47, %9, %2	\n\t"	// x3_r, x3_i
++       "lxvd2x		7, %9, %3	\n\t"	// y3_r, y3_i
++
++       "xxswapd		8, 4		\n\t"	// y0_i, y0_r
++       "xxswapd		9, 5		\n\t"	// y1_i, y1_r
++       "xxswapd		10, 6		\n\t"	// y2_i, y2_r
++       "xxswapd		11, 7		\n\t"	// y3_i, y3_r
++
++       "addi		%2, %2, 64	\n\t"
++       "addi		%3, %3, 64	\n\t"
++
++       "addic.		%1, %1, -8	\n\t"
++       "ble		2f		\n\t"
++
++       ".p2align	5		\n"
++     "1:				\n\t"
++
++       "xvmaddadp	32, 40, 48	\n\t"	// x0_r * y0_r , x0_i * y0_i
++       "lxvd2x		48, 0, %3	\n\t"	// y0_r, y0_i
++       "xvmaddadp	34, 41, 49	\n\t"	// x1_r * y1_r , x1_i * y1_i
++       "lxvd2x		49, %7, %3	\n\t"	// y1_r, y1_i
++
++       "xvmaddadp	36, 42, 50	\n\t"	// x2_r * y2_r , x2_i * y2_i
++       "lxvd2x		50, %8, %3	\n\t"	// y2_r, y2_i
++       "xvmaddadp	38, 43, 51	\n\t"	// x3_r * y3_r , x3_i * y3_i
++       "lxvd2x		51, %9, %3	\n\t"	// y3_r, y3_i
++
++       "xvmaddadp	33, 40, 0	\n\t"	// x0_r * y0_i , x0_i * y0_r
++       "lxvd2x		40, 0, %2	\n\t"	// x0_r, x0_i
++       "xvmaddadp	35, 41, 1	\n\t"	// x1_r * y1_i , x1_i * y1_r
++       "lxvd2x		41, %7, %2	\n\t"	// x1_r, x1_i
++
++       "xvmaddadp	37, 42, 2	\n\t"	// x2_r * y2_i , x2_i * y2_r
++       "lxvd2x		42, %8, %2	\n\t"	// x2_r, x2_i
++       "xvmaddadp	39, 43, 3	\n\t"	// x3_r * y3_i , x3_i * y3_r
++       "lxvd2x		43, %9, %2	\n\t"	// x3_r, x3_i
++
++       "xxswapd		0,48		\n\t"	// y0_i, y0_r
++       "xxswapd		1,49		\n\t"	// y1_i, y1_r
++
++       "addi		%2, %2, 64	\n\t"
++       "addi		%3, %3, 64	\n\t"
++
++       "xxswapd		2,50		\n\t"	// y2_i, y2_r
++       "xxswapd		3,51		\n\t"	// y3_i, y3_r
++
++       "xvmaddadp	32, 44, 4	\n\t"	// x0_r * y0_r , x0_i * y0_i
++       "lxvd2x		4, 0, %3	\n\t"	// y0_r, y0_i
++       "xvmaddadp	34, 45, 5	\n\t"	// x1_r * y1_r , x1_i * y1_i
++       "lxvd2x		5, %7, %3	\n\t"	// y1_r, y1_i
++       "xvmaddadp	36, 46, 6	\n\t"	// x2_r * y2_r , x2_i * y2_i
++       "lxvd2x		6, %8, %3	\n\t"	// y2_r, y2_i
++       "xvmaddadp	38, 47, 7	\n\t"	// x3_r * y3_r , x3_i * y3_i
++       "lxvd2x		7, %9, %3	\n\t"	// y3_r, y3_i
++
++       "xvmaddadp	33, 44, 8	\n\t"	// x0_r * y0_i , x0_i * y0_r
++       "lxvd2x		44, 0, %2	\n\t"	// x0_r, x0_i
++       "xvmaddadp	35, 45, 9	\n\t"	// x1_r * y1_i , x1_i * y1_r
++       "lxvd2x		45, %7, %2	\n\t"	// x1_r, x1_i
++       "xvmaddadp	37, 46, 10	\n\t"	// x2_r * y2_i , x2_i * y2_r
++       "lxvd2x		46, %8, %2	\n\t"	// x2_r, x2_i
++       "xvmaddadp	39, 47, 11	\n\t"	// x3_r * y3_i , x3_i * y3_r
++       "lxvd2x		47, %9, %2	\n\t"	// x3_r, x3_i
++
++       "xxswapd		8,4		\n\t"	// y0_i, y0_r
++       "xxswapd		9,5		\n\t"	// y1_i, y1_r
++
++       "addi		%2, %2, 64	\n\t"
++       "addi		%3, %3, 64	\n\t"
++
++       "xxswapd		10,6		\n\t"	// y2_i, y2_r
++       "xxswapd		11,7		\n\t"	// y3_i, y3_r
++
++       "addic.		%1, %1, -8	\n\t"
++       "bgt		1b		\n"
++
++     "2:				\n\t"
++
++       "xvmaddadp	32, 40, 48	\n\t"	// x0_r * y0_r , x0_i * y0_i
++       "xvmaddadp	34, 41, 49	\n\t"	// x1_r * y1_r , x1_i * y1_i
++       "xvmaddadp	36, 42, 50	\n\t"	// x2_r * y2_r , x2_i * y2_i
++       "xvmaddadp	38, 43, 51	\n\t"	// x3_r * y3_r , x3_i * y3_i
++
++       "xvmaddadp	33, 40, 0	\n\t"	// x0_r * y0_i , x0_i * y0_r
++       "xvmaddadp	35, 41, 1	\n\t"	// x1_r * y1_i , x1_i * y1_r
++       "xvmaddadp	37, 42, 2	\n\t"	// x2_r * y2_i , x2_i * y2_r
++       "xvmaddadp	39, 43, 3	\n\t"	// x3_r * y3_i , x3_i * y3_r
++
++       "xvmaddadp	32, 44, 4	\n\t"	// x0_r * y0_r , x0_i * y0_i
++       "xvmaddadp	34, 45, 5	\n\t"	// x1_r * y1_r , x1_i * y1_i
++       "xvmaddadp	36, 46, 6	\n\t"	// x2_r * y2_r , x2_i * y2_i
++       "xvmaddadp	38, 47, 7	\n\t"	// x3_r * y3_r , x3_i * y3_i
++
++       "xvmaddadp	33, 44, 8	\n\t"	// x0_r * y0_i , x0_i * y0_r
++       "xvmaddadp	35, 45, 9	\n\t"	// x1_r * y1_i , x1_i * y1_r
++       "xvmaddadp	37, 46, 10	\n\t"	// x2_r * y2_i , x2_i * y2_r
++       "xvmaddadp	39, 47, 11	\n\t"	// x3_r * y3_i , x3_i * y3_r
++
++       "xvadddp		32, 32, 34	\n\t"
++       "xvadddp		36, 36, 38	\n\t"
++
++       "xvadddp		33, 33, 35	\n\t"
++       "xvadddp		37, 37, 39	\n\t"
++
++       "xvadddp		32, 32, 36	\n\t"
++       "xvadddp		33, 33, 37	\n\t"
++
++       "stxvd2x		32, 0, %6	\n\t"
++       "stxvd2x		33, %7, %6	\n"
++
++     "#n=%1 x=%4=%2 y=%5=%3 dot=%0=%6 o16=%7 o32=%8 o48=%9"
++     :
++       "=m" (*dot),
++       "+r" (n),	// 1
++       "+b" (x),	// 2
++       "+b" (y)		// 3
++     :
++       "m" (*x),
++       "m" (*y),
++       "b" (dot),	// 6
++       "b" (16),	// 7
++       "b" (32),	// 8
++       "b" (48)		// 9
++     :
++       "cr0",
++       "vs32","vs33","vs34","vs35","vs36","vs37","vs38","vs39",
++       "vs40","vs41","vs42","vs43","vs44","vs45","vs46","vs47",
++       "vs48","vs49","vs50","vs51","vs0","vs1","vs2","vs3",
++       "vs4","vs5","vs6","vs7","vs8","vs9","vs10","vs11"
++     );
++}
+diff --git a/kernel/power/zscal.c b/kernel/power/zscal.c
+index 410fc98..14d677f 100644
+--- a/kernel/power/zscal.c
++++ b/kernel/power/zscal.c
+@@ -47,15 +47,15 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+ #ifndef HAVE_KERNEL_8
+ 
+-static void zscal_kernel_8(BLASLONG n, FLOAT *x, FLOAT *alpha)
++static void zscal_kernel_8(BLASLONG n, FLOAT *x, FLOAT da_r, FLOAT da_i)
+ {
+ 
+ 	BLASLONG i=0;
+ 	FLOAT *x1=x;
+-	FLOAT  alpha_r1=alpha[0];
+-	FLOAT  alpha_r2=alpha[1];
+-	FLOAT  alpha_i1=alpha[2];
+-	FLOAT  alpha_i2=alpha[3];
++	FLOAT  alpha_r1=da_r;
++	FLOAT  alpha_r2=da_r;
++	FLOAT  alpha_i1=-da_i;
++	FLOAT  alpha_i2=da_i;
+ 	FLOAT  temp00, temp01, temp10, temp11, temp20, temp21, temp30, temp31;
+ 	FLOAT  x0_r, x0_i, x1_r, x1_i, x2_r, x2_i, x3_r, x3_i;
+ 
+@@ -116,7 +116,6 @@ int CNAME(BLASLONG n, BLASLONG dummy0, BLASLONG dummy1, FLOAT da_r,FLOAT da_i, F
+ 	BLASLONG inc_x2;
+ 	BLASLONG ip = 0;
+ 	FLOAT temp;
+-	FLOAT alpha[4] __attribute__ ((aligned (16)));;
+ 	BLASLONG n1;
+ 
+ 	if ( n <= 0 )
+@@ -147,11 +146,7 @@ int CNAME(BLASLONG n, BLASLONG dummy0, BLASLONG dummy1, FLOAT da_r,FLOAT da_i, F
+ 		n1 = n & -8;
+ 		if ( n1 > 0 )
+ 		{
+-			alpha[0] = da_r;
+-			alpha[1] = da_r;
+-			alpha[2] = -da_i;
+-			alpha[3] = da_i;
+-			zscal_kernel_8(n1, x, alpha);
++			zscal_kernel_8(n1, x, da_r, da_i);
+ 			i=n1;
+ 			ip = n1 * 2;
+ 
+diff --git a/kernel/power/zscal_microk_power8.c b/kernel/power/zscal_microk_power8.c
+index 5e09d8d..aba9029 100644
+--- a/kernel/power/zscal_microk_power8.c
++++ b/kernel/power/zscal_microk_power8.c
+@@ -38,187 +38,202 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+ #define HAVE_KERNEL_8 1
+ 
+-static void zscal_kernel_8( BLASLONG n, FLOAT *x, FLOAT *alpha) __attribute__ ((noinline));
+-
+-static void zscal_kernel_8( BLASLONG n, FLOAT *x, FLOAT *alpha)
++static void zscal_kernel_8 (long n, double *x, double alpha_r, double alpha_i)
+ {
+-
+-
+-	BLASLONG i = n;
+-	BLASLONG o16 = 16;
+-	BLASLONG o32 = 32;
+-	BLASLONG o48 = 48;
+-	BLASLONG o64 = 64;
+-	BLASLONG o80 = 80;
+-	BLASLONG o96 = 96;
+-	BLASLONG o112 = 112;
+-	FLOAT *x1=x;
+-	FLOAT *x2=x+1;
+-	BLASLONG pre = 384;
+-
+-	__asm__  __volatile__
+-	(
+-
+-        "lxvd2x         32, 0, %3                           \n\t"	// alpha_r , alpha_r
+-        "lxvd2x         33, %5, %3                          \n\t"	// -alpha_i , alpha_i
+-        "addi           %1, %1, -8                          \n\t"
+-
+-	"dcbt		%2, %4				    \n\t"
+-
+-	"lxvd2x		40, 0, %2			    \n\t"	// x0_r, x0_i
+-	"lxvd2x		41, %5, %2			    \n\t"
+-	"lxvd2x		42, %6, %2			    \n\t"
+-	"lxvd2x		43, %7, %2			    \n\t"
+-	"lxvd2x		44, %8, %2			    \n\t"
+-	"lxvd2x		45, %9, %2			    \n\t"
+-	"lxvd2x		46, %10, %2			    \n\t"
+-	"lxvd2x		47, %11, %2			    \n\t"
+-
+-	"addi		%2, %2, 128			    \n\t"
+-
+-	"addic.		%0 , %0	, -8  	 	             \n\t"
+-	"ble		2f		             	     \n\t"
+-
+-	".align 5				            \n\t"
+-	"1:				                    \n\t"
+-
+-	"dcbt		%2, %4				    \n\t"
+-
+-	"xvmuldp	48, 40, 32		    	    \n\t"	// x0_r * alpha_r, x0_i * alpha_r
+-	"xvmuldp	49, 41, 32		    	    \n\t"
+-	"xvmuldp	50, 42, 32		    	    \n\t"
+-	"xvmuldp	51, 43, 32		    	    \n\t"
+-	"xvmuldp	52, 44, 32		    	    \n\t"
+-	"xvmuldp	53, 45, 32		    	    \n\t"
+-	"xvmuldp	54, 46, 32		    	    \n\t"
+-	"xvmuldp	55, 47, 32		    	    \n\t"
+-
+-	"xxswapd	56, 40				    \n\t"
+-	"xxswapd	57, 41				    \n\t"
+-	"xxswapd	58, 42				    \n\t"
+-	"xxswapd	59, 43				    \n\t"
+-	"xxswapd	60, 44				    \n\t"
+-	"xxswapd	61, 45				    \n\t"
+-	"xxswapd	62, 46				    \n\t"
+-	"xxswapd	63, 47				    \n\t"
+-
+-	"xvmuldp	56, 56, 33		    	    \n\t"	// x0_i * -alpha_i, x0_r * alpha_i
+-	"xvmuldp	57, 57, 33		    	    \n\t"
+-
+-	"lxvd2x		40, 0, %2			    \n\t"	// x0_r, x0_i
+-	"lxvd2x		41, %5, %2			    \n\t"
+-
+-	"xvmuldp	58, 58, 33		    	    \n\t"
+-	"xvmuldp	59, 59, 33		    	    \n\t"
+-
+-	"lxvd2x		42, %6, %2			    \n\t"
+-	"lxvd2x		43, %7, %2			    \n\t"
+-
+-	"xvmuldp	60, 60, 33		    	    \n\t"
+-	"xvmuldp	61, 61, 33		    	    \n\t"
+-
+-	"lxvd2x		44, %8, %2			    \n\t"
+-	"lxvd2x		45, %9, %2			    \n\t"
+-
+-	"xvmuldp	62, 62, 33		    	    \n\t"
+-	"xvmuldp	63, 63, 33		    	    \n\t"
+-
+-	"lxvd2x		46, %10, %2			    \n\t"
+-	"lxvd2x		47, %11, %2			    \n\t"
+-
+-	"xvadddp	48, 48 , 56			    \n\t"
+-	"xvadddp	49, 49 , 57			    \n\t"
+-	"xvadddp	50, 50 , 58			    \n\t"
+-	"xvadddp	51, 51 , 59			    \n\t"
+-
+-	"stxvd2x	48, 0, %1			    \n\t"
+-	"stxvd2x	49, %5, %1			    \n\t"
+-
+-	"xvadddp	52, 52 , 60			    \n\t"
+-	"xvadddp	53, 53 , 61			    \n\t"
+-
+-	"stxvd2x	50, %6, %1			    \n\t"
+-	"stxvd2x	51, %7, %1			    \n\t"
+-
+-	"xvadddp	54, 54 , 62			    \n\t"
+-	"xvadddp	55, 55 , 63			    \n\t"
+-
+-	"stxvd2x	52, %8, %1			    \n\t"
+-	"stxvd2x	53, %9, %1			    \n\t"
+-	"stxvd2x	54, %10, %1			    \n\t"
+-	"stxvd2x	55, %11, %1			    \n\t"
+-
+-	"addi		%1, %1, 128			    \n\t"
+-	"addi		%2, %2, 128			    \n\t"
+-
+-	"addic.		%0 , %0	, -8  	 	             \n\t"
+-	"bgt		1b		             	     \n\t"
+-
+-	"2:						     \n\t"
+-
+-	"xvmuldp	48, 40, 32		    	    \n\t"	// x0_r * alpha_r, x0_i * alpha_r
+-	"xvmuldp	49, 41, 32		    	    \n\t"
+-	"xvmuldp	50, 42, 32		    	    \n\t"
+-	"xvmuldp	51, 43, 32		    	    \n\t"
+-	"xvmuldp	52, 44, 32		    	    \n\t"
+-	"xvmuldp	53, 45, 32		    	    \n\t"
+-	"xvmuldp	54, 46, 32		    	    \n\t"
+-	"xvmuldp	55, 47, 32		    	    \n\t"
+-
+-	"xxswapd	56, 40				    \n\t"
+-	"xxswapd	57, 41				    \n\t"
+-	"xxswapd	58, 42				    \n\t"
+-	"xxswapd	59, 43				    \n\t"
+-	"xxswapd	60, 44				    \n\t"
+-	"xxswapd	61, 45				    \n\t"
+-	"xxswapd	62, 46				    \n\t"
+-	"xxswapd	63, 47				    \n\t"
+-
+-	"xvmuldp	56, 56, 33		    	    \n\t"	// x0_i * -alpha_i, x0_r * alpha_i
+-	"xvmuldp	57, 57, 33		    	    \n\t"
+-	"xvmuldp	58, 58, 33		    	    \n\t"
+-	"xvmuldp	59, 59, 33		    	    \n\t"
+-	"xvmuldp	60, 60, 33		    	    \n\t"
+-	"xvmuldp	61, 61, 33		    	    \n\t"
+-	"xvmuldp	62, 62, 33		    	    \n\t"
+-	"xvmuldp	63, 63, 33		    	    \n\t"
+-
+-	"xvadddp	48, 48 , 56			    \n\t"
+-	"xvadddp	49, 49 , 57			    \n\t"
+-	"xvadddp	50, 50 , 58			    \n\t"
+-	"xvadddp	51, 51 , 59			    \n\t"
+-	"xvadddp	52, 52 , 60			    \n\t"
+-	"xvadddp	53, 53 , 61			    \n\t"
+-	"xvadddp	54, 54 , 62			    \n\t"
+-	"xvadddp	55, 55 , 63			    \n\t"
+-
+-	"stxvd2x	48, 0, %1			    \n\t"
+-	"stxvd2x	49, %5, %1			    \n\t"
+-	"stxvd2x	50, %6, %1			    \n\t"
+-	"stxvd2x	51, %7, %1			    \n\t"
+-	"stxvd2x	52, %8, %1			    \n\t"
+-	"stxvd2x	53, %9, %1			    \n\t"
+-	"stxvd2x	54, %10, %1			    \n\t"
+-	"stxvd2x	55, %11, %1			    \n\t"
+-
+-
+-	:
+-        : 
+-          "r" (i),	// 0	
+-	  "r" (x2),  	// 1
+-          "r" (x1),     // 2
+-          "r" (alpha),  // 3
+-          "r" (pre),    // 4
+-	  "r" (o16),	// 5
+-	  "r" (o32),	// 6
+-	  "r" (o48),    // 7
+-          "r" (o64),    // 8
+-          "r" (o80),    // 9
+-          "r" (o96),    // 10
+-          "r" (o112)    // 11
+-	: "cr0", "%0", "%2" , "%1", "memory"
+-	);
+-
+-} 
+-
+-
++  __vector double t0;
++  __vector double t1;
++  __vector double t2;
++  __vector double t3;
++  __vector double t4;
++  __vector double t5;
++  __vector double t6;
++  __vector double t7;
++  __vector double t8;
++  __vector double t9;
++  __vector double t10;
++  __vector double t11;
++
++  __asm__
++    (
++       "dcbt		0, %2		\n\t"
++
++       "xsnegdp		33, %x16	\n\t"	// -alpha_i
++       "xxspltd		32, %x15, 0	\n\t"	// alpha_r , alpha_r
++       "xxmrghd		33, 33, %x16	\n\t"	// -alpha_i , alpha_i
++
++       "lxvd2x		40, 0, %2	\n\t"	// x0_r, x0_i
++       "lxvd2x		41, %17, %2	\n\t"
++       "lxvd2x		42, %18, %2	\n\t"
++       "lxvd2x		43, %19, %2	\n\t"
++       "lxvd2x		44, %20, %2	\n\t"
++       "lxvd2x		45, %21, %2	\n\t"
++       "lxvd2x		46, %22, %2	\n\t"
++       "lxvd2x		47, %23, %2	\n\t"
++
++       "addi		%2, %2, 128	\n\t"
++
++       "addic.		%1, %1, -8	\n\t"
++       "ble		2f		\n\t"
++
++       ".p2align	5		\n"
++     "1:				\n\t"
++
++       "xvmuldp		48, 40, 32	\n\t"	// x0_r * alpha_r, x0_i * alpha_r
++       "xvmuldp		49, 41, 32	\n\t"
++       "xvmuldp		50, 42, 32	\n\t"
++       "xvmuldp		51, 43, 32	\n\t"
++       "xvmuldp		%x3, 44, 32	\n\t"
++       "xvmuldp		%x4, 45, 32	\n\t"
++       "xvmuldp		%x5, 46, 32	\n\t"
++       "xvmuldp		%x6, 47, 32	\n\t"
++
++       "xxswapd		%x7, 40		\n\t"
++       "xxswapd		%x8, 41		\n\t"
++       "xxswapd		%x9, 42		\n\t"
++       "xxswapd		%x10, 43		\n\t"
++       "xxswapd		%x11, 44		\n\t"
++       "xxswapd		%x12, 45	\n\t"
++       "xxswapd		%x13, 46	\n\t"
++       "xxswapd		%x14, 47	\n\t"
++
++       "xvmuldp		%x7, %x7, 33	\n\t"	// x0_i * -alpha_i, x0_r * alpha_i
++       "xvmuldp		%x8, %x8, 33	\n\t"
++
++       "lxvd2x		40, 0, %2	\n\t"	// x0_r, x0_i
++       "lxvd2x		41, %17, %2	\n\t"
++
++       "xvmuldp		%x9, %x9, 33	\n\t"
++       "xvmuldp		%x10, %x10, 33	\n\t"
++
++       "lxvd2x		42, %18, %2	\n\t"
++       "lxvd2x		43, %19, %2	\n\t"
++
++       "xvmuldp		%x11, %x11, 33	\n\t"
++       "xvmuldp		%x12, %x12, 33	\n\t"
++
++       "lxvd2x		44, %20, %2	\n\t"
++       "lxvd2x		45, %21, %2	\n\t"
++
++       "xvmuldp		%x13, %x13, 33	\n\t"
++       "xvmuldp		%x14, %x14, 33	\n\t"
++
++       "lxvd2x		46, %22, %2	\n\t"
++       "lxvd2x		47, %23, %2	\n\t"
++
++       "addi		%2, %2, -128	\n\t"
++
++       "xvadddp		48, 48, %x7	\n\t"
++       "xvadddp		49, 49, %x8	\n\t"
++       "xvadddp		50, 50, %x9	\n\t"
++       "xvadddp		51, 51, %x10	\n\t"
++
++       "stxvd2x		48, 0, %2	\n\t"
++       "stxvd2x		49, %17, %2	\n\t"
++
++       "xvadddp		%x3, %x3, %x11	\n\t"
++       "xvadddp		%x4, %x4, %x12	\n\t"
++
++       "stxvd2x		50, %18, %2	\n\t"
++       "stxvd2x		51, %19, %2	\n\t"
++
++       "xvadddp		%x5, %x5, %x13	\n\t"
++       "xvadddp		%x6, %x6, %x14	\n\t"
++
++       "stxvd2x		%x3, %20, %2	\n\t"
++       "stxvd2x		%x4, %21, %2	\n\t"
++       "stxvd2x		%x5, %22, %2	\n\t"
++       "stxvd2x		%x6, %23, %2	\n\t"
++
++       "addi		%2, %2, 256	\n\t"
++
++       "addic.		%1, %1, -8	\n\t"
++       "bgt		1b		\n"
++
++     "2:				\n\t"
++
++       "xvmuldp		48, 40, 32	\n\t"	// x0_r * alpha_r, x0_i * alpha_r
++       "xvmuldp		49, 41, 32	\n\t"
++       "xvmuldp		50, 42, 32	\n\t"
++       "xvmuldp		51, 43, 32	\n\t"
++       "xvmuldp		%x3, 44, 32	\n\t"
++       "xvmuldp		%x4, 45, 32	\n\t"
++       "xvmuldp		%x5, 46, 32	\n\t"
++       "xvmuldp		%x6, 47, 32	\n\t"
++
++       "xxswapd		%x7, 40		\n\t"
++       "xxswapd		%x8, 41		\n\t"
++       "xxswapd		%x9, 42		\n\t"
++       "xxswapd		%x10, 43		\n\t"
++       "xxswapd		%x11, 44		\n\t"
++       "xxswapd		%x12, 45	\n\t"
++       "xxswapd		%x13, 46	\n\t"
++       "xxswapd		%x14, 47	\n\t"
++
++       "addi		%2, %2, -128	\n\t"
++
++       "xvmuldp		%x7, %x7, 33	\n\t"	// x0_i * -alpha_i, x0_r * alpha_i
++       "xvmuldp		%x8, %x8, 33	\n\t"
++       "xvmuldp		%x9, %x9, 33	\n\t"
++       "xvmuldp		%x10, %x10, 33	\n\t"
++       "xvmuldp		%x11, %x11, 33	\n\t"
++       "xvmuldp		%x12, %x12, 33	\n\t"
++       "xvmuldp		%x13, %x13, 33	\n\t"
++       "xvmuldp		%x14, %x14, 33	\n\t"
++
++       "xvadddp		48, 48, %x7	\n\t"
++       "xvadddp		49, 49, %x8	\n\t"
++       "xvadddp		50, 50, %x9	\n\t"
++       "xvadddp		51, 51, %x10	\n\t"
++
++       "stxvd2x		48, 0, %2	\n\t"
++       "stxvd2x		49, %17, %2	\n\t"
++
++       "xvadddp		%x3, %x3, %x11	\n\t"
++       "xvadddp		%x4, %x4, %x12	\n\t"
++
++       "stxvd2x		50, %18, %2	\n\t"
++       "stxvd2x		51, %19, %2	\n\t"
++
++       "xvadddp		%x5, %x5, %x13	\n\t"
++       "xvadddp		%x6, %x6, %x14	\n\t"
++
++       "stxvd2x		%x3, %20, %2	\n\t"
++       "stxvd2x		%x4, %21, %2	\n\t"
++       "stxvd2x		%x5, %22, %2	\n\t"
++       "stxvd2x		%x6, %23, %2	\n"
++
++     "#n=%1 x=%0=%2 alpha=(%15,%16) o16=%17 o32=%18 o48=%19 o64=%20 o80=%21 o96=%22 o112=%23\n"
++     "#t0=%x3 t1=%x4 t2=%x5 t3=%x6 t4=%x7 t5=%x8 t6=%x9 t7=%x10 t8=%x11 t9=%x12 t10=%x13 t11=%x14"
++     :
++       "+m" (*x),
++       "+r" (n),	// 1
++       "+b" (x),	// 2
++       "=wa" (t0),	// 3
++       "=wa" (t1),	// 4
++       "=wa" (t2),	// 5
++       "=wa" (t3),	// 6
++       "=wa" (t4),	// 7
++       "=wa" (t5),	// 8
++       "=wa" (t6),	// 9
++       "=wa" (t7),	// 10
++       "=wa" (t8),	// 11
++       "=wa" (t9),	// 12
++       "=wa" (t10),	// 13
++       "=wa" (t11)	// 14
++     :
++       "d" (alpha_r),	// 15
++       "d" (alpha_i),	// 16
++       "b" (16),	// 17
++       "b" (32),	// 18
++       "b" (48),	// 19
++       "b" (64),	// 20
++       "b" (80),	// 21
++       "b" (96),	// 22
++       "b" (112)	// 23
++     :
++       "cr0",
++       "vs32","vs33","vs34","vs35","vs36","vs37","vs38","vs39",
++       "vs40","vs41","vs42","vs43","vs44","vs45","vs46","vs47",
++       "vs48","vs49","vs50","vs51"
++     );
++}
+diff --git a/kernel/power/zswap_microk_power8.c b/kernel/power/zswap_microk_power8.c
+index 9e56237..54391ba 100644
+--- a/kernel/power/zswap_microk_power8.c
++++ b/kernel/power/zswap_microk_power8.c
+@@ -35,146 +35,123 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+ #define HAVE_KERNEL_16 1
+ 
+-static void zswap_kernel_16( BLASLONG n, FLOAT *x, FLOAT *y) __attribute__ ((noinline));
+-
+-static void zswap_kernel_16( BLASLONG n, FLOAT *x, FLOAT *y)
++static void
++zswap_kernel_16 (long n, double *x, double *y)
+ {
+-
+-
+-	BLASLONG i = n;
+-	BLASLONG o16 = 16;
+-	BLASLONG o32 = 32;
+-	BLASLONG o48 = 48;
+-	BLASLONG o64 = 64;
+-	BLASLONG o80 = 80;
+-	BLASLONG o96 = 96;
+-	BLASLONG o112 = 112;
+-	FLOAT *x1=x;
+-	FLOAT *y1=y;
+-	FLOAT *x2=x+1;
+-	FLOAT *y2=y+1;
+-	BLASLONG pre = 384;
+-	BLASLONG alpha=0;
+-
+-	__asm__  __volatile__
+-	(
+-
+-	"addi		%3, %3, -8			    \n\t"	
+-	"addi		%4, %4, -8			    \n\t"	
+-
+-	".align 5				            \n\t"
+-	"1:				                    \n\t"
+-
+-	"lxvd2x		32, 0, %2			    \n\t"
+-	"lxvd2x		33, %5, %2			    \n\t"
+-	"lxvd2x		34, %6, %2			    \n\t"
+-	"lxvd2x		35, %7, %2			    \n\t"
+-	"lxvd2x		36, %8, %2			    \n\t"
+-	"lxvd2x		37, %9, %2			    \n\t"
+-	"lxvd2x		38, %10, %2			    \n\t"
+-	"lxvd2x		39, %11, %2			    \n\t"
+-
+-	"addi		%2, %2, 128			    \n\t"
+-
+-	"lxvd2x		40, 0, %2			    \n\t"
+-	"lxvd2x		41, %5, %2			    \n\t"
+-	"lxvd2x		42, %6, %2			    \n\t"
+-	"lxvd2x		43, %7, %2			    \n\t"
+-	"lxvd2x		44, %8, %2			    \n\t"
+-	"lxvd2x		45, %9, %2			    \n\t"
+-	"lxvd2x		46, %10, %2			    \n\t"
+-	"lxvd2x		47, %11, %2			    \n\t"
+-
+-	"addi		%2, %2, 128			    \n\t"
+-
+-	"lxvd2x		48, 0, %1			    \n\t"
+-	"lxvd2x		49, %5, %1			    \n\t"
+-	"lxvd2x		50, %6, %1			    \n\t"
+-	"lxvd2x		51, %7, %1			    \n\t"
+-	"lxvd2x		52, %8, %1			    \n\t"
+-	"lxvd2x		53, %9, %1			    \n\t"
+-	"lxvd2x		54, %10, %1			    \n\t"
+-	"lxvd2x		55, %11, %1			    \n\t"
+-
+-	"addi		%1, %1, 128			    \n\t"
+-
+-	"lxvd2x		56, 0, %1			    \n\t"
+-	"lxvd2x		57, %5, %1			    \n\t"
+-	"lxvd2x		58, %6, %1			    \n\t"
+-	"lxvd2x		59, %7, %1			    \n\t"
+-	"lxvd2x		60, %8, %1			    \n\t"
+-	"lxvd2x		61, %9, %1			    \n\t"
+-	"lxvd2x		62, %10, %1			    \n\t"
+-	"lxvd2x		63, %11, %1			    \n\t"
+-
+-	"addi		%1, %1, 128			    \n\t"
+-
+-	"stxvd2x		32, 0, %3			    \n\t"
+-	"stxvd2x		33, %5, %3			    \n\t"
+-	"stxvd2x		34, %6, %3			    \n\t"
+-	"stxvd2x		35, %7, %3			    \n\t"
+-	"stxvd2x		36, %8, %3			    \n\t"
+-	"stxvd2x		37, %9, %3			    \n\t"
+-	"stxvd2x		38, %10, %3			    \n\t"
+-	"stxvd2x		39, %11, %3			    \n\t"
+-
+-	"addi		%3, %3, 128			    \n\t"
+-
+-	"stxvd2x		40, 0, %3			    \n\t"
+-	"stxvd2x		41, %5, %3			    \n\t"
+-	"stxvd2x		42, %6, %3			    \n\t"
+-	"stxvd2x		43, %7, %3			    \n\t"
+-	"stxvd2x		44, %8, %3			    \n\t"
+-	"stxvd2x		45, %9, %3			    \n\t"
+-	"stxvd2x		46, %10, %3			    \n\t"
+-	"stxvd2x		47, %11, %3			    \n\t"
+-
+-	"addi		%3, %3, 128			    \n\t"
+-
+-	"stxvd2x		48, 0, %4			    \n\t"
+-	"stxvd2x		49, %5, %4			    \n\t"
+-	"stxvd2x		50, %6, %4			    \n\t"
+-	"stxvd2x		51, %7, %4			    \n\t"
+-	"stxvd2x		52, %8, %4			    \n\t"
+-	"stxvd2x		53, %9, %4			    \n\t"
+-	"stxvd2x		54, %10, %4			    \n\t"
+-	"stxvd2x		55, %11, %4			    \n\t"
+-
+-	"addi		%4, %4, 128			    \n\t"
+-
+-	"stxvd2x		56, 0, %4			    \n\t"
+-	"stxvd2x		57, %5, %4			    \n\t"
+-	"stxvd2x		58, %6, %4			    \n\t"
+-	"stxvd2x		59, %7, %4			    \n\t"
+-	"stxvd2x		60, %8, %4			    \n\t"
+-	"stxvd2x		61, %9, %4			    \n\t"
+-	"stxvd2x		62, %10, %4			    \n\t"
+-	"stxvd2x		63, %11, %4			    \n\t"
+-
+-	"addi		%4, %4, 128			    \n\t"
+-
+-	"addic.		%0 , %0	, -16  	 	             \n\t"
+-	"bgt		1b		             	     \n\t"
+-
+-	"2:						     \n\t"
+-
+-	:
+-        : 
+-          "r" (i),	// 0	
+-	  "r" (y1),  	// 1
+-          "r" (x1),     // 2
+-          "r" (y2),     // 3
+-          "r" (x2),     // 4
+-	  "r" (o16),	// 5
+-	  "r" (o32),	// 6
+-	  "r" (o48),    // 7
+-          "r" (o64),    // 8
+-          "r" (o80),    // 9
+-          "r" (o96),    // 10
+-          "r" (o112)    // 11
+-	: "cr0", "%0", "%2" , "%1", "%3", "%4", "memory"
+-	);
+-
+-} 
+-
+-
++  __asm__
++    (
++       ".p2align	5		\n"
++     "1:				\n\t"
++       "lxvd2x		32, 0, %4	\n\t"
++       "lxvd2x		33, %5, %4	\n\t"
++       "lxvd2x		34, %6, %4	\n\t"
++       "lxvd2x		35, %7, %4	\n\t"
++       "lxvd2x		36, %8, %4	\n\t"
++       "lxvd2x		37, %9, %4	\n\t"
++       "lxvd2x		38, %10, %4	\n\t"
++       "lxvd2x		39, %11, %4	\n\t"
++
++       "addi		%4, %4, 128	\n\t"
++
++       "lxvd2x		40, 0, %4	\n\t"
++       "lxvd2x		41, %5, %4	\n\t"
++       "lxvd2x		42, %6, %4	\n\t"
++       "lxvd2x		43, %7, %4	\n\t"
++       "lxvd2x		44, %8, %4	\n\t"
++       "lxvd2x		45, %9, %4	\n\t"
++       "lxvd2x		46, %10, %4	\n\t"
++       "lxvd2x		47, %11, %4	\n\t"
++
++       "addi		%4, %4, -128	\n\t"
++
++       "lxvd2x		48, 0, %3	\n\t"
++       "lxvd2x		49, %5, %3	\n\t"
++       "lxvd2x		50, %6, %3	\n\t"
++       "lxvd2x		51, %7, %3	\n\t"
++       "lxvd2x		0, %8, %3	\n\t"
++       "lxvd2x		1, %9, %3	\n\t"
++       "lxvd2x		2, %10, %3	\n\t"
++       "lxvd2x		3, %11, %3	\n\t"
++
++       "addi		%3, %3, 128	\n\t"
++
++       "lxvd2x		4, 0, %3	\n\t"
++       "lxvd2x		5, %5, %3	\n\t"
++       "lxvd2x		6, %6, %3	\n\t"
++       "lxvd2x		7, %7, %3	\n\t"
++       "lxvd2x		8, %8, %3	\n\t"
++       "lxvd2x		9, %9, %3	\n\t"
++       "lxvd2x		10, %10, %3	\n\t"
++       "lxvd2x		11, %11, %3	\n\t"
++
++       "addi		%3, %3, -128	\n\t"
++
++       "stxvd2x		32, 0, %3	\n\t"
++       "stxvd2x		33, %5, %3	\n\t"
++       "stxvd2x		34, %6, %3	\n\t"
++       "stxvd2x		35, %7, %3	\n\t"
++       "stxvd2x		36, %8, %3	\n\t"
++       "stxvd2x		37, %9, %3	\n\t"
++       "stxvd2x		38, %10, %3	\n\t"
++       "stxvd2x		39, %11, %3	\n\t"
++
++       "addi		%3, %3, 128	\n\t"
++
++       "stxvd2x		40, 0, %3	\n\t"
++       "stxvd2x		41, %5, %3	\n\t"
++       "stxvd2x		42, %6, %3	\n\t"
++       "stxvd2x		43, %7, %3	\n\t"
++       "stxvd2x		44, %8, %3	\n\t"
++       "stxvd2x		45, %9, %3	\n\t"
++       "stxvd2x		46, %10, %3	\n\t"
++       "stxvd2x		47, %11, %3	\n\t"
++
++       "addi		%3, %3, 128	\n\t"
++
++       "stxvd2x		48, 0, %4	\n\t"
++       "stxvd2x		49, %5, %4	\n\t"
++       "stxvd2x		50, %6, %4	\n\t"
++       "stxvd2x		51, %7, %4	\n\t"
++       "stxvd2x		0, %8, %4	\n\t"
++       "stxvd2x		1, %9, %4	\n\t"
++       "stxvd2x		2, %10, %4	\n\t"
++       "stxvd2x		3, %11, %4	\n\t"
++
++       "addi		%4, %4, 128	\n\t"
++
++       "stxvd2x		4, 0, %4	\n\t"
++       "stxvd2x		5, %5, %4	\n\t"
++       "stxvd2x		6, %6, %4	\n\t"
++       "stxvd2x		7, %7, %4	\n\t"
++       "stxvd2x		8, %8, %4	\n\t"
++       "stxvd2x		9, %9, %4	\n\t"
++       "stxvd2x		10, %10, %4	\n\t"
++       "stxvd2x		11, %11, %4	\n\t"
++
++       "addi		%4, %4, 128	\n\t"
++       "addic.		%2, %2, -16	\n\t"
++       "bgt		1b		\n"
++
++     "#n=%2 x=%0=%3 y=%1=%4 o16=%5 o32=%6 o48=%7 o64=%8 o80=%9 o96=%10 o112=%11"
++     :
++       "+m" (*x),
++       "+m" (*y),
++       "+r" (n),	// 2
++       "+b" (x),	// 3
++       "+b" (y)		// 4
++     :
++       "b" (16),	// 5
++       "b" (32),	// 6
++       "b" (48),	// 7
++       "b" (64),	// 8
++       "b" (80),	// 9
++       "b" (96),	// 10
++       "b" (112)	// 11
++     :
++       "cr0",
++       "vs32","vs33","vs34","vs35","vs36","vs37","vs38","vs39",
++       "vs40","vs41","vs42","vs43","vs44","vs45","vs46","vs47",
++       "vs48","vs49","vs50","vs51","vs0","vs1","vs2","vs3",
++       "vs4","vs5","vs6","vs7","vs8","vs9","vs10","vs11"
++     );
++}
diff --git a/deps/patches/osx-10.10.llvm-3.3.patch b/deps/patches/osx-10.10.llvm-3.3.patch
deleted file mode 100644
index f22aaf03432f2a..00000000000000
--- a/deps/patches/osx-10.10.llvm-3.3.patch
+++ /dev/null
@@ -1,14 +0,0 @@
---- 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
-   # Strip a number like 10.4.7 to 10.4
--  DARWIN_VERSION := $(shell echo $(DARWIN_VERSION)| sed -E 's/(10.[0-9]).*/\1/')
-+  DARWIN_VERSION := $(shell echo $(DARWIN_VERSION)| sed -E 's/(10.[0-9]+).*/\1/')
-   # Get "4" out of 10.4 for later pieces in the makefile.
--  DARWIN_MAJVERS := $(shell echo $(DARWIN_VERSION)| sed -E 's/10.([0-9]).*/\1/')
-+  DARWIN_MAJVERS := $(shell echo $(DARWIN_VERSION)| sed -E 's/10.([0-9]+).*/\1/')
- 
-   LoadableModuleOptions := -Wl,-flat_namespace -Wl,-undefined,suppress
-   SharedLinkOptions := -dynamiclib
diff --git a/deps/patches/pcre-mingw.patch b/deps/patches/pcre-mingw.patch
new file mode 100644
index 00000000000000..862cd4bf3a0a96
--- /dev/null
+++ b/deps/patches/pcre-mingw.patch
@@ -0,0 +1,13 @@
+diff --git a/src/pcre2grep.c b/src/pcre2grep.c
+index e98d743..f00dac2 100644
+--- a/src/pcre2grep.c
++++ b/src/pcre2grep.c
+@@ -628,7 +628,7 @@ z/OS, and "no support". */
+ 
+ /************* Directory scanning Unix-style and z/OS ***********/
+ 
+-#if (defined HAVE_SYS_STAT_H && defined HAVE_DIRENT_H && defined HAVE_SYS_TYPES_H) || defined NATIVE_ZOS
++#if ((defined HAVE_SYS_STAT_H && defined HAVE_DIRENT_H && defined HAVE_SYS_TYPES_H) || defined NATIVE_ZOS) && !defined WIN32
+ #include <sys/types.h>
+ #include <sys/stat.h>
+ #include <dirent.h>
diff --git a/deps/patches/win64-int128.llvm-3.3.patch b/deps/patches/win64-int128.llvm-3.3.patch
deleted file mode 100644
index 6088df80ff6d91..00000000000000
--- a/deps/patches/win64-int128.llvm-3.3.patch
+++ /dev/null
@@ -1,397 +0,0 @@
-diff -rupN llvm-3.3.src/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp llvm-3.3/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp
---- llvm-3.3.src/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp	2013-04-20 08:32:17.000000000 -0400
-+++ llvm-3.3/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp	2013-08-20 23:12:52.847754541 -0400
-@@ -1849,6 +1849,17 @@ SDValue SelectionDAGLegalize::ExpandBUIL
- // and leave the Hi part unset.
- SDValue SelectionDAGLegalize::ExpandLibCall(RTLIB::Libcall LC, SDNode *Node,
-                                             bool isSigned) {
-+  Triple Trip(DAG.getTarget().getTargetTriple());
-+  int Win64 = Trip.isArch64Bit() && Trip.isOSWindows();
-+
-+  // By default, the input chain to this libcall is the entry node of the
-+  // function. If the libcall is going to be emitted as a tail call then
-+  // TLI.isUsedByReturnOnly will change it to the right chain if the return
-+  // node which is being folded has a non-entry input chain.
-+  SDValue InChain = DAG.getEntryNode();
-+  bool isTailCall = true;
-+  DebugLoc dl = Node->getDebugLoc();
-+
-   TargetLowering::ArgListTy Args;
-   TargetLowering::ArgListEntry Entry;
-   for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) {
-@@ -1857,31 +1868,48 @@ SDValue SelectionDAGLegalize::ExpandLibC
-     Entry.Node = Node->getOperand(i); Entry.Ty = ArgTy;
-     Entry.isSExt = isSigned;
-     Entry.isZExt = !isSigned;
-+    if (Win64 && Entry.Node.getValueType().getSizeInBits() > 64) {
-+      //printf("win64 libcall arg %d i128*\n", i);
-+      SDValue StackPtr = DAG.CreateStackTemporary(Entry.Node.getValueType(), 16); 
-+      int SPFI = cast<FrameIndexSDNode>(StackPtr.getNode())->getIndex();
-+      MachinePointerInfo PtrInfo = MachinePointerInfo::getFixedStack(SPFI);
-+      // Emit a store to the stack slot.
-+      InChain = DAG.getStore(InChain, dl, Entry.Node, StackPtr, PtrInfo,
-+                                   false, false, 16); 
-+      Entry.Node = StackPtr;
-+      Entry.Ty = PointerType::get(Entry.Ty,0);
-+      Entry.isSExt = false;
-+      Entry.isZExt = false;
-+      if (isTailCall) isTailCall = false;
-+    }
-     Args.push_back(Entry);
-   }
-   SDValue Callee = DAG.getExternalSymbol(TLI.getLibcallName(LC),
-                                          TLI.getPointerTy());
- 
--  Type *RetTy = Node->getValueType(0).getTypeForEVT(*DAG.getContext());
--
--  // By default, the input chain to this libcall is the entry node of the
--  // function. If the libcall is going to be emitted as a tail call then
--  // TLI.isUsedByReturnOnly will change it to the right chain if the return
--  // node which is being folded has a non-entry input chain.
--  SDValue InChain = DAG.getEntryNode();
-+  EVT RetVT = Node->getValueType(0);
-+  Type *RetTy;
-+  if (Win64 && RetVT.getSizeInBits() == 128) {
-+      RetTy = static_cast<EVT>(MVT::v2i64).getTypeForEVT(*DAG.getContext());
-+      isTailCall = false; // necessary because of the calling convention mismatch between LLVM and native Win64
-+  } else {
-+      RetTy = RetVT.getTypeForEVT(*DAG.getContext());
-+  }
- 
--  // isTailCall may be true since the callee does not reference caller stack
--  // frame. Check if it's in the right position.
--  SDValue TCChain = InChain;
--  bool isTailCall = TLI.isInTailCallPosition(DAG, Node, TCChain);
--  if (isTailCall)
--    InChain = TCChain;
-+  if (isTailCall) {
-+    // isTailCall may be true since the callee does not reference caller stack
-+    // frame. Check if it's in the right position.
-+    SDValue TCChain = InChain;
-+    isTailCall = TLI.isInTailCallPosition(DAG, Node, TCChain);
-+    if (isTailCall)
-+      InChain = TCChain;
-+  }
- 
-   TargetLowering::
-   CallLoweringInfo CLI(InChain, RetTy, isSigned, !isSigned, false, false,
-                     0, TLI.getLibcallCallingConv(LC), isTailCall,
-                     /*doesNotReturn=*/false, /*isReturnValueUsed=*/true,
--                    Callee, Args, DAG, Node->getDebugLoc());
-+                    Callee, Args, DAG, dl);
-   std::pair<SDValue, SDValue> CallInfo = TLI.LowerCallTo(CLI);
- 
- 
-@@ -1889,7 +1917,10 @@ SDValue SelectionDAGLegalize::ExpandLibC
-     // It's a tailcall, return the chain (which is the DAG root).
-     return DAG.getRoot();
- 
--  return CallInfo.first;
-+  SDValue ret = CallInfo.first;
-+  if (isa<VectorType>(RetTy))
-+      ret = DAG.getNode(ISD::BITCAST, dl, RetVT, ret);
-+  return ret;
- }
- 
- /// ExpandLibCall - Generate a libcall taking the given operands as arguments
-@@ -1900,27 +1931,52 @@ SDValue SelectionDAGLegalize::ExpandLibC
-   TargetLowering::ArgListTy Args;
-   Args.reserve(NumOps);
- 
-+  Triple Trip(DAG.getTarget().getTargetTriple());
-+  int Win64 = Trip.isArch64Bit() && Trip.isOSWindows();
-+
-+  SDValue InChain = DAG.getEntryNode();
-   TargetLowering::ArgListEntry Entry;
-   for (unsigned i = 0; i != NumOps; ++i) {
-     Entry.Node = Ops[i];
-     Entry.Ty = Entry.Node.getValueType().getTypeForEVT(*DAG.getContext());
-     Entry.isSExt = isSigned;
-     Entry.isZExt = !isSigned;
-+    if (Win64 && Entry.Node.getValueType().getSizeInBits() > 64) {
-+      //printf("win64 libcall arg %d i128*\n", i);
-+      SDValue StackPtr = DAG.CreateStackTemporary(Entry.Node.getValueType(), 16); 
-+      int SPFI = cast<FrameIndexSDNode>(StackPtr.getNode())->getIndex();
-+      MachinePointerInfo PtrInfo = MachinePointerInfo::getFixedStack(SPFI);
-+      // Emit a store to the stack slot.
-+      InChain = DAG.getStore(InChain, dl, Entry.Node, StackPtr, PtrInfo,
-+                                   false, false, 16); 
-+      Entry.Node = StackPtr;
-+      Entry.Ty = PointerType::get(Entry.Ty,0);
-+      Entry.isSExt = false;
-+      Entry.isZExt = false;
-+    }
-     Args.push_back(Entry);
-   }
-   SDValue Callee = DAG.getExternalSymbol(TLI.getLibcallName(LC),
-                                          TLI.getPointerTy());
- 
--  Type *RetTy = RetVT.getTypeForEVT(*DAG.getContext());
-+  Type *RetTy;
-+  if (Win64 && RetVT.getSizeInBits() == 128) {
-+      RetTy = static_cast<EVT>(MVT::v2i64).getTypeForEVT(*DAG.getContext());
-+  } else {
-+      RetTy = RetVT.getTypeForEVT(*DAG.getContext());
-+  }
-   TargetLowering::
--  CallLoweringInfo CLI(DAG.getEntryNode(), RetTy, isSigned, !isSigned, false,
-+  CallLoweringInfo CLI(InChain, RetTy, isSigned, !isSigned, false,
-                        false, 0, TLI.getLibcallCallingConv(LC),
-                        /*isTailCall=*/false,
-                   /*doesNotReturn=*/false, /*isReturnValueUsed=*/true,
-                   Callee, Args, DAG, dl);
-   std::pair<SDValue,SDValue> CallInfo = TLI.LowerCallTo(CLI);
- 
--  return CallInfo.first;
-+  SDValue ret = CallInfo.first;
-+  if (isa<VectorType>(RetTy))
-+      ret = DAG.getNode(ISD::BITCAST, dl, RetVT, ret);
-+  return ret; 
- }
- 
- // ExpandChainLibCall - Expand a node into a call to a libcall. Similar to
-@@ -1931,6 +1987,10 @@ SelectionDAGLegalize::ExpandChainLibCall
-                                          bool isSigned) {
-   SDValue InChain = Node->getOperand(0);
- 
-+  Triple Trip(DAG.getTarget().getTargetTriple());
-+  int Win64 = Trip.isArch64Bit() && Trip.isOSWindows();
-+  DebugLoc dl = Node->getDebugLoc();
-+
-   TargetLowering::ArgListTy Args;
-   TargetLowering::ArgListEntry Entry;
-   for (unsigned i = 1, e = Node->getNumOperands(); i != e; ++i) {
-@@ -1940,19 +2000,39 @@ SelectionDAGLegalize::ExpandChainLibCall
-     Entry.Ty = ArgTy;
-     Entry.isSExt = isSigned;
-     Entry.isZExt = !isSigned;
-+    if (Win64 && Entry.Node.getValueType().getSizeInBits() > 64) {
-+      //printf("win64 libcall arg %d i128*\n", i);
-+      SDValue StackPtr = DAG.CreateStackTemporary(Entry.Node.getValueType(), 16);
-+      int SPFI = cast<FrameIndexSDNode>(StackPtr.getNode())->getIndex();
-+      MachinePointerInfo PtrInfo = MachinePointerInfo::getFixedStack(SPFI);
-+      // Emit a store to the stack slot.
-+      InChain = DAG.getStore(InChain, dl, Entry.Node, StackPtr, PtrInfo,
-+                                   false, false, 16);
-+      Entry.Node = StackPtr;
-+      Entry.Ty = PointerType::get(Entry.Ty,0);
-+      Entry.isSExt = false;
-+      Entry.isZExt = false;
-+    }
-     Args.push_back(Entry);
-   }
-   SDValue Callee = DAG.getExternalSymbol(TLI.getLibcallName(LC),
-                                          TLI.getPointerTy());
--
--  Type *RetTy = Node->getValueType(0).getTypeForEVT(*DAG.getContext());
-+  EVT RetVT = Node->getValueType(0);
-+  Type *RetTy;
-+  if (Win64 && RetVT.getSizeInBits() == 128) {
-+      RetTy = static_cast<EVT>(MVT::v2i64).getTypeForEVT(*DAG.getContext());
-+  } else {
-+      RetTy = RetVT.getTypeForEVT(*DAG.getContext());
-+  }
-   TargetLowering::
-   CallLoweringInfo CLI(InChain, RetTy, isSigned, !isSigned, false, false,
-                     0, TLI.getLibcallCallingConv(LC), /*isTailCall=*/false,
-                     /*doesNotReturn=*/false, /*isReturnValueUsed=*/true,
--                    Callee, Args, DAG, Node->getDebugLoc());
-+                    Callee, Args, DAG, dl);
-   std::pair<SDValue, SDValue> CallInfo = TLI.LowerCallTo(CLI);
--
-+  
-+  if (isa<VectorType>(RetTy))
-+            CallInfo.first = DAG.getNode(ISD::BITCAST, dl, RetVT, CallInfo.first);
-   return CallInfo;
- }
- 
-@@ -2056,10 +2136,14 @@ SelectionDAGLegalize::ExpandDivRemLibCal
-   // Legalizing the call will automatically add the previous call to the
-   // dependence.
-   SDValue InChain = DAG.getEntryNode();
-+  DebugLoc dl = Node->getDebugLoc();
- 
-   EVT RetVT = Node->getValueType(0);
-   Type *RetTy = RetVT.getTypeForEVT(*DAG.getContext());
- 
-+  Triple Trip(DAG.getTarget().getTargetTriple());
-+  int Win64 = Trip.isArch64Bit() && Trip.isOSWindows();
-+
-   TargetLowering::ArgListTy Args;
-   TargetLowering::ArgListEntry Entry;
-   for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) {
-@@ -2068,6 +2152,19 @@ SelectionDAGLegalize::ExpandDivRemLibCal
-     Entry.Node = Node->getOperand(i); Entry.Ty = ArgTy;
-     Entry.isSExt = isSigned;
-     Entry.isZExt = !isSigned;
-+    if (Win64 && Entry.Node.getValueType().getSizeInBits() > 64) {
-+      //printf("win64 libcall arg %d i128*\n", i);
-+      SDValue StackPtr = DAG.CreateStackTemporary(Entry.Node.getValueType(), 16);
-+      int SPFI = cast<FrameIndexSDNode>(StackPtr.getNode())->getIndex();
-+      MachinePointerInfo PtrInfo = MachinePointerInfo::getFixedStack(SPFI);
-+      // Emit a store to the stack slot.
-+      InChain = DAG.getStore(InChain, dl, Entry.Node, StackPtr, PtrInfo,
-+                                   false, false, 16);
-+      Entry.Node = StackPtr;
-+      Entry.Ty = PointerType::get(Entry.Ty,0);
-+      Entry.isSExt = false;
-+      Entry.isZExt = false;
-+    }
-     Args.push_back(Entry);
-   }
- 
-@@ -2081,8 +2178,10 @@ SelectionDAGLegalize::ExpandDivRemLibCal
- 
-   SDValue Callee = DAG.getExternalSymbol(TLI.getLibcallName(LC),
-                                          TLI.getPointerTy());
--
--  DebugLoc dl = Node->getDebugLoc();
-+  
-+  if (Win64 && RetVT.getSizeInBits() == 128) {
-+      RetTy = static_cast<EVT>(MVT::v2i64).getTypeForEVT(*DAG.getContext());
-+  }
-   TargetLowering::
-   CallLoweringInfo CLI(InChain, RetTy, isSigned, !isSigned, false, false,
-                     0, TLI.getLibcallCallingConv(LC), /*isTailCall=*/false,
-@@ -2093,7 +2192,10 @@ SelectionDAGLegalize::ExpandDivRemLibCal
-   // Remainder is loaded back from the stack frame.
-   SDValue Rem = DAG.getLoad(RetVT, dl, CallInfo.second, FIPtr,
-                             MachinePointerInfo(), false, false, false, 0);
--  Results.push_back(CallInfo.first);
-+  if (isa<VectorType>(RetTy))
-+      Results.push_back(DAG.getNode(ISD::BITCAST, dl, RetVT, CallInfo.first));
-+  else
-+      Results.push_back(CallInfo.first);
-   Results.push_back(Rem);
- }
- 
-diff -rupN llvm-3.3.src/lib/CodeGen/SelectionDAG/LegalizeTypes.cpp llvm-3.3/lib/CodeGen/SelectionDAG/LegalizeTypes.cpp
---- llvm-3.3.src/lib/CodeGen/SelectionDAG/LegalizeTypes.cpp	2013-03-20 10:51:01.000000000 -0400
-+++ llvm-3.3/lib/CodeGen/SelectionDAG/LegalizeTypes.cpp	2013-08-20 23:00:29.455790788 -0400
-@@ -15,6 +15,7 @@
- 
- #include "LegalizeTypes.h"
- #include "llvm/ADT/SetVector.h"
-+#include "llvm/ADT/Triple.h"
- #include "llvm/IR/CallingConv.h"
- #include "llvm/IR/DataLayout.h"
- #include "llvm/Support/CommandLine.h"
-@@ -1069,6 +1070,10 @@ std::pair<SDValue, SDValue>
- DAGTypeLegalizer::ExpandChainLibCall(RTLIB::Libcall LC,
-                                          SDNode *Node,
-                                          bool isSigned) {
-+  Triple Trip(DAG.getTarget().getTargetTriple());
-+  int Win64 = Trip.isArch64Bit() && Trip.isOSWindows();
-+  DebugLoc dl = Node->getDebugLoc();
-+
-   SDValue InChain = Node->getOperand(0);
- 
-   TargetLowering::ArgListTy Args;
-@@ -1080,12 +1085,32 @@ DAGTypeLegalizer::ExpandChainLibCall(RTL
-     Entry.Ty = ArgTy;
-     Entry.isSExt = isSigned;
-     Entry.isZExt = !isSigned;
-+    if (Win64 && Entry.Node.getValueType().getSizeInBits() > 64) {
-+      //printf("win64 libcall arg %d i128*\n", i);
-+      SDValue StackPtr = DAG.CreateStackTemporary(Entry.Node.getValueType(), 16);
-+      int SPFI = cast<FrameIndexSDNode>(StackPtr.getNode())->getIndex();
-+      MachinePointerInfo PtrInfo = MachinePointerInfo::getFixedStack(SPFI);
-+      // Emit a store to the stack slot.
-+      InChain = DAG.getStore(InChain, dl, Entry.Node, StackPtr, PtrInfo,
-+                                   false, false, 16);
-+      Entry.Node = StackPtr;
-+      Entry.Ty = PointerType::get(Entry.Ty,0);
-+      Entry.isSExt = false;
-+      Entry.isZExt = false;
-+    }
-     Args.push_back(Entry);
-   }
-   SDValue Callee = DAG.getExternalSymbol(TLI.getLibcallName(LC),
-                                          TLI.getPointerTy());
- 
--  Type *RetTy = Node->getValueType(0).getTypeForEVT(*DAG.getContext());
-+  EVT RetVT = Node->getValueType(0);
-+  Type *RetTy;
-+  if (Win64 && RetVT.getSizeInBits() == 128) {
-+      RetTy = static_cast<EVT>(MVT::v2i64).getTypeForEVT(*DAG.getContext());
-+  } else {
-+      RetTy = RetVT.getTypeForEVT(*DAG.getContext());
-+  }
-+
-   TargetLowering::
-   CallLoweringInfo CLI(InChain, RetTy, isSigned, !isSigned, false, false,
-                     0, TLI.getLibcallCallingConv(LC), /*isTailCall=*/false,
-@@ -1093,6 +1118,8 @@ DAGTypeLegalizer::ExpandChainLibCall(RTL
-                     Callee, Args, DAG, Node->getDebugLoc());
-   std::pair<SDValue, SDValue> CallInfo = TLI.LowerCallTo(CLI);
- 
-+  if (isa<VectorType>(RetTy))
-+      CallInfo.first = DAG.getNode(ISD::BITCAST, dl, RetVT, CallInfo.first);
-   return CallInfo;
- }
- 
-diff -rupN llvm-3.3.src/lib/CodeGen/SelectionDAG/TargetLowering.cpp llvm-3.3/lib/CodeGen/SelectionDAG/TargetLowering.cpp
---- llvm-3.3.src/lib/CodeGen/SelectionDAG/TargetLowering.cpp	2013-02-12 16:21:59.000000000 -0500
-+++ llvm-3.3/lib/CodeGen/SelectionDAG/TargetLowering.cpp	2013-08-20 22:33:34.663869523 -0400
-@@ -14,6 +14,7 @@
- #include "llvm/Target/TargetLowering.h"
- #include "llvm/ADT/BitVector.h"
- #include "llvm/ADT/STLExtras.h"
-+#include "llvm/ADT/Triple.h"
- #include "llvm/CodeGen/Analysis.h"
- #include "llvm/CodeGen/MachineFrameInfo.h"
- #include "llvm/CodeGen/MachineFunction.h"
-@@ -74,26 +75,50 @@ SDValue TargetLowering::makeLibCall(Sele
-   TargetLowering::ArgListTy Args;
-   Args.reserve(NumOps);
- 
-+  Triple Trip(DAG.getTarget().getTargetTriple());
-+  int Win64 = Trip.isArch64Bit() && Trip.isOSWindows();
-+  SDValue InChain = DAG.getEntryNode();
-   TargetLowering::ArgListEntry Entry;
-   for (unsigned i = 0; i != NumOps; ++i) {
-     Entry.Node = Ops[i];
-     Entry.Ty = Entry.Node.getValueType().getTypeForEVT(*DAG.getContext());
-     Entry.isSExt = isSigned;
-     Entry.isZExt = !isSigned;
-+    if (Win64 && Entry.Node.getValueType().getSizeInBits() > 64) {
-+      //printf("win64 libcall arg %d i128*\n", i);
-+      SDValue StackPtr = DAG.CreateStackTemporary(Entry.Node.getValueType(), 16); 
-+      int SPFI = cast<FrameIndexSDNode>(StackPtr.getNode())->getIndex();
-+      MachinePointerInfo PtrInfo = MachinePointerInfo::getFixedStack(SPFI);
-+      // Emit a store to the stack slot.
-+      InChain = DAG.getStore(InChain, dl, Entry.Node, StackPtr, PtrInfo,
-+                                   false, false, 16); 
-+      Entry.Node = StackPtr;
-+      Entry.Ty = PointerType::get(Entry.Ty,0);
-+      Entry.isSExt = false;
-+      Entry.isZExt = false;
-+    }
-     Args.push_back(Entry);
-   }
-   SDValue Callee = DAG.getExternalSymbol(getLibcallName(LC), getPointerTy());
- 
--  Type *RetTy = RetVT.getTypeForEVT(*DAG.getContext());
-+  Type *RetTy;
-+  if (Win64 && RetVT.getSizeInBits() == 128) {
-+      RetTy = static_cast<EVT>(MVT::v2i64).getTypeForEVT(*DAG.getContext());
-+  } else {
-+      RetTy = RetVT.getTypeForEVT(*DAG.getContext());
-+  }
-   TargetLowering::
--  CallLoweringInfo CLI(DAG.getEntryNode(), RetTy, isSigned, !isSigned, false,
-+  CallLoweringInfo CLI(InChain, RetTy, isSigned, !isSigned, false,
-                     false, 0, getLibcallCallingConv(LC),
-                     /*isTailCall=*/false,
-                     /*doesNotReturn=*/false, /*isReturnValueUsed=*/true,
-                     Callee, Args, DAG, dl);
-   std::pair<SDValue,SDValue> CallInfo = LowerCallTo(CLI);
- 
--  return CallInfo.first;
-+  SDValue ret = CallInfo.first;
-+  if (isa<VectorType>(RetTy))
-+      ret = DAG.getNode(ISD::BITCAST, dl, RetVT, ret);
-+  return ret;
- }
- 
- 
diff --git a/deps/pcre.mk b/deps/pcre.mk
index 1fc32088f778e8..c5e86f338ef300 100644
--- a/deps/pcre.mk
+++ b/deps/pcre.mk
@@ -4,16 +4,21 @@
 PCRE_CFLAGS := -O3
 PCRE_LDFLAGS := $(RPATH_ESCAPED_ORIGIN)
 
-$(SRCDIR)/srccache/pcre2-$(PCRE_VER).tar.bz2: | $(SRCDIR)/srccache
+$(SRCCACHE)/pcre2-$(PCRE_VER).tar.bz2: | $(SRCCACHE)
 	$(JLDOWNLOAD) $@ https://ftp.csx.cam.ac.uk/pub/software/programming/pcre/pcre2-$(PCRE_VER).tar.bz2
 
-$(SRCDIR)/srccache/pcre2-$(PCRE_VER)/source-extracted: $(SRCDIR)/srccache/pcre2-$(PCRE_VER).tar.bz2
+$(SRCCACHE)/pcre2-$(PCRE_VER)/source-extracted: $(SRCCACHE)/pcre2-$(PCRE_VER).tar.bz2
 	$(JLCHECKSUM) $<
 	cd $(dir $<) && $(TAR) jxf $(notdir $<)
-	touch -c $(SRCDIR)/srccache/pcre2-$(PCRE_VER)/configure # old target
+	touch -c $(SRCCACHE)/pcre2-$(PCRE_VER)/configure # old target
 	echo $1 > $@
 
-$(BUILDDIR)/pcre2-$(PCRE_VER)/build-configured: $(SRCDIR)/srccache/pcre2-$(PCRE_VER)/source-extracted
+# patch for mingw build https://bugs.exim.org/show_bug.cgi?id=2067
+$(SRCCACHE)/pcre2-$(PCRE_VER)/pcre-mingw.patch-applied: $(SRCCACHE)/pcre2-$(PCRE_VER)/source-extracted
+	cd $(dir $@) && patch -p1 < $(SRCDIR)/patches/pcre-mingw.patch
+	echo 1 > $@
+
+$(BUILDDIR)/pcre2-$(PCRE_VER)/build-configured: $(SRCCACHE)/pcre2-$(PCRE_VER)/source-extracted $(SRCCACHE)/pcre2-$(PCRE_VER)/pcre-mingw.patch-applied
 	mkdir -p $(dir $@)
 	cd $(dir $@) && \
 	$(dir $<)/configure $(CONFIGURE_COMMON) --enable-jit --includedir=$(build_includedir) CFLAGS="$(CFLAGS) $(PCRE_CFLAGS)" LDFLAGS="$(LDFLAGS) $(PCRE_LDFLAGS)"
@@ -41,11 +46,11 @@ clean-pcre:
 	-$(MAKE) -C $(BUILDDIR)/pcre2-$(PCRE_VER) clean
 
 distclean-pcre:
-	-rm -rf $(SRCDIR)/srccache/pcre2-$(PCRE_VER).tar.bz2 $(SRCDIR)/srccache/pcre2-$(PCRE_VER) $(BUILDDIR)/pcre2-$(PCRE_VER)
+	-rm -rf $(SRCCACHE)/pcre2-$(PCRE_VER).tar.bz2 $(SRCCACHE)/pcre2-$(PCRE_VER) $(BUILDDIR)/pcre2-$(PCRE_VER)
 
 
-get-pcre: $(SRCDIR)/srccache/pcre2-$(PCRE_VER).tar.bz2
-extract-pcre: $(SRCDIR)/srccache/pcre2-$(PCRE_VER)/source-extracted
+get-pcre: $(SRCCACHE)/pcre2-$(PCRE_VER).tar.bz2
+extract-pcre: $(SRCCACHE)/pcre2-$(PCRE_VER)/source-extracted
 configure-pcre: $(BUILDDIR)/pcre2-$(PCRE_VER)/build-configured
 compile-pcre: $(BUILDDIR)/pcre2-$(PCRE_VER)/build-compiled
 fastcheck-pcre: check-pcre
diff --git a/deps/suitesparse.mk b/deps/suitesparse.mk
index 90b237628175ef..fb54f42af8e01b 100644
--- a/deps/suitesparse.mk
+++ b/deps/suitesparse.mk
@@ -24,10 +24,10 @@ SUITESPARSE_MFLAGS := CC="$(CC)" CXX="$(CXX)" F77="$(FC)" AR="$(AR)" RANLIB="$(R
 	  INSTALL_LIB="$(build_libdir)" INSTALL_INCLUDE="$(build_includedir)" LIB="$(SUITE_SPARSE_LIB)" \
 	  UMFPACK_CONFIG="$(UMFPACK_CONFIG)" CHOLMOD_CONFIG="$(CHOLMOD_CONFIG)" SPQR_CONFIG="$(SPQR_CONFIG)"
 
-$(SRCDIR)/srccache/SuiteSparse-$(SUITESPARSE_VER).tar.gz: | $(SRCDIR)/srccache
+$(SRCCACHE)/SuiteSparse-$(SUITESPARSE_VER).tar.gz: | $(SRCCACHE)
 	$(JLDOWNLOAD) $@ http://faculty.cse.tamu.edu/davis/SuiteSparse/$(notdir $@)
 
-$(BUILDDIR)/SuiteSparse-$(SUITESPARSE_VER)/source-extracted: $(SRCDIR)/srccache/SuiteSparse-$(SUITESPARSE_VER).tar.gz
+$(BUILDDIR)/SuiteSparse-$(SUITESPARSE_VER)/source-extracted: $(SRCCACHE)/SuiteSparse-$(SUITESPARSE_VER).tar.gz
 	$(JLCHECKSUM) $<
 	mkdir -p $(dir $@)
 	$(TAR) -C $(dir $@) --strip-components 1 -zxf $<
@@ -87,10 +87,10 @@ clean-suitesparse: clean-suitesparse-wrapper
 	-$(MAKE) -C $(BUILDDIR)/SuiteSparse-$(SUITESPARSE_VER) clean
 
 distclean-suitesparse: clean-suitesparse-wrapper
-	-rm -rf $(SRCDIR)/srccache/SuiteSparse-$(SUITESPARSE_VER).tar.gz \
+	-rm -rf $(SRCCACHE)/SuiteSparse-$(SUITESPARSE_VER).tar.gz \
 		$(BUILDDIR)/SuiteSparse-$(SUITESPARSE_VER)
 
-get-suitesparse: $(SRCDIR)/srccache/SuiteSparse-$(SUITESPARSE_VER).tar.gz
+get-suitesparse: $(SRCCACHE)/SuiteSparse-$(SUITESPARSE_VER).tar.gz
 extract-suitesparse: $(BUILDDIR)/SuiteSparse-$(SUITESPARSE_VER)/source-extracted
 configure-suitesparse: extract-suitesparse
 compile-suitesparse: $(BUILDDIR)/SuiteSparse-$(SUITESPARSE_VER)/build-compiled
diff --git a/deps/tools/common.mk b/deps/tools/common.mk
index cf92a637451fad..ec41a7c7dff0c0 100644
--- a/deps/tools/common.mk
+++ b/deps/tools/common.mk
@@ -1,5 +1,9 @@
 ## Some shared configuration options ##
 
+# NOTE: Do not make RPATH changes in CMAKE_COMMON on platforms other than FreeBSD, since
+# it will make its way into the LLVM build flags, and LLVM is picky about RPATH (though
+# apparently not on FreeBSD). Ref PR #22352
+
 CONFIGURE_COMMON := --prefix=$(abspath $(build_prefix)) --build=$(BUILD_MACHINE) --libdir=$(abspath $(build_libdir)) --bindir=$(abspath $(build_depsbindir)) $(CUSTOM_LD_LIBRARY_PATH)
 ifneq ($(XC_HOST),)
 CONFIGURE_COMMON += --host=$(XC_HOST)
@@ -8,11 +12,13 @@ ifeq ($(OS),WINNT)
 ifneq ($(USEMSVC), 1)
 CONFIGURE_COMMON += LDFLAGS="$(LDFLAGS) -Wl,--stack,8388608"
 endif
+else
+CONFIGURE_COMMON += LDFLAGS="$(LDFLAGS)"
 endif
-CONFIGURE_COMMON += F77="$(FC)" CC="$(CC) $(DEPS_CFLAGS)" CXX="$(CXX) $(DEPS_CXXFLAGS)"
+CONFIGURE_COMMON += F77="$(FC)" CC="$(CC)" CXX="$(CXX)" LD="$(LD)"
 
-CMAKE_CC_ARG := $(CC_ARG) $(DEPS_CFLAGS)
-CMAKE_CXX_ARG := $(CXX_ARG) $(DEPS_CXXFLAGS)
+CMAKE_CC_ARG := $(CC_ARG)
+CMAKE_CXX_ARG := $(CXX_ARG)
 
 CMAKE_COMMON := -DCMAKE_INSTALL_PREFIX:PATH=$(build_prefix) -DCMAKE_PREFIX_PATH=$(build_prefix)
 CMAKE_COMMON += -DCMAKE_INSTALL_LIBDIR=$(build_libdir) -DCMAKE_INSTALL_BINDIR=$(build_bindir)
@@ -29,6 +35,7 @@ CMAKE_COMMON += -DCMAKE_CXX_COMPILER="$(CXX_BASE)"
 ifneq ($(strip $(CMAKE_CXX_ARG)),)
 CMAKE_COMMON += -DCMAKE_CXX_COMPILER_ARG1="$(CMAKE_CXX_ARG)"
 endif
+CMAKE_COMMON += -DCMAKE_LINKER="$(LD)"
 
 ifeq ($(OS),WINNT)
 CMAKE_COMMON += -DCMAKE_SYSTEM_NAME=Windows
@@ -38,7 +45,6 @@ endif
 endif
 
 # For now this is LLVM specific, but I expect it won't be in the future
-ifeq ($(LLVM_USE_CMAKE),1)
 ifeq ($(CMAKE_GENERATOR),Ninja)
 CMAKE_GENERATOR_COMMAND := -G Ninja
 else ifeq ($(CMAKE_GENERATOR),make)
@@ -46,7 +52,6 @@ CMAKE_GENERATOR_COMMAND := -G "Unix Makefiles"
 else
 $(error Unknown CMake generator '$(CMAKE_GENERATOR)'. Options are 'Ninja' and 'make')
 endif
-endif
 
 # If the top-level Makefile is called with environment variables,
 # they will override the values passed above to ./configure
@@ -96,7 +101,7 @@ DIRS := $(sort $(build_bindir) $(build_depsbindir) $(build_libdir) $(build_inclu
 $(foreach dir,$(DIRS),$(eval $(call dir_target,$(dir))))
 
 $(build_prefix): | $(DIRS)
-$(eval $(call dir_target,$(SRCDIR)/srccache))
+$(eval $(call dir_target,$(SRCCACHE)))
 
 
 upper = $(shell echo $1 | tr a-z A-Z)
diff --git a/deps/tools/git-external.mk b/deps/tools/git-external.mk
index 717864e48a3084..152a895a5f39d9 100644
--- a/deps/tools/git-external.mk
+++ b/deps/tools/git-external.mk
@@ -5,7 +5,7 @@
 # VARNAME is the uppercased variable name prefix
 # file_from_download (deprecated)
 # file_from_compile (deprecated)
-# SRCDIR is either $(SRCDIR)/srccache or $(BUILDDIR), depending on whether the target supports out-of-tree builds
+# SRCDIR is either $(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
 #
@@ -14,7 +14,7 @@
 # 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, relative to $(SRCDIR)/srccache or $(BUILDDIR)
+#   VARNAME_SRC_DIR = source directory for the output, relative to $(SRCCACHE) or $(BUILDDIR)
 #   VARNAME_SRC_FILE = target file for make get-VARNAME target
 #   dirname:
 #   dirname/source-extracted:
@@ -25,8 +25,8 @@ include $(SRCDIR)/$1.version
 
 ifeq ($(DEPS_GIT),1)
 $2_SRC_DIR := $1
-$2_SRC_FILE := $$(SRCDIR)/srccache/$1.git
-$$($2_SRC_FILE)/HEAD: | $$(SRCDIR)/srccache
+$2_SRC_FILE := $$(SRCCACHE)/$1.git
+$$($2_SRC_FILE)/HEAD: | $$(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)
@@ -44,8 +44,8 @@ $5/$1/source-extracted: | $$(BUILDDIR)/$1
 endif
 $5/$1/source-extracted: $$(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 $$(SRCCACHE)/$1.git && git fetch -q $$($2_GIT_URL) $$($2_BRANCH):remotes/origin/$$($2_BRANCH)
+	cd $5/$1 && git fetch -q $$(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)
 	echo 1 > $$@
@@ -56,8 +56,8 @@ $$($2_SRC_FILE): | $$($2_SRC_FILE)/HEAD
 else # DEPS_GIT
 
 $2_SRC_DIR := $1-$$($2_SHA1)
-$2_SRC_FILE := $$(SRCDIR)/srccache/$$($2_SRC_DIR).tar.gz
-$$($2_SRC_FILE): | $$(SRCDIR)/srccache
+$2_SRC_FILE := $$(SRCCACHE)/$$($2_SRC_DIR).tar.gz
+$$($2_SRC_FILE): | $$(SRCCACHE)
 	$$(JLDOWNLOAD) $$@ $$(call $2_TAR_URL,$$($2_SHA1))
 $5/$$($2_SRC_DIR)/source-extracted: $$($2_SRC_FILE)
 	$$(JLCHECKSUM) $$<
diff --git a/deps/unwind.mk b/deps/unwind.mk
index 845086d95a6e7a..98d6f2a9f503c6 100644
--- a/deps/unwind.mk
+++ b/deps/unwind.mk
@@ -3,36 +3,36 @@
 LIBUNWIND_CFLAGS := -U_FORTIFY_SOURCE $(fPIC)
 LIBUNWIND_CPPFLAGS :=
 
-$(SRCDIR)/srccache/libunwind-$(UNWIND_VER).tar.gz: | $(SRCDIR)/srccache
+$(SRCCACHE)/libunwind-$(UNWIND_VER).tar.gz: | $(SRCCACHE)
 	$(JLDOWNLOAD) $@ https://s3.amazonaws.com/julialang/src/libunwind-$(UNWIND_VER).tar.gz
 
-$(SRCDIR)/srccache/libunwind-$(UNWIND_VER)/source-extracted: $(SRCDIR)/srccache/libunwind-$(UNWIND_VER).tar.gz
+$(SRCCACHE)/libunwind-$(UNWIND_VER)/source-extracted: $(SRCCACHE)/libunwind-$(UNWIND_VER).tar.gz
 	$(JLCHECKSUM) $<
 	cd $(dir $<) && $(TAR) xfz $<
-	touch -c $(SRCDIR)/srccache/libunwind-$(UNWIND_VER)/configure # old target
+	touch -c $(SRCCACHE)/libunwind-$(UNWIND_VER)/configure # old target
 	echo 1 > $@
 
-$(SRCDIR)/srccache/libunwind-$(UNWIND_VER)/libunwind-arm-dyn.patch-applied: $(SRCDIR)/srccache/libunwind-$(UNWIND_VER)/source-extracted
-	cd $(SRCDIR)/srccache/libunwind-$(UNWIND_VER) && patch -p1 -f < $(SRCDIR)/patches/libunwind-arm-dyn.patch
+$(SRCCACHE)/libunwind-$(UNWIND_VER)/libunwind-arm-dyn.patch-applied: $(SRCCACHE)/libunwind-$(UNWIND_VER)/source-extracted
+	cd $(SRCCACHE)/libunwind-$(UNWIND_VER) && patch -p1 -f < $(SRCDIR)/patches/libunwind-arm-dyn.patch
 	echo 1 > $@
 
-$(SRCDIR)/srccache/libunwind-$(UNWIND_VER)/libunwind-dwarf-ver.patch-applied: $(SRCDIR)/srccache/libunwind-$(UNWIND_VER)/libunwind-arm-dyn.patch-applied
-	cd $(SRCDIR)/srccache/libunwind-$(UNWIND_VER) && patch -p1 -f < $(SRCDIR)/patches/libunwind-dwarf-ver.patch
+$(SRCCACHE)/libunwind-$(UNWIND_VER)/libunwind-dwarf-ver.patch-applied: $(SRCCACHE)/libunwind-$(UNWIND_VER)/libunwind-arm-dyn.patch-applied
+	cd $(SRCCACHE)/libunwind-$(UNWIND_VER) && patch -p1 -f < $(SRCDIR)/patches/libunwind-dwarf-ver.patch
 	echo 1 > $@
 
-$(SRCDIR)/srccache/libunwind-$(UNWIND_VER)/libunwind-prefer-extbl.patch-applied: $(SRCDIR)/srccache/libunwind-$(UNWIND_VER)/libunwind-dwarf-ver.patch-applied
-	cd $(SRCDIR)/srccache/libunwind-$(UNWIND_VER) && patch -p1 -f < $(SRCDIR)/patches/libunwind-prefer-extbl.patch
+$(SRCCACHE)/libunwind-$(UNWIND_VER)/libunwind-prefer-extbl.patch-applied: $(SRCCACHE)/libunwind-$(UNWIND_VER)/libunwind-dwarf-ver.patch-applied
+	cd $(SRCCACHE)/libunwind-$(UNWIND_VER) && patch -p1 -f < $(SRCDIR)/patches/libunwind-prefer-extbl.patch
 	echo 1 > $@
 
-$(SRCDIR)/srccache/libunwind-$(UNWIND_VER)/libunwind-arm-pc-offset.patch-applied: $(SRCDIR)/srccache/libunwind-$(UNWIND_VER)/libunwind-prefer-extbl.patch-applied
-	cd $(SRCDIR)/srccache/libunwind-$(UNWIND_VER) && patch -p1 -f < $(SRCDIR)/patches/libunwind-arm-pc-offset.patch
+$(SRCCACHE)/libunwind-$(UNWIND_VER)/libunwind-arm-pc-offset.patch-applied: $(SRCCACHE)/libunwind-$(UNWIND_VER)/libunwind-prefer-extbl.patch-applied
+	cd $(SRCCACHE)/libunwind-$(UNWIND_VER) && patch -p1 -f < $(SRCDIR)/patches/libunwind-arm-pc-offset.patch
 	echo 1 > $@
 
-$(SRCDIR)/srccache/libunwind-$(UNWIND_VER)/libunwind-freebsd-mapper.patch-applied: $(SRCDIR)/srccache/libunwind-$(UNWIND_VER)/libunwind-arm-pc-offset.patch-applied
-	cd $(SRCDIR)/srccache/libunwind-$(UNWIND_VER) && patch -p0 -f < $(SRCDIR)/patches/libunwind-freebsd-mapper.patch
+$(SRCCACHE)/libunwind-$(UNWIND_VER)/libunwind-freebsd-mapper.patch-applied: $(SRCCACHE)/libunwind-$(UNWIND_VER)/libunwind-arm-pc-offset.patch-applied
+	cd $(SRCCACHE)/libunwind-$(UNWIND_VER) && patch -p0 -f < $(SRCDIR)/patches/libunwind-freebsd-mapper.patch
 	echo 1 > $@
 
-$(BUILDDIR)/libunwind-$(UNWIND_VER)/build-configured: $(SRCDIR)/srccache/libunwind-$(UNWIND_VER)/source-extracted $(SRCDIR)/srccache/libunwind-$(UNWIND_VER)/libunwind-freebsd-mapper.patch-applied
+$(BUILDDIR)/libunwind-$(UNWIND_VER)/build-configured: $(SRCCACHE)/libunwind-$(UNWIND_VER)/source-extracted $(SRCCACHE)/libunwind-$(UNWIND_VER)/libunwind-freebsd-mapper.patch-applied
 	mkdir -p $(dir $@)
 	cd $(dir $@) && \
 	$(dir $<)/configure $(CONFIGURE_COMMON) CPPFLAGS="$(CPPFLAGS) $(LIBUNWIND_CPPFLAGS)" CFLAGS="$(CFLAGS) $(LIBUNWIND_CFLAGS)" --disable-shared --disable-minidebuginfo
@@ -57,12 +57,12 @@ clean-unwind:
 	-$(MAKE) -C $(BUILDDIR)/libunwind-$(UNWIND_VER) clean
 
 distclean-unwind:
-	-rm -rf $(SRCDIR)/srccache/libunwind-$(UNWIND_VER).tar.gz \
-		$(SRCDIR)/srccache/libunwind-$(UNWIND_VER) \
+	-rm -rf $(SRCCACHE)/libunwind-$(UNWIND_VER).tar.gz \
+		$(SRCCACHE)/libunwind-$(UNWIND_VER) \
 		$(BUILDDIR)/libunwind-$(UNWIND_VER)
 
-get-unwind: $(SRCDIR)/srccache/libunwind-$(UNWIND_VER).tar.gz
-extract-unwind: $(SRCDIR)/srccache/libunwind-$(UNWIND_VER)/source-extracted
+get-unwind: $(SRCCACHE)/libunwind-$(UNWIND_VER).tar.gz
+extract-unwind: $(SRCCACHE)/libunwind-$(UNWIND_VER)/source-extracted
 configure-unwind: $(BUILDDIR)/libunwind-$(UNWIND_VER)/build-configured
 compile-unwind: $(BUILDDIR)/libunwind-$(UNWIND_VER)/build-compiled
 #todo: libunwind tests are known to fail, so they aren't run
@@ -74,10 +74,10 @@ check-unwind: $(BUILDDIR)/libunwind-$(UNWIND_VER)/build-checked
 
 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"
 
-$(SRCDIR)/srccache/libosxunwind-$(OSXUNWIND_VER).tar.gz: | $(SRCDIR)/srccache
+$(SRCCACHE)/libosxunwind-$(OSXUNWIND_VER).tar.gz: | $(SRCCACHE)
 	$(JLDOWNLOAD) $@ https://github.com/JuliaLang/libosxunwind/archive/v$(OSXUNWIND_VER).tar.gz
 
-$(BUILDDIR)/libosxunwind-$(OSXUNWIND_VER)/source-extracted: $(SRCDIR)/srccache/libosxunwind-$(OSXUNWIND_VER).tar.gz
+$(BUILDDIR)/libosxunwind-$(OSXUNWIND_VER)/source-extracted: $(SRCCACHE)/libosxunwind-$(OSXUNWIND_VER).tar.gz
 	$(JLCHECKSUM) $<
 	mkdir -p $(BUILDDIR)
 	cd $(BUILDDIR) && $(TAR) xfz $<
@@ -101,11 +101,11 @@ clean-osxunwind:
 	-$(MAKE) -C $(BUILDDIR)/libosxunwind-$(OSXUNWIND_VER) clean $(OSXUNWIND_FLAGS)
 
 distclean-osxunwind:
-	-rm -rf $(SRCDIR)/srccache/libosxunwind-$(OSXUNWIND_VER).tar.gz \
+	-rm -rf $(SRCCACHE)/libosxunwind-$(OSXUNWIND_VER).tar.gz \
 		$(BUILDDIR)/libosxunwind-$(OSXUNWIND_VER)
 
 
-get-osxunwind: $(SRCDIR)/srccache/libosxunwind-$(OSXUNWIND_VER).tar.gz
+get-osxunwind: $(SRCCACHE)/libosxunwind-$(OSXUNWIND_VER).tar.gz
 extract-osxunwind: $(BUILDDIR)/libosxunwind-$(OSXUNWIND_VER)/source-extracted
 configure-osxunwind: extract-osxunwind
 compile-osxunwind: $(BUILDDIR)/libosxunwind-$(OSXUNWIND_VER)/build-compiled
diff --git a/deps/utf8proc.mk b/deps/utf8proc.mk
index d9e15a4b8dd181..5ee4e20d6739f8 100644
--- a/deps/utf8proc.mk
+++ b/deps/utf8proc.mk
@@ -6,7 +6,7 @@ $(eval $(call git-external,utf8proc,UTF8PROC,,,$(BUILDDIR)))
 UTF8PROC_OBJ_LIB    := $(build_libdir)/libutf8proc.a
 UTF8PROC_OBJ_HEADER := $(build_includedir)/utf8proc.h
 UTF8PROC_CFLAGS     := -O2
-UTF8PROC_MFLAGS     := CC="$(CC) $(DEPS_CFLAGS)" CFLAGS="$(CFLAGS) $(UTF8PROC_CFLAGS)" PICFLAG="$(fPIC)" AR="$(AR)"
+UTF8PROC_MFLAGS     := CC="$(CC)" CFLAGS="$(CFLAGS) $(UTF8PROC_CFLAGS)" PICFLAG="$(fPIC)" AR="$(AR)"
 
 $(BUILDDIR)/$(UTF8PROC_SRC_DIR)/build-compiled: $(BUILDDIR)/$(UTF8PROC_SRC_DIR)/source-extracted
 	$(MAKE) -C $(dir $<) $(UTF8PROC_MFLAGS) libutf8proc.a
diff --git a/doc/Makefile b/doc/Makefile
index 39bac7ea31b596..743804d8b6968a 100644
--- a/doc/Makefile
+++ b/doc/Makefile
@@ -8,7 +8,7 @@ JULIAHOME        := $(abspath $(SRCDIR)/..)
 include $(JULIAHOME)/Make.inc
 JULIA_EXECUTABLE := $(call spawn,$(build_bindir)/julia)
 
-.PHONY: help clean cleanall html pdf linkcheck doctest check
+.PHONY: help clean cleanall html pdf linkcheck doctest check deps deploy
 
 help:
 	@echo "Please use 'make <target>' where <target> is one of"
@@ -32,32 +32,36 @@ cleanall: clean
 html: deps
 	@echo "Building HTML documentation."
 ifneq ($(OS),WINNT)
-	$(JULIA_EXECUTABLE) $(SRCDIR)/make.jl -- deploy
+	$(JULIA_EXECUTABLE) $(call cygpath_w,$(SRCDIR)/make.jl)
 else
 # work around issue #11727, windows output redirection breaking on buildbot
-	$(JULIA_EXECUTABLE) $(SRCDIR)/make.jl -- deploy > docbuild.log 2>&1
+	$(JULIA_EXECUTABLE) $(call cygpath_w,$(SRCDIR)/make.jl) > docbuild.log 2>&1
 	@cat docbuild.log
 endif
 	@echo "Build finished. The HTML pages are in _build/html."
 
 pdf: deps
 	@echo "Building PDF documentation."
-	$(JULIA_EXECUTABLE) $(SRCDIR)/make.jl -- pdf
+	$(JULIA_EXECUTABLE) $(call cygpath_w,$(SRCDIR)/make.jl) -- pdf
 	@echo "Build finished."
 
 linkcheck: deps
 	@echo "Checking external documentation links."
-	$(JULIA_EXECUTABLE) $(SRCDIR)/make.jl -- linkcheck
+	$(JULIA_EXECUTABLE) --color=yes $(call cygpath_w,$(SRCDIR)/make.jl) -- linkcheck
 	@echo "Checks finished."
 
 doctest: deps
 	@echo "Running all embedded 'doctests'."
-	$(JULIA_EXECUTABLE) --color=yes $(SRCDIR)/make.jl -- doctest
+	$(JULIA_EXECUTABLE) --color=yes $(call cygpath_w,$(SRCDIR)/make.jl) -- doctest
 	@echo "Checks finished."
 
 check: deps
 	@echo "Running all embedded 'doctests' and checking external links."
-	$(JULIA_EXECUTABLE) --color=yes $(SRCDIR)/make.jl -- doctest linkcheck
+	$(JULIA_EXECUTABLE) --color=yes $(call cygpath_w,$(SRCDIR)/make.jl) -- doctest linkcheck
 	@echo "Checks finished."
 
-.PHONY: deps
+# The deploy target should only be called in Travis builds
+deploy: deps
+	@echo "Deploying HTML documentation."
+	$(JULIA_EXECUTABLE) $(call cygpath_w,$(SRCDIR)/make.jl) -- deploy
+	@echo "Build & deploy of docs finished."
diff --git a/doc/NEWS-update.jl b/doc/NEWS-update.jl
index ebfda62c4de3b5..1841dc06df7ca4 100644
--- a/doc/NEWS-update.jl
+++ b/doc/NEWS-update.jl
@@ -3,7 +3,7 @@
 
 NEWS = get(ARGS, 1, "NEWS.md")
 
-s = readstring(NEWS)
+s = read(NEWS, String)
 
 s = s[1:match(r"\[#[0-9]+\]:", s).offset-1];
 
diff --git a/doc/README.md b/doc/README.md
index 0d55ec84c9b053..19a732f8800ba1 100644
--- a/doc/README.md
+++ b/doc/README.md
@@ -1,6 +1,6 @@
 # Julia Documentation README
 
-Julia's documentation is written in Markdown. A reference of all supported syntax can be found in the [manual](http://docs.julialang.org/en/latest/manual/documentation/#markdown-syntax). All documentation can be found in the Markdown files in `doc/src/` and the docstrings in Julia source files in `base/`.
+Julia's documentation is written in Markdown. A reference of all supported syntax can be found in the [manual](https://docs.julialang.org/en/latest/manual/documentation/#markdown-syntax). All documentation can be found in the Markdown files in `doc/src/` and the docstrings in Julia source files in `base/`.
 
 ## Requirements
 
diff --git a/doc/REQUIRE b/doc/REQUIRE
index 53e5f8775c2384..bf1f123f9e2da8 100644
--- a/doc/REQUIRE
+++ b/doc/REQUIRE
@@ -1,3 +1,3 @@
-Compat 0.9.5 0.9.5+
-DocStringExtensions 0.3.1 0.3.1+
-Documenter 0.9.0 0.9.0+
+Compat 0.25.2 0.25.2+
+DocStringExtensions 0.3.3 0.3.3+
+Documenter 0.11.1 0.11.1+
diff --git a/doc/make.jl b/doc/make.jl
index 1ea3d50f9f5b0c..ad966f96d51cb3 100644
--- a/doc/make.jl
+++ b/doc/make.jl
@@ -46,7 +46,7 @@ const PAGES = [
         "manual/running-external-programs.md",
         "manual/calling-c-and-fortran-code.md",
         "manual/handling-operating-system-variation.md",
-        "manual/interacting-with-julia.md",
+        "manual/environment-variables.md",
         "manual/embedding.md",
         "manual/packages.md",
         "manual/profile.md",
@@ -87,12 +87,13 @@ const PAGES = [
         "devdocs/reflection.md",
         "Documentation of Julia's Internals" => [
             "devdocs/init.md",
-            "devdocs/eval.md",
             "devdocs/ast.md",
             "devdocs/types.md",
             "devdocs/object.md",
-            "devdocs/functions.md",
+            "devdocs/eval.md",
             "devdocs/callconv.md",
+            "devdocs/compiler.md",
+            "devdocs/functions.md",
             "devdocs/cartesian.md",
             "devdocs/meta.md",
             "devdocs/subarrays.md",
@@ -102,6 +103,9 @@ const PAGES = [
             "devdocs/boundscheck.md",
             "devdocs/locks.md",
             "devdocs/offset-arrays.md",
+            "devdocs/libgit2.md",
+            "devdocs/require.md",
+            "devdocs/inference.md",
         ],
         "Developing/debugging Julia's C code" => [
             "devdocs/backtraces.md",
@@ -118,6 +122,7 @@ makedocs(
     clean     = false,
     doctest   = "doctest" in ARGS,
     linkcheck = "linkcheck" in ARGS,
+    linkcheck_ignore = ["https://bugs.kde.org/show_bug.cgi?id=136779"], # fails to load from nanosoldier?
     strict    = true,
     checkdocs = :none,
     format    = "pdf" in ARGS ? :latex : :html,
@@ -125,6 +130,7 @@ makedocs(
     authors   = "The Julia Project",
     analytics = "UA-28835595-6",
     pages     = PAGES,
+    html_prettyurls = ("deploy" in ARGS),
 )
 
 if "deploy" in ARGS
diff --git a/doc/man/julia.1 b/doc/man/julia.1
index ab01e94afe746b..cc77d36e079697 100644
--- a/doc/man/julia.1
+++ b/doc/man/julia.1
@@ -23,14 +23,14 @@
 
 .TH JULIA 1 2013-12-10 Julia "Julia Programmers' Reference Guide"
 
-.\" from the front page of http://julialang.org/
+.\" from the front page of https://julialang.org/
 .SH NAME
 julia - high-level, high-performance dynamic programming language for technical computing
 
 .SH SYNOPSIS
 julia [option] [program] [args..]
 
-.\" Taken almost verbatim from the front page of http://julialang.org/
+.\" Taken almost verbatim from the front page of https://julialang.org/
 .SH DESCRIPTION
 Julia is a high-level, high-performance dynamic programming language
 for technical computing, with syntax that is familiar to users
@@ -47,7 +47,7 @@ by defining functions and overloading them for different combinations
 of argument types, which can also be user-defined.
 For a more in-depth discussion of the rationale and advantages of Julia
 over other systems, please see the online manual:
-http://docs.julialang.org/en/latest/manual/
+https://docs.julialang.org/en/latest/manual/
 
 If a Julia source file is given as a \fIprogram\fP (optionally followed by
  arguments in \fIargs\fP) Julia will execute the program and exit.
diff --git a/doc/src/devdocs/ast.md b/doc/src/devdocs/ast.md
index bacb91e1bd0e3a..16724c3154954c 100644
--- a/doc/src/devdocs/ast.md
+++ b/doc/src/devdocs/ast.md
@@ -214,14 +214,14 @@ A unique'd container describing the shared metadata for a single method.
 
   * `source`
 
-    The original source code (compressed).
+    The original source code (usually compressed).
 
   * `roots`
 
     Pointers to non-AST things that have been interpolated into the AST, required by
     compression of the AST, type-inference, or the generation of native code.
 
-  * `nargs`, `isva`, `called`, `isstaged`
+  * `nargs`, `isva`, `called`, `isstaged`, `pure`
 
     Descriptive bit-fields for the source code of this Method.
 
@@ -242,8 +242,8 @@ for important details on how to modify these fields safely.
 
   * `def`
 
-    The `Method` that this function describes a specialization of. Or `#undef`, if this is
-    a top-level Lambda that is not part of a Method.
+    The `Method` that this function describes a specialization of. Or a `Module`,
+    if this is a top-level Lambda expanded in Module, and which is not part of a Method.
 
   * `sparam_vals`
 
@@ -288,7 +288,7 @@ A temporary container for holding lowered source code.
 
   * `code`
 
-    An `Any` array of statements, or a `UInt8` array with a compressed representation of the code.
+    An `Any` array of statements
 
   * `slotnames`
 
@@ -407,21 +407,21 @@ call. Finally, chains of comparisons have their own special expression structure
 
 ### Macros
 
-| Input         | AST                                   |
-|:------------- |:------------------------------------- |
-| `@m x y`      | `(macrocall @m x y)`                  |
-| `Base.@m x y` | `(macrocall (. Base (quote @m)) x y)` |
-| `@Base.m x y` | `(macrocall (. Base (quote @m)) x y)` |
+| Input         | AST                                          |
+|:------------- |:-------------------------------------------- |
+| `@m x y`      | `(macrocall @m (line) x y)`                  |
+| `Base.@m x y` | `(macrocall (. Base (quote @m)) (line) x y)` |
+| `@Base.m x y` | `(macrocall (. Base (quote @m)) (line) x y)` |
 
 ### Strings
 
-| Input           | AST                          |
-|:--------------- |:---------------------------- |
-| `"a"`           | `"a"`                        |
-| `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")`   |
+| Input           | AST                                 |
+|:--------------- |:----------------------------------- |
+| `"a"`           | `"a"`                               |
+| `x"y"`          | `(macrocall @x_str (line) "y")`     |
+| `x"y"z`         | `(macrocall @x_str (line) "y" "z")` |
+| `"x = $x"`      | `(string "x = " x)`                 |
+| ``` `a b c` ``` | `(macrocall @cmd (line) "a b c")`   |
 
 Doc string syntax:
 
@@ -430,7 +430,7 @@ Doc string syntax:
 f(x) = x
 ```
 
-parses as `(macrocall (|.| Core '@doc) "some docs" (= (call f x) (block x)))`.
+parses as `(macrocall (|.| Core '@doc) (line) "some docs" (= (call f x) (block x)))`.
 
 ### Imports and such
 
@@ -449,11 +449,11 @@ parses as `(macrocall (|.| Core '@doc) "some docs" (= (call f x) (block x)))`.
 Julia supports more number types than many scheme implementations, so not all numbers are represented
 directly as scheme numbers in the AST.
 
-| Input                   | AST                                              |
-|:----------------------- |:------------------------------------------------ |
-| `11111111111111111111`  | `(macrocall @int128_str "11111111111111111111")` |
-| `0xfffffffffffffffff`   | `(macrocall @uint128_str "0xfffffffffffffffff")` |
-| `1111...many digits...` | `(macrocall @big_str "1111....")`                |
+| Input                   | AST                                                     |
+|:----------------------- |:------------------------------------------------------- |
+| `11111111111111111111`  | `(macrocall @int128_str (null) "11111111111111111111")` |
+| `0xfffffffffffffffff`   | `(macrocall @uint128_str (null) "0xfffffffffffffffff")` |
+| `1111...many digits...` | `(macrocall @big_str (null) "1111....")`                |
 
 ### Block forms
 
@@ -476,7 +476,8 @@ parses as:
 ```
 (if a (block (line 2) b)
     (block (line 3) (if c (block (line 4) d)
-                        (block (line 5) e (line 6) f))))
+                             (block (line 5) e
+                                    (line 6) f))))
 ```
 
 A `while` loop parses as `(while condition body)`.
@@ -491,7 +492,7 @@ they are parsed as a block: `(for (block (= v1 iter1) (= v2 iter2)) body)`.
 A basic function definition is parsed as `(function (call f x) body)`. A more complex example:
 
 ```julia
-function f{T}(x::T; k = 1)
+function f(x::T; k = 1) where T
     return x+1
 end
 ```
@@ -499,15 +500,16 @@ end
 parses as:
 
 ```
-(function (call (curly f T) (parameters (kw k 1))
-                (:: x T))
-          (block (line 2 file.jl) (return (call + x 1))))
+(function (where (call f (parameters (kw k 1))
+                       (:: x T))
+                 T)
+          (block (line 2) (return (call + x 1))))
 ```
 
 Type definition:
 
 ```julia
-type Foo{T<:S}
+mutable struct Foo{T<:S}
     x::T
 end
 ```
@@ -515,8 +517,8 @@ end
 parses as:
 
 ```
-(type #t (curly Foo (<: T S))
-      (block (line 2 none) (:: x T)))
+(type true (curly Foo (<: T S))
+      (block (line 2) (:: x T)))
 ```
 
 The first argument is a boolean telling whether the type is mutable.
diff --git a/doc/src/devdocs/backtraces.md b/doc/src/devdocs/backtraces.md
index 5917e26ba7ac56..d6f053f15fe35c 100644
--- a/doc/src/devdocs/backtraces.md
+++ b/doc/src/devdocs/backtraces.md
@@ -8,31 +8,21 @@ to figure out why your script is running slower than expected.
 If you've been directed to this page, find the symptom that best matches what you're experiencing
 and follow the instructions to generate the debugging information requested.  Table of symptoms:
 
-  * [Segfaults during bootstrap (sysimg.jl)](@ref)
+  * [Segfaults during bootstrap (`sysimg.jl`)](@ref)
   * [Segfaults when running a script](@ref)
   * [Errors during Julia startup](@ref)
 
 ## [Version/Environment info](@id dev-version-info)
 
 No matter the error, we will always need to know what version of Julia you are running. When Julia
-first starts up, a header is printed out with a version number and date.  If your version is
-`0.2.0` or higher, please include the output of `versioninfo()` in any report you create:
+first starts up, a header is printed out with a version number and date. Please also include the
+output of `versioninfo()` in any report you create:
 
-```julia
-julia> versioninfo()
-Julia Version 0.3.3-pre+25
-Commit 417b50a* (2014-11-03 11:32 UTC)
-Platform Info:
-  OS: Linux (x86_64-linux-gnu)
-  CPU: Intel(R) Core(TM) i7 CPU       L 640  @ 2.13GHz
-  WORD_SIZE: 64
-  BLAS: libopenblas (USE64BITINT DYNAMIC_ARCH NO_AFFINITY Nehalem)
-  LAPACK: libopenblas
-  LIBM: libopenlibm
-  LLVM: libLLVM-3.3
+```@repl
+versioninfo()
 ```
 
-## Segfaults during bootstrap (sysimg.jl)
+## Segfaults during bootstrap (`sysimg.jl`)
 
 Segfaults toward the end of the `make` process of building Julia are a common symptom of something
 going wrong while Julia is preparsing the corpus of code in the `base/` folder.  Many factors
@@ -64,7 +54,7 @@ on Github with a link to the gist.
 
 ## Segfaults when running a script
 
-The procedure is very similar to [Segfaults during bootstrap (sysimg.jl)](@ref).  Create a debug
+The procedure is very similar to [Segfaults during bootstrap (`sysimg.jl`)](@ref).  Create a debug
 build of Julia, and run your script inside of a debugged Julia process:
 
 ```
diff --git a/doc/src/devdocs/cartesian.md b/doc/src/devdocs/cartesian.md
index c63df3f188283c..4e548c578909d1 100644
--- a/doc/src/devdocs/cartesian.md
+++ b/doc/src/devdocs/cartesian.md
@@ -51,11 +51,21 @@ practice is to read from left to right, which is why `@nloops` is `@nloops 3 i A
 is `@nref 3 A i` (as in `A[i_1,i_2,i_3]`, where the array comes first).
 
 If you're developing code with Cartesian, you may find that debugging is easier when you examine
-the generated code, using `macroexpand`:
+the generated code, using `@macroexpand`:
 
-```julia
-julia> macroexpand(:(@nref 2 A i))
-:(A[i_1,i_2])
+```@meta
+DocTestSetup = quote
+    import Base.Cartesian: @nref
+end
+```
+
+```jldoctest
+julia> @macroexpand @nref 2 A i
+:(A[i_1, i_2])
+```
+
+```@meta
+DocTestSetup = nothing
 ```
 
 ### Supplying the number of expressions
@@ -63,13 +73,13 @@ julia> macroexpand(:(@nref 2 A i))
 The first argument to both of these macros is the number of expressions, which must be an integer.
 When you're writing a function that you intend to work in multiple dimensions, this may not be
 something you want to hard-code. If you're writing code that you need to work with older Julia
-versions, currently you should use the `@ngenerate` macro described in [an older version of this documentation](http://docs.julialang.org/en/release-0.3/devdocs/cartesian/#supplying-the-number-of-expressions).
+versions, currently you should use the `@ngenerate` macro described in [an older version of this documentation](https://docs.julialang.org/en/release-0.3/devdocs/cartesian/#supplying-the-number-of-expressions).
 
 Starting in Julia 0.4-pre, the recommended approach is to use a `@generated function`.  Here's
 an example:
 
 ```julia
-@generated function mysum{T,N}(A::Array{T,N})
+@generated function mysum(A::Array{T,N}) where {T,N}
     quote
         s = zero(T)
         @nloops $N i A begin
diff --git a/doc/src/devdocs/compiler.md b/doc/src/devdocs/compiler.md
new file mode 100644
index 00000000000000..0749eafd81bd37
--- /dev/null
+++ b/doc/src/devdocs/compiler.md
@@ -0,0 +1,115 @@
+# High-level Overview of the Native-Code Generation Process
+
+## Representation of Pointers
+
+When emitting code to an object file, pointers will be emitted as relocations.
+The deserialization code will ensure any object that pointed to one of these constants
+gets recreated and contains the right runtime pointer.
+
+Otherwise, they will be emitted as literal constants.
+
+To emit one of these objects, call `literal_pointer_val`.
+It'll handle tracking the Julia value and the LLVM global,
+ensuring they are valid both for the current runtime and after deserialization.
+
+When emitted into the object file, these globals are stored as references
+in a large `gvals` table. This allows the deserializer to reference them by index,
+and implement a custom manual mechanism similar to a Global Offset Table (GOT) to restore them.
+
+Function pointers are handled similarly.
+They are stored as values in a large `fvals` table.
+Like globals, this allows the deserializer to reference them by index.
+
+Note that `extern` functions are handled separately,
+with names, via the usual symbol resolution mechanism in the linker.
+
+Note too that `ccall` functions are also handled separately,
+via a manual GOT and Procedure Linkage Table (PLT).
+
+
+## Representation of Intermediate Values
+
+Values are passed around in a `jl_cgval_t` struct.
+This represents an R-value, and includes enough information to
+determine how to assign or pass it somewhere.
+
+They are created via one of the helper constructors, usually:
+`mark_julia_type` (for immediate values) and `mark_julia_slot` (for pointers to values).
+
+The function `convert_julia_type` can transform between any two types.
+It returns an R-value with `cgval.typ` set to `typ`.
+It'll cast the object to the requested representation,
+making heap boxes, allocating stack copies, and computing tagged unions as
+needed to change the representation.
+
+By contrast `update_julia_type` will change `cgval.typ` to `typ`,
+only if it can be done at zero-cost (i.e. without emitting any code).
+
+
+## Union representation
+
+Inferred union types may be stack allocated via a tagged type representation.
+
+The primitive routines that need to be able to handle tagged unions are:
+- mark-type
+- load-local
+- store-local
+- isa
+- is
+- emit_typeof
+- emit_sizeof
+- boxed
+- unbox
+- specialized cc-ret
+
+Everything else should be possible to handle in inference by using these
+primitives to implement union-splitting.
+
+The representation of the tagged-union is as a pair
+of `< void* union, byte selector >`.
+The selector is fixed-size as `byte & 0x7f`,
+and will union-tag the first 126 isbits.
+It records the one-based depth-first count into the type-union of the
+isbits objects inside. An index of zero indicates that the `union*` is
+actually a tagged heap-allocated `jl_value_t*`,
+and needs to be treated as normal for a boxed object rather than as a
+tagged union.
+
+The high bit of the selector (`byte & 0x80`) can be tested to determine if the
+`void*` is actually a heap-allocated (`jl_value_t*`) box,
+thus avoiding the cost of re-allocating a box,
+while maintaining the ability to efficiently handle union-splitting based on the low bits.
+
+It is guaranteed that `byte & 0x7f` is an exact test for the type,
+if the value can be represented by a tag – it will never be marked `byte = 0x80`.
+It is not necessary to also test the type-tag when testing `isa`.
+
+The `union*` memory region may be allocated at *any* size.
+The only constraint is that it is big enough to contain the data
+currently specified by `selector`.
+It might not be big enough to contain the union of all types that
+could be stored there according to the associated Union type field.
+Use appropriate care when copying.
+
+
+## Specialized Calling Convention Signature Representation
+
+A `jl_returninfo_t` object describes the calling convention details of any callable.
+
+If any of the arguments or return type of a method can be represented unboxed,
+and the method is not varargs, it'll be given an optimized calling convention
+signature based on its `specTypes` and `rettype` fields.
+
+The general principles are that:
+
+- Primitive types get passed in int/float registers.
+- Tuples of VecElement types get passed in vector registers.
+- Structs get passed on the stack.
+- Return values are handle similarly to arguments,
+  with a size-cutoff at which they will instead be returned via a hidden sret argument.
+
+The total logic for this is implemented by `get_specsig_function` and `deserves_sret`.
+
+Additionally, if the return type is a union, it may be returned as a pair of values (a pointer and a tag).
+If the union values can be stack-allocated, then sufficient space to store them will also be passed as a hidden first argument.
+It is up to the callee whether the returned pointer will point to this space, a boxed object, or even other constant memory.
diff --git a/doc/src/devdocs/debuggingtips.md b/doc/src/devdocs/debuggingtips.md
index ba87f03c2a642e..fcc7ea99e159b2 100644
--- a/doc/src/devdocs/debuggingtips.md
+++ b/doc/src/devdocs/debuggingtips.md
@@ -26,10 +26,10 @@ Julia's flisp interpreter uses `value_t` objects; these can be displayed with `c
 ## Useful Julia variables for Inspecting
 
 While the addresses of many variables, like singletons, can be be useful to print for many failures,
-there are a number of additional variables (see julia.h for a complete list) that are even more
+there are a number of additional variables (see `julia.h` for a complete list) that are even more
 useful.
 
-  * (when in `jl_apply_generic`) `f->linfo` and `jl_uncompress_ast(f->linfo, f->linfo->ast)` :: for
+  * (when in `jl_apply_generic`) `mfunc` and `jl_uncompress_ast(mfunc->def, mfunc->code)` :: for
     figuring out a bit about the call-stack
   * `jl_lineno` and `jl_filename` :: for figuring out what line in a test to go start debugging from
     (or figure out how far into a file has been parsed)
@@ -234,9 +234,9 @@ 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
+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
 deterministically.  The replayed execution's address spaces, register contents, syscall data etc
 are exactly the same in every run.
 
-A recent version of `rr` (3.1.0 or higher) is required.
+A recent version of rr (3.1.0 or higher) is required.
diff --git a/doc/src/devdocs/eval.md b/doc/src/devdocs/eval.md
index 4ea9e8cbd2abc1..17290a8645e2e4 100644
--- a/doc/src/devdocs/eval.md
+++ b/doc/src/devdocs/eval.md
@@ -3,10 +3,10 @@
 One of the hardest parts about learning how the Julia Language runs code is learning 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` before turning into the desired result (hopefully).
+Each chunk of code typically makes a trip through many steps with potentially unfamiliar names,
+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, and primitive function, before turning into the desired result (hopefully).
 
 !!! sidebar "Definitions"
       * REPL
@@ -25,19 +25,19 @@ The 10,000 foot view of the whole process is as follows:
 1. The user starts `julia`.
 2. The C function `main()` from `ui/repl.c` gets called. This function processes the command line
    arguments, filling in the `jl_options` struct and setting the variable `ARGS`. It then initializes
-   Julia (by calling [julia_init in task.c](https://github.com/JuliaLang/julia/blob/master/src/task.c),
+   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](@ref dev-sysimg)). Finally, it passes off control to Julia
-   by calling [Base._start()](https://github.com/JuliaLang/julia/blob/master/base/client.jl).
+   by calling [`Base._start()`](https://github.com/JuliaLang/julia/blob/master/base/client.jl).
 3. 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.
 4. 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.
-5. 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)
+5. 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](@ref dev-parsing) it. Each fragment of code is then passed to `eval`
    to execute.
 6. Each fragment of code (or AST), is handed off to [`eval()`](@ref) to turn into results.
-7. [`eval()`](@ref) takes each code fragment and tries to run it in [jl_toplevel_eval_flex()](https://github.com/JuliaLang/julia/blob/master/src/toplevel.c).
+7. [`eval()`](@ref) takes each code fragment and tries to run it in [`jl_toplevel_eval_flex()`](https://github.com/JuliaLang/julia/blob/master/src/toplevel.c).
 8. `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.
@@ -45,16 +45,16 @@ The 10,000 foot view of the whole process is as follows:
    the AST to make it simpler to execute.
 10. `jl_toplevel_eval_flex()` then uses some simple heuristics to decide whether to JIT compiler the
     AST or to interpret it directly.
-11. 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).
+11. 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).
 12. 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](@ref dev-type-inference)
     will be run on that function. This information is used by the [codegen](@ref dev-codegen) step to generate
     faster code.
 13. Eventually, the user quits the REPL, or the end of the program is reached, and the `_start()`
     method returns.
-14. Just before exiting, `main()` calls [jl_atexit_hook(exit_code)](https://github.com/JuliaLang/julia/blob/master/src/init.c).
+14. Just before exiting, `main()` calls [`jl_atexit_hook(exit_code)`](https://github.com/JuliaLang/julia/blob/master/src/init.c).
     This calls `Base._atexit()` (which calls any functions registered to [`atexit()`](@ref) inside
-    Julia). Then it calls [jl_gc_run_all_finalizers()](https://github.com/JuliaLang/julia/blob/master/src/gc.c).
+    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.
 
 ## [Parsing](@id dev-parsing)
@@ -62,12 +62,12 @@ The 10,000 foot view of the whole process is as follows:
 The Julia parser is a small lisp program written in femtolisp, the source-code for which is distributed
 inside Julia in [src/flisp](https://github.com/JuliaLang/julia/tree/master/src/flisp).
 
-The interface functions for this are primarily defined in [jlfrontend.scm](https://github.com/JuliaLang/julia/blob/master/src/jlfrontend.scm).
-The code in [ast.c](https://github.com/JuliaLang/julia/blob/master/src/ast.c) handles this handoff
+The interface functions for this are primarily defined in [`jlfrontend.scm`](https://github.com/JuliaLang/julia/blob/master/src/jlfrontend.scm).
+The code in [`ast.c`](https://github.com/JuliaLang/julia/blob/master/src/ast.c) handles this handoff
 on the Julia side.
 
-The other relevant files at this stage are [julia-parser.scm](https://github.com/JuliaLang/julia/blob/master/src/julia-parser.scm),
-which handles tokenizing Julia code and turning it into an AST, and [julia-syntax.scm](https://github.com/JuliaLang/julia/blob/master/src/julia-syntax.scm),
+The other relevant files at this stage are [`julia-parser.scm`](https://github.com/JuliaLang/julia/blob/master/src/julia-parser.scm),
+which handles tokenizing Julia code and turning it into an AST, and [`julia-syntax.scm`](https://github.com/JuliaLang/julia/blob/master/src/julia-syntax.scm),
 which handles transforming complex AST representations into simpler, "lowered" AST representations
 which are more suitable for analysis and execution.
 
@@ -83,7 +83,7 @@ although it can also be invoked directly by a call to [`macroexpand()`](@ref)/`j
 
 ## [Type Inference](@id dev-type-inference)
 
-Type inference is implemented in Julia by [typeinf() in inference.jl](https://github.com/JuliaLang/julia/blob/master/base/inference.jl).
+Type inference is implemented in Julia by [`typeinf()` in `inference.jl`](https://github.com/JuliaLang/julia/blob/master/base/inference.jl).
 Type inference is the process of examining a Julia function and determining bounds for the types
 of each of its variables, as well as bounds on the type of the return value from the function.
 This enables many future optimizations, such as unboxing of known immutable values, and compile-time
@@ -103,7 +103,7 @@ Type inference may also include other steps such as constant propagation and inl
       * C++
 
         The programming language that LLVM is implemented in, which means that codegen is also implemented
-        in this language. The rest of Julia's library is implemented in C, in part because it's smaller
+        in this language. The rest of Julia's library is implemented in C, in part because its smaller
         feature set makes it more usable as a cross-language interface layer.
       * box
 
@@ -135,7 +135,7 @@ Type inference may also include other steps such as constant propagation and inl
 
 Codegen is the process of turning a Julia AST into native machine code.
 
-The JIT environment is initialized by an early call to [jl_init_codegen in codegen.cpp](https://github.com/JuliaLang/julia/blob/master/src/codegen.cpp).
+The JIT environment is initialized by an early call to [`jl_init_codegen` in `codegen.cpp`](https://github.com/JuliaLang/julia/blob/master/src/codegen.cpp).
 
 On demand, a Julia method is converted into a native function by the function `emit_function(jl_method_instance_t*)`.
 (note, when using the MCJIT (in LLVM v3.4+), each function must be JIT into a new module.) This
@@ -143,36 +143,36 @@ function recursively calls `emit_expr()` until the entire function has been emit
 
 Much of the remaining bulk of this file is devoted to various manual optimizations of specific
 code patterns. For example, `emit_known_call()` knows how to inline many of the primitive functions
-(defined in [builtins.c](https://github.com/JuliaLang/julia/blob/master/src/builtins.c)) for various
+(defined in [`builtins.c`](https://github.com/JuliaLang/julia/blob/master/src/builtins.c)) for various
 combinations of argument types.
 
 Other parts of codegen are handled by various helper files:
 
-  * [debuginfo.cpp](https://github.com/JuliaLang/julia/blob/master/src/debuginfo.cpp)
+  * [`debuginfo.cpp`](https://github.com/JuliaLang/julia/blob/master/src/debuginfo.cpp)
 
     Handles backtraces for JIT functions
-  * [ccall.cpp](https://github.com/JuliaLang/julia/blob/master/src/ccall.cpp)
+  * [`ccall.cpp`](https://github.com/JuliaLang/julia/blob/master/src/ccall.cpp)
 
     Handles the ccall and llvmcall FFI, along with various `abi_*.cpp` files
-  * [intrinsics.cpp](https://github.com/JuliaLang/julia/blob/master/src/intrinsics.cpp)
+  * [`intrinsics.cpp`](https://github.com/JuliaLang/julia/blob/master/src/intrinsics.cpp)
 
     Handles the emission of various low-level intrinsic functions
 
 !!! sidebar "Bootstrapping"
     The process of creating a new system image is called "bootstrapping".
 
-    The etymology of this word comes from the phrase "pulling one's self up by the bootstraps", and
+    The etymology of this word comes from the phrase "pulling oneself up by the bootstraps", 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.
 
 ## [System Image](@id dev-sysimg)
 
 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, generated by executing the file [sysimg.jl](https://github.com/JuliaLang/julia/blob/master/base/sysimg.jl),
+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 `Main`, `Core`, and
 `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).
+is implemented by [`jl_save_system_image`/`jl_restore_system_image` in `staticdata.c`](https://github.com/JuliaLang/julia/blob/master/src/staticdata.c).
 
 If there is no sysimg file (`jl_options.image_file == NULL`), this also implies that `--build`
 was given on the command line, so the final result should be a new sysimg file. During Julia initialization,
diff --git a/doc/src/devdocs/functions.md b/doc/src/devdocs/functions.md
index 8c98d0d418028d..f7535eabf9c7aa 100644
--- a/doc/src/devdocs/functions.md
+++ b/doc/src/devdocs/functions.md
@@ -33,14 +33,14 @@ 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:
 
-```
+```c
 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:
 
-```
+```c
 jl_value_t *jl_call(jl_function_t *f, jl_value_t **args, int32_t nargs);
 ```
 
@@ -80,7 +80,7 @@ end
 is lowered to (roughly):
 
 ```julia
-immutable ##1{T}
+struct ##1{T}
     x::T
 end
 
@@ -98,7 +98,7 @@ table for `DataType` contains most constructor definitions. One wrinkle is the f
 that makes all types callable via `convert`:
 
 ```julia
-(::Type{T}){T}(args...) = convert(T, args...)::T
+(::Type{T})(args...) where {T} = convert(T, args...)::T
 ```
 
 In this definition the function type is abstract, which is not normally supported. To make this
@@ -110,7 +110,7 @@ a method table via special arrangement.
 The "builtin" functions, defined in the `Core` module, are:
 
 ```
-is typeof sizeof issubtype isa typeassert throw tuple getfield setfield! fieldtype
+=== typeof sizeof <: isa typeassert throw tuple getfield setfield! fieldtype
 nfields isdefined arrayref arrayset arraysize applicable invoke apply_type _apply
 _expr svec
 ```
@@ -119,7 +119,7 @@ These are all singleton objects whose types are subtypes of `Builtin`, which is
 `Function`. Their purpose is to expose entry points in the run time that use the "jlcall" calling
 convention:
 
-```
+```c
 jl_value_t *(jl_value_t*, jl_value_t**, uint32_t)
 ```
 
@@ -152,7 +152,7 @@ actually produces *three* method definitions. The first is a function that accep
 (including keywords) as positional arguments, and includes the code for the method body. It has
 an auto-generated name:
 
-```
+```julia
 function #circle#1(color, fill::Bool, options, circle, center, radius)
     # draw
 end
@@ -223,8 +223,8 @@ Performance-critical higher-order functions like `map` certainly call their argu
 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.
+it behaves as if the `@nospecialize` annotation were applied. 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
@@ -251,54 +251,3 @@ The next problem was the `@test` macro, which generated a 0-argument closure for
 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 the QuadGK.jl package,
-formerly part of Base:
-
-```julia
-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/src/devdocs/inference.md b/doc/src/devdocs/inference.md
new file mode 100644
index 00000000000000..1cc4b29dab667d
--- /dev/null
+++ b/doc/src/devdocs/inference.md
@@ -0,0 +1,106 @@
+# Inference
+
+## How inference works
+
+[Type inference](https://en.wikipedia.org/wiki/Type_inference) refers
+to the process of deducing the types of later values from the types of
+input values. Julia's approach to inference has been described in blog
+posts
+([1](https://juliacomputing.com/blog/2016/04/04/inference-convergence.html),
+[2](https://juliacomputing.com/blog/2017/05/15/inference-converage2.html)).
+
+## Debugging inference.jl
+
+You can start a Julia session, edit `inference.jl` (for example to
+insert `print` statements), and then replace `Core.Inference` in your
+running session by navigating to `base/` and executing
+`include("coreimg.jl")`. This trick typically leads to much faster
+development than if you rebuild Julia for each change.
+
+A convenient entry point into inference is `typeinf_code`. Here's a
+demo running inference on `convert(Int, UInt(1))`:
+
+```julia
+# Get the method
+atypes = Tuple{Type{Int}, UInt}  # argument types
+mths = methods(convert, atypes)  # worth checking that there is only one
+m = first(mths)
+
+# Create variables needed to call `typeinf_code`
+params = Core.Inference.InferenceParams(typemax(UInt))  # parameter is the world age,
+                                                        #   typemax(UInt) -> most recent
+sparams = Core.svec()      # this particular method doesn't have type-parameters
+optimize = true            # run all inference optimizations
+cached = false             # force inference to happen (do not use cached results)
+Core.Inference.typeinf_code(m, atypes, sparams, optimize, cached, params)
+```
+
+If your debugging adventures require a `MethodInstance`, you can look it up by
+calling `Core.Inference.code_for_method` using many of the variables above.
+A `CodeInfo` object may be obtained with
+```julia
+# Returns the CodeInfo object for `convert(Int, ::UInt)`:
+ci = (@code_typed convert(Int, UInt(1)))[1]
+```
+
+## The inlining algorithm (inline_worthy)
+
+Much of the hardest work for inlining runs in
+`inlining_pass`. However, if your question is "why didn't my function
+inline?" then you will most likely be interested in `isinlineable` and
+its primary callee, `inline_worthy`. `isinlineable` handles a number
+of special cases (e.g., critical functions like `next` and `done`,
+incorporating a bonus for functions that return tuples, etc.). The
+main decision-making happens in `inline_worthy`, which returns `true`
+if the function should be inlined.
+
+`inline_worthy` implements a cost-model, where "cheap" functions get
+inlined; more specifically, we inline functions if their anticipated
+run-time is not large compared to the time it would take to
+[issue a call](https://en.wikipedia.org/wiki/Calling_convention) to
+them if they were not inlined. The cost-model is extremely simple and
+ignores many important details: for example, all `for` loops are
+analyzed as if they will be executed once, and the cost of an
+`if...else...end` includes the summed cost of all branches. It's also
+worth acknowledging that we currently lack a suite of functions
+suitable for testing how well the cost model predicts the actual
+run-time cost, although
+[BaseBenchmarks](https://github.com/JuliaCI/BaseBenchmarks.jl)
+provides a great deal of indirect information about the successes and
+failures of any modification to the inlining algorithm.
+
+The foundation of the cost-model is a lookup table, implemented in
+`add_tfunc` and its callers, that assigns an estimated cost (measured
+in CPU cycles) to each of Julia's intrinsic functions. These costs are
+based on
+[standard ranges for common architectures](http://ithare.com/wp-content/uploads/part101_infographics_v08.png)
+(see
+[Agner Fog's analysis](http://www.agner.org/optimize/instruction_tables.pdf)
+for more detail).
+
+We supplement this low-level lookup table with a number of special
+cases. For example, an `:invoke` expression (a call for which all
+input and output types were inferred in advance) is assigned a fixed
+cost (currently 20 cycles). In contrast, a `:call` expression, for
+functions other than intrinsics/builtins, indicates that the call will
+require dynamic dispatch, in which case we assign a cost set by
+`InferenceParams.inline_nonleaf_penalty` (currently set at 1000). Note
+that this is not a "first-principles" estimate of the raw cost of
+dynamic dispatch, but a mere heuristic indicating that dynamic
+dispatch is extremely expensive.
+
+Each statement gets analyzed for its total cost in a function called
+`statement_cost`. You can run this yourself by following this example:
+
+```julia
+params = Core.Inference.InferenceParams(typemax(UInt))
+# Get the CodeInfo object
+ci = (@code_typed fill(3, (5, 5)))[1]  # we'll try this on the code for `fill(3, (5, 5))`
+# Calculate cost of each statement
+cost(stmt) = Core.Inference.statement_cost(stmt, ci, Base, params)
+cst = map(cost, ci.code)
+```
+
+The output is a `Vector{Int}` holding the estimated cost of each
+statement in `ci.code`.  Note that `ci` includes the consequences of
+inlining callees, and consequently the costs do too.
diff --git a/doc/src/devdocs/init.md b/doc/src/devdocs/init.md
index 83d0b8e0f3cea2..d8e3e2a4f7cc86 100644
--- a/doc/src/devdocs/init.md
+++ b/doc/src/devdocs/init.md
@@ -4,42 +4,42 @@ How does the Julia runtime execute `julia -e 'println("Hello World!")'` ?
 
 ## main()
 
-Execution starts at [main() in julia/ui/repl.c](https://github.com/JuliaLang/julia/blob/master/ui/repl.c).
+Execution starts at [`main()` in `ui/repl.c`](https://github.com/JuliaLang/julia/blob/master/ui/repl.c).
 
-main() calls [libsupport_init()](https://github.com/JuliaLang/julia/blob/master/src/support/libsupportinit.c)
-to set the C library locale and to initialise the "ios" library (see [ios_init_stdstreams()](https://github.com/JuliaLang/julia/blob/master/src/support/ios.c)
-and [Legacy ios.c library](@ref)).
+`main()` calls [`libsupport_init()`](https://github.com/JuliaLang/julia/blob/master/src/support/libsupportinit.c)
+to set the C library locale and to initialize the "ios" library (see [`ios_init_stdstreams()`](https://github.com/JuliaLang/julia/blob/master/src/support/ios.c)
+and [Legacy `ios.c` library](@ref)).
 
-Next [parse_opts()](https://github.com/JuliaLang/julia/blob/master/ui/repl.c) is called to process
+Next [`parse_opts()`](https://github.com/JuliaLang/julia/blob/master/ui/repl.c) is called to process
 command line options. Note that `parse_opts()` only deals with options that affect code generation
-or early initialisation. Other options are handled later by [process_options() in base/client.jl](https://github.com/JuliaLang/julia/blob/master/base/client.jl).
+or early initialization. Other options are handled later by [`process_options()` in `base/client.jl`](https://github.com/JuliaLang/julia/blob/master/base/client.jl).
 
-`parse_opts()` stores command line options in the [global jl_options struct](https://github.com/JuliaLang/julia/blob/master/src/julia.h).
+`parse_opts()` stores command line options in the [global `jl_options` struct](https://github.com/JuliaLang/julia/blob/master/src/julia.h).
 
 ## julia_init()
 
-[julia_init() in task.c](https://github.com/JuliaLang/julia/blob/master/src/task.c) is called
-by main() and calls [_julia_init() in init.c](https://github.com/JuliaLang/julia/blob/master/src/init.c).
+[`julia_init()` in `task.c`](https://github.com/JuliaLang/julia/blob/master/src/task.c) is called
+by `main()` and calls [`_julia_init()` in `init.c`](https://github.com/JuliaLang/julia/blob/master/src/init.c).
 
 `_julia_init()` begins by calling `libsupport_init()` again (it does nothing the second time).
 
-[restore_signals()](https://github.com/JuliaLang/julia/blob/master/src/signals-unix.c) is called
+[`restore_signals()`](https://github.com/JuliaLang/julia/blob/master/src/signals-unix.c) is called
 to zero the signal handler mask.
 
-[jl_resolve_sysimg_location()](https://github.com/JuliaLang/julia/blob/master/src/init.c) searches
+[`jl_resolve_sysimg_location()`](https://github.com/JuliaLang/julia/blob/master/src/init.c) searches
 configured paths for the base system image. See [Building the Julia system image](@ref).
 
-[jl_gc_init()](https://github.com/JuliaLang/julia/blob/master/src/gc.c) sets up allocation pools
-and lists for: weak refs, preserved values and finalization.
+[`jl_gc_init()`](https://github.com/JuliaLang/julia/blob/master/src/gc.c) sets up allocation pools
+and lists for weak refs, preserved values and finalization.
 
-[jl_init_frontend()](https://github.com/JuliaLang/julia/blob/master/src/ast.c) loads and initialises
-a pre-compiled femtolisp image containing the scanner/parser;
+[`jl_init_frontend()`](https://github.com/JuliaLang/julia/blob/master/src/ast.c) loads and initializes
+a pre-compiled femtolisp image containing the scanner/parser.
 
-[jl_init_types()](https://github.com/JuliaLang/julia/blob/master/src/jltypes.c) creates `jl_datatype_t`
-type description objects for the [built-in types defined in julia.h](https://github.com/JuliaLang/julia/blob/master/src/julia.h).
+[`jl_init_types()`](https://github.com/JuliaLang/julia/blob/master/src/jltypes.c) creates `jl_datatype_t`
+type description objects for the [built-in types defined in `julia.h`](https://github.com/JuliaLang/julia/blob/master/src/julia.h).
 e.g.
 
-```julia
+```c
 jl_any_type = jl_new_abstracttype(jl_symbol("Any"), NULL, jl_null);
 jl_any_type->super = jl_any_type;
 
@@ -49,183 +49,182 @@ jl_int32_type = jl_new_bitstype(jl_symbol("Int32"),
                                 jl_any_type, jl_null, 32);
 ```
 
-[jl_init_tasks()](https://github.com/JuliaLang/julia/blob/master/src/task.c) creates the `jl_datatype_t* jl_task_type`
-object; initialises the global `jl_root_task` struct; and sets `jl_current_task` to the root task.
+[`jl_init_tasks()`](https://github.com/JuliaLang/julia/blob/master/src/task.c) creates the `jl_datatype_t* jl_task_type`
+object; initializes the global `jl_root_task` struct; and sets `jl_current_task` to the root task.
 
-[jl_init_codegen()](https://github.com/JuliaLang/julia/blob/master/src/codegen.cpp) initialises
+[`jl_init_codegen()`](https://github.com/JuliaLang/julia/blob/master/src/codegen.cpp) initializes
 the [LLVM library](http://llvm.org).
 
-[jl_init_serializer()](https://github.com/JuliaLang/julia/blob/master/src/dump.c) 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.
+[`jl_init_serializer()`](https://github.com/JuliaLang/julia/blob/master/src/staticdata.c) initializes
+8-bit serialization tags for builtin `jl_value_t` values.
 
 If there is no sysimg file (`!jl_options.image_file`) then the `Core` and `Main` modules are
 created and `boot.jl` is evaluated:
 
 `jl_core_module = jl_new_module(jl_symbol("Core"))` creates the Julia `Core` module.
 
-[jl_init_intrinsic_functions()](https://github.com/JuliaLang/julia/blob/master/src/intrinsics.cpp)
-creates a new Julia module "Intrinsics" containing constant jl_intrinsic_type symbols. These define
+[`jl_init_intrinsic_functions()`](https://github.com/JuliaLang/julia/blob/master/src/intrinsics.cpp)
+creates a new Julia module `Intrinsics` containing constant `jl_intrinsic_type` symbols. These define
 an integer code for each [intrinsic function](https://github.com/JuliaLang/julia/blob/master/src/intrinsics.cpp).
-[emit_intrinsic()](https://github.com/JuliaLang/julia/blob/master/src/intrinsics.cpp) translates
+[`emit_intrinsic()`](https://github.com/JuliaLang/julia/blob/master/src/intrinsics.cpp) translates
 these symbols into LLVM instructions during code generation.
 
-[jl_init_primitives()](https://github.com/JuliaLang/julia/blob/master/src/builtins.c) hooks C
+[`jl_init_primitives()`](https://github.com/JuliaLang/julia/blob/master/src/builtins.c) hooks C
 functions up to Julia function symbols. e.g. the symbol `Base.is()` is bound to C function pointer
 `jl_f_is()` by calling `add_builtin_func("eval", jl_f_top_eval)`.
 
-[jl_new_main_module()](https://github.com/JuliaLang/julia/blob/master/src/toplevel.c) creates
+[`jl_new_main_module()`](https://github.com/JuliaLang/julia/blob/master/src/toplevel.c) creates
 the global "Main" module and sets `jl_current_task->current_module = jl_main_module`.
 
-Note: _julia_init() [then sets](https://github.com/JuliaLang/julia/blob/master/src/init.c)`jl_root_task->current_module = jl_core_module`.
-`jl_root_task` is an alias of `jl_current_task` at this point, so the current_module set by `jl_new_main_module()`
+Note: `_julia_init()` [then sets](https://github.com/JuliaLang/julia/blob/master/src/init.c) `jl_root_task->current_module = jl_core_module`.
+`jl_root_task` is an alias of `jl_current_task` at this point, so the `current_module` set by `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](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_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
+[`jl_get_builtin_hooks()`](https://github.com/JuliaLang/julia/blob/master/src/init.c) initializes
 global C pointers to Julia globals defined in `boot.jl`.
 
-[jl_init_box_caches()](https://github.com/JuliaLang/julia/blob/master/src/alloc.c) pre-allocates
+[`jl_init_box_caches()`](https://github.com/JuliaLang/julia/blob/master/src/datatype.c) pre-allocates
 global boxed integer value objects for values up to 1024. This speeds up allocation of boxed ints
 later on. e.g.:
 
-```
+```c
 jl_value_t *jl_box_uint8(uint32_t x)
 {
     return boxed_uint8_cache[(uint8_t)x];
 }
 ```
 
-[_julia_init() iterates](https://github.com/JuliaLang/julia/blob/master/src/init.c) over the
+[`_julia_init()` iterates](https://github.com/JuliaLang/julia/blob/master/src/init.c) over the
 `jl_core_module->bindings.table` looking for `jl_datatype_t` values and sets the type name's module
 prefix to `jl_core_module`.
 
-[jl_add_standard_imports(jl_main_module)](https://github.com/JuliaLang/julia/blob/master/src/toplevel.c)
+[`jl_add_standard_imports(jl_main_module)`](https://github.com/JuliaLang/julia/blob/master/src/toplevel.c)
 does "using Base" in the "Main" module.
 
 Note: `_julia_init()` now reverts to `jl_root_task->current_module = jl_main_module` as it was
 before being set to `jl_core_module` above.
 
-Platform specific signal handlers are initialised for `SIGSEGV` (OSX, Linux), and `SIGFPE` (Windows).
+Platform specific signal handlers are initialized for `SIGSEGV` (OSX, Linux), and `SIGFPE` (Windows).
 
 Other signals (`SIGINFO, SIGBUS, SIGILL, SIGTERM, SIGABRT, SIGQUIT, SIGSYS` and `SIGPIPE`) are
-hooked up to [sigdie_handler()](https://github.com/JuliaLang/julia/blob/master/src/signals-unix.c)
+hooked up to [`sigdie_handler()`](https://github.com/JuliaLang/julia/blob/master/src/signals-unix.c)
 which prints a backtrace.
 
-[jl_init_restored_modules()](https://github.com/JuliaLang/julia/blob/master/src/dump.c) calls
-[jl_module_run_initializer()](https://github.com/JuliaLang/julia/blob/master/src/module.c) for
-each deserialised module to run the `__init__()` function.
+[`jl_init_restored_modules()`](https://github.com/JuliaLang/julia/blob/master/src/staticdata.c) calls
+[`jl_module_run_initializer()`](https://github.com/JuliaLang/julia/blob/master/src/module.c) for
+each deserialized module to run the `__init__()` function.
 
-Finally [sigint_handler()](https://github.com/JuliaLang/julia/blob/master/src/signals-unix.c)
+Finally [`sigint_handler()`](https://github.com/JuliaLang/julia/blob/master/src/signals-unix.c)
 is hooked up to `SIGINT` and calls `jl_throw(jl_interrupt_exception)`.
 
-`_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 `true_main(argc, (char**)argv)`.
+`_julia_init()` then returns [back to `main()` in `ui/repl.c`](https://github.com/JuliaLang/julia/blob/master/ui/repl.c)
+and `main()` calls `true_main(argc, (char**)argv)`.
 
 !!! sidebar "sysimg"
     If there is a sysimg file, it contains a pre-cooked image of the `Core` and `Main` modules (and
     whatever else is created by `boot.jl`). See [Building the Julia system image](@ref).
 
-    [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
+    [`jl_restore_system_image()`](https://github.com/JuliaLang/julia/blob/master/src/staticdata.c) deserializes
+    the saved sysimg into the current Julia runtime environment and initialization continues after
     `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 [Legacy ios.c library](@ref).
+    Note: [`jl_restore_system_image()` (and `staticdata.c` in general)](https://github.com/JuliaLang/julia/blob/master/src/staticdata.c)
+    uses the [Legacy `ios.c` library](@ref).
 
 ## true_main()
 
-[true_main()](https://github.com/JuliaLang/julia/blob/master/ui/repl.c) loads the contents of
+[`true_main()`](https://github.com/JuliaLang/julia/blob/master/ui/repl.c) loads the contents of
 `argv[]` into [`Base.ARGS`](@ref).
 
-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)
+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 (`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)
+However, in our example (`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.
 
 ## Base._start
 
-[Base._start](https://github.com/JuliaLang/julia/blob/master/base/client.jl) calls [Base.process_options](https://github.com/JuliaLang/julia/blob/master/base/client.jl)
-which calls [jl_parse_input_line("println("Hello World!")")](https://github.com/JuliaLang/julia/blob/master/src/ast.c)
+[`Base._start`](https://github.com/JuliaLang/julia/blob/master/base/client.jl) calls [`Base.process_options`](https://github.com/JuliaLang/julia/blob/master/base/client.jl)
+which calls [`jl_parse_input_line("println("Hello World!")")`](https://github.com/JuliaLang/julia/blob/master/src/ast.c)
 to create an expression object and [`Base.eval()`](@ref eval) to execute it.
 
 ## Base.eval
 
-[`Base.eval()`](@ref eval) was [mapped to jl_f_top_eval](https://github.com/JuliaLang/julia/blob/master/src/builtins.c)
+[`Base.eval()`](@ref eval) was [mapped to `jl_f_top_eval`](https://github.com/JuliaLang/julia/blob/master/src/builtins.c)
 by `jl_init_primitives()`.
 
-[jl_f_top_eval()](https://github.com/JuliaLang/julia/blob/master/src/builtins.c) calls [jl_toplevel_eval_in(jl_main_module, ex)](https://github.com/JuliaLang/julia/blob/master/src/builtins.c),
-where "ex" is the parsed expression `println("Hello World!")`.
+[`jl_f_top_eval()`](https://github.com/JuliaLang/julia/blob/master/src/builtins.c) calls [`jl_toplevel_eval_in(jl_main_module, ex)`](https://github.com/JuliaLang/julia/blob/master/src/builtins.c),
+where `ex` is the parsed expression `println("Hello World!")`.
 
-[jl_toplevel_eval_in()](https://github.com/JuliaLang/julia/blob/master/src/builtins.c) calls
-[jl_toplevel_eval_flex()](https://github.com/JuliaLang/julia/blob/master/src/toplevel.c) which
-calls [eval() in interpreter.c](https://github.com/JuliaLang/julia/blob/master/src/interpreter.c).
+[`jl_toplevel_eval_in()`](https://github.com/JuliaLang/julia/blob/master/src/builtins.c) calls
+[`jl_toplevel_eval_flex()`](https://github.com/JuliaLang/julia/blob/master/src/toplevel.c) which
+calls [`eval()` in `interpreter.c`](https://github.com/JuliaLang/julia/blob/master/src/interpreter.c).
 
 The stack dump below shows how the interpreter works its way through various methods of [`Base.println()`](@ref)
-and [`Base.print()`](@ref) before arriving at [write{T}(s::IO, a::Array{T})](https://github.com/JuliaLang/julia/blob/master/base/stream.jl)
+and [`Base.print()`](@ref) before arriving at [`write(s::IO, a::Array{T}) where T`](https://github.com/JuliaLang/julia/blob/master/base/stream.jl)
  which does `ccall(jl_uv_write())`.
 
-[jl_uv_write()](https://github.com/JuliaLang/julia/blob/master/src/jl_uv.c) calls `uv_write()`
+[`jl_uv_write()`](https://github.com/JuliaLang/julia/blob/master/src/jl_uv.c) calls `uv_write()`
 to write "Hello World!" to `JL_STDOUT`. See [Libuv wrappers for stdio](@ref).:
 
 ```
 Hello World!
 ```
 
-| Stack frame                  | Source code   | Notes                                             |
-|:---------------------------- |:------------- |:------------------------------------------------- |
-| jl_uv_write()                | jl_uv.c       | called though [`ccall`](@ref)                     |
-| julia_write_282942           | stream.jl     | function write!{T}(s::IO, a::Array{T})            |
-| julia_print_284639           | ascii.jl      | print(io::IO, s::String) = (write(io, s);nothing) |
-| jlcall_print_284639          |               |                                                   |
-| jl_apply()                   | julia.h       |                                                   |
-| jl_trampoline()              | builtins.c    |                                                   |
-| jl_apply()                   | julia.h       |                                                   |
-| jl_apply_generic()           | gf.c          | Base.print(Base.TTY, String)                      |
-| jl_apply()                   | julia.h       |                                                   |
-| jl_trampoline()              | builtins.c    |                                                   |
-| jl_apply()                   | julia.h       |                                                   |
-| jl_apply_generic()           | gf.c          | Base.print(Base.TTY, String, Char, Char...)       |
-| jl_apply()                   | julia.h       |                                                   |
-| jl_f_apply()                 | builtins.c    |                                                   |
-| jl_apply()                   | julia.h       |                                                   |
-| jl_trampoline()              | builtins.c    |                                                   |
-| jl_apply()                   | julia.h       |                                                   |
-| jl_apply_generic()           | gf.c          | Base.println(Base.TTY, String, String...)         |
-| jl_apply()                   | julia.h       |                                                   |
-| jl_trampoline()              | builtins.c    |                                                   |
-| jl_apply()                   | julia.h       |                                                   |
-| jl_apply_generic()           | gf.c          | Base.println(String,)                             |
-| jl_apply()                   | julia.h       |                                                   |
-| do_call()                    | interpreter.c |                                                   |
-| eval()                       | interpreter.c |                                                   |
-| jl_interpret_toplevel_expr() | interpreter.c |                                                   |
-| jl_toplevel_eval_flex()      | toplevel.c    |                                                   |
-| jl_toplevel_eval()           | toplevel.c    |                                                   |
-| jl_toplevel_eval_in()        | builtins.c    |                                                   |
-| jl_f_top_eval()              | builtins.c    |                                                   |
+| Stack frame                    | Source code     | Notes                                                |
+|:------------------------------ |:--------------- |:---------------------------------------------------- |
+| `jl_uv_write()`                | `jl_uv.c`       | called though [`ccall`](@ref)                        |
+| `julia_write_282942`           | `stream.jl`     | function `write!(s::IO, a::Array{T}) where T`        |
+| `julia_print_284639`           | `ascii.jl`      | `print(io::IO, s::String) = (write(io, s); nothing)` |
+| `jlcall_print_284639`          |                 |                                                      |
+| `jl_apply()`                   | `julia.h`       |                                                      |
+| `jl_trampoline()`              | `builtins.c`    |                                                      |
+| `jl_apply()`                   | `julia.h`       |                                                      |
+| `jl_apply_generic()`           | `gf.c`          | `Base.print(Base.TTY, String)`                       |
+| `jl_apply()`                   | `julia.h`       |                                                      |
+| `jl_trampoline()`              | `builtins.c`    |                                                      |
+| `jl_apply()`                   | `julia.h`       |                                                      |
+| `jl_apply_generic()`           | `gf.c`          | `Base.print(Base.TTY, String, Char, Char...)`        |
+| `jl_apply()`                   | `julia.h`       |                                                      |
+| `jl_f_apply()`                 | `builtins.c`    |                                                      |
+| `jl_apply()`                   | `julia.h`       |                                                      |
+| `jl_trampoline()`              | `builtins.c`    |                                                      |
+| `jl_apply()`                   | `julia.h`       |                                                      |
+| `jl_apply_generic()`           | `gf.c`          | `Base.println(Base.TTY, String, String...)`          |
+| `jl_apply()`                   | `julia.h`       |                                                      |
+| `jl_trampoline()`              | `builtins.c`    |                                                      |
+| `jl_apply()`                   | `julia.h`       |                                                      |
+| `jl_apply_generic()`           | `gf.c`          | `Base.println(String,)`                              |
+| `jl_apply()`                   | `julia.h`       |                                                      |
+| `do_call()`                    | `interpreter.c` |                                                      |
+| `eval()`                       | `interpreter.c` |                                                      |
+| `jl_interpret_toplevel_expr()` | `interpreter.c` |                                                      |
+| `jl_toplevel_eval_flex()`      | `toplevel.c`    |                                                      |
+| `jl_toplevel_eval()`           | `toplevel.c`    |                                                      |
+| `jl_toplevel_eval_in()`        | `builtins.c`    |                                                      |
+| `jl_f_top_eval()`              | `builtins.c`    |                                                      |
 
 Since our example has just one function call, which has done its job of printing "Hello World!",
 the stack now rapidly unwinds back to `main()`.
 
 ## jl_atexit_hook()
 
-`main()` calls [jl_atexit_hook()](https://github.com/JuliaLang/julia/blob/master/src/init.c).
-This calls _atexit for each module, then calls [jl_gc_run_all_finalizers()](https://github.com/JuliaLang/julia/blob/master/src/gc.c)
+`main()` calls [`jl_atexit_hook()`](https://github.com/JuliaLang/julia/blob/master/src/init.c).
+This calls `_atexit` for each module, then calls [`jl_gc_run_all_finalizers()`](https://github.com/JuliaLang/julia/blob/master/src/gc.c)
 and cleans up libuv handles.
 
 ## julia_save()
 
-Finally, `main()` calls [julia_save()](https://github.com/JuliaLang/julia/blob/master/src/init.c),
-which if requested on the command line, saves the runtime state to a new system image. See [jl_compile_all()](https://github.com/JuliaLang/julia/blob/master/src/gf.c)
-and [jl_save_system_image()](https://github.com/JuliaLang/julia/blob/master/src/dump.c).
+Finally, `main()` calls [`julia_save()`](https://github.com/JuliaLang/julia/blob/master/src/init.c),
+which if requested on the command line, saves the runtime state to a new system image. See [`jl_compile_all()`](https://github.com/JuliaLang/julia/blob/master/src/gf.c)
+and [`jl_save_system_image()`](https://github.com/JuliaLang/julia/blob/master/src/staticdata.c).
diff --git a/doc/src/devdocs/libgit2.md b/doc/src/devdocs/libgit2.md
new file mode 100644
index 00000000000000..fb86054d008112
--- /dev/null
+++ b/doc/src/devdocs/libgit2.md
@@ -0,0 +1,124 @@
+# Base.LibGit2
+
+The LibGit2 module provides bindings to [libgit2](https://libgit2.github.com/), a portable C library that
+implements core functionality for the [Git](https://git-scm.com/) version control system.
+These bindings are currently used to power Julia's package manager.
+It is expected that this module will eventually be moved into a separate package.
+
+### Functionality
+
+Some of this documentation assumes some prior knowledge of the libgit2 API.
+For more information on some of the objects and methods referenced here, consult the upstream
+[libgit2 API reference](https://libgit2.github.com/libgit2/#v0.25.1).
+
+```@docs
+Base.LibGit2.AbstractCredentials
+Base.LibGit2.Buffer
+Base.LibGit2.CachedCredentials
+Base.LibGit2.CheckoutOptions
+Base.LibGit2.CloneOptions
+Base.LibGit2.DiffDelta
+Base.LibGit2.DiffFile
+Base.LibGit2.DiffOptionsStruct
+Base.LibGit2.FetchHead
+Base.LibGit2.FetchOptions
+Base.LibGit2.GitBlob
+Base.LibGit2.GitCommit
+Base.LibGit2.GitHash
+Base.LibGit2.GitObject
+Base.LibGit2.GitRemote
+Base.LibGit2.GitRemoteAnon
+Base.LibGit2.GitRepo
+Base.LibGit2.GitRepoExt
+Base.LibGit2.GitShortHash
+Base.LibGit2.GitSignature
+Base.LibGit2.GitStatus
+Base.LibGit2.GitTag
+Base.LibGit2.GitTree
+Base.LibGit2.IndexEntry
+Base.LibGit2.IndexTime
+Base.LibGit2.MergeOptions
+Base.LibGit2.ProxyOptions
+Base.LibGit2.PushOptions
+Base.LibGit2.RebaseOperation
+Base.LibGit2.RebaseOptions
+Base.LibGit2.RemoteCallbacks
+Base.LibGit2.SSHCredentials
+Base.LibGit2.SignatureStruct
+Base.LibGit2.StatusEntry
+Base.LibGit2.StatusOptions
+Base.LibGit2.StrArrayStruct
+Base.LibGit2.TimeStruct
+Base.LibGit2.UserPasswordCredentials
+Base.LibGit2.add_fetch!
+Base.LibGit2.add_push!
+Base.LibGit2.addblob!
+Base.LibGit2.author
+Base.LibGit2.authors
+Base.LibGit2.branch
+Base.LibGit2.branch!
+Base.LibGit2.checkout!
+Base.LibGit2.checkused!
+Base.LibGit2.clone
+Base.LibGit2.commit
+Base.LibGit2.committer
+Base.LibGit2.create_branch
+Base.LibGit2.credentials_callback
+Base.LibGit2.credentials_cb
+Base.LibGit2.default_signature
+Base.LibGit2.delete_branch
+Base.LibGit2.diff_files
+Base.LibGit2.fetch
+Base.LibGit2.fetch_refspecs
+Base.LibGit2.fetchhead_foreach_cb
+Base.LibGit2.merge!(::Base.LibGit2.GitRepo; ::Any...)
+Base.LibGit2.ffmerge!
+Base.LibGit2.fullname
+Base.LibGit2.get_creds!
+Base.LibGit2.gitdir
+Base.LibGit2.head
+Base.LibGit2.head!
+Base.LibGit2.head_oid
+Base.LibGit2.headname
+Base.LibGit2.init
+Base.LibGit2.is_ancestor_of
+Base.LibGit2.isbinary
+Base.LibGit2.iscommit
+Base.LibGit2.isdiff
+Base.LibGit2.isdirty
+Base.LibGit2.isorphan
+Base.LibGit2.lookup_branch
+Base.LibGit2.mirror_callback
+Base.LibGit2.mirror_cb
+Base.LibGit2.message
+Base.LibGit2.name
+Base.LibGit2.need_update
+Base.LibGit2.objtype
+Base.LibGit2.path
+Base.LibGit2.peel
+Base.LibGit2.posixpath
+Base.LibGit2.push
+Base.LibGit2.push_refspecs
+Base.LibGit2.read_tree!
+Base.LibGit2.rebase!
+Base.LibGit2.ref_list
+Base.LibGit2.reftype
+Base.LibGit2.remotes
+Base.LibGit2.reset!
+Base.LibGit2.restore
+Base.LibGit2.revcount
+Base.LibGit2.set_remote_url
+Base.LibGit2.shortname
+Base.LibGit2.snapshot
+Base.LibGit2.status
+Base.LibGit2.stage
+Base.LibGit2.tag_create
+Base.LibGit2.tag_delete
+Base.LibGit2.tag_list
+Base.LibGit2.target
+Base.LibGit2.treewalk
+Base.LibGit2.upstream
+Base.LibGit2.url
+Base.LibGit2.with
+Base.LibGit2.workdir
+```
diff --git a/doc/src/devdocs/llvm.md b/doc/src/devdocs/llvm.md
index 0d88cc8cf17ea8..63f0d2f3072abe 100644
--- a/doc/src/devdocs/llvm.md
+++ b/doc/src/devdocs/llvm.md
@@ -50,8 +50,8 @@ development version of LLVM.
 
 ## Passing options to LLVM
 
-You can pass options to LLVM using *debug* builds of Julia.  To create a debug build, run `make debug`.
- The resulting executable is `usr/bin/julia-debug`. You can pass LLVM options to this executable
+You can pass options to LLVM using *debug* builds of Julia. To create a debug build, run `make debug`.
+The resulting executable is `usr/bin/julia-debug`. You can pass LLVM options to this executable
 via the environment variable `JULIA_LLVM_ARGS`. Here are example settings using `bash` syntax:
 
   * `export JULIA_LLVM_ARGS = -print-after-all` dumps IR after each pass.
@@ -60,6 +60,44 @@ via the environment variable `JULIA_LLVM_ARGS`. Here are example settings using
     about "Unknown command line argument". Counter-intuitively, building Julia with `LLVM_DEBUG=1`
     is *not* enough to dump `DEBUG` diagnostics from a pass.
 
+## Debugging LLVM transformations in isolation
+
+On occasion, it can be useful to debug LLVM's transformations in isolation from
+the rest of the Julia system, e.g. because reproducing the issue inside `julia`
+would take too long, or because one wants to take advantage of LLVM's tooling
+(e.g. bugpoint). To get unoptimized IR for the entire system image, pass the
+`--output-unopt-bc unopt.bc` option to the system image build process, which will
+output the unoptimized IR to an `unopt.bc` file. This file can then be passed to
+LLVM tools as usual. `libjulia` can function as an LLVM pass plugin and can be
+loaded into LLVM tools, to make julia-specific passes available in this
+environment. In addition, it exposes the `-julia` meta-pass, which runs the
+entire Julia pass-pipeline over the IR. As an example, to generate a system
+image, one could do:
+```
+opt -load libjulia.so -julia -o opt.bc unopt.bc
+llc -o sys.o opt.bc
+cc -shared -o sys.so sys.o
+```
+This system image can then be loaded by `julia` as usual.
+
+Alternatively, you can
+use `--output-jit-bc jit.bc` to obtain a trace of all IR passed to the JIT.
+This is useful for code that cannot be run as part of the sysimg generation
+process (e.g. because it creates unserializable state). However, the resulting
+`jit.bc` does not include sysimage data, and can thus not be used as such.
+
+It is also possible to dump an LLVM IR module for just one Julia function,
+using:
+```julia
+f, T = +, Tuple{Int,Int} # Substitute your function of interest here
+optimize = false
+open("plus.ll", "w") do f
+    println(f, Base._dump_function(f, T, false, false, false, true, :att, optimize))
+end
+```
+These files can be processed the same way as the unoptimized sysimg IR shown
+above.
+
 ## Improving LLVM optimizations for Julia
 
 Improving LLVM code generation usually involves either changing Julia lowering to be more friendly
@@ -75,3 +113,187 @@ study it and the pass of interest in isolation.
 4. Strip the debug metadata and fix up the TBAA metadata by hand.
 
 The last step is labor intensive.  Suggestions on a better way would be appreciated.
+
+## The jlcall calling convention
+
+Julia has a generic calling convention for unoptimized code, which looks somewhat
+as follows:
+```c
+jl_value_t *any_unoptimized_call(jl_value_t *, jl_value_t **, int);
+```
+where the first argument is the boxed function object, the second argument is
+an on-stack array of arguments and the third is the number of arguments. Now,
+we could perform a straightforward lowering and emit an alloca for the argument
+array. However, this would betray the SSA nature of the uses at the call site,
+making optimizations (including GC root placement), significantly harder.
+Instead, we emit it as follows:
+```llvm
+%bitcast = bitcast @any_unoptimized_call to %jl_value_t *(*)(%jl_value_t *, %jl_value_t *)
+call cc 37 %jl_value_t *%bitcast(%jl_value_t *%arg1, %jl_value_t *%arg2)
+```
+The special `cc 37` annotation marks the fact that this call site is really using
+the jlcall calling convention. This allows us to retain the SSA-ness of the
+uses throughout the optimizer. GC root placement will later lower this call to
+the original C ABI. In the code the calling convention number is represented by
+the `JLCALL_F_CC` constant. In addition, there is the `JLCALL_CC` calling
+convention which functions similarly, but omits the first argument.
+
+## GC root placement
+
+GC root placement is done by an LLVM pass late in the pass pipeline. Doing GC root
+placement this late enables LLVM to make more aggressive optimizations around
+code that requires GC roots, as well as allowing us to reduce the number of
+required GC roots and GC root store operations (since LLVM doesn't understand
+our GC, it wouldn't otherwise know what it is and is not allowed to do with
+values stored to the GC frame, so it'll conservatively do very little). As an
+example, consider an error path
+```julia
+if some_condition()
+    #= Use some variables maybe =#
+    error("An error occurred")
+end
+```
+During constant folding, LLVM may discover that the condition is always false,
+and can remove the basic block. However, if GC root lowering is done early,
+the GC root slots used in the deleted block, as well as any values kept alive
+in those slots only because they were used in the error path, would be kept
+alive by LLVM. By doing GC root lowering late, we give LLVM the license to do
+any of its usual optimizations (constant folding, dead code elimination, etc.),
+without having to worry (too much) about which values may or may not be GC
+tracked.
+
+However, in order to be able to do late GC root placement, we need to be able to
+identify a) which pointers are gc tracked and b) all uses of such pointers. The
+goal of the GC placement pass is thus simple:
+
+Minimize the number of needed GC roots/stores to them subject to the constraint
+that at every safepoint, any live GC-tracked pointer (i.e. for which there is
+a path after this point that contains a use of this pointer) is in some GC slot.
+
+### Representation
+
+The primary difficulty is thus choosing an IR representation that allows us to
+identify GC-tracked pointers and their uses, even after the program has been
+run through the optimizer. Our design makes use of three LLVM features to achieve
+this:
+- Custom address spaces
+- Operand Bundles
+- Non-integral pointers
+
+Custom address spaces allow us to tag every point with an integer that needs
+to be preserved through optimizations. The compiler may not insert casts between
+address spaces that did not exist in the original program and it must never
+change the address space of a pointer on a load/store/etc operation. This allows
+us to annotate which pointers are GC-tracked in an optimizer-resistant way. Note
+that metadata would not be able to achieve the same purpose. Metadata is supposed
+to always be discardable without altering the semantics of the program. However,
+failing to identify a GC-tracked pointer alters the resulting program behavior
+dramatically - it'll probably crash or return wrong results. We currently use
+three different address spaces (their numbers are defined in `src/codegen_shared.cpp`):
+
+- GC Tracked Pointers (currently 10): These are pointers to boxed values that may be put
+  into a GC frame. It is loosely equivalent to a `jl_value_t*` pointer on the C
+  side. N.B. It is illegal to ever have a pointer in this address space that may
+  not be stored to a GC slot.
+- Derived Pointers (currently 11): These are pointers that are derived from some GC
+  tracked pointer. Uses of these pointers generate uses of the original pointer.
+  However, they need not themselves be known to the GC. The GC root placement
+  pass MUST always find the GC tracked pointer from which this pointer is
+  derived and use that as the pointer to root.
+- Callee Rooted Pointers (currently 12): This is a utility address space to express the
+  notion of a callee rooted value. All values of this address space MUST be
+  storable to a GC root (though it is possible to relax this condition in the
+  future), but unlike the other pointers need not be rooted if passed to a
+  call (they do still need to be rooted if they are live across another safepoint
+  between the definition and the call).
+
+### Invariants
+
+The GC root placement pass makes use of several invariants, which need
+to be observed by the frontend and are preserved by the optimizer.
+
+First, only the following address space casts are allowed:
+- 0->{Tracked,Derived,CalleeRooted}: It is allowable to decay an untracked pointer to any of the
+  others. However, do note that the optimizer has broad license to not root
+  such a value. It is never safe to have a value in address space 0 in any part
+  of the program if it is (or is derived from) a value that requires a GC root.
+- Tracked->Derived: This is the standard decay route for interior values. The placement
+  pass will look for these to identify the base pointer for any use.
+- Tracked->CalleeRooted: Addrspace CalleeRooted serves merely as a hint that a GC root is not
+  required. However, do note that the Derived->CalleeRooted decay is prohibited, since
+  pointers should generally be storable to a GC slot, even in this address space.
+
+Now let us consider what constitutes a use:
+- Loads whose loaded values is in one of the address spaces
+- Stores of a value in one of the address spaces to a location
+- Stores to a pointer in one of the address spaces
+- Calls for which a value in one of the address spaces is an operand
+- Calls in jlcall ABI, for which the argument array contains a value
+- Return instructions.
+
+We explicitly allow load/stores and simple calls in address spaces Tracked/Derived. Elements of jlcall
+argument arrays must always be in address space Tracked (it is required by the ABI that
+they are valid `jl_value_t*` pointers). The same is true for return instructions
+(though note that struct return arguments are allowed to have any of the address
+spaces). The only allowable use of an address space CalleeRooted pointer is to pass it to
+a call (which must have an appropriately typed operand).
+
+Further, we disallow `getelementptr` in addrspace Tracked. This is because unless
+the operation is a noop, the resulting pointer will not be validly storable
+to a GC slot and may thus not be in this address space. If such a pointer
+is required, it should be decayed to addrspace Derived first.
+
+Lastly, we disallow `inttoptr`/`ptrtoint` instructions in these address spaces.
+Having these instructions would mean that some `i64` values are really GC tracked.
+This is problematic, because it breaks that stated requirement that we're able
+to identify GC-relevant pointers. This invariant is accomplished using the LLVM
+"non-integral pointers" feature, which is new in LLVM 5.0. It prohibits the
+optimizer from making optimizations that would introduce these operations. Note
+we can still insert static constants at JIT time by using `inttoptr` in address
+space 0 and then decaying to the appropriate address space afterwards.
+
+### Supporting ccall
+
+One important aspect missing from the discussion so far is the handling of
+`ccall`. `ccall` has the peculiar feature that the location and scope of a use
+do not coincide. As an example consider:
+```julia
+A = randn(1024)
+ccall(:foo, Void, (Ptr{Float64},), A)
+```
+In lowering, the compiler will insert a conversion from the array to the
+pointer which drops the reference to the array value. However, we of course
+need to make sure that the array does stay alive while we're doing the `ccall`.
+To understand how this is done, first recall the lowering of the above code:
+```julia
+return $(Expr(:foreigncall, :(:foo), Void, svec(Ptr{Float64}), :(:ccall), 1, :($(Expr(:foreigncall, :(:jl_array_ptr), Ptr{Float64}, svec(Any), :(:ccall), 1, :(A)))), :(A)))
+```
+The last `:(A)`, is an extra argument list inserted during lowering that informs
+the code generator which Julia level values need to be kept alive for the
+duration of this `ccall`. We then take this information and represent it in an
+"operand bundle" at the IR level. An operand bundle is essentially a fake use
+that is attached to the call site. At the IR level, this looks like so:
+```llvm
+call void inttoptr (i64 ... to void (double*)*)(double* %5) [ "jl_roots"(%jl_value_t addrspace(10)* %A) ]
+```
+The GC root placement pass will treat the `jl_roots` operand bundle as if it were
+a regular operand. However, as a final step, after the GC roots are inserted,
+it will drop the operand bundle to avoid confusing instruction selection.
+
+### Supporting pointer_from_objref
+
+`pointer_from_objref` is special because it requires the user to take explicit
+control of GC rooting. By our above invariants, this function is illegal,
+because it performs an address space cast from 10 to 0. However, it can be useful,
+in certain situations, so we provide a special intrinsic:
+```llvm
+declared %jl_value_t *julia.pointer_from_objref(%jl_value_t addrspace(10)*)
+```
+which is lowered to the corresponding address space cast after GC root lowering.
+Do note however that by using this intrinsic, the caller assumes all responsibility
+for making sure that the value in question is rooted. Further this intrinsic is
+not considered a use, so the GC root placement pass will not provide a GC root
+for the function. As a result, the external rooting must be arranged while the
+value is still tracked by the system. I.e. it is not valid to attempt to use the
+result of this operation to establish a global root - the optimizer may have
+already dropped the value.
diff --git a/doc/src/devdocs/object.md b/doc/src/devdocs/object.md
index f81e440676e964..222e6cfc94d2c7 100644
--- a/doc/src/devdocs/object.md
+++ b/doc/src/devdocs/object.md
@@ -6,14 +6,14 @@ The `jl_value_t` struct is the name for a block of memory owned by the Julia Gar
 representing the data associated with a Julia object in memory. Absent any type information, it
 is simply an opaque pointer:
 
-```
+```c
 typedef struct jl_value_t* jl_pvalue_t;
 ```
 
 Each `jl_value_t` struct is contained in a `jl_typetag_t` struct that contains metadata information
 about the Julia object, such as its type and garbage collector (gc) reachability:
 
-```
+```c
 typedef struct {
     opaque metadata;
     jl_value_t value;
@@ -23,14 +23,14 @@ typedef struct {
 The type of any Julia object is an instance of a concrete `jl_datatype_t` object. The `jl_typeof()`
 function can be used to query for it:
 
-```julia
+```c
 jl_value_t *jl_typeof(jl_value_t *v);
 ```
 
 The layout of the object depends on its type. Reflection methods can be used to inspect that layout.
 A field can be accessed by calling one of the get-field methods:
 
-```
+```c
 jl_value_t *jl_get_nth_field_checked(jl_value_t *v, size_t i);
 jl_value_t *jl_get_field(jl_value_t *o, char *fld);
 ```
@@ -38,17 +38,17 @@ jl_value_t *jl_get_field(jl_value_t *o, char *fld);
 If the field types are known, a priori, to be all pointers, the values can also be extracted directly
 as an array access:
 
-```julia
+```c
 jl_value_t *v = value->fieldptr[n];
 ```
 
 As an example, a "boxed" `uint16_t` is stored as follows:
 
-```
+```c
 struct {
     opaque metadata;
     struct {
-      uint16_t data;            -- 2 bytes
+        uint16_t data;        // -- 2 bytes
     } jl_value_t;
 };
 ```
@@ -58,10 +58,10 @@ data portion, not the metadata at the top of the struct.
 
 A value may be stored "unboxed" in many circumstances (just the data, without the metadata, and
 possibly not even stored but just kept in registers), so it is unsafe to assume that the address
-of a box is a unique identifier. The "egal" test (corresponding to the `is()` function in Julia),
+of a box is a unique identifier. The "egal" test (corresponding to the `===` function in Julia),
 should instead be used to compare two unknown objects for equivalence:
 
-```
+```c
 int jl_egal(jl_value_t *a, jl_value_t *b);
 ```
 
@@ -72,41 +72,40 @@ Note that modification of a `jl_value_t` pointer in memory is permitted only if
 mutable. Otherwise, modification of the value may corrupt the program and the result will be undefined.
 The mutability property of a value can be queried for with:
 
-```
+```c
 int jl_is_mutable(jl_value_t *v);
 ```
 
 If the object being stored is a `jl_value_t`, the Julia garbage collector must be notified also:
 
-```
+```c
 void jl_gc_wb(jl_value_t *parent, jl_value_t *ptr);
 ```
 
 However, the [Embedding Julia](@ref) section of the manual is also required reading at this point,
-
 for covering other details of boxing and unboxing various types, and understanding the gc interactions.
 
-Mirror structs for some of the built-in types are [defined in julia.h](https://github.com/JuliaLang/julia/blob/master/src/julia.h).
-The corresponding global `jl_datatype_t` objects are created by [jl_init_types in jltypes.c](https://github.com/JuliaLang/julia/blob/master/src/jltypes.c).
+Mirror structs for some of the built-in types are [defined in `julia.h`](https://github.com/JuliaLang/julia/blob/master/src/julia.h).
+The corresponding global `jl_datatype_t` objects are created by [`jl_init_types` in `jltypes.c`](https://github.com/JuliaLang/julia/blob/master/src/jltypes.c).
 
 ## Garbage collector mark bits
 
 The garbage collector uses several bits from the metadata portion of the `jl_typetag_t` to track
 each object in the system. Further details about this algorithm can be found in the comments of
-the [garbage collector implementation in gc.c](https://github.com/JuliaLang/julia/blob/master/src/gc.c).
+the [garbage collector implementation in `gc.c`](https://github.com/JuliaLang/julia/blob/master/src/gc.c).
 
 ## Object allocation
 
 Most new objects are allocated by `jl_new_structv()`:
 
-```
+```c
 jl_value_t *jl_new_struct(jl_datatype_t *type, ...);
 jl_value_t *jl_new_structv(jl_datatype_t *type, jl_value_t **args, uint32_t na);
 ```
 
 Although, [`isbits`](@ref) objects can be also constructed directly from memory:
 
-```julia
+```c
 jl_value_t *jl_new_bits(jl_value_t *bt, void *data)
 ```
 
@@ -114,20 +113,20 @@ And some objects have special constructors that must be used instead of the abov
 
 Types:
 
-```
+```c
 jl_datatype_t *jl_apply_type(jl_datatype_t *tc, jl_tuple_t *params);
 jl_datatype_t *jl_apply_array_type(jl_datatype_t *type, size_t dim);
 jl_uniontype_t *jl_new_uniontype(jl_tuple_t *types);
 ```
 
 While these are the most commonly used options, there are more low-level constructors too, which
-you can find declared in [julia.h](https://github.com/JuliaLang/julia/blob/master/src/julia.h).
+you can find declared in [`julia.h`](https://github.com/JuliaLang/julia/blob/master/src/julia.h).
 These are used in `jl_init_types()` to create the initial types needed to bootstrap the creation
 of the Julia system image.
 
 Tuples:
 
-```
+```c
 jl_tuple_t *jl_tuple(size_t n, ...);
 jl_tuple_t *jl_tuplev(size_t n, jl_value_t **v);
 jl_tuple_t *jl_alloc_tuple(size_t n);
@@ -137,7 +136,7 @@ The representation of tuples is highly unique in the Julia object representation
 some cases, a [`Base.tuple()`](@ref) object may be an array of pointers to the objects contained
 by the tuple equivalent to:
 
-```
+```c
 typedef struct {
     size_t length;
     jl_value_t *data[length];
@@ -150,20 +149,20 @@ stored unboxed, or it may not stored at all (if it is not being used in a generi
 
 Symbols:
 
-```
+```c
 jl_sym_t *jl_symbol(const char *str);
 ```
 
 Functions and MethodInstance:
 
-```julia
+```c
 jl_function_t *jl_new_generic_function(jl_sym_t *name);
 jl_method_instance_t *jl_new_method_instance(jl_value_t *ast, jl_tuple_t *sparams);
 ```
 
 Arrays:
 
-```
+```c
 jl_array_t *jl_new_array(jl_value_t *atype, jl_tuple_t *dims);
 jl_array_t *jl_new_arrayv(jl_value_t *atype, ...);
 jl_array_t *jl_alloc_array_1d(jl_value_t *atype, size_t nr);
@@ -174,12 +173,12 @@ jl_array_t *jl_alloc_vec_any(size_t n);
 
 Note that many of these have alternative allocation functions for various special-purposes. The
 list here reflects the more common usages, but a more complete list can be found by reading the
-[julia.h header file](https://github.com/JuliaLang/julia/blob/master/src/julia.h).
+[`julia.h` header file](https://github.com/JuliaLang/julia/blob/master/src/julia.h).
 
 Internal to Julia, storage is typically allocated by `newstruct()` (or `newobj()` for the special
 types):
 
-```
+```c
 jl_value_t *newstruct(jl_value_t *type);
 jl_value_t *newobj(jl_value_t *type, size_t nfields);
 ```
@@ -187,7 +186,7 @@ jl_value_t *newobj(jl_value_t *type, size_t nfields);
 And at the lowest level, memory is getting allocated by a call to the garbage collector (in `gc.c`),
 then tagged with its type:
 
-```
+```c
 jl_value_t *jl_gc_allocobj(size_t nbytes);
 void jl_set_typeof(jl_value_t *v, jl_datatype_t *type);
 ```
diff --git a/doc/src/devdocs/offset-arrays.md b/doc/src/devdocs/offset-arrays.md
index b524fa4af1fe92..9a8fe083421d54 100644
--- a/doc/src/devdocs/offset-arrays.md
+++ b/doc/src/devdocs/offset-arrays.md
@@ -59,7 +59,7 @@ the ranges may not start at 1.  If you just want the range for a particular dime
 is `indices(A, d)`.
 
 Base implements a custom range type, `OneTo`, where `OneTo(n)` means the same thing as `1:n` but
-in a form that guarantees (via the type system) that the lower index is 1.  For any new `AbstractArray`
+in a form that guarantees (via the type system) that the lower index is 1. For any new [`AbstractArray`](@ref)
 type, this is the default returned by `indices`, and it indicates that this array type uses "conventional"
 1-based indexing.  Note that if you don't want to be bothered supporting arrays with non-1 indexing,
 you can add the following line:
@@ -77,7 +77,7 @@ can sometimes simplify such tests.
 
 Some algorithms are most conveniently (or efficiently) written in terms of a single linear index,
 `A[i]` even if `A` is multi-dimensional.  In "true" linear indexing, the indices always range
-from `1:length(A)`. However, this raises an ambiguity for one-dimensional arrays (a.k.a., `AbstractVector`):
+from `1:length(A)`. However, this raises an ambiguity for one-dimensional arrays (a.k.a., [`AbstractVector`](@ref)):
 does `v[i]` mean linear indexing, or Cartesian indexing with the array's native indices?
 
 For this reason, if you want to use linear indexing in an algorithm, your best option is to get
@@ -108,8 +108,8 @@ Storage is often allocated with `Array{Int}(dims)` or `similar(A, args...)`. Whe
 to match the indices of some other array, this may not always suffice. The generic replacement
 for such patterns is to use `similar(storagetype, shape)`.  `storagetype` indicates the kind of
 underlying "conventional" behavior you'd like, e.g., `Array{Int}` or `BitArray` or even `dims->zeros(Float32, dims)`
-(which would allocate an all-zeros array). `shape` is a tuple of `Integer` or `AbstractUnitRange`
-values, specifying the indices that you want the result to use.
+(which would allocate an all-zeros array). `shape` is a tuple of [`Integer`](@ref) or
+`AbstractUnitRange` values, specifying the indices that you want the result to use.
 
 Let's walk through a couple of explicit examples. First, if `A` has conventional indices, then
 `similar(Array{Int}, indices(A))` would end up calling `Array{Int}(size(A))`, and thus return
@@ -169,8 +169,8 @@ is (perhaps counterintuitively) an advantage: `ModuleA.ZeroRange` indicates that
 create a `ModuleA.ZeroArray`, whereas `ModuleB.ZeroRange` indicates a `ModuleB.ZeroArray` type.
  This design allows peaceful coexistence among many different custom array types.
 
-Note that the Julia package `CustomUnitRanges.jl` can sometimes be used to avoid the need to write
-your own `ZeroRange` type.
+Note that the Julia package [CustomUnitRanges.jl](https://github.com/JuliaArrays/CustomUnitRanges.jl)
+can sometimes be used to avoid the need to write your own `ZeroRange` type.
 
 ### Specializing `indices`
 
@@ -186,7 +186,7 @@ implement this).
 In some cases, the fallback definition for `indices(A, d)`:
 
 ```julia
-indices{T,N}(A::AbstractArray{T,N}, d) = d <= N ? indices(A)[d] : OneTo(1)
+indices(A::AbstractArray{T,N}, d) where {T,N} = d <= N ? indices(A)[d] : OneTo(1)
 ```
 
 may not be what you want: you may need to specialize it to return something other than `OneTo(1)`
@@ -195,8 +195,8 @@ to `indices(A, 1)` but which avoids checking (at runtime) whether `ndims(A) > 0`
 a performance optimization.)  It is defined as:
 
 ```julia
-indices1{T}(A::AbstractArray{T,0}) = OneTo(1)
-indices1{T}(A::AbstractArray{T})   = indices(A)[1]
+indices1(A::AbstractArray{T,0}) where {T} = OneTo(1)
+indices1(A::AbstractArray) = indices(A)[1]
 ```
 
 If the first of these (the zero-dimensional case) is problematic for your custom array type, be
diff --git a/doc/src/devdocs/reflection.md b/doc/src/devdocs/reflection.md
index 7902970f8bbdea..09d2bba65abec0 100644
--- a/doc/src/devdocs/reflection.md
+++ b/doc/src/devdocs/reflection.md
@@ -14,8 +14,8 @@ The names of `DataType` fields may be interrogated using [`fieldnames()`](@ref).
 given the following type, `fieldnames(Point)` returns an arrays of [`Symbol`](@ref) elements representing
 the field names:
 
-```julia
-julia> type Point
+```jldoctest struct_point
+julia> struct Point
            x::Int
            y
        end
@@ -29,9 +29,9 @@ julia> fieldnames(Point)
 The type of each field in a `Point` object is stored in the `types` field of the `Point` variable
 itself:
 
-```julia
+```jldoctest struct_point
 julia> Point.types
-svec(Int64,Any)
+svec(Int64, Any)
 ```
 
 While `x` is annotated as an `Int`, `y` was unannotated in the type definition, therefore `y`
@@ -39,7 +39,7 @@ defaults to the `Any` type.
 
 Types are themselves represented as a structure called `DataType`:
 
-```julia
+```jldoctest struct_point
 julia> typeof(Point)
 DataType
 ```
@@ -50,11 +50,11 @@ of these fields is the `types` field observed in the example above.
 ## Subtypes
 
 The *direct* subtypes of any `DataType` may be listed using [`subtypes()`](@ref). For example,
-the abstract `DataType``AbstractFloat` has four (concrete) subtypes:
+the abstract `DataType` [`AbstractFloat`](@ref) has four (concrete) subtypes:
 
-```julia
+```jldoctest
 julia> subtypes(AbstractFloat)
-4-element Array{DataType,1}:
+4-element Array{Union{DataType, UnionAll},1}:
  BigFloat
  Float16
  Float32
@@ -83,9 +83,9 @@ the unquoted and interpolated expression (`Expr`) form for a given macro. To use
 `quote` the expression block itself (otherwise, the macro will be evaluated and the result will
 be passed instead!). For example:
 
-```julia
-julia> macroexpand( :(@edit println("")) )
-:((Base.edit)(println,(Base.typesof)("")))
+```jldoctest
+julia> macroexpand(@__MODULE__, :(@edit println("")) )
+:((Base.edit)(println, (Base.typesof)("")))
 ```
 
 The functions `Base.Meta.show_sexpr()` and [`dump()`](@ref) are used to display S-expr style views
@@ -95,11 +95,12 @@ Finally, the [`expand()`](@ref) function gives the `lowered` form of any express
 particular interest for understanding both macros and top-level statements such as function declarations
 and variable assignments:
 
-```julia
-julia> expand( :(f() = 1) )
+```jldoctest
+julia> expand(@__MODULE__, :(f() = 1) )
 :(begin
         $(Expr(:method, :f))
-        $(Expr(:method, :f, :((Core.svec)((Core.svec)((Core.Typeof)(f)),(Core.svec)())), CodeInfo(:(begin  # none, line 1:
+        $(Expr(:method, :f, :((Core.svec)((Core.svec)((Core.Typeof)(f)), (Core.svec)())), CodeInfo(:(begin
+        #= none:1 =#
         return 1
     end)), false))
         return f
@@ -123,7 +124,7 @@ generation for any function which has not previously been called).
 For convenience, there are macro versions of the above functions which take standard function
 calls and expand argument types automatically:
 
-```julia
+```julia-repl
 julia> @code_llvm +(1,1)
 
 ; Function Attrs: sspreq
diff --git a/doc/src/devdocs/require.md b/doc/src/devdocs/require.md
new file mode 100644
index 00000000000000..4862d9e5802b11
--- /dev/null
+++ b/doc/src/devdocs/require.md
@@ -0,0 +1,40 @@
+# Module loading
+
+[`Base.require`](@ref) is responsible for loading modules and it also manages the
+precompilation cache. It is the implementation of the `import` statement.
+
+## Experimental features
+The features below are experimental and not part of the stable Julia API.
+Before building upon them inform yourself about the current thinking and whether they might change soon.
+
+### Module loading callbacks
+
+It is possible to listen to the modules loaded by `Base.require`, by registering a callback.
+
+```julia
+loaded_packages = Channel{Symbol}()
+callback = (mod::Symbol) -> put!(loaded_packages, mod)
+push!(Base.package_callbacks, callback)
+```
+
+Please note that the symbol given to the callback is a non-unique identifier and
+it is the responsibility of the callback provider to walk the module chain to
+determine the fully qualified name of the loaded binding.
+
+The callback below is an example of how to do that:
+
+```julia
+# Get the fully-qualified name of a module.
+function module_fqn(name::Symbol)
+    fqn = Symbol[name]
+    mod = getfield(Main, name)
+    parent = Base.module_parent(mod)
+    while parent !== Main
+        push!(fqn, Base.module_name(parent))
+        parent = Base.module_parent(parent)
+    end
+    fqn = reverse!(fqn)
+    return join(fqn, '.')
+end
+```
+
diff --git a/doc/src/devdocs/sanitizers.md b/doc/src/devdocs/sanitizers.md
index 5e95dcbb9d3cac..7b065181a87c17 100644
--- a/doc/src/devdocs/sanitizers.md
+++ b/doc/src/devdocs/sanitizers.md
@@ -8,9 +8,8 @@ code generated by Julia's JIT relies on functionality from that library. This im
 LLVM version of your host compiler matches that of the LLVM library used within Julia.
 
 An easy solution is to have an dedicated build folder for providing a matching toolchain, by building
-with `BUILD_LLVM_CLANG=1` and overriding `LLVM_USE_CMAKE=1` (Autotool-based builds are incompatible
-with ASAN). You can then refer to this toolchain from another build folder by specifying `USECLANG=1`
-while overriding the `CC` and `CXX` variables.
+with `BUILD_LLVM_CLANG=1`. You can then refer to this toolchain from another build
+folder by specifying `USECLANG=1` while overriding the `CC` and `CXX` variables.
 
 ## Address Sanitizer (ASAN)
 
diff --git a/doc/src/devdocs/stdio.md b/doc/src/devdocs/stdio.md
index 1ccfee543837c2..f78d7c623e62b6 100644
--- a/doc/src/devdocs/stdio.md
+++ b/doc/src/devdocs/stdio.md
@@ -4,7 +4,7 @@
 
 `julia.h` defines [libuv](http://docs.libuv.org) wrappers for the `stdio.h` streams:
 
-```julia
+```c
 uv_stream_t *JL_STDIN;
 uv_stream_t *JL_STDOUT;
 uv_stream_t *JL_STDERR;
@@ -12,24 +12,24 @@ uv_stream_t *JL_STDERR;
 
 ... and corresponding output functions:
 
-```
+```c
 int jl_printf(uv_stream_t *s, const char *format, ...);
 int jl_vprintf(uv_stream_t *s, const char *format, va_list args);
 ```
 
-These `printf` functions are used by `julia/{src,ui}/*.c` wherever stdio is needed to ensure that
-output buffering is handled in a unified way.
+These `printf` functions are used by the `.c` files in the `src/` and `ui/` directories wherever stdio is
+needed to ensure that output buffering is handled in a unified way.
 
-In special cases, like signal handlers, where the full `libuv` infrastructure is too heavy, `jl_safe_printf()`
+In special cases, like signal handlers, where the full libuv infrastructure is too heavy, `jl_safe_printf()`
 can be used to [`write(2)`](@ref) directly to `STDERR_FILENO`:
 
-```
+```c
 void jl_safe_printf(const char *str, ...);
 ```
 
 ## Interface between JL_STD* and Julia code
 
-[`Base.STDIN`](@ref), [`Base.STDOUT`](@ref) and [`Base.STDERR`](@ref) are bound to the `JL_STD*`[libuv](http://docs.libuv.org)
+[`Base.STDIN`](@ref), [`Base.STDOUT`](@ref) and [`Base.STDERR`](@ref) are bound to the `JL_STD*` libuv
 streams defined in the runtime.
 
 Julia's `__init__()` function (in `base/sysimg.jl`) calls `reinit_stdio()` (in `base/stream.jl`)
@@ -51,7 +51,7 @@ Tuple{Base.PipeEndpoint,Base.PipeEndpoint,Base.TTY}
 ```
 
 The [`Base.read()`](@ref) and [`Base.write()`](@ref) methods for these streams use [`ccall`](@ref)
-to call `libuv` wrappers in `src/jl_uv.c`, e.g.:
+to call libuv wrappers in `src/jl_uv.c`, e.g.:
 
 ```
 stream.jl: function write(s::IO, p::Ptr, nb::Integer)
@@ -60,43 +60,44 @@ stream.jl: function write(s::IO, p::Ptr, nb::Integer)
                         -> uv_write(uvw, stream, buf, ...)
 ```
 
-## printf() during initialisation
+## printf() during initialization
 
-The `libuv` streams relied upon by `jl_printf()` etc., are not available until midway through
-initialisation of the runtime (see `init.c`, `init_stdio()`).  Error messages or warnings that
+The libuv streams relied upon by `jl_printf()` etc., are not available until midway through
+initialization of the runtime (see `init.c`, `init_stdio()`).  Error messages or warnings that
 need to be printed before this are routed to the standard C library `fwrite()` function by the
 following mechanism:
 
-In `sys.c`, the `JL_STD*` stream pointers are statically initialised to integer constants: `STD*_FILENO (0, 1 and 2)`.
+In `sys.c`, the `JL_STD*` stream pointers are statically initialized to integer constants: `STD*_FILENO (0, 1 and 2)`.
 In `jl_uv.c` the `jl_uv_puts()` function checks its `uv_stream_t* stream` argument and calls
 `fwrite()` if stream is set to `STDOUT_FILENO` or `STDERR_FILENO`.
 
 This allows for uniform use of `jl_printf()` throughout the runtime regardless of whether or not
-any particular piece of code is reachable before initialisation is complete.
+any particular piece of code is reachable before initialization is complete.
 
-## Legacy ios.c library
+## Legacy `ios.c` library
 
-The `julia/src/support/ios.c` library is inherited from [femtolisp](https://github.com/JeffBezanson/femtolisp).
+The `src/support/ios.c` library is inherited from [femtolisp](https://github.com/JeffBezanson/femtolisp).
 It provides cross-platform buffered file IO and in-memory temporary buffers.
 
 `ios.c` is still used by:
 
-  * `julia/src/flisp/*.c`
-  * `julia/src/dump.c` – for serialisation file IO and for memory buffers.
-  * `base/iostream.jl` – for file IO (see `base/fs.jl` for `libuv` equivalent).
+  * `src/flisp/*.c`
+  * `src/dump.c` – for serialization file IO and for memory buffers.
+  * `src/staticdata.c` – for serialization file IO and for memory buffers.
+  * `base/iostream.jl` – for file IO (see `base/fs.jl` for libuv equivalent).
 
-Use of `ios.c` in these modules is mostly self-contained and separated from the `libuv` I/O system.
+Use of `ios.c` in these modules is mostly self-contained and separated from the libuv I/O system.
 However, there is [one place](https://github.com/JuliaLang/julia/blob/master/src/flisp/print.c#L654)
 where femtolisp calls through to `jl_printf()` with a legacy `ios_t` stream.
 
 There is a hack in `ios.h` that makes the `ios_t.bm` field line up with the `uv_stream_t.type`
-and ensures that the values used for `ios_t.bm` to not overlap with valid UV_HANDLE_TYPE values.
+and ensures that the values used for `ios_t.bm` to not overlap with valid `UV_HANDLE_TYPE` values.
  This allows `uv_stream_t` pointers to point to `ios_t` streams.
 
 This is needed because `jl_printf()` caller `jl_static_show()` is passed an `ios_t` stream by
 femtolisp's `fl_print()` function. Julia's `jl_uv_puts()` function has special handling for this:
 
-```
+```c
 if (stream->type > UV_HANDLE_TYPE_MAX) {
     return ios_write((ios_t*)stream, str, n);
 }
diff --git a/doc/src/devdocs/subarrays.md b/doc/src/devdocs/subarrays.md
index 8055e72865b380..d77c7f68fb96b0 100644
--- a/doc/src/devdocs/subarrays.md
+++ b/doc/src/devdocs/subarrays.md
@@ -1,6 +1,6 @@
 # SubArrays
 
-Julia's `SubArray` type is a container encoding a "view" of a parent `AbstractArray`.  This page
+Julia's `SubArray` type is a container encoding a "view" of a parent [`AbstractArray`](@ref).  This page
 documents some of the design principles and implementation of `SubArray`s.
 
 ## Indexing: cartesian vs. linear indexing
@@ -17,9 +17,10 @@ allows you to combine these styles of indexing: for example, a 3d array `A3` can
 For `Array`s, linear indexing appeals to the underlying storage format: an array is laid out as
 a contiguous block of memory, and hence the linear index is just the offset (+1) of the corresponding
 entry relative to the beginning of the array.  However, this is not true for many other `AbstractArray`
-types: examples include `SparseMatrixCSC`, arrays that require some kind of computation (such
-as interpolation), and the type under discussion here, `SubArray`.  For these types, the underlying
-information is more naturally described in terms of cartesian indexes.
+types: examples include [`SparseMatrixCSC`](@ref), arrays that require some kind of
+computation (such as interpolation), and the type under discussion here, `SubArray`.
+For these types, the underlying information is more naturally described in terms of
+cartesian indexes.
 
 You can manually convert from a cartesian index to a linear index with `sub2ind`, and vice versa
 using `ind2sub`.  `getindex` and `setindex!` functions for `AbstractArray` types may include similar
@@ -54,8 +55,8 @@ any runtime overhead.
 
 The strategy adopted is first and foremost expressed in the definition of the type:
 
-```
-immutable SubArray{T,N,P,I,L} <: AbstractArray{T,N}
+```julia
+struct SubArray{T,N,P,I,L} <: AbstractArray{T,N}
     parent::P
     indexes::I
     offset1::Int       # for linear indexing and pointer, only valid when L==true
@@ -74,7 +75,7 @@ If in our example above `A` is a `Array{Float64, 3}`, our `S1` case above would
 Note in particular the tuple parameter, which stores the types of the indices used to create
 `S1`.  Likewise,
 
-```julia
+```julia-repl
 julia> S1.indexes
 (Colon(),5,2:6)
 ```
@@ -89,7 +90,7 @@ types.  For example, for `S1`, one needs to apply the `i,j` indices to the first
 of the parent array, whereas for `S2` one needs to apply them to the second and third.  The simplest
 approach to indexing would be to do the type-analysis at runtime:
 
-```
+```julia
 parentindexes = Array{Any}(0)
 for thisindex in S.indexes
     ...
@@ -137,7 +138,7 @@ For `SubArray` types, the availability of efficient linear indexing is based pur
 of the indices, and does not depend on values like the size of the parent array. You can ask whether
 a given set of indices supports fast linear indexing with the internal `Base.viewindexing` function:
 
-```julia
+```julia-repl
 julia> Base.viewindexing(S1.indexes)
 IndexCartesian()
 
@@ -152,7 +153,7 @@ we can define dispatch directly on `SubArray{T,N,A,I,true}` without any intermed
 Since this computation doesn't depend on runtime values, it can miss some cases in which the stride
 happens to be uniform:
 
-```julia
+```jldoctest
 julia> A = reshape(1:4*2, 4, 2)
 4×2 Base.ReshapedArray{Int64,2,UnitRange{Int64},Tuple{}}:
  1  5
@@ -171,7 +172,7 @@ A view constructed as `view(A, 2:2:4, :)` happens to have uniform stride, and th
 indexing indeed could be performed efficiently.  However, success in this case depends on the
 size of the array: if the first dimension instead were odd,
 
-```julia
+```jldoctest
 julia> A = reshape(1:5*2, 5, 2)
 5×2 Base.ReshapedArray{Int64,2,UnitRange{Int64},Tuple{}}:
  1   6
diff --git a/doc/src/devdocs/types.md b/doc/src/devdocs/types.md
index 2b86fb6becdcf4..3008a5990611e3 100644
--- a/doc/src/devdocs/types.md
+++ b/doc/src/devdocs/types.md
@@ -14,8 +14,8 @@ have.
 A *concrete* type `T` describes the set of values whose direct tag, as returned by the `typeof`
 function, is `T`. An *abstract* type describes some possibly-larger set of values.
 
-`Any` describes the entire universe of possible values. `Integer` is a subset of `Any` that includes
-`Int`, `Int8`, and other concrete types.
+`Any` describes the entire universe of possible values. [`Integer`](@ref) is a subset of
+`Any` that includes `Int`, [`Int8`](@ref), and other concrete types.
 Internally, Julia also makes heavy use of another type known as `Bottom`, which can also be written
 as `Union{}`. This corresponds to the empty set.
 
@@ -73,12 +73,12 @@ type, we could write `Array{T,2} where T`, which is the union of `Array{T,2}` fo
 Such a type is represented by a `UnionAll` object, which contains a variable (`T` in this example,
 of type `TypeVar`), and a wrapped type (`Array{T,2}` in this example).
 
-Consider the following methods::
+Consider the following methods:
 
 ```julia
 f1(A::Array) = 1
 f2(A::Array{Int}) = 2
-f3(A::Array{T}) where T<:Any = 3
+f3(A::Array{T}) where {T<:Any} = 3
 f4(A::Array{Any}) = 4
 ```
 
@@ -92,12 +92,12 @@ julia> dump(Array)
 UnionAll
   var: TypeVar
     name: Symbol T
-    lb: Core.BottomType Union{}
+    lb: Core.TypeofBottom Union{}
     ub: Any
   body: UnionAll
     var: TypeVar
       name: Symbol N
-      lb: Core.BottomType Union{}
+      lb: Core.TypeofBottom Union{}
       ub: Any
     body: Array{T,N} <: DenseArray{T,N}
 ```
@@ -169,7 +169,7 @@ Array{T,N}
 These can be distinguished by examining the `name` field of the type, which is an object of type
 `TypeName`:
 
-```julia
+```julia-repl
 julia> dump(Array{Int,1}.name)
 TypeName
   name: Symbol Array
@@ -178,12 +178,12 @@ TypeName
   wrapper: UnionAll
     var: TypeVar
       name: Symbol T
-      lb: Core.BottomType Union{}
+      lb: Core.TypeofBottom Union{}
       ub: Any
     body: UnionAll
       var: TypeVar
         name: Symbol N
-        lb: Core.BottomType Union{}
+        lb: Core.TypeofBottom Union{}
         ub: Any
       body: Array{T,N} <: DenseArray{T,N}
   cache: SimpleVector
@@ -207,7 +207,7 @@ TypeName
 In this case, the relevant field is `wrapper`, which holds a reference to the top-level type used
 to make new `Array` types.
 
-```julia
+```julia-repl
 julia> pointer_from_objref(Array)
 Ptr{Void} @0x00007fcc7de64850
 
@@ -229,7 +229,7 @@ field, it's helpful to pick a type that is less heavily used than Array. Let's f
 own type:
 
 ```jldoctest
-julia> type MyType{T,N} end
+julia> struct MyType{T,N} end
 
 julia> MyType{Int,2}
 MyType{Int64,2}
@@ -238,7 +238,7 @@ julia> MyType{Float32, 5}
 MyType{Float32,5}
 
 julia> MyType.body.body.name.cache
-svec(MyType{Float32,5}, MyType{Int64,2}, #undef, #undef, #undef, #undef, #undef, #undef)
+svec(MyType{Int64,2}, MyType{Float32,5}, #undef, #undef, #undef, #undef, #undef, #undef)
 ```
 
 (The cache is pre-allocated to have length 8, but only the first two entries are populated.) Consequently,
@@ -299,7 +299,7 @@ Union{}
 
 What is the "primary" tuple-type?
 
-```julia
+```julia-repl
 julia> pointer_from_objref(Tuple)
 Ptr{Void} @0x00007f5998a04370
 
@@ -315,7 +315,143 @@ Ptr{Void} @0x00007f5998a04370
 
 so `Tuple == Tuple{Vararg{Any}}` is indeed the primary type.
 
-## Introduction to the internal machinery: `jltypes.c`
+## Diagonal types
+
+Consider the type `Tuple{T,T} where T`.
+A method with this signature would look like:
+
+```julia
+f(x::T, y::T) where {T} = ...
+```
+
+According to the usual interpretation of a `UnionAll` type, this `T` ranges over all
+types, including `Any`, so this type should be equivalent to `Tuple{Any,Any}`.
+However, this interpretation causes some practical problems.
+
+First, a value of `T` needs to be available inside the method definition.
+For a call like `f(1, 1.0)`, it's not clear what `T` should be.
+It could be `Union{Int,Float64}`, or perhaps [`Real`](@ref).
+Intuitively, we expect the declaration `x::T` to mean `T === typeof(x)`.
+To make sure that invariant holds, we need `typeof(x) === typeof(y) === T` in this method.
+That implies the method should only be called for arguments of the exact same type.
+
+It turns out that being able to dispatch on whether two values have the same type
+is very useful (this is used by the promotion system for example), so we have
+multiple reasons to want a different interpretation of `Tuple{T,T} where T`.
+To make this work we add the following rule to subtyping: if a variable occurs
+more than once in covariant position, it is restricted to ranging over only concrete
+types.
+("Covariant position" means that only `Tuple` and `Union` types occur between an
+occurrence of a variable and the `UnionAll` type that introduces it.)
+Such variables are called "diagonal variables" or "concrete variables".
+
+So for example, `Tuple{T,T} where T` can be seen as
+`Union{Tuple{Int8,Int8}, Tuple{Int16,Int16}, ...}`, where `T` ranges over all
+concrete types.
+This gives rise to some interesting subtyping results.
+For example `Tuple{Real,Real}` is not a subtype of `Tuple{T,T} where T`, because
+it includes some types like `Tuple{Int8,Int16}` where the two elements have
+different types.
+`Tuple{Real,Real}` and `Tuple{T,T} where T` have the non-trivial intersection
+`Tuple{T,T} where T<:Real`.
+However, `Tuple{Real}` *is* a subtype of `Tuple{T} where T`, because in that case
+`T` occurs only once and so is not diagonal.
+
+Next consider a signature like the following:
+
+```julia
+f(a::Array{T}, x::T, y::T) where {T} = ...
+```
+
+In this case, `T` occurs in invariant position inside `Array{T}`.
+That means whatever type of array is passed unambiguously determines
+the value of `T` --- we say `T` has an *equality constraint* on it.
+Therefore in this case the diagonal rule is not really necessary, since
+the array determines `T` and we can then allow `x` and `y` to be of
+any subtypes of `T`.
+So variables that occur in invariant position are never considered diagonal.
+This choice of behavior is slightly controversial --- some feel this definition
+should be written as
+
+```julia
+f(a::Array{T}, x::S, y::S) where {T, S<:T} = ...
+```
+
+to clarify whether `x` and `y` need to have the same type.
+In this version of the signature they would, or we could introduce a third variable for
+the type of `y` if `x` and `y` can have different types.
+
+The next complication is the interaction of unions and diagonal variables, e.g.
+
+```julia
+f(x::Union{Void,T}, y::T) where {T} = ...
+```
+
+Consider what this declaration means.
+`y` has type `T`. `x` then can have either the same type `T`, or else be of type `Void`.
+So all of the following calls should match:
+
+```julia
+f(1, 1)
+f("", "")
+f(2.0, 2.0)
+f(nothing, 1)
+f(nothing, "")
+f(nothing, 2.0)
+```
+
+These examples are telling us something: when `x` is `nothing::Void`, there are no
+extra constraints on `y`.
+It is as if the method signature had `y::Any`.
+This means that whether a variable is diagonal is not a static property based on
+where it appears in a type.
+Rather, it depends on where a variable appears when the subtyping algorithm *uses* it.
+When `x` has type `Void`, we don't need to use the `T` in `Union{Void,T}`, so `T`
+does not "occur".
+Indeed, we have the following type equivalence:
+
+```julia
+(Tuple{Union{Void,T},T} where T) == Union{Tuple{Void,Any}, Tuple{T,T} where T}
+```
+
+## Subtyping diagonal variables
+
+The subtyping algorithm for diagonal variables has two components:
+(1) identifying variable occurrences, and (2) ensuring that diagonal
+variables range over concrete types only.
+
+The first task is accomplished by keeping counters `occurs_inv` and `occurs_cov`
+(in `src/subtype.c`) for each variable in the environment, tracking the number
+of invariant and covariant occurrences, respectively.
+A variable is diagonal when `occurs_inv == 0 && occurs_cov > 1`.
+
+The second task is accomplished by imposing a condition on a variable's lower bound.
+As the subtyping algorithm runs, it narrows the bounds of each variable
+(raising lower bounds and lowering upper bounds) to keep track of the
+range of variable values for which the subtype relation would hold.
+When we are done evaluating the body of a `UnionAll` type whose variable is diagonal,
+we look at the final values of the bounds.
+Since the variable must be concrete, a contradiction occurs if its lower bound
+could not be a subtype of a concrete type.
+For example, an abstract type like [`AbstractArray`](@ref) cannot be a subtype of a concrete
+type, but a concrete type like `Int` can be, and the empty type `Bottom` can be as well.
+If a lower bound fails this test the algorithm stops with the answer `false`.
+
+For example, in the problem `Tuple{Int,String} <: Tuple{T,T} where T`, we derive that
+this would be true if `T` were a supertype of `Union{Int,String}`.
+However, `Union{Int,String}` is an abstract type, so the relation does not hold.
+
+This concreteness test is done by the function `is_leaf_bound`.
+Note that this test is slightly different from `jl_is_leaf_type`, since it also returns
+`true` for `Bottom`.
+Currently this function is heuristic, and does not catch all possible concrete types.
+The difficulty is that whether a lower bound is concrete might depend on the values
+of other type variable bounds.
+For example, `Vector{T}` is equivalent to the concrete type `Vector{Int}` only if
+both the upper and lower bounds of `T` equal `Int`.
+We have not yet worked out a complete algorithm for this.
+
+## Introduction to the internal machinery
 
 Most operations for dealing with types are found in the files `jltypes.c` and `subtype.c`.
 A good way to start is to watch subtyping in action.
@@ -325,10 +461,10 @@ Build Julia with `make debug` and fire up Julia within a debugger.
 Because the subtyping code is used heavily in the REPL itself--and hence breakpoints in this
 code get triggered often--it will be easiest if you make the following definition:
 
-```julia
+```julia-repl
 julia> function mysubtype(a,b)
            ccall(:jl_breakpoint, Void, (Any,), nothing)
-           issubtype(a, b)
+           a <: b
        end
 ```
 
@@ -350,10 +486,10 @@ mysubtype(Tuple{Array{Int,2}, Int8}, Tuple{Array{T}, T} where T)
 ## Subtyping and method sorting
 
 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)` really means "is `a`
-at least as specific as `b`?" and not "is `a` strictly more specific than `b`?"
+tables (from most-to-least specific). Specificity is strict; if `a` is more specific than `b`,
+then `a` does not equal `b` and `b` is not more specific than `a`.
 
-If `a` is a subtype of `b`, then it is automatically considered more specific.
+If `a` is a strict subtype of `b`, then it is automatically considered more specific.
 From there, `type_morespecific` employs some less formal rules.
 For example, `subtype` is sensitive to the number of arguments, but `type_morespecific` may not be.
 In particular, `Tuple{Int,AbstractFloat}` is more specific than `Tuple{Integer}`, even though it is
diff --git a/doc/src/index.md b/doc/src/index.md
index a08246094d703b..d1028f46261ad8 100644
--- a/doc/src/index.md
+++ b/doc/src/index.md
@@ -28,6 +28,7 @@
   * [Running External Programs](@ref)
   * [Calling C and Fortran Code](@ref)
   * [Handling Operating System Variation](@ref)
+  * [Environment Variables](@ref)
   * [Interacting With Julia](@ref)
   * [Embedding Julia](@ref)
   * [Packages](@ref)
@@ -56,7 +57,7 @@
   * [Punctuation](@ref)
   * [Sorting and Related Functions](@ref)
   * [Package Manager Functions](@ref)
-  * [Dates and Time](@ref)
+  * [Dates and Time](@ref stdlib-dates)
   * [Iteration utilities](@ref)
   * [Unit Testing](@ref)
   * [C Interface](@ref)
@@ -71,12 +72,13 @@
   * [Reflection and introspection](@ref)
   * Documentation of Julia's Internals
       * [Initialization of the Julia runtime](@ref)
-      * [Eval of Julia code](@ref)
       * [Julia ASTs](@ref)
       * [More about types](@ref)
       * [Memory layout of Julia Objects](@ref)
-      * [Julia Functions](@ref)
+      * [Eval of Julia code](@ref)
       * [Calling Conventions](@ref)
+      * [High-level Overview of the Native-Code Generation Process](@ref)
+      * [Julia Functions](@ref)
       * [Base.Cartesian](@ref)
       * [Talking to the compiler (the `:meta` mechanism)](@ref)
       * [SubArrays](@ref)
@@ -86,6 +88,9 @@
       * [Bounds checking](@ref)
       * [Proper maintenance and care of multi-threading locks](@ref)
       * [Arrays with custom indices](@ref)
+      * [Base.LibGit2](@ref)
+      * [Module loading](@ref)
+      * [Inference](@ref)
   * Developing/debugging Julia's C code
       * [Reporting and analyzing crashes (segfaults)](@ref)
       * [gdb debugging tips](@ref)
diff --git a/doc/src/manual/arrays.md b/doc/src/manual/arrays.md
index 017a2252817c15..ecdcf33cb3855e 100644
--- a/doc/src/manual/arrays.md
+++ b/doc/src/manual/arrays.md
@@ -10,7 +10,7 @@ on implementing a custom array type.
 
 An array is a collection of objects stored in a multi-dimensional grid. In the most general case,
 an array may contain objects of type `Any`. For most computational purposes, arrays should contain
-objects of a more specific type, such as `Float64` or `Int32`.
+objects of a more specific type, such as [`Float64`](@ref) or [`Int32`](@ref).
 
 In general, unlike many other technical computing languages, Julia does not expect programs to
 be written in a vectorized style for performance. Julia's compiler uses type inference and generates
@@ -46,7 +46,7 @@ Many functions for constructing and initializing arrays are provided. In the fol
 such functions, calls with a `dims...` argument can either take a single tuple of dimension sizes
 or a series of dimension sizes passed as a variable number of arguments. Most of these functions
 also accept a first input `T`, which is the element type of the array. If the type `T` is
-omitted it will default to `Float64`.
+omitted it will default to [`Float64`](@ref).
 
 | Function                           | Description                                                                                                                                                                                                                                  |
 |:---------------------------------- |:-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
@@ -137,7 +137,7 @@ of the variable ranges `rx`, `ry`, etc. and each `F(x,y,...)` evaluation returns
 The following example computes a weighted average of the current element and its left and right
 neighbor along a 1-d grid. :
 
-```julia
+```julia-repl
 julia> x = rand(8)
 8-element Array{Float64,1}:
  0.843025
@@ -182,7 +182,7 @@ julia> sum(1/n^2 for n=1:1000)
 When writing a generator expression with multiple dimensions inside an argument list, parentheses
 are needed to separate the generator from subsequent arguments:
 
-```julia
+```julia-repl
 julia> map(tuple, 1/(i+j) for i=1:2, j=1:2, [1:4;])
 ERROR: syntax: invalid iteration specification
 ```
@@ -376,7 +376,7 @@ multidimensional index. When combined with other indexing forms and iterators
 that yield `CartesianIndex`es, however, this can lead directly to very elegant
 and efficient code. See [Iteration](@ref) below, and for some more advanced
 examples, see [this blog post on multidimensional algorithms and
-iteration](http://julialang.org/blog/2016/02/iteration).
+iteration](https://julialang.org/blog/2016/02/iteration).
 
 Arrays of `CartesianIndex{N}` are also supported. They represent a collection
 of scalar indices that each span `N` dimensions, enabling a form of indexing
@@ -510,44 +510,45 @@ iterate over any array type.
 
 ### Array traits
 
-If you write a custom `AbstractArray` type, you can specify that it has fast linear indexing using
+If you write a custom [`AbstractArray`](@ref) type, you can specify that it has fast linear indexing using
 
 ```julia
-Base.IndexStyle{T<:MyArray}(::Type{T}) = IndexLinear()
+Base.IndexStyle(::Type{<:MyArray}) = IndexLinear()
 ```
 
 This setting will cause `eachindex` iteration over a `MyArray` to use integers. If you don't
 specify this trait, the default value `IndexCartesian()` is used.
 
-### Vectorized Operators and Functions
+### Array and Vectorized Operators and Functions
 
-The following operators are supported for arrays. Also, *every* binary
-operator supports a [dot version](@ref man-dot-operators) that can be
-applied to arrays (and combinations of arrays and scalars) as a
-[fused broadcasting operation](@ref man-vectorized). (For comparison
-operations like `<`, *only* the `.<` version is applicable to arrays.)
+The following operators are supported for arrays:
 
-1. Unary arithmetic -- `-`, `+`, `!`
-2. Binary arithmetic -- `+`, `-`, `*`, `/`, `\`, `^`, `.^`, `div`, `mod`
+1. Unary arithmetic -- `-`, `+`
+2. Binary arithmetic -- `-`, `+`, `*`, `/`, `\`, `^`
 3. Comparison -- `==`, `!=`, `≈` ([`isapprox`](@ref)), `≉`
-4. Unary Boolean or bitwise -- `~`
-5. Binary Boolean or bitwise -- `&`, `|`, `⊻` ([`xor`](@ref))
 
-Some operators without dots operate elementwise anyway when one argument is a scalar:
-`*`, `+`, `-`, and the bitwise operators. The operators `/` and `\` operate elementwise when
-the denominator is a scalar.
+Most of the binary arithmetic operators listed above also operate elementwise
+when one argument is scalar: `-`, `+`, and `*` when either argument is scalar,
+and `/` and `\` when the denominator is scalar. For example, `[1, 2] + 3 == [4, 5]`
+and `[6, 4] / 2 == [3, 2]`.
 
-Note that comparisons such as `==` operate on whole arrays, giving a single boolean answer. Use
-dot operators like `.==` for elementwise comparisons.
+Additionally, to enable convenient vectorization of mathematical and other operations,
+Julia [provides the dot syntax](@ref man-vectorized) `f.(args...)`, e.g. `sin.(x)`
+or `min.(x,y)`, for elementwise operations over arrays or mixtures of arrays and
+scalars (a [Broadcasting](@ref) operation); these have the additional advantage of
+"fusing" into a single loop when combined with other dot calls, e.g. `sin.(cos.(x))`.
 
-To enable convenient vectorization of mathematical and other operations, Julia [provides the compact
-syntax](@ref man-vectorized) `f.(args...)`, e.g. `sin.(x)` or `min.(x,y)`, for elementwise operations over arrays or mixtures of arrays and scalars (a [Broadcasting](@ref) operation); these
-have the additional advantage of "fusing" into a single loop when combined with
-dot operators and other dot calls.
+Also, *every* binary operator supports a [dot version](@ref man-dot-operators)
+that can be applied to arrays (and combinations of arrays and scalars) in such
+[fused broadcasting operations](@ref man-vectorized), e.g. `z .== sin.(x .* y)`.
 
-Note that there is a difference between `max.(a,b)`, which `broadcast`s [`max()`](@ref) elementwise
-over `a` and `b`, and `maximum(a)`, which finds the largest value within `a`. The same relationship
-holds for `min.(a,b)` and `minimum(a)`.
+Note that comparisons such as `==` operate on whole arrays, giving a single boolean
+answer. Use dot operators like `.==` for elementwise comparisons. (For comparison
+operations like `<`, *only* the elementwise `.<` version is applicable to arrays.)
+
+Also notice the difference between `max.(a,b)`, which `broadcast`s [`max()`](@ref)
+elementwise over `a` and `b`, and `maximum(a)`, which finds the largest value within
+`a`. The same relationship holds for `min.(a,b)` and `minimum(a)`.
 
 ### Broadcasting
 
@@ -555,7 +556,7 @@ It is sometimes useful to perform element-by-element binary operations on arrays
 sizes, such as adding a vector to each column of a matrix. An inefficient way to do this would
 be to replicate the vector to the size of the matrix:
 
-```julia
+```julia-repl
 julia> a = rand(2,1); A = rand(2,3);
 
 julia> repmat(a,1,3)+A
@@ -568,7 +569,7 @@ This is wasteful when dimensions get large, so Julia offers [`broadcast()`](@ref
 singleton dimensions in array arguments to match the corresponding dimension in the other array
 without using extra memory, and applies the given function elementwise:
 
-```julia
+```julia-repl
 julia> broadcast(+, a, A)
 2×3 Array{Float64,2}:
  1.20813  1.82068  1.25387
@@ -616,8 +617,8 @@ julia> string.(1:3, ". ", ["First", "Second", "Third"])
 
 ### Implementation
 
-The base array type in Julia is the abstract type `AbstractArray{T,N}`. It is parametrized by
-the number of dimensions `N` and the element type `T`. `AbstractVector` and `AbstractMatrix` are
+The base array type in Julia is the abstract type [`AbstractArray{T,N}`](@ref). It is parametrized by
+the number of dimensions `N` and the element type `T`. [`AbstractVector`](@ref) and [`AbstractMatrix`](@ref) are
 aliases for the 1-d and 2-d cases. Operations on `AbstractArray` objects are defined using higher
 level operators and functions, in a way that is independent of the underlying storage. These operations
 generally work correctly as a fallback for any specific array implementation.
@@ -643,7 +644,7 @@ method [`Base.unsafe_convert(Ptr{T}, A)`](@ref) is provided, the memory layout s
 in the same way to these strides.
 
 The [`Array`](@ref) type is a specific instance of `DenseArray` where elements are stored in column-major
-order (see additional notes in [Performance Tips](@ref man-performance-tips)). `Vector` and `Matrix` are aliases for
+order (see additional notes in [Performance Tips](@ref man-performance-tips)). [`Vector`](@ref) and [`Matrix`](@ref) 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 [`Array`](@ref), so
 that the rest of the array library can be implemented in a generic manner.
@@ -665,7 +666,7 @@ The following example computes the QR decomposition of a small section of a larg
 creating any temporaries, and by calling the appropriate LAPACK function with the right leading
 dimension size and stride parameters.
 
-```julia
+```julia-repl
 julia> a = rand(10,10)
 10×10 Array{Float64,2}:
  0.561255   0.226678   0.203391  0.308912   …  0.750307  0.235023   0.217964
@@ -701,26 +702,27 @@ julia> r
   0.0       0.866567
 ```
 
-## Sparse Matrices
+## Sparse Vectors and Matrices
 
-[Sparse matrices](https://en.wikipedia.org/wiki/Sparse_matrix) are matrices that contain enough
-zeros that storing them in a special data structure leads to savings in space and execution time.
-Sparse matrices may be used when operations on the sparse representation of a matrix lead to considerable
-gains in either time or space when compared to performing the same operations on a dense matrix.
+Julia has built-in support for sparse vectors and
+[sparse matrices](https://en.wikipedia.org/wiki/Sparse_matrix). Sparse arrays are arrays
+that contain enough zeros that storing them in a special data structure leads to savings
+in space and execution time, compared to dense arrays.
 
-### Compressed Sparse Column (CSC) Storage
+### [Compressed Sparse Column (CSC) Sparse Matrix Storage](@id man-csc)
 
 In Julia, sparse matrices are stored in the [Compressed Sparse Column (CSC) format](https://en.wikipedia.org/wiki/Sparse_matrix#Compressed_sparse_column_.28CSC_or_CCS.29).
-Julia sparse matrices have the type `SparseMatrixCSC{Tv,Ti}`, where `Tv` is the type of the nonzero
-values, and `Ti` is the integer type for storing column pointers and row indices.:
+Julia sparse matrices have the type [`SparseMatrixCSC{Tv,Ti}`](@ref), where `Tv` is the
+type of the stored values, and `Ti` is the integer type for storing column pointers and
+row indices. The internal representation of `SparseMatrixCSC` is as follows:
 
 ```julia
-type SparseMatrixCSC{Tv,Ti<:Integer} <: AbstractSparseMatrix{Tv,Ti}
+struct SparseMatrixCSC{Tv,Ti<:Integer} <: AbstractSparseMatrix{Tv,Ti}
     m::Int                  # Number of rows
     n::Int                  # Number of columns
     colptr::Vector{Ti}      # Column i is in colptr[i]:(colptr[i+1]-1)
-    rowval::Vector{Ti}      # Row values of nonzeros
-    nzval::Vector{Tv}       # Nonzero values
+    rowval::Vector{Ti}      # Row indices of stored values
+    nzval::Vector{Tv}       # Stored values, typically nonzeros
 end
 ```
 
@@ -742,19 +744,50 @@ In some applications, it is convenient to store explicit zero values in a `Spars
 *are* accepted by functions in `Base` (but there is no guarantee that they will be preserved in
 mutating operations). Such explicitly stored zeros are treated as structural nonzeros by many
 routines. The [`nnz()`](@ref) function returns the number of elements explicitly stored in the
-sparse data structure, including structural nonzeros. In order to count the exact number of actual
-values that are nonzero, use [`countnz()`](@ref), which inspects every stored element of a sparse
-matrix.
+sparse data structure, including structural nonzeros. In order to count the exact number of
+numerical nonzeros, use [`countnz()`](@ref), which inspects every stored element of a sparse
+matrix. [`dropzeros()`](@ref), and the in-place [`dropzeros!()`](@ref), can be used to
+remove stored zeros from the sparse matrix.
+
+```jldoctest
+julia> A = sparse([1, 2, 3], [1, 2, 3], [0, 2, 0])
+3×3 SparseMatrixCSC{Int64,Int64} with 3 stored entries:
+  [1, 1]  =  0
+  [2, 2]  =  2
+  [3, 3]  =  0
+
+julia> dropzeros(A)
+3×3 SparseMatrixCSC{Int64,Int64} with 1 stored entry:
+  [2, 2]  =  2
+```
+
+### Sparse Vector Storage
+
+Sparse vectors are stored in a close analog to compressed sparse column format for sparse
+matrices. In Julia, sparse vectors have the type [`SparseVector{Tv,Ti}`](@ref) where `Tv`
+is the type of the stored values and `Ti` the integer type for the indices. The internal
+representation is as follows:
+
+```julia
+struct SparseVector{Tv,Ti<:Integer} <: AbstractSparseVector{Tv,Ti}
+    n::Int              # Length of the sparse vector
+    nzind::Vector{Ti}   # Indices of stored values
+    nzval::Vector{Tv}   # Stored values, typically nonzeros
+end
+```
+
+As for [`SparseMatrixCSC`](@ref), the `SparseVector` type can also contain explicitly
+stored zeros. (See [Sparse Matrix Storage](@ref man-csc).).
 
-### Sparse matrix constructors
+### Sparse Vector and Matrix Constructors
 
-The simplest way to create sparse matrices is to use functions equivalent to the [`zeros()`](@ref)
-and [`eye()`](@ref) functions that Julia provides for working with dense matrices. To produce
-sparse matrices instead, you can use the same names with an `sp` prefix:
+The simplest way to create sparse arrays is to use functions equivalent to the [`zeros()`](@ref)
+and [`eye()`](@ref) functions that Julia provides for working with dense arrays. To produce
+sparse arrays instead, you can use the same names with an `sp` prefix:
 
 ```jldoctest
-julia> spzeros(3,5)
-3×5 SparseMatrixCSC{Float64,Int64} with 0 stored entries
+julia> spzeros(3)
+3-element SparseVector{Float64,Int64} with 0 stored entries
 
 julia> speye(3,5)
 3×5 SparseMatrixCSC{Float64,Int64} with 3 stored entries:
@@ -763,11 +796,16 @@ julia> speye(3,5)
   [3, 3]  =  1.0
 ```
 
-The [`sparse()`](@ref) function is often a handy way to construct sparse matrices. It takes as
-its input a vector `I` of row indices, a vector `J` of column indices, and a vector `V` of nonzero
-values. `sparse(I,J,V)` constructs a sparse matrix such that `S[I[k], J[k]] = V[k]`.
+The [`sparse()`](@ref) function is often a handy way to construct sparse arrays. For
+example, to construct a sparse matrix we can input a vector `I` of row indices, a vector
+`J` of column indices, and a vector `V` of stored values (this is also known as the
+[COO (coordinate) format](https://en.wikipedia.org/wiki/Sparse_matrix#Coordinate_list_.28COO.29)).
+`sparse(I,J,V)` then constructs a sparse matrix such that `S[I[k], J[k]] = V[k]`. The
+equivalent sparse vector constructor is [`sparsevec`](@ref), which takes the (row) index
+vector `I` and the vector `V` with the stored values and constructs a sparse vector `R`
+such that `R[I[k]] = V[k]`.
 
-```jldoctest
+```jldoctest sparse_function
 julia> I = [1, 4, 3, 5]; J = [4, 7, 18, 9]; V = [1, 2, -5, 3];
 
 julia> S = sparse(I,J,V)
@@ -776,20 +814,38 @@ julia> S = sparse(I,J,V)
   [4 ,  7]  =  2
   [5 ,  9]  =  3
   [3 , 18]  =  -5
+
+julia> R = sparsevec(I,V)
+5-element SparseVector{Int64,Int64} with 4 stored entries:
+  [1]  =  1
+  [3]  =  -5
+  [4]  =  2
+  [5]  =  3
 ```
 
-The inverse of the [`sparse()`](@ref) function is [`findn()`](@ref), which retrieves the inputs
-used to create the sparse matrix.
+The inverse of the [`sparse()`](@ref) and [`sparsevec`](@ref) functions is
+[`findnz()`](@ref), which retrieves the inputs used to create the sparse array.
+There is also a [`findn`](@ref) function which only returns the index vectors.
+
+```jldoctest sparse_function
+julia> findnz(S)
+([1, 4, 5, 3], [4, 7, 9, 18], [1, 2, 3, -5])
 
-```julia
 julia> findn(S)
-([1,4,5,3],[4,7,9,18])
+([1, 4, 5, 3], [4, 7, 9, 18])
 
-julia> findnz(S)
-([1,4,5,3],[4,7,9,18],[1,2,3,-5])
+julia> findnz(R)
+([1, 3, 4, 5], [1, -5, 2, 3])
+
+julia> findn(R)
+4-element Array{Int64,1}:
+ 1
+ 3
+ 4
+ 5
 ```
 
-Another way to create sparse matrices is to convert a dense matrix into a sparse matrix using
+Another way to create a sparse array is to convert a dense array into a sparse array using
 the [`sparse()`](@ref) function:
 
 ```jldoctest
@@ -800,9 +856,14 @@ julia> sparse(eye(5))
   [3, 3]  =  1.0
   [4, 4]  =  1.0
   [5, 5]  =  1.0
+
+julia> sparse([1.0, 0.0, 1.0])
+3-element SparseVector{Float64,Int64} with 2 stored entries:
+  [1]  =  1.0
+  [3]  =  1.0
 ```
 
-You can go in the other direction using the [`full()`](@ref) function. The [`issparse()`](@ref)
+You can go in the other direction using the [`Array`](@ref) constructor. The [`issparse()`](@ref)
 function can be used to query if a matrix is sparse.
 
 ```jldoctest
@@ -827,8 +888,8 @@ differ from their dense counterparts in that the resulting matrix follows the sa
 as a given sparse matrix `S`, or that the resulting sparse matrix has density `d`, i.e. each matrix
 element has a probability `d` of being non-zero.
 
-Details can be found in the [Sparse Vectors and Matrices](@ref) section of the standard library
-reference.
+Details can be found in the [Sparse Vectors and Matrices](@ref stdlib-sparse-arrays)
+section of the standard library reference.
 
 | Sparse                     | Dense                  | Description                                                                                                                                                           |
 |:-------------------------- |:---------------------- |:--------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
diff --git a/doc/src/manual/calling-c-and-fortran-code.md b/doc/src/manual/calling-c-and-fortran-code.md
index bc771c7eac97ab..0a139d3af32093 100644
--- a/doc/src/manual/calling-c-and-fortran-code.md
+++ b/doc/src/manual/calling-c-and-fortran-code.md
@@ -55,7 +55,7 @@ to [`ccall`](@ref) are as follows:
 As a complete but simple example, the following calls the `clock` function from the standard C
 library:
 
-```julia
+```julia-repl
 julia> t = ccall((:clock, "libc"), Int32, ())
 2292761
 
@@ -66,11 +66,11 @@ julia> typeof(ans)
 Int32
 ```
 
-`clock` takes no arguments and returns an `Int32`. One common gotcha is that a 1-tuple must be
+`clock` takes no arguments and returns an [`Int32`](@ref). One common gotcha 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
+```julia-repl
 julia> path = ccall((:getenv, "libc"), Cstring, (Cstring,), "SHELL")
 Cstring(@0x00007fff5fbffc45)
 
@@ -95,7 +95,7 @@ uses in Julia functions that set up arguments and then check for errors in whate
 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,
-which is a simplified version of the actual definition from [env.jl](https://github.com/JuliaLang/julia/blob/master/base/env.jl):
+which is a simplified version of the actual definition from [`env.jl`](https://github.com/JuliaLang/julia/blob/master/base/env.jl):
 
 ```julia
 function getenv(var::AbstractString)
@@ -113,7 +113,7 @@ indicate errors in various different ways, including by returning -1, 0, 1 and o
 This wrapper throws an exception clearly indicating the problem if the caller tries to get a non-existent
 environment variable:
 
-```julia
+```julia-repl
 julia> getenv("SHELL")
 "/bin/bash"
 
@@ -149,20 +149,24 @@ throw a conversion error.
 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:
 
-```
+```c
 typedef returntype (*functiontype)(argumenttype,...)
 ```
 
 The function [`cfunction()`](@ref) generates the C-compatible function pointer for a call to a
-Julia library function. Arguments to [`cfunction()`](@ref) are as follows:
+Julia function. Arguments to [`cfunction()`](@ref) are as follows:
 
 1. A Julia Function
 2. Return type
 3. A tuple of input types
 
+Only platform-default C calling convention is supported. `cfunction`-generated pointers cannot
+be used in calls where WINAPI expects `stdcall` function on 32-bit windows, but can be used on WIN64
+(where `stdcall` is unified with C calling convention).
+
 A classic example is the standard C library `qsort` function, declared as:
 
-```
+```c
 void qsort(void *base, size_t nmemb, size_t size,
            int(*compare)(const void *a, const void *b));
 ```
@@ -176,7 +180,7 @@ calling `qsort` and passing arguments, we need to write a comparison function th
 arbitrary type T:
 
 ```jldoctest mycompare
-julia> function mycompare{T}(a::T, b::T)
+julia> function mycompare(a::T, b::T) where T
            return convert(Cint, a < b ? -1 : a > b ? +1 : 0)::Cint
        end
 mycompare (generic function with 1 method)
@@ -192,8 +196,8 @@ julia> const mycompare_c = cfunction(mycompare, Cint, (Ref{Cdouble}, Ref{Cdouble
 ```
 
 [`cfunction()`](@ref) 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.
+(`Cint`), and a tuple of the argument types, in this case to sort an array of `Cdouble`
+([`Float64`](@ref)) elements.
 
 The final call to `qsort` looks like this:
 
@@ -251,8 +255,9 @@ ccall((:foo, "libfoo"), Void, (Int32, Float64),
 ```
 
 [`Base.cconvert()`](@ref) normally just calls [`convert()`](@ref), 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.
+arbitrary new object more appropriate for passing to C.
+This should be used to perform all allocations of memory that will be accessed by the C code.
+For example, this is used to convert an `Array` of objects (e.g. strings) to an array of pointers.
 
 [`Base.unsafe_convert()`](@ref) 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
@@ -269,7 +274,7 @@ First, a review of some relevant Julia type terminology:
 | `T{A}`                        | `Vector{Int}`                               | "Type Parameter" :: A specialization of a type (typically used for dispatch or storage optimization).                                                                                                                                                                          |
 |                               |                                             | "TypeVar" :: The `T` in the type parameter declaration is referred to as a TypeVar (short for type variable).                                                                                                                                                                  |
 | `primitive type`              | `Int`, `Float64`                            | "Primitive Type" :: A type with no fields, but a size. It is stored and defined by-value.                                                                                                                                                                                           |
-| `struct`                      | `Pair{Int, Int}`                            | "Struct" :: A type with all fields defined to be constant. It is defined by-value. And may be stored with a type-tag.                                                                                                                                                       |
+| `struct`                      | `Pair{Int, Int}`                            | "Struct" :: A type with all fields defined to be constant. It is defined by-value, and may be stored with a type-tag.                                                                                                                                                       |
 |                               | `Complex128` (`isbits`)                     | "Is-Bits"   :: A `primitive type`, or a `struct` type where all fields are other `isbits` types. It is defined by-value, and is stored without a type-tag.                                                                                                                       |
 | `struct ...; end`             | `nothing`                                   | "Singleton" :: a Concrete Type or Struct with no fields.                                                                                                                                                                                                                        |
 | `(...)` or `tuple(...)`       | `(1, 2, 3)`                                 | "Tuple" :: an immutable data-structure similar to an anonymous struct type, or a constant array. Represented as either an array or a struct.                                                                                                                                |
@@ -298,7 +303,7 @@ same:
   * `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.
+    Any Julia type that is not a subtype of [`Signed`](@ref) is assumed to be unsigned.
 
 
   * `Ref{T}`
@@ -409,7 +414,7 @@ checks and is only meant to improve readability of the call.
     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:
 
-    ```
+    ```c
     int main(int argc, char **argv);
     ```
 
@@ -451,17 +456,17 @@ struct B {
 b_a_2 = B.A[2];
 
 in Julia:
-type B
+struct B
     A::NTuple{3, CInt}
 end
-b_a_2 = B.A[2]
+b_a_2 = B.A[3]  # note the difference in indexing (1-based in Julia, 0-based in C)
 ```
 
 Arrays of unknown size (C99-compliant variable length structs specified by `[]` or `[0]`) are not directly supported.
 Often the best way to deal with these is to deal with the byte offsets directly.
-For example, if a c-library declared a proper string type and returned a pointer to it:
+For example, if a C library declared a proper string type and returned a pointer to it:
 
-```
+```c
 struct String {
     int strlen;
     char data[];
@@ -470,7 +475,7 @@ struct String {
 
 In Julia, we can access the parts independently to make a copy of that string:
 
-```
+```julia
 str = from_c::Ptr{Void}
 len = unsafe_load(Ptr{Cint}(str))
 unsafe_string(str + Core.sizeof(Cint), len)
@@ -489,9 +494,9 @@ However, while the type layout must be known statically to compute the `ccall` A
 the static parameters of the function are considered to be part of this static environment.
 The static parameters of the function may be used as type parameters in the `ccall` signature,
 as long as they don't affect the layout of the type.
-For example, `f{T}(x::T) = ccall(:valid, Ptr{T}, (Ptr{T},), x)`
+For example, `f(x::T) where {T} = ccall(:valid, Ptr{T}, (Ptr{T},), x)`
 is valid, since `Ptr` is always a word-size primitive type.
-But, `g{T}(x::T) = ccall(:notvalid, T, (T,), x)`
+But, `g(x::T) where {T} = ccall(:notvalid, T, (T,), x)`
 is not valid, since the type layout of `T` is not known statically.
 
 ### SIMD Values
@@ -508,7 +513,7 @@ Julia type is a homogeneous tuple of `VecElement` that naturally maps to the SIM
 
 For instance, consider this C routine that uses AVX intrinsics:
 
-```
+```c
 #include <immintrin.h>
 
 __m256 dist( __m256 a, __m256 b ) {
@@ -677,14 +682,14 @@ arguments, as noted above). The following example computes a dot product using a
 
 ```julia
 function compute_dot(DX::Vector{Float64}, DY::Vector{Float64})
-  assert(length(DX) == length(DY))
-  n = length(DX)
-  incx = incy = 1
-  product = ccall((:ddot_, "libLAPACK"),
-                  Float64,
-                  (Ptr{Int32}, Ptr{Float64}, Ptr{Int32}, Ptr{Float64}, Ptr{Int32}),
-                  &n, DX, &incx, DY, &incy)
-  return product
+    @assert length(DX) == length(DY)
+    n = length(DX)
+    incx = incy = 1
+    product = ccall((:ddot_, "libLAPACK"),
+                    Float64,
+                    (Ptr{Int32}, Ptr{Float64}, Ptr{Int32}, Ptr{Float64}, Ptr{Int32}),
+                    &n, DX, &incx, DY, &incy)
+    return product
 end
 ```
 
@@ -702,7 +707,7 @@ converted to type `T`.
 Here is a simple example of a C wrapper that returns a `Ptr` type:
 
 ```julia
-type gsl_permutation
+mutable struct gsl_permutation
 end
 
 # The corresponding C signature is
@@ -847,21 +852,19 @@ case, the expression must evaluate to a `Ptr`, which will be used as the address
 function to call. This behavior occurs when the first [`ccall`](@ref) 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`, then cache it in a global variable for
-that session. For example:
+For example, you might look up the function via `dlsym`,
+then cache it in a shared reference for that session. For example:
 
 ```julia
 macro dlsym(func, lib)
-    z, zlocal = gensym(string(func)), gensym()
-    eval(current_module(), :(global $z = C_NULL))
-    z = esc(z)
+    z = Ref{Ptr{Void}}(C_NULL)
     quote
-        let $zlocal::Ptr{Void} = $z::Ptr{Void}
-            if $zlocal == C_NULL
-                $zlocal = dlsym($(esc(lib))::Ptr{Void}, $(esc(func)))
-                global $z = $zlocal
+        let zlocal = $z[]
+            if zlocal == C_NULL
+                zlocal = dlsym($(esc(lib))::Ptr{Void}, $(esc(func)))::Ptr{Void}
+                $z[] = $zlocal
             end
-            $zlocal
+            zlocal
         end
     end
 end
@@ -874,7 +877,7 @@ ccall(@dlsym("myfunc", mylibvar), Void, ())
 
 The second argument to [`ccall`](@ref) 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
+Other supported conventions are: `stdcall`, `cdecl`, `fastcall`, and `thiscall` (no-op on 64-bit Windows). For example (from
 `base/libc.jl`) we see the same `gethostname`[`ccall`](@ref) as above, but with the correct
 signature for Windows:
 
@@ -905,7 +908,7 @@ Global variables exported by native libraries can be accessed by name using the
 function. The arguments to [`cglobal()`](@ref) are a symbol specification identical to that used
 by [`ccall`](@ref), and a type describing the value stored in the variable:
 
-```julia
+```julia-repl
 julia> cglobal((:errno, :libc), Int32)
 Ptr{Int32} @0x00007f418d0816b8
 ```
@@ -965,7 +968,7 @@ wait(cond)
 ```
 
 The callback you pass to C should only execute a [`ccall`](@ref) to `:uv_async_send`, passing
-`cb.handle` as the argument, taking care to avoid any allocations or other interactions with the
+`cond.handle` as the argument, taking care to avoid any allocations or other interactions with the
 Julia runtime.
 
 Note that events may be coalesced, so multiple calls to `uv_async_send` may result in a single wakeup
@@ -973,8 +976,9 @@ notification to the condition.
 
 ## More About Callbacks
 
-For more details on how to pass callbacks to C libraries, see this [blog post](http://julialang.org/blog/2013/05/callback).
+For more details on how to pass callbacks to C libraries, see this [blog post](https://julialang.org/blog/2013/05/callback).
 
 ## C++
 
-For direct C++ interfacing, see the [Cxx](https://github.com/Keno/Cxx.jl) package. For tools to create C++ bindings, see the [CxxWrap](https://github.com/JuliaInterop/CxxWrap.jl) package.
+For direct C++ interfacing, see the [Cxx](https://github.com/Keno/Cxx.jl) package. For tools to create C++
+bindings, see the [CxxWrap](https://github.com/JuliaInterop/CxxWrap.jl) package.
diff --git a/doc/src/manual/complex-and-rational-numbers.md b/doc/src/manual/complex-and-rational-numbers.md
index 767428ee623e12..b76a128bb72ab8 100644
--- a/doc/src/manual/complex-and-rational-numbers.md
+++ b/doc/src/manual/complex-and-rational-numbers.md
@@ -140,10 +140,12 @@ when applied to `-1` versus `-1 + 0im` even though `-1 == -1 + 0im`:
 
 ```jldoctest
 julia> sqrt(-1)
-ERROR: DomainError:
-sqrt will only return a complex result if called with a complex argument. Try sqrt(complex(x)).
+ERROR: DomainError with -1.0:
+sqrt will only return a complex result if called with a complex argument. Try sqrt(Complex(x)).
 Stacktrace:
- [1] sqrt(::Int64) at ./math.jl:421
+ [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
+ [2] sqrt at ./math.jl:462 [inlined]
+ [3] sqrt(::Int64) at ./math.jl:472
 
 julia> sqrt(-1 + 0im)
 0.0 + 1.0im
@@ -283,8 +285,8 @@ Trying to construct a [`NaN`](@ref) rational value, however, is not:
 julia> 0//0
 ERROR: ArgumentError: invalid rational: zero(Int64)//zero(Int64)
 Stacktrace:
- [1] Rational{Int64}(::Int64, ::Int64) at ./rational.jl:8
- [2] //(::Int64, ::Int64) at ./rational.jl:35
+ [1] Rational{Int64}(::Int64, ::Int64) at ./rational.jl:13
+ [2] //(::Int64, ::Int64) at ./rational.jl:40
 ```
 
 As usual, the promotion system makes interactions with other numeric types effortless:
diff --git a/doc/src/manual/constructors.md b/doc/src/manual/constructors.md
index c4eaa53d6820b5..0d77cdcb563737 100644
--- a/doc/src/manual/constructors.md
+++ b/doc/src/manual/constructors.md
@@ -181,7 +181,7 @@ julia> mutable struct SelfReferential
 This type may appear innocuous enough, until one considers how to construct an instance of it.
 If `a` is an instance of `SelfReferential`, then a second instance can be created by the call:
 
-```julia
+```julia-repl
 julia> b = SelfReferential(a)
 ```
 
@@ -246,7 +246,7 @@ and does not reference other objects. The plain data types consist of primitive
 and immutable structs of other plain data types. The initial contents of a plain data type is
 undefined:
 
-```julia
+```julia-repl
 julia> struct HasPlain
            n::Int
            HasPlain() = new()
@@ -293,16 +293,15 @@ Point{Float64}(1.0, 2.5)
 julia> Point(1,2.5) ## implicit T ##
 ERROR: MethodError: no method matching Point(::Int64, ::Float64)
 Closest candidates are:
-  Point(::Any) where T at sysimg.jl:24
   Point(::T<:Real, !Matched::T<:Real) where T<:Real at none:2
 
 julia> Point{Int64}(1, 2) ## explicit T ##
 Point{Int64}(1, 2)
 
 julia> Point{Int64}(1.0,2.5) ## explicit T ##
-ERROR: InexactError()
+ERROR: InexactError: convert(Int64, 2.5)
 Stacktrace:
- [1] convert(::Type{Int64}, ::Float64) at ./float.jl:675
+ [1] convert at ./float.jl:681 [inlined]
  [2] Point{Int64}(::Float64, ::Float64) at ./none:2
 
 julia> Point{Float64}(1.0, 2.5) ## explicit T ##
@@ -314,10 +313,10 @@ Point{Float64}(1.0, 2.0)
 
 As you can see, for constructor calls with explicit type parameters, the arguments are converted
 to the implied field types: `Point{Int64}(1,2)` works, but `Point{Int64}(1.0,2.5)` raises an
-[`InexactError`](@ref) when converting `2.5` to `Int64`. When the type is implied by the arguments to
-the constructor call, as in `Point(1,2)`, then the types of the arguments must agree -- otherwise
-the `T` cannot be determined -- but any pair of real arguments with matching type may be given
-to the generic `Point` constructor.
+[`InexactError`](@ref) when converting `2.5` to [`Int64`](@ref). When the type is implied
+by the arguments to the constructor call, as in `Point(1,2)`, then the types of the
+arguments must agree -- otherwise the `T` cannot be determined -- but any pair of real
+arguments with matching type may be given to the generic `Point` constructor.
 
 What's really going on here is that `Point`, `Point{Float64}` and `Point{Int64}` are all different
 constructor functions. In fact, `Point{T}` is a distinct constructor function for each type `T`.
@@ -331,10 +330,10 @@ This automatic provision of constructors is equivalent to the following explicit
 julia> struct Point{T<:Real}
            x::T
            y::T
-           Point{T}(x,y) where T<:Real = new(x,y)
+           Point{T}(x,y) where {T<:Real} = new(x,y)
        end
 
-julia> Point(x::T, y::T) where T<:Real = Point{T}(x,y);
+julia> Point(x::T, y::T) where {T<:Real} = Point{T}(x,y);
 ```
 
 Notice that each definition looks like the form of constructor call that it handles.
@@ -374,7 +373,6 @@ However, other similar calls still don't work:
 julia> Point(1.5,2)
 ERROR: MethodError: no method matching Point(::Float64, ::Int64)
 Closest candidates are:
-  Point(::Any) where T at sysimg.jl:24
   Point(::T<:Real, !Matched::T<:Real) where T<:Real at none:1
 ```
 
@@ -409,7 +407,7 @@ defining sophisticated behavior is typically quite simple.
 ## Case Study: Rational
 
 Perhaps the best way to tie all these pieces together is to present a real world example of a
-parametric composite type and its constructor methods. To that end, here is the (slightly modified) beginning of [rational.jl](https://github.com/JuliaLang/julia/blob/master/base/rational.jl),
+parametric composite type and its constructor methods. To that end, here is the (slightly modified) beginning of [`rational.jl`](https://github.com/JuliaLang/julia/blob/master/base/rational.jl),
 which implements Julia's [Rational Numbers](@ref):
 
 ```jldoctest rational
@@ -427,7 +425,7 @@ julia> struct OurRational{T<:Integer} <: Real
            end
        end
 
-julia> OurRational(n::T, d::T) where T<:Integer = OurRational{T}(n,d)
+julia> OurRational(n::T, d::T) where {T<:Integer} = OurRational{T}(n,d)
 OurRational
 
 julia> OurRational(n::Integer, d::Integer) = OurRational(promote(n,d)...)
@@ -504,7 +502,7 @@ false
 
 Thus, although the [`//`](@ref) operator usually returns an instance of `OurRational`, if either
 of its arguments are complex integers, it will return an instance of `Complex{OurRational}` instead.
-The interested reader should consider perusing the rest of [rational.jl](https://github.com/JuliaLang/julia/blob/master/base/rational.jl):
+The interested 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 and Conversion](@id constructors-and-conversion)
@@ -553,10 +551,11 @@ SummedArray{Int32,Int32}(Int32[1, 2, 3], 6)
 ```
 
 The problem is that we want `S` to be a larger type than `T`, so that we can sum many elements
-with less information loss. 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 a constructor only for `SummedArray`,
-but inside the `type` definition block to suppress generation of default constructors:
+with less information loss. For example, when `T` is [`Int32`](@ref), we would like `S` to
+be [`Int64`](@ref). 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 a
+constructor only for `SummedArray`, but inside the `type` definition block to suppress
+generation of default constructors:
 
 ```jldoctest
 julia> struct SummedArray{T<:Number,S<:Number}
@@ -572,7 +571,6 @@ julia> SummedArray(Int32[1; 2; 3], Int32(6))
 ERROR: MethodError: no method matching SummedArray(::Array{Int32,1}, ::Int32)
 Closest candidates are:
   SummedArray(::Array{T,1}) where T at none:5
-  SummedArray(::Any) where T at sysimg.jl:24
 ```
 
 This constructor will be invoked by the syntax `SummedArray(a)`. The syntax `new{T,S}` allows
diff --git a/doc/src/manual/control-flow.md b/doc/src/manual/control-flow.md
index 336ed7da59d32b..4d751a836aceba 100644
--- a/doc/src/manual/control-flow.md
+++ b/doc/src/manual/control-flow.md
@@ -60,11 +60,11 @@ value of a boolean expression. Here is the anatomy of the `if`-`elseif`-`else` c
 
 ```julia
 if x < y
-  println("x is less than y")
+    println("x is less than y")
 elseif x > y
-  println("x is greater than y")
+    println("x is greater than y")
 else
-  println("x is equal to y")
+    println("x is equal to y")
 end
 ```
 
@@ -173,8 +173,8 @@ julia> if 1
 ERROR: TypeError: non-boolean (Int64) used in boolean context
 ```
 
-This error indicates that the conditional was of the wrong type: `Int64` rather than the required
-`Bool`.
+This error indicates that the conditional was of the wrong type: [`Int64`](@ref) rather
+than the required [`Bool`](@ref).
 
 The so-called "ternary operator", `?:`, is closely related to the `if`-`elseif`-`else` syntax,
 but is used where a conditional choice between single expression values is required, as opposed
@@ -187,7 +187,9 @@ a ? b : c
 
 The expression `a`, before the `?`, is a condition expression, and the ternary operation evaluates
 the expression `b`, before the `:`, if the condition `a` is `true` or the expression `c`, after
-the `:`, if it is `false`.
+the `:`, if it is `false`. Note that the spaces around `?` and `:` are mandatory: an expression
+like `a?b:c` is not a valid ternary expression (but a newline is acceptable after both the `?` and
+the `:`).
 
 The easiest way to understand this behavior is to see an example. In the previous example, the
 `println` call is shared by all three branches: the only real choice is which literal string to
@@ -568,10 +570,12 @@ real value:
 
 ```jldoctest
 julia> sqrt(-1)
-ERROR: DomainError:
-sqrt will only return a complex result if called with a complex argument. Try sqrt(complex(x)).
+ERROR: DomainError with -1.0:
+sqrt will only return a complex result if called with a complex argument. Try sqrt(Complex(x)).
 Stacktrace:
- [1] sqrt(::Int64) at ./math.jl:421
+ [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
+ [2] sqrt at ./math.jl:462 [inlined]
+ [3] sqrt(::Int64) at ./math.jl:472
 ```
 
 You may define your own exceptions in the following way:
@@ -587,14 +591,15 @@ for nonnegative numbers could be written to [`throw()`](@ref) a [`DomainError`](
 is negative:
 
 ```jldoctest
-julia> f(x) = x>=0 ? exp(-x) : throw(DomainError())
+julia> f(x) = x>=0 ? exp(-x) : throw(DomainError(x, "argument must be nonnegative"))
 f (generic function with 1 method)
 
 julia> f(1)
 0.36787944117144233
 
 julia> f(-1)
-ERROR: DomainError:
+ERROR: DomainError with -1:
+argument must be nonnegative
 Stacktrace:
  [1] f(::Int64) at ./none:1
 ```
@@ -603,7 +608,7 @@ Note that [`DomainError`](@ref) without parentheses is not an exception, but a t
 It needs to be called to obtain an `Exception` object:
 
 ```jldoctest
-julia> typeof(DomainError()) <: Exception
+julia> typeof(DomainError(nothing)) <: Exception
 true
 
 julia> typeof(DomainError) <: Exception
@@ -757,9 +762,13 @@ julia> sqrt_second(9)
 3.0
 
 julia> sqrt_second(-9)
-ERROR: DomainError:
+ERROR: DomainError with -9.0:
+sqrt will only return a complex result if called with a complex argument. Try sqrt(Complex(x)).
 Stacktrace:
- [1] sqrt_second(::Int64) at ./none:7
+ [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
+ [2] sqrt at ./math.jl:462 [inlined]
+ [3] sqrt at ./math.jl:472 [inlined]
+ [4] sqrt_second(::Int64) at ./none:7
 ```
 
 Note that the symbol following `catch` will always be interpreted as a name for the exception,
@@ -777,7 +786,7 @@ try bad() catch; x end
 
 try bad()
 catch
-  x
+    x
 end
 ```
 
diff --git a/doc/src/manual/conversion-and-promotion.md b/doc/src/manual/conversion-and-promotion.md
index c71024df14a2ba..3ce8b87830ef86 100644
--- a/doc/src/manual/conversion-and-promotion.md
+++ b/doc/src/manual/conversion-and-promotion.md
@@ -46,7 +46,7 @@ generally takes two arguments: the first is a type object while the second is a
 to that type; the returned value is the value converted to an instance of given type. The simplest
 way to understand this function is to see it in action:
 
-```julia
+```jldoctest
 julia> x = 12
 12
 
@@ -66,12 +66,12 @@ julia> typeof(ans)
 Float64
 
 julia> a = Any[1 2 3; 4 5 6]
-2x3 Array{Any,2}:
+2×3 Array{Any,2}:
  1  2  3
  4  5  6
 
 julia> convert(Array{Float64}, a)
-2x3 Array{Float64,2}:
+2×3 Array{Float64,2}:
  1.0  2.0  3.0
  4.0  5.0  6.0
 ```
@@ -79,12 +79,11 @@ julia> convert(Array{Float64}, a)
 Conversion isn't always possible, in which case a no method error is thrown indicating that `convert`
 doesn't know how to perform the requested conversion:
 
-```julia
+```jldoctest
 julia> convert(AbstractFloat, "foo")
 ERROR: MethodError: Cannot `convert` an object of type String 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.
- ...
 ```
 
 Some languages consider parsing strings as numbers or formatting numbers as strings to be conversions
@@ -102,16 +101,17 @@ is to it. For example, the method to convert a real number to a boolean is this:
 convert(::Type{Bool}, x::Real) = x==0 ? false : x==1 ? true : throw(InexactError())
 ```
 
-The type of the first argument of this method is a [singleton type](@ref man-singleton-types), `Type{Bool}`, the only
-instance of which is `Bool`. Thus, this method is only invoked when the first argument is the
-type value `Bool`. Notice the syntax used for the first argument: the argument name is omitted
-prior to the `::` symbol, and only the type is given.  This is the syntax in Julia for a function
-argument whose type is specified but whose value is never used in the function body.  In this
-example, since the type is a singleton, there would never be any reason to use its value within
-the body. When invoked, the method determines whether a numeric value is true or false as a boolean,
+The type of the first argument of this method is a [singleton type](@ref man-singleton-types),
+`Type{Bool}`, the only instance of which is [`Bool`](@ref). Thus, this method is only invoked
+when the first argument is the type value `Bool`. Notice the syntax used for the first
+argument: the argument name is omitted prior to the `::` symbol, and only the type is given.
+This is the syntax in Julia for a function argument whose type is specified but whose value
+is never used in the function body. In this example, since the type is a singleton, there
+would never be any reason to use its value within the body. When invoked, the method
+determines whether a numeric value is true or false as a boolean,
 by comparing it to one and zero:
 
-```julia
+```jldoctest
 julia> convert(Bool, 1)
 true
 
@@ -119,9 +119,9 @@ julia> convert(Bool, 0)
 false
 
 julia> convert(Bool, 1im)
-ERROR: InexactError()
- in convert(::Type{Bool}, ::Complex{Int64}) at ./complex.jl:23
- ...
+ERROR: InexactError: convert(Bool, 0 + 1im)
+Stacktrace:
+ [1] convert(::Type{Bool}, ::Complex{Int64}) at ./complex.jl:37
 
 julia> convert(Bool, 0im)
 false
@@ -132,25 +132,21 @@ especially for parametric types. The example above is meant to be pedagogical, a
 actual Julia behaviour. This is the actual implementation in Julia:
 
 ```julia
-convert{T<:Real}(::Type{T}, z::Complex) = (imag(z)==0 ? convert(T,real(z)) :
-                                           throw(InexactError()))
-
-julia> convert(Bool, 1im)
-ERROR: InexactError()
- in convert(::Type{Bool}, ::Complex{Int64}) at ./complex.jl:18
- ...
+convert(::Type{T}, z::Complex) where {T<:Real} =
+    (imag(z) == 0 ? convert(T, real(z)) : throw(InexactError()))
 ```
 
 ### [Case Study: Rational Conversions](@id man-rational-conversion)
 
-To continue our case study of Julia's `Rational` type, here are the conversions declared in [rational.jl](https://github.com/JuliaLang/julia/blob/master/base/rational.jl),
+To continue our case study of Julia's [`Rational`](@ref) type, here are the conversions declared in
+[`rational.jl`](https://github.com/JuliaLang/julia/blob/master/base/rational.jl),
 right after the declaration of the type and its constructors:
 
 ```julia
-convert{T<:Integer}(::Type{Rational{T}}, x::Rational) = Rational(convert(T,x.num),convert(T,x.den))
-convert{T<:Integer}(::Type{Rational{T}}, x::Integer) = Rational(convert(T,x), convert(T,1))
+convert(::Type{Rational{T}}, x::Rational) where {T<:Integer} = Rational(convert(T,x.num),convert(T,x.den))
+convert(::Type{Rational{T}}, x::Integer) where {T<:Integer} = Rational(convert(T,x), convert(T,1))
 
-function convert{T<:Integer}(::Type{Rational{T}}, x::AbstractFloat, tol::Real)
+function convert(::Type{Rational{T}}, x::AbstractFloat, tol::Real) where T<:Integer
     if isnan(x); return zero(T)//zero(T); end
     if isinf(x); return sign(x)//zero(T); end
     y = x
@@ -165,10 +161,10 @@ function convert{T<:Integer}(::Type{Rational{T}}, x::AbstractFloat, tol::Real)
         y = 1/y
     end
 end
-convert{T<:Integer}(rt::Type{Rational{T}}, x::AbstractFloat) = convert(rt,x,eps(x))
+convert(rt::Type{Rational{T}}, x::AbstractFloat) where {T<:Integer} = convert(rt,x,eps(x))
 
-convert{T<:AbstractFloat}(::Type{T}, x::Rational) = convert(T,x.num)/convert(T,x.den)
-convert{T<:Integer}(::Type{T}, x::Rational) = div(convert(T,x.num),convert(T,x.den))
+convert(::Type{T}, x::Rational) where {T<:AbstractFloat} = convert(T,x.num)/convert(T,x.den)
+convert(::Type{T}, x::Rational) where {T<:Integer} = div(convert(T,x.num),convert(T,x.den))
 ```
 
 The initial four convert methods provide conversions to rational types. The first method converts
@@ -193,32 +189,32 @@ since the values are converted to a "greater" type -- i.e. one which can represe
 input values in a single common type. It is important, however, not to confuse this with object-oriented
 (structural) super-typing, or Julia's notion of abstract super-types: promotion has nothing to
 do with the type hierarchy, and everything to do with converting between alternate representations.
-For instance, although every `Int32` value can also be represented as a `Float64` value, `Int32`
-is not a subtype of `Float64`.
+For instance, although every [`Int32`](@ref) value can also be represented as a [`Float64`](@ref) value,
+`Int32` is not a subtype of `Float64`.
 
 Promotion to a common "greater" type is performed in Julia by the `promote` function, which takes
 any number of arguments, and returns a tuple of the same number of values, converted to a common
 type, or throws an exception if promotion is not possible. The most common use case for promotion
 is to convert numeric arguments to a common type:
 
-```julia
+```jldoctest
 julia> promote(1, 2.5)
-(1.0,2.5)
+(1.0, 2.5)
 
 julia> promote(1, 2.5, 3)
-(1.0,2.5,3.0)
+(1.0, 2.5, 3.0)
 
 julia> promote(2, 3//4)
-(2//1,3//4)
+(2//1, 3//4)
 
 julia> promote(1, 2.5, 3, 3//4)
-(1.0,2.5,3.0,0.75)
+(1.0, 2.5, 3.0, 0.75)
 
 julia> promote(1.5, im)
-(1.5 + 0.0im,0.0 + 1.0im)
+(1.5 + 0.0im, 0.0 + 1.0im)
 
 julia> promote(1 + 2im, 3//4)
-(1//1 + 2//1*im,3//4 + 0//1*im)
+(1//1 + 2//1*im, 3//4 + 0//1*im)
 ```
 
 Floating-point values are promoted to the largest of the floating-point argument types. Integer
@@ -231,7 +227,7 @@ promoted to the appropriate kind of complex value.
 That is really all there is to using promotions. The rest is just a matter of clever application,
 the most typical "clever" application being the definition of catch-all methods for numeric operations
 like the arithmetic operators `+`, `-`, `*` and `/`. Here are some of the catch-all method definitions
-given in [promotion.jl](https://github.com/JuliaLang/julia/blob/master/base/promotion.jl):
+given in [`promotion.jl`](https://github.com/JuliaLang/julia/blob/master/base/promotion.jl):
 
 ```julia
 +(x::Number, y::Number) = +(promote(x,y)...)
@@ -245,11 +241,11 @@ multiplying and dividing pairs of numeric values, promote the values to a common
 try again. That's all there is to it: nowhere else does one ever need to worry about promotion
 to a common numeric type for arithmetic operations -- it just happens automatically. There are
 definitions of catch-all promotion methods for a number of other arithmetic and mathematical functions
-in [promotion.jl](https://github.com/JuliaLang/julia/blob/master/base/promotion.jl), but beyond
+in [`promotion.jl`](https://github.com/JuliaLang/julia/blob/master/base/promotion.jl), but beyond
 that, there are hardly any calls to `promote` required in the Julia standard library. The most
 common usages of `promote` occur in outer constructors methods, provided for convenience, to allow
 constructor calls with mixed types to delegate to an inner type with fields promoted to an appropriate
-common type. For example, recall that [rational.jl](https://github.com/JuliaLang/julia/blob/master/base/rational.jl)
+common type. For example, recall that [`rational.jl`](https://github.com/JuliaLang/julia/blob/master/base/rational.jl)
 provides the following outer constructor method:
 
 ```julia
@@ -258,7 +254,7 @@ Rational(n::Integer, d::Integer) = Rational(promote(n,d)...)
 
 This allows calls like the following to work:
 
-```julia
+```jldoctest
 julia> Rational(Int8(15),Int32(-5))
 -3//1
 
@@ -280,7 +276,7 @@ another type object, such that instances of the argument types will be promoted
 type. Thus, by defining the rule:
 
 ```julia
-promote_rule(::Type{Float64}, ::Type{Float32} ) = Float64
+promote_rule(::Type{Float64}, ::Type{Float32}) = Float64
 ```
 
 one declares that when 64-bit and 32-bit floating-point values are promoted together, they should
@@ -292,24 +288,25 @@ promote_rule(::Type{UInt8}, ::Type{Int8}) = Int
 promote_rule(::Type{BigInt}, ::Type{Int8}) = BigInt
 ```
 
-In the latter case, the result type is `BigInt` since `BigInt` is the only type large enough to
-hold integers for arbitrary-precision integer arithmetic.  Also note that one does not need to
-define both `promote_rule(::Type{A}, ::Type{B})` and `promote_rule(::Type{B}, ::Type{A})` -- the
-symmetry is implied by the way `promote_rule` is used in the promotion process.
+In the latter case, the result type is [`BigInt`](@ref) since `BigInt` is the only type
+large enough to hold integers for arbitrary-precision integer arithmetic. Also note that
+one does not need to define both `promote_rule(::Type{A}, ::Type{B})` and
+`promote_rule(::Type{B}, ::Type{A})` -- the symmetry is implied by the way `promote_rule`
+is used in the promotion process.
 
 The `promote_rule` function is used as a building block to define a second function called `promote_type`,
 which, given any number of type objects, returns the common type to which those values, as arguments
 to `promote` should be promoted. Thus, if one wants to know, in absence of actual values, what
 type a collection of values of certain types would promote to, one can use `promote_type`:
 
-```julia
+```jldoctest
 julia> promote_type(Int8, UInt16)
 Int64
 ```
 
 Internally, `promote_type` is used inside of `promote` to determine what type argument values
 should be converted to for promotion. It can, however, be useful in its own right. The curious
-reader can read the code in [promotion.jl](https://github.com/JuliaLang/julia/blob/master/base/promotion.jl),
+reader can read the code in [`promotion.jl`](https://github.com/JuliaLang/julia/blob/master/base/promotion.jl),
 which defines the complete promotion mechanism in about 35 lines.
 
 ### Case Study: Rational Promotions
@@ -318,9 +315,9 @@ Finally, we finish off our ongoing case study of Julia's rational number type, w
 sophisticated use of the promotion mechanism with the following promotion rules:
 
 ```julia
-promote_rule{T<:Integer,S<:Integer}(::Type{Rational{T}}, ::Type{S}) = Rational{promote_type(T,S)}
-promote_rule{T<:Integer,S<:Integer}(::Type{Rational{T}}, ::Type{Rational{S}}) = Rational{promote_type(T,S)}
-promote_rule{T<:Integer,S<:AbstractFloat}(::Type{Rational{T}}, ::Type{S}) = promote_type(T,S)
+promote_rule(::Type{Rational{T}}, ::Type{S}) where {T<:Integer,S<:Integer} = Rational{promote_type(T,S)}
+promote_rule(::Type{Rational{T}}, ::Type{Rational{S}}) where {T<:Integer,S<:Integer} = Rational{promote_type(T,S)}
+promote_rule(::Type{Rational{T}}, ::Type{S}) where {T<:Integer,S<:AbstractFloat} = promote_type(T,S)
 ```
 
 The first rule says that promoting a rational number with any other integer type promotes to a
diff --git a/doc/src/manual/dates.md b/doc/src/manual/dates.md
index dc72256fdf0ed2..ec2c5eb54ed1a2 100644
--- a/doc/src/manual/dates.md
+++ b/doc/src/manual/dates.md
@@ -12,13 +12,14 @@ For example, since the [`Date`](@ref) type only resolves to the precision of a s
 no hours, minutes, or seconds), normal considerations for time zones, daylight savings/summer
 time, and leap seconds are unnecessary and avoided.
 
-Both [`Date`](@ref) and [`DateTime`](@ref) are basically immutable `Int64` wrappers. The single
-`instant` field of either type is actually a `UTInstant{P}` type, which represents a continuously
-increasing machine timeline based on the UT second [^1]. The [`DateTime`](@ref) type is *timezone-unaware*
-(in Python parlance) or is analogous to a *LocalDateTime* in Java 8. Additional time zone functionality
+Both [`Date`](@ref) and [`DateTime`](@ref) are basically immutable [`Int64`](@ref) wrappers.
+The single `instant` field of either type is actually a `UTInstant{P}` type, which
+represents a continuously increasing machine timeline based on the UT second [^1]. The
+[`DateTime`](@ref) type is not aware of time zones (*naive*, in Python parlance),
+analogous to a *LocalDateTime* in Java 8. Additional time zone functionality
 can be added through the [TimeZones.jl package](https://github.com/JuliaTime/TimeZones.jl/), which
 compiles the [IANA time zone database](http://www.iana.org/time-zones). Both [`Date`](@ref) and
-[`DateTime`](@ref) are based on the ISO 8601 standard, which follows the proleptic Gregorian calendar.
+[`DateTime`](@ref) are based on the [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) standard, which follows the proleptic Gregorian calendar.
 One note is that the ISO 8601 standard is particular about BC/BCE dates. In general, the last
 day of the BC/BCE era, 1-12-31 BC/BCE, was followed by 1-1-1 AD/CE, thus no year zero exists.
 The ISO standard, however, states that 1 BC/BCE is year zero, so `0000-12-31` is the day before
@@ -119,12 +120,12 @@ julia> dt2 = Date("2015-01-02",df)
 You can also use the `dateformat""` string macro. This macro creates the `DateFormat` object once when the macro is expanded and uses the same `DateFormat` object even if a code snippet is run multiple times.
 
 ```jldoctest
-julia> for i=1:10^5
-           Date("2015-01-01",dateformat"y-m-d")
+julia> for i = 1:10^5
+           Date("2015-01-01", dateformat"y-m-d")
        end
 ```
 
-A full suite of parsing and formatting tests and examples is available in [tests/dates/io.jl](https://github.com/JuliaLang/julia/blob/master/test/dates/io.jl).
+A full suite of parsing and formatting tests and examples is available in [`tests/dates/io.jl`](https://github.com/JuliaLang/julia/blob/master/test/dates/io.jl).
 
 ## Durations/Comparisons
 
@@ -132,7 +133,7 @@ Finding the length of time between two [`Date`](@ref) or [`DateTime`](@ref) is s
 given their underlying representation as `UTInstant{Day}` and `UTInstant{Millisecond}`, respectively.
 The difference between [`Date`](@ref) is returned in the number of [`Day`](@ref), and [`DateTime`](@ref)
 in the number of [`Millisecond`](@ref). Similarly, comparing [`TimeType`](@ref) is a simple matter
-of comparing the underlying machine instants (which in turn compares the internal `Int64` values).
+of comparing the underlying machine instants (which in turn compares the internal [`Int64`](@ref) values).
 
 ```jldoctest
 julia> dt = Date(2012,2,29)
@@ -189,7 +190,7 @@ julia> dt - dt2
 
 ## Accessor Functions
 
-Because the [`Date`](@ref) and [`DateTime`](@ref) types are stored as single `Int64` values, date
+Because the [`Date`](@ref) and [`DateTime`](@ref) types are stored as single [`Int64`](@ref) values, date
 parts or fields can be retrieved through accessor functions. The lowercase accessors return the
 field as an integer:
 
@@ -453,7 +454,8 @@ julia> Dates.lastdayofquarter(Date(2014,7,16)) # Adjusts to the last day of the
 The next two higher-order methods, [`tonext()`](@ref), and [`toprev()`](@ref), generalize working
 with temporal expressions by taking a `DateFunction` as first argument, along with a starting
 [`TimeType`](@ref). A `DateFunction` is just a function, usually anonymous, that takes a single
-[`TimeType`](@ref) as input and returns a `Bool`, `true` indicating a satisfied adjustment criterion.
+[`TimeType`](@ref) as input and returns a [`Bool`](@ref), `true` indicating a satisfied
+adjustment criterion.
 For example:
 
 ```jldoctest
@@ -503,14 +505,14 @@ julia> filter(dr) do x
  2014-11-11
 ```
 
-Additional examples and tests are available in [test/dates/adjusters.jl](https://github.com/JuliaLang/julia/blob/master/test/dates/adjusters.jl).
+Additional examples and tests are available in [`test/dates/adjusters.jl`](https://github.com/JuliaLang/julia/blob/master/test/dates/adjusters.jl).
 
 ## Period Types
 
 Periods are a human view of discrete, sometimes irregular durations of time. Consider 1 month;
 it could represent, in days, a value of 28, 29, 30, or 31 depending on the year and month context.
 Or a year could represent 365 or 366 days in the case of a leap year. [`Period`](@ref) types are
-simple `Int64` wrappers and are constructed by wrapping any `Int64` convertible type, i.e. `Year(1)`
+simple [`Int64`](@ref) wrappers and are constructed by wrapping any `Int64` convertible type, i.e. `Year(1)`
 or `Month(3.0)`. Arithmetic between [`Period`](@ref) of the same type behave like integers, and
 limited `Period-Real` arithmetic is available.
 
@@ -559,7 +561,7 @@ julia> round(DateTime(2016, 8, 6, 20, 15), Dates.Day)
 Unlike the numeric [`round()`](@ref) method, which breaks ties toward the even number by default,
 the [`TimeType`](@ref)[`round()`](@ref) method uses the `RoundNearestTiesUp` rounding mode. (It's
 difficult to guess what breaking ties to nearest "even" [`TimeType`](@ref) would entail.) Further
-details on the available `RoundingMode` s can be found in the [API reference](http://docs.julialang.org/en/latest/stdlib/dates/).
+details on the available `RoundingMode` s can be found in the [API reference](@ref stdlib-dates).
 
 Rounding should generally behave as expected, but there are a few cases in which the expected
 behaviour is not obvious.
@@ -624,5 +626,5 @@ will result in the months field having an odd value. Because both months and yea
 an irregular number of days, whether rounding to an even number of days will result in an even
 value in the days field is uncertain.
 
-See the [API reference](http://docs.julialang.org/en/latest/stdlib/dates/) for additional information
+See the [API reference](@ref stdlib-dates) for additional information
 on methods exported from the `Dates` module.
diff --git a/doc/src/manual/documentation.md b/doc/src/manual/documentation.md
index 754bca4ca96998..a8176c4f1a59f0 100644
--- a/doc/src/manual/documentation.md
+++ b/doc/src/manual/documentation.md
@@ -27,7 +27,7 @@ Compute the Bar index between `x` and `y`. If `y` is missing, compute
 the Bar index between all pairs of columns of `x`.
 
 # Examples
-```julia
+```julia-repl
 julia> bar([1, 2], [1, 2])
 1
 ```
@@ -69,15 +69,15 @@ As in the example above, we recommend following some simple conventions when wri
    description of the function's purpose. An argument list would only repeat information already
    provided elsewhere. However, providing an argument list can be a good idea for complex functions
    with many arguments (in particular keyword arguments). In that case, insert it after the general
-   description of the function, under an `# Arguments` header, with one `*` bullet for each argument.
+   description of the function, under an `# Arguments` header, with one `-` bullet for each argument.
    The list should mention the types and default values (if any) of the arguments:
 
    ```julia
    """
    ...
    # Arguments
-   * `n::Integer`: the number of elements to compute.
-   * `dim::Integer=1`: the dimensions along which to perform the computation.
+   - `n::Integer`: the number of elements to compute.
+   - `dim::Integer=1`: the dimensions along which to perform the computation.
    ...
    """
    ```
@@ -107,10 +107,13 @@ As in the example above, we recommend following some simple conventions when wri
 
    !!! warning
        Calling `rand` and other RNG-related functions should be avoided in doctests since they will not
-       produce consistent outputs during different Julia sessions.
+       produce consistent outputs during different Julia sessions. If you would like to show some random
+       number generation related functionality, one option is to explicitly construct and seed your own
+       [`MersenneTwister`](@ref) (or other pseudorandom number generator) and pass it to the functions you are
+       doctesting.
 
-       Operating system word size (`Int32` or `Int64`) as well as path separator differences (`/` or
-       `\`) will also effect the reproducibility of some doctests.
+       Operating system word size ([`Int32`](@ref) or [`Int64`](@ref)) as well as path separator differences
+       (`/` or `\`) will also affect the reproducibility of some doctests.
 
        Note that whitespace in your doctest is significant! The doctest will fail if you misalign the
        output of pretty-printing an array, for example.
@@ -164,7 +167,7 @@ Documentation can be accessed at the REPL or in [IJulia](https://github.com/Juli
 by typing `?` followed by the name of a function or macro, and pressing `Enter`. For example,
 
 ```julia
-?fft
+?cos
 ?@time
 ?r""
 ```
@@ -267,7 +270,7 @@ instance, rather than just on the type itself. In these cases, you can add a met
 for your custom type that returns the documentation on a per-instance basis. For instance,
 
 ```julia
-type MyType
+struct MyType
     value::String
 end
 
diff --git a/doc/src/manual/embedding.md b/doc/src/manual/embedding.md
index 21a8f42ae04ea0..eadfdf96a80992 100644
--- a/doc/src/manual/embedding.md
+++ b/doc/src/manual/embedding.md
@@ -11,13 +11,14 @@ further language bridges (e.g. calling Julia from Python or C#).
 
 We start with a simple C program that initializes Julia and calls some Julia code:
 
-```
+```c
 #include <julia.h>
+JULIA_DEFINE_FAST_TLS() // only define this once, in an executable (not in a shared library) if you want fast code.
 
 int main(int argc, char *argv[])
 {
     /* required: setup the Julia context */
-    jl_init(NULL);
+    jl_init();
 
     /* run Julia commands */
     jl_eval_string("print(sqrt(2.0))");
@@ -48,9 +49,9 @@ The file `ui/repl.c` program is another simple example of how to set `jl_options
 linking against `libjulia`.
 
 The first thing that has to be done before calling any other Julia C function is to initialize
-Julia. This is done by calling `jl_init`, which takes as argument a C string (`const char*`) to
-the location where Julia is installed. When the argument is `NULL`, Julia tries to determine the
-install location automatically.
+Julia. This is done by calling `jl_init`, which tries to automatically determine Julia's install
+location. If you need to specify a custom location, or specify which system image to load,
+use `jl_init_with_image` instead.
 
 The second statement in the test program evaluates a Julia statement using a call to `jl_eval_string`.
 
@@ -63,8 +64,8 @@ example program calls this before returning from `main`.
 
     ```
     >>> julia=CDLL('./libjulia.dylib',RTLD_GLOBAL)
-    >>> julia.jl_init.argtypes = [c_char_p]
-    >>> julia.jl_init('.')
+    >>> julia.jl_init.argtypes = []
+    >>> julia.jl_init()
     250593296
     ```
 
@@ -75,7 +76,7 @@ example program calls this before returning from `main`.
 
 ### Using julia-config to automatically determine build parameters
 
-The script *julia-config.jl* was created to aid in determining what build parameters are required
+The script `julia-config.jl` was created to aid in determining what build parameters are required
 by a program that uses embedded Julia.  This script uses the build parameters and system configuration
 of the particular Julia distribution it is invoked by to export the necessary compiler flags for
 an embedding program to interact with that distribution.  This script is located in the Julia
@@ -83,25 +84,22 @@ shared data directory.
 
 #### Example
 
-Below is essentially the same as above with one small change; the argument to `jl_init` is now
-**JULIA_INIT_DIR** which is defined by *julia-config.jl*.:
-
-```
+```c
 #include <julia.h>
 
 int main(int argc, char *argv[])
 {
-   jl_init(JULIA_INIT_DIR);
-   (void)jl_eval_string("println(sqrt(2.0))");
-   jl_atexit_hook(0);
-   return 0;
+    jl_init();
+    (void)jl_eval_string("println(sqrt(2.0))");
+    jl_atexit_hook(0);
+    return 0;
 }
 ```
 
 #### On the command line
 
-A simple use of this script is from the command line.  Assuming that *julia-config.jl* is located
-in */usr/local/julia/share/julia*, it can be invoked on the command line directly and takes any
+A simple use of this script is from the command line.  Assuming that `julia-config.jl` is located
+in `/usr/local/julia/share/julia`, it can be invoked on the command line directly and takes any
 combination of 3 flags:
 
 ```
@@ -109,7 +107,7 @@ combination of 3 flags:
 Usage: julia-config [--cflags|--ldflags|--ldlibs]
 ```
 
-If the above example source is saved in the file *embed_example.c*, then the following command
+If the above example source is saved in the file `embed_example.c`, then the following command
 will compile it into a running program on Linux and Windows (MSYS2 environment), or if on OS/X,
 then substitute `clang` for `gcc`.:
 
@@ -121,8 +119,8 @@ then substitute `clang` for `gcc`.:
 
 But in general, embedding projects will be more complicated than the above, and so the following
 allows general makefile support as well – assuming GNU make because of the use of the **shell**
-macro expansions.  Additionally, though many times *julia-config.jl* may be found in the directory
-*/usr/local*, this is not necessarily the case, but Julia can be used to locate *julia-config.jl*
+macro expansions.  Additionally, though many times `julia-config.jl` may be found in the directory
+`/usr/local`, this is not necessarily the case, but Julia can be used to locate `julia-config.jl`
 too, and the makefile can be used to take advantage of that.  The above example is extended to
 use a Makefile:
 
@@ -136,33 +134,37 @@ LDLIBS   += $(shell $(JL_SHARE)/julia-config.jl --ldlibs)
 all: embed_example
 ```
 
-Now the build command is simply **make**.
+Now the build command is simply `make`.
 
 ## Converting Types
 
 Real applications will not just need to execute expressions, but also return their values to the
 host program. `jl_eval_string` returns a `jl_value_t*`, which is a pointer to a heap-allocated
-Julia object. Storing simple data types like `Float64` in this way is called `boxing`, and extracting
-the stored primitive data is called `unboxing`. Our improved sample program that calculates the
-square root of 2 in Julia and reads back the result in C looks as follows:
+Julia object. Storing simple data types like [`Float64`](@ref) in this way is called `boxing`,
+and extracting the stored primitive data is called `unboxing`. Our improved sample program that
+calculates the square root of 2 in Julia and reads back the result in C looks as follows:
 
-```
+```c
 jl_value_t *ret = jl_eval_string("sqrt(2.0)");
 
-if (jl_is_float64(ret)) {
+if (jl_typeis(ret, jl_float64_type)) {
     double ret_unboxed = jl_unbox_float64(ret);
     printf("sqrt(2.0) in C: %e \n", ret_unboxed);
 }
+else {
+    printf("ERROR: unexpected return type from sqrt(::Float64)\n");
+}
 ```
 
-In order to check whether `ret` is of a specific Julia type, we can use the `jl_is_...` functions.
-By typing `typeof(sqrt(2.0))` into the Julia shell we can see that the return type is `Float64`
-(`double` in C). To convert the boxed Julia value into a C double the `jl_unbox_float64` function
-is used in the above code snippet.
+In order to check whether `ret` is of a specific Julia type, we can use the
+`jl_isa`, `jl_typeis`, or `jl_is_...` functions.
+By typing `typeof(sqrt(2.0))` into the Julia shell we can see that the return type is
+[`Float64`](@ref) (`double` in C). To convert the boxed Julia value into a C double the
+`jl_unbox_float64` function is used in the above code snippet.
 
 Corresponding `jl_box_...` functions are used to convert the other way:
 
-```julia
+```c
 jl_value_t *a = jl_box_float64(3.0);
 jl_value_t *b = jl_box_float32(3.0f);
 jl_value_t *c = jl_box_int32(3);
@@ -176,7 +178,7 @@ While `jl_eval_string` allows C to obtain the result of a Julia expression, it d
 passing arguments computed in C to Julia. For this you will need to invoke Julia functions directly,
 using `jl_call`:
 
-```julia
+```c
 jl_function_t *func = jl_get_function(jl_base_module, "sqrt");
 jl_value_t *argument = jl_box_float64(2.0);
 jl_value_t *ret = jl_call1(func, argument);
@@ -210,7 +212,7 @@ safe to use pointers in between `jl_...` calls. But in order to make sure that v
 `jl_...` calls, we have to tell Julia that we hold a reference to a Julia value. This can be done
 using the `JL_GC_PUSH` macros:
 
-```
+```c
 jl_value_t *ret = jl_eval_string("sqrt(2.0)");
 JL_GC_PUSH1(&ret);
 // Do something with ret
@@ -225,7 +227,7 @@ Several Julia values can be pushed at once using the `JL_GC_PUSH2` , `JL_GC_PUSH
 macros. To push an array of Julia values one can use the  `JL_GC_PUSHARGS` macro, which can be
 used as follows:
 
-```
+```c
 jl_value_t **args;
 JL_GC_PUSHARGS(args, 2); // args can now hold 2 `jl_value_t*` objects
 args[0] = some_value;
@@ -238,7 +240,7 @@ The garbage collector also operates under the assumption that it is aware of eve
 object pointing to a young-generation one. Any time a pointer is updated breaking that assumption,
 it must be signaled to the collector with the `jl_gc_wb` (write barrier) function like so:
 
-```
+```c
 jl_value_t *parent = some_old_value, *child = some_young_value;
 ((some_specific_type*)parent)->field = child;
 jl_gc_wb(parent, child);
@@ -252,7 +254,7 @@ can sometimes invoke garbage collection.
 The write barrier is also necessary for arrays of pointers when updating their data directly.
 For example:
 
-```
+```c
 jl_array_t *some_array = ...; // e.g. a Vector{Any}
 void **data = (void**)jl_array_data(some_array);
 jl_value_t *some_value = ...;
@@ -285,7 +287,7 @@ struct that contains:
 To keep things simple, we start with a 1D array. Creating an array containing Float64 elements
 of length 10 is done by:
 
-```julia
+```c
 jl_value_t* array_type = jl_apply_array_type(jl_float64_type, 1);
 jl_array_t* x          = jl_alloc_array_1d(array_type, 10);
 ```
@@ -293,7 +295,7 @@ jl_array_t* x          = jl_alloc_array_1d(array_type, 10);
 Alternatively, if you have already allocated the array you can generate a thin wrapper around
 its data:
 
-```
+```c
 double *existingArray = (double*)malloc(sizeof(double)*10);
 jl_array_t *x = jl_ptr_to_array_1d(array_type, existingArray, 10, 0);
 ```
@@ -304,21 +306,21 @@ referenced.
 
 In order to access the data of x, we can use `jl_array_data`:
 
-```
+```c
 double *xData = (double*)jl_array_data(x);
 ```
 
 Now we can fill the array:
 
-```
+```c
 for(size_t i=0; i<jl_array_len(x); i++)
     xData[i] = i;
 ```
 
 Now let us call a Julia function that performs an in-place operation on `x`:
 
-```
-jl_function_t *func  = jl_get_function(jl_base_module, "reverse!");
+```c
+jl_function_t *func = jl_get_function(jl_base_module, "reverse!");
 jl_call1(func, (jl_value_t*)x);
 ```
 
@@ -329,7 +331,7 @@ By printing the array, one can verify that the elements of `x` are now reversed.
 If a Julia function returns an array, the return value of `jl_eval_string` and `jl_call` can be
 cast to a `jl_array_t*`:
 
-```
+```c
 jl_function_t *func  = jl_get_function(jl_base_module, "reverse");
 jl_array_t *y = (jl_array_t*)jl_call1(func, (jl_value_t*)x);
 ```
@@ -342,7 +344,7 @@ keep a reference to the array while it is in use.
 Julia's multidimensional arrays are stored in memory in column-major order. Here is some code
 that creates a 2D array and accesses its properties:
 
-```
+```c
 // Create 2D array of float64 type
 jl_value_t *array_type = jl_apply_array_type(jl_float64_type, 2);
 jl_array_t *x  = jl_alloc_array_2d(array_type, 10, 5);
@@ -368,14 +370,14 @@ in calling `jl_array_dim`) in order to read as idiomatic C code.
 
 Julia code can throw exceptions. For example, consider:
 
-```julia
+```c
 jl_eval_string("this_function_does_not_exist()");
 ```
 
 This call will appear to do nothing. However, it is possible to check whether an exception was
 thrown:
 
-```julia
+```c
 if (jl_exception_occurred())
     printf("%s \n", jl_typeof_str(jl_exception_occurred()));
 ```
@@ -389,22 +391,22 @@ was thrown, and then rethrows the exception in the host language.
 When writing Julia callable functions, it might be necessary to validate arguments and throw exceptions
 to indicate errors. A typical type check looks like:
 
-```
-if (!jl_is_float64(val)) {
+```c
+if (!jl_typeis(val, jl_float64_type)) {
     jl_type_error(function_name, (jl_value_t*)jl_float64_type, val);
 }
 ```
 
 General exceptions can be raised using the functions:
 
-```
+```c
 void jl_error(const char *str);
 void jl_errorf(const char *fmt, ...);
 ```
 
 `jl_error` takes a C string, and `jl_errorf` is called like `printf`:
 
-```julia
+```c
 jl_errorf("argument x = %d is too large", x);
 ```
 
diff --git a/doc/src/manual/environment-variables.md b/doc/src/manual/environment-variables.md
new file mode 100644
index 00000000000000..d2fe606136b762
--- /dev/null
+++ b/doc/src/manual/environment-variables.md
@@ -0,0 +1,327 @@
+# Environment Variables
+
+Julia may be configured with a number of environment variables, either in the
+usual way of the operating system, or in a portable way from within Julia.
+Suppose you want to set the environment variable `JULIA_EDITOR` to
+`vim`, then either type `ENV["JULIA_EDITOR"] = "vim"` for instance in the REPL
+to make this change on a case by case basis, or add the same to the user
+configuration file `.juliarc.jl` in the user's home directory to have
+a permanent effect. The current value of the same environment variable is
+determined by evaluating `ENV["JULIA_EDITOR"]`.
+
+The environment variables that Julia uses generally start with `JULIA`. If
+[`Base.versioninfo`](@ref) is called with `verbose` equal to `true`, then the
+output will list defined environment variables relevant for Julia, including
+those for which `JULIA` appears in the name.
+
+## File locations
+
+### `JULIA_HOME`
+
+The absolute path of the directory containing the Julia executable, which sets
+the global variable [`Base.JULIA_HOME`](@ref). If `$JULIA_HOME` is not set, then
+Julia determines the value `Base.JULIA_HOME` at run-time.
+
+The executable itself is one of
+
+```
+$JULIA_HOME/julia
+$JULIA_HOME/julia-debug
+```
+
+by default.
+
+The global variable `Base.DATAROOTDIR` determines a relative path from
+`Base.JULIA_HOME` to the data directory associated with Julia. Then the path
+
+```
+$JULIA_HOME/$DATAROOTDIR/julia/base
+```
+
+determines the directory in which Julia initially searches for source files (via
+`Base.find_source_file()`).
+
+Likewise, the global variable `Base.SYSCONFDIR` determines a relative path to the
+configuration file directory. Then Julia searches for a `juliarc.jl` file at
+
+```
+$JULIA_HOME/$SYSCONFDIR/julia/juliarc.jl
+$JULIA_HOME/../etc/julia/juliarc.jl
+```
+
+by default (via `Base.load_juliarc()`).
+
+For example, a Linux installation with a Julia executable located at
+`/bin/julia`, a `DATAROOTDIR` of `../share`, and a `SYSCONFDIR` of `../etc` will
+have `JULIA_HOME` set to `/bin`, a source-file search path of
+
+```
+/share/julia/base
+```
+
+and a global configuration search path of
+
+```
+/etc/julia/juliarc.jl
+```
+
+### `JULIA_LOAD_PATH`
+
+A separated list of absolute paths that are to be appended to the variable
+[`LOAD_PATH`](@ref). (In Unix-like systems, the path separator is `:`; in Windows
+systems, the path separator is `;`.) The `LOAD_PATH` variable is where
+[`Base.require`](@ref) and `Base.load_in_path()` look for code; it defaults to the absolute
+paths
+
+```
+$JULIA_HOME/../local/share/julia/site/v$(VERSION.major).$(VERSION.minor)
+$JULIA_HOME/../share/julia/site/v$(VERSION.major).$(VERSION.minor)
+```
+
+so that, e.g., version 0.6 of Julia on a Linux system with a Julia executable at
+`/bin/julia` will have a default `LOAD_PATH` of
+
+```
+/local/share/julia/site/v0.6
+/share/julia/site/v0.6
+```
+
+### `JULIA_PKGDIR`
+
+The path of the parent directory `Pkg.Dir._pkgroot()` for the version-specific
+Julia package repositories. If the path is relative, then it is taken with
+respect to the working directory. If `$JULIA_PKGDIR` is not set, then
+`Pkg.Dir._pkgroot()` defaults to
+
+```
+$HOME/.julia
+```
+
+Then the repository location [`Pkg.dir`](@ref) for a given Julia version is
+
+```
+$JULIA_PKGDIR/v$(VERSION.major).$(VERSION.minor)
+```
+
+For example, for a Linux user whose home directory is `/home/alice`, the directory
+containing the package repositories would by default be
+
+```
+/home/alice/.julia
+```
+
+and the package repository for version 0.6 of Julia would be
+
+```
+/home/alice/.julia/v0.6
+```
+
+### `JULIA_HISTORY`
+
+The absolute path `Base.REPL.find_hist_file()` of the REPL's history file. If
+`$JULIA_HISTORY` is not set, then `Base.REPL.find_hist_file()` defaults to
+
+```
+$HOME/.julia_history
+```
+
+### `JULIA_PKGRESOLVE_ACCURACY`
+
+A positive `Int` that determines how much time the max-sum subroutine
+`MaxSum.maxsum()` of the package dependency resolver [`Base.Pkg.resolve`](@ref)
+will devote to attempting satisfying constraints before giving up: this value is
+by default `1`, and larger values correspond to larger amounts of time.
+
+Suppose the value of `$JULIA_PKGRESOLVE_ACCURACY` is `n`. Then
+
+*   the number of pre-decimation iterations is `20*n`,
+*   the number of iterations between decimation steps is `10*n`, and
+*   at decimation steps, at most one in every `20*n` packages is decimated.
+
+## External applications
+
+### `JULIA_SHELL`
+
+The absolute path of the shell with which Julia should execute external commands
+(via `Base.repl_cmd()`). Defaults to the environment variable `$SHELL`, and
+falls back to `/bin/sh` if `$SHELL` is unset.
+
+!!! note
+
+    On Windows, this environment variable is ignored, and external commands are
+    executed directly.
+
+### `JULIA_EDITOR`
+
+The editor returned by `Base.editor()` and used in, e.g., [`Base.edit`](@ref),
+referring to the command of the preferred editor, for instance `vim`.
+
+`$JULIA_EDITOR` takes precedence over `$VISUAL`, which in turn takes precedence
+over `$EDITOR`. If none of these environment variables is set, then the editor
+is taken to be `open` on Windows and OS X, or `/etc/alternatives/editor` if it
+exists, or `emacs` otherwise.
+
+!!! note
+
+    `$JULIA_EDITOR` is *not* used in the determination of the editor for
+    [`Base.Pkg.edit`](@ref): this function checks `$VISUAL` and `$EDITOR` alone.
+
+## Parallelization
+
+### `JULIA_CPU_CORES`
+
+Overrides the global variable [`Base.Sys.CPU_CORES`](@ref), the number of
+logical CPU cores available.
+
+### `JULIA_WORKER_TIMEOUT`
+
+A [`Float64`](@ref) that sets the value of `Base.worker_timeout()` (default: `60.0`).
+This function gives the number of seconds a worker process will wait for
+a master process to establish a connection before dying.
+
+### `JULIA_NUM_THREADS`
+
+An unsigned 64-bit integer (`uint64_t`) that sets the maximum number of threads
+available to Julia. If `$JULIA_NUM_THREADS` exceeds the number of available
+physical CPU cores, then the number of threads is set to the number of cores. If
+`$JULIA_NUM_THREADS` is not positive or is not set, or if the number of CPU
+cores cannot be determined through system calls, then the number of threads is
+set to `1`.
+
+### `JULIA_THREAD_SLEEP_THRESHOLD`
+
+If set to a string that starts with the case-insensitive substring `"infinite"`,
+then spinning threads never sleep. Otherwise, `$JULIA_THREAD_SLEEP_THRESHOLD` is
+interpreted as an unsigned 64-bit integer (`uint64_t`) and gives, in
+nanoseconds, the amount of time after which spinning threads should sleep.
+
+### `JULIA_EXCLUSIVE`
+
+If set to anything besides `0`, then Julia's thread policy is consistent with
+running on a dedicated machine: the master thread is on proc 0, and threads are
+affinitized. Otherwise, Julia lets the operating system handle thread policy.
+
+## REPL formatting
+
+Environment variables that determine how REPL output should be formatted at the
+terminal. Generally, these variables should be set to [ANSI terminal escape
+sequences](http://ascii-table.com/ansi-escape-sequences.php). Julia provides
+a high-level interface with much of the same functionality: see the section on
+[Interacting With Julia](@ref).
+
+### `JULIA_ERROR_COLOR`
+
+The formatting `Base.error_color()` (default: light red, `"\033[91m"`) that
+errors should have at the terminal.
+
+### `JULIA_WARN_COLOR`
+
+The formatting `Base.warn_color()` (default: yellow, `"\033[93m"`) that warnings
+should have at the terminal.
+
+### `JULIA_INFO_COLOR`
+
+The formatting `Base.info_color()` (default: cyan, `"\033[36m"`) that info
+should have at the terminal.
+
+### `JULIA_INPUT_COLOR`
+
+The formatting `Base.input_color()` (default: normal, `"\033[0m"`) that input
+should have at the terminal.
+
+### `JULIA_ANSWER_COLOR`
+
+The formatting `Base.answer_color()` (default: normal, `"\033[0m"`) that output
+should have at the terminal.
+
+### `JULIA_STACKFRAME_LINEINFO_COLOR`
+
+The formatting `Base.stackframe_lineinfo_color()` (default: bold, `"\033[1m"`)
+that line info should have during a stack trace at the terminal.
+
+### `JULIA_STACKFRAME_FUNCTION_COLOR`
+
+The formatting `Base.stackframe_function_color()` (default: bold, `"\033[1m"`)
+that function calls should have during a stack trace at the terminal.
+
+## Debugging and profiling
+
+### `JULIA_GC_ALLOC_POOL`, `JULIA_GC_ALLOC_OTHER`, `JULIA_GC_ALLOC_PRINT`
+
+If set, these environment variables take strings that optionally start with the
+character `'r'`, followed by a string interpolation of a colon-separated list of
+three signed 64-bit integers (`int64_t`). This triple of integers `a:b:c`
+represents the arithmetic sequence `a`, `a + b`, `a + 2*b`, ... `c`.
+
+*   If it's the `n`th time that `jl_gc_pool_alloc()` has been called, and `n`
+    belongs to the arithmetic sequence represented by `$JULIA_GC_ALLOC_POOL`,
+    then garbage collection is forced.
+*   If it's the `n`th time that `maybe_collect()` has been called, and `n` belongs
+    to the arithmetic sequence represented by `$JULIA_GC_ALLOC_OTHER`, then garbage
+    collection is forced.
+*   If it's the `n`th time that `jl_gc_collect()` has been called, and `n` belongs
+    to the arithmetic sequence represented by `$JULIA_GC_ALLOC_PRINT`, then counts
+    for the number of calls to `jl_gc_pool_alloc()` and `maybe_collect()` are
+    printed.
+
+If the value of the environment variable begins with the character `'r'`, then
+the interval between garbage collection events is randomized.
+
+!!! note
+
+    These environment variables only have an effect if Julia was compiled with
+    garbage-collection debugging (that is, if `WITH_GC_DEBUG_ENV` is set to `1`
+    in the build configuration).
+
+### `JULIA_GC_NO_GENERATIONAL`
+
+If set to anything besides `0`, then the Julia garbage collector never performs
+"quick sweeps" of memory.
+
+!!! note
+
+    This environment variable only has an effect if Julia was compiled with
+    garbage-collection debugging (that is, if `WITH_GC_DEBUG_ENV` is set to `1`
+    in the build configuration).
+
+### `JULIA_GC_WAIT_FOR_DEBUGGER`
+
+If set to anything besides `0`, then the Julia garbage collector will wait for
+a debugger to attach instead of aborting whenever there's a critical error.
+
+!!! note
+
+    This environment variable only has an effect if Julia was compiled with
+    garbage-collection debugging (that is, if `WITH_GC_DEBUG_ENV` is set to `1`
+    in the build configuration).
+
+### `ENABLE_JITPROFILING`
+
+If set to anything besides `0`, then the compiler will create and register an
+event listener for just-in-time (JIT) profiling.
+
+!!! note
+
+    This environment variable only has an effect if Julia was compiled with JIT
+    profiling support, using either
+
+*   Intel's [VTune™ Amplifier](https://software.intel.com/en-us/intel-vtune-amplifier-xe)
+    (`USE_INTEL_JITEVENTS` set to `1` in the build configuration), or
+*   [OProfile](http://oprofile.sourceforge.net/news/) (`USE_OPROFILE_JITEVENTS` set to `1`
+    in the build configuration).
+
+### `JULIA_LLVM_ARGS`
+
+Arguments to be passed to the LLVM backend.
+
+!!! note
+
+    This environment variable has an effect only if Julia was compiled with
+    `JL_DEBUG_BUILD` set — in particular, the `julia-debug` executable is always
+    compiled with this build variable.
+
+### `JULIA_DEBUG_LOADING`
+
+If set, then Julia prints detailed information about the cache in the loading
+process of [`Base.require`](@ref).
+
diff --git a/doc/src/manual/faq.md b/doc/src/manual/faq.md
index 052cfe9d21b38e..cb0d7c9a396965 100644
--- a/doc/src/manual/faq.md
+++ b/doc/src/manual/faq.md
@@ -29,7 +29,7 @@ you can redefine types and constants.  You can't import the type names into `Mai
 to be able to redefine them there, but you can use the module name to resolve the scope.  In other
 words, while developing you might use a workflow something like this:
 
-```
+```julia
 include("mynewcode.jl")              # this defines a module MyModule
 obj1 = MyModule.ObjConstructor(a, b)
 obj2 = MyModule.somefunction(obj1)
@@ -43,8 +43,7 @@ obj3 = MyModule.someotherfunction(obj2, c)
 
 ## Functions
 
-### I passed an argument `x` to a function, modified it inside that function, but on the outside,
-the variable `x` is still unchanged. Why?
+### I passed an argument `x` to a function, modified it inside that function, but on the outside, the variable `x` is still unchanged. Why?
 
 Suppose you call a function like this:
 
@@ -108,10 +107,10 @@ have two options:
 
 1. Use `import`:
 
-   ```
+   ```julia
    import Foo
    function bar(...)
-       ... refer to Foo symbols via Foo.baz ...
+       # ... refer to Foo symbols via Foo.baz ...
    end
    ```
 
@@ -120,12 +119,12 @@ have two options:
    `Foo` symbols by their qualified names `Foo.bar` etc.
 2. Wrap your function in a module:
 
-   ```
+   ```julia
    module Bar
    export bar
    using Foo
    function bar(...)
-       ... refer to Foo.baz as simply baz ....
+       # ... refer to Foo.baz as simply baz ....
    end
    end
    using Bar
@@ -214,9 +213,10 @@ julia> function unstable(flag::Bool)
 unstable (generic function with 1 method)
 ```
 
-It returns either an `Int` or a `Float64` depending on the value of its argument. Since Julia
-can't predict the return type of this function at compile-time, any computation that uses it will
-have to guard against both types possibly occurring, making generation of fast machine code difficult.
+It returns either an `Int` or a [`Float64`](@ref) depending on the value of its argument.
+Since Julia can't predict the return type of this function at compile-time, any computation
+that uses it will have to guard against both types possibly occurring, making generation of
+fast machine code difficult.
 
 ### [Why does Julia give a `DomainError` for certain seemingly-sensible operations?](@id faq-domain-errors)
 
@@ -224,18 +224,21 @@ Certain operations make mathematical sense but result in errors:
 
 ```jldoctest
 julia> sqrt(-2.0)
-ERROR: DomainError:
-sqrt will only return a complex result if called with a complex argument. Try sqrt(complex(x)).
+ERROR: DomainError with -2.0:
+sqrt will only return a complex result if called with a complex argument. Try sqrt(Complex(x)).
 Stacktrace:
- [1] sqrt(::Float64) at ./math.jl:412
+ [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
+ [2] sqrt(::Float64) at ./math.jl:462
 
 julia> 2^-5
-ERROR: DomainError:
-Cannot raise an integer x to a negative power -n.
-Make 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.
+ERROR: DomainError with -5:
+Cannot raise an integer x to a negative power -5.
+Make x a float by adding a zero decimal (e.g., 2.0^-5 instead of 2^-5), or write 1/x^5, float(x)^-5, or (x//1)^-5
 Stacktrace:
- [1] power_by_squaring(::Int64, ::Int64) at ./intfuncs.jl:170
- [2] ^(::Int64, ::Type{Val{-5}}) at ./intfuncs.jl:201
+ [1] throw_domerr_powbysq(::Int64) at ./intfuncs.jl:163
+ [2] power_by_squaring at ./intfuncs.jl:178 [inlined]
+ [3] ^ at ./intfuncs.jl:202 [inlined]
+ [4] literal_pow(::Base.#^, ::Int64, ::Val{-5}) at ./intfuncs.jl:213
 ```
 
 This behavior is an inconvenient consequence of the requirement for type-stability.  In the case
@@ -281,7 +284,7 @@ ideal for a high-level programming language to expose this to the user. For nume
 efficiency and transparency are at a premium, however, the alternatives are worse.
 
 One alternative to consider would be to check each integer operation for overflow and promote
-results to bigger integer types such as `Int128` or [`BigInt`](@ref) in the case of overflow.
+results to bigger integer types such as [`Int128`](@ref) or [`BigInt`](@ref) in the case of overflow.
 Unfortunately, this introduces major overhead on every integer operation (think incrementing a
 loop counter) – it requires emitting code to perform run-time overflow checks after arithmetic
 instructions and branches to handle potential overflows. Worse still, this would cause every computation
@@ -391,7 +394,7 @@ arithmetic. For example, since Julia integers use normal machine integer arithme
 to aggressively optimize simple little functions like `f(k) = 5k-1`. The machine code for this
 function is just this:
 
-```julia
+```julia-repl
 julia> code_native(f, Tuple{Int})
   .text
 Filename: none
@@ -407,7 +410,7 @@ Source line: 1
 The actual body of the function is a single `leaq` instruction, which computes the integer multiply
 and add at once. This is even more beneficial when `f` gets inlined into another function:
 
-```julia
+```julia-repl
 julia> function g(k, n)
            for i = 1:n
                k = f(k)
@@ -442,7 +445,7 @@ L26:
 Since the call to `f` gets inlined, the loop body ends up being just a single `leaq` instruction.
 Next, consider what happens if we make the number of loop iterations fixed:
 
-```julia
+```julia-repl
 julia> function g(k)
            for i = 1:10
                k = f(k)
@@ -474,7 +477,7 @@ the loop, but it cannot algebraically reduce multiple operations into fewer equi
 
 The most reasonable alternative to having integer arithmetic silently overflow is to do checked
 arithmetic everywhere, raising errors when adds, subtracts, and multiplies overflow, producing
-values that are not value-correct. In this [blog post](http://danluu.com/integer-overflow), Dan
+values that are not value-correct. In this [blog post](http://danluu.com/integer-overflow/), Dan
 Luu analyzes this and finds that rather than the trivial cost that this approach should in theory
 have, it ends up having a substantial cost due to compilers (LLVM and GCC) not gracefully optimizing
 around the added overflow checks. If this improves in the future, we could consider defaulting
@@ -485,7 +488,7 @@ to checked integer arithmetic in Julia, but for now, we have to live with the po
 As the error states, an immediate cause of an `UndefVarError` on a remote node is that a binding
 by that name does not exist. Let us explore some of the possible causes.
 
-```julia
+```julia-repl
 julia> module Foo
            foo() = remotecall_fetch(x->x, 2, "Hello")
        end
@@ -502,7 +505,7 @@ an `UndefVarError` is thrown.
 Globals under modules other than `Main` are not serialized by value to the remote node. Only a reference is sent.
 Functions which create global bindings (except under `Main`) may cause an `UndefVarError` to be thrown later.
 
-```julia
+```julia-repl
 julia> @everywhere module Foo
            function foo()
                global gvar = "Hello"
@@ -522,7 +525,7 @@ a new global binding `gvar` on the local node, but this was not found on node 2
 Note that this does not apply to globals created under module `Main`. Globals under module `Main` are serialized
 and new bindings created under `Main` on the remote node.
 
-```julia
+```julia-repl
 julia> gvar_self = "Node1"
 "Node1"
 
@@ -540,7 +543,7 @@ julia> remotecall_fetch(whos, 2)
 This does not apply to `function` or `type` declarations. However, anonymous functions bound to global
 variables are serialized as can be seen below.
 
-```julia
+```julia-repl
 julia> bar() = 1
 bar (generic function with 1 method)
 
@@ -710,7 +713,7 @@ Finally, you may also consider building Julia from source for yourself. This opt
 for those individuals who are comfortable at the command line, or interested in learning. If this
 describes you, you may also be interested in reading our [guidelines for contributing](https://github.com/JuliaLang/julia/blob/master/CONTRIBUTING.md).
 
-Links to each of these download types can be found on the download page at [http://julialang.org/downloads/](http://julialang.org/downloads/).
+Links to each of these download types can be found on the download page at [https://julialang.org/downloads/](https://julialang.org/downloads/).
 Note that not all versions of Julia are available for all platforms.
 
 ### When are deprecated functions removed?
diff --git a/doc/src/manual/functions.md b/doc/src/manual/functions.md
index 1793befa0beedf..2f417d9466596d 100644
--- a/doc/src/manual/functions.md
+++ b/doc/src/manual/functions.md
@@ -169,9 +169,6 @@ A few special expressions correspond to calls to functions with non-obvious name
 | `A[i]`            | [`getindex()`](@ref)   |
 | `A[i]=x`          | [`setindex!()`](@ref)  |
 
-These functions are included in the `Base.Operators` module even though they do not have operator-like
-names.
-
 ## [Anonymous Functions](@id man-anonymous-functions)
 
 Functions in Julia are [first-class objects](https://en.wikipedia.org/wiki/First-class_citizen):
@@ -206,10 +203,10 @@ julia> map(round, [1.2,3.5,1.7])
  2.0
 ```
 
-This is fine if a named function effecting the transform one wants already exists to pass as the
-first argument to [`map()`](@ref). Often, however, a ready-to-use, named function does not exist.
-In these situations, the anonymous function construct allows easy creation of a single-use function
-object without needing a name:
+This is fine if a named function effecting the transform already exists to pass as the first argument
+to [`map()`](@ref). Often, however, a ready-to-use, named function does not exist. In these
+situations, the anonymous function construct allows easy creation of a single-use function object
+without needing a name:
 
 ```jldoctest
 julia> map(x -> x^2 + 2x - 1, [1,3,-1])
@@ -392,7 +389,7 @@ interprets a string as a number in some base. The `base` argument defaults to `1
 can be expressed concisely as:
 
 ```julia
-function parse(type, num, base=10)
+function parse(T, num, base=10)
     ###
 end
 ```
@@ -446,7 +443,7 @@ prior keyword arguments.
 The types of keyword arguments can be made explicit as follows:
 
 ```julia
-function f(;x::Int64=1)
+function f(;x::Int=1)
     ###
 end
 ```
@@ -475,9 +472,8 @@ this example, `width` is certain to have the value `2`.
 
 ## Evaluation Scope of Default Values
 
-Optional and keyword arguments differ slightly in how their default values are evaluated. When
-optional argument default expressions are evaluated, only *previous* arguments are in scope. In
-contrast, *all* the arguments are in scope when keyword arguments default expressions are evaluated.
+When optional and keyword argument default expressions are evaluated, only *previous* arguments are in
+scope.
 For example, given this definition:
 
 ```julia
@@ -486,11 +482,7 @@ function f(x, a=b, b=1)
 end
 ```
 
-the `b` in `a=b` refers to a `b` in an outer scope, not the subsequent argument `b`. However,
-if `a` and `b` were keyword arguments instead, then both would be created in the same scope and
-the `b` in `a=b` would refer to the subsequent argument `b` (shadowing any `b` in an outer scope),
-which would result in an undefined variable error (since the default expressions are evaluated
-left-to-right, and `b` has not been assigned yet).
+the `b` in `a=b` refers to a `b` in an outer scope, not the subsequent argument `b`.
 
 ## Do-Block Syntax for Function Arguments
 
@@ -635,7 +627,7 @@ loops cannot be merged because of the intervening `sort` function.
 
 Finally, the maximum efficiency is typically achieved when the output array of a vectorized operation
 is *pre-allocated*, so that repeated calls do not allocate new arrays over and over again for
-the results ([Pre-allocating outputs](@ref):). A convenient syntax for this is `X .= ...`, which
+the results (see [Pre-allocating outputs](@ref)). A convenient syntax for this is `X .= ...`, which
 is equivalent to `broadcast!(identity, X, ...)` except that, as above, the `broadcast!` loop is
 fused with any nested "dot" calls. For example, `X .= sin.(Y)` is equivalent to `broadcast!(sin, X, Y)`,
 overwriting `X` with `sin.(Y)` in-place. If the left-hand side is an array-indexing expression,
diff --git a/doc/src/manual/getting-started.md b/doc/src/manual/getting-started.md
index 94979fbda50cb3..d41d6b1bdfa03c 100644
--- a/doc/src/manual/getting-started.md
+++ b/doc/src/manual/getting-started.md
@@ -1,7 +1,7 @@
 # Getting Started
 
 Julia installation is straightforward, whether using precompiled binaries or compiling from source.
-Download and install Julia by following the instructions at [http://julialang.org/downloads/](http://julialang.org/downloads/).
+Download and install Julia by following the instructions at [https://julialang.org/downloads/](https://julialang.org/downloads/).
 
 The easiest way to learn and experiment with Julia is by starting an interactive session (also
 known as a read-eval-print loop or "repl") by double-clicking the Julia executable or running
@@ -11,7 +11,7 @@ known as a read-eval-print loop or "repl") by double-clicking the Julia executab
 $ julia
                _
    _       _ _(_)_     |  A fresh approach to technical computing
-  (_)     | (_) (_)    |  Documentation: http://docs.julialang.org
+  (_)     | (_) (_)    |  Documentation: https://docs.julialang.org
    _ _   _| |_  __ _   |  Type "?help" for help.
   | | | | | | |/ _` |  |
   | | |_| | | | (_| |  |  Version 0.5.0-dev+2440 (2016-02-01 02:22 UTC)
@@ -151,6 +151,5 @@ with Julia:
   * [Hands-on Julia](https://github.com/dpsanders/hands_on_julia)
   * [Tutorial for Homer Reid's numerical analysis class](http://homerreid.dyndns.org/teaching/18.330/JuliaProgramming.shtml)
   * [An introductory presentation](https://raw.githubusercontent.com/ViralBShah/julia-presentations/master/Fifth-Elephant-2013/Fifth-Elephant-2013.pdf)
-  * [Videos from the Julia tutorial at MIT](http://julialang.org/blog/2013/03/julia-tutorial-MIT)
-  * [Forio Julia Tutorials](http://forio.com/about/labs/julia-studio/tutorials/)
+  * [Videos from the Julia tutorial at MIT](https://julialang.org/blog/2013/03/julia-tutorial-MIT)
   * [YouTube videos from the JuliaCons](https://www.youtube.com/user/JuliaLanguage/playlists)
diff --git a/doc/src/manual/handling-operating-system-variation.md b/doc/src/manual/handling-operating-system-variation.md
index 5312afe7bc9558..46ee1ae3a6f708 100644
--- a/doc/src/manual/handling-operating-system-variation.md
+++ b/doc/src/manual/handling-operating-system-variation.md
@@ -2,38 +2,38 @@
 
 When dealing with platform libraries, it is often necessary to provide special cases for various
 platforms. The variable `Sys.KERNEL` can be used to write these special cases. There are several
-functions intended to make this easier: `is_unix`, `is_linux`, `is_apple`, `is_bsd`, and `is_windows`.
-These may be used as follows:
+functions in the `Sys` module intended to make this easier: `isunix`, `islinux`, `isapple`,
+`isbsd`, and `iswindows`. These may be used as follows:
 
 ```julia
-if is_windows()
+if Sys.iswindows()
     some_complicated_thing(a)
 end
 ```
 
-Note that `is_linux` and `is_apple` are mutually exclusive subsets of `is_unix`. Additionally,
+Note that `islinux` and `isapple` are mutually exclusive subsets of `isunix`. Additionally,
 there is a macro `@static` which makes it possible to use these functions to conditionally hide
 invalid code, as demonstrated in the following examples.
 
 Simple blocks:
 
 ```
-ccall( (@static is_windows() ? :_fopen : :fopen), ...)
+ccall((@static Sys.iswindows() ? :_fopen : :fopen), ...)
 ```
 
 Complex blocks:
 
 ```julia
-@static if is_linux()
+@static if Sys.islinux()
     some_complicated_thing(a)
 else
     some_different_thing(a)
 end
 ```
 
-When chaining conditionals (including if/elseif/end), the `@static` must be repeated for each
-level (parentheses optional, but recommended for readability):
+When chaining conditionals (including `if`/`elseif`/`end`), the `@static` must be repeated for
+each level (parentheses optional, but recommended for readability):
 
 ```julia
-@static is_windows() ? :a : (@static is_apple() ? :b : :c)
+@static Sys.iswindows() ? :a : (@static Sys.isapple() ? :b : :c)
 ```
diff --git a/doc/src/manual/index.md b/doc/src/manual/index.md
index c516ad473e0e8a..37a8b0b67862e7 100644
--- a/doc/src/manual/index.md
+++ b/doc/src/manual/index.md
@@ -26,6 +26,7 @@
   * [Running External Programs](@ref)
   * [Calling C and Fortran Code](@ref)
   * [Handling Operating System Variation](@ref)
+  * [Environment Variables](@ref)
   * [Interacting With Julia](@ref)
   * [Embedding Julia](@ref)
   * [Packages](@ref)
diff --git a/doc/src/manual/integers-and-floating-point-numbers.md b/doc/src/manual/integers-and-floating-point-numbers.md
index 6d7d8aaeb96dad..1b819938cc625e 100644
--- a/doc/src/manual/integers-and-floating-point-numbers.md
+++ b/doc/src/manual/integers-and-floating-point-numbers.md
@@ -18,25 +18,25 @@ The following are Julia's primitive numeric types:
 
   * **Integer types:**
 
-| Type      | Signed? | Number of bits | Smallest value | Largest value |
-|:--------- |:------- |:-------------- |:-------------- |:------------- |
-| `Int8`    | ✓       | 8              | -2^7           | 2^7 - 1       |
-| `UInt8`   |         | 8              | 0              | 2^8 - 1       |
-| `Int16`   | ✓       | 16             | -2^15          | 2^15 - 1      |
-| `UInt16`  |         | 16             | 0              | 2^16 - 1      |
-| `Int32`   | ✓       | 32             | -2^31          | 2^31 - 1      |
-| `UInt32`  |         | 32             | 0              | 2^32 - 1      |
-| `Int64`   | ✓       | 64             | -2^63          | 2^63 - 1      |
-| `UInt64`  |         | 64             | 0              | 2^64 - 1      |
-| `Int128`  | ✓       | 128            | -2^127         | 2^127 - 1     |
-| `UInt128` |         | 128            | 0              | 2^128 - 1     |
-| `Bool`    | N/A     | 8              | `false` (0)    | `true` (1)    |
+| Type              | Signed? | Number of bits | Smallest value | Largest value |
+|:----------------- |:------- |:-------------- |:-------------- |:------------- |
+| [`Int8`](@ref)    | ✓       | 8              | -2^7           | 2^7 - 1       |
+| [`UInt8`](@ref)   |         | 8              | 0              | 2^8 - 1       |
+| [`Int16`](@ref)   | ✓       | 16             | -2^15          | 2^15 - 1      |
+| [`UInt16`](@ref)  |         | 16             | 0              | 2^16 - 1      |
+| [`Int32`](@ref)   | ✓       | 32             | -2^31          | 2^31 - 1      |
+| [`UInt32`](@ref)  |         | 32             | 0              | 2^32 - 1      |
+| [`Int64`](@ref)   | ✓       | 64             | -2^63          | 2^63 - 1      |
+| [`UInt64`](@ref)  |         | 64             | 0              | 2^64 - 1      |
+| [`Int128`](@ref)  | ✓       | 128            | -2^127         | 2^127 - 1     |
+| [`UInt128`](@ref) |         | 128            | 0              | 2^128 - 1     |
+| [`Bool`](@ref)    | N/A     | 8              | `false` (0)    | `true` (1)    |
 
   * **Floating-point types:**
 
 | Type              | Precision                                                                      | Number of bits |
 |:----------------- |:------------------------------------------------------------------------------ |:-------------- |
-| `Float16`         | [half](https://en.wikipedia.org/wiki/Half-precision_floating-point_format)     | 16             |
+| [`Float16`](@ref) | [half](https://en.wikipedia.org/wiki/Half-precision_floating-point_format)     | 16             |
 | [`Float32`](@ref) | [single](https://en.wikipedia.org/wiki/Single_precision_floating-point_format) | 32             |
 | [`Float64`](@ref) | [double](https://en.wikipedia.org/wiki/Double_precision_floating-point_format) | 64             |
 
@@ -59,7 +59,7 @@ julia> 1234
 The default type for an integer literal depends on whether the target system has a 32-bit architecture
 or a 64-bit architecture:
 
-```julia
+```julia-repl
 # 32-bit system:
 julia> typeof(1)
 Int32
@@ -72,7 +72,7 @@ Int64
 The Julia internal variable [`Sys.WORD_SIZE`](@ref) indicates whether the target system is 32-bit
 or 64-bit:
 
-```julia
+```julia-repl
 # 32-bit system:
 julia> Sys.WORD_SIZE
 32
@@ -85,7 +85,7 @@ julia> Sys.WORD_SIZE
 Julia also defines the types `Int` and `UInt`, which are aliases for the system's signed and unsigned
 native integer types respectively:
 
-```julia
+```julia-repl
 # 32-bit system:
 julia> Int
 Int32
@@ -206,7 +206,7 @@ true
 Thus, arithmetic with Julia integers is actually a form of [modular arithmetic](https://en.wikipedia.org/wiki/Modular_arithmetic).
 This reflects the characteristics of the underlying arithmetic of integers as implemented on modern
 computers. In applications where overflow is possible, explicit checking for wraparound produced
-by overflow is essential; otherwise, the `BigInt` type in [Arbitrary Precision Arithmetic](@ref)
+by overflow is essential; otherwise, the [`BigInt`](@ref) type in [Arbitrary Precision Arithmetic](@ref)
 is recommended instead.
 
 ### Division errors
@@ -243,8 +243,8 @@ julia> 2.5e-4
 0.00025
 ```
 
-The above results are all `Float64` values. Literal `Float32` values can be entered by writing
-an `f` in place of `e`:
+The above results are all [`Float64`](@ref) values. Literal [`Float32`](@ref) values can be
+entered by writing an `f` in place of `e`:
 
 ```jldoctest
 julia> 0.5f0
@@ -257,7 +257,7 @@ julia> 2.5f-4
 0.00025f0
 ```
 
-Values can be converted to `Float32` easily:
+Values can be converted to [`Float32`](@ref) easily:
 
 ```jldoctest
 julia> Float32(-1.5)
@@ -267,7 +267,7 @@ julia> typeof(ans)
 Float32
 ```
 
-Hexadecimal floating-point literals are also valid, but only as `Float64` values:
+Hexadecimal floating-point literals are also valid, but only as [`Float64`](@ref) values:
 
 ```jldoctest
 julia> 0x1p0
@@ -283,8 +283,8 @@ julia> typeof(ans)
 Float64
 ```
 
-Half-precision floating-point numbers are also supported (`Float16`), but they are
-implemented in software and use `Float32` for calculations.
+Half-precision floating-point numbers are also supported ([`Float16`](@ref)), but they are
+implemented in software and use [`Float32`](@ref) for calculations.
 
 ```jldoctest
 julia> sizeof(Float16(4.))
@@ -404,11 +404,11 @@ julia> eps() # same as eps(Float64)
 2.220446049250313e-16
 ```
 
-These values are `2.0^-23` and `2.0^-52` as `Float32` and `Float64` values, respectively. The
-[`eps()`](@ref) function can also take a floating-point value as an argument, and gives the absolute
-difference between that value and the next representable floating point value. That is, `eps(x)`
-yields a value of the same type as `x` such that `x + eps(x)` is the next representable floating-point
-value larger than `x`:
+These values are `2.0^-23` and `2.0^-52` as [`Float32`](@ref) and [`Float64`](@ref) values,
+respectively. The [`eps()`](@ref) function can also take a floating-point value as an
+argument, and gives the absolute difference between that value and the next representable
+floating point value. That is, `eps(x)` yields a value of the same type as `x` such that
+`x + eps(x)` is the next representable floating-point value larger than `x`:
 
 ```jldoctest
 julia> eps(1.0)
@@ -492,8 +492,8 @@ most books on scientific computation, and also in the following references:
   * The definitive guide to floating point arithmetic is the [IEEE 754-2008 Standard](http://standards.ieee.org/findstds/standard/754-2008.html);
     however, it is not available for free online.
   * For a brief but lucid presentation of how floating-point numbers are represented, see John D.
-    Cook's [article](http://www.johndcook.com/blog/2009/04/06/anatomy-of-a-floating-point-number/)
-    on the subject as well as his [introduction](http://www.johndcook.com/blog/2009/04/06/numbers-are-a-leaky-abstraction/)
+    Cook's [article](https://www.johndcook.com/blog/2009/04/06/anatomy-of-a-floating-point-number/)
+    on the subject as well as his [introduction](https://www.johndcook.com/blog/2009/04/06/numbers-are-a-leaky-abstraction/)
     to some of the issues arising from how this representation differs in behavior from the idealized
     abstraction of real numbers.
   * Also recommended is Bruce Dawson's [series of blog posts on floating-point numbers](https://randomascii.wordpress.com/2012/05/20/thats-not-normalthe-performance-of-odd-floats/).
@@ -584,7 +584,7 @@ To make common numeric formulas and expressions clearer, Julia allows variables
 preceded by a numeric literal, implying multiplication. This makes writing polynomial expressions
 much cleaner:
 
-```jldoctest
+```jldoctest numeric-coefficients
 julia> x = 3
 3
 
@@ -597,7 +597,7 @@ julia> 1.5x^2 - .5x + 1
 
 It also makes writing exponential functions more elegant:
 
-```julia
+```jldoctest numeric-coefficients
 julia> 2^2x
 64
 ```
@@ -607,7 +607,7 @@ negation. So `2^3x` is parsed as `2^(3x)`, and `2x^3` is parsed as `2*(x^3)`.
 
 Numeric literals also work as coefficients to parenthesized expressions:
 
-```julia
+```jldoctest numeric-coefficients
 julia> 2(x-1)^2 - 3(x-1) + 1
 3
 ```
@@ -615,7 +615,7 @@ julia> 2(x-1)^2 - 3(x-1) + 1
 Additionally, parenthesized expressions can be used as coefficients to variables, implying multiplication
 of the expression by the variable:
 
-```julia
+```jldoctest numeric-coefficients
 julia> (x-1)x
 6
 ```
@@ -623,7 +623,7 @@ julia> (x-1)x
 Neither juxtaposition of two parenthesized expressions, nor placing a variable before a parenthesized
 expression, however, can be used to imply multiplication:
 
-```julia
+```jldoctest numeric-coefficients
 julia> (x-1)(x+1)
 ERROR: MethodError: objects of type Int64 are not callable
 
diff --git a/doc/src/manual/interacting-with-julia.md b/doc/src/manual/interacting-with-julia.md
index b214e6ec9d0521..515a640dad5d82 100644
--- a/doc/src/manual/interacting-with-julia.md
+++ b/doc/src/manual/interacting-with-julia.md
@@ -10,7 +10,7 @@ on the executable:
 $ julia
                _
    _       _ _(_)_     |  A fresh approach to technical computing
-  (_)     | (_) (_)    |  Documentation: http://docs.julialang.org
+  (_)     | (_) (_)    |  Documentation: https://docs.julialang.org
    _ _   _| |_  __ _   |  Type "?help" for help.
   | | | | | | |/ _` |  |
   | | |_| | | | (_| |  |  Version 0.6.0-dev.2493 (2017-01-31 18:53 UTC)
@@ -63,11 +63,11 @@ at detecting when a paste occurs.
 When the cursor is at the beginning of the line, the prompt can be changed to a help mode by typing
 `?`. Julia will attempt to print help or documentation for anything entered in help mode:
 
-```julia
+```julia-repl
 julia> ? # upon typing ?, the prompt changes (in place) to: help?>
 
 help?> string
-search: string String stringmime Cstring Cwstring RevString readstring randstring bytestring SubString
+search: string String stringmime Cstring Cwstring RevString randstring bytestring SubString
 
   string(xs...)
 
@@ -111,7 +111,7 @@ system shell to execute system commands. Just as `?` entered help mode when at t
 of the line, a semicolon (`;`) will enter the shell mode. And it can be exited by pressing backspace
 at the beginning of the line.
 
-```julia
+```julia-repl
 julia> ; # upon typing ;, the prompt changes (in place) to: shell>
 
 shell> echo hello
@@ -139,39 +139,41 @@ control-key, there are also meta-key bindings. These vary more by platform, but
 default to using alt- or option- held down with a key to send the meta-key (or can be configured
 to do so).
 
-| Keybinding          | Description                                                                      |
-|:------------------- |:-------------------------------------------------------------------------------- |
-| **Program control** |                                                                                  |
-| `^D`                | Exit (when buffer is empty)                                                      |
-| `^C`                | Interrupt or cancel                                                              |
-| `^L`                | Clear console screen                                                             |
-| Return/Enter, `^J`  | New line, executing if it is complete                                            |
-| meta-Return/Enter   | Insert new line without executing it                                             |
-| `?` or `;`          | Enter help or shell mode (when at start of a line)                               |
-| `^R`, `^S`          | Incremental history search, described above                                      |
-| **Cursor movement** |                                                                                  |
-| Right arrow, `^F`   | Move right one character                                                         |
-| Left arrow, `^B`    | Move left one character                                                          |
-| Home, `^A`          | Move to beginning of line                                                        |
-| End, `^E`           | Move to end of line                                                              |
-| `^P`                | Change to the previous or next history entry                                     |
-| `^N`                | Change to the next history entry                                                 |
-| Up arrow            | Move up one line (or to the previous history entry)                              |
-| Down arrow          | Move down one line (or to the next history entry)                                |
-| Page-up             | Change to the previous history entry that matches the text before the cursor     |
-| Page-down           | Change to the next history entry that matches the text before the cursor         |
-| `meta-F`            | Move right one word                                                              |
-| `meta-B`            | Move left one word                                                               |
-| **Editing**         |                                                                                  |
-| Backspace, `^H`     | Delete the previous character                                                    |
-| Delete, `^D`        | Forward delete one character (when buffer has text)                              |
-| meta-Backspace      | Delete the previous word                                                         |
-| `meta-D`            | Forward delete the next word                                                     |
-| `^W`                | Delete previous text up to the nearest whitespace                                |
-| `^K`                | "Kill" to end of line, placing the text in a buffer                              |
-| `^Y`                | "Yank" insert the text from the kill buffer                                      |
-| `^T`                | Transpose the characters about the cursor                                        |
-| `^Q`                | Write a number in REPL and press `^Q` to open editor at corresponding stackframe |
+| Keybinding          | Description                                                                                |
+|:------------------- |:------------------------------------------------------------------------------------------ |
+| **Program control** |                                                                                            |
+| `^D`                | Exit (when buffer is empty)                                                                |
+| `^C`                | Interrupt or cancel                                                                        |
+| `^L`                | Clear console screen                                                                       |
+| Return/Enter, `^J`  | New line, executing if it is complete                                                      |
+| meta-Return/Enter   | Insert new line without executing it                                                       |
+| `?` or `;`          | Enter help or shell mode (when at start of a line)                                         |
+| `^R`, `^S`          | Incremental history search, described above                                                |
+| **Cursor movement** |                                                                                            |
+| Right arrow, `^F`   | Move right one character                                                                   |
+| Left arrow, `^B`    | Move left one character                                                                    |
+| Home, `^A`          | Move to beginning of line                                                                  |
+| End, `^E`           | Move to end of line                                                                        |
+| `^P`                | Change to the previous or next history entry                                               |
+| `^N`                | Change to the next history entry                                                           |
+| Up arrow            | Move up one line (or to the previous history entry)                                        |
+| Down arrow          | Move down one line (or to the next history entry)                                          |
+| Page-up             | Change to the previous history entry that matches the text before the cursor               |
+| Page-down           | Change to the next history entry that matches the text before the cursor                   |
+| `meta-F`            | Move right one word                                                                        |
+| `meta-B`            | Move left one word                                                                         |
+| `meta-<`            | Change to the first history entry                                                          |
+| `meta->`            | Change to the last history entry                                                           |
+| **Editing**         |                                                                                            |
+| Backspace, `^H`     | Delete the previous character                                                              |
+| Delete, `^D`        | Forward delete one character (when buffer has text)                                        |
+| meta-Backspace      | Delete the previous word                                                                   |
+| `meta-D`            | Forward delete the next word                                                               |
+| `^W`                | Delete previous text up to the nearest whitespace                                          |
+| `^K`                | "Kill" to end of line, placing the text in a buffer                                        |
+| `^Y`                | "Yank" insert the text from the kill buffer                                                |
+| `^T`                | Transpose the characters about the cursor                                                  |
+| `^Q`                | Write a number in REPL and press `^Q` to open editor at corresponding stackframe or method |
 
 
 ### Customizing keybindings
@@ -189,27 +191,27 @@ history without prefix search, one could put the following code in `.juliarc.jl`
 import Base: LineEdit, REPL
 
 const mykeys = Dict{Any,Any}(
-  # Up Arrow
-  "\e[A" => (s,o...)->(LineEdit.edit_move_up(s) || LineEdit.history_prev(s, LineEdit.mode(s).hist)),
-  # Down Arrow
-  "\e[B" => (s,o...)->(LineEdit.edit_move_up(s) || LineEdit.history_next(s, LineEdit.mode(s).hist))
+    # Up Arrow
+    "\e[A" => (s,o...)->(LineEdit.edit_move_up(s) || LineEdit.history_prev(s, LineEdit.mode(s).hist)),
+    # Down Arrow
+    "\e[B" => (s,o...)->(LineEdit.edit_move_up(s) || LineEdit.history_next(s, LineEdit.mode(s).hist))
 )
 
 function customize_keys(repl)
-  repl.interface = REPL.setup_interface(repl; extra_repl_keymap = mykeys)
+    repl.interface = REPL.setup_interface(repl; extra_repl_keymap = mykeys)
 end
 
 atreplinit(customize_keys)
 ```
 
-Users should refer to `base/LineEdit.jl` to discover the available actions on key input.
+Users should refer to `LineEdit.jl` to discover the available actions on key input.
 
 ## Tab completion
 
 In both the Julian and help modes of the REPL, one can enter the first few characters of a function
 or type and then press the tab key to get a list all matches:
 
-```julia
+```julia-repl
 julia> stri[TAB]
 stride     strides     string      stringmime  strip
 
@@ -220,7 +222,7 @@ StridedArray    StridedMatrix    StridedVecOrMat  StridedVector    String
 The tab key can also be used to substitute LaTeX math symbols with their Unicode equivalents,
 and get a list of LaTeX matches as well:
 
-```julia
+```julia-repl
 julia> \pi[TAB]
 julia> π
 π = 3.1415926535897...
@@ -258,7 +260,7 @@ A full list of tab-completions can be found in the [Unicode Input](@ref) section
 
 Completion of paths works for strings and julia's shell mode:
 
-```julia
+```julia-repl
 julia> path="/[TAB]"
 .dockerenv  .juliabox/   boot/        etc/         lib/         media/       opt/         root/        sbin/        sys/         usr/
 .dockerinit bin/         dev/         home/        lib64/       mnt/         proc/        run/         srv/         tmp/         var/
@@ -269,7 +271,7 @@ shell> /[TAB]
 
 Tab completion can help with investigation of the available methods matching the input arguments:
 
-```julia
+```julia-repl
 julia> max([TAB] # All methods are displayed, not shown here due to size of the list
 
 julia> max([1, 2], [TAB] # All methods where `Vector{Int}` matches as first argument
@@ -284,10 +286,10 @@ max(a, b, c, xs...) in Base at operators.jl:281
 Keywords are also displayed in the suggested methods, see second line after `;` where `limit`
 and `keep` are keyword arguments:
 
-```julia
+```julia-repl
 julia> split("1 1 1", [TAB]
-split(str::AbstractString) in Base at strings/util.jl:278
-split{T<:AbstractString}(str::T, splitter; limit, keep) in Base at strings/util.jl:254
+split(str::AbstractString) in Base at strings/util.jl:302
+split(str::T, splitter; limit, keep) where T<:AbstractString in Base at strings/util.jl:277
 ```
 
 The completion of the methods uses type inference and can therefore see if the arguments match
@@ -296,14 +298,14 @@ completion to be able to remove non-matching methods.
 
 Tab completion can also help completing fields:
 
-```julia
+```julia-repl
 julia> Pkg.a[TAB]
 add       available
 ```
 
 Fields for output from functions can also be completed:
 
-```julia
+```julia-repl
 julia> split("","")[1].[TAB]
 endof  offset  string
 ```
@@ -313,8 +315,9 @@ fields if the function is type stable.
 
 ## 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:
+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, which is to be placed inside your home directory:
 
 ```julia
 function customize_colors(repl)
@@ -333,9 +336,22 @@ input and answer text by setting the appropriate field of `repl` in the `customi
 above (respectively, `help_color`, `shell_color`, `input_color`, and `answer_color`). For the
 latter two, be sure that the `envcolors` field is also set to false.
 
+It is also possible to apply boldface formatting by using
+`Base.text_colors[:bold]` as a color. For instance, to print answers in
+boldface font, one can use the following as a `.juliarc.jl`:
+
+```julia
+function customize_colors(repl)
+    repl.envcolors = false
+    repl.answer_color = Base.text_colors[:bold]
+end
+
+atreplinit(customize_colors)
+```
+
 You can also customize the color used to render warning and informational messages by
 setting the appropriate environment variables. For instance, to render error, warning, and informational
-messages respectively in magenta, yellow, and cyan you can add the following to your `juliarc.jl` file:
+messages respectively in magenta, yellow, and cyan you can add the following to your `.juliarc.jl` file:
 
 ```julia
 ENV["JULIA_ERROR_COLOR"] = :magenta
diff --git a/doc/src/manual/interfaces.md b/doc/src/manual/interfaces.md
index f6ae319302b263..3b679db3d8aa8c 100644
--- a/doc/src/manual/interfaces.md
+++ b/doc/src/manual/interfaces.md
@@ -187,7 +187,7 @@ julia> Squares(10)[[3,4.,5]]
 While this is starting to support more of the [indexing operations supported by some of the builtin types](@ref man-array-indexing),
 there's still quite a number of behaviors missing. This `Squares` sequence is starting to look
 more and more like a vector as we've added behaviors to it. Instead of defining all these behaviors
-ourselves, we can officially define it as a subtype of an `AbstractArray`.
+ourselves, we can officially define it as a subtype of an [`AbstractArray`](@ref).
 
 ## [Abstract Arrays](@id man-interface-array)
 
@@ -231,8 +231,9 @@ arrays are simple: just define `getindex(A::ArrayType, i::Int)`.  When the array
 indexed with a multidimensional set of indices, the fallback `getindex(A::AbstractArray, I...)()`
 efficiently converts the indices into one linear index and then calls the above method. `IndexCartesian()`
 arrays, on the other hand, require methods to be defined for each supported dimensionality with
-`ndims(A)``Int` indices.  For example, the builtin `SparseMatrixCSC` type only supports two dimensions,
-so it just defines `getindex(A::SparseMatrixCSC, i::Int, j::Int)()`.  The same holds for `setindex!()`.
+`ndims(A)` `Int` indices. For example, the built-in [`SparseMatrixCSC`](@ref) type only
+supports two dimensions, so it just defines
+`getindex(A::SparseMatrixCSC, i::Int, j::Int)`. The same holds for `setindex!()`.
 
 Returning to the sequence of squares from above, we could instead define it as a subtype of an
 `AbstractArray{Int, 1}`:
@@ -294,11 +295,11 @@ julia> SparseArray{T,N}(::Type{T}, dims::NTuple{N,Int}) = SparseArray{T,N}(Dict{
 
 julia> Base.size(A::SparseArray) = A.dims
 
-julia> Base.similar{T}(A::SparseArray, ::Type{T}, dims::Dims) = SparseArray(T, dims)
+julia> Base.similar(A::SparseArray, ::Type{T}, dims::Dims) where {T} = SparseArray(T, dims)
 
-julia> Base.getindex{T,N}(A::SparseArray{T,N}, I::Vararg{Int,N}) = get(A.data, I, zero(T))
+julia> Base.getindex(A::SparseArray{T,N}, I::Vararg{Int,N}) where {T,N} = get(A.data, I, zero(T))
 
-julia> Base.setindex!{T,N}(A::SparseArray{T,N}, v, I::Vararg{Int,N}) = (A.data[I] = v)
+julia> Base.setindex!(A::SparseArray{T,N}, v, I::Vararg{Int,N}) where {T,N} = (A.data[I] = v)
 ```
 
 Notice that this is an `IndexCartesian` array, so we must manually define [`getindex()`](@ref) and [`setindex!()`](@ref)
diff --git a/doc/src/manual/linear-algebra.md b/doc/src/manual/linear-algebra.md
index af5ff9a2766f4e..8bb0e2101a8d68 100644
--- a/doc/src/manual/linear-algebra.md
+++ b/doc/src/manual/linear-algebra.md
@@ -62,6 +62,7 @@ julia> factorize(A)
 Base.LinAlg.LU{Float64,Array{Float64,2}} with factors L and U:
 [1.0 0.0 0.0; -0.15 1.0 0.0; -0.3 -0.132196 1.0]
 [-10.0 2.3 4.0; 0.0 2.345 -3.4; 0.0 0.0 -5.24947]
+successful: true
 ```
 
 Since `A` is not Hermitian, symmetric, triangular, tridiagonal, or bidiagonal, an LU factorization may be the
@@ -75,7 +76,23 @@ julia> B = [1.5 2 -4; 2 -1 -3; -4 -3 5]
  -4.0  -3.0   5.0
 
 julia> factorize(B)
-Base.LinAlg.BunchKaufman{Float64,Array{Float64,2}}([-1.64286 0.142857 -0.8; 2.0 -2.8 -0.6; -4.0 -3.0 5.0], [1, 2, 3], 'U', true, false, 0)
+Base.LinAlg.BunchKaufman{Float64,Array{Float64,2}}
+D factor:
+3×3 Tridiagonal{Float64}:
+ -1.64286   0.0   ⋅
+  0.0      -2.8  0.0
+   ⋅        0.0  5.0
+U factor:
+3×3 Base.LinAlg.UnitUpperTriangular{Float64,Array{Float64,2}}:
+ 1.0  0.142857  -0.8
+ 0.0  1.0       -0.6
+ 0.0  0.0        1.0
+permutation:
+3-element Array{Int64,1}:
+ 1
+ 2
+ 3
+successful: true
 ```
 
 Here, Julia was able to detect that `B` is in fact symmetric, and used a more appropriate factorization.
@@ -144,29 +161,31 @@ specialized routines that are specially developed for particular matrix types.
 The following tables summarize the types of special matrices that have been implemented in Julia,
 as well as whether hooks to various optimized methods for them in LAPACK are available.
 
-| Type                     | Description                                                                      |
-|:------------------------ |:-------------------------------------------------------------------------------- |
-| [`Hermitian`](@ref)      | [Hermitian matrix](https://en.wikipedia.org/wiki/Hermitian_matrix)               |
-| `UpperTriangular`        | Upper [triangular matrix](https://en.wikipedia.org/wiki/Triangular_matrix)       |
-| `LowerTriangular`        | Lower [triangular matrix](https://en.wikipedia.org/wiki/Triangular_matrix)       |
-| [`Tridiagonal`](@ref)    | [Tridiagonal matrix](https://en.wikipedia.org/wiki/Tridiagonal_matrix)           |
-| [`SymTridiagonal`](@ref) | Symmetric tridiagonal matrix                                                     |
-| [`Bidiagonal`](@ref)     | Upper/lower [bidiagonal matrix](https://en.wikipedia.org/wiki/Bidiagonal_matrix) |
-| [`Diagonal`](@ref)       | [Diagonal matrix](https://en.wikipedia.org/wiki/Diagonal_matrix)                 |
-| `UniformScaling`         | [Uniform scaling operator](https://en.wikipedia.org/wiki/Uniform_scaling)        |
+| Type                      | Description                                                                      |
+|:------------------------- |:-------------------------------------------------------------------------------- |
+| [`Symmetric`](@ref)       | [Symmetric matrix](https://en.wikipedia.org/wiki/Symmetric_matrix)               |
+| [`Hermitian`](@ref)       | [Hermitian matrix](https://en.wikipedia.org/wiki/Hermitian_matrix)               |
+| [`UpperTriangular`](@ref) | Upper [triangular matrix](https://en.wikipedia.org/wiki/Triangular_matrix)       |
+| [`LowerTriangular`](@ref) | Lower [triangular matrix](https://en.wikipedia.org/wiki/Triangular_matrix)       |
+| [`Tridiagonal`](@ref)     | [Tridiagonal matrix](https://en.wikipedia.org/wiki/Tridiagonal_matrix)           |
+| [`SymTridiagonal`](@ref)  | Symmetric tridiagonal matrix                                                     |
+| [`Bidiagonal`](@ref)      | Upper/lower [bidiagonal matrix](https://en.wikipedia.org/wiki/Bidiagonal_matrix) |
+| [`Diagonal`](@ref)        | [Diagonal matrix](https://en.wikipedia.org/wiki/Diagonal_matrix)                 |
+| [`UniformScaling`](@ref)  | [Uniform scaling operator](https://en.wikipedia.org/wiki/Uniform_scaling)        |
 
 ### Elementary operations
 
-| Matrix type              | `+` | `-` | `*` | `\` | Other functions with optimized methods                              |
-|:------------------------ |:--- |:--- |:--- |:--- |:------------------------------------------------------------------- |
-| [`Hermitian`](@ref)      |     |     |     | MV  | [`inv()`](@ref), [`sqrtm()`](@ref), [`expm()`](@ref)                |
-| `UpperTriangular`        |     |     | MV  | MV  | [`inv()`](@ref), [`det()`](@ref)                                    |
-| `LowerTriangular`        |     |     | MV  | MV  | [`inv()`](@ref), [`det()`](@ref)                                    |
-| [`SymTridiagonal`](@ref) | M   | M   | MS  | MV  | [`eigmax()`](@ref), [`eigmin()`](@ref)                              |
-| [`Tridiagonal`](@ref)    | M   | M   | MS  | MV  |                                                                     |
-| [`Bidiagonal`](@ref)     | M   | M   | MS  | MV  |                                                                     |
-| [`Diagonal`](@ref)       | M   | M   | MV  | MV  | [`inv()`](@ref), [`det()`](@ref), [`logdet()`](@ref), [`/()`](@ref) |
-| `UniformScaling`         | M   | M   | MVS | MVS | [`/()`](@ref)                                                       |
+| Matrix type               | `+` | `-` | `*` | `\` | Other functions with optimized methods                              |
+|:------------------------- |:--- |:--- |:--- |:--- |:------------------------------------------------------------------- |
+| [`Symmetric`](@ref)       |     |     |     | MV  | [`inv()`](@ref), [`sqrtm()`](@ref), [`expm()`](@ref)                |
+| [`Hermitian`](@ref)       |     |     |     | MV  | [`inv()`](@ref), [`sqrtm()`](@ref), [`expm()`](@ref)                |
+| [`UpperTriangular`](@ref) |     |     | MV  | MV  | [`inv()`](@ref), [`det()`](@ref)                                    |
+| [`LowerTriangular`](@ref) |     |     | MV  | MV  | [`inv()`](@ref), [`det()`](@ref)                                    |
+| [`SymTridiagonal`](@ref)  | M   | M   | MS  | MV  | [`eigmax()`](@ref), [`eigmin()`](@ref)                              |
+| [`Tridiagonal`](@ref)     | M   | M   | MS  | MV  |                                                                     |
+| [`Bidiagonal`](@ref)      | M   | M   | MS  | MV  |                                                                     |
+| [`Diagonal`](@ref)        | M   | M   | MV  | MV  | [`inv()`](@ref), [`det()`](@ref), [`logdet()`](@ref), [`/()`](@ref) |
+| [`UniformScaling`](@ref)  | M   | M   | MVS | MVS | [`/()`](@ref)                                                       |
 
 Legend:
 
@@ -178,15 +197,16 @@ Legend:
 
 ### Matrix factorizations
 
-| Matrix type              | LAPACK | [`eig()`](@ref) | [`eigvals()`](@ref) | [`eigvecs()`](@ref) | [`svd()`](@ref) | [`svdvals()`](@ref) |
-|:------------------------ |:------ |:--------------- |:------------------- |:------------------- |:--------------- |:------------------- |
-| [`Hermitian`](@ref)      | HE     |                 | ARI                 |                     |                 |                     |
-| `UpperTriangular`        | TR     | A               | A                   | A                   |                 |                     |
-| `LowerTriangular`        | TR     | A               | A                   | A                   |                 |                     |
-| [`SymTridiagonal`](@ref) | ST     | A               | ARI                 | AV                  |                 |                     |
-| [`Tridiagonal`](@ref)    | GT     |                 |                     |                     |                 |                     |
-| [`Bidiagonal`](@ref)     | BD     |                 |                     |                     | A               | A                   |
-| [`Diagonal`](@ref)       | DI     |                 | A                   |                     |                 |                     |
+| Matrix type               | LAPACK | [`eig()`](@ref) | [`eigvals()`](@ref) | [`eigvecs()`](@ref) | [`svd()`](@ref) | [`svdvals()`](@ref) |
+|:------------------------- |:------ |:--------------- |:------------------- |:------------------- |:--------------- |:------------------- |
+| [`Symmetric`](@ref)       | SY     |                 | ARI                 |                     |                 |                     |
+| [`Hermitian`](@ref)       | HE     |                 | ARI                 |                     |                 |                     |
+| [`UpperTriangular`](@ref) | TR     | A               | A                   | A                   |                 |                     |
+| [`LowerTriangular`](@ref) | TR     | A               | A                   | A                   |                 |                     |
+| [`SymTridiagonal`](@ref)  | ST     | A               | ARI                 | AV                  |                 |                     |
+| [`Tridiagonal`](@ref)     | GT     |                 |                     |                     |                 |                     |
+| [`Bidiagonal`](@ref)      | BD     |                 |                     |                     | A               | A                   |
+| [`Diagonal`](@ref)        | DI     |                 | A                   |                     |                 |                     |
 
 Legend:
 
@@ -199,8 +219,8 @@ Legend:
 
 ### The uniform scaling operator
 
-A `UniformScaling` operator represents a scalar times the identity operator, `λ*I`. The identity
-operator  `I` is defined as a constant and is an instance of `UniformScaling`. The size of these
+A [`UniformScaling`](@ref) operator represents a scalar times the identity operator, `λ*I`. The identity
+operator `I` is defined as a constant and is an instance of `UniformScaling`. The size of these
 operators are generic and match the other matrix in the binary operations [`+`](@ref), [`-`](@ref),
 [`*`](@ref) and [`\`](@ref). For `A+I` and `A-I` this means that `A` must be square. Multiplication
 with the identity operator `I` is a noop (except for checking that the scaling factor is one)
@@ -230,4 +250,3 @@ of the standard library documentation.
 | `Eigen`           | [Spectral decomposition](https://en.wikipedia.org/wiki/Eigendecomposition_(matrix))                            |
 | `SVD`             | [Singular value decomposition](https://en.wikipedia.org/wiki/Singular_value_decomposition)                     |
 | `GeneralizedSVD`  | [Generalized SVD](https://en.wikipedia.org/wiki/Generalized_singular_value_decomposition#Higher_order_version) |
-
diff --git a/doc/src/manual/mathematical-operations.md b/doc/src/manual/mathematical-operations.md
index f25778f895dbe9..0311108131697c 100644
--- a/doc/src/manual/mathematical-operations.md
+++ b/doc/src/manual/mathematical-operations.md
@@ -21,7 +21,7 @@ are supported on all primitive numeric types:
 | `x ^ y`    | power          | raises `x` to the `y`th power          |
 | `x % y`    | remainder      | equivalent to `rem(x,y)`               |
 
-as well as the negation on `Bool` types:
+as well as the negation on [`Bool`](@ref) types:
 
 | Expression | Name     | Description                              |
 |:---------- |:-------- |:---------------------------------------- |
@@ -169,6 +169,11 @@ For example, if you define `⊗(A,B) = kron(A,B)` to give a convenient
 infix syntax `A ⊗ B` for Kronecker products ([`kron`](@ref)), then
 `[A,B] .⊗ [C,D]` will compute `[A⊗C, B⊗D]` with no additional coding.
 
+Combining dot operators with numeric literals can be ambiguous.
+For example, it is not clear whether `1.+x` means `1. + x` or `1 .+ x`.
+Therefore this syntax is disallowed, and spaces must be used around
+the operator in such cases.
+
 ## Numeric Comparisons
 
 Standard comparison operations are defined for all the primitive numeric types:
@@ -331,7 +336,18 @@ comparison is undefined. It is strongly recommended not to use expressions with
 as printing) in chained comparisons. If side effects are required, the short-circuit `&&` operator
 should be used explicitly (see [Short-Circuit Evaluation](@ref)).
 
-### Operator Precedence
+### Elementary Functions
+
+Julia provides a comprehensive collection of mathematical functions and operators. These mathematical
+operations are defined over as broad a class of numerical values as permit sensible definitions,
+including integers, floating-point numbers, rationals, and complex numbers,
+wherever such definitions make sense.
+
+Moreover, these functions (like any Julia function) can be applied in "vectorized" fashion to
+arrays and other collections with the [dot syntax](@ref man-vectorized) `f.(A)`,
+e.g. `sin.(A)` will compute the sine of each element of an array `A`.
+
+## Operator Precedence
 
 Julia applies the following order of operations, from highest precedence to lowest:
 
@@ -348,16 +364,18 @@ Julia applies the following order of operations, from highest precedence to lowe
 | Control flow   | `&&` followed by `\|\|` followed by `?`                                                           |
 | Assignments    | `= += -= *= /= //= \= ^= ÷= %= \|= &= ⊻= <<= >>= >>>=`                                            |
 
-### Elementary Functions
+For a complete list of *every* Julia operator's precedence, see the top of this file:
+[`src/julia-parser.scm`](https://github.com/JuliaLang/julia/blob/master/src/julia-parser.scm)
 
-Julia provides a comprehensive collection of mathematical functions and operators. These mathematical
-operations are defined over as broad a class of numerical values as permit sensible definitions,
-including integers, floating-point numbers, rationals, and complexes, wherever such definitions
-make sense.
+You can also find the numerical precedence for any given operator via the built-in function `Base.operator_precedence`, where higher numbers take precedence:
 
-Moreover, these functions (like any Julia function) can be applied in "vectorized" fashion to
-arrays and other collections with the [dot syntax](@ref man-vectorized) `f.(A)`,
-e.g. `sin.(A)` will compute the elementwise sine of each element of an array `A`.
+```jldoctest
+julia> Base.operator_precedence(:+), Base.operator_precedence(:*), Base.operator_precedence(:.)
+(9, 11, 15)
+
+julia> Base.operator_precedence(:+=), Base.operator_precedence(:(=))  # (Note the necessary parens on `:(=)`)
+(1, 1)
+```
 
 ## Numerical Conversions
 
@@ -382,24 +400,27 @@ julia> Int8(127)
 127
 
 julia> Int8(128)
-ERROR: InexactError()
+ERROR: InexactError: trunc(Int8, 128)
 Stacktrace:
- [1] Int8(::Int64) at ./sysimg.jl:24
+ [1] throw_inexacterror(::Symbol, ::Type{Int8}, ::Int64) at ./int.jl:34
+ [2] checked_trunc_sint at ./int.jl:419 [inlined]
+ [3] convert at ./int.jl:439 [inlined]
+ [4] Int8(::Int64) at ./sysimg.jl:102
 
 julia> Int8(127.0)
 127
 
 julia> Int8(3.14)
-ERROR: InexactError()
+ERROR: InexactError: convert(Int8, 3.14)
 Stacktrace:
- [1] convert(::Type{Int8}, ::Float64) at ./float.jl:654
- [2] Int8(::Float64) at ./sysimg.jl:24
+ [1] convert at ./float.jl:660 [inlined]
+ [2] Int8(::Float64) at ./sysimg.jl:102
 
 julia> Int8(128.0)
-ERROR: InexactError()
+ERROR: InexactError: convert(Int8, 128.0)
 Stacktrace:
- [1] convert(::Type{Int8}, ::Float64) at ./float.jl:654
- [2] Int8(::Float64) at ./sysimg.jl:24
+ [1] convert at ./float.jl:660 [inlined]
+ [2] Int8(::Float64) at ./sysimg.jl:102
 
 julia> 127 % Int8
 127
@@ -411,10 +432,10 @@ julia> round(Int8,127.4)
 127
 
 julia> round(Int8,127.6)
-ERROR: InexactError()
+ERROR: InexactError: trunc(Int8, 128.0)
 Stacktrace:
- [1] trunc(::Type{Int8}, ::Float64) at ./float.jl:647
- [2] round(::Type{Int8}, ::Float64) at ./float.jl:333
+ [1] trunc at ./float.jl:653 [inlined]
+ [2] round(::Type{Int8}, ::Float64) at ./float.jl:338
 ```
 
 See [Conversion and Promotion](@ref conversion-and-promotion) for how to define your own conversions and promotions.
@@ -478,8 +499,8 @@ See [Conversion and Promotion](@ref conversion-and-promotion) for how to define
 | [`significand(x)`](@ref) | binary significand (a.k.a. mantissa) of a floating-point number `x`        |
 
 For an overview of why functions like [`hypot()`](@ref), [`expm1()`](@ref), and [`log1p()`](@ref)
-are necessary and useful, see John D. Cook's excellent pair of blog posts on the subject: [expm1, log1p, erfc](http://www.johndcook.com/blog/2010/06/07/math-library-functions-that-seem-unnecessary/),
-and [hypot](http://www.johndcook.com/blog/2010/06/02/whats-so-hard-about-finding-a-hypotenuse/).
+are necessary and useful, see John D. Cook's excellent pair of blog posts on the subject: [expm1, log1p, erfc](https://www.johndcook.com/blog/2010/06/07/math-library-functions-that-seem-unnecessary/),
+and [hypot](https://www.johndcook.com/blog/2010/06/02/whats-so-hard-about-finding-a-hypotenuse/).
 
 ### Trigonometric and hyperbolic functions
 
diff --git a/doc/src/manual/metaprogramming.md b/doc/src/manual/metaprogramming.md
index 633cbfc5b1ad0e..8bb806c546cd71 100644
--- a/doc/src/manual/metaprogramming.md
+++ b/doc/src/manual/metaprogramming.md
@@ -33,7 +33,7 @@ julia> typeof(ex1)
 Expr
 ```
 
-`Expr` objects contain three parts:
+`Expr` objects contain two parts:
 
   * a `Symbol` identifying the kind of expression. A symbol is an [interned string](https://en.wikipedia.org/wiki/String_interning)
     identifier (more discussion below).
@@ -53,14 +53,6 @@ julia> ex1.args
  1
 ```
 
-  * finally, the expression result type, which may be annotated by the user or inferred by the compiler
-    (and may be ignored completely for the purposes of this chapter):
-
-```jldoctest prog
-julia> ex1.typ
-Any
-```
-
 Expressions may also be constructed directly in [prefix notation](https://en.wikipedia.org/wiki/Polish_notation):
 
 ```jldoctest prog
@@ -166,7 +158,7 @@ Expr
 ```
 
 (to view the structure of this expression, try `ex.head` and `ex.args`, or use [`dump()`](@ref)
-as above)
+as above or [`Meta.@dump`](@ref))
 
 Note that equivalent expressions may be constructed using [`parse()`](@ref) or the direct `Expr`
 form:
@@ -194,9 +186,12 @@ julia> ex = quote
            y = 2
            x + y
        end
-quote  # none, line 2:
-    x = 1 # none, line 3:
-    y = 2 # none, line 4:
+quote
+    #= none:2 =#
+    x = 1
+    #= none:3 =#
+    y = 2
+    #= none:4 =#
     x + y
 end
 
@@ -238,7 +233,7 @@ julia> ex = :(a in $:((1,2,3)) )
 Interpolating symbols into a nested expression requires enclosing each symbol in an enclosing
 quote block:
 
-```julia
+```julia-repl
 julia> :( :a in $( :(:a + :b) ) )
                    ^^^^^^^^^^
                    quoted inner expression
@@ -298,7 +293,7 @@ Since expressions are just `Expr` objects which can be constructed programmatica
 it is possible to dynamically generate arbitrary code which can then be run using [`eval()`](@ref).
 Here is a simple example:
 
-```julia
+```julia-repl
 julia> a = 1;
 
 julia> ex = Expr(:call, :+, a, :b)
@@ -418,9 +413,9 @@ Hello, human
 We can view the quoted return expression using the function [`macroexpand()`](@ref) (**important note:**
 this is an extremely useful tool for debugging macros):
 
-```jldoctest sayhello2
-julia> ex = macroexpand( :(@sayhello("human")) )
-:((println)("Hello, ", "human"))
+```julia-repl sayhello2
+julia> ex = macroexpand(Main, :(@sayhello("human")) )
+:((Main.println)("Hello, ", "human"))
 
 julia> typeof(ex)
 Expr
@@ -445,21 +440,21 @@ Macros are necessary because they execute when code is parsed, therefore, macros
 to generate and include fragments of customized code *before* the full program is run. To illustrate
 the difference, consider the following example:
 
-```jldoctest whymacros
+```julia-repl whymacros
 julia> macro twostep(arg)
            println("I execute at parse time. The argument is: ", arg)
            return :(println("I execute at runtime. The argument is: ", $arg))
        end
 @twostep (macro with 1 method)
 
-julia> ex = macroexpand( :(@twostep :(1, 2, 3)) );
+julia> ex = macroexpand(Main, :(@twostep :(1, 2, 3)) );
 I execute at parse time. The argument is: $(Expr(:quote, :((1, 2, 3))))
 ```
 
 The first call to [`println()`](@ref) is executed when [`macroexpand()`](@ref) is called. The
 resulting expression contains *only* the second `println`:
 
-```jldoctest whymacros
+```julia-repl whymacros
 julia> typeof(ex)
 Expr
 
@@ -474,7 +469,7 @@ I execute at runtime. The argument is: (1, 2, 3)
 
 Macros are invoked with the following general syntax:
 
-```
+```julia
 @name expr1 expr2 ...
 @name(expr1, expr2, ...)
 ```
@@ -484,7 +479,7 @@ expressions in the first form, and the lack of whitespace after `@name` in the s
 two styles should not be mixed. For example, the following syntax is different from the examples
 above; it passes the tuple `(expr1, expr2, ...)` as one argument to the macro:
 
-```
+```julia
 @name (expr1, expr2, ...)
 ```
 
@@ -509,6 +504,35 @@ julia> @showarg(println("Yo!"))
 :(println("Yo!"))
 ```
 
+In addition to the given argument list, every macro is passed extra arguments named `__source__` and `__module__`.
+
+The argument `__source__` provides information (in the form of a `LineNumberNode` object) about the parser location
+of the `@` sign from the macro invocation.
+This allows macros to include better error diagnostic information,
+and is commonly used by logging, string-parser macros, and docs, for example,
+as well as to implement the `@__LINE__`, `@__FILE__`, and `@__DIR__` macros.
+
+The location information can be accessed by referencing `__source__.line` and `__source__.file`:
+
+```jldoctest
+julia> macro __LOCATION__(); return QuoteNode(__source__); end
+@__LOCATION__ (macro with 1 method)
+
+julia> dump(
+            @__LOCATION__(
+       ))
+LineNumberNode
+  line: Int64 2
+  file: Symbol none
+```
+
+The argument `__module__` provides information (in the form of a `Module` object)
+about the expansion context of the macro invocation.
+This allows macros to look up contextual information, such as existing bindings,
+or to insert the value as an extra argument to a runtime function call doing self-reflection
+in the current module.
+
+
 ### Building an advanced macro
 
 Here is a simplified definition of Julia's `@assert` macro:
@@ -564,21 +588,21 @@ Now `@assert` has two modes of operation, depending upon the number of arguments
 If there's only one argument, the tuple of expressions captured by `msgs` will be empty and it
 will behave the same as the simpler definition above. But now if the user specifies a second argument,
 it is printed in the message body instead of the failing expression. You can inspect the result
-of a macro expansion with the aptly named [`macroexpand()`](@ref) function:
+of a macro expansion with the aptly named [`@macroexpand`](@ref) macro:
 
-```jldoctest assert2
-julia> macroexpand(:(@assert a == b))
-:(if a == b
-        nothing
+```julia-repl assert2
+julia> @macroexpand @assert a == b
+:(if Main.a == Main.b
+        Main.nothing
     else
-        (throw)((AssertionError)("a == b"))
+        (Main.throw)((Main.AssertionError)("a == b"))
     end)
 
-julia> macroexpand(:(@assert a==b "a should equal b!"))
-:(if a == b
-        nothing
+julia> @macroexpand @assert a==b "a should equal b!"
+:(if Main.a == Main.b
+        Main.nothing
     else
-        (throw)((AssertionError)("a should equal b!"))
+        (Main.throw)((Main.AssertionError)("a should equal b!"))
     end)
 ```
 
@@ -609,7 +633,7 @@ Expr
 
 So now instead of getting a plain string in `msg_body`, the macro is receiving a full expression
 that will need to be evaluated in order to display as expected. This can be spliced directly into
-the returned expression as an argument to the [`string()`](@ref) call; see [error.jl](https://github.com/JuliaLang/julia/blob/master/base/error.jl)
+the returned expression as an argument to the [`string()`](@ref) call; see [`error.jl`](https://github.com/JuliaLang/julia/blob/master/base/error.jl)
 for the complete implementation.
 
 The `@assert` macro makes great use of splicing into quoted expressions to simplify the manipulation
@@ -661,7 +685,7 @@ with any user variables, and `time` and `println` will refer to the standard lib
 
 One problem remains however. Consider the following use of this macro:
 
-```
+```julia
 module MyModule
 import Base.@time
 
@@ -675,7 +699,7 @@ Here the user expression `ex` is a call to `time`, but not the same `time` funct
 uses. It clearly refers to `MyModule.time`. Therefore we must arrange for the code in `ex` to
 be resolved in the macro call environment. This is done by "escaping" the expression with [`esc()`](@ref):
 
-```
+```julia
 macro time(ex)
     ...
     local val = $(esc(ex))
@@ -708,6 +732,32 @@ julia> foo()
 
 This kind of manipulation of variables should be used judiciously, but is occasionally quite handy.
 
+Getting the hygiene rules correct can be a formidable challenge.
+Before using a macro, you might want to consider whether a function closure
+would be sufficient. Another useful strategy is to defer as much work as possible to runtime.
+For example, many macros simply wrap their arguments in a QuoteNode or other similar Expr.
+Some examples of this include `@task body` which simply returns `schedule(Task(() -> $body))`,
+and `@eval expr`, which simply returns `eval(QuoteNode(expr))`.
+
+To demonstrate, we might rewrite the `@time` example above as:
+
+```julia
+macro time(expr)
+    return :(timeit(() -> $(esc(expr))))
+end
+function timeit(f)
+    t0 = time()
+    val = f()
+    t1 = time()
+    println("elapsed time: ", t1-t0, " seconds")
+    return val
+end
+```
+
+However, we don't do this for a good reason: wrapping the `expr` in a new scope block (the anonymous function)
+also slightly changes the meaning of the expression (the scope of any variables in it),
+while we want `@time` to be usable with minimum impact on the wrapped code.
+
 ## Code Generation
 
 When a significant amount of repetitive boilerplate code is required, it is common to generate
@@ -876,8 +926,10 @@ When defining generated functions, there are four main differences to ordinary f
    function.
 3. Instead of calculating something or performing some action, you return a *quoted expression* which,
    when evaluated, does what you want.
-4. Generated functions must not have any side-effects or examine any non-constant global state (including,
-   for example, IO, locks, or non-local dictionaries). In other words, they must be completely pure.
+4. Generated functions must not *mutate* or *observe* any non-constant global state (including,
+   for example, IO, locks, non-local dictionaries, or using `method_exists`).
+   This means they can only read global constants, and cannot have any side effects.
+   In other words, they must be completely pure.
    Due to an implementation limitation, this also means that they currently cannot define a closure
    or untyped generator.
 
@@ -918,12 +970,12 @@ we returned from the definition, now with the *value* of `x`.
 
 What happens if we evaluate `foo` again with a type that we have already used?
 
-```julia generated
+```jldoctest generated
 julia> foo(4)
 16
 ```
 
-Note that there is no printout of `Int64`. We can see that the body of the generated function
+Note that there is no printout of [`Int64`](@ref). We can see that the body of the generated function
 was only executed once here, for the specific set of argument types, and the result was cached.
 After that, for this example, the expression returned from the generated function on the first
 invocation was re-used as the method body. However, the actual caching behavior is an implementation-defined
@@ -1073,7 +1125,7 @@ can be used to index into an array `A` using `A[i]`, instead of `A[x,y,z,...]`.
 is the following:
 
 ```jldoctest sub2ind
-julia> function sub2ind_loop{N}(dims::NTuple{N}, I::Integer...)
+julia> function sub2ind_loop(dims::NTuple{N}, I::Integer...) where N
            ind = I[N] - 1
            for i = N-1:-1:1
                ind = I[i]-1 + dims[i]*ind
@@ -1112,7 +1164,7 @@ we use generated functions to manually unroll the loop. The body becomes almost
 instead of calculating the linear index, we build up an *expression* that calculates the index:
 
 ```jldoctest sub2ind_gen
-julia> @generated function sub2ind_gen{N}(dims::NTuple{N}, I::Integer...)
+julia> @generated function sub2ind_gen(dims::NTuple{N}, I::Integer...) where N
            ex = :(I[$N] - 1)
            for i = (N - 1):-1:1
                ex = :(I[$i] - 1 + dims[$i] * $ex)
@@ -1130,7 +1182,7 @@ julia> sub2ind_gen((3, 5), 1, 2)
 An easy way to find out is to extract the body into another (regular) function:
 
 ```jldoctest sub2ind_gen2
-julia> @generated function sub2ind_gen{N}(dims::NTuple{N}, I::Integer...)
+julia> @generated function sub2ind_gen(dims::NTuple{N}, I::Integer...) where N
            return sub2ind_gen_impl(dims, I...)
        end
 sub2ind_gen (generic function with 1 method)
diff --git a/doc/src/manual/methods.md b/doc/src/manual/methods.md
index 8e681f25511941..89f9be82bf1594 100644
--- a/doc/src/manual/methods.md
+++ b/doc/src/manual/methods.md
@@ -58,7 +58,8 @@ julia> f(x::Float64, y::Float64) = 2x + y
 f (generic function with 1 method)
 ```
 
-This function definition applies only to calls where `x` and `y` are both values of type `Float64`:
+This function definition applies only to calls where `x` and `y` are both values of type
+[`Float64`](@ref):
 
 ```jldoctest fofxy
 julia> f(2.0, 3.0)
@@ -87,12 +88,12 @@ julia> f("2.0", "3.0")
 ERROR: MethodError: no method matching f(::String, ::String)
 ```
 
-As you can see, the arguments must be precisely of type `Float64`. Other numeric types, such as
-integers or 32-bit floating-point values, are not automatically converted to 64-bit floating-point,
-nor are strings parsed as numbers. Because `Float64` is a concrete type and concrete types cannot
-be subclassed in Julia, such a definition can only be applied to arguments that are exactly of
-type `Float64`. It may often be useful, however, to write more general methods where the declared
-parameter types are abstract:
+As you can see, the arguments must be precisely of type [`Float64`](@ref). Other numeric
+types, such as integers or 32-bit floating-point values, are not automatically converted
+to 64-bit floating-point, nor are strings parsed as numbers. Because `Float64` is a concrete
+type and concrete types cannot be subclassed in Julia, such a definition can only be applied
+to arguments that are exactly of type `Float64`. It may often be useful, however, to write
+more general methods where the declared parameter types are abstract:
 
 ```jldoctest fofxy
 julia> f(x::Number, y::Number) = 2x - y
@@ -102,9 +103,10 @@ julia> f(2.0, 3)
 1.0
 ```
 
-This method definition applies to any pair of arguments that are instances of `Number`. They need
-not be of the same type, so long as they are each numeric values. The problem of handling disparate
-numeric types is delegated to the arithmetic operations in the expression `2x - y`.
+This method definition applies to any pair of arguments that are instances of [`Number`](@ref).
+They need not be of the same type, so long as they are each numeric values. The problem of
+handling disparate numeric types is delegated to the arithmetic operations in the
+expression `2x - y`.
 
 To define a function with multiple methods, one simply defines the function multiple times, with
 different numbers and types of arguments. The first method definition for a function creates the
@@ -112,9 +114,9 @@ function object, and subsequent method definitions add new methods to the existi
 The most specific method definition matching the number and types of the arguments will be executed
 when the function is applied. Thus, the two method definitions above, taken together, define the
 behavior for `f` over all pairs of instances of the abstract type `Number` -- but with a different
-behavior specific to pairs of `Float64` values. If one of the arguments is a 64-bit float but
-the other one is not, then the `f(Float64,Float64)` method cannot be called and the more general
-`f(Number,Number)` method must be used:
+behavior specific to pairs of [`Float64`](@ref) values. If one of the arguments is a 64-bit
+float but the other one is not, then the `f(Float64,Float64)` method cannot be called and
+the more general `f(Number,Number)` method must be used:
 
 ```jldoctest fofxy
 julia> f(2.0, 3.0)
@@ -163,11 +165,11 @@ f (generic function with 2 methods)
 This output tells us that `f` is a function object with two methods. To find out what the signatures
 of those methods are, use the [`methods()`](@ref) function:
 
-```julia
+```julia-repl
 julia> methods(f)
 # 2 methods for generic function "f":
-f(x::Float64, y::Float64) in Main at none:1
-f(x::Number, y::Number) in Main at none:1
+[1] f(x::Float64, y::Float64) in Main at none:1
+[2] f(x::Number, y::Number) in Main at none:1
 ```
 
 which shows that `f` has two methods, one taking two `Float64` arguments and one taking arguments
@@ -187,34 +189,34 @@ Whoa there, Nelly.
 ```
 
 This catch-all is less specific than any other possible method definition for a pair of parameter
-values, so it is only be called on pairs of arguments to which no other method definition applies.
+values, so it will only be called on pairs of arguments to which no other method definition applies.
 
 Although it seems a simple concept, multiple dispatch on the types of values is perhaps the single
 most powerful and central feature of the Julia language. Core operations typically have dozens
 of methods:
 
-```julia
- julia> methods(+)
- # 166 methods for generic function "+":
- +(a::Float16, b::Float16) at float16.jl:136
- +(x::Float32, y::Float32) at float.jl:206
- +(x::Float64, y::Float64) at float.jl:207
- +(x::Bool, z::Complex{Bool}) at complex.jl:126
- +(x::Bool, y::Bool) at bool.jl:48
- +(x::Bool) at bool.jl:45
- +{T<:AbstractFloat}(x::Bool, y::T) at bool.jl:55
- +(x::Bool, z::Complex) at complex.jl:133
- +(x::Bool, A::AbstractArray{Bool,N<:Any}) at arraymath.jl:105
- +(x::Char, y::Integer) at char.jl:40
- +{T<:Union{Int128,Int16,Int32,Int64,Int8,UInt128,UInt16,UInt32,UInt64,UInt8}}(x::T, y::T) at int.jl:32
- +(z::Complex, w::Complex) at complex.jl:115
- +(z::Complex, x::Bool) at complex.jl:134
- +(x::Real, z::Complex{Bool}) at complex.jl:140
- +(x::Real, z::Complex) at complex.jl:152
- +(z::Complex, x::Real) at complex.jl:153
- +(x::Rational, y::Rational) at rational.jl:179
- ...
- +(a, b, c, xs...) at operators.jl:119
+```julia-repl
+julia> methods(+)
+# 180 methods for generic function "+":
+[1] +(x::Bool, z::Complex{Bool}) in Base at complex.jl:227
+[2] +(x::Bool, y::Bool) in Base at bool.jl:89
+[3] +(x::Bool) in Base at bool.jl:86
+[4] +(x::Bool, y::T) where T<:AbstractFloat in Base at bool.jl:96
+[5] +(x::Bool, z::Complex) in Base at complex.jl:234
+[6] +(a::Float16, b::Float16) in Base at float.jl:373
+[7] +(x::Float32, y::Float32) in Base at float.jl:375
+[8] +(x::Float64, y::Float64) in Base at float.jl:376
+[9] +(z::Complex{Bool}, x::Bool) in Base at complex.jl:228
+[10] +(z::Complex{Bool}, x::Real) in Base at complex.jl:242
+[11] +(x::Char, y::Integer) in Base at char.jl:40
+[12] +(c::BigInt, x::BigFloat) in Base.MPFR at mpfr.jl:307
+[13] +(a::BigInt, b::BigInt, c::BigInt, d::BigInt, e::BigInt) in Base.GMP at gmp.jl:392
+[14] +(a::BigInt, b::BigInt, c::BigInt, d::BigInt) in Base.GMP at gmp.jl:391
+[15] +(a::BigInt, b::BigInt, c::BigInt) in Base.GMP at gmp.jl:390
+[16] +(x::BigInt, y::BigInt) in Base.GMP at gmp.jl:361
+[17] +(x::BigInt, c::Union{UInt16, UInt32, UInt64, UInt8}) in Base.GMP at gmp.jl:398
+...
+[180] +(a, b, c, xs...) in Base at operators.jl:424
 ```
 
 Multiple dispatch together with the flexible parametric type system give Julia its ability to
@@ -412,7 +414,7 @@ Indeed, any new method definition won't be visible to the current runtime enviro
 including Tasks and Threads (and any previously defined `@generated` functions).
 Let's start with an example to see what this means:
 
-```julia
+```julia-repl
 julia> function tryeval()
            @eval newfun() = 1
            newfun()
@@ -455,17 +457,12 @@ In the example above, we see that the "current world" (in which the method `newf
 is one greater than the task-local "runtime world" that was fixed when the execution of `tryeval` started.
 
 Sometimes it is necessary to get around this (for example, if you are implementing the above REPL).
-Well, don't despair, since there's an easy solution: just call `eval` a second time.
-For example, here we create a zero-argument closure over `ans` and `eval` a call to it:
+Fortunately, there is an easy solution: call the function using [`Base.invokelatest`](@ref):
 
 ```jldoctest
 julia> function tryeval2()
-           ans = (@eval newfun2() = 1)
-           res = eval(Expr(:call,
-               function()
-                   return ans() + 1
-               end))
-           return res
+           @eval newfun2() = 2
+           Base.invokelatest(newfun2)
        end
 tryeval2 (generic function with 1 method)
 
@@ -545,11 +542,14 @@ Closest candidates are:
 More usefully, it is possible to constrain varargs methods by a parameter. For example:
 
 ```julia
-function getindex{T,N}(A::AbstractArray{T,N}, indexes::Vararg{Number,N})
+function getindex(A::AbstractArray{T,N}, indexes::Vararg{Number,N}) where {T,N}
 ```
 
 would be called only when the number of `indexes` matches the dimensionality of the array.
 
+When only the type of supplied arguments needs to be constrained `Vararg{T}` can be equivalently
+written as `T...`. For instance `f(x::Int...) = x` is a shorthand for `f(x::Vararg{Int}) = x`.
+
 ## Note on Optional and keyword Arguments
 
 As mentioned briefly in [Functions](@ref man-functions), optional arguments are implemented as syntax for multiple
@@ -666,8 +666,8 @@ Below we discuss particular challenges and some alternative ways to resolve such
 `Tuple` (and `NTuple`) arguments present special challenges. For example,
 
 ```julia
-f{N}(x::NTuple{N,Int}) = 1
-f{N}(x::NTuple{N,Float64}) = 2
+f(x::NTuple{N,Int}) where {N} = 1
+f(x::NTuple{N,Float64}) where {N} = 2
 ```
 
 are ambiguous because of the possibility that `N == 0`: there are no
@@ -683,7 +683,7 @@ Alternatively, for all methods but one you can insist that there is at
 least one element in the tuple:
 
 ```julia
-f{N}(x::NTuple{N,Int}) = 1                  # this is the fallback
+f(x::NTuple{N,Int}) where {N} = 1           # this is the fallback
 f(x::Tuple{Float64, Vararg{Float64}}) = 2   # this requires at least one Float64
 ```
 
@@ -721,7 +721,7 @@ A related strategy exploits `promote` to bring `x` and `y` to a common
 type:
 
 ```julia
-f{T}(x::T, y::T) = ...
+f(x::T, y::T) where {T} = ...
 f(x, y) = f(promote(x, y)...)
 ```
 
@@ -761,13 +761,13 @@ Where possible, try to avoid defining methods that dispatch on
 specific element types of abstract containers. For example,
 
 ```julia
--{T<:Date}(A::AbstractArray{T}, b::Date)
+-(A::AbstractArray{T}, b::Date) where {T<:Date}
 ```
 
 generates ambiguities for anyone who defines a method
 
 ```julia
--{T}(A::MyArrayType{T}, b::T)
+-(A::MyArrayType{T}, b::T) where {T}
 ```
 
 The best approach is to avoid defining *either* of these methods:
@@ -784,7 +784,7 @@ can't be modified or eliminated.  As a last resort, one developer can
 define the "band-aid" method
 
 ```julia
--{T<:Date}(A::MyArrayType{T}, b::Date) = ...
+-(A::MyArrayType{T}, b::Date) where {T<:Date} = ...
 ```
 
 that resolves the ambiguity by brute force.
@@ -820,14 +820,14 @@ struct NoPad end  # indicate that no padding is desired, or that it's already ap
 myfilter(A, kernel) = myfilter(A, kernel, Replicate())  # default boundary conditions
 
 function myfilter(A, kernel, ::Replicate)
-    Apadded = pad(A, kernel)
+    Apadded = replicate_edges(A, size(kernel))
     myfilter(Apadded, kernel, NoPad())  # indicate the new boundary conditions
 end
 
 # other padding methods go here
 
 function myfilter(A, kernel, ::NoPad)
-     # Here's the "real" implementation of the core computation
+    # Here's the "real" implementation of the core computation
 end
 ```
 
diff --git a/doc/src/manual/modules.md b/doc/src/manual/modules.md
index 870e3029ea12ae..3063b1d45c41cb 100644
--- a/doc/src/manual/modules.md
+++ b/doc/src/manual/modules.md
@@ -21,7 +21,7 @@ importall OtherLib
 
 export MyType, foo
 
-type MyType
+struct MyType
     x
 end
 
@@ -321,7 +321,7 @@ Other known potential failure scenarios include:
    code snippet:
 
    ```julia
-   type UniquedById
+   mutable struct UniquedById
        myid::Int
        let counter = 0
            UniquedById() = new(counter += 1)
@@ -336,8 +336,8 @@ Other known potential failure scenarios include:
    Note that `object_id` (which works by hashing the memory pointer) has similar issues (see notes
    on `Dict` usage below).
 
-   One alternative is to store both [`current_module()`](@ref) and the current `counter` value, however,
-   it may be better to redesign the code to not depend on this global state.
+   One alternative is to use a macro to capture [`@__MODULE__`](@ref) and store it alone with the current `counter` value,
+   however, it may be better to redesign the code to not depend on this global state.
 2. Associative collections (such as `Dict` and `Set`) need to be re-hashed in `__init__`. (In the
    future, a mechanism may be provided to register an initializer function.)
 3. Depending on compile-time side-effects persisting through load-time. Example include: modifying
diff --git a/doc/src/manual/networking-and-streams.md b/doc/src/manual/networking-and-streams.md
index db4d77564521c8..d2708a16bba69d 100644
--- a/doc/src/manual/networking-and-streams.md
+++ b/doc/src/manual/networking-and-streams.md
@@ -11,7 +11,7 @@ functionality.
 All Julia streams expose at least a [`read()`](@ref) and a [`write()`](@ref) method, taking the
 stream as their first argument, e.g.:
 
-```julia
+```julia-repl
 julia> write(STDOUT,"Hello World");  # suppress return value 11 with ;
 Hello World
 julia> read(STDIN,Char)
@@ -28,7 +28,7 @@ takes the type of the data to be read as the second argument.
 
 For example, to read a simple byte array, we could do:
 
-```julia
+```julia-repl
 julia> x = zeros(UInt8, 4)
 4-element Array{UInt8,1}:
  0x00
@@ -48,7 +48,7 @@ abcd
 However, since this is slightly cumbersome, there are several convenience methods provided. For
 example, we could have written the above as:
 
-```julia
+```julia-repl
 julia> read(STDIN,4)
 abcd
 4-element Array{UInt8,1}:
@@ -60,7 +60,7 @@ abcd
 
 or if we had wanted to read the entire line instead:
 
-```julia
+```julia-repl
 julia> readline(STDIN)
 abcd
 "abcd"
@@ -120,7 +120,7 @@ Like many other environments, Julia has an [`open()`](@ref) function, which take
 returns an `IOStream` object that you can use to read and write things from the file. For example
 if we have a file, `hello.txt`, whose contents are `Hello, World!`:
 
-```julia
+```julia-repl
 julia> f = open("hello.txt")
 IOStream(<file hello.txt>)
 
@@ -131,7 +131,7 @@ julia> readlines(f)
 
 If you want to write to a file, you can open it with the write (`"w"`) flag:
 
-```julia
+```julia-repl
 julia> f = open("hello.txt","w")
 IOStream(<file hello.txt>)
 
@@ -143,7 +143,7 @@ If you examine the contents of `hello.txt` at this point, you will notice that i
 has actually been written to disk yet. This is because the `IOStream` must be closed before the
 write is actually flushed to disk:
 
-```julia
+```julia-repl
 julia> close(f)
 ```
 
@@ -156,13 +156,13 @@ file as an argument, and then closes it again. For example, given a function:
 
 ```julia
 function read_and_capitalize(f::IOStream)
-    return uppercase(readstring(f))
+    return uppercase(read(f, String))
 end
 ```
 
 You can call:
 
-```julia
+```julia-repl
 julia> open(read_and_capitalize, "hello.txt")
 "HELLO AGAIN."
 ```
@@ -173,9 +173,9 @@ contents.
 To avoid even having to define a named function, you can use the `do` syntax, which creates an
 anonymous function on the fly:
 
-```julia
+```julia-repl
 julia> open("hello.txt") do f
-          uppercase(readstring(f))
+           uppercase(read(f, String))
        end
 "HELLO AGAIN."
 ```
@@ -184,13 +184,13 @@ julia> open("hello.txt") do f
 
 Let's jump right in with a simple example involving TCP sockets. Let's first create a simple server:
 
-```julia
+```julia-repl
 julia> @async begin
-         server = listen(2000)
-         while true
-           sock = accept(server)
-           println("Hello World\n")
-         end
+           server = listen(2000)
+           while true
+               sock = accept(server)
+               println("Hello World\n")
+           end
        end
 Task (runnable) @0x00007fd31dc11ae0
 ```
@@ -200,37 +200,43 @@ usage is somewhat simpler than the raw Unix socket API. The first call to [`list
 create a server waiting for incoming connections on the specified port (2000) in this case. The
 same function may also be used to create various other kinds of servers:
 
-```julia
+```julia-repl
 julia> listen(2000) # Listens on localhost:2000 (IPv4)
-TCPServer(active)
+Base.TCPServer(active)
 
 julia> listen(ip"127.0.0.1",2000) # Equivalent to the first
-TCPServer(active)
+Base.TCPServer(active)
 
 julia> listen(ip"::1",2000) # Listens on localhost:2000 (IPv6)
-TCPServer(active)
+Base.TCPServer(active)
 
 julia> listen(IPv4(0),2001) # Listens on port 2001 on all IPv4 interfaces
-TCPServer(active)
+Base.TCPServer(active)
 
 julia> listen(IPv6(0),2001) # Listens on port 2001 on all IPv6 interfaces
-TCPServer(active)
+Base.TCPServer(active)
 
-julia> listen("testsocket") # Listens on a UNIX domain socket/named pipe
-PipeServer(active)
-```
+julia> listen("testsocket") # Listens on a UNIX domain socket
+Base.PipeServer(active)
 
-Note that the return type of the last invocation is different. This is because this server does
-not listen on TCP, but rather on a named pipe (Windows) or UNIX domain socket. The difference
-is subtle and has to do with the [`accept()`](@ref) and [`connect()`](@ref) methods. The [`accept()`](@ref)
-method retrieves a connection to the client that is connecting on the server we just created,
-while the [`connect()`](@ref) function connects to a server using the specified method. The [`connect()`](@ref)
-function takes the same arguments as [`listen()`](@ref), so, assuming the environment (i.e. host,
-cwd, etc.) is the same you should be able to pass the same arguments to [`connect()`](@ref) as
-you did to listen to establish the connection. So let's try that out (after having created the
-server above):
+julia> listen("\\\\.\\pipe\\testsocket") # Listens on a Windows named pipe
+Base.PipeServer(active)
+```
 
-```julia
+Note that the return type of the last invocation is different. This is because this server does not
+listen on TCP, but rather on a named pipe (Windows) or UNIX domain socket. Also note that Windows
+named pipe format has to be a specific pattern such that the name prefix (`\\.\pipe\`) uniquely
+identifies the [file type](https://msdn.microsoft.com/en-
+us/library/windows/desktop/aa365783(v=vs.85).aspx). The difference between TCP and named pipes or
+UNIX domain sockets is subtle and has to do with the [`accept()`](@ref) and [`connect()`](@ref)
+methods. The [`accept()`](@ref) method retrieves a connection to the client that is connecting on
+the server we just created, while the [`connect()`](@ref) function connects to a server using the
+specified method. The [`connect()`](@ref) function takes the same arguments as [`listen()`](@ref),
+so, assuming the environment (i.e. host, cwd, etc.) is the same you should be able to pass the same
+arguments to [`connect()`](@ref) as you did to listen to establish the connection. So let's try that
+out (after having created the server above):
+
+```julia-repl
 julia> connect(2000)
 TCPSocket(open, 0 bytes waiting)
 
@@ -250,15 +256,15 @@ task resumed execution (because a connection request was now available), accepte
 printed the message and waited for the next client. Reading and writing works in the same way.
 To see this, consider the following simple echo server:
 
-```julia
+```julia-repl
 julia> @async begin
-         server = listen(2001)
-         while true
-           sock = accept(server)
-           @async while isopen(sock)
-             write(sock,readline(sock))
+           server = listen(2001)
+           while true
+               sock = accept(server)
+               @async while isopen(sock)
+                   write(sock,readline(sock))
+               end
            end
-         end
        end
 Task (runnable) @0x00007fd31dc12e60
 
@@ -266,7 +272,7 @@ julia> clientside = connect(2001)
 TCPSocket(RawFD(28) open, 0 bytes waiting)
 
 julia> @async while true
-          write(STDOUT,readline(clientside))
+           write(STDOUT,readline(clientside))
        end
 Task (runnable) @0x00007fd31dc11870
 
@@ -276,7 +282,7 @@ Hello World from the Echo Server
 
 As with other streams, use [`close()`](@ref) to disconnect the socket:
 
-```julia
+```julia-repl
 julia> close(clientside)
 ```
 
@@ -286,7 +292,7 @@ One of the [`connect()`](@ref) methods that does not follow the [`listen()`](@re
 `connect(host::String,port)`, which will attempt to connect to the host given by the `host` parameter
 on the port given by the port parameter. It allows you to do things like:
 
-```julia
+```julia-repl
 julia> connect("google.com",80)
 TCPSocket(RawFD(30) open, 0 bytes waiting)
 ```
@@ -294,7 +300,7 @@ TCPSocket(RawFD(30) open, 0 bytes waiting)
 At the base of this functionality is [`getaddrinfo()`](@ref), which will do the appropriate address
 resolution:
 
-```julia
+```julia-repl
 julia> getaddrinfo("google.com")
 ip"74.125.226.225"
 ```
diff --git a/doc/src/manual/noteworthy-differences.md b/doc/src/manual/noteworthy-differences.md
index 5457f201dbd6d1..c94e231252499f 100644
--- a/doc/src/manual/noteworthy-differences.md
+++ b/doc/src/manual/noteworthy-differences.md
@@ -52,8 +52,6 @@ may trip up Julia users accustomed to MATLAB:
   * In Julia, functions such as [`sort()`](@ref) that operate column-wise by default (`sort(A)` is
     equivalent to `sort(A,1)`) do not have special behavior for `1xN` arrays; the argument is returned
     unmodified since it still performs `sort(A,1)`. To sort a `1xN` matrix like a vector, use `sort(A,2)`.
-  * In Julia, if `A` is a 2-dimensional array, `fft(A)` computes a 2D FFT. In particular, it is not
-    equivalent to `fft(A,1)`, which computes a 1D FFT acting column-wise.
   * In Julia, parentheses must be used to call a function with zero arguments, like in [`tic()`](@ref)
     and [`toc()`](@ref).
   * Julia discourages the used of semicolons to end statements. The results of statements are not
@@ -207,8 +205,8 @@ For users coming to Julia from R, these are some noteworthy differences:
     be reversed in Julia relative to NumPy (see relevant section of [Performance Tips](@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`.
+    to the result of the right-hand side `B = B + 3`, which is a new array. For in-place operation, use `B .+= 3`
+    (see also [dot operators](@ref man-dot-operators)), 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` returns a new random number every time it is invoked without argument.
@@ -239,11 +237,11 @@ For users coming to Julia from R, these are some noteworthy differences:
     unsigned and/or signed vs. unsigned. Decimal literals are always signed, and hexadecimal literals
     (which start with `0x` like C/C++), are unsigned. Hexadecimal literals also, unlike C/C++/Java
     and unlike decimal literals in Julia, have a type based on the *length* of the literal, including
-    leading 0s.  For example, `0x0` and `0x00` have type UInt8, `0x000` and `0x0000` have type `UInt16`,
-    then literals with 5 to 8 hex digits have type `UInt32`, 9 to 16 hex digits type `UInt64` and
-    17 to 32 hex digits type `UInt128`. This needs to be taken into account when defining hexadecimal
-    masks, for example `~0xf == 0xf0` is very different from `~0x000f == 0xfff0`. 64 bit `Float64`
-    and 32 bit `Float32` bit literals are expressed as `1.0` and `1.0f0` respectively. Floating point
+    leading 0s. For example, `0x0` and `0x00` have type [`UInt8`](@ref), `0x000` and `0x0000` have type
+    [`UInt16`](@ref), then literals with 5 to 8 hex digits have type `UInt32`, 9 to 16 hex digits type
+    `UInt64` and 17 to 32 hex digits type `UInt128`. This needs to be taken into account when defining
+    hexadecimal masks, for example `~0xf == 0xf0` is very different from `~0x000f == 0xfff0`. 64 bit `Float64`
+    and 32 bit [`Float32`](@ref) bit literals are expressed as `1.0` and `1.0f0` respectively. Floating point
     literals are rounded (and not promoted to the `BigFloat` type) if they can not be exactly represented.
      Floating point literals are closer in behavior to C/C++. Octal (prefixed with `0o`) and binary
     (prefixed with `0b`) literals are also treated as unsigned.
@@ -251,7 +249,7 @@ For users coming to Julia from R, these are some noteworthy differences:
     `"` 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`](@ref) 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. `(a, b) = myfunction()` or
diff --git a/doc/src/manual/packages.md b/doc/src/manual/packages.md
index 0eb96ac70ee6f0..569806656811f5 100644
--- a/doc/src/manual/packages.md
+++ b/doc/src/manual/packages.md
@@ -16,7 +16,7 @@ add your code to the curated METADATA repository.
 The [`Pkg.status()`](@ref) function prints out a summary of the state of packages you have installed.
 Initially, you'll have no packages installed:
 
-```julia
+```julia-repl
 julia> Pkg.status()
 INFO: Initializing package repository /Users/stefan/.julia/v0.6
 INFO: Cloning METADATA from git://github.com/JuliaLang/METADATA.jl
@@ -27,11 +27,11 @@ Your package directory is automatically initialized the first time you run a `Pk
 that expects it to exist – which includes [`Pkg.status()`](@ref). Here's an example non-trivial
 set of required and additional packages:
 
-```julia
+```julia-repl
 julia> Pkg.status()
 Required packages:
  - Distributions                 0.2.8
- - UTF16                         0.2.0
+ - SHA                           0.3.2
 Additional packages:
  - NumericExtensions             0.2.17
  - Stats                         0.2.6
@@ -43,12 +43,12 @@ will explain these states and annotations as we encounter them. For programmatic
 returns a dictionary, mapping installed package names to the version of that package which is
 installed:
 
-```julia
+```julia-repl
 julia> Pkg.installed()
 Dict{String,VersionNumber} with 4 entries:
 "Distributions"     => v"0.2.8"
 "Stats"             => v"0.2.6"
-"UTF16"             => v"0.2.0"
+"SHA"               => v"0.3.2"
 "NumericExtensions" => v"0.2.17"
 ```
 
@@ -73,7 +73,7 @@ commands, which add or remove a single requirement to `REQUIRE` and then call [`
 You can add a package to the list of requirements with the [`Pkg.add()`](@ref) function, and the
 package and all the packages that it depends on will be installed:
 
-```julia
+```julia-repl
 julia> Pkg.status()
 No packages installed.
 
@@ -106,23 +106,23 @@ that the `Distributions` package should be installed since it is required but no
 stated before, you can accomplish the same thing by editing your `~/.julia/v0.6/REQUIRE` file
 by hand and then running [`Pkg.resolve()`](@ref) yourself:
 
-```julia
-$ echo UTF16 >> ~/.julia/v0.6/REQUIRE
+```julia-repl
+$ echo SHA >> ~/.julia/v0.6/REQUIRE
 
 julia> Pkg.resolve()
-INFO: Cloning cache of UTF16 from git://github.com/nolta/UTF16.jl.git
-INFO: Installing UTF16 v0.2.0
+INFO: Cloning cache of SHA from git://github.com/staticfloat/SHA.jl.git
+INFO: Installing SHA v0.3.2
 
 julia> Pkg.status()
 Required packages:
  - Distributions                 0.2.7
- - UTF16                         0.2.0
+ - SHA                           0.3.2
 Additional packages:
  - NumericExtensions             0.2.17
  - Stats                         0.2.6
 ```
 
-This is functionally equivalent to calling [`Pkg.add("UTF16")`](@ref), except that [`Pkg.add()`](@ref)
+This is functionally equivalent to calling [`Pkg.add("SHA")`](@ref), except that [`Pkg.add()`](@ref)
 doesn't change `REQUIRE` until *after* installation has completed, so if there are problems,
 `REQUIRE` will be left as it was before calling [`Pkg.add()`](@ref). The format of the `REQUIRE`
 file is described in [Requirements Specification](@ref); it allows, among other things, requiring
@@ -131,7 +131,7 @@ specific ranges of versions of packages.
 When you decide that you don't want to have a package around any more, you can use [`Pkg.rm()`](@ref)
 to remove the requirement for it from the `REQUIRE` file:
 
-```julia
+```julia-repl
 julia> Pkg.rm("Distributions")
 INFO: Removing Distributions v0.2.7
 INFO: Removing Stats v0.2.6
@@ -140,10 +140,10 @@ INFO: REQUIRE updated.
 
 julia> Pkg.status()
 Required packages:
- - UTF16                         0.2.0
+ - SHA                           0.3.2
 
-julia> Pkg.rm("UTF16")
-INFO: Removing UTF16 v0.2.0
+julia> Pkg.rm("SHA")
+INFO: Removing SHA v0.3.2
 INFO: REQUIRE updated.
 
 julia> Pkg.status()
@@ -171,6 +171,15 @@ git config --global url."https://".insteadOf git://
 
 However, this change will be system-wide and thus the use of [`Pkg.setprotocol!()`](@ref) is preferable.
 
+!!! note
+    The package manager functions also accept the `.jl` suffix on package names, though the suffix is
+    stripped internally. For example:
+
+    ```julia
+    Pkg.add("Distributions.jl")
+    Pkg.rm("Distributions.jl")
+    ```
+
 ## Offline Installation of Packages
 
 For machines with no Internet connection, packages may be installed by copying the package root
@@ -198,7 +207,7 @@ in the previous section interact with registered packages, but the package manag
 and work with unregistered packages too. To install an unregistered package, use [`Pkg.clone(url)`](@ref),
 where `url` is a git URL from which the package can be cloned:
 
-```julia
+```julia-repl
 julia> Pkg.clone("git://example.com/path/to/Package.jl.git")
 INFO: Cloning Package from git://example.com/path/to/Package.jl.git
 Cloning into 'Package'...
@@ -233,7 +242,7 @@ When package developers publish new registered versions of packages that you're
 of course, want the new shiny versions. To get the latest and greatest versions of all your packages,
 just do [`Pkg.update()`](@ref):
 
-```julia
+```julia-repl
 julia> Pkg.update()
 INFO: Updating METADATA...
 INFO: Computing changes...
@@ -267,7 +276,7 @@ You can also update only a subset of the installed packages, by providing argume
 function. In that case, only the packages provided as arguments and their dependencies will be
 updated:
 
-```julia
+```julia-repl
 julia> Pkg.update("Example")
 INFO: Updating METADATA...
 INFO: Computing changes...
@@ -286,7 +295,7 @@ registered versions, or you may be a developer of the package and need to make c
 or some other development branch. In such cases, you can do [`Pkg.checkout(pkg)`](@ref) to checkout
 the `master` branch of `pkg` or [`Pkg.checkout(pkg,branch)`](@ref) to checkout some other branch:
 
-```julia
+```julia-repl
 julia> Pkg.add("Distributions")
 INFO: Installing Distributions v0.2.9
 INFO: Installing NumericExtensions v0.2.17
@@ -328,7 +337,7 @@ for this (described below).
 When you decide that you no longer want to have a package checked out on a branch, you can "free"
 it back to the control of the package manager with [`Pkg.free(pkg)`](@ref):
 
-```julia
+```julia-repl
 julia> Pkg.free("Distributions")
 INFO: Freeing Distributions...
 INFO: No packages to install, update or remove.
@@ -347,7 +356,7 @@ be updated as new registered versions of the package are published.
 If you want to pin a package at a specific version so that calling [`Pkg.update()`](@ref) won't
 change the version the package is on, you can use the [`Pkg.pin()`](@ref) function:
 
-```julia
+```julia-repl
 julia> Pkg.pin("Stats")
 INFO: Creating Stats branch pinned.47c198b1.tmp
 
@@ -365,7 +374,7 @@ the same thing. [`Pkg.pin()`](@ref) works by creating a throw-away branch for th
 to pin the package at and then checking that branch out. By default, it pins a package at the
 current commit, but you can choose a different version by passing a second argument:
 
-```julia
+```julia-repl
 julia> Pkg.pin("Stats",v"0.2.5")
 INFO: Creating Stats branch pinned.1fd0983b.tmp
 INFO: No packages to install, update or remove.
@@ -382,7 +391,7 @@ Now the `Stats` package is pinned at commit `1fd0983b`, which corresponds to ver
 When you decide to "unpin" a package and let the package manager update it again, you can use
 [`Pkg.free()`](@ref) like you would to move off of any branch:
 
-```julia
+```julia-repl
 julia> Pkg.free("Stats")
 INFO: Freeing Stats...
 INFO: No packages to install, update or remove.
@@ -415,7 +424,7 @@ local metadata repository using that custom location and branch and then periodi
 custom branch with the official `metadata-v2` branch. In order to use a custom repository and
 branch, issue the following command:
 
-```julia
+```julia-repl
 julia> Pkg.init("https://me.example.com/METADATA.jl.git", "branch")
 ```
 
@@ -516,7 +525,7 @@ starting with `Pkg.` or `PkgDev.` is meant to be typed at the Julia prompt; anyt
 with `git` is meant to be typed in [julia's shell mode](@ref man-shell-mode) (or using the shell that comes with
 your operating system). Within Julia, you can combine these two modes:
 
-```julia
+```julia-repl
 julia> cd(Pkg.dir("Foo"))          # go to Foo's folder
 
 shell> git command arguments...    # command will apply to Foo
@@ -734,7 +743,7 @@ Suppose you want to create a new Julia package called `FooBar`. To get started,
 where `pkg` is the new package name and `license` is the name of a license that the package generator
 knows about:
 
-```julia
+```julia-repl
 julia> PkgDev.generate("FooBar","MIT")
 INFO: Initializing FooBar repo: /Users/stefan/.julia/v0.6/FooBar
 INFO: Origin: git://github.com/StefanKarpinski/FooBar.jl.git
@@ -821,7 +830,7 @@ For your package, it will be your GitHub user name and the name of your package,
 idea. People you send this URL to can use [`Pkg.clone()`](@ref) to install the package and try
 it out:
 
-```julia
+```julia-repl
 julia> Pkg.clone("git://github.com/StefanKarpinski/FooBar.jl.git")
 INFO: Cloning FooBar from git@github.com:StefanKarpinski/FooBar.jl.git
 ```
@@ -840,7 +849,7 @@ INFO: Cloning FooBar from git@github.com:StefanKarpinski/FooBar.jl.git
 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 `PkgDev.register()`:
 
-```julia
+```julia-repl
 julia> PkgDev.register("FooBar")
 INFO: Registering FooBar at git://github.com/StefanKarpinski/FooBar.jl.git
 INFO: Committing METADATA for FooBar
@@ -871,7 +880,7 @@ need to merge your local `METADATA` upstream into the official repo. The `PkgDev
 will fork the `METADATA` repository on GitHub, push your changes to your fork, and open a pull
 request:
 
-```julia
+```julia-repl
 julia> PkgDev.publish()
 INFO: Validating METADATA
 INFO: No new package versions to publish
@@ -894,14 +903,14 @@ INFO: To create a pull-request open:
     is to delete the "Julia Package Manager" personal access token [from your Github account](https://github.com/login?return_to=https%3A%2F%2Fgithub.com%2Fsettings%2Ftokens)
     and try again.
 
-    Other failures may require you to circumvent `PkgDev.publish()` by [creating a pull request on GitHub](https://help.github.com/articles/creating-a-pull-request).
+    Other failures may require you to circumvent `PkgDev.publish()` by [creating a pull request on GitHub](https://help.github.com/articles/creating-a-pull-request/).
     See: [Publishing METADATA manually](@ref) 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 `PkgDev.tag()` command:
 
-```julia
+```julia-repl
 julia> PkgDev.tag("FooBar")
 INFO: Tagging FooBar v0.0.1
 INFO: Committing METADATA for FooBar
@@ -949,7 +958,7 @@ they've been included upstream. Again, use the `PkgDev.publish()` command, which
 that individual package repos have been tagged, pushes them if they haven't already been, and
 then opens a pull request to `METADATA`:
 
-```julia
+```julia-repl
 julia> PkgDev.publish()
 INFO: Validating METADATA
 INFO: Pushing FooBar permanent tags: v0.0.1
@@ -1071,7 +1080,7 @@ If a requirement line has leading words that begin with `@`, it is a system-depe
 If your system matches these system conditionals, the requirement is included, if not, the requirement
 is ignored. For example:
 
-```julia
+```
 @osx Homebrew
 ```
 
@@ -1089,7 +1098,7 @@ conditions that are currently supported are (hierarchically):
 The `@unix` condition is satisfied on all UNIX systems, including Linux and BSD. Negated system
 conditionals are also supported by adding a `!` after the leading `@`. Examples:
 
-```julia
+```
 @!windows
 @unix @!osx
 ```
diff --git a/doc/src/manual/parallel-computing.md b/doc/src/manual/parallel-computing.md
index ec83bae36cd5f7..0d31a561f149ed 100644
--- a/doc/src/manual/parallel-computing.md
+++ b/doc/src/manual/parallel-computing.md
@@ -71,7 +71,7 @@ you read from a remote object to obtain data needed by the next local operation.
 [`remotecall_fetch()`](@ref) exists for this purpose. It is equivalent to `fetch(remotecall(...))`
 but is more efficient.
 
-```julia
+```julia-repl
 julia> remotecall_fetch(getindex, 2, r, 1, 1)
 0.18526337335308085
 ```
@@ -83,7 +83,7 @@ The syntax of [`remotecall()`](@ref) is not especially convenient. The macro [`@
 makes things easier. It operates on an expression rather than a function, and picks where to do
 the operation for you:
 
-```julia
+```julia-repl
 julia> r = @spawn rand(2,2)
 Future(2, 1, 4, Nullable{Any}())
 
@@ -113,7 +113,7 @@ have fetched, the remote stored value is deleted.
 Your code must be available on any process that runs it. For example, type the following into
 the Julia prompt:
 
-```julia
+```julia-repl
 julia> function rand2(dims...)
            return 2*rand(dims...)
        end
@@ -131,7 +131,7 @@ ERROR: RemoteException(2, CapturedException(UndefVarError(Symbol("#rand2"))
 Process 1 knew about the function `rand2`, but process 2 did not.
 
 Most commonly you'll be loading code from files or packages, and you have a considerable amount
-of flexibility in controlling which processes load code. Consider a file, `"DummyModule.jl"`,
+of flexibility in controlling which processes load code. Consider a file, `DummyModule.jl`,
 containing the following code:
 
 ```julia
@@ -152,8 +152,8 @@ end
 
 Starting Julia with `julia -p 2`, you can use this to verify the following:
 
-  * [`include("DummyModule.jl")`](@ref) loads the file on just a single process (whichever one executes
-    the statement).
+  * `include("DummyModule.jl")` loads the file on just a single process
+    (whichever one executes the statement).
   * `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
@@ -169,7 +169,7 @@ Starting Julia with `julia -p 2`, you can use this to verify the following:
 You can force a command to run on all processes using the [`@everywhere`](@ref) macro. For example, `@everywhere`
 can also be used to directly define a function on all processes:
 
-```julia
+```julia-repl
 julia> @everywhere id = myid()
 
 julia> remotecall_fetch(()->id, 2)
@@ -216,7 +216,7 @@ operation. Consider these two approaches to constructing and squaring a random m
 
 Method 1:
 
-```julia
+```julia-repl
 julia> A = rand(1000,1000);
 
 julia> Bref = @spawn A^2;
@@ -228,7 +228,7 @@ julia> fetch(Bref);
 
 Method 2:
 
-```julia
+```julia-repl
 julia> Bref = @spawn rand(1000,1000)^2;
 
 [...]
@@ -256,13 +256,17 @@ Expressions executed remotely via `@spawn`, or closures specified for remote exe
 a little differently compared to global bindings in other modules. Consider the following code
 snippet:
 
-```julia
+```julia-repl
 A = rand(10,10)
-remotecall_fetch(()->foo(A), 2)
+remotecall_fetch(()->norm(A), 2)
 ```
 
+In this case [`norm`](@ref) is a function that takes 2D array as a parameter, and MUST be defined in
+the remote process.  You could use any function other than `norm` as long as it is defined in the remote
+process and accepts the appropriate parameter.
+
 Note that `A` is a global variable defined in the local workspace. Worker 2 does not have a variable called
-`A` under `Main`. The act of shipping the closure `()->foo(A)` to worker 2 results in `Main.A` being defined
+`A` under `Main`. The act of shipping the closure `()->norm(A)` to worker 2 results in `Main.A` being defined
 on 2. `Main.A` continues to exist on worker 2 even after the call `remotecall_fetch` returns. Remote calls
 with embedded global references (under `Main` module only) manage globals as follows:
 
@@ -276,9 +280,9 @@ with embedded global references (under `Main` module only) manage globals as fol
 
   ```julia
   A = rand(10,10)
-  remotecall_fetch(()->foo(A), 2) # worker 2
+  remotecall_fetch(()->norm(A), 2) # worker 2
   A = rand(10,10)
-  remotecall_fetch(()->foo(A), 3) # worker 3
+  remotecall_fetch(()->norm(A), 3) # worker 3
   A = nothing
   ```
 
@@ -296,7 +300,7 @@ altogether if possible. If you must reference globals, consider using `let` bloc
 
 For example:
 
-```julia
+```julia-repl
 julia> A = rand(10,10);
 
 julia> remotecall_fetch(()->A, 2);
@@ -339,8 +343,8 @@ end
 The function `count_heads` simply adds together `n` random bits. Here is how we can perform some
 trials on two machines, and add together the results:
 
-```julia
-julia> @everywhere include("count_heads.jl")
+```julia-repl
+julia> @everywhere include_string(Main, $(read("count_heads.jl", String)), "count_heads.jl")
 
 julia> a = @spawn count_heads(100000000)
 Future(2, 1, 6, Nullable{Any}())
@@ -424,7 +428,7 @@ in some range (or, more generally, to all elements in some collection). This is
 operation called *parallel map*, implemented in Julia as the [`pmap()`](@ref) function. For example,
 we could compute the singular values of several large random matrices in parallel as follows:
 
-```julia
+```julia-repl
 julia> M = Matrix{Float64}[rand(1000,1000) for i = 1:10];
 
 julia> pmap(svd, M);
@@ -453,7 +457,7 @@ work to processes only when they finish their current tasks.
 
 As an example, consider computing the singular values of matrices of different sizes:
 
-```julia
+```julia-repl
 julia> M = Matrix{Float64}[rand(800,800), rand(600,600), rand(800,800), rand(600,600)];
 
 julia> pmap(svd, M);
@@ -520,7 +524,7 @@ A channel can be visualized as a pipe, i.e., it has a write end and read end.
   * Multiple readers in different tasks can read data concurrently via [`take!()`](@ref) calls.
   * As an example:
 
-    ```
+    ```julia
     # Given Channels c1 and c2,
     c1 = Channel(32)
     c2 = Channel(32)
@@ -553,7 +557,7 @@ A channel can be visualized as a pipe, i.e., it has a write end and read end.
     freely via [`take!()`](@ref) and [`put!()`](@ref) calls. [`close()`](@ref) closes a [`Channel`](@ref).
     On a closed [`Channel`](@ref), [`put!()`](@ref) will fail. For example:
 
-```julia
+```julia-repl
 julia> c = Channel(2);
 
 julia> put!(c, 1) # `put!` on an open channel succeeds
@@ -569,7 +573,7 @@ ERROR: InvalidStateException("Channel is closed.",:closed)
   * [`take!()`](@ref) and [`fetch()`](@ref) (which retrieves but does not remove the value) on a closed
     channel successfully return any existing values until it is emptied. Continuing the above example:
 
-```julia
+```julia-repl
 julia> fetch(c) # Any number of `fetch` calls succeed.
 1
 
@@ -590,7 +594,7 @@ long as the `Channel` has data or is open. The loop variable takes on all values
 
 For example, the following would cause the `for` loop to wait for more data:
 
-```julia
+```julia-repl
 julia> c = Channel{Int}(10);
 
 julia> foreach(i->put!(c, i), 1:3) # add a few entries
@@ -600,7 +604,7 @@ julia> data = [i for i in c]
 
 while this will return after reading all data:
 
-```julia
+```julia-repl
 julia> c = Channel{Int}(10);
 
 julia> foreach(i->put!(c, i), 1:3); # add a few entries
@@ -620,7 +624,7 @@ Each task in this simulation reads a `job_id`, waits for a random amout of time
 a tuple of `job_id` and the simulated time to the results channel. Finally all the `results` are
 printed out.
 
-```julia
+```julia-repl
 julia> const jobs = Channel{Int}(32);
 
 julia> const results = Channel{Tuple}(32);
@@ -725,7 +729,7 @@ are written to the channel. Each remotely executing task in this simulation read
 waits for a random amount of time and writes back a tuple of `job_id`, time taken and its own
 `pid` to the results channel. Finally all the `results` are printed out on the master process.
 
-```julia
+```julia-repl
 julia> addprocs(4); # add worker processes
 
 julia> const jobs = RemoteChannel(()->Channel{Int}(32));
@@ -752,7 +756,7 @@ julia> n = 12;
 julia> @schedule make_jobs(n); # feed the jobs channel with "n" jobs
 
 julia> for p in workers() # start tasks on the workers to process requests in parallel
-           @async remote_do(do_work, p, jobs, results)
+           remote_do(do_work, p, jobs, results)
        end
 
 julia> @elapsed while n > 0 # print out results
@@ -777,14 +781,16 @@ julia> @elapsed while n > 0 # print out results
 
 ## 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.
+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`](@ref) or a (unfetched) [`Future`](@ref) is serialized to a worker,
 the node pointed to by the reference is notified. And every time a [`RemoteChannel`](@ref) or
 a (unfetched) [`Future`](@ref) is garbage collected locally, the node owning the value is again
-notified.
+notified. This is implemented in an internal cluster aware serializer. Remote references are only
+valid in the context of a running cluster. Serializing and deserializing references to and from
+regular `IO` objects is not supported.
 
 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
@@ -814,8 +820,8 @@ Once finalized, a reference becomes invalid and cannot be used in any further ca
 ## [Shared Arrays](@id man-shared-arrays)
 
 Shared Arrays use system shared memory to map the same array across many processes. While there
-are some similarities to a [DArray](https://github.com/JuliaParallel/DistributedArrays.jl), the
-behavior of a [`SharedArray`](@ref) is quite different. In a [DArray](https://github.com/JuliaParallel/DistributedArrays.jl),
+are some similarities to a [`DArray`](https://github.com/JuliaParallel/DistributedArrays.jl), the
+behavior of a [`SharedArray`](@ref) is quite different. In a [`DArray`](https://github.com/JuliaParallel/DistributedArrays.jl),
 each process has local access to just a chunk of the data, and no two processes share the same
 chunk; in contrast, in a [`SharedArray`](@ref) each "participating" process has access to the
 entire array.  A [`SharedArray`](@ref) is a good choice when you want to have a large amount of
@@ -845,7 +851,7 @@ portion of the array, thereby parallelizing initialization.
 
 Here's a brief example:
 
-```julia
+```julia-repl
 julia> addprocs(3)
 3-element Array{Int64,1}:
  2
@@ -872,7 +878,7 @@ julia> S
 convenient for splitting up tasks among processes. You can, of course, divide the work any way
 you wish:
 
-```julia
+```julia-repl
 julia> S = SharedArray{Int,2}((3,4), init = S -> S[indexpids(S):length(procs(S)):length(S)] = myid())
 3×4 SharedArray{Int64,2}:
  2  2  2  2
@@ -910,7 +916,7 @@ not be ready at the time it's needed for computing `q[i,j,t+1]`. In such cases,
 off chunking the array manually. Let's split along the second dimension.
 Define a function that returns the `(irange, jrange)` indexes assigned to this worker:
 
-```julia
+```julia-repl
 julia> @everywhere function myrange(q::SharedArray)
            idx = indexpids(q)
            if idx == 0 # This worker is not assigned a piece
@@ -924,11 +930,11 @@ julia> @everywhere function myrange(q::SharedArray)
 
 Next, define the kernel:
 
-```julia
+```julia-repl
 julia> @everywhere function advection_chunk!(q, u, irange, jrange, trange)
            @show (irange, jrange, trange)  # display so we can see what's happening
            for t in trange, j in jrange, i in irange
-               q[i,j,t+1] = q[i,j,t] +  u[i,j,t]
+               q[i,j,t+1] = q[i,j,t] + u[i,j,t]
            end
            q
        end
@@ -936,20 +942,20 @@ julia> @everywhere function advection_chunk!(q, u, irange, jrange, trange)
 
 We also define a convenience wrapper for a `SharedArray` implementation
 
-```julia
+```julia-repl
 julia> @everywhere advection_shared_chunk!(q, u) =
            advection_chunk!(q, u, myrange(q)..., 1:size(q,3)-1)
 ```
 
 Now let's compare three different versions, one that runs in a single process:
 
-```julia
+```julia-repl
 julia> advection_serial!(q, u) = advection_chunk!(q, u, 1:size(q,1), 1:size(q,2), 1:size(q,3)-1);
 ```
 
 one that uses [`@parallel`](@ref):
 
-```julia
+```julia-repl
 julia> function advection_parallel!(q, u)
            for t = 1:size(q,3)-1
                @sync @parallel for j = 1:size(q,2)
@@ -964,7 +970,7 @@ julia> function advection_parallel!(q, u)
 
 and one that delegates in chunks:
 
-```julia
+```julia-repl
 julia> function advection_shared!(q, u)
            @sync begin
                for p in procs(q)
@@ -977,7 +983,7 @@ julia> function advection_shared!(q, u)
 
 If we create `SharedArray`s and time these functions, we get the following results (with `julia -p 4`):
 
-```julia
+```julia-repl
 julia> q = SharedArray{Float64,3}((500,500,500));
 
 julia> u = SharedArray{Float64,3}((500,500,500));
@@ -985,7 +991,7 @@ julia> u = SharedArray{Float64,3}((500,500,500));
 
 Run the functions once to JIT-compile and [`@time`](@ref) them on the second run:
 
-```julia
+```julia-repl
 julia> @time advection_serial!(q, u);
 (irange,jrange,trange) = (1:500,1:500,1:499)
  830.220 milliseconds (216 allocations: 13820 bytes)
@@ -1099,11 +1105,18 @@ The [`launch()`](@ref) method is called asynchronously in a separate task. The t
 this task signals that all requested workers have been launched. Hence the [`launch()`](@ref)
 function MUST exit as soon as all the requested workers have been launched.
 
-Newly launched workers are connected to each other, and the master process, in an all-to-all manner.
-Specifying the command argument `--worker <cookie>` results in the launched processes initializing
-themselves as workers and connections being set up via TCP/IP sockets. Optionally, `--bind-to bind_addr[:port]`
-may also be specified to enable other workers to connect to it at the specified `bind_addr` and
-`port`. This is useful for multi-homed hosts.
+Newly launched workers are connected to each other and the master process in an all-to-all manner.
+Specifying the command line argument `--worker[=<cookie>]` results in the launched processes
+initializing themselves as workers and connections being set up via TCP/IP sockets.
+
+All workers in a cluster share the same [cookie](#cluster-cookie) as the master. When the cookie is
+unspecified, i.e, with the `--worker` option, the worker tries to read it from its standard input.
+ `LocalManager` and `SSHManager` both pass the cookie to newly launched workers via their
+ standard inputs.
+
+By default a worker will listen on a free port at the address returned by a call to `getipaddr()`.
+A specific address to listen on may be specified by optional argument `--bind-to bind_addr[:port]`.
+This is useful for multi-homed hosts.
 
 As an example of a non-TCP/IP transport, an implementation may choose to use MPI, in which case
 `--worker` must NOT be specified. Instead, newly launched workers should call `init_worker(cookie)`
@@ -1231,8 +1244,8 @@ as local laptops, departmental clusters, or even the cloud. This section covers
 requirements for the inbuilt `LocalManager` and `SSHManager`:
 
   * The master process does not listen on any port. It only connects out to the workers.
-  * Each worker binds to only one of the local interfaces and listens on the first free port starting
-    from `9009`.
+  * Each worker binds to only one of the local interfaces and listens on an ephemeral port number
+    assigned by the OS.
   * `LocalManager`, used by `addprocs(N)`, by default binds only to the loopback interface. This means
     that workers started later on remote hosts (or by anyone with malicious intentions) are unable
     to connect to the cluster. An `addprocs(4)` followed by an `addprocs(["remote_host"])` will fail.
@@ -1250,8 +1263,9 @@ requirements for the inbuilt `LocalManager` and `SSHManager`:
     authenticated via public key infrastructure (PKI). Authentication credentials can be supplied
     via `sshflags`, for example ```sshflags=`-e <keyfile>` ```.
 
-    Note that worker-worker connections are still plain TCP and the local security policy on the remote
-    cluster must allow for free connections between worker nodes, at least for ports 9009 and above.
+    In an all-to-all topology (the default), all workers connect to each other via plain TCP sockets.
+    The security policy on the cluster nodes must thus ensure free connectivity between workers for
+    the ephemeral port range (varies by OS).
 
     Securing and encrypting all worker-worker traffic (via SSH) or encrypting individual messages
     can be done via a custom ClusterManager.
@@ -1265,10 +1279,12 @@ on the master process:
     it and returns the new cookie.
   * All connections are authenticated on both sides to ensure that only workers started by the master
     are allowed to connect to each other.
-  * The cookie must be passed to the workers at startup via argument `--worker <cookie>`. Custom ClusterManagers
-    can retrieve the cookie on the master by calling [`Base.cluster_cookie()`](@ref). Cluster managers
-    not using the default TCP/IP transport (and hence not specifying `--worker`) must call `init_worker(cookie, manager)`
-    with the same cookie as on the master.
+  * The cookie may be passed to the workers at startup via argument `--worker=<cookie>`. If argument
+    `--worker` is specified without the cookie, the worker tries to read the cookie from its
+    standard input (STDIN). The STDIN is closed immediately after the cookie is retrieved.
+  * ClusterManagers can retrieve the cookie on the master by calling [`Base.cluster_cookie()`](@ref).
+    Cluster managers not using the default TCP/IP transport (and hence not specifying `--worker`)
+    must call `init_worker(cookie, manager)` with the same cookie as on the master.
 
 Note that environments requiring higher levels of security can implement this via a custom `ClusterManager`.
 For example, cookies can be pre-shared and hence not specified as a startup argument.
@@ -1284,6 +1300,12 @@ connected to each other:
     fields `ident` and `connect_idents` in `WorkerConfig`. A worker with a cluster-manager-provided
     identity `ident` will connect to all workers specified in `connect_idents`.
 
+Keyword argument `lazy=true|false` only affects `topology` option `:all_to_all`. If `true`, the cluster
+starts off with the master connected to all workers. Specific worker-worker connections are established
+at the first remote invocation between two workers. This helps in reducing initial resources allocated for
+intra-cluster communication. Connections are setup depending on the runtime requirements of a parallel
+program. Default value for `lazy` is `true`.
+
 Currently, sending a message between unconnected workers results in an error. This behaviour,
 as with the functionality and interface, should be considered experimental in nature and may change
 in future releases.
@@ -1299,7 +1321,7 @@ in the future.
 By default, Julia starts up with a single thread of execution. This can be verified by using the
 command [`Threads.nthreads()`](@ref):
 
-```julia
+```julia-repl
 julia> Threads.nthreads()
 1
 ```
@@ -1307,7 +1329,7 @@ julia> Threads.nthreads()
 The number of threads Julia starts up with is controlled by an environment variable called `JULIA_NUM_THREADS`.
 Now, let's start up Julia with 4 threads:
 
-```
+```bash
 export JULIA_NUM_THREADS=4
 ```
 
@@ -1317,14 +1339,14 @@ start up the command line in the location of `julia.exe` and use `set` instead o
 
 Let's verify there are 4 threads at our disposal.
 
-```julia
+```julia-repl
 julia> Threads.nthreads()
 4
 ```
 
 But we are currently on the master thread. To check, we use the command [`Threads.threadid()`](@ref)
 
-```julia
+```julia-repl
 julia> Threads.threadid()
 1
 ```
@@ -1354,7 +1376,7 @@ thread ID into each location.
 Julia supports parallel loops using the [`Threads.@threads`](@ref) macro. This macro is affixed
 in front of a `for` loop to indicate to Julia that the loop is a multi-threaded region:
 
-```julia
+```julia-repl
 julia> Threads.@threads for i = 1:10
            a[i] = Threads.threadid()
        end
@@ -1363,7 +1385,7 @@ julia> Threads.@threads for i = 1:10
 The iteration space is split amongst the threads, after which each thread writes its thread ID
 to its assigned locations:
 
-```julia
+```julia-repl
 julia> a
 10-element Array{Float64,1}:
  1.0
@@ -1413,5 +1435,4 @@ It is very important that the called function does not call back into Julia.
     In this context, MPI refers to the MPI-1 standard. Beginning with MPI-2, the MPI standards committee
     introduced a new set of communication mechanisms, collectively referred to as Remote Memory Access
     (RMA). The motivation for adding RMA to the MPI standard was to facilitate one-sided communication
-    patterns. For additional information on the latest MPI standard, see [http://mpi-forum.org/docs](http://mpi-forum.org/docs).
-
+    patterns. For additional information on the latest MPI standard, see [http://mpi-forum.org/docs](http://mpi-forum.org/docs/).
diff --git a/doc/src/manual/performance-tips.md b/doc/src/manual/performance-tips.md
index 5c49243f4516ca..f0f5fcb3563278 100644
--- a/doc/src/manual/performance-tips.md
+++ b/doc/src/manual/performance-tips.md
@@ -34,13 +34,13 @@ being done, and what their inputs and outputs are.
 
 In the following REPL session:
 
-```julia
+```julia-repl
 julia> x = 1.0
 ```
 
 is equivalent to:
 
-```julia
+```julia-repl
 julia> global x = 1.0
 ```
 
@@ -51,7 +51,7 @@ so all the performance issues discussed previously apply.
 A useful tool for measuring performance is the [`@time`](@ref) macro. The following example
 illustrates good working style:
 
-```julia
+```julia-repl
 julia> function f(n)
            s = 0
            for i = 1:n
@@ -81,14 +81,14 @@ problem with type-stability. Consequently, in addition to the allocation itself,
 that the code generated for your function is far from optimal. Take such indications seriously
 and follow the advice below.
 
-For more serious benchmarking, consider the [`BenchmarkTools.jl`](https://github.com/JuliaCI/BenchmarkTools.jl)
+For more serious benchmarking, consider the [BenchmarkTools.jl](https://github.com/JuliaCI/BenchmarkTools.jl)
 package which evaluates the function multiple times in order to reduce noise.
 
 As a teaser, an improved version of this function allocates no memory
 (the allocation reported below is due to running the `@time` macro in global scope)
 and has an order of magnitude faster execution after the first call:
 
-```julia
+```julia-repl
 julia> @time f_improved(1)
   0.007008 seconds (1.32 k allocations: 63.640 KiB)
 0.5
@@ -137,10 +137,10 @@ if (f = rand()) < .8
 end
 ```
 
-Because `a` is a an array of abstract type `Real`, it must be able to hold any `Real` value.  Since
-`Real` objects can be of arbitrary size and structure, `a` must be represented as an array of
-pointers to individually allocated `Real` objects.  Because `f` will always be a [`Float64`](@ref),
-we should instead, use:
+Because `a` is a an array of abstract type [`Real`](@ref), it must be able to hold any
+`Real` value.  Since `Real` objects can be of arbitrary size and structure, `a` must be
+represented as an array of pointers to individually allocated `Real` objects. Because `f`
+will always be a [`Float64`](@ref), we should instead, use:
 
 ```julia
 a = Float64[] # typeof(a) = Array{Float64,1}
@@ -188,9 +188,9 @@ 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.
+of a [`UInt8`](@ref) differs from a [`Float64`](@ref) 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:
@@ -257,7 +257,7 @@ 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:
 
-```julia myambig2
+```jldoctest myambig2
 julia> m = MyType{AbstractFloat}(3.2)
 MyType{AbstractFloat}(3.2)
 
@@ -359,10 +359,10 @@ However, there are cases where you may need to declare different versions of the
 for different element types of `a`. You could do it like this:
 
 ```
-function myfun{T<:AbstractFloat}(c::MySimpleContainer{Vector{T}})
+function myfun(c::MySimpleContainer{Vector{T}}) where T<:AbstractFloat
     ...
 end
-function myfun{T<:Integer}(c::MySimpleContainer{Vector{T}})
+function myfun(c::MySimpleContainer{Vector{T}}) where T<:Integer
     ...
 end
 ```
@@ -389,17 +389,17 @@ Note the somewhat surprising fact that `T` doesn't appear in the declaration of
 that we'll return to in a moment. With this approach, one can write functions such as:
 
 ```jldoctest containers2
-julia> function myfunc{T<:Integer, A<:AbstractArray}(c::MyContainer{T,A})
+julia> function myfunc(c::MyContainer{<:Integer, <:AbstractArray})
            return c.a[1]+1
        end
 myfunc (generic function with 1 method)
 
-julia> function myfunc{T<:AbstractFloat}(c::MyContainer{T})
+julia> function myfunc(c::MyContainer{<:AbstractFloat})
            return c.a[1]+2
        end
 myfunc (generic function with 2 methods)
 
-julia> function myfunc{T<:Integer}(c::MyContainer{T,Vector{T}})
+julia> function myfunc(c::MyContainer{T,Vector{T}}) where T<:Integer
            return c.a[1]+3
        end
 myfunc (generic function with 3 methods)
@@ -409,7 +409,7 @@ myfunc (generic function with 3 methods)
     Because we can only define `MyContainer` for
     `A<:AbstractArray`, and any unspecified parameters are arbitrary,
     the first function above could have been written more succinctly as
-    `function myfunc{T<:Integer}(c::MyContainer{T})`
+    `function myfunc(c::MyContainer{<:Integer})`
 
 
 ```jldoctest containers2
@@ -429,7 +429,7 @@ 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
+```jldoctest containers2
 julia> b = MyContainer{Int64, UnitRange{Float64}}(UnitRange(1.3, 5.0));
 
 julia> typeof(b)
@@ -465,7 +465,7 @@ It is often convenient to work with data structures that may contain values of a
 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:
 
-```
+```julia
 function foo(a::Array{Any,1})
     x = a[1]::Int32
     b = x+1
@@ -473,15 +473,23 @@ function foo(a::Array{Any,1})
 end
 ```
 
-Here, we happened to know that the first element of `a` would be an `Int32`. Making an annotation
-like this has the added benefit that it will raise a run-time error if the value is not of the
-expected type, potentially catching certain bugs earlier.
+Here, we happened to know that the first element of `a` would be an [`Int32`](@ref). Making
+an annotation like this has the added benefit that it will raise a run-time error if the
+value is not of the expected type, potentially catching certain bugs earlier.
+
+In the case that the type of `a[1]` is not known precisely, `x` can be declared via
+`x = convert(Int32,a[1])::Int32`. The use of the [`convert`](@ref) function allows `a[1]`
+to be any object convertible to an `Int32` (such as `UInt8`), thus increasing the genericity
+of the code by loosening the type requirement. Notice that `convert` itself needs a type
+annotation in this context in order to achieve type stability. This is because the compiler
+cannot deduce the type of the return value of a function, even `convert`, unless the types of
+all the function's arguments are known.
 
 ### Declare types of keyword arguments
 
 Keyword arguments can have declared types:
 
-```
+```julia
 function with_keyword(x; name::Int = 1)
     ...
 end
@@ -509,7 +517,7 @@ function norm(A)
     if isa(A, Vector)
         return sqrt(real(dot(A,A)))
     elseif isa(A, Matrix)
-        return max(svd(A)[2])
+        return maximum(svd(A)[2])
     else
         error("norm: invalid argument")
     end
@@ -520,7 +528,7 @@ This can be written more concisely and efficiently as:
 
 ```julia
 norm(x::Vector) = sqrt(real(dot(x,x)))
-norm(A::Matrix) = max(svd(A)[2])
+norm(A::Matrix) = maximum(svd(A)[2])
 ```
 
 ## Write "type-stable" functions
@@ -629,7 +637,7 @@ of `fill_twos!` for different types of `a`.
 The second form is also often better style and can lead to more code reuse.
 
 This pattern is used in several places in the standard library. For example, see `hvcat_fill`
-in [abstractarray.jl](https://github.com/JuliaLang/julia/blob/master/base/abstractarray.jl), or
+in [`abstractarray.jl`](https://github.com/JuliaLang/julia/blob/master/base/abstractarray.jl), or
 the [`fill!`](@ref) function, which we could have used instead of writing our own `fill_twos!`.
 
 Functions like `strange_twos` occur when dealing with data of uncertain type, for example data
@@ -637,7 +645,7 @@ loaded from an input file that might contain either integers, floats, strings, o
 
 ## Types with values-as-parameters
 
-Let's say you want to create an `N`-dimensional array that has size 3 along each axis.  Such arrays
+Let's say you want to create an `N`-dimensional array that has size 3 along each axis. Such arrays
 can be created like this:
 
 ```jldoctest
@@ -677,37 +685,37 @@ slow.
 
 Now, one very good way to solve such problems is by using the [function-barrier technique](@ref kernal-functions).
 However, in some cases you might want to eliminate the type-instability altogether.  In such cases,
-one approach is to pass the dimensionality as a parameter, for example through `Val{T}` (see
+one approach is to pass the dimensionality as a parameter, for example through `Val{T}()` (see
 ["Value types"](@ref)):
 
 ```jldoctest
-julia> function array3{N}(fillval, ::Type{Val{N}})
-           fill(fillval, ntuple(d->3, Val{N}))
+julia> function array3(fillval, ::Val{N}) where N
+           fill(fillval, ntuple(d->3, Val(N)))
        end
 array3 (generic function with 1 method)
 
-julia> array3(5.0, Val{2})
+julia> array3(5.0, Val(2))
 3×3 Array{Float64,2}:
  5.0  5.0  5.0
  5.0  5.0  5.0
  5.0  5.0  5.0
 ```
 
-Julia has a specialized version of `ntuple` that accepts a `Val{::Int}` as the second parameter;
-by passing `N` as a type-parameter, you make its "value" known to the compiler. Consequently,
-this version of `array3` allows the compiler to predict the return type.
+Julia has a specialized version of `ntuple` that accepts a `Val{::Int}` instance as the second
+parameter; by passing `N` as a type-parameter, you make its "value" known to the compiler.
+Consequently, this version of `array3` allows the compiler to predict the return type.
 
 However, making use of such techniques can be surprisingly subtle. For example, it would be of
 no help if you called `array3` from a function like this:
 
 ```julia
 function call_array3(fillval, n)
-    A = array3(fillval, Val{n})
+    A = array3(fillval, Val(n))
 end
 ```
 
-Here, you've created the same problem all over again: the compiler can't guess the type of `n`,
-so it doesn't know the type of `Val{n}`.  Attempting to use `Val`, but doing so incorrectly, can
+Here, you've created the same problem all over again: the compiler can't guess what `n` is,
+so it doesn't know the *type* of `Val(n)`.  Attempting to use `Val`, but doing so incorrectly, can
 easily make performance *worse* in many situations.  (Only in situations where you're effectively
 combining `Val` with the function-barrier trick, to make the kernel function more efficient, should
 code like the above be used.)
@@ -715,14 +723,15 @@ code like the above be used.)
 An example of correct usage of `Val` would be:
 
 ```julia
-function filter3{T,N}(A::AbstractArray{T,N})
-    kernel = array3(1, Val{N})
+function filter3(A::AbstractArray{T,N}) where {T,N}
+    kernel = array3(1, Val(N))
     filter(A, kernel)
 end
 ```
 
 In this example, `N` is passed as a parameter, so its "value" is known to the compiler.  Essentially,
-`Val{T}` works only when `T` is either hard-coded (`Val{3}`) or already specified in the type-domain.
+`Val(T)` works only when `T` is either hard-coded/literal (`Val(3)`) or already specified in the
+type-domain.
 
 ## The dangers of abusing multiple dispatch (aka, more on types with values-as-parameters)
 
@@ -798,13 +807,13 @@ is that with column-major arrays, the first index changes most rapidly. Essentia
 that looping will be faster if the inner-most loop index is the first to appear in a slice expression.
 
 Consider the following contrived example. Imagine we wanted to write a function that accepts a
-`Vector` and returns a square `Matrix` with either the rows or the columns filled with copies
+[`Vector`](@ref) and returns a square [`Matrix`](@ref) with either the rows or the columns filled with copies
 of the input vector. Assume that it is not important whether rows or columns are filled with these
 copies (perhaps the rest of the code can be easily adapted accordingly). We could conceivably
 do this in at least four ways (in addition to the recommended call to the built-in [`repmat()`](@ref)):
 
 ```julia
-function copy_cols{T}(x::Vector{T})
+function copy_cols(x::Vector{T}) where T
     n = size(x, 1)
     out = Array{T}(n, n)
     for i = 1:n
@@ -813,7 +822,7 @@ function copy_cols{T}(x::Vector{T})
     out
 end
 
-function copy_rows{T}(x::Vector{T})
+function copy_rows(x::Vector{T}) where T
     n = size(x, 1)
     out = Array{T}(n, n)
     for i = 1:n
@@ -822,7 +831,7 @@ function copy_rows{T}(x::Vector{T})
     out
 end
 
-function copy_col_row{T}(x::Vector{T})
+function copy_col_row(x::Vector{T}) where T
     n = size(x, 1)
     out = Array{T}(n, n)
     for col = 1:n, row = 1:n
@@ -831,7 +840,7 @@ function copy_col_row{T}(x::Vector{T})
     out
 end
 
-function copy_row_col{T}(x::Vector{T})
+function copy_row_col(x::Vector{T}) where T
     n = size(x, 1)
     out = Array{T}(n, n)
     for row = 1:n, col = 1:n
@@ -843,7 +852,7 @@ end
 
 Now we will time each of these functions using the same random `10000` by `1` input vector:
 
-```julia
+```julia-repl
 julia> x = randn(10000);
 
 julia> fmt(f) = println(rpad(string(f)*": ", 14, ' '), @elapsed f(x))
@@ -886,7 +895,7 @@ end
 with
 
 ```julia
-function xinc!{T}(ret::AbstractVector{T}, x::T)
+function xinc!(ret::AbstractVector{T}, x::T) where T
     ret[1] = x
     ret[2] = x+1
     ret[3] = x+2
@@ -906,7 +915,7 @@ end
 
 Timing results:
 
-```julia
+```julia-repl
 julia> @time loopinc()
   0.529894 seconds (40.00 M allocations: 1.490 GiB, 12.14% gc time)
 50000015000000
@@ -951,7 +960,7 @@ Both `f` and `fdot` compute the same thing.  However, `fdot`
 (defined with the help of the [`@.`](@ref @__dot__) macro) is
 significantly faster when applied to an array:
 
-```julia
+```julia-repl
 julia> x = rand(10^6);
 
 julia> @time f(x);
@@ -992,7 +1001,7 @@ This can be done for individual slices by calling [`view()`](@ref),
 or more simply for a whole expression or block of code by putting
 [`@views`](@ref) in front of that expression.  For example:
 
-```julia
+```julia-repl
 julia> fcopy(x) = sum(x[2:end-1])
 
 julia> @views fview(x) = sum(x[2:end-1])
@@ -1009,6 +1018,44 @@ julia> @time fview(x);
 Notice both the 3× speedup and the decreased memory allocation
 of the `fview` version of the function.
 
+## Copying data is not always bad
+
+Arrays are stored contiguously in memory, lending themselves to CPU vectorization
+and fewer memory accesses due to caching. These are the same reasons that it is recommended
+to access arrays in column-major order (see above). Irregular access patterns and non-contiguous views
+can drastically slow down computations on arrays because of non-sequential memory access.
+
+Copying irregularly-accessed data into a contiguous array before operating on it can result
+in a large speedup, such as in the example below. Here, a matrix and a vector are being accessed at
+800,000 of their randomly-shuffled indices before being multiplied. Copying the views into
+plain arrays speeds the multiplication by more than a factor of 2 even with the cost of the copying operation.
+
+```julia-repl
+julia> x = randn(1_000_000);
+
+julia> inds = shuffle(1:1_000_000)[1:800000];
+
+julia> A = randn(50, 1_000_000);
+
+julia> xtmp = zeros(800_000);
+
+julia> Atmp = zeros(50, 800_000);
+
+julia> @time sum(view(A, :, inds) * view(x, inds))
+  0.640320 seconds (41 allocations: 1.391 KiB)
+7253.242699002263
+
+julia> @time begin
+           copy!(xtmp, view(x, inds))
+           copy!(Atmp, view(A, :, inds))
+           sum(Atmp * xtmp)
+       end
+  0.261294 seconds (41 allocations: 1.391 KiB)
+7253.242699002323
+```
+Provided there is enough memory for the copies, the cost of copying the view to an array is
+far outweighed by the speed boost from doing the matrix multiplication on a contiguous array.
+
 ## Avoid string interpolation for I/O
 
 When writing data to a file (or other I/O device), forming extra intermediate strings is a source
@@ -1082,7 +1129,7 @@ These are some minor points that might help in tight inner loops.
   * Use [`div(x,y)`](@ref) for truncating division of integers instead of [`trunc(x/y)`](@ref), [`fld(x,y)`](@ref)
     instead of [`floor(x/y)`](@ref), and [`cld(x,y)`](@ref) instead of [`ceil(x/y)`](@ref).
 
-## Performance Annotations
+## [Performance Annotations](@id man-performance-annotations)
 
 Sometimes you can enable better optimization by promising certain program properties.
 
@@ -1261,7 +1308,7 @@ strict IEEE behavior for subnormal numbers.
 Below is an example where subnormals noticeably impact performance on some hardware:
 
 ```julia
-function timestep{T}( b::Vector{T}, a::Vector{T}, Δt::T )
+function timestep(b::Vector{T}, a::Vector{T}, Δt::T) where T
     @assert length(a)==length(b)
     n = length(b)
     b[1] = 1                            # Boundary condition
@@ -1271,7 +1318,7 @@ function timestep{T}( b::Vector{T}, a::Vector{T}, Δt::T )
     b[n] = 0                            # Boundary condition
 end
 
-function heatflow{T}( a::Vector{T}, nstep::Integer )
+function heatflow(a::Vector{T}, nstep::Integer) where T
     b = similar(a)
     for t=1:div(nstep,2)                # Assume nstep is even
         timestep(b,a,T(0.1))
@@ -1388,7 +1435,7 @@ code defined in `pos`.
 
 Starting at `2:`, the variable `y` is defined, and again annotated as a `Union` type.  Next, we
 see that the compiler created the temporary variable `_var1` to hold the result of `y*x`. Because
-a [`Float64`](@ref) times *either* an `Int64` or [`Float64`](@ref) yields a [`Float64`](@ref),
+a [`Float64`](@ref) times *either* an [`Int64`](@ref) or `Float64` yields a `Float64`,
 all type-instability ends here. The net result is that `f(x::Float64)` will not be type-unstable
 in its output, even if some of the intermediate computations are type-unstable.
 
diff --git a/doc/src/manual/profile.md b/doc/src/manual/profile.md
index 55ad6ee430f697..863c41de36c9c7 100644
--- a/doc/src/manual/profile.md
+++ b/doc/src/manual/profile.md
@@ -36,7 +36,7 @@ any alternatives.
 
 Let's work with a simple test case:
 
-```julia
+```julia-repl
 julia> function myfunc()
            A = rand(200, 200, 400)
            maximum(A)
@@ -46,20 +46,20 @@ julia> function myfunc()
 It's a good idea to first run the code you intend to profile at least once (unless you want to
 profile Julia's JIT-compiler):
 
-```julia
+```julia-repl
 julia> myfunc() # run once to force compilation
 ```
 
 Now we're ready to profile this function:
 
-```julia
+```julia-repl
 julia> @profile myfunc()
 ```
 
 To see the profiling results, there is a [graphical browser](https://github.com/timholy/ProfileView.jl)
 available, but here we'll use the text-based display that comes with the standard library:
 
-```julia
+```julia-repl
 julia> Profile.print()
 80 ./event.jl:73; (::Base.REPL.##1#2{Base.REPL.REPLBackend})()
  80 ./REPL.jl:97; macro expansion
@@ -126,7 +126,7 @@ Overall, we can tentatively conclude that generating the random numbers is appro
 as finding the maximum element. We could increase our confidence in this result by
 collecting more samples:
 
-```julia
+```julia-repl
 julia> @profile (for i = 1:100; myfunc(); end)
 
 julia> Profile.print()
@@ -150,7 +150,7 @@ using the `C=true` output mode described below, or by using [ProfileView.jl](htt
 This illustrates the default "tree" dump; an alternative is the "flat" dump, which accumulates
 counts independent of their nesting:
 
-```julia
+```julia-repl
 julia> Profile.print(format=:flat)
  Count File          Line Function
   6714 ./<missing>     -1 anonymous
diff --git a/doc/src/manual/running-external-programs.md b/doc/src/manual/running-external-programs.md
index a179d9f5d006be..e1f96a9bad903e 100644
--- a/doc/src/manual/running-external-programs.md
+++ b/doc/src/manual/running-external-programs.md
@@ -37,10 +37,10 @@ The `hello` is the output of the `echo` command, sent to [`STDOUT`](@ref). The r
 returns `nothing`, and throws an [`ErrorException`](@ref) if the external command fails to run
 successfully.
 
-If you want to read the output of the external command, [`readstring()`](@ref) can be used instead:
+If you want to read the output of the external command, [`read`](@ref) can be used instead:
 
 ```jldoctest
-julia> a = readstring(`echo hello`)
+julia> a = read(`echo hello`, String)
 "hello\n"
 
 julia> chomp(a) == "hello"
@@ -49,7 +49,7 @@ true
 
 More generally, you can use [`open()`](@ref) to read from or write to an external command.
 
-```julia
+```jldoctest
 julia> open(`less`, "w", STDOUT) do io
            for i = 1:3
                println(io, i)
@@ -60,6 +60,18 @@ julia> open(`less`, "w", STDOUT) do io
 3
 ```
 
+The program name and the individual arguments in a command can be accessed
+and iterated over as if the command were an array of strings:
+```jldoctest
+julia> collect(`echo "foo bar"`)
+2-element Array{String,1}:
+ "echo"
+ "foo bar"
+
+julia> `echo "foo bar"`[2]
+"foo bar"
+```
+
 ## [Interpolation](@id command-interpolation)
 
 Suppose you want to do something a bit more complicated and use the name of a file in the variable
@@ -244,7 +256,7 @@ This pipes the output of the `echo` command to the `sort` command. Of course, th
 interesting since there's only one line to sort, but we can certainly do much more interesting
 things:
 
-```julia
+```julia-repl
 julia> run(pipeline(`cut -d: -f3 /etc/passwd`, `sort -n`, `tail -n5`))
 210
 211
@@ -261,7 +273,7 @@ that shells cannot.
 
 Julia can run multiple commands in parallel:
 
-```julia
+```julia-repl
 julia> run(`echo hello` & `echo world`)
 world
 hello
@@ -294,15 +306,15 @@ pipeline(`do_work`, stdout=pipeline(`sort`, "out.txt"), stderr="errs.txt")
 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 `readstring(out)`, not `wait(process)`,
+For example, when reading all of the output from a command, call `read(out, String)`, 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.
 
 Another common solution is to separate the reader and writer of the pipeline into separate Tasks:
 
 ```julia
-writer = @async writeall(process, "data")
-reader = @async do_compute(readstring(process))
+writer = @async write(process, "data")
+reader = @async do_compute(read(process, String))
 wait(process)
 fetch(reader)
 ```
@@ -314,7 +326,7 @@ setup of pipes between processes is a powerful one. To give some sense of the co
 that can be created easily, here are some more sophisticated examples, with apologies for the
 excessive use of Perl one-liners:
 
-```julia
+```julia-repl
 julia> prefixer(prefix, sleep) = `perl -nle '$|=1; print "'$prefix' ", $_; sleep '$sleep';'`;
 
 julia> run(pipeline(`perl -le '$|=1; for(0..9){ print; sleep 1 }'`, prefixer("A",2) & prefixer("B",2)))
@@ -340,7 +352,7 @@ the output is buffered and printed to the pipe at once, to be read by just one c
 
 Here is an even more complex multi-stage producer-consumer example:
 
-```julia
+```julia-repl
 julia> run(pipeline(`perl -le '$|=1; for(0..9){ print; sleep 1 }'`,
            prefixer("X",3) & prefixer("Y",3) & prefixer("Z",3),
            prefixer("A",2) & prefixer("B",2)))
diff --git a/doc/src/manual/stacktraces.md b/doc/src/manual/stacktraces.md
index 2c74b980126e40..82f0ad70f5070d 100644
--- a/doc/src/manual/stacktraces.md
+++ b/doc/src/manual/stacktraces.md
@@ -7,7 +7,7 @@ easy to use programmatically.
 
 The primary function used to obtain a stack trace is [`stacktrace()`](@ref):
 
-```julia
+```julia-repl
 julia> stacktrace()
 4-element Array{StackFrame,1}:
  eval(::Module, ::Any) at boot.jl:236
@@ -20,7 +20,7 @@ Calling [`stacktrace()`](@ref) returns a vector of [`StackFrame`](@ref) s. For e
 alias [`StackTrace`](@ref) can be used in place of `Vector{StackFrame}`. (Examples with `[...]`
 indicate that output may vary depending on how the code is run.)
 
-```julia
+```julia-repl
 julia> example() = stacktrace()
 example (generic function with 1 method)
 
@@ -51,7 +51,7 @@ Note that when calling [`stacktrace()`](@ref) you'll typically see a frame with
 When calling [`stacktrace()`](@ref) from the REPL you'll also have a few extra frames in the stack
 from `REPL.jl`, usually looking something like this:
 
-```julia
+```julia-repl
 julia> example() = stacktrace()
 example (generic function with 1 method)
 
@@ -71,7 +71,7 @@ indicating whether the frame has been inlined, a flag indicating whether it is a
 default C functions do not appear in the stack trace), and an integer representation of the pointer
 returned by [`backtrace()`](@ref):
 
-```julia
+```julia-repl
 julia> top_frame = stacktrace()[1]
 eval(::Module, ::Any) at boot.jl:236
 
@@ -94,7 +94,7 @@ julia> top_frame.from_c
 false
 ```
 
-```julia
+```julia-repl
 julia> top_frame.pointer
 0x00007f390d152a59
 ```
@@ -107,7 +107,7 @@ more.
 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.
 
-```julia
+```julia-repl
 julia> @noinline bad_function() = undeclared_variable
 bad_function (generic function with 1 method)
 
@@ -135,7 +135,7 @@ This can be remedied by calling [`catch_stacktrace()`](@ref) instead of [`stackt
 Instead of returning callstack information for the current context, [`catch_stacktrace()`](@ref)
 returns stack information for the context of the most recent exception:
 
-```julia
+```julia-repl
 julia> @noinline bad_function() = undeclared_variable
 bad_function (generic function with 1 method)
 
@@ -155,7 +155,7 @@ julia> example()
 
 Notice that the stack trace now indicates the appropriate line number and the missing frame.
 
-```julia
+```julia-repl
 julia> @noinline child() = error("Whoops!")
 child (generic function with 1 method)
 
@@ -186,7 +186,7 @@ ERROR: Whoops!
 A call to [`backtrace()`](@ref) returns a vector of `Ptr{Void}`, which may then be passed into
 [`stacktrace()`](@ref) for translation:
 
-```julia
+```julia-repl
 julia> trace = backtrace()
 21-element Array{Ptr{Void},1}:
  Ptr{Void} @0x00007f10049d5b2f
@@ -225,7 +225,7 @@ by [`stacktrace()`](@ref) only has 5. This is because, by default, [`stacktrace(
 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
+```julia-repl
 julia> stacktrace(trace, true)
 27-element Array{StackFrame,1}:
  jl_backtrace_from_here at stackwalk.c:103
@@ -260,7 +260,7 @@ julia> stacktrace(trace, true)
 Individual pointers returned by [`backtrace()`](@ref) can be translated into [`StackFrame`](@ref)
 s by passing them into [`StackTraces.lookup()`](@ref):
 
-```julia
+```julia-repl
 julia> pointer = backtrace()[1];
 
 julia> frame = StackTraces.lookup(pointer)
diff --git a/doc/src/manual/strings.md b/doc/src/manual/strings.md
index 0d5788b18707aa..76bb81ddbe9edf 100644
--- a/doc/src/manual/strings.md
+++ b/doc/src/manual/strings.md
@@ -64,8 +64,8 @@ julia> typeof(ans)
 Int64
 ```
 
-On 32-bit architectures, [`typeof(ans)`](@ref) will be `Int32`. You can convert an integer value
-back to a `Char` just as easily:
+On 32-bit architectures, [`typeof(ans)`](@ref) will be [`Int32`](@ref). You can convert an
+integer value back to a `Char` just as easily:
 
 ```jldoctest
 julia> Char(120)
@@ -179,7 +179,8 @@ julia> str[end]
 ```
 
 All indexing in Julia is 1-based: the first element of any integer-indexed object is found at
-index 1, and the last element is found at index `n`, when the string has a length of `n`.
+index 1. (As we will see below, this does not necessarily mean that the last element is found
+at index `n`, where `n` is the length of the string.)
 
 In any indexing expression, the keyword `end` can be used as a shorthand for the last index (computed
 by [`endof(str)`](@ref)). You can perform arithmetic and other operations with `end`, just like
@@ -512,15 +513,10 @@ julia> contains("Xylophon", "a")
 false
 
 julia> contains("Xylophon", 'o')
-ERROR: MethodError: no method matching contains(::String, ::Char)
-Closest candidates are:
-  contains(!Matched::Function, ::Any, !Matched::Any) at reduce.jl:660
-  contains(::AbstractString, !Matched::AbstractString) at strings/search.jl:378
+true
 ```
 
-The last error is because `'o'` is a character literal, and [`contains()`](@ref) is a generic
-function that looks for subsequences. To look for an element in a sequence, you must use [`in()`](@ref)
-instead.
+The last example shows that [`contains()`](@ref) can also look for a character literal.
 
 Two other handy string functions are [`repeat()`](@ref) and [`join()`](@ref):
 
@@ -644,7 +640,7 @@ For when a capture doesn't match, instead of a substring, `m.captures` contains
 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 is a pair of somewhat contrived examples:
 
-```jldoctest
+```jldoctest acdmatch
 julia> m = match(r"(a|b)(c)?(d)", "acd")
 RegexMatch("acd", 1="a", 2="c", 3="d")
 
@@ -691,7 +687,7 @@ julia> m.offsets
 It is convenient to have captures returned as an array so that one can use destructuring syntax
 to bind them to local variables:
 
-```julia
+```jldoctest acdmatch
 julia> first, second, third = m.captures; first
 "a"
 ```
@@ -777,8 +773,8 @@ for regular expressions containing quotation marks or newlines).
 ## [Byte Array Literals](@id man-byte-array-literals)
 
 Another useful non-standard string literal is the byte-array string literal: `b"..."`. This form
-lets you use string notation to express literal byte arrays -- i.e. arrays of `UInt8` values.
-The rules for byte array literals are the following:
+lets you use string notation to express literal byte arrays -- i.e. arrays of
+[`UInt8`](@ref) values. The rules for byte array literals are the following:
 
   * ASCII characters and ASCII escapes produce a single byte.
   * `\x` and octal escape sequences produce the *byte* corresponding to the escape value.
@@ -807,7 +803,7 @@ The Unicode escape `\u2200` is encoded in UTF-8 as the three bytes 226, 136, 128
 resulting byte array does not correspond to a valid UTF-8 string -- if you try to use this as
 a regular string literal, you will get a syntax error:
 
-```julia
+```julia-repl
 julia> "DATA\xff\u2200"
 ERROR: syntax: invalid UTF-8 sequence
 ```
@@ -837,9 +833,11 @@ so the distinction can safely be ignored. For the escapes `\x80` through `\xff`
 bytes, which -- unless followed by very specific continuation bytes -- do not form valid UTF-8
 data, whereas the latter escapes all represent Unicode code points with two-byte encodings.
 
-If this is all extremely confusing, try reading ["The Absolute Minimum Every Software Developer Absolutely, Positively Must Know About Unicode
-and Character Sets"](http://www.joelonsoftware.com/articles/Unicode.html). It's an excellent introduction
-to Unicode and UTF-8, and may help alleviate some confusion regarding the matter.
+If this is all extremely confusing, try reading ["The Absolute Minimum Every
+Software Developer Absolutely, Positively Must Know About Unicode and Character
+Sets"](https://www.joelonsoftware.com/2003/10/08/the-absolute-minimum-every-software-developer-absolutely-positively-must-know-about-unicode-and-character-sets-no-excuses/).
+It's an excellent introduction to Unicode and UTF-8, and may help alleviate
+some confusion regarding the matter.
 
 ## [Version Number Literals](@id man-version-number-literals)
 
diff --git a/doc/src/manual/style-guide.md b/doc/src/manual/style-guide.md
index 2b0b0fc09dba72..458cd5c37b5d04 100644
--- a/doc/src/manual/style-guide.md
+++ b/doc/src/manual/style-guide.md
@@ -32,11 +32,12 @@ complex(float(x))
 The second version will convert `x` to an appropriate type, instead of always the same type.
 
 This style point is especially relevant to function arguments. For example, don't declare an argument
-to be of type `Int` or `Int32` if it really could be any integer, expressed with the abstract
-type `Integer`. In fact, in many cases you can omit the argument type altogether, unless it is
-needed to disambiguate from other method definitions, since a [`MethodError`](@ref) will be thrown
-anyway if a type is passed that does not support any of the requisite operations. (This is known
-as [duck typing](https://en.wikipedia.org/wiki/Duck_typing).)
+to be of type `Int` or [`Int32`](@ref) if it really could be any integer, expressed with the abstract
+type [`Integer`](@ref). In fact, in many cases you can omit the argument type altogether,
+unless it is needed to disambiguate from other method definitions, since a
+[`MethodError`](@ref) will be thrown anyway if a type is passed that does not support any
+of the requisite operations. (This is known as
+[duck typing](https://en.wikipedia.org/wiki/Duck_typing).)
 
 For example, consider the following definitions of a function `addone` that returns one plus its
 argument:
@@ -90,7 +91,7 @@ is that declaring more specific types leaves more "space" for future method defi
 Instead of:
 
 ```julia
-function double{T<:Number}(a::AbstractArray{T})
+function double(a::AbstractArray{<:Number})
     for i = 1:endof(a)
         a[i] *= 2
     end
@@ -101,7 +102,7 @@ end
 use:
 
 ```julia
-function double!{T<:Number}(a::AbstractArray{T})
+function double!(a::AbstractArray{<:Number})
     for i = 1:endof(a)
         a[i] *= 2
     end
@@ -123,7 +124,7 @@ Types such as `Union{Function,AbstractString}` are often a sign that some design
 When creating a type such as:
 
 ```julia
-type MyType
+mutable struct MyType
     ...
     x::Union{Void,T}
 end
@@ -194,7 +195,7 @@ is already iterable it is often even better to leave it alone, and not convert i
 A function signature:
 
 ```julia
-foo{T<:Real}(x::T) = ...
+foo(x::T) where {T<:Real} = ...
 ```
 
 should be written as:
@@ -243,7 +244,7 @@ it will naturally have access to the run-time values it needs.
 If you have a type that uses a native pointer:
 
 ```julia
-type NativeType
+mutable struct NativeType
     p::Ptr{UInt8}
     ...
 end
@@ -273,9 +274,40 @@ This would provide custom showing of vectors with a specific new element type. W
 this should be avoided. The trouble is that users will expect a well-known type like `Vector()`
 to behave in a certain way, and overly customizing its behavior can make it harder to work with.
 
+## Avoid type piracy
+
+"Type piracy" refers to the practice of extending or redefining methods in Base
+or other packages on types that you have not defined. In some cases, you can get away with
+type piracy with little ill effect. In extreme cases, however, you can even crash Julia
+(e.g. if your method extension or redefinition causes invalid input to be passed to a
+`ccall`). Type piracy can complicate reasoning about code, and may introduce
+incompatibilities that are hard to predict and diagnose.
+
+As an example, suppose you wanted to define multiplication on symbols in a module:
+
+```julia
+module A
+import Base.*
+*(x::Symbol, y::Symbol) = Symbol(x,y)
+end
+```
+
+The problem is that now any other module that uses `Base.*` will also see this definition.
+Since `Symbol` is defined in Base and is used by other modules, this can change the
+behavior of unrelated code unexpectedly. There are several alternatives here, including
+using a different function name, or wrapping the `Symbol`s in another type that you define.
+
+Sometimes, coupled packages may engage in type piracy to separate features from definitions,
+especially when the packages were designed by collaborating authors, and when the
+definitions are reusable. For example, one package might provide some types useful for
+working with colors; another package could define methods for those types that enable
+conversions between color spaces. Another example might be a package that acts as a thin
+wrapper for some C code, which another package might then pirate to implement a
+higher-level, Julia-friendly API.
+
 ## Be careful with type equality
 
-You generally want to use [`isa()`](@ref) and `<:` ([`issubtype()`](@ref)) for testing types,
+You generally want to use [`isa()`](@ref) and [`<:`](@ref) for testing types,
 not `==`. Checking types for exact equality typically only makes sense when comparing to a known
 concrete type (e.g. `T == Float64`), or if you *really, really* know what you're doing.
 
@@ -325,7 +357,7 @@ julia> g(1)
 
 As you can see, the second version, where we used an `Int` literal, preserved the type of the
 input argument, while the first didn't. This is because e.g. `promote_type(Int, Float64) == Float64`,
-and promotion happens with the multiplication. Similarly, `Rational` literals are less type disruptive
+and promotion happens with the multiplication. Similarly, [`Rational`](@ref) literals are less type disruptive
 than [`Float64`](@ref) literals, but more disruptive than `Int`s:
 
 ```jldoctest
diff --git a/doc/src/manual/types.md b/doc/src/manual/types.md
index 3fc827684a6e13..5a2551ef85f699 100644
--- a/doc/src/manual/types.md
+++ b/doc/src/manual/types.md
@@ -133,18 +133,19 @@ system: they form the conceptual hierarchy which makes Julia's type system more
 of object implementations.
 
 Recall that in [Integers and Floating-Point Numbers](@ref), we introduced a variety of concrete
-types of numeric values: `Int8`, `UInt8`, `Int16`, `UInt16`, `Int32`, `UInt32`, `Int64`, `UInt64`,
-`Int128`, `UInt128`, `Float16`, [`Float32`](@ref), and [`Float64`](@ref).  Although they have
-different representation sizes, `Int8`, `Int16`, `Int32`, `Int64`  and `Int128` all have in common
-that they are signed integer types. Likewise `UInt8`, `UInt16`, `UInt32`, `UInt64` and `UInt128`
-are all unsigned integer types, while `Float16`, [`Float32`](@ref) and [`Float64`](@ref) are distinct
-in being floating-point types rather than integers. It is common for a piece of code to make sense,
-for example, only if its arguments are some kind of integer, but not really depend on what particular
-*kind* of integer.  For example, the greatest common denominator algorithm works for all kinds
-of integers, but will not work for floating-point numbers.  Abstract types allow the construction
-of a hierarchy of types, providing a context into which concrete types can fit.  This allows you,
-for example, to easily program to any type that is an integer, without restricting an algorithm
-to a specific type of integer.
+types of numeric values: [`Int8`](@ref), [`UInt8`](@ref), [`Int16`](@ref), [`UInt16`](@ref),
+[`Int32`](@ref), [`UInt32`](@ref), [`Int64`](@ref), [`UInt64`](@ref), [`Int128`](@ref),
+[`UInt128`](@ref), [`Float16`](@ref), [`Float32`](@ref), and [`Float64`](@ref). Although
+they have different representation sizes, `Int8`, `Int16`, `Int32`, `Int64` and `Int128`
+all have in common that they are signed integer types. Likewise `UInt8`, `UInt16`, `UInt32`,
+`UInt64` and `UInt128` are all unsigned integer types, while `Float16`, `Float32` and
+`Float64` are distinct in being floating-point types rather than integers. It is common for
+a piece of code to make sense, for example, only if its arguments are some kind of integer,
+but not really depend on what particular *kind* of integer. For example, the greatest common
+denominator algorithm works for all kinds of integers, but will not work for floating-point
+numbers. Abstract types allow the construction of a hierarchy of types, providing a context
+into which concrete types can fit. This allows you, for example, to easily program to any type
+that is an integer, without restricting an algorithm to a specific type of integer.
 
 Abstract types are declared using the `abstract type` keyword. The general syntaxes for declaring an
 abstract type are:
@@ -154,7 +155,7 @@ abstract type «name» end
 abstract type «name» <: «supertype» end
 ```
 
-The `abstract` keyword introduces a new abstract type, whose name is given by `«name»`. This
+The `abstract type` keyword introduces a new abstract type, whose name is given by `«name»`. This
 name can be optionally followed by `<:` and an already-existing type, indicating that the newly
 declared abstract type is a subtype of this "parent" type.
 
@@ -175,13 +176,14 @@ abstract type Signed   <: Integer end
 abstract type Unsigned <: Integer end
 ```
 
-The `Number` type is a direct child type of `Any`, and `Real` is its child. In turn, `Real` has
-two children (it has more, but only two are shown here; we'll get to the others later): `Integer`
-and `AbstractFloat`, separating the world into representations of integers and representations
-of real numbers. Representations of real numbers include, of course, floating-point types, but
-also include other types, such as rationals. Hence, `AbstractFloat` is a proper subtype of `Real`,
-including only floating-point representations of real numbers. Integers are further subdivided
-into `Signed` and `Unsigned` varieties.
+The [`Number`](@ref) type is a direct child type of `Any`, and [`Real`](@ref) is its child.
+In turn, `Real` has two children (it has more, but only two are shown here; we'll get to
+the others later): [`Integer`](@ref) and [`AbstractFloat`](@ref), separating the world into
+representations of integers and representations of real numbers. Representations of real
+numbers include, of course, floating-point types, but also include other types, such as
+rationals. Hence, `AbstractFloat` is a proper subtype of `Real`, including only
+floating-point representations of real numbers. Integers are further subdivided into
+[`Signed`](@ref) and [`Unsigned`](@ref) varieties.
 
 The `<:` operator in general means "is a subtype of", and, used in declarations like this, declares
 the right-hand type to be an immediate supertype of the newly declared type. It can also be used
@@ -268,19 +270,21 @@ primitive type «name» <: «supertype» «bits» end
 The number of bits indicates how much storage the type requires and the name gives the new type
 a name. A primitive type can optionally be declared to be a subtype of some supertype. If a supertype
 is omitted, then the type defaults to having `Any` as its immediate supertype. The declaration
-of `Bool` above therefore means that a boolean value takes eight bits to store, and has `Integer`
-as its immediate supertype. Currently, only sizes that are multiples of 8 bits are supported.
-Therefore, boolean values, although they really need just a single bit, cannot be declared to
-be any smaller than eight bits.
-
-The types `Bool`, `Int8` and `UInt8` all have identical representations: they are eight-bit chunks
-of memory. Since Julia's type system is nominative, however, they are not interchangeable despite
-having identical structure. A fundamental difference between them is that they have different
-supertypes: `Bool`'s direct supertype is `Integer`, `Int8`'s is `Signed`, and `UInt8`'s is `Unsigned`.
-All other differences between `Bool`, `Int8`, and `UInt8` are matters of behavior -- the way functions
-are defined to act when given objects of these types as arguments. This is why a nominative type
-system is necessary: if structure determined type, which in turn dictates behavior, then it would
-be impossible to make `Bool` behave any differently than `Int8` or `UInt8`.
+of [`Bool`](@ref) above therefore means that a boolean value takes eight bits to store, and has
+[`Integer`](@ref) as its immediate supertype. Currently, only sizes that are multiples of
+8 bits are supported. Therefore, boolean values, although they really need just a single bit,
+cannot be declared to be any smaller than eight bits.
+
+The types [`Bool`](@ref), [`Int8`](@ref) and [`UInt8`](@ref) all have identical representations:
+they are eight-bit chunks of memory. Since Julia's type system is nominative, however, they
+are not interchangeable despite having identical structure. A fundamental difference between
+them is that they have different supertypes: [`Bool`](@ref)'s direct supertype is [`Integer`](@ref),
+[`Int8`](@ref)'s is [`Signed`](@ref), and [`UInt8`](@ref)'s is [`Unsigned`](@ref). All other
+differences between [`Bool`](@ref), [`Int8`](@ref), and [`UInt8`](@ref) are matters of
+behavior -- the way functions are defined to act when given objects of these types as
+arguments. This is why a nominative type system is necessary: if structure determined type,
+which in turn dictates behavior, then it would be impossible to make [`Bool`](@ref) behave
+any differently than [`Int8`](@ref) or [`UInt8`](@ref).
 
 ## Composite Types
 
@@ -339,16 +343,16 @@ must be convertible to `Int`:
 
 ```jldoctest footype
 julia> Foo((), 23.5, 1)
-ERROR: InexactError()
+ERROR: InexactError: convert(Int64, 23.5)
 Stacktrace:
- [1] convert(::Type{Int64}, ::Float64) at ./float.jl:675
+ [1] convert at ./float.jl:681 [inlined]
  [2] Foo(::Tuple{}, ::Float64, ::Int64) at ./none:2
 ```
 
 You may find a list of field names using the `fieldnames` function.
 
 ```jldoctest footype
-julia> fieldnames(foo)
+julia> fieldnames(Foo)
 3-element Array{Symbol,1}:
  :bar
  :baz
@@ -586,14 +590,16 @@ have different representations in memory:
 
   * An instance of `Point{Float64}` can be represented compactly and efficiently as an immediate pair
     of 64-bit values;
-  * An instance of `Point{Real}` must be able to hold any pair of instances of `Real`. Since objects
-    that are instances of `Real` can be of arbitrary size and structure, in practice an instance of
-    `Point{Real}` must be represented as a pair of pointers to individually allocated `Real` objects.
+  * An instance of `Point{Real}` must be able to hold any pair of instances of [`Real`](@ref).
+    Since objects that are instances of `Real` can be of arbitrary size and structure, in
+    practice an instance of `Point{Real}` must be represented as a pair of pointers to
+    individually allocated `Real` objects.
 
 The efficiency gained by being able to store `Point{Float64}` objects with immediate values is
 magnified enormously in the case of arrays: an `Array{Float64}` can be stored as a contiguous
 memory block of 64-bit floating-point values, whereas an `Array{Real}` must be an array of pointers
-to individually allocated `Real` objects -- which may well be [boxed](https://en.wikipedia.org/wiki/Object_type_%28object-oriented_programming%29#Boxing)
+to individually allocated [`Real`](@ref) objects -- which may well be
+[boxed](https://en.wikipedia.org/wiki/Object_type_%28object-oriented_programming%29#Boxing)
 64-bit floating-point values, but also might be arbitrarily large, complex objects, which are
 declared to be implementations of the `Real` abstract type.
 
@@ -607,7 +613,7 @@ end
 ```
 
 A correct way to define a method that accepts all arguments of type `Point{T}` where `T` is
-a subtype of `Real` is:
+a subtype of [`Real`](@ref) is:
 
 ```julia
 function norm(p::Point{<:Real})
@@ -645,7 +651,7 @@ ERROR: MethodError: Cannot `convert` an object of type Float64 to an object of t
 This may have arisen from a call to the constructor Point{Float64}(...),
 since type constructors fall back to convert methods.
 Stacktrace:
- [1] Point{Float64}(::Float64) at ./sysimg.jl:24
+ [1] Point{Float64}(::Float64) at ./sysimg.jl:102
 
 julia> Point{Float64}(1.0,2.0,3.0)
 ERROR: MethodError: no method matching Point{Float64}(::Float64, ::Float64, ::Float64)
@@ -680,7 +686,6 @@ to `Point` have the same type. When this isn't the case, the constructor will fa
 julia> Point(1,2.5)
 ERROR: MethodError: no method matching Point(::Int64, ::Float64)
 Closest candidates are:
-  Point(::Any) where T at sysimg.jl:24
   Point(::T, !Matched::T) where T at none:2
 ```
 
@@ -785,8 +790,8 @@ possible types. In such situations, one can constrain the range of `T` like so:
 julia> abstract type Pointy{T<:Real} end
 ```
 
-With such a declaration, it is acceptable to use any type that is a subtype of `Real` in place
-of `T`, but not types that are not subtypes of `Real`:
+With such a declaration, it is acceptable to use any type that is a subtype of
+[`Real`](@ref) in place of `T`, but not types that are not subtypes of `Real`:
 
 ```jldoctest realpointytype
 julia> Pointy{Float64}
@@ -812,8 +817,8 @@ end
 ```
 
 To give a real-world example of how all this parametric type machinery can be useful, here is
-the actual definition of Julia's `Rational` immutable type (except that we omit the constructor
-here for simplicity), representing an exact ratio of integers:
+the actual definition of Julia's [`Rational`](@ref) immutable type (except that we omit the
+constructor here for simplicity), representing an exact ratio of integers:
 
 ```julia
 struct Rational{T<:Integer} <: Real
@@ -823,8 +828,8 @@ end
 ```
 
 It only makes sense to take ratios of integer values, so the parameter type `T` is restricted
-to being a subtype of `Integer`, and a ratio of integers represents a value on the real number
-line, so any `Rational` is an instance of the `Real` abstraction.
+to being a subtype of [`Integer`](@ref), and a ratio of integers represents a value on the
+real number line, so any [`Rational`](@ref) is an instance of the [`Real`](@ref) abstraction.
 
 ### Tuple Types
 
@@ -973,7 +978,7 @@ The slightly odd feature of these declarations as compared to typical parametric
 is that the type parameter `T` is not used in the definition of the type itself -- it is just
 an abstract tag, essentially defining an entire family of types with identical structure, differentiated
 only by their type parameter. Thus, `Ptr{Float64}` and `Ptr{Int64}` are distinct types, even though
-they have identical representations. And of course, all specific pointer types are subtype of
+they have identical representations. And of course, all specific pointer types are subtypes of
 the umbrella `Ptr` type:
 
 ```jldoctest
@@ -989,7 +994,7 @@ true
 We have said that a parametric type like `Ptr` acts as a supertype of all its instances
 (`Ptr{Int64}` etc.). How does this work? `Ptr` itself cannot be a normal data type, since without
 knowing the type of the referenced data the type clearly cannot be used for memory operations.
-The answer is that `Ptr` (or other parametric type like `Array`) is a different kind of type called a
+The answer is that `Ptr` (or other parametric types like `Array`) is a different kind of type called a
 `UnionAll` type. Such a type expresses the *iterated union* of types for all values of some parameter.
 
 `UnionAll` types are usually written using the keyword `where`. For example `Ptr` could be more
@@ -1009,21 +1014,22 @@ Using explicit `where` syntax, any subset of parameters can be fixed. For exampl
 1-dimensional arrays can be written as `Array{T,1} where T`.
 
 Type variables can be restricted with subtype relations.
-`Array{T} where T<:Integer` refers to all arrays whose element type is some kind of `Integer`.
+`Array{T} where T<:Integer` refers to all arrays whose element type is some kind of
+[`Integer`](@ref).
 The syntax `Array{<:Integer}` is a convenient shorthand for `Array{T} where T<:Integer`.
 Type variables can have both lower and upper bounds.
-`Array{T} where Int<:T<:Number` refers to all arrays of `Number`s that are able to contain `Int`s
-(since `T` must be at least as big as `Int`).
+`Array{T} where Int<:T<:Number` refers to all arrays of [`Number`](@ref)s that are able to
+contain `Int`s (since `T` must be at least as big as `Int`).
 The syntax `where T>:Int` also works to specify only the lower bound of a type variable,
 and `Array{>:Int}` is equivalent to `Array{T} where T>:Int`.
 
 Since `where` expressions nest, type variable bounds can refer to outer type variables.
-For example `Tuple{T,Array{S}} where S<:AbstractArray{T} where T<:Real` refers to 2-tuples whose first
-element is some `Real`, and whose second element is an `Array` of any kind of array whose element type
-contains the type of the first tuple element.
+For example `Tuple{T,Array{S}} where S<:AbstractArray{T} where T<:Real` refers to 2-tuples
+whose first element is some [`Real`](@ref), and whose second element is an `Array` of any
+kind of array whose element type contains the type of the first tuple element.
 
-The `where` keyword itself can be nested inside a more complex declaration.  For example, consider the
-two types created by the following declarations:
+The `where` keyword itself can be nested inside a more complex declaration. For example,
+consider the two types created by the following declarations:
 
 ```jldoctest
 julia> const T1 = Array{Array{T,1} where T, 1}
@@ -1057,10 +1063,10 @@ element type.
 
 Sometimes it is convenient to introduce a new name for an already expressible type.
 This can be done with a simple assignment statement.
-For example, UInt is aliased to either UInt32 or UInt64 as is appropriate for the size of pointers
-on the system:
+For example, `UInt` is aliased to either [`UInt32`](@ref) or [`UInt64`](@ref) as is
+appropriate for the size of pointers on the system:
 
-```julia
+```julia-repl
 # 32-bit system:
 julia> UInt
 UInt32
@@ -1081,11 +1087,12 @@ end
 ```
 
 Of course, this depends on what `Int` is aliased to -- but that is predefined to be the correct
-type -- either `Int32` or `Int64`.
+type -- either [`Int32`](@ref) or [`Int64`](@ref).
 
-(Note that unlike `Int`, `Float` does not exist as a type alias for a specific sized `AbstractFloat`.
-Unlike with integer registers, the floating point register sizes are specified by the IEEE-754 standard.
-Whereas the size of `Int` reflects the size of a native pointer on that machine.)
+(Note that unlike `Int`, `Float` does not exist as a type alias for a specific sized
+[`AbstractFloat`](@ref). Unlike with integer registers, the floating point register sizes
+are specified by the IEEE-754 standard. Whereas the size of `Int` reflects the size of a
+native pointer on that machine.)
 
 ## Operations on Types
 
@@ -1176,11 +1183,13 @@ julia> Polar(r::Real,Θ::Real) = Polar(promote(r,Θ)...)
 Polar
 ```
 
-Here, we've added a custom constructor function so that it can take arguments of different `Real`
-types and promote them to a common type (see [Constructors](@ref man-constructors) and [Conversion and Promotion](@ref conversion-and-promotion)).
-(Of course, we would have to define lots of other methods, too, to make it act like a `Number`,
-e.g. `+`, `*`, `one`, `zero`, promotion rules and so on.) By default, instances of this type display
-rather simply, with information about the type name and the field values, as e.g. `Polar{Float64}(3.0,4.0)`.
+Here, we've added a custom constructor function so that it can take arguments of different
+[`Real`](@ref) types and promote them to a common type (see [Constructors](@ref man-constructors)
+and [Conversion and Promotion](@ref conversion-and-promotion)).
+(Of course, we would have to define lots of other methods, too, to make it act like a
+[`Number`](@ref), e.g. `+`, `*`, `one`, `zero`, promotion rules and so on.) By default,
+instances of this type display rather simply, with information about the type name and
+the field values, as e.g. `Polar{Float64}(3.0,4.0)`.
 
 If we want it to display instead as `3.0 * exp(4.0im)`, we would define the following method to
 print the object to a given output object `io` (representing a file, terminal, buffer, etcetera;
@@ -1199,7 +1208,7 @@ format for displaying an object by overloading a three-argument form of `show` t
 `text/plain` MIME type as its second argument (see [Multimedia I/O](@ref)), for example:
 
 ```jldoctest polartype
-julia> Base.show{T}(io::IO, ::MIME"text/plain", z::Polar{T}) =
+julia> Base.show(io::IO, ::MIME"text/plain", z::Polar{T}) where{T} =
            print(io, "Polar{$T} complex number:\n   ", z)
 ```
 
@@ -1226,7 +1235,7 @@ Moreover, you can also define `show` methods for other MIME types in order to en
 we can define formatted HTML display of `Polar` objects, with superscripts and italics, via:
 
 ```jldoctest polartype
-julia> Base.show{T}(io::IO, ::MIME"text/html", z::Polar{T}) =
+julia> Base.show(io::IO, ::MIME"text/html", z::Polar{T}) where {T} =
            println(io, "<code>Polar{$T}</code> complex number: ",
                    z.r, " <i>e</i><sup>", z.Θ, " <i>i</i></sup>")
 ```
@@ -1243,45 +1252,97 @@ julia> show(STDOUT, "text/html", Polar(3.0,4.0))
 <p>An HTML renderer would display this as: <code>Polar{Float64}</code> complex number: 3.0 <i>e</i><sup>4.0 <i>i</i></sup></p>
 ```
 
+As a rule of thumb, the single-line `show` method should print a valid Julia expression for creating
+the shown object.  When this `show` method contains infix operators, such as the multiplication
+operator (`*`) in our single-line `show` method for `Polar` above, it may not parse correctly when
+printed as part of another object.  To see this, consider the expression object (see [Program
+representation](@ref)) which takes the square of a specific instance of our `Polar` type:
+
+```jldoctest polartype
+julia> a = Polar(3, 4.0)
+Polar{Float64} complex number:
+   3.0 * exp(4.0im)
+
+julia> print(:($a^2))
+3.0 * exp(4.0im) ^ 2
+```
+
+Because the operator `^` has higher precedence than `*` (see [Operator Precedence](@ref)), this
+output does not faithfully represent the expression `a ^ 2` which should be equal to `(3.0 *
+exp(4.0im)) ^ 2`.  To solve this issue, we must make a custom method for `Base.show_unquoted(io::IO,
+z::Polar, indent::Int, precedence::Int)`, which is called internally by the expression object when
+printing:
+
+```jldoctest polartype
+julia> function Base.show_unquoted(io::IO, z::Polar, ::Int, precedence::Int)
+           if Base.operator_precedence(:*) <= precedence
+               print(io, "(")
+               show(io, z)
+               print(io, ")")
+           else
+               show(io, z)
+           end
+       end
+
+julia> :($a^2)
+:((3.0 * exp(4.0im)) ^ 2)
+```
+
+The method defined above adds parentheses around the call to `show` when the precedence of the
+calling operator is higher than or equal to the precedence of multiplication.  This check allows
+expressions which parse correctly without the parentheses (such as `:($a + 2)` and `:($a == 2)`) to
+omit them when printing:
+
+```jldoctest polartype
+julia> :($a + 2)
+:(3.0 * exp(4.0im) + 2)
+
+julia> :($a == 2)
+:(3.0 * exp(4.0im) == 2)
+```
+
 ## "Value types"
 
 In Julia, you can't dispatch on a *value* such as `true` or `false`. However, you can dispatch
 on parametric types, and Julia allows you to include "plain bits" values (Types, Symbols, Integers,
 floating-point numbers, tuples, etc.) as type parameters.  A common example is the dimensionality
-parameter in `Array{T,N}`, where `T` is a type (e.g., `Float64`) but `N` is just an `Int`.
+parameter in `Array{T,N}`, where `T` is a type (e.g., [`Float64`](@ref)) but `N` is just an `Int`.
 
 You can create your own custom types that take values as parameters, and use them to control dispatch
-of custom types. By way of illustration of this idea, let's introduce a parametric type, `Val{T}`,
-which serves as a customary way to exploit this technique for cases where you don't need a more
-elaborate hierarchy.
+of custom types. By way of illustration of this idea, let's introduce a parametric type, `Val{x}`,
+and a constructor `Val(x) = Val{x}()`, which serves as a customary way to exploit this technique
+for cases where you don't need a more elaborate hierarchy.
 
 `Val` is defined as:
 
 ```jldoctest valtype
-julia> struct Val{T}
+julia> struct Val{x}
        end
+
+julia> Base.@pure Val(x) = Val{x}()
+Val
 ```
 
 There is no more to the implementation of `Val` than this.  Some functions in Julia's standard
-library accept `Val` types as arguments, and you can also use it to write your own functions.
+library accept `Val` instances as arguments, and you can also use it to write your own functions.
  For example:
 
 ```jldoctest valtype
-julia> firstlast(::Type{Val{true}}) = "First"
+julia> firstlast(::Val{true}) = "First"
 firstlast (generic function with 1 method)
 
-julia> firstlast(::Type{Val{false}}) = "Last"
+julia> firstlast(::Val{false}) = "Last"
 firstlast (generic function with 2 methods)
 
-julia> firstlast(Val{true})
+julia> firstlast(Val(true))
 "First"
 
-julia> firstlast(Val{false})
+julia> firstlast(Val(false))
 "Last"
 ```
 
-For consistency across Julia, the call site should always pass a `Val`*type* rather than creating
-an *instance*, i.e., use `foo(Val{:bar})` rather than `foo(Val{:bar}())`.
+For consistency across Julia, the call site should always pass a `Val`*instance* rather than using
+a *type*, i.e., use `foo(Val(:bar))` rather than `foo(Val{:bar})`.
 
 It's worth noting that it's extremely easy to mis-use parametric "value" types, including `Val`;
 in unfavorable cases, you can easily end up making the performance of your code much *worse*.
diff --git a/doc/src/manual/unicode-input.md b/doc/src/manual/unicode-input.md
index 39cf0d7d750485..bb0ab649e70b7c 100644
--- a/doc/src/manual/unicode-input.md
+++ b/doc/src/manual/unicode-input.md
@@ -20,6 +20,8 @@ the symbol).
 # Generate a table containing all LaTeX and Emoji tab completions available in the REPL.
 #
 
+const NBSP = '\u00A0'
+
 function tab_completions(symbols...)
     completions = Dict{String, Vector{String}}()
     for each in symbols, (k, v) in each
@@ -41,6 +43,15 @@ function unicode_data()
     return names
 end
 
+# Surround combining characters with no-break spaces (i.e '\u00A0'). Follows the same format
+# for how unicode is displayed on the unicode.org website:
+# http://unicode.org/cldr/utility/character.jsp?a=0300
+function fix_combining_chars(char)
+    cat = Base.UTF8proc.category_code(char)
+    return cat == 6 || cat == 8 ? "$NBSP$char$NBSP" : "$char"
+end
+
+
 function table_entries(completions, unicode_dict)
     entries = [[
         "Code point(s)", "Character(s)",
@@ -51,10 +62,10 @@ function table_entries(completions, unicode_dict)
         for char in chars
             push!(code_points, "U+$(uppercase(hex(char, 5)))")
             push!(unicode_names, get(unicode_dict, UInt32(char), "(No Unicode name)"))
-            push!(characters, Base.UTF8proc.category_code(char) == 6 ? "◌$char" : "$char")
+            push!(characters, isempty(characters) ? fix_combining_chars(char) : "$char")
         end
         push!(entries, [
-            join(code_points, " + "), join(chars),
+            join(code_points, " + "), join(characters),
             join(inputs, ", "), join(unicode_names, " + ")
         ])
     end
diff --git a/doc/src/manual/variables-and-scoping.md b/doc/src/manual/variables-and-scoping.md
index af4d02bfcefc8a..e519050bd4e0b2 100644
--- a/doc/src/manual/variables-and-scoping.md
+++ b/doc/src/manual/variables-and-scoping.md
@@ -149,6 +149,9 @@ julia> z
 10
 ```
 
+The `local` and `global` keywords can also be applied to destructuring assignments, e.g.
+`local x, y = 1, 2`. In this case the keyword affects all listed variables.
+
 ### Soft Local Scope
 
 > In a soft local scope, all variables are inherited from its parent scope unless a variable is
@@ -174,7 +177,7 @@ julia> x
 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
+```jldoctest
 julia> let
            local j = 2
            let
@@ -332,7 +335,7 @@ The reason to allow *modifying local* variables of parent scopes in nested funct
 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:
 
-```julia
+```jldoctest
 julia> let
            state = 0
            global counter
@@ -411,7 +414,7 @@ julia> Fs[2]()
 Since the `begin` construct does not introduce a new scope, it can be useful to use a zero-argument
 `let` to just introduce a new scope block without creating any new bindings:
 
-```julia
+```jldoctest
 julia> let
            local x = 1
            let
diff --git a/doc/src/manual/variables.md b/doc/src/manual/variables.md
index 61ac187c547649..8683b3ace795b7 100644
--- a/doc/src/manual/variables.md
+++ b/doc/src/manual/variables.md
@@ -3,7 +3,7 @@
 A variable, in Julia, is a name associated (or bound) to a value. It's useful when you want to
 store a value (that you obtained after some math, for example) for later use. For example:
 
-```julia
+```julia-repl
 # Assign the value 10 to the variable x
 julia> x = 10
 10
@@ -100,7 +100,7 @@ to define `⊗` as an infix Kronecker product).
 
 The only explicitly disallowed names for variables are the names of built-in statements:
 
-```julia
+```julia-repl
 julia> else = false
 ERROR: syntax: unexpected "else"
 
@@ -129,3 +129,5 @@ conventions:
   * Functions that write to their arguments have names that end in `!`. These are sometimes called
     "mutating" or "in-place" functions because they are intended to produce changes in their arguments
     after the function is called, not just return a value.
+
+For more information about stylistic conventions, see the [Style Guide](@ref).
diff --git a/doc/src/stdlib/arrays.md b/doc/src/stdlib/arrays.md
index 6d596f0c0d4ada..aedb79e7f6a64b 100644
--- a/doc/src/stdlib/arrays.md
+++ b/doc/src/stdlib/arrays.md
@@ -1,5 +1,36 @@
 # [Arrays](@id lib-arrays)
 
+## Constructors and Types
+
+```@docs
+Core.AbstractArray
+Base.AbstractVector
+Base.AbstractMatrix
+Core.Array
+Core.Array(::Any)
+Base.Vector
+Base.Vector(::Any)
+Base.Matrix
+Base.Matrix(::Any, ::Any)
+Base.getindex(::Type, ::Any...)
+Base.zeros
+Base.ones
+Base.BitArray
+Base.BitArray(::Integer...)
+Base.BitArray(::Any)
+Base.trues
+Base.falses
+Base.fill
+Base.fill!
+Base.similar(::AbstractArray)
+Base.similar(::Any, ::Tuple)
+Base.eye
+Base.linspace
+Base.logspace
+Base.Random.randsubseq
+Base.Random.randsubseq!
+```
+
 ## Basic functions
 
 ```@docs
@@ -20,27 +51,6 @@ Base.sub2ind
 Base.LinAlg.checksquare
 ```
 
-## Constructors
-
-```@docs
-Core.Array
-Base.getindex(::Type, ::Any...)
-Base.zeros
-Base.ones
-Base.BitArray
-Base.trues
-Base.falses
-Base.fill
-Base.fill!
-Base.reshape
-Base.similar(::AbstractArray)
-Base.similar(::Any, ::Tuple)
-Base.reinterpret
-Base.eye
-Base.linspace
-Base.logspace
-```
-
 ## Broadcast and vectorization
 
 See also the [dot syntax for vectorizing functions](@ref man-vectorized);
@@ -56,20 +66,39 @@ Base.Broadcast.broadcast_getindex
 Base.Broadcast.broadcast_setindex!
 ```
 
-## Indexing, Assignment, and Concatenation
+## Indexing and assignment
 
 ```@docs
 Base.getindex(::AbstractArray, ::Any...)
+Base.setindex!(::AbstractArray, ::Any, ::Any...)
+Base.copy!(::AbstractArray, ::CartesianRange, ::AbstractArray, ::CartesianRange)
+Base.isassigned
+Base.Colon
+Base.CartesianIndex
+Base.CartesianRange
+Base.to_indices
+Base.checkbounds
+Base.checkindex
+```
+
+## Views (SubArrays and other view types)
+
+```@docs
 Base.view
 Base.@view
 Base.@views
-Base.to_indices
-Base.Colon
 Base.parent
 Base.parentindexes
 Base.slicedim
-Base.setindex!(::AbstractArray, ::Any, ::Any...)
-Base.isassigned
+Base.reinterpret
+Base.reshape
+Base.squeeze
+Base.vec
+```
+
+## Concatenation and permutation
+
+```@docs
 Base.cat
 Base.vcat
 Base.hcat
@@ -98,13 +127,7 @@ Base.findprev(::Any, ::Any, ::Integer)
 Base.permutedims
 Base.permutedims!
 Base.PermutedDimsArray
-Base.squeeze
-Base.vec
 Base.promote_shape
-Base.checkbounds
-Base.checkindex
-Base.Random.randsubseq
-Base.Random.randsubseq!
 ```
 
 ## Array functions
@@ -117,8 +140,10 @@ Base.cumprod!
 Base.cumsum
 Base.cumsum!
 Base.cumsum_kbn
+Base.crc32c
 Base.LinAlg.diff
 Base.LinAlg.gradient
+Base.repeat(::AbstractArray)
 Base.rot180
 Base.rotl90
 Base.rotr90
@@ -132,11 +157,13 @@ Base.sum_kbn
 
 ```@docs
 Base.Random.randperm
+Base.Random.randperm!
 Base.invperm
 Base.isperm
-Base.permute!{T}(::Any, ::AbstractArray{T, 1})
+Base.permute!(::Any, ::AbstractVector)
 Base.ipermute!
 Base.Random.randcycle
+Base.Random.randcycle!
 Base.Random.shuffle
 Base.Random.shuffle!
 Base.reverse
@@ -146,8 +173,8 @@ Base.reverse!
 
 ## BitArrays
 
-`BitArray`s are space-efficient "packed" boolean arrays, which store one bit per boolean value.
- They can be used similarly to `Array{Bool}` arrays (which store one byte per boolean value),
+[`BitArray`](@ref)s are space-efficient "packed" boolean arrays, which store one bit per boolean value.
+They can be used similarly to `Array{Bool}` arrays (which store one byte per boolean value),
 and can be converted to/from the latter via `Array(bitarray)` and `BitArray(array)`, respectively.
 
 ```@docs
@@ -158,12 +185,14 @@ Base.ror!
 Base.ror
 ```
 
-## Sparse Vectors and Matrices
+## [Sparse Vectors and Matrices](@id stdlib-sparse-arrays)
 
 Sparse vectors and matrices largely support the same set of operations as their dense counterparts.
 The following functions are specific to sparse arrays.
 
 ```@docs
+Base.SparseArrays.SparseVector
+Base.SparseArrays.SparseMatrixCSC
 Base.SparseArrays.sparse
 Base.SparseArrays.sparsevec
 Base.SparseArrays.issparse
diff --git a/doc/src/stdlib/base.md b/doc/src/stdlib/base.md
index 4c6289d551f2f4..fa72079d535a5b 100644
--- a/doc/src/stdlib/base.md
+++ b/doc/src/stdlib/base.md
@@ -76,6 +76,7 @@ Base.finalize
 Base.copy
 Base.deepcopy
 Core.isdefined
+Base.@isdefined
 Base.convert
 Base.promote
 Base.oftype
@@ -87,8 +88,7 @@ Base.identity
 
 ```@docs
 Base.supertype
-Core.issubtype
-Base.:(<:)
+Core.:(<:)
 Base.:(>:)
 Base.subtypes
 Base.typemin
@@ -118,9 +118,11 @@ Base.instances
 ## Generic Functions
 
 ```@docs
+Core.Function
 Base.method_exists
 Core.applicable
 Core.invoke
+Base.invokelatest
 Base.:(|>)
 Base.:(∘)
 ```
@@ -135,6 +137,7 @@ Base.esc
 Base.@inbounds
 Base.@inline
 Base.@noinline
+Base.@nospecialize
 Base.gensym
 Base.@gensym
 Base.@polly
@@ -186,11 +189,11 @@ Base.@elapsed
 Base.@allocated
 Base.EnvHash
 Base.ENV
-Base.is_unix
-Base.is_apple
-Base.is_linux
-Base.is_bsd
-Base.is_windows
+Base.Sys.isunix
+Base.Sys.isapple
+Base.Sys.islinux
+Base.Sys.isbsd
+Base.Sys.iswindows
 Base.Sys.windows_version
 Base.@static
 ```
@@ -248,12 +251,13 @@ Base.AsyncCondition(::Function)
 ```@docs
 Base.module_name
 Base.module_parent
-Base.current_module
+Base.@__MODULE__
 Base.fullname
 Base.names
 Core.nfields
 Base.fieldnames
 Base.fieldname
+Base.fieldcount
 Base.datatype_module
 Base.datatype_name
 Base.isconst
@@ -272,6 +276,7 @@ Base.gc
 Base.gc_enable
 Base.macroexpand
 Base.@macroexpand
+Base.@macroexpand1
 Base.expand
 Base.code_lowered
 Base.@code_lowered
diff --git a/doc/src/stdlib/collections.md b/doc/src/stdlib/collections.md
index 29d8c38f3b1a8e..9415ae0fc1ce60 100644
--- a/doc/src/stdlib/collections.md
+++ b/doc/src/stdlib/collections.md
@@ -39,7 +39,7 @@ Fully implemented by:
   * `UnitRange`
   * `Tuple`
   * `Number`
-  * `AbstractArray`
+  * [`AbstractArray`](@ref)
   * [`IntSet`](@ref)
   * [`ObjectIdDict`](@ref)
   * [`Dict`](@ref)
@@ -54,7 +54,6 @@ Fully implemented by:
 Base.isempty
 Base.empty!
 Base.length(::Any)
-Base.endof
 ```
 
 Fully implemented by:
@@ -63,7 +62,7 @@ Fully implemented by:
   * `UnitRange`
   * `Tuple`
   * `Number`
-  * `AbstractArray`
+  * [`AbstractArray`](@ref)
   * [`IntSet`](@ref)
   * [`ObjectIdDict`](@ref)
   * [`Dict`](@ref)
@@ -79,6 +78,7 @@ Base.eltype
 Base.indexin
 Base.findin
 Base.unique
+Base.unique!
 Base.allunique
 Base.reduce(::Any, ::Any, ::Any)
 Base.reduce(::Any, ::Any)
@@ -139,24 +139,25 @@ Base.filter!
 ```@docs
 Base.getindex(::Any, ::Any...)
 Base.setindex!(::Any, ::Any, ::Any...)
+Base.endof
 ```
 
 Fully implemented by:
 
   * [`Array`](@ref)
   * [`BitArray`](@ref)
-  * `AbstractArray`
+  * [`AbstractArray`](@ref)
   * `SubArray`
-  * [`ObjectIdDict`](@ref)
-  * [`Dict`](@ref)
-  * [`WeakKeyDict`](@ref)
-  * `AbstractString`
 
 Partially implemented by:
 
   * `Range`
   * `UnitRange`
   * `Tuple`
+  * `AbstractString`
+  * [`Dict`](@ref)
+  * [`ObjectIdDict`](@ref)
+  * [`WeakKeyDict`](@ref)
 
 ## Associative Collections
 
@@ -196,7 +197,8 @@ Base.pop!(::Any, ::Any, ::Any)
 Base.keys
 Base.values
 Base.merge
-Base.merge!
+Base.merge!(::Associative, ::Associative...)
+Base.merge!(::Function, ::Associative, ::Associative...)
 Base.sizehint!
 Base.keytype
 Base.valtype
diff --git a/doc/src/stdlib/constants.md b/doc/src/stdlib/constants.md
index f5174fddc42d41..e88211b354038c 100644
--- a/doc/src/stdlib/constants.md
+++ b/doc/src/stdlib/constants.md
@@ -8,7 +8,6 @@ Base.C_NULL
 Base.VERSION
 Base.LOAD_PATH
 Base.JULIA_HOME
-Core.ANY
 Base.Sys.CPU_CORES
 Base.Sys.WORD_SIZE
 Base.Sys.KERNEL
diff --git a/doc/src/stdlib/dates.md b/doc/src/stdlib/dates.md
index 2b9df1820bdad0..a7ebd9f3d64ddd 100644
--- a/doc/src/stdlib/dates.md
+++ b/doc/src/stdlib/dates.md
@@ -1,4 +1,4 @@
-# Dates and Time
+# [Dates and Time](@id stdlib-dates)
 
 ## Dates and Time Types
 
@@ -117,7 +117,7 @@ Base.Dates.toprev(::Function, ::Base.Dates.TimeType)
 
 ```@docs
 Base.Dates.Period(::Any)
-Base.Dates.CompoundPeriod{P <: Base.Dates.Period}(::Array{P,1})
+Base.Dates.CompoundPeriod(::Vector{<:Base.Dates.Period})
 Base.Dates.default
 ```
 
diff --git a/doc/src/stdlib/file.md b/doc/src/stdlib/file.md
index e0f5874d0d5277..26e9f9d5779286 100644
--- a/doc/src/stdlib/file.md
+++ b/doc/src/stdlib/file.md
@@ -49,7 +49,7 @@ Base.Filesystem.dirname
 Base.Filesystem.basename
 Base.@__FILE__
 Base.@__DIR__
-@__LINE__
+Base.@__LINE__
 Base.Filesystem.isabspath
 Base.Filesystem.isdirpath
 Base.Filesystem.joinpath
diff --git a/doc/src/stdlib/index.md b/doc/src/stdlib/index.md
index 0684e1964af161..c4b9d525c3b8e9 100644
--- a/doc/src/stdlib/index.md
+++ b/doc/src/stdlib/index.md
@@ -14,7 +14,7 @@
   * [Punctuation](@ref)
   * [Sorting and Related Functions](@ref)
   * [Package Manager Functions](@ref)
-  * [Dates and Time](@ref)
+  * [Dates and Time](@ref stdlib-dates)
   * [Iteration utilities](@ref)
   * [Unit Testing](@ref)
   * [C Interface](@ref)
diff --git a/doc/src/stdlib/io-network.md b/doc/src/stdlib/io-network.md
index cb697abfbac334..3c94efcc2e3395 100644
--- a/doc/src/stdlib/io-network.md
+++ b/doc/src/stdlib/io-network.md
@@ -8,10 +8,11 @@ Base.STDERR
 Base.STDIN
 Base.open
 Base.IOBuffer
-Base.take!(::Base.AbstractIOBuffer)
+Base.take!(::Base.GenericIOBuffer)
 Base.fdio
 Base.flush
 Base.close
+Base.crc32c(::IO, ::Integer, ::UInt32)
 Base.write
 Base.read
 Base.read!
@@ -58,7 +59,6 @@ Base.IOContext(::IO, ::IOContext)
 ```@docs
 Base.show(::Any)
 Base.showcompact
-Base.showall
 Base.summary
 Base.print
 Base.println
@@ -71,7 +71,7 @@ Base.Printf.@sprintf
 Base.sprint
 Base.showerror
 Base.dump
-Base.readstring
+Meta.@dump
 Base.readline
 Base.readuntil
 Base.readlines
@@ -162,6 +162,7 @@ Base.listen(::Any)
 Base.listen(::AbstractString)
 Base.getaddrinfo
 Base.getsockname
+Base.getpeername
 Base.IPv4
 Base.IPv6
 Base.nb_available
diff --git a/doc/src/stdlib/linalg.md b/doc/src/stdlib/linalg.md
index f8dc0fe81446dd..e9421cb2168574 100644
--- a/doc/src/stdlib/linalg.md
+++ b/doc/src/stdlib/linalg.md
@@ -18,6 +18,9 @@ Base.LinAlg.SymTridiagonal
 Base.LinAlg.Tridiagonal
 Base.LinAlg.Symmetric
 Base.LinAlg.Hermitian
+Base.LinAlg.LowerTriangular
+Base.LinAlg.UpperTriangular
+Base.LinAlg.UniformScaling
 Base.LinAlg.lu
 Base.LinAlg.lufact
 Base.LinAlg.lufact!
@@ -34,6 +37,9 @@ Base.LinAlg.qr
 Base.LinAlg.qr!
 Base.LinAlg.qrfact
 Base.LinAlg.qrfact!
+Base.LinAlg.QR
+Base.LinAlg.QRCompactWY
+Base.LinAlg.QRPivoted
 Base.LinAlg.lqfact!
 Base.LinAlg.lqfact
 Base.LinAlg.lq
@@ -79,11 +85,10 @@ Base.LinAlg.trace
 Base.LinAlg.det
 Base.LinAlg.logdet
 Base.LinAlg.logabsdet
-Base.inv
+Base.inv(::AbstractMatrix)
 Base.LinAlg.pinv
 Base.LinAlg.nullspace
 Base.repmat
-Base.repeat
 Base.kron
 Base.SparseArrays.blkdiag
 Base.LinAlg.linreg
@@ -92,6 +97,7 @@ Base.LinAlg.logm
 Base.LinAlg.sqrtm
 Base.LinAlg.lyap
 Base.LinAlg.sylvester
+Base.LinAlg.issuccess
 Base.LinAlg.issymmetric
 Base.LinAlg.isposdef
 Base.LinAlg.isposdef!
@@ -151,13 +157,13 @@ Base.At_rdiv_Bt
 
 In Julia (as in much of scientific computation), dense linear-algebra operations are based on
 the [LAPACK library](http://www.netlib.org/lapack/), which in turn is built on top of basic linear-algebra
-building-blocks known as the [BLAS](http://www.netlib.org/blas/).  There are highly optimized
+building-blocks known as the [BLAS](http://www.netlib.org/blas/). There are highly optimized
 implementations of BLAS available for every computer architecture, and sometimes in high-performance
 linear algebra routines it is useful to call the BLAS functions directly.
 
 `Base.LinAlg.BLAS` provides wrappers for some of the BLAS functions. Those BLAS functions
 that overwrite one of the input arrays have names ending in `'!'`.  Usually, a BLAS function has
-four methods defined, for `Float64`, `Float32`, `Complex128`, and `Complex64` arrays.
+four methods defined, for [`Float64`](@ref), [`Float32`](@ref), `Complex128`, and `Complex64` arrays.
 
 ### [BLAS Character Arguments](@id stdlib-blas-chars)
 Many BLAS functions accept arguments that determine whether to transpose an argument (`trans`),
@@ -221,7 +227,6 @@ Base.LinAlg.BLAS.gemv(::Any, ::Any, ::Any)
 Base.LinAlg.BLAS.symm!
 Base.LinAlg.BLAS.symm(::Any, ::Any, ::Any, ::Any, ::Any)
 Base.LinAlg.BLAS.symm(::Any, ::Any, ::Any, ::Any)
-Base.LinAlg.BLAS.symm(::Char, ::Char, ::Any, ::Any, ::Any)
 Base.LinAlg.BLAS.symv!
 Base.LinAlg.BLAS.symv(::Any, ::Any, ::Any, ::Any)
 Base.LinAlg.BLAS.symv(::Any, ::Any, ::Any)
@@ -242,8 +247,8 @@ Base.LinAlg.I
 `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.
+Usually a function has 4 methods defined, one each for [`Float64`](@ref), [`Float32`](@ref),
+`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
diff --git a/doc/src/stdlib/math.md b/doc/src/stdlib/math.md
index a195a354e9a0f7..1d8666c54a77ec 100644
--- a/doc/src/stdlib/math.md
+++ b/doc/src/stdlib/math.md
@@ -12,6 +12,7 @@ Base.:\(::Any, ::Any)
 Base.:^(::Number, ::Number)
 Base.fma
 Base.muladd
+Base.inv(::Number)
 Base.div
 Base.fld
 Base.cld
@@ -58,6 +59,7 @@ Base.:(!)
 Base.isapprox
 Base.sin
 Base.cos
+Base.sincos
 Base.tan
 Base.Math.sind
 Base.Math.cosd
@@ -180,6 +182,7 @@ Base.Math.lbeta
 Base.ndigits
 Base.widemul
 Base.Math.@evalpoly
+Base.FastMath.@fastmath
 ```
 
 ## Statistics
@@ -199,54 +202,3 @@ Base.quantile!
 Base.cov
 Base.cor
 ```
-
-## Signal Processing
-
-Fast Fourier transform (FFT) functions in Julia are implemented by calling functions from [FFTW](http://www.fftw.org).
-
-```@docs
-Base.DFT.fft
-Base.DFT.fft!
-Base.DFT.ifft
-Base.DFT.ifft!
-Base.DFT.bfft
-Base.DFT.bfft!
-Base.DFT.plan_fft
-Base.DFT.plan_ifft
-Base.DFT.plan_bfft
-Base.DFT.plan_fft!
-Base.DFT.plan_ifft!
-Base.DFT.plan_bfft!
-Base.DFT.rfft
-Base.DFT.irfft
-Base.DFT.brfft
-Base.DFT.plan_rfft
-Base.DFT.plan_brfft
-Base.DFT.plan_irfft
-Base.DFT.FFTW.dct
-Base.DFT.FFTW.dct!
-Base.DFT.FFTW.idct
-Base.DFT.FFTW.idct!
-Base.DFT.FFTW.plan_dct
-Base.DFT.FFTW.plan_dct!
-Base.DFT.FFTW.plan_idct
-Base.DFT.FFTW.plan_idct!
-Base.DFT.fftshift(::Any)
-Base.DFT.fftshift(::Any, ::Any)
-Base.DFT.ifftshift
-Base.DSP.filt
-Base.DSP.filt!
-Base.DSP.deconv
-Base.DSP.conv
-Base.DSP.conv2
-Base.DSP.xcorr
-```
-
-The following functions are defined within the `Base.FFTW` module.
-
-```@docs
-Base.DFT.FFTW.r2r
-Base.DFT.FFTW.r2r!
-Base.DFT.FFTW.plan_r2r
-Base.DFT.FFTW.plan_r2r!
-```
diff --git a/doc/src/stdlib/numbers.md b/doc/src/stdlib/numbers.md
index 36ee7e5634d2ff..d04e7510a536f0 100644
--- a/doc/src/stdlib/numbers.md
+++ b/doc/src/stdlib/numbers.md
@@ -2,22 +2,40 @@
 
 ## Standard Numeric Types
 
-  * `Bool`
-  * `Int8`
-  * `UInt8`
-  * `Int16`
-  * `UInt16`
-  * `Int32`
-  * `UInt32`
-  * `Int64`
-  * `UInt64`
-  * `Int128`
-  * `UInt128`
-  * `Float16`
-  * `Float32`
-  * `Float64`
-  * `Complex64`
-  * `Complex128`
+### Abstract number types
+
+```@docs
+Core.Number
+Core.Real
+Core.AbstractFloat
+Core.Integer
+Core.Signed
+Core.Unsigned
+```
+
+### Concrete number types
+
+```@docs
+Core.Float16
+Core.Float32
+Core.Float64
+Base.BigFloat
+Core.Bool
+Core.Int8
+Core.UInt8
+Core.Int16
+Core.UInt16
+Core.Int32
+Core.UInt32
+Core.Int64
+Core.UInt64
+Core.Int128
+Core.UInt128
+Base.BigInt
+Base.Complex
+Base.Rational
+Base.Irrational
+```
 
 ## Data Formats
 
@@ -69,14 +87,15 @@ Base.isfinite
 Base.isinf
 Base.isnan
 Base.iszero
+Base.isone
 Base.nextfloat
 Base.prevfloat
 Base.isinteger
 Base.isreal
-Core.Float32
-Core.Float64
-Base.GMP.BigInt
-Base.MPFR.BigFloat
+Core.Float32(::Any)
+Core.Float64(::Any)
+Base.GMP.BigInt(::Any)
+Base.MPFR.BigFloat(::Any)
 Base.Rounding.rounding
 Base.Rounding.setrounding(::Type, ::Any)
 Base.Rounding.setrounding(::Function, ::Type, ::RoundingMode)
@@ -99,7 +118,8 @@ Base.iseven
 
 ## BigFloats
 
-The `BigFloat` type implements arbitrary-precision floating-point arithmetic using the [GNU MPFR library](http://www.mpfr.org/).
+The [`BigFloat`](@ref) type implements arbitrary-precision floating-point arithmetic using
+the [GNU MPFR library](http://www.mpfr.org/).
 
 ```@docs
 Base.precision
@@ -125,10 +145,12 @@ dimension specifications `dims...` (which can be given as a tuple) to generate a
 values.
 
 A `MersenneTwister` or `RandomDevice` RNG can generate random numbers of the following types:
-`Float16`, `Float32`, `Float64`, `Bool`, `Int8`, `UInt8`, `Int16`, `UInt16`, `Int32`, `UInt32`,
-`Int64`, `UInt64`, `Int128`, `UInt128`, `BigInt` (or complex numbers of those types). Random floating
-point numbers are generated uniformly in ``[0, 1)``. As `BigInt` represents unbounded integers,
-the interval must be specified (e.g. `rand(big(1:6))`).
+[`Float16`](@ref), [`Float32`](@ref), [`Float64`](@ref), [`Bool`](@ref), [`Int8`](@ref),
+[`UInt8`](@ref), [`Int16`](@ref), [`UInt16`](@ref), [`Int32`](@ref), [`UInt32`](@ref),
+[`Int64`](@ref), [`UInt64`](@ref), [`Int128`](@ref), [`UInt128`](@ref), [`BigInt`](@ref)
+(or complex numbers of those types). Random floating point numbers are generated uniformly
+in ``[0, 1)``. As `BigInt` represents unbounded integers, the interval must be specified
+(e.g. `rand(big(1:6))`).
 
 ```@docs
 Base.Random.srand
diff --git a/doc/src/stdlib/parallel.md b/doc/src/stdlib/parallel.md
index d668f346136d1f..17f19ec64ab3c4 100644
--- a/doc/src/stdlib/parallel.md
+++ b/doc/src/stdlib/parallel.md
@@ -4,11 +4,11 @@
 
 ```@docs
 Core.Task
-Base.yieldto
 Base.current_task
 Base.istaskdone
 Base.istaskstarted
 Base.yield
+Base.yieldto
 Base.task_local_storage(::Any)
 Base.task_local_storage(::Any, ::Any)
 Base.task_local_storage(::Function, ::Any, ::Any)
@@ -150,7 +150,8 @@ and transport messages between processes. It is possible for Cluster Managers to
 Base.launch
 Base.manage
 Base.kill(::ClusterManager, ::Int, ::WorkerConfig)
-Base.init_worker
 Base.connect(::ClusterManager, ::Int, ::WorkerConfig)
+Base.init_worker
+Base.start_worker
 Base.process_messages
 ```
diff --git a/doc/src/stdlib/simd-types.md b/doc/src/stdlib/simd-types.md
index e35c4439487071..dbd362053c64c2 100644
--- a/doc/src/stdlib/simd-types.md
+++ b/doc/src/stdlib/simd-types.md
@@ -4,13 +4,13 @@ Type `VecElement{T}` is intended for building libraries of SIMD operations. Prac
 requires using `llvmcall`. The type is defined as:
 
 ```julia
-immutable VecElement{T}
+struct VecElement{T}
     value::T
 end
 ```
 
 It has a special compilation rule: a homogeneous tuple of `VecElement{T}` maps to an LLVM `vector`
-type when `T` is a bitstype and the tuple length is in the set {2-6,8-10,16}.
+type when `T` is a primitive bits type and the tuple length is in the set {2-6,8-10,16}.
 
 At `-O3`, the compiler *might* automatically vectorize operations on such tuples. For example,
 the following program, when compiled with `julia -O3` generates two SIMD addition instructions
diff --git a/doc/src/stdlib/sort.md b/doc/src/stdlib/sort.md
index 83ef65eef01cad..65bfd0e70bbc91 100644
--- a/doc/src/stdlib/sort.md
+++ b/doc/src/stdlib/sort.md
@@ -3,7 +3,7 @@
 Julia has an extensive, flexible API for sorting and interacting with already-sorted arrays of
 values. By default, Julia picks reasonable algorithms and sorts in standard ascending order:
 
-```julia
+```jldoctest
 julia> sort([2,3,1])
 3-element Array{Int64,1}:
  1
@@ -13,7 +13,7 @@ julia> sort([2,3,1])
 
 You can easily sort in reverse order as well:
 
-```julia
+```jldoctest
 julia> sort([2,3,1], rev=true)
 3-element Array{Int64,1}:
  3
@@ -23,7 +23,7 @@ julia> sort([2,3,1], rev=true)
 
 To sort an array in-place, use the "bang" version of the sort function:
 
-```julia
+```jldoctest
 julia> a = [2,3,1];
 
 julia> sort!(a);
@@ -38,7 +38,7 @@ julia> a
 Instead of directly sorting an array, you can compute a permutation of the array's indices that
 puts the array into sorted order:
 
-```julia
+```julia-repl
 julia> v = randn(5)
 5-element Array{Float64,1}:
   0.297288
@@ -66,7 +66,7 @@ julia> v[p]
 
 Arrays can easily be sorted according to an arbitrary transformation of their values:
 
-```julia
+```julia-repl
 julia> sort(v, by=abs)
 5-element Array{Float64,1}:
  -0.0104452
@@ -78,7 +78,7 @@ julia> sort(v, by=abs)
 
 Or in reverse order by a transformation:
 
-```julia
+```julia-repl
 julia> sort(v, by=abs, rev=true)
 5-element Array{Float64,1}:
  -0.839027
@@ -90,7 +90,7 @@ julia> sort(v, by=abs, rev=true)
 
 If needed, the sorting algorithm can be chosen:
 
-```julia
+```julia-repl
 julia> sort(v, alg=InsertionSort)
 5-element Array{Float64,1}:
  -0.839027
@@ -174,11 +174,11 @@ your preferred algorithm, e.g. `sort!(v, alg=QuickSort)`.
 
 The mechanism by which Julia picks default sorting algorithms is implemented via the `Base.Sort.defalg`
 function. It allows a particular algorithm to be registered as the default in all sorting functions
-for specific arrays. For example, here are the two default methods from [sort.jl](https://github.com/JuliaLang/julia/blob/master/base/sort.jl):
+for specific arrays. For example, here are the two default methods from [`sort.jl`](https://github.com/JuliaLang/julia/blob/master/base/sort.jl):
 
 ```julia
 defalg(v::AbstractArray) = MergeSort
-defalg{T<:Number}(v::AbstractArray{T}) = QuickSort
+defalg(v::AbstractArray{<:Number}) = QuickSort
 ```
 
 As for numeric arrays, choosing a non-stable default algorithm for array types for which the notion
diff --git a/doc/src/stdlib/strings.md b/doc/src/stdlib/strings.md
index c04edc20566cb0..e8d6ee63c1b55a 100644
--- a/doc/src/stdlib/strings.md
+++ b/doc/src/stdlib/strings.md
@@ -6,6 +6,8 @@ Base.sizeof(::AbstractString)
 Base.:*(::AbstractString, ::Any...)
 Base.:^(::AbstractString, ::Integer)
 Base.string
+Base.repeat(::AbstractString, ::Integer)
+Base.repeat(::Char, ::Integer)
 Base.repr
 Core.String(::AbstractString)
 Base.transcode
diff --git a/doc/src/stdlib/test.md b/doc/src/stdlib/test.md
index 7c4195014b0e09..baf78ae1c16b6a 100644
--- a/doc/src/stdlib/test.md
+++ b/doc/src/stdlib/test.md
@@ -1,5 +1,11 @@
 # Unit Testing
 
+```@meta
+DocTestSetup = quote
+    using Base.Test
+end
+```
+
 ## Testing Base Julia
 
 Julia is under rapid development and has an extensive test suite to verify functionality across
@@ -26,7 +32,7 @@ Base.Test.@test_throws
 
 For example, suppose we want to check our new function `foo(x)` works as expected:
 
-```julia
+```jldoctest testfoo
 julia> using Base.Test
 
 julia> foo(x) = length(x)^2
@@ -35,61 +41,56 @@ foo (generic function with 1 method)
 
 If the condition is true, a `Pass` is returned:
 
-```julia
+```jldoctest testfoo
 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
+```jldoctest testfoo
 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 `length()` is not defined for symbols, an `Error` object is returned and an exception
 is thrown:
 
-```julia
+```julia-repl
 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
+  MethodError: no method matching length(::Symbol)
+  Closest candidates are:
+    length(::SimpleVector) at essentials.jl:256
+    length(::Base.MethodList) at reflection.jl:521
+    length(::MethodTable) at reflection.jl:597
+    ...
+  Stacktrace:
+   [...]
 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 `@test_throws()`
 to check that this occurs:
 
-```julia
+```jldoctest testfoo
 julia> @test_throws MethodError foo(:cat)
 Test Passed
-  Expression: foo(:cat)
-   Evaluated: MethodError
+      Thrown: MethodError
 ```
 
 ## Working with Test Sets
 
-Typically a large of number of tests are used to make sure functions work correctly over a range
+Typically a large 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.
@@ -104,19 +105,19 @@ Base.Test.@testset
 
 We can put our tests for the `foo(x)` function in a test set:
 
-```julia
+```jldoctest testfoo
 julia> @testset "Foo Tests" begin
            @test foo("a")   == 1
            @test foo("ab")  == 4
            @test foo("abc") == 9
-       end
+       end;
 Test Summary: | Pass  Total
 Foo Tests     |    3      3
 ```
 
 Test sets can also be nested:
 
-```julia
+```jldoctest testfoo
 julia> @testset "Foo Tests" begin
            @testset "Animals" begin
                @test foo("cat") == 9
@@ -126,7 +127,7 @@ julia> @testset "Foo Tests" begin
                @test foo(zeros(i)) == i^2
                @test foo(ones(i)) == i^2
            end
-       end
+       end;
 Test Summary: | Pass  Total
 Foo Tests     |    8      8
 ```
@@ -134,7 +135,7 @@ 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
+```julia-repl
 julia> @testset "Foo Tests" begin
            @testset "Animals" begin
                @testset "Felines" begin
@@ -153,14 +154,13 @@ julia> @testset "Foo Tests" begin
 Arrays: Test Failed
   Expression: foo(ones(4)) == 15
    Evaluated: 16 == 15
- in record at test.jl:297
- in do_test at test.jl:191
+Stacktrace:
+    [...]
 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, 0 broken.
- in finish at test.jl:362
 ```
 
 ## Other Test Macros
@@ -169,15 +169,15 @@ As calculations on floating-point values can be imprecise, you can perform appro
 checks using either `@test a ≈ b` (where `≈`, typed via tab completion of `\approx`, is the
 [`isapprox()`](@ref) function) or use [`isapprox()`](@ref) directly.
 
-```julia
+```jldoctest
 julia> @test 1 ≈ 0.999999999
+Test Passed
 
 julia> @test 1 ≈ 0.999999
-ERROR: test failed: 1 isapprox 0.999999
- in expression: 1 ≈ 0.999999
- in error at error.jl:21
- in default_handler at test.jl:30
- in do_test at test.jl:53
+Test Failed
+  Expression: 1 ≈ 0.999999
+   Evaluated: 1 ≈ 0.999999
+ERROR: There was an error during testing
 ```
 
 ```@docs
@@ -235,7 +235,7 @@ 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
+struct CustomTestSet <: Base.Test.AbstractTestSet
     description::AbstractString
     foo::Int
     results::Vector
@@ -264,3 +264,7 @@ And using that testset looks like:
     end
 end
 ```
+
+```@meta
+DocTestSetup = nothing
+```
diff --git a/etc/juliarc.jl b/etc/juliarc.jl
index 5b218a1532a694..3993e62867710f 100644
--- a/etc/juliarc.jl
+++ b/etc/juliarc.jl
@@ -1,3 +1,3 @@
 # This file should contain site-specific commands to be executed on Julia startup
-# Users should store their own personal commands in homedir(), in a file named .juliarc.jl
+# Users may store their own personal commands in the user home directory `homedir()`, in a file named `.juliarc.jl`
 
diff --git a/examples/Makefile b/examples/Makefile
index 66d7210adfc918..08e2ff962966e8 100644
--- a/examples/Makefile
+++ b/examples/Makefile
@@ -1,41 +1,13 @@
-JULIAHOME = $(abspath ..)
+## this is a simple wrapper just to forward on known commands to the
+## embedding example with values pulled from Make.inc
+SRCDIR := $(abspath $(dir $(lastword $(MAKEFILE_LIST))))
+JULIAHOME := $(abspath $(SRCDIR)/..)
+BUILDDIR := .
 include $(JULIAHOME)/Make.inc
 
-FLAGS = -Wall -Wno-strict-aliasing -fno-omit-frame-pointer \
-	-I$(JULIAHOME)/src -I$(JULIAHOME)/src/support -I$(build_includedir) $(CFLAGS)
-
-DEBUGFLAGS += $(FLAGS)
-SHIPFLAGS += $(FLAGS)
-JLDFLAGS += $(LDFLAGS) $(NO_WHOLE_ARCHIVE) $(call exec,$(LLVM_CONFIG) --ldflags) $(OSLIBS) $(RPATH)
-
-ifeq ($(USE_SYSTEM_LIBM),0)
-ifneq ($(UNTRUSTED_SYSTEM_LIBM),0)
-JLDFLAGS += $(WHOLE_ARCHIVE) $(build_libdir)/libopenlibm.a $(NO_WHOLE_ARCHIVE)
-endif
-endif
-
-embedding-release: embedding
-
-release debug:
-	$(MAKE) embedding-$@
-
-%.o: %.c
-	@$(call PRINT_CC, $(CC) $(CPPFLAGS) $(CFLAGS) $(SHIPFLAGS) -c $< -o $@)
-%.do: %.c
-	@$(call PRINT_CC, $(CC) $(CPPFLAGS) $(CFLAGS) $(DEBUGFLAGS) -c $< -o $@)
-
-embedding: $(build_bindir)/embedding$(EXE)
-embedding-debug: $(build_bindir)/embedding-debug$(EXE)
-
-$(build_bindir)/embedding$(EXE): embedding.o
-	@$(call PRINT_LINK, $(CXX) $(LINK_FLAGS) $(SHIPFLAGS) $^ -o $@ -L$(build_private_libdir) -L$(build_shlibdir) -ljulia $(JLDFLAGS))
-$(build_bindir)/embedding-debug$(EXE): embedding.do
-	@$(call PRINT_LINK, $(CXX) $(LINK_FLAGS) $(DEBUGFLAGS) $^ -o $@ -L$(build_private_libdir) -L$(build_shlibdir) -ljulia-debug $(JLDFLAGS))
-
-
-clean: | $(CLEAN_TARGETS)
-	rm -f *.o *.do
-	rm -f $(build_bindir)/embedding-debug $(build_bindir)/embedding
-
-.PHONY: clean release debug
-
+release: # default target
+# forward all variables expected by the embedding example
+JULIA:=$(call spawn,$(JULIA_EXECUTABLE))
+BIN:=$(BUILDDIR)/embedding
+CC:=$(CC)
+include $(SRCDIR)/embedding/Makefile
diff --git a/examples/ModInts.jl b/examples/ModInts.jl
index d8117228148432..59fde002d26c52 100644
--- a/examples/ModInts.jl
+++ b/examples/ModInts.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module ModInts
 export ModInt
@@ -7,21 +7,21 @@ import Base: +, -, *, /, inv
 
 struct ModInt{n} <: Integer
     k::Int
-    ModInt{n}(k) where n = new(mod(k,n))
+    ModInt{n}(k) where {n} = new(mod(k,n))
 end
 
-Base.show{n}(io::IO, k::ModInt{n}) =
+Base.show(io::IO, k::ModInt{n}) where {n} =
     print(io, get(io, :compact, false) ? k.k : "$(k.k) mod $n")
 
-+{n}(a::ModInt{n}, b::ModInt{n}) = ModInt{n}(a.k+b.k)
--{n}(a::ModInt{n}, b::ModInt{n}) = ModInt{n}(a.k-b.k)
-*{n}(a::ModInt{n}, b::ModInt{n}) = ModInt{n}(a.k*b.k)
--{n}(a::ModInt{n}) = ModInt{n}(-a.k)
+(+)(a::ModInt{n}, b::ModInt{n}) where {n} = ModInt{n}(a.k+b.k)
+(-)(a::ModInt{n}, b::ModInt{n}) where {n} = ModInt{n}(a.k-b.k)
+(*)(a::ModInt{n}, b::ModInt{n}) where {n} = ModInt{n}(a.k*b.k)
+(-)(a::ModInt{n}) where {n} = ModInt{n}(-a.k)
 
-inv{n}(a::ModInt{n}) = ModInt{n}(invmod(a.k, n))
-/{n}(a::ModInt{n}, b::ModInt{n}) = a*inv(b) # broaden for non-coprime?
+inv(a::ModInt{n}) where {n} = ModInt{n}(invmod(a.k, n))
+(/)(a::ModInt{n}, b::ModInt{n}) where {n} = a*inv(b) # broaden for non-coprime?
 
-Base.promote_rule{n}(::Type{ModInt{n}}, ::Type{Int}) = ModInt{n}
-Base.convert{n}(::Type{ModInt{n}}, i::Int) = ModInt{n}(i)
+Base.promote_rule(::Type{ModInt{n}}, ::Type{Int}) where {n} = ModInt{n}
+Base.convert(::Type{ModInt{n}}, i::Int) where {n} = ModInt{n}(i)
 
 end # module
diff --git a/examples/bubblesort.jl b/examples/bubblesort.jl
index 8b39e6793ded4d..6b7c244da1fa96 100644
--- a/examples/bubblesort.jl
+++ b/examples/bubblesort.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 import Base.Sort
 struct BubbleSortAlg <: Sort.Algorithm end
diff --git a/examples/clustermanager/0mq/ZMQCM.jl b/examples/clustermanager/0mq/ZMQCM.jl
index 4d89de0ed029c1..d18e7b66d58d0d 100644
--- a/examples/clustermanager/0mq/ZMQCM.jl
+++ b/examples/clustermanager/0mq/ZMQCM.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using ZMQ
 
diff --git a/examples/clustermanager/0mq/broker.jl b/examples/clustermanager/0mq/broker.jl
index 6801700b762c59..87d28490463567 100644
--- a/examples/clustermanager/0mq/broker.jl
+++ b/examples/clustermanager/0mq/broker.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 include("ZMQCM.jl")
 start_broker()
diff --git a/examples/clustermanager/0mq/head.jl b/examples/clustermanager/0mq/head.jl
index b8929c47889ff5..ff0f718eb10b58 100644
--- a/examples/clustermanager/0mq/head.jl
+++ b/examples/clustermanager/0mq/head.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 include("ZMQCM.jl")
 
diff --git a/examples/clustermanager/0mq/worker.jl b/examples/clustermanager/0mq/worker.jl
index e541044b009f28..bbb2ebca60a852 100644
--- a/examples/clustermanager/0mq/worker.jl
+++ b/examples/clustermanager/0mq/worker.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 include("ZMQCM.jl")
 
diff --git a/examples/clustermanager/simple/UnixDomainCM.jl b/examples/clustermanager/simple/UnixDomainCM.jl
index f96c6e0fcf7a62..afffa610a21b95 100644
--- a/examples/clustermanager/simple/UnixDomainCM.jl
+++ b/examples/clustermanager/simple/UnixDomainCM.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 import Base: launch, manage, connect, exit
 
@@ -12,11 +12,12 @@ function launch(manager::UnixDomainCM, params::Dict, launched::Array, c::Conditi
     for i in 1:manager.np
         sockname = tempname()
         try
-            cmd = `$(params[:exename]) --startup-file=no $(@__FILE__) udwrkr $sockname $cookie`
-            io, pobj = open(cmd, "r")
+            __file__ = @__FILE__
+            cmd = `$(params[:exename]) --startup-file=no $__file__ udwrkr $sockname $cookie`
+            pobj = open(cmd)
 
             wconfig = WorkerConfig()
-            wconfig.userdata = Dict(:sockname=>sockname, :io=>io, :process=>pobj)
+            wconfig.userdata = Dict(:sockname=>sockname, :io=>pobj.out, :process=>pobj)
             push!(launched, wconfig)
             notify(c)
         catch e
diff --git a/examples/clustermanager/simple/head.jl b/examples/clustermanager/simple/head.jl
index b42331ef9fcf1b..cb16b8eb4d7408 100644
--- a/examples/clustermanager/simple/head.jl
+++ b/examples/clustermanager/simple/head.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 include("UnixDomainCM.jl")
 
diff --git a/examples/clustermanager/simple/test_simple.jl b/examples/clustermanager/simple/test_simple.jl
index faca7e168fc989..2460eadd77b537 100644
--- a/examples/clustermanager/simple/test_simple.jl
+++ b/examples/clustermanager/simple/test_simple.jl
@@ -1,6 +1,6 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
-cmanpath = joinpath(dirname(@__FILE__), "UnixDomainCM.jl")
+cmanpath = joinpath(@__DIR__, "UnixDomainCM.jl")
 include(cmanpath)
 
 npids = addprocs(UnixDomainCM(2))
diff --git a/examples/dictchannel.jl b/examples/dictchannel.jl
index 83c8e1eebc70cd..f1b9bfd68a6ca4 100644
--- a/examples/dictchannel.jl
+++ b/examples/dictchannel.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 import Base: put!, wait, isready, take!, fetch
 
diff --git a/examples/embedding.c b/examples/embedding.c
deleted file mode 100644
index 34a7e422908413..00000000000000
--- a/examples/embedding.c
+++ /dev/null
@@ -1,105 +0,0 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
-
-#include <julia.h>
-#include <stdio.h>
-#include <math.h>
-
-#ifdef _OS_WINDOWS_
-__declspec(dllexport) __cdecl
-#endif
-double my_c_sqrt(double x)
-{
-    return sqrt(x);
-}
-
-int main()
-{
-    jl_init(NULL);
-
-    {
-        // Simple running Julia code
-
-        jl_eval_string("println(sqrt(2.0))");
-    }
-
-    {
-        // Accessing the return value
-
-        jl_value_t *ret = jl_eval_string("sqrt(2.0)");
-
-        if (jl_is_float64(ret)) {
-            double retDouble = jl_unbox_float64(ret);
-            printf("sqrt(2.0) in C: %e\n", retDouble);
-        }
-    }
-
-    {
-        // Same as above but with function handle (more flexible)
-
-        jl_function_t *func = jl_get_function(jl_base_module, "sqrt");
-        jl_value_t* argument = jl_box_float64(2.0);
-        jl_value_t* ret = jl_call1(func, argument);
-
-        if (jl_is_float64(ret)) {
-            double retDouble = jl_unbox_float64(ret);
-            printf("sqrt(2.0) in C: %e\n", retDouble);
-        }
-    }
-
-    {
-        // 1D arrays
-
-        jl_value_t* array_type = jl_apply_array_type( jl_float64_type, 1 );
-        jl_array_t* x          = jl_alloc_array_1d(array_type , 10);
-        JL_GC_PUSH1(&x);
-
-        double* xData = jl_array_data(x);
-
-        size_t i;
-        for(i=0; i<jl_array_len(x); i++)
-            xData[i] = i;
-
-        jl_function_t *func  = jl_get_function(jl_base_module, "reverse!");
-        jl_call1(func, (jl_value_t*) x);
-
-        printf("x = [");
-        for(i=0; i<jl_array_len(x); i++)
-            printf("%e ", xData[i]);
-        printf("]\n");
-
-        JL_GC_POP();
-    }
-
-    {
-        // define julia function and call it
-
-        jl_eval_string("my_func(x) = 2*x");
-
-        jl_function_t *func = jl_get_function(jl_current_module, "my_func");
-        jl_value_t* arg = jl_box_float64(5.0);
-        double ret = jl_unbox_float64(jl_call1(func, arg));
-
-        printf("my_func(5.0) = %f\n", ret);
-    }
-
-    {
-        // call c function
-
-        jl_eval_string("println( ccall( :my_c_sqrt, Float64, (Float64,), 2.0 ) )");
-    }
-
-    {
-        // check for exceptions
-
-        jl_eval_string("this_function_does_not_exist()");
-
-        if (jl_exception_occurred()) {
-            jl_show(jl_stderr_obj(), jl_exception_occurred());
-            jl_printf(jl_stderr_stream(), "\n");
-        }
-    }
-
-    int ret = 0;
-    jl_atexit_hook(ret);
-    return ret;
-}
diff --git a/examples/embedding/.gitignore b/examples/embedding/.gitignore
new file mode 100644
index 00000000000000..4ce246ef166199
--- /dev/null
+++ b/examples/embedding/.gitignore
@@ -0,0 +1,2 @@
+/embedding
+/embedding-debug
diff --git a/examples/embedding/Makefile b/examples/embedding/Makefile
new file mode 100644
index 00000000000000..38e9bc33b2cae6
--- /dev/null
+++ b/examples/embedding/Makefile
@@ -0,0 +1,53 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
+# This Makefile template requires the following variables to be set
+# in the environment or on the command-line:
+#   JULIA: path to julia[.exe] executable
+#   BIN:   binary build directory
+
+ifndef JULIA
+  $(error "Please pass JULIA=[path of target julia binary], or set as environment variable!")
+endif
+ifndef BIN
+  $(error "Please pass BIN=[path of build directory], or set as environment variable!")
+endif
+
+#=============================================================================
+# this source directory where embedding.c is located
+SRCDIR := $(abspath $(dir $(lastword $(MAKEFILE_LIST))))
+
+# get the executable suffix, if any
+EXE := $(suffix $(abspath $(JULIA)))
+
+# get compiler and linker flags. (see: `contrib/julia-config.jl`)
+JULIA_CONFIG := $(JULIA) -e 'include(joinpath(JULIA_HOME, Base.DATAROOTDIR, "julia", "julia-config.jl"))' --
+CPPFLAGS_ADD :=
+CFLAGS_ADD = $(shell $(JULIA_CONFIG) --cflags)
+LDFLAGS_ADD = -lm $(shell $(JULIA_CONFIG) --ldflags --ldlibs)
+
+DEBUGFLAGS += -g
+
+#=============================================================================
+
+release: $(BIN)/embedding$(EXE)
+debug:   $(BIN)/embedding-debug$(EXE)
+
+$(BIN)/embedding$(EXE): $(SRCDIR)/embedding.c
+	$(CC) $^ -o $@ $(CPPFLAGS_ADD) $(CPPFLAGS) $(CFLAGS_ADD) $(CFLAGS) $(LDFLAGS_ADD) $(LDFLAGS)
+
+$(BIN)/embedding-debug$(EXE): $(SRCDIR)/embedding.c
+	$(CC) $^ -o $@ $(CPPFLAGS_ADD) $(CPPFLAGS) $(CFLAGS_ADD) $(CFLAGS) $(LDFLAGS_ADD) $(LDFLAGS) $(DEBUGFLAGS)
+
+check: $(BIN)/embedding$(EXE)
+	$(JULIA) $(SRCDIR)/embedding-test.jl $<
+	@echo SUCCESS
+
+clean:
+	-rm -f $(BIN)/embedding-debug$(EXE) $(BIN)/embedding$(EXE)
+
+.PHONY: release debug clean check
+
+# Makefile debugging trick:
+# call print-VARIABLE to see the runtime value of any variable
+print-%:
+	@echo '$*=$($*)'
diff --git a/examples/embedding/embedding-test.jl b/examples/embedding/embedding-test.jl
new file mode 100644
index 00000000000000..02f72609507d84
--- /dev/null
+++ b/examples/embedding/embedding-test.jl
@@ -0,0 +1,22 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
+# tests the output of the embedding example is correct
+using Base.Test
+
+@test length(ARGS) == 1
+@testset "embedding example" begin
+    stdout = Pipe()
+    stderr = Pipe()
+    p = spawn(pipeline(Cmd(ARGS), stdin=DevNull, stdout=stdout, stderr=stderr))
+    close(stdout.in)
+    close(stderr.in)
+    stdout_task = @async readlines(stdout)
+    stderr = read(stderr, String)
+    @test stderr == "MethodError: no method matching this_function_has_no_methods()\n"
+    @test success(p)
+    lines = wait(stdout_task)
+    @test length(lines) == 9
+    @test parse(Float64, lines[1]) ≈ sqrt(2)
+    @test lines[8] == "called bar"
+    @test lines[9] == "calling new bar"
+end
diff --git a/examples/embedding/embedding.c b/examples/embedding/embedding.c
new file mode 100644
index 00000000000000..c820e5b3c02ad6
--- /dev/null
+++ b/examples/embedding/embedding.c
@@ -0,0 +1,155 @@
+// This file is a part of Julia. License is MIT: https://julialang.org/license
+
+#include <julia.h>
+#include <stdio.h>
+#include <math.h>
+
+JULIA_DEFINE_FAST_TLS() // only define this once, in an executable
+
+#ifdef _OS_WINDOWS_
+__declspec(dllexport) __cdecl
+#endif
+double my_c_sqrt(double x)
+{
+    return sqrt(x);
+}
+
+jl_value_t *checked_eval_string(const char* code)
+{
+    jl_value_t *result = jl_eval_string(code);
+    if (jl_exception_occurred()) {
+        // none of these allocate, so a gc-root (JL_GC_PUSH) is not necessary
+        jl_call2(jl_get_function(jl_base_module, "showerror"),
+                 jl_stderr_obj(),
+                 jl_exception_occurred());
+        jl_printf(jl_stderr_stream(), "\n");
+        jl_atexit_hook(1);
+        exit(1);
+    }
+    assert(result && "Missing return value but no exception occurred!");
+    return result;
+}
+
+int main()
+{
+    jl_init();
+
+    {
+        // Simple running of Julia code
+
+        checked_eval_string("println(sqrt(2.0))");
+    }
+
+    {
+        // Accessing the return value
+
+        jl_value_t *ret = checked_eval_string("sqrt(2.0)");
+        double retDouble = jl_unbox_float64(ret);
+        printf("sqrt(2.0) in C: %e\n", retDouble);
+        fflush(stdout);
+    }
+
+    {
+        // Same as above but with function handle (more flexible)
+
+        jl_function_t *func = jl_get_function(jl_base_module, "sqrt");
+        jl_value_t* argument = jl_box_float64(2.0);
+        jl_value_t* ret = jl_call1(func, argument);
+        double retDouble = jl_unbox_float64(ret);
+        printf("sqrt(2.0) in C: %e\n", retDouble);
+        fflush(stdout);
+    }
+
+    {
+        // 1D arrays
+
+        jl_value_t* array_type = jl_apply_array_type((jl_value_t*)jl_float64_type, 1);
+        jl_array_t* x          = jl_alloc_array_1d(array_type, 10);
+        // JL_GC_PUSH* is required here to ensure that `x` is not deleted before
+        // (aka, is gc-rooted until) the program reaches the corresponding JL_GC_POP()
+        JL_GC_PUSH1(&x);
+
+        double* xData = jl_array_data(x);
+
+        size_t i;
+        for (i = 0; i < jl_array_len(x); i++)
+            xData[i] = i;
+
+        jl_function_t *func  = jl_get_function(jl_base_module, "reverse!");
+        jl_call1(func, (jl_value_t*) x);
+
+        printf("x = [");
+        for (i = 0; i < jl_array_len(x); i++)
+            printf("%e ", xData[i]);
+        printf("]\n");
+        fflush(stdout);
+
+        JL_GC_POP();
+    }
+
+    {
+        // Defining a Julia function and calling it
+
+        checked_eval_string("my_func(x) = 2 * x");
+
+        jl_function_t *func = jl_get_function(jl_current_module, "my_func");
+        jl_value_t* arg = jl_box_float64(5.0);
+        double ret = jl_unbox_float64(jl_call1(func, arg));
+
+        printf("my_func(5.0) = %f\n", ret);
+        fflush(stdout);
+    }
+
+    {
+        // Calling a C function from Julia (from C)
+
+        // in a shared library (exported, by name)
+        checked_eval_string("println( ccall(:my_c_sqrt, Float64, (Float64,), 2.0) )");
+
+        // or via a pointer
+        jl_value_t *call_by_ptr = checked_eval_string(
+                "my_c_sqrt -> println( ccall(my_c_sqrt, Float64, (Float64,), 2.0) )");
+        jl_call1(call_by_ptr, jl_box_voidpointer(my_c_sqrt));
+    }
+
+    {
+        // Handling exceptions gracefully
+
+        jl_value_t *f = checked_eval_string("function this_function_has_no_methods end");
+        jl_call0(f);
+
+        if (jl_exception_occurred()) {
+            jl_call2(jl_get_function(jl_base_module, "showerror"),
+                     jl_stderr_obj(),
+                     jl_exception_occurred());
+            jl_printf(jl_stderr_stream(), "\n");
+        }
+
+    }
+
+    {
+        // Creating and using a native C function handle
+        // to a Julia function signature
+
+        checked_eval_string(
+                "function bar()\n"
+                "    println(\"called bar\")\n"
+                "    random_return_value = 42\n"
+                "end");
+        checked_eval_string(
+                "function bar_from_c()\n"
+                "    bar()\n"
+                "    nothing\n"
+                "end");
+        typedef void (*Func_VOID__VOID)(void);
+        jl_value_t *pbar = jl_eval_string("cfunction(bar_from_c, Void, ())");
+        Func_VOID__VOID bar = (Func_VOID__VOID)jl_unbox_voidpointer(pbar);
+        bar();
+        checked_eval_string("bar() = println(\"calling new bar\")");
+        bar();
+    }
+
+    int ret = 0;
+    jl_atexit_hook(ret);
+    return ret;
+}
diff --git a/examples/juliatypes.jl b/examples/juliatypes.jl
index efd924c18e828f..09f6fc582947e1 100644
--- a/examples/juliatypes.jl
+++ b/examples/juliatypes.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 import Base: convert, show
 
diff --git a/examples/lru.jl b/examples/lru.jl
index dd682ba5177e70..a76550deb41f29 100644
--- a/examples/lru.jl
+++ b/examples/lru.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module LRUExample
 # An LRU (Least Recently Used) cache is an associative data structure which
@@ -109,7 +109,7 @@ function setindex!(lru::LRU, v, key)
 end
 
 # Eviction
-function setindex!{V,K}(lru::BoundedLRU, v::V, key::K)
+function setindex!(lru::BoundedLRU, v::V, key::K) where {V,K}
     invoke(setindex!, Tuple{LRU,V,K}, lru, v, key)
     nrm = length(lru) - lru.maxsize
     for i in 1:nrm
diff --git a/examples/lru_test.jl b/examples/lru_test.jl
index 62aa29fbf6a037..21b4e5b668cdcb 100644
--- a/examples/lru_test.jl
+++ b/examples/lru_test.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using .LRUExample
 
@@ -7,8 +7,8 @@ TestBLRU = LRUExample.BoundedLRU{String, String}(1000)
 
 get_str(i) = String(vcat(map(x->[x>>4; x&0x0F], reinterpret(UInt8, [Int32(i)]))...))
 
-isbounded{L<:LRUExample.LRU}(::Type{L}) = any(map(n->n==:maxsize, fieldnames(L)))
-isbounded{L<:LRUExample.LRU}(l::L) = isbounded(L)
+isbounded(::Type{L}) where {L<:LRUExample.LRU} = any(map(n->n==:maxsize, fieldnames(L)))
+isbounded(l::L) where {L<:LRUExample.LRU} = isbounded(L)
 
 nmax = round.(Int, logspace(2, 5, 4))
 
diff --git a/examples/ndgrid.jl b/examples/ndgrid.jl
index 228c609ee7fa27..fc2e6bad8a203a 100644
--- a/examples/ndgrid.jl
+++ b/examples/ndgrid.jl
@@ -1,8 +1,8 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ndgrid(v::AbstractVector) = copy(v)
 
-function ndgrid{T}(v1::AbstractVector{T}, v2::AbstractVector{T})
+function ndgrid(v1::AbstractVector{T}, v2::AbstractVector{T}) where T
     m, n = length(v1), length(v2)
     v1 = reshape(v1, m, 1)
     v2 = reshape(v2, 1, n)
@@ -15,7 +15,7 @@ function ndgrid_fill(a, v, s, snext)
     end
 end
 
-function ndgrid{T}(vs::AbstractVector{T}...)
+function ndgrid(vs::AbstractVector{T}...) where T
     n = length(vs)
     sz = map(length, vs)
     out = ntuple(i->Array{T}(sz), n)
@@ -32,15 +32,15 @@ end
 
 meshgrid(v::AbstractVector) = meshgrid(v, v)
 
-function meshgrid{T}(vx::AbstractVector{T}, vy::AbstractVector{T})
+function meshgrid(vx::AbstractVector{T}, vy::AbstractVector{T}) where T
     m, n = length(vy), length(vx)
     vx = reshape(vx, 1, n)
     vy = reshape(vy, m, 1)
     (repmat(vx, m, 1), repmat(vy, 1, n))
 end
 
-function meshgrid{T}(vx::AbstractVector{T}, vy::AbstractVector{T},
-                     vz::AbstractVector{T})
+function meshgrid(vx::AbstractVector{T}, vy::AbstractVector{T},
+                  vz::AbstractVector{T}) where T
     m, n, o = length(vy), length(vx), length(vz)
     vx = reshape(vx, 1, n, 1)
     vy = reshape(vy, m, 1, 1)
diff --git a/examples/queens.jl b/examples/queens.jl
index 0e70d7d5eb8954..e44e2fd2c083bd 100644
--- a/examples/queens.jl
+++ b/examples/queens.jl
@@ -1,8 +1,8 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # n-queens (nqueens) solver, for nsquaresx-by-nsquaresy board
 
-immutable Queen
+struct Queen
     x::Int
     y::Int
 end
diff --git a/examples/quine.jl b/examples/quine.jl
index be60f8baca92a2..aae47e3dbfdbf2 100644
--- a/examples/quine.jl
+++ b/examples/quine.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
-x="println(\"# This file is a part of Julia. License is MIT: http://julialang.org/license\\n\\nx=\$(repr(x))\\n\$x\")"
-println("# This file is a part of Julia. License is MIT: http://julialang.org/license\n\nx=$(repr(x))\n$x")
+x="println(\"# This file is a part of Julia. License is MIT: https://julialang.org/license\\n\\nx=\$(repr(x))\\n\$x\")"
+println("# This file is a part of Julia. License is MIT: https://julialang.org/license\n\nx=$(repr(x))\n$x")
diff --git a/examples/staged.jl b/examples/staged.jl
index f65db5942687e9..5b14f1d1117d36 100644
--- a/examples/staged.jl
+++ b/examples/staged.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 function add_method(gf, an, at, body)
     argexs = [Expr(Symbol("::"), an[i], at[i]) for i=1:length(an)]
diff --git a/examples/time.jl b/examples/time.jl
index 98f14449c8d815..2ffb69dcaabbdc 100644
--- a/examples/time.jl
+++ b/examples/time.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module Time
 export TimeDelta
@@ -16,7 +16,7 @@ const PREFIXES = [
 const ZERO_INDEX = 9
 const MAX_INDEX = 17
 
-function show{p}(io::IO, x::TimeDelta{p})
+function show(io::IO, x::TimeDelta{p}) where p
     k = max(1,min(MAX_INDEX,fld(p,3)+ZERO_INDEX))
     r = p-3(k-ZERO_INDEX)
     prefix = PREFIXES[k]
@@ -30,16 +30,16 @@ function show{p}(io::IO, x::TimeDelta{p})
     end
 end
 
-convert{p,q}(::Type{TimeDelta{p}}, x::TimeDelta{q}) =
+convert(::Type{TimeDelta{p}}, x::TimeDelta{q}) where {p,q} =
     TimeDelta{p}(p <= q ? x.v*10^(q-p) : div(x.v,10^(p-q)))
 
-promote_rule{p,q}(::Type{TimeDelta{p}}, ::Type{TimeDelta{q}}) = TimeDelta{min(p,q)}
+promote_rule(::Type{TimeDelta{p}}, ::Type{TimeDelta{q}}) where {p,q} = TimeDelta{min(p,q)}
 
--{p}(x::TimeDelta{p}) = TimeDelta{p}(-x.v)
-+{p}(x::TimeDelta{p}, y::TimeDelta{p}) = TimeDelta{p}(x.v+y.v)
--{p}(x::TimeDelta{p}, y::TimeDelta{p}) = TimeDelta{p}(x.v-y.v)
+(-)(x::TimeDelta{p}) where {p} = TimeDelta{p}(-x.v)
+(+)(x::TimeDelta{p}, y::TimeDelta{p}) where {p} = TimeDelta{p}(x.v+y.v)
+(-)(x::TimeDelta{p}, y::TimeDelta{p}) where {p} = TimeDelta{p}(x.v-y.v)
 
-+(x::TimeDelta, y::TimeDelta) = +(promote(x,y)...)
--(x::TimeDelta, y::TimeDelta) = -(promote(x,y)...)
+(+)(x::TimeDelta, y::TimeDelta) = +(promote(x,y)...)
+(-)(x::TimeDelta, y::TimeDelta) = -(promote(x,y)...)
 
 end # module
diff --git a/examples/typetree.jl b/examples/typetree.jl
index 08c05b946f7bd9..7d614f71870158 100644
--- a/examples/typetree.jl
+++ b/examples/typetree.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module TypeTrees
 ##
@@ -17,7 +17,7 @@ struct TTNode
     typ # ::Type
     subtypes::Dict{Binding, TTNode}
 
-    TTNode(t::ANY) = new(t, Dict{Binding, TTNode}())
+    TTNode(@nospecialize t) = new(t, Dict{Binding, TTNode}())
 end
 
 # Add a node to a dict if not added
@@ -44,7 +44,7 @@ function store_type(sname::Binding, t::Union)
 
     return tnode.subtypes
 end
-function store_union(sname::Binding, tnode::TTNode, t::ANY)
+function store_union(sname::Binding, tnode::TTNode, @nospecialize t)
     t = Base.unwrap_unionall(t)
     if isa(t, Union)
         store_union(sname, tnode, t.a)
diff --git a/examples/wordcount.jl b/examples/wordcount.jl
index 601ffc3321a60e..f93dd84e2893db 100644
--- a/examples/wordcount.jl
+++ b/examples/wordcount.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # wordcount.jl
 #
@@ -75,7 +75,7 @@ end
 function wordcount_files(result_file,inputs...)
     text = ""
     for file in inputs
-        text *= readstring(file)
+        text *= read(file, String)
     end
     wc = parallel_wordcount(text)
     open(result_file,"w") do f
diff --git a/src/APInt-C.cpp b/src/APInt-C.cpp
index a4ba5d0a7158c5..38bbdbe96a2e88 100644
--- a/src/APInt-C.cpp
+++ b/src/APInt-C.cpp
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include "llvm-version.h"
 #include <llvm/ADT/ArrayRef.h>
@@ -6,15 +6,20 @@
 #include <llvm/ADT/APFloat.h>
 #include <llvm/Support/MathExtras.h>
 
+#include "fix_llvm_assert.h"
+
 #include "APInt-C.h"
 #include "julia.h"
 
 using namespace llvm;
 
-#if JL_LLVM_VERSION >= 30900
 inline uint64_t RoundUpToAlignment(uint64_t Value, uint64_t Align, uint64_t Skew = 0) {
     return alignTo(Value, Align, Skew);
 }
+
+#if JL_LLVM_VERSION >= 50000
+const unsigned int integerPartWidth = llvm::APInt::APINT_BITS_PER_WORD;
+const unsigned int host_char_bit = 8;
 #endif
 
 /* create "APInt s" from "integerPart *ps" */
@@ -350,7 +355,11 @@ void LLVMFPtoInt(unsigned numbits, integerPart *pa, unsigned onumbits, integerPa
         APFloat::roundingMode rounding_mode = APFloat::rmNearestTiesToEven;
         unsigned nbytes = RoundUpToAlignment(onumbits, integerPartWidth) / host_char_bit;
         integerPart *parts = (integerPart*)alloca(nbytes);
+#if JL_LLVM_VERSION >= 50000
+        APFloat::opStatus status = a.convertToInteger(MutableArrayRef<integerPart>(parts, nbytes), onumbits, isSigned, rounding_mode, &isVeryExact);
+#else
         APFloat::opStatus status = a.convertToInteger(parts, onumbits, isSigned, rounding_mode, &isVeryExact);
+#endif
         memcpy(pr, parts, onumbytes);
         if (isExact)
             *isExact = (status == APFloat::opOK);
@@ -448,38 +457,22 @@ void LLVMTrunc(unsigned inumbits, integerPart *pa, unsigned onumbits, integerPar
 
 extern "C" JL_DLLEXPORT
 unsigned countTrailingZeros_8(uint8_t Val) {
-#if JL_LLVM_VERSION >= 30500
     return countTrailingZeros(Val);
-#else
-    return CountTrailingZeros_32(Val);
-#endif
 }
 
 extern "C" JL_DLLEXPORT
 unsigned countTrailingZeros_16(uint16_t Val) {
-#if JL_LLVM_VERSION >= 30500
     return countTrailingZeros(Val);
-#else
-    return CountTrailingZeros_32(Val);
-#endif
 }
 
 extern "C" JL_DLLEXPORT
 unsigned countTrailingZeros_32(uint32_t Val) {
-#if JL_LLVM_VERSION >= 30500
     return countTrailingZeros(Val);
-#else
-    return CountTrailingZeros_32(Val);
-#endif
 }
 
 extern "C" JL_DLLEXPORT
 unsigned countTrailingZeros_64(uint64_t Val) {
-#if JL_LLVM_VERSION >= 30500
     return countTrailingZeros(Val);
-#else
-    return CountTrailingZeros_64(Val);
-#endif
 }
 
 extern "C" JL_DLLEXPORT
diff --git a/src/APInt-C.h b/src/APInt-C.h
index af0a778ddfc5eb..6aa70380917efa 100644
--- a/src/APInt-C.h
+++ b/src/APInt-C.h
@@ -1,7 +1,7 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
-#ifndef APINT_C_H
-#define APINT_C_H
+#ifndef JL_APINT_C_H
+#define JL_APINT_C_H
 
 #ifdef __cplusplus
 extern "C" {
@@ -9,7 +9,11 @@ extern "C" {
 #include "dtypes.h"
 
 #ifdef LLVM_VERSION_MAJOR
+#  if JL_LLVM_VERSION >= 50000
+using integerPart = llvm::APInt::WordType;
+#  else
 using llvm::integerPart;
+#  endif
 #else
 typedef void integerPart;
 #endif
diff --git a/src/Makefile b/src/Makefile
index 4dab3bfa2a3346..da00f0f652842e 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -6,11 +6,7 @@ include $(JULIAHOME)/Make.inc
 include $(JULIAHOME)/deps/llvm-ver.make
 
 override CFLAGS += $(JCFLAGS)
-ifeq ($(LLVM_VER),3.3)
-override CXXFLAGS += $(JCXXFLAGS) -std=c++11
-else
 override CXXFLAGS += $(JCXXFLAGS)
-endif
 override CPPFLAGS += $(JCPPFLAGS)
 
 # -I BUILDDIR comes before -I SRCDIR so that the user can override <options.h> on a per-build-directory basis
@@ -41,10 +37,11 @@ endif
 
 SRCS := \
 	jltypes gf typemap ast builtins module interpreter symbol \
-	dlload sys init task array dump toplevel jl_uv datatype \
-	simplevector APInt-C runtime_intrinsics runtime_ccall \
+	dlload sys init task array dump staticdata toplevel jl_uv datatype \
+	simplevector APInt-C runtime_intrinsics runtime_ccall precompile \
 	threadgroup threading stackwalk gc gc-debug gc-pages method \
-	jlapi signal-handling safepoint jloptions timing subtype rtutils
+	jlapi signal-handling safepoint jloptions timing subtype rtutils \
+	crc32c
 
 ifeq ($(USEMSVC), 1)
 SRCS += getopt
@@ -53,7 +50,9 @@ endif
 LLVMLINK :=
 
 ifeq ($(JULIACODEGEN),LLVM)
-SRCS += codegen jitlayers disasm debuginfo llvm-simdloop llvm-ptls llvm-gcroot cgmemmgr
+SRCS += codegen jitlayers disasm debuginfo llvm-simdloop llvm-ptls llvm-muladd \
+	llvm-late-gc-lowering llvm-lower-handlers llvm-gc-invariant-verifier \
+	llvm-propagate-addrspaces llvm-alloc-opt cgmemmgr
 FLAGS += -I$(shell $(LLVM_CONFIG_HOST) --includedir)
 LLVM_LIBS := all
 ifeq ($(USE_POLLY),1)
@@ -64,6 +63,11 @@ FLAGS += -DUSE_POLLY
 ifeq ($(USE_POLLY_OPENMP),1)
 FLAGS += -fopenmp
 endif
+ifeq ($(USE_POLLY_ACC),1)
+LLVMLINK += -lPollyPPCG -lGPURuntime
+FLAGS += -DUSE_POLLY_ACC
+FLAGS += -I$(shell $(LLVM_CONFIG_HOST) --src-root)/tools/polly/tools # Required to find GPURuntime/GPUJIT.h
+endif
 endif
 else
 SRCS += anticodegen
@@ -71,8 +75,8 @@ LLVM_LIBS := support
 endif
 
 # headers are used for dependency tracking, while public headers will be part of the dist
-HEADERS := $(BUILDDIR)/julia_version.h $(wildcard $(SRCDIR)/support/*.h) $(addprefix $(SRCDIR)/,julia.h julia_threads.h julia_internal.h options.h timing.h)
-PUBLIC_HEADERS := $(BUILDDIR)/julia_version.h $(wildcard $(SRCDIR)/support/*.h) $(addprefix $(SRCDIR)/,julia.h julia_threads.h)
+HEADERS := $(BUILDDIR)/julia_version.h $(wildcard $(SRCDIR)/support/*.h) $(addprefix $(SRCDIR)/,julia.h julia_threads.h tls.h locks.h atomics.h julia_internal.h options.h timing.h)
+PUBLIC_HEADERS := $(BUILDDIR)/julia_version.h $(wildcard $(SRCDIR)/support/*.h) $(addprefix $(SRCDIR)/,julia.h julia_threads.h tls.h locks.h atomics.h)
 ifeq ($(USE_SYSTEM_LIBUV),0)
 ifeq ($(OS),WINNT)
 HEADERS += $(build_includedir)/tree.h
@@ -88,15 +92,7 @@ PUBLIC_HEADER_TARGETS := $(addprefix $(build_includedir)/julia/,$(notdir $(PUBLI
 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 += $(shell $(LLVM_CONFIG_HOST) --ldflags) -lLLVM
-else
-ifeq ($(OS),WINNT)
-LLVMLINK += $(shell $(LLVM_CONFIG_HOST) --ldflags) -lLLVM-$(LLVM_VER_SHORT)
-else
-LLVMLINK += $(shell $(LLVM_CONFIG_HOST) --ldflags) -lLLVM-$(shell $(LLVM_CONFIG_HOST) --version)
-endif # OS == WINNT
-endif # LLVM_USE_CMAKE == 1
 FLAGS += -DLLVM_SHLIB
 endif # USE_LLVM_SHLIB == 1
 
@@ -141,7 +137,7 @@ $(BUILDDIR)/%.o: $(SRCDIR)/%.c $(HEADERS) | $(BUILDDIR)
 $(BUILDDIR)/%.dbg.obj: $(SRCDIR)/%.c $(HEADERS) | $(BUILDDIR)
 	@$(call PRINT_CC, $(CC) $(CPPFLAGS) $(CFLAGS) $(DEBUGFLAGS) -c $< -o $@)
 $(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 $@)
+	@$(call PRINT_CC, $(CXX) $(shell $(LLVM_CONFIG_HOST) --cxxflags) $(CPPFLAGS) $(CXXFLAGS) $(SHIPFLAGS) $(CXX_DISABLE_ASSERTION) -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 $@)
 
@@ -189,10 +185,11 @@ $(BUILDDIR)/julia_flisp.boot: $(addprefix $(SRCDIR)/,jlfrontend.scm flisp/aliase
 
 # 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 jitlayers.h intrinsics.h codegen_internal.h cgutils.cpp ccall.cpp abi_*.cpp)
+$(BUILDDIR)/codegen.o $(BUILDDIR)/codegen.dbg.obj: $(addprefix $(SRCDIR)/,\
+	intrinsics.cpp jitlayers.h intrinsics.h debuginfo.h codegen_shared.h cgutils.cpp ccall.cpp abi_*.cpp)
 $(BUILDDIR)/anticodegen.o $(BUILDDIR)/anticodegen.dbg.obj: $(SRCDIR)/intrinsics.h
-$(BUILDDIR)/debuginfo.o $(BUILDDIR)/debuginfo.dbg.obj: $(SRCDIR)/codegen_internal.h
-$(BUILDDIR)/disasm.o $(BUILDDIR)/disasm.dbg.obj: $(SRCDIR)/codegen_internal.h
+$(BUILDDIR)/debuginfo.o $(BUILDDIR)/debuginfo.dbg.obj: $(SRCDIR)/debuginfo.h
+$(BUILDDIR)/disasm.o $(BUILDDIR)/disasm.dbg.obj: $(SRCDIR)/debuginfo.h
 $(BUILDDIR)/jitlayers.o $(BUILDDIR)/jitlayers.dbg.obj: $(SRCDIR)/jitlayers.h
 $(BUILDDIR)/builtins.o $(BUILDDIR)/builtins.dbg.obj: $(SRCDIR)/table.c
 $(BUILDDIR)/gc.o $(BUILDDIR)/gc.dbg.obj: $(SRCDIR)/gc.h
@@ -220,8 +217,8 @@ $(BUILDDIR)/flisp/libflisp-debug.a: $(addprefix $(SRCDIR)/,flisp/*.h flisp/*.c)
 
 $(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
+	@echo "#ifndef JL_VERSION_H" >> $@.$(JULIA_BUILD_MODE).tmp
+	@echo "#define JL_VERSION_H" >> $@.$(JULIA_BUILD_MODE).tmp
 	@echo "#define JULIA_VERSION_STRING" \"$(JULIA_VERSION)\" >> $@.$(JULIA_BUILD_MODE).tmp
 	@echo $(JULIA_VERSION) | awk 'BEGIN {FS="[.,-]"} \
 	{print "#define JULIA_VERSION_MAJOR " $$1 "\n" \
diff --git a/src/abi_aarch64.cpp b/src/abi_aarch64.cpp
index 03938491cf64b0..346dbf1ec52769 100644
--- a/src/abi_aarch64.cpp
+++ b/src/abi_aarch64.cpp
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 //===----------------------------------------------------------------------===//
 //
@@ -58,6 +58,7 @@ Type *get_llvm_vectype(jl_datatype_t *dt) const
     return lltype;
 }
 
+#define jl_is_floattype(v)   jl_subtype(v,(jl_value_t*)jl_floatingpoint_type)
 Type *get_llvm_fptype(jl_datatype_t *dt) const
 {
     // Assume jl_is_datatype(dt) && !jl_is_abstracttype(dt)
diff --git a/src/abi_arm.cpp b/src/abi_arm.cpp
index feb0bbfedfe11b..1a5d3d06513689 100644
--- a/src/abi_arm.cpp
+++ b/src/abi_arm.cpp
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 //===----------------------------------------------------------------------===//
 //
@@ -28,6 +28,8 @@ bool needPassByRef(jl_datatype_t *dt, AttrBuilder &ab) override
     return false;
 }
 
+#define jl_is_floattype(v)   jl_subtype(v,(jl_value_t*)jl_floatingpoint_type)
+
 Type *get_llvm_fptype(jl_datatype_t *dt) const
 {
     // Assume jl_is_datatype(dt) && !jl_is_abstracttype(dt)
@@ -268,7 +270,7 @@ Type *preferred_llvm_type(jl_datatype_t *dt, bool isret) const override
     //   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->layout->alignment;
+    size_t align = jl_datatype_align(dt);
     if (align < 4)
         align = 4;
     if (align > 8)
diff --git a/src/abi_ppc64le.cpp b/src/abi_ppc64le.cpp
index 5c4cc4b4d5b5be..a6ae101040b4c7 100644
--- a/src/abi_ppc64le.cpp
+++ b/src/abi_ppc64le.cpp
@@ -144,7 +144,7 @@ Type *preferred_llvm_type(jl_datatype_t *dt, bool isret) const override
     // rewrite integer-sized (non-HFA) struct to an array
     // the bitsize of the integer gives the desired alignment
     if (size > 8) {
-        if (dt->layout->alignment <= 8) {
+        if (jl_datatype_align(dt) <= 8) {
             return ArrayType::get(T_int64, (size + 7) / 8);
         }
         else {
diff --git a/src/anticodegen.c b/src/anticodegen.c
index 03e1178ea45d86..b19afe21d57a8c 100644
--- a/src/anticodegen.c
+++ b/src/anticodegen.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include "julia.h"
 #include "julia_internal.h"
@@ -36,9 +36,10 @@ int jl_getFunctionInfo(jl_frame_t **frames, uintptr_t pointer, int skipC, int no
     return 0;
 }
 
-void jl_register_fptrs(uint64_t sysimage_base, void **fptrs, jl_method_instance_t **linfos, size_t n)
+void jl_register_fptrs(uint64_t sysimage_base, const char *base, const int32_t *offsets,
+                       jl_method_instance_t **linfos, size_t n)
 {
-    (void)sysimage_base; (void)fptrs; (void)linfos; (void)n;
+    (void)sysimage_base; (void)base; (void)offsets; (void)linfos; (void)n;
 }
 
 void jl_compile_linfo(jl_method_instance_t *li) { }
diff --git a/src/array.c b/src/array.c
index 6caf56fd3aa493..11510d2d0b5ec9 100644
--- a/src/array.c
+++ b/src/array.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 /*
   array constructors and primitives
@@ -188,10 +188,19 @@ JL_DLLEXPORT jl_array_t *jl_reshape_array(jl_value_t *atype, jl_array_t *data,
     a->offset = 0;
     a->data = NULL;
     a->flags.isaligned = data->flags.isaligned;
+    jl_array_t *owner = (jl_array_t*)jl_array_owner(data);
     jl_value_t *el_type = jl_tparam0(atype);
     assert(store_unboxed(el_type) == !data->flags.ptrarray);
     if (!data->flags.ptrarray) {
         a->elsize = jl_datatype_size(el_type);
+        unsigned align = jl_datatype_align(el_type);
+        jl_value_t *ownerty = jl_typeof(owner);
+        unsigned oldalign = (ownerty == (jl_value_t*)jl_string_type ? 1 :
+                             jl_datatype_align(jl_tparam0(ownerty)));
+        if (oldalign < align)
+            jl_exceptionf(jl_argumenterror_type,
+                          "reinterpret from alignment %u bytes to alignment %u bytes not allowed",
+                          oldalign, align);
         a->flags.ptrarray = 0;
     }
     else {
@@ -201,7 +210,7 @@ JL_DLLEXPORT jl_array_t *jl_reshape_array(jl_value_t *atype, jl_array_t *data,
 
     // if data is itself a shared wrapper,
     // owner should point back to the original array
-    jl_array_data_owner(a) = jl_array_owner(data);
+    jl_array_data_owner(a) = (jl_value_t*)owner;
 
     a->flags.how = 3;
     a->data = data->data;
@@ -266,15 +275,22 @@ JL_DLLEXPORT jl_array_t *jl_ptr_to_array_1d(jl_value_t *atype, void *data,
                                             size_t nel, int own_buffer)
 {
     jl_ptls_t ptls = jl_get_ptls_states();
-    size_t elsz;
     jl_array_t *a;
     jl_value_t *el_type = jl_tparam0(atype);
 
     int isunboxed = store_unboxed(el_type);
-    if (isunboxed)
+    size_t elsz;
+    unsigned align;
+    if (isunboxed) {
         elsz = jl_datatype_size(el_type);
-    else
-        elsz = sizeof(void*);
+        align = jl_datatype_align(el_type);
+    }
+    else {
+        align = elsz = sizeof(void*);
+    }
+    if (((uintptr_t)data) & (align - 1))
+        jl_exceptionf(jl_argumenterror_type,
+                      "unsafe_wrap: pointer %p is not properly aligned to %u bytes", data, align);
 
     int ndimwords = jl_array_ndimwords(1);
     int tsz = JL_ARRAY_ALIGN(sizeof(jl_array_t) + ndimwords*sizeof(size_t), JL_CACHE_BYTE_ALIGNMENT);
@@ -309,7 +325,7 @@ JL_DLLEXPORT jl_array_t *jl_ptr_to_array(jl_value_t *atype, void *data,
                                          jl_value_t *_dims, int own_buffer)
 {
     jl_ptls_t ptls = jl_get_ptls_states();
-    size_t elsz, nel = 1;
+    size_t nel = 1;
     jl_array_t *a;
     size_t ndims = jl_nfields(_dims);
     wideint_t prod;
@@ -326,10 +342,18 @@ JL_DLLEXPORT jl_array_t *jl_ptr_to_array(jl_value_t *atype, void *data,
     jl_value_t *el_type = jl_tparam0(atype);
 
     int isunboxed = store_unboxed(el_type);
-    if (isunboxed)
+    size_t elsz;
+    unsigned align;
+    if (isunboxed) {
         elsz = jl_datatype_size(el_type);
-    else
-        elsz = sizeof(void*);
+        align = jl_datatype_align(el_type);
+    }
+    else {
+        align = elsz = sizeof(void*);
+    }
+    if (((uintptr_t)data) & (align - 1))
+        jl_exceptionf(jl_argumenterror_type,
+                      "unsafe_wrap: pointer %p is not properly aligned to %u bytes", data, align);
 
     int ndimwords = jl_array_ndimwords(ndims);
     int tsz = JL_ARRAY_ALIGN(sizeof(jl_array_t) + ndimwords*sizeof(size_t), JL_CACHE_BYTE_ALIGNMENT);
@@ -731,14 +755,17 @@ STATIC_INLINE void jl_array_grow_at_end(jl_array_t *a, size_t idx,
     size_t elsz = a->elsize;
     char *data = (char*)a->data;
     int has_gap = n > idx;
-    if (__unlikely((n + inc) > a->maxsize - a->offset)) {
+    size_t reqmaxsize = a->offset + n + inc;
+    if (__unlikely(reqmaxsize > a->maxsize)) {
         size_t nb1 = idx * elsz;
         size_t nbinc = inc * elsz;
-        size_t newlen = a->maxsize == 0 ? (inc < 4 ? 4 : inc) : a->maxsize * 2;
-        while ((n + inc) > newlen - a->offset)
-            newlen *= 2;
-        newlen = limit_overallocation(a, n, newlen, inc);
-        int newbuf = array_resize_buffer(a, newlen);
+        // if the requested size is more than 2x current maxsize, grow exactly
+        // otherwise double the maxsize
+        size_t newmaxsize = reqmaxsize >= a->maxsize * 2
+                          ? (reqmaxsize < 4 ? 4 : reqmaxsize)
+                          : a->maxsize * 2;
+        newmaxsize = limit_overallocation(a, n, newmaxsize, inc);
+        int newbuf = array_resize_buffer(a, newmaxsize);
         char *newdata = (char*)a->data + a->offset * elsz;
         if (newbuf) {
             memcpy(newdata, data, nb1);
@@ -989,6 +1016,19 @@ JL_DLLEXPORT void jl_array_ptr_1d_push(jl_array_t *a, jl_value_t *item)
     jl_array_ptr_set(a, n - 1, item);
 }
 
+JL_DLLEXPORT void jl_array_ptr_1d_append(jl_array_t *a, jl_array_t *a2)
+{
+    assert(jl_typeis(a, jl_array_any_type));
+    assert(jl_typeis(a2, jl_array_any_type));
+    size_t i;
+    size_t n = jl_array_nrows(a);
+    size_t n2 = jl_array_nrows(a2);
+    jl_array_grow_end(a, n2);
+    for (i = 0; i < n2; i++) {
+        jl_array_ptr_set(a, n + i, jl_array_ptr_ref(a2, i));
+    }
+}
+
 JL_DLLEXPORT void jl_array_ptr_1d_push2(jl_array_t *a, jl_value_t *b, jl_value_t *c)
 {
     assert(jl_typeis(a, jl_array_any_type));
diff --git a/src/ast.c b/src/ast.c
index b43ce6e418d549..33a709b6d54efe 100644
--- a/src/ast.c
+++ b/src/ast.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 /*
   AST
@@ -56,6 +56,7 @@ jl_sym_t *inert_sym; jl_sym_t *vararg_sym;
 jl_sym_t *unused_sym; jl_sym_t *static_parameter_sym;
 jl_sym_t *polly_sym; jl_sym_t *inline_sym;
 jl_sym_t *propagate_inbounds_sym;
+jl_sym_t *isdefined_sym; jl_sym_t *nospecialize_sym;
 
 static uint8_t flisp_system_image[] = {
 #include <julia_flisp.boot.inc>
@@ -97,6 +98,7 @@ typedef struct _jl_ast_context_t {
     jl_ast_context_list_t list;
     int ref;
     jl_task_t *task;
+    jl_module_t *module;
     // 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.
@@ -109,14 +111,19 @@ static jl_ast_context_t jl_ast_main_ctx;
 #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)     \
+#define JL_AST_PRESERVE_PUSH(ctx, _roots, old, inmodule)  \
+    jl_array_t *(_roots) = NULL;                \
+    struct { jl_array_t **roots;                \
+             jl_module_t *module; } (old);      \
+    old.roots = ctx->roots;                     \
+    old.module = ctx->module;                   \
+    ctx->roots = &(_roots);                     \
+    ctx->module = (inmodule);                   \
+    JL_GC_PUSH2(&(_roots), &(inmodule))
+#define JL_AST_PRESERVE_POP(ctx, old)           \
     JL_GC_POP();                                \
-    ctx->roots = old_roots
+    ctx->roots = (old).roots;                   \
+    ctx->module = (old).module
 
 static void jl_ast_preserve(fl_context_t *fl_ctx, jl_value_t *obj)
 {
@@ -137,10 +144,10 @@ 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)
 {
-    jl_ptls_t ptls = jl_get_ptls_states();
+    jl_ast_context_t *ctx = jl_ast_ctx(fl_ctx);
     // tells whether a var is defined in and *by* the current module
     argcount(fl_ctx, "defined-julia-global", nargs, 1);
-    jl_module_t *mod = ptls->current_module;
+    jl_module_t *mod = ctx->module;
     jl_sym_t *sym = (jl_sym_t*)scm_to_julia(fl_ctx, args[0], 0);
     if (jl_is_globalref(sym)) {
         mod = jl_globalref_mod(sym);
@@ -154,45 +161,62 @@ value_t fl_defined_julia_global(fl_context_t *fl_ctx, value_t *args, uint32_t na
     return (b != HT_NOTFOUND && b->owner == mod) ? fl_ctx->T : fl_ctx->F;
 }
 
-value_t fl_current_julia_module(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
-{
-    jl_ptls_t ptls = jl_get_ptls_states();
-    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*)ptls->current_module;
-    return opaque;
-}
-
 value_t fl_current_module_counter(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    jl_ptls_t ptls = jl_get_ptls_states();
-    static uint32_t fallback_counter = 0;
-    if (ptls->current_module == NULL)
-        return fixnum(++fallback_counter);
-    else
-        return fixnum(jl_module_next_counter(ptls->current_module));
+    jl_ast_context_t *ctx = jl_ast_ctx(fl_ctx);
+    assert(ctx->module);
+    return fixnum(jl_module_next_counter(ctx->module));
 }
 
 value_t fl_invoke_julia_macro(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
     JL_TIMING(MACRO_INVOCATION);
     jl_ptls_t ptls = jl_get_ptls_states();
-    if (nargs < 1)
-        argcount(fl_ctx, "invoke-julia-macro", nargs, 1);
+    jl_ast_context_t *ctx = jl_ast_ctx(fl_ctx);
+    if (nargs < 3) // macro name and location
+        argcount(fl_ctx, "invoke-julia-macro", nargs, 3);
     jl_method_instance_t *mfunc = NULL;
     jl_value_t **margs;
     // 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(fl_ctx, args[i], 1);
+    margs[0] = scm_to_julia(fl_ctx, args[1], 1);
+    // __source__ argument
+    jl_value_t *lno = scm_to_julia(fl_ctx, args[2], 1);
+    margs[1] = lno;
+    if (jl_is_expr(lno) && ((jl_expr_t*)lno)->head == line_sym) {
+        jl_value_t *file = jl_nothing;
+        jl_value_t *line = NULL;
+        switch (jl_expr_nargs(lno)) {
+        case 2:
+            file = jl_exprarg(lno, 1); // file
+            JL_FALLTHROUGH;
+        case 1:
+            line = jl_exprarg(lno, 0); // line
+            JL_FALLTHROUGH;
+        default: ;
+        }
+        if (line == NULL)
+            line = jl_box_long(0);
+        margs[1] = jl_new_struct(jl_linenumbernode_type, line, file);
+    }
+    else if (!jl_typeis(lno, jl_linenumbernode_type)) {
+        margs[1] = jl_new_struct(jl_linenumbernode_type, jl_box_long(0), jl_nothing);
+    }
+    margs[2] = (jl_value_t*)ctx->module;
+    for (i = 3; i < nargs; i++)
+        margs[i] = scm_to_julia(fl_ctx, args[i], 1);
+    margs[nargs] = scm_to_julia(fl_ctx, args[0], 1); // module context for @macrocall argument
     jl_value_t *result = NULL;
     size_t world = jl_get_ptls_states()->world_age;
 
     JL_TRY {
-        margs[0] = scm_to_julia(fl_ctx, args[0], 1);
-        margs[0] = jl_toplevel_eval(margs[0]);
+        jl_module_t *m = (jl_module_t*)margs[nargs];
+        if (!jl_is_module(m))
+            m = ctx->module;
+        margs[0] = jl_toplevel_eval(m, margs[0]);
         mfunc = jl_method_lookup(jl_gf_mtable(margs[0]), margs, nargs, 1, world);
         if (mfunc == NULL) {
-            JL_GC_POP();
             jl_method_error((jl_function_t*)margs[0], margs, nargs, world);
             // unreachable
         }
@@ -214,15 +238,10 @@ value_t fl_invoke_julia_macro(fl_context_t *fl_ctx, value_t *args, uint32_t narg
     value_t scm = julia_to_scm(fl_ctx, result);
     fl_gc_handle(fl_ctx, &scm);
     value_t scmresult;
-    jl_module_t *defmod = mfunc->def->module;
-    /* if (defmod == NULL || defmod == ptls->current_module) { */
-    /*     scmresult = fl_cons(fl_ctx, scm, fl_ctx->F); */
-    /* } */
-    /* else { */
+    jl_module_t *defmod = mfunc->def.method->module;
     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(fl_ctx, scm, opaque);
-    /* } */
     fl_free_gc_handles(fl_ctx, 1);
 
     JL_GC_POP();
@@ -248,7 +267,6 @@ value_t fl_julia_scalar(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 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 },
     { "julia-scalar?", fl_julia_scalar },
     { NULL, NULL }
@@ -269,14 +287,17 @@ static void jl_init_ast_ctx(jl_ast_context_t *ast_ctx)
 
     fl_applyn(fl_ctx, 0, symbol_value(symbol(fl_ctx, "__init_globals")));
 
-    jl_ast_ctx(fl_ctx)->jvtype = define_opaque_type(fl_ctx->jl_sym, sizeof(void*), NULL, NULL);
+    jl_ast_context_t *ctx = jl_ast_ctx(fl_ctx);
+    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)->ssavalue_sym = symbol(fl_ctx, "ssavalue");
-    jl_ast_ctx(fl_ctx)->slot_sym = symbol(fl_ctx, "slot");
+    ctx->true_sym = symbol(fl_ctx, "true");
+    ctx->false_sym = symbol(fl_ctx, "false");
+    ctx->error_sym = symbol(fl_ctx, "error");
+    ctx->null_sym = symbol(fl_ctx, "null");
+    ctx->ssavalue_sym = symbol(fl_ctx, "ssavalue");
+    ctx->slot_sym = symbol(fl_ctx, "slot");
+    ctx->task = NULL;
+    ctx->module = NULL;
 
     // Enable / disable syntax deprecation warnings
     if (jl_options.depwarn == JL_OPTIONS_DEPWARN_ERROR)
@@ -314,6 +335,7 @@ static jl_ast_context_t *jl_ast_ctx_enter(void)
         ctx->ref = 1;
         ctx->task = ptls->current_task;
         ctx->roots = NULL;
+        ctx->module = NULL;
         JL_UNLOCK_NOGC(&flisp_lock);
         return ctx;
     }
@@ -413,6 +435,8 @@ void jl_init_frontend(void)
     polly_sym = jl_symbol("polly");
     inline_sym = jl_symbol("inline");
     propagate_inbounds_sym = jl_symbol("propagate_inbounds");
+    isdefined_sym = jl_symbol("isdefined");
+    nospecialize_sym = jl_symbol("nospecialize");
 }
 
 JL_DLLEXPORT void jl_lisp_prompt(void)
@@ -422,7 +446,7 @@ JL_DLLEXPORT void jl_lisp_prompt(void)
     JL_SIGATOMIC_BEGIN();
     jl_init_frontend();
     jl_ast_context_t *ctx = jl_ast_ctx_enter();
-    JL_AST_PRESERVE_PUSH(ctx, roots, old_roots);
+    JL_AST_PRESERVE_PUSH(ctx, roots, old_roots, jl_main_module);
     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);
@@ -490,7 +514,7 @@ extern int64_t conv_to_int64(void *data, numerictype_t tag);
 
 static jl_value_t *scm_to_julia_(fl_context_t *fl_ctx, value_t e, int eo)
 {
-    jl_ptls_t ptls = jl_get_ptls_states();
+    jl_ast_context_t *ctx = jl_ast_ctx(fl_ctx);
     if (fl_isnumber(fl_ctx, e)) {
         int64_t i64;
         if (isfixnum(e)) {
@@ -561,10 +585,13 @@ static jl_value_t *scm_to_julia_(fl_context_t *fl_ctx, value_t e, int eo)
         else
             n++;
         if (!eo) {
-            if (sym == line_sym && n==1) {
+            if (sym == line_sym && (n == 1 || n == 2)) {
                 jl_value_t *linenum = scm_to_julia_(fl_ctx, car_(e), 0);
-                JL_GC_PUSH1(&linenum);
-                jl_value_t *temp = jl_new_struct(jl_linenumbernode_type, linenum);
+                jl_value_t *file = jl_nothing;
+                JL_GC_PUSH2(&linenum, &file);
+                if (n == 2)
+                    file = scm_to_julia_(fl_ctx, car_(cdr_(e)), 0);
+                jl_value_t *temp = jl_new_struct(jl_linenumbernode_type, linenum, file);
                 JL_GC_POP();
                 return temp;
             }
@@ -591,7 +618,7 @@ static jl_value_t *scm_to_julia_(fl_context_t *fl_ctx, value_t e, int eo)
             if (sym == top_sym) {
                 scmv = scm_to_julia_(fl_ctx,car_(e),0);
                 assert(jl_is_symbol(scmv));
-                temp = jl_module_globalref(jl_base_relative_to(ptls->current_module), (jl_sym_t*)scmv);
+                temp = jl_module_globalref(jl_base_relative_to(ctx->module), (jl_sym_t*)scmv);
                 JL_GC_POP();
                 return temp;
             }
@@ -663,7 +690,7 @@ static value_t julia_to_scm(fl_context_t *fl_ctx, jl_value_t *v)
         temp = julia_to_scm_(fl_ctx, v);
     }
     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"));
+        temp = fl_ctx->lasterror;
     }
     return temp;
 }
@@ -671,7 +698,7 @@ static value_t julia_to_scm(fl_context_t *fl_ctx, jl_value_t *v)
 static void array_to_list(fl_context_t *fl_ctx, jl_array_t *a, value_t *pv)
 {
     if (jl_array_len(a) > 300000)
-        lerror(fl_ctx, fl_ctx->OutOfMemoryError, "expression too large");
+        lerror(fl_ctx, symbol(fl_ctx, "error"), "expression too large");
     value_t temp;
     for(long i=jl_array_len(a)-1; i >= 0; i--) {
         *pv = fl_cons(fl_ctx, fl_ctx->NIL, *pv);
@@ -693,6 +720,8 @@ static value_t julia_to_list2(fl_context_t *fl_ctx, jl_value_t *a, jl_value_t *b
 
 static value_t julia_to_scm_(fl_context_t *fl_ctx, jl_value_t *v)
 {
+    if (v == NULL)
+        lerror(fl_ctx, symbol(fl_ctx, "error"), "undefined reference in AST");
     if (jl_is_symbol(v))
         return symbol(fl_ctx, jl_symbol_name((jl_sym_t*)v));
     if (v == jl_true)
@@ -723,8 +752,16 @@ static value_t julia_to_scm_(fl_context_t *fl_ctx, jl_value_t *v)
     //          shouldn't allocate in this case.
     if (jl_typeis(v, jl_labelnode_type))
         return julia_to_list2(fl_ctx, (jl_value_t*)label_sym, jl_fieldref(v,0));
-    if (jl_typeis(v, jl_linenumbernode_type))
-        return julia_to_list2(fl_ctx, (jl_value_t*)line_sym, jl_fieldref(v,0));
+    if (jl_typeis(v, jl_linenumbernode_type)) {
+        jl_value_t *file = jl_fieldref(v,1); // non-allocating
+        jl_value_t *line = jl_fieldref(v,0); // allocating
+        value_t args = julia_to_list2(fl_ctx, line, file);
+        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;
+    }
     if (jl_typeis(v, jl_gotonode_type))
         return julia_to_list2(fl_ctx, (jl_value_t*)goto_sym, jl_fieldref(v,0));
     if (jl_typeis(v, jl_quotenode_type))
@@ -747,9 +784,9 @@ static value_t julia_to_scm_(fl_context_t *fl_ctx, jl_value_t *v)
     if (jl_is_long(v) && fits_fixnum(jl_unbox_long(v)))
         return fixnum(jl_unbox_long(v));
     if (jl_is_ssavalue(v))
-        jl_error("SSAValue objects should not occur in an AST");
+        lerror(fl_ctx, symbol(fl_ctx, "error"), "SSAValue objects should not occur in an AST");
     if (jl_is_slot(v))
-        jl_error("Slot objects should not occur in an AST");
+        lerror(fl_ctx, symbol(fl_ctx, "error"), "Slot objects should not occur in an AST");
     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;
@@ -804,7 +841,8 @@ JL_DLLEXPORT jl_value_t *jl_parse_string(const char *str, size_t len,
 
 // parse and eval a whole file, possibly reading from a string (`content`)
 jl_value_t *jl_parse_eval_all(const char *fname,
-                              const char *content, size_t contentlen)
+                              const char *content, size_t contentlen,
+                              jl_module_t *inmodule)
 {
     jl_ptls_t ptls = jl_get_ptls_states();
     if (ptls->in_pure_callback)
@@ -841,10 +879,12 @@ jl_value_t *jl_parse_eval_all(const char *fname,
     jl_filename = fname;
     jl_array_t *roots = NULL;
     jl_array_t **old_roots = ctx->roots;
+    jl_module_t *old_module = ctx->module;
     ctx->roots = &roots;
+    ctx->module = inmodule;
     jl_value_t *form=NULL, *result=jl_nothing;
     int err = 0;
-    JL_GC_PUSH3(&roots, &form, &result);
+    JL_GC_PUSH4(&roots, &form, &result, &inmodule);
     JL_TRY {
         assert(iscons(ast) && car_(ast) == symbol(fl_ctx,"toplevel"));
         ast = cdr_(ast);
@@ -861,15 +901,15 @@ jl_value_t *jl_parse_eval_all(const char *fname,
             JL_SIGATOMIC_END();
             jl_get_ptls_states()->world_age = jl_world_counter;
             if (head == jl_incomplete_sym)
-                jl_errorf("syntax: %s", jl_string_data(jl_exprarg(form,0)));
+                jl_errorf("syntax: %s", jl_string_data(jl_exprarg(form, 0)));
             else if (head == error_sym)
-                jl_interpret_toplevel_expr(form);
+                jl_interpret_toplevel_expr_in(inmodule, form, NULL, NULL);
             else if (head == line_sym)
-                jl_lineno = jl_unbox_long(jl_exprarg(form,0));
+                jl_lineno = jl_unbox_long(jl_exprarg(form, 0));
             else if (jl_is_linenode(form))
                 jl_lineno = jl_linenode_line(form);
             else
-                result = jl_toplevel_eval_flex(form, 1, 1);
+                result = jl_toplevel_eval_flex(inmodule, form, 1, 1);
             JL_SIGATOMIC_BEGIN();
             ast = cdr_(ast);
         }
@@ -884,6 +924,7 @@ jl_value_t *jl_parse_eval_all(const char *fname,
     jl_filename = last_filename;
     fl_free_gc_handles(fl_ctx, 1);
     ctx->roots = old_roots;
+    ctx->module = old_module;
     jl_ast_ctx_leave(ctx);
     if (err) {
         if (jl_loaderror_type == NULL)
@@ -897,9 +938,9 @@ jl_value_t *jl_parse_eval_all(const char *fname,
 }
 
 JL_DLLEXPORT jl_value_t *jl_load_file_string(const char *text, size_t len,
-                                             char *filename)
+                                             char *filename, jl_module_t *inmodule)
 {
-    return jl_parse_eval_all(filename, text, len);
+    return jl_parse_eval_all(filename, text, len, inmodule);
 }
 
 JL_DLLEXPORT int jl_parse_depwarn(int warn)
@@ -925,11 +966,11 @@ static int jl_parse_deperror(fl_context_t *fl_ctx, int err)
 }
 
 // returns either an expression or a thunk
-jl_value_t *jl_call_scm_on_ast(const char *funcname, jl_value_t *expr)
+jl_value_t *jl_call_scm_on_ast(const char *funcname, jl_value_t *expr, jl_module_t *inmodule)
 {
     jl_ast_context_t *ctx = jl_ast_ctx_enter();
     fl_context_t *fl_ctx = &ctx->fl;
-    JL_AST_PRESERVE_PUSH(ctx, roots, old_roots);
+    JL_AST_PRESERVE_PUSH(ctx, roots, old_roots, inmodule);
     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);
@@ -938,16 +979,22 @@ jl_value_t *jl_call_scm_on_ast(const char *funcname, jl_value_t *expr)
     return result;
 }
 
-JL_DLLEXPORT jl_value_t *jl_expand(jl_value_t *expr)
+JL_DLLEXPORT jl_value_t *jl_expand(jl_value_t *expr, jl_module_t *inmodule)
+{
+    JL_TIMING(LOWERING);
+    return jl_call_scm_on_ast("jl-expand-to-thunk", expr, inmodule);
+}
+
+JL_DLLEXPORT jl_value_t *jl_macroexpand(jl_value_t *expr, jl_module_t *inmodule)
 {
     JL_TIMING(LOWERING);
-    return jl_call_scm_on_ast("jl-expand-to-thunk", expr);
+    return jl_call_scm_on_ast("jl-macroexpand", expr, inmodule);
 }
 
-JL_DLLEXPORT jl_value_t *jl_macroexpand(jl_value_t *expr)
+JL_DLLEXPORT jl_value_t *jl_macroexpand1(jl_value_t *expr, jl_module_t *inmodule)
 {
     JL_TIMING(LOWERING);
-    return jl_call_scm_on_ast("jl-macroexpand", expr);
+    return jl_call_scm_on_ast("jl-macroexpand-1", expr, inmodule);
 }
 
 // wrap expr in a thunk AST
diff --git a/src/ast.scm b/src/ast.scm
index 2541b1cb1edd02..c821de9496b5ed 100644
--- a/src/ast.scm
+++ b/src/ast.scm
@@ -2,7 +2,12 @@
 
 ;; deparser
 
-(define (deparse-arglist l (sep ",")) (string.join (map deparse l) sep))
+(define (deparse-arglist l (sep ", "))
+  (if (has-parameters? l)
+      (string (string.join (map deparse (cdr l)) sep)
+              "; "
+              (string.join (map deparse (cdar l)) ", "))
+      (string.join (map deparse l) sep)))
 
 (define (deparse e)
   (define (block-stmts e)
@@ -25,16 +30,22 @@
                ;; successfully printed as a julia value
                (string.sub s 9 (string.dec s (length s)))
                s)))
+        ((char? e) (string "'" e "'"))
         ((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)) #\)))))
+                 (cond ((and (pair? (caddr e)) (memq (caaddr e) '(quote inert)))
+                        (deparse (cadr (caddr e))))
+                       ((and (pair? (caddr e)) (eq? (caaddr e) 'copyast))
+                        (deparse (cadr (cadr (caddr e)))))
+                       (else
+                        (string #\( (deparse (caddr e)) #\))))))
         ((memq (car e) '(... |'| |.'|))
          (string (deparse (cadr e)) (car e)))
         ((or (syntactic-op? (car e)) (eq? (car e) '|<:|) (eq? (car e) '|>:|))
-         (string (deparse (cadr e)) (car e) (deparse (caddr e))))
+         (if (length= e 2)
+             (string (car e) (deparse (cadr e)))
+             (string (deparse (cadr e)) " " (car e) " " (deparse (caddr e)))))
         ((memq (car e) '($ &))
          (string (car e) (deparse (cadr e))))
         ((eq? (car e) '|::|)
@@ -46,18 +57,35 @@
                  (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)) #\}))
+                ((macrocall) (string (cadr e) " " (deparse-arglist (cddr e) " ")))
                 ((quote inert)
                  (if (and (symbol? (cadr e))
                           (not (= (string.char (string (cadr e)) 0) #\=)))
                      (string ":" (deparse (cadr e)))
                      (string ":(" (deparse (cadr e)) ")")))
                 ((vect)   (string #\[ (deparse-arglist (cdr e)) #\]))
-                ((vcat)   (string #\[ (deparse-arglist (cdr e) ";") #\]))
-                ((hcat)   (string #\[ (deparse-arglist (cdr e) " ") #\]))
+                ((vcat)
+                 (string #\[
+                         ;; note: this is a parser quasi-bug; arguably `[a,b;c]` should
+                         ;; be a `vect` expression with parameters, not `vcat`
+                         (deparse-arglist (cdr e) (if (has-parameters? (cdr e))
+                                                      ", " "; "))
+                         #\]))
+                ((typed_vcat)  (string (deparse (cadr e))
+                                       (deparse (cons 'vcat (cddr e)))))
+                ((hcat)        (string #\[ (deparse-arglist (cdr e) " ") #\]))
+                ((typed_hcat)  (string (deparse (cadr e))
+                                       (deparse (cons 'hcat (cddr e)))))
+                ((row)        (deparse-arglist (cdr e) " "))
+                ((braces)     (string #\{ (deparse-arglist (cdr e)) #\}))
+                ((bracescat)
+                 (string #\{
+                         (deparse-arglist (cdr e) (if (has-parameters? (cdr e))
+                                                      ", " "; "))
+                         #\}))
                 ((const)  (string "const " (deparse (cadr e))))
                 ((global local)
                  (string (car e) " " (string.join (map deparse (cdr e)) ", ")))
@@ -79,17 +107,23 @@
                 ((block)
                  (deparse-block "begin" (cdr e)))
                 ((comprehension)
-                 (string "[ " (deparse (cadr e)) " for " (deparse-arglist (cddr e) ", ") " ]"))
+                 (let ((e (cadr e)))
+                   (string "[ " (deparse (cadr e)) " for " (deparse-arglist (cddr e) ", ") " ]")))
+                ((typed_comprehension)
+                 (string (deparse (cadr e))
+                         (deparse (cons 'comprehension (cddr e)))))
                 ((generator)
                  (string "(" (deparse (cadr e)) " for " (deparse-arglist (cddr e) ", ") ")"))
                 ((where)
                  (string (deparse (cadr e)) " where "
                          (if (length= e 3)
                              (deparse (caddr e))
-                             (deparse (cons 'cell1d (cddr e))))))
+                             (deparse (cons 'braces (cddr e))))))
                 ((function for while)
                  (deparse-block (string (car e) " " (deparse (cadr e)))
                                 (block-stmts (caddr e))))
+                ((copyast) (deparse (cadr e)))
+                ((kw) (string (deparse (cadr e)) " = " (deparse (caddr e))))
                 (else
                  (string e))))))
 
@@ -146,10 +180,14 @@
             (if (not (symbol? (cadr v)))
                 (bad-formal-argument (cadr v)))
             (decl-var v))
+           ((meta)  ;; allow certain per-argument annotations
+            (if (nospecialize-meta? v #t)
+                (arg-name (caddr v))
+                (bad-formal-argument v)))
            (else (bad-formal-argument v))))))
 
 (define (arg-type v)
-  (cond ((symbol? v)  'Any)
+  (cond ((symbol? v)  '(core Any))
         ((not (pair? v))
          (bad-formal-argument v))
         (else
@@ -161,6 +199,10 @@
             (if (not (symbol? (cadr v)))
                 (bad-formal-argument (cadr v)))
             (decl-type v))
+           ((meta)  ;; allow certain per-argument annotations
+            (if (nospecialize-meta? v #t)
+                (arg-type (caddr v))
+                (bad-formal-argument v)))
            (else (bad-formal-argument v))))))
 
 ;; convert a lambda list into a list of just symbols
@@ -202,7 +244,7 @@
   (if (decl? v) (cadr v) v))
 
 (define (decl-type v)
-  (if (decl? v) (caddr v) 'Any))
+  (if (decl? v) (caddr v) '(core Any)))
 
 (define (sym-dot? e)
   (and (length= e 3) (eq? (car e) '|.|)
@@ -268,7 +310,7 @@
 (define (eq-sym? a b)
   (or (eq? a b) (and (ssavalue? a) (ssavalue? b) (eqv? (cdr a) (cdr b)))))
 
-(define (make-var-info name) (list name 'Any 0))
+(define (make-var-info name) (list name '(core Any) 0))
 (define vinfo:name car)
 (define vinfo:type cadr)
 (define (vinfo:set-type! v t) (set-car! (cdr v) t))
@@ -304,6 +346,10 @@
 (define (kwarg? e)
   (and (pair? e) (eq? (car e) 'kw)))
 
+(define (nospecialize-meta? e (one #f))
+  (and (if one (length= e 3) (length> e 2))
+       (eq? (car e) 'meta) (eq? (cadr e) 'nospecialize)))
+
 ;; flatten nested expressions with the given head
 ;; (op (op a b) c) => (op a b c)
 (define (flatten-ex head e)
diff --git a/src/atomics.h b/src/atomics.h
new file mode 100644
index 00000000000000..493f0297892bc2
--- /dev/null
+++ b/src/atomics.h
@@ -0,0 +1,279 @@
+// This file is a part of Julia. License is MIT: https://julialang.org/license
+
+#ifndef JL_ATOMICS_H
+#define JL_ATOMICS_H
+
+// Low-level atomic operations
+
+#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
+#ifndef _OS_WINDOWS_
+#  include <pthread.h>
+#endif
+#include <signal.h>
+
+/**
+ * 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 intrinsics 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 guarantee 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_relaxed(obj, arg)         \
+    __atomic_fetch_add(obj, arg, __ATOMIC_RELAXED)
+#  define jl_atomic_fetch_add(obj, arg)                 \
+    __atomic_fetch_add(obj, arg, __ATOMIC_SEQ_CST)
+#  define jl_atomic_fetch_and_relaxed(obj, arg)         \
+    __atomic_fetch_and(obj, arg, __ATOMIC_RELAXED)
+#  define jl_atomic_fetch_and(obj, arg)                 \
+    __atomic_fetch_and(obj, arg, __ATOMIC_SEQ_CST)
+#  define jl_atomic_fetch_or_relaxed(obj, arg)          \
+    __atomic_fetch_or(obj, arg, __ATOMIC_RELAXED)
+#  define jl_atomic_fetch_or(obj, arg)                  \
+    __atomic_fetch_or(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)
+#  define jl_atomic_exchange(obj, desired)              \
+    __atomic_exchange_n(obj, desired, __ATOMIC_SEQ_CST)
+#  define jl_atomic_exchange_relaxed(obj, desired)      \
+    __atomic_exchange_n(obj, desired, __ATOMIC_RELAXED)
+// 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) do {      \
+        jl_signal_fence();                              \
+        __atomic_store_n(obj, val, __ATOMIC_RELEASE);   \
+    } while (0)
+#  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()
+
+// add
+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);
+}
+#define jl_atomic_fetch_add_relaxed(obj, arg) jl_atomic_fetch_add(obj, arg)
+
+// and
+template<typename T, typename T2>
+static inline typename std::enable_if<sizeof(T) == 1, T>::type
+jl_atomic_fetch_and(T *obj, T2 arg)
+{
+    return (T)_InterlockedAnd8((volatile char*)obj, (char)arg);
+}
+template<typename T, typename T2>
+static inline typename std::enable_if<sizeof(T) == 2, T>::type
+jl_atomic_fetch_and(T *obj, T2 arg)
+{
+    return (T)_InterlockedAnd16((volatile short*)obj, (short)arg);
+}
+template<typename T, typename T2>
+static inline typename std::enable_if<sizeof(T) == 4, T>::type
+jl_atomic_fetch_and(T *obj, T2 arg)
+{
+    return (T)_InterlockedAnd((volatile LONG*)obj, (LONG)arg);
+}
+template<typename T, typename T2>
+static inline typename std::enable_if<sizeof(T) == 8, T>::type
+jl_atomic_fetch_and(T *obj, T2 arg)
+{
+    return (T)_InterlockedAnd64((volatile __int64*)obj, (__int64)arg);
+}
+#define jl_atomic_fetch_and_relaxed(obj, arg) jl_atomic_fetch_and(obj, arg)
+
+// or
+template<typename T, typename T2>
+static inline typename std::enable_if<sizeof(T) == 1, T>::type
+jl_atomic_fetch_or(T *obj, T2 arg)
+{
+    return (T)_InterlockedOr8((volatile char*)obj, (char)arg);
+}
+template<typename T, typename T2>
+static inline typename std::enable_if<sizeof(T) == 2, T>::type
+jl_atomic_fetch_or(T *obj, T2 arg)
+{
+    return (T)_InterlockedOr16((volatile short*)obj, (short)arg);
+}
+template<typename T, typename T2>
+static inline typename std::enable_if<sizeof(T) == 4, T>::type
+jl_atomic_fetch_or(T *obj, T2 arg)
+{
+    return (T)_InterlockedOr((volatile LONG*)obj, (LONG)arg);
+}
+template<typename T, typename T2>
+static inline typename std::enable_if<sizeof(T) == 8, T>::type
+jl_atomic_fetch_or(T *obj, T2 arg)
+{
+    return (T)_InterlockedOr64((volatile __int64*)obj, (__int64)arg);
+}
+#define jl_atomic_fetch_or_relaxed(obj, arg) jl_atomic_fetch_or(obj, 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 exchange
+template<typename T, typename T2>
+static inline typename std::enable_if<sizeof(T) == 1, T>::type
+jl_atomic_exchange(volatile T *obj, T2 val)
+{
+    return _InterlockedExchange8((volatile char*)obj, (char)val);
+}
+template<typename T, typename T2>
+static inline typename std::enable_if<sizeof(T) == 2, T>::type
+jl_atomic_exchange(volatile T *obj, T2 val)
+{
+    return _InterlockedExchange16((volatile short*)obj, (short)val);
+}
+template<typename T, typename T2>
+static inline typename std::enable_if<sizeof(T) == 4, T>::type
+jl_atomic_exchange(volatile T *obj, T2 val)
+{
+    return _InterlockedExchange((volatile LONG*)obj, (LONG)val);
+}
+template<typename T, typename T2>
+static inline typename std::enable_if<sizeof(T) == 8, T>::type
+jl_atomic_exchange(volatile T *obj, T2 val)
+{
+    return _InterlockedExchange64((volatile __int64*)obj, (__int64)val);
+}
+#define jl_atomic_exchange_relaxed(obj, val) jl_atomic_exchange(obj, val)
+// 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
+
+#endif // JL_ATOMICS_H
diff --git a/src/builtin_proto.h b/src/builtin_proto.h
index 0ac2a70c4b19b3..808edcd252c980 100644
--- a/src/builtin_proto.h
+++ b/src/builtin_proto.h
@@ -1,7 +1,7 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
-#ifndef BUILTIN_PROTO_H
-#define BUILTIN_PROTO_H
+#ifndef JL_BUILTIN_PROTO_H
+#define JL_BUILTIN_PROTO_H
 
 #ifdef __cplusplus
 extern "C" {
@@ -23,6 +23,7 @@ DECLARE_BUILTIN(throw);      DECLARE_BUILTIN(is);
 DECLARE_BUILTIN(typeof);     DECLARE_BUILTIN(sizeof);
 DECLARE_BUILTIN(issubtype);  DECLARE_BUILTIN(isa);
 DECLARE_BUILTIN(_apply);     DECLARE_BUILTIN(_apply_pure);
+DECLARE_BUILTIN(_apply_latest);
 DECLARE_BUILTIN(isdefined);  DECLARE_BUILTIN(nfields);
 DECLARE_BUILTIN(tuple);      DECLARE_BUILTIN(svec);
 DECLARE_BUILTIN(getfield);   DECLARE_BUILTIN(setfield);
diff --git a/src/builtins.c b/src/builtins.c
index b41e42a76f06d1..3b0b39faeab822 100644
--- a/src/builtins.c
+++ b/src/builtins.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 /*
   implementations of built-in functions
@@ -121,6 +121,12 @@ JL_DLLEXPORT int jl_egal(jl_value_t *a, jl_value_t *b)
         jl_datatype_t *dtb = (jl_datatype_t*)b;
         return dta->name == dtb->name && compare_svec(dta->parameters, dtb->parameters);
     }
+    if (dt == jl_string_type) {
+        size_t l = jl_string_len(a);
+        if (jl_string_len(b) != l)
+            return 0;
+        return !memcmp(jl_string_data(a), jl_string_data(b), l);
+    }
     if (dt->mutabl) return 0;
     size_t sz = jl_datatype_size(dt);
     if (sz == 0) return 1;
@@ -186,6 +192,13 @@ static uintptr_t jl_object_id_(jl_value_t *tv, jl_value_t *v)
 #else
     if (v == jl_ANY_flag) return 0x8ee30bdd;
 #endif
+    if (dt == jl_string_type) {
+#ifdef _P64
+        return memhash_seed(jl_string_data(v), jl_string_len(v), 0xedc3b677);
+#else
+        return memhash32_seed(jl_string_data(v), jl_string_len(v), 0xedc3b677);
+#endif
+    }
     if (dt->mutabl) return inthash((uintptr_t)v);
     size_t sz = jl_datatype_size(tv);
     uintptr_t h = jl_object_id(tv);
@@ -244,45 +257,41 @@ JL_CALLABLE(jl_f_sizeof)
 {
     JL_NARGS(sizeof, 1, 1);
     jl_value_t *x = args[0];
-    if (jl_is_unionall(x)) {
+    if (jl_is_unionall(x) || jl_is_uniontype(x)) {
         x = jl_unwrap_unionall(x);
         if (!jl_is_datatype(x))
             jl_error("argument is an abstract type; size is indeterminate");
     }
     if (jl_is_datatype(x)) {
         jl_datatype_t *dx = (jl_datatype_t*)x;
-        if (dx->name == jl_array_typename || dx == jl_symbol_type || dx == jl_simplevector_type ||
-            dx == jl_string_type)
-            jl_error("type does not have a canonical binary representation");
-        if (!(dx->name->names == jl_emptysvec && jl_datatype_size(dx) > 0)) {
-            // names===() and size > 0  =>  bitstype, size always known
-            if (dx->abstract || !jl_is_concrete_type(x))
-                jl_error("argument is an abstract type; size is indeterminate");
-        }
+        if (dx->layout == NULL)
+            jl_error("argument is an abstract type; size is indeterminate");
+        if (jl_is_layout_opaque(dx->layout))
+            jl_error("type does not have a fixed size");
         return jl_box_long(jl_datatype_size(x));
     }
     if (jl_is_array(x))
         return jl_box_long(jl_array_len(x) * ((jl_array_t*)x)->elsize);
     if (jl_is_string(x))
         return jl_box_long(jl_string_len(x));
+    if (jl_is_symbol(x))
+        return jl_box_long(strlen(jl_symbol_name((jl_sym_t*)x)));
+    if (jl_is_svec(x))
+        return jl_box_long((1+jl_svec_len(x))*sizeof(void*));
     jl_datatype_t *dt = (jl_datatype_t*)jl_typeof(x);
     assert(jl_is_datatype(dt));
     assert(!dt->abstract);
-    if (dt == jl_symbol_type)
-        jl_error("value does not have a canonical binary representation");
-    if (dt == jl_simplevector_type)
-        return jl_box_long((1+jl_svec_len(x))*sizeof(void*));
     return jl_box_long(jl_datatype_size(dt));
 }
 
 JL_CALLABLE(jl_f_issubtype)
 {
-    JL_NARGS(issubtype, 2, 2);
+    JL_NARGS(<:, 2, 2);
     jl_value_t *a = args[0], *b = args[1];
     if (jl_is_typevar(a)) a = ((jl_tvar_t*)a)->ub; // TODO should we still allow this?
     if (jl_is_typevar(b)) b = ((jl_tvar_t*)b)->ub;
-    JL_TYPECHK(issubtype, type, a);
-    JL_TYPECHK(issubtype, type, b);
+    JL_TYPECHK(<:, type, a);
+    JL_TYPECHK(<:, type, b);
     return (jl_subtype(a,b) ? jl_true : jl_false);
 }
 
@@ -454,6 +463,18 @@ JL_CALLABLE(jl_f__apply_pure)
     return ret;
 }
 
+// this is like `_apply`, but always runs in the newest world
+JL_CALLABLE(jl_f__apply_latest)
+{
+    jl_ptls_t ptls = jl_get_ptls_states();
+    size_t last_age = ptls->world_age;
+    if (!ptls->in_pure_callback)
+        ptls->world_age = jl_world_counter;
+    jl_value_t *ret = jl_f__apply(NULL, args, nargs);
+    ptls->world_age = last_age;
+    return ret;
+}
+
 // eval -----------------------------------------------------------------------
 
 JL_DLLEXPORT jl_value_t *jl_toplevel_eval_in(jl_module_t *m, jl_value_t *ex)
@@ -481,7 +502,7 @@ JL_DLLEXPORT jl_value_t *jl_toplevel_eval_in(jl_module_t *m, jl_value_t *ex)
     JL_TRY {
         ptls->current_task->current_module = ptls->current_module = m;
         ptls->world_age = jl_world_counter;
-        v = jl_toplevel_eval(ex);
+        v = jl_toplevel_eval(m, ex);
     }
     JL_CATCH {
         jl_lineno = last_lineno;
@@ -499,9 +520,8 @@ JL_DLLEXPORT jl_value_t *jl_toplevel_eval_in(jl_module_t *m, jl_value_t *ex)
 
 JL_CALLABLE(jl_f_isdefined)
 {
-    jl_ptls_t ptls = jl_get_ptls_states();
-    jl_module_t *m = ptls->current_module;
-    jl_sym_t *s=NULL;
+    jl_module_t *m = NULL;
+    jl_sym_t *s = NULL;
     JL_NARGSV(isdefined, 1);
     if (jl_is_array(args[0])) {
         return jl_array_isdefined(args, nargs) ? jl_true : jl_false;
@@ -512,13 +532,16 @@ JL_CALLABLE(jl_f_isdefined)
     }
     if (nargs != 2) {
         JL_NARGS(isdefined, 1, 1);
+        jl_depwarn("`isdefined(:symbol)` is deprecated, "
+                   "use `@isdefined symbol` instead",
+                   (jl_value_t*)jl_symbol("isdefined"));
+        jl_ptls_t ptls = jl_get_ptls_states();
+        m = ptls->current_module;
     }
     else {
         if (!jl_is_module(args[0])) {
             jl_datatype_t *vt = (jl_datatype_t*)jl_typeof(args[0]);
-            if (!jl_is_datatype(vt)) {
-                jl_type_error("isdefined", (jl_value_t*)jl_datatype_type, args[0]);
-            }
+            assert(jl_is_datatype(vt));
             size_t idx;
             if (jl_is_long(args[1])) {
                 idx = jl_unbox_long(args[1])-1;
@@ -683,7 +706,10 @@ JL_CALLABLE(jl_f_nfields)
 {
     JL_NARGS(nfields, 1, 1);
     jl_value_t *x = args[0];
-    if (!jl_is_datatype(x))
+    if (jl_is_datatype(x))
+        jl_depwarn("`nfields(::DataType)` is deprecated, use `fieldcount` instead",
+                   (jl_value_t*)jl_symbol("nfields"));
+    else
         x = jl_typeof(x);
     return jl_box_long(jl_field_count(x));
 }
@@ -1057,7 +1083,7 @@ void jl_init_primitives(void)
     add_builtin_func("===", jl_f_is);
     add_builtin_func("typeof", jl_f_typeof);
     add_builtin_func("sizeof", jl_f_sizeof);
-    add_builtin_func("issubtype", jl_f_issubtype);
+    add_builtin_func("<:", jl_f_issubtype);
     add_builtin_func("isa", jl_f_isa);
     add_builtin_func("typeassert", jl_f_typeassert);
     add_builtin_func("throw", jl_f_throw);
@@ -1089,6 +1115,7 @@ void jl_init_primitives(void)
     add_builtin_func("apply_type", jl_f_apply_type);
     add_builtin_func("_apply", jl_f__apply);
     add_builtin_func("_apply_pure", jl_f__apply_pure);
+    add_builtin_func("_apply_latest", jl_f__apply_latest);
     add_builtin_func("_expr", jl_f__expr);
     add_builtin_func("svec", jl_f_svec);
 
@@ -1102,7 +1129,7 @@ void jl_init_primitives(void)
     add_builtin("TypeVar", (jl_value_t*)jl_tvar_type);
     add_builtin("UnionAll", (jl_value_t*)jl_unionall_type);
     add_builtin("Union", (jl_value_t*)jl_uniontype_type);
-    add_builtin("BottomType", (jl_value_t*)jl_bottomtype_type);
+    add_builtin("TypeofBottom", (jl_value_t*)jl_typeofbottom_type);
     add_builtin("Tuple", (jl_value_t*)jl_anytuple_type);
     add_builtin("Vararg", (jl_value_t*)jl_vararg_type);
     add_builtin("SimpleVector", (jl_value_t*)jl_simplevector_type);
@@ -1138,6 +1165,10 @@ void jl_init_primitives(void)
     add_builtin("NewvarNode", (jl_value_t*)jl_newvarnode_type);
     add_builtin("GlobalRef", (jl_value_t*)jl_globalref_type);
 
+    add_builtin("Bool", (jl_value_t*)jl_bool_type);
+    add_builtin("UInt8", (jl_value_t*)jl_uint8_type);
+    add_builtin("Int32", (jl_value_t*)jl_int32_type);
+    add_builtin("Int64", (jl_value_t*)jl_int64_type);
 #ifdef _P64
     add_builtin("Int", (jl_value_t*)jl_int64_type);
 #else
diff --git a/src/ccall.cpp b/src/ccall.cpp
index f1d67dd2db0462..f0b6f0fe6fc8d7 100644
--- a/src/ccall.cpp
+++ b/src/ccall.cpp
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 // --- the ccall, cglobal, and llvm intrinsics ---
 
@@ -95,7 +95,7 @@ static bool runtime_sym_gvs(const char *f_lib, const char *f_name, MT &&M,
         }
     }
     if (libsym == NULL) {
-        libsym = *(void**)jl_get_global(libptrgv);
+        libsym = *(void**)jl_get_globalvar(libptrgv);
     }
     assert(libsym != NULL);
 
@@ -128,10 +128,12 @@ static bool runtime_sym_gvs(const char *f_lib, const char *f_name, MT &&M,
     return runtime_lib;
 }
 
-static Value *runtime_sym_lookup(PointerType *funcptype, const char *f_lib,
-                                 const char *f_name, Function *f,
-                                 GlobalVariable *libptrgv,
-                                 GlobalVariable *llvmgv, bool runtime_lib)
+static Value *runtime_sym_lookup(
+        IRBuilder<> &irbuilder,
+        PointerType *funcptype, const char *f_lib,
+        const char *f_name, Function *f,
+        GlobalVariable *libptrgv,
+        GlobalVariable *llvmgv, bool runtime_lib)
 {
     // in pseudo-code, this function emits the following:
     //   global HMODULE *libptrgv
@@ -140,11 +142,11 @@ static Value *runtime_sym_lookup(PointerType *funcptype, const char *f_lib,
     //       *llvmgv = jl_load_and_lookup(f_lib, f_name, libptrgv);
     //   }
     //   return (*llvmgv)
-    BasicBlock *enter_bb = builder.GetInsertBlock();
+    BasicBlock *enter_bb = irbuilder.GetInsertBlock();
     BasicBlock *dlsym_lookup = BasicBlock::Create(jl_LLVMContext, "dlsym");
     BasicBlock *ccall_bb = BasicBlock::Create(jl_LLVMContext, "ccall");
     Constant *initnul = ConstantPointerNull::get((PointerType*)T_pvoidfunc);
-    LoadInst *llvmf_orig = builder.CreateAlignedLoad(llvmgv, sizeof(void*));
+    LoadInst *llvmf_orig = irbuilder.CreateAlignedLoad(llvmgv, sizeof(void*));
     // This in principle needs a consume ordering so that load from
     // this pointer sees a valid value. However, this is not supported by
     // LLVM (or agreed on in the C/C++ standard FWIW) and should be
@@ -153,42 +155,40 @@ static Value *runtime_sym_lookup(PointerType *funcptype, const char *f_lib,
     // invalid load from the `cglobal` but doesn't depend on the `cglobal`
     // value for this to happen.
     // llvmf_orig->setAtomic(AtomicOrdering::Consume);
-    builder.CreateCondBr(builder.CreateICmpNE(llvmf_orig, initnul),
-                         ccall_bb, dlsym_lookup);
+    irbuilder.CreateCondBr(
+            irbuilder.CreateICmpNE(llvmf_orig, initnul),
+            ccall_bb,
+            dlsym_lookup);
 
     assert(f->getParent() != NULL);
     f->getBasicBlockList().push_back(dlsym_lookup);
-    builder.SetInsertPoint(dlsym_lookup);
+    irbuilder.SetInsertPoint(dlsym_lookup);
     Value *libname;
     if (runtime_lib) {
-        libname = stringConstPtr(builder, f_lib);
+        libname = stringConstPtr(irbuilder, f_lib);
     }
     else {
-        libname = literal_static_pointer_val(f_lib, T_pint8);
+        // f_lib is actually one of the special sentinel values
+        libname = ConstantExpr::getIntToPtr(ConstantInt::get(T_size, (uintptr_t)f_lib), T_pint8);
     }
-#if JL_LLVM_VERSION >= 30700
-    Value *llvmf = builder.CreateCall(prepare_call(builder, jldlsym_func), { libname, stringConstPtr(builder, f_name), libptrgv });
-#else
-    Value *llvmf = builder.CreateCall3(prepare_call(builder, jldlsym_func), libname, stringConstPtr(builder, f_name), libptrgv);
-#endif
-    auto store = builder.CreateAlignedStore(llvmf, llvmgv, sizeof(void*));
-#  if JL_LLVM_VERSION >= 30900
+    Value *llvmf = irbuilder.CreateCall(prepare_call_in(jl_builderModule(irbuilder), jldlsym_func),
+            { libname, stringConstPtr(irbuilder, f_name), libptrgv });
+    auto store = irbuilder.CreateAlignedStore(llvmf, llvmgv, sizeof(void*));
     store->setAtomic(AtomicOrdering::Release);
-#  else
-    store->setAtomic(Release);
-#  endif
-    builder.CreateBr(ccall_bb);
+    irbuilder.CreateBr(ccall_bb);
 
     f->getBasicBlockList().push_back(ccall_bb);
-    builder.SetInsertPoint(ccall_bb);
-    PHINode *p = builder.CreatePHI(T_pvoidfunc, 2);
+    irbuilder.SetInsertPoint(ccall_bb);
+    PHINode *p = irbuilder.CreatePHI(T_pvoidfunc, 2);
     p->addIncoming(llvmf_orig, enter_bb);
     p->addIncoming(llvmf, dlsym_lookup);
-    return builder.CreatePointerCast(p, funcptype);
+    return irbuilder.CreatePointerCast(p, funcptype);
 }
 
-static Value *runtime_sym_lookup(PointerType *funcptype, const char *f_lib,
-                                 const char *f_name, Function *f)
+static Value *runtime_sym_lookup(
+        jl_codectx_t &ctx,
+        PointerType *funcptype, const char *f_lib,
+        const char *f_name, Function *f)
 {
     GlobalVariable *libptrgv;
     GlobalVariable *llvmgv;
@@ -196,7 +196,7 @@ static Value *runtime_sym_lookup(PointerType *funcptype, const char *f_lib,
                                        libptrgv, llvmgv);
     libptrgv = prepare_global(libptrgv);
     llvmgv = prepare_global(llvmgv);
-    return runtime_sym_lookup(funcptype, f_lib, f_name, f, libptrgv, llvmgv,
+    return runtime_sym_lookup(ctx.builder, funcptype, f_lib, f_name, f, libptrgv, llvmgv,
                               runtime_lib);
 }
 
@@ -206,24 +206,30 @@ static Value *runtime_sym_lookup(PointerType *funcptype, const char *f_lib,
 // all the arguments without writing assembly directly.
 // This doesn't matter too much in reality since a single function is usually
 // not called with multiple signatures.
+#if JL_LLVM_VERSION >= 50000
+static DenseMap<AttributeList,
+#else
 static DenseMap<AttributeSet,
+#endif
                 std::map<std::tuple<GlobalVariable*,FunctionType*,
                                     CallingConv::ID>,GlobalVariable*>> allPltMap;
 
 // Emit a "PLT" entry that will be lazily initialized
 // when being called the first time.
-static GlobalVariable *emit_plt_thunk(Module *M, FunctionType *functype, const AttributeSet &attrs,
-                                      CallingConv::ID cc, const char *f_lib, const char *f_name,
-                                      GlobalVariable *libptrgv, GlobalVariable *llvmgv,
-                                      void *symaddr, bool runtime_lib)
+static GlobalVariable *emit_plt_thunk(
+        Module *M, FunctionType *functype,
+#if JL_LLVM_VERSION >= 50000
+        const AttributeList &attrs,
+#else
+        const AttributeSet &attrs,
+#endif
+        CallingConv::ID cc, const char *f_lib, const char *f_name,
+        GlobalVariable *libptrgv, GlobalVariable *llvmgv,
+        void *symaddr, bool runtime_lib)
 {
     PointerType *funcptype = PointerType::get(functype, 0);
-    libptrgv = prepare_global(libptrgv, M);
-    llvmgv = prepare_global(llvmgv, M);
-    BasicBlock *old = builder.GetInsertBlock();
-    DebugLoc olddl = builder.getCurrentDebugLocation();
-    DebugLoc noDbg;
-    builder.SetCurrentDebugLocation(noDbg);
+    libptrgv = prepare_global_in(M, libptrgv);
+    llvmgv = prepare_global_in(M, llvmgv);
     std::stringstream funcName;
     funcName << "jlplt_" << f_name << "_" << globalUnique++;
     auto fname = funcName.str();
@@ -241,45 +247,44 @@ static GlobalVariable *emit_plt_thunk(Module *M, FunctionType *functype, const A
                                              nullptr, gname);
     *(void**)jl_emit_and_add_to_shadow(got) = symaddr;
     BasicBlock *b0 = BasicBlock::Create(jl_LLVMContext, "top", plt);
-    builder.SetInsertPoint(b0);
-    Value *ptr = runtime_sym_lookup(funcptype, f_lib, f_name, plt, libptrgv,
+    IRBuilder<> irbuilder(b0);
+    Value *ptr = runtime_sym_lookup(irbuilder, funcptype, f_lib, f_name, plt, libptrgv,
                                     llvmgv, runtime_lib);
-    auto store = builder.CreateAlignedStore(builder.CreateBitCast(ptr, T_pvoidfunc), got, sizeof(void*));
-#if JL_LLVM_VERSION >= 30900
+    auto store = irbuilder.CreateAlignedStore(irbuilder.CreateBitCast(ptr, T_pvoidfunc), got, sizeof(void*));
     store->setAtomic(AtomicOrdering::Release);
-#else
-    store->setAtomic(Release);
-#endif
     SmallVector<Value*, 16> args;
     for (Function::arg_iterator arg = plt->arg_begin(), arg_e = plt->arg_end(); arg != arg_e; ++arg)
         args.push_back(&*arg);
-    CallInst *ret = builder.CreateCall(ptr, ArrayRef<Value*>(args));
+    CallInst *ret = irbuilder.CreateCall(ptr, ArrayRef<Value*>(args));
     ret->setAttributes(attrs);
     if (cc != CallingConv::C)
         ret->setCallingConv(cc);
     // NoReturn function can trigger LLVM verifier error when declared as
     // MustTail since other passes might replace the `ret` with
     // `unreachable` (LLVM should probably accept `unreachable`).
+#if JL_LLVM_VERSION >= 50000
+    if (attrs.hasAttribute(AttributeList::FunctionIndex,
+#else
     if (attrs.hasAttribute(AttributeSet::FunctionIndex,
+#endif
                            Attribute::NoReturn)) {
-        builder.CreateUnreachable();
+        irbuilder.CreateUnreachable();
     }
     else {
         // musttail support is very bad on ARM, PPC, PPC64 (as of LLVM 3.9)
         // Known failures includes vararg (not needed here) and sret.
-#if JL_LLVM_VERSION >= 30700 && (defined(_CPU_X86_) || defined(_CPU_X86_64_) || \
+#if (defined(_CPU_X86_) || defined(_CPU_X86_64_) || \
                         defined(_CPU_AARCH64_))
         ret->setTailCallKind(CallInst::TCK_MustTail);
 #endif
         if (functype->getReturnType() == T_void) {
-            builder.CreateRetVoid();
+            irbuilder.CreateRetVoid();
         }
         else {
-            builder.CreateRet(ret);
+            irbuilder.CreateRet(ret);
         }
     }
-    builder.SetInsertPoint(old);
-    builder.SetCurrentDebugLocation(olddl);
+    irbuilder.ClearInsertionPoint();
     got = global_proto(got); // exchange got for the permanent global before jl_finalize_module destroys it
     jl_finalize_module(M, true);
 
@@ -291,8 +296,15 @@ static GlobalVariable *emit_plt_thunk(Module *M, FunctionType *functype, const A
     return got;
 }
 
-static Value *emit_plt(FunctionType *functype, const AttributeSet &attrs,
-                       CallingConv::ID cc, const char *f_lib, const char *f_name)
+static Value *emit_plt(
+        jl_codectx_t &ctx,
+        FunctionType *functype,
+#if JL_LLVM_VERSION >= 50000
+       const AttributeList &attrs,
+#else
+       const AttributeSet &attrs,
+#endif
+       CallingConv::ID cc, const char *f_lib, const char *f_name)
 {
     assert(imaging_mode);
     // Don't do this for vararg functions so that the `musttail` is only
@@ -322,13 +334,13 @@ static Value *emit_plt(FunctionType *functype, const AttributeSet &attrs,
         assert(!LM.m);
     }
     GlobalVariable *got = prepare_global(shadowgot);
-    LoadInst *got_val = builder.CreateAlignedLoad(got, sizeof(void*));
+    LoadInst *got_val = ctx.builder.CreateAlignedLoad(got, sizeof(void*));
     // See comment in `runtime_sym_lookup` above. This in principle needs a
     // consume ordering too. This is even less likely to cause issues though
     // since the only thing we do to this loaded pointer is to call it
     // immediately.
     // got_val->setAtomic(AtomicOrdering::Consume);
-    return builder.CreateBitCast(got_val, funcptype);
+    return ctx.builder.CreateBitCast(got_val, funcptype);
 }
 
 // --- ABI Implementations ---
@@ -398,9 +410,9 @@ static bool is_native_simd_type(jl_datatype_t *dt) {
 
 // basic type widening and cast conversions
 static Value *llvm_type_rewrite(
+        jl_codectx_t &ctx,
         Value *v, Type *target_type,
-        bool issigned, /* determines whether an integer value should be zero or sign extended */
-        jl_codectx_t *ctx)
+        bool issigned) /* determines whether an integer value should be zero or sign extended */
 {
     Type *from_type = v->getType();
     if (target_type == from_type)
@@ -411,27 +423,27 @@ static Value *llvm_type_rewrite(
 
     assert(from_type->isPointerTy() == target_type->isPointerTy()); // expect that all ABIs consider all pointers to be equivalent
     if (target_type->isPointerTy())
-        return emit_bitcast(v, target_type);
+        return emit_bitcast(ctx, v, target_type);
 
     // simple integer and float widening & conversion cases
     if (from_type->getPrimitiveSizeInBits() > 0 &&
             target_type->getPrimitiveSizeInBits() == from_type->getPrimitiveSizeInBits())
-        return emit_bitcast(v, target_type);
+        return emit_bitcast(ctx, v, target_type);
 
     if (target_type->isFloatingPointTy() && from_type->isFloatingPointTy()) {
         if (target_type->getPrimitiveSizeInBits() > from_type->getPrimitiveSizeInBits())
-            return builder.CreateFPExt(v, target_type);
+            return ctx.builder.CreateFPExt(v, target_type);
         else if (target_type->getPrimitiveSizeInBits() < from_type->getPrimitiveSizeInBits())
-            return builder.CreateFPTrunc(v, target_type);
+            return ctx.builder.CreateFPTrunc(v, target_type);
         else
             return v;
     }
 
     if (target_type->isIntegerTy() && from_type->isIntegerTy()) {
         if (issigned)
-            return builder.CreateSExtOrTrunc(v, target_type);
+            return ctx.builder.CreateSExtOrTrunc(v, target_type);
         else
-            return builder.CreateZExtOrTrunc(v, target_type);
+            return ctx.builder.CreateZExtOrTrunc(v, target_type);
     }
 
     // one or both of from_type and target_type is a VectorType or AggregateType
@@ -441,39 +453,39 @@ static Value *llvm_type_rewrite(
     // sizes.
     Value *from;
     Value *to;
-#if JL_LLVM_VERSION >= 30600
-    const DataLayout &DL = jl_ExecutionEngine->getDataLayout();
+#if JL_LLVM_VERSION >= 40000
+    const DataLayout &DL = jl_data_layout;
 #else
-    const DataLayout &DL = *jl_ExecutionEngine->getDataLayout();
+    const DataLayout &DL = jl_ExecutionEngine->getDataLayout();
 #endif
     if (DL.getTypeAllocSize(target_type) >= DL.getTypeAllocSize(from_type)) {
-        to = emit_static_alloca(target_type, ctx);
-        from = emit_bitcast(to, from_type->getPointerTo());
+        to = emit_static_alloca(ctx, target_type);
+        from = emit_bitcast(ctx, to, from_type->getPointerTo());
     }
     else {
-        from = emit_static_alloca(from_type, ctx);
-        to = emit_bitcast(from, target_type->getPointerTo());
+        from = emit_static_alloca(ctx, from_type);
+        to = emit_bitcast(ctx, from, target_type->getPointerTo());
     }
-    builder.CreateStore(v, from);
-    return builder.CreateLoad(to);
+    ctx.builder.CreateStore(v, from);
+    return ctx.builder.CreateLoad(to);
 }
 
 // --- argument passing and scratch space utilities ---
 
-static Value *runtime_apply_type(jl_value_t *ty, jl_unionall_t *unionall, jl_codectx_t *ctx)
+static Value *runtime_apply_type(jl_codectx_t &ctx, jl_value_t *ty, jl_unionall_t *unionall)
 {
     // box if concrete type was not statically known
     Value *args[3];
-    args[0] = literal_pointer_val(ty);
-    args[1] = literal_pointer_val((jl_value_t*)ctx->linfo->def->sig);
-    args[2] = builder.CreateInBoundsGEP(
-            LLVM37_param(T_pjlvalue)
-            emit_bitcast(ctx->spvals_ptr, T_ppjlvalue),
+    args[0] = literal_pointer_val(ctx, ty);
+    args[1] = literal_pointer_val(ctx, (jl_value_t*)ctx.linfo->def.method->sig);
+    args[2] = ctx.builder.CreateInBoundsGEP(
+            T_prjlvalue,
+            ctx.spvals_ptr,
             ConstantInt::get(T_size, sizeof(jl_svec_t) / sizeof(jl_value_t*)));
-    return builder.CreateCall(prepare_call(jlapplytype_func), makeArrayRef(args));
+    return ctx.builder.CreateCall(prepare_call(jlapplytype_func), makeArrayRef(args));
 }
 
-static void typeassert_input(const jl_cgval_t &jvinfo, jl_value_t *jlto, jl_unionall_t *jlto_env, int argn, bool addressOf, jl_codectx_t *ctx)
+static void typeassert_input(jl_codectx_t &ctx, const jl_cgval_t &jvinfo, jl_value_t *jlto, jl_unionall_t *jlto_env, int argn, bool addressOf)
 {
     if (jlto != (jl_value_t*)jl_any_type && !jl_subtype(jvinfo.typ, jlto)) {
         if (!addressOf && jlto == (jl_value_t*)jl_voidpointer_type) {
@@ -483,7 +495,7 @@ static void typeassert_input(const jl_cgval_t &jvinfo, jl_value_t *jlto, jl_unio
                 std::stringstream msg;
                 msg << "ccall argument ";
                 msg << argn;
-                emit_cpointercheck(jvinfo, msg.str(), ctx);
+                emit_cpointercheck(ctx, jvinfo, msg.str());
             }
         }
         else {
@@ -492,40 +504,37 @@ static void typeassert_input(const jl_cgval_t &jvinfo, jl_value_t *jlto, jl_unio
             msg << "ccall argument ";
             msg << argn;
             if (!jlto_env || !jl_has_typevar_from_unionall(jlto, jlto_env)) {
-                emit_typecheck(jvinfo, jlto, msg.str(), ctx);
+                emit_typecheck(ctx, jvinfo, jlto, msg.str());
             }
             else {
-                jl_cgval_t jlto_runtime = mark_julia_type(runtime_apply_type(jlto, jlto_env, ctx), true, jl_any_type, ctx);
-                Value *vx = boxed(jvinfo, ctx);
-                Value *istype = builder.
-                    CreateICmpNE(
-#if JL_LLVM_VERSION >= 30700
-                                 builder.CreateCall(prepare_call(jlisa_func), { vx, boxed(jlto_runtime, ctx) }),
-#else
-                                 builder.CreateCall2(prepare_call(jlisa_func), vx, boxed(jlto_runtime, ctx)),
-#endif
-                                 ConstantInt::get(T_int32, 0));
-                BasicBlock *failBB = BasicBlock::Create(jl_LLVMContext, "fail", ctx->f);
-                BasicBlock *passBB = BasicBlock::Create(jl_LLVMContext, "pass", ctx->f);
-                builder.CreateCondBr(istype, passBB, failBB);
-
-                builder.SetInsertPoint(failBB);
-                emit_type_error(mark_julia_type(vx, true, jl_any_type, ctx), boxed(jlto_runtime, ctx), msg.str(), ctx);
-                builder.CreateUnreachable();
-
-                builder.SetInsertPoint(passBB);
+                jl_cgval_t jlto_runtime = mark_julia_type(ctx, runtime_apply_type(ctx, jlto, jlto_env), true, jl_any_type);
+                Value *vx = boxed(ctx, jvinfo);
+                Value *istype = ctx.builder.CreateICmpNE(
+                        ctx.builder.CreateCall(prepare_call(jlisa_func), { vx, boxed(ctx, jlto_runtime) }),
+                        ConstantInt::get(T_int32, 0));
+                BasicBlock *failBB = BasicBlock::Create(jl_LLVMContext, "fail", ctx.f);
+                BasicBlock *passBB = BasicBlock::Create(jl_LLVMContext, "pass", ctx.f);
+                ctx.builder.CreateCondBr(istype, passBB, failBB);
+
+                ctx.builder.SetInsertPoint(failBB);
+                emit_type_error(ctx, mark_julia_type(ctx, vx, true, jl_any_type), boxed(ctx, jlto_runtime), msg.str());
+                ctx.builder.CreateUnreachable();
+                ctx.builder.SetInsertPoint(passBB);
             }
         }
     }
 }
 
-static Value *julia_to_address(Type *to, jl_value_t *jlto, jl_unionall_t *jlto_env, const jl_cgval_t &jvinfo,
-                               int argn, jl_codectx_t *ctx, bool *needStackRestore)
+static Value *julia_to_address(
+        jl_codectx_t &ctx,
+        Type *to, jl_value_t *jlto, jl_unionall_t *jlto_env,
+        const jl_cgval_t &jvinfo,
+        int argn, bool *needStackRestore)
 {
     assert(jl_is_datatype(jlto) && julia_struct_has_layout((jl_datatype_t*)jlto, jlto_env));
 
     if (!jl_is_cpointer_type(jlto) || !to->isPointerTy()) {
-        emit_error("ccall: & on argument was not matched by Ptr{T} argument type", ctx);
+        emit_error(ctx, "ccall: & on argument was not matched by Ptr{T} argument type");
         return UndefValue::get(to);
     }
 
@@ -535,7 +544,7 @@ static Value *julia_to_address(Type *to, jl_value_t *jlto, jl_unionall_t *jlto_e
     }
     else {
         ety = jl_tparam0(jlto);
-        typeassert_input(jvinfo, ety, jlto_env, argn, true, ctx);
+        typeassert_input(ctx, jvinfo, ety, jlto_env, argn, true);
     }
     assert(to->isPointerTy());
 
@@ -543,7 +552,7 @@ static Value *julia_to_address(Type *to, jl_value_t *jlto, jl_unionall_t *jlto_e
         if (!jl_is_abstracttype(ety)) {
             if (jl_is_mutable_datatype(ety)) {
                 // no copy, just reference the data field
-                return data_pointer(jvinfo, ctx, to);
+                return data_pointer(ctx, jvinfo, to);
             }
             else if (jl_is_immutable_datatype(ety) && jlto != (jl_value_t*)jl_voidpointer_type) {
                 // yes copy
@@ -552,38 +561,38 @@ static Value *julia_to_address(Type *to, jl_value_t *jlto, jl_unionall_t *jlto_e
                 if (jl_is_concrete_type(ety) || jl_is_primitivetype(ety)) {
                     int nb = jl_datatype_size(ety);
                     nbytes = ConstantInt::get(T_int32, nb);
-                    ai = emit_static_alloca(T_int8, nb, ctx);
+                    ai = emit_static_alloca(ctx, T_int8, nb);
                 }
                 else {
-                    nbytes = emit_datatype_size(emit_typeof_boxed(jvinfo,ctx));
-                    ai = builder.CreateAlloca(T_int8, nbytes);
+                    nbytes = emit_datatype_size(ctx, emit_typeof_boxed(ctx, jvinfo));
+                    ai = ctx.builder.CreateAlloca(T_int8, nbytes);
                     *needStackRestore = true;
                 }
                 ai->setAlignment(16);
-                builder.CreateMemCpy(ai, data_pointer(jvinfo, ctx, T_pint8), nbytes, sizeof(void*)); // minimum gc-alignment in julia is pointer size
-                return emit_bitcast(ai, to);
+                ctx.builder.CreateMemCpy(ai, data_pointer(ctx, jvinfo, T_pint8), nbytes, sizeof(void*)); // minimum gc-alignment in julia is pointer size
+                return emit_bitcast(ctx, ai, to);
             }
         }
         // emit maybe copy
         *needStackRestore = true;
-        Value *jvt = emit_typeof_boxed(jvinfo, ctx);
-        BasicBlock *mutableBB = BasicBlock::Create(jl_LLVMContext, "is-mutable", ctx->f);
-        BasicBlock *immutableBB = BasicBlock::Create(jl_LLVMContext, "is-immutable", ctx->f);
-        BasicBlock *afterBB = BasicBlock::Create(jl_LLVMContext, "after", ctx->f);
-        Value *ismutable = emit_datatype_mutabl(jvt);
-        builder.CreateCondBr(ismutable, mutableBB, immutableBB);
-        builder.SetInsertPoint(mutableBB);
-        Value *p1 = data_pointer(jvinfo, ctx, to);
-        builder.CreateBr(afterBB);
-        builder.SetInsertPoint(immutableBB);
-        Value *nbytes = emit_datatype_size(jvt);
-        AllocaInst *ai = builder.CreateAlloca(T_int8, nbytes);
+        Value *jvt = emit_typeof_boxed(ctx, jvinfo);
+        BasicBlock *mutableBB = BasicBlock::Create(jl_LLVMContext, "is-mutable", ctx.f);
+        BasicBlock *immutableBB = BasicBlock::Create(jl_LLVMContext, "is-immutable", ctx.f);
+        BasicBlock *afterBB = BasicBlock::Create(jl_LLVMContext, "after", ctx.f);
+        Value *ismutable = emit_datatype_mutabl(ctx, jvt);
+        ctx.builder.CreateCondBr(ismutable, mutableBB, immutableBB);
+        ctx.builder.SetInsertPoint(mutableBB);
+        Value *p1 = data_pointer(ctx, jvinfo, to);
+        ctx.builder.CreateBr(afterBB);
+        ctx.builder.SetInsertPoint(immutableBB);
+        Value *nbytes = emit_datatype_size(ctx, jvt);
+        AllocaInst *ai = ctx.builder.CreateAlloca(T_int8, nbytes);
         ai->setAlignment(16);
-        builder.CreateMemCpy(ai, data_pointer(jvinfo, ctx, T_pint8), nbytes, sizeof(void*)); // minimum gc-alignment in julia is pointer size
-        Value *p2 = emit_bitcast(ai, to);
-        builder.CreateBr(afterBB);
-        builder.SetInsertPoint(afterBB);
-        PHINode *p = builder.CreatePHI(to, 2);
+        ctx.builder.CreateMemCpy(ai, data_pointer(ctx, jvinfo, T_pint8), nbytes, sizeof(void*)); // minimum gc-alignment in julia is pointer size
+        Value *p2 = emit_bitcast(ctx, ai, to);
+        ctx.builder.CreateBr(afterBB);
+        ctx.builder.SetInsertPoint(afterBB);
+        PHINode *p = ctx.builder.CreatePHI(to, 2);
         p->addIncoming(p1, mutableBB);
         p->addIncoming(p2, immutableBB);
         return p;
@@ -592,19 +601,18 @@ static Value *julia_to_address(Type *to, jl_value_t *jlto, jl_unionall_t *jlto_e
     Type *slottype = julia_struct_to_llvm(jvinfo.typ, NULL, NULL);
     // pass the address of an alloca'd thing, not a box
     // since those are immutable.
-    Value *slot = emit_static_alloca(slottype, ctx);
+    Value *slot = emit_static_alloca(ctx, slottype);
     if (!jvinfo.ispointer()) {
-        builder.CreateStore(emit_unbox(slottype, jvinfo, ety), slot);
+        ctx.builder.CreateStore(emit_unbox(ctx, slottype, jvinfo, ety), slot);
     }
     else {
-        builder.CreateMemCpy(slot,
-                             data_pointer(jvinfo, ctx, slot->getType()),
+        ctx.builder.CreateMemCpy(slot,
+                             data_pointer(ctx, jvinfo, slot->getType()),
                              (uint64_t)jl_datatype_size(ety),
-                             (uint64_t)((jl_datatype_t*)ety)->layout->alignment);
-        mark_gc_use(jvinfo);
+                             (uint64_t)jl_datatype_align(ety));
     }
     if (slot->getType() != to)
-        slot = emit_bitcast(slot, to);
+        slot = emit_bitcast(ctx, slot, to);
     return slot;
 }
 
@@ -613,34 +621,35 @@ static Value *julia_to_address(Type *to, jl_value_t *jlto, jl_unionall_t *jlto_e
 // to = desired LLVM type
 // jlto = Julia type of formal argument
 // jvinfo = value of actual argument
-static Value *julia_to_native(Type *to, bool toboxed, jl_value_t *jlto, jl_unionall_t *jlto_env,
-                              const jl_cgval_t &jvinfo,
-                              bool byRef, int argn, jl_codectx_t *ctx,
-                              bool *needStackRestore)
+static Value *julia_to_native(
+        jl_codectx_t &ctx,
+        Type *to, bool toboxed, jl_value_t *jlto, jl_unionall_t *jlto_env,
+        const jl_cgval_t &jvinfo,
+        bool byRef, int argn,
+        bool *needStackRestore)
 {
     // We're passing Any
     if (toboxed) {
         assert(!byRef); // don't expect any ABI to pass pointers by pointer
-        return boxed(jvinfo, ctx);
+        return maybe_decay_untracked(boxed(ctx, jvinfo));
     }
     assert(jl_is_datatype(jlto) && julia_struct_has_layout((jl_datatype_t*)jlto, jlto_env));
 
-    typeassert_input(jvinfo, jlto, jlto_env, argn, false, ctx);
+    typeassert_input(ctx, jvinfo, jlto, jlto_env, argn, false);
     if (!byRef)
-        return emit_unbox(to, jvinfo, jlto);
+        return emit_unbox(ctx, to, jvinfo, jlto);
 
     // pass the address of an alloca'd thing, not a box
     // since those are immutable.
-    Value *slot = emit_static_alloca(to, ctx);
+    Value *slot = emit_static_alloca(ctx, to);
     if (!jvinfo.ispointer()) {
-        builder.CreateStore(emit_unbox(to, jvinfo, jlto), slot);
+        ctx.builder.CreateStore(emit_unbox(ctx, to, jvinfo, jlto), slot);
     }
     else {
-        builder.CreateMemCpy(slot,
-                             data_pointer(jvinfo, ctx, slot->getType()),
+        ctx.builder.CreateMemCpy(slot,
+                             data_pointer(ctx, jvinfo, slot->getType()),
                              (uint64_t)jl_datatype_size(jlto),
-                             (uint64_t)((jl_datatype_t*)jlto)->layout->alignment);
-        mark_gc_use(jvinfo);
+                             (uint64_t)jl_datatype_align(jlto));
     }
     return slot;
 }
@@ -654,26 +663,25 @@ typedef struct {
 } native_sym_arg_t;
 
 // --- parse :sym or (:sym, :lib) argument into address info ---
-static void interpret_symbol_arg(native_sym_arg_t &out, jl_value_t *arg, jl_codectx_t *ctx, const char *fname, bool llvmcall)
+static void interpret_symbol_arg(jl_codectx_t &ctx, native_sym_arg_t &out, jl_value_t *arg, const char *fname, bool llvmcall)
 {
     Value *&jl_ptr = out.jl_ptr;
     void (*&fptr)(void) = out.fptr;
     const char *&f_name = out.f_name;
     const char *&f_lib = out.f_lib;
 
-    jl_value_t *ptr = static_eval(arg, ctx, true);
+    jl_value_t *ptr = static_eval(ctx, arg, true);
     if (ptr == NULL) {
-        jl_value_t *ptr_ty = expr_type(arg, ctx);
-        jl_cgval_t arg1 = emit_expr(arg, ctx);
+        jl_cgval_t arg1 = emit_expr(ctx, arg);
+        jl_value_t *ptr_ty = arg1.typ;
         if (!jl_is_cpointer_type(ptr_ty)) {
-            emit_cpointercheck(arg1,
-                               !strcmp(fname,"ccall") ?
-                               "ccall: first argument not a pointer or valid constant expression" :
-                               "cglobal: first argument not a pointer or valid constant expression",
-                               ctx);
+           const char *errmsg = !strcmp(fname, "ccall") ?
+               "ccall: first argument not a pointer or valid constant expression" :
+               "cglobal: first argument not a pointer or valid constant expression";
+            emit_cpointercheck(ctx, arg1, errmsg);
         }
-        arg1 = remark_julia_type(arg1, (jl_value_t*)jl_voidpointer_type, ctx);
-        jl_ptr = emit_unbox(T_size, arg1, (jl_value_t*)jl_voidpointer_type);
+        arg1 = update_julia_type(ctx, arg1, (jl_value_t*)jl_voidpointer_type);
+        jl_ptr = emit_unbox(ctx, T_size, arg1, (jl_value_t*)jl_voidpointer_type);
     }
     else {
         out.gcroot = ptr;
@@ -721,23 +729,23 @@ static void interpret_symbol_arg(native_sym_arg_t &out, jl_value_t *arg, jl_code
 }
 
 
-static jl_value_t* try_eval(jl_value_t *ex, jl_codectx_t *ctx, const char *failure, bool compiletime=false)
+static jl_value_t* try_eval(jl_codectx_t &ctx, jl_value_t *ex, const char *failure, bool compiletime=false)
 {
     jl_value_t *constant = NULL;
-    constant = static_eval(ex, ctx, true, true);
+    constant = static_eval(ctx, ex, true, true);
     if (constant || jl_is_ssavalue(ex))
         return constant;
     JL_TRY {
         size_t last_age = jl_get_ptls_states()->world_age;
-        jl_get_ptls_states()->world_age = ctx->world;
-        constant = jl_interpret_toplevel_expr_in(ctx->module, ex, ctx->source, ctx->linfo->sparam_vals);
+        jl_get_ptls_states()->world_age = ctx.world;
+        constant = jl_interpret_toplevel_expr_in(ctx.module, ex, ctx.source, ctx.linfo->sparam_vals);
         jl_get_ptls_states()->world_age = last_age;
     }
     JL_CATCH {
         if (compiletime)
             jl_rethrow_with_add(failure);
         if (failure)
-            emit_error(failure, ctx);
+            emit_error(ctx, failure);
         constant = NULL;
     }
     return constant;
@@ -745,9 +753,9 @@ static jl_value_t* try_eval(jl_value_t *ex, jl_codectx_t *ctx, const char *failu
 
 // --- code generator for cglobal ---
 
-static jl_cgval_t emit_runtime_call(JL_I::intrinsic f, const jl_cgval_t *argv, size_t nargs, jl_codectx_t *ctx);
+static jl_cgval_t emit_runtime_call(jl_codectx_t &ctx, JL_I::intrinsic f, const jl_cgval_t *argv, size_t nargs);
 
-static jl_cgval_t emit_cglobal(jl_value_t **args, size_t nargs, jl_codectx_t *ctx)
+static jl_cgval_t emit_cglobal(jl_codectx_t &ctx, jl_value_t **args, size_t nargs)
 {
     JL_NARGS(cglobal, 1, 2);
     jl_value_t *rt = NULL;
@@ -756,13 +764,13 @@ static jl_cgval_t emit_cglobal(jl_value_t **args, size_t nargs, jl_codectx_t *ct
     JL_GC_PUSH2(&rt, &sym.gcroot);
 
     if (nargs == 2) {
-        rt = static_eval(args[2], ctx, true, true);
+        rt = static_eval(ctx, args[2], true, true);
         if (rt == NULL) {
             JL_GC_POP();
             jl_cgval_t argv[2];
-            argv[0] = emit_expr(args[0], ctx);
-            argv[1] = emit_expr(args[1], ctx);
-            return emit_runtime_call(JL_I::cglobal, argv, nargs, ctx);
+            argv[0] = emit_expr(ctx, args[1]);
+            argv[1] = emit_expr(ctx, args[2]);
+            return emit_runtime_call(ctx, JL_I::cglobal, argv, nargs);
         }
 
         JL_TYPECHK(cglobal, type, rt);
@@ -775,19 +783,19 @@ static jl_cgval_t emit_cglobal(jl_value_t **args, size_t nargs, jl_codectx_t *ct
     if (lrt == NULL)
         lrt = T_pint8;
 
-    interpret_symbol_arg(sym, args[1], ctx, "cglobal", false);
+    interpret_symbol_arg(ctx, sym, args[1], "cglobal", false);
 
     if (sym.jl_ptr != NULL) {
-        res = builder.CreateIntToPtr(sym.jl_ptr, lrt);
+        res = ctx.builder.CreateIntToPtr(sym.jl_ptr, lrt);
     }
     else if (sym.fptr != NULL) {
-        res = literal_static_pointer_val((void*)(uintptr_t)sym.fptr, lrt);
+        res = literal_static_pointer_val(ctx, (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);
     }
     else {
         if (imaging_mode) {
-            res = runtime_sym_lookup((PointerType*)lrt, sym.f_lib, sym.f_name, ctx->f);
+            res = runtime_sym_lookup(ctx, (PointerType*)lrt, sym.f_lib, sym.f_name, ctx.f);
         }
         else {
             void *symaddr = jl_dlsym_e(jl_get_library(sym.f_lib), sym.f_name);
@@ -797,24 +805,23 @@ static jl_cgval_t emit_cglobal(jl_value_t **args, size_t nargs, jl_codectx_t *ct
                 msg << sym.f_name;
                 if (sym.f_lib != NULL) {
 #ifdef _OS_WINDOWS_
-                    assert((intptr_t)sym.f_lib != 1 && (intptr_t)sym.f_lib != 2);
+                    assert(sym.f_lib != JL_EXE_LIBNAME && sym.f_lib != JL_DL_LIBNAME);
 #endif
                     msg << " in library ";
                     msg << sym.f_lib;
                 }
-                emit_error(msg.str(), ctx);
+                emit_error(ctx, msg.str());
             }
             // since we aren't saving this code, there's no sense in
             // putting anything complicated here: just JIT the address of the cglobal
-            res = literal_static_pointer_val(symaddr, lrt);
+            res = literal_static_pointer_val(ctx, symaddr, lrt);
         }
     }
 
     JL_GC_POP();
-    return mark_julia_type(res, false, rt, ctx);
+    return mark_julia_type(ctx, res, false, rt);
 }
 
-#ifdef USE_MCJIT
 class FunctionMover final : public ValueMaterializer
 {
 public:
@@ -851,11 +858,6 @@ class FunctionMover final : public ValueMaterializer
             VMap[&*I] = &*(DestI++);        // Add mapping to VMap
         }
 
-    #if JL_LLVM_VERSION >= 30600
-        // Clone debug info - Not yet public API
-        // llvm::CloneDebugInfoMetadata(NewF,F,VMap);
-    #endif
-
         SmallVector<ReturnInst*, 8> Returns;
         llvm::CloneFunctionInto(NewF,F,VMap,true,Returns,"",NULL,NULL,this);
         NewF->setComdat(nullptr);
@@ -890,13 +892,7 @@ class FunctionMover final : public ValueMaterializer
         return NewF;
     }
 
-#if JL_LLVM_VERSION >= 30900
     Value *materialize(Value *V) override
-#elif JL_LLVM_VERSION >= 30800
-    Value *materializeDeclFor(Value *V) override
-#else
-    Value *materializeValueFor (Value *V) override
-#endif
     {
         Function *F = dyn_cast<Function>(V);
         if (F) {
@@ -911,12 +907,8 @@ class FunctionMover final : public ValueMaterializer
                     Function *oldF = destModule->getFunction(F->getName());
                     if (oldF)
                         return oldF;
-
-                    #ifdef USE_ORCJIT
                     if (jl_ExecutionEngine->findSymbol(F->getName(), false))
                         return InjectFunctionProto(F);
-                    #endif
-
                     return CloneFunctionProto(shadow);
                 }
                 else if (!F->isDeclaration()) {
@@ -964,18 +956,16 @@ class FunctionMover final : public ValueMaterializer
         return NULL;
     };
 };
-#endif
 
 // llvmcall(ir, (rettypes...), (argtypes...), args...)
-static jl_cgval_t emit_llvmcall(jl_value_t **args, size_t nargs, jl_codectx_t *ctx)
+static jl_cgval_t emit_llvmcall(jl_codectx_t &ctx, jl_value_t **args, size_t nargs)
 {
     JL_NARGSV(llvmcall, 3);
     jl_value_t *rt = NULL, *at = NULL, *ir = NULL, *decl = NULL;
-    jl_svec_t *stt = NULL;
-    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);
+    JL_GC_PUSH4(&ir, &rt, &at, &decl);
+    at = try_eval(ctx, args[3], "error statically evaluating llvmcall argument tuple", true);
+    rt = try_eval(ctx, args[2], "error statically evaluating llvmcall return type", true);
+    ir = try_eval(ctx, args[1], "error statically evaluating llvm IR argument", true);
     int i = 1;
     if (jl_is_tuple(ir)) {
         // if the IR is a tuple, we expect (declarations, ir)
@@ -997,43 +987,34 @@ static jl_cgval_t emit_llvmcall(jl_value_t **args, size_t nargs, jl_codectx_t *c
 
     std::stringstream ir_stream;
 
-    stt = jl_alloc_svec(nargs - 3);
-
-    for (size_t i = 0; i < nargs - 3; ++i) {
-        jl_svecset(stt, i, expr_type(args[4 + i], ctx));
-    }
-
     // Generate arguments
     std::string arguments;
     llvm::raw_string_ostream argstream(arguments);
     jl_svec_t *tt = ((jl_datatype_t*)at)->parameters;
     jl_value_t *rtt = rt;
-
     size_t nargt = jl_svec_len(tt);
-    Value **argvals = (Value**) alloca(nargt*sizeof(Value*));
-    std::vector<llvm::Type*> argtypes;
+
     /*
      * Semantics for arguments are as follows:
      * 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);
+    std::vector<llvm::Type*> argtypes;
+    Value **argvals = (Value**)alloca(nargt * sizeof(Value*));
     for (size_t i = 0; i < nargt; ++i) {
         jl_value_t *tti = jl_svecref(tt,i);
         bool toboxed;
         Type *t = julia_type_to_llvm(tti, &toboxed);
         argtypes.push_back(t);
-        if (4+i > nargs) {
+        if (4 + i > nargs) {
             jl_error("Missing arguments to llvmcall!");
         }
         jl_value_t *argi = args[4 + i];
-        jl_cgval_t &arg = argv[i];
-        arg = emit_expr(argi, ctx);
+        jl_cgval_t arg = emit_expr(ctx, argi);
 
-        Value *v = julia_to_native(t, toboxed, tti, NULL, arg, false, i, ctx, NULL);
+        Value *v = julia_to_native(ctx, t, toboxed, tti, NULL, arg, false, i, NULL);
         bool issigned = jl_signed_type && jl_subtype(tti, (jl_value_t*)jl_signed_type);
-        // make sure args are rooted
-        argvals[i] = llvm_type_rewrite(v, t, issigned, ctx);
+        argvals[i] = llvm_type_rewrite(ctx, v, t, issigned);
     }
 
     Function *f;
@@ -1044,7 +1025,7 @@ static jl_cgval_t emit_llvmcall(jl_value_t **args, size_t nargs, jl_codectx_t *c
         std::string ir_name;
         while(true) {
             std::stringstream name;
-            name << (ctx->f->getName().str()) << "u" << i++;
+            name << (ctx.f->getName().str()) << "u" << i++;
             ir_name = name.str();
             if (jl_Module->getFunction(ir_name) == NULL)
                 break;
@@ -1089,14 +1070,10 @@ static jl_cgval_t emit_llvmcall(jl_value_t **args, size_t nargs, jl_codectx_t *c
         << jl_string_data(ir) << "\n}";
         SMDiagnostic Err = SMDiagnostic();
         std::string ir_string = ir_stream.str();
-#if JL_LLVM_VERSION >= 30600
         Module *m = NULL;
         bool failed = parseAssemblyInto(llvm::MemoryBufferRef(ir_string,"llvmcall"),*jl_Module,Err);
         if (!failed)
             m = jl_Module;
-#else
-        Module *m = ParseAssemblyString(ir_string.c_str(),jl_Module,Err,jl_LLVMContext);
-#endif
         if (m == NULL) {
             std::string message = "Failed to parse LLVM Assembly: \n";
             llvm::raw_string_ostream stream(message);
@@ -1116,20 +1093,14 @@ static jl_cgval_t emit_llvmcall(jl_value_t **args, size_t nargs, jl_codectx_t *c
             it != argtypes.end(); ++it, ++i)
             assert(*it == f->getFunctionType()->getParamType(i));
 
-#ifdef USE_MCJIT
         if (f->getParent() != jl_Module) {
             FunctionMover mover(jl_Module, f->getParent());
             f = mover.CloneFunction(f);
         }
-#endif
 
         //f->dump();
-#if JL_LLVM_VERSION < 30500
-        if (verifyFunction(*f,PrintMessageAction)) {
-#else
         llvm::raw_fd_ostream out(1,false);
         if (verifyFunction(*f,&out)) {
-#endif
 #if JL_LLVM_VERSION >= 50000
             f->print(llvm::dbgs(), nullptr, false, true);
 #else
@@ -1155,22 +1126,9 @@ static jl_cgval_t emit_llvmcall(jl_value_t **args, size_t nargs, jl_codectx_t *c
         f->setLinkage(GlobalValue::LinkOnceODRLinkage);
     }
 
-    // the actual call
-    builder.CreateCall(prepare_call(gcroot_flush_func));
-    SmallVector<Value*, 16> gc_uses;
-    for (size_t i = 0; i < nargt; ++i) {
-        const jl_cgval_t &arg = argv[i];
-        push_gc_use(gc_uses, arg);
-    }
-    // Mark GC use before **and** after the llvmcall to make sure the arguments
-    // are alive during the llvmcall even if the llvmcall has `unreachable`.
-    // If the llvmcall generates GC safepoint, it might need to emit its own
-    // gckill.
-    mark_gc_uses(gc_uses);
-    CallInst *inst = builder.CreateCall(f, ArrayRef<Value*>(&argvals[0], nargt));
+    CallInst *inst = ctx.builder.CreateCall(f, ArrayRef<Value*>(&argvals[0], nargt));
     if (isString)
         f->addFnAttr(Attribute::AlwaysInline);
-    mark_gc_uses(gc_uses);
 
     JL_GC_POP();
 
@@ -1178,30 +1136,30 @@ 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(inst, retboxed, rtt, ctx);
+    return mark_julia_type(ctx, inst, retboxed, rtt);
 }
 
 // --- code generator for ccall itself ---
 
-static jl_cgval_t mark_or_box_ccall_result(Value *result, bool isboxed, jl_value_t *rt, jl_unionall_t *unionall, bool static_rt, jl_codectx_t *ctx)
+static jl_cgval_t mark_or_box_ccall_result(jl_codectx_t &ctx, Value *result, bool isboxed, jl_value_t *rt, jl_unionall_t *unionall, bool static_rt)
 {
     if (!static_rt) {
-        assert(!isboxed && ctx->spvals_ptr && unionall && jl_is_datatype(rt));
-        Value *runtime_dt = runtime_apply_type(rt, unionall, ctx);
+        assert(!isboxed && ctx.spvals_ptr && unionall && jl_is_datatype(rt));
+        Value *runtime_dt = runtime_apply_type(ctx, rt, unionall);
         // TODO: is this concrete check actually necessary, or is it structurally guaranteed?
-        emit_concrete_check(runtime_dt, "ccall: return type must be a concrete DataType", ctx);
-#if JL_LLVM_VERSION >= 30600
-        const DataLayout &DL = jl_ExecutionEngine->getDataLayout();
+        emit_concrete_check(ctx, runtime_dt, "ccall: return type must be a concrete DataType");
+#if JL_LLVM_VERSION >= 40000
+        const DataLayout &DL = jl_data_layout;
 #else
-        const DataLayout &DL = *jl_ExecutionEngine->getDataLayout();
+        const DataLayout &DL = jl_ExecutionEngine->getDataLayout();
 #endif
         unsigned nb = DL.getTypeStoreSize(result->getType());
         MDNode *tbaa = jl_is_mutable(rt) ? tbaa_mutab : tbaa_immut;
         Value *strct = emit_allocobj(ctx, nb, runtime_dt);
-        init_bits_value(strct, result, tbaa);
-        return mark_julia_type(strct, true, rt, ctx);
+        init_bits_value(ctx, strct, result, tbaa);
+        return mark_julia_type(ctx, strct, true, rt);
     }
-    return mark_julia_type(result, isboxed, rt, ctx);
+    return mark_julia_type(ctx, result, isboxed, rt);
 }
 
 class function_sig_t {
@@ -1211,7 +1169,11 @@ class function_sig_t {
     std::vector<bool> fargt_isboxed; // vector of whether the llvm output type is a Julia-box for each argument (vararg is the last item, if applicable)
     Type *fargt_vasig = NULL; // ABI coercion type for vararg list
     std::vector<bool> byRefList; // vector of "byref" parameters (vararg is the last item, if applicable)
+#if JL_LLVM_VERSION >= 50000
+    AttributeList attributes; // vector of function call site attributes (vararg is the last item, if applicable)
+#else
     AttributeSet attributes; // vector of function call site attributes (vararg is the last item, if applicable)
+#endif
     Type *lrt; // input parameter of the llvm return type (from julia_struct_to_llvm)
     bool retboxed; // input parameter indicating whether lrt is jl_value_t*
     Type *prt; // out parameter of the llvm return type for the function signature
@@ -1238,13 +1200,13 @@ class function_sig_t {
     }
 
     jl_cgval_t emit_a_ccall(
+            jl_codectx_t &ctx,
             const native_sym_arg_t &symarg,
             size_t nargt,
             std::vector<bool> &addressOf,
             jl_cgval_t *argv,
             SmallVector<Value*, 16> &gc_uses,
-            bool static_rt,
-            jl_codectx_t *ctx);
+            bool static_rt);
 
 private:
 std::string generate_func_sig()
@@ -1252,7 +1214,11 @@ std::string generate_func_sig()
     size_t nargt = jl_svec_len(at);
     assert(rt && !jl_is_abstract_ref_type(rt));
 
+#if JL_LLVM_VERSION >= 50000
+    std::vector<AttrBuilder> paramattrs;
+#else
     std::vector<AttributeSet> paramattrs;
+#endif
     std::unique_ptr<AbiLayout> abi;
     if (llvmcall)
         abi.reset(new ABI_LLVMLayout());
@@ -1271,12 +1237,16 @@ std::string generate_func_sig()
         }
         else if (abi->use_sret((jl_datatype_t*)rt)) {
             AttrBuilder retattrs = AttrBuilder();
-#if !defined(_OS_WINDOWS_) || JL_LLVM_VERSION >= 30500 // llvm used to use the old mingw ABI, skipping this marking works around that difference
+#if !defined(_OS_WINDOWS_) // llvm used to use the old mingw ABI, skipping this marking works around that difference
             retattrs.addAttribute(Attribute::StructRet);
 #endif
             retattrs.addAttribute(Attribute::NoAlias);
+#if JL_LLVM_VERSION >= 50000
+            paramattrs.push_back(std::move(retattrs));
+#else
             paramattrs.push_back(AttributeSet::get(jl_LLVMContext, 1, retattrs));
-            fargt_sig.push_back(PointerType::get(lrt, 0));
+#endif
+            fargt_sig.push_back(PointerType::get(lrt, AddressSpace::Derived));
             sret = 1;
             prt = lrt;
         }
@@ -1319,6 +1289,8 @@ std::string generate_func_sig()
             }
 
             t = julia_struct_to_llvm(tti, unionall_env, &isboxed);
+            if (isboxed)
+                t = T_prjlvalue;
             if (t == NULL || t == T_void) {
                 std::stringstream msg;
                 msg << "ccall: the type of argument ";
@@ -1339,7 +1311,7 @@ std::string generate_func_sig()
             pat = t;
         }
         else if (byRef) {
-            pat = PointerType::get(t, 0);
+            pat = PointerType::get(t, AddressSpace::Derived);
         }
         else {
             pat = abi->preferred_llvm_type((jl_datatype_t*)tti, false);
@@ -1357,21 +1329,35 @@ std::string generate_func_sig()
 
         do { // for each arg for which this type applies, add the appropriate LLVM parameter attributes
             if (i < nargs) { // if vararg, the last declared arg type may not have a corresponding arg value
+#if JL_LLVM_VERSION >= 50000
+                paramattrs.push_back(std::move(ab));
+#else
                 AttributeSet params = AttributeSet::get(jl_LLVMContext, i + sret + 1, ab);
                 paramattrs.push_back(params);
+#endif
             }
             i++;
         } while (current_isVa && i < nargs); // if is this is the vararg, loop to the end
     }
 
     for (i = 0; i < nargs + sret; ++i) {
-        const AttributeSet &as = paramattrs.at(i);
-        if (!as.isEmpty())
-            attributes = attributes.addAttributes(jl_LLVMContext, i + 1, as);
+        const auto &as = paramattrs.at(i);
+#if JL_LLVM_VERSION >= 50000
+        if (!as.hasAttributes())
+            continue;
+#else
+        if (as.isEmpty())
+            continue;
+#endif
+        attributes = attributes.addAttributes(jl_LLVMContext, i + 1, as);
     }
     if (rt == jl_bottom_type) {
         attributes = attributes.addAttribute(jl_LLVMContext,
+#if JL_LLVM_VERSION >= 50000
+                                             AttributeList::FunctionIndex,
+#else
                                              AttributeSet::FunctionIndex,
+#endif
                                              Attribute::NoReturn);
     }
     return "";
@@ -1384,7 +1370,10 @@ static std::pair<CallingConv::ID, bool> convert_cconv(jl_sym_t *lhd)
     if (lhd == jl_symbol("stdcall")) {
         return std::make_pair(CallingConv::X86_StdCall, false);
     }
-    else if (lhd == jl_symbol("cdecl")) {
+    else if (lhd == jl_symbol("cdecl") || lhd == jl_symbol("ccall")) {
+        // `ccall` calling convention is a placeholder for when there isn't one provided
+        // it is not by itself a valid calling convention name to be specified in the surface
+        // syntax.
         return std::make_pair(CallingConv::C, false);
     }
     else if (lhd == jl_symbol("fastcall")) {
@@ -1399,7 +1388,7 @@ static std::pair<CallingConv::ID, bool> convert_cconv(jl_sym_t *lhd)
     jl_errorf("ccall: invalid calling convention %s", jl_symbol_name(lhd));
 }
 
-static const std::string verify_ccall_sig(size_t nargs, jl_value_t *&rt, jl_value_t *at,
+static const std::string verify_ccall_sig(size_t nccallargs, jl_value_t *&rt, jl_value_t *at,
                                           jl_unionall_t *unionall_env, jl_svec_t *sparam_vals, const char *funcName,
                                           size_t &nargt, bool &isVa, Type *&lrt, bool &retboxed, bool &static_rt)
 {
@@ -1415,6 +1404,8 @@ static const std::string verify_ccall_sig(size_t nargs, jl_value_t *&rt, jl_valu
     lrt = julia_struct_to_llvm(rt, unionall_env, &retboxed);
     if (lrt == NULL)
         return "ccall: return type doesn't correspond to a C type";
+    else if (retboxed)
+        lrt = T_prjlvalue;
 
     // is return type fully statically known?
     if (unionall_env == NULL) {
@@ -1422,7 +1413,7 @@ static const std::string verify_ccall_sig(size_t nargs, jl_value_t *&rt, jl_valu
     }
     else {
         static_rt = retboxed || !jl_has_typevar_from_unionall(rt, unionall_env);
-        if (!static_rt && sparam_vals != NULL) {
+        if (!static_rt && sparam_vals != NULL && jl_svec_len(sparam_vals) > 0) {
             rt = jl_instantiate_type_in_env(rt, unionall_env, jl_svec_data(sparam_vals));
             // `rt` is gc-rooted by the caller
             static_rt = true;
@@ -1440,46 +1431,50 @@ static const std::string verify_ccall_sig(size_t nargs, jl_value_t *&rt, jl_valu
 
     nargt = jl_svec_len(at);
     isVa = (nargt > 0 && jl_is_vararg_type(jl_svecref(at, nargt - 1)));
-    if ((!isVa && nargt    != (nargs - 2) / 2) ||
-        ( isVa && nargt - 1 > (nargs - 2) / 2))
+    if ((!isVa && nargt    != nccallargs) ||
+        ( isVa && nargt - 1 > nccallargs))
         return "ccall: wrong number of arguments to C function";
 
     return "";
 }
 
 // Expr(:foreigncall, pointer, rettype, (argtypes...), args...)
-static jl_cgval_t emit_ccall(jl_value_t **args, size_t nargs, jl_codectx_t *ctx)
+static jl_cgval_t emit_ccall(jl_codectx_t &ctx, jl_value_t **args, size_t nargs)
 {
-    JL_NARGSV(ccall, 3);
+    JL_NARGSV(ccall, 5);
     args -= 1;
     jl_value_t *rt = args[2];
     jl_value_t *at = args[3];
+    assert(jl_is_quotenode(args[4]));
+    jl_sym_t *cc_sym = *(jl_sym_t**)args[4];
+    size_t nccallargs = jl_unbox_long(args[5]);
+    assert(jl_is_symbol(cc_sym));
     native_sym_arg_t symarg = {};
     JL_GC_PUSH3(&rt, &at, &symarg.gcroot);
 
     CallingConv::ID cc = CallingConv::C;
     bool llvmcall = false;
-    if (nargs % 2 == 0) {
-        jl_value_t *last = args[nargs];
-        JL_TYPECHK(ccall, expr, last);
-        std::tie(cc, llvmcall) = convert_cconv(((jl_expr_t*)last)->head);
-        nargs -= 1;
-    }
+    std::tie(cc, llvmcall) = convert_cconv(cc_sym);
 
-    interpret_symbol_arg(symarg, args[1], ctx, "ccall", llvmcall);
+    interpret_symbol_arg(ctx, symarg, args[1], "ccall", llvmcall);
     Value *&jl_ptr = symarg.jl_ptr;
     void (*&fptr)(void) = symarg.fptr;
     const char *&f_name = symarg.f_name;
     const char *&f_lib = symarg.f_lib;
 
     if (f_name == NULL && fptr == NULL && jl_ptr == NULL) {
-        emit_error("ccall: null function pointer", ctx);
+        emit_error(ctx, "ccall: null function pointer");
         JL_GC_POP();
         return jl_cgval_t();
     }
 
-    jl_unionall_t *unionall = (ctx->linfo->def && jl_is_unionall(ctx->linfo->def->sig))
-        ? (jl_unionall_t*)ctx->linfo->def->sig
+    auto ccallarg = [=] (size_t i) {
+        assert(i < nccallargs);
+        return args[6 + i];
+    };
+
+    jl_unionall_t *unionall = (jl_is_method(ctx.linfo->def.method) && jl_is_unionall(ctx.linfo->def.method->sig))
+        ? (jl_unionall_t*)ctx.linfo->def.method->sig
         : NULL;
 
     if (jl_is_abstract_ref_type(rt)) {
@@ -1496,16 +1491,16 @@ static jl_cgval_t emit_ccall(jl_value_t **args, size_t nargs, jl_codectx_t *ctx)
                 jl_unionall_t *ua = unionall;
                 for (i = 0; jl_is_unionall(ua); i++) {
                     if (ua->var == (jl_tvar_t*)ref) {
-                        jl_cgval_t runtime_sp = emit_sparam(i, ctx);
+                        jl_cgval_t runtime_sp = emit_sparam(ctx, i);
                         if (runtime_sp.constant) {
                             if (runtime_sp.constant != (jl_value_t*)jl_any_type)
                                 always_error = false;
                         }
                         else {
-                            Value *notany = builder.CreateICmpNE(
-                                    boxed(runtime_sp, ctx, false),
-                                    literal_pointer_val((jl_value_t*)jl_any_type));
-                            error_unless(notany, "ccall: return type Ref{Any} is invalid. use Ptr{Any} instead.", ctx);
+                            Value *notany = ctx.builder.CreateICmpNE(
+                                    boxed(ctx, runtime_sp, false),
+                                    literal_pointer_val(ctx, (jl_value_t*)jl_any_type));
+                            error_unless(ctx, notany, "ccall: return type Ref{Any} is invalid. use Ptr{Any} instead.");
                             always_error = false;
                         }
                         break;
@@ -1514,13 +1509,19 @@ static jl_cgval_t emit_ccall(jl_value_t **args, size_t nargs, jl_codectx_t *ctx)
             }
         }
         if (always_error) {
-            emit_error("ccall: return type Ref{Any} is invalid. use Ptr{Any} instead.", ctx);
+            emit_error(ctx, "ccall: return type Ref{Any} is invalid. use Ptr{Any} instead.");
             JL_GC_POP();
             return jl_cgval_t();
         }
         rt = (jl_value_t*)jl_any_type; // convert return type to jl_value_t*
     }
 
+    // check if we require the runtime
+    // TODO: could be more fine-grained,
+    //       respecting special functions below that don't require the runtime
+    if (!llvmcall && (!f_lib || f_lib == JL_DL_LIBNAME))
+        JL_FEAT_REQUIRE(ctx, runtime);
+
     // some sanity checking and check whether there's a vararg
     bool isVa;
     size_t nargt;
@@ -1529,196 +1530,262 @@ static jl_cgval_t emit_ccall(jl_value_t **args, size_t nargs, jl_codectx_t *ctx)
     bool static_rt;
     std::string err = verify_ccall_sig(
             /* inputs:  */
-            nargs, rt, at, unionall,
-            ctx->spvals_ptr == NULL ? ctx->linfo->sparam_vals : NULL,
-            ctx->funcName.c_str(),
+            nccallargs, rt, at, unionall,
+            ctx.spvals_ptr == NULL ? ctx.linfo->sparam_vals : NULL,
+            ctx.funcName.c_str(),
             /* outputs: */
             nargt, isVa, lrt, retboxed, static_rt);
     if (!err.empty()) {
-        emit_error(err, ctx);
+        emit_error(ctx, err);
         JL_GC_POP();
         return jl_cgval_t();
     }
     if (rt != args[2] && rt != (jl_value_t*)jl_any_type)
         jl_add_method_root(ctx, rt);
 
+    auto _is_libjulia_func = [&] (uintptr_t ptr, const char *name) {
+        if ((uintptr_t)fptr == ptr)
+            return true;
+        return (!f_lib || f_lib == JL_DL_LIBNAME) && f_name && !strcmp(f_name, name);
+    };
+#define is_libjulia_func(name) _is_libjulia_func((uintptr_t)&(name), #name)
+
+#ifdef _OS_LINUX_
+    // directly accessing the address of an ifunc can cause linker issue on
+    // some configurations (e.g. AArch64 + -Bsymbolic-functions).
+    static const auto ptls_getter = jl_dlsym_e(jl_dlopen(nullptr, 0),
+                                               "jl_get_ptls_states");
+#else
+    static const auto ptls_getter = &jl_get_ptls_states;
+#endif
+
+    // emit arguments
+    jl_cgval_t *argv = (jl_cgval_t*)alloca(sizeof(jl_cgval_t) * nccallargs);
+    std::vector<bool> addressOf(0);
+    for (size_t i = 0; i < nccallargs; i++) {
+        // Julia (expression) value of current parameter
+        jl_value_t *argi = ccallarg(i);
+
+        // pass the address of the argument rather than the argument itself
+        if (jl_is_expr(argi) && ((jl_expr_t*)argi)->head == amp_sym) {
+            addressOf.push_back(true);
+            argi = jl_exprarg(argi, 0);
+        }
+        else {
+            addressOf.push_back(false);
+        }
+
+        argv[i] = emit_expr(ctx, argi);
+    }
+
+    // emit roots
+    SmallVector<Value*, 16> gc_uses;
+    for (size_t i = nccallargs + 6; i <= nargs; i++) {
+        // Julia (expression) value of current parameter gcroot
+        jl_value_t *argi_root = args[i];
+        if (jl_is_long(argi_root))
+            continue;
+        jl_cgval_t arg_root = emit_expr(ctx, argi_root);
+        Value *gcuse = arg_root.gcroot ? ctx.builder.CreateLoad(arg_root.gcroot) : arg_root.V;
+        if (gcuse) {
+            gc_uses.push_back(gcuse);
+        }
+    }
+
     // some special functions
-    if (fptr == (void(*)(void))&jl_array_ptr ||
-        ((f_lib==NULL || (intptr_t)f_lib==2)
-         && f_name && !strcmp(f_name,"jl_array_ptr"))) {
+    if (is_libjulia_func(jl_array_ptr)) {
         assert(lrt->isPointerTy());
-        assert(!isVa && !llvmcall);
-        assert(nargt==1);
-        jl_value_t *argi = args[4];
-        assert(!(jl_is_expr(argi) && ((jl_expr_t*)argi)->head == amp_sym));
-        jl_cgval_t ary = emit_expr(argi, ctx);
+        assert(!isVa && !llvmcall && nargt == 1);
+        assert(!addressOf.at(0));
+        const jl_cgval_t &ary = argv[0];
+        jl_value_t *aryex = ccallarg(0);
         JL_GC_POP();
-        return mark_or_box_ccall_result(emit_bitcast(emit_arrayptr(ary, ctx), lrt),
-                                        retboxed, rt, unionall, static_rt, ctx);
+        return mark_or_box_ccall_result(ctx, emit_bitcast(ctx, emit_arrayptr(ctx, ary, aryex), lrt),
+                                        retboxed, rt, unionall, static_rt);
     }
-    if (fptr == (void(*)(void))&jl_value_ptr ||
-        ((f_lib==NULL || (intptr_t)f_lib==2)
-         && f_name && !strcmp(f_name,"jl_value_ptr"))) {
+    else if (is_libjulia_func(jl_value_ptr)) {
         assert(lrt->isPointerTy());
-        assert(!isVa && !llvmcall);
-        assert(nargt==1);
-        jl_value_t *argi = args[4];
-        bool addressOf = false;
+        assert(!isVa && !llvmcall && nargt == 1);
         jl_value_t *tti = jl_svecref(at, 0);
-        if (jl_is_expr(argi) && ((jl_expr_t*)argi)->head == amp_sym) {
-            addressOf = true;
-            argi = jl_exprarg(argi,0);
-        }
-        else if (jl_is_abstract_ref_type(tti)) {
-            tti = (jl_value_t*)jl_voidpointer_type;
-        }
         Value *ary;
         Type *largty;
         bool isboxed;
-        if (addressOf) {
+        if (addressOf.at(0)) {
             largty = T_pjlvalue;
             isboxed = true;
         }
+        else if (jl_is_abstract_ref_type(tti)) {
+            tti = (jl_value_t*)jl_voidpointer_type;
+            largty = T_pint8;
+            isboxed = false;
+        }
         else {
             largty = julia_struct_to_llvm(tti, unionall, &isboxed);
         }
         if (isboxed) {
-            ary = boxed(emit_expr(argi, ctx), ctx);
+            ary = boxed(ctx, argv[0]);
         }
         else {
-            assert(!addressOf);
-            ary = emit_unbox(largty, emit_expr(argi, ctx), tti);
+            ary = emit_unbox(ctx, largty, argv[0], tti);
         }
         JL_GC_POP();
-        return mark_or_box_ccall_result(emit_bitcast(ary, lrt),
-                                        retboxed, rt, unionall, static_rt, ctx);
+        if (!retboxed) {
+            return mark_or_box_ccall_result(
+                    ctx,
+                    emit_bitcast(ctx, emit_pointer_from_objref(ctx,
+                            emit_bitcast(ctx, ary, T_prjlvalue)), lrt),
+                    retboxed, rt, unionall, static_rt);
+        } else {
+            return mark_or_box_ccall_result(
+                    ctx,
+                    maybe_decay_untracked(emit_bitcast(ctx, ary, lrt)),
+                    retboxed, rt, unionall, static_rt);
+        }
+    }
+    else if (is_libjulia_func(jl_cpu_pause)) {
+        // Keep in sync with the julia_threads.h version
+        assert(lrt == T_void);
+        assert(!isVa && !llvmcall && nargt == 0);
+#ifdef __MIC__
+        // TODO
+#elif defined(_CPU_X86_64_) || defined(_CPU_X86_)  /* !__MIC__ */
+        static auto pauseinst = InlineAsm::get(FunctionType::get(T_void, false), "pause",
+                                               "~{memory}", true);
+        ctx.builder.CreateCall(pauseinst);
+        JL_GC_POP();
+        return ghostValue(jl_void_type);
+#elif defined(_CPU_AARCH64_) || (defined(_CPU_ARM_) && __ARM_ARCH >= 7)
+        static auto wfeinst = InlineAsm::get(FunctionType::get(T_void, false), "wfe",
+                                             "~{memory}", true);
+        ctx.builder.CreateCall(wfeinst);
+        JL_GC_POP();
+        return ghostValue(jl_void_type);
+#else
+        JL_GC_POP();
+        return ghostValue(jl_void_type);
+#endif
     }
-    if (JL_CPU_WAKE_NOOP &&
-        (fptr == &jl_cpu_wake || ((!f_lib || (intptr_t)f_lib == 2) &&
-                                  f_name && !strcmp(f_name, "jl_cpu_wake")))) {
+    else if (is_libjulia_func(jl_cpu_wake)) {
+        // Keep in sync with the julia_threads.h version
         assert(lrt == T_void);
-        assert(!isVa && !llvmcall);
-        assert(nargt == 0);
+        assert(!isVa && !llvmcall && nargt == 0);
+#if JL_CPU_WAKE_NOOP == 1
+        JL_GC_POP();
+        return ghostValue(jl_void_type);
+#elif defined(_CPU_AARCH64_) || (defined(_CPU_ARM_) && __ARM_ARCH >= 7)
+        static auto sevinst = InlineAsm::get(FunctionType::get(T_void, false), "sev",
+                                             "~{memory}", true);
+        ctx.builder.CreateCall(sevinst);
         JL_GC_POP();
         return ghostValue(jl_void_type);
+#endif
     }
-    if (fptr == &jl_gc_safepoint ||
-        ((!f_lib || (intptr_t)f_lib == 2) && f_name &&
-         strcmp(f_name, "jl_gc_safepoint") == 0)) {
+    else if (is_libjulia_func(jl_gc_safepoint)) {
         assert(lrt == T_void);
-        assert(!isVa && !llvmcall);
-        assert(nargt == 0);
+        assert(!isVa && !llvmcall && nargt == 0);
         JL_GC_POP();
-        builder.CreateCall(prepare_call(gcroot_flush_func));
-        emit_signal_fence();
-        builder.CreateLoad(ctx->signalPage, true);
-        emit_signal_fence();
+        ctx.builder.CreateCall(prepare_call(gcroot_flush_func));
+        emit_signal_fence(ctx);
+        ctx.builder.CreateLoad(ctx.signalPage, true);
+        emit_signal_fence(ctx);
         return ghostValue(jl_void_type);
     }
-#ifdef _OS_LINUX_
-    // directly access the address of a ifunc can cause linker issue on
-    // some configurations (e.g. AArch64 + -Bsymbolic-functions).
-    static const auto ptls_getter = jl_dlsym_e(jl_dlopen(nullptr, 0),
-                                               "jl_get_ptls_states");
-#else
-    static const auto ptls_getter = &jl_get_ptls_states;
-#endif
-    if (fptr == (void(*)(void))(uintptr_t)ptls_getter ||
-        ((!f_lib || (intptr_t)f_lib == 2) && f_name &&
-         strcmp(f_name, "jl_get_ptls_states") == 0)) {
+    else if (_is_libjulia_func((uintptr_t)ptls_getter, "jl_get_ptls_states")) {
         assert(lrt == T_pint8);
-        assert(!isVa && !llvmcall);
-        assert(nargt == 0);
+        assert(!isVa && !llvmcall && nargt == 0);
         JL_GC_POP();
-        return mark_or_box_ccall_result(
-            emit_bitcast(ctx->ptlsStates, lrt),
-            retboxed, rt, unionall, static_rt, ctx);
+        return mark_or_box_ccall_result(ctx,
+            emit_bitcast(ctx, ctx.ptlsStates, lrt),
+            retboxed, rt, unionall, static_rt);
     }
-    if (fptr == &jl_sigatomic_begin ||
-        ((!f_lib || (intptr_t)f_lib == 2) && f_name &&
-         strcmp(f_name, "jl_sigatomic_begin") == 0)) {
+    else if (is_libjulia_func(jl_threadid)) {
+        assert(lrt == T_int16);
+        assert(!isVa && !llvmcall && nargt == 0);
+        JL_GC_POP();
+        Value *ptls_i16 = emit_bitcast(ctx, ctx.ptlsStates, T_pint16);
+        const int tid_offset = offsetof(jl_tls_states_t, tid);
+        Value *ptid = ctx.builder.CreateGEP(ptls_i16, ConstantInt::get(T_size, tid_offset / 2));
+        return mark_or_box_ccall_result(ctx,
+            tbaa_decorate(tbaa_const, ctx.builder.CreateLoad(ptid)),
+            retboxed, rt, unionall, static_rt);
+    }
+    else if (is_libjulia_func(jl_sigatomic_begin)) {
         assert(lrt == T_void);
-        assert(!isVa && !llvmcall);
-        assert(nargt == 0);
+        assert(!isVa && !llvmcall && nargt == 0);
         JL_GC_POP();
-        builder.CreateCall(prepare_call(gcroot_flush_func));
+        ctx.builder.CreateCall(prepare_call(gcroot_flush_func));
         Value *pdefer_sig = emit_defer_signal(ctx);
-        Value *defer_sig = builder.CreateLoad(pdefer_sig);
-        defer_sig = builder.CreateAdd(defer_sig,
+        Value *defer_sig = ctx.builder.CreateLoad(pdefer_sig);
+        defer_sig = ctx.builder.CreateAdd(defer_sig,
                                       ConstantInt::get(T_sigatomic, 1));
-        builder.CreateStore(defer_sig, pdefer_sig);
-        emit_signal_fence();
+        ctx.builder.CreateStore(defer_sig, pdefer_sig);
+        emit_signal_fence(ctx);
         return ghostValue(jl_void_type);
     }
-    if (fptr == &jl_sigatomic_end ||
-        ((!f_lib || (intptr_t)f_lib == 2) && f_name &&
-         strcmp(f_name, "jl_sigatomic_end") == 0)) {
+    else if (is_libjulia_func(jl_sigatomic_end)) {
         assert(lrt == T_void);
-        assert(!isVa && !llvmcall);
-        assert(nargt == 0);
+        assert(!isVa && !llvmcall && nargt == 0);
         JL_GC_POP();
-        builder.CreateCall(prepare_call(gcroot_flush_func));
+        ctx.builder.CreateCall(prepare_call(gcroot_flush_func));
         Value *pdefer_sig = emit_defer_signal(ctx);
-        Value *defer_sig = builder.CreateLoad(pdefer_sig);
-        emit_signal_fence();
-        error_unless(builder.CreateICmpNE(defer_sig,
-                                          ConstantInt::get(T_sigatomic, 0)),
-                     "sigatomic_end called in non-sigatomic region", ctx);
-        defer_sig = builder.CreateSub(defer_sig,
-                                      ConstantInt::get(T_sigatomic, 1));
-        builder.CreateStore(defer_sig, pdefer_sig);
+        Value *defer_sig = ctx.builder.CreateLoad(pdefer_sig);
+        emit_signal_fence(ctx);
+        error_unless(ctx,
+                ctx.builder.CreateICmpNE(defer_sig, ConstantInt::get(T_sigatomic, 0)),
+                "sigatomic_end called in non-sigatomic region");
+        defer_sig = ctx.builder.CreateSub(
+                defer_sig,
+                ConstantInt::get(T_sigatomic, 1));
+        ctx.builder.CreateStore(defer_sig, pdefer_sig);
         BasicBlock *checkBB = BasicBlock::Create(jl_LLVMContext, "check",
-                                                 ctx->f);
+                                                 ctx.f);
         BasicBlock *contBB = BasicBlock::Create(jl_LLVMContext, "cont");
-        builder.CreateCondBr(
-            builder.CreateICmpEQ(defer_sig, ConstantInt::get(T_sigatomic, 0)),
-            checkBB, contBB);
-        builder.SetInsertPoint(checkBB);
-        builder.CreateLoad(builder.CreateConstGEP1_32(ctx->signalPage, -1),
-                           true);
-        builder.CreateBr(contBB);
-        ctx->f->getBasicBlockList().push_back(contBB);
-        builder.SetInsertPoint(contBB);
+        ctx.builder.CreateCondBr(
+                ctx.builder.CreateICmpEQ(defer_sig, ConstantInt::get(T_sigatomic, 0)),
+                checkBB, contBB);
+        ctx.builder.SetInsertPoint(checkBB);
+        ctx.builder.CreateLoad(
+                ctx.builder.CreateConstGEP1_32(ctx.signalPage, -1),
+                true);
+        ctx.builder.CreateBr(contBB);
+        ctx.f->getBasicBlockList().push_back(contBB);
+        ctx.builder.SetInsertPoint(contBB);
         return ghostValue(jl_void_type);
     }
-    if (fptr == (void(*)(void))&jl_is_concrete_type ||
-        ((f_lib==NULL || (intptr_t)f_lib==2)
-         && f_name && !strcmp(f_name, "jl_is_concrete_type"))) {
-        assert(nargt == 1);
-        assert(!isVa && !llvmcall);
-        jl_value_t *arg = args[4];
-        jl_value_t *ty = expr_type(arg, ctx);
-        if (jl_is_type_type(ty) && !jl_is_typevar(jl_tparam0(ty))) {
-            int isconcrete = jl_is_concrete_type(jl_tparam0(ty));
+    else if (is_libjulia_func(jl_is_concrete_type)) {
+        assert(!isVa && !llvmcall && nargt == 1 && !addressOf.at(0));
+        const jl_cgval_t &arg = argv[0];
+        jl_value_t *ty = arg.constant;
+        if (!ty && jl_is_type_type(arg.typ) && !jl_has_free_typevars(arg.typ))
+            ty = jl_tparam0(arg.typ);
+        if (ty) {
+            int isconcrete = jl_is_concrete_type(ty);
             JL_GC_POP();
-            return mark_or_box_ccall_result(ConstantInt::get(T_int32, isconcrete),
-                    false, rt, unionall, static_rt, ctx);
-        }
-    }
-    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);
-        assert(!isVa && !llvmcall);
-        jl_value_t *f = static_eval(args[4], ctx, false, false);
-        jl_value_t *fargt = nullptr;
-        JL_GC_PUSH2(&f, &fargt);
-        jl_value_t *frt = expr_type(args[6], ctx);
-        if (f && (jl_is_type_type((jl_value_t*)frt) && !jl_has_free_typevars(jl_tparam0(frt)))) {
-            fargt = static_eval(args[8], ctx, true, true);
-            if (fargt) {
-                if (jl_is_tuple(fargt)) {
-                    // TODO: maybe deprecation warning, better checking
-                    fargt = (jl_value_t*)jl_apply_tuple_type_v((jl_value_t**)jl_data_ptr(fargt), jl_nfields(fargt));
-                }
+            return mark_or_box_ccall_result(ctx,
+                    ConstantInt::get(T_int32, isconcrete),
+                    false, rt, unionall, static_rt);
+        }
+    }
+    else if (is_libjulia_func(jl_function_ptr)) {
+        assert(!isVa && !llvmcall && nargt == 3);
+        jl_value_t *f = argv[0].constant;
+        jl_value_t *frt = argv[1].constant;
+        if (!frt) {
+            if (jl_is_type_type(argv[1].typ) && !jl_has_free_typevars(argv[1].typ))
+                frt = jl_tparam0(argv[1].typ);
+        }
+        if (f && frt) {
+            jl_value_t *fargt = argv[2].constant;;
+            JL_GC_PUSH1(&fargt);
+            if (!fargt && jl_is_type_type(argv[2].typ)) {
+                if (!jl_has_free_typevars(argv[2].typ))
+                    fargt = jl_tparam0(argv[2].typ);
             }
-            else {
-                fargt = expr_type(args[8], ctx);
-                if (jl_is_type_type((jl_value_t*)fargt))
-                    fargt = jl_tparam0(fargt);
+            else if (fargt && jl_is_tuple(fargt)) {
+                // TODO: maybe deprecation warning, better checking
+                fargt = (jl_value_t*)jl_apply_tuple_type_v((jl_value_t**)jl_data_ptr(fargt), jl_nfields(fargt));
             }
-            if (jl_is_tuple_type(fargt) && jl_is_concrete_type(fargt)) {
-                frt = jl_tparam0(frt);
+            if (fargt && jl_is_tuple_type(fargt)) {
                 Value *llvmf = NULL;
                 JL_TRY {
                     llvmf = jl_cfunction_object((jl_function_t*)f, frt, (jl_tupletype_t*)fargt);
@@ -1728,83 +1795,79 @@ static jl_cgval_t emit_ccall(jl_value_t **args, size_t nargs, jl_codectx_t *ctx)
                 }
                 if (llvmf) {
                     llvmf = prepare_call(llvmf);
-                    // make sure to emit any side-effects that may have been part of the original expression
-                    emit_expr(args[4], ctx);
-                    emit_expr(args[6], ctx);
-                    emit_expr(args[8], ctx);
                     JL_GC_POP();
                     JL_GC_POP();
-                    return mark_or_box_ccall_result(emit_bitcast(llvmf, lrt),
-                                                    retboxed, rt, unionall, static_rt, ctx);
+                    return mark_or_box_ccall_result(ctx, emit_bitcast(ctx, llvmf, lrt),
+                                                    retboxed, rt, unionall, static_rt);
                 }
             }
+            JL_GC_POP();
         }
-        JL_GC_POP();
     }
-
-    // emit arguments
-    jl_cgval_t *argv = (jl_cgval_t*)alloca(sizeof(jl_cgval_t) * (nargs - 3) / 2);
-    SmallVector<Value*, 16> gc_uses;
-    std::vector<bool> addressOf(0);
-
-    size_t i;
-    for (i = 4; i < nargs + 1; i += 2) {
-        // Current C function parameter
-        size_t ai = (i - 4) / 2;
-
-        // Julia (expression) value of current parameter
-        jl_value_t *argi = args[i];
-
-        // pass the address of the argument rather than the argument itself
-        if (jl_is_expr(argi) && ((jl_expr_t*)argi)->head == amp_sym) {
-            addressOf.push_back(true);
-            argi = jl_exprarg(argi, 0);
-        }
-        else {
-            addressOf.push_back(false);
+    else if (is_libjulia_func(jl_array_isassigned) &&
+             argv[1].typ == (jl_value_t*)jl_ulong_type) {
+        assert(!isVa && !llvmcall && nargt == 2 && !addressOf.at(0) && !addressOf.at(1));
+        jl_value_t *aryex = ccallarg(0);
+        const jl_cgval_t &aryv = argv[0];
+        const jl_cgval_t &idxv = argv[1];
+        jl_datatype_t *arydt = (jl_datatype_t*)jl_unwrap_unionall(aryv.typ);
+        if (jl_is_array_type(arydt)) {
+            jl_value_t *ety = jl_tparam0(arydt);
+            if (jl_array_store_unboxed(ety)) {
+                JL_GC_POP();
+                return mark_or_box_ccall_result(ctx, ConstantInt::get(T_int32, 1),
+                                                false, rt, unionall, static_rt);
+            }
+            else if (!jl_has_free_typevars(ety)) {
+                Value *idx = emit_unbox(ctx, T_size, idxv, (jl_value_t*)jl_ulong_type);
+                Value *arrayptr = emit_bitcast(ctx, emit_arrayptr(ctx, aryv, aryex), T_ppjlvalue);
+                Value *slot_addr = ctx.builder.CreateGEP(arrayptr, idx);
+                Value *load = tbaa_decorate(tbaa_arraybuf, ctx.builder.CreateLoad(slot_addr));
+                Value *res = ctx.builder.CreateZExt(ctx.builder.CreateICmpNE(load, V_null), T_int32);
+                JL_GC_POP();
+                return mark_or_box_ccall_result(ctx, res, retboxed, rt, unionall, static_rt);
+            }
         }
-
-        jl_cgval_t &arg = argv[ai];
-        arg = emit_expr((jl_value_t*)argi, ctx);
-        push_gc_use(gc_uses, arg);
-
-        // Julia (expression) value of current parameter gcroot
-        jl_value_t *argi_root = args[i + 1];
-        if (jl_is_long(argi_root))
-            continue;
-        jl_cgval_t arg_root = emit_expr(argi_root, ctx);
-        push_gc_use(gc_uses, arg_root);
+    }
+    else if (is_libjulia_func(jl_string_ptr)) {
+        assert(lrt == T_pint8);
+        assert(!isVa && !llvmcall && nargt == 1 && !addressOf.at(0));
+        auto obj = emit_pointer_from_objref(ctx, boxed(ctx, argv[0]));
+        auto strp = ctx.builder.CreateConstGEP1_32(emit_bitcast(ctx, obj, T_pint8), sizeof(void*));
+        JL_GC_POP();
+        return mark_or_box_ccall_result(ctx, strp, retboxed, rt, unionall, static_rt);
     }
 
-    function_sig_t sig(lrt, rt, retboxed, (jl_svec_t*)at, unionall, (nargs - 3) / 2, isVa, cc, llvmcall);
+    function_sig_t sig(lrt, rt, retboxed, (jl_svec_t*)at, unionall, nccallargs,
+                       isVa, cc, llvmcall);
     jl_cgval_t retval = sig.emit_a_ccall(
+            ctx,
             symarg,
             nargt,
             addressOf,
             argv,
             gc_uses,
-            static_rt,
-            ctx);
+            static_rt);
     JL_GC_POP();
     return retval;
 }
 
 jl_cgval_t function_sig_t::emit_a_ccall(
+        jl_codectx_t &ctx,
         const native_sym_arg_t &symarg,
         size_t nargt,
         std::vector<bool> &addressOf,
         jl_cgval_t *argv,
         SmallVector<Value*, 16> &gc_uses,
-        bool static_rt,
-        jl_codectx_t *ctx)
+        bool static_rt)
 {
     if (!err_msg.empty()) {
-        emit_error(err_msg, ctx);
+        emit_error(ctx, err_msg);
         return jl_cgval_t();
     }
 
     // save place before arguments, for possible insertion of temp arg area saving code.
-    BasicBlock::InstListType &instList = builder.GetInsertBlock()->getInstList();
+    BasicBlock::InstListType &instList = ctx.builder.GetInsertBlock()->getInstList();
     Instruction *savespot = instList.empty() ? NULL : &instList.back();
 
     bool needStackRestore = false;
@@ -1833,8 +1896,9 @@ jl_cgval_t function_sig_t::emit_a_ccall(
         // if we know the function sparams, try to fill those in now
         // so that the julia_to_native type checks are more likely to be doable (e.g. concrete types) at compile-time
         jl_value_t *jargty_in_env = jargty;
-        if (ctx->spvals_ptr == NULL && !toboxed && unionall_env && jl_has_typevar_from_unionall(jargty, unionall_env)) {
-            jargty_in_env = jl_instantiate_type_in_env(jargty_in_env, unionall_env, jl_svec_data(ctx->linfo->sparam_vals));
+        if (ctx.spvals_ptr == NULL && !toboxed && unionall_env && jl_has_typevar_from_unionall(jargty, unionall_env) &&
+            jl_svec_len(ctx.linfo->sparam_vals) > 0) {
+            jargty_in_env = jl_instantiate_type_in_env(jargty_in_env, unionall_env, jl_svec_data(ctx.linfo->sparam_vals));
             if (jargty_in_env != jargty)
                 jl_add_method_root(ctx, jargty_in_env);
         }
@@ -1843,37 +1907,42 @@ jl_cgval_t function_sig_t::emit_a_ccall(
         if (!addressOf.at(ai)) {
             if (jl_is_abstract_ref_type(jargty)) {
                 if (!jl_is_cpointer_type(arg.typ)) {
-                    emit_cpointercheck(arg, "ccall: argument to Ref{T} is not a pointer", ctx);
+                    emit_cpointercheck(ctx, arg, "ccall: argument to Ref{T} is not a pointer");
                     arg.typ = (jl_value_t*)jl_voidpointer_type;
                     arg.isboxed = false;
                 }
                 jargty_in_env = (jl_value_t*)jl_voidpointer_type;
             }
 
-            v = julia_to_native(largty, toboxed, jargty_in_env, unionall_env, arg, byRef,
-                                ai + 1, ctx, &needStackRestore);
+            v = julia_to_native(ctx, largty, toboxed, jargty_in_env, unionall_env, arg, byRef,
+                                ai + 1, &needStackRestore);
             bool issigned = jl_signed_type && jl_subtype(jargty, (jl_value_t*)jl_signed_type);
             if (byRef) {
+                v = decay_derived(v);
                 // julia_to_native should already have done the alloca and store
                 assert(v->getType() == pargty);
             }
             else {
-                v = llvm_type_rewrite(v, pargty, issigned, ctx);
+                v = llvm_type_rewrite(ctx, v, pargty, issigned);
             }
         }
         else {
             if (jl_is_abstract_ref_type(jargty)) {
-                emit_error("ccall: & on a Ref{T} argument is invalid", ctx);
-                JL_GC_POP();
+                emit_error(ctx, "ccall: & on a Ref{T} argument is invalid");
+                return jl_cgval_t();
+            }
+            v = julia_to_address(ctx, largty, jargty_in_env, unionall_env, arg,
+                                 ai + 1, &needStackRestore);
+            if (isa<UndefValue>(v)) {
                 return jl_cgval_t();
             }
-            v = julia_to_address(largty, jargty_in_env, unionall_env, arg,
-                                 ai + 1, ctx, &needStackRestore);
+            // A bit of a hack, but we're trying to get rid of this feature
+            // anyway.
+            v = emit_bitcast(ctx, emit_pointer_from_objref(ctx, v), pargty);
             assert((!toboxed && !byRef) || isa<UndefValue>(v));
         }
 
         if (isa<UndefValue>(v)) {
-            JL_GC_POP();
             return jl_cgval_t();
         }
         assert(v->getType() == pargty);
@@ -1885,19 +1954,18 @@ jl_cgval_t function_sig_t::emit_a_ccall(
     // 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");
-        if (!sret_val.ispointer()) {
-            Value *mem = emit_static_alloca(lrt, ctx);
-            builder.CreateStore(sret_val.V, mem);
-            result = mem;
+        assert(!retboxed && jl_is_datatype(rt) && "sret return type invalid");
+        if (jl_isbits(rt)) {
+            result = emit_static_alloca(ctx, lrt);
         }
         else {
-            // XXX: result needs a GC root here if result->getType() == T_pjlvalue
-            result = sret_val.V;
+            // XXX: result needs to be zero'd and given a GC root here
+            assert(jl_datatype_size(rt) > 0 && "sret shouldn't be a singleton instance");
+            result = emit_allocobj(ctx, jl_datatype_size(rt),
+                                   literal_pointer_val(ctx, (jl_value_t*)rt));
+            sretboxed = true;
         }
-        argvals[0] = emit_bitcast(result, fargt_sig.at(0));
-        sretboxed = sret_val.isboxed;
+        argvals[0] = emit_bitcast(ctx, decay_derived(result), fargt_sig.at(0));
     }
 
     Instruction *stacksave = NULL;
@@ -1905,11 +1973,7 @@ jl_cgval_t function_sig_t::emit_a_ccall(
         stacksave = CallInst::Create(Intrinsic::getDeclaration(jl_Module,
                                                                Intrinsic::stacksave));
         if (savespot) {
-#if JL_LLVM_VERSION >= 30800
             instList.insertAfter(savespot->getIterator(), stacksave);
-#else
-            instList.insertAfter(savespot, stacksave);
-#endif
         }
         else {
             instList.push_front(stacksave);
@@ -1938,13 +2002,13 @@ jl_cgval_t function_sig_t::emit_a_ccall(
         }
     }
     else if (symarg.jl_ptr != NULL) {
-        null_pointer_check(symarg.jl_ptr, ctx);
+        null_pointer_check(ctx, symarg.jl_ptr);
         Type *funcptype = PointerType::get(functype, 0);
-        llvmf = builder.CreateIntToPtr(symarg.jl_ptr, funcptype);
+        llvmf = ctx.builder.CreateIntToPtr(symarg.jl_ptr, funcptype);
     }
     else if (symarg.fptr != NULL) {
         Type *funcptype = PointerType::get(functype, 0);
-        llvmf = literal_static_pointer_val((void*)(uintptr_t)symarg.fptr, funcptype);
+        llvmf = literal_static_pointer_val(ctx, (void*)(uintptr_t)symarg.fptr, funcptype);
         if (imaging_mode)
             jl_printf(JL_STDERR,"WARNING: literal address used in ccall for %s; code cannot be statically compiled\n", symarg.f_name);
     }
@@ -1956,9 +2020,9 @@ jl_cgval_t function_sig_t::emit_a_ccall(
             // vararg requires musttail,
             // but musttail is incompatible with noreturn.
             if (functype->isVarArg())
-                llvmf = runtime_sym_lookup(funcptype, symarg.f_lib, symarg.f_name, ctx->f);
+                llvmf = runtime_sym_lookup(ctx, funcptype, symarg.f_lib, symarg.f_name, ctx.f);
             else
-                llvmf = emit_plt(functype, attributes, cc, symarg.f_lib, symarg.f_name);
+                llvmf = emit_plt(ctx, functype, attributes, cc, symarg.f_lib, symarg.f_name);
         }
         else {
             void *symaddr = jl_dlsym_e(jl_get_library(symarg.f_lib), symarg.f_name);
@@ -1968,26 +2032,25 @@ jl_cgval_t function_sig_t::emit_a_ccall(
                 msg << symarg.f_name;
                 if (symarg.f_lib != NULL) {
 #ifdef _OS_WINDOWS_
-                    assert((intptr_t)symarg.f_lib != 1 && (intptr_t)symarg.f_lib != 2);
+                    assert(symarg.f_lib != JL_EXE_LIBNAME && symarg.f_lib != JL_DL_LIBNAME);
 #endif
                     msg << " in library ";
                     msg << symarg.f_lib;
                 }
-                emit_error(msg.str(), ctx);
+                emit_error(ctx, msg.str());
                 return jl_cgval_t();
             }
             // since we aren't saving this code, there's no sense in
             // putting anything complicated here: just JIT the function address
-            llvmf = literal_static_pointer_val(symaddr, funcptype);
+            llvmf = literal_static_pointer_val(ctx, symaddr, funcptype);
         }
     }
 
-    // Mark GC use before **and** after the ccall to make sure the arguments
-    // are alive during the ccall even if the function called is `noreturn`.
-    mark_gc_uses(gc_uses);
+    OperandBundleDef OpBundle("jl_roots", gc_uses);
     // the actual call
-    Value *ret = builder.CreateCall(prepare_call(llvmf),
-                                    ArrayRef<Value*>(&argvals[0], nargs + sret));
+    Value *ret = ctx.builder.CreateCall(prepare_call(llvmf),
+                                    ArrayRef<Value*>(&argvals[0], nargs + sret),
+                                    ArrayRef<OperandBundleDef>(&OpBundle, gc_uses.empty() ? 0 : 1));
     ((CallInst*)ret)->setAttributes(attributes);
 
     if (cc != CallingConv::C)
@@ -1996,16 +2059,14 @@ jl_cgval_t function_sig_t::emit_a_ccall(
         result = ret;
     if (needStackRestore) {
         assert(stacksave != NULL);
-        builder.CreateCall(Intrinsic::getDeclaration(jl_Module, Intrinsic::stackrestore), stacksave);
+        ctx.builder.CreateCall(Intrinsic::getDeclaration(jl_Module, Intrinsic::stackrestore), stacksave);
     }
     if (0) { // Enable this to turn on SSPREQ (-fstack-protector) on the function containing this ccall
-        ctx->f->addFnAttr(Attribute::StackProtectReq);
+        ctx.f->addFnAttr(Attribute::StackProtectReq);
     }
 
-    mark_gc_uses(gc_uses);
     if (rt == jl_bottom_type) {
-        // Do this after we marked all the GC uses.
-        CreateTrap(builder);
+        CreateTrap(ctx.builder);
         return jl_cgval_t();
     }
 
@@ -2020,11 +2081,18 @@ jl_cgval_t function_sig_t::emit_a_ccall(
     }
     else if (sret) {
         jlretboxed = sretboxed;
-        if (!jlretboxed)
-            result = builder.CreateLoad(result); // something alloca'd above
+        if (!jlretboxed) {
+            // something alloca'd above is SSA
+            if (static_rt)
+                return mark_julia_slot(result, rt, NULL, tbaa_stack);
+            result = ctx.builder.CreateLoad(result);
+        }
     }
     else {
         Type *jlrt = julia_type_to_llvm(rt, &jlretboxed); // compute the real "julian" return type and compute whether it is boxed
+        if (jlretboxed) {
+            jlrt = T_prjlvalue;
+        }
         if (type_is_ghost(jlrt)) {
             return ghostValue(rt);
         }
@@ -2034,16 +2102,16 @@ jl_cgval_t function_sig_t::emit_a_ccall(
         else if (jlretboxed && !retboxed) {
             assert(jl_is_datatype(rt));
             if (static_rt) {
-                Value *runtime_bt = literal_pointer_val(rt);
+                Value *runtime_bt = literal_pointer_val(ctx, rt);
                 size_t rtsz = jl_datatype_size(rt);
                 assert(rtsz > 0);
                 Value *strct = emit_allocobj(ctx, rtsz, runtime_bt);
-                int boxalign = jl_gc_alignment(rtsz);
-#ifndef NDEBUG
-#if JL_LLVM_VERSION >= 30600
-                const DataLayout &DL = jl_ExecutionEngine->getDataLayout();
+                int boxalign = jl_datatype_align(rt);
+#ifndef JL_NDEBUG
+#if JL_LLVM_VERSION >= 40000
+                const DataLayout &DL = jl_data_layout;
 #else
-                const DataLayout &DL = *jl_ExecutionEngine->getDataLayout();
+                const DataLayout &DL = jl_ExecutionEngine->getDataLayout();
 #endif
                 // ARM and AArch64 can use a LLVM type larger than the julia
                 // type. However, the LLVM type size should be no larger than
@@ -2052,16 +2120,16 @@ jl_cgval_t function_sig_t::emit_a_ccall(
 #endif
                 // copy the data from the return value to the new struct
                 MDNode *tbaa = jl_is_mutable(rt) ? tbaa_mutab : tbaa_immut;
-                init_bits_value(strct, result, tbaa, boxalign);
-                return mark_julia_type(strct, true, rt, ctx);
+                init_bits_value(ctx, strct, result, tbaa, boxalign);
+                return mark_julia_type(ctx, strct, true, rt);
             }
             jlretboxed = false; // trigger mark_or_box_ccall_result to build the runtime box
         }
         else if (lrt != prt) {
             assert(jlrt == lrt || !lrt->isStructTy()); // julia_type_to_llvm and julia_struct_to_llvm should be returning the same StructType
-            result = llvm_type_rewrite(result, lrt, false, ctx);
+            result = llvm_type_rewrite(ctx, result, lrt, false);
         }
     }
 
-    return mark_or_box_ccall_result(result, jlretboxed, rt, unionall_env, static_rt, ctx);
+    return mark_or_box_ccall_result(ctx, result, jlretboxed, rt, unionall_env, static_rt);
 }
diff --git a/src/ccalltest.c b/src/ccalltest.c
index b8781567fcf40a..91b804e0742b48 100644
--- a/src/ccalltest.c
+++ b/src/ccalltest.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include <stdio.h>
 #include <stdlib.h>
diff --git a/src/cgmemmgr.cpp b/src/cgmemmgr.cpp
index c4b93638caed32..b4f0ff0969b694 100644
--- a/src/cgmemmgr.cpp
+++ b/src/cgmemmgr.cpp
@@ -1,18 +1,14 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include "llvm-version.h"
 #include "platform.h"
 #include "options.h"
 
-#ifdef USE_MCJIT
 #include <llvm/ExecutionEngine/SectionMemoryManager.h>
+#include "fix_llvm_assert.h"
 #include "julia.h"
 #include "julia_internal.h"
 
-#if JL_LLVM_VERSION >= 30700
-#if JL_LLVM_VERSION < 30800
-#  include <llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h>
-#endif
 #ifdef _OS_LINUX_
 #  include <sys/syscall.h>
 #  include <sys/utsname.h>
@@ -262,9 +258,9 @@ static void *alloc_shared_page(size_t size, size_t *id, bool exec)
 #ifdef _OS_LINUX_
 // Using `/proc/self/mem`, A.K.A. Keno's remote memory manager.
 
-static int self_mem_fd = -1;
-
-static int init_self_mem()
+// Do not call this directly.
+// Use `get_self_mem_fd` which has a guard to call this only once.
+static int _init_self_mem()
 {
     struct utsname kernel;
     uname(&kernel);
@@ -286,22 +282,34 @@ static int init_self_mem()
         return -1;
     fcntl(fd, F_SETFD, FD_CLOEXEC);
 #endif
-    // buffer to check if write works;
-    volatile uint64_t buff = 0;
-    uint64_t v = 0x12345678;
-    int ret = pwrite(fd, (void*)&v, sizeof(uint64_t), (uintptr_t)&buff);
-    if (ret != sizeof(uint64_t) || buff != 0x12345678) {
+
+    // Check if we can write to a RX page
+    void *test_pg = mmap(nullptr, jl_page_size, PROT_READ | PROT_EXEC,
+                         MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+    // We can ignore this though failure to allocate executable memory would be a bigger problem.
+    assert(test_pg != MAP_FAILED && "Cannot allocate executable memory");
+
+    const uint64_t v = 0xffff000012345678u;
+    int ret = pwrite(fd, (const void*)&v, sizeof(uint64_t), (uintptr_t)test_pg);
+    if (ret != sizeof(uint64_t) || *(volatile uint64_t*)test_pg != v) {
+        munmap(test_pg, jl_page_size);
         close(fd);
         return -1;
     }
-    self_mem_fd = fd;
+    munmap(test_pg, jl_page_size);
+    return fd;
+}
+
+static int get_self_mem_fd()
+{
+    static int fd = _init_self_mem();
     return fd;
 }
 
 static void write_self_mem(void *dest, void *ptr, size_t size)
 {
     while (size > 0) {
-        ssize_t ret = pwrite(self_mem_fd, ptr, size, (uintptr_t)dest);
+        ssize_t ret = pwrite(get_self_mem_fd(), ptr, size, (uintptr_t)dest);
         if ((size_t)ret == size)
             return;
         if (ret == -1 && (errno == EAGAIN || errno == EINTR))
@@ -655,7 +663,7 @@ class SelfMemAllocator : public ROAllocator<exec> {
         : ROAllocator<exec>(),
           temp_buff()
     {
-        assert(self_mem_fd != -1);
+        assert(get_self_mem_fd() != -1);
     }
     void finalize() override
     {
@@ -715,7 +723,7 @@ class RTDyldMemoryManagerJL : public SectionMemoryManager {
           code_allocated(false)
     {
 #ifdef _OS_LINUX_
-        if (!ro_alloc && init_self_mem() != -1) {
+        if (!ro_alloc && get_self_mem_fd() != -1) {
             ro_alloc.reset(new SelfMemAllocator<false>());
             exe_alloc.reset(new SelfMemAllocator<true>());
         }
@@ -730,19 +738,20 @@ class RTDyldMemoryManagerJL : public SectionMemoryManager {
     }
     void registerEHFrames(uint8_t *Addr, uint64_t LoadAddr,
                           size_t Size) override;
+#if 0
+    // Disable for now since we are not actually using this.
     void deregisterEHFrames(uint8_t *Addr, uint64_t LoadAddr,
                             size_t Size) override;
+#endif
     uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
                                  unsigned SectionID,
                                  StringRef SectionName) override;
     uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
                                  unsigned SectionID, StringRef SectionName,
                                  bool isReadOnly) override;
-#if JL_LLVM_VERSION >= 30800
     using SectionMemoryManager::notifyObjectLoaded;
     void notifyObjectLoaded(RuntimeDyld &Dyld,
                             const object::ObjectFile &Obj) override;
-#endif
     bool finalizeMemory(std::string *ErrMsg = nullptr) override;
     template <typename DL, typename Alloc>
     void mapAddresses(DL &Dyld, Alloc &&allocator)
@@ -814,7 +823,6 @@ uint8_t *RTDyldMemoryManagerJL::allocateDataSection(uintptr_t Size,
                                                      SectionName, isReadOnly);
 }
 
-#if JL_LLVM_VERSION >= 30800
 void RTDyldMemoryManagerJL::notifyObjectLoaded(RuntimeDyld &Dyld,
                                                const object::ObjectFile &Obj)
 {
@@ -826,7 +834,6 @@ void RTDyldMemoryManagerJL::notifyObjectLoaded(RuntimeDyld &Dyld,
     assert(exe_alloc);
     mapAddresses(Dyld);
 }
-#endif
 
 bool RTDyldMemoryManagerJL::finalizeMemory(std::string *ErrMsg)
 {
@@ -858,23 +865,17 @@ void RTDyldMemoryManagerJL::registerEHFrames(uint8_t *Addr,
     }
 }
 
+#if 0
 void RTDyldMemoryManagerJL::deregisterEHFrames(uint8_t *Addr,
                                                uint64_t LoadAddr,
                                                size_t Size)
 {
     deregister_eh_frames((uint8_t*)LoadAddr, Size);
 }
+#endif
 
 }
 
-#if JL_LLVM_VERSION < 30800
-void notifyObjectLoaded(RTDyldMemoryManager *memmgr,
-                        llvm::orc::ObjectLinkingLayerBase::ObjSetHandleT H)
-{
-    ((RTDyldMemoryManagerJL*)memmgr)->mapAddresses(**H);
-}
-#endif
-
 #ifdef _OS_WINDOWS_
 void *lookupWriteAddressFor(RTDyldMemoryManager *memmgr, void *rt_addr)
 {
@@ -882,12 +883,7 @@ void *lookupWriteAddressFor(RTDyldMemoryManager *memmgr, void *rt_addr)
 }
 #endif
 
-#else // JL_LLVM_VERSION >= 30700
-typedef SectionMemoryManager RTDyldMemoryManagerJL;
-#endif // JL_LLVM_VERSION >= 30700
-
 RTDyldMemoryManager* createRTDyldMemoryManager()
 {
     return new RTDyldMemoryManagerJL();
 }
-#endif // USE_MCJIT
diff --git a/src/cgutils.cpp b/src/cgutils.cpp
index c3afcdcf75408c..a4ca0497233823 100644
--- a/src/cgutils.cpp
+++ b/src/cgutils.cpp
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 // utility procedures used in code generation
 
@@ -8,10 +8,43 @@ static Instruction *tbaa_decorate(MDNode *md, Instruction *load_or_store)
     return load_or_store;
 }
 
-static Value *prepare_call(IRBuilder<> &builder, Value *Callee)
+static Function *function_proto(Function *F, Module *M = nullptr)
+{
+    // Copy the declaration characteristics of the Function (not the body)
+    Function *NewF = Function::Create(F->getFunctionType(),
+                                      Function::ExternalLinkage,
+                                      F->getName(),
+                                      M);
+
+    // Declarations are not allowed to have personality routines, but
+    // copyAttributesFrom sets them anyway. Temporarily unset the personality
+    // routine from `F`, since copying it and then resetting is more expensive
+    // as well as introducing an extra use from this unowned function, which
+    // can cause crashes in the LLVMContext's global destructor.
+    llvm::Constant *OldPersonalityFn = nullptr;
+    if (F->hasPersonalityFn()) {
+        OldPersonalityFn = F->getPersonalityFn();
+        F->setPersonalityFn(nullptr);
+    }
+
+     // 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);
+
+    if (OldPersonalityFn)
+        F->setPersonalityFn(OldPersonalityFn);
+
+    // DLLImport only needs to be set for the shadow module
+    // it just gets annoying in the JIT
+    NewF->setDLLStorageClass(GlobalValue::DefaultStorageClass);
+
+    return NewF;
+}
+
+#define prepare_call(Callee) prepare_call_in(jl_Module, (Callee))
+static Value *prepare_call_in(Module *M, Value *Callee)
 {
     if (Function *F = dyn_cast<Function>(Callee)) {
-        Module *M = jl_builderModule;
         GlobalValue *local = M->getNamedValue(Callee->getName());
         if (!local) {
             local = function_proto(F, M);
@@ -20,22 +53,58 @@ static Value *prepare_call(IRBuilder<> &builder, Value *Callee)
     }
     return Callee;
 }
-static Value *prepare_call(Value *Callee)
+
+static Value *maybe_decay_untracked(IRBuilder<> &irbuilder, Value *V)
+{
+    if (V->getType() == T_pjlvalue)
+        return irbuilder.CreateAddrSpaceCast(V, T_prjlvalue);
+    else if (V->getType() == T_ppjlvalue)
+        return irbuilder.CreateBitCast(V, T_pprjlvalue);
+    return V;
+}
+
+static Constant *maybe_decay_untracked(IRBuilder<> &irbuilder, Constant *C)
+{
+    if (C->getType() == T_pjlvalue)
+        return ConstantExpr::getAddrSpaceCast(C, T_prjlvalue);
+    else if (C->getType() == T_ppjlvalue)
+        return ConstantExpr::getBitCast(C, T_pprjlvalue);
+    return C;
+}
+
+static Value *decay_derived(IRBuilder<> &irbuilder, Value *V)
+{
+    Type *T = V->getType();
+    if (cast<PointerType>(T)->getAddressSpace() == AddressSpace::Derived)
+        return V;
+    // Once llvm deletes pointer element types, we won't need it here any more either.
+    Type *NewT = PointerType::get(cast<PointerType>(T)->getElementType(), AddressSpace::Derived);
+    return irbuilder.CreateAddrSpaceCast(V, NewT);
+}
+
+static Value *mark_callee_rooted(IRBuilder<> &irbuilder, Value *V)
 {
-    return prepare_call(builder, Callee);
+    assert(V->getType() == T_pjlvalue || V->getType() == T_prjlvalue);
+    return irbuilder.CreateAddrSpaceCast(V,
+        PointerType::get(T_jlvalue, AddressSpace::CalleeRooted));
 }
 
+#define maybe_decay_untracked(V)  maybe_decay_untracked(ctx.builder, (V))
+#define maybe_decay_untracked(V)  maybe_decay_untracked(ctx.builder, (V))
+#define decay_derived(V)          decay_derived(ctx.builder, (V))
+#define mark_callee_rooted(V)     mark_callee_rooted(ctx.builder, (V))
+
 
 // --- language feature checks ---
 
 // branch on whether a language feature is enabled or not
-#define JL_FEAT_TEST(ctx, feature) ((ctx)->params->feature)
+#define JL_FEAT_TEST(ctx, feature) ((ctx).params->feature)
 
 // require a language feature to be enabled
 #define JL_FEAT_REQUIRE(ctx, feature) \
     if (!JL_FEAT_TEST(ctx, feature)) \
         jl_errorf("%s for %s:%d requires the " #feature " language feature, which is disabled", \
-                  __FUNCTION__, (ctx)->file.str().c_str(), *(ctx)->line);
+                  __FUNCTION__, (ctx).file.str().c_str(), *(ctx).line);
 
 
 // --- hook checks ---
@@ -58,48 +127,32 @@ static inline void _hook_call(jl_value_t *hook, std::array<jl_value_t*,N> args)
 
 // --- string constants ---
 static StringMap<GlobalVariable*> stringConstants;
-static Value *stringConstPtr(IRBuilder<> &builder, const std::string &txt)
+static Value *stringConstPtr(IRBuilder<> &irbuilder, const std::string &txt)
 {
     StringRef ctxt(txt.c_str(), strlen(txt.c_str()) + 1);
-#if JL_LLVM_VERSION >= 30600
     StringMap<GlobalVariable*>::iterator pooledval =
         stringConstants.insert(std::pair<StringRef, GlobalVariable*>(ctxt, NULL)).first;
-#else
-    StringMap<GlobalVariable*>::MapEntryTy *pooledval =
-        &stringConstants.GetOrCreateValue(ctxt, (GlobalVariable*)NULL);
-#endif
     StringRef pooledtxt = pooledval->getKey();
     if (imaging_mode) {
         if (pooledval->second == NULL) {
             static int strno = 0;
             std::stringstream ssno;
             ssno << "_j_str" << strno++;
-            GlobalVariable *gv = new GlobalVariable(*shadow_output,
-                                    ArrayType::get(T_int8, pooledtxt.size()),
-                                    true,
-                                    GlobalVariable::PrivateLinkage,
+            GlobalVariable *gv = get_pointer_to_constant(
                                     ConstantDataArray::get(jl_LLVMContext,
                                                            ArrayRef<unsigned char>(
                                                            (const unsigned char*)pooledtxt.data(),
                                                            pooledtxt.size())),
-                                    ssno.str());
-#if JL_LLVM_VERSION >= 30900
-            gv->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
-#else
-            gv->setUnnamedAddr(true);
-#endif
+                                    ssno.str(),
+                                    *shadow_output);
             pooledval->second = gv;
             jl_ExecutionEngine->addGlobalMapping(gv, (void*)(uintptr_t)pooledtxt.data());
         }
 
-        GlobalVariable *v = prepare_global(pooledval->second, jl_builderModule);
+        GlobalVariable *v = prepare_global_in(jl_builderModule(irbuilder), pooledval->second);
         Value *zero = ConstantInt::get(Type::getInt32Ty(jl_LLVMContext), 0);
         Value *Args[] = { zero, zero };
-#if JL_LLVM_VERSION >= 30700
-        return builder.CreateInBoundsGEP(v->getValueType(), v, Args);
-#else
-        return builder.CreateInBoundsGEP(v, Args);
-#endif
+        return irbuilder.CreateInBoundsGEP(v->getValueType(), v, Args);
     }
     else {
         Value *v = ConstantExpr::getIntToPtr(
@@ -108,143 +161,112 @@ static Value *stringConstPtr(IRBuilder<> &builder, const std::string &txt)
         return v;
     }
 }
-static Value *stringConstPtr(const std::string &txt)
-{
-    return stringConstPtr(builder, txt);
-}
 
 // --- Debug info ---
 
-#if JL_LLVM_VERSION >= 30700
 static DIType *julia_type_to_di(jl_value_t *jt, DIBuilder *dbuilder, bool isboxed = false)
-#else
-static DIType julia_type_to_di(jl_value_t *jt, DIBuilder *dbuilder, bool isboxed = false)
-#endif
 {
-    if (isboxed)
+    if (isboxed || !jl_is_datatype(jt))
         return jl_pvalue_dillvmt;
+    jl_datatype_t *jdt = (jl_datatype_t*)jt;
     // always return the boxed representation for types with hidden content
-    if (jl_is_abstracttype(jt) || !jl_is_datatype(jt) || jl_is_array_type(jt) ||
+    if (jl_is_abstracttype(jt) || jl_is_array_type(jt) ||
         jt == (jl_value_t*)jl_sym_type || jt == (jl_value_t*)jl_module_type ||
         jt == (jl_value_t*)jl_simplevector_type || jt == (jl_value_t*)jl_datatype_type ||
         jt == (jl_value_t*)jl_method_instance_type)
         return jl_pvalue_dillvmt;
-    if (jl_is_unionall(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) {
-#if JL_LLVM_VERSION >= 30700
         DIType* t = (DIType*)jdt->ditype;
-#if JL_LLVM_VERSION < 30900
-        // On LLVM 3.7 and 3.8, DICompositeType with a unique name
-        // are ref'd by their unique name and needs to be explicitly
-        // retained in order to be used in the module.
-        if (auto *Composite = dyn_cast<DICompositeType>(t)) {
-            if (Composite->getRawIdentifier()) {
-                dbuilder->retainType(Composite);
-            }
-        }
-#endif
         return t;
-#else
-        return DIType((llvm::MDNode*)jdt->ditype);
-#endif
     }
     if (jl_is_primitivetype(jt)) {
         uint64_t SizeInBits = jl_datatype_nbits(jdt);
-    #if JL_LLVM_VERSION >= 40000
+#if JL_LLVM_VERSION >= 40000
         llvm::DIType *t = dbuilder->createBasicType(
                 jl_symbol_name(jdt->name->name),
                 SizeInBits,
                 llvm::dwarf::DW_ATE_unsigned);
         jdt->ditype = t;
         return t;
-    #elif JL_LLVM_VERSION >= 30700
+#else
         llvm::DIType *t = dbuilder->createBasicType(
                 jl_symbol_name(jdt->name->name),
                 SizeInBits,
-                8 * jdt->layout->alignment,
+                8 * jl_datatype_align(jdt),
                 llvm::dwarf::DW_ATE_unsigned);
         jdt->ditype = t;
         return t;
-    #else
-        DIType t = dbuilder->createBasicType(
-                jl_symbol_name(jdt->name->name),
-                SizeInBits,
-                8 * jdt->layout->alignment,
-                llvm::dwarf::DW_ATE_unsigned);
-        MDNode *M = t;
-        jdt->ditype = M;
-        return t;
-    #endif
-    }
-    #if JL_LLVM_VERSION >= 30700
-    else if (!jl_is_concrete_type(jt)) {
-        jdt->ditype = jl_pvalue_dillvmt;
-        return jl_pvalue_dillvmt;
+#endif
     }
-    else if (jl_is_structtype(jt)) {
-        jl_datatype_t *jst = (jl_datatype_t*)jt;
-        size_t ntypes = jl_datatype_nfields(jst);
+    if (jl_is_structtype(jt) && jdt->layout) {
+        size_t ntypes = jl_datatype_nfields(jdt);
         const char *tname = jl_symbol_name(jdt->name->name);
         std::stringstream unique_name;
         unique_name << tname << "_" << globalUnique++;
         llvm::DICompositeType *ct = dbuilder->createStructType(
-            NULL,                       // Scope
-            tname,                      // Name
-            NULL,                       // File
-            0,                          // LineNumber
-            jl_datatype_nbits(jdt),     // SizeInBits
-            8 * jdt->layout->alignment, // AlignInBits
-            DIFlagZero,                 // Flags
-            NULL,                       // DerivedFrom
-            DINodeArray(),              // Elements
-            dwarf::DW_LANG_Julia,       // RuntimeLanguage
-            nullptr,                    // VTableHolder
-            unique_name.str()           // UniqueIdentifier
-            );
+                NULL,                       // Scope
+                tname,                      // Name
+                NULL,                       // File
+                0,                          // LineNumber
+                jl_datatype_nbits(jdt),     // SizeInBits
+                8 * jl_datatype_align(jdt), // AlignInBits
+                DIFlagZero,                 // Flags
+                NULL,                       // DerivedFrom
+                DINodeArray(),              // Elements
+                dwarf::DW_LANG_Julia,       // RuntimeLanguage
+                nullptr,                    // VTableHolder
+                unique_name.str()           // UniqueIdentifier
+                );
         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));
+        for (unsigned i = 0; i < ntypes; i++)
+            Elements.push_back(julia_type_to_di(jl_svecref(jdt->types, i), dbuilder, false));
         dbuilder->replaceArrays(ct, dbuilder->getOrCreateArray(ArrayRef<Metadata*>(Elements)));
         return ct;
     }
-    else {
-        assert(jl_is_datatype(jt));
-        jdt->ditype = dbuilder->createTypedef(jl_pvalue_dillvmt,
+    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;
+    return (llvm::DIType*)jdt->ditype;
+}
+
+static Value *emit_pointer_from_objref(jl_codectx_t &ctx, Value *V)
+{
+    unsigned AS = cast<PointerType>(V->getType())->getAddressSpace();
+    if (AS != AddressSpace::Tracked && AS != AddressSpace::Derived)
+        return ctx.builder.CreateBitCast(V, T_pjlvalue);
+    V = ctx.builder.CreateBitCast(decay_derived(V),
+            PointerType::get(T_jlvalue, AddressSpace::Derived));
+    CallInst *Call = ctx.builder.CreateCall(prepare_call(pointer_from_objref_func), V);
+#if JL_LLVM_VERSION >= 50000
+    Call->addAttribute(AttributeList::FunctionIndex, Attribute::ReadNone);
+#else
+    Call->addAttribute(AttributeSet::FunctionIndex, Attribute::ReadNone);
+#endif
+    return Call;
 }
 
 // --- emitting pointers directly into code ---
 
-static Value *literal_static_pointer_val(const void *p, Type *t)
+static Constant *literal_static_pointer_val(jl_codectx_t &ctx, 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,
     // and thus, this should typically be avoided in new API's
 #if defined(_P64)
-    return ConstantExpr::getIntToPtr(ConstantInt::get(T_int64, (uint64_t)p), t);
+    return ConstantExpr::getPointerBitCastOrAddrSpaceCast(ConstantExpr::getIntToPtr(ConstantInt::get(T_int64, (uint64_t)p), T_pjlvalue), t);
 #else
-    return ConstantExpr::getIntToPtr(ConstantInt::get(T_int32, (uint32_t)p), t);
+    return ConstantExpr::getPointerBitCastOrAddrSpaceCast(ConstantExpr::getIntToPtr(ConstantInt::get(T_int32, (uint32_t)p), T_pjlvalue), t);
 #endif
 }
 
 
-static Value *julia_gv(const char *cname, void *addr)
+static Value *julia_pgv(jl_codectx_t &ctx, const char *cname, void *addr)
 {
     // emit a GlobalVariable for a jl_value_t named "cname"
-    GlobalVariable *gv = jl_get_global_for(cname, addr, jl_builderModule);
-    return tbaa_decorate(tbaa_const, builder.CreateLoad(gv));
+    return jl_get_global_for(cname, addr, jl_Module);
 }
 
-static Value *julia_gv(const char *prefix, jl_sym_t *name, jl_module_t *mod, void *addr)
+static Value *julia_pgv(jl_codectx_t &ctx, const char *prefix, jl_sym_t *name, jl_module_t *mod, void *addr)
 {
     // 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
@@ -257,71 +279,88 @@ static Value *julia_gv(const char *prefix, jl_sym_t *name, jl_module_t *mod, voi
     }
     char *fullname = (char*)alloca(len);
     strcpy(fullname, prefix);
-    len -= strlen(jl_symbol_name(name))+1;
-    strcpy(fullname + len, jl_symbol_name(name));
+    int skipfirst = jl_symbol_name(name)[0] == '@';
+    len -= strlen(jl_symbol_name(name)) + 1 - skipfirst;
+    strcpy(fullname + len, jl_symbol_name(name) + skipfirst);
     parent = mod;
     prev = NULL;
     while (parent != NULL && parent != prev) {
-        size_t part = strlen(jl_symbol_name(parent->name))+1;
-        strcpy(fullname+len-part,jl_symbol_name(parent->name));
+        size_t part = strlen(jl_symbol_name(parent->name))+1-skipfirst;
+        strcpy(fullname+len-part,jl_symbol_name(parent->name)+skipfirst);
         fullname[len-1] = '.';
         len -= part;
         prev = parent;
         parent = parent->parent;
     }
-    return julia_gv(fullname, addr);
+    return julia_pgv(ctx, fullname, addr);
 }
 
 static GlobalVariable *julia_const_gv(jl_value_t *val);
-static Value *literal_pointer_val(jl_value_t *p)
+static Value *literal_pointer_val_slot(jl_codectx_t &ctx, jl_value_t *p)
 {
-    // emit a pointer to any jl_value_t which will be valid across reloading code
+    // emit a pointer to a jl_value_t* which will allow it to 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*)T_pjlvalue);
-    if (!imaging_mode)
-        return literal_static_pointer_val(p, T_pjlvalue);
-    if (auto gv = julia_const_gv(p)) {
-        return tbaa_decorate(tbaa_const, builder.CreateLoad(prepare_global(gv)));
+    if (!imaging_mode) {
+        Module *M = jl_Module;
+        GlobalVariable *gv = new GlobalVariable(
+                *M, T_pjlvalue, true, GlobalVariable::PrivateLinkage,
+                literal_static_pointer_val(ctx, p, T_pjlvalue));
+        gv->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
+        return gv;
+    }
+    if (GlobalVariable *gv = julia_const_gv(p)) {
+        // if this is a known object, use the existing GlobalValue
+        return maybe_decay_untracked(prepare_global(gv));
     }
     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);
+        return maybe_decay_untracked(julia_pgv(ctx, "+", addr->name->name, addr->name->module, p));
     }
     if (jl_is_method(p)) {
         jl_method_t *m = (jl_method_t*)p;
         // functions are prefixed with a -
-        return julia_gv("-", m->name, m->module, p);
+        return maybe_decay_untracked(julia_pgv(ctx, "-", m->name, m->module, p));
     }
     if (jl_is_method_instance(p)) {
         jl_method_instance_t *linfo = (jl_method_instance_t*)p;
         // Type-inferred functions are also prefixed with a -
-        if (linfo->def)
-            return julia_gv("-", linfo->def->name, linfo->def->module, p);
+        if (jl_is_method(linfo->def.method))
+            return maybe_decay_untracked(julia_pgv(ctx, "-", linfo->def.method->name, linfo->def.method->module, p));
     }
     if (jl_is_symbol(p)) {
         jl_sym_t *addr = (jl_sym_t*)p;
         // Symbols are prefixed with jl_sym#
-        return julia_gv("jl_sym#", addr, NULL, p);
+        return maybe_decay_untracked(julia_pgv(ctx, "jl_sym#", addr, NULL, p));
     }
     // something else gets just a generic name
-    return julia_gv("jl_global#", p);
+    return maybe_decay_untracked(julia_pgv(ctx, "jl_global#", p));
 }
 
-static Value *literal_pointer_val(jl_binding_t *p)
+static Value *literal_pointer_val(jl_codectx_t &ctx, jl_value_t *p)
+{
+    if (p == NULL)
+        return V_null;
+    if (!imaging_mode)
+        return literal_static_pointer_val(ctx, p, T_prjlvalue);
+    Value *pgv = literal_pointer_val_slot(ctx, p);
+    return tbaa_decorate(tbaa_const, ctx.builder.CreateLoad(pgv));
+}
+
+static Value *literal_pointer_val(jl_codectx_t &ctx, 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*)T_pjlvalue);
+        return V_null;
     if (!imaging_mode)
-        return literal_static_pointer_val(p, T_pjlvalue);
+        return literal_static_pointer_val(ctx, p, T_pjlvalue);
     // bindings are prefixed with jl_bnd#
-    return julia_gv("jl_bnd#", p->name, p->owner, p);
+    Value *pgv = julia_pgv(ctx, "jl_bnd#", p->name, p->owner, p);
+    return tbaa_decorate(tbaa_const, ctx.builder.CreateLoad(pgv));
 }
 
 // bitcast a value, but preserve its address space when dealing with pointer types
-static Value *emit_bitcast(Value *v, Type *jl_value)
+static Value *emit_bitcast(jl_codectx_t &ctx, Value *v, Type *jl_value)
 {
     if (isa<PointerType>(jl_value) &&
         v->getType()->getPointerAddressSpace() != jl_value->getPointerAddressSpace()) {
@@ -329,28 +368,32 @@ static Value *emit_bitcast(Value *v, Type *jl_value)
         Type *jl_value_addr =
                 PointerType::get(cast<PointerType>(jl_value)->getElementType(),
                                  v->getType()->getPointerAddressSpace());
-        return builder.CreateBitCast(v, jl_value_addr);
+        return ctx.builder.CreateBitCast(v, jl_value_addr);
     }
     else {
-        return builder.CreateBitCast(v, jl_value);
+        return ctx.builder.CreateBitCast(v, jl_value);
     }
 }
 
-static Value *julia_binding_gv(Value *bv)
+static Value *julia_binding_gv(jl_codectx_t &ctx, Value *bv)
 {
-    return builder.
-        CreateGEP(bv,ConstantInt::get(T_size,
-                                      offsetof(jl_binding_t,value)/sizeof(size_t)));
+    Value *offset = ConstantInt::get(T_size, offsetof(jl_binding_t, value) / sizeof(size_t));
+    return ctx.builder.CreateGEP(bv, offset);
 }
 
-static Value *julia_binding_gv(jl_binding_t *b)
+static Value *julia_binding_gv(jl_codectx_t &ctx, 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 ?
-        emit_bitcast(julia_gv("*", b->name, b->owner, b), T_ppjlvalue) :
-        literal_static_pointer_val(b,T_ppjlvalue);
-    return julia_binding_gv(bv);
+    Value *bv;
+    if (imaging_mode)
+        bv = emit_bitcast(ctx,
+                tbaa_decorate(tbaa_const,
+                              ctx.builder.CreateLoad(julia_pgv(ctx, "*", b->name, b->owner, b))),
+                T_pprjlvalue);
+    else
+        bv = literal_static_pointer_val(ctx, b, T_pprjlvalue);
+    return julia_binding_gv(ctx, bv);
 }
 
 // --- mapping between julia and llvm types ---
@@ -386,6 +429,10 @@ static Type *bitstype_to_llvm(jl_value_t *bt)
         return T_int8;
     if (bt == (jl_value_t*)jl_long_type)
         return T_size;
+    if (bt == (jl_value_t*)jl_float32_type)
+        return T_float32;
+    if (bt == (jl_value_t*)jl_float64_type)
+        return T_float64;
     if (jl_is_cpointer_type(bt)) {
         Type *lt = julia_type_to_llvm(jl_tparam0(bt));
         if (lt == T_void)
@@ -393,19 +440,6 @@ static Type *bitstype_to_llvm(jl_value_t *bt)
         return PointerType::get(lt, 0);
     }
     int nb = jl_datatype_size(bt);
-    if (jl_is_floattype(bt)) {
-#ifndef DISABLE_FLOAT16
-        if (nb == 2)
-            return T_float16;
-        else
-#endif
-        if (nb == 4)
-            return T_float32;
-        else if (nb == 8)
-            return T_float64;
-        else if (nb == 16)
-            return T_float128;
-    }
     return Type::getIntNTy(jl_LLVMContext, nb * 8);
 }
 
@@ -417,7 +451,7 @@ static bool julia_struct_has_layout(jl_datatype_t *dt, jl_unionall_t *ua)
     if (dt->layout || dt->struct_decl || jl_is_primitivetype(dt) || jl_isbits(dt))
         return true;
     if (ua) {
-        size_t i, ntypes = jl_datatype_nfields(dt);
+        size_t i, ntypes = jl_svec_len(dt->types);
         for (i = 0; i < ntypes; i++) {
             jl_value_t *ty = jl_svecref(dt->types, i);
             if (jl_has_typevar_from_unionall(ty, ua))
@@ -438,8 +472,8 @@ static Type *julia_struct_to_llvm(jl_value_t *jt, jl_unionall_t *ua, bool *isbox
     if (jl_is_primitivetype(jt))
         return bitstype_to_llvm(jt);
     bool isTuple = jl_is_tuple_type(jt);
-    if ((isTuple || jl_is_structtype(jt)) && !jl_is_array_type(jt)) {
-        jl_datatype_t *jst = (jl_datatype_t*)jt;
+    jl_datatype_t *jst = (jl_datatype_t*)jt;
+    if (jl_is_structtype(jt) && !(jst->layout && jl_is_layout_opaque(jst->layout))) {
         if (jst->struct_decl == NULL) {
             size_t i, ntypes = jl_svec_len(jst->types);
             if (ntypes == 0 || (jst->layout && jl_datatype_nbits(jst) == 0))
@@ -505,18 +539,22 @@ static Type *julia_struct_to_llvm(jl_value_t *jt, jl_unionall_t *ua, bool *isbox
                     jst->struct_decl = StructType::get(jl_LLVMContext, ArrayRef<Type*>(&latypes[0], ntypes));
                 }
             }
-#ifndef NDEBUG
+#ifndef JL_NDEBUG
             // If LLVM and Julia disagree about alignment, much trouble ensues, so check it!
             if (jst->layout) {
                 const DataLayout &DL =
-#if JL_LLVM_VERSION >= 30600
-                    jl_ExecutionEngine->getDataLayout();
+#if JL_LLVM_VERSION >= 40000
+                    jl_data_layout;
 #else
-                    *jl_ExecutionEngine->getDataLayout();
+                    jl_ExecutionEngine->getDataLayout();
 #endif
                 unsigned llvm_alignment = DL.getABITypeAlignment((Type*)jst->struct_decl);
-                unsigned julia_alignment = jst->layout->alignment;
-                assert(llvm_alignment == julia_alignment);
+                unsigned julia_alignment = jl_datatype_align(jst);
+                // Check that the alignment adheres to the heap alignment.
+                assert(julia_alignment <= JL_HEAP_ALIGNMENT);
+                // TODO: Fix alignment calculation in LLVM, as well as in the GC and the struct declaration
+                if (llvm_alignment  <= JL_HEAP_ALIGNMENT)
+                    assert(julia_alignment == llvm_alignment);
             }
 #endif
         }
@@ -537,15 +575,24 @@ static bool is_datatype_all_pointers(jl_datatype_t *dt)
     return true;
 }
 
-static bool is_tupletype_homogeneous(jl_svec_t *t)
+static bool is_tupletype_homogeneous(jl_svec_t *t, bool allow_va = false)
 {
     size_t i, l = jl_svec_len(t);
     if (l > 0) {
         jl_value_t *t0 = jl_svecref(t, 0);
-        if (!jl_is_concrete_type(t0))
+        if (!jl_is_concrete_type(t0)) {
+            if (allow_va && jl_is_vararg_type(t0) &&
+                  jl_is_concrete_type(jl_unwrap_vararg(t0)))
+                return true;
             return false;
+        }
         for(i=1; i < l; i++) {
-            if (!jl_types_equal(t0, jl_svecref(t,i)))
+            if (allow_va && i == l - 1 && jl_is_vararg_type(jl_svecref(t,i))) {
+                if (t0 != jl_unwrap_vararg(jl_svecref(t,i)))
+                    return false;
+                continue;
+            }
+            if (t0 != jl_svecref(t,i))
                 return false;
         }
     }
@@ -558,67 +605,150 @@ static bool deserves_sret(jl_value_t *dt, Type *T)
     return (size_t)jl_datatype_size(dt) > sizeof(void*) && !T->isFloatingPointTy() && !T->isVectorTy();
 }
 
+static bool for_each_uniontype_small(
+        std::function<void(unsigned, jl_datatype_t*)> f,
+        jl_value_t *ty,
+        unsigned &counter)
+{
+    if (counter > 127)
+        return false;
+    if (jl_is_uniontype(ty)) {
+        bool allunbox = for_each_uniontype_small(f, ((jl_uniontype_t*)ty)->a, counter);
+        allunbox &= for_each_uniontype_small(f, ((jl_uniontype_t*)ty)->b, counter);
+        return allunbox;
+    }
+    else if (isbits_spec(ty)) {
+        f(++counter, (jl_datatype_t*)ty);
+        return true;
+    }
+    return false;
+}
+
+static Value *emit_typeof_boxed(jl_codectx_t &ctx, const jl_cgval_t &p);
+
+static unsigned get_box_tindex(jl_datatype_t *jt, jl_value_t *ut)
+{
+    unsigned new_idx = 0;
+    unsigned new_counter = 0;
+    for_each_uniontype_small(
+            // find the corresponding index in the new union-type
+            [&](unsigned new_idx_, jl_datatype_t *new_jt) {
+                if (jt == new_jt)
+                    new_idx = new_idx_;
+            },
+            ut,
+            new_counter);
+    return new_idx;
+}
+
+
 // --- generating various field accessors ---
 
-static Value *emit_nthptr_addr(Value *v, ssize_t n)
+static Value *emit_nthptr_addr(jl_codectx_t &ctx, Value *v, ssize_t n, bool gctracked = true)
 {
-    return builder.CreateGEP(emit_bitcast(v, T_ppjlvalue),
+    return ctx.builder.CreateGEP(emit_bitcast(ctx, gctracked ? decay_derived(v) : v, T_pprjlvalue),
                              ConstantInt::get(T_size, n));
 }
 
-static Value *emit_nthptr_addr(Value *v, Value *idx)
+static Value *emit_nthptr_addr(jl_codectx_t &ctx, Value *v, Value *idx, bool gctracked = true)
 {
-    return builder.CreateGEP(emit_bitcast(v, T_ppjlvalue), idx);
+    return ctx.builder.CreateGEP(emit_bitcast(ctx, gctracked ? decay_derived(v) : v, T_pprjlvalue), idx);
 }
 
-static Value *emit_nthptr(Value *v, ssize_t n, MDNode *tbaa)
+static Value *emit_nthptr(jl_codectx_t &ctx, Value *v, ssize_t n, MDNode *tbaa)
 {
     // p = (jl_value_t**)v; p[n]
-    Value *vptr = emit_nthptr_addr(v, n);
-    return tbaa_decorate(tbaa,builder.CreateLoad(vptr, false));
+    Value *vptr = emit_nthptr_addr(ctx, v, n);
+    return tbaa_decorate(tbaa, ctx.builder.CreateLoad(vptr, false));
 }
 
-static Value *emit_nthptr_recast(Value *v, Value *idx, MDNode *tbaa, Type *ptype)
+static Value *emit_nthptr_recast(jl_codectx_t &ctx, Value *v, Value *idx, MDNode *tbaa, Type *ptype, bool gctracked = true)
 {
     // p = (jl_value_t**)v; *(ptype)&p[n]
-    Value *vptr = emit_nthptr_addr(v, idx);
-    return tbaa_decorate(tbaa,builder.CreateLoad(emit_bitcast(vptr,ptype), false));
+    Value *vptr = emit_nthptr_addr(ctx, v, idx, gctracked);
+    return tbaa_decorate(tbaa, ctx.builder.CreateLoad(emit_bitcast(ctx, vptr, ptype), false));
 }
 
-static Value *emit_nthptr_recast(Value *v, ssize_t n, MDNode *tbaa, Type *ptype)
+static Value *emit_nthptr_recast(jl_codectx_t &ctx, Value *v, ssize_t n, MDNode *tbaa, Type *ptype, bool gctracked = true)
 {
     // p = (jl_value_t**)v; *(ptype)&p[n]
-    Value *vptr = emit_nthptr_addr(v, n);
-    return tbaa_decorate(tbaa,builder.CreateLoad(emit_bitcast(vptr,ptype), false));
+    Value *vptr = emit_nthptr_addr(ctx, v, n, gctracked);
+    return tbaa_decorate(tbaa, ctx.builder.CreateLoad(emit_bitcast(ctx, vptr, ptype), false));
 }
 
-static Value *emit_typeptr_addr(Value *p)
+static Value *emit_typeptr_addr(jl_codectx_t &ctx, Value *p)
 {
     ssize_t offset = (sizeof(jl_taggedvalue_t) -
                       offsetof(jl_taggedvalue_t, type)) / sizeof(jl_value_t*);
-    return emit_nthptr_addr(p, -offset);
+    return emit_nthptr_addr(ctx, p, -offset);
 }
 
-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 Value *boxed(jl_codectx_t &ctx, const jl_cgval_t &v, bool gcooted=true);
+static Value *boxed(jl_codectx_t &ctx, const jl_cgval_t &v, jl_value_t* type) = delete; // C++11 (temporary to prevent rebase error)
 
-static Value *emit_typeof(Value *tt)
+static Value* mask_gc_bits(jl_codectx_t &ctx, Value *tag)
 {
+    return ctx.builder.CreateIntToPtr(ctx.builder.CreateAnd(
+                ctx.builder.CreatePtrToInt(tag, T_size),
+                ConstantInt::get(T_size, ~(uintptr_t)15)),
+            tag->getType());
+}
+
+static Value *emit_typeof(jl_codectx_t &ctx, Value *tt)
+{
+    assert(tt != NULL && !isa<AllocaInst>(tt) && "expected a conditionally boxed value");
     // given p, a jl_value_t*, compute its type tag
-    assert(tt->getType() == T_pjlvalue);
-    tt = tbaa_decorate(tbaa_tag, builder.CreateLoad(emit_typeptr_addr(tt), false));
-    tt = builder.CreateIntToPtr(builder.CreateAnd(
-                builder.CreatePtrToInt(tt, T_size),
-                ConstantInt::get(T_size,~(uintptr_t)15)),
-            T_pjlvalue);
-    return tt;
+    // The raw address is not GC-safe to load from as it may have mask bits set.
+    // Note that this gives the optimizer license to not root this value. That
+    // is fine however, since concrete types are not GCed at the moment. Should
+    // that ever change, this may have to go through a special intrinsic.
+    Value *addr = emit_bitcast(ctx, emit_typeptr_addr(ctx, tt), T_ppjlvalue);
+    tt = tbaa_decorate(tbaa_tag, ctx.builder.CreateLoad(addr));
+    return maybe_decay_untracked(mask_gc_bits(ctx, tt));
 }
 
-static jl_cgval_t emit_typeof(const jl_cgval_t &p, jl_codectx_t *ctx)
+static jl_cgval_t emit_typeof(jl_codectx_t &ctx, const jl_cgval_t &p)
 {
     // given p, compute its type
-    if (!p.constant && p.isboxed && !jl_is_concrete_type(p.typ)) {
-        return mark_julia_type(emit_typeof(p.V), true, jl_datatype_type, ctx, /*needsroot*/false);
+    if (p.constant)
+        return mark_julia_const(jl_typeof(p.constant));
+    if (p.isboxed && !jl_is_concrete_type(p.typ)) {
+        return mark_julia_type(ctx, emit_typeof(ctx, p.V), true, jl_datatype_type, /*needsroot*/false);
+    }
+    if (p.TIndex) {
+        Value *tindex = ctx.builder.CreateAnd(p.TIndex, ConstantInt::get(T_int8, 0x7f));
+        Value *pdatatype;
+        unsigned counter;
+        counter = 0;
+        bool allunboxed = for_each_uniontype_small(
+                [&](unsigned idx, jl_datatype_t *jt) { },
+                p.typ,
+                counter);
+        if (allunboxed)
+            pdatatype = Constant::getNullValue(T_ppjlvalue);
+        else {
+            // See note above in emit_typeof(Value*), we can't tell the system
+            // about this until we've cleared the GC bits.
+            pdatatype = emit_bitcast(ctx, emit_typeptr_addr(ctx, ctx.builder.CreateLoad(p.gcroot)), T_ppjlvalue);
+        }
+        counter = 0;
+        for_each_uniontype_small(
+                [&](unsigned idx, jl_datatype_t *jt) {
+                    Value *cmp = ctx.builder.CreateICmpEQ(tindex, ConstantInt::get(T_int8, idx));
+                    pdatatype = ctx.builder.CreateSelect(cmp,
+                        decay_derived(emit_bitcast(ctx, literal_pointer_val_slot(ctx, (jl_value_t*)jt), T_ppjlvalue)),
+                        decay_derived(pdatatype));
+                },
+                p.typ,
+                counter);
+        Value *datatype;
+        if (allunboxed) {
+            datatype = tbaa_decorate(tbaa_const, ctx.builder.CreateLoad(maybe_decay_untracked(pdatatype)));
+        }
+        else {
+            datatype = maybe_decay_untracked(mask_gc_bits(ctx, tbaa_decorate(tbaa_tag, ctx.builder.CreateLoad(pdatatype))));
+        }
+        return mark_julia_type(ctx, datatype, true, jl_datatype_type, /*needsroot*/false);
     }
     jl_value_t *aty = p.typ;
     if (jl_is_type_type(aty)) {
@@ -629,76 +759,116 @@ static jl_cgval_t emit_typeof(const jl_cgval_t &p, jl_codectx_t *ctx)
     return mark_julia_const(aty);
 }
 
-static Value *emit_typeof_boxed(const jl_cgval_t &p, jl_codectx_t *ctx)
+static Value *emit_typeof_boxed(jl_codectx_t &ctx, const jl_cgval_t &p)
 {
-    return boxed(emit_typeof(p, ctx), ctx);
+    return boxed(ctx, emit_typeof(ctx, p));
 }
 
-static Value *emit_datatype_types(Value *dt)
+static Value *emit_datatype_types(jl_codectx_t &ctx, Value *dt)
 {
-    return tbaa_decorate(tbaa_const, builder.
-        CreateLoad(emit_bitcast(builder.
-                                CreateGEP(emit_bitcast(dt, T_pint8),
-                                          ConstantInt::get(T_size, offsetof(jl_datatype_t, types))),
-                                T_ppjlvalue)));
+    Value *Ptr = emit_bitcast(ctx, decay_derived(dt), T_ppjlvalue);
+    Value *Idx = ConstantInt::get(T_size, offsetof(jl_datatype_t, types) / sizeof(void*));
+    return tbaa_decorate(tbaa_const, ctx.builder.CreateLoad(T_pjlvalue, ctx.builder.CreateGEP(T_pjlvalue, Ptr, Idx)));
 }
 
-static Value *emit_datatype_nfields(Value *dt)
+static Value *emit_datatype_nfields(jl_codectx_t &ctx, Value *dt)
 {
-    Value *nf = tbaa_decorate(tbaa_const, builder.CreateLoad(
-        tbaa_decorate(tbaa_const, builder.CreateLoad(
-            emit_bitcast(
-                builder.CreateGEP(
-                    emit_bitcast(dt, T_pint8),
-                    ConstantInt::get(T_size, offsetof(jl_datatype_t, types))),
-                T_pint32->getPointerTo())))));
-#ifdef _P64
-    nf = builder.CreateSExt(nf, T_int64);
-#endif
-    return nf;
+    Value *type_svec = emit_bitcast(ctx, emit_datatype_types(ctx, dt), T_psize);
+    return tbaa_decorate(tbaa_const, ctx.builder.CreateLoad(T_size, type_svec));
 }
 
-static Value *emit_datatype_size(Value *dt)
+static Value *emit_datatype_size(jl_codectx_t &ctx, Value *dt)
 {
-    Value *size = tbaa_decorate(tbaa_const, builder.
-        CreateLoad(emit_bitcast(builder.
-                                CreateGEP(emit_bitcast(dt, T_pint8),
-                                          ConstantInt::get(T_size, offsetof(jl_datatype_t, size))),
-                                T_pint32)));
-    return size;
+    Value *Ptr = emit_bitcast(ctx, decay_derived(dt), T_pint32);
+    Value *Idx = ConstantInt::get(T_size, offsetof(jl_datatype_t, size) / sizeof(int));
+    return tbaa_decorate(tbaa_const, ctx.builder.CreateLoad(T_int32, ctx.builder.CreateGEP(T_int32, Ptr, Idx)));
+}
+
+/* this is valid code, it's simply unused
+static Value *emit_sizeof(jl_codectx_t &ctx, const jl_cgval_t &p)
+{
+    if (p.TIndex) {
+        Value *tindex = ctx.builder.CreateAnd(p.TIndex, ConstantInt::get(T_int8, 0x7f));
+        Value *size = ConstantInt::get(T_int32, -1);
+        unsigned counter = 0;
+        bool allunboxed = for_each_uniontype_small(
+                [&](unsigned idx, jl_datatype_t *jt) {
+                    Value *cmp = ctx.builder.CreateICmpEQ(tindex, ConstantInt::get(T_int8, idx));
+                    size = ctx.builder.CreateSelect(cmp, ConstantInt::get(T_int32, jl_datatype_size(jt)), size);
+                },
+                p.typ,
+                counter);
+        if (!allunboxed && p.ispointer() && p.V && !isa<AllocaInst>(p.V)) {
+            BasicBlock *currBB = ctx.builder.GetInsertBlock();
+            BasicBlock *dynloadBB = BasicBlock::Create(jl_LLVMContext, "dyn_sizeof", ctx.f);
+            BasicBlock *postBB = BasicBlock::Create(jl_LLVMContext, "post_sizeof", ctx.f);
+            Value *isboxed = ctx.builder.CreateICmpNE(
+                    ctx.builder.CreateAnd(p.TIndex, ConstantInt::get(T_int8, 0x80)),
+                    ConstantInt::get(T_int8, 0));
+            ctx.builder.CreateCondBr(isboxed, dynloadBB, postBB);
+            ctx.builder.SetInsertPoint(dynloadBB);
+            Value *datatype = emit_typeof(p.V);
+            Value *dyn_size = emit_datatype_size(ctx, datatype);
+            ctx.builder.CreateBr(postBB);
+            ctx.builder.SetInsertPoint(postBB);
+            PHINode *sizeof_merge = ctx.builder.CreatePHI(T_int32, 2);
+            sizeof_merge->addIncoming(dyn_size, dynloadBB);
+            sizeof_merge->addIncoming(size, currBB);
+            size = sizeof_merge;
+        }
+#ifndef NDEBUG
+        // try to catch codegen errors early, before it uses this to memcpy over the entire stack
+        CreateConditionalAbort(ctx.builder, ctx.builder.CreateICmpEQ(size, ConstantInt::get(T_int32, -1)));
+#endif
+        return size;
+    }
+    else if (jl_is_concrete_type(p.typ)) {
+        return ConstantInt::get(T_int32, jl_datatype_size(p.typ));
+    }
+    else {
+        Value *datatype = emit_typeof_boxed(ctx, p);
+        Value *dyn_size = emit_datatype_size(ctx, datatype);
+        return dyn_size;
+    }
 }
+*/
 
-static Value *emit_datatype_mutabl(Value *dt)
+static Value *emit_datatype_mutabl(jl_codectx_t &ctx, Value *dt)
 {
-    Value *mutabl = tbaa_decorate(tbaa_const, builder.
-        CreateLoad(builder.CreateGEP(emit_bitcast(dt, T_pint8),
-                                     ConstantInt::get(T_size, offsetof(jl_datatype_t, mutabl)))));
-    return builder.CreateTrunc(mutabl, T_int1);
+    Value *Ptr = emit_bitcast(ctx, decay_derived(dt), T_pint8);
+    Value *Idx = ConstantInt::get(T_size, offsetof(jl_datatype_t, mutabl));
+    Value *mutabl = tbaa_decorate(tbaa_const,
+            ctx.builder.CreateLoad(T_int8, ctx.builder.CreateGEP(T_int8, Ptr, Idx)));
+    return ctx.builder.CreateTrunc(mutabl, T_int1);
 }
 
-static Value *emit_datatype_abstract(Value *dt)
+static Value *emit_datatype_abstract(jl_codectx_t &ctx, Value *dt)
 {
-    Value *abstract = tbaa_decorate(tbaa_const, builder.
-        CreateLoad(builder.CreateGEP(emit_bitcast(dt, T_pint8),
-                                     ConstantInt::get(T_size, offsetof(jl_datatype_t, abstract)))));
-    return builder.CreateTrunc(abstract, T_int1);
+    Value *Ptr = emit_bitcast(ctx, decay_derived(dt), T_pint8);
+    Value *Idx = ConstantInt::get(T_size, offsetof(jl_datatype_t, abstract));
+
+    Value *abstract = tbaa_decorate(tbaa_const,
+            ctx.builder.CreateLoad(T_int8, ctx.builder.CreateGEP(T_int8, Ptr, Idx)));
+    return ctx.builder.CreateTrunc(abstract, T_int1);
 }
 
-static Value *emit_datatype_isbitstype(Value *dt)
+static Value *emit_datatype_isbitstype(jl_codectx_t &ctx, 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))),
+    Value *immut = ctx.builder.CreateXor(emit_datatype_mutabl(ctx, dt), ConstantInt::get(T_int1, -1));
+    Value *nofields = ctx.builder.CreateICmpEQ(emit_datatype_nfields(ctx, dt), ConstantInt::get(T_size, 0));
+    Value *isbitstype = ctx.builder.CreateAnd(immut, ctx.builder.CreateAnd(nofields,
+            ctx.builder.CreateXor(ctx.builder.CreateAnd(emit_datatype_abstract(ctx, dt),
+                    ctx.builder.CreateICmpSGT(emit_datatype_size(ctx, dt), ConstantInt::get(T_int32, 0))),
                 ConstantInt::get(T_int1, -1))));
     return isbitstype;
 }
 
-static Value *emit_datatype_name(Value *dt)
+static Value *emit_datatype_name(jl_codectx_t &ctx, Value *dt)
 {
-    return emit_nthptr(dt, (ssize_t)(offsetof(jl_datatype_t,name)/sizeof(char*)),
-                       tbaa_const);
+    return emit_nthptr(
+            ctx, dt,
+            (ssize_t)(offsetof(jl_datatype_t, name) / sizeof(char*)),
+            tbaa_const);
 }
 
 // --- generating various error checks ---
@@ -706,202 +876,247 @@ static Value *emit_datatype_name(Value *dt)
 // the error is always thrown. This may cause non dominated use
 // of SSA value error in the verifier.
 
-static void just_emit_error(const std::string &txt, jl_codectx_t *ctx)
+static void just_emit_error(jl_codectx_t &ctx, const std::string &txt)
 {
-    builder.CreateCall(prepare_call(jlerror_func), stringConstPtr(txt));
+    ctx.builder.CreateCall(prepare_call(jlerror_func), stringConstPtr(ctx.builder, txt));
 }
 
-static void emit_error(const std::string &txt, jl_codectx_t *ctx)
+static void emit_error(jl_codectx_t &ctx, const std::string &txt)
 {
-    just_emit_error(txt, ctx);
-    builder.CreateUnreachable();
-    BasicBlock *cont = BasicBlock::Create(jl_LLVMContext,"after_error",ctx->f);
-    builder.SetInsertPoint(cont);
+    just_emit_error(ctx, txt);
+    ctx.builder.CreateUnreachable();
+    BasicBlock *cont = BasicBlock::Create(jl_LLVMContext,"after_error",ctx.f);
+    ctx.builder.SetInsertPoint(cont);
 }
 
 // DO NOT PASS IN A CONST CONDITION!
-static void error_unless(Value *cond, const std::string &msg, jl_codectx_t *ctx)
+static void error_unless(jl_codectx_t &ctx, Value *cond, const std::string &msg)
 {
-    BasicBlock *failBB = BasicBlock::Create(jl_LLVMContext,"fail",ctx->f);
+    BasicBlock *failBB = BasicBlock::Create(jl_LLVMContext,"fail",ctx.f);
     BasicBlock *passBB = BasicBlock::Create(jl_LLVMContext,"pass");
-    builder.CreateCondBr(cond, passBB, failBB);
-    builder.SetInsertPoint(failBB);
-    just_emit_error(msg, ctx);
-    builder.CreateUnreachable();
-    ctx->f->getBasicBlockList().push_back(passBB);
-    builder.SetInsertPoint(passBB);
+    ctx.builder.CreateCondBr(cond, passBB, failBB);
+    ctx.builder.SetInsertPoint(failBB);
+    just_emit_error(ctx, msg);
+    ctx.builder.CreateUnreachable();
+    ctx.f->getBasicBlockList().push_back(passBB);
+    ctx.builder.SetInsertPoint(passBB);
 }
 
-static void raise_exception(Value *exc, jl_codectx_t *ctx,
+static void raise_exception(jl_codectx_t &ctx, Value *exc,
                             BasicBlock *contBB=nullptr)
 {
-    if (JL_HOOK_TEST(ctx->params, raise_exception)) {
-        JL_HOOK_CALL(ctx->params, raise_exception, 2,
-                     jl_box_voidpointer(wrap(builder.GetInsertBlock())),
+    if (JL_HOOK_TEST(ctx.params, raise_exception)) {
+        JL_HOOK_CALL(ctx.params, raise_exception, 2,
+                     jl_box_voidpointer(wrap(ctx.builder.GetInsertBlock())),
                      jl_box_voidpointer(wrap(exc)));
     } else {
         JL_FEAT_REQUIRE(ctx, runtime);
-#if JL_LLVM_VERSION >= 30700
-        builder.CreateCall(prepare_call(jlthrow_func), { exc });
-#else
-        builder.CreateCall(prepare_call(jlthrow_func), exc);
-#endif
+        ctx.builder.CreateCall(prepare_call(jlthrow_func), { mark_callee_rooted(exc) });
     }
-    builder.CreateUnreachable();
+    ctx.builder.CreateUnreachable();
     if (!contBB) {
-        contBB = BasicBlock::Create(jl_LLVMContext, "after_throw", ctx->f);
+        contBB = BasicBlock::Create(jl_LLVMContext, "after_throw", ctx.f);
     }
     else {
-        ctx->f->getBasicBlockList().push_back(contBB);
+        ctx.f->getBasicBlockList().push_back(contBB);
     }
-    builder.SetInsertPoint(contBB);
+    ctx.builder.SetInsertPoint(contBB);
 }
 
 // DO NOT PASS IN A CONST CONDITION!
-static void raise_exception_unless(Value *cond, Value *exc, jl_codectx_t *ctx)
+static void raise_exception_unless(jl_codectx_t &ctx, Value *cond, Value *exc)
 {
-    BasicBlock *failBB = BasicBlock::Create(jl_LLVMContext,"fail",ctx->f);
+    BasicBlock *failBB = BasicBlock::Create(jl_LLVMContext,"fail",ctx.f);
     BasicBlock *passBB = BasicBlock::Create(jl_LLVMContext,"pass");
-    builder.CreateCondBr(cond, passBB, failBB);
-    builder.SetInsertPoint(failBB);
-    raise_exception(exc, ctx, passBB);
+    ctx.builder.CreateCondBr(cond, passBB, failBB);
+    ctx.builder.SetInsertPoint(failBB);
+    raise_exception(ctx, exc, passBB);
 }
 
-// DO NOT PASS IN A CONST CONDITION!
-static void raise_exception_if(Value *cond, Value *exc, jl_codectx_t *ctx)
-{
-    raise_exception_unless(builder.CreateXor(cond, ConstantInt::get(T_int1,-1)),
-                           exc, ctx);
+static size_t dereferenceable_size(jl_value_t *jt) {
+    size_t size = 0;
+    if (jl_is_array_type(jt)) {
+        // Array has at least this much data
+        size = sizeof(jl_array_t);
+    } else {
+        size = jl_datatype_size(jt);
+    }
+    return size;
 }
 
-static void null_pointer_check(Value *v, jl_codectx_t *ctx)
-{
-    raise_exception_unless(builder.CreateICmpNE(v,Constant::getNullValue(v->getType())),
-                           literal_pointer_val(jl_undefref_exception), ctx);
+static inline void maybe_mark_argument_dereferenceable(Argument *A, jl_value_t *jt) {
+    if (!jl_is_concrete_type(jt)) {
+        return;
+    }
+    size_t size = dereferenceable_size(jt);
+    if (!size) {
+        return;
+    }
+    A->getParent()->addDereferenceableAttr(A->getArgNo() + 1, size);
+}
+
+static inline Instruction *maybe_mark_load_dereferenceable(Instruction *LI, bool can_be_null, size_t size) {
+    if (!size) {
+        return LI;
+    }
+    llvm::SmallVector<Metadata *, 1> OPs;
+    OPs.push_back(ConstantAsMetadata::get(ConstantInt::get(T_int64, size)));
+    LI->setMetadata(can_be_null ? "dereferenceable_or_null" :
+                                  "dereferenceable",
+                    MDNode::get(jl_LLVMContext, OPs));
+    return LI;
+}
+
+static inline Instruction *maybe_mark_load_dereferenceable(Instruction *LI, bool can_be_null, jl_value_t *jt) {
+    if (!jl_is_concrete_type(jt)) {
+        return LI;
+    }
+    size_t size = dereferenceable_size(jt);
+    return maybe_mark_load_dereferenceable(LI, can_be_null, size);
 }
 
-static void emit_type_error(const jl_cgval_t &x, Value *type, const std::string &msg,
-                            jl_codectx_t *ctx)
+static void null_pointer_check(jl_codectx_t &ctx, Value *v)
 {
-    Value *fname_val = stringConstPtr(ctx->funcName);
-    Value *msg_val = stringConstPtr(msg);
-#if JL_LLVM_VERSION >= 30700
-    builder.CreateCall(prepare_call(jltypeerror_func),
-                       { fname_val, msg_val,
-                         type, boxed(x, ctx, false)}); // x is rooted by jl_type_error_rt
-#else
-    builder.CreateCall4(prepare_call(jltypeerror_func),
-                        fname_val, msg_val,
-                        type, boxed(x, ctx, false)); // x is rooted by jl_type_error_rt
-#endif
+    raise_exception_unless(ctx,
+            ctx.builder.CreateICmpNE(v, Constant::getNullValue(v->getType())),
+            literal_pointer_val(ctx, jl_undefref_exception));
 }
 
-static Value *emit_isa(const jl_cgval_t &x, jl_value_t *type, const std::string *msg, jl_codectx_t *ctx)
+static void emit_type_error(jl_codectx_t &ctx, const jl_cgval_t &x, Value *type, const std::string &msg)
 {
-    Value *istype;
-    if (jl_type_intersection(x.typ, type) == (jl_value_t*)jl_bottom_type) {
-        if (msg) {
-            emit_type_error(x, literal_pointer_val(type), *msg, ctx);
-            builder.CreateUnreachable();
-            BasicBlock *failBB = BasicBlock::Create(jl_LLVMContext, "fail", ctx->f);
-            builder.SetInsertPoint(failBB);
+    Value *fname_val = stringConstPtr(ctx.builder, ctx.funcName);
+    Value *msg_val = stringConstPtr(ctx.builder, msg);
+    ctx.builder.CreateCall(prepare_call(jltypeerror_func),
+                       { fname_val, msg_val,
+                         type, mark_callee_rooted(boxed(ctx, x, false))});
+}
+
+static std::pair<Value*, bool> emit_isa(jl_codectx_t &ctx, const jl_cgval_t &x, jl_value_t *type, const std::string *msg)
+{
+    Optional<bool> known_isa;
+    if (x.constant)
+        known_isa = jl_isa(x.constant, type);
+    else if (jl_subtype(x.typ, type))
+        known_isa = true;
+    else if (jl_type_intersection(x.typ, type) == (jl_value_t*)jl_bottom_type)
+        known_isa = false;
+    if (known_isa) {
+        if (!*known_isa && msg) {
+            emit_type_error(ctx, x, literal_pointer_val(ctx, type), *msg);
+            ctx.builder.CreateUnreachable();
+            BasicBlock *failBB = BasicBlock::Create(jl_LLVMContext, "fail", ctx.f);
+            ctx.builder.SetInsertPoint(failBB);
         }
-        return ConstantInt::get(T_int1, 0);
+        return std::make_pair(ConstantInt::get(T_int1, *known_isa), true);
     }
-    else if (jl_has_intersect_type_not_kind(x.typ) ||
-             jl_has_intersect_type_not_kind(type)) {
-        Value *vx = boxed(x, ctx);
+
+    // intersection with Type needs to be handled specially
+    if (jl_has_intersect_type_not_kind(type)) {
+        Value *vx = maybe_decay_untracked(boxed(ctx, x));
+        Value *vtyp = literal_pointer_val(ctx, type);
         if (msg && *msg == "typeassert") {
-#if JL_LLVM_VERSION >= 30700
-            builder.CreateCall(prepare_call(jltypeassert_func), { vx, literal_pointer_val(type) });
-#else
-            builder.CreateCall2(prepare_call(jltypeassert_func), vx, literal_pointer_val(type));
-#endif
-            return ConstantInt::get(T_int1, 1);
+            ctx.builder.CreateCall(prepare_call(jltypeassert_func), { vx, vtyp });
+            return std::make_pair(ConstantInt::get(T_int1, 1), true);
         }
-        istype = builder.CreateICmpNE(
-#if JL_LLVM_VERSION >= 30700
-                builder.CreateCall(prepare_call(jlisa_func), { vx, literal_pointer_val(type) }),
-#else
-                builder.CreateCall2(prepare_call(jlisa_func), vx, literal_pointer_val(type)),
-#endif
-                ConstantInt::get(T_int32, 0));
-    }
-    else if (jl_is_concrete_type(type)) {
-        istype = builder.CreateICmpEQ(emit_typeof_boxed(x, ctx), literal_pointer_val(type));
-    }
-    else {
-        Value *vxt = emit_typeof_boxed(x, ctx);
-        istype = builder.CreateICmpNE(
-#if JL_LLVM_VERSION >= 30700
-                builder.CreateCall(prepare_call(jlsubtype_func), { vxt, literal_pointer_val(type) }),
-#else
-                builder.CreateCall2(prepare_call(jlsubtype_func), vxt, literal_pointer_val(type)),
-#endif
-                ConstantInt::get(T_int32, 0));
+        return std::make_pair(ctx.builder.CreateICmpNE(
+                ctx.builder.CreateCall(prepare_call(jlisa_func), { vx, vtyp }),
+                ConstantInt::get(T_int32, 0)), false);
+    }
+    // tests for is a concrete type can be handled with pointer comparisons
+    if (jl_is_concrete_type(type)) {
+        if (x.TIndex) {
+            unsigned tindex = get_box_tindex((jl_datatype_t*)type, x.typ);
+            if (tindex > 0) {
+                // optimize more when we know that this is a split union-type where tindex = 0 is invalid
+                Value *xtindex = ctx.builder.CreateAnd(x.TIndex, ConstantInt::get(T_int8, 0x7f));
+                return std::make_pair(ctx.builder.CreateICmpEQ(xtindex, ConstantInt::get(T_int8, tindex)), false);
+            }
+            else {
+                // test for (x.TIndex == 0x80 && typeof(x.V) == type)
+                Value *isboxed = ctx.builder.CreateICmpEQ(x.TIndex, ConstantInt::get(T_int8, 0x80));
+                BasicBlock *currBB = ctx.builder.GetInsertBlock();
+                BasicBlock *isaBB = BasicBlock::Create(jl_LLVMContext, "isa", ctx.f);
+                BasicBlock *postBB = BasicBlock::Create(jl_LLVMContext, "post_isa", ctx.f);
+                ctx.builder.CreateCondBr(isboxed, isaBB, postBB);
+                ctx.builder.SetInsertPoint(isaBB);
+                Value *istype_boxed = ctx.builder.CreateICmpEQ(emit_typeof(ctx, x.V),
+                    maybe_decay_untracked(literal_pointer_val(ctx, type)));
+                ctx.builder.CreateBr(postBB);
+                ctx.builder.SetInsertPoint(postBB);
+                PHINode *istype = ctx.builder.CreatePHI(T_int1, 2);
+                istype->addIncoming(ConstantInt::get(T_int1, 0), currBB);
+                istype->addIncoming(istype_boxed, isaBB);
+                return std::make_pair(istype, false);
+            }
+        }
+        return std::make_pair(ctx.builder.CreateICmpEQ(emit_typeof_boxed(ctx, x),
+            maybe_decay_untracked(literal_pointer_val(ctx, type))), false);
     }
-    return istype;
+    // everything else can be handled via subtype tests
+    Value *vxt = maybe_decay_untracked(emit_typeof_boxed(ctx, x));
+    return std::make_pair(ctx.builder.CreateICmpNE(
+            ctx.builder.CreateCall(prepare_call(jlsubtype_func),
+              { vxt,
+                literal_pointer_val(ctx, type) }),
+            ConstantInt::get(T_int32, 0)), false);
 }
 
-static void emit_typecheck(const jl_cgval_t &x, jl_value_t *type, const std::string &msg,
-                           jl_codectx_t *ctx)
+static void emit_typecheck(jl_codectx_t &ctx, const jl_cgval_t &x, jl_value_t *type, const std::string &msg)
 {
-    // if (jl_subtype(x.typ, type)) {
-    //     // This case should already be handled by the caller
-    //     return;
-    // }
-    Value *istype = emit_isa(x, type, &msg, ctx);
-    if (!isa<Constant>(istype)) {
-        BasicBlock *failBB = BasicBlock::Create(jl_LLVMContext, "fail", ctx->f);
+    Value *istype;
+    bool handled_msg;
+    std::tie(istype, handled_msg) = emit_isa(ctx, x, type, &msg);
+    if (!handled_msg) {
+        BasicBlock *failBB = BasicBlock::Create(jl_LLVMContext, "fail", ctx.f);
         BasicBlock *passBB = BasicBlock::Create(jl_LLVMContext, "pass");
-        builder.CreateCondBr(istype, passBB, failBB);
-        builder.SetInsertPoint(failBB);
+        ctx.builder.CreateCondBr(istype, passBB, failBB);
+        ctx.builder.SetInsertPoint(failBB);
 
-        emit_type_error(x, literal_pointer_val(type), msg, ctx);
-        builder.CreateUnreachable();
+        emit_type_error(ctx, x, literal_pointer_val(ctx, type), msg);
+        ctx.builder.CreateUnreachable();
 
-        ctx->f->getBasicBlockList().push_back(passBB);
-        builder.SetInsertPoint(passBB);
+        ctx.f->getBasicBlockList().push_back(passBB);
+        ctx.builder.SetInsertPoint(passBB);
     }
 }
 
-static void emit_concrete_check(Value *typ, const std::string &msg, jl_codectx_t *ctx)
+static void emit_concretecheck(jl_codectx_t &ctx, Value *typ, const std::string &msg)
 {
-    assert(typ->getType() == T_pjlvalue);
-    emit_typecheck(mark_julia_type(typ, true, jl_any_type, ctx, false), (jl_value_t*)jl_datatype_type, msg, ctx);
+    assert(typ->getType() == T_prjlvalue);
+    emit_typecheck(ctx, mark_julia_type(ctx, typ, true, jl_any_type, false), (jl_value_t*)jl_datatype_type, msg);
     Value *isconcrete;
-    isconcrete = builder.CreateConstInBoundsGEP1_32(LLVM37_param(T_int8) emit_bitcast(typ, T_pint8), offsetof(jl_datatype_t, isconcrete));
-    isconcrete = builder.CreateLoad(isconcrete, tbaa_const);
-    isconcrete = builder.CreateTrunc(isconcrete, T_int1);
-    error_unless(isconcrete, msg, ctx);
+    isconcrete = ctx.builder.CreateConstInBoundsGEP1_32(T_int8, emit_bitcast(ctx, decay_derived(typ), T_pint8), offsetof(jl_datatype_t, isconcretetype));
+    isconcrete = ctx.builder.CreateLoad(isconcrete, tbaa_const);
+    isconcrete = ctx.builder.CreateTrunc(isconcrete, T_int1);
+    error_unless(ctx, isconcrete, msg);
 }
 
 #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));
+static bool bounds_check_enabled(jl_codectx_t &ctx) {
 #if CHECK_BOUNDS==1
-    if ((!ctx->is_inbounds &&
+    return (!ctx.is_inbounds &&
          jl_options.check_bounds != JL_OPTIONS_CHECK_BOUNDS_OFF) ||
-         jl_options.check_bounds == JL_OPTIONS_CHECK_BOUNDS_ON) {
-        Value *ok = builder.CreateICmpULT(im1, len);
-        BasicBlock *failBB = BasicBlock::Create(jl_LLVMContext,"fail",ctx->f);
-        BasicBlock *passBB = BasicBlock::Create(jl_LLVMContext,"pass");
-        builder.CreateCondBr(ok, passBB, failBB);
-        builder.SetInsertPoint(failBB);
-        if (!ty) { // jl_value_t** tuple (e.g. the vararg)
-#if JL_LLVM_VERSION >= 30700
-            builder.CreateCall(prepare_call(jlvboundserror_func), { ainfo.V, len, i });
+         jl_options.check_bounds == JL_OPTIONS_CHECK_BOUNDS_ON;
 #else
-            builder.CreateCall3(prepare_call(jlvboundserror_func), ainfo.V, len, i);
+    return 0;
 #endif
+}
+
+static Value *emit_bounds_check(jl_codectx_t &ctx, const jl_cgval_t &ainfo, jl_value_t *ty, Value *i, Value *len)
+{
+    Value *im1 = ctx.builder.CreateSub(i, ConstantInt::get(T_size, 1));
+#if CHECK_BOUNDS==1
+    if (bounds_check_enabled(ctx)) {
+        Value *ok = ctx.builder.CreateICmpULT(im1, len);
+        BasicBlock *failBB = BasicBlock::Create(jl_LLVMContext,"fail",ctx.f);
+        BasicBlock *passBB = BasicBlock::Create(jl_LLVMContext,"pass");
+        ctx.builder.CreateCondBr(ok, passBB, failBB);
+        ctx.builder.SetInsertPoint(failBB);
+        if (!ty) { // jl_value_t** tuple (e.g. the vararg)
+            ctx.builder.CreateCall(prepare_call(jlvboundserror_func), { ainfo.V, len, i });
         }
         else if (ainfo.isboxed) { // jl_datatype_t or boxed jl_value_t
-#if JL_LLVM_VERSION >= 30700
-            builder.CreateCall(prepare_call(jlboundserror_func), { boxed(ainfo, ctx), i });
-#else
-            builder.CreateCall2(prepare_call(jlboundserror_func), boxed(ainfo, ctx), i);
-#endif
+            ctx.builder.CreateCall(prepare_call(jlboundserror_func), { mark_callee_rooted(boxed(ctx, ainfo)), i });
         }
         else { // unboxed jl_value_t*
             Value *a = ainfo.V;
@@ -910,25 +1125,18 @@ static Value *emit_bounds_check(const jl_cgval_t &ainfo, jl_value_t *ty, Value *
             }
             else if (!ainfo.ispointer()) {
                 // CreateAlloca is OK here since we are on an error branch
-                Value *tempSpace = builder.CreateAlloca(a->getType());
-                builder.CreateStore(a, tempSpace);
+                Value *tempSpace = ctx.builder.CreateAlloca(a->getType());
+                ctx.builder.CreateStore(a, tempSpace);
                 a = tempSpace;
             }
-#if JL_LLVM_VERSION >= 30700
-            builder.CreateCall(prepare_call(jluboundserror_func), {
-                                builder.CreatePointerCast(a, T_pint8),
-                                literal_pointer_val(ty),
+            ctx.builder.CreateCall(prepare_call(jluboundserror_func), {
+                                emit_bitcast(ctx, decay_derived(a), T_pint8),
+                                literal_pointer_val(ctx, ty),
                                 i });
-#else
-            builder.CreateCall3(prepare_call(jluboundserror_func),
-                                builder.CreatePointerCast(a, T_pint8),
-                                literal_pointer_val(ty),
-                                i);
-#endif
         }
-        builder.CreateUnreachable();
-        ctx->f->getBasicBlockList().push_back(passBB);
-        builder.SetInsertPoint(passBB);
+        ctx.builder.CreateUnreachable();
+        ctx.f->getBasicBlockList().push_back(passBB);
+        ctx.builder.SetInsertPoint(passBB);
     }
 #endif
     return im1;
@@ -944,55 +1152,61 @@ static Value *emit_bounds_check(const jl_cgval_t &ainfo, jl_value_t *ty, Value *
 // It is currently unused, but might be used in the future for a more precise answer.
 static unsigned julia_alignment(Value* /*ptr*/, jl_value_t *jltype, unsigned alignment)
 {
-    if (!alignment && ((jl_datatype_t*)jltype)->layout->alignment > MAX_ALIGN) {
-        // Type's natural alignment exceeds strictest alignment promised in heap, so return the heap alignment.
-        return MAX_ALIGN;
+    if (!alignment) {
+        alignment = jl_datatype_align(jltype);
+        assert(alignment <= JL_HEAP_ALIGNMENT);
+        assert(JL_HEAP_ALIGNMENT % alignment == 0);
     }
     return alignment;
 }
 
-static Value *emit_unbox(Type *to, const jl_cgval_t &x, jl_value_t *jt, Value* dest = NULL, bool volatile_store = false);
+static Value *emit_unbox(jl_codectx_t &ctx, Type *to, const jl_cgval_t &x, jl_value_t *jt, Value* dest = NULL, bool volatile_store = false);
 
-static jl_cgval_t typed_load(Value *ptr, Value *idx_0based, jl_value_t *jltype,
-                             jl_codectx_t *ctx, MDNode *tbaa, unsigned alignment = 0)
+static jl_cgval_t typed_load(jl_codectx_t &ctx, Value *ptr, Value *idx_0based, jl_value_t *jltype,
+                             MDNode *tbaa, bool maybe_null_if_boxed = true, unsigned alignment = 0)
 {
     bool isboxed;
     Type *elty = julia_type_to_llvm(jltype, &isboxed);
     if (type_is_ghost(elty))
         return ghostValue(jltype);
     Value *data;
+    if (isboxed)
+        elty = T_prjlvalue;
     // TODO: preserving_pointercast?
     if (ptr->getType()->getContainedType(0) != elty)
-        data = builder.CreatePointerCast(ptr, PointerType::get(elty, 0));
+        data = emit_bitcast(ctx, ptr, PointerType::get(elty, 0));
     else
         data = ptr;
     if (idx_0based)
-        data = builder.CreateGEP(data, idx_0based);
+        data = ctx.builder.CreateGEP(data, idx_0based);
     Value *elt;
     // TODO: can only lazy load if we can create a gc root for ptr for the lifetime of elt
     //if (elty->isAggregateType() && tbaa == tbaa_immut && !alignment) { // can lazy load on demand, no copy needed
     //    elt = data;
     //}
     //else {
-        Instruction *load = builder.CreateAlignedLoad(data, isboxed ?
+        Instruction *load = ctx.builder.CreateAlignedLoad(data, isboxed ?
             alignment : julia_alignment(data, jltype, alignment), false);
+        if (isboxed)
+            load = maybe_mark_load_dereferenceable(load, true, jltype);
         if (tbaa) {
             elt = tbaa_decorate(tbaa, load);
         }
         else {
             elt = load;
         }
-        if (isboxed) {
-            null_pointer_check(elt, ctx);
+        if (maybe_null_if_boxed && isboxed) {
+            null_pointer_check(ctx, elt);
         }
     //}
-    return mark_julia_type(elt, isboxed, jltype, ctx);
+    return mark_julia_type(ctx, elt, isboxed, jltype);
 }
 
-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
-                        unsigned alignment = 0, bool root_box = true) // if the value to store needs a box, should we root it ?
+static void typed_store(jl_codectx_t &ctx,
+        Value *ptr, Value *idx_0based, const jl_cgval_t &rhs,
+        jl_value_t *jltype, MDNode *tbaa,
+        Value *parent,  // for the write barrier, NULL if no barrier needed
+        unsigned alignment = 0, bool root_box = true) // if the value to store needs a box, should we root it ?
 {
     bool isboxed;
     Type *elty = julia_type_to_llvm(jltype, &isboxed);
@@ -1000,18 +1214,23 @@ static void typed_store(Value *ptr, Value *idx_0based, const jl_cgval_t &rhs,
         return;
     Value *r;
     if (!isboxed) {
-        r = emit_unbox(elty, rhs, jltype);
+        r = emit_unbox(ctx, elty, rhs, jltype);
     }
     else {
-        r = boxed(rhs, ctx, root_box);
-        if (parent != NULL) emit_write_barrier(ctx, parent, r);
+        r = maybe_decay_untracked(boxed(ctx, rhs, root_box));
+        if (parent != NULL)
+            emit_write_barrier(ctx, parent, r);
     }
     Value *data;
-    if (ptr->getType()->getContainedType(0) != elty)
-        data = emit_bitcast(ptr, PointerType::get(elty, 0));
-    else
+    if (ptr->getType()->getContainedType(0) != elty) {
+        if (isboxed) {
+            data = emit_bitcast(ctx, ptr, T_pprjlvalue);
+        } else {
+            data = emit_bitcast(ctx, ptr, PointerType::get(elty, cast<PointerType>(ptr->getType())->getAddressSpace()));
+        }
+    } else
         data = ptr;
-    Instruction *store = builder.CreateAlignedStore(r, builder.CreateGEP(data,
+    Instruction *store = ctx.builder.CreateAlignedStore(r, ctx.builder.CreateGEP(data,
         idx_0based), isboxed ? alignment : julia_alignment(r, jltype, alignment));
     if (tbaa)
         tbaa_decorate(tbaa, store);
@@ -1019,167 +1238,114 @@ static void typed_store(Value *ptr, Value *idx_0based, const jl_cgval_t &rhs,
 
 // --- convert boolean value to julia ---
 
-static Value *julia_bool(Value *cond)
+static Value *julia_bool(jl_codectx_t &ctx, Value *cond)
 {
-    return builder.CreateSelect(cond, literal_pointer_val(jl_true),
-                                      literal_pointer_val(jl_false));
+    return ctx.builder.CreateSelect(cond, literal_pointer_val(ctx, jl_true),
+                                      literal_pointer_val(ctx, jl_false));
 }
 
-// --- get the inferred type of an AST node ---
-
-static inline jl_module_t *topmod(jl_codectx_t *ctx)
-{
-    return jl_base_relative_to(ctx->module);
-}
+// --- accessing the representations of built-in data types ---
 
-static jl_value_t *expr_type(jl_value_t *e, jl_codectx_t *ctx)
+static Constant *julia_const_to_llvm(jl_value_t *e);
+static Value *data_pointer(jl_codectx_t &ctx, const jl_cgval_t &x, Type *astype = T_ppjlvalue)
 {
-    if (jl_is_ssavalue(e)) {
-        if (jl_is_long(ctx->source->ssavaluetypes))
-            return (jl_value_t*)jl_any_type;
-        int idx = ((jl_ssavalue_t*)e)->id;
-        assert(jl_is_array(ctx->source->ssavaluetypes));
-        jl_array_t *ssavalue_types = (jl_array_t*)ctx->source->ssavaluetypes;
-        return jl_array_ptr_ref(ssavalue_types, idx);
-    }
-    if (jl_typeis(e, jl_slotnumber_type)) {
-        jl_array_t *slot_types = (jl_array_t*)ctx->source->slottypes;
-        if (!jl_is_array(slot_types))
-            return (jl_value_t*)jl_any_type;
-        return jl_array_ptr_ref(slot_types, jl_slot_number(e)-1);
-    }
-    if (jl_typeis(e, jl_typedslot_type)) {
-        jl_value_t *typ = jl_typedslot_get_type(e);
-        if (jl_is_typevar(typ))
-            typ = ((jl_tvar_t*)typ)->ub;
-        return typ;
-    }
-    if (jl_is_expr(e)) {
-        if (((jl_expr_t*)e)->head == static_parameter_sym) {
-            size_t idx = jl_unbox_long(jl_exprarg(e,0))-1;
-            if (idx >= jl_svec_len(ctx->linfo->sparam_vals))
-                return (jl_value_t*)jl_any_type;
-            e = jl_svecref(ctx->linfo->sparam_vals, idx);
-            if (jl_is_typevar(e))
-                return (jl_value_t*)jl_any_type;
-            goto type_of_constant;
+    Value *data = x.V;
+    if (x.constant) {
+        Constant *val = julia_const_to_llvm(x.constant);
+        if (val) {
+            data = get_pointer_to_constant(val, "", *jl_Module);
         }
-        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_quotenode(e)) {
-        e = jl_fieldref(e,0);
-        goto type_of_constant;
-    }
-    if (jl_is_globalref(e)) {
-        jl_sym_t *s = (jl_sym_t*)jl_globalref_name(e);
-        jl_binding_t *b = jl_get_binding(jl_globalref_mod(e), s);
-        if (b && b->constp) {
-            e = b->value;
-            goto type_of_constant;
+        else {
+            data = boxed(ctx, x);
         }
-        return (jl_value_t*)jl_any_type;
-    }
-    if (jl_is_symbol(e)) {
-        jl_binding_t *b = jl_get_binding(ctx->module, (jl_sym_t*)e);
-        if (!b || !b->value)
-            return (jl_value_t*)jl_any_type;
-        if (b->constp)
-            e = b->value;
-        else
-            return (jl_value_t*)jl_any_type;
     }
-type_of_constant:
-    if (jl_is_type(e))
-        return (jl_value_t*)jl_wrap_Type(e);
-    return (jl_value_t*)jl_typeof(e);
-}
-
-// --- accessing the representations of built-in data types ---
-
-static Value *data_pointer(const jl_cgval_t &x, jl_codectx_t *ctx, Type *astype = T_ppjlvalue)
-{
-    Value *data = x.constant ? boxed(x, ctx) : x.V;
     if (data->getType() != astype)
-        data = emit_bitcast(data, astype);
-    return data;
+        data = emit_bitcast(ctx, data, astype);
+    return decay_derived(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)
+static bool emit_getfield_unknownidx(jl_codectx_t &ctx,
+        jl_cgval_t *ret, const jl_cgval_t &strct,
+        Value *idx, jl_datatype_t *stt)
 {
     size_t nfields = jl_datatype_nfields(stt);
     if (strct.ispointer()) { // boxed or stack
         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(strct.tbaa, builder.CreateLoad(
-                        builder.CreateGEP(data_pointer(strct, ctx), idx)));
-            if ((unsigned)stt->ninitialized != nfields)
-                null_pointer_check(fld, ctx);
-            *ret = mark_julia_type(fld, true, jl_any_type, ctx, strct.gcroot || !strct.isimmutable);
+            idx = emit_bounds_check(ctx, strct, (jl_value_t*)stt, idx, ConstantInt::get(T_size, nfields));
+            bool maybe_null = (unsigned)stt->ninitialized != nfields;
+            size_t minimum_field_size = (size_t)-1;
+            for (size_t i = 0; i < nfields; ++i) {
+                minimum_field_size = std::min(minimum_field_size,
+                    dereferenceable_size(jl_field_type(stt, i)));
+                if (minimum_field_size == 0)
+                    break;
+            }
+            Value *fld = tbaa_decorate(strct.tbaa,
+                maybe_mark_load_dereferenceable(
+                    ctx.builder.CreateLoad(
+                        ctx.builder.CreateBitCast(ctx.builder.CreateGEP(decay_derived(data_pointer(ctx, strct)), idx),
+                            PointerType::get(T_prjlvalue, AddressSpace::Derived))),
+                    maybe_null,  minimum_field_size));
+            if (maybe_null)
+                null_pointer_check(ctx, fld);
+            *ret = mark_julia_type(ctx, fld, true, jl_any_type, strct.gcroot || !strct.isimmutable);
             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, ctx);
+            idx = emit_bounds_check(ctx, strct, (jl_value_t*)stt, idx, ConstantInt::get(T_size, nfields));
+            Value *ptr = data_pointer(ctx, strct);
             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);
-                *ret = mark_julia_slot(addr, jt, strct.tbaa);
+                Value *addr = ctx.builder.CreateGEP(emit_bitcast(ctx, decay_derived(ptr), PointerType::get(fty,0)), idx);
+                *ret = mark_julia_slot(addr, jt, NULL, strct.tbaa);
                 ret->gcroot = strct.gcroot;
                 ret->isimmutable = strct.isimmutable;
                 return true;
             }
-            *ret = typed_load(ptr, idx, jt, ctx, strct.tbaa);
+            *ret = typed_load(ctx, ptr, idx, jt, strct.tbaa, false);
             return true;
         }
         else if (strct.isboxed) {
-            idx = builder.CreateSub(idx, ConstantInt::get(T_size, 1));
-#if JL_LLVM_VERSION >= 30700
-            Value *fld = builder.CreateCall(prepare_call(jlgetnthfieldchecked_func), { boxed(strct, ctx), idx });
-#else
-            Value *fld = builder.CreateCall2(prepare_call(jlgetnthfieldchecked_func), boxed(strct, ctx), idx);
-#endif
-            *ret = mark_julia_type(fld, true, jl_any_type, ctx);
+            idx = ctx.builder.CreateSub(idx, ConstantInt::get(T_size, 1));
+            Value *fld = ctx.builder.CreateCall(prepare_call(jlgetnthfieldchecked_func), { boxed(ctx, strct), idx });
+            *ret = mark_julia_type(ctx, fld, true, jl_any_type);
             return true;
         }
     }
     else if (is_tupletype_homogeneous(stt->types)) {
         assert(jl_isbits(stt));
         if (nfields == 0) {
-            idx = emit_bounds_check(ghostValue(stt),
-                                    (jl_value_t*)stt, idx, ConstantInt::get(T_size, nfields), ctx);
+            idx = emit_bounds_check(ctx, ghostValue(stt),
+                                    (jl_value_t*)stt, idx, ConstantInt::get(T_size, nfields));
             *ret = jl_cgval_t();
             return true;
         }
         assert(!jl_field_isptr(stt, 0));
         jl_value_t *jt = jl_field_type(stt, 0);
-        Value *idx0 = emit_bounds_check(strct, (jl_value_t*)stt, idx, ConstantInt::get(T_size, nfields), ctx);
+        Value *idx0 = emit_bounds_check(ctx, strct, (jl_value_t*)stt, idx, ConstantInt::get(T_size, nfields));
         if (strct.isghost) {
             *ret = ghostValue(jt);
             return true;
         }
         // llvm::VectorType
         if (sizeof(void*) != sizeof(int))
-            idx0 = builder.CreateTrunc(idx0, T_int32); // llvm3.3 requires this, harmless elsewhere
-        Value *fld = builder.CreateExtractElement(strct.V, idx0);
-        *ret = mark_julia_type(fld, false, jt, ctx);
+            idx0 = ctx.builder.CreateTrunc(idx0, T_int32); // llvm3.3 requires this, harmless elsewhere
+        Value *fld = ctx.builder.CreateExtractElement(strct.V, idx0);
+        *ret = mark_julia_type(ctx, fld, false, jt);
         return true;
     }
     return false;
 }
 
-static jl_cgval_t emit_getfield_knownidx(const jl_cgval_t &strct, unsigned idx, jl_datatype_t *jt, jl_codectx_t *ctx)
+static jl_cgval_t emit_getfield_knownidx(jl_codectx_t &ctx, const jl_cgval_t &strct, unsigned idx, jl_datatype_t *jt)
 {
     jl_value_t *jfty = jl_field_type(jt, idx);
     Type *elty = julia_type_to_llvm(jfty);
     if (jfty == jl_bottom_type) {
-        raise_exception(literal_pointer_val(jl_undefref_exception), ctx);
+        raise_exception(ctx, literal_pointer_val(ctx, jl_undefref_exception));
         return jl_cgval_t(); // unreachable
     }
     if (type_is_ghost(elty))
@@ -1187,18 +1353,44 @@ static jl_cgval_t emit_getfield_knownidx(const jl_cgval_t &strct, unsigned idx,
     Value *fldv = NULL;
     if (strct.ispointer()) {
         Value *addr;
-        Value *ptr = data_pointer(strct, ctx, T_pint8);
-        Value *llvm_idx = ConstantInt::get(T_size, jl_field_offset(jt, idx));
-        addr = builder.CreateGEP(ptr, llvm_idx);
+        bool isboxed;
+        Type *lt = julia_type_to_llvm((jl_value_t*)jt, &isboxed);
+        if (isboxed) {
+            Value *ptr = decay_derived(data_pointer(ctx, strct, T_pint8));
+            Value *llvm_idx = ConstantInt::get(T_size, jl_field_offset(jt, idx));
+            addr = ctx.builder.CreateGEP(ptr, llvm_idx);
+        }
+        else {
+            if (VectorType *vlt = dyn_cast<VectorType>(lt)) {
+                // doesn't have the struct wrapper, so this must have been a VecElement
+                // cast to the element type so that it can be addressed with GEP
+                lt = vlt->getElementType();
+                Value *ptr = data_pointer(ctx, strct, lt->getPointerTo());
+                Value *llvm_idx = ConstantInt::get(T_size, idx);
+                addr = ctx.builder.CreateGEP(lt, ptr, llvm_idx);
+            }
+            else if (lt->isSingleValueType()) {
+                addr = data_pointer(ctx, strct, lt->getPointerTo());
+            }
+            else {
+                Value *ptr = data_pointer(ctx, strct, lt->getPointerTo());
+                addr = ctx.builder.CreateStructGEP(lt, ptr, idx);
+            }
+        }
         if (jl_field_isptr(jt, idx)) {
-            Value *fldv = tbaa_decorate(strct.tbaa, builder.CreateLoad(emit_bitcast(addr, T_ppjlvalue)));
-            if (idx >= (unsigned)jt->ninitialized)
-                null_pointer_check(fldv, ctx);
-            return mark_julia_type(fldv, true, jfty, ctx, strct.gcroot || !strct.isimmutable);
+            bool maybe_null = idx >= (unsigned)jt->ninitialized;
+            Instruction *Load = maybe_mark_load_dereferenceable(
+                ctx.builder.CreateLoad(emit_bitcast(ctx, addr, T_pprjlvalue)),
+                maybe_null, jl_field_type(jt, idx)
+            );
+            Value *fldv = tbaa_decorate(strct.tbaa, Load);
+            if (maybe_null)
+                null_pointer_check(ctx, fldv);
+            return mark_julia_type(ctx, fldv, true, jfty, strct.gcroot || !strct.isimmutable);
         }
         else if (!jt->mutabl) {
             // just compute the pointer and let user load it when necessary
-            jl_cgval_t fieldval = mark_julia_slot(addr, jfty, strct.tbaa);
+            jl_cgval_t fieldval = mark_julia_slot(addr, jfty, NULL, strct.tbaa);
             fieldval.isimmutable = strct.isimmutable;
             fieldval.gcroot = strct.gcroot;
             return fieldval;
@@ -1206,14 +1398,14 @@ static jl_cgval_t emit_getfield_knownidx(const jl_cgval_t &strct, unsigned idx,
         int align = jl_field_offset(jt, idx);
         align |= 16;
         align &= -align;
-        return typed_load(addr, ConstantInt::get(T_size, 0), jfty, ctx, strct.tbaa, align);
+        return typed_load(ctx, addr, ConstantInt::get(T_size, 0), jfty, strct.tbaa, true, align);
     }
     else if (isa<UndefValue>(strct.V)) {
         return jl_cgval_t();
     }
     else {
         if (strct.V->getType()->isVectorTy()) {
-            fldv = builder.CreateExtractElement(strct.V, ConstantInt::get(T_int32, idx));
+            fldv = ctx.builder.CreateExtractElement(strct.V, ConstantInt::get(T_int32, idx));
         }
         else {
             // VecElement types are unwrapped in LLVM.
@@ -1221,18 +1413,18 @@ static jl_cgval_t emit_getfield_knownidx(const jl_cgval_t &strct, unsigned idx,
             fldv = strct.V;
         }
         assert(!jl_field_isptr(jt, idx));
-        return mark_julia_type(fldv, false, jfty, ctx);
+        return mark_julia_type(ctx, fldv, false, jfty);
     }
 }
 
 // emit length of vararg tuple
-static Value *emit_n_varargs(jl_codectx_t *ctx)
+static Value *emit_n_varargs(jl_codectx_t &ctx)
 {
-    int nreq = ctx->nReqArgs;
-    Value *valen = builder.CreateSub((Value*)ctx->argCount,
+    int nreq = ctx.nReqArgs;
+    Value *valen = ctx.builder.CreateSub((Value*)ctx.argCount,
                                      ConstantInt::get(T_int32, nreq));
 #ifdef _P64
-    return builder.CreateSExt(valen, T_int64);
+    return ctx.builder.CreateSExt(valen, T_int64);
 #else
     return valen;
 #endif
@@ -1244,54 +1436,80 @@ static bool arraytype_constshape(jl_value_t *ty)
             jl_is_long(jl_tparam1(ty)) && jl_unbox_long(jl_tparam1(ty)) != 1);
 }
 
-static Value *emit_arraysize(const jl_cgval_t &tinfo, Value *dim, jl_codectx_t *ctx)
-{
-    Value *t = boxed(tinfo, ctx);
-    int o = offsetof(jl_array_t, nrows)/sizeof(void*) - 1;
+static void maybe_alloc_arrayvar(jl_codectx_t &ctx, int s)
+{
+    jl_value_t *jt = ctx.slots[s].value.typ;
+    if (arraytype_constshape(jt)) {
+        // TODO: this optimization does not yet work with 1-d arrays, since the
+        // length and data pointer can change at any time via push!
+        // we could make it work by reloading the metadata when the array is
+        // passed to an external function (ideally only impure functions)
+        int ndims = jl_unbox_long(jl_tparam1(jt));
+        jl_value_t *jelt = jl_tparam0(jt);
+        bool isboxed = !jl_array_store_unboxed(jelt);
+        Type *elt = julia_type_to_llvm(jelt);
+        if (type_is_ghost(elt))
+            return;
+        if (isboxed)
+            elt = T_prjlvalue;
+        // CreateAlloca is OK here because maybe_alloc_arrayvar is only called in the prologue setup
+        jl_arrayvar_t &av = (*ctx.arrayvars)[s];
+        av.dataptr = ctx.builder.CreateAlloca(PointerType::get(elt, 0));
+        av.len = ctx.builder.CreateAlloca(T_size);
+        for (int i = 0; i < ndims - 1; i++)
+            av.sizes.push_back(ctx.builder.CreateAlloca(T_size));
+        av.ty = jt;
+    }
+}
+
+static Value *emit_arraysize(jl_codectx_t &ctx, const jl_cgval_t &tinfo, Value *dim)
+{
+    Value *t = boxed(ctx, tinfo);
+    int o = offsetof(jl_array_t, nrows) / sizeof(void*) - 1;
     MDNode *tbaa = arraytype_constshape(tinfo.typ) ? tbaa_const : tbaa_arraysize;
-    return emit_nthptr_recast(t, builder.CreateAdd(dim,
-                                                   ConstantInt::get(dim->getType(), o)),
-                              tbaa, T_psize);
+    return emit_nthptr_recast(ctx,
+            t,
+            ctx.builder.CreateAdd(dim, ConstantInt::get(dim->getType(), o)),
+            tbaa, T_psize);
 }
 
-static jl_arrayvar_t *arrayvar_for(jl_value_t *ex, jl_codectx_t *ctx)
+static jl_arrayvar_t *arrayvar_for(jl_codectx_t &ctx, jl_value_t *ex)
 {
-    if (ex == NULL) return NULL;
+    if (ex == NULL)
+        return NULL;
     if (!jl_is_slot(ex))
         return NULL;
-    int sl = jl_slot_number(ex)-1;
-    if (ctx->arrayvars->find(sl) != ctx->arrayvars->end())
-        return &(*ctx->arrayvars)[sl];
+    int sl = jl_slot_number(ex) - 1;
+    auto av = ctx.arrayvars->find(sl);
+    if (av != ctx.arrayvars->end())
+        return &av->second;
     //TODO: ssavalue case
     return NULL;
 }
 
-static Value *emit_arraysize(const jl_cgval_t &tinfo, int dim, jl_codectx_t *ctx)
+static Value *emit_arraysize(jl_codectx_t &ctx, const jl_cgval_t &tinfo, int dim)
 {
-    return emit_arraysize(tinfo, ConstantInt::get(T_int32, dim), ctx);
+    return emit_arraysize(ctx, tinfo, ConstantInt::get(T_int32, dim));
 }
 
-static Value *emit_arraylen_prim(const jl_cgval_t &tinfo, jl_codectx_t *ctx)
+static Value *emit_arraylen_prim(jl_codectx_t &ctx, const jl_cgval_t &tinfo)
 {
-    Value *t = boxed(tinfo, ctx);
+    Value *t = boxed(ctx, tinfo);
     jl_value_t *ty = tinfo.typ;
 #ifdef STORE_ARRAY_LEN
-    Value *addr = builder.CreateStructGEP(
-#if JL_LLVM_VERSION >= 30700
-                                          nullptr,
-#endif
-                                          emit_bitcast(t,jl_parray_llvmt),
+    Value *addr = ctx.builder.CreateStructGEP(jl_array_llvmt,
+                                          emit_bitcast(ctx, decay_derived(t), jl_parray_llvmt),
                                           1); //index (not offset) of length field in jl_parray_llvmt
 
     MDNode *tbaa = arraytype_constshape(ty) ? tbaa_const : tbaa_arraylen;
-    return tbaa_decorate(tbaa, builder.CreateLoad(addr, false));
+    return tbaa_decorate(tbaa, ctx.builder.CreateLoad(addr, false));
 #else
     jl_value_t *p1 = jl_tparam1(ty); // FIXME: check that ty is an array type
     if (jl_is_long(p1)) {
         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), ctx));
+            l = ctx.builder.CreateMul(l, emit_arraysize(ctx, t, (int)(i + 1)));
         }
         return l;
     }
@@ -1300,93 +1518,107 @@ static Value *emit_arraylen_prim(const jl_cgval_t &tinfo, jl_codectx_t *ctx)
         fargt.push_back(T_pjlvalue);
         FunctionType *ft = FunctionType::get(T_size, fargt, false);
         Value *alen = jl_Module->getOrInsertFunction("jl_array_len_", ft); // TODO: move to codegen init block
-        return builder.CreateCall(prepare_call(alen), t);
+        return ctx.builder.CreateCall(prepare_call(alen), t);
     }
 #endif
 }
 
-static Value *emit_arraylen(const jl_cgval_t &tinfo, jl_value_t *ex, jl_codectx_t *ctx)
+static Value *emit_arraylen(jl_codectx_t &ctx, const jl_cgval_t &tinfo, jl_value_t *ex)
 {
-    jl_arrayvar_t *av = arrayvar_for(ex, ctx);
-    if (av!=NULL)
-        return builder.CreateLoad(av->len);
-    return emit_arraylen_prim(tinfo, ctx);
+    jl_arrayvar_t *av = arrayvar_for(ctx, ex);
+    if (av != NULL)
+        return ctx.builder.CreateLoad(av->len);
+    return emit_arraylen_prim(ctx, tinfo);
 }
 
-static Value *emit_arrayptr(const jl_cgval_t &tinfo, jl_codectx_t *ctx)
+static Value *emit_arrayptr(jl_codectx_t &ctx, const jl_cgval_t &tinfo, bool isboxed = false)
 {
-    Value *t = boxed(tinfo, ctx);
-    Value *addr = builder.CreateStructGEP(
-#if JL_LLVM_VERSION >= 30700
-                                          nullptr,
-#endif
-                                          emit_bitcast(t,jl_parray_llvmt),
+    Value *t = boxed(ctx, tinfo);
+    Value *addr = ctx.builder.CreateStructGEP(jl_array_llvmt,
+                                          emit_bitcast(ctx, decay_derived(t), jl_parray_llvmt),
                                           0); //index (not offset) of data field in jl_parray_llvmt
 
     MDNode *tbaa = arraytype_constshape(tinfo.typ) ? tbaa_const : tbaa_arrayptr;
-    return tbaa_decorate(tbaa, builder.CreateLoad(addr, false));
+    if (isboxed) {
+        addr = ctx.builder.CreateBitCast(addr,
+            PointerType::get(T_pprjlvalue, cast<PointerType>(addr->getType())->getAddressSpace()));
+    }
+    return tbaa_decorate(tbaa, ctx.builder.CreateLoad(addr, false));
 }
 
-static Value *emit_arrayptr(const jl_cgval_t &tinfo, jl_value_t *ex, jl_codectx_t *ctx)
+static Value *emit_arrayptr(jl_codectx_t &ctx, const jl_cgval_t &tinfo, jl_value_t *ex, bool isboxed = false)
 {
-    jl_arrayvar_t *av = arrayvar_for(ex, ctx);
+    jl_arrayvar_t *av = arrayvar_for(ctx, ex);
     if (av!=NULL)
-        return builder.CreateLoad(av->dataptr);
-    return emit_arrayptr(tinfo, ctx);
+        return ctx.builder.CreateLoad(av->dataptr);
+    return emit_arrayptr(ctx, tinfo, isboxed);
 }
 
-static Value *emit_arraysize(const jl_cgval_t &tinfo, jl_value_t *ex, int dim, jl_codectx_t *ctx)
+static Value *emit_arraysize(jl_codectx_t &ctx, const jl_cgval_t &tinfo, jl_value_t *ex, int dim)
 {
-    jl_arrayvar_t *av = arrayvar_for(ex, ctx);
+    jl_arrayvar_t *av = arrayvar_for(ctx, ex);
     if (av != NULL && dim <= (int)av->sizes.size())
-        return builder.CreateLoad(av->sizes[dim-1]);
-    return emit_arraysize(tinfo, dim, ctx);
+        return ctx.builder.CreateLoad(av->sizes[dim - 1]);
+    return emit_arraysize(ctx, tinfo, dim);
 }
 
-static Value *emit_arrayflags(const jl_cgval_t &tinfo, jl_codectx_t *ctx)
+static Value *emit_arrayflags(jl_codectx_t &ctx, const jl_cgval_t &tinfo)
 {
-    Value *t = boxed(tinfo, ctx);
+    Value *t = boxed(ctx, tinfo);
 #ifdef STORE_ARRAY_LEN
     int arrayflag_field = 2;
 #else
     int arrayflag_field = 1;
 #endif
-    Value *addr = builder.CreateStructGEP(
-#if JL_LLVM_VERSION >= 30700
-                            nullptr,
+    Value *addr = ctx.builder.CreateStructGEP(
+            jl_array_llvmt,
+            emit_bitcast(ctx, decay_derived(t), jl_parray_llvmt),
+            arrayflag_field);
+    return tbaa_decorate(tbaa_arrayflags, ctx.builder.CreateLoad(addr));
+}
+
+static Value *emit_arrayelsize(jl_codectx_t &ctx, const jl_cgval_t &tinfo)
+{
+    Value *t = boxed(ctx, tinfo);
+#ifdef STORE_ARRAY_LEN
+    int elsize_field = 3;
+#else
+    int elsize_field = 2;
 #endif
-                            emit_bitcast(t, jl_parray_llvmt),
-                            arrayflag_field);
-    return tbaa_decorate(tbaa_arrayflags, builder.CreateLoad(addr));
+    Value *addr = ctx.builder.CreateStructGEP(jl_array_llvmt,
+                                          emit_bitcast(ctx, decay_derived(t), jl_parray_llvmt),
+                                          elsize_field);
+    return tbaa_decorate(tbaa_const, ctx.builder.CreateLoad(addr));
 }
 
-static void assign_arrayvar(jl_arrayvar_t &av, const jl_cgval_t &ainfo, jl_codectx_t *ctx)
+static void assign_arrayvar(jl_codectx_t &ctx, jl_arrayvar_t &av, const jl_cgval_t &ainfo)
 {
-    tbaa_decorate(tbaa_arrayptr,builder.CreateStore(emit_bitcast(emit_arrayptr(ainfo, ctx),
-                                                    av.dataptr->getType()->getContainedType(0)),
-                                                    av.dataptr));
-    builder.CreateStore(emit_arraylen_prim(ainfo, ctx), av.len);
-    for(size_t i=0; i < av.sizes.size(); i++)
-        builder.CreateStore(emit_arraysize(ainfo, i+1, ctx), av.sizes[i]);
+    Value *aptr = emit_bitcast(ctx,
+        emit_arrayptr(ctx, ainfo),
+        av.dataptr->getType()->getContainedType(0));
+    tbaa_decorate(tbaa_arrayptr, ctx.builder.CreateStore(aptr, av.dataptr));
+    ctx.builder.CreateStore(emit_arraylen_prim(ctx, ainfo), av.len);
+    for (size_t i = 0; i < av.sizes.size(); i++)
+        ctx.builder.CreateStore(emit_arraysize(ctx, ainfo, i + 1), av.sizes[i]);
 }
 
 // Returns the size of the array represented by `tinfo` for the given dimension `dim` if
 // `dim` is a valid dimension, otherwise returns constant one.
-static Value *emit_arraysize_for_unsafe_dim(const jl_cgval_t &tinfo, jl_value_t *ex, size_t dim,
-                                            size_t nd, jl_codectx_t *ctx)
+static Value *emit_arraysize_for_unsafe_dim(jl_codectx_t &ctx,
+        const jl_cgval_t &tinfo, jl_value_t *ex, size_t dim, size_t nd)
 {
-    return dim > nd ? ConstantInt::get(T_size, 1) : emit_arraysize(tinfo, ex, dim, ctx);
+    return dim > nd ? ConstantInt::get(T_size, 1) : emit_arraysize(ctx, tinfo, ex, dim);
 }
 
 // `nd == -1` means the dimension is unknown.
-static Value *emit_array_nd_index(const jl_cgval_t &ainfo, jl_value_t *ex, ssize_t nd, jl_value_t **args,
-                                  size_t nidxs, jl_codectx_t *ctx)
+static Value *emit_array_nd_index(jl_codectx_t &ctx,
+        const jl_cgval_t &ainfo, jl_value_t *ex, ssize_t nd, const jl_cgval_t *argv, size_t nidxs)
 {
-    Value *a = boxed(ainfo, ctx);
+    Value *a = boxed(ctx, ainfo);
     Value *i = ConstantInt::get(T_size, 0);
     Value *stride = ConstantInt::get(T_size, 1);
 #if CHECK_BOUNDS==1
-    bool bc = (!ctx->is_inbounds &&
+    bool bc = (!ctx.is_inbounds &&
                jl_options.check_bounds != JL_OPTIONS_CHECK_BOUNDS_OFF) ||
         jl_options.check_bounds == JL_OPTIONS_CHECK_BOUNDS_ON;
     BasicBlock *failBB=NULL, *endBB=NULL;
@@ -1396,26 +1628,26 @@ static Value *emit_array_nd_index(const jl_cgval_t &ainfo, jl_value_t *ex, ssize
     }
 #endif
     Value **idxs = (Value**)alloca(sizeof(Value*)*nidxs);
-    for(size_t k=0; k < nidxs; k++) {
-        idxs[k] = emit_unbox(T_size, emit_expr(args[k], ctx), NULL);
+    for (size_t k = 0; k < nidxs; k++) {
+        idxs[k] = emit_unbox(ctx, T_size, argv[k], NULL);
     }
     Value *ii;
-    for(size_t k=0; k < nidxs; k++) {
-        ii = builder.CreateSub(idxs[k], ConstantInt::get(T_size, 1));
-        i = builder.CreateAdd(i, builder.CreateMul(ii, stride));
-        if (k < nidxs-1) {
+    for (size_t k = 0; k < nidxs; k++) {
+        ii = ctx.builder.CreateSub(idxs[k], ConstantInt::get(T_size, 1));
+        i = ctx.builder.CreateAdd(i, ctx.builder.CreateMul(ii, stride));
+        if (k < nidxs - 1) {
             assert(nd >= 0);
-            Value *d = emit_arraysize_for_unsafe_dim(ainfo, ex, k+1, nd, ctx);
+            Value *d = emit_arraysize_for_unsafe_dim(ctx, ainfo, ex, k + 1, nd);
 #if CHECK_BOUNDS==1
             if (bc) {
                 BasicBlock *okBB = BasicBlock::Create(jl_LLVMContext, "ib");
                 // if !(i < d) goto error
-                builder.CreateCondBr(builder.CreateICmpULT(ii, d), okBB, failBB);
-                ctx->f->getBasicBlockList().push_back(okBB);
-                builder.SetInsertPoint(okBB);
+                ctx.builder.CreateCondBr(ctx.builder.CreateICmpULT(ii, d), okBB, failBB);
+                ctx.f->getBasicBlockList().push_back(okBB);
+                ctx.builder.SetInsertPoint(okBB);
             }
 #endif
-            stride = builder.CreateMul(stride, d);
+            stride = ctx.builder.CreateMul(stride, d);
         }
     }
 #if CHECK_BOUNDS==1
@@ -1431,50 +1663,47 @@ static Value *emit_array_nd_index(const jl_cgval_t &ainfo, jl_value_t *ex, ssize
                 // We need to check if this is inside the non-linearized size
                 BasicBlock *partidx = BasicBlock::Create(jl_LLVMContext, "partlinidx");
                 BasicBlock *partidxwarn = BasicBlock::Create(jl_LLVMContext, "partlinidxwarn");
-                Value *d = emit_arraysize_for_unsafe_dim(ainfo, ex, nidxs, nd, ctx);
-                builder.CreateCondBr(builder.CreateICmpULT(ii, d), endBB, partidx);
+                Value *d = emit_arraysize_for_unsafe_dim(ctx, ainfo, ex, nidxs, nd);
+                ctx.builder.CreateCondBr(ctx.builder.CreateICmpULT(ii, d), endBB, partidx);
 
                 // We failed the normal bounds check; check to see if we're
                 // inside the linearized size (partial linear indexing):
-                ctx->f->getBasicBlockList().push_back(partidx);
-                builder.SetInsertPoint(partidx);
-                Value *alen = emit_arraylen(ainfo, ex, ctx);
-                builder.CreateCondBr(builder.CreateICmpULT(i, alen), partidxwarn, failBB);
+                ctx.f->getBasicBlockList().push_back(partidx);
+                ctx.builder.SetInsertPoint(partidx);
+                Value *alen = emit_arraylen(ctx, ainfo, ex);
+                ctx.builder.CreateCondBr(ctx.builder.CreateICmpULT(i, alen), partidxwarn, failBB);
 
                 // We passed the linearized bounds check; now throw the depwarn:
-                ctx->f->getBasicBlockList().push_back(partidxwarn);
-                builder.SetInsertPoint(partidxwarn);
-                builder.CreateCall(prepare_call(jldepwarnpi_func), ConstantInt::get(T_size, nidxs));
-                builder.CreateBr(endBB);
+                ctx.f->getBasicBlockList().push_back(partidxwarn);
+                ctx.builder.SetInsertPoint(partidxwarn);
+                ctx.builder.CreateCall(prepare_call(jldepwarnpi_func), ConstantInt::get(T_size, nidxs));
+                ctx.builder.CreateBr(endBB);
             } else {
-                Value *alen = emit_arraylen(ainfo, ex, ctx);
-                builder.CreateCondBr(builder.CreateICmpULT(i, alen), endBB, failBB);
+                Value *alen = emit_arraylen(ctx, ainfo, ex);
+                ctx.builder.CreateCondBr(ctx.builder.CreateICmpULT(i, alen), endBB, failBB);
             }
         } else {
             // Compare the last index of the access against the last dimension of
             // the accessed array, i.e. `if !(last_index < last_dimension) goto error`.
             assert(nd >= 0);
             Value *last_index = ii;
-            Value *last_dimension = emit_arraysize_for_unsafe_dim(ainfo, ex, nidxs, nd, ctx);
-            builder.CreateCondBr(builder.CreateICmpULT(last_index, last_dimension), endBB, failBB);
+            Value *last_dimension = emit_arraysize_for_unsafe_dim(ctx, ainfo, ex, nidxs, nd);
+            ctx.builder.CreateCondBr(ctx.builder.CreateICmpULT(last_index, last_dimension), endBB, failBB);
         }
 
-        ctx->f->getBasicBlockList().push_back(failBB);
-        builder.SetInsertPoint(failBB);
+        ctx.f->getBasicBlockList().push_back(failBB);
+        ctx.builder.SetInsertPoint(failBB);
         // CreateAlloca is OK here since we are on an error branch
-        Value *tmp = builder.CreateAlloca(T_size, ConstantInt::get(T_size, nidxs));
+        Value *tmp = ctx.builder.CreateAlloca(T_size, ConstantInt::get(T_size, nidxs));
         for(size_t k=0; k < nidxs; k++) {
-            builder.CreateStore(idxs[k], builder.CreateGEP(tmp, ConstantInt::get(T_size, k)));
+            ctx.builder.CreateStore(idxs[k], ctx.builder.CreateGEP(tmp, ConstantInt::get(T_size, k)));
         }
-#if JL_LLVM_VERSION >= 30700
-        builder.CreateCall(prepare_call(jlboundserrorv_func), { a, tmp, ConstantInt::get(T_size, nidxs) });
-#else
-        builder.CreateCall3(prepare_call(jlboundserrorv_func), a, tmp, ConstantInt::get(T_size, nidxs));
-#endif
-        builder.CreateUnreachable();
+        ctx.builder.CreateCall(prepare_call(jlboundserrorv_func),
+            { mark_callee_rooted(a), tmp, ConstantInt::get(T_size, nidxs) });
+        ctx.builder.CreateUnreachable();
 
-        ctx->f->getBasicBlockList().push_back(endBB);
-        builder.SetInsertPoint(endBB);
+        ctx.f->getBasicBlockList().push_back(endBB);
+        ctx.builder.SetInsertPoint(endBB);
     }
 #endif
 
@@ -1483,26 +1712,24 @@ static Value *emit_array_nd_index(const jl_cgval_t &ainfo, jl_value_t *ex, ssize
 
 // --- boxing ---
 
-static Value *emit_allocobj(jl_codectx_t *ctx, size_t static_size, Value *jt);
-static Value *emit_allocobj(jl_codectx_t *ctx, size_t static_size, const jl_cgval_t &v);
+static Value *emit_allocobj(jl_codectx_t &ctx, size_t static_size, Value *jt);
 
-static Value *init_bits_value(Value *newv, Value *v, MDNode *tbaa, unsigned alignment = sizeof(void*)) // min alignment in julia's gc is pointer-aligned
+static void init_bits_value(jl_codectx_t &ctx, Value *newv, Value *v, MDNode *tbaa,
+                            unsigned alignment = sizeof(void*)) // min alignment in julia's gc is pointer-aligned
 {
     // newv should already be tagged
-    tbaa_decorate(tbaa, builder.CreateAlignedStore(v, emit_bitcast(newv,
+    tbaa_decorate(tbaa, ctx.builder.CreateAlignedStore(v, emit_bitcast(ctx, newv,
         PointerType::get(v->getType(), 0)), alignment));
-    return newv;
 }
 
-static Value *init_bits_cgval(Value *newv, const jl_cgval_t& v, MDNode *tbaa, jl_codectx_t *ctx)
+static void init_bits_cgval(jl_codectx_t &ctx, Value *newv, const jl_cgval_t& v, MDNode *tbaa)
 {
     // newv should already be tagged
     if (v.ispointer()) {
-        builder.CreateMemCpy(newv, data_pointer(v, ctx, T_pint8), jl_datatype_size(v.typ), sizeof(void*));
-        return newv;
+        ctx.builder.CreateMemCpy(newv, data_pointer(ctx, v, T_pint8), jl_datatype_size(v.typ), sizeof(void*));
     }
     else {
-        return init_bits_value(newv, v.V, tbaa);
+        init_bits_value(ctx, newv, v.V, tbaa);
     }
 }
 
@@ -1570,43 +1797,43 @@ static jl_value_t *static_constant_instance(Constant *constant, jl_value_t *jt)
     return tpl;
 }
 
-static Value *call_with_signed(Function *sfunc, Value *v)
+static Value *call_with_signed(jl_codectx_t &ctx, Function *sfunc, Value *v)
 {
-    CallInst *Call = builder.CreateCall(prepare_call(sfunc), v);
+    CallInst *Call = ctx.builder.CreateCall(prepare_call(sfunc), v);
     Call->addAttribute(1, Attribute::SExt);
     return Call;
 }
 
-static Value *call_with_unsigned(Function *ufunc, Value *v)
+static Value *call_with_unsigned(jl_codectx_t &ctx, Function *ufunc, Value *v)
 {
-    CallInst *Call = builder.CreateCall(prepare_call(ufunc), v);
+    CallInst *Call = ctx.builder.CreateCall(prepare_call(ufunc), v);
     Call->addAttribute(1, Attribute::ZExt);
     return Call;
 }
 
-static void jl_add_method_root(jl_codectx_t *ctx, jl_value_t *val);
+static void jl_add_method_root(jl_codectx_t &ctx, jl_value_t *val);
 
-static Value *as_value(Type *to, const jl_cgval_t &v)
+static Value *as_value(jl_codectx_t &ctx, Type *to, const jl_cgval_t &v)
 {
     assert(!v.isboxed);
-    return emit_unbox(to, v, v.typ);
+    return emit_unbox(ctx, to, v, v.typ);
 }
 
 // some types have special boxing functions with small-value caches
-static Value *_boxed_special(const jl_cgval_t &vinfo, Type *t, jl_codectx_t *ctx)
+static Value *_boxed_special(jl_codectx_t &ctx, const jl_cgval_t &vinfo, Type *t)
 {
     jl_value_t *jt = vinfo.typ;
     if (jt == (jl_value_t*)jl_bool_type)
-        return julia_bool(builder.CreateTrunc(as_value(t, vinfo), T_int1));
+        return julia_bool(ctx, ctx.builder.CreateTrunc(as_value(ctx, t, vinfo), T_int1));
     if (t == T_int1)
-        return julia_bool(as_value(t, vinfo));
+        return julia_bool(ctx, as_value(ctx, t, vinfo));
 
-    if (ctx->linfo && ctx->linfo->def && !vinfo.ispointer()) { // don't bother codegen pre-boxing for toplevel
+    if (ctx.linfo && jl_is_method(ctx.linfo->def.method) && !vinfo.ispointer()) { // don't bother codegen pre-boxing for toplevel
         if (Constant *c = dyn_cast<Constant>(vinfo.V)) {
             jl_value_t *s = static_constant_instance(c, jt);
             if (s) {
                 jl_add_method_root(ctx, s);
-                return literal_pointer_val(s);
+                return literal_pointer_val(ctx, s);
             }
         }
     }
@@ -1615,209 +1842,346 @@ static Value *_boxed_special(const jl_cgval_t &vinfo, Type *t, jl_codectx_t *ctx
     assert(jl_is_datatype(jb));
     Value *box = NULL;
     if (jb == jl_int8_type)
-        box = call_with_signed(box_int8_func, as_value(t, vinfo));
+        box = call_with_signed(ctx, box_int8_func, as_value(ctx, t, vinfo));
     else if (jb == jl_int16_type)
-        box = call_with_signed(box_int16_func, as_value(t, vinfo));
+        box = call_with_signed(ctx, box_int16_func, as_value(ctx, t, vinfo));
     else if (jb == jl_int32_type)
-        box = call_with_signed(box_int32_func, as_value(t, vinfo));
+        box = call_with_signed(ctx, box_int32_func, as_value(ctx, t, vinfo));
     else if (jb == jl_int64_type)
-        box = call_with_signed(box_int64_func, as_value(t, vinfo));
+        box = call_with_signed(ctx, box_int64_func, as_value(ctx, t, vinfo));
     else if (jb == jl_float32_type)
-        box = builder.CreateCall(prepare_call(box_float32_func), as_value(t, vinfo));
+        box = ctx.builder.CreateCall(prepare_call(box_float32_func), as_value(ctx, t, vinfo));
     //if (jb == jl_float64_type)
-    //  box = builder.CreateCall(box_float64_func, as_value(t, vinfo);
+    //  box = ctx.builder.CreateCall(box_float64_func, as_value(ctx, t, vinfo);
     // for Float64, fall through to generic case below, to inline alloc & init of Float64 box. cheap, I know.
     else if (jb == jl_uint8_type)
-        box = call_with_unsigned(box_uint8_func, as_value(t, vinfo));
+        box = call_with_unsigned(ctx, box_uint8_func, as_value(ctx, t, vinfo));
     else if (jb == jl_uint16_type)
-        box = call_with_unsigned(box_uint16_func, as_value(t, vinfo));
+        box = call_with_unsigned(ctx, box_uint16_func, as_value(ctx, t, vinfo));
     else if (jb == jl_uint32_type)
-        box = call_with_unsigned(box_uint32_func, as_value(t, vinfo));
+        box = call_with_unsigned(ctx, box_uint32_func, as_value(ctx, t, vinfo));
     else if (jb == jl_uint64_type)
-        box = call_with_unsigned(box_uint64_func, as_value(t, vinfo));
+        box = call_with_unsigned(ctx, box_uint64_func, as_value(ctx, t, vinfo));
     else if (jb == jl_char_type)
-        box = call_with_unsigned(box_char_func, as_value(t, vinfo));
+        box = call_with_unsigned(ctx, box_char_func, as_value(ctx, t, vinfo));
     else if (jb == jl_ssavalue_type) {
         unsigned zero = 0;
-        Value *v = as_value(t, vinfo);
+        Value *v = as_value(ctx, t, vinfo);
         assert(v->getType() == jl_ssavalue_type->struct_decl);
-        v = builder.CreateExtractValue(v, makeArrayRef(&zero, 1));
-        box = call_with_unsigned(box_ssavalue_func, v);
+        v = ctx.builder.CreateExtractValue(v, makeArrayRef(&zero, 1));
+        box = call_with_unsigned(ctx, box_ssavalue_func, v);
     }
     else if (!jb->abstract && jl_datatype_nbits(jb) == 0) {
         // singleton
         assert(jb->instance != NULL);
-        return literal_pointer_val(jb->instance);
+        return literal_pointer_val(ctx, jb->instance);
     }
     return box;
 }
 
+
+
+static Value *box_union(jl_codectx_t &ctx, const jl_cgval_t &vinfo, const SmallBitVector &skip)
+{
+    // given vinfo::Union{T, S}, emit IR of the form:
+    //   ...
+    //   switch <tindex>, label <box_union_isboxed> [ 1, label <box_union_1>
+    //                                                2, label <box_union_2> ]
+    // box_union_1:
+    //   box1 = create_box(T)
+    //   br post_box_union
+    // box_union_2:
+    //   box2 = create_box(S)
+    //   br post_box_union
+    // box_union_isboxed:
+    //   br post_box_union
+    // post_box_union:
+    //   box = phi [ box1, box_union_1 ], [ box2, box_union_2 ], [ vinfo, box_union_isboxed ]
+    //   ...
+    Value *tindex = vinfo.TIndex;
+    BasicBlock *defaultBB = BasicBlock::Create(jl_LLVMContext, "box_union_isboxed", ctx.f);
+    SwitchInst *switchInst = ctx.builder.CreateSwitch(tindex, defaultBB);
+    BasicBlock *postBB = BasicBlock::Create(jl_LLVMContext, "post_box_union", ctx.f);
+    ctx.builder.SetInsertPoint(postBB);
+    PHINode *box_merge = ctx.builder.CreatePHI(T_prjlvalue, 2);
+    unsigned counter = 0;
+    for_each_uniontype_small(
+            [&](unsigned idx, jl_datatype_t *jt) {
+                if (idx < skip.size() && skip[idx])
+                    return;
+                Type *t = julia_type_to_llvm((jl_value_t*)jt);
+                BasicBlock *tempBB = BasicBlock::Create(jl_LLVMContext, "box_union", ctx.f);
+                ctx.builder.SetInsertPoint(tempBB);
+                switchInst->addCase(ConstantInt::get(T_int8, idx), tempBB);
+                Value *box;
+                if (type_is_ghost(t)) {
+                    box = literal_pointer_val(ctx, jt->instance);
+                }
+                else {
+                    jl_cgval_t vinfo_r = jl_cgval_t(vinfo, (jl_value_t*)jt, NULL);
+                    box = _boxed_special(ctx, vinfo_r, t);
+                    if (!box) {
+                        box = emit_allocobj(ctx, jl_datatype_size(jt), literal_pointer_val(ctx, (jl_value_t*)jt));
+                        init_bits_cgval(ctx, box, vinfo_r, jl_is_mutable(jt) ? tbaa_mutab : tbaa_immut);
+                    }
+                }
+                box_merge->addIncoming(maybe_decay_untracked(box), tempBB);
+                ctx.builder.CreateBr(postBB);
+            },
+            vinfo.typ,
+            counter);
+    ctx.builder.SetInsertPoint(defaultBB);
+    if (skip.size() > 0 && skip[0]) {
+        // skip[0] specifies where to return NULL or the original pointer
+        // if the value was not handled above
+        box_merge->addIncoming(maybe_decay_untracked(V_null), defaultBB);
+        ctx.builder.CreateBr(postBB);
+    }
+    else if ((vinfo.V == NULL || isa<AllocaInst>(vinfo.V)) && !vinfo.gcroot) {
+        Function *trap_func = Intrinsic::getDeclaration(
+                ctx.f->getParent(),
+                Intrinsic::trap);
+        ctx.builder.CreateCall(trap_func);
+        ctx.builder.CreateUnreachable();
+    }
+    else {
+        // We're guaranteed here that Load(.gcroot) == .V, because we have determined
+        // that this union is a boxed value, rather than an interior pointer of some sort
+        box_merge->addIncoming(ctx.builder.CreateLoad(vinfo.gcroot), defaultBB);
+        ctx.builder.CreateBr(postBB);
+    }
+    ctx.builder.SetInsertPoint(postBB);
+    return box_merge;
+}
+
 // 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, bool gcrooted)
+static Value *boxed(jl_codectx_t &ctx, const jl_cgval_t &vinfo, bool gcrooted)
 {
     jl_value_t *jt = vinfo.typ;
     if (jt == jl_bottom_type || jt == NULL)
         // We have an undef value on a (hopefully) dead branch
-        return UndefValue::get(T_pjlvalue);
+        return UndefValue::get(T_prjlvalue);
     if (vinfo.constant)
-        return literal_pointer_val(vinfo.constant);
-    assert(vinfo.V);
-    if (vinfo.isboxed)
-        return vinfo.V;
-
-    assert(jl_isbits(jt) && jl_is_concrete_type(jt) && "This type shouldn't have been unboxed.");
-    Type *t = julia_type_to_llvm(jt);
-    assert(!type_is_ghost(t)); // ghost values should have been handled by vinfo.constant above!
-    Value *box = _boxed_special(vinfo, t, ctx);
-    if (!box) {
-        box = init_bits_cgval(emit_allocobj(ctx, jl_datatype_size(jt), vinfo),
-                              vinfo, jl_is_mutable(jt) ? tbaa_mutab : tbaa_immut, ctx);
+        return literal_pointer_val(ctx, vinfo.constant);
+    if (vinfo.isboxed) {
+        assert(vinfo.V && "Missing value for box.");
+        // We're guaranteed here that Load(.gcroot) == .V, because we have determined
+        // that this value is a box, so if it has a gcroot, that's where the value is.
+        return vinfo.gcroot ? ctx.builder.CreateLoad(vinfo.gcroot) : vinfo.V;
+    }
+
+    Value *box;
+    if (vinfo.TIndex) {
+        SmallBitVector skip_none;
+        box = box_union(ctx, vinfo, skip_none);
+    }
+    else {
+        assert(vinfo.V && "Missing data for unboxed value.");
+        assert(jl_isbits(jt) && jl_is_concrete_type(jt) && "This type shouldn't have been unboxed.");
+        Type *t = julia_type_to_llvm(jt);
+        assert(!type_is_ghost(t)); // ghost values should have been handled by vinfo.constant above!
+        box = _boxed_special(ctx, vinfo, t);
+        if (!box) {
+            box = emit_allocobj(ctx, jl_datatype_size(jt), literal_pointer_val(ctx, (jl_value_t*)jt));
+            init_bits_cgval(ctx, box, vinfo, jl_is_mutable(jt) ? tbaa_mutab : tbaa_immut);
+        }
     }
     if (gcrooted) {
         // make a gcroot for the new box
         // (unless the caller explicitly said this was unnecessary)
         Value *froot = emit_local_root(ctx);
-        builder.CreateStore(box, froot);
+        ctx.builder.CreateStore(box, froot);
     }
     return box;
 }
 
+// copy src to dest, if src is isbits. if skip is true, the value of dest is undefined
+static void emit_unionmove(jl_codectx_t &ctx, Value *dest, const jl_cgval_t &src, Value *skip, bool isVolatile, MDNode *tbaa)
+{
+    if (AllocaInst *ai = dyn_cast<AllocaInst>(dest))
+        ctx.builder.CreateStore(UndefValue::get(ai->getAllocatedType()), ai);
+    if (jl_is_concrete_type(src.typ) || src.constant) {
+        jl_value_t *typ = src.constant ? jl_typeof(src.constant) : src.typ;
+        Type *store_ty = julia_type_to_llvm(typ);
+        assert(skip || jl_isbits(typ));
+        if (jl_isbits(typ)) {
+            if (!src.ispointer() || src.constant) {
+                emit_unbox(ctx, store_ty, src, typ, dest, isVolatile);
+            }
+            else {
+                Value *src_ptr = data_pointer(ctx, src, T_pint8);
+                if (dest->getType() != T_pint8)
+                    dest = emit_bitcast(ctx, dest, T_pint8);
+                if (skip) // copy dest -> dest to simulate an undef value / conditional copy
+                    src_ptr = ctx.builder.CreateSelect(skip, dest, src_ptr);
+                unsigned nb = jl_datatype_size(typ);
+                unsigned alignment = 0;
+                ctx.builder.CreateMemCpy(dest, src_ptr, nb, alignment, isVolatile, tbaa);
+            }
+        }
+    }
+    else if (src.TIndex) {
+        Value *tindex = ctx.builder.CreateAnd(src.TIndex, ConstantInt::get(T_int8, 0x7f));
+        if (skip)
+            tindex = ctx.builder.CreateSelect(skip, ConstantInt::get(T_int8, 0), tindex);
+        Value *src_ptr = data_pointer(ctx, src, T_pint8);
+        if (dest->getType() != T_pint8)
+            dest = emit_bitcast(ctx, dest, T_pint8);
+        BasicBlock *defaultBB = BasicBlock::Create(jl_LLVMContext, "union_move_skip", ctx.f);
+        SwitchInst *switchInst = ctx.builder.CreateSwitch(tindex, defaultBB);
+        BasicBlock *postBB = BasicBlock::Create(jl_LLVMContext, "post_union_move", ctx.f);
+        unsigned counter = 0;
+        bool allunboxed = for_each_uniontype_small(
+                [&](unsigned idx, jl_datatype_t *jt) {
+                    unsigned nb = jl_datatype_size(jt);
+                    unsigned alignment = 0;
+                    BasicBlock *tempBB = BasicBlock::Create(jl_LLVMContext, "union_move", ctx.f);
+                    ctx.builder.SetInsertPoint(tempBB);
+                    switchInst->addCase(ConstantInt::get(T_int8, idx), tempBB);
+                    if (nb > 0)
+                        ctx.builder.CreateMemCpy(dest, src_ptr, nb, alignment, isVolatile, tbaa);
+                    ctx.builder.CreateBr(postBB);
+                },
+                src.typ,
+                counter);
+        ctx.builder.SetInsertPoint(defaultBB);
+        if (!skip && allunboxed && (src.V == NULL || isa<AllocaInst>(src.V))) {
+            Function *trap_func = Intrinsic::getDeclaration(
+                    ctx.f->getParent(),
+                    Intrinsic::trap);
+            ctx.builder.CreateCall(trap_func);
+            ctx.builder.CreateUnreachable();
+        }
+        else {
+            ctx.builder.CreateBr(postBB);
+        }
+        ctx.builder.SetInsertPoint(postBB);
+    }
+    else {
+        Value *datatype = emit_typeof_boxed(ctx, src);
+        Value *copy_bytes = emit_datatype_size(ctx, datatype);
+        if (skip)
+            copy_bytes = ctx.builder.CreateSelect(skip, ConstantInt::get(copy_bytes->getType(), 0), copy_bytes);
+        ctx.builder.CreateMemCpy(dest,
+                             data_pointer(ctx, src, T_pint8),
+                             copy_bytes,
+                             /*TODO: min-align*/1);
+    }
+}
 
-static void emit_cpointercheck(const jl_cgval_t &x, const std::string &msg, jl_codectx_t *ctx)
+
+static void emit_cpointercheck(jl_codectx_t &ctx, const jl_cgval_t &x, const std::string &msg)
 {
-    Value *t = emit_typeof_boxed(x,ctx);
-    emit_typecheck(mark_julia_type(t, true, jl_any_type, ctx, false), (jl_value_t*)jl_datatype_type, msg, ctx);
+    Value *t = emit_typeof_boxed(ctx, x);
+    emit_typecheck(ctx, mark_julia_type(ctx, t, true, jl_any_type, false), (jl_value_t*)jl_datatype_type, msg);
 
     Value *istype =
-        builder.CreateICmpEQ(emit_datatype_name(t),
-                             literal_pointer_val((jl_value_t*)jl_pointer_typename));
-    BasicBlock *failBB = BasicBlock::Create(jl_LLVMContext,"fail",ctx->f);
+        ctx.builder.CreateICmpEQ(mark_callee_rooted(emit_datatype_name(ctx, t)),
+                             mark_callee_rooted(literal_pointer_val(ctx, (jl_value_t*)jl_pointer_typename)));
+    BasicBlock *failBB = BasicBlock::Create(jl_LLVMContext,"fail",ctx.f);
     BasicBlock *passBB = BasicBlock::Create(jl_LLVMContext,"pass");
-    builder.CreateCondBr(istype, passBB, failBB);
-    builder.SetInsertPoint(failBB);
+    ctx.builder.CreateCondBr(istype, passBB, failBB);
+    ctx.builder.SetInsertPoint(failBB);
 
-    emit_type_error(x, literal_pointer_val((jl_value_t*)jl_pointer_type), msg, ctx);
-    builder.CreateUnreachable();
+    emit_type_error(ctx, x, literal_pointer_val(ctx, (jl_value_t*)jl_pointer_type), msg);
+    ctx.builder.CreateUnreachable();
 
-    ctx->f->getBasicBlockList().push_back(passBB);
-    builder.SetInsertPoint(passBB);
+    ctx.f->getBasicBlockList().push_back(passBB);
+    ctx.builder.SetInsertPoint(passBB);
 }
 
 // allocation for known size object
-static Value *emit_allocobj(jl_codectx_t *ctx, size_t static_size, Value *jt)
+static Value *emit_allocobj(jl_codectx_t &ctx, size_t static_size, Value *jt)
 {
     JL_FEAT_REQUIRE(ctx, dynamic_alloc);
     JL_FEAT_REQUIRE(ctx, runtime);
-
-    int osize;
-    int offset = jl_gc_classify_pools(static_size, &osize);
-    Value *ptls_ptr = emit_bitcast(ctx->ptlsStates, T_pint8);
-    Value *v;
-    if (offset < 0) {
-        Value *args[] = {ptls_ptr,
-                         ConstantInt::get(T_size, static_size + sizeof(void*))};
-        v = builder.CreateCall(prepare_call(jlalloc_big_func),
-                               ArrayRef<Value*>(args, 2));
-    }
-    else {
-        Value *pool_offs = ConstantInt::get(T_int32, offset);
-        Value *args[] = {ptls_ptr, pool_offs, ConstantInt::get(T_int32, osize)};
-        v = builder.CreateCall(prepare_call(jlalloc_pool_func),
-                               ArrayRef<Value*>(args, 3));
-    }
-    tbaa_decorate(tbaa_tag, builder.CreateStore(jt, emit_typeptr_addr(v)));
-    return v;
-}
-static Value *emit_allocobj(jl_codectx_t *ctx, size_t static_size,
-                            const jl_cgval_t &v)
-{
-    return emit_allocobj(ctx, static_size, literal_pointer_val(v.typ));
+    Value *ptls_ptr = emit_bitcast(ctx, ctx.ptlsStates, T_pint8);
+    auto call = ctx.builder.CreateCall(prepare_call(jl_alloc_obj_func),
+                                       {ptls_ptr, ConstantInt::get(T_size, static_size),
+                                               maybe_decay_untracked(jt)});
+    call->setAttributes(jl_alloc_obj_func->getAttributes());
+    return call;
 }
 
 // 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 = emit_bitcast(emit_typeptr_addr(parent), T_psize);
-    Value *parent_type = tbaa_decorate(tbaa_tag, builder.CreateLoad(parenttag));
-    Value *parent_bits = builder.CreateAnd(parent_type, 3);
+    Value *parenttag = emit_bitcast(ctx, emit_typeptr_addr(ctx, parent), T_psize);
+    Value *parent_type = tbaa_decorate(tbaa_tag, ctx.builder.CreateLoad(parenttag));
+    Value *parent_bits = ctx.builder.CreateAnd(parent_type, 3);
 
     // the branch hint does not seem to make it to the generated code
-    Value *parent_old_marked = builder.CreateICmpEQ(parent_bits,
+    Value *parent_old_marked = ctx.builder.CreateICmpEQ(parent_bits,
                                                     ConstantInt::get(T_size, 3));
 
     BasicBlock *cont = BasicBlock::Create(jl_LLVMContext, "cont");
-    BasicBlock *barrier_may_trigger = BasicBlock::Create(jl_LLVMContext, "wb_may_trigger", ctx->f);
-    BasicBlock *barrier_trigger = BasicBlock::Create(jl_LLVMContext, "wb_trigger", ctx->f);
-    builder.CreateCondBr(parent_old_marked, barrier_may_trigger, cont);
+    BasicBlock *barrier_may_trigger = BasicBlock::Create(jl_LLVMContext, "wb_may_trigger", ctx.f);
+    BasicBlock *barrier_trigger = BasicBlock::Create(jl_LLVMContext, "wb_trigger", ctx.f);
+    ctx.builder.CreateCondBr(parent_old_marked, barrier_may_trigger, cont);
 
-    builder.SetInsertPoint(barrier_may_trigger);
-    Value *ptr_mark_bit = builder.CreateAnd(tbaa_decorate(tbaa_tag,
-        builder.CreateLoad(emit_bitcast(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), emit_bitcast(parent, T_pjlvalue));
-    builder.CreateBr(cont);
-    ctx->f->getBasicBlockList().push_back(cont);
-    builder.SetInsertPoint(cont);
+    ctx.builder.SetInsertPoint(barrier_may_trigger);
+    Value *ptr_mark_bit = ctx.builder.CreateAnd(tbaa_decorate(tbaa_tag,
+        ctx.builder.CreateLoad(emit_bitcast(ctx, emit_typeptr_addr(ctx, ptr), T_psize))), 1);
+    Value *ptr_not_marked = ctx.builder.CreateICmpEQ(ptr_mark_bit, ConstantInt::get(T_size, 0));
+    ctx.builder.CreateCondBr(ptr_not_marked, barrier_trigger, cont);
+    ctx.builder.SetInsertPoint(barrier_trigger);
+    ctx.builder.CreateCall(prepare_call(queuerootfun), maybe_decay_untracked(emit_bitcast(ctx, parent, T_prjlvalue)));
+    ctx.builder.CreateBr(cont);
+    ctx.f->getBasicBlockList().push_back(cont);
+    ctx.builder.SetInsertPoint(cont);
 }
 
-static void emit_checked_write_barrier(jl_codectx_t *ctx, Value *parent, Value *ptr)
+static void emit_checked_write_barrier(jl_codectx_t &ctx, Value *parent, Value *ptr)
 {
     BasicBlock *cont;
-    Value *not_null = builder.CreateICmpNE(ptr, V_null);
-    BasicBlock *if_not_null = BasicBlock::Create(jl_LLVMContext, "wb_not_null", ctx->f);
+    Value *not_null = ctx.builder.CreateICmpNE(mark_callee_rooted(ptr), mark_callee_rooted(V_null));
+    BasicBlock *if_not_null = BasicBlock::Create(jl_LLVMContext, "wb_not_null", ctx.f);
     cont = BasicBlock::Create(jl_LLVMContext, "cont");
-    builder.CreateCondBr(not_null, if_not_null, cont);
-    builder.SetInsertPoint(if_not_null);
+    ctx.builder.CreateCondBr(not_null, if_not_null, cont);
+    ctx.builder.SetInsertPoint(if_not_null);
     emit_write_barrier(ctx, parent, ptr);
-    builder.CreateBr(cont);
-    ctx->f->getBasicBlockList().push_back(cont);
-    builder.SetInsertPoint(cont);
+    ctx.builder.CreateBr(cont);
+    ctx.f->getBasicBlockList().push_back(cont);
+    ctx.builder.SetInsertPoint(cont);
 }
 
-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)
+static void emit_setfield(jl_codectx_t &ctx,
+        jl_datatype_t *sty, const jl_cgval_t &strct, size_t idx0,
+        const jl_cgval_t &rhs, bool checked, bool wb)
 {
     if (sty->mutabl || !checked) {
         assert(strct.ispointer());
-        Value *addr = builder.CreateGEP(data_pointer(strct, ctx, T_pint8),
+        Value *addr = ctx.builder.CreateGEP(data_pointer(ctx, strct, T_pint8),
                 ConstantInt::get(T_size, jl_field_offset(sty, idx0)));
         jl_value_t *jfty = jl_svecref(sty->types, idx0);
         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)
-            tbaa_decorate(strct.tbaa, builder.CreateStore(r, emit_bitcast(addr, T_ppjlvalue)));
-            if (wb && strct.isboxed) emit_checked_write_barrier(ctx, boxed(strct, ctx), r);
-            mark_gc_use(strct);
+            Value *r = maybe_decay_untracked(boxed(ctx, rhs, false)); // don't need a temporary gcroot since it'll be rooted by strct
+            tbaa_decorate(strct.tbaa, ctx.builder.CreateStore(r,
+                emit_bitcast(ctx, addr, T_pprjlvalue)));
+            if (wb && strct.isboxed)
+                emit_checked_write_barrier(ctx, boxed(ctx, strct), r);
         }
         else {
             int align = jl_field_offset(sty, idx0);
             align |= 16;
             align &= -align;
-            typed_store(addr, ConstantInt::get(T_size, 0), rhs, jfty, ctx,
-                strct.tbaa, data_pointer(strct, ctx, T_pjlvalue), align);
+            typed_store(ctx, addr, ConstantInt::get(T_size, 0), rhs, jfty,
+                strct.tbaa, data_pointer(ctx, strct, T_pjlvalue), align);
         }
     }
     else {
         // TODO: better error
-        emit_error("type is immutable", ctx);
+        emit_error(ctx, "type is immutable");
     }
 }
 
-static bool might_need_root(jl_value_t *ex)
-{
-    return (!jl_is_symbol(ex) && !jl_is_slot(ex) && !jl_is_ssavalue(ex) &&
-            !jl_is_bool(ex) && !jl_is_quotenode(ex) && !jl_is_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)
+static jl_cgval_t emit_new_struct(jl_codectx_t &ctx, jl_value_t *ty, size_t nargs, const jl_cgval_t *argv)
 {
     assert(jl_is_datatype(ty));
     assert(jl_is_concrete_type(ty));
-    assert(nargs>0);
+    assert(nargs > 0);
     jl_datatype_t *sty = (jl_datatype_t*)ty;
     size_t nf = jl_datatype_nfields(sty);
     if (nf > 0) {
@@ -1836,31 +2200,30 @@ static jl_cgval_t emit_new_struct(jl_value_t *ty, size_t nargs, jl_value_t **arg
             if (init_as_value)
                 strct = UndefValue::get(lt == T_void ? NoopType : lt);
             else
-                strct = emit_static_alloca(lt);
+                strct = emit_static_alloca(ctx, lt);
 
             unsigned idx = 0;
-            for (size_t i=0; i < na; i++) {
-                jl_value_t *jtype = jl_svecref(sty->types,i);
+            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_expr(args[i+1], ctx);
-                if (!jl_subtype(fval_info.typ, jtype))
-                    emit_typecheck(fval_info, jtype, "new", ctx);
+                const jl_cgval_t &fval_info = argv[i + 1];
+                emit_typecheck(ctx, fval_info, jtype, "new");
                 if (!type_is_ghost(fty)) {
                     Value *fval = NULL, *dest = NULL;
                     if (!init_as_value) {
-                        // avoid unboxing the argument explicitely
+                        // avoid unboxing the argument explicitly
                         // and use memcpy instead
-                        dest = builder.CreateConstInBoundsGEP2_32(LLVM37_param(lt) strct, 0, i);
+                        dest = ctx.builder.CreateConstInBoundsGEP2_32(lt, strct, 0, i);
                     }
-                    fval = emit_unbox(fty, fval_info, jtype, dest);
+                    fval = emit_unbox(ctx, fty, fval_info, jtype, dest);
 
                     if (init_as_value) {
                         if (lt->isVectorTy())
-                            strct = builder.CreateInsertElement(strct, fval, ConstantInt::get(T_int32,idx));
+                            strct = ctx.builder.CreateInsertElement(strct, fval, ConstantInt::get(T_int32, idx));
                         else if (jl_is_vecelement_type(ty))
                             strct = fval;  // VecElement type comes unwrapped in LLVM.
                         else if (lt->isAggregateType())
-                            strct = builder.CreateInsertValue(strct, fval, ArrayRef<unsigned>(&idx,1));
+                            strct = ctx.builder.CreateInsertValue(strct, fval, ArrayRef<unsigned>(&idx, 1));
                         else
                             assert(false);
                     }
@@ -1868,54 +2231,31 @@ static jl_cgval_t emit_new_struct(jl_value_t *ty, size_t nargs, jl_value_t **arg
                 idx++;
             }
             if (init_as_value)
-                return mark_julia_type(strct, false, ty, ctx);
+                return mark_julia_type(ctx, strct, false, ty);
             else
-                return mark_julia_slot(strct, ty, tbaa_stack);
-        }
-        Value *f1 = NULL;
-        size_t j = 0;
-        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
-            // for the new struct.
-            jl_cgval_t fval_info = emit_expr(args[1],ctx);
-            f1 = boxed(fval_info, ctx);
-            j++;
+                return mark_julia_slot(strct, ty, NULL, tbaa_stack);
         }
         Value *strct = emit_allocobj(ctx, jl_datatype_size(sty),
-                                     literal_pointer_val((jl_value_t*)ty));
-        jl_cgval_t strctinfo = mark_julia_type(strct, true, ty, ctx);
-        if (f1) {
-            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)))
-                emit_typecheck(f1info, jl_field_type(sty,0), "new", ctx);
-            emit_setfield(sty, strctinfo, 0, f1info, ctx, false, false);
-        }
-        for(size_t i=j; i < nf; i++) {
+                                     literal_pointer_val(ctx, (jl_value_t*)ty));
+        jl_cgval_t strctinfo = mark_julia_type(ctx, strct, true, ty);
+        for (size_t i = 0; i < nf; i++) {
             if (jl_field_isptr(sty, i)) {
-                tbaa_decorate(strctinfo.tbaa, builder.CreateStore(
-                        V_null,
-                        builder.CreatePointerCast(
-                            builder.CreateGEP(emit_bitcast(strct, T_pint8),
-                                ConstantInt::get(T_size, jl_field_offset(sty,i))),
-                            T_ppjlvalue)));
+                tbaa_decorate(strctinfo.tbaa, ctx.builder.CreateStore(
+                        ConstantPointerNull::get(cast<PointerType>(T_prjlvalue)),
+                        emit_bitcast(ctx,
+                            ctx.builder.CreateGEP(emit_bitcast(ctx, decay_derived(strct), T_pint8),
+                                ConstantInt::get(T_size, jl_field_offset(sty, i))),
+                            T_pprjlvalue)));
             }
         }
         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 (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)))
-                    emit_typecheck(rhs, jl_svecref(sty->types,i-1), "new", ctx);
-            }
-            if (might_need_root(args[i])) // TODO: how to remove this?
+        for (size_t i = 1; i < nargs; i++) {
+            const jl_cgval_t &rhs = argv[i];
+            if (jl_field_isptr(sty, i - 1) && !rhs.isboxed)
                 need_wb = true;
-            emit_setfield(sty, strctinfo, i-1, rhs, ctx, false, need_wb);
+            emit_typecheck(ctx, rhs, jl_svecref(sty->types, i - 1), "new");
+            emit_setfield(ctx, sty, strctinfo, i - 1, rhs, false, need_wb);
         }
         return strctinfo;
     }
@@ -1923,12 +2263,10 @@ static jl_cgval_t emit_new_struct(jl_value_t *ty, size_t nargs, jl_value_t **arg
         // 0 fields, ghost or bitstype
         if (jl_datatype_nbits(sty) == 0)
             return ghostValue(sty);
-        if (nargs >= 2)
-            return emit_expr(args[1], ctx);  // do side effects
         bool isboxed;
         Type *lt = julia_type_to_llvm(ty, &isboxed);
         assert(!isboxed);
-        return mark_julia_type(UndefValue::get(lt), false, ty, ctx);
+        return mark_julia_type(ctx, UndefValue::get(lt), false, ty);
     }
     else {
         // 0 fields, singleton
@@ -1937,39 +2275,35 @@ static jl_cgval_t emit_new_struct(jl_value_t *ty, size_t nargs, jl_value_t **arg
     }
 }
 
-static Value *emit_exc_in_transit(jl_codectx_t *ctx)
+static Value *emit_exc_in_transit(jl_codectx_t &ctx)
 {
-    Value *pexc_in_transit = emit_bitcast(ctx->ptlsStates, T_ppjlvalue);
+    Value *pexc_in_transit = emit_bitcast(ctx, ctx.ptlsStates, T_pprjlvalue);
     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");
+    return ctx.builder.CreateGEP(pexc_in_transit, ArrayRef<Value*>(offset), "jl_exception_in_transit");
 }
 
-static void emit_signal_fence(void)
+static void emit_signal_fence(jl_codectx_t &ctx)
 {
 #if defined(_CPU_ARM_) || defined(_CPU_AARCH64_)
     // LLVM generates very inefficient code (and might include function call)
     // for signal fence. Fallback to the poor man signal fence with
     // inline asm instead.
     // https://llvm.org/bugs/show_bug.cgi?id=27545
-    builder.CreateCall(InlineAsm::get(FunctionType::get(T_void, false), "",
+    ctx.builder.CreateCall(InlineAsm::get(FunctionType::get(T_void, false), "",
                                       "~{memory}", true));
 #else
-#  if JL_LLVM_VERSION >= 30900
-    builder.CreateFence(AtomicOrdering::SequentiallyConsistent, SingleThread);
-#  else
-    builder.CreateFence(SequentiallyConsistent, SingleThread);
-#  endif
+    ctx.builder.CreateFence(AtomicOrdering::SequentiallyConsistent, SingleThread);
 #endif
 }
 
-static Value *emit_defer_signal(jl_codectx_t *ctx)
+static Value *emit_defer_signal(jl_codectx_t &ctx)
 {
-    Value *ptls = emit_bitcast(ctx->ptlsStates,
+    Value *ptls = emit_bitcast(ctx, ctx.ptlsStates,
                                         PointerType::get(T_sigatomic, 0));
     Constant *offset = ConstantInt::getSigned(T_int32,
         offsetof(jl_tls_states_t, defer_signal) / sizeof(sig_atomic_t));
-    return builder.CreateGEP(ptls, ArrayRef<Value*>(offset), "jl_defer_signal");
+    return ctx.builder.CreateGEP(ptls, ArrayRef<Value*>(offset), "jl_defer_signal");
 }
 
 static int compare_cgparams(const jl_cgparams_t *a, const jl_cgparams_t *b)
diff --git a/src/codegen.cpp b/src/codegen.cpp
index 36feb8b1005b25..65a2f4a56ccf23 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include "llvm-version.h"
 #include "platform.h"
@@ -33,74 +33,59 @@
 #include <cstdio>
 #include <cassert>
 #include <iostream>
+#include <functional>
 
 // target machine computation
 #include <llvm/Target/TargetSubtargetInfo.h>
 #include <llvm/Support/TargetRegistry.h>
-#if JL_LLVM_VERSION < 30700
-#include <llvm/Target/TargetLibraryInfo.h>
-#endif
 #include <llvm/Target/TargetOptions.h>
 #include <llvm/Support/Host.h>
 #include <llvm/Support/TargetSelect.h>
-#if JL_LLVM_VERSION >= 30700
 #include <llvm/Analysis/TargetLibraryInfo.h>
-#endif
-
-#if JL_LLVM_VERSION >= 30700
 #include <llvm/Object/SymbolSize.h>
-#endif
 
 // IR building
 #include <llvm/IR/IntrinsicInst.h>
-#if JL_LLVM_VERSION >= 30500
 #include <llvm/Object/ObjectFile.h>
 #include <llvm/IR/DIBuilder.h>
 #include <llvm/AsmParser/Parser.h>
-#else
-#include <llvm/Assembly/Parser.h>
-#endif
 #include <llvm/DebugInfo/DIContext.h>
 #include <llvm/IR/DerivedTypes.h>
 #include <llvm/IR/Intrinsics.h>
 #include <llvm/IR/Attributes.h>
 #include <llvm/IR/IRBuilder.h>
 #include <llvm/IR/MDBuilder.h>
-#if JL_LLVM_VERSION < 30500
-#include <llvm/DebugInfo.h>
-#include <llvm/DIBuilder.h>
-#endif
 
 // support
+#include <llvm/ADT/SmallBitVector.h>
+#include <llvm/ADT/Optional.h>
 #include <llvm/Support/raw_ostream.h>
 #include <llvm/Support/FormattedStream.h>
 #include <llvm/Support/SourceMgr.h> // for llvmcall
 #include <llvm/Transforms/Utils/Cloning.h> // for llvmcall inlining
-#if JL_LLVM_VERSION >= 30500
 #include <llvm/IR/Verifier.h> // for llvmcall validation
+#if JL_LLVM_VERSION >= 40000
+#  include <llvm/Bitcode/BitcodeWriter.h>
 #else
-#include <llvm/Analysis/Verifier.h>
+#  include <llvm/Bitcode/ReaderWriter.h>
 #endif
 
 // C API
-#if JL_LLVM_VERSION >= 30800
 #include <llvm-c/Types.h>
-#else
-#include <llvm-c/Core.h>
-#endif
 
 // for configuration options
 #include <llvm/Support/PrettyStackTrace.h>
 #include <llvm/Support/CommandLine.h>
 
+#include <llvm/IR/InlineAsm.h>
 #if defined(_CPU_ARM_) || defined(_CPU_AARCH64_)
-#  include <llvm/IR/InlineAsm.h>
 #  include <sys/utsname.h>
 #endif
 #if defined(USE_POLLY)
 #include <polly/RegisterPasses.h>
 #include <polly/ScopDetection.h>
 #endif
+#include "fix_llvm_assert.h"
 
 using namespace llvm;
 namespace llvm {
@@ -114,16 +99,10 @@ namespace llvm {
 #include "julia.h"
 #include "julia_internal.h"
 #include "jitlayers.h"
-#include "codegen_internal.h"
+#include "codegen_shared.h"
 
 // LLVM version compatibility macros
-#if JL_LLVM_VERSION >= 30700
 legacy::PassManager *jl_globalPM;
-#define LLVM37_param(x) (x),
-#else
-#define LLVM37_param(x)
-PassManager *jl_globalPM;
-#endif
 
 #if JL_LLVM_VERSION >= 40000
 #define DIFlagZero (DINode::FlagZero)
@@ -131,14 +110,6 @@ PassManager *jl_globalPM;
 #define DIFlagZero (0)
 #endif
 
-#if JL_LLVM_VERSION < 30500
-#define AddrSpaceCastInst BitCastInst
-#endif
-
-#if !defined(_COMPILER_MICROSOFT_) && __cplusplus < 201103L && !defined(static_assert)
-#  define static_assert(...)
-#endif
-
 extern "C" {
 
 #include "builtin_proto.h"
@@ -185,12 +156,7 @@ extern void _chkstk(void);
 #define DISABLE_FLOAT16
 
 // llvm state
-#if JL_LLVM_VERSION >= 30900
 JL_DLLEXPORT LLVMContext jl_LLVMContext;
-#else
-JL_DLLEXPORT LLVMContext &jl_LLVMContext = getGlobalContext();
-#endif
-static IRBuilder<> builder(jl_LLVMContext);
 static bool nested_compile = false;
 TargetMachine *jl_TargetMachine;
 
@@ -200,20 +166,18 @@ extern JITEventListener *CreateJuliaJITEventListener();
 bool imaging_mode = false;
 
 Module *shadow_output;
-#define jl_Module ctx->f->getParent()
-#define jl_builderModule builder.GetInsertBlock()->getParent()->getParent()
+#define jl_Module ctx.f->getParent()
+#define jl_builderModule(builder) (builder).GetInsertBlock()->getParent()->getParent()
 
-#if JL_LLVM_VERSION >= 30700
-// No DataLayout pass needed anymore.
-#elif JL_LLVM_VERSION >= 30500
-static DataLayoutPass *jl_data_layout;
-#else
-static DataLayout *jl_data_layout;
-#endif
+static DataLayout jl_data_layout("");
 
 // types
+static Type *T_jlvalue;
 static Type *T_pjlvalue;
+static Type *T_prjlvalue;
 static Type *T_ppjlvalue;
+static Type *T_pprjlvalue;
+static Type *jl_array_llvmt;
 static Type *jl_parray_llvmt;
 static FunctionType *jl_func_sig;
 static FunctionType *jl_func_sig_sparams;
@@ -263,7 +227,8 @@ static MDNode *tbaa_binding;        // jl_binding_t::value
 static MDNode *tbaa_value;          // jl_value_t, that is not jl_array_t
 static MDNode *tbaa_mutab;              // mutable type
 static MDNode *tbaa_immut;              // immutable type
-static MDNode *tbaa_arraybuf;       // Data in an array
+static MDNode *tbaa_ptrarraybuf;    // Data in an array of boxed values
+static MDNode *tbaa_arraybuf;       // Data in an array of POD
 static MDNode *tbaa_array;      // jl_array_t
 static MDNode *tbaa_arrayptr;       // The pointer inside a jl_array_t
 static MDNode *tbaa_arraysize;      // A size in a jl_array_t
@@ -272,34 +237,19 @@ static MDNode *tbaa_arrayflags;     // The flags in a jl_array_t
 static MDNode *tbaa_const;      // Memory that is immutable by the time LLVM can see it
 
 // Basic DITypes
-#if JL_LLVM_VERSION >= 30700
 static DICompositeType *jl_value_dillvmt;
 static DIDerivedType *jl_pvalue_dillvmt;
 static DIDerivedType *jl_ppvalue_dillvmt;
 static DISubroutineType *jl_di_func_sig;
 static DISubroutineType *jl_di_func_null_sig;
-#else
-static DICompositeType jl_value_dillvmt;
-static DIDerivedType jl_pvalue_dillvmt;
-static DIDerivedType jl_ppvalue_dillvmt;
-#if JL_LLVM_VERSION >= 30600
-DISubroutineType jl_di_func_sig;
-DISubroutineType jl_di_func_null_sig;
-#else
-DICompositeType jl_di_func_sig;
-DICompositeType jl_di_func_null_sig;
-#endif
-#endif
-
 
 extern "C"
-int32_t jl_jlcall_api(const void *function)
+int32_t jl_jlcall_api(const char *fname)
 {
     // give the function an index in the constant lookup table
-    if (function == NULL)
+    if (fname == NULL)
         return 0;
-    const Function *F = cast<const Function>((const Value*)function);
-    StringRef Name = F->getName();
+    StringRef Name(fname);
     if (Name.startswith("japi3_")) // jlcall abi 3 from JIT
         return 3;
     assert(Name.startswith("japi1_") || // jlcall abi 1 from JIT
@@ -311,9 +261,8 @@ int32_t jl_jlcall_api(const void *function)
 
 
 // constants
-static Value *V_null;
+static Constant *V_null;
 static Type *NoopType;
-static Value *literal_pointer_val(jl_value_t *p);
 extern "C" {
 JL_DLLEXPORT Type *julia_type_to_llvm(jl_value_t *jt, bool *isboxed=NULL);
 }
@@ -327,9 +276,6 @@ static GlobalVariable *jlRTLD_DEFAULT_var;
 #ifdef _OS_WINDOWS_
 static GlobalVariable *jlexe_var;
 static GlobalVariable *jldll_var;
-#if defined(_CPU_X86_64_) && !defined(USE_MCJIT)
-JITMemoryManager *createJITMemoryManagerWin();
-#endif
 #endif //_OS_WINDOWS_
 
 static Function *jltls_states_func;
@@ -337,8 +283,8 @@ static Function *jltls_states_func;
 static GlobalVariable *jltls_states_var;
 #else
 // Imaging mode only
-static GlobalVariable *jltls_states_func_ptr = NULL;
 size_t jltls_states_func_idx = 0;
+size_t jltls_offset_idx = 0;
 #endif
 
 // important functions
@@ -354,6 +300,7 @@ static Function *jlboundserrorv_func;
 static Function *jlcheckassign_func;
 static Function *jldeclareconst_func;
 static Function *jlgetbindingorerror_func;
+static Function *jlboundp_func;
 static Function *jltopeval_func;
 static Function *jlcopyast_func;
 static Function *jltuple_func;
@@ -367,13 +314,12 @@ static Function *jlgenericfunction_func;
 static Function *jlenter_func;
 static Function *jlleave_func;
 static Function *jlegal_func;
-static Function *jlalloc_pool_func;
-static Function *jlalloc_big_func;
+static Function *jl_alloc_obj_func;
 static Function *jlisa_func;
 static Function *jlsubtype_func;
 static Function *jlapplytype_func;
 static Function *setjmp_func;
-static Function *memcmp_func;
+static Function *memcmp_derived_func;
 static Function *box_int8_func;
 static Function *box_uint8_func;
 static Function *box_int16_func;
@@ -396,10 +342,6 @@ static Function *jldlsym_func;
 static Function *jlnewbits_func;
 static Function *jltypeassert_func;
 static Function *jldepwarnpi_func;
-#if JL_LLVM_VERSION < 30600
-static Function *jlpow_func;
-static Function *jlpowf_func;
-#endif
 //static Function *jlgetnthfield_func;
 static Function *jlgetnthfieldchecked_func;
 //static Function *jlsetnthfield_func;
@@ -414,11 +356,9 @@ static Function *jlarray_data_owner_func;
 static GlobalVariable *jlgetworld_global;
 
 // placeholder functions
-static Function *gcroot_func;
-static Function *gckill_func;
-static Function *jlcall_frame_func;
 static Function *gcroot_flush_func;
 static Function *except_enter_func;
+static Function *pointer_from_objref_func;
 
 static std::vector<Type *> two_pvalue_llvmt;
 static std::vector<Type *> three_pvalue_llvmt;
@@ -431,35 +371,61 @@ extern "C" {
     int globalUnique = 0;
 }
 
+static bool isbits_spec(jl_value_t *jt, bool allow_singleton = true)
+{
+    return jl_isbits(jt) && jl_is_concrete_type(jt) &&
+        (allow_singleton || (jl_datatype_size(jt) > 0) || (jl_datatype_nfields(jt) > 0));
+}
+
+static MDNode *best_tbaa(jl_value_t *jt) {
+    jt = jl_unwrap_unionall(jt);
+    if (!jl_is_datatype(jt))
+        return tbaa_value;
+    if (jl_is_abstracttype(jt))
+        return tbaa_value;
+    // If we're here, we know all subtypes are (im)mutable, even if we
+    // don't know what the exact type is
+    return jl_is_mutable(jt) ? tbaa_mutab : tbaa_immut;
+}
+
 // 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)
+    Value *TIndex; // if `V` is an unboxed (tagged) Union described by `typ`, this gives the DataType index (1-based, small int) as an i8
     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
     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 isimmutable; // V points to something that is definitely immutable (e.g. single-assignment, but including memory)
-    MDNode *tbaa; // The related tbaa node. Non-NULL iff this is not a pointer.
+    MDNode *tbaa; // The related tbaa node. Non-NULL iff this holds an address.
     bool ispointer() const
     {
+        // whether this value is compatible with `data_pointer`
         return tbaa != nullptr;
     }
-    jl_cgval_t(Value *V, Value *gcroot, bool isboxed, jl_value_t *typ) : // general constructor (with pointer type auto-detect)
+    //bool isvalue() const
+    //{
+    //    // whether this value is compatible with loading into registers (`emit_unbox` without an explicit type)
+    //    return isbits_spec(typ) && (!ispointer() || constant);
+    //}
+    jl_cgval_t(Value *V, Value *gcroot, bool isboxed, jl_value_t *typ, Value *tindex) : // 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
+        TIndex(tindex),
         constant(NULL),
         gcroot(gcroot),
         typ(typ),
         isboxed(isboxed),
         isghost(false),
         isimmutable(isboxed && jl_is_immutable_datatype(typ)),
-        tbaa(isboxed ? (jl_is_concrete_type(typ) ?
-                        (jl_is_mutable(typ) ? tbaa_mutab : tbaa_immut) :
-                        tbaa_value) : nullptr)
+        tbaa(isboxed ? best_tbaa(typ) : nullptr)
     {
+        assert(!(isboxed && TIndex != NULL));
+        assert(TIndex == NULL || TIndex->getType() == T_int8);
     }
     jl_cgval_t(jl_value_t *typ) : // ghost value constructor
         V(NULL),
+        TIndex(NULL),
         constant(((jl_datatype_t*)typ)->instance),
         gcroot(NULL),
         typ(typ),
@@ -471,8 +437,9 @@ struct jl_cgval_t {
         assert(jl_is_datatype(typ));
         assert(constant);
     }
-    jl_cgval_t(const jl_cgval_t &v, jl_value_t *typ) : // copy constructor with new type
+    jl_cgval_t(const jl_cgval_t &v, jl_value_t *typ, Value *tindex) : // copy constructor with new type
         V(v.V),
+        TIndex(tindex),
         constant(v.constant),
         gcroot(v.gcroot),
         typ(typ),
@@ -481,10 +448,18 @@ struct jl_cgval_t {
         isimmutable(v.isimmutable),
         tbaa(v.tbaa)
     {
-        assert(isboxed || v.typ == typ); // expect a badly or equivalently typed version
+        // this constructor expects we had a badly or equivalently typed version
+        // make sure we aren't discarding the actual type information
+        if (v.TIndex) {
+            assert((TIndex == NULL) == jl_is_concrete_type(typ));
+        }
+        else {
+            assert(isboxed || v.typ == typ || tindex);
+        }
     }
     jl_cgval_t() : // undef / unreachable / default constructor
         V(UndefValue::get(T_void)),
+        TIndex(NULL),
         constant(NULL),
         gcroot(NULL),
         typ(jl_bottom_type),
@@ -498,35 +473,27 @@ struct jl_cgval_t {
 
 // per-local-variable information
 struct jl_varinfo_t {
-    Value *boxroot; // an address, if the var is in a jl_value_t* gc stack slot or jl_box_t* Box object (marked tbaa_const, if appropriate)
-    jl_cgval_t value; // a value, if the var is unboxed or SSA (and thus boxroot == NULL)
-#if JL_LLVM_VERSION >= 30700
+    Instruction *boxroot; // an address, if the var might be in a jl_value_t** stack slot (marked tbaa_const, if appropriate)
+    jl_cgval_t value; // a stack slot or constant value
+    Value *pTIndex; // i8* stack slot for the value.TIndex tag describing `value.V`
     DILocalVariable *dinfo;
-#else
-    DIVariable dinfo;
-#endif
     // if the variable might be used undefined and is not boxed
     // this i1 flag is true when it is defined
     Value *defFlag;
     bool isSA;
     bool isVolatile;
     bool isArgument;
-    bool escapes;
     bool usedUndef;
     bool used;
 
     jl_varinfo_t() : boxroot(NULL),
                      value(jl_cgval_t()),
-#if JL_LLVM_VERSION >= 30700
+                     pTIndex(NULL),
                      dinfo(NULL),
-#else
-                     dinfo(DIVariable()),
-#endif
                      defFlag(NULL),
                      isSA(false),
                      isVolatile(false),
                      isArgument(false),
-                     escapes(true),
                      usedUndef(false),
                      used(false)
     {
@@ -541,100 +508,123 @@ typedef struct {
     jl_value_t *ty;
 } jl_arrayvar_t;
 
+struct jl_returninfo_t {
+    Function *decl;
+    enum CallingConv {
+        Boxed = 0,
+        Register,
+        SRet,
+        Union,
+        Ghosts
+    } cc;
+    size_t union_bytes;
+    size_t union_align;
+    size_t union_minalign;
+};
+
+static jl_returninfo_t get_specsig_function(Module *M, const std::string &name, jl_value_t *sig, jl_value_t *jlrettype);
+
 // information about the context of a piece of code: its enclosing
 // function and module, and visible local variables and labels.
 class jl_codectx_t {
 public:
-    Function *f;
+    IRBuilder<> builder;
+    Function *f = NULL;
     // local var info. globals are not in here.
     std::vector<jl_varinfo_t> slots;
     std::vector<jl_cgval_t> SAvalues;
     std::vector<bool> ssavalue_assigned;
-    std::map<int, jl_arrayvar_t> *arrayvars;
-    jl_module_t *module;
-    jl_method_instance_t *linfo;
-    jl_code_info_t *source;
-    jl_array_t *code;
-    size_t world;
-    jl_array_t *roots;
-    const char *name;
-    StringRef file;
-    ssize_t *line;
-    Value *spvals_ptr;
-    Value *argArray;
-    Value *argCount;
+    std::map<int, jl_arrayvar_t> *arrayvars = NULL;
+    jl_module_t *module = NULL;
+    jl_method_instance_t *linfo = NULL;
+    jl_code_info_t *source = NULL;
+    jl_array_t *code = NULL;
+    size_t world = 0;
+    jl_array_t *roots = NULL;
+    const char *name = NULL;
+    StringRef file{};
+    ssize_t *line = NULL;
+    Value *spvals_ptr = NULL;
+    Value *argArray = NULL;
+    Value *argCount = NULL;
     std::string funcName;
-    int vaSlot;        // name of vararg argument
-    bool vaStack;      // varargs stack-allocated
-    bool sret;
-    int nReqArgs;
-    int nargs;
+    int vaSlot = -1;        // name of vararg argument
+    bool vaStack = false;      // varargs stack-allocated
+    bool has_sret = false;
+    int nReqArgs = 0;
+    int nargs = 0;
 
-    CallInst *ptlsStates;
-    Value *signalPage;
-    Value *world_age_field;
+    CallInst *ptlsStates = NULL;
+    Value *signalPage = NULL;
+    Value *world_age_field = NULL;
 
-    bool debug_enabled;
-    bool is_inbounds{false};
+    bool debug_enabled = false;
+    bool is_inbounds = false;
 
-    const jl_cgparams_t *params;
+    const jl_cgparams_t *params = NULL;
+
+    jl_codectx_t(LLVMContext &llvmctx)
+      : builder(llvmctx) { }
 
     ~jl_codectx_t() {
         assert(this->roots == NULL);
     }
 };
 
-static jl_cgval_t emit_expr(jl_value_t *expr, jl_codectx_t *ctx);
-
-static Value *emit_local_root(jl_codectx_t *ctx, jl_varinfo_t *vi = NULL);
-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, MDNode *tbaa);
-static jl_cgval_t emit_sparam(size_t i, jl_codectx_t *ctx);
-static Value *emit_condition(const jl_cgval_t &condV, const std::string &msg, jl_codectx_t *ctx);
-static void allocate_gc_frame(BasicBlock *b0, jl_codectx_t *ctx);
-static GlobalVariable *prepare_global(GlobalVariable *G, Module *M = jl_builderModule);
-static Value *prepare_call(Value *Callee);
-static Value *prepare_call(IRBuilder<> &builder, Value *Callee);
-
-
-template<typename T> static void push_gc_use(T &&vec, const jl_cgval_t &v)
-{
-    if (v.gcroot) {
-        vec.push_back(v.gcroot);
-    }
-}
-
-template<typename T> static void mark_gc_uses(T &&vec)
-{
-    auto f = prepare_call(gckill_func);
-    for (auto &v: vec) {
-        builder.CreateCall(f, v);
-    }
-}
+static jl_cgval_t emit_expr(jl_codectx_t &ctx, jl_value_t *expr);
+static Value *emit_local_root(jl_codectx_t &ctx, jl_varinfo_t *vi = NULL);
+static Value *global_binding_pointer(jl_codectx_t &ctx, jl_module_t *m, jl_sym_t *s,
+                                     jl_binding_t **pbnd, bool assign);
+static jl_cgval_t emit_checked_var(jl_codectx_t &ctx, Value *bp, jl_sym_t *name, bool isvol, MDNode *tbaa);
+static jl_cgval_t emit_sparam(jl_codectx_t &ctx, size_t i);
+static Value *emit_condition(jl_codectx_t &ctx, const jl_cgval_t &condV, const std::string &msg);
+static void allocate_gc_frame(jl_codectx_t &ctx, BasicBlock *b0);
+static void CreateTrap(IRBuilder<> &irbuilder);
+static Value *emit_jlcall(jl_codectx_t &ctx, Value *theFptr, Value *theF,
+                          jl_cgval_t *args, size_t nargs);
+
+static Value *literal_pointer_val(jl_codectx_t &ctx, jl_value_t *p);
+static GlobalVariable *prepare_global_in(Module *M, GlobalVariable *G);
+#define prepare_global(G) prepare_global_in(jl_Module, (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->ptlsStates);
-}
-static AllocaInst *emit_static_alloca(Type *lty, jl_codectx_t *ctx)
+static GlobalVariable *get_pointer_to_constant(Constant *val, StringRef name, Module &M)
 {
-    return emit_static_alloca(lty, 1, ctx);
+    GlobalVariable *gv = new GlobalVariable(
+            M,
+            val->getType(),
+            true,
+            GlobalVariable::PrivateLinkage,
+            val,
+            name);
+    gv->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
+    return gv;
 }
-static AllocaInst *emit_static_alloca(Type *lty)
+
+static AllocaInst *emit_static_alloca(jl_codectx_t &ctx, Type *lty, int arraysize=1)
 {
-    return new AllocaInst(lty, "",
-            /*InsertBefore=*/&*builder.GetInsertBlock()->getParent()->getEntryBlock().getFirstInsertionPt());
+    return new AllocaInst(lty,
+#if JL_LLVM_VERSION >= 50000
+            0,
+#endif
+            ConstantInt::get(T_int32, arraysize), "", /*InsertBefore=*/ctx.ptlsStates);
 }
 
 static inline jl_cgval_t ghostValue(jl_value_t *typ)
 {
     if (typ == jl_bottom_type)
         return jl_cgval_t(); // Undef{}
+    if (typ == (jl_value_t*)jl_typeofbottom_type) {
+        // normalize TypeofBottom to Type{Union{}}
+        typ = (jl_value_t*)jl_wrap_Type(jl_bottom_type);
+    }
+    if (jl_is_type_type(typ)) {
+        // replace T::Type{T} with T, by assuming that T must be a concrete type of some sort
+        jl_cgval_t constant(NULL, NULL, true, typ, NULL);
+        constant.constant = jl_tparam0(typ);
+        return constant;
+    }
     return jl_cgval_t(typ);
 }
 static inline jl_cgval_t ghostValue(jl_datatype_t *typ)
@@ -642,27 +632,46 @@ static inline jl_cgval_t ghostValue(jl_datatype_t *typ)
     return ghostValue((jl_value_t*)typ);
 }
 
-static inline jl_cgval_t mark_julia_slot(Value *v, jl_value_t *typ, MDNode *tbaa)
+static inline jl_cgval_t mark_julia_const(jl_value_t *jv)
+{
+    jl_value_t *typ;
+    if (jl_is_type(jv)) {
+        typ = (jl_value_t*)jl_wrap_Type(jv); // TODO: gc-root this?
+    }
+    else {
+        typ = jl_typeof(jv);
+        if (type_is_ghost(julia_type_to_llvm(typ))) {
+            return ghostValue(typ);
+        }
+    }
+    jl_cgval_t constant(NULL, NULL, true, typ, NULL);
+    constant.constant = jv;
+    return constant;
+}
+
+
+static inline jl_cgval_t mark_julia_slot(Value *v, jl_value_t *typ, Value *tindex, MDNode *tbaa)
 {
     // this enables lazy-copying of immutable values and stack or argument slots
     assert(tbaa);
-    jl_cgval_t tagval(v, NULL, false, typ);
+    jl_cgval_t tagval(v, NULL, false, typ, tindex);
     tagval.tbaa = tbaa;
     tagval.isimmutable = true;
     return tagval;
 }
 
-static inline jl_cgval_t mark_julia_type(Value *v, bool isboxed, jl_value_t *typ, jl_codectx_t *ctx, bool needsroot = true)
+static inline jl_cgval_t mark_julia_type(jl_codectx_t &ctx, Value *v, bool isboxed, jl_value_t *typ, bool needsroot = true)
 {
     if (jl_is_datatype(typ) && jl_is_datatype_singleton((jl_datatype_t*)typ)) {
         // no need to explicitly load/store a constant/ghost value
         return ghostValue(typ);
     }
-    if (jl_is_type_type(typ) && jl_is_concrete_type(jl_tparam0(typ))) {
-        // replace T::Type{T} with T
-        jl_cgval_t constant(NULL, NULL, true, typ);
-        constant.constant = jl_tparam0(typ);
-        return constant;
+    if (jl_is_type_type(typ)) {
+        jl_value_t *tp0 = jl_tparam0(typ);
+        if (jl_is_concrete_type(tp0) || tp0 == jl_bottom_type) {
+            // replace T::Type{T} with T
+            return ghostValue(typ);
+        }
     }
     Type *T = julia_type_to_llvm(typ);
     if (type_is_ghost(T)) {
@@ -671,51 +680,121 @@ static inline jl_cgval_t mark_julia_type(Value *v, bool isboxed, jl_value_t *typ
     if (v && T->isAggregateType() && !isboxed) {
         // 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, tbaa_stack);
+        Value *loc;
+        if (Constant *cv = dyn_cast<Constant>(v)) {
+            loc = get_pointer_to_constant(cv, "", *jl_Module);
+        }
+        else {
+            loc = emit_static_alloca(ctx, T);
+            ctx.builder.CreateStore(v, loc);
+        }
+        return mark_julia_slot(loc, typ, NULL, tbaa_stack);
     }
     Value *froot = NULL;
     if (needsroot && isboxed) {
         froot = emit_local_root(ctx);
-        builder.CreateStore(v, froot);
+        ctx.builder.CreateStore(v, froot);
     }
-    return jl_cgval_t(v, froot, isboxed, typ);
+    return jl_cgval_t(v, froot, isboxed, typ, NULL);
 }
 
-static inline jl_cgval_t mark_julia_type(Value *v, bool isboxed, jl_datatype_t *typ, jl_codectx_t *ctx, bool needsroot = true)
+static inline jl_cgval_t mark_julia_type(jl_codectx_t &ctx, Value *v, bool isboxed, jl_datatype_t *typ, bool needsroot = true)
 {
-    return mark_julia_type(v, isboxed, (jl_value_t*)typ, ctx, needsroot);
+    return mark_julia_type(ctx, v, isboxed, (jl_value_t*)typ, needsroot);
 }
 
-static inline jl_cgval_t remark_julia_type(const jl_cgval_t &v, jl_value_t *typ, jl_codectx_t *ctx)
+// see if it might be profitable (and cheap) to change the type of v to typ
+static inline jl_cgval_t update_julia_type(jl_codectx_t &ctx, const jl_cgval_t &v, jl_value_t *typ)
 {
-    if (v.typ == typ)
+    if (v.typ == typ || v.typ == jl_bottom_type || v.constant || typ == (jl_value_t*)jl_any_type || jl_egal(v.typ, typ))
         return v; // fast-path
+    if (jl_is_concrete_type(v.typ) && !jl_is_kind(v.typ)) {
+        if (jl_is_concrete_type(typ) && !jl_is_kind(typ) && !((jl_datatype_t*)typ)->abstract && !((jl_datatype_t*)v.typ)->abstract) {
+            // type mismatch: changing from one concrete type to another
+            CreateTrap(ctx.builder);
+            return jl_cgval_t();
+        }
+        return v; // doesn't improve type info
+    }
+    if (v.TIndex) {
+        if (!jl_is_concrete_type(typ))
+            return v; // not worth trying to improve type info
+        if (!isbits_spec(typ)) {
+            // discovered that this union-split type must actually be isboxed
+            if (v.V) {
+                return jl_cgval_t(v.V, v.gcroot, true, typ, NULL);
+            }
+            else {
+                // type mismatch (there weren't any boxed values in the union)
+                CreateTrap(ctx.builder);
+                return jl_cgval_t();
+            }
+        }
+    }
     Type *T = julia_type_to_llvm(typ);
     if (type_is_ghost(T))
         return ghostValue(typ);
-    return jl_cgval_t(v, typ);
+    return jl_cgval_t(v, typ, NULL);
 }
 
-static inline jl_cgval_t mark_julia_const(jl_value_t *jv)
+// --- allocating local variables ---
+
+static jl_sym_t *slot_symbol(jl_codectx_t &ctx, int s)
 {
-    jl_value_t *typ;
-    if (jl_is_type(jv))
-        typ = (jl_value_t*)jl_wrap_Type(jv); // TODO: gc-root this?
-    else
-        typ = jl_typeof(jv);
-    if (type_is_ghost(julia_type_to_llvm(typ))) {
-        return ghostValue(typ);
+    return (jl_sym_t*)jl_array_ptr_ref(ctx.source->slotnames, s);
+}
+
+static void store_def_flag(jl_codectx_t &ctx, const jl_varinfo_t &vi, bool val)
+{
+    assert((!vi.boxroot || vi.pTIndex) && "undef check is null pointer for boxed things");
+    assert(vi.usedUndef && vi.defFlag && "undef flag codegen corrupted");
+    ctx.builder.CreateStore(ConstantInt::get(T_int1, val), vi.defFlag, vi.isVolatile);
+}
+
+static void alloc_def_flag(jl_codectx_t &ctx, jl_varinfo_t& vi)
+{
+    assert((!vi.boxroot || vi.pTIndex) && "undef check is null pointer for boxed things");
+    if (vi.usedUndef) {
+        vi.defFlag = emit_static_alloca(ctx, T_int1);
+        store_def_flag(ctx, vi, false);
     }
-    jl_cgval_t constant(NULL, NULL, true, typ);
-    constant.constant = jv;
-    return constant;
 }
 
+
 // --- utilities ---
 
-static void emit_write_barrier(jl_codectx_t*, Value*, Value*);
+static void CreateTrap(IRBuilder<> &irbuilder)
+{
+    Function *f = irbuilder.GetInsertBlock()->getParent();
+    Function *trap_func = Intrinsic::getDeclaration(
+            f->getParent(),
+            Intrinsic::trap);
+    irbuilder.CreateCall(trap_func);
+    irbuilder.CreateUnreachable();
+    BasicBlock *newBB = BasicBlock::Create(irbuilder.getContext(), "after_noret", f);
+    irbuilder.SetInsertPoint(newBB);
+}
+
+#if 0 // this code is likely useful, but currently unused
+#ifndef JL_NDEBUG
+static void CreateConditionalAbort(IRBuilder<> &irbuilder, Value *test)
+{
+    Function *f = irbuilder.GetInsertBlock()->getParent();
+    BasicBlock *abortBB = BasicBlock::Create(jl_LLVMContext, "debug_abort", f);
+    BasicBlock *postBB = BasicBlock::Create(jl_LLVMContext, "post_abort", f);
+    irbuilder.CreateCondBr(test, abortBB, postBB);
+    irbuilder.SetInsertPoint(abortBB);
+    Function *trap_func = Intrinsic::getDeclaration(
+            f->getParent(),
+            Intrinsic::trap);
+    irbuilder.CreateCall(trap_func);
+    irbuilder.CreateUnreachable();
+    irbuilder.SetInsertPoint(postBB);
+}
+#endif
+#endif
+
+static void emit_write_barrier(jl_codectx_t&, Value*, Value*);
 
 #include "cgutils.cpp"
 
@@ -737,68 +816,220 @@ static void jl_rethrow_with_add(const char *fmt, ...)
     jl_rethrow();
 }
 
-static void CreateTrap(IRBuilder<> &builder)
-{
-    Function *f = builder.GetInsertBlock()->getParent();
-    Function *trap_func = Intrinsic::getDeclaration(
-            f->getParent(),
-            Intrinsic::trap);
-    builder.CreateCall(trap_func);
-    builder.CreateUnreachable();
-    BasicBlock *newBB = BasicBlock::Create(builder.getContext(), "after_noret", f);
-    builder.SetInsertPoint(newBB);
-}
-
-// --- allocating local variables ---
-
-static bool isbits_spec(jl_value_t *jt, bool allow_singleton = true)
+// given a value marked with type `v.typ`, compute the mapping and/or boxing to return a value of type `typ`
+static jl_cgval_t convert_julia_type(jl_codectx_t &ctx, const jl_cgval_t &v, jl_value_t *typ, bool needsroot = true)
 {
-    return jl_isbits(jt) && jl_is_concrete_type(jt) &&
-        (allow_singleton || (jl_datatype_size(jt) > 0) || (jl_datatype_nfields(jt) > 0));
-}
-
-static jl_sym_t *slot_symbol(int s, jl_codectx_t *ctx)
-{
-    return (jl_sym_t*)jl_array_ptr_ref(ctx->source->slotnames, s);
-}
+    if (typ == (jl_value_t*)jl_typeofbottom_type)
+        return ghostValue(typ); // normalize TypeofBottom to Type{Union{}}
+    if (v.typ == typ || v.typ == jl_bottom_type || jl_egal(v.typ, typ))
+        return v; // fast-path
+    Type *T = julia_type_to_llvm(typ);
+    if (type_is_ghost(T))
+        return ghostValue(typ);
+    Value *new_tindex = NULL;
+    if (jl_is_concrete_type(typ)) {
+        if (v.TIndex && !isbits_spec(typ)) {
+            // discovered that this union-split type must actually be isboxed
+            if (v.V) {
+                return jl_cgval_t(v.V, v.gcroot, true, typ, NULL);
+            }
+            else {
+                // type mismatch: there weren't any boxed values in the union
+                CreateTrap(ctx.builder);
+                return jl_cgval_t();
+            }
+        }
+        if (jl_is_concrete_type(v.typ) && !jl_is_kind(v.typ) && !((jl_datatype_t*)v.typ)->abstract) {
+            if (jl_is_concrete_type(typ) && !jl_is_kind(typ) && !((jl_datatype_t*)typ)->abstract) {
+                // type mismatch: changing from one concrete type to another
+                CreateTrap(ctx.builder);
+                return jl_cgval_t();
+            }
+        }
+    }
+    else {
+        bool makeboxed = false;
+        if (v.TIndex) {
+            // previous value was a split union, compute new index, or box
+            new_tindex = ConstantInt::get(T_int8, 0x80);
+            SmallBitVector skip_box(1, true);
+            Value *tindex = ctx.builder.CreateAnd(v.TIndex, ConstantInt::get(T_int8, 0x7f));
+            if (jl_is_uniontype(typ)) {
+                // compute the TIndex mapping from v.typ -> typ
+                unsigned counter = 0;
+                for_each_uniontype_small(
+                        // for each old union-split value
+                        [&](unsigned idx, jl_datatype_t *jt) {
+                            unsigned new_idx = get_box_tindex(jt, typ);
+                            bool t;
+                            if (new_idx) {
+                                // found a matching element,
+                                // match it against either the unboxed index
+                                Value *cmp = ctx.builder.CreateICmpEQ(tindex, ConstantInt::get(T_int8, idx));
+                                new_tindex = ctx.builder.CreateSelect(cmp, ConstantInt::get(T_int8, new_idx), new_tindex);
+                                t = true;
+                            }
+                            else if (!jl_subtype((jl_value_t*)jt, typ)) {
+                                // new value doesn't need to be boxed
+                                // since it isn't part of the new union
+                                t = true;
+                            }
+                            else {
+                                // will actually need to box this element
+                                // since it appeared as a concrete type in the original type
+                                // but not in the remark type
+                                t = false;
+                            }
+                            skip_box.resize(idx + 1, t);
+                        },
+                        v.typ,
+                        counter);
+            }
 
-static void store_def_flag(const jl_varinfo_t &vi, bool val)
-{
-    assert(!vi.boxroot && "undef check is null pointer for boxed things");
-    assert(vi.usedUndef && vi.defFlag && "undef flag codegen corrupted");
-    builder.CreateStore(ConstantInt::get(T_int1, val), vi.defFlag, vi.isVolatile);
-}
+            // some of the values are still unboxed
+            if (!isa<Constant>(new_tindex)) {
+                Value *wasboxed = NULL;
+                // check if some of the old values might have been boxed
+                // and copy that information over into the new tindex
+                if (v.ispointer() && v.V && !isa<AllocaInst>(v.V)) {
+                    wasboxed = ctx.builder.CreateAnd(v.TIndex, ConstantInt::get(T_int8, 0x80));
+                    new_tindex = ctx.builder.CreateOr(wasboxed, new_tindex);
+                    wasboxed = ctx.builder.CreateICmpNE(wasboxed, ConstantInt::get(T_int8, 0));
+
+                    // may need to handle compute_box_tindex for some of the values
+                    BasicBlock *currBB = ctx.builder.GetInsertBlock();
+                    Value *union_box_dt = NULL;
+                    Value *union_box_tindex = ConstantInt::get(T_int8, 0x80);
+                    unsigned counter = 0;
+                    for_each_uniontype_small(
+                            // for each new union-split value
+                            [&](unsigned idx, jl_datatype_t *jt) {
+                                unsigned old_idx = get_box_tindex(jt, v.typ);
+                                if (old_idx == 0) {
+                                    if (!union_box_dt) {
+                                        BasicBlock *isaBB = BasicBlock::Create(jl_LLVMContext, "union_isa", ctx.f);
+                                        ctx.builder.SetInsertPoint(isaBB);
+                                        union_box_dt = emit_typeof(ctx, v.V);
+                                    }
+                                    // didn't handle this item before, select its new union index
+                                    Value *cmp = ctx.builder.CreateICmpEQ(maybe_decay_untracked(literal_pointer_val(ctx, (jl_value_t*)jt)), union_box_dt);
+                                    union_box_tindex = ctx.builder.CreateSelect(cmp, ConstantInt::get(T_int8, 0x80 | idx), union_box_tindex);
+                                }
+                            },
+                            typ,
+                            counter);
+                    if (union_box_dt) {
+                        BasicBlock *isaBB = ctx.builder.GetInsertBlock();
+                        BasicBlock *postBB = BasicBlock::Create(jl_LLVMContext, "post_union_isa", ctx.f);
+                        ctx.builder.CreateBr(postBB);
+                        ctx.builder.SetInsertPoint(currBB);
+                        Value *wasunknown = ctx.builder.CreateICmpEQ(v.TIndex, ConstantInt::get(T_int8, 0x80));
+                        ctx.builder.CreateCondBr(wasunknown, isaBB, postBB);
+                        ctx.builder.SetInsertPoint(postBB);
+                        PHINode *tindex_phi = ctx.builder.CreatePHI(T_int8, 2);
+                        tindex_phi->addIncoming(new_tindex, currBB);
+                        tindex_phi->addIncoming(union_box_tindex, isaBB);
+                        new_tindex = tindex_phi;
+                    }
 
-static void alloc_def_flag(jl_varinfo_t& vi, jl_codectx_t* ctx)
-{
-    assert(!vi.boxroot && "undef check is null pointer for boxed things");
-    if (vi.usedUndef) {
-        vi.defFlag = emit_static_alloca(T_int1, ctx);
-        store_def_flag(vi, false);
-    }
-}
+                }
 
-static void maybe_alloc_arrayvar(int s, jl_codectx_t *ctx)
-{
-    jl_value_t *jt = ctx->slots[s].value.typ;
-    if (arraytype_constshape(jt)) {
-        // TODO: this optimization does not yet work with 1-d arrays, since the
-        // length and data pointer can change at any time via push!
-        // we could make it work by reloading the metadata when the array is
-        // passed to an external function (ideally only impure functions)
-        jl_arrayvar_t av;
-        int ndims = jl_unbox_long(jl_tparam1(jt));
-        Type *elt = julia_type_to_llvm(jl_tparam0(jt));
-        if (type_is_ghost(elt))
-            return;
-        // CreateAlloca is OK here because maybe_alloc_arrayvar is only called in the prologue setup
-        av.dataptr = builder.CreateAlloca(PointerType::get(elt,0));
-        av.len = builder.CreateAlloca(T_size);
-        for (int i = 0; i < ndims - 1; i++)
-            av.sizes.push_back(builder.CreateAlloca(T_size));
-        av.ty = jt;
-        (*ctx->arrayvars)[s] = av;
+                if (!skip_box.all()) {
+                    // some values weren't unboxed in the new union
+                    // box them now (tindex above already selected 0x80 = box for them)
+                    // root the result, and return a new mark_julia_slot over the result
+                    Value *boxv = box_union(ctx, v, skip_box);
+                    Value *froot = NULL;
+                    if (needsroot) {
+                        // build a new gc-root, as needed
+                        froot = emit_local_root(ctx);
+                        Value *newroot = boxv;
+                        if (wasboxed || v.gcroot) { // oldbox might be all ghost values (which don't need roots)
+                            // store either the old box or the new box into the gc-root (skip_box ensures these are mutually-exclusive)
+                            // need to clone the value from `v.gcroot` if this isn't a new box
+                            Value *oldroot;
+                            if (v.gcroot)
+                                oldroot = ctx.builder.CreateLoad(v.gcroot);
+                            else
+                                oldroot = v.V;
+                            newroot = ctx.builder.CreateSelect(wasboxed, emit_bitcast(ctx, oldroot, boxv->getType()), newroot);
+                        }
+                        ctx.builder.CreateStore(newroot, froot);
+                    }
+                    if (v.V == NULL) {
+                        // v.V might be NULL if it was all ghost objects before
+                        return jl_cgval_t(boxv, froot, false, typ, new_tindex);
+                    }
+                    else {
+                        Value *isboxv = ctx.builder.CreateIsNotNull(boxv);
+                        Value *slotv;
+                        MDNode *tbaa;
+                        bool isimmutable;
+                        if (v.ispointer()) {
+                            slotv = v.V;
+                            tbaa = v.tbaa;
+                            isimmutable = v.isimmutable;
+                        }
+                        else {
+                            slotv = emit_static_alloca(ctx, v.V->getType());
+                            ctx.builder.CreateStore(v.V, slotv);
+                            tbaa = tbaa_stack;
+                            isimmutable = true;
+                        }
+                        slotv = ctx.builder.CreateSelect(isboxv,
+                            decay_derived(boxv), emit_bitcast(ctx, slotv, boxv->getType()));
+                        jl_cgval_t newv = jl_cgval_t(slotv, froot, false, typ, new_tindex);
+                        newv.tbaa = tbaa;
+                        newv.isimmutable = isimmutable;
+                        return newv;
+                    }
+                }
+            }
+            else {
+                new_tindex = NULL;
+                makeboxed = true;
+            }
+        }
+        else if (!v.isboxed && jl_is_uniontype(typ)) {
+            // previous value was unboxed (concrete type), statically compute union tindex
+            assert(jl_is_concrete_type(v.typ));
+            unsigned new_idx = get_box_tindex((jl_datatype_t*)v.typ, typ);
+            if (new_idx) {
+                new_tindex = ConstantInt::get(T_int8, new_idx);
+                if (v.V && !v.ispointer()) {
+                    // TODO: remove this branch once all consumers of v.TIndex understand how to handle a non-ispointer value
+                    Value *slotv = emit_static_alloca(ctx, v.V->getType());
+                    ctx.builder.CreateStore(v.V, slotv);
+                    jl_cgval_t newv = jl_cgval_t(slotv, NULL, false, typ, new_tindex);
+                    newv.tbaa = tbaa_stack;
+                    newv.isimmutable = true;
+                    return newv;
+                }
+            }
+            else if (jl_subtype(v.typ, typ)) {
+                makeboxed = true;
+            }
+            else {
+                // unreachable
+                CreateTrap(ctx.builder);
+                return jl_cgval_t();
+            }
+        }
+        else if (!v.isboxed) {
+            makeboxed = true;
+        }
+        if (makeboxed) {
+            // convert to a simple isboxed value
+            Value *boxv = boxed(ctx, v, false);
+            Value *froot = NULL;
+            if (needsroot) {
+                froot = emit_local_root(ctx);
+                ctx.builder.CreateStore(maybe_decay_untracked(boxv), froot);
+            }
+            return jl_cgval_t(boxv, froot, true, typ, NULL);
+        }
     }
+    return jl_cgval_t(v, typ, new_tindex);
 }
 
 // Snooping on which functions are being compiled, and how long it takes
@@ -827,6 +1058,7 @@ void jl_add_linfo_in_flight(StringRef name, jl_method_instance_t *linfo, const D
 extern "C"
 jl_llvm_functions_t jl_compile_linfo(jl_method_instance_t **pli, jl_code_info_t *src, size_t world, const jl_cgparams_t *params)
 {
+    // N.B.: `src` may have not been rooted by the caller.
     JL_TIMING(CODEGEN);
     jl_method_instance_t *li = *pli;
     assert(jl_is_method_instance(li));
@@ -836,151 +1068,156 @@ jl_llvm_functions_t jl_compile_linfo(jl_method_instance_t **pli, jl_code_info_t
         !compare_cgparams(params, &jl_default_cgparams) && params->cached)
         jl_error("functions compiled with custom codegen params mustn't be cached");
 
-    // Step 1. See if it is already compiled,
-    //         Get the codegen lock,
-    //         And get the source
-    if (li->def == NULL) {
-        JL_LOCK(&codegen_lock);
-        src = (jl_code_info_t*)li->inferred;
-        decls = li->functionObjectsDecls;
-        if (decls.functionObject != NULL || !src || !jl_is_code_info(src) || li->jlcall_api == 2) {
-            JL_UNLOCK(&codegen_lock);
-            return decls;
-        }
-    }
-    else if (!src) {
-        // Step 1a. If the caller didn't provide the source,
-        //          try to infer it for ourself
-        // first see if it is already compiled
+    // Fast path for the already-compiled case
+    if (jl_is_method(li->def.method)) {
         decls = li->functionObjectsDecls;
-        if ((params->cached && decls.functionObject != NULL) || li->jlcall_api == 2) {
-            if (li->min_world <= world && li->max_world >= world)
+        bool already_compiled = params->cached && decls.functionObject != NULL;
+        if (!src) {
+            if ((already_compiled || li->jlcall_api == 2) &&
+                (li->min_world <= world && li->max_world >= world)) {
                 return decls;
-        }
-        JL_LOCK(&codegen_lock);
-        assert(li->min_world <= world && li->max_world >= world);
-        decls = li->functionObjectsDecls;
-        if ((params->cached && decls.functionObject != NULL) || li->jlcall_api == 2) {
-            JL_UNLOCK(&codegen_lock);
+            }
+        } else if (already_compiled) {
             return decls;
         }
+    }
 
-        // see if it is inferred
-        src = (jl_code_info_t*)li->inferred;
-        if (src) {
-            if (!jl_is_code_info(src)) {
-                src = jl_type_infer(pli, world, 0);
-                li = *pli;
-            }
-            if (!src || li->jlcall_api == 2) {
-                JL_UNLOCK(&codegen_lock);
-                return decls;
+    JL_GC_PUSH1(&src);
+    JL_LOCK(&codegen_lock);
+    decls = li->functionObjectsDecls;
+
+    // Codegen lock held in this block
+    {
+        // Step 1: Re-check if this was already compiled (it may have been while
+        // we waited at the lock).
+        if (!jl_is_method(li->def.method)) {
+            src = (jl_code_info_t*)li->inferred;
+            if (decls.functionObject != NULL || !src || !jl_is_code_info(src) || li->jlcall_api == 2) {
+                goto locked_out;
             }
         }
-        else {
-            // declare a failure to compile
-            JL_UNLOCK(&codegen_lock);
-            return decls;
-        }
-    }
-    else {
-        // similar to above, but never returns a NULL
-        // decl (unless compile fails), even if jlcall_api == 2
-        decls = li->functionObjectsDecls;
-        if (params->cached && decls.functionObject != NULL) {
-            return decls;
+        else if (!src) {
+            // If the caller didn't provide the source,
+            // try to infer it for ourself, but first, re-check if it's already compiled.
+            assert(li->min_world <= world && li->max_world >= world);
+            if ((params->cached && decls.functionObject != NULL) || li->jlcall_api == 2)
+                goto locked_out;
+
+            // see if it is inferred
+            src = (jl_code_info_t*)li->inferred;
+            if (src) {
+                if ((jl_value_t*)src != jl_nothing)
+                    src = jl_uncompress_ast(li->def.method, (jl_array_t*)src);
+                if (!jl_is_code_info(src)) {
+                    src = jl_type_infer(pli, world, 0);
+                    li = *pli;
+                }
+                if (!src || li->jlcall_api == 2)
+                    goto locked_out;
+            }
+            else {
+                // declare a failure to compile
+                goto locked_out;
+            }
         }
-        JL_LOCK(&codegen_lock);
-        decls = li->functionObjectsDecls;
-        if (params->cached && decls.functionObject != NULL) {
-            JL_UNLOCK(&codegen_lock);
-            return decls;
+        else if (params->cached && decls.functionObject != NULL) {
+            // similar to above, but never returns a NULL
+            // decl (unless compile fails), even if jlcall_api == 2
+            goto locked_out;
         }
-    }
-    JL_GC_PUSH1(&src);
-    assert(jl_is_code_info(src));
-
-    // Step 2: setup global state
-    IRBuilderBase::InsertPoint old = builder.saveAndClearIP();
-    DebugLoc olddl = builder.getCurrentDebugLocation();
-    bool last_n_c = nested_compile;
-    if (!nested_compile && dump_compiles_stream != NULL)
-        last_time = jl_hrtime();
-    nested_compile = true;
+        else {
+            if ((jl_value_t*)src != jl_nothing)
+                src = jl_uncompress_ast(li->def.method, (jl_array_t*)src);
+        }
+        assert(jl_is_code_info(src));
+
+        // Step 2: setup global state
+        bool last_n_c = nested_compile;
+        if (!nested_compile && dump_compiles_stream != NULL)
+            last_time = jl_hrtime();
+        nested_compile = true;
+
+        // Step 3. actually do the work of emitting the function
+        std::unique_ptr<Module> m;
+        JL_TRY {
+            jl_llvm_functions_t *pdecls;
+            if (!params->cached)
+                pdecls = &decls;
+            else if (li->min_world <= world && li->max_world >= world)
+                pdecls = &li->functionObjectsDecls;
+            else if (!jl_is_method(li->def.method)) // toplevel thunk
+                pdecls = &li->functionObjectsDecls;
+            else
+                pdecls = &decls;
+            m = emit_function(li, src, world, pdecls, params);
+            if (params->cached && world)
+                decls = li->functionObjectsDecls;
+            //n_emit++;
+        }
+        JL_CATCH {
+            // something failed! this is very bad, since other WIP may be pointing to this function
+            // but there's not much we can do now. try to clear much of the WIP anyways.
+            li->functionObjectsDecls.functionObject = NULL;
+            li->functionObjectsDecls.specFunctionObject = NULL;
+            nested_compile = last_n_c;
+            JL_UNLOCK(&codegen_lock); // Might GC
+            const char *mname = jl_symbol_name(jl_is_method(li->def.method) ? li->def.method->name : anonymous_sym);
+            jl_rethrow_with_add("error compiling %s", mname);
+        }
+        const char *f = decls.functionObject;
+        const char *specf = decls.specFunctionObject;
+
+        if (JL_HOOK_TEST(params, module_activation)) {
+            JL_HOOK_CALL(params, module_activation, 1, jl_box_voidpointer(wrap(m.release())));
+        } else {
+            // Step 4. Prepare debug info to receive this function
+            // record that this function name came from this linfo,
+            // so we can build a reverse mapping for debug-info.
+            bool toplevel = !jl_is_method(li->def.method);
+            if (!toplevel) {
+                const DataLayout &DL = m->getDataLayout();
+                // but don't remember toplevel thunks 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(StringRef(specf ? specf : f), li, DL);
+            }
 
-    // Step 3. actually do the work of emitting the function
-    std::unique_ptr<Module> m;
-    JL_TRY {
-        jl_llvm_functions_t *pdecls;
-        if (!params->cached)
-            pdecls = &decls;
-        else if (li->min_world <= world && li->max_world >= world)
-            pdecls = &li->functionObjectsDecls;
-        else if (li->def == NULL)
-            pdecls = &li->functionObjectsDecls;
-        else
-            pdecls = &decls;
-        m = emit_function(li, src, world, pdecls, params);
-        if (params->cached && world)
-            decls = li->functionObjectsDecls;
-        //n_emit++;
-    }
-    JL_CATCH {
-        // something failed! this is very bad, since other WIP may be pointing to this function
-        // but there's not much we can do now. try to clear much of the WIP anyways.
-        li->functionObjectsDecls.functionObject = NULL;
-        li->functionObjectsDecls.specFunctionObject = NULL;
-        nested_compile = last_n_c;
-        builder.restoreIP(old);
-        builder.SetCurrentDebugLocation(olddl);
-        JL_UNLOCK(&codegen_lock); // Might GC
-        jl_rethrow_with_add("error compiling %s", jl_symbol_name(li->def ? li->def->name : anonymous_sym));
-    }
-    Function *f = (Function*)decls.functionObject;
-    Function *specf = (Function*)decls.specFunctionObject;
-
-
-    if (JL_HOOK_TEST(params, module_activation)) {
-        JL_HOOK_CALL(params, module_activation, 1, jl_box_voidpointer(wrap(m.release())));
-    } else {
-        // Step 4. Prepare debug info to receive this function
-        // record that this function name came from this linfo,
-        // so we can build a reverse mapping for debug-info.
-        bool toplevel = li->def == NULL;
-        if (!toplevel) {
-            const DataLayout &DL =
-#if JL_LLVM_VERSION >= 30500
-                m->getDataLayout();
-#else
-                *jl_data_layout;
-#endif
-            // but don't remember toplevel thunks 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);
+            // Step 5. Add the result to the execution engine now
+            jl_finalize_module(m.release(), !toplevel);
         }
 
-        // Step 5. Add the result to the execution engine now
-        jl_finalize_module(m.release(), !toplevel);
-    }
-
-    if (world && li->jlcall_api != 2) {
         // if not inlineable, code won't be needed again
-        if (JL_DELETE_NON_INLINEABLE && jl_options.debug_level <= 1 &&
-            li->def && li->inferred && jl_is_code_info(li->inferred) &&
-            !((jl_code_info_t*)li->inferred)->inlineable &&
-            li != li->def->unspecialized && !imaging_mode) {
+        if (JL_DELETE_NON_INLINEABLE &&
+                // don't delete code when debugging level >= 2
+                jl_options.debug_level <= 1 &&
+                // don't delete toplevel code
+                jl_is_method(li->def.method) &&
+                // don't change inferred state
+                li->inferred &&
+                // and there is something to delete (test this before calling jl_ast_flag_inlineable)
+                li->inferred != jl_nothing &&
+                // don't delete the code for the generator
+                li != li->def.method->generator &&
+                // don't delete inlineable code, unless it is constant
+                (li->jlcall_api == 2 || !jl_ast_flag_inlineable((jl_array_t*)li->inferred)) &&
+                // don't delete code when generating a precompile file
+                !imaging_mode &&
+                // don't delete code when it's not actually directly being used
+                world) {
             li->inferred = jl_nothing;
         }
+
+        // Step 6: Done compiling: Restore global state
+        nested_compile = last_n_c;
     }
 
-    // Step 6: Done compiling: Restore global state
-    builder.restoreIP(old);
-    builder.SetCurrentDebugLocation(olddl);
-    nested_compile = last_n_c;
     JL_UNLOCK(&codegen_lock); // Might GC
 
-    if (dump_compiles_stream != NULL) {
+    // If logging of the compilation stream is enabled then dump the function to the stream
+    // ... unless li->def isn't defined here meaning the function is a toplevel thunk and
+    // would have its CodeInfo printed in the stream, which might contain double-quotes that
+    // would not be properly escaped given the double-quotes added to the stream below.
+    if (dump_compiles_stream != NULL && jl_is_method(li->def.method)) {
         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);
@@ -989,23 +1226,14 @@ jl_llvm_functions_t jl_compile_linfo(jl_method_instance_t **pli, jl_code_info_t
     }
     JL_GC_POP();
     return decls;
-}
 
-#if JL_LLVM_VERSION < 30700
-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;
+locked_out:
+    JL_UNLOCK(&codegen_lock);
+    JL_GC_POP();
+    return decls;
 }
-#else
+
 #define getModuleFlag(m,str) m->getModuleFlag(str)
-#endif
 
 static void jl_setup_module(Module *m, const jl_cgparams_t *params = &jl_default_cgparams)
 {
@@ -1025,63 +1253,51 @@ static void jl_setup_module(Module *m, const jl_cgparams_t *params = &jl_default
 #endif
         m->addModuleFlag(llvm::Module::Warning, "Dwarf Version", dwarf_version);
     }
-#if JL_LLVM_VERSION >= 30400
     if (!getModuleFlag(m,"Debug Info Version"))
         m->addModuleFlag(llvm::Module::Error, "Debug Info Version",
             llvm::DEBUG_METADATA_VERSION);
-#endif
-#if JL_LLVM_VERSION >= 30700
-#ifdef USE_ORCJIT
-    m->setDataLayout(jl_ExecutionEngine->getDataLayout());
-#elif JL_LLVM_VERSION >= 30800
-    m->setDataLayout(jl_ExecutionEngine->getDataLayout().getStringRepresentation());
+#if JL_LLVM_VERSION >= 40000
+    m->setDataLayout(jl_data_layout);
 #else
-    m->setDataLayout(jl_ExecutionEngine->getDataLayout()->getStringRepresentation());
-#endif
-    m->setTargetTriple(jl_TargetMachine->getTargetTriple().str());
-#elif JL_LLVM_VERSION >= 30600
     m->setDataLayout(jl_ExecutionEngine->getDataLayout());
 #endif
+    m->setTargetTriple(jl_TargetMachine->getTargetTriple().str());
+
 }
 
 // this ensures that llvmf has been emitted to the execution engine,
 // returning the function pointer to it
 extern void jl_callback_triggered_linfos(void);
-static uint64_t getAddressForFunction(llvm::Function *llvmf)
+static uint64_t getAddressForFunction(StringRef fname)
 {
     JL_TIMING(LLVM_EMIT);
 #ifdef JL_DEBUG_BUILD
-    llvm::raw_fd_ostream out(1,false);
+    llvm::raw_fd_ostream out(1, false);
 #endif
-#ifdef USE_MCJIT
-    jl_finalize_function(llvmf);
-    uint64_t ret = jl_ExecutionEngine->getFunctionAddress(llvmf->getName());
+    jl_finalize_function(fname);
+    uint64_t ret = jl_ExecutionEngine->getFunctionAddress(fname);
     // delay executing trace callbacks until here to make sure there's no
     // recursive compilation.
     jl_callback_triggered_linfos();
     return ret;
-#else
-    return (uint64_t)jl_ExecutionEngine->getPointerToFunction(
-            cast<Function>(shadow_output->getNamedValue(llvmf->getName())));
-#endif
 }
 
+// convenience helper exported for usage from gdb
 extern "C" JL_DLLEXPORT
-uint64_t jl_get_llvm_fptr(llvm::Function *llvmf)
+uint64_t jl_get_llvm_fptr(void *function)
 {
-    uint64_t addr = getAddressForFunction(llvmf);
-#ifdef USE_ORCJIT
+    Function *F = (Function*)function;
+    uint64_t addr = getAddressForFunction(F->getName());
     if (!addr)
-        addr = jl_ExecutionEngine->findUnmangledSymbol(llvmf->getName()).getAddress();
-#endif
+        addr = jl_ExecutionEngine->findUnmangledSymbol(F->getName()).getAddress();
     return addr;
 }
 
 static jl_method_instance_t *jl_get_unspecialized(jl_method_instance_t *method)
 {
     // one unspecialized version of a function can be shared among all cached specializations
-    jl_method_t *def = method->def;
-    if (def->isstaged) {
+    jl_method_t *def = method->def.method;
+    if (def->source == NULL) {
         return method;
     }
     if (def->unspecialized == NULL) {
@@ -1097,9 +1313,8 @@ static jl_method_instance_t *jl_get_unspecialized(jl_method_instance_t *method)
 
 // this compiles li and emits fptr
 extern "C"
-jl_generic_fptr_t jl_generate_fptr(jl_method_instance_t *li, void *_F, size_t world)
+jl_generic_fptr_t jl_generate_fptr(jl_method_instance_t *li, const char *F, size_t world)
 {
-    Function *F = (Function*)_F;
     jl_generic_fptr_t fptr;
     fptr.fptr = li->fptr;
     fptr.jlcall_api = li->jlcall_api;
@@ -1119,9 +1334,9 @@ jl_generic_fptr_t jl_generate_fptr(jl_method_instance_t *li, void *_F, size_t wo
         return fptr;
     }
     jl_method_instance_t *unspec = NULL;
-    if (li->def) {
-        if (!li->def->isstaged && li->def->unspecialized) {
-            unspec = li->def->unspecialized;
+    if (jl_is_method(li->def.method)) {
+        if (li->def.method->unspecialized) {
+            unspec = li->def.method->unspecialized;
         }
         if (!F || !jl_can_finalize_function(F)) {
             // can't compile F in the JIT right now,
@@ -1129,7 +1344,11 @@ jl_generic_fptr_t jl_generate_fptr(jl_method_instance_t *li, void *_F, size_t wo
             // and return its fptr instead
             if (!unspec)
                 unspec = jl_get_unspecialized(li); // get-or-create the unspecialized version to cache the result
-            jl_code_info_t *src = unspec->def->isstaged ? jl_code_for_staged(unspec) : unspec->def->source;
+            jl_code_info_t *src = (jl_code_info_t*)unspec->def.method->source;
+            if (src == NULL) {
+                assert(unspec->def.method->generator);
+                src = jl_code_for_staged(unspec);
+            }
             fptr.fptr = unspec->fptr;
             fptr.jlcall_api = unspec->jlcall_api;
             if (fptr.fptr && fptr.jlcall_api) {
@@ -1143,7 +1362,7 @@ jl_generic_fptr_t jl_generate_fptr(jl_method_instance_t *li, void *_F, size_t wo
                 unspec->functionObjectsDecls.specFunctionObject = NULL;
             }
             assert(src);
-            F = (Function*)jl_compile_linfo(&unspec, src, unspec->min_world, &jl_default_cgparams).functionObject; // this does not change unspec
+            F = jl_compile_linfo(&unspec, src, unspec->min_world, &jl_default_cgparams).functionObject; // this does not change unspec
             if (unspec == li) {
                 unspec->functionObjectsDecls = decls;
             }
@@ -1196,9 +1415,12 @@ void *jl_function_ptr(jl_function_t *f, jl_value_t *rt, jl_value_t *argt)
         // TODO: maybe deprecation warning, better checking
         argt = (jl_value_t*)jl_apply_tuple_type_v((jl_value_t**)jl_data_ptr(argt), jl_nfields(argt));
     }
+    JL_LOCK(&codegen_lock);
     Function *llvmf = jl_cfunction_object(f, rt, (jl_tupletype_t*)argt);
     JL_GC_POP();
-    return (void*)getAddressForFunction(llvmf);
+    void *ptr = (void*)getAddressForFunction(llvmf->getName());
+    JL_UNLOCK(&codegen_lock);
+    return ptr;
 }
 
 
@@ -1209,7 +1431,7 @@ void *jl_function_ptr_by_llvm_name(char *name) {
 #ifdef JL_MSAN_ENABLED
     __msan_unpoison_string(name);
 #endif
-    return (void*)(intptr_t)jl_ExecutionEngine->FindFunctionNamed(name);
+    return (void*)jl_ExecutionEngine->FindFunctionNamed(name); // returns an llvm::Function*
 }
 
 // export a C-callable entry point for a function (dllexport'ed dlsym), with a given name
@@ -1217,35 +1439,22 @@ 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));
+    JL_LOCK(&codegen_lock);
     Function *llvmf = jl_cfunction_object(f, rt, (jl_tupletype_t*)argt);
     // force eager emission of the function (llvm 3.3 gets confused otherwise and tries to do recursive compilation)
-    uint64_t Addr = getAddressForFunction(llvmf);
+    uint64_t Addr = getAddressForFunction(llvmf->getName());
 
-#if defined(USE_ORCJIT) || defined(USE_MCJIT)
     if (imaging_mode)
-         // in the old JIT, the shadow_module aliases the engine_module,
-         // otherwise, just point the alias to the declaration
-#endif
         llvmf = cast<Function>(shadow_output->getNamedValue(llvmf->getName()));
 
     // make the alias to the shadow_module
     GlobalAlias *GA =
-#if JL_LLVM_VERSION >= 30800
         GlobalAlias::create(llvmf->getType()->getElementType(), llvmf->getType()->getAddressSpace(),
                             GlobalValue::ExternalLinkage, name, llvmf, shadow_output);
-#elif JL_LLVM_VERSION >= 30700
-        GlobalAlias::create(cast<PointerType>(llvmf->getType()),
-                            GlobalValue::ExternalLinkage, name, llvmf, shadow_output);
-#else
-        new GlobalAlias(llvmf->getType(), GlobalValue::ExternalLinkage, name, llvmf, shadow_output);
-#endif
 
-#if defined(USE_ORCJIT) || defined(USE_MCJIT)
     // make sure the alias name is valid for the current session
     jl_ExecutionEngine->addGlobalMapping(GA, (void*)(uintptr_t)Addr);
-#else
-    (void)GA; (void)Addr;
-#endif
+    JL_UNLOCK(&codegen_lock);
 }
 
 // --- native code info, and dump function to IR and ASM ---
@@ -1256,24 +1465,31 @@ void jl_extern_c(jl_function_t *f, jl_value_t *rt, jl_value_t *argt, char *name)
 extern "C" JL_DLLEXPORT
 void *jl_get_llvmf_defn(jl_method_instance_t *linfo, size_t world, bool getwrapper, bool optimize, const jl_cgparams_t params)
 {
-    if (linfo->def && linfo->def->source == NULL) {
+    if (jl_is_method(linfo->def.method) && linfo->def.method->source == NULL &&
+        linfo->def.method->generator == NULL) {
         // not a generic function
         return NULL;
     }
 
     jl_code_info_t *src = (jl_code_info_t*)linfo->inferred;
     JL_GC_PUSH1(&src);
-    if (!src || !jl_is_code_info(src)) {
+    if (!src || (jl_value_t*)src == jl_nothing) {
         src = jl_type_infer(&linfo, world, 0);
-        if (!src)
-            src = linfo->def->isstaged ? jl_code_for_staged(linfo) : linfo->def->source;
-    }
+        if (!src && jl_is_method(linfo->def.method))
+            src = linfo->def.method->generator ? jl_code_for_staged(linfo) : (jl_code_info_t*)linfo->def.method->source;
+    }
+    if ((jl_value_t*)src == jl_nothing)
+        src = NULL;
+    if (src && !jl_is_code_info(src) && jl_is_method(linfo->def.method))
+        src = jl_uncompress_ast(linfo->def.method, (jl_array_t*)src);
+    if (src && !jl_is_code_info(src))
+        src = NULL;
+    if (!src)
+        jl_error("source not found for function");
 
     // Backup the info for the nested compile
     JL_LOCK(&codegen_lock);
 
-    IRBuilderBase::InsertPoint old = builder.saveAndClearIP();
-    DebugLoc olddl = builder.getCurrentDebugLocation();
     bool last_n_c = nested_compile;
     nested_compile = true;
     // emit this function into a new module
@@ -1285,40 +1501,37 @@ void *jl_get_llvmf_defn(jl_method_instance_t *linfo, size_t world, bool getwrapp
     JL_CATCH {
         // something failed!
         nested_compile = last_n_c;
-        builder.restoreIP(old);
-        builder.SetCurrentDebugLocation(olddl);
         JL_UNLOCK(&codegen_lock); // Might GC
-        jl_rethrow_with_add("error compiling %s", jl_symbol_name(linfo->def ? linfo->def->name : anonymous_sym));
+        const char *mname = jl_symbol_name(jl_is_method(linfo->def.method) ? linfo->def.method->name : anonymous_sym);
+        jl_rethrow_with_add("error compiling %s", mname);
     }
     // Restore the previous compile context
-    builder.restoreIP(old);
-    builder.SetCurrentDebugLocation(olddl);
     nested_compile = last_n_c;
 
     if (optimize)
         jl_globalPM->run(*m.get());
-    Function *f = (llvm::Function*)declarations.functionObject;
-    Function *specf = (llvm::Function*)declarations.specFunctionObject;
+    const char *fname = declarations.functionObject;
+    const char *specfname = declarations.specFunctionObject;
+    Function *f = NULL;
+    Function *specf = NULL;
     // swap declarations for definitions and destroy declarations
-    if (specf) {
-        Function *tempf = cast<Function>(m->getNamedValue(specf->getName()));
-        delete specf;
-        specf = tempf;
+    if (specfname) {
+        specf = cast<Function>(m->getNamedValue(specfname));
+        free(const_cast<char*>(specfname));
     }
-    if (f) {
-        Function *tempf = cast<Function>(m->getNamedValue(f->getName()));
-        delete f;
-        f = tempf;
+    if (fname) {
+        f = cast<Function>(m->getNamedValue(fname));
+        free(const_cast<char*>(fname));
     }
     // clone the name from the runtime linfo, if it exists
     // to give the user a (false) sense of stability
-    Function *specf_decl = (Function*)linfo->functionObjectsDecls.specFunctionObject;
-    if (specf_decl) {
-        specf->setName(specf_decl->getName());
+    specfname = linfo->functionObjectsDecls.specFunctionObject;
+    if (specfname) {
+        specf->setName(specfname);
     }
-    Function *f_decl = (Function*)linfo->functionObjectsDecls.functionObject;
-    if (f_decl) {
-        f->setName(f_decl->getName());
+    fname = linfo->functionObjectsDecls.functionObject;
+    if (fname) {
+        f->setName(fname);
     }
     m.release(); // the return object `llvmf` will be the owning pointer
     JL_UNLOCK(&codegen_lock); // Might GC
@@ -1333,7 +1546,8 @@ void *jl_get_llvmf_defn(jl_method_instance_t *linfo, size_t world, bool getwrapp
 extern "C" JL_DLLEXPORT
 void *jl_get_llvmf_decl(jl_method_instance_t *linfo, size_t world, bool getwrapper, const jl_cgparams_t params)
 {
-    if (linfo->def && linfo->def->source == NULL) {
+    if (jl_is_method(linfo->def.method) && linfo->def.method->source == NULL &&
+        linfo->def.method->generator == NULL) {
         // not a generic function
         return NULL;
     }
@@ -1341,7 +1555,7 @@ void *jl_get_llvmf_decl(jl_method_instance_t *linfo, size_t world, bool getwrapp
     // compile this normally
     jl_llvm_functions_t decls = jl_compile_for_dispatch(&linfo, world);
 
-    if (decls.functionObject == NULL && linfo->jlcall_api == 2 && linfo->def) {
+    if (decls.functionObject == NULL && linfo->jlcall_api == 2 && jl_is_method(linfo->def.method)) {
         // normally we don't generate native code for these functions, so need an exception here
         // This leaks a bit of memory to cache native code that we'll never actually need
         JL_LOCK(&codegen_lock);
@@ -1350,7 +1564,7 @@ void *jl_get_llvmf_decl(jl_method_instance_t *linfo, size_t world, bool getwrapp
             jl_code_info_t *src = NULL;
             src = jl_type_infer(&linfo, world, 0);
             if (!src) {
-                src = linfo->def->isstaged ? jl_code_for_staged(linfo) : linfo->def->source;
+                src = linfo->def.method->generator ? jl_code_for_staged(linfo) : (jl_code_info_t*)linfo->def.method->source;
             }
             decls = jl_compile_linfo(&linfo, src, world, &params);
             linfo->functionObjectsDecls = decls;
@@ -1358,221 +1572,29 @@ void *jl_get_llvmf_decl(jl_method_instance_t *linfo, size_t world, bool getwrapp
         JL_UNLOCK(&codegen_lock);
     }
 
-    if (getwrapper || !decls.specFunctionObject)
-        return decls.functionObject;
-    else
-        return decls.specFunctionObject;
-}
-
-
-// print an llvm IR acquired from jl_get_llvmf
-// warning: this takes ownership of, and destroys, f->getParent()
-extern "C" JL_DLLEXPORT
-const jl_value_t *jl_dump_function_ir(void *f, bool strip_ir_metadata, bool dump_module)
-{
-    std::string code;
-    llvm::raw_string_ostream stream(code);
-
-    Function *llvmf = dyn_cast<Function>((Function*)f);
-    if (!llvmf || (!llvmf->isDeclaration() && !llvmf->getParent()))
-        jl_error("jl_dump_function_ir: Expected Function* in a temporary Module");
-
-    JL_LOCK(&codegen_lock); // Might GC
-    if (!llvmf->getParent()) {
-        // print the function declaration as-is
-        llvmf->print(stream);
+    if (getwrapper || !decls.specFunctionObject) {
+        return Function::Create(jl_func_sig, GlobalVariable::ExternalLinkage, decls.functionObject);
     }
     else {
-        Module *m = llvmf->getParent();
-        if (strip_ir_metadata) {
-            // strip metadata from all instructions in the module
-            for (Module::iterator I = m->begin(), E = m->end(); I != E; ++I) {
-                Function *f2 = &*I;
-                Function::BasicBlockListType::iterator f2_bb = f2->getBasicBlockList().begin();
-                // iterate over all basic blocks in the function
-                for (; f2_bb != f2->getBasicBlockList().end(); ++f2_bb) {
-                    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++;
-                        // remove dbg.declare and dbg.value calls
-                        if (isa<DbgDeclareInst>(inst) || isa<DbgValueInst>(inst)) {
-                            inst->eraseFromParent();
-                            continue;
-                        }
-
-                        SmallVector<std::pair<unsigned, MDNode*>, 4> MDForInst;
-                        inst->getAllMetadata(MDForInst);
-                        SmallVector<std::pair<unsigned, MDNode*>, 4>::iterator md_iter = MDForInst.begin();
-
-                        // iterate over all metadata kinds and set to NULL to remove
-                        for (; md_iter != MDForInst.end(); ++md_iter) {
-                            inst->setMetadata((*md_iter).first, NULL);
-                        }
-                    }
-                }
-            }
-        }
-        if (dump_module) {
-            m->print(stream, NULL);
-        }
-        else {
-            llvmf->print(stream);
-        }
-        delete m;
+        jl_returninfo_t returninfo = get_specsig_function(NULL, decls.specFunctionObject, linfo->specTypes, linfo->rettype);
+        return returninfo.decl;
     }
-    JL_UNLOCK(&codegen_lock); // Might GC
-
-    return jl_cstr_to_string(const_cast<char*>(stream.str().c_str()));
-}
-
-// This isn't particularly fast, but it's only used for interactive mode
-static uint64_t compute_obj_symsize(const object::ObjectFile *obj, uint64_t offset)
-{
-    // Scan the object file for the closest symbols above and below offset in the .text section
-    uint64_t lo = 0;
-    uint64_t hi = 0;
-    bool setlo = false;
-#if JL_LLVM_VERSION >= 30700
-    for (const object::SectionRef &Section : obj->sections()) {
-#else
-    llvm::error_code err;
-    for (object::section_iterator I = obj->begin_sections(), E = obj->end_sections();
-            !err && I != E; I.increment(err)) {
-        object::SectionRef Section = *I;
-#endif
-        uint64_t SAddr, SSize;
-#if JL_LLVM_VERSION >= 30500
-        if (!Section.isText()) continue;
-#else
-        bool isText;
-        if (Section.isText(isText) || !isText) continue;
-#endif
-#if JL_LLVM_VERSION >= 30600
-        SAddr = Section.getAddress();
-        SSize = Section.getSize();
-#else
-        Section.getAddress(SAddr);
-        Section.getSize(SSize);
-#endif
-        if (offset < SAddr || offset >= SAddr + SSize) continue;
-        assert(hi == 0);
-
-        // test for lower and upper symbol bounds relative to other symbols
-        hi = SAddr + SSize;
-#if JL_LLVM_VERSION >= 30700
-        object::section_iterator ESection = obj->section_end();
-        for (const object::SymbolRef &Sym : obj->symbols()) {
-#else
-        llvm::error_code err;
-        object::section_iterator ESection = obj->end_sections();
-        for (object::symbol_iterator I = obj->begin_symbols(), E = obj->end_symbols();
-                !err && I != E; I.increment(err)) {
-            object::SymbolRef Sym = *I;
-#endif
-            uint64_t Addr;
-            object::section_iterator Sect = ESection;
-#if JL_LLVM_VERSION >= 30800
-            auto SectOrError = Sym.getSection();
-            assert(SectOrError);
-            Sect = SectOrError.get();
-#else
-            if (Sym.getSection(Sect)) continue;
-#endif
-            if (Sect == ESection) continue;
-            if (Sect != Section) continue;
-#if JL_LLVM_VERSION >= 30700
-            auto AddrOrError = Sym.getAddress();
-            assert(AddrOrError);
-            Addr = AddrOrError.get();
-#else
-            if (Sym.getAddress(Addr)) continue;
-#endif
-            if (Addr <= offset && Addr >= lo) {
-                // test for lower bound on symbol
-                lo = Addr;
-                setlo = true;
-            }
-            if (Addr > offset && Addr < hi) {
-                // test for upper bound on symbol
-                hi = Addr;
-            }
-        }
-    }
-    if (setlo)
-        return hi - lo;
-    return 0;
 }
 
-// print a native disassembly for f (an LLVM function)
+// get a native disassembly for f (an LLVM function)
+// warning: this takes ownership of, and destroys, f
 extern "C" JL_DLLEXPORT
-const jl_value_t *jl_dump_function_asm(void *f, int raw_mc, const char* asm_variant="att")
+const jl_value_t *jl_dump_function_asm(void *f, int raw_mc, const char* asm_variant)
 {
-    jl_ptls_t ptls = jl_get_ptls_states();
-    std::string code;
-    llvm::raw_string_ostream stream(code);
-#if JL_LLVM_VERSION < 30700
-    llvm::formatted_raw_ostream fstream(stream);
-#endif
-
-    Function *llvmf = dyn_cast<Function>((Function*)f);
+    Function *llvmf = dyn_cast_or_null<Function>((Function*)f);
     if (!llvmf)
         jl_error("jl_dump_function_asm: Expected Function*");
-
-    // Dump assembly code
-    uint64_t symsize = 0;
-    int64_t slide = 0, section_slide = 0;
-    uint64_t fptr = getAddressForFunction(llvmf);
-#ifdef USE_MCJIT
+    uint64_t fptr = getAddressForFunction(llvmf->getName());
     // Look in the system image as well
     if (fptr == 0)
         fptr = (uintptr_t)jl_ExecutionEngine->getPointerToGlobalIfAvailable(llvmf);
-    llvm::DIContext *context = NULL;
-    llvm::DIContext *&objcontext = context;
-#else
-    std::vector<JITEvent_EmittedFunctionDetails::LineStart> context;
-    llvm::DIContext *objcontext = NULL;
-#endif
-    const object::ObjectFile *object = NULL;
-    assert(fptr != 0);
-    if (!jl_DI_for_fptr(fptr, &symsize, &slide, &section_slide, &object, &context)) {
-        if (!jl_dylib_DI_for_fptr(fptr, &object, &objcontext, &slide, &section_slide, false,
-            NULL, NULL, NULL, NULL)) {
-                jl_printf(JL_STDERR, "WARNING: Unable to find function pointer\n");
-                return jl_cstr_to_string("");
-        }
-    }
-    if (symsize == 0 && object != NULL)
-        symsize = compute_obj_symsize(object, fptr + slide + section_slide);
-    if (symsize == 0) {
-        jl_printf(JL_STDERR, "WARNING: Could not determine size of symbol\n");
-        return jl_cstr_to_string("");
-    }
-
-    if (raw_mc) {
-        return (jl_value_t*)jl_pchar_to_array((char*)fptr, symsize);
-    }
-
-    int8_t gc_state = jl_gc_safe_enter(ptls);
-    jl_dump_asm_internal(fptr, symsize, slide,
-#ifndef USE_MCJIT
-            context,
-#endif
-            object, objcontext,
-#if JL_LLVM_VERSION >= 30700
-            stream,
-#else
-            fstream,
-#endif
-            asm_variant
-            );
-
-#if JL_LLVM_VERSION < 30700
-    fstream.flush();
-#endif
-    jl_gc_safe_leave(ptls, gc_state);
-
-    return jl_cstr_to_string(const_cast<char*>(stream.str().c_str()));
+    delete llvmf;
+    return jl_dump_fptr_asm(fptr, raw_mc, asm_variant);
 }
 
 // Logging for code coverage and memory allocation
@@ -1581,7 +1603,7 @@ const int logdata_blocksize = 32; // target getting nearby lines in the same gen
 typedef uint64_t logdata_block[logdata_blocksize];
 typedef StringMap< std::vector<logdata_block*> > logdata_t;
 
-static void visitLine(std::vector<logdata_block*> &vec, int line, Value *addend, const char* name)
+static void visitLine(jl_codectx_t &ctx, std::vector<logdata_block*> &vec, int line, Value *addend, const char* name)
 {
     unsigned block = line / logdata_blocksize;
     line = line % logdata_blocksize;
@@ -1596,7 +1618,7 @@ static void visitLine(std::vector<logdata_block*> &vec, int line, Value *addend,
     Value *v = ConstantExpr::getIntToPtr(
         ConstantInt::get(T_size, (uintptr_t)&data[line]),
         T_pint64);
-    builder.CreateStore(builder.CreateAdd(builder.CreateLoad(v, true, name),
+    ctx.builder.CreateStore(ctx.builder.CreateAdd(ctx.builder.CreateLoad(v, true, name),
                                           addend),
                         v, true); // not atomic, so this might be an underestimate,
                                   // but it's faster this way
@@ -1606,32 +1628,27 @@ static void visitLine(std::vector<logdata_block*> &vec, int line, Value *addend,
 
 static logdata_t coverageData;
 
-static void coverageVisitLine(StringRef filename, int line)
+static void coverageVisitLine(jl_codectx_t &ctx, StringRef filename, int line)
 {
     assert(!imaging_mode);
     if (filename == "" || filename == "none" || filename == "no file" || filename == "<missing>" || line < 0)
         return;
-    visitLine(coverageData[filename], line, ConstantInt::get(T_int64, 1), "lcnt");
+    visitLine(ctx, coverageData[filename], line, ConstantInt::get(T_int64, 1), "lcnt");
 }
 
 // Memory allocation log (malloc_log)
 
 static logdata_t mallocData;
 
-static void mallocVisitLine(StringRef filename, int line)
+static void mallocVisitLine(jl_codectx_t &ctx, StringRef filename, int line)
 {
     assert(!imaging_mode);
     if (filename == "" || filename == "none" || filename == "no file" || filename == "<missing>" || line < 0) {
         jl_gc_sync_total_bytes();
         return;
     }
-    visitLine( mallocData[filename], line,
-               builder.CreateCall(prepare_call(diff_gc_total_bytes_func)
-#if JL_LLVM_VERSION >= 30700
-                                  , {}
-#endif
-                                  ),
-                        "bytecnt");
+    Value *addend = ctx.builder.CreateCall(prepare_call(diff_gc_total_bytes_func), {});
+    visitLine(ctx, mallocData[filename], line, addend, "bytecnt");
 }
 
 // Resets the malloc counts. Needed to avoid including memory usage
@@ -1722,32 +1739,47 @@ extern "C" void jl_write_malloc_log(void)
 
 // --- constant determination ---
 
-static void show_source_loc(JL_STREAM *out, jl_codectx_t *ctx)
+static void show_source_loc(jl_codectx_t &ctx, JL_STREAM *out)
 {
-    if (ctx == NULL) return;
-    jl_printf(out, "in %s at %s", ctx->name, ctx->file.str().c_str());
+    jl_printf(out, "in %s at %s", ctx.name, ctx.file.str().c_str());
 }
 
 extern "C" void jl_binding_deprecation_warning(jl_binding_t *b);
 
-static void cg_bdw(jl_binding_t *b, jl_codectx_t *ctx)
+static void cg_bdw(jl_codectx_t &ctx, jl_binding_t *b)
 {
     jl_binding_deprecation_warning(b);
-    if (jl_options.depwarn) {
-        show_source_loc(JL_STDERR, ctx);
+    if (b->deprecated == 1 && jl_options.depwarn) {
+        show_source_loc(ctx, JL_STDERR);
         jl_printf(JL_STDERR, "\n");
     }
 }
 
+static jl_value_t *static_apply_type(jl_codectx_t &ctx, const jl_cgval_t *args, size_t nargs)
+{
+    jl_value_t **v = (jl_value_t**)alloca(sizeof(jl_value_t*) * nargs);
+    for (size_t i = 0; i < nargs; i++) {
+        if (!args[i].constant)
+            return NULL;
+        v[i] = args[i].constant;
+    }
+    assert(v[0] == jl_builtin_apply_type);
+    size_t last_age = jl_get_ptls_states()->world_age;
+    // call apply_type, but ignore errors. we know that will work in world 1.
+    jl_get_ptls_states()->world_age = 1;
+    jl_value_t *result = jl_apply_with_saved_exception_state(v, nargs, 1);
+    jl_get_ptls_states()->world_age = last_age;
+    return result;
+}
 
 // try to statically evaluate, NULL if not possible
-static jl_value_t *static_eval(jl_value_t *ex, jl_codectx_t *ctx, int sparams=true, int allow_alloc=true)
+static jl_value_t *static_eval(jl_codectx_t &ctx, jl_value_t *ex, int sparams=true, int allow_alloc=true)
 {
     if (!JL_FEAT_TEST(ctx, static_alloc)) allow_alloc = 0;
     if (jl_is_symbol(ex)) {
         jl_sym_t *sym = (jl_sym_t*)ex;
-        if (jl_is_const(ctx->module, sym))
-            return jl_get_global(ctx->module, sym);
+        if (jl_is_const(ctx.module, sym))
+            return jl_get_global(ctx.module, sym);
         return NULL;
     }
     if (jl_is_slot(ex))
@@ -1755,8 +1787,8 @@ static jl_value_t *static_eval(jl_value_t *ex, jl_codectx_t *ctx, int sparams=tr
     if (jl_is_ssavalue(ex)) {
         ssize_t idx = ((jl_ssavalue_t*)ex)->id;
         assert(idx >= 0);
-        if (ctx->ssavalue_assigned.at(idx)) {
-            return ctx->SAvalues.at(idx).constant;
+        if (ctx.ssavalue_assigned.at(idx)) {
+            return ctx.SAvalues.at(idx).constant;
         }
         return NULL;
     }
@@ -1770,7 +1802,8 @@ static jl_value_t *static_eval(jl_value_t *ex, jl_codectx_t *ctx, int sparams=tr
         s = jl_globalref_name(ex);
         jl_binding_t *b = jl_get_binding(jl_globalref_mod(ex), s);
         if (b && b->constp) {
-            if (b->deprecated) cg_bdw(b, ctx);
+            if (b->deprecated)
+                cg_bdw(ctx, b);
             return b->value;
         }
         return NULL;
@@ -1778,20 +1811,21 @@ static jl_value_t *static_eval(jl_value_t *ex, jl_codectx_t *ctx, int sparams=tr
     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, sparams, allow_alloc);
+            jl_value_t *f = static_eval(ctx, jl_exprarg(e, 0), sparams, allow_alloc);
             if (f) {
                 if (jl_array_dim0(e->args) == 3 && f==jl_builtin_getfield) {
-                    m = (jl_module_t*)static_eval(jl_exprarg(e, 1), ctx, sparams, allow_alloc);
+                    m = (jl_module_t*)static_eval(ctx, jl_exprarg(e, 1), sparams, allow_alloc);
                     // Check the tag before evaluating `s` so that a value of random
                     // type won't be corrupted.
                     if (!m || !jl_is_module(m))
                         return NULL;
                     // Assumes that the module is rooted somewhere.
-                    s = (jl_sym_t*)static_eval(jl_exprarg(e, 2), ctx, sparams, allow_alloc);
+                    s = (jl_sym_t*)static_eval(ctx, jl_exprarg(e, 2), sparams, allow_alloc);
                     if (s && jl_is_symbol(s)) {
                         jl_binding_t *b = jl_get_binding(m, s);
                         if (b && b->constp) {
-                            if (b->deprecated) cg_bdw(b, ctx);
+                            if (b->deprecated)
+                                cg_bdw(ctx, b);
                             return b->value;
                         }
                     }
@@ -1803,24 +1837,20 @@ static jl_value_t *static_eval(jl_value_t *ex, jl_codectx_t *ctx, int sparams=tr
                     if (!allow_alloc)
                         return NULL;
                     jl_value_t **v;
-                    JL_GC_PUSHARGS(v, n);
+                    JL_GC_PUSHARGS(v, n+1);
+                    v[0] = f;
                     for (i = 0; i < n; i++) {
-                        v[i] = static_eval(jl_exprarg(e, i+1), ctx, sparams, allow_alloc);
-                        if (v[i] == NULL) {
+                        v[i+1] = static_eval(ctx, jl_exprarg(e, i+1), sparams, allow_alloc);
+                        if (v[i+1] == NULL) {
                             JL_GC_POP();
                             return NULL;
                         }
                     }
-                    jl_value_t *result;
-                    JL_TRY {
-                        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;
-                    }
+                    size_t last_age = jl_get_ptls_states()->world_age;
+                    // here we know we're calling specific builtin functions that work in world 1.
+                    jl_get_ptls_states()->world_age = 1;
+                    jl_value_t *result = jl_apply_with_saved_exception_state(v, n+1, 1);
+                    jl_get_ptls_states()->world_age = last_age;
                     JL_GC_POP();
                     return result;
                 }
@@ -1828,8 +1858,8 @@ static jl_value_t *static_eval(jl_value_t *ex, jl_codectx_t *ctx, int sparams=tr
         }
         else if (e->head == static_parameter_sym) {
             size_t idx = jl_unbox_long(jl_exprarg(e, 0));
-            if (idx <= jl_svec_len(ctx->linfo->sparam_vals)) {
-                jl_value_t *e = jl_svecref(ctx->linfo->sparam_vals, idx - 1);
+            if (idx <= jl_svec_len(ctx.linfo->sparam_vals)) {
+                jl_value_t *e = jl_svecref(ctx.linfo->sparam_vals, idx - 1);
                 if (jl_is_typevar(e))
                     return NULL;
                 return e;
@@ -1840,11 +1870,6 @@ static jl_value_t *static_eval(jl_value_t *ex, jl_codectx_t *ctx, int sparams=tr
     return ex;
 }
 
-static bool is_constant(jl_value_t *ex, jl_codectx_t *ctx, bool sparams=true)
-{
-    return static_eval(ex, ctx, sparams) != NULL;
-}
-
 static bool slot_eq(jl_value_t *e, int sl)
 {
     return jl_is_slot(e) && jl_slot_number(e)-1 == sl;
@@ -1925,79 +1950,36 @@ static void mark_volatile_vars(jl_array_t *stmts, std::vector<jl_varinfo_t> &slo
     }
 }
 
-// --- escape analysis ---
-
-static bool expr_is_symbol(jl_value_t *e)
-{
-    return (jl_is_symbol(e) || jl_is_globalref(e));
-}
+// --- use analysis ---
 
-// a very simple, conservative escape analysis that is sufficient for
-// eliding allocation of varargs tuples.
-// "esc" means "in escaping context"
-static void simple_escape_analysis(jl_value_t *expr, bool esc, jl_codectx_t *ctx)
+// a very simple, conservative use analysis
+// to eagerly remove slot assignments that are never read from
+static void simple_use_analysis(jl_codectx_t &ctx, jl_value_t *expr)
 {
-    if (jl_is_expr(expr)) {
-        esc = true;
+    if (jl_is_slot(expr)) {
+        int i = jl_slot_number(expr) - 1;
+        ctx.slots[i].used = true;
+    }
+    else if (jl_is_expr(expr)) {
         jl_expr_t *e = (jl_expr_t*)expr;
         size_t i;
-        if (e->head == call_sym || e->head == new_sym) {
-            int alen = jl_array_dim0(e->args);
-            jl_value_t *f = jl_exprarg(e,0);
-            simple_escape_analysis(f, esc, ctx);
-            if (expr_is_symbol(f)) {
-                if (jl_value_t *fv = static_eval(f, ctx, false)) {
-                    if (jl_typeis(fv, jl_intrinsic_type)) {
-                        esc = false;
-                    }
-                    else {
-                        if ((fv==jl_builtin_getfield && alen==3 &&
-                             expr_type(jl_exprarg(e,2),ctx) == (jl_value_t*)jl_long_type) ||
-                            fv==jl_builtin_nfields ||
-                            (fv==jl_builtin__apply && alen==3)) {
-                            esc = false;
-                        }
-                    }
-                }
-            }
-
-            for (i = 1; i < (size_t)alen; i++) {
-                simple_escape_analysis(jl_exprarg(e,i), esc, ctx);
-            }
-        }
-        else if (e->head == foreigncall_sym) {
-            esc = true;
-            simple_escape_analysis(jl_exprarg(e, 0), esc, ctx);
-            // 2nd and 3d arguments are static
-            size_t alen = jl_array_dim0(e->args);
-            for (i = 3; i < alen; i += 2) {
-                simple_escape_analysis(jl_exprarg(e, i), esc, ctx);
-            }
-        }
-        else if (e->head == method_sym) {
-            simple_escape_analysis(jl_exprarg(e,0), esc, ctx);
+        if (e->head == method_sym) {
+            simple_use_analysis(ctx, jl_exprarg(e, 0));
             if (jl_expr_nargs(e) > 1) {
-                simple_escape_analysis(jl_exprarg(e,1), esc, ctx);
-                simple_escape_analysis(jl_exprarg(e,2), esc, ctx);
+                simple_use_analysis(ctx, jl_exprarg(e, 1));
+                simple_use_analysis(ctx, jl_exprarg(e, 2));
             }
         }
         else if (e->head == assign_sym) {
             // don't consider assignment LHS as a variable "use"
-            simple_escape_analysis(jl_exprarg(e,1), esc, ctx);
+            simple_use_analysis(ctx, jl_exprarg(e, 1));
         }
         else if (e->head != line_sym) {
             size_t elen = jl_array_dim0(e->args);
-            for(i=0; i < elen; i++) {
-                simple_escape_analysis(jl_exprarg(e,i), esc, ctx);
+            for (i = 0; i < elen; i++) {
+                simple_use_analysis(ctx, jl_exprarg(e, i));
             }
         }
-        return;
-    }
-    if (jl_is_slot(expr)) {
-        int i = jl_slot_number(expr)-1;
-        jl_varinfo_t &vi = ctx->slots[i];
-        vi.escapes |= esc;
-        vi.used = true;
     }
 }
 
@@ -2006,156 +1988,113 @@ 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 a gc-root slot indicator
-static Value *emit_local_root(jl_codectx_t *ctx, jl_varinfo_t *vi)
+static Value *emit_local_root(jl_codectx_t &ctx, jl_varinfo_t *vi)
 {
-    CallInst *newroot = CallInst::Create(prepare_call(gcroot_func), "", /*InsertBefore*/ctx->ptlsStates);
+    Instruction *newroot = new AllocaInst(T_prjlvalue, 0, "gcroot", /*InsertBefore*/ctx.ptlsStates);
     if (vi) {
         vi->boxroot->replaceAllUsesWith(newroot);
         newroot->takeName(vi->boxroot);
+        vi->boxroot->eraseFromParent();
         vi->boxroot = newroot;
     }
-    return newroot;
-}
-
-
-// Marks a use (and thus a potential kill) of a gcroot
-// Note that if the operation that needs the root has terminating control flow
-// (e.g. `unreachable`, `noreturn` functions) the use needs to be marked before
-// the operation as well as after it.
-static void mark_gc_use(const jl_cgval_t &v)
-{
-    if (v.gcroot)
-        builder.CreateCall(prepare_call(gckill_func), v.gcroot);
-}
 
-// 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)
-{
-    // 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;
+    return newroot;
 }
 
-static void jl_add_method_root(jl_codectx_t *ctx, jl_value_t *val)
+static void jl_add_method_root(jl_codectx_t &ctx, jl_value_t *val)
 {
     if (jl_is_concrete_type(val) || jl_is_bool(val) || jl_is_symbol(val) ||
             val == (jl_value_t*)jl_any_type || val == (jl_value_t*)jl_bottom_type)
         return;
     JL_GC_PUSH1(&val);
-    if (ctx->roots == NULL) {
-        ctx->roots = jl_alloc_vec_any(1);
-        jl_array_ptr_set(ctx->roots, 0, val);
+    if (ctx.roots == NULL) {
+        ctx.roots = jl_alloc_vec_any(1);
+        jl_array_ptr_set(ctx.roots, 0, val);
     }
     else {
-        size_t rlen = jl_array_dim0(ctx->roots);
+        size_t rlen = jl_array_dim0(ctx.roots);
         for (size_t i = 0; i < rlen; i++) {
-            if (jl_array_ptr_ref(ctx->roots,i) == val) {
+            if (jl_array_ptr_ref(ctx.roots,i) == val) {
                 JL_GC_POP();
                 return;
             }
         }
-        jl_array_ptr_1d_push(ctx->roots, val);
+        jl_array_ptr_1d_push(ctx.roots, val);
     }
     JL_GC_POP();
 }
 
 // --- generating function calls ---
 
-static jl_cgval_t emit_getfield(jl_value_t *expr, jl_sym_t *name, jl_codectx_t *ctx)
+static jl_cgval_t emit_globalref(jl_codectx_t &ctx, jl_module_t *mod, jl_sym_t *name)
 {
-    if (jl_is_quotenode(expr) && jl_is_module(jl_fieldref(expr,0)))
-        expr = jl_fieldref(expr,0);
-
-    jl_value_t *static_val = static_eval(expr, ctx, true, false);
-    if (static_val != NULL && jl_is_module(static_val))
-        expr = static_val;
-
-    if (jl_is_module(expr)) {
-        jl_binding_t *bnd = NULL;
-        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) {
-                return mark_julia_const(bnd->value);
-            }
-            return mark_julia_type(tbaa_decorate(tbaa_binding, builder.CreateLoad(bp)), true, (jl_value_t*)jl_any_type, ctx);
+    jl_binding_t *bnd = NULL;
+    Value *bp = global_binding_pointer(ctx, mod, name, &bnd, false);
+    // TODO: refactor. this partially duplicates code in emit_var
+    if (bnd && bnd->value != NULL) {
+        if (bnd->constp) {
+            return mark_julia_const(bnd->value);
         }
-        // todo: use type info to avoid undef check
-        return emit_checked_var(bp, name, ctx, false, tbaa_binding);
+        return mark_julia_type(ctx, tbaa_decorate(tbaa_binding, ctx.builder.CreateLoad(bp)), true, (jl_value_t*)jl_any_type);
     }
+    // todo: use type info to avoid undef check
+    return emit_checked_var(ctx, bp, name, false, tbaa_binding);
+}
+
+static jl_cgval_t emit_getfield(jl_codectx_t &ctx, const jl_cgval_t &strct, jl_sym_t *name)
+{
+    if (strct.constant && jl_is_module(strct.constant))
+        return emit_globalref(ctx, (jl_module_t*)strct.constant, name);
 
-    jl_datatype_t *sty = (jl_datatype_t*)expr_type(expr, ctx);
-    JL_GC_PUSH1(&sty);
+    jl_datatype_t *sty = (jl_datatype_t*)strct.typ;
     if (jl_is_type_type((jl_value_t*)sty) && jl_is_concrete_type(jl_tparam0(sty)))
         sty = (jl_datatype_t*)jl_typeof(jl_tparam0(sty));
-    if (jl_is_structtype(sty) && sty != jl_module_type && sty->uid != 0 &&
-        jl_is_concrete_type((jl_value_t*)sty)) {
+    sty = (jl_datatype_t*)jl_unwrap_unionall((jl_value_t*)sty);
+    if (jl_is_structtype(sty) && sty != jl_module_type && sty->layout) {
         unsigned idx = jl_field_index(sty, name, 0);
         if (idx != (unsigned)-1) {
-            jl_cgval_t strct = emit_expr(expr, ctx);
-            jl_cgval_t fld = emit_getfield_knownidx(strct, idx, sty, ctx);
-            JL_GC_POP();
-            return fld;
+            return emit_getfield_knownidx(ctx, strct, idx, sty);
         }
     }
-    JL_GC_POP(); // kill sty
     // TODO: attempt better codegen for approximate types, if the types
     // and offsets of some fields are independent of parameters.
 
     // TODO: generic getfield func with more efficient calling convention
-    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);
-#if JL_LLVM_VERSION >= 30700
-    Value *result = builder.CreateCall(prepare_call(jlgetfield_func), {V_null, myargs,
-                                        ConstantInt::get(T_int32,2)});
-#else
-    Value *result = builder.CreateCall3(prepare_call(jlgetfield_func), V_null, myargs,
-                                        ConstantInt::get(T_int32,2));
-#endif
+    jl_cgval_t myargs_array[2] = {
+        strct,
+        mark_julia_const((jl_value_t*)name)
+    };
+    Value *result = emit_jlcall(ctx, jlgetfield_func, maybe_decay_untracked(V_null), myargs_array, 2);
     bool needsgcroot = true; // !arg1.isimmutable || !jl_is_concrete_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;
+    return mark_julia_type(ctx, result, true, jl_any_type, needsgcroot);
 }
 
-static Value *emit_bits_compare(const jl_cgval_t &arg1, const jl_cgval_t &arg2, jl_codectx_t *ctx)
+static Value *emit_bits_compare(jl_codectx_t &ctx, const jl_cgval_t &arg1, const jl_cgval_t &arg2)
 {
     assert(jl_is_datatype(arg1.typ) && arg1.typ == arg2.typ);
     Type *at = julia_type_to_llvm(arg1.typ);
 
     if (at->isIntegerTy() || at->isPointerTy() || at->isFloatingPointTy()) {
         Type *at_int = INTT(at);
-        Value *varg1 = emit_unbox(at_int, arg1, arg1.typ);
-        Value *varg2 = emit_unbox(at_int, arg2, arg2.typ);
-        return builder.CreateICmpEQ(varg1, varg2);
+        Value *varg1 = emit_unbox(ctx, at_int, arg1, arg1.typ);
+        Value *varg2 = emit_unbox(ctx, at_int, arg2, arg2.typ);
+        return ctx.builder.CreateICmpEQ(varg1, varg2);
     }
 
     if (at->isVectorTy()) {
         jl_svec_t *types = ((jl_datatype_t*)arg1.typ)->types;
         Value *answer = ConstantInt::get(T_int1, 1);
-        Value *varg1 = emit_unbox(at, arg1, arg1.typ);
-        Value *varg2 = emit_unbox(at, arg2, arg2.typ);
-        size_t l = jl_svec_len(types);
-        for (unsigned i = 0; i < l; i++) {
+        Value *varg1 = emit_unbox(ctx, at, arg1, arg1.typ);
+        Value *varg2 = emit_unbox(ctx, at, arg2, arg2.typ);
+        for (size_t i = 0, l = jl_svec_len(types); i < l; i++) {
             jl_value_t *fldty = jl_svecref(types, i);
             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, false, fldty, ctx), mark_julia_type(fld2, false, fldty, ctx), ctx);
-            answer = builder.CreateAnd(answer, subAns);
+            fld1 = ctx.builder.CreateExtractElement(varg1, ConstantInt::get(T_int32, i)),
+            fld2 = ctx.builder.CreateExtractElement(varg2, ConstantInt::get(T_int32, i)),
+            subAns = emit_bits_compare(ctx,
+                    mark_julia_type(ctx, fld1, false, fldty),
+                    mark_julia_type(ctx, fld2, false, fldty));
+            answer = ctx.builder.CreateAnd(answer, subAns);
         }
         return answer;
     }
@@ -2164,40 +2103,31 @@ static Value *emit_bits_compare(const jl_cgval_t &arg1, const jl_cgval_t &arg2,
         assert(arg1.ispointer() && arg2.ispointer());
         size_t sz = jl_datatype_size(arg1.typ);
         if (sz > 512 && !((jl_datatype_t*)arg1.typ)->layout->haspadding) {
-#if JL_LLVM_VERSION >= 30700
-            Value *answer = builder.CreateCall(prepare_call(memcmp_func),
+            Value *answer = ctx.builder.CreateCall(prepare_call(memcmp_derived_func),
                             {
-                            data_pointer(arg1, ctx, T_pint8),
-                            data_pointer(arg2, ctx, T_pint8),
+                            data_pointer(ctx, arg1, T_pint8),
+                            data_pointer(ctx, arg2, T_pint8),
                             ConstantInt::get(T_size, sz)
                             });
-#else
-            Value *answer = builder.CreateCall3(prepare_call(memcmp_func),
-                    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));
+            return ctx.builder.CreateICmpEQ(answer, ConstantInt::get(T_int32, 0));
         }
         else {
             Type *atp = at->getPointerTo();
-            Value *varg1 = data_pointer(arg1, ctx, atp);
-            Value *varg2 = data_pointer(arg2, ctx, atp);
+            Value *varg1 = data_pointer(ctx, arg1, atp);
+            Value *varg2 = data_pointer(ctx, arg2, 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);
-            for(unsigned i=0; i < l; i++) {
+            for (size_t i = 0, l = jl_svec_len(types); i < l; i++) {
                 jl_value_t *fldty = jl_svecref(types, i);
                 Value *subAns, *fld1, *fld2;
-                fld1 = builder.CreateConstGEP2_32(LLVM37_param(at) varg1, 0, i);
-                fld2 = builder.CreateConstGEP2_32(LLVM37_param(at) varg2, 0, i);
+                fld1 = ctx.builder.CreateConstGEP2_32(at, varg1, 0, i);
+                fld2 = ctx.builder.CreateConstGEP2_32(at, varg2, 0, i);
                 if (type_is_ghost(fld1->getType()->getPointerElementType()))
                     continue;
-                subAns = emit_bits_compare(
-                        mark_julia_slot(fld1, fldty, arg1.tbaa),
-                        mark_julia_slot(fld2, fldty, arg2.tbaa),
-                        ctx);
-                answer = builder.CreateAnd(answer, subAns);
+                subAns = emit_bits_compare(ctx,
+                        mark_julia_slot(fld1, fldty, NULL, arg1.tbaa),
+                        mark_julia_slot(fld2, fldty, NULL, arg2.tbaa));
+                answer = ctx.builder.CreateAnd(answer, subAns);
             }
             return answer;
         }
@@ -2207,436 +2137,417 @@ static Value *emit_bits_compare(const jl_cgval_t &arg1, const jl_cgval_t &arg2,
 }
 
 // emit code for is (===).
-static Value *emit_f_is(const jl_cgval_t &arg1, const jl_cgval_t &arg2, jl_codectx_t *ctx)
+static Value *emit_f_is(jl_codectx_t &ctx, const jl_cgval_t &arg1, const jl_cgval_t &arg2)
 {
     jl_value_t *rt1 = arg1.typ, *rt2 = arg2.typ;
-    bool isconcrete = jl_is_concrete_type(rt1) && jl_is_concrete_type(rt2);
-    if (isconcrete && rt1 != rt2 && !jl_is_type_type(rt1) && !jl_is_type_type(rt2))
+    bool istypes = false;
+    if (jl_subtype(rt1, (jl_value_t*)jl_type_type) ||
+        jl_subtype(rt2, (jl_value_t*)jl_type_type)) {
+        // need to use typeseq for datatypes
+        istypes = true;
+    }
+    if (!istypes && jl_is_concrete_type(rt1) && jl_is_concrete_type(rt2) && rt1 != rt2)
         // disjoint concrete types are never equal (quick test)
         return ConstantInt::get(T_int1, 0);
-    bool ghost1 = arg1.isghost || (isconcrete && jl_is_datatype_singleton((jl_datatype_t*)rt1));
-    bool ghost2 = arg2.isghost || (isconcrete && jl_is_datatype_singleton((jl_datatype_t*)rt2));
-    if (ghost1 || ghost2) {
-        // comparing singleton objects
-        if (ghost1 && ghost2) {
-            return ConstantInt::get(T_int1, rt1 == rt2);
-        }
-        // mark_gc_use isn't needed since we won't load this pointer
+
+    if (arg1.isghost || arg2.isghost) {
+        // comparing to a singleton object
+        if (arg1.TIndex)
+            return emit_isa(ctx, arg1, rt2, NULL).first; // rt2 is a singleton type
+        if (arg2.TIndex)
+            return emit_isa(ctx, arg2, rt1, NULL).first; // rt1 is a singleton type
+        // rooting these values isn't needed since we won't load this pointer
         // and we know at least one of them is a unique Singleton
         // which is already enough to ensure pointer uniqueness for this test
         // even if the other pointer managed to get garbage collected
-        return builder.CreateICmpEQ(boxed(arg1, ctx, false), boxed(arg2, ctx, false));
+        return ctx.builder.CreateICmpEQ(
+            mark_callee_rooted(boxed(ctx, arg1, false)),
+            mark_callee_rooted(boxed(ctx, arg2, false)));
     }
 
     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 = isconcrete && jl_isbits(rt1) && jl_types_equal(rt1, rt2);
+    bool isbits = jl_isbits(rt1) || jl_isbits(rt2);
     if (isbits) { // whether this type is unique'd by value
-        return emit_bits_compare(arg1, arg2, ctx);
+        jl_value_t *typ = jl_isbits(rt1) ? rt1 : rt2;
+        if (rt1 == rt2)
+            return emit_bits_compare(ctx, arg1, arg2);
+        Value *same_type = (typ == rt2) ? emit_isa(ctx, arg1, typ, NULL).first : emit_isa(ctx, arg2, typ, NULL).first;
+        BasicBlock *currBB = ctx.builder.GetInsertBlock();
+        BasicBlock *isaBB = BasicBlock::Create(jl_LLVMContext, "is", ctx.f);
+        BasicBlock *postBB = BasicBlock::Create(jl_LLVMContext, "post_is", ctx.f);
+        ctx.builder.CreateCondBr(same_type, isaBB, postBB);
+        ctx.builder.SetInsertPoint(isaBB);
+        Value *bitcmp = emit_bits_compare(ctx,
+                jl_cgval_t(arg1, typ, NULL),
+                jl_cgval_t(arg2, typ, NULL));
+        ctx.builder.CreateBr(postBB);
+        ctx.builder.SetInsertPoint(postBB);
+        PHINode *cmp = ctx.builder.CreatePHI(T_int1, 2);
+        cmp->addIncoming(ConstantInt::get(T_int1, 0), currBB);
+        cmp->addIncoming(bitcmp, isaBB);
+        return cmp;
     }
 
     int ptr_comparable = 0; // whether this type is unique'd by pointer
-    if (rt1==(jl_value_t*)jl_sym_type || rt2==(jl_value_t*)jl_sym_type ||
-        jl_is_mutable_datatype(rt1) || jl_is_mutable_datatype(rt2)) // excludes abstract types
+    if (rt1 == (jl_value_t*)jl_sym_type || rt2 == (jl_value_t*)jl_sym_type)
         ptr_comparable = 1;
-    if (jl_subtype(rt1, (jl_value_t*)jl_type_type) ||
-        jl_subtype(rt2, (jl_value_t*)jl_type_type)) // use typeseq for datatypes
+    if (jl_is_mutable_datatype(rt1) || jl_is_mutable_datatype(rt2)) // excludes abstract types
+        ptr_comparable = 1;
+    if (istypes) // need to use typeseq for datatypes
         ptr_comparable = 0;
     if ((jl_is_type_type(rt1) && jl_is_concrete_type(jl_tparam0(rt1))) ||
         (jl_is_type_type(rt2) && jl_is_concrete_type(jl_tparam0(rt2)))) // can compare concrete types by pointer
         ptr_comparable = 1;
+    if ((rt1 == (jl_value_t*)jl_string_type && rt2 == (jl_value_t*)jl_string_type) ||
+        (rt1 == (jl_value_t*)jl_simplevector_type && rt2 == (jl_value_t*)jl_simplevector_type))
+        ptr_comparable = 0; // technically mutable, but compared by contents
     if (ptr_comparable) {
-        assert(arg1.isboxed && arg2.isboxed); // only boxed types are valid for pointer comparison
-        return builder.CreateICmpEQ(boxed(arg1, ctx), boxed(arg2, ctx));
+        Value *varg1 = arg1.constant ? literal_pointer_val(ctx, arg1.constant) : arg1.V;
+        Value *varg2 = arg2.constant ? literal_pointer_val(ctx, arg2.constant) : arg2.V;
+        assert(varg1 && varg2 && (arg1.isboxed || arg1.TIndex) && (arg2.isboxed || arg2.TIndex) &&
+                "Only boxed types are valid for pointer comparison.");
+        return ctx.builder.CreateICmpEQ(decay_derived(varg1),
+                                        decay_derived(varg2));
     }
 
     JL_FEAT_REQUIRE(ctx, runtime);
-    Value *varg1 = boxed(arg1, ctx);
-    Value *varg2 = boxed(arg2, ctx, false); // potentially unrooted!
-#if JL_LLVM_VERSION >= 30700
-    return builder.CreateTrunc(builder.CreateCall(prepare_call(jlegal_func), {varg1, varg2}), T_int1);
-#else
-    return builder.CreateTrunc(builder.CreateCall2(prepare_call(jlegal_func), varg1, varg2), T_int1);
-#endif
+    Value *varg1 = mark_callee_rooted(boxed(ctx, arg1));
+    Value *varg2 = mark_callee_rooted(boxed(ctx, arg2, false)); // potentially unrooted!
+    return ctx.builder.CreateTrunc(ctx.builder.CreateCall(prepare_call(jlegal_func), {varg1, varg2}), T_int1);
 }
 
-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)
+static bool emit_builtin_call(jl_codectx_t &ctx, jl_cgval_t *ret, jl_value_t *f,
+                              const jl_cgval_t *argv, size_t nargs, jl_value_t *rt,
+                              jl_expr_t *ex)
 // returns true if the call has been handled
 {
-    jl_value_t *rt1=NULL, *rt2=NULL, *rt3=NULL;
-    JL_GC_PUSH3(&rt1, &rt2, &rt3);
-
-    if (f==jl_builtin_is && nargs==2) {
+    if (f == jl_builtin_is && nargs == 2) {
         // emit values
-        jl_cgval_t v1 = emit_expr(args[1], ctx);
-        jl_cgval_t v2 = emit_expr(args[2], ctx);
+        const jl_cgval_t &v1 = argv[1];
+        const jl_cgval_t &v2 = argv[2];
         // handle simple static expressions with no side-effects
         if (v1.constant) {
             if (v2.constant) {
-                *ret = mark_julia_type(ConstantInt::get(T_int8, jl_egal(v1.constant, v2.constant)), false, jl_bool_type, ctx);
-                JL_GC_POP();
+                *ret = mark_julia_type(ctx, ConstantInt::get(T_int8, jl_egal(v1.constant, v2.constant)), false, jl_bool_type);
                 return true;
             }
         }
-        // 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), ctx); // patch up typ if necessary
-        if (v2.typ == (jl_value_t*)jl_datatype_type)
-            v2 = remark_julia_type(v2, expr_type(args[2], ctx), ctx); // patch up typ if necessary
         // emit comparison test
-        Value *ans = emit_f_is(v1, v2, ctx);
-        mark_gc_use(v1);
-        mark_gc_use(v2);
-        *ret = mark_julia_type(builder.CreateZExt(ans, T_int8), false, jl_bool_type, ctx);
-        JL_GC_POP();
+        Value *ans = emit_f_is(ctx, v1, v2);
+        *ret = mark_julia_type(ctx, ctx.builder.CreateZExt(ans, T_int8), false, jl_bool_type);
         return true;
     }
 
-    else if (f==jl_builtin_typeof && nargs==1) {
-        jl_cgval_t arg1 = emit_expr(args[1], ctx);
-        *ret = emit_typeof(arg1, ctx);
-        JL_GC_POP();
+    else if (f == jl_builtin_typeof && nargs == 1) {
+        *ret = emit_typeof(ctx, argv[1]);
         return true;
     }
 
-    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_has_free_typevars(ty)) {
-            jl_value_t *tp0 = jl_tparam0(ty);
-            *ret = emit_expr(args[1], ctx);
-            emit_expr(args[2], ctx);
-            if (jl_subtype(arg, tp0)) {
-                JL_GC_POP();
-                return true;
-            }
-            emit_typecheck(*ret, tp0, "typeassert", ctx);
-            if (ret->isboxed)
-                *ret = remark_julia_type(*ret, expr_type(expr, ctx), ctx);
-            JL_GC_POP();
+    else if (f == jl_builtin_typeassert && nargs == 2) {
+        const jl_cgval_t &arg = argv[1];
+        const jl_cgval_t &ty = argv[2];
+        if (jl_is_type_type(ty.typ) && !jl_has_free_typevars(ty.typ)) {
+            jl_value_t *tp0 = jl_tparam0(ty.typ);
+            emit_typecheck(ctx, arg, tp0, "typeassert");
+            *ret = arg;
             return true;
         }
-        if (jl_subtype(ty, (jl_value_t*)jl_type_type)) {
-            *ret = emit_expr(args[1], ctx);
-            Value *rt_ty = boxed(emit_expr(args[2], ctx), ctx);
+        if (jl_subtype(ty.typ, (jl_value_t*)jl_type_type)) {
+            Value *rt_arg = boxed(ctx, arg);
+            Value *rt_ty = boxed(ctx, ty);
             JL_FEAT_REQUIRE(ctx, runtime);
-#if JL_LLVM_VERSION >= 30700
-            builder.CreateCall(prepare_call(jltypeassert_func), {boxed(*ret, ctx), rt_ty});
-#else
-            builder.CreateCall2(prepare_call(jltypeassert_func), boxed(*ret, ctx), rt_ty);
-#endif
-            JL_GC_POP();
+            ctx.builder.CreateCall(prepare_call(jltypeassert_func), {rt_arg, rt_ty});
+            *ret = arg;
             return true;
         }
     }
 
-    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) {
-            emit_expr(args[1], ctx);
-            emit_expr(args[2], ctx);
-            *ret = jl_cgval_t();
-            JL_GC_POP();
-            return true;
-        }
-        if (jl_is_type_type(ty) && !jl_has_free_typevars(ty)) {
-            jl_value_t *tp0 = jl_tparam0(ty);
-            jl_cgval_t rt_arg = emit_expr(args[1], ctx);
-            emit_expr(args[2], ctx);
-            if (jl_subtype(arg, tp0)) {
-                *ret = mark_julia_type(ConstantInt::get(T_int8, 1), false, jl_bool_type, ctx);
-                JL_GC_POP();
-                return true;
-            }
-            Value *isa = emit_isa(rt_arg, tp0, NULL, ctx);
-            *ret = mark_julia_type(builder.CreateZExt(isa, T_int8), false, jl_bool_type, ctx);
-            JL_GC_POP();
+    else if (f == jl_builtin_isa && nargs == 2) {
+        const jl_cgval_t &arg = argv[1];
+        const jl_cgval_t &ty = argv[2];
+        if (jl_is_type_type(ty.typ) && !jl_has_free_typevars(ty.typ)) {
+            jl_value_t *tp0 = jl_tparam0(ty.typ);
+            Value *isa_result = emit_isa(ctx, arg, tp0, NULL).first;
+            if (isa_result->getType() == T_int1)
+                isa_result = ctx.builder.CreateZExt(isa_result, T_int8);
+            *ret = mark_julia_type(ctx, isa_result, false, jl_bool_type);
             return true;
         }
     }
 
-    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_has_free_typevars(rt1) &&
-            jl_is_type_type(rt2) && !jl_has_free_typevars(rt2)) {
-            int issub = jl_subtype(jl_tparam0(rt1), jl_tparam0(rt2));
-            emit_expr(args[1], ctx);
-            emit_expr(args[2], ctx);
-            *ret = mark_julia_type(ConstantInt::get(T_int8, issub), false, jl_bool_type, ctx);
-            JL_GC_POP();
+    else if (f == jl_builtin_issubtype && nargs == 2) {
+        const jl_cgval_t &ta = argv[1];
+        const jl_cgval_t &tb = argv[2];
+        if (jl_is_type_type(ta.typ) && !jl_has_free_typevars(ta.typ) &&
+            jl_is_type_type(tb.typ) && !jl_has_free_typevars(tb.typ)) {
+            int issub = jl_subtype(jl_tparam0(ta.typ), jl_tparam0(tb.typ));
+            *ret = mark_julia_type(ctx, ConstantInt::get(T_int8, issub), false, jl_bool_type);
             return true;
         }
     }
 
-    else if (f==jl_builtin__apply && nargs==2 && ctx->vaStack && slot_eq(args[2], ctx->vaSlot)) {
+    else if (f == jl_builtin__apply && nargs == 2 && ctx.vaSlot > 0) {
         // turn Core._apply(f, Tuple) ==> f(Tuple...) using the jlcall calling convention if Tuple is the vaStack allocation
-        Value *theF = boxed(emit_expr(args[1], ctx), ctx);
-        Value *nva = emit_n_varargs(ctx);
+        if (LoadInst *load = dyn_cast_or_null<LoadInst>(argv[2].V)) {
+            if (load->getPointerOperand() == ctx.slots[ctx.vaSlot].boxroot) {
+                Value *theF = maybe_decay_untracked(boxed(ctx, argv[1]));
+                Value *nva = emit_n_varargs(ctx);
 #ifdef _P64
-        nva = builder.CreateTrunc(nva, T_int32);
-#endif
-        JL_FEAT_REQUIRE(ctx, runtime);
-        Value *r =
-#if JL_LLVM_VERSION >= 30700
-            builder.CreateCall(prepare_call(jlapply2va_func), {theF,
-                                builder.CreateGEP(ctx->argArray,
-                                                  ConstantInt::get(T_size, ctx->nReqArgs)),
-                                nva});
-#else
-            builder.CreateCall3(prepare_call(jlapply2va_func), theF,
-                                builder.CreateGEP(ctx->argArray,
-                                                  ConstantInt::get(T_size, ctx->nReqArgs)),
-                                nva);
+                nva = ctx.builder.CreateTrunc(nva, T_int32);
 #endif
-        *ret = mark_julia_type(r, true, expr_type(expr, ctx), ctx);
-        JL_GC_POP();
-        return true;
+                Value *theArgs = ctx.builder.CreateGEP(ctx.argArray, ConstantInt::get(T_size, ctx.nReqArgs));
+                JL_FEAT_REQUIRE(ctx, runtime);
+                Value *r = ctx.builder.CreateCall(prepare_call(jlapply2va_func), { theF, theArgs, nva });
+                *ret = mark_julia_type(ctx, r, true, jl_any_type);
+                return true;
+            }
+        }
     }
 
-    else if (f==jl_builtin_tuple) {
+    else if (f == jl_builtin_tuple) {
         if (nargs == 0) {
             *ret = ghostValue(jl_emptytuple_type);
-            JL_GC_POP();
             return true;
         }
-        if (ctx->source->inferred) {
-            rt1 = expr_type(expr, ctx);
-            if (jl_is_tuple_type(rt1) && jl_is_concrete_type(rt1) && nargs == jl_datatype_nfields(rt1)) {
-                *ret = emit_new_struct(rt1, nargs+1, args, ctx);
-                JL_GC_POP();
-                return true;
-            }
+        if (jl_is_tuple_type(rt) && jl_is_concrete_type(rt) && nargs == jl_datatype_nfields(rt)) {
+            *ret = emit_new_struct(ctx, rt, nargs + 1, argv);
+            return true;
         }
     }
 
-    else if (f==jl_builtin_throw && nargs==1) {
-        Value *arg1 = boxed(emit_expr(args[1], ctx), ctx, false); // rooted by throw
-        raise_exception(arg1, ctx);
+    else if (f == jl_builtin_throw && nargs == 1) {
+        Value *arg1 = boxed(ctx, argv[1], false); // rooted by throw
+        raise_exception(ctx, arg1);
         *ret = jl_cgval_t();
-        JL_GC_POP();
         return true;
     }
 
-    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;
-        aty = jl_unwrap_unionall(aty);
-        if (jl_is_array_type(aty) && ity == (jl_value_t*)jl_long_type) {
+    else if (f == jl_builtin_arraysize && nargs == 2) {
+        const jl_cgval_t &ary = argv[1];
+        const jl_cgval_t &idx = argv[2];
+        jl_value_t *aty = jl_unwrap_unionall(ary.typ);
+        if (jl_is_array_type(aty) && idx.typ == (jl_value_t*)jl_long_type) {
             jl_value_t *ndp = jl_tparam1(aty);
             if (jl_is_long(ndp)) {
-                jl_cgval_t ary = emit_expr(args[1], ctx);
                 size_t ndims = jl_unbox_long(ndp);
-                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), false, jl_long_type, ctx);
-                        JL_GC_POP();
+                if (idx.constant) {
+                    uint32_t idx_const = (uint32_t)jl_unbox_long(idx.constant);
+                    if (idx_const > 0 && idx_const <= ndims) {
+                        jl_value_t *ary_ex = jl_exprarg(ex, 1);
+                        *ret = mark_julia_type(ctx, emit_arraysize(ctx, ary, ary_ex, idx_const), false, jl_long_type);
                         return true;
                     }
-                    else if (idx > ndims) {
-                        *ret = mark_julia_type(ConstantInt::get(T_size, 1), false, jl_long_type, ctx);
-                        JL_GC_POP();
+                    else if (idx_const > ndims) {
+                        *ret = mark_julia_type(ctx, ConstantInt::get(T_size, 1), false, jl_long_type);
                         return true;
                     }
                 }
                 else {
-                    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);
-                    BasicBlock *outBB = BasicBlock::Create(jl_LLVMContext,"outofrange",ctx->f);
-                    BasicBlock *inBB = BasicBlock::Create(jl_LLVMContext,"inrange");
-                    BasicBlock *ansBB = BasicBlock::Create(jl_LLVMContext,"arraysize");
-                    builder.CreateCondBr(builder.CreateICmpSLE(idx,
-                                                              ConstantInt::get(T_size, ndims)),
-                                         inBB, outBB);
-                    builder.SetInsertPoint(outBB);
+                    Value *idx_dyn = emit_unbox(ctx, T_size, idx, (jl_value_t*)jl_long_type);
+                    error_unless(ctx, ctx.builder.CreateICmpSGT(idx_dyn, ConstantInt::get(T_size, 0)),
+                                 "arraysize: dimension out of range");
+                    BasicBlock *outBB = BasicBlock::Create(jl_LLVMContext, "outofrange", ctx.f);
+                    BasicBlock *inBB = BasicBlock::Create(jl_LLVMContext, "inrange");
+                    BasicBlock *ansBB = BasicBlock::Create(jl_LLVMContext, "arraysize");
+                    ctx.builder.CreateCondBr(ctx.builder.CreateICmpSLE(idx_dyn,
+                                ConstantInt::get(T_size, ndims)),
+                            inBB, outBB);
+                    ctx.builder.SetInsertPoint(outBB);
                     Value *v_one = ConstantInt::get(T_size, 1);
-                    builder.CreateBr(ansBB);
-                    ctx->f->getBasicBlockList().push_back(inBB);
-                    builder.SetInsertPoint(inBB);
-                    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);
+                    ctx.builder.CreateBr(ansBB);
+                    ctx.f->getBasicBlockList().push_back(inBB);
+                    ctx.builder.SetInsertPoint(inBB);
+                    Value *v_sz = emit_arraysize(ctx, ary, idx_dyn);
+                    ctx.builder.CreateBr(ansBB);
+                    ctx.f->getBasicBlockList().push_back(ansBB);
+                    ctx.builder.SetInsertPoint(ansBB);
+                    PHINode *result = ctx.builder.CreatePHI(T_size, 2);
                     result->addIncoming(v_one, outBB);
                     result->addIncoming(v_sz, inBB);
-                    *ret = mark_julia_type(result, false, jl_long_type, ctx);
-                    JL_GC_POP();
+                    *ret = mark_julia_type(ctx, result, false, jl_long_type);
                     return true;
                 }
             }
         }
     }
 
-    else if (f==jl_builtin_arrayref && nargs>=2) {
-        jl_value_t *aty = expr_type(args[1], ctx); rt1 = aty;
+    else if (f == jl_builtin_arrayref && nargs >= 2) {
+        const jl_cgval_t &ary = argv[1];
         bool indexes_ok = true;
-        for (size_t i=2; i <= nargs; i++) {
-            if (expr_type(args[i], ctx) != (jl_value_t*)jl_long_type) {
+        for (size_t i = 2; i <= nargs; i++) {
+            if (argv[i].typ != (jl_value_t*)jl_long_type) {
                 indexes_ok = false;
                 break;
             }
         }
-        jl_value_t *aty_dt = jl_unwrap_unionall(aty);
+        jl_value_t *aty_dt = jl_unwrap_unionall(ary.typ);
         if (jl_is_array_type(aty_dt) && indexes_ok) {
             jl_value_t *ety = jl_tparam0(aty_dt);
-            if (!jl_has_free_typevars(ety)) { // TODO: jn/foreigncall branch has a better predicate
+            jl_value_t *ndp = jl_tparam1(aty_dt);
+            if (!jl_has_free_typevars(ety) && (jl_is_long(ndp) || nargs == 2)) {
+                jl_value_t *ary_ex = jl_exprarg(ex, 1);
                 if (!jl_array_store_unboxed(ety))
                     ety = (jl_value_t*)jl_any_type;
-                jl_value_t *ndp = jl_tparam1(aty_dt);
-                if (jl_is_long(ndp) || nargs==2) {
-                    jl_cgval_t ary = emit_expr(args[1], ctx);
-                    ssize_t nd = jl_is_long(ndp) ? jl_unbox_long(ndp) : -1;
-                    Value *idx = emit_array_nd_index(ary, args[1], nd, &args[2], nargs-1, ctx);
-                    if (jl_array_store_unboxed(ety) &&
-                        jl_datatype_size(ety) == 0) {
-                        assert(jl_is_datatype(ety));
-                        assert(((jl_datatype_t*)ety)->instance != NULL);
-                        *ret = ghostValue(ety);
-                    }
-                    else {
-                        *ret = typed_load(emit_arrayptr(ary, args[1], ctx), idx, ety, ctx, tbaa_arraybuf);
-                    }
-                    JL_GC_POP();
-                    return true;
+                ssize_t nd = jl_is_long(ndp) ? jl_unbox_long(ndp) : -1;
+                Value *idx = emit_array_nd_index(ctx, ary, ary_ex, nd, &argv[2], nargs - 1);
+                if (jl_array_store_unboxed(ety) && jl_datatype_size(ety) == 0) {
+                    assert(jl_is_datatype(ety));
+                    assert(((jl_datatype_t*)ety)->instance != NULL);
+                    *ret = ghostValue(ety);
+                }
+                else {
+                    *ret = typed_load(ctx, emit_arrayptr(ctx, ary, ary_ex), idx, ety,
+                        jl_array_store_unboxed(ety) ? tbaa_arraybuf : tbaa_ptrarraybuf);
                 }
+                return true;
             }
         }
     }
 
-    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;
+    else if (f == jl_builtin_arrayset && nargs >= 3) {
+        const jl_cgval_t &ary = argv[1];
+        const jl_cgval_t &val = argv[2];
         bool indexes_ok = true;
-        for (size_t i=3; i <= nargs; i++) {
-            if (expr_type(args[i], ctx) != (jl_value_t*)jl_long_type) {
+        for (size_t i = 3; i <= nargs; i++) {
+            if (argv[i].typ != (jl_value_t*)jl_long_type) {
                 indexes_ok = false;
                 break;
             }
         }
-        jl_value_t *aty_dt = jl_unwrap_unionall(aty);
+        jl_value_t *aty_dt = jl_unwrap_unionall(ary.typ);
         if (jl_is_array_type(aty_dt) && indexes_ok) {
             jl_value_t *ety = jl_tparam0(aty_dt);
-            if (!jl_has_free_typevars(ety) && jl_subtype(vty, ety)) { // TODO: jn/foreigncall branch has a better predicate
-                if (!jl_array_store_unboxed(ety))
-                    ety = (jl_value_t*)jl_any_type;
-                jl_value_t *ndp = jl_tparam1(aty_dt);
-                if (jl_is_long(ndp) || nargs==3) {
-                    jl_cgval_t ary = emit_expr(args[1], ctx);
-                    ssize_t nd = jl_is_long(ndp) ? jl_unbox_long(ndp) : -1;
-                    Value *idx = emit_array_nd_index(ary, args[1], nd, &args[3], nargs-2, ctx);
+            jl_value_t *ndp = jl_tparam1(aty_dt);
+            if (!jl_has_free_typevars(ety) && (jl_is_long(ndp) || nargs == 3)) {
+                if (jl_subtype(val.typ, ety)) { // TODO: probably should just convert this to a type-assert
                     bool isboxed = !jl_array_store_unboxed(ety);
+                    if (isboxed)
+                        ety = (jl_value_t*)jl_any_type;
+                    jl_value_t *ary_ex = jl_exprarg(ex, 1);
+                    ssize_t nd = jl_is_long(ndp) ? jl_unbox_long(ndp) : -1;
+                    Value *idx = emit_array_nd_index(ctx, ary, ary_ex, nd, &argv[3], nargs - 2);
                     if (!isboxed && jl_datatype_size(ety) == 0) {
-                        // no-op, but emit expr for possible effects
                         assert(jl_is_datatype(ety));
-                        emit_expr(args[2], ctx);
                     }
                     else {
-                        jl_cgval_t v = 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);
+                            Value *aryv = maybe_decay_untracked(boxed(ctx, ary));
+                            Value *flags = emit_arrayflags(ctx, ary);
                             // the owner of the data is ary itself except if ary->how == 3
-                            flags = builder.CreateAnd(flags, 3);
-                            Value *is_owned = builder.CreateICmpEQ(flags, ConstantInt::get(T_int16, 3));
-                            BasicBlock *curBB = builder.GetInsertBlock();
-                            BasicBlock *ownedBB = BasicBlock::Create(jl_LLVMContext, "array_owned", ctx->f);
-                            BasicBlock *mergeBB = BasicBlock::Create(jl_LLVMContext, "merge_own", ctx->f);
-                            builder.CreateCondBr(is_owned, ownedBB, mergeBB);
-                            builder.SetInsertPoint(ownedBB);
+                            flags = ctx.builder.CreateAnd(flags, 3);
+                            Value *is_owned = ctx.builder.CreateICmpEQ(flags, ConstantInt::get(T_int16, 3));
+                            BasicBlock *curBB = ctx.builder.GetInsertBlock();
+                            BasicBlock *ownedBB = BasicBlock::Create(jl_LLVMContext, "array_owned", ctx.f);
+                            BasicBlock *mergeBB = BasicBlock::Create(jl_LLVMContext, "merge_own", ctx.f);
+                            ctx.builder.CreateCondBr(is_owned, ownedBB, mergeBB);
+                            ctx.builder.SetInsertPoint(ownedBB);
                             // load owner pointer
                             Value *own_ptr;
                             if (jl_is_long(ndp)) {
-                                own_ptr = tbaa_decorate(tbaa_const, builder.CreateLoad(
-                                    emit_bitcast(
-                                        builder.CreateConstGEP1_32(
-                                            emit_bitcast(aryv, T_pint8),
+                                own_ptr = tbaa_decorate(tbaa_const, ctx.builder.CreateLoad(
+                                    emit_bitcast(ctx,
+                                        ctx.builder.CreateConstGEP1_32(
+                                            emit_bitcast(ctx, decay_derived(aryv), T_pint8),
                                             jl_array_data_owner_offset(nd)),
-                                        T_ppjlvalue)));
+                                        T_pprjlvalue)));
                             }
                             else {
-#if JL_LLVM_VERSION >= 30700
-                                own_ptr = builder.CreateCall(
+                                own_ptr = ctx.builder.CreateCall(
                                     prepare_call(jlarray_data_owner_func),
                                     {aryv});
-#else
-                                own_ptr = builder.CreateCall(
-                                    prepare_call(jlarray_data_owner_func),
-                                    aryv);
-#endif
                             }
-                            builder.CreateBr(mergeBB);
-                            builder.SetInsertPoint(mergeBB);
-                            data_owner = builder.CreatePHI(T_pjlvalue, 2);
+                            ctx.builder.CreateBr(mergeBB);
+                            ctx.builder.SetInsertPoint(mergeBB);
+                            data_owner = ctx.builder.CreatePHI(T_prjlvalue, 2);
                             data_owner->addIncoming(aryv, curBB);
                             data_owner->addIncoming(own_ptr, ownedBB);
                         }
-                        typed_store(emit_arrayptr(ary,args[1],ctx), idx, v,
-                                    ety, ctx, tbaa_arraybuf, data_owner, 0,
+                        typed_store(ctx,
+                                    emit_arrayptr(ctx, ary, ary_ex, isboxed),
+                                    idx, val, ety,
+                                    !isboxed ? tbaa_arraybuf : tbaa_ptrarraybuf,
+                                    data_owner, 0,
                                     false); // don't need to root the box if we had to make one since it's being stored in the array immediatly
                     }
                     *ret = ary;
-                    JL_GC_POP();
                     return true;
                 }
             }
         }
     }
 
-    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);
-            if (ret->typ == (jl_value_t*)jl_any_type) // improve the type, if known from the expr
-                *ret = remark_julia_type(*ret, expr_type(expr, ctx), ctx);
-            JL_GC_POP();
-            return true;
-        }
-        jl_datatype_t *stt = (jl_datatype_t*)expr_type(args[1], ctx);
-        jl_value_t *fldt   = expr_type(args[2], ctx);
-
-        // VA tuple
-        if (ctx->vaStack && slot_eq(args[1], ctx->vaSlot)) {
-            Value *valen = emit_n_varargs(ctx);
-            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, false, NULL),
-                    NULL, idx, valen, ctx);
-            idx = builder.CreateAdd(idx, ConstantInt::get(T_size, ctx->nReqArgs));
-            *ret = mark_julia_type(
-                tbaa_decorate(tbaa_value, builder.CreateLoad(builder.CreateGEP(ctx->argArray, idx))),
-                /*boxed*/ true, expr_type(expr, ctx), ctx, /*needsgcroot*/ false);
-            JL_GC_POP();
+    else if (f == jl_builtin_getfield && nargs == 2) {
+        const jl_cgval_t &obj = argv[1];
+        const jl_cgval_t &fld = argv[2];
+        if (fld.constant && fld.typ == (jl_value_t*)jl_symbol_type) {
+            *ret = emit_getfield(ctx, argv[1], (jl_sym_t*)fld.constant);
             return true;
         }
 
-        if (fldt == (jl_value_t*)jl_long_type && jl_is_concrete_type((jl_value_t*)stt)) {
-            if ((jl_is_structtype(stt) || jl_is_tuple_type(stt)) && !jl_subtype((jl_value_t*)jl_module_type, (jl_value_t*)stt)) {
-                size_t nfields = jl_datatype_nfields(stt);
-                jl_cgval_t strct = emit_expr(args[1], ctx);
-                // integer index
-                size_t idx;
-                if (jl_is_long(args[2]) && (idx=jl_unbox_long(args[2])-1) < nfields) {
-                    // known index
-                    *ret = emit_getfield_knownidx(strct, idx, stt, ctx);
-                    JL_GC_POP();
-                    return true;
+        if (fld.typ == (jl_value_t*)jl_long_type) {
+            if (ctx.vaSlot > 0) {
+                // optimize VA tuple
+                if (LoadInst *load = dyn_cast_or_null<LoadInst>(obj.V)) {
+                    if (load->getPointerOperand() == ctx.slots[ctx.vaSlot].boxroot) {
+                        Value *valen = emit_n_varargs(ctx);
+                        jl_cgval_t va_ary( // fake instantiation of a cgval, in order to call emit_bounds_check
+                                ctx.builder.CreateGEP(ctx.argArray, ConstantInt::get(T_size, ctx.nReqArgs)),
+                                NULL, false, NULL, NULL);
+                        Value *idx = emit_unbox(ctx, T_size, fld, (jl_value_t*)jl_long_type);
+                        idx = emit_bounds_check(ctx, va_ary, NULL, idx, valen);
+                        idx = ctx.builder.CreateAdd(idx, ConstantInt::get(T_size, ctx.nReqArgs));
+                        Value *v = tbaa_decorate(tbaa_value, ctx.builder.CreateLoad(ctx.builder.CreateGEP(ctx.argArray, idx)));
+                        *ret = mark_julia_type(ctx, v, /*boxed*/ true, jl_any_type, /*needsgcroot*/ false);
+                        return true;
+                    }
                 }
-                else {
-                    // unknown index
-                    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);
-                        JL_GC_POP();
+            }
+
+            jl_datatype_t *utt = (jl_datatype_t*)jl_unwrap_unionall(obj.typ);
+            if (jl_is_datatype(utt) && utt->layout) {
+                if ((jl_is_structtype(utt) || jl_is_tuple_type(utt)) && !jl_subtype((jl_value_t*)jl_module_type, obj.typ)) {
+                    size_t nfields = jl_datatype_nfields(utt);
+                    // integer index
+                    size_t idx;
+                    if (fld.constant && (idx = jl_unbox_long(fld.constant) - 1) < nfields) {
+                        // known index
+                        *ret = emit_getfield_knownidx(ctx, obj, idx, utt);
+                        return true;
+                    }
+                    else {
+                        // unknown index
+                        Value *vidx = emit_unbox(ctx, T_size, fld, (jl_value_t*)jl_long_type);
+                        if (emit_getfield_unknownidx(ctx, ret, obj, vidx, utt)) {
+                            return true;
+                        }
+                    }
+                }
+            }
+            else {
+                if (jl_is_tuple_type(utt) && is_tupletype_homogeneous(utt->types, true)) {
+                    // For tuples, we can emit code even if we don't know the exact
+                    // type (e.g. because we don't know the length). This is possible
+                    // as long as we know that all elements are of the same (concrete) type.
+                    if (obj.ispointer()) {
+                        // Determine which was the type that was homogenous
+                        jl_value_t *jt = jl_tparam0(utt);
+                        if (jl_is_vararg_type(jt))
+                            jt = jl_unwrap_vararg(jt);
+                        Value *vidx = emit_unbox(ctx, T_size, fld, (jl_value_t*)jl_long_type);
+                        // This is not necessary for correctness, but allows to omit
+                        // the extra code for getting the length of the tuple
+                        if (!bounds_check_enabled(ctx)) {
+                            vidx = ctx.builder.CreateSub(vidx, ConstantInt::get(T_size, 1));
+                        } else {
+                            vidx = emit_bounds_check(ctx, obj, (jl_value_t*)obj.typ, vidx,
+                                emit_datatype_nfields(ctx, emit_typeof_boxed(ctx, obj)));
+                        }
+                        Value *ptr = data_pointer(ctx, obj);
+                        *ret = typed_load(ctx, ptr, vidx, jt, obj.tbaa, false);
                         return true;
                     }
                 }
@@ -2644,156 +2555,177 @@ static bool emit_builtin_call(jl_cgval_t *ret, jl_value_t *f, jl_value_t **args,
         }
     }
 
-    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 &&
-            jl_is_quotenode(args[2]) && jl_is_symbol(jl_fieldref(args[2],0))) {
-            size_t idx = jl_field_index(sty,
-                                        (jl_sym_t*)jl_fieldref(args[2],0), 0);
+    else if (f == jl_builtin_setfield && nargs == 3) {
+        const jl_cgval_t &obj = argv[1];
+        const jl_cgval_t &fld = argv[2];
+        const jl_cgval_t &val = argv[3];
+
+        jl_datatype_t *uty = (jl_datatype_t*)jl_unwrap_unionall(obj.typ);
+        if (jl_is_structtype(uty) && uty != jl_module_type && uty->layout) {
+            size_t idx = (size_t)-1;
+            if (fld.constant && fld.typ == (jl_value_t*)jl_symbol_type) {
+                idx = jl_field_index(uty, (jl_sym_t*)fld.constant, 0);
+            }
+            else if (fld.constant && fld.typ == (jl_value_t*)jl_long_type) {
+                ssize_t i = jl_unbox_long(fld.constant);
+                if (i > 0 && i <= jl_datatype_nfields(uty))
+                    idx = i - 1;
+            }
             if (idx != (size_t)-1) {
-                jl_value_t *ft = jl_svecref(sty->types, idx);
-                jl_value_t *rhst = expr_type(args[3], ctx);
-                rt2 = rhst;
-                if (jl_is_concrete_type((jl_value_t*)sty) && jl_subtype(rhst, ft)) {
+                jl_value_t *ft = jl_svecref(uty->types, idx);
+                if (jl_subtype(val.typ, ft)) {
                     // TODO: attempt better codegen for approximate types
-                    jl_cgval_t strct = emit_expr(args[1], ctx); // emit lhs
-                    *ret = emit_expr(args[3], ctx);
-                    emit_setfield(sty, strct, idx, *ret, ctx, true, true);
-                    JL_GC_POP();
+                    emit_setfield(ctx, uty, obj, idx, val, true, true);
+                    *ret = val;
                     return true;
                 }
             }
         }
-        // TODO: faster code for integer index
     }
 
-    else if (f==jl_builtin_nfields && nargs==1) {
-        if (ctx->vaStack && slot_eq(args[1], ctx->vaSlot)) {
-            *ret = mark_julia_type(emit_n_varargs(ctx), false, jl_long_type, ctx);
-            JL_GC_POP();
-            return true;
+    else if (f == jl_builtin_nfields && nargs == 1) {
+        const jl_cgval_t &obj = argv[1];
+        if (ctx.vaSlot > 0) {
+            // optimize VA tuple
+            if (LoadInst *load = dyn_cast_or_null<LoadInst>(obj.V)) {
+                if (load->getPointerOperand() == ctx.slots[ctx.vaSlot].boxroot) {
+                    *ret = mark_julia_type(ctx, emit_n_varargs(ctx), false, jl_long_type);
+                    return true;
+                }
+            }
         }
-        jl_value_t *aty = expr_type(args[1], ctx); rt1 = aty;
-        if (jl_is_type_type(aty)) {
-            jl_value_t *tp0 = jl_tparam0(aty);
+        if (jl_is_type_type(obj.typ)) {
+            jl_value_t *tp0 = jl_tparam0(obj.typ);
             if (jl_is_concrete_type(tp0)) {
-                emit_expr(args[1], ctx);
-                assert(jl_is_datatype(tp0));
-                *ret = mark_julia_type(ConstantInt::get(T_size, jl_datatype_nfields(tp0)), false, jl_long_type, ctx);
-                JL_GC_POP();
+                *ret = mark_julia_type(ctx, ConstantInt::get(T_size, jl_datatype_nfields(tp0)), false, jl_long_type);
                 return true;
             }
         }
-        else if (jl_is_concrete_type(aty)) {
-            jl_cgval_t arg1 = emit_expr(args[1], ctx);
+        else if (jl_is_concrete_type(obj.typ) || obj.constant) {
             Value *sz;
-            if (arg1.constant) {
-                sz = ConstantInt::get(T_size, jl_datatype_nfields(arg1.typ));
+            if (obj.constant) {
+                if (jl_typeof(obj.constant) == (jl_value_t*)jl_datatype_type)
+                    sz = ConstantInt::get(T_size, jl_datatype_nfields(obj.constant));
+                else
+                    sz = ConstantInt::get(T_size, jl_datatype_nfields(obj.typ));
             }
-            else if (aty == (jl_value_t*)jl_datatype_type) {
-                assert(arg1.isboxed);
-                sz = emit_datatype_nfields(boxed(arg1, ctx));
+            else if (obj.typ == (jl_value_t*)jl_datatype_type) {
+                sz = emit_datatype_nfields(ctx, boxed(ctx, obj));
             }
             else {
-                assert(jl_is_datatype(aty));
-                sz = ConstantInt::get(T_size, jl_datatype_nfields(aty));
+                assert(jl_is_datatype(obj.typ));
+                sz = ConstantInt::get(T_size, jl_datatype_nfields(obj.typ));
             }
-            *ret = mark_julia_type(sz, false, jl_long_type, ctx);
-            JL_GC_POP();
+            *ret = mark_julia_type(ctx, sz, false, jl_long_type);
             return true;
         }
     }
 
-    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);
-                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 = tbaa_decorate(tbaa_const, builder.CreateLoad(builder.CreateGEP(emit_bitcast(types_svec, T_ppjlvalue), idx)));
-                *ret = mark_julia_type(fieldtyp, true, expr_type(expr, ctx), ctx);
-                JL_GC_POP();
+    else if (f == jl_builtin_fieldtype && nargs == 2) {
+        const jl_cgval_t &typ = argv[1];
+        const jl_cgval_t &fld = argv[2];
+        if ((jl_is_type_type(typ.typ) && jl_is_concrete_type(jl_tparam0(typ.typ))) ||
+                (typ.constant && jl_is_datatype(typ.constant)) ||
+                typ.typ == (jl_value_t*)jl_datatype_type) {
+            if (fld.typ == (jl_value_t*)jl_long_type) {
+                assert(typ.isboxed);
+                Value *tyv = boxed(ctx, typ);
+                Value *types_svec = emit_datatype_types(ctx, tyv);
+                Value *types_len = emit_datatype_nfields(ctx, tyv);
+                Value *idx = emit_unbox(ctx, T_size, fld, (jl_value_t*)jl_long_type);
+                emit_bounds_check(ctx, typ, (jl_value_t*)jl_datatype_type, idx, types_len);
+                Value *fieldtyp_p = ctx.builder.CreateGEP(decay_derived(emit_bitcast(ctx, types_svec, T_pprjlvalue)), idx);
+                Value *fieldtyp = tbaa_decorate(tbaa_const, ctx.builder.CreateLoad(fieldtyp_p));
+                *ret = mark_julia_type(ctx, fieldtyp, true, (jl_value_t*)jl_type_type);
                 return true;
             }
         }
     }
 
-    else if (f==jl_builtin_sizeof && nargs == 1) {
-        jl_value_t *sty = expr_type(args[1], ctx); rt1 = sty;
-        sty = jl_unwrap_unionall(sty);
-        if (jl_is_type_type(sty) && !jl_is_typevar(jl_tparam0(sty))) {
-            sty = jl_tparam0(sty);
+    else if (f == jl_builtin_sizeof && nargs == 1) {
+        const jl_cgval_t &obj = argv[1];
+        jl_datatype_t *sty = (jl_datatype_t*)jl_unwrap_unionall(obj.typ);
+        assert(jl_string_type->mutabl);
+        if (sty == jl_string_type || sty == jl_simplevector_type) {
+            // String and SimpleVector's length fields have the same layout
+            auto ptr = emit_bitcast(ctx, boxed(ctx, obj), T_psize);
+            Value *len = tbaa_decorate(tbaa_mutab, ctx.builder.CreateLoad(ptr));
+            if (sty == jl_simplevector_type) {
+                len = ctx.builder.CreateMul(len, ConstantInt::get(T_size, sizeof(void*)));
+                len = ctx.builder.CreateAdd(len, ConstantInt::get(T_size, sizeof(void*)));
+            }
+            *ret = mark_julia_type(ctx, len, false, jl_long_type);
+            return true;
         }
-        if (jl_is_datatype(sty) && sty != (jl_value_t*)jl_symbol_type &&
-            ((jl_datatype_t*)sty)->name != jl_array_typename &&
-            sty != (jl_value_t*)jl_simplevector_type && sty != (jl_value_t*)jl_string_type &&
-            // exclude DataType, since each DataType has its own size, not sizeof(DataType).
-            // this is issue #8798
-            sty != (jl_value_t*)jl_datatype_type) {
-            if (jl_is_concrete_type(sty) ||
-                (((jl_datatype_t*)sty)->name->names == jl_emptysvec && jl_datatype_size(sty) > 0)) {
-                *ret = mark_julia_type(ConstantInt::get(T_size, jl_datatype_size(sty)), false, jl_long_type, ctx);
-                JL_GC_POP();
+        else if (jl_is_datatype(sty) && sty->name == jl_array_typename) {
+            jl_value_t *ary_ex = jl_exprarg(ex, 1);
+            auto len = emit_arraylen(ctx, obj, ary_ex);
+            jl_value_t *ety = jl_tparam0(sty);
+            Value *elsize;
+            if (!jl_has_free_typevars(ety)) {
+                if (!jl_array_store_unboxed(ety)) {
+                    elsize = ConstantInt::get(T_size, sizeof(void*));
+                }
+                else {
+                    elsize = ConstantInt::get(T_size, jl_datatype_size(ety));
+                }
+            }
+            else {
+                elsize = ctx.builder.CreateZExt(emit_arrayelsize(ctx, obj), T_size);
+            }
+            *ret = mark_julia_type(ctx, ctx.builder.CreateMul(len, elsize), false, jl_long_type);
+            return true;
+        }
+        if (jl_is_type_type((jl_value_t*)sty) && !jl_is_typevar(jl_tparam0(sty))) {
+            sty = (jl_datatype_t*)jl_tparam0(sty);
+        }
+        if (jl_is_datatype(sty) && sty != jl_symbol_type &&
+                sty->name != jl_array_typename &&
+                sty != jl_simplevector_type && sty != jl_string_type &&
+                // exclude DataType, since each DataType has its own size, not sizeof(DataType).
+                // this is issue #8798
+                sty != jl_datatype_type) {
+            if (jl_is_concrete_type((jl_value_t*)sty) ||
+                    (jl_field_names(sty) == jl_emptysvec && jl_datatype_size(sty) > 0)) {
+                *ret = mark_julia_type(ctx, ConstantInt::get(T_size, jl_datatype_size(sty)), false, jl_long_type);
                 return true;
             }
         }
     }
 
-    else if (f==jl_builtin_apply_type && nargs > 0) {
-        size_t i;
-        if (ctx->linfo->def == NULL) {
-            // don't bother codegen constant-folding for toplevel
-            JL_GC_POP();
-            return false;
-        }
-        for (i=1; i <= nargs; i++) {
-            if (!is_constant(args[i], ctx))
-                break;
-        }
-        if (i > nargs) {
-            jl_value_t *ty = static_eval(expr, ctx, true, true);
-            if (ty!=NULL && jl_is_concrete_type(ty)) {
-                if (jl_has_free_typevars(ty)) {
-                    // add root for types not cached. issue #7065
-                    jl_add_method_root(ctx, ty);
-                }
+    else if (f == jl_builtin_apply_type && nargs > 0) {
+        if (jl_is_method(ctx.linfo->def.method)) {
+            // don't bother codegen constant-folding for toplevel.
+            jl_value_t *ty = static_apply_type(ctx, argv, nargs + 1);
+            if (ty != NULL) {
+                jl_add_method_root(ctx, ty);
                 *ret = mark_julia_const(ty);
-                JL_GC_POP();
                 return true;
             }
         }
     }
 
     else if (f == jl_builtin_isdefined && nargs == 2) {
-        jl_datatype_t *stt = (jl_datatype_t*)expr_type(args[1], ctx);
+        const jl_cgval_t &obj = argv[1];
+        const jl_cgval_t &fld = argv[2];
+        jl_datatype_t *stt = (jl_datatype_t*)obj.typ;
         if (!jl_is_concrete_type((jl_value_t*)stt) || jl_is_array_type(stt) ||
-            stt == jl_module_type) {
-            JL_GC_POP();
+            stt == jl_module_type) { // TODO: use ->layout here instead of concrete_type
             return false;
         }
         assert(jl_is_datatype(stt));
 
         ssize_t fieldidx = -1;
-        if (jl_is_quotenode(args[2]) && jl_is_symbol(jl_fieldref(args[2], 0))) {
-            jl_sym_t * sym = (jl_sym_t*)jl_fieldref(args[2], 0);
+        if (fld.constant && fld.typ == (jl_value_t*)jl_symbol_type) {
+            jl_sym_t *sym = (jl_sym_t*)fld.constant;
             fieldidx = jl_field_index(stt, sym, 0);
         }
-        else if (jl_is_long(args[2])) {
-            fieldidx = jl_unbox_long(args[2]) - 1;
+        else if (fld.constant && fld.typ == (jl_value_t*)jl_long_type) {
+            fieldidx = jl_unbox_long(fld.constant) - 1;
         }
         else {
-            JL_GC_POP();
             return false;
         }
-        jl_cgval_t strct = emit_expr(args[1], ctx);
         if (fieldidx < 0 || fieldidx >= jl_datatype_nfields(stt)) {
             *ret = mark_julia_const(jl_false);
         }
@@ -2802,198 +2734,231 @@ static bool emit_builtin_call(jl_cgval_t *ret, jl_value_t *f, jl_value_t **args,
         }
         else {
             size_t offs = jl_field_offset(stt, fieldidx);
-            Value *ptr = data_pointer(strct, ctx, T_pint8);
+            Value *ptr = data_pointer(ctx, obj, T_pint8);
             Value *llvm_idx = ConstantInt::get(T_size, offs);
-            Value *addr = builder.CreateGEP(ptr, llvm_idx);
-            Value *fldv = tbaa_decorate(strct.tbaa, builder.CreateLoad(emit_bitcast(addr, T_ppjlvalue)));
-            Value *isdef = builder.CreateICmpNE(fldv, V_null);
-            *ret = mark_julia_type(isdef, false, jl_bool_type, ctx);
+            Value *addr = ctx.builder.CreateGEP(ptr, llvm_idx);
+            Value *fldv = tbaa_decorate(obj.tbaa, ctx.builder.CreateLoad(emit_bitcast(ctx, addr, T_ppjlvalue)));
+            Value *isdef = ctx.builder.CreateICmpNE(fldv, V_null);
+            *ret = mark_julia_type(ctx, isdef, false, jl_bool_type);
         }
-        JL_GC_POP();
         return true;
     }
-    // TODO: other known builtins
-    JL_GC_POP();
     return false;
 }
 
-static Value *emit_jlcall(Value *theFptr, Value *theF, jl_value_t **args,
-                          size_t nargs, jl_codectx_t *ctx)
+static Value *emit_jlcall(jl_codectx_t &ctx, Value *theFptr, Value *theF,
+                          jl_cgval_t *argv, size_t nargs)
 {
     // emit arguments
-    Value *myargs;
-    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);
-    }
-#if JL_LLVM_VERSION >= 30700
-    Value *result = builder.CreateCall(prepare_call(theFptr), {theF, myargs,
-                                       ConstantInt::get(T_int32,nargs)});
-#else
-    Value *result = builder.CreateCall3(prepare_call(theFptr), theF, myargs,
-                                        ConstantInt::get(T_int32,nargs));
-#endif
+    SmallVector<Value*, 3> theArgs;
+    if (theF)
+        theArgs.push_back(theF);
+    for (size_t i = 0; i < nargs; i++) {
+        Value *arg = maybe_decay_untracked(boxed(ctx, argv[i], false));
+        theArgs.push_back(arg);
+    }
+    SmallVector<Type *, 3> argsT;
+    for (size_t i = 0; i < nargs + (theF != nullptr); i++) {
+        argsT.push_back(T_prjlvalue);
+    }
+    FunctionType *FTy = FunctionType::get(T_prjlvalue, argsT, false);
+    CallInst *result = ctx.builder.CreateCall(FTy,
+        ctx.builder.CreateBitCast(prepare_call(theFptr), FTy->getPointerTo()),
+        theArgs);
+    if (theF)
+        result->setCallingConv(JLCALL_F_CC);
+    else
+        result->setCallingConv(JLCALL_CC);
     return result;
 }
 
-static jl_cgval_t emit_call_function_object(jl_method_instance_t *li, const jl_cgval_t &theF, jl_llvm_functions_t decls,
-                                            jl_value_t **args, size_t nargs, jl_value_t *callexpr, jl_codectx_t *ctx)
+
+static jl_cgval_t emit_call_function_object(jl_method_instance_t *li, jl_llvm_functions_t decls,
+                                            jl_cgval_t *argv, size_t nargs, jl_value_t *inferred_retty, jl_codectx_t &ctx)
 {
-    Value *theFptr = (Value*)decls.functionObject;
-    jl_value_t *inferred_retty = expr_type(callexpr, ctx);
     if (decls.specFunctionObject != NULL) {
         // emit specialized call site
         jl_value_t *jlretty = li->rettype;
-        bool retboxed;
-        (void)julia_type_to_llvm(jlretty, &retboxed);
-        Function *cf = cast<Function>(prepare_call((Function*)decls.specFunctionObject));
-        FunctionType *cft = cf->getFunctionType();
+        jl_returninfo_t returninfo = get_specsig_function(jl_Module, decls.specFunctionObject, li->specTypes, jlretty);
+        FunctionType *cft = returninfo.decl->getFunctionType();
+
         size_t nfargs = cft->getNumParams();
-        Value **argvals = (Value**) alloca(nfargs*sizeof(Value*));
-        bool sret = cf->hasStructRetAttr();
+        Value **argvals = (Value**)alloca(nfargs * sizeof(Value*));
         unsigned idx = 0;
-        Value *result;
-        if (sret) {
-            assert(!retboxed);
-            result = emit_static_alloca(cft->getParamType(0)->getContainedType(0), ctx);
+        AllocaInst *result;
+        switch (returninfo.cc) {
+        case jl_returninfo_t::Boxed:
+        case jl_returninfo_t::Register:
+        case jl_returninfo_t::Ghosts:
+            break;
+        case jl_returninfo_t::SRet:
+            result = emit_static_alloca(ctx, cft->getParamType(0)->getContainedType(0));
+            argvals[idx] = decay_derived(result);
+            idx++;
+            break;
+        case jl_returninfo_t::Union:
+            result = emit_static_alloca(ctx, ArrayType::get(T_int8, returninfo.union_bytes));
+            if (returninfo.union_align > 1)
+                result->setAlignment(returninfo.union_align);
             argvals[idx] = result;
             idx++;
+            break;
         }
-        SmallVector<Value*, 16> gc_uses;
-        for (size_t i = 0; i < nargs + 1; i++) {
-            jl_value_t *jt = jl_nth_slot_type(li->specTypes,i);
+
+        for (size_t i = 0; i < nargs; i++) {
+            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
-                if (i > 0)
-                    emit_expr(args[i], ctx);
+            if (type_is_ghost(et))
                 continue;
-            }
             assert(idx < nfargs);
             Type *at = cft->getParamType(idx);
+            const jl_cgval_t &arg = argv[i];
             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(at == T_prjlvalue && (et == T_pjlvalue || et == T_prjlvalue));
+                argvals[idx] = maybe_decay_untracked(boxed(ctx, arg));
             }
             else if (et->isAggregateType()) {
                 // can lazy load on demand, no copy needed
-                assert(at == PointerType::get(et, 0));
-                jl_cgval_t arg = i == 0 ? theF : emit_expr(args[i], ctx);
+                assert(at == PointerType::get(et, AddressSpace::Derived));
                 assert(arg.ispointer());
-                argvals[idx] = data_pointer(arg, ctx, at);
-                push_gc_use(gc_uses, arg);
+                argvals[idx] = decay_derived(data_pointer(ctx, arg, at));
             }
             else {
                 assert(at == et);
-                if (i == 0)
-                    argvals[idx] = emit_unbox(et, theF, jt);
-                else
-                    argvals[idx] = emit_unbox(et, emit_expr(args[i], ctx), jt);
+                argvals[idx] = emit_unbox(ctx, et, arg, jt);
             }
             idx++;
         }
         assert(idx == nfargs);
-        mark_gc_uses(gc_uses);
-        CallInst *call = builder.CreateCall(prepare_call(cf), ArrayRef<Value*>(&argvals[0], nfargs));
-        call->setAttributes(cf->getAttributes());
-        mark_gc_uses(gc_uses);
-        if (sret)
-            return mark_julia_slot(result, jlretty, tbaa_stack);
-        // see if codegen has a better type for the call than inference had at the time
-        if (!retboxed && jlretty != inferred_retty) {
-            inferred_retty = jlretty;
-        }
-        return mark_julia_type(call, retboxed, inferred_retty, ctx);
-    }
-    Value *ret = emit_jlcall(theFptr, boxed(theF, ctx), &args[1], nargs, ctx);
-    return mark_julia_type(ret, true, inferred_retty, ctx);
+        CallInst *call = ctx.builder.CreateCall(returninfo.decl, ArrayRef<Value*>(&argvals[0], nfargs));
+        call->setAttributes(returninfo.decl->getAttributes());
+
+        jl_cgval_t retval;
+        switch (returninfo.cc) {
+            case jl_returninfo_t::Boxed:
+                retval = mark_julia_type(ctx, call, true, inferred_retty);
+                break;
+            case jl_returninfo_t::Register:
+                retval = mark_julia_type(ctx, call, false, jlretty);
+                break;
+            case jl_returninfo_t::SRet:
+                retval = mark_julia_slot(result, jlretty, NULL, tbaa_stack);
+                break;
+            case jl_returninfo_t::Union: {
+                Value *box = ctx.builder.CreateExtractValue(call, 0);
+                Value *tindex = ctx.builder.CreateExtractValue(call, 1);
+                Value *derived = ctx.builder.CreateSelect(
+                    ctx.builder.CreateICmpEQ(
+                            ctx.builder.CreateAnd(tindex, ConstantInt::get(T_int8, 0x80)),
+                            ConstantInt::get(T_int8, 0)),
+                    decay_derived(ctx.builder.CreateBitCast(argvals[0], T_pjlvalue)),
+                    decay_derived(box)
+                );
+                retval = mark_julia_slot(derived,
+                                         jlretty,
+                                         tindex,
+                                         tbaa_stack);
+                // root this, if the return value was a box (tindex & 0x80) != 0
+                retval.gcroot = emit_local_root(ctx);
+                ctx.builder.CreateStore(box, retval.gcroot);
+                break;
+            }
+            case jl_returninfo_t::Ghosts:
+                retval = mark_julia_slot(NULL, jlretty, call, tbaa_stack);
+                break;
+        }
+        // see if inference has a different / better type for the call than the lambda
+        if (inferred_retty != retval.typ)
+            retval = update_julia_type(ctx, retval, inferred_retty);
+        return retval;
+    }
+    Value *theFptr = jl_Module->getOrInsertFunction(decls.functionObject, jl_func_sig);
+    Value *ret = emit_jlcall(ctx, theFptr, boxed(ctx, argv[0]), &argv[1], nargs - 1);
+    return mark_julia_type(ctx, ret, true, inferred_retty);
 }
 
-static jl_cgval_t emit_invoke(jl_expr_t *ex, jl_codectx_t *ctx)
+static jl_cgval_t emit_invoke(jl_codectx_t &ctx, jl_expr_t *ex)
 {
     jl_value_t **args = (jl_value_t**)jl_array_data(ex->args);
     size_t arglen = jl_array_dim0(ex->args);
     size_t nargs = arglen - 1;
+    jl_value_t *rt = ex->etype;
     assert(arglen >= 2);
 
-    jl_cgval_t lival = emit_expr(args[0], ctx);
+    jl_cgval_t lival = emit_expr(ctx, args[0]);
+    jl_cgval_t *argv = (jl_cgval_t*)alloca(sizeof(jl_cgval_t) * nargs);
+    for (size_t i = 0; i < nargs; ++i) {
+        argv[i] = emit_expr(ctx, args[i + 1]);
+    }
+
     if (lival.constant) {
         jl_method_instance_t *li = (jl_method_instance_t*)lival.constant;
         assert(jl_is_method_instance(li));
-        jl_llvm_functions_t decls = jl_compile_linfo(&li, NULL, ctx->world, ctx->params);
+        jl_llvm_functions_t decls = jl_compile_linfo(&li, NULL, ctx.world, ctx.params);
         if (li->jlcall_api == 2) {
-            assert(li->inferred);
-            return mark_julia_const(li->inferred);
+            assert(li->inferred_const);
+            return mark_julia_const(li->inferred_const);
         }
         if (decls.functionObject) {
             int jlcall_api = jl_jlcall_api(decls.functionObject);
             if (jlcall_api == 1) {
-                jl_cgval_t fval = emit_expr(args[1], ctx);
-                jl_cgval_t result = emit_call_function_object(li, fval, decls, &args[1], nargs - 1, (jl_value_t*)ex, ctx);
+                jl_cgval_t result = emit_call_function_object(li, decls, argv, nargs, rt, ctx);
                 if (result.typ == jl_bottom_type)
-                    CreateTrap(builder);
+                    CreateTrap(ctx.builder);
                 return result;
             }
         }
     }
     JL_FEAT_REQUIRE(ctx, runtime);
-    jl_cgval_t result = mark_julia_type(emit_jlcall(prepare_call(jlinvoke_func), boxed(lival, ctx, false),
-                                                    &args[1], nargs, ctx),
-                                        true, expr_type((jl_value_t*)ex, ctx), ctx);
+    jl_cgval_t result = mark_julia_type(ctx,
+            emit_jlcall(
+                ctx,
+                prepare_call(jlinvoke_func),
+                boxed(ctx, lival, false),
+                argv, nargs),
+            true,
+            rt);
     if (result.typ == jl_bottom_type)
-        CreateTrap(builder);
+        CreateTrap(ctx.builder);
     return result;
 }
 
-static jl_cgval_t emit_call(jl_expr_t *ex, jl_codectx_t *ctx)
+static jl_cgval_t emit_call(jl_codectx_t &ctx, jl_expr_t *ex)
 {
-    jl_value_t *expr = (jl_value_t*)ex;
     jl_value_t **args = (jl_value_t**)jl_array_data(ex->args);
-    size_t arglen = jl_array_dim0(ex->args);
-    size_t nargs = arglen - 1;
-    assert(arglen >= 1);
-    Value *theFptr = NULL;
-    jl_cgval_t result;
-
-    jl_function_t *f = (jl_function_t*)static_eval(args[0], ctx, true);
-    JL_GC_PUSH1(&f);
-    if (f != NULL) {
-        // function is a compile-time constant
-        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), ctx);
-            JL_GC_POP();
+    size_t nargs = jl_array_dim0(ex->args);
+    assert(nargs >= 1);
+    jl_value_t *rt = ex->etype;
+    jl_cgval_t f = emit_expr(ctx, args[0]);
+
+    if (f.constant && jl_typeis(f.constant, jl_intrinsic_type)) {
+        return emit_intrinsic(ctx, (intrinsic)*(uint32_t*)jl_data_ptr(f.constant), args, nargs - 1);
+    }
+
+    jl_cgval_t *argv = (jl_cgval_t*)alloca(sizeof(jl_cgval_t) * nargs);
+    argv[0] = f;
+    for (size_t i = 1; i < nargs; ++i) {
+        argv[i] = emit_expr(ctx, args[i]);
+        if (argv[i].typ == jl_bottom_type)
+            return jl_cgval_t(); // anything past here is unreachable
+    }
+
+    if (f.constant && jl_isa(f.constant, (jl_value_t*)jl_builtin_type)) {
+        jl_cgval_t result;
+        bool handled = emit_builtin_call(ctx, &result, f.constant, argv, nargs - 1, rt, ex);
+        if (handled) {
             return result;
         }
-        if (jl_isa(f, (jl_value_t*)jl_builtin_type)) {
-            bool handled = emit_builtin_call(&result, (jl_value_t*)f, args, nargs, ctx, expr);
-            if (handled) {
-                JL_GC_POP();
-                return result;
-            }
-        }
     }
 
     // special case for known builtin not handled by emit_builtin_call
-    if (f && jl_isa(f, (jl_value_t*)jl_builtin_type)) {
-        std::map<jl_fptr_t,Function*>::iterator it = builtin_func_map.find(jl_get_builtin_fptr(f));
+    if (f.constant && jl_isa(f.constant, (jl_value_t*)jl_builtin_type)) {
+        std::map<jl_fptr_t, Function*>::iterator it = builtin_func_map.find(jl_get_builtin_fptr(f.constant));
         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;
+            Value *theFptr = it->second;
+            Value *ret = emit_jlcall(ctx, theFptr, maybe_decay_untracked(V_null), &argv[1], nargs - 1);
+            return mark_julia_type(ctx, ret, true, rt);
         }
     }
 
@@ -3004,51 +2969,34 @@ static jl_cgval_t emit_call(jl_expr_t *ex, jl_codectx_t *ctx)
         if (jl_is_globalref(args[0]))
             name = jl_symbol_name(jl_globalref_name(args[0]));
         jl_errorf("generic call to %s requires the runtime language feature",
-                  name!=NULL ? name : "<unknown>");
+                  name ? name : "<unknown>");
     }
 
     // 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);
-#if JL_LLVM_VERSION >= 30700
-    Value *callval = builder.CreateCall(prepare_call(jlapplygeneric_func),
-                                 {myargs, ConstantInt::get(T_int32, nargs)});
-#else
-    Value *callval = builder.CreateCall2(prepare_call(jlapplygeneric_func),
-                                  myargs, ConstantInt::get(T_int32, nargs));
-#endif
-    result = mark_julia_type(callval, true, expr_type(expr, ctx), ctx);
-
-    JL_GC_POP();
-    return result;
+    Value *callval = emit_jlcall(ctx, jlapplygeneric_func, nullptr, argv, nargs);
+    return mark_julia_type(ctx, callval, true, rt);
 }
 
 // --- accessing and assigning variables ---
 
-static void undef_var_error_ifnot(Value *ok, jl_sym_t *name, jl_codectx_t *ctx)
+static void undef_var_error_ifnot(jl_codectx_t &ctx, Value *ok, jl_sym_t *name)
 {
-    BasicBlock *err = BasicBlock::Create(jl_LLVMContext, "err", ctx->f);
+    BasicBlock *err = BasicBlock::Create(jl_LLVMContext, "err", ctx.f);
     BasicBlock *ifok = BasicBlock::Create(jl_LLVMContext, "ok");
-    builder.CreateCondBr(ok, ifok, err);
-    builder.SetInsertPoint(err);
-    builder.CreateCall(prepare_call(jlundefvarerror_func), literal_pointer_val((jl_value_t*)name));
-    builder.CreateUnreachable();
-    ctx->f->getBasicBlockList().push_back(ifok);
-    builder.SetInsertPoint(ifok);
+    ctx.builder.CreateCondBr(ok, ifok, err);
+    ctx.builder.SetInsertPoint(err);
+    ctx.builder.CreateCall(prepare_call(jlundefvarerror_func),
+        mark_callee_rooted(literal_pointer_val(ctx, (jl_value_t*)name)));
+    ctx.builder.CreateUnreachable();
+    ctx.f->getBasicBlockList().push_back(ifok);
+    ctx.builder.SetInsertPoint(ifok);
 }
 
 // returns a jl_ppvalue_t location for the global variable m.s
 // if the reference currently bound or assign == true,
 //   pbnd will also be assigned with the binding address
-static Value *global_binding_pointer(jl_module_t *m, jl_sym_t *s,
-                                     jl_binding_t **pbnd, bool assign, jl_codectx_t *ctx)
+static Value *global_binding_pointer(jl_codectx_t &ctx, jl_module_t *m, jl_sym_t *s,
+                                     jl_binding_t **pbnd, bool assign)
 {
     jl_binding_t *b = NULL;
     if (assign) {
@@ -3062,70 +3010,67 @@ static Value *global_binding_pointer(jl_module_t *m, jl_sym_t *s,
             JL_FEAT_REQUIRE(ctx, runtime);
             std::stringstream name;
             name << "delayedvar" << globalUnique++;
-            Constant *initnul = ConstantPointerNull::get((PointerType*)T_pjlvalue);
-            GlobalVariable *bindinggv = new GlobalVariable(*ctx->f->getParent(), T_pjlvalue,
+            Constant *initnul = V_null;
+            GlobalVariable *bindinggv = new GlobalVariable(*ctx.f->getParent(), T_pjlvalue,
                     false, GlobalVariable::InternalLinkage,
                     initnul, name.str());
-            Value *cachedval = builder.CreateLoad(bindinggv);
+            Value *cachedval = ctx.builder.CreateLoad(bindinggv);
             BasicBlock *have_val = BasicBlock::Create(jl_LLVMContext, "found"),
                 *not_found = BasicBlock::Create(jl_LLVMContext, "notfound");
-            BasicBlock *currentbb = builder.GetInsertBlock();
-            builder.CreateCondBr(builder.CreateICmpNE(cachedval, initnul), have_val, not_found);
-            ctx->f->getBasicBlockList().push_back(not_found);
-            builder.SetInsertPoint(not_found);
-#if JL_LLVM_VERSION >= 30700
-            Value *bval = builder.CreateCall(prepare_call(jlgetbindingorerror_func),
-                                              {literal_pointer_val((jl_value_t*)m),
-                                              literal_pointer_val((jl_value_t*)s)});
-#else
-            Value *bval = builder.CreateCall2(prepare_call(jlgetbindingorerror_func),
-                                              literal_pointer_val((jl_value_t*)m),
-                                              literal_pointer_val((jl_value_t*)s));
-#endif
-            builder.CreateStore(bval, bindinggv);
-            builder.CreateBr(have_val);
-            ctx->f->getBasicBlockList().push_back(have_val);
-            builder.SetInsertPoint(have_val);
-            PHINode *p = builder.CreatePHI(T_pjlvalue, 2);
+            BasicBlock *currentbb = ctx.builder.GetInsertBlock();
+            ctx.builder.CreateCondBr(ctx.builder.CreateICmpNE(cachedval, initnul), have_val, not_found);
+            ctx.f->getBasicBlockList().push_back(not_found);
+            ctx.builder.SetInsertPoint(not_found);
+            Value *bval = ctx.builder.CreateCall(prepare_call(jlgetbindingorerror_func),
+                                              {maybe_decay_untracked(literal_pointer_val(ctx, (jl_value_t*)m)),
+                                              literal_pointer_val(ctx, (jl_value_t*)s)});
+            ctx.builder.CreateStore(bval, bindinggv);
+            ctx.builder.CreateBr(have_val);
+            ctx.f->getBasicBlockList().push_back(have_val);
+            ctx.builder.SetInsertPoint(have_val);
+            PHINode *p = ctx.builder.CreatePHI(T_pjlvalue, 2);
             p->addIncoming(cachedval, currentbb);
             p->addIncoming(bval, not_found);
-            return julia_binding_gv(emit_bitcast(p, T_ppjlvalue));
+            return julia_binding_gv(ctx, emit_bitcast(ctx, p, T_pprjlvalue));
         }
-        if (b->deprecated) cg_bdw(b, ctx);
+        if (b->deprecated)
+            cg_bdw(ctx, b);
     }
-    if (pbnd) *pbnd = b;
-    return julia_binding_gv(b);
+    if (pbnd)
+        *pbnd = b;
+    return julia_binding_gv(ctx, b);
 }
 
-static jl_cgval_t emit_checked_var(Value *bp, jl_sym_t *name, jl_codectx_t *ctx, bool isvol, MDNode *tbaa)
+static jl_cgval_t emit_checked_var(jl_codectx_t &ctx, Value *bp, jl_sym_t *name, bool isvol, MDNode *tbaa)
 {
-    assert(bp->getType() == T_ppjlvalue);
-    Instruction *v = builder.CreateLoad(bp, isvol);
+    assert(bp->getType() == T_pprjlvalue);
+    Instruction *v = ctx.builder.CreateLoad(bp, isvol);
     if (tbaa)
         tbaa_decorate(tbaa, v);
-    undef_var_error_ifnot(builder.CreateICmpNE(v, V_null), name, ctx);
-    return mark_julia_type(v, true, jl_any_type, ctx);
+    undef_var_error_ifnot(ctx, ctx.builder.CreateICmpNE(v, maybe_decay_untracked(V_null)), name);
+    return mark_julia_type(ctx, v, true, jl_any_type);
 }
 
-static jl_cgval_t emit_sparam(size_t i, jl_codectx_t *ctx)
+static jl_cgval_t emit_sparam(jl_codectx_t &ctx, size_t i)
 {
-    if (jl_svec_len(ctx->linfo->sparam_vals) > 0) {
-        jl_value_t *e = jl_svecref(ctx->linfo->sparam_vals, i);
+    if (jl_svec_len(ctx.linfo->sparam_vals) > 0) {
+        jl_value_t *e = jl_svecref(ctx.linfo->sparam_vals, i);
         if (!jl_is_typevar(e)) {
             return mark_julia_const(e);
         }
     }
-    assert(ctx->spvals_ptr != NULL);
-    Value *bp = builder.CreateConstInBoundsGEP1_32(LLVM37_param(T_pjlvalue)
-            emit_bitcast(ctx->spvals_ptr, T_ppjlvalue),
+    assert(ctx.spvals_ptr != NULL);
+    Value *bp = ctx.builder.CreateConstInBoundsGEP1_32(
+            T_prjlvalue,
+            ctx.spvals_ptr,
             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, false);
+    return mark_julia_type(ctx, tbaa_decorate(tbaa_const, ctx.builder.CreateLoad(bp)), true, jl_any_type, false);
 }
 
-static jl_cgval_t emit_global(jl_sym_t *sym, jl_codectx_t *ctx)
+static jl_cgval_t emit_global(jl_codectx_t &ctx, jl_sym_t *sym)
 {
-    jl_binding_t *jbp=NULL;
-    Value *bp = global_binding_pointer(ctx->module, sym, &jbp, false, ctx);
+    jl_binding_t *jbp = NULL;
+    Value *bp = global_binding_pointer(ctx, ctx.module, sym, &jbp, false);
     assert(bp != NULL);
     if (jbp && jbp->value != NULL) {
         if (jbp->constp)
@@ -3133,16 +3078,84 @@ static jl_cgval_t emit_global(jl_sym_t *sym, jl_codectx_t *ctx)
         // 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(tbaa_decorate(tbaa_binding, builder.CreateLoad(bp)), true, jl_any_type, ctx);
+        return mark_julia_type(ctx, tbaa_decorate(tbaa_binding, ctx.builder.CreateLoad(bp)), true, jl_any_type);
+    }
+    return emit_checked_var(ctx, bp, sym, false, tbaa_binding);
+}
+
+static jl_cgval_t emit_isdefined(jl_codectx_t &ctx, jl_value_t *sym)
+{
+    Value *isnull;
+    if (jl_is_slot(sym)) {
+        size_t sl = jl_slot_number(sym) - 1;
+        jl_varinfo_t &vi = ctx.slots[sl];
+        if (!vi.usedUndef)
+            return mark_julia_const(jl_true);
+        if (vi.boxroot == NULL || vi.pTIndex != NULL) {
+            assert(vi.defFlag);
+            isnull = ctx.builder.CreateLoad(vi.defFlag, vi.isVolatile);
+        }
+        if (vi.boxroot != NULL) {
+            Value *boxed = ctx.builder.CreateLoad(vi.boxroot, vi.isVolatile);
+            Value *box_isnull = ctx.builder.CreateICmpNE(boxed, maybe_decay_untracked(V_null));
+            if (vi.pTIndex) {
+                // value is either boxed in the stack slot, or unboxed in value
+                // as indicated by testing (pTIndex & 0x80)
+                Value *tindex = ctx.builder.CreateLoad(vi.pTIndex, vi.isVolatile);
+                Value *load_unbox = ctx.builder.CreateICmpEQ(
+                            ctx.builder.CreateAnd(tindex, ConstantInt::get(T_int8, 0x80)),
+                            ConstantInt::get(T_int8, 0));
+                isnull = ctx.builder.CreateSelect(load_unbox, isnull, box_isnull);
+            }
+            else {
+                isnull = box_isnull;
+            }
+        }
+    }
+    else if (jl_is_expr(sym)) {
+        assert(((jl_expr_t*)sym)->head == static_parameter_sym && "malformed isdefined expression");
+        size_t i = jl_unbox_long(jl_exprarg(sym, 0)) - 1;
+        (void)i;
+        return mark_julia_const(jl_true);
+    }
+    else {
+        jl_module_t *modu;
+        jl_sym_t *name;
+        if (jl_is_globalref(sym)) {
+            modu = jl_globalref_mod(sym);
+            name = jl_globalref_name(sym);
+        }
+        else {
+            assert(jl_is_symbol(sym) && "malformed isdefined expression");
+            modu = ctx.module;
+            name = (jl_sym_t*)sym;
+        }
+        jl_binding_t *bnd = jl_get_binding(modu, name);
+        if (bnd) {
+            if (bnd->value != NULL)
+                return mark_julia_const(jl_true);
+            Value *bp = julia_binding_gv(ctx, bnd);
+            Instruction *v = ctx.builder.CreateLoad(bp);
+            tbaa_decorate(tbaa_binding, v);
+            isnull = ctx.builder.CreateICmpNE(v, V_null);
+        }
+        else {
+            Value *v = ctx.builder.CreateCall(prepare_call(jlboundp_func), {
+                    literal_pointer_val(ctx, (jl_value_t*)modu),
+                    literal_pointer_val(ctx, (jl_value_t*)name)
+                });
+            isnull = ctx.builder.CreateICmpNE(v, ConstantInt::get(T_int32, 0));
+        }
     }
-    return emit_checked_var(bp, sym, ctx, false, tbaa_binding);
+    return mark_julia_type(ctx, isnull, false, jl_bool_type);
 }
 
-static jl_cgval_t emit_local(jl_value_t *slotload, jl_codectx_t *ctx)
+static jl_cgval_t emit_local(jl_codectx_t &ctx, jl_value_t *slotload)
 {
     size_t sl = jl_slot_number(slotload) - 1;
-    jl_varinfo_t &vi = ctx->slots[sl];
-    jl_sym_t *sym = slot_symbol(sl, ctx);
+    jl_varinfo_t &vi = ctx.slots[sl];
+    assert(!(ctx.vaStack && (int)sl == ctx.vaSlot && "error in escape analysis"));
+    jl_sym_t *sym = slot_symbol(ctx, sl);
     jl_value_t *typ;
     if (jl_typeis(slotload, jl_typedslot_type)) {
         // use the better type from inference for this load
@@ -3157,67 +3170,208 @@ static jl_cgval_t emit_local(jl_value_t *slotload, jl_codectx_t *ctx)
 
     jl_cgval_t v;
     Value *isnull = NULL;
-    if (vi.boxroot == NULL) {
-        if (!vi.isVolatile || vi.value.constant) {
+    if (vi.boxroot == NULL || vi.pTIndex != NULL) {
+        if (!vi.isVolatile || vi.value.constant || !vi.value.V) {
             v = vi.value;
+            if (vi.pTIndex)
+                v.TIndex = ctx.builder.CreateLoad(vi.pTIndex);
         }
         else {
             // copy value to a non-volatile location
             AllocaInst *volatile_slot = cast<AllocaInst>(vi.value.V);
             Type *T = volatile_slot->getAllocatedType();
             assert(!volatile_slot->isArrayAllocation() && "variables not expected to be VLA");
-            AllocaInst *slot = emit_static_alloca(T, ctx);
+            AllocaInst *slot = emit_static_alloca(ctx, T);
             // TODO: emit memcpy instead
-            Value *unbox = builder.CreateLoad(vi.value.V, /*volatile*/true);
-            builder.CreateStore(unbox, slot);
-            v = mark_julia_slot(slot, vi.value.typ, tbaa_stack);
-        }
+            Value *unbox = ctx.builder.CreateLoad(vi.value.V, /*volatile*/true);
+            ctx.builder.CreateStore(unbox, slot);
+            Value *tindex = NULL;
+            if (vi.pTIndex)
+                tindex = ctx.builder.CreateLoad(vi.pTIndex, /*volatile*/true);
+            v = mark_julia_slot(slot, vi.value.typ, tindex, tbaa_stack);
+        }
+        if (vi.boxroot == NULL)
+            v = update_julia_type(ctx, v, typ);
         if (vi.usedUndef) {
             assert(vi.defFlag);
-            isnull = builder.CreateLoad(vi.defFlag, vi.isVolatile);
+            isnull = ctx.builder.CreateLoad(vi.defFlag, vi.isVolatile);
         }
     }
-    else {
-        Value *boxed = builder.CreateLoad(vi.boxroot, vi.isVolatile);
-        v = mark_julia_type(boxed, true, typ, ctx,
-                            /*gc-root*/!vi.isArgument); // if an argument, doesn't need an additional root
+    if (vi.boxroot != NULL) {
+        Value *boxed = ctx.builder.CreateLoad(vi.boxroot, vi.isVolatile);
+        Value *box_isnull;
+        v.gcroot = vi.boxroot;
         if (vi.usedUndef)
-            isnull = builder.CreateICmpNE(boxed, V_null);
+            box_isnull = ctx.builder.CreateICmpNE(boxed, maybe_decay_untracked(V_null));
+        if (vi.pTIndex) {
+            // value is either boxed in the stack slot, or unboxed in value
+            // as indicated by testing (pTIndex & 0x80)
+            Value *load_unbox = ctx.builder.CreateICmpEQ(
+                        ctx.builder.CreateAnd(v.TIndex, ConstantInt::get(T_int8, 0x80)),
+                        ConstantInt::get(T_int8, 0));
+            if (vi.usedUndef)
+                isnull = ctx.builder.CreateSelect(load_unbox, isnull, box_isnull);
+            if (v.V) { // v.V will be null if it is a union of all ghost values
+                boxed = decay_derived(boxed);
+                v.V = ctx.builder.CreateSelect(load_unbox, emit_bitcast(ctx,
+                    decay_derived(v.V), boxed->getType()), boxed);
+            } else
+                v.V = boxed;
+            v = update_julia_type(ctx, v, typ);
+        }
+        else {
+            v = mark_julia_type(ctx, boxed, true, typ,
+                                /*gc-root*/!vi.isArgument); // if an argument, doesn't need an additional root
+            if (vi.usedUndef)
+                isnull = box_isnull;
+        }
     }
     if (isnull)
-        undef_var_error_ifnot(isnull, sym, ctx);
+        undef_var_error_ifnot(ctx, isnull, sym);
     return v;
 }
 
 
-static void emit_assignment(jl_value_t *l, jl_value_t *r, jl_codectx_t *ctx)
+static void union_alloca_type(jl_uniontype_t *ut,
+        bool &allunbox, size_t &nbytes, size_t &align, size_t &min_align)
+{
+    nbytes = 0;
+    align = 0;
+    min_align = MAX_ALIGN;
+    // compute the size of the union alloca that could hold this type
+    unsigned counter = 0;
+    allunbox = for_each_uniontype_small(
+            [&](unsigned idx, jl_datatype_t *jt) {
+                if (!jl_is_datatype_singleton(jt)) {
+                    size_t nb1 = jl_datatype_size(jt);
+                    size_t align1 = jl_datatype_align(jt);
+                    if (nb1 > nbytes)
+                        nbytes = nb1;
+                    if (align1 > align)
+                        align = align1;
+                    if (align1 < min_align)
+                        min_align = align1;
+                }
+            },
+            (jl_value_t*)ut,
+            counter);
+}
+
+static Value *try_emit_union_alloca(jl_codectx_t &ctx, jl_uniontype_t *ut, bool &allunbox, size_t &min_align)
+{
+    size_t nbytes, align;
+    union_alloca_type(ut, allunbox, nbytes, align, min_align);
+    if (nbytes > 0) {
+        // at least some of the values can live on the stack
+        // try to pick an Integer type size such that SROA will emit reasonable code
+        Type *AT = ArrayType::get(IntegerType::get(jl_LLVMContext, 8 * min_align), (nbytes + min_align - 1) / min_align);
+        AllocaInst *lv = emit_static_alloca(ctx, AT);
+        if (align > 1)
+            lv->setAlignment(align);
+        return lv;
+    }
+    return NULL;
+}
+
+static Value *compute_box_tindex(jl_codectx_t &ctx, Value *datatype, jl_value_t *supertype, jl_value_t *ut)
+{
+    Value *tindex = ConstantInt::get(T_int8, 0);
+    unsigned counter = 0;
+    for_each_uniontype_small(
+            [&](unsigned idx, jl_datatype_t *jt) {
+                if (jl_subtype((jl_value_t*)jt, supertype)) {
+                    Value *cmp = ctx.builder.CreateICmpEQ(maybe_decay_untracked(literal_pointer_val(ctx, (jl_value_t*)jt)), datatype);
+                    tindex = ctx.builder.CreateSelect(cmp, ConstantInt::get(T_int8, idx), tindex);
+                }
+            },
+            ut,
+            counter);
+    return tindex;
+}
+
+// get the runtime tindex value
+static Value *compute_tindex_unboxed(jl_codectx_t &ctx, const jl_cgval_t &val, jl_value_t *typ)
+{
+    if (val.constant)
+        return ConstantInt::get(T_int8, get_box_tindex((jl_datatype_t*)jl_typeof(val.constant), typ));
+    if (val.isboxed)
+        return compute_box_tindex(ctx, emit_typeof_boxed(ctx, val), val.typ, typ);
+    assert(val.TIndex);
+    return ctx.builder.CreateAnd(val.TIndex, ConstantInt::get(T_int8, 0x7f));
+}
+
+static void emit_assignment(jl_codectx_t &ctx, jl_value_t *l, jl_value_t *r)
 {
     if (jl_is_ssavalue(l)) {
         ssize_t idx = ((jl_ssavalue_t*)l)->id;
         assert(idx >= 0);
-        assert(!ctx->ssavalue_assigned.at(idx));
-        jl_cgval_t slot = emit_expr(r, ctx); // slot could be a jl_value_t (unboxed) or jl_value_t* (ispointer)
-        if (slot.isboxed) {
-            // see if inference had a better type for the ssavalue than the expression (after inlining getfield on a Tuple)
-            jl_value_t *ssavalue_types = (jl_value_t*)ctx->source->ssavaluetypes;
+        assert(!ctx.ssavalue_assigned.at(idx));
+        jl_cgval_t slot = emit_expr(ctx, r); // slot could be a jl_value_t (unboxed) or jl_value_t* (ispointer)
+        if (slot.isboxed || slot.TIndex) {
+            // see if inference suggested a different type for the ssavalue than the expression
+            // e.g. sometimes the information is inconsistent after inlining getfield on a Tuple
+            jl_value_t *ssavalue_types = (jl_value_t*)ctx.source->ssavaluetypes;
             if (jl_is_array(ssavalue_types)) {
                 jl_value_t *declType = jl_array_ptr_ref(ssavalue_types, idx);
                 if (declType != slot.typ) {
-                    slot = remark_julia_type(slot, declType, ctx);
+                    slot = update_julia_type(ctx, slot, declType);
                 }
             }
         }
         if (!slot.isboxed && !slot.isimmutable) {
             // emit a copy of values stored in mutable slots
-            bool isboxed;
-            Type *vtype = julia_type_to_llvm(slot.typ, &isboxed);
-            assert(!isboxed);
-            Value *dest = emit_static_alloca(vtype);
-            emit_unbox(vtype, slot, slot.typ, dest);
-            slot = mark_julia_slot(dest, slot.typ, tbaa_stack);
+            Value *dest;
+            jl_value_t *jt = slot.typ;
+            if (jl_is_uniontype(jt)) {
+                assert(slot.TIndex && "Unboxed union must have a type-index.");
+                bool allunbox;
+                size_t min_align;
+                dest = try_emit_union_alloca(ctx, ((jl_uniontype_t*)jt), allunbox, min_align);
+                Value *isboxed = NULL;
+                if (slot.ispointer() && slot.V != NULL && !isa<AllocaInst>(slot.V)) {
+                    isboxed = ctx.builder.CreateICmpNE(
+                            ctx.builder.CreateAnd(slot.TIndex, ConstantInt::get(T_int8, 0x80)),
+                            ConstantInt::get(T_int8, 0));
+                }
+                if (dest)
+                    emit_unionmove(ctx, dest, slot, isboxed, false, NULL);
+                Value *gcroot = NULL;
+                if (isboxed) {
+                    Value *box;
+                    if (slot.gcroot) {
+                        gcroot = emit_local_root(ctx);
+                        // This might load the wrong object in general, but if it gets selected, below,
+                        // we know that it was in fact the one we wanted.
+                        box = ctx.builder.CreateLoad(slot.gcroot);
+                    } else {
+                        gcroot = emit_static_alloca(ctx, T_pjlvalue);
+                        box = V_null;
+                    }
+                    ctx.builder.CreateStore(box, gcroot);
+                    if (dest) // might be all ghost values
+                        dest = ctx.builder.CreateSelect(isboxed,
+                            decay_derived(box),
+                            emit_bitcast(ctx, decay_derived(dest), box->getType()));
+                    else
+                        dest = box;
+                }
+                else {
+                    assert(allunbox && "Failed to allocate correct union-type storage.");
+                }
+                slot = mark_julia_slot(dest, slot.typ, slot.TIndex, tbaa_stack);
+                slot.gcroot = gcroot;
+            }
+            else {
+                bool isboxed;
+                Type *vtype = julia_type_to_llvm(slot.typ, &isboxed);
+                assert(!isboxed);
+                dest = emit_static_alloca(ctx, vtype);
+                emit_unbox(ctx, vtype, slot, slot.typ, dest);
+                slot = mark_julia_slot(dest, slot.typ, NULL, tbaa_stack);
+            }
         }
-        ctx->SAvalues.at(idx) = slot; // now SAvalues[idx] contains the SAvalue
-        ctx->ssavalue_assigned.at(idx) = true;
+        ctx.SAvalues.at(idx) = slot; // now SAvalues[idx] contains the SAvalue
+        ctx.ssavalue_assigned.at(idx) = true;
         return;
     }
 
@@ -3227,24 +3381,18 @@ static void emit_assignment(jl_value_t *l, jl_value_t *r, jl_codectx_t *ctx)
     if (jl_is_symbol(l))
         s = (jl_sym_t*)l;
     else if (jl_is_globalref(l))
-        bp = global_binding_pointer(jl_globalref_mod(l), jl_globalref_name(l), &bnd, true, ctx); // now bp != NULL
+        bp = global_binding_pointer(ctx, jl_globalref_mod(l), jl_globalref_name(l), &bnd, true); // now bp != NULL
     else
         assert(jl_is_slot(l));
     if (bp == NULL && s != NULL)
-        bp = global_binding_pointer(ctx->module, s, &bnd, true, ctx);
+        bp = global_binding_pointer(ctx, ctx.module, s, &bnd, true);
     if (bp != NULL) { // it's a global
         JL_FEAT_REQUIRE(ctx, runtime);
         assert(bnd);
-        Value *rval = boxed(emit_expr(r, ctx), ctx, false); // no root needed since this is about to be assigned to a global
-#if JL_LLVM_VERSION >= 30700
-        builder.CreateCall(prepare_call(jlcheckassign_func),
-                           {literal_pointer_val(bnd),
-                            rval});
-#else
-        builder.CreateCall2(prepare_call(jlcheckassign_func),
-                           literal_pointer_val(bnd),
-                            rval);
-#endif
+        Value *rval = mark_callee_rooted(boxed(ctx, emit_expr(ctx, r), false)); // no root needed since this is about to be assigned to a global
+        ctx.builder.CreateCall(prepare_call(jlcheckassign_func),
+                           { literal_pointer_val(ctx, bnd),
+                             rval });
         // Global variable. Does not need debug info because the debugger knows about
         // its memory location.
         return;
@@ -3252,71 +3400,169 @@ static void emit_assignment(jl_value_t *l, jl_value_t *r, jl_codectx_t *ctx)
 
     int sl = jl_slot_number(l) - 1;
     // it's a local variable
-    jl_varinfo_t &vi = ctx->slots[sl];
-    jl_cgval_t rval_info = emit_expr(r, ctx);
+    jl_varinfo_t &vi = ctx.slots[sl];
+    jl_cgval_t rval_info = emit_expr(ctx, r);
     if (!vi.used)
         return;
 
+    bool needs_root = false;
+    if ((!vi.isSA && rval_info.gcroot) || !rval_info.isboxed)
+        // rval needed a gcroot, so lval will need one too
+        needs_root = true;
+
+    // convert rval-type to lval-type
+    jl_value_t *slot_type = vi.value.typ;
+    rval_info = convert_julia_type(ctx, rval_info, slot_type, /*needs-root*/true);
+    if (rval_info.typ == jl_bottom_type)
+        return;
+
     // add info to arrayvar 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);
+        jl_arrayvar_t *av = arrayvar_for(ctx, l);
         if (av != NULL)
-            assign_arrayvar(*av, rval_info, ctx);
+            assign_arrayvar(ctx, *av, rval_info);
+    }
+
+    // compute / store tindex info
+    if (vi.pTIndex) {
+        Value *tindex;
+        if (rval_info.TIndex) {
+            tindex = rval_info.TIndex;
+            if (!vi.boxroot)
+                tindex = ctx.builder.CreateAnd(tindex, ConstantInt::get(T_int8, 0x7f));
+        }
+        else {
+            assert(rval_info.isboxed || rval_info.constant);
+            tindex = compute_tindex_unboxed(ctx, rval_info, vi.value.typ);
+            if (vi.boxroot)
+                tindex = ctx.builder.CreateOr(tindex, ConstantInt::get(T_int8, 0x80));
+            if (!vi.boxroot)
+                rval_info.TIndex = tindex;
+        }
+        ctx.builder.CreateStore(tindex, vi.pTIndex, vi.isVolatile);
     }
 
+    // store boxed variables
+    Value *isboxed = NULL;
     if (vi.boxroot) {
-        // boxed variables
-        if (((!vi.isSA && rval_info.gcroot) || !rval_info.isboxed) && isa<AllocaInst>(vi.boxroot)) {
-            // rval had a gcroot, so lval needs one too: promote variable slot to a gcroot
-            emit_local_root(ctx, &vi);
+        if (isa<AllocaInst>(vi.boxroot) && needs_root)
+            emit_local_root(ctx, &vi); // promote variable slot to a gcroot
+        Value *rval;
+        if (vi.pTIndex && rval_info.TIndex) {
+            ctx.builder.CreateStore(rval_info.TIndex, vi.pTIndex, vi.isVolatile);
+            isboxed = ctx.builder.CreateICmpNE(
+                    ctx.builder.CreateAnd(rval_info.TIndex, ConstantInt::get(T_int8, 0x80)),
+                    ConstantInt::get(T_int8, 0));
+            rval = maybe_decay_untracked(V_null);
+            if (rval_info.ispointer() && rval_info.V != NULL && !isa<AllocaInst>(rval_info.V) &&
+                !(isa<Constant>(isboxed) && cast<ConstantInt>(isboxed)->isZero())) // might be all ghost values or otherwise definitely not boxed
+                rval = ctx.builder.CreateLoad(rval_info.gcroot);
+            assert(!vi.value.constant);
+        }
+        else {
+            assert(!vi.pTIndex || rval_info.isboxed || rval_info.constant);
+            rval = maybe_decay_untracked(boxed(ctx, rval_info, false));
         }
-        Value *rval = boxed(rval_info, ctx, false); // no root needed on the temporary since it is about to be assigned to the variable slot
-        builder.CreateStore(rval, vi.boxroot, vi.isVolatile);
+        ctx.builder.CreateStore(maybe_decay_untracked(rval), vi.boxroot, vi.isVolatile);
     }
-    else {
+
+    // store unboxed variables
+    if (!vi.boxroot || (vi.pTIndex && rval_info.TIndex)) {
         if (vi.usedUndef)
-            store_def_flag(vi, true);
+            store_def_flag(ctx, vi, true);
 
-        if (vi.value.constant) {
-            // virtual store
+        if (!vi.value.constant) { // check that this is not a virtual store
+            assert(vi.value.ispointer() || (vi.pTIndex && vi.value.V == NULL));
+            // store value
+            if (vi.value.V == NULL) {
+                // all ghost values in destination - nothing to copy or store
+            }
+            else if (rval_info.constant || !rval_info.ispointer()) {
+                if (rval_info.isghost) {
+                    // all ghost values in source - nothing to copy or store
+                }
+                else {
+                    if (rval_info.typ != vi.value.typ && !vi.pTIndex && !rval_info.TIndex) {
+                        // isbits cast-on-assignment is invalid. this branch should be dead-code.
+                        CreateTrap(ctx.builder);
+                    }
+                    else {
+                        Value *dest = vi.value.V;
+                        if (vi.pTIndex)
+                            ctx.builder.CreateStore(UndefValue::get(cast<AllocaInst>(vi.value.V)->getAllocatedType()), vi.value.V);
+                        Type *store_ty = julia_type_to_llvm(rval_info.constant ? jl_typeof(rval_info.constant) : rval_info.typ);
+                        Type *dest_ty = store_ty->getPointerTo();
+                        if (dest_ty != dest->getType())
+                            dest = emit_bitcast(ctx, dest, dest_ty);
+                        tbaa_decorate(tbaa_stack, ctx.builder.CreateStore(
+                                          emit_unbox(ctx, store_ty, rval_info, rval_info.typ),
+                                          dest,
+                                          vi.isVolatile));
+                    }
+                }
+            }
+            else {
+                MDNode *tbaa = rval_info.tbaa;
+                // the memcpy intrinsic does not allow to specify different alias tags
+                // for the load part (x.tbaa) and the store part (tbaa_stack).
+                // since the tbaa lattice has to be a tree we have unfortunately
+                // x.tbaa ∪ tbaa_stack = tbaa_root if x.tbaa != tbaa_stack
+                if (tbaa != tbaa_stack)
+                    tbaa = NULL;
+                if (vi.pTIndex == NULL) {
+                    assert(jl_is_concrete_type(vi.value.typ));
+                    Value *copy_bytes = ConstantInt::get(T_int32, jl_datatype_size(vi.value.typ));
+                    ctx.builder.CreateMemCpy(vi.value.V,
+                                         data_pointer(ctx, rval_info, T_pint8),
+                                         copy_bytes,
+                                         jl_datatype_align(rval_info.typ),
+                                         vi.isVolatile,
+                                         tbaa);
+                }
+                else {
+                    emit_unionmove(ctx, vi.value.V, rval_info, isboxed, vi.isVolatile, tbaa);
+                }
+            }
         }
         else {
-            // store unboxed
-            assert(vi.value.ispointer());
-            emit_unbox(julia_type_to_llvm(vi.value.typ), rval_info, vi.value.typ, vi.value.V, vi.isVolatile);
+            assert(vi.pTIndex == NULL);
         }
     }
 }
 
 // --- convert expression to code ---
 
-static Value *emit_condition(const jl_cgval_t &condV, const std::string &msg,
-                             jl_codectx_t *ctx)
+static Value *emit_condition(jl_codectx_t &ctx, const jl_cgval_t &condV, const std::string &msg)
 {
     bool isbool = (condV.typ == (jl_value_t*)jl_bool_type);
     if (!isbool) {
-        emit_typecheck(condV, (jl_value_t*)jl_bool_type, msg, ctx);
+        if (condV.TIndex) {
+            // check whether this might be bool
+            isbool = jl_subtype((jl_value_t*)jl_bool_type, condV.typ);
+        }
+        emit_typecheck(ctx, condV, (jl_value_t*)jl_bool_type, msg);
     }
     if (isbool) {
-        Value *cond = emit_unbox(T_int8, condV, (jl_value_t*)jl_bool_type);
+        Value *cond = emit_unbox(ctx, T_int8, condV, (jl_value_t*)jl_bool_type);
         assert(cond->getType() == T_int8);
-        return builder.CreateXor(builder.CreateTrunc(cond, T_int1), ConstantInt::get(T_int1, 1));
+        return ctx.builder.CreateXor(ctx.builder.CreateTrunc(cond, T_int1), ConstantInt::get(T_int1, 1));
     }
     if (condV.isboxed) {
-        return builder.CreateICmpEQ(boxed(condV, ctx), literal_pointer_val(jl_false));
+        return ctx.builder.CreateICmpEQ(boxed(ctx, condV),
+            maybe_decay_untracked(literal_pointer_val(ctx, jl_false)));
     }
     // not a boolean
     return ConstantInt::get(T_int1, 0); // TODO: replace with Undef
 }
 
-static Value *emit_condition(jl_value_t *cond, const std::string &msg, jl_codectx_t *ctx)
+static Value *emit_condition(jl_codectx_t &ctx, jl_value_t *cond, const std::string &msg)
 {
-    return emit_condition(emit_expr(cond, ctx), msg, ctx);
+    return emit_condition(ctx, emit_expr(ctx, cond), msg);
 }
 
-static void emit_stmtpos(jl_value_t *expr, jl_codectx_t *ctx)
+static void emit_stmtpos(jl_codectx_t &ctx, jl_value_t *expr)
 {
     if (jl_is_ssavalue(expr))
         return; // value not used, no point in attempting codegen for it
@@ -3324,27 +3570,27 @@ static void emit_stmtpos(jl_value_t *expr, jl_codectx_t *ctx)
         return;
     if (jl_is_slot(expr)) {
         size_t sl = jl_slot_number(expr) - 1;
-        jl_varinfo_t &vi = ctx->slots[sl];
+        jl_varinfo_t &vi = ctx.slots[sl];
         if (vi.usedUndef)
-            (void)emit_expr(expr, ctx);
+            (void)emit_expr(ctx, expr);
         return;
     }
     if (jl_is_newvarnode(expr)) {
         jl_value_t *var = jl_fieldref(expr, 0);
         assert(jl_is_slot(var));
-        jl_varinfo_t &vi = ctx->slots[jl_slot_number(var)-1];
+        jl_varinfo_t &vi = ctx.slots[jl_slot_number(var)-1];
         if (vi.usedUndef) {
             // create a new uninitialized variable
             Value *lv = vi.boxroot;
             if (lv != NULL)
-                builder.CreateStore(V_null, lv);
-            else
-                store_def_flag(vi, false);
+                ctx.builder.CreateStore(maybe_decay_untracked(V_null), lv);
+            if (lv == NULL || vi.pTIndex != NULL)
+                store_def_flag(ctx, vi, false);
         }
         return;
     }
     if (!jl_is_expr(expr)) {
-        (void)emit_expr(expr, ctx);
+        (void)emit_expr(ctx, expr);
         return;
     }
     jl_expr_t *ex = (jl_expr_t*)expr;
@@ -3359,49 +3605,50 @@ static void emit_stmtpos(jl_value_t *expr, jl_codectx_t *ctx)
     else if (head == leave_sym) {
         assert(jl_is_long(args[0]));
         JL_FEAT_REQUIRE(ctx, runtime);
-        builder.CreateCall(prepare_call(jlleave_func),
+        ctx.builder.CreateCall(prepare_call(jlleave_func),
                            ConstantInt::get(T_int32, jl_unbox_long(args[0])));
     }
     else {
-        if (ctx->linfo->def == NULL) {
-            Value *world = builder.CreateLoad(prepare_global(jlgetworld_global));
-            builder.CreateStore(world, ctx->world_age_field);
+        if (!jl_is_method(ctx.linfo->def.method)) {
+            // TODO: inference is invalid if this has an effect
+            Value *world = ctx.builder.CreateLoad(prepare_global(jlgetworld_global));
+            ctx.builder.CreateStore(world, ctx.world_age_field);
         }
-        (void)emit_expr(expr, ctx);
+        (void)emit_expr(ctx, expr);
     }
 }
 
-static jl_cgval_t emit_expr(jl_value_t *expr, jl_codectx_t *ctx)
+static jl_cgval_t emit_expr(jl_codectx_t &ctx, jl_value_t *expr)
 {
     if (jl_is_symbol(expr)) {
         jl_sym_t *sym = (jl_sym_t*)expr;
-        return emit_global(sym, ctx);
+        return emit_global(ctx, sym);
     }
     if (jl_is_slot(expr)) {
-        return emit_local(expr, ctx);
+        return emit_local(ctx, expr);
     }
     if (jl_is_ssavalue(expr)) {
         ssize_t idx = ((jl_ssavalue_t*)expr)->id;
         assert(idx >= 0);
-        if (!ctx->ssavalue_assigned.at(idx)) {
-            ctx->ssavalue_assigned.at(idx) = true; // (assignment, not comparison test)
+        if (!ctx.ssavalue_assigned.at(idx)) {
+            ctx.ssavalue_assigned.at(idx) = true; // (assignment, not comparison test)
             return jl_cgval_t(); // dead code branch
         }
         else {
-            return ctx->SAvalues.at(idx); // at this point, SAvalues[idx] actually contains the SAvalue
+            return ctx.SAvalues.at(idx); // at this point, SAvalues[idx] actually contains the SAvalue
         }
     }
     if (jl_is_globalref(expr)) {
-        return emit_getfield((jl_value_t*)jl_globalref_mod(expr), jl_globalref_name(expr), ctx);
+        return emit_globalref(ctx, jl_globalref_mod(expr), jl_globalref_name(expr));
     }
     if (jl_is_labelnode(expr)) {
-        jl_error("Labelnode in value position");
+        jl_error("LabelNode in value position");
     }
     if (jl_is_linenode(expr)) {
-        jl_error("Linenode in value position");
+        jl_error("LineNumberNode in value position");
     }
     if (jl_is_gotonode(expr)) {
-        jl_error("Gotonode in value position");
+        jl_error("GotoNode in value position");
     }
     if (!jl_is_expr(expr)) {
         int needroot = true;
@@ -3425,7 +3672,7 @@ static jl_cgval_t emit_expr(jl_value_t *expr, jl_codectx_t *ctx)
                 expr = jl_box_int64(val);
             }
         }
-        if (needroot && ctx->linfo->def) { // toplevel exprs and some integers are already rooted
+        if (needroot && jl_is_method(ctx.linfo->def.method)) { // toplevel exprs and some integers are already rooted
             jl_add_method_root(ctx, expr);
         }
         return mark_julia_const(expr);
@@ -3437,38 +3684,32 @@ static jl_cgval_t emit_expr(jl_value_t *expr, jl_codectx_t *ctx)
     // this is object-disoriented.
     // however, this is a good way to do it because it should *not* be easy
     // to add new node types.
-    if (head == invoke_sym) {
-        return emit_invoke(ex, ctx);
+    if (head == isdefined_sym) {
+        return emit_isdefined(ctx, args[0]);
+    }
+    else if (head == invoke_sym) {
+        return emit_invoke(ctx, ex);
     }
     else if (head == call_sym) {
-        if (ctx->linfo->def) { // don't bother codegen constant-folding for toplevel
-            jl_value_t *c = static_eval(expr, ctx, true, true);
-            if (c) {
-                jl_add_method_root(ctx, c);
-                return mark_julia_const(c);
-            }
-        }
-        jl_cgval_t res = emit_call(ex, ctx);
+        jl_cgval_t res = emit_call(ctx, ex);
         // some intrinsics (e.g. typeassert) can return a wider type
         // than what's actually possible
-        jl_value_t *expr_t = expr_type((jl_value_t*)ex, ctx);
-        if (res.typ != expr_t && res.isboxed && !jl_is_concrete_type(res.typ)) {
-            res = remark_julia_type(res, expr_t, ctx);
-        }
+        jl_value_t *expr_t = ex->etype;
+        res = update_julia_type(ctx, res, expr_t);
         if (res.typ == jl_bottom_type || expr_t == jl_bottom_type) {
-            CreateTrap(builder);
+            CreateTrap(ctx.builder);
         }
         return res;
     }
     else if (head == foreigncall_sym) {
-        return emit_ccall(args, jl_array_dim0(ex->args), ctx);
+        return emit_ccall(ctx, args, jl_array_dim0(ex->args));
     }
     else if (head == assign_sym) {
-        emit_assignment(args[0], args[1], ctx);
+        emit_assignment(ctx, args[0], args[1]);
         return ghostValue(jl_void_type);
     }
     else if (head == static_parameter_sym) {
-        return emit_sparam(jl_unbox_long(args[0])-1, ctx);
+        return emit_sparam(ctx, jl_unbox_long(args[0]) - 1);
     }
     else if (head == method_sym) {
         jl_value_t *mn = args[0];
@@ -3479,42 +3720,50 @@ static jl_cgval_t emit_expr(jl_value_t *expr, jl_codectx_t *ctx)
         jl_binding_t *bnd = NULL;
         bool issym = jl_is_symbol(mn);
         bool isglobalref = !issym && jl_is_globalref(mn);
+        jl_module_t *mod = ctx.module;
         if (issym || isglobalref) {
-            jl_module_t *mod = ctx->module;
             if (isglobalref) {
                 mod = jl_globalref_mod(mn);
                 mn = (jl_value_t*)jl_globalref_name(mn);
             }
             if (jl_symbol_name((jl_sym_t*)mn)[0] == '@')
                 jl_errorf("macro definition not allowed inside a local scope");
-            name = literal_pointer_val(mn);
+            name = literal_pointer_val(ctx, mn);
             bnd = jl_get_binding_for_method_def(mod, (jl_sym_t*)mn);
-            bp = julia_binding_gv(bnd);
-            bp_owner = literal_pointer_val((jl_value_t*)mod);
+            bp = julia_binding_gv(ctx, bnd);
+            bp_owner = literal_pointer_val(ctx, (jl_value_t*)mod);
         }
         else if (jl_is_slot(mn)) {
             int sl = jl_slot_number(mn)-1;
-            jl_varinfo_t &vi = ctx->slots[sl];
+            jl_varinfo_t &vi = ctx.slots[sl];
             bp = vi.boxroot;
-            name = literal_pointer_val((jl_value_t*)slot_symbol(sl, ctx));
+            name = literal_pointer_val(ctx, (jl_value_t*)slot_symbol(ctx, sl));
         }
         if (bp) {
-            Value *mdargs[4] = { name, bp, bp_owner, literal_pointer_val(bnd) };
+            Value *mdargs[5] = { name, literal_pointer_val(ctx, (jl_value_t*)mod), bp,
+                                 maybe_decay_untracked(bp_owner), literal_pointer_val(ctx, bnd) };
             jl_cgval_t gf = mark_julia_type(
-                    builder.CreateCall(prepare_call(jlgenericfunction_func), ArrayRef<Value*>(&mdargs[0], 4)),
-                    true, jl_function_type, ctx);
+                    ctx,
+                    ctx.builder.CreateCall(prepare_call(jlgenericfunction_func), makeArrayRef(mdargs)),
+                    true,
+                    jl_function_type);
             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));
+        Value *a1 = maybe_decay_untracked(boxed(ctx, emit_expr(ctx, args[1])));
+        Value *a2 = maybe_decay_untracked(boxed(ctx, emit_expr(ctx, args[2])));
+        Value *mdargs[4] = {
+            /*argdata*/a1,
+            /*code*/a2,
+            /*module*/literal_pointer_val(ctx, (jl_value_t*)ctx.module),
+            /*isstaged*/literal_pointer_val(ctx, args[3])
+        };
+        ctx.builder.CreateCall(prepare_call(jlmethod_func), makeArrayRef(mdargs));
         return ghostValue(jl_void_type);
     }
     else if (head == const_sym) {
         jl_sym_t *sym = (jl_sym_t*)args[0];
-        jl_module_t *mod = ctx->module;
+        jl_module_t *mod = ctx.module;
         if (jl_is_globalref(sym)) {
             mod = jl_globalref_mod(sym);
             sym = jl_globalref_name(sym);
@@ -3522,44 +3771,50 @@ static jl_cgval_t emit_expr(jl_value_t *expr, jl_codectx_t *ctx)
         if (jl_is_symbol(sym)) {
             JL_FEAT_REQUIRE(ctx, runtime);
             jl_binding_t *bnd = NULL;
-            (void)global_binding_pointer(mod, sym, &bnd, true, ctx); assert(bnd);
-            builder.CreateCall(prepare_call(jldeclareconst_func),
-                               literal_pointer_val(bnd));
+            (void)global_binding_pointer(ctx, mod, sym, &bnd, true); assert(bnd);
+            ctx.builder.CreateCall(prepare_call(jldeclareconst_func),
+                               literal_pointer_val(ctx, bnd));
         }
     }
     else if (head == new_sym) {
-        jl_value_t *ty = expr_type(args[0], ctx);
         size_t nargs = jl_array_len(ex->args);
+        jl_cgval_t *argv = (jl_cgval_t*)alloca(sizeof(jl_cgval_t) * nargs);
+        for (size_t i = 0; i < nargs; ++i) {
+            argv[i] = emit_expr(ctx, args[i]);
+        }
+        jl_value_t *ty = argv[0].typ;
         if (jl_is_type_type(ty) &&
-            jl_is_datatype(jl_tparam0(ty)) &&
-            jl_is_concrete_type(jl_tparam0(ty))) {
-            assert(nargs <= jl_datatype_nfields(jl_tparam0(ty))+1);
-            return emit_new_struct(jl_tparam0(ty),nargs,args,ctx);
+                jl_is_datatype(jl_tparam0(ty)) &&
+                jl_is_concrete_type(jl_tparam0(ty))) {
+            assert(nargs <= jl_datatype_nfields(jl_tparam0(ty)) + 1);
+            return emit_new_struct(ctx, jl_tparam0(ty), nargs, argv);
         }
-        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, true, ty, ctx);
+        Value *typ = boxed(ctx, argv[0]);
+        Value *val = emit_jlcall(ctx, jlnew_func, typ, &argv[1], nargs - 1);
+        return mark_julia_type(ctx, val, true, ty);
     }
     else if (head == exc_sym) { // *ptls->exception_in_transit
-        return mark_julia_type(builder.CreateLoad(emit_exc_in_transit(ctx),
-                                                  /*isvolatile*/true),
-                               true, jl_any_type, ctx);
+        return mark_julia_type(ctx,
+                ctx.builder.CreateLoad(emit_exc_in_transit(ctx), /*isvolatile*/true),
+                true, jl_any_type);
     }
     else if (head == copyast_sym) {
         JL_FEAT_REQUIRE(ctx, runtime);
         jl_value_t *arg = args[0];
         if (jl_is_quotenode(arg)) {
-            jl_value_t *arg1 = jl_fieldref(arg,0);
-            if (!(jl_is_expr(arg1) || jl_typeis(arg1,jl_array_any_type) || jl_is_quotenode(arg1))) {
+            jl_value_t *arg1 = jl_fieldref(arg, 0);
+            if (!(jl_is_expr(arg1) || jl_typeis(arg1, jl_array_any_type) || jl_is_quotenode(arg1))) {
                 // elide call to jl_copy_ast when possible
-                return emit_expr(arg, ctx);
+                return emit_expr(ctx, arg);
             }
         }
-        jl_cgval_t ast = emit_expr(arg, ctx);
-        return mark_julia_type(builder.CreateCall(prepare_call(jlcopyast_func), boxed(ast, ctx)), true, ast.typ, ctx);
+        jl_cgval_t ast = emit_expr(ctx, arg);
+        return mark_julia_type(ctx,
+                ctx.builder.CreateCall(prepare_call(jlcopyast_func),
+                    maybe_decay_untracked(boxed(ctx, ast))), true, ast.typ);
     }
     else if (head == simdloop_sym) {
-        llvm::annotateSimdLoop(builder.GetInsertBlock());
+        llvm::annotateSimdLoop(ctx.builder.GetInsertBlock());
         return jl_cgval_t();
     }
     else if (head == goto_ifnot_sym) {
@@ -3581,11 +3836,15 @@ static jl_cgval_t emit_expr(jl_value_t *expr, jl_codectx_t *ctx)
         if (!strcmp(jl_symbol_name(head), "$"))
             jl_error("syntax: prefix \"$\" in non-quoted expression");
         if (jl_is_toplevel_only_expr(expr) &&
-            ctx->linfo->def == NULL) {
+            !jl_is_method(ctx.linfo->def.method)) {
             JL_FEAT_REQUIRE(ctx, runtime);
             // call interpreter to run a toplevel expr from inside a
             // compiled toplevel thunk.
-            builder.CreateCall(prepare_call(jltopeval_func), literal_pointer_val(expr));
+            Value *args[2] = {
+                literal_pointer_val(ctx, (jl_value_t*)ctx.module),
+                literal_pointer_val(ctx, expr)
+            };
+            ctx.builder.CreateCall(prepare_call(jltopeval_func), args);
             return ghostValue(jl_void_type);
         }
         if (head == abstracttype_sym || head == compositetype_sym ||
@@ -3594,7 +3853,7 @@ static jl_cgval_t emit_expr(jl_value_t *expr, jl_codectx_t *ctx)
         }
         else {
             jl_errorf("unsupported or misplaced expression \"%s\" in function %s",
-                      jl_symbol_name(head), ctx->name);
+                      jl_symbol_name(head), ctx.name);
         }
     }
     return jl_cgval_t();
@@ -3603,24 +3862,124 @@ static jl_cgval_t emit_expr(jl_value_t *expr, jl_codectx_t *ctx)
 // --- generate function bodies ---
 
 // gc frame emission
-static void allocate_gc_frame(BasicBlock *b0, jl_codectx_t *ctx)
+static void allocate_gc_frame(jl_codectx_t &ctx, BasicBlock *b0)
 {
     // TODO: requires the runtime, but is generated unconditionally
 
     // allocate a placeholder gc instruction
-    ctx->ptlsStates = builder.CreateCall(prepare_call(jltls_states_func));
+    ctx.ptlsStates = ctx.builder.CreateCall(prepare_call(jltls_states_func));
     int nthfield = offsetof(jl_tls_states_t, safepoint) / sizeof(void*);
-    ctx->signalPage = emit_nthptr_recast(ctx->ptlsStates, nthfield, tbaa_const,
-                                         PointerType::get(T_psize, 0));
+    ctx.signalPage = emit_nthptr_recast(ctx, ctx.ptlsStates, nthfield, tbaa_const,
+                                        PointerType::get(T_psize, 0), false);
 }
 
-static void emit_last_age_field(jl_codectx_t *ctx)
+static void emit_last_age_field(jl_codectx_t &ctx)
 {
-    ctx->world_age_field = builder.CreateGEP(
-            builder.CreateBitCast(ctx->ptlsStates, T_psize),
+    ctx.world_age_field = ctx.builder.CreateGEP(
+            ctx.builder.CreateBitCast(ctx.ptlsStates, T_psize),
             ConstantInt::get(T_size, offsetof(jl_tls_states_t, world_age) / sizeof(size_t)));
 }
 
+static void emit_cfunc_invalidate(
+        Function *gf_thunk, jl_returninfo_t::CallingConv cc,
+        jl_method_instance_t *lam, size_t nargs, size_t world)
+{
+    jl_codectx_t ctx(jl_LLVMContext);
+    ctx.f = gf_thunk;
+    ctx.world = world;
+    ctx.params = &jl_default_cgparams;
+
+    BasicBlock *b0 = BasicBlock::Create(jl_LLVMContext, "top", gf_thunk);
+    ctx.builder.SetInsertPoint(b0);
+    DebugLoc noDbg;
+    ctx.builder.SetCurrentDebugLocation(noDbg);
+    allocate_gc_frame(ctx, b0);
+
+    Function::arg_iterator AI = gf_thunk->arg_begin();
+    Value *myargs = new AllocaInst(T_prjlvalue,
+#if JL_LLVM_VERSION >= 50000
+        0,
+#endif
+        ConstantInt::get(T_int32, nargs), "jlcall", ctx.ptlsStates);
+    if (cc == jl_returninfo_t::SRet || cc == jl_returninfo_t::Union)
+        ++AI;
+    for (size_t i = 0; i < nargs; i++) {
+        jl_value_t *jt = jl_nth_slot_type(lam->specTypes, i);
+        bool isboxed;
+        Type *et = julia_type_to_llvm(jt, &isboxed);
+        Value *arg_box;
+        if (type_is_ghost(et)) {
+            assert(jl_is_datatype(jt) && ((jl_datatype_t*)jt)->instance);
+            arg_box = literal_pointer_val(ctx, ((jl_datatype_t*)jt)->instance);
+        }
+        else {
+            Value *arg_v = &*AI;
+            ++AI;
+            Type *at = arg_v->getType();
+            if (isboxed) {
+                assert(at == T_prjlvalue && et == T_pjlvalue);
+                arg_box = arg_v;
+            }
+            else if (et->isAggregateType()) {
+                arg_box = boxed(ctx, mark_julia_slot(arg_v, jt, NULL, tbaa_const), false);
+            }
+            else {
+                assert(at == et);
+                arg_box = boxed(ctx, mark_julia_type(ctx, arg_v, false, jt), false);
+            }
+            (void)at;
+        }
+        Value *argn = ctx.builder.CreateConstInBoundsGEP1_32(T_prjlvalue, myargs, i);
+        ctx.builder.CreateStore(maybe_decay_untracked(arg_box), argn);
+    }
+    assert(AI == gf_thunk->arg_end());
+    Value *nargs_v = ConstantInt::get(T_int32, nargs);
+    Value *gf_ret = ctx.builder.CreateCall(prepare_call(jlapplygeneric_func), { myargs, nargs_v });
+    jl_cgval_t gf_retbox = mark_julia_type(ctx, gf_ret, true, jl_any_type, /*needsroot*/false);
+    jl_value_t *astrt = lam->rettype;
+    if (cc != jl_returninfo_t::Boxed) {
+        emit_typecheck(ctx, gf_retbox, astrt, "cfunction");
+    }
+
+    switch (cc) {
+    case jl_returninfo_t::Boxed:
+        ctx.builder.CreateRet(gf_ret);
+        break;
+    case jl_returninfo_t::Register: {
+        Type *gfrt = gf_thunk->getReturnType();
+        if (gfrt->isVoidTy()) {
+            ctx.builder.CreateRetVoid();
+        }
+        else {
+            gf_ret = emit_bitcast(ctx, gf_ret, gfrt->getPointerTo());
+            ctx.builder.CreateRet(ctx.builder.CreateLoad(gf_ret));
+        }
+        break;
+    }
+    case jl_returninfo_t::SRet: {
+        unsigned sret_nbytes = jl_datatype_size(astrt);
+        ctx.builder.CreateMemCpy(&*gf_thunk->arg_begin(), gf_ret, sret_nbytes, jl_alignment(sret_nbytes));
+        ctx.builder.CreateRetVoid();
+        break;
+    }
+    case jl_returninfo_t::Union: {
+        Type *retty = gf_thunk->getReturnType();
+        Value *gf_retval = UndefValue::get(retty);
+        Value *tindex = compute_box_tindex(ctx, gf_ret, (jl_value_t*)jl_any_type, astrt);
+        tindex = ctx.builder.CreateOr(tindex, ConstantInt::get(T_int8, 0x80));
+        gf_retval = ctx.builder.CreateInsertValue(gf_retval, gf_ret, 0);
+        gf_retval = ctx.builder.CreateInsertValue(gf_retval, tindex, 1);
+        ctx.builder.CreateRet(gf_retval);
+        break;
+    }
+    case jl_returninfo_t::Ghosts: {
+        Value *gf_retval = compute_tindex_unboxed(ctx, gf_retbox, astrt);
+        ctx.builder.CreateRet(gf_retval);
+        break;
+    }
+    }
+}
+
 static Function *gen_cfun_wrapper(jl_function_t *ff, jl_value_t *jlrettype, jl_tupletype_t *argt,
                                   jl_typemap_entry_t *sf, jl_value_t *declrt, jl_tupletype_t *sigt)
 {
@@ -3629,6 +3988,8 @@ static Function *gen_cfun_wrapper(jl_function_t *ff, jl_value_t *jlrettype, jl_t
     Type *crt = julia_struct_to_llvm(jlrettype, NULL, &toboxed);
     if (crt == NULL)
         jl_error("cfunction: return type doesn't correspond to a C type");
+    else if (toboxed)
+        crt = T_prjlvalue;
 
     size_t nargs = jl_nparams(argt);
     function_sig_t sig(crt, jlrettype, toboxed, argt->parameters, NULL, nargs, false, CallingConv::C, false);
@@ -3644,7 +4005,7 @@ static Function *gen_cfun_wrapper(jl_function_t *ff, jl_value_t *jlrettype, jl_t
     jl_value_t *astrt = (jl_value_t*)jl_any_type;
     // infer it first, if necessary
     if (lam) {
-        name = jl_symbol_name(lam->def->name);
+        name = jl_symbol_name(lam->def.method->name);
         jl_code_info_t *src = NULL;
         if (!lam->inferred) // TODO: this isn't ideal to be unconditionally calling type inference from here
             src = jl_type_infer(&lam, world, 0);
@@ -3678,114 +4039,71 @@ static Function *gen_cfun_wrapper(jl_function_t *ff, jl_value_t *jlrettype, jl_t
             funcName.str(), M);
     jl_init_function(cw);
     cw->setAttributes(sig.attributes);
-#if JL_LLVM_VERSION >= 30700
     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;
-    builder.SetCurrentDebugLocation(noDbg);
-
-    jl_codectx_t ctx = {};
+    jl_codectx_t ctx(jl_LLVMContext);
     ctx.f = cw;
     ctx.linfo = lam;
-    ctx.code = NULL;
     ctx.world = world;
-    ctx.sret = false;
-    ctx.spvals_ptr = NULL;
     ctx.params = &jl_default_cgparams;
-    allocate_gc_frame(b0, &ctx);
-    emit_last_age_field(&ctx);
 
-    Value *dummy_world = builder.CreateAlloca(T_size);
-    Value *have_tls = builder.CreateIsNotNull(ctx.ptlsStates);
+    BasicBlock *b0 = BasicBlock::Create(jl_LLVMContext, "top", cw);
+    ctx.builder.SetInsertPoint(b0);
+    DebugLoc noDbg;
+    ctx.builder.SetCurrentDebugLocation(noDbg);
+    allocate_gc_frame(ctx, b0);
+    emit_last_age_field(ctx);
+
+    Value *dummy_world = ctx.builder.CreateAlloca(T_size);
+    Value *have_tls = ctx.builder.CreateIsNotNull(ctx.ptlsStates);
     // TODO: in the future, try to initialize a full TLS context here
     // for now, just use a dummy field to avoid a branch in this function
-    ctx.world_age_field = builder.CreateSelect(have_tls, ctx.world_age_field, dummy_world);
-    Value *last_age = tbaa_decorate(tbaa_gcframe, builder.CreateLoad(ctx.world_age_field));
-    have_tls = builder.CreateAnd(have_tls, builder.CreateIsNotNull(last_age));
-    Value *world_v = builder.CreateLoad(prepare_global(jlgetworld_global));
+    ctx.world_age_field = ctx.builder.CreateSelect(have_tls, ctx.world_age_field, dummy_world);
+    Value *last_age = tbaa_decorate(tbaa_gcframe, ctx.builder.CreateLoad(ctx.world_age_field));
+    have_tls = ctx.builder.CreateAnd(have_tls, ctx.builder.CreateIsNotNull(last_age));
+    Value *world_v = ctx.builder.CreateLoad(prepare_global(jlgetworld_global));
 
     Value *age_ok = NULL;
     if (lam) {
-        Value *lam_max = builder.CreateLoad(
-                builder.CreateConstInBoundsGEP1_32(
-                    LLVM37_param(T_size)
-                    emit_bitcast(literal_pointer_val((jl_value_t*)lam), T_psize),
+        Value *lam_max = ctx.builder.CreateLoad(
+                ctx.builder.CreateConstInBoundsGEP1_32(
+                    T_size,
+                    emit_bitcast(ctx, decay_derived(literal_pointer_val(ctx, (jl_value_t*)lam)), T_psize),
                     offsetof(jl_method_instance_t, max_world) / sizeof(size_t)));
         // XXX: age is always OK if we don't have a TLS. This is a hack required due to `@threadcall` abuse.
         // and adds quite a bit of complexity here, even though it's still wrong
         // (anything that tries to interact with the runtime will fault)
-        age_ok = builder.CreateICmpUGE(lam_max, world_v);
-        world_v = builder.CreateSelect(builder.CreateOr(have_tls, age_ok), world_v, lam_max);
-        age_ok = builder.CreateOr(builder.CreateNot(have_tls), age_ok);
+        age_ok = ctx.builder.CreateICmpUGE(lam_max, world_v);
+        world_v = ctx.builder.CreateSelect(ctx.builder.CreateOr(have_tls, age_ok), world_v, lam_max);
+        age_ok = ctx.builder.CreateOr(ctx.builder.CreateNot(have_tls), age_ok);
     }
-    builder.CreateStore(world_v, ctx.world_age_field);
+    ctx.builder.CreateStore(world_v, ctx.world_age_field);
     // Save the Function object reference
     sf->func.value = jl_box_voidpointer((void*)cw_proto);
     jl_gc_wb(sf, sf->func.value);
 
-    // See whether this function is specsig or jlcall or generic (unknown)
-    bool specsig, jlfunc_sret;
-    Function *theFptr;
-    Value *result;
-    Value *myargs;
-    size_t FParamIndex = 0;
-    std::vector<Value*> args;
+    // first emit code to record the arguments
     Function::arg_iterator AI = cw->arg_begin();
     Value *sretPtr = sig.sret ? &*AI++ : NULL;
-    if (lam && lam->jlcall_api == 2) {
-        nargs = 0; // arguments not needed
-        specsig = true;
-        jlfunc_sret = false;
-        myargs = NULL;
-        theFptr = NULL;
-    }
-    else if (lam && lam->functionObjectsDecls.specFunctionObject != NULL) {
-        theFptr = (Function*)lam->functionObjectsDecls.specFunctionObject;
-        specsig = true;
-        jlfunc_sret = theFptr->hasStructRetAttr();
-        if (jlfunc_sret) {
-            // fuse the two sret together, or emit an alloca to hold it
-            if (sig.sret)
-                result = emit_bitcast(sretPtr, theFptr->getFunctionType()->getParamType(0));
-            else
-                result = builder.CreateAlloca(theFptr->getFunctionType()->getParamType(0)->getContainedType(0));
-            args.push_back(result);
-            FParamIndex++;
-        }
-        myargs = NULL;
-    }
-    else {
-        theFptr = lam ? (Function*)lam->functionObjectsDecls.functionObject : NULL;
-        specsig = false;
-        jlfunc_sret = false;
-        myargs = CallInst::Create(prepare_call(jlcall_frame_func),
-            ConstantInt::get(T_int32, nargs + 1),
-            "",
-            /*InsertBefore*/ctx.ptlsStates);
-        FParamIndex++; // leave room for writing the ff object at the beginning
-    }
-
-    // first emit the arguments
-    for (size_t i = 0; i < nargs; i++) {
-        Value *val = &*AI++;
+    jl_cgval_t *inputargs = (jl_cgval_t*)alloca(sizeof(jl_cgval_t) * (nargs + 1));
+    inputargs[0] = mark_julia_const(ff); // we need to pass the function object even if (even though) it is a ghost
+    for (size_t i = 0; i < nargs; ++i, ++AI) {
+        Value *val = &*AI;
         jl_value_t *jargty = jl_nth_slot_type((jl_value_t*)argt, i);
         // figure out how to unpack this type
-        jl_cgval_t inputarg;
+        jl_cgval_t &inputarg = inputargs[i + 1];
         if (jl_is_abstract_ref_type(jargty)) {
             // a pointer to a value
             jargty = jl_tparam0(jargty);
             if (jargty == (jl_value_t*)jl_any_type) {
-                inputarg = mark_julia_type(
-                        builder.CreateLoad(builder.CreatePointerCast(val, T_ppjlvalue)),
-                        true, jargty, &ctx);
+                inputarg = mark_julia_type(ctx,
+                        ctx.builder.CreateLoad(emit_bitcast(ctx, val, T_pprjlvalue)),
+                        true, jargty);
             }
             else if (!jl_isbits(jargty)) {
                 // must be a jl_value_t* (because it's mutable or contains gc roots)
-                inputarg = mark_julia_type(builder.CreatePointerCast(val, T_pjlvalue), true, jargty, &ctx);
+                inputarg = mark_julia_type(ctx, maybe_decay_untracked(emit_bitcast(ctx, val, T_prjlvalue)), true, jargty);
             }
             else {
                 bool isboxed;
@@ -3796,9 +4114,9 @@ static Function *gen_cfun_wrapper(jl_function_t *ff, jl_value_t *jlrettype, jl_t
                     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);
+                    val = emit_bitcast(ctx, val, T->getPointerTo());
+                    val = ctx.builder.CreateAlignedLoad(val, 1); // make no alignment assumption about pointer from C
+                    inputarg = mark_julia_type(ctx, val, false, jargty);
                 }
             }
         }
@@ -3807,110 +4125,146 @@ static Function *gen_cfun_wrapper(jl_function_t *ff, jl_value_t *jlrettype, jl_t
             (void)julia_struct_to_llvm(jargty, NULL, &argboxed);
             if (argboxed) {
                 // a jl_value_t*, even when represented as a struct
-                inputarg = mark_julia_type(val, true, jargty, &ctx);
+                inputarg = mark_julia_type(ctx, val, true, jargty);
             }
             else {
                 // something of type T
                 // undo whatever we might have done to this poor argument
                 if (sig.byRefList.at(i)) {
-                    assert(val->getType() == sig.fargt[i]->getPointerTo());
-                    val = builder.CreateAlignedLoad(val, 1); // unknown alignment from C
+                    assert(cast<PointerType>(val->getType())->getElementType() == sig.fargt[i]);
+                    val = ctx.builder.CreateAlignedLoad(val, 1); // unknown alignment from C
                 }
                 else {
                     bool issigned = jl_signed_type && jl_subtype(jargty, (jl_value_t*)jl_signed_type);
-                    val = llvm_type_rewrite(val, sig.fargt[i], issigned, &ctx);
+                    val = llvm_type_rewrite(ctx, val, sig.fargt[i], issigned);
                 }
                 bool isboxed;
                 (void)julia_type_to_llvm(jargty, &isboxed);
                 if (isboxed) {
                     // passed an unboxed T, but want something boxed
-                    Value *mem = emit_allocobj(&ctx, jl_datatype_size(jargty),
-                                               literal_pointer_val((jl_value_t*)jargty));
+                    Value *mem = emit_allocobj(ctx, jl_datatype_size(jargty),
+                                               literal_pointer_val(ctx, (jl_value_t*)jargty));
                     tbaa_decorate(jl_is_mutable(jargty) ? tbaa_mutab : tbaa_immut,
-                                  builder.CreateAlignedStore(val,
-                                                             emit_bitcast(mem, val->getType()->getPointerTo()),
+                                  ctx.builder.CreateAlignedStore(val,
+                                                             emit_bitcast(ctx, mem, val->getType()->getPointerTo()),
                                                              16)); // julia's gc gives 16-byte aligned addresses
-                    inputarg = mark_julia_type(mem, true, jargty, &ctx);
+                    inputarg = mark_julia_type(ctx, mem, true, jargty);
                 }
                 else {
                     // mark that this is an unboxed T
-                    inputarg = mark_julia_type(val, false, jargty, &ctx);
+                    inputarg = mark_julia_type(ctx, val, false, jargty);
                 }
             }
         }
+    }
+    assert(AI == cw->arg_end());
 
-        // figure out how to repack this type
-        if (!specsig) {
-            Value *arg = boxed(inputarg, &ctx, false); // don't want a gcroot, since it's about to be put into the jlcall frame anyways
-            GetElementPtrInst *slot = GetElementPtrInst::Create(LLVM37_param(NULL) myargs,
-                    ArrayRef<Value*>(ConstantInt::get(T_int32, FParamIndex)));
-            slot->insertAfter(ctx.ptlsStates);
-            builder.CreateStore(arg, slot);
+    // Create the call
+    bool jlfunc_sret;
+    jl_cgval_t retval;
+    if (lam && lam->jlcall_api == 2) {
+        nargs = 0; // arguments not needed -- TODO: not really true, should emit an age_ok test and jlcall
+        jlfunc_sret = false;
+        retval = mark_julia_const(lam->inferred_const);
+    }
+    else if (lam && lam->functionObjectsDecls.specFunctionObject != NULL) {
+        // emit a specsig call
+        const char *protoname = lam->functionObjectsDecls.specFunctionObject;
+        jl_returninfo_t returninfo = get_specsig_function(M, protoname, lam->specTypes, lam->rettype);
+        FunctionType *cft = returninfo.decl->getFunctionType();
+        jlfunc_sret = (returninfo.cc == jl_returninfo_t::SRet);
+
+        std::vector<Value*> args;
+        Value *result;
+        if (jlfunc_sret || returninfo.cc == jl_returninfo_t::Union) {
+            // fuse the two sret together, or emit an alloca to hold it
+            if (sig.sret && jlfunc_sret)
+                result = emit_bitcast(ctx, sretPtr, cft->getParamType(0));
+            else
+                result = decay_derived(emit_static_alloca(ctx, cft->getParamType(0)->getContainedType(0)));
+            args.push_back(result);
         }
-        else {
+        for (size_t i = 0; i < nargs + 1; i++) {
+            // figure out how to repack the arguments
+            const jl_cgval_t &inputarg = inputargs[i];
             Value *arg;
-            jl_value_t *spect = jl_nth_slot_type(lam->specTypes, i + 1); // +1 because argt excludes function
+            jl_value_t *spect = jl_nth_slot_type(lam->specTypes, i);
             bool isboxed;
             Type *T = julia_type_to_llvm(spect, &isboxed);
             if (isboxed) {
-                arg = boxed(inputarg, &ctx);
+                arg = boxed(ctx, inputarg);
             }
             else if (type_is_ghost(T)) {
                 continue; // ghost types are skipped by the specsig method signature
             }
             else if (T->isAggregateType()) {
                 // aggregate types are passed by pointer
-                arg = data_pointer(inputarg, &ctx, T->getPointerTo());
+                arg = data_pointer(ctx, inputarg, T->getPointerTo());
             }
             else {
-                arg = emit_unbox(T, inputarg, spect);
+                arg = emit_unbox(ctx, T, inputarg, spect);
                 assert(!isa<UndefValue>(arg));
             }
 
             // add to argument list
             args.push_back(arg);
         }
-        FParamIndex++;
-    }
-
-    // Create the call
-    jl_cgval_t retval;
-    Function *gf_thunk = NULL;
-    if (specsig) {
-        if (lam->jlcall_api == 2) {
-            retval = mark_julia_const(lam->inferred);
-        }
-        else {
-            assert(theFptr);
-            bool retboxed;
-            Value *call_v = prepare_call(theFptr);
-            if (age_ok) {
-                funcName << "_gfthunk";
-                gf_thunk = Function::Create(theFptr->getFunctionType(),
-                                GlobalVariable::InternalLinkage,
-                                funcName.str(), M);
-                jl_init_function(gf_thunk);
-                gf_thunk->setAttributes(theFptr->getAttributes());
-#if JL_LLVM_VERSION >= 30700
-                gf_thunk->addFnAttr("no-frame-pointer-elim", "true");
-#endif
-                call_v = builder.CreateSelect(age_ok, call_v, gf_thunk);
-            }
-            CallInst *call = builder.CreateCall(call_v, ArrayRef<Value*>(args));
-            call->setAttributes(theFptr->getAttributes());
-            (void)julia_type_to_llvm(astrt, &retboxed);
-            retval = mark_julia_type(jlfunc_sret ? (Value*)builder.CreateLoad(result) : (Value*)call, retboxed, astrt, &ctx);
+        Value *theFptr = returninfo.decl;
+        assert(theFptr);
+        if (age_ok) {
+            funcName << "_gfthunk";
+            Function *gf_thunk = Function::Create(returninfo.decl->getFunctionType(),
+                    GlobalVariable::InternalLinkage, funcName.str(), M);
+            jl_init_function(gf_thunk);
+            gf_thunk->setAttributes(returninfo.decl->getAttributes());
+            gf_thunk->addFnAttr("no-frame-pointer-elim", "true");
+            // build a  specsig -> jl_apply_generic converter thunk
+            // this builds a method that calls jl_apply_generic (as a closure over a singleton function pointer),
+            // but which has the signature of a specsig
+            emit_cfunc_invalidate(gf_thunk, returninfo.cc, lam, nargs + 1, world);
+            theFptr = ctx.builder.CreateSelect(age_ok, theFptr, gf_thunk);
+        }
+        CallInst *call = ctx.builder.CreateCall(theFptr, ArrayRef<Value*>(args));
+        call->setAttributes(returninfo.decl->getAttributes());
+        switch (returninfo.cc) {
+            case jl_returninfo_t::Boxed:
+                retval = mark_julia_type(ctx, call, true, astrt);
+                break;
+            case jl_returninfo_t::Register:
+                retval = mark_julia_type(ctx, call, false, astrt);
+                break;
+            case jl_returninfo_t::SRet:
+                retval = mark_julia_slot(result, astrt, NULL, tbaa_stack);
+                break;
+            case jl_returninfo_t::Union:
+                retval = mark_julia_slot(ctx.builder.CreateExtractValue(call, 0),
+                                         astrt,
+                                         ctx.builder.CreateExtractValue(call, 1),
+                                         tbaa_stack);
+                // note that the value may not be rooted here (on the return path)
+                break;
+            case jl_returninfo_t::Ghosts:
+                retval = mark_julia_slot(NULL, astrt, call, tbaa_stack);
+                break;
         }
     }
     else {
-        // 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);
-        GetElementPtrInst *slot = GetElementPtrInst::Create(LLVM37_param(NULL) myargs,
-                ArrayRef<Value*>(ConstantInt::get(T_int32, 0)));
-        slot->insertAfter(ctx.ptlsStates);
-        builder.CreateStore(theF, slot);
-
+        // emit a jlcall
+        jlfunc_sret = false;
+        Function *theFptr = NULL;
+        if (lam) {
+            const char *fname = lam->functionObjectsDecls.functionObject;
+            if (fname) {
+                theFptr = cast_or_null<Function>(jl_Module->getNamedValue(fname));
+                if (!theFptr) {
+                    theFptr = Function::Create(jl_func_sig, GlobalVariable::ExternalLinkage,
+                                               fname, jl_Module);
+                }
+                else {
+                    assert(theFptr->getFunctionType() == jl_func_sig);
+                }
+            }
+        }
         BasicBlock *b_generic, *b_jlcall, *b_after;
         Value *ret_jlcall;
         if (age_ok) {
@@ -3918,160 +4272,65 @@ static Function *gen_cfun_wrapper(jl_function_t *ff, jl_value_t *jlrettype, jl_t
             b_generic = BasicBlock::Create(jl_LLVMContext, "generic", cw);
             b_jlcall = BasicBlock::Create(jl_LLVMContext, "apply", cw);
             b_after = BasicBlock::Create(jl_LLVMContext, "after", cw);
-            builder.CreateCondBr(age_ok, b_jlcall, b_generic);
-            builder.SetInsertPoint(b_jlcall);
-            Value *nargs_v = ConstantInt::get(T_int32, nargs);
-            Value *myargs1 = builder.CreateConstInBoundsGEP1_32(LLVM37_param(NULL) myargs, 1);
-#if JL_LLVM_VERSION >= 30700
-            ret_jlcall = builder.CreateCall(prepare_call(theFptr), {theF, myargs1, nargs_v});
-#else
-            ret_jlcall = builder.CreateCall3(prepare_call(theFptr), theF, myargs1, nargs_v);
-#endif
-            builder.CreateBr(b_after);
-            builder.SetInsertPoint(b_generic);
-        }
-
-        Value *nargs_v = ConstantInt::get(T_int32, nargs + 1);
-#if JL_LLVM_VERSION >= 30700
-        Value *ret = builder.CreateCall(prepare_call(jlapplygeneric_func), {myargs, nargs_v});
-#else
-        Value *ret = builder.CreateCall2(prepare_call(jlapplygeneric_func), myargs, nargs_v);
-#endif
+            ctx.builder.CreateCondBr(age_ok, b_jlcall, b_generic);
+            ctx.builder.SetInsertPoint(b_jlcall);
+            // for jlcall, we need to pass the function object even if it is a ghost.
+            Value *theF = boxed(ctx, inputargs[0]);
+            assert(theF);
+            ret_jlcall = emit_jlcall(ctx, theFptr, theF, &inputargs[1], nargs);
+            ctx.builder.CreateBr(b_after);
+            ctx.builder.SetInsertPoint(b_generic);
+        }
+        Value *ret = emit_jlcall(ctx, prepare_call(jlapplygeneric_func), NULL, inputargs, nargs + 1);
         if (age_ok) {
-            builder.CreateBr(b_after);
-            builder.SetInsertPoint(b_after);
-            PHINode *retphi = builder.CreatePHI(T_pjlvalue, 2);
+            ctx.builder.CreateBr(b_after);
+            ctx.builder.SetInsertPoint(b_after);
+            PHINode *retphi = ctx.builder.CreatePHI(T_prjlvalue, 2);
             retphi->addIncoming(ret_jlcall, b_jlcall);
             retphi->addIncoming(ret, b_generic);
             ret = retphi;
         }
-        retval = mark_julia_type(ret, true, astrt, &ctx);
+        retval = mark_julia_type(ctx, ret, true, astrt);
     }
 
-    if (!jl_subtype(astrt, declrt)) {
-        // inline a call to typeassert here
-        emit_typecheck(retval, declrt, "cfunction", &ctx);
-    }
+    // inline a call to typeassert here
+    emit_typecheck(ctx, retval, declrt, "cfunction");
 
     // Prepare the return value
     Value *r;
     if (toboxed) {
         assert(!sig.sret);
         // return a jl_value_t*
-        r = boxed(retval, &ctx, false); // no gcroot since this is on the return path
+        r = boxed(ctx, retval, false); // no gcroot since this is on the return path
     }
     else if (sig.sret && jlfunc_sret) {
         // nothing to do
+        r = NULL;
     }
     else if (!type_is_ghost(sig.lrt)) {
         Type *prt = sig.prt;
         if (sig.sret)
             prt = sig.fargt_sig[0]->getContainedType(0); // sret is a PointerType
         bool issigned = jl_signed_type && jl_subtype(declrt, (jl_value_t*)jl_signed_type);
-        Value *v = julia_to_native(sig.lrt, toboxed, declrt, NULL, retval,
-                                   false, 0, &ctx, NULL);
-        r = llvm_type_rewrite(v, prt, issigned, &ctx);
-        if (sig.sret)
-            builder.CreateStore(r, sretPtr);
+        Value *v = julia_to_native(ctx, sig.lrt, toboxed, declrt, NULL, retval,
+                                   false, 0, NULL);
+        r = llvm_type_rewrite(ctx, v, prt, issigned);
+        if (sig.sret) {
+            ctx.builder.CreateStore(r, sretPtr);
+            r = NULL;
+        }
     }
     else {
         assert(type_is_ghost(sig.lrt));
         sig.sret = true;
+        r = NULL;
     }
 
-    builder.CreateStore(last_age, ctx.world_age_field);
-    if (sig.sret)
-        builder.CreateRetVoid();
-    else
-        builder.CreateRet(r);
-
-    // also need to finish emission of our specsig -> jl_apply_generic converter thunk
-    if (gf_thunk) {
-        assert(lam && specsig);
-        BasicBlock *b0 = BasicBlock::Create(jl_LLVMContext, "top", gf_thunk);
-        builder.SetInsertPoint(b0);
-        builder.SetCurrentDebugLocation(noDbg);
-
-        jl_codectx_t ctx2 = {};
-        ctx2.f = gf_thunk;
-        ctx2.linfo = NULL;
-        ctx2.code = NULL;
-        ctx2.world = world;
-        ctx2.sret = false;
-        ctx2.spvals_ptr = NULL;
-        ctx2.params = &jl_default_cgparams;
-        allocate_gc_frame(b0, &ctx2);
-
-        Function::arg_iterator AI = gf_thunk->arg_begin();
-        Value *myargs = CallInst::Create(prepare_call(jlcall_frame_func),
-            ConstantInt::get(T_int32, nargs + 1),
-            "",
-            /*InsertBefore*/ctx2.ptlsStates);
-        if (jlfunc_sret)
-            ++AI;
-        for (size_t i = 0; i < nargs + 1; i++) {
-            jl_value_t *jt = jl_nth_slot_type(lam->specTypes, i);
-            bool isboxed;
-            Type *et = julia_type_to_llvm(jt, &isboxed);
-            Value *arg_box;
-            if (type_is_ghost(et)) {
-                assert(jl_is_datatype(jt) && ((jl_datatype_t*)jt)->instance);
-                arg_box = literal_pointer_val(((jl_datatype_t*)jt)->instance);
-            }
-            else {
-                Value *arg_v = &*AI;
-                ++AI;
-                Type *at = arg_v->getType();
-                if (isboxed) {
-                    assert(at == T_pjlvalue && et == T_pjlvalue);
-                    arg_box = arg_v;
-                }
-                else if (et->isAggregateType()) {
-                    arg_box = boxed(mark_julia_slot(arg_v, jt, tbaa_const), &ctx2, false);
-                }
-                else {
-                    assert(at == et);
-                    arg_box = boxed(mark_julia_type(arg_v, false, jt, &ctx2), &ctx2, false);
-                }
-                (void)at;
-            }
-            Value *argn = builder.CreateConstInBoundsGEP1_32(LLVM37_param(NULL) myargs, i);
-            builder.CreateStore(arg_box, argn);
-        }
-        assert(AI == gf_thunk->arg_end());
-        Value *nargs_v = ConstantInt::get(T_int32, nargs + 1);
-#if JL_LLVM_VERSION >= 30700
-        Value *gf_ret = builder.CreateCall(prepare_call(jlapplygeneric_func), {myargs, nargs_v});
-#else
-        Value *gf_ret = builder.CreateCall2(prepare_call(jlapplygeneric_func), myargs, nargs_v);
-#endif
-        bool retboxed;
-        (void)julia_type_to_llvm(astrt, &retboxed);
-        if (retboxed) {
-            assert(!jlfunc_sret);
-            builder.CreateRet(gf_ret);
-        }
-        else {
-            jl_cgval_t gf_retbox = mark_julia_type(gf_ret, true, jl_any_type, &ctx2);
-            emit_typecheck(gf_retbox, astrt, "cfunction", &ctx2);
-            Type *gfrt = gf_thunk->getReturnType();
-            if (jlfunc_sret) {
-                unsigned sret_nbytes = jl_datatype_size(astrt);
-                builder.CreateMemCpy(&*gf_thunk->arg_begin(), gf_ret, sret_nbytes, jl_alignment(sret_nbytes));
-                builder.CreateRetVoid();
-            }
-            else if (gfrt->isVoidTy()) {
-                builder.CreateRetVoid();
-            }
-            else {
-                gf_ret = emit_bitcast(gf_ret, gfrt->getPointerTo());
-                builder.CreateRet(builder.CreateLoad(gf_ret));
-            }
-        }
-    }
+    ctx.builder.CreateStore(last_age, ctx.world_age_field);
+    ctx.builder.CreateRet(r);
 
-    builder.SetCurrentDebugLocation(noDbg);
-    builder.ClearInsertionPoint();
+    ctx.builder.SetCurrentDebugLocation(noDbg);
+    ctx.builder.ClearInsertionPoint();
 
     jl_finalize_module(M, true);
 
@@ -4087,6 +4346,8 @@ const struct jl_typemap_info cfunction_cache = {
 // here argt does not include the leading function type argument
 static Function *jl_cfunction_object(jl_function_t *ff, jl_value_t *declrt, jl_tupletype_t *argt)
 {
+    // Assumes the codegen lock is acquired. The caller is responsible for that.
+
     // validate and unpack the arguments
     JL_TYPECHK(cfunction, type, declrt);
     JL_TYPECHK(cfunction, type, (jl_value_t*)argt);
@@ -4156,9 +4417,6 @@ static Function *jl_cfunction_object(jl_function_t *ff, jl_value_t *declrt, jl_t
     }
 
     // Backup the info for the nested compile
-    JL_LOCK(&codegen_lock);
-    IRBuilderBase::InsertPoint old = builder.saveAndClearIP();
-    DebugLoc olddl = builder.getCurrentDebugLocation();
     bool last_n_c = nested_compile;
     nested_compile = true;
     Function *f;
@@ -4169,10 +4427,7 @@ static Function *jl_cfunction_object(jl_function_t *ff, jl_value_t *declrt, jl_t
         f = NULL;
     }
     // Restore the previous compile context
-    builder.restoreIP(old);
-    builder.SetCurrentDebugLocation(olddl);
     nested_compile = last_n_c;
-    JL_UNLOCK(&codegen_lock); // Might GC
     JL_GC_POP();
     if (f == NULL)
         jl_rethrow();
@@ -4180,43 +4435,52 @@ static Function *jl_cfunction_object(jl_function_t *ff, jl_value_t *declrt, jl_t
 }
 
 // generate a julia-callable function that calls f (AKA lam)
-static Function *gen_jlcall_wrapper(jl_method_instance_t *lam, Function *f, const std::string &funcName, bool sret, Module *M)
+static Function *gen_jlcall_wrapper(jl_method_instance_t *lam, const jl_returninfo_t &f, const std::string &funcName, Module *M)
 {
     Function *w = Function::Create(jl_func_sig, GlobalVariable::ExternalLinkage,
                                    funcName, M);
     jl_init_function(w);
-#if JL_LLVM_VERSION >= 30700
     w->addFnAttr("no-frame-pointer-elim", "true");
-#endif
     Function::arg_iterator AI = w->arg_begin();
     Value *fArg = &*AI++;
     Value *argArray = &*AI++;
     /* const Argument &argCount = *AI++; */
-    BasicBlock *b0 = BasicBlock::Create(jl_LLVMContext, "top", w);
-
-    builder.SetInsertPoint(b0);
-    DebugLoc noDbg;
-    builder.SetCurrentDebugLocation(noDbg);
 
-    jl_codectx_t ctx = {};
+    jl_codectx_t ctx(jl_LLVMContext);
     ctx.f = w;
     ctx.linfo = lam;
-    ctx.code = NULL;
     ctx.world = 0;
-    ctx.sret = false;
-    ctx.spvals_ptr = NULL;
     ctx.params = &jl_default_cgparams;
-    allocate_gc_frame(b0, &ctx);
 
-    size_t nargs = lam->def->nargs;
-    size_t nfargs = f->getFunctionType()->getNumParams();
+    BasicBlock *b0 = BasicBlock::Create(jl_LLVMContext, "top", w);
+    ctx.builder.SetInsertPoint(b0);
+    DebugLoc noDbg;
+    ctx.builder.SetCurrentDebugLocation(noDbg);
+    allocate_gc_frame(ctx, b0);
+
+    FunctionType *ftype = f.decl->getFunctionType();
+    size_t nargs = lam->def.method->nargs;
+    size_t nfargs = ftype->getNumParams();
     Value **args = (Value**) alloca(nfargs*sizeof(Value*));
     unsigned idx = 0;
-    Value *result;
-    if (sret) {
-        result = builder.CreateAlloca(f->getFunctionType()->getParamType(0)->getContainedType(0));
+    AllocaInst *result;
+    switch (f.cc) {
+    case jl_returninfo_t::Boxed:
+    case jl_returninfo_t::Register:
+    case jl_returninfo_t::Ghosts:
+        break;
+    case jl_returninfo_t::SRet:
+        result = ctx.builder.CreateAlloca(ftype->getParamType(0)->getContainedType(0));
+        args[idx] = decay_derived(result);
+        idx++;
+        break;
+    case jl_returninfo_t::Union:
+        result = ctx.builder.CreateAlloca(ArrayType::get(T_int8, f.union_bytes));
+        if (f.union_align > 1)
+            result->setAlignment(f.union_align);
         args[idx] = result;
         idx++;
+        break;
     }
     for (size_t i = 0; i < nargs; i++) {
         jl_value_t *ty = jl_nth_slot_type(lam->specTypes, i);
@@ -4229,92 +4493,176 @@ static Function *gen_jlcall_wrapper(jl_method_instance_t *lam, Function *f, cons
             theArg = fArg;
         }
         else {
-            Value *argPtr = builder.CreateGEP(argArray, ConstantInt::get(T_size, i-1));
-            theArg = builder.CreateLoad(argPtr);
+            Value *argPtr = ctx.builder.CreateGEP(argArray, ConstantInt::get(T_size, i-1));
+            theArg = ctx.builder.CreateLoad(argPtr);
         }
         if (lty != NULL && !isboxed) {
-            theArg = builder.CreatePointerCast(theArg, PointerType::get(lty, 0));
+            theArg = decay_derived(emit_bitcast(ctx, theArg, PointerType::get(lty, 0)));
             if (!lty->isAggregateType()) // keep "aggregate" type values in place as pointers
-                theArg = builder.CreateAlignedLoad(theArg, julia_alignment(theArg, ty, 0));
+                theArg = ctx.builder.CreateAlignedLoad(theArg, julia_alignment(theArg, ty, 0));
         }
         assert(dyn_cast<UndefValue>(theArg) == NULL);
         args[idx] = theArg;
         idx++;
     }
-    CallInst *call = builder.CreateCall(prepare_call(f), ArrayRef<Value*>(&args[0], nfargs));
-    call->setAttributes(f->getAttributes());
-
-    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, tbaa_stack)
-        : mark_julia_type(call, retboxed, jlretty, &ctx, /*needsroot*/false);
-    builder.CreateRet(boxed(retval, &ctx, false)); // no gcroot needed since this on the return path
-
-    assert(!ctx.roots);
-    return w;
+    CallInst *call = ctx.builder.CreateCall(f.decl, ArrayRef<Value*>(&args[0], nfargs));
+    call->setAttributes(f.decl->getAttributes());
+
+    jl_value_t *jlretty = lam->rettype;
+    jl_cgval_t retval;
+    switch (f.cc) {
+    case jl_returninfo_t::Boxed:
+        retval = mark_julia_type(ctx, call, true, jlretty, /*needsroot*/false);
+        break;
+    case jl_returninfo_t::Register:
+        retval = mark_julia_type(ctx, call, false, jlretty, /*needsroot*/false);
+        break;
+    case jl_returninfo_t::SRet:
+        retval = mark_julia_slot(result, jlretty, NULL, tbaa_stack);
+        break;
+    case jl_returninfo_t::Union:
+        // result is technically not right here, but we only need to look at it
+        // for the unboxed values, so it's ok.
+        retval = mark_julia_slot(result,
+                                 jlretty,
+                                 ctx.builder.CreateExtractValue(call, 1),
+                                 tbaa_stack);
+        retval.gcroot = emit_local_root(ctx);
+        ctx.builder.CreateStore(ctx.builder.CreateExtractValue(call, 0), retval.gcroot);
+        break;
+    case jl_returninfo_t::Ghosts:
+        retval = mark_julia_slot(NULL, jlretty, call, tbaa_stack);
+        break;
+    }
+    ctx.builder.CreateRet(boxed(ctx, retval, false)); // no gcroot needed since this on the return path
+    assert(!ctx.roots);
+    return w;
+}
+
+static bool uses_specsig(jl_value_t *sig, jl_value_t *rettype, bool needsparam, bool va, jl_code_info_t *src)
+{
+    if (va || needsparam)
+        return false;
+    if (!src || !jl_ast_flag_inferred((jl_array_t*)src))
+        return false;
+    if (sig == (jl_value_t*)jl_anytuple_type)
+        return false;
+    if (!jl_is_datatype(sig))
+        return false;
+    if (jl_nparams(sig) == 0)
+        return false;
+    // not invalid, consider if specialized signature is worthwhile
+    if (isbits_spec(rettype, false))
+        return true;
+    if (jl_is_uniontype(rettype)) {
+        bool allunbox;
+        size_t nbytes, align, min_align;
+        union_alloca_type((jl_uniontype_t*)rettype, allunbox, nbytes, align, min_align);
+        if (nbytes > 0)
+            return true; // some elements of the union could be returned unboxed avoiding allocation
+    }
+    for (size_t i = 0; i < jl_nparams(sig); i++) {
+        if (isbits_spec(jl_tparam(sig, i), false)) { // assumes !va
+            return true;
+        }
+    }
+    return false; // jlcall sig won't require any box allocations
 }
 
-static Function *get_specsig_function(Module *M, const std::string &name, jl_value_t *sig, jl_value_t *jlrettype, bool &sret)
+static jl_returninfo_t get_specsig_function(Module *M, const std::string &name, jl_value_t *sig, jl_value_t *jlrettype)
 {
+    jl_returninfo_t props = {};
     SmallVector<Type*, 8> fsig;
     Type *rt;
-    bool retboxed;
     if (jlrettype == (jl_value_t*)jl_void_type) {
         rt = T_void;
-        retboxed = false;
+        props.cc = jl_returninfo_t::Register;
+    }
+    else if (jl_is_uniontype(jlrettype)) {
+        bool allunbox;
+        union_alloca_type((jl_uniontype_t*)jlrettype, allunbox, props.union_bytes, props.union_align, props.union_minalign);
+        if (props.union_bytes) {
+            props.cc = jl_returninfo_t::Union;
+            Type *AT = ArrayType::get(T_int8, props.union_bytes);
+            fsig.push_back(AT->getPointerTo());
+            Type *pair[] = { T_prjlvalue, T_int8 };
+            rt = StructType::get(jl_LLVMContext, makeArrayRef(pair));
+        }
+        else if (allunbox) {
+            props.cc = jl_returninfo_t::Ghosts;
+            rt = T_int8;
+        }
+        else {
+            rt = T_prjlvalue;
+        }
     }
     else {
+        bool retboxed;
         rt = julia_type_to_llvm(jlrettype, &retboxed);
+        if (!retboxed) {
+            if (rt != T_void && deserves_sret(jlrettype, rt)) {
+                props.cc = jl_returninfo_t::SRet;
+                fsig.push_back(rt->getPointerTo(AddressSpace::Derived));
+                rt = T_void;
+            }
+            else {
+                props.cc = jl_returninfo_t::Register;
+            }
+        } else {
+            rt = T_prjlvalue;
+        }
     }
-    if (!retboxed && rt != T_void && deserves_sret(jlrettype, rt)) {
-        sret = true;
-        fsig.push_back(rt->getPointerTo());
-        rt = T_void;
+#if JL_LLVM_VERSION >= 50000
+    AttributeList attributes; // function declaration attributes
+#else
+    AttributeSet attributes; // function declaration attributes
+#endif
+    if (props.cc == jl_returninfo_t::SRet) {
+        attributes = attributes.addAttribute(jl_LLVMContext, 1, Attribute::StructRet);
+        attributes = attributes.addAttribute(jl_LLVMContext, 1, Attribute::NoAlias);
+        attributes = attributes.addAttribute(jl_LLVMContext, 1, Attribute::NoCapture);
     }
-    else {
-        sret = false;
+    if (props.cc == jl_returninfo_t::Union) {
+        attributes = attributes.addAttribute(jl_LLVMContext, 1, Attribute::NoAlias);
+        attributes = attributes.addAttribute(jl_LLVMContext, 1, Attribute::NoCapture);
     }
     for (size_t i = 0; i < jl_nparams(sig); i++) {
         jl_value_t *jt = jl_tparam(sig, i);
-        Type *ty = julia_type_to_llvm(jt);
+        bool isboxed;
+        Type *ty = julia_type_to_llvm(jt, &isboxed);
         if (type_is_ghost(ty))
             continue;
-        if (ty->isAggregateType()) // aggregate types are passed by pointer
-            ty = PointerType::get(ty, 0);
+        if (ty->isAggregateType()) { // aggregate types are passed by pointer
+            attributes = attributes.addAttribute(jl_LLVMContext, fsig.size() + 1, Attribute::NoCapture);
+            attributes = attributes.addAttribute(jl_LLVMContext, fsig.size() + 1, Attribute::ReadOnly);
+            ty = PointerType::get(ty, AddressSpace::Derived);
+        }
+        if (isboxed)
+            ty = PointerType::get(cast<PointerType>(ty)->getElementType(), AddressSpace::Tracked);
         fsig.push_back(ty);
     }
     FunctionType *ftype = FunctionType::get(rt, fsig, false);
-    Function *f = Function::Create(ftype, GlobalVariable::ExternalLinkage, name, M);
-    if (sret) {
-        f->addAttribute(1, Attribute::StructRet);
-        f->addAttribute(1, Attribute::NoAlias);
+    Function *f = M ? cast_or_null<Function>(M->getNamedValue(name)) : NULL;
+    if (f == NULL) {
+        f = Function::Create(ftype, GlobalVariable::ExternalLinkage, name, M);
+        f->setAttributes(attributes);
     }
-    return f;
+    else {
+        assert(f->getFunctionType() == ftype);
+    }
+    props.decl = f;
+    return props;
 }
 
-#if JL_LLVM_VERSION >= 30700
 static DISubroutineType *
-#elif JL_LLVM_VERSION >= 30600
-static DISubroutineType
-#else
-static DICompositeType
-#endif
-get_specsig_di(jl_value_t *sig,
-#if JL_LLVM_VERSION >= 30700
-    DIFile *topfile,
-#else
-    DIFile topfile,
-#endif
-    DIBuilder &dbuilder)
+get_specsig_di(jl_value_t *rt, jl_value_t *sig, DIFile *topfile, DIBuilder &dbuilder)
 {
-#if JL_LLVM_VERSION >= 30600
     std::vector<Metadata*> ditypes(0);
-#else
-    std::vector<Value*> ditypes(0);
-#endif
+    Type *ty = julia_type_to_llvm(rt);
+    if (type_is_ghost(ty))
+        ditypes.push_back(nullptr);
+    else
+        ditypes.push_back(julia_type_to_di(rt, &dbuilder, false));
     for (size_t i = 0; i < jl_nparams(sig); i++) {
         jl_value_t *jt = jl_tparam(sig, i);
         Type *ty = julia_type_to_llvm(jt);
@@ -4322,13 +4670,7 @@ get_specsig_di(jl_value_t *sig,
             continue;
         ditypes.push_back(julia_type_to_di(jt, &dbuilder, false));
     }
-#if JL_LLVM_VERSION >= 30800
     return dbuilder.createSubroutineType(dbuilder.getOrCreateTypeArray(ditypes));
-#elif JL_LLVM_VERSION >= 30600
-    return dbuilder.createSubroutineType(topfile, dbuilder.getOrCreateTypeArray(ditypes));
-#else
-    return dbuilder.createSubroutineType(topfile, dbuilder.getOrCreateArray(ditypes));
-#endif
 }
 
 
@@ -4340,33 +4682,29 @@ static std::unique_ptr<Module> emit_function(
         jl_llvm_functions_t *declarations,
         const jl_cgparams_t *params)
 {
-    jl_ptls_t ptls = jl_get_ptls_states();
     assert(declarations && "Capturing declarations is always required");
 
     // step 1. unpack AST and allocate codegen context for this function
-    jl_codectx_t ctx = {};
+    jl_codectx_t ctx(jl_LLVMContext);
     JL_GC_PUSH2(&ctx.code, &ctx.roots);
     ctx.code = (jl_array_t*)src->code;
-    if (!jl_typeis(ctx.code, jl_array_any_type))
-        ctx.code = jl_uncompress_ast(lam->def, ctx.code);
 
     //jl_static_show(JL_STDOUT, (jl_value_t*)ast);
     //jl_printf(JL_STDOUT, "\n");
     std::map<int, jl_arrayvar_t> arrayvars;
     std::map<int, BasicBlock*> labels;
     ctx.arrayvars = &arrayvars;
-    ctx.module = lam->def ? lam->def->module : ptls->current_module;
+    ctx.module = jl_is_method(lam->def.method) ? lam->def.method->module : lam->def.module;
     ctx.linfo = lam;
     ctx.source = src;
     ctx.world = world;
-    ctx.name = jl_symbol_name(lam->def ? lam->def->name : anonymous_sym);
+    ctx.name = jl_symbol_name(jl_is_method(lam->def.method) ? lam->def.method->name : anonymous_sym);
     ctx.funcName = ctx.name;
-    ctx.vaSlot = -1;
     ctx.vaStack = false;
     ctx.params = params;
     ctx.spvals_ptr = NULL;
-    ctx.nargs = lam->def ? lam->def->nargs : 0;
-    bool toplevel = lam->def == NULL;
+    ctx.nargs = jl_is_method(lam->def.method) ? lam->def.method->nargs : 0;
+    bool toplevel = !jl_is_method(lam->def.method);
 
     // step 1b. unpack debug information
     int coverage_mode = jl_options.code_coverage;
@@ -4374,10 +4712,10 @@ static std::unique_ptr<Module> emit_function(
     StringRef filename = "<missing>";
     StringRef dbgFuncName = ctx.name;
     int toplineno = -1;
-    if (lam->def) {
-        toplineno = lam->def->line;
-        if (lam->def->file != empty_sym)
-            filename = jl_symbol_name(lam->def->file);
+    if (jl_is_method(lam->def.method)) {
+        toplineno = lam->def.method->line;
+        if (lam->def.method->file != empty_sym)
+            filename = jl_symbol_name(lam->def.method->file);
     }
     ctx.file = filename;
     // jl_printf(JL_STDERR, "\n*** compiling %s at %s:%d\n\n",
@@ -4403,7 +4741,7 @@ static std::unique_ptr<Module> emit_function(
 
     assert(lam->specTypes); // the specTypes field should always be assigned
 
-    if (nreq > 0 && lam->def->isva) {
+    if (nreq > 0 && lam->def.method->isva) {
         nreq--;
         va = 1;
         jl_sym_t *vn = (jl_sym_t*)jl_array_ptr_ref(src->slotnames, ctx.nargs - 1);
@@ -4425,62 +4763,49 @@ static std::unique_ptr<Module> emit_function(
         jl_varinfo_t &varinfo = ctx.slots[i];
         varinfo.isArgument = true;
         jl_value_t *ty = jl_nth_slot_type(lam->specTypes, i);
-        varinfo.value = mark_julia_type((Value*)NULL, false, ty, &ctx);
+        varinfo.value = mark_julia_type(ctx, (Value*)NULL, false, ty);
     }
     if (va && ctx.vaSlot != -1) {
         jl_varinfo_t &varinfo = ctx.slots[ctx.vaSlot];
         varinfo.isArgument = true;
-        varinfo.value = mark_julia_type((Value*)NULL, false, jl_tuple_type, &ctx);
+        varinfo.value = mark_julia_type(ctx, (Value*)NULL, false, jl_tuple_type);
     }
 
     for (i = 0; i < vinfoslen; i++) {
         jl_varinfo_t &varinfo = ctx.slots[i];
         uint8_t flags = jl_array_uint8_ref(src->slotflags, i);
-        varinfo.escapes = false;
         varinfo.isSA = (jl_vinfo_sa(flags) != 0);
         varinfo.usedUndef = (jl_vinfo_usedundef(flags) != 0) || (!varinfo.isArgument && !src->inferred);
         if (!varinfo.isArgument) {
             jl_value_t *typ = jl_is_array(src->slottypes) ? jl_array_ptr_ref(src->slottypes, i) : (jl_value_t*)jl_any_type;
             if (!jl_is_type(typ))
                 typ = (jl_value_t*)jl_any_type;
-            varinfo.value = mark_julia_type((Value*)NULL, false, typ, &ctx);
+            varinfo.value = mark_julia_type(ctx, (Value*)NULL, false, typ);
         }
     }
 
     jl_array_t *stmts = ctx.code;
     size_t stmtslen = jl_array_dim0(stmts);
 
-    // finish recording escape info
+    // finish recording variable use info
     for (i = 0; i < stmtslen; i++)
-        simple_escape_analysis(jl_array_ptr_ref(stmts, i), true, &ctx);
+        simple_use_analysis(ctx, jl_array_ptr_ref(stmts, i));
 
     // determine which vars need to be volatile
     mark_volatile_vars(stmts, ctx.slots);
 
     // step 4. determine function signature
-    jl_value_t *jlrettype = lam->rettype;
-
-    bool specsig = false;
-    bool needsparams = lam->def ? jl_svec_len(lam->def->sparam_syms) != jl_svec_len(lam->sparam_vals) : false;
+    bool needsparams = jl_is_method(lam->def.method)
+        ? jl_svec_len(lam->def.method->sparam_syms) != jl_svec_len(lam->sparam_vals)
+        : false;
     for (i = 0; !needsparams && i < jl_svec_len(lam->sparam_vals); i++) {
         jl_value_t *e = jl_svecref(lam->sparam_vals, i);
         if (jl_is_typevar(e))
             needsparams = true;
     }
-    if (!va && ctx.nargs > 0 && !needsparams && lam->specTypes != (jl_value_t*)jl_anytuple_type && src->inferred) {
-        assert(jl_is_datatype(lam->specTypes));
-        // 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;
-                break;
-            }
-        }
-        if (jl_nparams(lam->specTypes) == 0)
-            specsig = true;
-        if (isbits_spec(jlrettype))
-            specsig = true;
-    }
+
+    jl_value_t *jlrettype = lam->rettype;
+    bool specsig = uses_specsig(lam->specTypes, jlrettype, needsparams, va, src);
     if (!specsig)
         ctx.nReqArgs--;  // function not part of argArray in jlcall
 
@@ -4493,7 +4818,7 @@ static std::unique_ptr<Module> emit_function(
     else
         funcName << "japi1_";
     const char* unadorned_name = ctx.name;
-#if (defined(_OS_LINUX_) && JL_LLVM_VERSION < 30400)
+#if defined(_OS_LINUX_)
     if (unadorned_name[0] == '@')
         unadorned_name++;
 #endif
@@ -4502,31 +4827,32 @@ static std::unique_ptr<Module> emit_function(
     // allocate Function declarations and wrapper objects
     Module *M = new Module(ctx.name, jl_LLVMContext);
     jl_setup_module(M);
+    jl_returninfo_t returninfo = {};
     Function *f = NULL;
     Function *fwrap = NULL;
-    ctx.sret = false;
     if (specsig) { // assumes !va and !needsparams
         std::stringstream specName;
         specName << "julia_" << unadorned_name << "_" << globalUnique;
-        f = get_specsig_function(M, specName.str(), lam->specTypes, jlrettype, ctx.sret);
+        returninfo = get_specsig_function(M, specName.str(), lam->specTypes, jlrettype);
+        f = returninfo.decl;
+        ctx.has_sret = (returninfo.cc == jl_returninfo_t::SRet || returninfo.cc == jl_returninfo_t::Union);
         jl_init_function(f);
 
-        fwrap = gen_jlcall_wrapper(lam, f, funcName.str(), ctx.sret, M);
-        declarations->functionObject = function_proto(fwrap);
-        declarations->specFunctionObject = function_proto(f);
+        fwrap = gen_jlcall_wrapper(lam, returninfo, funcName.str(), M);
+        declarations->functionObject = strdup(fwrap->getName().str().c_str());
+        declarations->specFunctionObject = strdup(f->getName().str().c_str());
     }
     else {
         f = Function::Create(needsparams ? jl_func_sig_sparams : jl_func_sig,
                              GlobalVariable::ExternalLinkage,
                              funcName.str(), M);
+        returninfo.decl = f;
         jl_init_function(f);
-        declarations->functionObject = function_proto(f);
+        declarations->functionObject = strdup(f->getName().str().c_str());
         declarations->specFunctionObject = NULL;
     }
 
-#if JL_LLVM_VERSION >= 30700
     f->addFnAttr("no-frame-pointer-elim", "true");
-#endif
     if (jlrettype == (jl_value_t*)jl_bottom_type)
         f->setDoesNotReturn();
 #if defined(_OS_WINDOWS_) && !defined(_CPU_X86_64_)
@@ -4536,11 +4862,17 @@ static std::unique_ptr<Module> emit_function(
     // i686 Windows (which uses a 4-byte-aligned stack)
     AttrBuilder *attr = new AttrBuilder();
     attr->addStackAlignmentAttr(16);
+#if JL_LLVM_VERSION >= 50000
+    f->addAttributes(AttributeList::FunctionIndex,
+        AttributeList::get(f->getContext(),
+            AttributeList::FunctionIndex, *attr));
+#else
     f->addAttributes(AttributeSet::FunctionIndex,
         AttributeSet::get(f->getContext(),
             AttributeSet::FunctionIndex, *attr));
 #endif
-#if defined(_OS_WINDOWS_) && defined(_CPU_X86_64_) && JL_LLVM_VERSION >= 30500
+#endif
+#if defined(_OS_WINDOWS_) && defined(_CPU_X86_64_)
     f->setHasUWTable(); // force NeedsWinEH
 #endif
 
@@ -4557,36 +4889,19 @@ static std::unique_ptr<Module> emit_function(
 
     // Step 4b. determine debug info signature and other type info for locals
     DIBuilder dbuilder(*M);
-#if JL_LLVM_VERSION >= 30700
     DIFile *topfile = NULL;
     DISubprogram *SP = NULL;
-#else
-    DIFile topfile;
-    DISubprogram SP;
-#endif
     DebugLoc noDbg, topdebugloc;
     if (ctx.debug_enabled) {
         // TODO: Fix when moving to new LLVM version
         topfile = dbuilder.createFile(filename, ".");
-#if JL_LLVM_VERSION < 30400
-        dbuilder.createCompileUnit(0x01, filename, ".", "julia", true, "", 0);
-        DIDescriptor CU = DIDescriptor(dbuilder.getCU());
-#elif JL_LLVM_VERSION >= 40000
+#if JL_LLVM_VERSION >= 40000
         DICompileUnit *CU = dbuilder.createCompileUnit(0x01, topfile, "julia", true, "", 0);
-#elif JL_LLVM_VERSION >= 30700
-        DICompileUnit *CU = dbuilder.createCompileUnit(0x01, filename, ".", "julia", true, "", 0);
 #else
-        DICompileUnit CU = dbuilder.createCompileUnit(0x01, filename, ".", "julia", true, "", 0);
-        assert(CU.Verify());
+        DICompileUnit *CU = dbuilder.createCompileUnit(0x01, filename, ".", "julia", true, "", 0);
 #endif
 
-#if JL_LLVM_VERSION >= 30700
         DISubroutineType *subrty;
-#elif JL_LLVM_VERSION >= 30600
-        DISubroutineType subrty;
-#else
-        DICompositeType subrty;
-#endif
         if (jl_options.debug_level <= 1) {
             subrty = jl_di_func_null_sig;
         }
@@ -4594,7 +4909,7 @@ static std::unique_ptr<Module> emit_function(
             subrty = jl_di_func_sig;
         }
         else {
-            subrty = get_specsig_di(lam->specTypes, topfile, dbuilder);
+            subrty = get_specsig_di(lam->rettype, lam->specTypes, topfile, dbuilder);
         }
         SP = dbuilder.createFunction(CU,
                                      dbgFuncName,      // Name
@@ -4607,19 +4922,9 @@ static std::unique_ptr<Module> emit_function(
                                      0,                // ScopeLine
                                      DIFlagZero,       // Flags
                                      true,             // isOptimized
-#if JL_LLVM_VERSION >= 30800
                                      nullptr);         // Template Parameters
-#else
-                                     f);               // Function
-#endif
         topdebugloc = DebugLoc::get(toplineno, 0, SP, NULL);
-#if JL_LLVM_VERSION >= 30800
         f->setSubprogram(SP);
-#endif
-#if JL_LLVM_VERSION < 30700
-        assert(SP.Verify() && SP.describes(f) && SP.getFunction() == f);
-#endif
-
         if (jl_options.debug_level >= 2) {
             const bool AlwaysPreserve = true;
             // Go over all arguments and local variables and initialize their debug information
@@ -4628,53 +4933,27 @@ static std::unique_ptr<Module> emit_function(
                 if (argname == unused_sym)
                     continue;
                 jl_varinfo_t &varinfo = ctx.slots[i];
-#if JL_LLVM_VERSION >= 30800
                 varinfo.dinfo = dbuilder.createParameterVariable(
                     SP,                                 // Scope (current function will be fill in later)
                     jl_symbol_name(argname),            // Variable name
-                    ctx.sret + i + 1,                   // Argument number (1-based)
+                    ctx.has_sret + i + 1,               // Argument number (1-based)
                     topfile,                            // File
                     toplineno == -1 ? 0 : toplineno,    // Line
                     // Variable type
                     julia_type_to_di(varinfo.value.typ, &dbuilder, false),
                     AlwaysPreserve,                     // May be deleted if optimized out
                     DIFlagZero);                        // Flags (TODO: Do we need any)
-#else
-                varinfo.dinfo = dbuilder.createLocalVariable(
-                    llvm::dwarf::DW_TAG_arg_variable,    // Tag
-                    SP,         // Scope (current function will be fill in later)
-                    jl_symbol_name(argname),    // Variable name
-                    topfile,                    // File
-                    toplineno == -1 ? 0 : toplineno,             // Line (for now, use lineno of the function)
-                    julia_type_to_di(varinfo.value.typ, &dbuilder, false), // Variable type
-                    AlwaysPreserve,                  // May be deleted if optimized out
-                    0,                      // Flags (TODO: Do we need any)
-                    ctx.sret + i + 1);                   // Argument number (1-based)
-#endif
             }
             if (va && ctx.vaSlot != -1) {
-#if JL_LLVM_VERSION >= 30800
                 ctx.slots[ctx.vaSlot].dinfo = dbuilder.createParameterVariable(
-                    SP,                     // Scope (current function will be fill in later)
-                    std::string(jl_symbol_name(slot_symbol(ctx.vaSlot, &ctx))) + "...",  // Variable name
-                    ctx.sret + nreq + 1,             // Argument number (1-based)
-                    topfile,                         // File
-                    toplineno == -1 ? 0 : toplineno, // Line (for now, use lineno of the function)
-                    julia_type_to_di(ctx.slots[ctx.vaSlot].value.typ, &dbuilder, false),
-                    AlwaysPreserve,                  // May be deleted if optimized out
-                    DIFlagZero);                     // Flags (TODO: Do we need any)
-#else
-                ctx.slots[ctx.vaSlot].dinfo = dbuilder.createLocalVariable(
-                    llvm::dwarf::DW_TAG_arg_variable,   // Tag
                     SP,                                 // Scope (current function will be fill in later)
-                    std::string(jl_symbol_name(slot_symbol(ctx.vaSlot, &ctx))) + "...",  // Variable name
+                    std::string(jl_symbol_name(slot_symbol(ctx, ctx.vaSlot))) + "...",  // Variable name
+                    ctx.has_sret + nreq + 1,            // Argument number (1-based)
                     topfile,                            // File
-                    toplineno == -1 ? 0 : toplineno,  // Line (for now, use lineno of the function)
-                    julia_type_to_di(ctx.slots[ctx.vaSlot].value.typ, &dbuilder, false),      // Variable type
-                    AlwaysPreserve,                  // May be deleted if optimized out
-                    0,                      // Flags (TODO: Do we need any)
-                    ctx.sret + nreq + 1);              // Argument number (1-based)
-#endif
+                    toplineno == -1 ? 0 : toplineno,    // Line (for now, use lineno of the function)
+                    julia_type_to_di(ctx.slots[ctx.vaSlot].value.typ, &dbuilder, false),
+                    AlwaysPreserve,                     // May be deleted if optimized out
+                    DIFlagZero);                        // Flags (TODO: Do we need any)
             }
             for (i = 0; i < vinfoslen; i++) {
                 jl_sym_t *s = (jl_sym_t*)jl_array_ptr_ref(src->slotnames, i);
@@ -4682,12 +4961,7 @@ static std::unique_ptr<Module> emit_function(
                 if (varinfo.isArgument || s == compiler_temp_sym || s == unused_sym)
                     continue;
                 // LLVM 4.0: Assume the variable has default alignment
-#if JL_LLVM_VERSION >= 30800
                 varinfo.dinfo = dbuilder.createAutoVariable(
-#else
-                varinfo.dinfo = dbuilder.createLocalVariable(
-                    llvm::dwarf::DW_TAG_auto_variable,    // Tag
-#endif
                     SP,                     // Scope (current function will be fill in later)
                     jl_symbol_name(s),       // Variable name
                     topfile,                 // File
@@ -4695,9 +4969,6 @@ static std::unique_ptr<Module> emit_function(
                     julia_type_to_di(varinfo.value.typ, &dbuilder, false), // Variable type
                     AlwaysPreserve,          // May be deleted if optimized out
                     DIFlagZero               // Flags (TODO: Do we need any)
-#if JL_LLVM_VERSION < 30800
-                    ,0                       // Argument number (1-based)
-#endif
                     );
             }
         }
@@ -4705,8 +4976,8 @@ static std::unique_ptr<Module> emit_function(
 
     // step 5. create first basic block
     BasicBlock *b0 = BasicBlock::Create(jl_LLVMContext, "top", f);
-    builder.SetInsertPoint(b0);
-    builder.SetCurrentDebugLocation(noDbg);
+    ctx.builder.SetInsertPoint(b0);
+    ctx.builder.SetCurrentDebugLocation(noDbg);
 
     // spill arguments into stack slots
     // so it is more likely to be possible to find them when debugging
@@ -4714,12 +4985,13 @@ static std::unique_ptr<Module> emit_function(
     if (!specsig) {
         Function::arg_iterator AI = f->arg_begin();
         if (needsparams) {
-            ctx.spvals_ptr = &*AI++;
+            ctx.spvals_ptr = &*AI;
+            ++AI;
         }
         fArg = &*AI++;
         argArray = &*AI++;
-        pargArray = builder.CreateAlloca(argArray->getType());
-        builder.CreateStore(argArray, pargArray, true/*volatile store to prevent removal of this alloca*/);
+        pargArray = ctx.builder.CreateAlloca(argArray->getType());
+        ctx.builder.CreateStore(argArray, pargArray, true/*volatile store to prevent removal of this alloca*/);
         argCount = &*AI++;
         ctx.argArray = argArray;
         ctx.argCount = argCount;
@@ -4728,22 +5000,22 @@ static std::unique_ptr<Module> emit_function(
     /*
     // step 6. (optional) check for stack overflow (the slower way)
     Value *cur_sp =
-        builder.CreateCall(Intrinsic::getDeclaration(M,
+        ctx.builder.CreateCall(Intrinsic::getDeclaration(M,
                                                      Intrinsic::frameaddress),
                            ConstantInt::get(T_int32, 0));
     Value *sp_ok =
-        builder.CreateICmpUGT(cur_sp,
+        ctx.builder.CreateICmpUGT(cur_sp,
                               ConstantInt::get(T_size,
                                                (uptrint_t)jl_stack_lo));
-    error_unless(sp_ok, "stack overflow", &ctx);
+    error_unless(ctx, sp_ok, "stack overflow");
     */
 
     // step 7. set up GC frame
-    allocate_gc_frame(b0, &ctx);
+    allocate_gc_frame(ctx, b0);
     Value *last_age = NULL;
     if (toplevel) {
-        emit_last_age_field(&ctx);
-        last_age = tbaa_decorate(tbaa_gcframe, builder.CreateLoad(ctx.world_age_field));
+        emit_last_age_field(ctx);
+        last_age = tbaa_decorate(tbaa_gcframe, ctx.builder.CreateLoad(ctx.world_age_field));
     }
 
     // step 8. allocate local variables slots
@@ -4751,15 +5023,19 @@ static std::unique_ptr<Module> emit_function(
 
     // get pointers for locals stored in the gc frame array (argTemp)
     for (i = 0; i < vinfoslen; i++) {
-        jl_sym_t *s = slot_symbol(i, &ctx);
+        jl_sym_t *s = slot_symbol(ctx, i);
         if (s == unused_sym)
             continue;
         jl_varinfo_t &varinfo = ctx.slots[i];
+        if (!varinfo.used) {
+            varinfo.usedUndef = false;
+            continue;
+        }
         jl_value_t *jt = varinfo.value.typ;
         assert(!varinfo.boxroot); // variables shouldn't have memory locs already
         if (varinfo.value.constant) {
             // no need to explicitly load/store a constant/ghost value
-            alloc_def_flag(varinfo, &ctx);
+            alloc_def_flag(ctx, varinfo);
             continue;
         }
         else if (varinfo.isArgument) {
@@ -4767,36 +5043,65 @@ static std::unique_ptr<Module> emit_function(
             if (i != (size_t)ctx.vaSlot && isbits_spec(jt, false))
                 continue;
         }
+        else if (jl_is_uniontype(jt)) {
+            bool allunbox;
+            size_t align;
+            Value *lv = try_emit_union_alloca(ctx, (jl_uniontype_t*)jt, allunbox, align);
+            if (lv) {
+                lv->setName(jl_symbol_name(s));
+                varinfo.value = mark_julia_slot(lv, jt, NULL, tbaa_stack);
+                varinfo.pTIndex = emit_static_alloca(ctx, T_int8);
+                // the slot is not immutable if there are multiple assignments
+                varinfo.value.isimmutable &= varinfo.isSA;
+            }
+            else if (allunbox) {
+                // all ghost values just need a selector allocated
+                AllocaInst *lv = emit_static_alloca(ctx, T_int8);
+                lv->setName(jl_symbol_name(s));
+                varinfo.pTIndex = lv;
+                varinfo.value.tbaa = NULL;
+                varinfo.value.isboxed = false;
+                varinfo.value.isimmutable = true;
+            }
+            if (lv || allunbox)
+                alloc_def_flag(ctx, varinfo);
+            if (allunbox)
+                continue;
+        }
         else if (isbits_spec(jt, false)) {
             bool isboxed;
             Type *vtype = julia_type_to_llvm(jt, &isboxed);
             assert(!isboxed);
             assert(!type_is_ghost(vtype) && "constants should already be handled");
             // CreateAlloca is OK during prologue setup
-            Value *lv = builder.CreateAlloca(vtype, NULL, jl_symbol_name(s));
-            varinfo.value = mark_julia_slot(lv, jt, tbaa_stack);
+            Value *lv = ctx.builder.CreateAlloca(vtype, NULL, jl_symbol_name(s));
+            varinfo.value = mark_julia_slot(lv, jt, NULL, tbaa_stack);
             // slot is not immutable if there are multiple assignments
             varinfo.value.isimmutable &= varinfo.isSA;
-            alloc_def_flag(varinfo, &ctx);
-#if JL_LLVM_VERSION >= 30600
+            alloc_def_flag(ctx, varinfo);
             if (ctx.debug_enabled && varinfo.dinfo) {
                 assert((Metadata*)varinfo.dinfo->getType() != jl_pvalue_dillvmt);
                 dbuilder.insertDeclare(lv, varinfo.dinfo, dbuilder.createExpression(),
-#if JL_LLVM_VERSION >= 30700
                                        topdebugloc,
-#endif
-                                       builder.GetInsertBlock());
+                                       ctx.builder.GetInsertBlock());
             }
-#endif
             continue;
         }
         if (!varinfo.isArgument || // always need a slot if the variable is assigned
             specsig || // for arguments, give them stack slots if they aren't in `argArray` (otherwise, will use that pointer)
-            (va && (int)i == ctx.vaSlot && varinfo.escapes) || // or it's the va arg tuple
-            (s != unused_sym && i == 0)) { // or it is the first argument (which isn't in `argArray`)
-            AllocaInst *av = new AllocaInst(T_pjlvalue, jl_symbol_name(s), /*InsertBefore*/ctx.ptlsStates);
+            (va && (int)i == ctx.vaSlot) || // or it's the va arg tuple
+            i == 0) { // or it is the first argument (which isn't in `argArray`)
+#if JL_LLVM_VERSION >= 50000
+            AllocaInst *av = new AllocaInst(T_prjlvalue, 0,
+#else
+            AllocaInst *av = new AllocaInst(T_prjlvalue,
+#endif
+                jl_symbol_name(s), /*InsertBefore*/ctx.ptlsStates);
+            StoreInst *SI = new StoreInst(
+                ConstantPointerNull::get(cast<PointerType>(T_prjlvalue)), av,
+                false);
+            SI->insertAfter(ctx.ptlsStates);
             varinfo.boxroot = av;
-#if JL_LLVM_VERSION >= 30600
             if (ctx.debug_enabled && varinfo.dinfo) {
                 DIExpression *expr;
                 if ((Metadata*)varinfo.dinfo->getType() == jl_pvalue_dillvmt) {
@@ -4808,19 +5113,16 @@ static std::unique_ptr<Module> emit_function(
                     expr = dbuilder.createExpression(addr);
                 }
                 dbuilder.insertDeclare(av, varinfo.dinfo, expr,
-#if JL_LLVM_VERSION >= 30700
                                             topdebugloc,
-#endif
-                                builder.GetInsertBlock());
+                                ctx.builder.GetInsertBlock());
             }
-#endif
         }
-        maybe_alloc_arrayvar(i, &ctx);
+        maybe_alloc_arrayvar(ctx, i);
     }
 
     // step 9. move args into local variables
     Function::arg_iterator AI = f->arg_begin();
-    if (ctx.sret)
+    if (ctx.has_sret)
         AI++; // skip sret slot
     for (i = 0; i < nreq; i++) {
         jl_sym_t *s = (jl_sym_t*)jl_array_ptr_ref(src->slotnames, i);
@@ -4845,22 +5147,26 @@ static std::unique_ptr<Module> emit_function(
                     theArg = ghostValue(argType);
                 }
                 else if (llvmArgType->isAggregateType()) {
-                    theArg = mark_julia_slot(&*AI++, argType, tbaa_const); // this argument is by-pointer
+                    Argument *Arg = &*AI++;
+                    maybe_mark_argument_dereferenceable(Arg, argType);
+                    theArg = mark_julia_slot(Arg, argType, NULL, tbaa_const); // this argument is by-pointer
                     theArg.isimmutable = true;
                 }
                 else {
-                    theArg = mark_julia_type(&*AI++, isboxed, argType, &ctx, /*needsgcroot*/false);
+                    Argument *Arg = &*AI++;
+                    if (isboxed)
+                        maybe_mark_argument_dereferenceable(Arg, argType);
+                    theArg = mark_julia_type(ctx, Arg, isboxed, argType, /*needsgcroot*/false);
                 }
             }
             else {
                 if (i == 0) {
                     // first (function) arg is separate in jlcall
-                    theArg = mark_julia_type(fArg, true, vi.value.typ, &ctx, /*needsgcroot*/false);
+                    theArg = mark_julia_type(ctx, fArg, true, vi.value.typ, /*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);
-#if JL_LLVM_VERSION >= 30600
+                    Value *argPtr = ctx.builder.CreateGEP(argArray, ConstantInt::get(T_size, i-1));
+                    theArg = mark_julia_type(ctx, ctx.builder.CreateLoad(argPtr), true, vi.value.typ, /*needsgcroot*/false);
                     if (ctx.debug_enabled && vi.dinfo && !vi.boxroot && !vi.value.V) {
                         SmallVector<uint64_t, 8> addr;
                         addr.push_back(llvm::dwarf::DW_OP_deref);
@@ -4869,12 +5175,9 @@ static std::unique_ptr<Module> emit_function(
                         if ((Metadata*)vi.dinfo->getType() != jl_pvalue_dillvmt)
                             addr.push_back(llvm::dwarf::DW_OP_deref);
                         dbuilder.insertDeclare(pargArray, vi.dinfo, dbuilder.createExpression(addr),
-#if JL_LLVM_VERSION >= 30700
                                         topdebugloc,
-#endif
-                                        builder.GetInsertBlock());
+                                        ctx.builder.GetInsertBlock());
                     }
-#endif
                 }
             }
 
@@ -4882,73 +5185,52 @@ static std::unique_ptr<Module> emit_function(
                 assert(vi.value.V == NULL && "unexpected variable slot created for argument");
                 // keep track of original (possibly boxed) value to avoid re-boxing or moving
                 vi.value = theArg;
-#if JL_LLVM_VERSION >= 30600
                 if (specsig && theArg.V && ctx.debug_enabled && vi.dinfo) {
                     SmallVector<uint64_t, 8> addr;
                     if ((Metadata*)vi.dinfo->getType() != jl_pvalue_dillvmt && theArg.ispointer())
                         addr.push_back(llvm::dwarf::DW_OP_deref);
                     AllocaInst *parg = dyn_cast<AllocaInst>(theArg.V);
                     if (!parg) {
-                        parg = builder.CreateAlloca(theArg.V->getType(), NULL, jl_symbol_name(s));
-                        builder.CreateStore(theArg.V, parg);
+                        parg = ctx.builder.CreateAlloca(theArg.V->getType(), NULL, jl_symbol_name(s));
+                        ctx.builder.CreateStore(theArg.V, parg);
                     }
                     dbuilder.insertDeclare(parg, vi.dinfo, dbuilder.createExpression(addr),
-#if JL_LLVM_VERSION >= 30700
                                                 topdebugloc,
-#endif
-                                                builder.GetInsertBlock());
+                                                ctx.builder.GetInsertBlock());
                 }
-#endif
             }
             else {
-                Value *argp = boxed(theArg, &ctx, false); // skip the temporary gcroot since it would be folded to argp anyways
-                builder.CreateStore(argp, vi.boxroot);
+                Value *argp = boxed(ctx, theArg, false); // skip the temporary gcroot since it would be folded to argp anyways
+                ctx.builder.CreateStore(argp, vi.boxroot);
                 if (!theArg.isboxed)
-                    emit_local_root(&ctx, &vi); // create a root for vi
+                    emit_local_root(ctx, &vi); // create a root for vi
             }
             // get arrayvar data if applicable
             if (arrayvars.find(i) != arrayvars.end()) {
                 jl_arrayvar_t av = arrayvars[i];
-                assign_arrayvar(av, theArg, &ctx);
+                assign_arrayvar(ctx, av, theArg);
             }
         }
     }
 
-    // step 10. allocate rest argument if necessary
+    // step 10. allocate rest argument
     if (va && ctx.vaSlot != -1) {
         jl_varinfo_t &vi = ctx.slots[ctx.vaSlot];
-        if (!vi.escapes) {
-            ctx.vaStack = true;
-        }
-        else if (!vi.value.constant) {
-            // restarg = jl_f_tuple(NULL, &args[nreq], nargs-nreq)
-            if (vi.boxroot != NULL) {
-#if JL_LLVM_VERSION >= 30700
-                Value *restTuple =
-                    builder.CreateCall(prepare_call(jltuple_func), {V_null,
-                                        builder.CreateGEP(argArray,
-                                                          ConstantInt::get(T_size,nreq-1)),
-                                        builder.CreateSub(argCount,
-                                                          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-1)),
-                                        builder.CreateSub(argCount,
-                                                          ConstantInt::get(T_int32,nreq-1)));
-#endif
-                builder.CreateStore(restTuple, vi.boxroot);
-                emit_local_root(&ctx, &vi); // create a root for vi
-            }
-            else {
-                // TODO: Perhaps allow this in the future, but for now since varargs
-                // are always unspecialized we don't
-                assert(false);
-            }
+        if (vi.value.constant || !vi.used) {
+            assert(vi.boxroot == NULL);
         }
         else {
-            assert(vi.boxroot == NULL);
+            // restarg = jl_f_tuple(NULL, &args[nreq], nargs - nreq)
+            CallInst *restTuple =
+                ctx.builder.CreateCall(prepare_call(jltuple_func),
+                        { maybe_decay_untracked(V_null),
+                          ctx.builder.CreateGEP(argArray,
+                                  ConstantInt::get(T_size, nreq - 1)),
+                          ctx.builder.CreateSub(argCount,
+                                  ConstantInt::get(T_int32, nreq - 1)) });
+            restTuple->setAttributes(jltuple_func->getAttributes());
+            ctx.builder.CreateStore(restTuple, vi.boxroot);
+            emit_local_root(ctx, &vi); // create a root for vi
         }
     }
 
@@ -4961,11 +5243,7 @@ static std::unique_ptr<Module> emit_function(
     };
     struct DbgState {
         DebugLoc loc;
-#if JL_LLVM_VERSION >= 30700
         DISubprogram *sp;
-#else
-        DISubprogram sp;
-#endif
         StringRef file;
         ssize_t line;
         bool in_user_code;
@@ -5002,7 +5280,7 @@ static std::unique_ptr<Module> emit_function(
         cur_prop.is_poploc = false;
         jl_value_t *stmt = jl_array_ptr_ref(stmts, i);
         jl_expr_t *expr = jl_is_expr(stmt) ? (jl_expr_t*)stmt : nullptr;
-#ifndef NDEBUG
+#ifndef JL_NDEBUG
         if (jl_is_labelnode(stmt)) {
             size_t lname = jl_labelnode_label(stmt);
             if (lname != i + 1) {
@@ -5022,11 +5300,7 @@ static std::unique_ptr<Module> emit_function(
             }
             MDNode *inlinedAt = NULL;
             if (DI_stack.size() > 0) {
-#if JL_LLVM_VERSION >= 30700
                 inlinedAt = DI_stack.back().loc;
-#else
-                inlinedAt = DI_stack.back().loc.getAsMDNode(jl_LLVMContext);
-#endif
             }
             if (ctx.debug_enabled)
                 cur_prop.loc = DebugLoc::get(lno, 0, SP, inlinedAt);
@@ -5042,11 +5316,7 @@ static std::unique_ptr<Module> emit_function(
                 jl_sym_t *filesym = (jl_sym_t*)jl_exprarg(expr, 1);
                 if (filesym != empty_sym)
                     new_filename = jl_symbol_name(filesym);
-#if JL_LLVM_VERSION >= 30700
                 DIFile *new_file = nullptr;
-#else
-                DIFile new_file;
-#endif
                 if (ctx.debug_enabled)
                     new_file = dbuilder.createFile(new_filename, ".");
                 DI_stack.push_back(DbgState{cur_prop.loc, SP,
@@ -5086,11 +5356,7 @@ static std::unique_ptr<Module> emit_function(
                                                  true,
                                                  nullptr);
                     MDNode *inlinedAt = NULL;
-#if JL_LLVM_VERSION >= 30700
                     inlinedAt = cur_prop.loc;
-#else
-                    inlinedAt = cur_prop.loc.getAsMDNode(jl_LLVMContext);
-#endif
                     cur_prop.loc = DebugLoc::get(inlined_func_lineno,
                                                  0, SP, inlinedAt);
                 }
@@ -5150,15 +5416,15 @@ static std::unique_ptr<Module> emit_function(
             cursor = seq_next;
             return;
         }
-        if (!builder.GetInsertBlock()->getTerminator())
-            builder.CreateUnreachable();
+        if (!ctx.builder.GetInsertBlock()->getTerminator())
+            ctx.builder.CreateUnreachable();
         if (workstack.empty()) {
             cursor = -1;
             linear_codegen = false;
             return;
         }
         auto &item = workstack.back();
-        builder.SetInsertPoint(item.second);
+        ctx.builder.SetInsertPoint(item.second);
         linear_codegen = (item.first - cursor) == 1;
         cursor = item.first;
         workstack.pop_back();
@@ -5173,14 +5439,14 @@ static std::unique_ptr<Module> emit_function(
     // label and the cursor is set to the next statement to process
     auto handle_label = [&] (int lname, bool unconditional) {
         auto &bb = labels[lname];
-        BasicBlock *cur_bb = builder.GetInsertBlock();
+        BasicBlock *cur_bb = ctx.builder.GetInsertBlock();
         // Check if we've already visited this label
         if (bb) {
             // Already in the work list
             // branch to it and pop one from the work list
             if (unconditional) {
                 if (!cur_bb->getTerminator())
-                    builder.CreateBr(bb);
+                    ctx.builder.CreateBr(bb);
                 find_next_stmt(-1);
             }
             return bb;
@@ -5198,8 +5464,8 @@ static std::unique_ptr<Module> emit_function(
                                     "L" + std::to_string(lname), f);
             if (unconditional) {
                 if (!cur_bb->getTerminator())
-                    builder.CreateBr(bb);
-                builder.SetInsertPoint(bb);
+                    ctx.builder.CreateBr(bb);
+                ctx.builder.SetInsertPoint(bb);
             }
             else {
                 add_to_list(lname, bb);
@@ -5211,29 +5477,29 @@ static std::unique_ptr<Module> emit_function(
     };
 
     auto do_coverage = [&] (bool in_user_code) {
-        if (!JL_FEAT_TEST(&ctx, code_coverage)) return false;
+        if (!JL_FEAT_TEST(ctx, code_coverage)) return false;
         return (coverage_mode == JL_LOG_ALL ||
                 (coverage_mode == JL_LOG_USER && in_user_code));
     };
     auto do_malloc_log = [&] (bool in_user_code) {
-        if (!JL_FEAT_TEST(&ctx, track_allocations)) return false;
+        if (!JL_FEAT_TEST(ctx, track_allocations)) return false;
         return (malloc_log_mode == JL_LOG_ALL ||
                 (malloc_log_mode == JL_LOG_USER && in_user_code));
     };
 
     // Handle the implicit first line number node.
     if (ctx.debug_enabled)
-        builder.SetCurrentDebugLocation(topdebugloc);
+        ctx.builder.SetCurrentDebugLocation(topdebugloc);
     if (coverage_mode != JL_LOG_NONE && do_coverage(in_user_mod(ctx.module)))
-        coverageVisitLine(filename, toplineno);
+        coverageVisitLine(ctx, filename, toplineno);
     while (cursor != -1) {
         auto &props = stmtprops[cursor];
         if ((props.loc_changed || !linear_codegen) && ctx.debug_enabled)
-            builder.SetCurrentDebugLocation(props.loc);
+            ctx.builder.SetCurrentDebugLocation(props.loc);
         // Disable coverage for pop_loc, it doesn't start a new expression
         if (props.loc_changed && do_coverage(props.in_user_code) &&
             !props.is_poploc) {
-            coverageVisitLine(props.file, props.line);
+            coverageVisitLine(ctx, props.file, props.line);
         }
         ctx.is_inbounds = props.is_inbounds;
         jl_value_t *stmt = jl_array_ptr_ref(stmts, cursor);
@@ -5245,36 +5511,108 @@ static std::unique_ptr<Module> emit_function(
             continue;
         }
         if (expr && expr->head == return_sym) {
-            bool retboxed = false;
-            Type *retty;
-            if (specsig) {
-                retty = julia_type_to_llvm(jlrettype, &retboxed);
-            }
-            else {
-                retty = T_pjlvalue;
-                retboxed = true;
+            // this is basically a copy of emit_assignment,
+            // but where the assignment slot is the retval
+            jl_cgval_t retvalinfo = emit_expr(ctx, jl_exprarg(expr, 0));
+            retvalinfo = convert_julia_type(ctx, retvalinfo, jlrettype, /*needs-root*/false);
+            if (retvalinfo.typ == jl_bottom_type) {
+                ctx.builder.CreateUnreachable();
+                find_next_stmt(-1);
+                continue;
             }
-            jl_cgval_t retvalinfo = emit_expr(jl_exprarg(expr, 0), &ctx);
+
+            Value *isboxed_union = NULL;
             Value *retval;
-            if (retboxed) {
-                retval = boxed(retvalinfo, &ctx, false); // skip the gcroot on the return path
-                assert(!ctx.sret);
+            Value *sret = ctx.has_sret ? &*f->arg_begin() : NULL;
+            Type *retty = f->getReturnType();
+            switch (returninfo.cc) {
+            case jl_returninfo_t::Boxed:
+                retval = boxed(ctx, retvalinfo, false); // skip the gcroot on the return path
+                break;
+            case jl_returninfo_t::Register:
+                if (type_is_ghost(retty))
+                    retval = NULL;
+                else
+                    retval = emit_unbox(ctx, retty, retvalinfo, jlrettype);
+                break;
+            case jl_returninfo_t::SRet:
+                retval = NULL;
+                break;
+            case jl_returninfo_t::Union: {
+                Value *data, *tindex;
+                if (retvalinfo.TIndex) {
+                    tindex = retvalinfo.TIndex;
+                    if (retvalinfo.V == NULL) {
+                        // treat this as a simple Ghosts
+                        data = maybe_decay_untracked(V_null);
+                        sret = NULL;
+                    }
+                    else {
+                        data = maybe_decay_untracked(V_null);
+                        if (retvalinfo.ispointer() && !isa<AllocaInst>(retvalinfo.V)) {
+                            // also need to account for the possibility the return object is boxed
+                            // and avoid / skip copying it to the stack
+                            isboxed_union = ctx.builder.CreateICmpNE(
+                                    ctx.builder.CreateAnd(tindex, ConstantInt::get(T_int8, 0x80)),
+                                    ConstantInt::get(T_int8, 0));
+                            // Lift the select, because gcroot may be NULL if
+                            // there's no boxed value.
+                            if (isa<Constant>(isboxed_union))
+                                data = cast<ConstantInt>(isboxed_union)->isZero() ? data : ctx.builder.CreateLoad(retvalinfo.gcroot);
+                            else
+                                data = ctx.builder.CreateSelect(isboxed_union,
+                                    ctx.builder.CreateLoad(retvalinfo.gcroot),
+                                    data);
+                        }
+                    }
+                }
+                else {
+                    // treat this as a simple boxed returninfo
+                    //assert(retvalinfo.isboxed);
+                    tindex = compute_tindex_unboxed(ctx, retvalinfo, jlrettype);
+                    tindex = ctx.builder.CreateOr(tindex, ConstantInt::get(T_int8, 0x80));
+                    data = maybe_decay_untracked(boxed(ctx, retvalinfo, false)); // skip the gcroot on the return path
+                    sret = NULL;
+                }
+                retval = UndefValue::get(retty);
+                retval = ctx.builder.CreateInsertValue(retval, data, 0);
+                retval = ctx.builder.CreateInsertValue(retval, tindex, 1);
+                break;
             }
-            else if (!type_is_ghost(retty)) {
-                retval = emit_unbox(retty, retvalinfo, jlrettype,
-                                    ctx.sret ? &*ctx.f->arg_begin() : NULL);
+            case jl_returninfo_t::Ghosts:
+                retval = compute_tindex_unboxed(ctx, retvalinfo, jlrettype);
+                break;
             }
-            else { // undef return type
-                retval = NULL;
+            if (sret) {
+                if (retvalinfo.ispointer()) {
+                    if (returninfo.cc == jl_returninfo_t::SRet) {
+                        assert(jl_is_concrete_type(jlrettype));
+                        Value *copy_bytes = ConstantInt::get(T_int32, jl_datatype_size(jlrettype));
+                        ctx.builder.CreateMemCpy(sret,
+                                             data_pointer(ctx, retvalinfo, T_pint8),
+                                             copy_bytes,
+                                             returninfo.union_minalign);
+                    }
+                    else {
+                        emit_unionmove(ctx, sret, retvalinfo, isboxed_union, false, NULL);
+                    }
+                }
+                else {
+                    Type *store_ty = julia_type_to_llvm(retvalinfo.typ);
+                    Type *dest_ty = store_ty->getPointerTo();
+                    if (dest_ty != sret->getType())
+                        sret = emit_bitcast(ctx, sret, dest_ty);
+                    ctx.builder.CreateStore(emit_unbox(ctx, store_ty, retvalinfo, retvalinfo.typ), sret);
+                }
             }
+
             if (do_malloc_log(props.in_user_code) && props.line != -1)
-                mallocVisitLine(props.file, props.line);
+                mallocVisitLine(ctx, props.file, props.line);
             if (toplevel)
-                builder.CreateStore(last_age, ctx.world_age_field);
-            if (type_is_ghost(retty) || ctx.sret)
-                builder.CreateRetVoid();
-            else
-                builder.CreateRet(retval);
+                ctx.builder.CreateStore(last_age, ctx.world_age_field);
+            assert(type_is_ghost(retty) || returninfo.cc == jl_returninfo_t::SRet ||
+                retval->getType() == ctx.f->getReturnType());
+            ctx.builder.CreateRet(retval);
             find_next_stmt(-1);
             continue;
         }
@@ -5287,67 +5625,101 @@ static std::unique_ptr<Module> emit_function(
             jl_value_t **args = (jl_value_t**)jl_array_data(expr->args);
             jl_value_t *cond = args[0];
             int lname = jl_unbox_long(args[1]);
-            Value *isfalse = emit_condition(cond, "if", &ctx);
+            Value *isfalse = emit_condition(ctx, cond, "if");
             if (do_malloc_log(props.in_user_code) && props.line != -1)
-                mallocVisitLine(props.file, props.line);
+                mallocVisitLine(ctx, props.file, props.line);
             BasicBlock *ifso = BasicBlock::Create(jl_LLVMContext, "if", f);
             BasicBlock *ifnot = handle_label(lname, false);
             // Any branches treated as constant in type inference should be
             // eliminated before running
-            builder.CreateCondBr(isfalse, ifnot, ifso);
-            builder.SetInsertPoint(ifso);
+            ctx.builder.CreateCondBr(isfalse, ifnot, ifso);
+            ctx.builder.SetInsertPoint(ifso);
         }
         else if (expr && expr->head == enter_sym) {
             jl_value_t **args = (jl_value_t**)jl_array_data(expr->args);
             assert(jl_is_long(args[0]));
             int lname = jl_unbox_long(args[0]);
-            CallInst *sj = builder.CreateCall(prepare_call(except_enter_func));
+            CallInst *sj = ctx.builder.CreateCall(prepare_call(except_enter_func));
             // We need to mark this on the call site as well. See issue #6757
             sj->setCanReturnTwice();
-            Value *isz = builder.CreateICmpEQ(sj, ConstantInt::get(T_int32, 0));
+            Value *isz = ctx.builder.CreateICmpEQ(sj, ConstantInt::get(T_int32, 0));
             BasicBlock *tryblk = BasicBlock::Create(jl_LLVMContext, "try", f);
             BasicBlock *handlr = handle_label(lname, false);
 #ifdef _OS_WINDOWS_
             BasicBlock *cond_resetstkoflw_blk = BasicBlock::Create(jl_LLVMContext, "cond_resetstkoflw", f);
             BasicBlock *resetstkoflw_blk = BasicBlock::Create(jl_LLVMContext, "resetstkoflw", f);
-            builder.CreateCondBr(isz, tryblk, cond_resetstkoflw_blk);
-            builder.SetInsertPoint(cond_resetstkoflw_blk);
-            builder.CreateCondBr(builder.CreateICmpEQ(
-                                     literal_pointer_val(jl_stackovf_exception),
-                                     builder.CreateLoad(emit_exc_in_transit(&ctx), true)),
+            ctx.builder.CreateCondBr(isz, tryblk, cond_resetstkoflw_blk);
+            ctx.builder.SetInsertPoint(cond_resetstkoflw_blk);
+            ctx.builder.CreateCondBr(ctx.builder.CreateICmpEQ(
+                                     literal_pointer_val(ctx, jl_stackovf_exception),
+                                     ctx.builder.CreateLoad(emit_exc_in_transit(ctx), true)),
                                  resetstkoflw_blk, handlr);
-            builder.SetInsertPoint(resetstkoflw_blk);
-            builder.CreateCall(prepare_call(resetstkoflw_func)
-#                          if JL_LLVM_VERSION >= 30700
-                               , {}
-#                          endif
-                );
-            builder.CreateBr(handlr);
+            ctx.builder.SetInsertPoint(resetstkoflw_blk);
+            ctx.builder.CreateCall(prepare_call(resetstkoflw_func), {});
+            ctx.builder.CreateBr(handlr);
 #else
-            builder.CreateCondBr(isz, tryblk, handlr);
+            ctx.builder.CreateCondBr(isz, tryblk, handlr);
 #endif
-            builder.SetInsertPoint(tryblk);
+            ctx.builder.SetInsertPoint(tryblk);
         }
         else {
-            emit_stmtpos(stmt, &ctx);
+            emit_stmtpos(ctx, stmt);
             if (do_malloc_log(props.in_user_code) && props.line != -1) {
-                mallocVisitLine(props.file, props.line);
+                mallocVisitLine(ctx, props.file, props.line);
             }
         }
         find_next_stmt(cursor + 1);
     }
-    builder.SetCurrentDebugLocation(noDbg);
-    builder.ClearInsertionPoint();
+    ctx.builder.SetCurrentDebugLocation(noDbg);
+    ctx.builder.ClearInsertionPoint();
 
     // step 13. Perform any delayed instantiations
     if (ctx.debug_enabled) {
         dbuilder.finalize();
     }
 
+    if (ctx.vaSlot > 0) {
+        // remove VA allocation if we never referenced it
+        Instruction *root = cast_or_null<Instruction>(ctx.slots[ctx.vaSlot].boxroot);
+        if (root) {
+            Instruction *store_value = NULL;
+            bool have_real_use = false;
+            for (Use &U : root->uses()) {
+                User *RU = U.getUser();
+                if (StoreInst *SRU = dyn_cast<StoreInst>(RU)) {
+                    if (!store_value)
+                        store_value = dyn_cast<Instruction>(SRU->getValueOperand());
+                }
+                else if (isa<DbgInfoIntrinsic>(RU)) {
+                }
+                else if (isa<LoadInst>(RU) && RU->use_empty()) {
+                }
+                else {
+                    have_real_use = true;
+                    break;
+                }
+            }
+            if (!have_real_use) {
+                Instruction *use = NULL;
+                for (Use &U : root->uses()) {
+                    if (use) // erase after the iterator moves on
+                        use->eraseFromParent();
+                    User *RU = U.getUser();
+                    use = cast<Instruction>(RU);
+                }
+                if (use)
+                    use->eraseFromParent();
+                root->eraseFromParent();
+                if (store_value)
+                    store_value->eraseFromParent();
+            }
+        }
+    }
+
     // copy ctx.roots into m->roots
     // if we created any new roots during codegen
     if (ctx.roots) {
-        jl_method_t *m = lam->def;
+        jl_method_t *m = lam->def.method;
         JL_LOCK(&m->writelock);
         if (m->roots == NULL) {
             m->roots = ctx.roots;
@@ -5383,20 +5755,8 @@ std::pair<MDNode*,MDNode*> tbaa_make_child(const char *name, MDNode *parent=null
     static MDNode *tbaa_root = mbuilder->createTBAARoot("jtbaa");
     if (!parent)
         parent = tbaa_root;
-#if JL_LLVM_VERSION >= 30700
     MDNode *scalar = mbuilder->createTBAAScalarTypeNode(name, parent);
     MDNode *n = mbuilder->createTBAAStructTagNode(scalar, scalar, 0, isConstant);
-#else
-    MDNode *n = mbuilder->createTBAANode(name, parent, isConstant);
-    MDNode *scalar = n;
-#if JL_LLVM_VERSION < 30600
-#if JL_LLVM_VERSION >= 30500
-    n->setValueName(ValueName::Create(name));
-#else
-    n->setValueName(ValueName::Create(name, name + strlen(name)));
-#endif
-#endif
-#endif
     return std::make_pair(n, scalar);
 }
 
@@ -5447,42 +5807,27 @@ extern "C" void jl_fptr_to_llvm(jl_fptr_t fptr, jl_method_instance_t *lam, int s
             funcName << "jlsysw_"; // it's a specsig wrapper
         else if (lam->jlcall_api == 1)
             funcName << "jsys1_"; // it's a jlcall without a specsig
-        const char* unadorned_name = jl_symbol_name(lam->def->name);
-#if (defined(_OS_LINUX_) && JL_LLVM_VERSION < 30400)
-        if (unadorned_name[0] == '@')
-            unadorned_name++;
-#endif
+        const char* unadorned_name = jl_symbol_name(lam->def.method->name);
         funcName << unadorned_name << "_" << globalUnique++;
-        if (specsig) { // assumes !va
-            bool sret;
-            Function *f = get_specsig_function(shadow_output, funcName.str(), lam->specTypes, lam->rettype, sret);
+        Function *f = jlcall_func_to_llvm(funcName.str(), fptr, NULL);
+        if (specsig) {
             if (lam->functionObjectsDecls.specFunctionObject == NULL) {
-                lam->functionObjectsDecls.specFunctionObject = (void*)f;
+                lam->functionObjectsDecls.specFunctionObject = strdup(f->getName().str().c_str());
             }
-            add_named_global(f, fptr);
         }
         else {
-            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.str(), fptr, shadow_output);
+            assert(lam->fptr == NULL);
+            lam->fptr = fptr;
+            if (lam->jlcall_api == 1) {
                 if (lam->functionObjectsDecls.functionObject == NULL) {
-                    lam->functionObjectsDecls.functionObject = (void*)f;
-                    assert(lam->fptr == NULL);
-                    lam->fptr = fptr;
+                    lam->functionObjectsDecls.functionObject = strdup(f->getName().str().c_str());
                 }
             }
         }
+        delete f;
     }
 }
 
-#if LLVM_VERSION_MAJOR == 3 && LLVM_VERSION_MINOR == 3 && defined(SYSTEM_LLVM)
-#define INSTCOMBINE_BUG
-#define V128_BUG
-#endif
-
 static void init_julia_llvm_meta(void)
 {
     tbaa_gcframe = tbaa_make_child("jtbaa_gcframe").first;
@@ -5497,6 +5842,7 @@ static void init_julia_llvm_meta(void)
     tbaa_mutab = tbaa_make_child("jtbaa_mutab", tbaa_value_scalar).first;
     tbaa_immut = tbaa_make_child("jtbaa_immut", tbaa_value_scalar).first;
     tbaa_arraybuf = tbaa_make_child("jtbaa_arraybuf", tbaa_data_scalar).first;
+    tbaa_ptrarraybuf = tbaa_make_child("jtbaa_ptrarraybuf", tbaa_data_scalar).first;
     MDNode *tbaa_array_scalar;
     std::tie(tbaa_array, tbaa_array_scalar) = tbaa_make_child("jtbaa_array");
     tbaa_arrayptr = tbaa_make_child("jtbaa_arrayptr", tbaa_array_scalar).first;
@@ -5539,47 +5885,32 @@ static void init_julia_llvm_env(Module *m)
     T_void = Type::getVoidTy(jl_LLVMContext);
     T_pvoidfunc = FunctionType::get(T_void, /*isVarArg*/false)->getPointerTo();
 
+    auto T_pint8_derived = PointerType::get(T_int8, AddressSpace::Derived);
+
     // This type is used to create undef Values for use in struct declarations to skip indices
     NoopType = ArrayType::get(T_int1, 0);
 
     // add needed base debugging definitions to our LLVM environment
     DIBuilder dbuilder(*m);
-#if JL_LLVM_VERSION >= 30700
     DIFile *julia_h = dbuilder.createFile("julia.h","");
     jl_value_dillvmt = dbuilder.createStructType(nullptr,
-#else
-    DIFile julia_h = dbuilder.createFile("julia.h","");
-    jl_value_dillvmt = dbuilder.createStructType(DIDescriptor(),
-#endif
         "jl_value_t",
         julia_h,
         71, // At the time of this writing. Not sure if it's worth it to keep this in sync
         0 * 8, // sizeof(jl_value_t) * 8,
         __alignof__(void*) * 8, // __alignof__(jl_value_t) * 8,
         DIFlagZero, // Flags
-#if JL_LLVM_VERSION >= 30700
         nullptr,    // Derived from
         nullptr);  // Elements - will be corrected later
-#else
-        DIType(), // Derived from
-        DIArray()); // Elements - will be corrected later
-#endif
 
     jl_pvalue_dillvmt = dbuilder.createPointerType(jl_value_dillvmt, sizeof(jl_value_t*) * 8,
                                                    __alignof__(jl_value_t*) * 8);
 
-#if JL_LLVM_VERSION >= 30600
     SmallVector<llvm::Metadata *, 1> Elts;
     std::vector<Metadata*> diargs(0);
     Elts.push_back(jl_pvalue_dillvmt);
     dbuilder.replaceArrays(jl_value_dillvmt,
        dbuilder.getOrCreateArray(Elts));
-#else
-    SmallVector<llvm::Value *, 1> Elts;
-    std::vector<Value*> diargs(0);
-    Elts.push_back(jl_pvalue_dillvmt);
-    jl_value_dillvmt.setTypeArray(dbuilder.getOrCreateArray(Elts));
-#endif
 
     jl_ppvalue_dillvmt = dbuilder.createPointerType(jl_pvalue_dillvmt,sizeof(jl_value_t**)*8,
                                                     __alignof__(jl_value_t**)*8);
@@ -5590,25 +5921,16 @@ 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));
 
-#if JL_LLVM_VERSION >= 30800
     jl_di_func_sig = dbuilder.createSubroutineType(
         dbuilder.getOrCreateTypeArray(diargs));
     jl_di_func_null_sig = dbuilder.createSubroutineType(
         dbuilder.getOrCreateTypeArray(None));
-#elif JL_LLVM_VERSION >= 30600
-    jl_di_func_sig = dbuilder.createSubroutineType(julia_h,
-        dbuilder.getOrCreateTypeArray(diargs));
-    jl_di_func_null_sig = dbuilder.createSubroutineType(julia_h,
-        dbuilder.getOrCreateTypeArray(None));
-#else
-    jl_di_func_sig = dbuilder.createSubroutineType(julia_h,
-        dbuilder.getOrCreateArray(diargs));
-    jl_di_func_null_sig = dbuilder.createSubroutineType(julia_h,
-        dbuilder.getOrCreateArray(ArrayRef<Value*>()));
-#endif
 
-    T_pjlvalue = T_ppint8;
+    T_jlvalue = StructType::create(jl_LLVMContext, "jl_value_t");
+    T_pjlvalue = PointerType::get(T_jlvalue, 0);
+    T_prjlvalue = PointerType::get(T_jlvalue, AddressSpace::Tracked);
     T_ppjlvalue = PointerType::get(T_pjlvalue, 0);
+    T_pprjlvalue = PointerType::get(T_prjlvalue, 0);
     two_pvalue_llvmt.push_back(T_pjlvalue);
     two_pvalue_llvmt.push_back(T_pjlvalue);
     three_pvalue_llvmt.push_back(T_pjlvalue);
@@ -5622,14 +5944,14 @@ static void init_julia_llvm_env(Module *m)
     jl_init_jit(T_pjlvalue);
 
     std::vector<Type*> ftargs(0);
-    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);
+    ftargs.push_back(T_pprjlvalue); // linfo->sparam_vals
+    ftargs.push_back(T_prjlvalue);  // function
+    ftargs.push_back(T_pprjlvalue); // args[]
+    ftargs.push_back(T_int32);      // nargs
+    jl_func_sig_sparams = FunctionType::get(T_prjlvalue, 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);
+    jl_func_sig = FunctionType::get(T_prjlvalue, ftargs, false);
     assert(jl_func_sig != NULL);
 
     Type *vaelts[] = {T_pint8
@@ -5637,10 +5959,11 @@ static void init_julia_llvm_env(Module *m)
                       , T_size
 #endif
                       , T_int16
+                      , T_int16
     };
     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 =
+    jl_array_llvmt =
         StructType::create(jl_LLVMContext,
                            ArrayRef<Type*>(vaelts,sizeof(vaelts)/sizeof(vaelts[0])),
                            "jl_array_t");
@@ -5660,9 +5983,7 @@ static void init_julia_llvm_env(Module *m)
     global_jlvalue_to_llvm("jl_emptytuple", &jl_emptytuple, m);
     global_jlvalue_to_llvm("jl_diverror_exception", &jl_diverror_exception, m);
     global_jlvalue_to_llvm("jl_undefref_exception", &jl_undefref_exception, m);
-    global_jlvalue_to_llvm("jl_domain_exception", &jl_domain_exception, m);
     global_jlvalue_to_llvm("jl_overflow_exception", &jl_overflow_exception, m);
-    global_jlvalue_to_llvm("jl_inexact_exception", &jl_inexact_exception, m);
 
     jlRTLD_DEFAULT_var =
         new GlobalVariable(*m, T_pint8,
@@ -5711,10 +6032,12 @@ static void init_julia_llvm_env(Module *m)
     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 =
-            jl_emit_sysimg_slot(m, pfunctype, "jl_get_ptls_states.ptr",
-                                (uintptr_t)jl_get_ptls_states_getter(),
-                                jltls_states_func_idx);
+        jl_emit_sysimg_slot(m, pfunctype, "jl_get_ptls_states.ptr",
+                            (uintptr_t)jl_get_ptls_states_getter(),
+                            jltls_states_func_idx);
+        jl_emit_sysimg_slot(m, T_size, "jl_tls_offset.val",
+                            (uintptr_t)(jl_tls_offset == -1 ? 0 : jl_tls_offset),
+                            jltls_offset_idx);
     }
 #endif
 
@@ -5728,7 +6051,7 @@ static void init_julia_llvm_env(Module *m)
     add_named_global(jlerror_func, &jl_error);
 
     std::vector<Type*> args1_(0);
-    args1_.push_back(T_pjlvalue);
+    args1_.push_back(PointerType::get(T_jlvalue, AddressSpace::CalleeRooted));
     jlthrow_func =
         Function::Create(FunctionType::get(T_void, args1_, false),
                          Function::ExternalLinkage,
@@ -5736,6 +6059,8 @@ static void init_julia_llvm_env(Module *m)
     jlthrow_func->setDoesNotReturn();
     add_named_global(jlthrow_func, &jl_throw);
 
+    // Symbols are not gc-tracked, but we'll treat them as callee rooted anyway,
+    // because they may come from a gc-rooted location
     jlundefvarerror_func =
         Function::Create(FunctionType::get(T_void, args1_, false),
                          Function::ExternalLinkage,
@@ -5744,7 +6069,7 @@ static void init_julia_llvm_env(Module *m)
     add_named_global(jlundefvarerror_func, &jl_undefined_var_error);
 
     std::vector<Type*> args2_boundserrorv(0);
-    args2_boundserrorv.push_back(T_pjlvalue);
+    args2_boundserrorv.push_back(PointerType::get(T_jlvalue, AddressSpace::CalleeRooted));
     args2_boundserrorv.push_back(T_psize);
     args2_boundserrorv.push_back(T_size);
     jlboundserrorv_func =
@@ -5755,7 +6080,7 @@ static void init_julia_llvm_env(Module *m)
     add_named_global(jlboundserrorv_func, &jl_bounds_error_ints);
 
     std::vector<Type*> args2_boundserror(0);
-    args2_boundserror.push_back(T_pjlvalue);
+    args2_boundserror.push_back(PointerType::get(T_jlvalue, AddressSpace::CalleeRooted));
     args2_boundserror.push_back(T_size);
     jlboundserror_func =
         Function::Create(FunctionType::get(T_void, args2_boundserror, false),
@@ -5765,7 +6090,7 @@ static void init_julia_llvm_env(Module *m)
     add_named_global(jlboundserror_func, &jl_bounds_error_int);
 
     std::vector<Type*> args3_vboundserror(0);
-    args3_vboundserror.push_back(T_ppjlvalue);
+    args3_vboundserror.push_back(T_pprjlvalue);
     args3_vboundserror.push_back(T_size);
     args3_vboundserror.push_back(T_size);
     jlvboundserror_func =
@@ -5776,8 +6101,8 @@ static void init_julia_llvm_env(Module *m)
     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(T_pjlvalue);
+    args3_uboundserror.push_back(T_pint8_derived);
+    args3_uboundserror.push_back(T_prjlvalue);
     args3_uboundserror.push_back(T_size);
     jluboundserror_func =
         Function::Create(FunctionType::get(T_void, args3_uboundserror, false),
@@ -5803,19 +6128,19 @@ static void init_julia_llvm_env(Module *m)
     add_named_global(setjmp_func, &jl_setjmp_f);
 
     std::vector<Type*> args_memcmp(0);
-    args_memcmp.push_back(T_pint8);
-    args_memcmp.push_back(T_pint8);
+    args_memcmp.push_back(T_pint8_derived);
+    args_memcmp.push_back(T_pint8_derived);
     args_memcmp.push_back(T_size);
-    memcmp_func =
+    memcmp_derived_func =
         Function::Create(FunctionType::get(T_int32, args_memcmp, false),
                          Function::ExternalLinkage, "memcmp", m);
-    add_named_global(memcmp_func, &memcmp);
+    add_named_global(memcmp_derived_func, &memcmp);
 
     std::vector<Type*> te_args(0);
     te_args.push_back(T_pint8);
     te_args.push_back(T_pint8);
-    te_args.push_back(T_pjlvalue);
-    te_args.push_back(T_pjlvalue);
+    te_args.push_back(T_prjlvalue);
+    te_args.push_back(PointerType::get(T_jlvalue, AddressSpace::CalleeRooted));
     jltypeerror_func =
         Function::Create(FunctionType::get(T_void, te_args, false),
                          Function::ExternalLinkage,
@@ -5825,27 +6150,36 @@ static void init_julia_llvm_env(Module *m)
 
     std::vector<Type *> args_2ptrs(0);
     args_2ptrs.push_back(T_pjlvalue);
-    args_2ptrs.push_back(T_pjlvalue);
+    args_2ptrs.push_back(PointerType::get(T_jlvalue, AddressSpace::CalleeRooted));
     jlcheckassign_func =
         Function::Create(FunctionType::get(T_void, args_2ptrs, false),
                          Function::ExternalLinkage,
                          "jl_checked_assignment", m);
     add_named_global(jlcheckassign_func, &jl_checked_assignment);
 
-    std::vector<Type *> args_1ptr(0);
-    args_1ptr.push_back(T_pjlvalue);
+    std::vector<Type *> args_1binding(0);
+    args_1binding.push_back(T_pjlvalue);
     jldeclareconst_func =
-        Function::Create(FunctionType::get(T_void, args_1ptr, false),
+        Function::Create(FunctionType::get(T_void, args_1binding, false),
                          Function::ExternalLinkage,
                          "jl_declare_constant", m);
     add_named_global(jldeclareconst_func, &jl_declare_constant);
 
+    std::vector<Type *> args_2ptrs_(0);
+    args_2ptrs_.push_back(T_prjlvalue);
+    args_2ptrs_.push_back(T_prjlvalue);
     jlgetbindingorerror_func =
-        Function::Create(FunctionType::get(T_pjlvalue, 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, &jl_get_binding_or_error);
 
+    jlboundp_func =
+        Function::Create(FunctionType::get(T_int32, args_2ptrs_, false),
+                         Function::ExternalLinkage,
+                         "jl_boundp", m);
+    add_named_global(jlboundp_func, &jl_boundp);
+
     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);
@@ -5854,6 +6188,7 @@ static void init_julia_llvm_env(Module *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__apply_pure] = jlcall_func_to_llvm("jl_f__apply_pure", &jl_f__apply_pure, m);
+    builtin_func_map[jl_f__apply_latest] = jlcall_func_to_llvm("jl_f__apply_latest", &jl_f__apply_latest, 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);
@@ -5875,11 +6210,6 @@ static void init_julia_llvm_env(Module *m)
 
     jlapply2va_func = jlcall_func_to_llvm("jl_apply_2va", &jl_apply_2va, m);
 
-    jltypeassert_func = Function::Create(FunctionType::get(T_void, two_pvalue_llvmt, false),
-                                        Function::ExternalLinkage,
-                                        "jl_typeassert", m);
-    add_named_global(jltypeassert_func, &jl_typeassert);
-
     std::vector<Type*> argsdepwarnpi(0);
     argsdepwarnpi.push_back(T_size);
     jldepwarnpi_func = Function::Create(FunctionType::get(T_void, argsdepwarnpi, false),
@@ -5887,24 +6217,26 @@ static void init_julia_llvm_env(Module *m)
                                         "jl_depwarn_partial_indexing", m);
     add_named_global(jldepwarnpi_func, &jl_depwarn_partial_indexing);
 
+    std::vector<Type *> args_1ptr(0);
+    args_1ptr.push_back(T_prjlvalue);
     queuerootfun = Function::Create(FunctionType::get(T_void, args_1ptr, false),
                                     Function::ExternalLinkage,
                                     "jl_gc_queue_root", m);
     add_named_global(queuerootfun, &jl_gc_queue_root);
 
     std::vector<Type *> agargs(0);
-    agargs.push_back(T_ppjlvalue);
+    agargs.push_back(T_pprjlvalue);
     agargs.push_back(T_uint32);
-    jlapplygeneric_func = Function::Create(FunctionType::get(T_pjlvalue, agargs, false),
+    jlapplygeneric_func = Function::Create(FunctionType::get(T_prjlvalue, agargs, false),
                                            Function::ExternalLinkage,
                                            "jl_apply_generic", m);
     add_named_global(jlapplygeneric_func, &jl_apply_generic);
 
     std::vector<Type *> invokeargs(0);
-    invokeargs.push_back(T_pjlvalue);
-    invokeargs.push_back(T_ppjlvalue);
+    invokeargs.push_back(T_prjlvalue);
+    invokeargs.push_back(T_pprjlvalue);
     invokeargs.push_back(T_uint32);
-    jlinvoke_func = Function::Create(FunctionType::get(T_pjlvalue, invokeargs, false),
+    jlinvoke_func = Function::Create(FunctionType::get(T_prjlvalue, invokeargs, false),
                                      Function::ExternalLinkage,
                                      "jl_invoke", m);
     add_named_global(jlinvoke_func, &jl_invoke);
@@ -5913,16 +6245,19 @@ static void init_julia_llvm_env(Module *m)
     exp_args.push_back(T_int1);
     expect_func = Intrinsic::getDeclaration(m, Intrinsic::expect, exp_args);
 
-    std::vector<Type*> args3(0);
-    args3.push_back(T_pjlvalue);
+    std::vector<Type*> args_topeval(0);
+    args_topeval.push_back(T_prjlvalue);
+    args_topeval.push_back(T_prjlvalue);
     jltopeval_func =
-        Function::Create(FunctionType::get(T_pjlvalue, args3, false),
+        Function::Create(FunctionType::get(T_pjlvalue, args_topeval, false),
                          Function::ExternalLinkage,
                          "jl_toplevel_eval", m);
     add_named_global(jltopeval_func, &jl_toplevel_eval);
 
+    std::vector<Type*> args_copyast(0);
+    args_copyast.push_back(T_prjlvalue);
     jlcopyast_func =
-        Function::Create(FunctionType::get(T_pjlvalue, args3, false),
+        Function::Create(FunctionType::get(T_prjlvalue, args_copyast, false),
                          Function::ExternalLinkage,
                          "jl_copy_ast", m);
     add_named_global(jlcopyast_func, &jl_copy_ast);
@@ -5936,9 +6271,10 @@ static void init_julia_llvm_env(Module *m)
     add_named_global(jlnsvec_func, &jl_svec);
 
     std::vector<Type*> mdargs(0);
-    mdargs.push_back(T_pjlvalue);
-    mdargs.push_back(T_pjlvalue);
-    mdargs.push_back(T_pjlvalue);
+    mdargs.push_back(T_prjlvalue);
+    mdargs.push_back(T_prjlvalue);
+    mdargs.push_back(T_prjlvalue);
+    mdargs.push_back(T_prjlvalue);
     jlmethod_func =
         Function::Create(FunctionType::get(T_void, mdargs, false),
                          Function::ExternalLinkage,
@@ -5946,12 +6282,13 @@ static void init_julia_llvm_env(Module *m)
     add_named_global(jlmethod_func, &jl_method_def);
 
     std::vector<Type*> funcdefargs(0);
-    funcdefargs.push_back(T_pjlvalue);
-    funcdefargs.push_back(T_ppjlvalue);
-    funcdefargs.push_back(T_pjlvalue);
+    funcdefargs.push_back(T_prjlvalue);
+    funcdefargs.push_back(T_prjlvalue);
+    funcdefargs.push_back(T_pprjlvalue);
+    funcdefargs.push_back(T_prjlvalue);
     funcdefargs.push_back(T_pjlvalue);
     jlgenericfunction_func =
-        Function::Create(FunctionType::get(T_pjlvalue, funcdefargs, false),
+        Function::Create(FunctionType::get(T_prjlvalue, funcdefargs, false),
                          Function::ExternalLinkage,
                          "jl_generic_function_def", m);
     add_named_global(jlgenericfunction_func, &jl_generic_function_def);
@@ -6006,55 +6343,58 @@ static void init_julia_llvm_env(Module *m)
                          "jl_pop_handler", m);
     add_named_global(jlleave_func, &jl_pop_handler);
 
-    std::vector<Type *> args_2vals(0);
-    args_2vals.push_back(T_pjlvalue);
-    args_2vals.push_back(T_pjlvalue);
+    std::vector<Type *> args_2vals_callee_rooted(0);
+    args_2vals_callee_rooted.push_back(PointerType::get(T_jlvalue, AddressSpace::CalleeRooted));
+    args_2vals_callee_rooted.push_back(PointerType::get(T_jlvalue, AddressSpace::CalleeRooted));
     jlegal_func =
-        Function::Create(FunctionType::get(T_int32, args_2vals, false),
+        Function::Create(FunctionType::get(T_int32, args_2vals_callee_rooted, false),
                          Function::ExternalLinkage,
                          "jl_egal", m);
     add_named_global(jlegal_func, &jl_egal);
 
+    std::vector<Type *> args_2vals_tracked(0);
+    args_2vals_tracked.push_back(T_prjlvalue);
+    args_2vals_tracked.push_back(T_prjlvalue);
     jlisa_func =
-        Function::Create(FunctionType::get(T_int32, args_2vals, false),
+        Function::Create(FunctionType::get(T_int32, args_2vals_tracked, false),
                          Function::ExternalLinkage,
                          "jl_isa", m);
     add_named_global(jlisa_func, &jl_isa);
 
     jlsubtype_func =
-        Function::Create(FunctionType::get(T_int32, args_2vals, false),
+        Function::Create(FunctionType::get(T_int32, args_2vals_tracked, false),
                          Function::ExternalLinkage,
                          "jl_subtype", m);
     add_named_global(jlsubtype_func, &jl_subtype);
 
+    jltypeassert_func = Function::Create(FunctionType::get(T_void, args_2vals_tracked, false),
+                                        Function::ExternalLinkage,
+                                        "jl_typeassert", m);
+    add_named_global(jltypeassert_func, &jl_typeassert);
+
     std::vector<Type *> applytype_args(0);
-    applytype_args.push_back(T_pjlvalue);
-    applytype_args.push_back(T_pjlvalue);
-    applytype_args.push_back(T_ppjlvalue);
+    applytype_args.push_back(T_prjlvalue);
+    applytype_args.push_back(T_prjlvalue);
+    applytype_args.push_back(T_pprjlvalue);
     jlapplytype_func =
-        Function::Create(FunctionType::get(T_pjlvalue, applytype_args, false),
+        Function::Create(FunctionType::get(T_prjlvalue, applytype_args, false),
                          Function::ExternalLinkage,
                          "jl_instantiate_type_in_env", m);
     add_named_global(jlapplytype_func, &jl_instantiate_type_in_env);
 
-    std::vector<Type*> alloc_pool_args(0);
-    alloc_pool_args.push_back(T_pint8);
-    alloc_pool_args.push_back(T_int32);
-    alloc_pool_args.push_back(T_int32);
-    jlalloc_pool_func =
-        Function::Create(FunctionType::get(T_pjlvalue, alloc_pool_args, false),
-                         Function::ExternalLinkage,
-                         "jl_gc_pool_alloc", m);
-    add_named_global(jlalloc_pool_func, &jl_gc_pool_alloc);
-
-    std::vector<Type*> alloc_big_args(0);
-    alloc_big_args.push_back(T_pint8);
-    alloc_big_args.push_back(T_size);
-    jlalloc_big_func =
-        Function::Create(FunctionType::get(T_pjlvalue, alloc_big_args, false),
-                         Function::ExternalLinkage,
-                         "jl_gc_big_alloc", m);
-    add_named_global(jlalloc_big_func, &jl_gc_big_alloc);
+    std::vector<Type*> gc_alloc_args(0);
+    gc_alloc_args.push_back(T_pint8);
+    gc_alloc_args.push_back(T_size);
+    gc_alloc_args.push_back(T_prjlvalue);
+    jl_alloc_obj_func = Function::Create(FunctionType::get(T_prjlvalue, gc_alloc_args, false),
+                                         Function::ExternalLinkage,
+                                         "julia.gc_alloc_obj");
+#if JL_LLVM_VERSION >= 50000
+    jl_alloc_obj_func->addAttribute(AttributeList::ReturnIndex, Attribute::NoAlias);
+#else
+    jl_alloc_obj_func->addAttribute(AttributeSet::ReturnIndex, Attribute::NoAlias);
+#endif
+    add_named_global(jl_alloc_obj_func, (void*)NULL, /*dllimport*/false);
 
     std::vector<Type *> dlsym_args(0);
     dlsym_args.push_back(T_pint8);
@@ -6076,10 +6416,10 @@ static void init_julia_llvm_env(Module *m)
     add_named_global(jlnewbits_func, &jl_new_bits);
 
     std::vector<Type *> getnthfld_args(0);
-    getnthfld_args.push_back(T_pjlvalue);
+    getnthfld_args.push_back(T_prjlvalue);
     getnthfld_args.push_back(T_size);
     jlgetnthfieldchecked_func =
-        Function::Create(FunctionType::get(T_pjlvalue, getnthfld_args, false),
+        Function::Create(FunctionType::get(T_prjlvalue, getnthfld_args, false),
                          Function::ExternalLinkage,
                          "jl_get_nth_field_checked", m);
     add_named_global(jlgetnthfieldchecked_func, *jl_get_nth_field_checked);
@@ -6090,62 +6430,39 @@ static void init_julia_llvm_env(Module *m)
                          "jl_gc_diff_total_bytes", m);
     add_named_global(diff_gc_total_bytes_func, *jl_gc_diff_total_bytes);
 
-#if JL_LLVM_VERSION < 30600
-    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
     std::vector<Type*> array_owner_args(0);
-    array_owner_args.push_back(T_pjlvalue);
+    array_owner_args.push_back(T_prjlvalue);
     jlarray_data_owner_func =
-        Function::Create(FunctionType::get(T_pjlvalue, array_owner_args, false),
+        Function::Create(FunctionType::get(T_prjlvalue, array_owner_args, false),
                          Function::ExternalLinkage,
                          "jl_array_data_owner", m);
     jlarray_data_owner_func->setAttributes(
         jlarray_data_owner_func->getAttributes()
+#if JL_LLVM_VERSION >= 50000
+        .addAttribute(jlarray_data_owner_func->getContext(),
+                      AttributeList::FunctionIndex, Attribute::ReadOnly)
+        .addAttribute(jlarray_data_owner_func->getContext(),
+                      AttributeList::FunctionIndex, Attribute::NoUnwind));
+#else
         .addAttribute(jlarray_data_owner_func->getContext(),
                       AttributeSet::FunctionIndex, Attribute::ReadOnly)
         .addAttribute(jlarray_data_owner_func->getContext(),
                       AttributeSet::FunctionIndex, Attribute::NoUnwind));
+#endif
     add_named_global(jlarray_data_owner_func, jl_array_data_owner);
 
-    gcroot_func =
-        Function::Create(FunctionType::get(T_ppjlvalue, false),
-                     Function::ExternalLinkage,
-                     "julia.gc_root_decl");
-    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");
-    add_named_global(gckill_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");
-    add_named_global(jlcall_frame_func, (void*)NULL, /*dllimport*/false);
-
     gcroot_flush_func = Function::Create(FunctionType::get(T_void, false),
                                          Function::ExternalLinkage,
                                          "julia.gcroot_flush");
     add_named_global(gcroot_flush_func, (void*)NULL, /*dllimport*/false);
 
+    pointer_from_objref_func = Function::Create(FunctionType::get(T_pjlvalue,
+                                         ArrayRef<Type*>(PointerType::get(T_jlvalue, AddressSpace::Derived)), false),
+                                         Function::ExternalLinkage,
+                                         "julia.pointer_from_objref");
+    pointer_from_objref_func->addFnAttr(Attribute::ReadNone);
+    add_named_global(pointer_from_objref_func, (void*)NULL, /*dllimport*/false);
+
     except_enter_func = Function::Create(FunctionType::get(T_int32, false),
                                          Function::ExternalLinkage,
                                          "julia.except_enter");
@@ -6158,31 +6475,9 @@ static void init_julia_llvm_env(Module *m)
                            NULL, "jl_world_counter");
     add_named_global(jlgetworld_global, &jl_world_counter);
 
-    // set up optimization passes
-#if JL_LLVM_VERSION >= 30700
-// No DataLayout pass needed anymore.
-#elif JL_LLVM_VERSION >= 30600
-    jl_data_layout = new llvm::DataLayoutPass();
-#elif JL_LLVM_VERSION >= 30500
-    jl_data_layout = new llvm::DataLayoutPass(*jl_ExecutionEngine->getDataLayout());
-#else
-    jl_data_layout = new DataLayout(*jl_ExecutionEngine->getDataLayout());
-#endif
-
-#if JL_LLVM_VERSION >= 30700
     jl_globalPM = new legacy::PassManager();
-#else
-    jl_globalPM = new PassManager();
-#endif
-#if JL_LLVM_VERSION < 30700
-    jl_globalPM->add(new TargetLibraryInfo(Triple(jl_TargetMachine->getTargetTriple())));
-#else
     jl_globalPM->add(new TargetLibraryInfoWrapperPass(Triple(jl_TargetMachine->getTargetTriple())));
-#endif
-#if JL_LLVM_VERSION < 30700
-    jl_globalPM->add(jl_data_layout);
-#endif
-    addOptimizationPasses(jl_globalPM);
+    addOptimizationPasses(jl_globalPM, jl_options.opt_level);
 }
 
 static inline std::string getNativeTarget()
@@ -6250,7 +6545,11 @@ static inline void checkARMArchFeature(std::string &cpu,
         HostFeatures[cpu] = true;
     }
 #else
-    HostFeatures[cpu.substr(3)] = true;
+    // These two are allowed on 32bit. Allow them on 64bits too for consistency since
+    // they basically mean "generic" on aarch64.
+    // In particular, "armv8-a" is the generic value for the GCC `-march` option.
+    if (cpu != "armv8" && cpu != "armv8-a")
+        HostFeatures[cpu.substr(3)] = true;
 #endif
     cpu = "generic";
 }
@@ -6262,23 +6561,13 @@ static inline void checkARMArchFeature(std::string &cpu,
 static inline SmallVector<std::string,10> getTargetFeatures(std::string &cpu)
 {
     StringMap<bool> HostFeatures;
-    if (!strcmp(jl_options.cpu_target,"native")) {
+    if (jl_options.cpu_target && !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
-#ifdef V128_BUG
-    HostFeatures["avx"] = false;
-#endif
-#endif
-#if defined(_CPU_X86_64_) && JL_LLVM_VERSION >= 30600
+#if defined(_CPU_X86_64_)
     // Require cx16 (cmpxchg16b)
     // We need this for 128-bit atomic operations. We only need this
     // when threading is enabled; however, to test whether this
@@ -6288,8 +6577,8 @@ static inline SmallVector<std::string,10> getTargetFeatures(std::string &cpu)
 #endif
 
     // Figure out if we know the cpu_target
-    cpu = (strcmp(jl_options.cpu_target,"native") ? jl_options.cpu_target :
-           getNativeTarget());
+    cpu = ((jl_options.cpu_target && strcmp(jl_options.cpu_target,"native")) ?
+            jl_options.cpu_target : getNativeTarget());
 #if defined(_CPU_ARM_)
     // Figure out what we are compiling against from the C defines.
     // This might affect ABI but is fine since
@@ -6374,7 +6663,7 @@ static inline SmallVector<std::string,10> getTargetFeatures(std::string &cpu)
     return attr;
 }
 
-extern "C" void jl_init_codegen(void)
+extern "C" void *jl_init_llvm(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");
@@ -6386,15 +6675,11 @@ extern "C" void jl_init_codegen(void)
     cl::ParseEnvironmentOptions("Julia", "JULIA_LLVM_ARGS");
 #endif
 
+    jl_page_size = jl_getpagesize();
     imaging_mode = jl_generating_output();
     jl_init_debuginfo();
     jl_init_runtime_ccall();
 
-#if JL_LLVM_VERSION < 30400
-    // this option disables LLVM's signal handlers
-    llvm::DisablePrettyStackTrace = true;
-#endif
-
 #ifdef USE_POLLY
     PassRegistry &Registry = *PassRegistry::getPassRegistry();
     polly::initializePollyPasses(Registry);
@@ -6408,53 +6693,23 @@ extern "C" void jl_init_codegen(void)
 
     Module *m, *engine_module;
     engine_module = new Module("julia", jl_LLVMContext);
-#ifdef USE_MCJIT
     m = new Module("julia", jl_LLVMContext);
-#else
-    m = engine_module;
-#endif
     shadow_output = m;
 
     TargetOptions options = TargetOptions();
     //options.PrintMachineCode = true; //Print machine code produced during JIT compiling
-#if defined(JL_DEBUG_BUILD) && JL_LLVM_VERSION < 30700
-    options.JITEmitDebugInfo = true;
-#endif
-#if JL_LLVM_VERSION < 30700
-    options.NoFramePointerElim = true;
-#endif
-#if JL_LLVM_VERSION < 30400
-    options.NoFramePointerElimNonLeaf = true;
-#endif
 #if defined(_OS_WINDOWS_) && !defined(_CPU_X86_64_)
     // tell Win32 to assume the stack is always 16-byte aligned,
     // and to ensure that it is 16-byte aligned for out-going calls,
     // to ensure compatibility with GCC codes
     options.StackAlignmentOverride = 16;
 #endif
-#if defined(__APPLE__) && JL_LLVM_VERSION < 30400
-    // turn on JIT support for libunwind to walk the stack
-    options.JITExceptionHandling = 1;
-#endif
-
-#if JL_LLVM_VERSION >= 30600
     EngineBuilder eb((std::unique_ptr<Module>(engine_module)));
-#else
-    EngineBuilder eb(engine_module);
-#endif
     std::string ErrorStr;
     eb  .setEngineKind(EngineKind::JIT)
-#if defined(_OS_WINDOWS_) && defined(_CPU_X86_64_) && !defined(USE_MCJIT)
-        .setJITMemoryManager(createJITMemoryManagerWin())
-#elif defined(USE_MCJIT)
-        .setMCJITMemoryManager(std::unique_ptr<RTDyldMemoryManager>{createRTDyldMemoryManager()})
-#endif
         .setTargetOptions(options)
-#if (defined(_OS_LINUX_) && defined(_CPU_X86_64_))
-        .setRelocationModel(Reloc::PIC_)
-#elif JL_LLVM_VERSION < 30900
-        .setRelocationModel(Reloc::Default)
-#endif
+        // Generate simpler code for JIT
+        .setRelocationModel(Reloc::Static)
 #ifdef _P64
         .setCodeModel(CodeModel::Large)
 #else
@@ -6464,21 +6719,11 @@ extern "C" void jl_init_codegen(void)
         .setOptLevel(CodeGenOpt::None)
 #else
         .setOptLevel(jl_options.opt_level == 0 ? CodeGenOpt::None : CodeGenOpt::Aggressive)
-#endif
-#if defined(USE_MCJIT) && JL_LLVM_VERSION < 30600
-        .setUseMCJIT(true)
-#endif
-#ifdef USE_ORCMCJIT
-        .setUseOrcMCJITReplacement(true)
 #endif
     ;
     Triple TheTriple(sys::getProcessTriple());
 #if defined(FORCE_ELF)
-#if JL_LLVM_VERSION >= 30500
     TheTriple.setObjectFormat(Triple::ELF);
-#else
-    TheTriple.setEnvironment(Triple::ELF);
-#endif
 #endif
     std::string TheCPU;
     SmallVector<std::string, 10> targetFeatures = getTargetFeatures(TheCPU);
@@ -6489,49 +6734,32 @@ extern "C" void jl_init_codegen(void)
             targetFeatures);
     assert(jl_TargetMachine && "Failed to select target machine -"
                                " Is the LLVM backend for this CPU enabled?");
-#if defined(USE_MCJIT) && (!defined(_CPU_ARM_) && !defined(_CPU_PPC64_))
+    #if (!defined(_CPU_ARM_) && !defined(_CPU_PPC64_))
     // FastISel seems to be buggy for ARM. Ref #13321
     if (jl_options.opt_level < 2)
         jl_TargetMachine->setFastISel(true);
-#endif
+    #endif
 
     init_julia_llvm_meta();
-
-#ifdef USE_ORCJIT
     jl_ExecutionEngine = new JuliaOJIT(*jl_TargetMachine);
-#else
-    jl_ExecutionEngine = eb.create(jl_TargetMachine);
-    //jl_printf(JL_STDERR,"%s\n",jl_ExecutionEngine->getDataLayout()->getStringRepresentation().c_str());
-    if (!jl_ExecutionEngine) {
-        jl_printf(JL_STDERR, "Critical error initializing llvm: %s\n",
-                  ErrorStr.c_str());
-        exit(1);
-    }
-#if JL_LLVM_VERSION >= 30500 && !defined(USE_ORCMCJIT)
-    jl_ExecutionEngine->setProcessAllSections(true);
-#endif
-    jl_ExecutionEngine->DisableLazyCompilation();
+
+// Mark our address spaces as non-integral
+#if JL_LLVM_VERSION >= 40000
+    jl_data_layout = jl_ExecutionEngine->getDataLayout();
+    std::string DL = jl_data_layout.getStringRepresentation() + "-ni:10:11:12";
+    jl_data_layout.reset(DL);
 #endif
 
     // Now that the execution engine exists, initialize all modules
     jl_setup_module(engine_module);
     jl_setup_module(m);
-    init_julia_llvm_env(m);
+    return (void*)m;
+}
 
-#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
+extern "C" void jl_init_codegen(void)
+{
+    Module *m = (Module *)jl_init_llvm();
+    init_julia_llvm_env(m);
 
     BOX_F(int8,int8);  UBOX_F(uint8,uint8);
     BOX_F(int16,int16); UBOX_F(uint16,uint16);
@@ -6561,6 +6789,14 @@ extern "C" void jl_dump_llvm_value(void *v)
     ((Value*)v)->dump();
 #endif
 }
+extern "C" void jl_dump_llvm_inst_function(void *v)
+{
+#if JL_LLVM_VERSION >= 50000
+    cast<Instruction>(((Value*)v))->getParent()->getParent()->print(llvm::dbgs(), nullptr, true);
+#else
+    cast<Instruction>(((Value*)v))->getParent()->getParent()->dump();
+#endif
+}
 extern "C" void jl_dump_llvm_type(void *v)
 {
 #if JL_LLVM_VERSION >= 50000
@@ -6570,3 +6806,15 @@ extern "C" void jl_dump_llvm_type(void *v)
 #endif
     putchar('\n');
 }
+
+extern void jl_write_bitcode_func(void *F, char *fname) {
+    std::error_code EC;
+    raw_fd_ostream OS(fname, EC, sys::fs::F_None);
+    llvm::WriteBitcodeToFile(((llvm::Function*)F)->getParent(), OS);
+}
+
+extern void jl_write_bitcode_module(void *M, char *fname) {
+    std::error_code EC;
+    raw_fd_ostream OS(fname, EC, sys::fs::F_None);
+    llvm::WriteBitcodeToFile((llvm::Module*)M, OS);
+}
diff --git a/src/codegen_internal.h b/src/codegen_internal.h
deleted file mode 100644
index 3932884788726b..00000000000000
--- a/src/codegen_internal.h
+++ /dev/null
@@ -1,46 +0,0 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
-
-#if defined(USE_ORCJIT) && JL_LLVM_VERSION <= 30800
-#  include <llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h>
-void notifyObjectLoaded(RTDyldMemoryManager *memmgr,
-                        llvm::orc::ObjectLinkingLayerBase::ObjSetHandleT H);
-#endif
-
-// Declarations for disasm.cpp
-extern "C"
-void jl_dump_asm_internal(uintptr_t Fptr, size_t Fsize, int64_t slide,
-#ifndef USE_MCJIT
-                          std::vector<JITEvent_EmittedFunctionDetails::LineStart> lineinfo,
-#endif
-                          const object::ObjectFile *object,
-                          llvm::DIContext *context,
-#if JL_LLVM_VERSION >= 30700
-                          raw_ostream &rstream,
-#else
-                          formatted_raw_ostream &stream,
-#endif
-                          const char* asm_variant="att"
-                          );
-
-// Declarations for debuginfo.cpp
-extern int jl_DI_for_fptr(uint64_t fptr, uint64_t *symsize, int64_t *slide, int64_t *section_slide,
-                      const object::ObjectFile **object,
-#ifdef USE_MCJIT
-                      llvm::DIContext **context
-#else
-                      std::vector<JITEvent_EmittedFunctionDetails::LineStart> *lines
-#endif
-                      );
-
-extern bool jl_dylib_DI_for_fptr(size_t pointer, const object::ObjectFile **object, llvm::DIContext **context, int64_t *slide, int64_t *section_slide,
-        bool onlySysImg, bool *isSysImg, void **saddr, char **name, char **filename);
-
-#ifdef USE_ORCJIT
-#ifdef _OS_WINDOWS_
-void *lookupWriteAddressFor(RTDyldMemoryManager *memmgr, void *rt_addr);
-#endif
-#endif
-
-#ifdef USE_MCJIT
-RTDyldMemoryManager* createRTDyldMemoryManager(void);
-#endif
diff --git a/src/codegen_shared.h b/src/codegen_shared.h
new file mode 100644
index 00000000000000..6930d007e83153
--- /dev/null
+++ b/src/codegen_shared.h
@@ -0,0 +1,9 @@
+enum AddressSpace {
+    Generic = 0,
+    Tracked = 10, Derived = 11, CalleeRooted = 12,
+    FirstSpecial = Tracked,
+    LastSpecial = CalleeRooted,
+};
+
+#define JLCALL_CC (CallingConv::ID)36
+#define JLCALL_F_CC (CallingConv::ID)37
diff --git a/src/common_symbols1.inc b/src/common_symbols1.inc
index bc8380648a201f..013dfdd15dc069 100644
--- a/src/common_symbols1.inc
+++ b/src/common_symbols1.inc
@@ -1,63 +1,63 @@
 jl_symbol("getfield"),
-jl_symbol("bitcast"),
-jl_symbol("apply_type"),
 jl_symbol("meta"),
-jl_symbol("Ptr"),
+jl_symbol("inbounds"),
 jl_symbol("push_loc"),
 jl_symbol("pop_loc"),
-jl_symbol("abstractarray.jl"),
+jl_symbol("apply_type"),
 jl_symbol("add_int"),
+jl_symbol("Ptr"),
+jl_symbol("pop"),
+jl_symbol("bitcast"),
+jl_symbol("==="),
+jl_symbol("foreigncall"),
 jl_symbol("getindex"),
-jl_symbol("BlasInt"),
-jl_symbol("static_parameter"),
 jl_symbol("new"),
-jl_symbol("start"),
-jl_symbol("Any"),
-jl_symbol("convert"),
-jl_symbol("svec"),
-jl_symbol("ccall"),
-jl_symbol("Bool"),
-jl_symbol("inbounds"),
-jl_symbol("==="),
-jl_symbol("typeof"),
-jl_symbol("tuple.jl"),
-jl_symbol("Array"),
-jl_symbol("indexed_next"),
-jl_symbol("sle_int"),
-jl_symbol("Void"),
 jl_symbol("arrayref"),
-jl_symbol("array.jl"),
-jl_symbol("unsafe_convert"),
-jl_symbol("done"),
+jl_symbol("static_parameter"),
+jl_symbol("abstractarray.jl"),
+jl_symbol("slt_int"),
+jl_symbol("convert"),
+jl_symbol("start"),
+jl_symbol("BlasInt"),
+jl_symbol("+"),
 jl_symbol("not_int"),
-jl_symbol("next"),
-jl_symbol("dict.jl"),
+jl_symbol("unsafe_convert"),
+jl_symbol("isa"),
+jl_symbol("sle_int"),
+jl_symbol("select_value"),
+jl_symbol("throw"),
+jl_symbol("sub_int"),
+jl_symbol("=="),
+jl_symbol("!"),
 jl_symbol("cconvert"),
 jl_symbol("length"),
-jl_symbol("slt_int"),
-jl_symbol("sub_int"),
-jl_symbol("typeassert"),
-jl_symbol("Int"),
-jl_symbol("size"),
+jl_symbol("-"),
+jl_symbol("next"),
+jl_symbol("&"),
+jl_symbol("indexed_next"),
+jl_symbol("string"),
+jl_symbol("done"),
 jl_symbol("colon"),
-jl_symbol("pop"),
-jl_symbol("throw"),
-jl_symbol("setindex!"),
+jl_symbol("_apply"),
+jl_symbol("arrayset"),
+jl_symbol("indices"),
+jl_symbol("typeof"),
 jl_symbol("ptr_arg_unsafe_convert"),
 jl_symbol("ptr_arg_cconvert"),
+jl_symbol("setindex!"),
+jl_symbol("*"),
+jl_symbol("check_top_bit"),
+jl_symbol("setfield!"),
 jl_symbol("arraylen"),
-jl_symbol("Float64"),
-jl_symbol("nothing"),
+jl_symbol("typeassert"),
 jl_symbol("and_int"),
-jl_symbol("int.jl"),
-jl_symbol("_apply"),
+jl_symbol("jl_alloc_array_1d"),
+jl_symbol("arraysize"),
+jl_symbol("size"),
+jl_symbol("Int"),
+jl_symbol("nothing"),
+jl_symbol("_expr"),
+jl_symbol("args"),
+jl_symbol("print"),
+jl_symbol("Float64"),
 jl_symbol("UInt8"),
-jl_symbol("string"),
-jl_symbol("setfield!"),
-jl_symbol("JJ"),
-jl_symbol("operators.jl"),
-jl_symbol("nfields"),
-jl_symbol("iobuffer.jl"),
-jl_symbol("Float32"),
-jl_symbol("strings/io.jl"),
-jl_symbol("arrayset"),
diff --git a/src/common_symbols2.inc b/src/common_symbols2.inc
index a53732df4e3bb7..4554dfef79b5b8 100644
--- a/src/common_symbols2.inc
+++ b/src/common_symbols2.inc
@@ -1,250 +1,252 @@
-jl_symbol("essentials.jl"),
-jl_symbol("select_value"),
-jl_symbol("jl_alloc_array_1d"),
-jl_symbol("_expr"),
-jl_symbol("check_top_bit"),
-jl_symbol("Type"),
-jl_symbol("Int32"),
-jl_symbol("isa"),
-jl_symbol("print"),
-jl_symbol("data"),
+jl_symbol("stop"),
 jl_symbol("copyast"),
-jl_symbol("zext_int"),
-jl_symbol("uM"),
-jl_symbol("mul_int"),
-jl_symbol("KJ"),
-jl_symbol("Cint"),
-jl_symbol("Complex128"),
-jl_symbol("Complex64"),
-jl_symbol("arraysize"),
-jl_symbol("iterator.jl"),
-jl_symbol("zero"),
-jl_symbol("UInt"),
+jl_symbol("!="),
+jl_symbol("write"),
+jl_symbol("Array"),
 jl_symbol("neg_int"),
+jl_symbol("len"),
+jl_symbol("Void"),
 jl_symbol("ArgumentError"),
-jl_symbol("indices"),
-jl_symbol("BigFloat"),
-jl_symbol("write"),
-jl_symbol("args"),
-jl_symbol("range.jl"),
-jl_symbol("stop"),
-jl_symbol("J"),
-jl_symbol("uR"),
-jl_symbol("generator.jl"),
+jl_symbol("indices1"),
+jl_symbol("<"),
+jl_symbol("sizeof"),
+jl_symbol("Float32"),
+jl_symbol("t"),
+jl_symbol("mul_int"),
+jl_symbol("linearindices"),
+jl_symbol("o"),
+jl_symbol("Type"),
+jl_symbol("array.jl"),
+jl_symbol("strings/string.jl"),
+jl_symbol("contents"),
+jl_symbol("zext_int"),
+jl_symbol("push!"),
+jl_symbol("iter"),
+jl_symbol(">"),
+jl_symbol("Base"),
 jl_symbol("endof"),
+jl_symbol("shl_int"),
+jl_symbol("Any"),
+jl_symbol("Enums.jl"),
+jl_symbol("zero"),
+jl_symbol("strings/io.jl"),
+jl_symbol("Main"),
 jl_symbol("leave"),
-jl_symbol("count"),
-jl_symbol("Base"),
-jl_symbol("docs/helpdb/Base.jl"),
-jl_symbol("vj"),
-jl_symbol("contents"),
-jl_symbol("ptr"),
+jl_symbol("name"),
+jl_symbol("<="),
+jl_symbol("or_int"),
 jl_symbol("similar"),
-jl_symbol("@f"),
-jl_symbol("show.jl"),
-jl_symbol("keys"),
-jl_symbol("vector_any"),
-jl_symbol("BigInt"),
-jl_symbol("push!"),
-jl_symbol("reduce.jl"),
-jl_symbol("boot.jl"),
+jl_symbol("Complex64"),
+jl_symbol("Complex128"),
 jl_symbol("isempty"),
-jl_symbol("uO"),
+jl_symbol("#print_to_string#227"),
+jl_symbol("pointer"),
+jl_symbol("jl_value_ptr"),
+jl_symbol("head"),
+jl_symbol("src"),
 jl_symbol("sext_int"),
-jl_symbol("vals"),
-jl_symbol("bitarray.jl"),
-jl_symbol("uf"),
 jl_symbol("max"),
+jl_symbol("Expr"),
+jl_symbol("parameters"),
+jl_symbol("lshr_int"),
+jl_symbol("vector_any"),
+jl_symbol("count"),
+jl_symbol("age"),
+jl_symbol("Int32"),
+jl_symbol("keys"),
+jl_symbol("Tuple"),
+jl_symbol("range.jl"),
+jl_symbol(">>"),
+jl_symbol("ptr"),
+jl_symbol("data"),
+jl_symbol("unsafe_write"),
+jl_symbol("Const"),
+jl_symbol("BigFloat"),
+jl_symbol("DimensionMismatch"),
 jl_symbol("slots"),
-jl_symbol("uN"),
-jl_symbol("kwfunc"),
-jl_symbol("shl_int"),
-jl_symbol("sizeof"),
-jl_symbol("Enums.jl"),
-jl_symbol("promotion.jl"),
-jl_symbol("C_NULL"),
-jl_symbol("Ref"),
-jl_symbol("eltype"),
-jl_symbol("or_int"),
-jl_symbol("#print_to_string#138"),
-jl_symbol("Main"),
 jl_symbol("pointer.jl"),
-jl_symbol("DimensionMismatch"),
+jl_symbol("eltype"),
+jl_symbol("Bool"),
+jl_symbol("Val"),
 jl_symbol("stride"),
-jl_symbol("uP"),
-jl_symbol("III"),
-jl_symbol("uW"),
-jl_symbol("checked_trunc_uint"),
-jl_symbol("sparse/sparsematrix.jl"),
-jl_symbol("inference.jl"),
-jl_symbol("Csize_t"),
 jl_symbol("fieldtype"),
-jl_symbol("uT"),
-jl_symbol("uQ"),
-jl_symbol("unbox"),
-jl_symbol("String"),
-jl_symbol("Expr"),
-jl_symbol("multidimensional.jl"),
-jl_symbol("boundscheck"),
-jl_symbol("multi.jl"),
-jl_symbol("strings/basic.jl"),
-jl_symbol("uS"),
-jl_symbol("promote_type"),
-jl_symbol("checked_trunc_sint"),
-jl_symbol("ult_int"),
-jl_symbol("reshapedarray.jl"),
-jl_symbol("block"),
-jl_symbol("Cstring"),
-jl_symbol("LineEdit.jl"),
-jl_symbol("idxfloor"),
-jl_symbol("one"),
-jl_symbol("UInt32"),
-jl_symbol("print_to_string"),
-jl_symbol("HuJ"),
-jl_symbol("name"),
-jl_symbol("resize!"),
-jl_symbol("u]"),
-jl_symbol("jl_array_grow_end"),
-jl_symbol("lshr_int"),
-jl_symbol("linalg/lapack.jl"),
-jl_symbol("u["),
-jl_symbol("enter"),
-jl_symbol("Tuple"),
-jl_symbol("subarray.jl"),
+jl_symbol("dict.jl"),
 jl_symbol("checkbounds"),
-jl_symbol("Symbol"),
-jl_symbol("indices1"),
-jl_symbol("jl_array_ptr"),
-jl_symbol("reflection.jl"),
-jl_symbol("hash"),
-jl_symbol("ub"),
+jl_symbol("map"),
+jl_symbol("vals"),
+jl_symbol("Cint"),
+jl_symbol("copy!"),
+jl_symbol("promotion.jl"),
+jl_symbol("MethodError"),
+jl_symbol("jl_array_grow_end"),
+jl_symbol("checked_trunc_uint"),
+jl_symbol("BigInt"),
+jl_symbol("block"),
 jl_symbol("fill!"),
-jl_symbol("refpointer.jl"),
-jl_symbol("uU"),
-jl_symbol("float.jl"),
-jl_symbol("ua"),
-jl_symbol("u`"),
-jl_symbol("inline"),
-jl_symbol("linalg/triangular.jl"),
-jl_symbol("ud"),
-jl_symbol("uX"),
-jl_symbol("Generator"),
-jl_symbol("char.jl"),
-jl_symbol("_chkbnds"),
-jl_symbol("uY"),
-jl_symbol("head"),
-jl_symbol("real"),
-jl_symbol("dict"),
-jl_symbol("get"),
-jl_symbol("uV"),
-jl_symbol("ue"),
-jl_symbol("parameters"),
+jl_symbol("nfields"),
+jl_symbol("hash"),
+jl_symbol("DataType"),
 jl_symbol("first"),
-jl_symbol("hashing.jl"),
-jl_symbol("kwerr"),
+jl_symbol("<:"),
+jl_symbol("in"),
+jl_symbol("C_NULL"),
+jl_symbol("ult_int"),
+jl_symbol("broadcast"),
+jl_symbol("char.jl"),
+jl_symbol("val"),
 jl_symbol("value"),
-jl_symbol("iter"),
-jl_symbol("the_exception"),
-jl_symbol("step"),
-jl_symbol("UInt64"),
-jl_symbol("eachindex"),
-jl_symbol("process.jl"),
-jl_symbol("Int64"),
-jl_symbol("ht_keyindex"),
-jl_symbol("len"),
-jl_symbol("io.jl"),
+jl_symbol("id"),
+jl_symbol("inference.jl"),
+jl_symbol("io"),
+jl_symbol("kwfunc"),
+jl_symbol("Symbol"),
+jl_symbol("mod"),
+jl_symbol("isdefined"),
+jl_symbol("enter"),
+jl_symbol("bitarray.jl"),
+jl_symbol("/"),
+jl_symbol("Ref"),
+jl_symbol("typ"),
+jl_symbol("generator.jl"),
+jl_symbol("_ftl"),
+jl_symbol("checked.jl"),
+jl_symbol("UInt"),
+jl_symbol("chunks"),
+jl_symbol("ht"),
+jl_symbol("resize!"),
+jl_symbol("|"),
+jl_symbol("depwarn"),
+jl_symbol("Vector"),
+jl_symbol("String"),
+jl_symbol("checked_trunc_sint"),
+jl_symbol("promote_type"),
+jl_symbol("noinline"),
 jl_symbol("error"),
-jl_symbol("copy!"),
 jl_symbol("BoundsError"),
-jl_symbol("jl_new_array"),
+jl_symbol("the_exception"),
+jl_symbol("ashr_int"),
+jl_symbol("dict"),
+jl_symbol("mt"),
+jl_symbol("<<"),
+jl_symbol("Bottom"),
+jl_symbol("ht_keyindex"),
+jl_symbol("get"),
+jl_symbol("AnyVector"),
+jl_symbol("real"),
+jl_symbol("one"),
+jl_symbol("boundscheck"),
+jl_symbol("widenconst"),
+jl_symbol("Cstring"),
+jl_symbol("collect_to!"),
+jl_symbol("println"),
+jl_symbol("tuple.jl"),
+jl_symbol("."),
+jl_symbol("UInt64"),
+jl_symbol("idxfloor"),
 jl_symbol("f"),
-jl_symbol("sysimg.jl"),
-jl_symbol("u^"),
-jl_symbol("uc"),
-jl_symbol("rdims"),
-jl_symbol("ul"),
-jl_symbol("u_"),
-jl_symbol("liblapack"),
+jl_symbol("Int64"),
+jl_symbol("kwerr"),
+jl_symbol("AssertionError"),
+jl_symbol("multidimensional.jl"),
+jl_symbol("bits"),
+jl_symbol("collect"),
 jl_symbol("copy"),
-jl_symbol("strings/string.jl"),
-jl_symbol("uZ"),
-jl_symbol("ashr_int"),
-jl_symbol("reshape"),
-jl_symbol("random.jl"),
-jl_symbol("K"),
-jl_symbol("sparse/sparsevector.jl"),
-jl_symbol("linearindices"),
-jl_symbol("stream.jl"),
-jl_symbol("checkindex"),
-jl_symbol("ug"),
-jl_symbol("_front"),
+jl_symbol("jl_array_ptr"),
 jl_symbol("throw_boundserror"),
-jl_symbol("uo"),
-jl_symbol("chkstride1"),
-jl_symbol("c.jl"),
-jl_symbol("colptr"),
-jl_symbol("Vector"),
+jl_symbol("liblapack"),
+jl_symbol("checkindex"),
+jl_symbol("haskey"),
 jl_symbol("min"),
+jl_symbol("last"),
+jl_symbol("_length"),
+jl_symbol(">="),
+jl_symbol("isleaftype"),
+jl_symbol("UInt32"),
+jl_symbol("Generator"),
+jl_symbol("TypeVar"),
+jl_symbol("hashing.jl"),
+jl_symbol("chkstride1"),
+jl_symbol("step"),
+jl_symbol("UnionAll"),
+jl_symbol("typejoin"),
+jl_symbol("kwsorter"),
+jl_symbol("jl_rethrow_other"),
+jl_symbol("var"),
+jl_symbol("handle"),
+jl_symbol("Csize_t"),
+jl_symbol("argtail"),
+jl_symbol("associative.jl"),
+jl_symbol("secret_table_token"),
+jl_symbol("abs"),
 jl_symbol("esc"),
-jl_symbol("IOContext"),
-jl_symbol("println"),
-jl_symbol("set.jl"),
-jl_symbol("nzval"),
-jl_symbol("div"),
-jl_symbol("skip_deleted"),
-jl_symbol("uj"),
-jl_symbol("uh"),
-jl_symbol("un"),
-jl_symbol("ref"),
+jl_symbol("unwrap_unionall"),
 jl_symbol("maxprobe"),
-jl_symbol("pointer"),
-jl_symbol("abs"),
-jl_symbol("multimedia.jl"),
-jl_symbol("Af"),
-jl_symbol("xFI"),
-jl_symbol("libgit2/types.jl"),
-jl_symbol("jl_rethrow_other"),
-jl_symbol("mpfr.jl"),
-jl_symbol("map"),
-jl_symbol("DataType"),
+jl_symbol("unsafe_copy!"),
+jl_symbol("checked_add"),
+jl_symbol("broadcast.jl"),
 jl_symbol("vect"),
-jl_symbol("error.jl"),
+jl_symbol("lock"),
+jl_symbol("params"),
 jl_symbol("chklapackerror"),
-jl_symbol("haskey"),
-jl_symbol("elsize"),
-jl_symbol("ut"),
 jl_symbol("show"),
-jl_symbol("sprint"),
-jl_symbol("ui"),
-jl_symbol("ROUNDING_MODE"),
-jl_symbol("handle"),
-jl_symbol("um"),
-jl_symbol("last"),
-jl_symbol("Val"),
-jl_symbol("ErrorException"),
-jl_symbol("sort.jl"),
-jl_symbol("docs/Docs.jl"),
-jl_symbol("KeyError"),
-jl_symbol("stat.jl"),
-jl_symbol("Complex"),
+jl_symbol("code"),
+jl_symbol("hash_64_64"),
+jl_symbol("s"),
+jl_symbol("Union"),
 jl_symbol("checked_sadd_int"),
-jl_symbol("checksquare"),
-jl_symbol("II"),
+jl_symbol("ndel"),
+jl_symbol("ref"),
+jl_symbol("istopfunction"),
+jl_symbol("checked_sub"),
 jl_symbol("checked_ssub_int"),
+jl_symbol("KeyError"),
+jl_symbol("%"),
+jl_symbol("eval"),
+jl_symbol("pointerref"),
+jl_symbol("checksquare"),
+jl_symbol("status"),
 jl_symbol("trunc_int"),
-jl_symbol("ndel"),
-jl_symbol("libgit2"),
-jl_symbol("Ah"),
-jl_symbol("LinearFast"),
-jl_symbol("linalg/blas.jl"),
-jl_symbol("isless"),
-jl_symbol("printf.jl"),
-jl_symbol("rowval"),
-jl_symbol("joinpath"),
+jl_symbol("ssavaluetypes"),
 jl_symbol("rehash!"),
-jl_symbol("chunks"),
-jl_symbol("Hvz"),
-jl_symbol("base.jl"),
-jl_symbol("deprecated.jl"),
-jl_symbol("jl_value_ptr"),
-jl_symbol("REPL.jl"),
+jl_symbol("show.jl"),
+jl_symbol("jl_array_ptr_1d_push"),
+jl_symbol("intset.jl"),
+jl_symbol("I"),
+jl_symbol("def"),
+jl_symbol("_collect"),
+jl_symbol("linfo"),
+jl_symbol("jl_object_id"),
+jl_symbol("div"),
+jl_symbol("deserialize"),
+jl_symbol("essentials.jl"),
+jl_symbol("^"),
+jl_symbol("macrocall"),
+jl_symbol("ErrorException"),
+jl_symbol("SSAValue"),
+jl_symbol("read"),
+jl_symbol("QuoteNode"),
+jl_symbol("x"),
+jl_symbol("get_chunks_id"),
+jl_symbol("escape"),
+jl_symbol("d"),
+jl_symbol("libmpfr"),
+jl_symbol("Box"),
+jl_symbol("!=="),
+jl_symbol("Conditional"),
+jl_symbol("show_unquoted"),
+jl_symbol("Slot"),
+jl_symbol("nzval"),
+jl_symbol("Complex"),
+jl_symbol("reflection.jl"),
+jl_symbol("colptr"),
+jl_symbol("jl_eqtable_get"),
+jl_symbol("isnan"),
+jl_symbol("IndexStyle"),
+jl_symbol("Dict"),
+jl_symbol("promote"),
+jl_symbol("offset"),
+jl_symbol("NF"),
+jl_symbol("isvarargtype"),
+jl_symbol("n"),
+jl_symbol("inferred"),
+jl_symbol("eachindex"),
diff --git a/src/support/crc32c-tables.c b/src/crc32c-tables.c
similarity index 99%
rename from src/support/crc32c-tables.c
rename to src/crc32c-tables.c
index 10811d6cc3edf2..81c6f37172d0a0 100644
--- a/src/support/crc32c-tables.c
+++ b/src/crc32c-tables.c
@@ -1,9 +1,11 @@
+// This file is a part of Julia. License is MIT: https://julialang.org/license
+
 /* Pregenerated tables for crc32c.c, produced by compiling with -DGEN_CRC32C_TABLES. */
 #if POLY != 0x82f63b78
 #  error "tables generated for different polynomial"
 #endif
 
-static const uint32_t crc32c_table[8][256] = {
+JL_UNUSED static const uint32_t crc32c_table[8][256] = {
     { 0,4067132163,3778769143,324072436,3348797215,904991772,648144872,3570033899,2329499855,2024987596,1809983544,2575936315,1296289744,3207089363,2893594407,1578318884,274646895,3795141740,4049975192,51262619,3619967088,632279923,922689671,3298075524,2592579488,1760304291,2075979607,2312596564,1562183871,2943781820,3156637768,1313733451,549293790,3537243613,3246849577,871202090,3878099393,357341890,102525238,4101499445,2858735121,1477399826,1264559846,3107202533,1845379342,2677391885,2361733625,2125378298,820201905,3263744690,3520608582,598981189,4151959214,85089709,373468761,3827903834,3124367742,1213305469,1526817161,2842354314,2107672161,2412447074,2627466902,1861252501,1098587580,3004210879,2688576843,1378610760,2262928035,1955203488,1742404180,2511436119,3416409459,969524848,714683780,3639785095,205050476,4266873199,3976438427,526918040,1361435347,2739821008,2954799652,1114974503,2529119692,1691668175,2005155131,2247081528,3690758684,697762079,986182379,3366744552,476452099,3993867776,4250756596,255256311,1640403810,2477592673,2164122517,1922457750,2791048317,1412925310,1197962378,3037525897,3944729517,427051182,170179418,4165941337,746937522,3740196785,3451792453,1070968646,1905808397,2213795598,2426610938,1657317369,3053634322,1147748369,1463399397,2773627110,4215344322,153784257,444234805,3893493558,1021025245,3467647198,3722505002,797665321,2197175160,1889384571,1674398607,2443626636,1164749927,3070701412,2757221520,1446797203,137323447,4198817972,3910406976,461344835,3484808360,1037989803,781091935,3705997148,2460548119,1623424788,1939049696,2180517859,1429367560,2807687179,3020495871,1180866812,410100952,3927582683,4182430767,186734380,3756733383,763408580,1053836080,3434856499,2722870694,1344288421,1131464017,2971354706,1708204729,2545590714,2229949006,1988219213,680717673,3673779818,3383336350,1002577565,4010310262,493091189,238226049,4233660802,2987750089,1082061258,1395524158,2705686845,1972364758,2279892693,2494862625,1725896226,952904198,3399985413,3656866545,731699698,4283874585,222117402,510512622,3959836397,3280807620,837199303,582374963,3504198960,68661723,4135334616,3844915500,390545967,1230274059,3141532936,2825850620,1510247935,2395924756,2091215383,1878366691,2644384480,3553878443,565732008,854102364,3229815391,340358836,3861050807,4117890627,119113024,1493875044,2875275879,3090270611,1247431312,2660249211,1828433272,2141937292,2378227087,3811616794,291187481,34330861,4032846830,615137029,3603020806,3314634738,939183345,1776939221,2609017814,2295496738,2058945313,2926798794,1545135305,1330124605,3173225534,4084100981,17165430,307568514,3762199681,888469610,3332340585,3587147933,665062302,2042050490,2346497209,2559330125,1793573966,3190661285,1279665062,1595330642,2910671697 },
     { 0,329422967,658845934,887597209,1317691868,1562966443,1775194418,2054015301,2635383736,2394315727,3125932886,2851302177,3550388836,3225172499,4108030602,3883469565,1069937025,744974838,411091311,186800408,1901039709,1659701290,1443537075,1168652484,2731618873,2977147470,2241069783,2520160928,3965408229,4294560658,3407766283,3636263804,2139874050,1814657909,1489949676,1265388443,822182622,581114537,373600816,98970183,3802079418,4047354061,3319402580,3598223395,2887074150,3216496913,2337304968,2566056447,1078858371,1408010996,1728782957,1957280282,247755615,493284136,696337329,975428550,3713716539,3472378188,4196393429,3921508770,2479927527,2154965136,3029696521,2805405822,4279748100,3971309171,3629315818,3421531805,2979899352,2722054063,2530776886,2239369025,1644365244,1906417099,1162229074,1457827109,747201632,1059847191,197940366,409914617,3235002245,3547377650,3885434731,4097154844,2388153945,2650459694,2837276343,3133144768,1573319741,1315204170,2055455955,1763794084,323786209,15601046,873047311,665533816,2157716742,2470362481,2816021992,3027996063,3457565914,3719617709,3914560564,4210158659,495511230,237665993,986568272,695160359,1392674658,1084235541,1950857100,1743073275,3210335367,2902150384,2552030313,2344516638,4057183579,3799067948,3600188853,3308527042,575477567,837783368,84420561,380288934,1825011427,2137386644,1266828813,1478549114,4223924985,3898696334,3699821079,3475264096,3041499941,2800419666,2450303947,2175677372,1725380929,1970643254,1100089775,1378914776,677206173,1006616810,253257843,482013188,3288730488,3617886991,3812834198,4041319393,2324458148,2569990867,2915654218,3194733117,1494403264,1253068983,2119694382,1844797529,395880732,70922603,819829234,595526021,2219317755,2548728204,2735548693,2964304226,3401742375,3647004752,3985066185,4263891134,425515587,184435252,1041885869,767259354,1473690527,1148462056,1888717681,1664160518,3146639482,2821681165,2630408340,2406105315,4110911910,3869577681,3527588168,3252691263,647572418,893105077,31202092,310281051,1746094622,2075251305,1331067632,1559552647,81018109,393651338,596708371,808686692,1247698209,1509737814,1830514127,2126116280,2579562309,2321704754,3196440491,2905036764,3611991705,3303540462,4027559543,3819779584,991022460,682841355,475331986,267806181,1973136544,1715025111,1390320718,1098646585,2785349316,3047659187,2168471082,2464327261,3901714200,4214093679,3486146550,3697854337,2069880831,1761429384,1545269009,1337489254,903200291,645342804,311463629,20059834,3863682119,4125721648,3238931625,3534533854,2831252891,3143886316,2407812469,2619790594,1150955134,1463334409,1675566736,1887274727,168841122,431151061,760577868,1056433979,3650022854,3391911345,4274773288,3983099231,2533657626,2225476717,2957098228,2749572227 },
     { 0,2772537982,1332695565,3928932467,2665391130,1000289892,3518101015,1961911401,944848581,2635115707,2000579784,3531603638,2794429151,63834273,3923822802,1285642924,1889697162,3588485108,1070411655,2592914937,4001159568,1262308334,2702412701,72489443,1223902031,3987919153,127668546,2732426044,3593332565,1936487723,2571285848,1006839590,3779394324,1141205354,2922096921,191511399,2140823310,3671838064,821366019,2511642493,3642082769,2085902255,2524616668,859506082,1204511179,3800757173,144978886,2917507512,2447804062,883365088,3733574803,2076722925,255337092,2860101882,1079472265,3843482359,2847389787,217459237,3872975446,1134131240,929635393,2452131391,2013679180,3712474162,3345318105,1646531239,2282410708,759906474,1505436867,4244289213,383022798,3012945072,4281646620,1517628514,2958814225,354057839,1642732038,3299575928,780486667,2344934005,3083337043,310800173,4171804510,1575566624,689527113,2354629431,1719012164,3275200826,2409022358,718754280,3237581211,1706558437,289957772,3020551666,1579627905,4217808895,639728589,2204166579,1766730176,3423583166,3103776727,499010985,4153445850,1389436836,510674184,3140605814,1360992005,4099835259,2158944530,636449644,3485578015,1786782049,1451427399,4089615417,434918474,3165505076,3361579613,1830563875,2268262480,577987118,1859270786,3415452412,566061711,2231171313,4027358360,1431113446,3210989205,438459627,2334619459,778495293,3293062478,1628026672,368694105,2964865319,1519812948,4292285226,3010873734,372759544,4229503883,1498974709,766045596,2297004002,1657257873,3347459567,4219800265,1589942455,3035257028,296471226,1700507347,3222944941,708115678,2406837920,3285464076,1721083506,2361091585,704312447,1560973334,4165665384,308658715,3072610405,1784908887,3475119657,621600346,2152549412,4106037325,1375517235,3151133248,513009726,1379054226,4151517420,492691615,3088872161,3438024328,1772979446,2206418053,650303227,448917981,3212862371,1437508560,4042207662,2216646087,559859641,3413116874,1848743348,579915544,2278645094,1845468437,3367898987,3159255810,420477308,4079040783,1449175921,1279457178,3909314020,53323159,2792110057,3533460352,2011021822,2649948557,951227379,1947453791,3511835425,998021970,2654800172,3939331397,1334640443,2778873672,14921014,1021348368,2577471598,1938806813,3603843683,2721984010,125811828,3981540359,1209069177,78755029,2716870315,1272899288,4003427494,2590970063,1060012721,3573564098,1883361468,2902854798,138911472,3798556291,1193856253,869836948,2526624490,2092432025,3656804583,2505519691,806789173,3661127750,2138698296,193566289,2932343855,1155974236,3785840162,3718541572,2028331898,2462786313,931836279,1132123422,3862644576,202737427,2840860013,3858059201,1085595071,2862226892,266047410,2066475995,3731519909,876919254,2433035176 },
@@ -14,17 +16,15 @@ static const uint32_t crc32c_table[8][256] = {
     { 0,1228700967,2457401934,3678701417,555582061,1747058506,3009771555,4200137988,1111164122,185039357,3494117012,2575270835,1663469239,706411408,4049501433,3093430750,2222328244,3444208787,370078714,1597148893,2775288793,3965187838,924021143,2117012656,3326938478,2406576201,1412822816,487164423,3880816387,2926375460,1965585741,1007945834,218129817,1144789182,2675482583,3594838768,740157428,1696701139,3194297786,4149829789,1329291587,101129316,3712195341,2491409962,1848042286,656055817,4234025312,3043124295,2306239533,3226079498,453940835,1379068740,2825645632,3780612967,974328846,1932486953,3410847991,2188449232,1496683193,269086622,3931171482,2741802941,2015891668,823422451,436259634,1396487701,2289578364,3242478683,991775071,1914778744,2842014481,3763981878,1480314856,285717199,3393402278,2206156929,2032553349,807022754,3948853195,2724383468,2658583174,3612000161,202258632,1160922607,3211477227,4132912588,756267685,1680852866,3696084572,2507258747,1312111634,118047029,4249895985,3026991382,1864941183,638894936,385920683,1581044620,2239255781,3427019202,907881670,2132890081,2758137480,3982076847,1429973617,470275926,3343077439,2390699288,1948657692,1025135931,3864973906,2942480245,2474026783,3662338616,17718609,1211244662,2993366386,4216805461,538173244,1764729371,3511526341,2557599458,1127569803,168371372,4031783336,3110886543,1646844902,722773697,872519268,2101209923,2792975402,4014280973,354161673,1545627950,2271538759,3461911392,1983550142,1057419161,3829557488,2910721495,1462178003,505114100,3311397533,2355337146,2960629712,4182500087,571434398,1798510777,2439650749,3629539482,51570675,1244568276,4065106698,3144738349,1614045508,688397411,3545307495,2590860352,1093264169,135634446,956429309,1883082458,2876836275,3796202644,404517264,1361054903,2321845214,3277387513,2067461927,839289344,3913420137,2692640846,1512535370,320538733,3361705732,2170810915,3178756681,4098590574,789512199,1714650400,2624223268,3579184387,236094058,1194262349,4283235987,3060827060,1832125661,604535290,3729882366,2540503513,1277789872,85326743,771841366,1732059249,3162089240,4114995775,253550395,1176543772,2640586101,3562559570,1815763340,621159595,4265780162,3078545125,1294457825,68921030,3747553711,2523094152,2859947234,3813353925,940551852,1899221899,2339034767,3260459944,420621505,1345212902,3897315384,2708483359,2050271862,856217425,3377582677,2154671986,1529423899,303387964,587282639,1782400488,2977546881,4165320614,35437218,1260439429,2422489324,3646438859,1631206421,671498546,4081239643,3128867708,1076346488,152814431,3529458742,2606971153,2809606523,3997912156,890227509,2083763730,2255139606,3478572593,336742744,1563309183,3846976929,2893039750,1999949807,1040757448,3293689804,2372782827,1445547394,521482405 }
 };
 
-#ifdef HW_CRC
-static const uint32_t crc32c_long[4][256] = {
+JL_UNUSED static const uint32_t crc32c_long[4][256] = {
     { 0,3762348204,3312301993,623728389,2402752931,1870133519,1247456778,2853850790,461522359,4223837467,3740267038,1051660978,2494913556,1962261688,1373170621,2979531537,923044718,3611585474,4066983111,304733291,3090387661,1483960929,2103321956,2636039624,747032281,3435540085,3924523376,162240988,2746341242,1139881942,1725718739,2258403455,1846089436,2387211888,2875498869,1260667353,3778940799,25096147,609466582,3289602170,1972065131,2513155015,2967921858,1353057390,4206643912,452766308,1070726497,3750829517,1494064562,3108863262,2623547931,2082523831,3594159121,913990845,324481976,4078424852,1116723205,2731489449,2279763884,1738706688,3451437478,771236106,148207119,3902117539,3692178872,1012059412,427792913,4181686973,1394947099,3009795255,2521334706,1980261150,3348129807,667977891,50192294,3804053258,1218933164,2833748224,2378876421,1837770409,3944130262,190203514,779817343,3460035027,1679933301,2220974041,2706114780,1091364976,4036289377,282330061,905532616,3585717348,2141452994,2682460782,3134082411,1519300039,2988129124,1381751752,2004257997,2536926305,1026302663,3714892395,4165047662,402748866,2845408979,1238998655,1827981690,2360617430,648963952,3337521116,3821261017,58929269,2233446410,1700745382,1081214883,2687690511,170437033,3932702981,3477413376,788922028,2661152189,2128418065,1542472212,3148915384,296414238,4058647730,3569834935,881310491,3184012673,1569246509,2024118824,2565175940,855585826,3535787150,4153574283,399663911,2789894198,1175095450,1663557535,2204581683,696086933,3376255289,3960522300,206579344,2328667887,1787577923,1335955782,2950820330,100384588,3854262240,3231058149,550955081,2437866328,1896743924,1411601649,3026433117,511310587,4265155159,3675540818,995405310,3552656221,864148465,380407028,4142689368,1559634686,3166093906,2577110359,2044425723,3359866602,671325766,221169987,3983419887,1198810953,2805237733,2182729952,1650012236,3838160947,75845791,564660122,3253266230,1811065232,2343717180,2929663545,1323302549,4282905988,520557864,975847981,3664421505,1886448679,2419068043,3038600078,1432206114,1641676857,2174410901,2763503504,1157060412,4008515994,246282550,729853491,3418377887,2052605326,2585306402,3207983655,1601507979,4117716013,355449985,805497732,3493989160,1457425239,3063835643,2477997310,1945361490,3655963380,967406168,478422365,4240754161,1297927904,2904305228,2284943689,1752275429,3261847363,573257711,117858538,3880157254,265492197,4019451465,3401490764,721306080,2162429766,1621422058,1166653679,2781435971,340874066,4094800894,3510428923,830211159,2607172337,2066131549,1577844056,3192593908,953654667,3633806631,4256836130,502975118,3084944424,1470129284,1921856385,2462962477,592828476,3272947856,3862458261,108564281,2892153247,1277305139,1762620982,2303694490 },
     { 0,2122067443,4244134886,2189719061,4229742909,2187390158,14981851,2123937576,4258657419,2208946552,19771245,2136048286,29963702,2142574661,4247875152,2202878883,4266106855,2151395860,46121985,2093214194,39542490,2082960169,4272096572,2162108623,59927404,2112767647,4285149322,2165710201,4287539793,2180155298,58126775,2097863748,4184033599,2266981580,94048985,2078752554,92243970,2063836657,4186428388,2281438743,79084980,2060095559,4165920338,2251475873,4171922569,2262192506,72492911,2049837724,119854808,2035874603,4225535294,2241896653,4214757349,2235841046,130042883,2042388976,4210106963,2223837088,101284277,2020955206,116253550,2022821533,4195727496,2221512059,4146783375,2304166268,198360937,1974375066,188097970,1967786049,4157505108,2310165415,184487940,1954758135,4127673314,2289788433,4142125369,2292186314,169577183,1952950060,158169960,1997624987,4120191118,2347306365,4117871189,2332923814,160031155,2012597312,4105736163,2328142352,138466309,1983707638,144985822,1993892653,4099675448,2317367499,239709616,1882554435,4071749206,2362301349,4065684621,2351513982,246232939,1892752024,4087109947,2380297416,258212573,1897410350,260085766,1912387061,4084777952,2365910547,4027462231,2389843876,217475505,1921664066,202568554,1919868569,4041910412,2392229247,232507100,1940384559,4045643066,2405413065,4056352737,2411407890,222256135,1933799924,3954819055,2512753180,390194185,1765657082,396721874,1775850273,3948750132,2501970119,376195940,1745905303,3935572098,2498248049,3933243993,2483857322,378065343,1760885836,368975880,1803685371,3909516270,2541377053,3923960117,2543766726,354073299,1801885472,3895186563,2522347888,349409125,1789895318,339154366,1783314509,3905900120,2528338859,316339920,1822874403,3995249974,2422112453,4005967853,2428115486,306080779,1816281592,4010738267,2440245160,334977469,1837855822,320062310,1836052117,4025194624,2442638707,3969739063,2464236740,275067601,1847140130,276932618,1862108665,3967415276,2449858079,289971644,1865723983,3987785306,2479680425,3981728897,2468901234,296486759,1875913364,479419232,1659860627,3765108870,2652319093,3767507549,2666772398,477610427,1644948552,3779506155,2671411736,499053581,1673714174,492465878,1663451941,3785504048,2682132675,3805594759,2628315508,506240865,1615901330,516425146,1622419529,3794820700,2622256047,520171532,1635589631,3824774122,2642757145,3810390321,2640436418,535145175,1637451556,3857715807,2609659820,419973561,1735681098,434951010,1737555601,3843328132,2607326583,405137108,1717160743,3839737138,2594279617,3828951017,2588215834,415333391,1723683324,465014200,1707843659,3880769118,2570320813,3886763141,2581029238,458430307,1697594000,3865213235,2552124608,446309077,1692798758,444512270,1677891069,3867599848,2566573595 },
     { 0,3533637935,2698142895,1917676928,1145618351,2530719360,3835353856,906351151,2291236702,1510897265,675486705,4208726750,3436822769,507955678,1812702302,3197414769,349079629,3327230306,3021794530,1719920077,1350973410,2182692557,4032058189,583752290,2623534867,1321270844,1015911356,3994196627,3625404604,176701843,2026187795,2858034492,698159258,4211218869,2303685685,1540390170,1842720565,3209340442,3439840154,530105013,2701946820,1939039979,31329131,3544252996,3846492267,937154884,1167504580,2533998059,1028888791,4023161336,2642541688,1327428951,2031822712,2877566551,3653845975,190204664,3049449353,1734209190,353403686,3348072969,4052375590,588599561,1364737161,2210870694,1396318516,2175084571,4092085659,561466548,393387675,3320682420,3080780340,1698689819,3685441130,154425157,2071542469,2850436074,2682511813,1300031722,1060210026,3987639365,1207216505,2506858582,3878079958,901367033,62658262,3508740089,2741924473,1911651158,3479557671,502980360,1874309768,3173563303,2335009160,1504862375,738135335,4183819272,2057777582,2822256769,3665122561,149576750,1055886849,3966797614,2654857902,1285743489,4063645424,547964895,1390684767,2155553648,3061772639,1692530800,380409328,3291716831,1852422627,3170283724,3468418380,472175715,706807372,4173205347,2331206371,1483500492,3875063485,879218578,1177199122,2494933821,2729474322,1882157117,39984573,3506246802,2792637032,1961577287,111552199,3560517608,3795647943,816051432,1122933096,2423361607,786775350,4235867161,2385992089,1554534582,1789756057,3090320310,3397379638,417394457,2998585893,1613087498,308850314,3237455781,4143084938,611155109,1444942117,2227116042,975943035,3904158804,2600063444,1214699771,2120420052,2902197243,3736170107,204367700,2414433010,1568037853,792409693,4255399794,3416386909,423552114,1802734066,3119284445,125316524,3588695171,2812954883,1966424108,1127256579,2444204844,3823302316,830340995,2603080383,1236849552,1005960720,3916085055,3748619536,233860159,2143093183,2904688784,330737121,3240733902,3009724750,1643890785,1476270670,2237731681,4146888417,632518606,4115555164,668035699,1436289011,2265124572,2970017011,1671026140,299153500,3276517747,2111773698,2940212525,3708647597,261255554,966239149,3943213698,2571486978,1272630829,3783322385,857727550,1095929790,2479720081,2781369534,2002214289,85602321,3615832382,1762759759,3146685792,3385061600,459078095,760818656,4291175119,2374717263,1595164256,3704845254,239893225,2080446313,2929598022,2560347241,1241826630,944351430,3939934697,1413614744,2262631863,4103104567,638542104,269136695,3264592408,2967000984,1648877239,3357408139,444789412,1758437156,3125843467,2354398244,1590316299,747053195,4262996388,1082950869,2450755066,3764314234,851568981,79969146,3596300885,2752929749,1988712186 },
     { 0,1225060897,2450121794,3675068003,570408565,1761299540,3019266615,4210206742,1140817130,184258251,3522599080,2566023817,1644216991,721694910,4027131613,3104691452,2281634260,3472493557,368516502,1559490487,2785101729,4010128768,872981475,2097959362,3288433982,2365945631,1443389820,520917853,3858643787,2902116714,2012733193,1056124200,168920409,1125480312,2551734555,3508310842,737033004,1659554061,3118980974,4041420111,1240398259,15338386,3689356785,2464411600,1745962950,555070951,4195918724,3004977573,2381282445,3303771820,535206095,1457679086,2886779640,3843305689,1041835706,1998443675,3457155175,2266296902,1545200677,354227716,4025466386,2800438323,2112248400,887269489,337840818,1562900627,2250960624,3475905745,903656647,2094548710,2815774853,4006716068,1474066008,517506169,3319108122,2362531899,1982056493,1059535372,3827969135,2905529934,2480796518,3671654727,30676772,1221649669,2988592403,4213620530,539732305,1764711280,3491925900,2569436589,1110141902,187668975,4057805305,3101279192,1674892731,718284698,506630123,1463188938,2352704425,3309279624,1070412190,1992934335,2915358172,3837798397,1573778177,348717344,3485734723,2260788578,2083671412,892780373,3996887350,2805947159,2580313663,3502801950,197497469,1119969372,3090401354,4046928491,708455432,1665064489,3660778197,2469918964,1211821719,20847798,4224496800,2999469697,1774538978,549561027,675681636,1631774533,3125801254,4081779463,163162897,1086150960,2612023123,3535060338,1807313294,582851503,4189097420,2964619245,1246156795,54666714,3629069241,2437661080,2948132016,3871088273,1035012338,1958083283,2387038917,3343098084,474920583,1430930598,3964112986,2772656763,2119070744,927630905,3451399727,2226969614,1605487213,380975180,576163901,1800626716,2958980223,4183459422,61353544,1252842601,2443299338,3634706475,1638460631,682368758,4087416981,3131439796,1079464610,156475523,3529422560,2606384321,2779343337,3970800584,933268907,2124709770,2220283804,3444712893,375337950,1599848959,3864401155,2941445922,1952444737,1029374816,3349785462,2393725271,1436569396,480558357,1013260246,1969352183,2926377876,3882355125,496673187,1419662210,2408793569,3331831744,2140824380,916361501,3985868670,2761389407,1583734089,392245096,3429644555,2238237482,3147556354,4070511651,697434688,1620504673,2590267511,3546327638,141409333,1097420308,4167342824,2975885513,1785560746,594119819,3650823325,2426394300,1267908831,43397886,913611407,2138073262,2759687885,3984166124,394994938,1586484955,2239938744,3431346841,1972102757,1016009796,3884057127,2928078854,1416910864,493922865,3330128978,2407091827,2978636635,4170092922,595822361,1787262264,2423643438,3648073487,41695596,1266207565,4067762097,3144805776,1618803699,695732690,3549077956,2593018853,1099122054,143112103 }
 };
-static const uint32_t crc32c_short[4][256] = {
+JL_UNUSED static const uint32_t crc32c_short[4][256] = {
     { 0,3702618788,3163456441,1614805277,2096198019,2688551719,3229610554,483297438,4192396038,626235810,1164730559,2581404187,2232652421,1503848481,966594876,3844893592,4129927421,714656345,1252471620,2518043104,2329461118,1449769946,911622855,3941021795,264983547,3547998559,3007696962,1878305510,1933189752,2945145052,3484721601,319150949,3921614603,890138031,1429312690,2306928150,2504943240,1241455660,700507441,4117864341,274592781,3438055081,2899539892,1885474064,1823245710,2954755882,3491890743,210992275,529967094,3274169682,2736268367,2141806315,1667749493,3218517201,3756611020,56110952,3866379504,986005076,1526384457,2253110765,2592421235,1177833431,638301898,4206546030,3599915239,170074691,1780276062,3064832506,2858625380,1993495488,384674525,3395080313,795917281,4089561413,2482911320,1330594556,1401014882,2402332870,4010756571,868103039,549185562,4228551358,2620746659,1082396935,1548392857,2163991357,3770948128,1014325380,3646491420,99119544,1708624037,3110531585,2779282079,2031681595,421984550,3315041154,1059934188,3818665288,2208549973,1595062001,1138507375,2674738379,4283612630,602130290,3335498986,444520014,2051092307,2800768503,3124682089,1720690637,112221904,3657507956,3372547857,364217781,1972010152,2839217676,3052768914,1766126646,159059243,3586815887,820386839,3965150899,2355666862,1356457226,1276603796,2426804016,4036619821,740856969,2831730495,1954135451,340149382,3371646498,3560552124,143182872,1756837125,3020312481,1361716281,2375769757,3986990976,823516452,769349050,4050267934,2438321667,1306832039,1591834562,2186284390,3798987899,1054772959,571475521,4271996133,2661189112,1110441820,2802029764,2075324000,462231421,3342626265,3690128711,121872355,1736206078,3150781530,1098371124,2647042704,4260975501,558377257,1032233399,3778534163,2164793870,1572427946,3096785714,1680099734,68923531,3635071535,3294905009,416626709,2028650760,2757475244,3076415689,1810831981,198239088,3613497812,3417248074,387869678,1998689011,2878400599,1320977359,2450389355,4063363190,780368594,843969100,4009527528,2395173365,1383205713,2119868376,2733368700,3268680801,509961925,44822107,3726284031,3190124002,1653872454,2277014750,1527318138,993460071,3884418499,4215868765,670595065,1204260580,2608264256,2289250085,1422022017,889040028,3897349688,4102184614,674440194,1208802591,2495457211,1905380387,2904602247,3441381274,296629566,224443808,3520186116,2985180697,1834960061,2548402387,1263858295,728435562,4158288334,3944020304,933594100,1469741801,2334851149,1845980117,2998276465,3532253292,238588616,318118486,3460784370,2927139311,1925833547,1640773678,3179102858,3712138135,32751923,490555821,3247190793,2712914452,2097328304,2553207592,1151312268,614488209,4161872437,3839863467,946786319,1481713938,2229294006 },
     { 0,1417541775,2835083550,4236642705,1411093709,6712386,4242564563,2828901724,2822187418,4232761621,13424772,1420894219,4230790487,2823898584,1423395913,11187398,1434592709,33545546,4252619995,2835622996,26849544,1441024391,2841788438,4246714521,4256500831,2848519376,1431240001,20121038,2846791826,4258488349,22374796,1428721923,2869185418,4286165765,67091092,1468154395,4280278855,2875336648,1474571865,60413654,53699088,1464769183,2882048782,4290079617,1462302429,55905874,4292020163,2880372556,4270222927,2868614848,1451073361,33581022,2862480002,4276093453,40242076,1444672275,1454458837,46972762,4266309323,2855751236,44749592,1456941975,2857443846,4264352393,1407508965,127474026,4213117179,2942494836,134182184,1401064871,2936308790,4219043001,4224960639,2947428592,1395145057,123060718,2949143730,4222985277,120827308,1397642531,107398176,1377516719,2929538366,4209036721,1383944429,100706402,4203127283,2935708028,2924604858,4197193013,111811748,1389880363,4199184759,2922873336,1387366505,114061542,4175473263,2895991520,1343970161,73835518,2902146722,4169582125,67162044,1350383411,1356301301,78281594,4163662571,2891024996,80484152,1353838519,2889344550,4165607081,2908917674,4179588901,93945524,1373931067,4185463655,2902778856,1367534201,100602614,89499184,1361600191,2913883950,4191399841,1364079357,87280242,4189438947,2915580780,2815017930,4088675141,254948052,1531955803,4090648327,2813308808,1529456153,257187478,268364368,1535316703,2802129742,4084786113,1541766813,261654034,4078866307,2808313612,4065060367,2788564608,1521489681,248377246,2790290114,4063070797,246121436,1524005715,1518129045,234960666,4068949643,2801452548,241654616,1511695319,2795285062,4074853065,214796352,1487958223,2755033438,4031480273,1490427021,212591618,4029541779,2756711708,2767888858,4035402069,201412804,1484564555,4041291031,2761739672,1478149129,208092294,1498393989,221402378,4055129243,2781455380,223623496,1495908807,2779760726,4057084121,4051207199,2768600208,1501787393,234786190,2774733010,4045334621,228123084,1508186435,4096598575,2689653408,1557582641,145435582,2687940322,4098575981,147671036,1555087219,1545210805,141030202,4108450475,2694578724,134324088,1551656951,2700766822,4102526697,2712602602,4124245861,156563188,1562971771,4122252071,2714332072,1565483577,154311350,160968304,1575343871,2707677038,4112394209,1568914109,167658034,4118301603,2701505324,1596549541,190091562,4157774011,2746179636,187891048,1599014375,2747862134,4155831545,4145954879,2741221552,1608888609,194529710,2735068402,4151848061,201205228,1602477411,178998368,1591129327,2723200382,4130162161,1588648109,181215266,4132121011,2721501500,2728158714,4141981045,174560484,1578789995,4136104247,2734295480,1585184809,167901350 },
     { 0,1249898853,2499797706,3732935599,739488613,1718370816,3102495151,4069761226,1478977226,307795887,3436741632,2259121509,1949619631,1045112010,3771414373,2863973888,2957954452,4197530865,615591774,1859051067,2623373041,3592589204,144874555,1121807710,3899239262,2719373883,2090224020,921286897,3296335931,2382752094,1350957809,452594580,1701965273,789454012,4052619027,3153198710,1231183548,52277209,3718102134,2548190483,1029081875,1999207030,2846452185,3822491836,289749110,1530579219,2243615420,3485805529,3577684045,2671825192,1103151751,197080034,4180448040,3008586317,1842573794,665616519,2367178375,3345463266,434611277,1402492200,2701915618,3950249095,905189160,2139874893,3403930546,2157718231,1578908024,342083613,3874515159,2895092146,1913621021,946895736,2462367096,3636153373,104554418,1279569623,3201764893,4104716152,707325143,1616321970,2058163750,819128131,3998414060,2754413961,1455334723,482432038,3259058057,2285811436,579498220,1760919945,3061158438,4228539203,244958089,1155937004,2590384451,3491352614,2945594987,3857565454,997053601,1897014724,2206303502,3388896363,394160068,1560385185,4155855009,3184173508,1665839723,691356430,3685147588,2446922401,1331233038,86437995,534576127,1436748442,2334333237,3244091472,869222554,2041625087,2804984400,3981400885,1207672117,226782288,3540287487,2575011482,1810378320,563601205,4279749786,3043507711,2418786709,3662950640,81011551,1319883322,3157816048,4131881877,684167226,1656250719,3356272479,2188596794,1559446933,378320112,3827242042,2925585759,1893791472,983500693,543493121,1780153700,3030052555,4276428718,209108836,1175014913,2559139246,3539381451,2017618635,842898350,3971844097,2797762916,1414650286,506341579,3232643940,2329004545,4116327500,3206929705,1638256262,735723491,3645480745,2469817932,1303805411,130649222,2910669446,3875716067,964864076,1945983273,2171533795,3406891142,361831209,1609493068,1158996440,258674877,3521839890,2610229879,1762087613,595108824,4260933751,3079094546,489916178,1464628855,2311874008,3283326141,824194167,2069873938,2782910141,4020250584,1523063335,280488770,3459774701,2219313544,1994107202,1017403431,3794029448,2824583917,49249517,1217432968,2517671463,3698290498,788320136,1686322925,3120770370,4034714663,3934705587,2700682966,2121872761,872858652,3331679446,2364183987,1382712860,404060025,2996941177,4175314972,643716019,1814143702,2662466076,3570267001,172875990,1077023155,1069152254,1975912091,2873496884,3778667601,329925787,1507177982,2270537297,3442104116,1738445108,769744977,4083250174,3105784475,1267540561,32690996,3748839579,2500669950,2415344234,3314076431,453564576,1366763973,2749663503,3919280234,924543941,2103745184,3620756640,2645536197,1127202410,156258063,4223922117,2981895840,1866206479,625212522 },
     { 0,633075163,1266150326,1858870893,2532300652,3008635575,3717741786,4163094785,674486313,227028466,1665414047,1191167556,3202092869,2607282846,4121683187,3490713896,1348972626,1977369993,454056932,1051438655,3330828094,3811807973,2382335112,2823059795,2018797691,1575984544,857965517,379090454,4005281559,3405793996,2781631649,2155323770,2697945252,2239010175,3954739986,3456335561,908113864,328942099,2102877310,1491904933,2298263693,2907131222,3280687931,3861948128,504590305,1000905274,1432650839,1893691788,4037595382,3574801709,3151969088,2657406619,1715931034,1140650561,758180908,143333879,3634039007,4246797572,2481775465,3059160754,1316282291,1808738920,84096005,548979166,1148368825,1640579682,252009487,717138388,3533529301,4146500878,2582285155,3159457464,1816227728,1241160267,657884198,42824189,4205754620,3742715175,2983809866,2489493137,336922603,833548848,1600318557,2061048198,2197475463,2806064476,3381476145,3963014890,1009180610,429730329,2001810548,1391116719,2865301678,2406677877,3787383576,3288667843,3837646621,3238404806,2949266603,2322712944,1917976689,1474950570,958786503,480124444,3431862068,3912628975,2281301122,2722238809,1516361816,2145004931,286667758,883803701,3034212175,2439090836,4289563897,3658905890,573943843,126764536,1765956501,1291431502,2632564582,3109178045,3617477840,4062552331,168192010,800955857,1097958332,1690990183,2296737650,2908658345,3281159364,3861475615,504018974,1001475525,1434276776,1892066931,2698426203,2238530176,3953220845,3457853750,909729847,327325164,2102299521,1492483674,3632455456,4248382203,2482320534,3058614605,1315768396,1809251735,85648378,547427873,4038133513,3574264530,3150376127,2658998628,1717489765,1139090878,757677011,143838728,673845206,227670541,1667097696,1189482939,3200637114,2608737633,4122096396,3490301655,1693695,631382564,1265515593,1859504530,2532704403,3008230728,3716279077,4164558590,2018361220,1576421983,859460658,377594345,4003621096,3407453491,2782233438,2154722949,1350461357,1975882358,453610523,1051883968,3331436737,3811198234,2380684151,2824711852,3432503499,3911986448,2279617405,2723923622,1517817767,2143550076,286254097,884216266,3835953378,3240097081,2949901140,2322079375,1917573006,1475355221,960248888,478661091,2633001113,3108740418,3615982383,4064048884,169852917,799296046,1097356355,1691591064,3032723632,2440578411,4290009862,3658460893,573335516,127373831,1767607402,1289779633,1817753711,1239633332,657413081,43296258,4206325507,3742145240,2982184117,2491117934,1147887686,1641059741,253529072,715619883,3531913002,4148118257,2582863004,3158878535,1010763837,428146150,2001265547,1391662672,2865815377,2406165130,3785831655,3290218812,336384020,834086351,1601911714,2059456121,2195916664,2807624355,3381980366,3962509589 }
 };
-#endif /* HW_CRC */
diff --git a/src/crc32c.c b/src/crc32c.c
new file mode 100644
index 00000000000000..e9e71bffe5183a
--- /dev/null
+++ b/src/crc32c.c
@@ -0,0 +1,612 @@
+/* crc32c.c -- compute CRC-32C using software table or available hardware instructions
+ * Copyright (C) 2013 Mark Adler
+ * Version 1.1  1 Aug 2013  Mark Adler
+ *
+ * Code retrieved in August 2016 from August 2013 post by Mark Adler on
+ *    http://stackoverflow.com/questions/17645167/implementing-sse-4-2s-crc32c-in-software
+ * Modified for use in libjulia:
+ *    - exported function renamed to jl_crc32c, DLL exports added.
+ *    - removed main() function
+ *    - architecture and compiler detection
+ *    - precompute crc32c tables and store in a generated .c file
+ *    - ARMv8 support
+ */
+
+/*
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the author be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  Mark Adler
+  madler@alumni.caltech.edu
+*/
+
+/* This computes a CRC-32C, *not* the CRC-32 used by Ethernet and zip, gzip, etc.
+ * A software version is provided as a fall-back, as well as for speed comparisons. */
+
+/* Version history:
+   1.0  10 Feb 2013  First version
+   1.1   1 Aug 2013  Correct comments on why three crc instructions in parallel
+*/
+
+#include "julia.h"
+#include "julia_internal.h"
+
+#ifdef _CPU_AARCH64_
+#  include <sys/auxv.h>
+#endif
+
+/* CRC-32C (iSCSI) polynomial in reversed bit order. */
+#define POLY 0x82f63b78
+
+/* Block sizes for three-way parallel crc computation.  LONG and SHORT must
+   both be powers of two.  The associated string constants must be set
+   accordingly, for use in constructing the assembler instructions. */
+#define LONG 8192
+#define LONGx1 "8192"
+#define LONGx2 "16384"
+#define SHORT 256
+#define SHORTx1 "256"
+#define SHORTx2 "512"
+
+#ifndef GEN_CRC32C_TABLES
+#include "crc32c-tables.c"
+
+#if JL_USE_IFUNC
+// Archs that can't use ifunc to do feature detection (e.g. ARM) should undef this below.
+#  define JL_CRC32C_USE_IFUNC
+#endif
+
+JL_DLLEXPORT uint32_t jl_crc32c_sw(uint32_t crci, const char *buf, size_t len);
+typedef uint32_t (*crc32c_func_t)(uint32_t crc, const char *buf, size_t len);
+
+/* Apply the zeros operator table to crc. */
+JL_UNUSED static inline uint32_t crc32c_shift(const uint32_t zeros[][256], uint32_t crc)
+{
+    return zeros[0][crc & 0xff] ^ zeros[1][(crc >> 8) & 0xff] ^
+        zeros[2][(crc >> 16) & 0xff] ^ zeros[3][crc >> 24];
+}
+
+#if (defined(_CPU_X86_64_) || defined(_CPU_X86_)) && !defined(_COMPILER_MICROSOFT_)
+#  ifdef _CPU_X86_64_
+#    define CRC32_PTR "crc32q"
+#  else
+#    define CRC32_PTR "crc32l"
+#  endif
+
+/* Compute CRC-32C using the SSE4.2 hardware instruction. */
+static uint32_t crc32c_sse42(uint32_t crc, const char *buf, size_t len)
+{
+    /* need to be 64 bits for crc32q */
+    /* pre-process the crc */
+    uintptr_t crc0 = crc ^ 0xffffffff;
+
+    /* compute the crc for up to seven leading bytes to bring the data pointer
+       to an eight-byte boundary */
+    while (len && ((uintptr_t)buf & 7) != 0) {
+        __asm__("crc32b\t" "(%1), %0"
+                : "=r"(crc0)
+                : "r"(buf), "0"(crc0));
+        buf++;
+        len--;
+    }
+
+    /* compute the crc on sets of LONG*3 bytes, executing three independent crc
+       instructions, each on LONG bytes -- this is optimized for the Nehalem,
+       Westmere, Sandy Bridge, and Ivy Bridge architectures, which have a
+       throughput of one crc per cycle, but a latency of three cycles */
+    while (len >= LONG * 3) {
+        uintptr_t crc1 = 0;
+        uintptr_t crc2 = 0;
+        const char *end = buf + LONG;
+        do {
+            __asm__(CRC32_PTR "\t" "(%3), %0\n\t"
+                    CRC32_PTR "\t" LONGx1 "(%3), %1\n\t"
+                    CRC32_PTR "\t" LONGx2 "(%3), %2"
+                    : "=r"(crc0), "=r"(crc1), "=r"(crc2)
+                    : "r"(buf), "0"(crc0), "1"(crc1), "2"(crc2));
+            buf += sizeof(void*);
+        } while (buf < end);
+        crc0 = crc32c_shift(crc32c_long, crc0) ^ crc1;
+        crc0 = crc32c_shift(crc32c_long, crc0) ^ crc2;
+        buf += LONG * 2;
+        len -= LONG * 3;
+    }
+
+    /* do the same thing, but now on SHORT*3 blocks for the remaining data less
+       than a LONG*3 block */
+    while (len >= SHORT * 3) {
+        uintptr_t crc1 = 0;
+        uintptr_t crc2 = 0;
+        const char *end = buf + SHORT;
+        do {
+            __asm__(CRC32_PTR "\t" "(%3), %0\n\t"
+                    CRC32_PTR "\t" SHORTx1 "(%3), %1\n\t"
+                    CRC32_PTR "\t" SHORTx2 "(%3), %2"
+                    : "=r"(crc0), "=r"(crc1), "=r"(crc2)
+                    : "r"(buf), "0"(crc0), "1"(crc1), "2"(crc2));
+            buf += sizeof(void*);
+        } while (buf < end);
+        crc0 = crc32c_shift(crc32c_short, crc0) ^ crc1;
+        crc0 = crc32c_shift(crc32c_short, crc0) ^ crc2;
+        buf += SHORT * 2;
+        len -= SHORT * 3;
+    }
+
+    /* compute the crc on the remaining eight-byte units less than a SHORT*3
+       block */
+    const char *end = buf + (len - (len & 7));
+    while (buf < end) {
+        __asm__(CRC32_PTR "\t" "(%1), %0"
+                : "=r"(crc0)
+                : "r"(buf), "0"(crc0));
+        buf += sizeof(void*);
+    }
+    len &= 7;
+
+    /* compute the crc for up to seven trailing bytes */
+    while (len) {
+        __asm__("crc32b\t" "(%1), %0"
+                : "=r"(crc0)
+                : "r"(buf), "0"(crc0));
+        buf++;
+        len--;
+    }
+
+    /* return a post-processed crc */
+    return (uint32_t)crc0 ^ 0xffffffff;
+}
+
+// HW feature detection
+#  ifdef __SSE4_2__
+// The C code is compiled with SSE42 being required. Skip runtime dispatch.
+JL_DLLEXPORT uint32_t jl_crc32c(uint32_t crc, const char *buf, size_t len)
+{
+    return crc32c_sse42(crc, buf, len);
+}
+#  else
+static crc32c_func_t crc32c_dispatch(void)
+{
+    // When used in ifunc, we cannot call external functions (i.e. jl_cpuid)
+    uint32_t eax = 1, ebx, ecx, edx;
+    asm (
+#if defined(__i386__) && defined(__PIC__)
+        "xchg %%ebx, %%esi;"
+        "cpuid;"
+        "xchg %%esi, %%ebx;":
+        "=S" (ebx) ,
+#else
+        "cpuid":
+        "=b" (ebx),
+#endif
+        "+a" (eax),
+        "=c" (ecx),
+        "=d" (edx));
+    if ((ecx >> 20) & 1)
+        return crc32c_sse42;
+    return jl_crc32c_sw;
+}
+// For ifdef detection below
+#    define crc32c_dispatch crc32c_dispatch
+#    define crc32c_dispatch_ifunc "crc32c_dispatch"
+#  endif
+#elif defined(_CPU_AARCH64_)
+#define CRC_TARGET __attribute__((target("+crc")))
+/* Compute CRC-32C using the ARMv8 CRC32 extension. */
+CRC_TARGET static inline uint32_t crc32cx(uint32_t crc, uint64_t val)
+{
+    uint32_t res;
+    asm("crc32cx %w0, %w1, %2" : "=r"(res) : "r"(crc), "r"(val));
+    return res;
+}
+CRC_TARGET static inline uint32_t crc32cw(uint32_t crc, uint32_t val)
+{
+    uint32_t res;
+    asm("crc32cw %w0, %w1, %w2" : "=r"(res) : "r"(crc), "r"(val));
+    return res;
+}
+CRC_TARGET static inline uint32_t crc32ch(uint32_t crc, uint32_t val)
+{
+    uint32_t res;
+    asm("crc32ch %w0, %w1, %w2" : "=r"(res) : "r"(crc), "r"(val));
+    return res;
+}
+CRC_TARGET static inline uint32_t crc32cb(uint32_t crc, uint32_t val)
+{
+    uint32_t res;
+    asm("crc32cb %w0, %w1, %w2" : "=r"(res) : "r"(crc), "r"(val));
+    return res;
+}
+static inline uint64_t unaligned_i64(const char *ptr)
+{
+    uint64_t val;
+    memcpy(&val, ptr, 8);
+    return val;
+}
+static inline uint32_t unaligned_i32(const char *ptr)
+{
+    uint32_t val;
+    memcpy(&val, ptr, 4);
+    return val;
+}
+static inline uint16_t unaligned_i16(const char *ptr)
+{
+    uint16_t val;
+    memcpy(&val, ptr, 2);
+    return val;
+}
+
+// Modified from the SSE4.2 version.
+CRC_TARGET static uint32_t crc32c_armv8(uint32_t crc, const char *buf, size_t len)
+{
+    /* pre-process the crc */
+    crc = ~crc;
+
+    // Misaligned access doesn't seem to have any measurable performance overhead
+    // on Cortex-A57
+
+    // crc32c has a latency of 3 and throughput of 1 on Cortex-A57
+    // The latency and throughput are 2 and 1 on Cortex-A72
+    // In either case, the 3 wide parallel processing shouldn't hurt since the block size
+    // should be big enough.
+    /* compute the crc on sets of LONG*3 bytes, executing three independent crc
+     * instructions, each on LONG bytes. */
+    while (len >= LONG * 3) {
+        uint32_t crc1 = 0;
+        uint32_t crc2 = 0;
+        const char *end = buf + LONG;
+        const char *buf2 = end;
+        const char *buf3 = end + LONG;
+        do {
+            crc = crc32cx(crc, unaligned_i64(buf));
+            buf += 8;
+            crc1 = crc32cx(crc1, unaligned_i64(buf2));
+            buf2 += 8;
+            crc2 = crc32cx(crc2, unaligned_i64(buf3));
+            buf3 += 8;
+        } while (buf < end);
+        crc = crc32c_shift(crc32c_long, crc) ^ crc1;
+        crc = crc32c_shift(crc32c_long, crc) ^ crc2;
+        buf += LONG * 2;
+        len -= LONG * 3;
+    }
+
+    /* do the same thing, but now on SHORT*3 blocks for the remaining data less
+     * than a LONG*3 block */
+    while (len >= SHORT * 3) {
+        uint32_t crc1 = 0;
+        uint32_t crc2 = 0;
+        const char *end = buf + SHORT;
+        const char *buf2 = end;
+        const char *buf3 = end + SHORT;
+        do {
+            crc = crc32cx(crc, unaligned_i64(buf));
+            buf += 8;
+            crc1 = crc32cx(crc1, unaligned_i64(buf2));
+            buf2 += 8;
+            crc2 = crc32cx(crc2, unaligned_i64(buf3));
+            buf3 += 8;
+        } while (buf < end);
+        crc = crc32c_shift(crc32c_short, crc) ^ crc1;
+        crc = crc32c_shift(crc32c_short, crc) ^ crc2;
+        buf += SHORT * 2;
+        len -= SHORT * 3;
+    }
+    // The same shift table can be used to compute two SHORT blocks simultaneously
+    if (len >= SHORT * 2) {
+        uint32_t crc1 = 0;
+        const char *end = buf + SHORT;
+        const char *buf2 = end;
+        do {
+            crc = crc32cx(crc, unaligned_i64(buf));
+            buf += 8;
+            crc1 = crc32cx(crc1, unaligned_i64(buf2));
+            buf2 += 8;
+        } while (buf < end);
+        crc = crc32c_shift(crc32c_short, crc) ^ crc1;
+        buf += SHORT;
+        len -= SHORT * 2;
+    }
+
+    /* compute the crc on the remaining eight-byte units less than a SHORT*2
+       block */
+    const char *end = buf + len - 8;
+    while (buf <= end) {
+        crc = crc32cx(crc, unaligned_i64(buf));
+        buf += 8;
+    }
+    if (len & 4) {
+        crc = crc32cw(crc, unaligned_i32(buf));
+        buf += 4;
+    }
+    if (len & 2) {
+        crc = crc32ch(crc, unaligned_i16(buf));
+        buf += 2;
+    }
+    if (len & 1)
+        crc = crc32cb(crc, *buf);
+    /* return a post-processed crc */
+    return ~crc;
+}
+
+// HW feature detection
+#  ifdef __ARM_FEATURE_CRC32
+// The C code is compiled with CRC32 being required. Skip runtime dispatch.
+JL_DLLEXPORT uint32_t jl_crc32c(uint32_t crc, const char *buf, size_t len)
+{
+    return crc32c_armv8(crc, buf, len);
+}
+#  else
+static crc32c_func_t crc32c_dispatch(unsigned long hwcap)
+{
+    if (hwcap & HWCAP_CRC32)
+        return crc32c_armv8;
+    return jl_crc32c_sw;
+}
+// For ifdef detection below
+#    define crc32c_dispatch() crc32c_dispatch(getauxval(AT_HWCAP))
+#    define crc32c_dispatch_ifunc "crc32c_dispatch"
+#  endif
+#else
+// If we don't have any accelerated version to define, just make the _sw version define
+// the real version and then define a _sw version as test wrapper.
+JL_DLLEXPORT uint32_t jl_crc32c(uint32_t crc, const char *buf, size_t len);
+JL_DLLEXPORT uint32_t jl_crc32c_sw(uint32_t crc, const char *buf, size_t len)
+{
+    return jl_crc32c(crc, buf, len);
+}
+#define jl_crc32c_sw jl_crc32c
+#endif
+
+#ifdef crc32c_dispatch
+#  ifdef JL_CRC32C_USE_IFUNC
+// ifunc dispatch
+JL_DLLEXPORT uint32_t jl_crc32c(uint32_t crc, const char *buf, size_t len)
+    __attribute__((ifunc (crc32c_dispatch_ifunc)));
+#  else
+// lazy wrapper dispatch
+static uint32_t crc32c_lazy(uint32_t crc, const char *buf, size_t len);
+static crc32c_func_t crc32c_func = crc32c_lazy;
+
+static uint32_t crc32c_lazy(uint32_t crc, const char *buf, size_t len)
+{
+    crc32c_func = crc32c_dispatch();
+    return crc32c_func(crc, buf, len);
+}
+
+/* Compute a CRC-32C. Do a lazy dispatch based on hardware features */
+JL_DLLEXPORT uint32_t jl_crc32c(uint32_t crc, const char *buf, size_t len)
+{
+    return crc32c_func(crc, buf, len);
+}
+#  endif
+#endif
+
+/* Table-driven software version as a fall-back.  This is about 15 times slower
+   than using the hardware instructions.  This computes a little-endian
+   CRC32c, equivalent to the little-endian CRC of the SSE4.2 or ARMv8 instructions,
+   regardless of the endianness of the machine this is running on.  */
+JL_DLLEXPORT uint32_t jl_crc32c_sw(uint32_t crci, const char *buf, size_t len)
+{
+    uintptr_t crc = crci ^ 0xffffffff;
+    while (len && ((uintptr_t)buf & 7) != 0) {
+        crc = crc32c_table[0][(crc ^ *buf++) & 0xff] ^ (crc >> 8);
+        len--;
+    }
+    while (len >= 8) {
+#ifdef _P64
+        crc ^= *(uint64_t*)buf;
+        crc = crc32c_table[7][crc & 0xff] ^
+            crc32c_table[6][(crc >> 8) & 0xff] ^
+            crc32c_table[5][(crc >> 16) & 0xff] ^
+            crc32c_table[4][(crc >> 24) & 0xff] ^
+            crc32c_table[3][(crc >> 32) & 0xff] ^
+            crc32c_table[2][(crc >> 40) & 0xff] ^
+            crc32c_table[1][(crc >> 48) & 0xff] ^
+            crc32c_table[0][crc >> 56];
+#else
+        uint32_t *p = (uint32_t*)buf;
+        crc ^= p[0];
+        uint32_t hi = p[1];
+        crc = crc32c_table[7][crc & 0xff] ^
+            crc32c_table[6][(crc >> 8) & 0xff] ^
+            crc32c_table[5][(crc >> 16) & 0xff] ^
+            crc32c_table[4][(crc >> 24) & 0xff] ^
+            crc32c_table[3][hi & 0xff] ^
+            crc32c_table[2][(hi >> 8) & 0xff] ^
+            crc32c_table[1][(hi >> 16) & 0xff] ^
+            crc32c_table[0][hi >> 24];
+#endif
+        buf += 8;
+        len -= 8;
+    }
+    while (len) {
+        crc = crc32c_table[0][(crc ^ *buf++) & 0xff] ^ (crc >> 8);
+        len--;
+    }
+    return (uint32_t)crc ^ 0xffffffff;
+}
+
+/*****************************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+
+/* Compile with -DGEN_CRC32C_TABLES to generate header file containing
+   precomputed hardware and software tables */
+// Example command line, run from top level directory:
+// $ gcc src/crc32c.c -o main -DGEN_CRC32C_TABLES -I src -I src/support
+// $ ./main > src/crc32c-tables.c
+
+#else /* ifdef GEN_CRC32C_TABLES */
+
+/* Table for a quadword-at-a-time software crc. */
+static uint32_t crc32c_table[8][256];
+
+/* Construct table for software CRC-32C calculation. */
+static void crc32c_init_sw(void)
+{
+    uint32_t n, crc, k;
+
+    for (n = 0; n < 256; n++) {
+        crc = n;
+        crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
+        crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
+        crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
+        crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
+        crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
+        crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
+        crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
+        crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
+        crc32c_table[0][n] = crc;
+    }
+    for (n = 0; n < 256; n++) {
+        crc = crc32c_table[0][n];
+        for (k = 1; k < 8; k++) {
+            crc = crc32c_table[0][crc & 0xff] ^ (crc >> 8);
+            crc32c_table[k][n] = crc;
+        }
+    }
+}
+
+/* Tables for hardware crc that shift a crc by LONG and SHORT zeros. */
+static uint32_t crc32c_long[4][256];
+static uint32_t crc32c_short[4][256];
+
+/* Multiply a matrix times a vector over the Galois field of two elements,
+   GF(2).  Each element is a bit in an unsigned integer.  mat must have at
+   least as many entries as the power of two for most significant one bit in
+   vec. */
+static inline uint32_t gf2_matrix_times(uint32_t *mat, uint32_t vec)
+{
+    uint32_t sum;
+
+    sum = 0;
+    while (vec) {
+        if (vec & 1)
+            sum ^= *mat;
+        vec >>= 1;
+        mat++;
+    }
+    return sum;
+}
+
+/* Multiply a matrix by itself over GF(2).  Both mat and square must have 32
+   rows. */
+static inline void gf2_matrix_square(uint32_t *square, uint32_t *mat)
+{
+    int n;
+
+    for (n = 0; n < 32; n++)
+        square[n] = gf2_matrix_times(mat, mat[n]);
+}
+
+/* Construct an operator to apply len zeros to a crc.  len must be a power of
+   two.  If len is not a power of two, then the result is the same as for the
+   largest power of two less than len.  The result for len == 0 is the same as
+   for len == 1.  A version of this routine could be easily written for any
+   len, but that is not needed for this application. */
+static void crc32c_zeros_op(uint32_t *even, size_t len)
+{
+    int n;
+    uint32_t row;
+    uint32_t odd[32];       /* odd-power-of-two zeros operator */
+
+    /* put operator for one zero bit in odd */
+    odd[0] = POLY;              /* CRC-32C polynomial */
+    row = 1;
+    for (n = 1; n < 32; n++) {
+        odd[n] = row;
+        row <<= 1;
+    }
+
+    /* put operator for two zero bits in even */
+    gf2_matrix_square(even, odd);
+
+    /* put operator for four zero bits in odd */
+    gf2_matrix_square(odd, even);
+
+    /* first square will put the operator for one zero byte (eight zero bits),
+       in even -- next square puts operator for two zero bytes in odd, and so
+       on, until len has been rotated down to zero */
+    do {
+        gf2_matrix_square(even, odd);
+        len >>= 1;
+        if (len == 0)
+            return;
+        gf2_matrix_square(odd, even);
+        len >>= 1;
+    } while (len);
+
+    /* answer ended up in odd -- copy to even */
+    for (n = 0; n < 32; n++)
+        even[n] = odd[n];
+}
+
+/* Take a length and build four lookup tables for applying the zeros operator
+   for that length, byte-by-byte on the operand. */
+static void crc32c_zeros(uint32_t zeros[][256], size_t len)
+{
+    uint32_t n;
+    uint32_t op[32];
+
+    crc32c_zeros_op(op, len);
+    for (n = 0; n < 256; n++) {
+        zeros[0][n] = gf2_matrix_times(op, n);
+        zeros[1][n] = gf2_matrix_times(op, n << 8);
+        zeros[2][n] = gf2_matrix_times(op, n << 16);
+        zeros[3][n] = gf2_matrix_times(op, n << 24);
+    }
+}
+
+/* Initialize tables for shifting crcs. */
+static void crc32c_init_hw(void)
+{
+    crc32c_zeros(crc32c_long, LONG);
+    crc32c_zeros(crc32c_short, SHORT);
+}
+
+#include <stdio.h>
+
+static void print_array(const char *name, int m, int n, const uint32_t *a)
+{
+    int i, j;
+    printf("JL_UNUSED static const uint32_t %s[%d][%d] = {\n", name, m, n);
+    for (i = 0; i < m; ++i) {
+        printf("    { %u", a[i*n+0]);
+        for (j = 1; j < n; ++j) printf(",%u", a[i*n+j]);
+        printf(" }%s", i == m-1 ? "\n" : ",\n");
+    }
+    printf("};\n");
+}
+
+int main(void)
+{
+    printf("// This file is a part of Julia. License is MIT: https://julialang.org/license\n\n");
+    printf("/* Pregenerated tables for crc32c.c, produced by compiling with -DGEN_CRC32C_TABLES. */\n"
+           "#if POLY != 0x%x\n#  error \"tables generated for different polynomial\"\n#endif\n\n", POLY);
+    crc32c_init_sw();
+    print_array("crc32c_table", 8, 256, &crc32c_table[0][0]);
+    crc32c_init_hw();
+    printf("\n");
+    print_array("crc32c_long", 4, 256, &crc32c_long[0][0]);
+    print_array("crc32c_short", 4, 256, &crc32c_short[0][0]);
+    return 0;
+}
+
+#endif /* GEN_CRC32C_TABLES */
+
+/*****************************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
diff --git a/src/datatype.c b/src/datatype.c
index ed9bd48f8e3211..aa419f521dc5cb 100644
--- a/src/datatype.c
+++ b/src/datatype.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 /*
   defining DataTypes
@@ -66,17 +66,11 @@ JL_DLLEXPORT jl_typename_t *jl_new_typename_in(jl_sym_t *name, jl_module_t *modu
     return tn;
 }
 
-JL_DLLEXPORT jl_typename_t *jl_new_typename(jl_sym_t *name)
-{
-    jl_ptls_t ptls = jl_get_ptls_states();
-    return jl_new_typename_in(name, ptls->current_module);
-}
-
 // allocating DataTypes -----------------------------------------------------------
 
-jl_datatype_t *jl_new_abstracttype(jl_value_t *name, jl_datatype_t *super, jl_svec_t *parameters)
+jl_datatype_t *jl_new_abstracttype(jl_value_t *name, jl_module_t *module, jl_datatype_t *super, jl_svec_t *parameters)
 {
-    return jl_new_datatype((jl_sym_t*)name, super, parameters, jl_emptysvec, jl_emptysvec, 1, 0, 0);
+    return jl_new_datatype((jl_sym_t*)name, module, super, parameters, jl_emptysvec, jl_emptysvec, 1, 0, 0);
 }
 
 jl_datatype_t *jl_new_uninitialized_datatype(void)
@@ -97,12 +91,23 @@ static jl_datatype_layout_t *jl_get_layout(uint32_t nfields,
 {
     // compute the smallest fielddesc type that can hold the layout description
     int fielddesc_type = 0;
+    uint32_t npointers = 0;
+    // First pointer field
+    uint32_t first_ptr = (uint32_t)-1;
+    // Last pointer field
+    uint32_t last_ptr = 0;
     if (nfields > 0) {
         uint32_t max_size = 0;
         uint32_t max_offset = desc[nfields - 1].offset;
         for (size_t i = 0; i < nfields; i++) {
             if (desc[i].size > max_size)
                 max_size = desc[i].size;
+            if (desc[i].isptr) {
+                npointers++;
+                if (first_ptr == (uint32_t)-1)
+                    first_ptr = i;
+                last_ptr = i;
+            }
         }
         jl_fielddesc8_t maxdesc8 = { 0, max_size, max_offset };
         jl_fielddesc16_t maxdesc16 = { 0, max_size, max_offset };
@@ -120,8 +125,20 @@ static jl_datatype_layout_t *jl_get_layout(uint32_t nfields,
 
     // allocate a new descriptor
     uint32_t fielddesc_size = jl_fielddesc_size(fielddesc_type);
+    int has_padding = nfields && npointers;
     jl_datatype_layout_t *flddesc =
-        (jl_datatype_layout_t*)jl_gc_perm_alloc(sizeof(jl_datatype_layout_t) + nfields * fielddesc_size);
+        (jl_datatype_layout_t*)jl_gc_perm_alloc(sizeof(jl_datatype_layout_t) +
+                                                nfields * fielddesc_size +
+                                                (has_padding ? sizeof(uint32_t) : 0), 0, 4, 0);
+    if (has_padding) {
+        if (first_ptr > UINT16_MAX)
+            first_ptr = UINT16_MAX;
+        last_ptr = nfields - last_ptr - 1;
+        if (last_ptr > UINT16_MAX)
+            last_ptr = UINT16_MAX;
+        flddesc = (jl_datatype_layout_t*)(((char*)flddesc) + sizeof(uint32_t));
+        jl_datatype_layout_n_nonptr(flddesc) = (first_ptr << 16) | last_ptr;
+    }
     flddesc->nfields = nfields;
     flddesc->alignment = alignment;
     flddesc->haspadding = haspadding;
@@ -131,7 +148,6 @@ static jl_datatype_layout_t *jl_get_layout(uint32_t nfields,
     jl_fielddesc8_t* desc8 = (jl_fielddesc8_t*)jl_dt_layout_fields(flddesc);
     jl_fielddesc16_t* desc16 = (jl_fielddesc16_t*)jl_dt_layout_fields(flddesc);
     jl_fielddesc32_t* desc32 = (jl_fielddesc32_t*)jl_dt_layout_fields(flddesc);
-    uint32_t npointers = 0;
     for (size_t i = 0; i < nfields; i++) {
         if (fielddesc_type == 0) {
             desc8[i].offset = desc[i].offset;
@@ -148,9 +164,6 @@ static jl_datatype_layout_t *jl_get_layout(uint32_t nfields,
             desc32[i].size = desc[i].size;
             desc32[i].isptr = desc[i].isptr;
         }
-        if (desc[i].isptr) {
-            npointers++;
-        }
     }
     uint32_t nexp = 0;
     while (npointers >= 0x10000) {
@@ -203,16 +216,69 @@ unsigned jl_special_vector_alignment(size_t nfields, jl_value_t *t)
     return alignment;
 }
 
+STATIC_INLINE int jl_is_datatype_make_singleton(jl_datatype_t *d)
+{
+    return (!d->abstract && jl_datatype_size(d) == 0 && d != jl_sym_type && d->name != jl_array_typename &&
+            d->uid != 0 && (d->types == jl_emptysvec || !d->mutabl));
+}
+
+STATIC_INLINE void jl_allocate_singleton_instance(jl_datatype_t *st)
+{
+    if (jl_is_datatype_make_singleton(st)) {
+        st->instance = jl_gc_alloc(jl_get_ptls_states(), 0, st);
+        jl_gc_wb(st, st->instance);
+    }
+}
+
 void jl_compute_field_offsets(jl_datatype_t *st)
 {
     size_t sz = 0, alignm = 1;
     int homogeneous = 1;
     jl_value_t *lastty = NULL;
-
     uint64_t max_offset = (((uint64_t)1) << 32) - 1;
     uint64_t max_size = max_offset >> 1;
 
+    if (st->name->wrapper) {
+        // If layout doesn't depend on type parameters, it's stored in st->name->wrapper
+        // and reused by all subtypes.
+        jl_datatype_t *w = (jl_datatype_t*)jl_unwrap_unionall(st->name->wrapper);
+        if (st != w &&  // this check allows us to re-compute layout for some types during init
+            w->layout) {
+            st->layout = w->layout;
+            st->size = w->size;
+            jl_allocate_singleton_instance(st);
+            return;
+        }
+    }
+    if (st->types == NULL)
+        return;
     uint32_t nfields = jl_svec_len(st->types);
+    if (nfields == 0) {
+        if (st == jl_sym_type || st == jl_string_type) {
+            // opaque layout - heap-allocated blob
+            static const jl_datatype_layout_t opaque_byte_layout = {0, 1, 0, 1, 0};
+            st->layout = &opaque_byte_layout;
+        }
+        else if (st == jl_simplevector_type || st->name == jl_array_typename) {
+            static const jl_datatype_layout_t opaque_ptr_layout = {0, sizeof(void*), 0, 1, 0};
+            st->layout = &opaque_ptr_layout;
+        }
+        else {
+            // reuse the same layout for all singletons
+            static const jl_datatype_layout_t singleton_layout = {0, 1, 0, 0, 0};
+            st->layout = &singleton_layout;
+            jl_allocate_singleton_instance(st);
+        }
+        return;
+    }
+    if (!jl_is_leaf_type((jl_value_t*)st)) {
+        // compute layout whenever field types have no free variables
+        for (size_t i = 0; i < nfields; i++) {
+            if (jl_has_free_typevars(jl_field_type(st, i)))
+                return;
+        }
+    }
+
     size_t descsz = nfields * sizeof(jl_fielddesc32_t);
     jl_fielddesc32_t *desc;
     if (descsz < jl_page_size)
@@ -233,7 +299,7 @@ void jl_compute_field_offsets(jl_datatype_t *st)
             // Should never happen
             if (__unlikely(fsz > max_size))
                 goto throw_ovf;
-            al = ((jl_datatype_t*)ty)->layout->alignment;
+            al = jl_datatype_align(ty);
             desc[i].isptr = 0;
             if (((jl_datatype_t*)ty)->layout->haspadding)
                 haspadding = 1;
@@ -245,6 +311,7 @@ void jl_compute_field_offsets(jl_datatype_t *st)
             al = fsz;
             desc[i].isptr = 1;
         }
+        assert(al <= JL_HEAP_ALIGNMENT && (JL_HEAP_ALIGNMENT % al) == 0);
         if (al != 0) {
             size_t alsz = LLT_ALIGN(sz, al);
             if (sz & (al - 1))
@@ -265,7 +332,10 @@ void jl_compute_field_offsets(jl_datatype_t *st)
         // Some tuples become LLVM vectors with stronger alignment than what was calculated above.
         unsigned al = jl_special_vector_alignment(nfields, lastty);
         assert(al % alignm == 0);
-        if (al)
+        // JL_HEAP_ALIGNMENT is the biggest alignment we can guarantee on the heap.
+        if (al > JL_HEAP_ALIGNMENT)
+            alignm = JL_HEAP_ALIGNMENT;
+        else if (al)
             alignm = al;
     }
     st->size = LLT_ALIGN(sz, alignm);
@@ -273,6 +343,7 @@ void jl_compute_field_offsets(jl_datatype_t *st)
         haspadding = 1;
     st->layout = jl_get_layout(nfields, alignm, haspadding, desc);
     if (descsz >= jl_page_size) free(desc);
+    jl_allocate_singleton_instance(st);
     return;
  throw_ovf:
     if (descsz >= jl_page_size) free(desc);
@@ -281,34 +352,25 @@ void jl_compute_field_offsets(jl_datatype_t *st)
 
 extern int jl_boot_file_loaded;
 
-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_datatype(
+        jl_sym_t *name,
+        jl_module_t *module,
+        jl_datatype_t *super,
+        jl_svec_t *parameters,
+        jl_svec_t *fnames,
+        jl_svec_t *ftypes,
+        int abstract, int mutabl,
+        int ninitialized)
 {
-    jl_ptls_t ptls = jl_get_ptls_states();
-    jl_datatype_t *t=NULL;
-    jl_typename_t *tn=NULL;
+    jl_datatype_t *t = NULL;
+    jl_typename_t *tn = NULL;
     JL_GC_PUSH2(&t, &tn);
 
-    if (!jl_boot_file_loaded && jl_is_symbol(name)) {
-        // hack to avoid making two versions of basic types needed
-        // during bootstrapping
-        if (!strcmp(jl_symbol_name((jl_sym_t*)name), "Int32"))
-            t = jl_int32_type;
-        else if (!strcmp(jl_symbol_name((jl_sym_t*)name), "Int64"))
-            t = jl_int64_type;
-        else if (!strcmp(jl_symbol_name((jl_sym_t*)name), "Bool"))
-            t = jl_bool_type;
-        else if (!strcmp(jl_symbol_name((jl_sym_t*)name), "UInt8"))
-            t = jl_uint8_type;
-    }
     if (t == NULL)
         t = jl_new_uninitialized_datatype();
     else
         tn = t->name;
-    // init before possibly calling jl_new_typename
+    // init before possibly calling jl_new_typename_in
     t->super = super;
     if (super != NULL) jl_gc_wb(t, t->super);
     t->parameters = parameters;
@@ -329,9 +391,9 @@ JL_DLLEXPORT jl_datatype_t *jl_new_datatype(jl_sym_t *name, jl_datatype_t *super
             tn = (jl_typename_t*)name;
         }
         else {
-            tn = jl_new_typename((jl_sym_t*)name);
+            tn = jl_new_typename_in((jl_sym_t*)name, module);
             if (!abstract) {
-                tn->mt = jl_new_method_table(name, ptls->current_module);
+                tn->mt = jl_new_method_table(name, module);
                 jl_gc_wb(tn, tn->mt);
             }
         }
@@ -353,27 +415,21 @@ JL_DLLEXPORT jl_datatype_t *jl_new_datatype(jl_sym_t *name, jl_datatype_t *super
     }
     jl_precompute_memoized_dt(t);
 
-    if (abstract || jl_svec_len(parameters) > 0) {
-        t->uid = 0;
-    }
-    else {
-        t->uid = jl_assign_type_uid();
-        if (t->types != NULL && t->isconcrete) {
-            static const jl_datatype_layout_t singleton_layout = {0, 1, 0, 0, 0};
-            if (fnames == jl_emptysvec)
-                t->layout = &singleton_layout;
-            else
-                jl_compute_field_offsets(t);
-        }
+    t->uid = 0;
+    if (!abstract) {
+        if (jl_svec_len(parameters) == 0)
+            t->uid = jl_assign_type_uid();
+        jl_compute_field_offsets(t);
     }
     JL_GC_POP();
     return t;
 }
 
-JL_DLLEXPORT jl_datatype_t *jl_new_primitivetype(jl_value_t *name, jl_datatype_t *super,
+JL_DLLEXPORT jl_datatype_t *jl_new_primitivetype(jl_value_t *name, jl_module_t *module,
+                                                 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_datatype_t *bt = jl_new_datatype((jl_sym_t*)name, module, super, parameters,
                                         jl_emptysvec, jl_emptysvec, 0, 0, 0);
     uint32_t nbytes = (nbits + 7) / 8;
     uint32_t alignm = next_power_of_two(nbytes);
@@ -381,6 +437,7 @@ JL_DLLEXPORT jl_datatype_t *jl_new_primitivetype(jl_value_t *name, jl_datatype_t
         alignm = MAX_ALIGN;
     bt->size = nbytes;
     bt->layout = jl_get_layout(0, alignm, 0, NULL);
+    bt->instance = NULL;
     return bt;
 }
 
@@ -400,7 +457,7 @@ static jl_value_t *jl_new_bits_internal(jl_value_t *dt, void *data, size_t *len)
     size_t nb = jl_datatype_size(bt);
     if (nb == 0)
         return jl_new_struct_uninit(bt);
-    *len = LLT_ALIGN(*len, bt->layout->alignment);
+    *len = LLT_ALIGN(*len, jl_datatype_align(bt));
     data = (char*)data + (*len);
     *len += nb;
     if (bt == jl_uint8_type)   return jl_box_uint8(*(uint8_t*)data);
@@ -450,6 +507,14 @@ void jl_assign_bits(void *dest, jl_value_t *bits)
         jl_value_t *v = jl_gc_alloc(ptls, nw * sizeof(void*), t);       \
         *(int##nb##_t*)jl_data_ptr(v) = x;                              \
         return v;                                                       \
+    }                                                                   \
+    jl_value_t *jl_permbox##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_gc_permobj(nw * sizeof(void*), t);           \
+        *(int##nb##_t*)jl_data_ptr(v) = x;                              \
+        return v;                                                       \
     }
 BOXN_FUNC(8,  1)
 BOXN_FUNC(16, 1)
@@ -554,18 +619,18 @@ void jl_init_int32_int64_cache(void)
 {
     int64_t i;
     for(i=0; i < NBOX_C; i++) {
-        boxed_int32_cache[i]  = jl_box32(jl_int32_type, i-NBOX_C/2);
-        boxed_int64_cache[i]  = jl_box64(jl_int64_type, i-NBOX_C/2);
+        boxed_int32_cache[i]  = jl_permbox32(jl_int32_type, i-NBOX_C/2);
+        boxed_int64_cache[i]  = jl_permbox64(jl_int64_type, i-NBOX_C/2);
 #ifdef _P64
-        boxed_ssavalue_cache[i] = jl_box64(jl_ssavalue_type, i);
-        boxed_slotnumber_cache[i] = jl_box64(jl_slotnumber_type, i);
+        boxed_ssavalue_cache[i] = jl_permbox64(jl_ssavalue_type, i);
+        boxed_slotnumber_cache[i] = jl_permbox64(jl_slotnumber_type, i);
 #else
-        boxed_ssavalue_cache[i] = jl_box32(jl_ssavalue_type, i);
-        boxed_slotnumber_cache[i] = jl_box32(jl_slotnumber_type, i);
+        boxed_ssavalue_cache[i] = jl_permbox32(jl_ssavalue_type, i);
+        boxed_slotnumber_cache[i] = jl_permbox32(jl_slotnumber_type, i);
 #endif
     }
     for(i=0; i < 256; i++) {
-        boxed_uint8_cache[i] = jl_box8(jl_uint8_type, i);
+        boxed_uint8_cache[i] = jl_permbox8(jl_uint8_type, i);
     }
 }
 
@@ -573,34 +638,14 @@ void jl_init_box_caches(void)
 {
     int64_t i;
     for(i=0; i < 256; i++) {
-        boxed_int8_cache[i]  = jl_box8(jl_int8_type, i);
-    }
-    for(i=0; i < NBOX_C; i++) {
-        boxed_int16_cache[i]  = jl_box16(jl_int16_type, i-NBOX_C/2);
-        boxed_uint16_cache[i] = jl_box16(jl_uint16_type, i);
-        boxed_uint32_cache[i] = jl_box32(jl_uint32_type, i);
-        boxed_char_cache[i]   = jl_box32(jl_char_type, i);
-        boxed_uint64_cache[i] = jl_box64(jl_uint64_type, i);
-    }
-}
-
-void jl_mark_box_caches(jl_ptls_t ptls)
-{
-    int64_t i;
-    for(i=0; i < 256; i++) {
-        jl_gc_setmark(ptls, boxed_int8_cache[i]);
-        jl_gc_setmark(ptls, boxed_uint8_cache[i]);
+        boxed_int8_cache[i]  = jl_permbox8(jl_int8_type, i);
     }
     for(i=0; i < NBOX_C; i++) {
-        jl_gc_setmark(ptls, boxed_int16_cache[i]);
-        jl_gc_setmark(ptls, boxed_int32_cache[i]);
-        jl_gc_setmark(ptls, boxed_int64_cache[i]);
-        jl_gc_setmark(ptls, boxed_uint16_cache[i]);
-        jl_gc_setmark(ptls, boxed_uint32_cache[i]);
-        jl_gc_setmark(ptls, boxed_char_cache[i]);
-        jl_gc_setmark(ptls, boxed_uint64_cache[i]);
-        jl_gc_setmark(ptls, boxed_ssavalue_cache[i]);
-        jl_gc_setmark(ptls, boxed_slotnumber_cache[i]);
+        boxed_int16_cache[i]  = jl_permbox16(jl_int16_type, i-NBOX_C/2);
+        boxed_uint16_cache[i] = jl_permbox16(jl_uint16_type, i);
+        boxed_uint32_cache[i] = jl_permbox32(jl_uint32_type, i);
+        boxed_char_cache[i]   = jl_permbox32(jl_char_type, i);
+        boxed_uint64_cache[i] = jl_permbox64(jl_uint64_type, i);
     }
 }
 
@@ -661,7 +706,7 @@ JL_DLLEXPORT jl_value_t *jl_new_struct_uninit(jl_datatype_t *type)
 
 JL_DLLEXPORT int jl_field_index(jl_datatype_t *t, jl_sym_t *fld, int err)
 {
-    jl_svec_t *fn = t->name->names;
+    jl_svec_t *fn = jl_field_names(t);
     for(size_t i=0; i < jl_svec_len(fn); i++) {
         if (jl_svecref(fn,i) == (jl_value_t*)fld) {
             return (int)i;
@@ -733,7 +778,7 @@ JL_DLLEXPORT size_t jl_get_alignment(jl_datatype_t *ty)
 {
     if (ty->layout == NULL)
         jl_error("non-concrete type doesn't have an alignment");
-    return ty->layout->alignment;
+    return jl_datatype_align(ty);
 }
 
 #ifdef __cplusplus
diff --git a/src/debuginfo.cpp b/src/debuginfo.cpp
index 743af5f97a964a..551ffb9b81d032 100644
--- a/src/debuginfo.cpp
+++ b/src/debuginfo.cpp
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include "platform.h"
 
@@ -6,47 +6,36 @@
 #include <llvm/ExecutionEngine/ExecutionEngine.h>
 #include <llvm/ExecutionEngine/JITEventListener.h>
 #include <llvm/DebugInfo/DIContext.h>
-#if JL_LLVM_VERSION >= 30700
 #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>
-#if JL_LLVM_VERSION >= 30500
 #include <llvm/IR/DebugInfo.h>
-#else
-#include <llvm/DebugInfo.h>
-#endif
-#if defined(USE_MCJIT) || defined(USE_ORCJIT)
 #include <llvm/IR/DataLayout.h>
 #include <llvm/IR/Mangler.h>
-#if JL_LLVM_VERSION < 30600
-#include <llvm/ExecutionEngine/ObjectImage.h>
-#endif
 #include <llvm/ExecutionEngine/RuntimeDyld.h>
-#else
-#include <llvm/ExecutionEngine/JITMemoryManager.h>
+#if JL_LLVM_VERSION >= 50000
+#include <llvm/BinaryFormat/Magic.h>
 #endif
 #include <llvm/Object/MachO.h>
 #include <llvm/Object/COFF.h>
-#if JL_LLVM_VERSION >= 30700
-#  include <llvm/Object/ELFObjectFile.h>
-#endif
-
-#if defined(USE_MCJIT) && JL_LLVM_VERSION < 30600 && defined(_OS_DARWIN_)
-#include "../deps/llvm-3.5.0/lib/ExecutionEngine/MCJIT/MCJIT.h"
-#endif
+#include <llvm/Object/ELFObjectFile.h>
+#include "fix_llvm_assert.h"
 
 using namespace llvm;
 
+#if JL_LLVM_VERSION >= 50000
+using llvm_file_magic = file_magic;
+#else
+using llvm_file_magic = sys::fs::file_magic;
+#endif
+
 #include "julia.h"
 #include "julia_internal.h"
-#include "codegen_internal.h"
-#ifdef _OS_LINUX_
-#  define UNW_LOCAL_ONLY
-#  include <libunwind.h>
+#include "debuginfo.h"
+#if defined(_OS_LINUX_)
 #  include <link.h>
 #endif
 
@@ -59,13 +48,7 @@ using namespace llvm;
 #include <cstdio>
 #include <cassert>
 
-#if JL_LLVM_VERSION >= 30500 && JL_LLVM_VERSION < 30600
-extern ExecutionEngine *jl_ExecutionEngine;
-#endif
-
-#ifdef USE_MCJIT
 typedef object::SymbolRef SymRef;
-#endif
 
 // Any function that acquires this lock must be either a unmanaged thread
 // or in the GC safe region and must NOT allocate anything through the GC
@@ -81,26 +64,12 @@ extern "C" void jl_init_debuginfo()
 
 // --- storing and accessing source location metadata ---
 
-#ifndef USE_MCJIT
-struct FuncInfo {
-    const Function *func;
-    size_t lengthAdr;
-    std::vector<JITEvent_EmittedFunctionDetails::LineStart> lines;
-    jl_method_instance_t *linfo;
-};
-#else
 struct ObjectInfo {
     const object::ObjectFile *object;
     size_t SectionSize;
     ptrdiff_t slide;
-#if JL_LLVM_VERSION >= 30700
     DIContext *context;
-#endif
-#if defined(_OS_DARWIN_) && JL_LLVM_VERSION < 30700
-    const char *name;
-#endif
 };
-#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
@@ -108,22 +77,25 @@ struct ObjectInfo {
 static StringMap<jl_method_instance_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_method_instance_t *linfo, const DataLayout &DL)
 {
     linfo_in_flight[mangle(name, DL)] = linfo;
 }
 
+
+#ifdef _OS_WINDOWS_
+#if defined(_CPU_X86_64_)
+void *lookupWriteAddressFor(RTDyldMemoryManager *memmgr, void *rt_addr);
+#endif
+#endif
+
 #if defined(_OS_WINDOWS_)
 static void create_PRUNTIME_FUNCTION(uint8_t *Code, size_t Size, StringRef fnname,
                                      uint8_t *Section, size_t Allocated, uint8_t *UnwindData)
@@ -131,30 +103,7 @@ static void create_PRUNTIME_FUNCTION(uint8_t *Code, size_t Size, StringRef fnnam
     // GC safe
     DWORD mod_size = 0;
 #if defined(_CPU_X86_64_)
-#if !defined(USE_MCJIT)
-    uint8_t *catchjmp = Section+Allocated;
-    UnwindData = (uint8_t*)(((uintptr_t)catchjmp+12+3)&~(uintptr_t)3);
-    if (!catchjmp[0]) {
-        catchjmp[0] = 0x48;
-        catchjmp[1] = 0xb8; // mov RAX, QWORD PTR [...]
-        *(uint64_t*)(&catchjmp[2]) = (uint64_t)&__julia_personality;
-        catchjmp[10] = 0xff;
-        catchjmp[11] = 0xe0; // jmp RAX
-        UnwindData[0] = 0x09; // version info, UNW_FLAG_EHANDLER
-        UnwindData[1] = 4;    // size of prolog (bytes)
-        UnwindData[2] = 2;    // count of unwind codes (slots)
-        UnwindData[3] = 0x05; // frame register (rbp) = rsp
-        UnwindData[4] = 4;    // second instruction
-        UnwindData[5] = 0x03; // mov RBP, RSP
-        UnwindData[6] = 1;    // first instruction
-        UnwindData[7] = 0x50; // push RBP
-        *(DWORD*)&UnwindData[8] = (DWORD)(catchjmp - Section); // relative location of catchjmp
-        mod_size = (DWORD)Allocated+48;
-    }
-    PRUNTIME_FUNCTION tbl = (PRUNTIME_FUNCTION)(UnwindData+12);
-#else
     PRUNTIME_FUNCTION tbl = (PRUNTIME_FUNCTION)malloc(sizeof(RUNTIME_FUNCTION));
-#endif
     tbl->BeginAddress = (DWORD)(Code - Section);
     tbl->EndAddress = (DWORD)(Code - Section + Size);
     tbl->UnwindData = (DWORD)(UnwindData - Section);
@@ -166,9 +115,6 @@ static void create_PRUNTIME_FUNCTION(uint8_t *Code, size_t Size, StringRef fnnam
         assert(!jl_in_stackwalk);
         jl_in_stackwalk = 1;
         if (mod_size && !SymLoadModuleEx(GetCurrentProcess(), NULL, NULL, NULL, (DWORD64)Section, mod_size, NULL, SLMFLAG_VIRTUAL)) {
-#if defined(_CPU_X86_64_) && !defined(USE_MCJIT)
-            catchjmp[0] = 0;
-#endif
             static int warned = 0;
             if (!warned) {
                 jl_printf(JL_STDERR, "WARNING: failed to insert module info for backtrace: %lu\n", GetLastError());
@@ -206,14 +152,12 @@ struct revcomp {
     { return lhs>rhs; }
 };
 
-#if JL_LLVM_VERSION >= 30800
 struct strrefcomp {
     bool operator() (const StringRef& lhs, const StringRef& rhs) const
     {
         return lhs.compare(rhs) > 0;
     }
 };
-#endif
 
 extern "C" tracer_cb jl_linfo_tracer;
 static std::vector<jl_method_instance_t*> triggered_linfos;
@@ -230,61 +174,13 @@ void jl_callback_triggered_linfos(void)
 
 class JuliaJITEventListener: public JITEventListener
 {
-#ifndef USE_MCJIT
-    std::map<size_t, FuncInfo, revcomp> info;
-#else
     std::map<size_t, ObjectInfo, revcomp> objectmap;
     std::map<size_t, std::pair<size_t, jl_method_instance_t *>, revcomp> linfomap;
-#endif
 
 public:
     JuliaJITEventListener(){}
     virtual ~JuliaJITEventListener() {}
 
-#ifndef USE_MCJIT
-    virtual void NotifyFunctionEmitted(const Function &F, void *Code,
-                                       size_t Size, const EmittedFunctionDetails &Details)
-    {
-        jl_ptls_t ptls = jl_get_ptls_states();
-        // This function modify linfo->fptr in GC safe region.
-        // This should be fine since the GC won't scan this field.
-        int8_t gc_state = jl_gc_safe_enter(ptls);
-        uv_rwlock_wrlock(&threadsafe);
-        StringRef sName = F.getName();
-        StringMap<jl_method_instance_t*>::iterator linfo_it = linfo_in_flight.find(sName);
-        jl_method_instance_t *linfo = NULL;
-        if (linfo_it != linfo_in_flight.end()) {
-            linfo = linfo_it->second;
-            linfo_in_flight.erase(linfo_it);
-            if (!linfo->fptr && linfo->functionObjectsDecls.functionObject &&
-                    ((Function*)linfo->functionObjectsDecls.functionObject)->getName().equals(sName)) {
-                int jlcall_api = jl_jlcall_api(&F);
-                if (linfo->inferred || jlcall_api != 1) {
-                    linfo->jlcall_api = jlcall_api;
-                    linfo->fptr = (jl_fptr_t)(uintptr_t)Code;
-                }
-                else {
-                    linfo->unspecialized_ducttape = (jl_fptr_t)(uintptr_t)Code;
-                }
-            }
-        }
-#if defined(_OS_WINDOWS_)
-        create_PRUNTIME_FUNCTION((uint8_t*)Code, Size, F.getName(), (uint8_t*)Code, Size, NULL);
-#endif
-        FuncInfo tmp = {&F, Size, Details.LineStarts, linfo};
-        info[(size_t)(Code)] = tmp;
-        uv_rwlock_wrunlock(&threadsafe);
-        jl_gc_safe_leave(ptls, gc_state);
-    }
-
-    std::map<size_t, FuncInfo, revcomp>& getMap()
-    {
-        uv_rwlock_rdlock(&threadsafe);
-        return info;
-    }
-#endif // ifndef USE_MCJIT
-
-#ifdef USE_MCJIT
     jl_method_instance_t *lookupLinfo(size_t pointer)
     {
         auto linfo = linfomap.lower_bound(pointer);
@@ -293,7 +189,6 @@ class JuliaJITEventListener: public JITEventListener
         else
             return NULL;
     }
-#if JL_LLVM_VERSION >= 30600
 
     virtual void NotifyObjectEmitted(const object::ObjectFile &obj,
                                      const RuntimeDyld::LoadedObjectInfo &L)
@@ -305,24 +200,15 @@ class JuliaJITEventListener: public JITEventListener
                                       const object::ObjectFile &debugObj,
                                       const RuntimeDyld::LoadedObjectInfo &L,
                                       RTDyldMemoryManager *memmgr)
-#else
-    virtual void NotifyObjectEmitted(const ObjectImage &obj)
-#endif
     {
         jl_ptls_t ptls = jl_get_ptls_states();
         // This function modify linfo->fptr in GC safe region.
         // This should be fine since the GC won't scan this field.
         int8_t gc_state = jl_gc_safe_enter(ptls);
         uv_rwlock_wrlock(&threadsafe);
-#if JL_LLVM_VERSION >= 30600
         object::section_iterator Section = debugObj.section_begin();
         object::section_iterator EndSection = debugObj.section_end();
-#else
-        object::section_iterator Section = debugObj.begin_sections();
-        object::section_iterator EndSection = debugObj.end_sections();
-#endif
 
-#if JL_LLVM_VERSION >= 30800
         std::map<StringRef,object::SectionRef,strrefcomp> loadedSections;
         for (const object::SectionRef &lSection: obj.sections()) {
             StringRef sName;
@@ -336,7 +222,6 @@ class JuliaJITEventListener: public JITEventListener
                 return 0;
             return L.getSectionLoadAddress(search->second);
         };
-#endif
 
 #ifdef _CPU_ARM_
         // ARM does not have/use .eh_frame
@@ -357,11 +242,7 @@ class JuliaJITEventListener: public JITEventListener
                     continue;
                 }
             }
-#if JL_LLVM_VERSION >= 30800
             uint64_t loadaddr = L.getSectionLoadAddress(section);
-#else
-            uint64_t loadaddr = L.getSectionLoadAddress(sName);
-#endif
             size_t seclen = section.getSize();
             if (istext) {
                 arm_text_addr = loadaddr;
@@ -398,13 +279,9 @@ class JuliaJITEventListener: public JITEventListener
         uint8_t *catchjmp = NULL;
         for (const object::SymbolRef &sym_iter : debugObj.symbols()) {
             StringRef sName;
-#if JL_LLVM_VERSION >= 30700
             auto sNameOrError = sym_iter.getName();
             assert(sNameOrError);
             sName = sNameOrError.get();
-#else
-            sym_iter.getName(sName);
-#endif
             uint8_t **pAddr = NULL;
             if (sName.equals("__UnwindData")) {
                 pAddr = &UnwindData;
@@ -414,7 +291,6 @@ class JuliaJITEventListener: public JITEventListener
             }
             if (pAddr) {
                 uint64_t Addr, SectionAddr, SectionLoadAddr;
-#if JL_LLVM_VERSION >= 30800
                 auto AddrOrError = sym_iter.getAddress();
                 assert(AddrOrError);
                 Addr = AddrOrError.get();
@@ -425,42 +301,16 @@ class JuliaJITEventListener: public JITEventListener
                 SectionAddr = Section->getAddress();
                 Section->getName(sName);
                 SectionLoadAddr = getLoadAddress(sName);
-#elif JL_LLVM_VERSION >= 30700
-                auto AddrOrError = sym_iter.getAddress();
-                assert(AddrOrError);
-                Addr = AddrOrError.get();
-                sym_iter.getSection(Section);
-                assert(Section != EndSection && Section->isText());
-                Section->getName(sName);
-                SectionAddr = Section->getAddress();
-                SectionLoadAddr = L.getSectionLoadAddress(sName);
-#elif JL_LLVM_VERSION >= 30600
-                sym_iter.getAddress(Addr);
-                sym_iter.getSection(Section);
-                assert(Section != EndSection && Section->isText());
-                Section->getName(sName);
-                SectionAddr = Section->getAddress();
-                SectionLoadAddr = L.getSectionLoadAddress(sName);
-#else // JL_LLVM_VERSION >= 30500
-                sym_iter.getAddress(Addr);
-                sym_iter.getSection(Section);
-                assert(Section != EndSection);
-                assert(!Section->isText(isText) && isText);
-                Section->getAddress(SectionAddr);
-                Section->getAddress(SectionLoadAddr);
-#endif
                 Addr -= SectionAddr - SectionLoadAddr;
                 *pAddr = (uint8_t*)Addr;
                 if (SectionAddrCheck)
                     assert(SectionAddrCheck == SectionLoadAddr);
                 else
                     SectionAddrCheck = SectionLoadAddr;
-#ifdef USE_ORCJIT
                 if (memmgr)
                     SectionAddr =
                         (uintptr_t)lookupWriteAddressFor(memmgr,
                                                          (void*)SectionLoadAddr);
-#endif
                 if (SectionLoadOffset != 1)
                     assert(SectionLoadOffset == SectionAddr - SectionLoadAddr);
                 else
@@ -489,39 +339,26 @@ class JuliaJITEventListener: public JITEventListener
 #endif // defined(_OS_X86_64_)
 #endif // defined(_OS_WINDOWS_)
 
-#if JL_LLVM_VERSION >= 30700
         auto symbols = object::computeSymbolSizes(debugObj);
         bool first = true;
         for(const auto &sym_size : symbols) {
             const object::SymbolRef &sym_iter = sym_size.first;
-#if JL_LLVM_VERSION >= 30900
             auto SymbolTypeOrError = sym_iter.getType();
             assert(SymbolTypeOrError);
             object::SymbolRef::Type SymbolType = SymbolTypeOrError.get();
-#else
-            object::SymbolRef::Type SymbolType = sym_iter.getType();
-#endif
             if (SymbolType != object::SymbolRef::ST_Function) continue;
             auto AddrOrError = sym_iter.getAddress();
             assert(AddrOrError);
             uint64_t Addr = AddrOrError.get();
-#if JL_LLVM_VERSION >= 30800
             auto SectionOrError = sym_iter.getSection();
             assert(SectionOrError);
             Section = SectionOrError.get();
-#else
-            sym_iter.getSection(Section);
-#endif
             if (Section == EndSection) continue;
             if (!Section->isText()) continue;
             uint64_t SectionAddr = Section->getAddress();
             StringRef secName;
             Section->getName(secName);
-#if JL_LLVM_VERSION >= 30800
             uint64_t SectionLoadAddr = getLoadAddress(secName);
-#else
-            uint64_t SectionLoadAddr = L.getSectionLoadAddress(secName);
-#endif
             Addr -= SectionAddr - SectionLoadAddr;
             auto sNameOrError = sym_iter.getName();
             assert(sNameOrError);
@@ -544,8 +381,8 @@ class JuliaJITEventListener: public JITEventListener
                 if (linfo->compile_traced)
                     triggered_linfos.push_back(linfo);
                 linfo_in_flight.erase(linfo_it);
-                Function *F = (Function*)linfo->functionObjectsDecls.functionObject;
-                if (!linfo->fptr && F && F->getName().equals(sName)) {
+                const char *F = linfo->functionObjectsDecls.functionObject;
+                if (!linfo->fptr && F && sName.equals(F)) {
                     int jlcall_api = jl_jlcall_api(F);
                     if (linfo->inferred || jlcall_api != 1) {
                         linfo->jlcall_api = jlcall_api;
@@ -568,109 +405,6 @@ class JuliaJITEventListener: public JITEventListener
                 first = false;
            }
         }
-
-#else // pre-LLVM 3.7
-        uint64_t Addr;
-        uint64_t Size;
-        object::SymbolRef::Type SymbolType;
-        StringRef sName;
-        uint64_t SectionLoadAddr = 0, SectionAddr = 0;
-#if JL_LLVM_VERSION < 30600
-        bool isText;
-#endif
-
-#if JL_LLVM_VERSION >= 30500
-        for (const object::SymbolRef &sym_iter : obj.symbols()) {
-            sym_iter.getType(SymbolType);
-            if (SymbolType != object::SymbolRef::ST_Function) continue;
-            sym_iter.getSize(Size);
-            sym_iter.getAddress(Addr);
-            sym_iter.getSection(Section);
-            if (Section == EndSection) continue;
-#if JL_LLVM_VERSION >= 30600
-            if (!Section->isText()) continue;
-            Section->getName(sName);
-            SectionAddr = Section->getAddress();
-            SectionLoadAddr = L.getSectionLoadAddress(sName);
-            Addr += SectionLoadAddr;
-#else
-            if (Section->isText(isText) || !isText) continue;
-            Section->getAddress(SectionAddr);
-            Section->getAddress(SectionLoadAddr);
-#endif
-            sym_iter.getName(sName);
-#ifdef _OS_DARWIN_
-#   if JL_LLVM_VERSION < 30600
-            Addr = ((MCJIT*)jl_ExecutionEngine)->getSymbolAddress(sName, true);
-            if (!Addr && sName[0] == '_') {
-                Addr = ((MCJIT*)jl_ExecutionEngine)->getSymbolAddress(sName.substr(1), true);
-            }
-            if (!Addr) continue;
-#   endif
-#elif defined(_OS_WINDOWS_)
-            uint64_t SectionSize = 0;
-#   if JL_LLVM_VERSION >= 30600
-            SectionSize = Section->getSize();
-#   else
-            Section->getSize(SectionSize);
-#   endif
-            if (SectionAddrCheck)
-                assert(SectionAddrCheck == SectionLoadAddr);
-            else
-                SectionAddrCheck = SectionLoadAddr;
-            create_PRUNTIME_FUNCTION(
-                   (uint8_t*)(uintptr_t)Addr, (size_t)Size, sName,
-                   (uint8_t*)(uintptr_t)SectionLoadAddr, (size_t)SectionSize, UnwindData);
-#endif
-            StringMap<jl_method_instance_t*>::iterator linfo_it = linfo_in_flight.find(sName);
-            jl_method_instance_t *linfo = NULL;
-            if (linfo_it != linfo_in_flight.end()) {
-                linfo = linfo_it->second;
-                linfo_in_flight.erase(linfo_it);
-                Function *F = (Function*)linfo->functionObjectsDecls.functionObject;
-                if (!linfo->fptr && F && F->getName().equals(sName)) {
-                    int jlcall_api = jl_jlcall_api(F);
-                    if (linfo->inferred || jlcall_api != 1) {
-                        linfo->jlcall_api = jlcall_api;
-                        linfo->fptr = (jl_fptr_t)(uintptr_t)Addr;
-                    }
-                    else {
-                        linfo->unspecialized_ducttape = (jl_fptr_t)(uintptr_t)Addr;
-                    }
-                }
-            }
-            if (linfo)
-                linfomap[Addr] = std::make_pair(Size, linfo);
-            const object::ObjectFile *objfile =
-#if JL_LLVM_VERSION >= 30600
-                &obj;
-#else
-                obj.getObjectFile();
-#endif
-            ObjectInfo tmp = {objfile, (size_t)Size,
-                (ptrdiff_t)(SectionAddr - SectionLoadAddr),
-#ifdef _OS_DARWIN_
-                strndup(sName.data(), sName.size()),
-#endif
-                linfo
-            };
-            objectmap[Addr] = tmp;
-        }
-#else //JL_LLVM_VERSION >= 30400
-        error_code itererr;
-        object::symbol_iterator sym_iter = obj.begin_symbols();
-        object::symbol_iterator sym_end = obj.end_symbols();
-        for (; sym_iter != sym_end; sym_iter.increment(itererr)) {
-            sym_iter->getType(SymbolType);
-            if (SymbolType != object::SymbolRef::ST_Function) continue;
-            sym_iter->getAddress(Addr);
-            sym_iter->getSize(Size);
-
-            ObjectInfo tmp = {obj.getObjectFile(), (size_t)Size};
-            objectmap[Addr] = tmp;
-        }
-#endif
-#endif
         uv_rwlock_wrunlock(&threadsafe);
         jl_gc_safe_leave(ptls, gc_state);
     }
@@ -684,10 +418,8 @@ class JuliaJITEventListener: public JITEventListener
         uv_rwlock_rdlock(&threadsafe);
         return objectmap;
     }
-#endif // USE_MCJIT
 };
 
-#ifdef USE_ORCJIT
 JL_DLLEXPORT void ORCNotifyObjectEmitted(JITEventListener *Listener,
                                          const object::ObjectFile &obj,
                                          const object::ObjectFile &debugObj,
@@ -696,7 +428,6 @@ JL_DLLEXPORT void ORCNotifyObjectEmitted(JITEventListener *Listener,
 {
     ((JuliaJITEventListener*)Listener)->_NotifyObjectEmitted(obj,debugObj,L,memmgr);
 }
-#endif
 
 static std::pair<char *, bool> jl_demangle(const char *name)
 {
@@ -764,22 +495,19 @@ static int lookup_pointer(DIContext *context, jl_frame_t **frames,
         }
         return 1;
     }
-#if JL_LLVM_VERSION >= 30500
+    jl_mutex_lock_maybe_nogc(&codegen_lock);
     DILineInfoSpecifier infoSpec(DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath,
                                  DILineInfoSpecifier::FunctionNameKind::ShortName);
-#else
-    int infoSpec = DILineInfoSpecifier::FileLineInfo |
-                   DILineInfoSpecifier::AbsoluteFilePath |
-                   DILineInfoSpecifier::FunctionName;
-#endif
 
     auto inlineInfo = context->getInliningInfoForAddress(pointer, infoSpec);
 
     int fromC = (*frames)[0].fromC;
     int n_frames = inlineInfo.getNumberOfFrames();
-    if (n_frames == 0)
+    if (n_frames == 0) {
+        jl_mutex_unlock_maybe_nogc(&codegen_lock);
         // no line number info available in the context, return without the context
         return lookup_pointer(NULL, frames, pointer, demangle, noInline);
+    }
     if (noInline)
         n_frames = 1;
     if (n_frames > 1) {
@@ -799,11 +527,7 @@ static int lookup_pointer(DIContext *context, jl_frame_t **frames,
         }
 
         jl_frame_t *frame = &(*frames)[i];
-#if JL_LLVM_VERSION < 30500
-        std::string func_name(info.getFunctionName());
-#else
         std::string func_name(info.FunctionName);
-#endif
 
         if (inlined_frame) {
             frame->inlined = 1;
@@ -824,19 +548,15 @@ static int lookup_pointer(DIContext *context, jl_frame_t **frames,
         if (!frame->func_name)
             frame->fromC = 1;
 
-#if JL_LLVM_VERSION < 30500
-        frame->line = info.getLine();
-        std::string file_name(info.getFileName());
-#else
         frame->line = info.Line;
         std::string file_name(info.FileName);
-#endif
 
         if (file_name == "<invalid>")
             frame->file_name = NULL;
         else
             jl_copy_str(&frame->file_name, file_name.c_str());
     }
+    jl_mutex_unlock_maybe_nogc(&codegen_lock);
     return n_frames;
 }
 
@@ -859,41 +579,16 @@ static obfiletype objfilemap;
 
 static bool getObjUUID(llvm::object::MachOObjectFile *obj, uint8_t uuid[16])
 {
-# if JL_LLVM_VERSION >= 30700
     for (auto Load : obj->load_commands())
-# else
-#  if JL_LLVM_VERSION >= 30500
-    uint32_t LoadCommandCount = obj->getHeader().ncmds;
-#  else
-    uint32_t LoadCommandCount = obj->getHeader().NumLoadCommands;
-#  endif
-    llvm::object::MachOObjectFile::LoadCommandInfo Load = obj->getFirstLoadCommandInfo();
-    for (unsigned I = 0; ; ++I)
-# endif
     {
-        if (
-# if JL_LLVM_VERSION >= 30500
-            Load.C.cmd == LC_UUID
-# else
-            Load.C.Type == LC_UUID
-# endif
-            ) {
+        if (Load.C.cmd == LC_UUID) {
             memcpy(uuid, ((const MachO::uuid_command*)Load.Ptr)->uuid, 16);
             return true;
         }
-# if JL_LLVM_VERSION < 30700
-        else if (I == LoadCommandCount - 1) {
-            return false;
-        }
-        else {
-            Load = obj->getNextLoadCommandInfo(Load);
-        }
-# endif
     }
     return false;
 }
 
-#if JL_LLVM_VERSION >= 30600
 struct debug_link_info {
     StringRef filename;
     uint32_t crc32;
@@ -979,42 +674,26 @@ calc_gnu_debuglink_crc32(const void *buf, size_t size)
     return crc ^ ~0U;
 }
 
-#if JL_LLVM_VERSION >= 30900
 static Expected<object::OwningBinary<object::ObjectFile>>
-#else
-static ErrorOr<object::OwningBinary<object::ObjectFile>>
-#endif
 openDebugInfo(StringRef debuginfopath, const debug_link_info &info)
 {
     auto SplitFile = MemoryBuffer::getFile(debuginfopath);
     if (std::error_code EC = SplitFile.getError()) {
-#if JL_LLVM_VERSION >= 30900
         return errorCodeToError(EC);
-#else
-        return EC;
-#endif
     }
 
     uint32_t crc32 = calc_gnu_debuglink_crc32(
             SplitFile.get()->getBufferStart(),
             SplitFile.get()->getBufferSize());
     if (crc32 != info.crc32) {
-#if JL_LLVM_VERSION >= 30900
         return errorCodeToError(object::object_error::arch_not_found);
-#else
-        return object::object_error::arch_not_found;
-#endif
     }
 
     auto error_splitobj = object::ObjectFile::createObjectFile(
             SplitFile.get().get()->getMemBufferRef(),
-            sys::fs::file_magic::unknown);
+            llvm_file_magic::unknown);
     if (!error_splitobj) {
-#if JL_LLVM_VERSION >= 30900
         return error_splitobj.takeError();
-#else
-        return error_splitobj.getError();
-#endif
     }
 
     // successfully validated and loaded split debug info file
@@ -1022,16 +701,22 @@ openDebugInfo(StringRef debuginfopath, const debug_link_info &info)
             std::move(error_splitobj.get()),
             std::move(SplitFile.get()));
 }
-#endif
 
 static uint64_t jl_sysimage_base;
-static void **sysimg_fvars;
+static const char *sysimg_fvars_base = nullptr;
+static const int32_t *sysimg_fvars_offsets;
 static jl_method_instance_t **sysimg_fvars_linfo;
 static size_t sysimg_fvars_n;
-extern "C" void jl_register_fptrs(uint64_t sysimage_base, void **fptrs, jl_method_instance_t **linfos, size_t n)
+static const void *sysimg_fvars(size_t idx)
+{
+    return sysimg_fvars_base + sysimg_fvars_offsets[idx];
+}
+void jl_register_fptrs(uint64_t sysimage_base, const char *base, const int32_t *offsets,
+                       jl_method_instance_t **linfos, size_t n)
 {
     jl_sysimage_base = (uintptr_t)sysimage_base;
-    sysimg_fvars = fptrs;
+    sysimg_fvars_base = base;
+    sysimg_fvars_offsets = offsets;
     sysimg_fvars_linfo = linfos;
     sysimg_fvars_n = n;
 }
@@ -1039,108 +724,97 @@ extern "C" void jl_register_fptrs(uint64_t sysimage_base, void **fptrs, jl_metho
 template<typename T>
 static inline void ignoreError(T &err)
 {
-#if JL_LLVM_VERSION >= 30900 && !defined(NDEBUG)
+#if !defined(NDEBUG)
+    // Needed only with LLVM assertion build
     consumeError(err.takeError());
 #endif
 }
 
-extern "C" void jl_refresh_dbg_module_list(void);
-bool jl_dylib_DI_for_fptr(size_t pointer, const llvm::object::ObjectFile **obj, llvm::DIContext **context, int64_t *slide, int64_t *section_slide,
-    bool onlySysImg, bool *isSysImg, void **saddr, char **name, char **filename)
+static void get_function_name_and_base(const object::ObjectFile *object, bool insysimage,
+                                       void **saddr, char **name, size_t pointer,
+                                       int64_t slide, bool untrusted_dladdr)
 {
-    *obj = NULL;
-    *context = NULL;
-    *slide = 0;
-    *section_slide = 0;
-
-// GOAL: Determine containing Library
-// Assigning fname, fbase
-#ifdef _OS_WINDOWS_
-    IMAGEHLP_MODULE64 ModuleInfo;
-    ModuleInfo.SizeOfStruct = sizeof(IMAGEHLP_MODULE64);
-    jl_refresh_dbg_module_list();
-    jl_in_stackwalk = 1;
-    bool isvalid = SymGetModuleInfo64(GetCurrentProcess(), (DWORD64)pointer, &ModuleInfo);
-    jl_in_stackwalk = 0;
-    if (!isvalid) return false;
-
-    StringRef fname = ModuleInfo.LoadedImageName;
-    if (fname.empty()) // empirically, LoadedImageName might be missing
-        fname = ModuleInfo.ImageName;
-    DWORD64 fbase = ModuleInfo.BaseOfImage;
-    bool insysimage = (fbase == jl_sysimage_base);
-    if (isSysImg)
-        *isSysImg = insysimage;
-    if (onlySysImg && !insysimage) {
-        return false;
+    // Assume we only need base address for sysimg for now
+    if (!insysimage || !sysimg_fvars_base)
+        saddr = nullptr;
+    bool needs_saddr = saddr && (!*saddr || untrusted_dladdr);
+    bool needs_name = name && (!*name || untrusted_dladdr);
+    // Try platform specific methods first since they are usually faster
+    if (needs_saddr) {
+#if (defined(_OS_LINUX_) || defined(_OS_FREEBSD_)) && !defined(JL_DISABLE_LIBUNWIND)
+        unw_proc_info_t pip;
+        if (unw_get_proc_info_by_ip(unw_local_addr_space, pointer, &pip, NULL) == 0) {
+            *saddr = (void*)pip.start_ip;
+            needs_saddr = false;
+        }
+#endif
+#if defined(_OS_WINDOWS_) && defined(_CPU_X86_64_)
+        DWORD64 ImageBase;
+        PRUNTIME_FUNCTION fn = RtlLookupFunctionEntry(pointer, &ImageBase, NULL);
+        if (fn) {
+            *saddr = (void*)(ImageBase + fn->BeginAddress);
+            needs_saddr = false;
+        }
+#endif
     }
-    static char frame_info_func[
-        sizeof(SYMBOL_INFO) +
-        MAX_SYM_NAME * sizeof(TCHAR)];
-    DWORD64 dwDisplacement64 = 0;
-    DWORD64 dwAddress = pointer;
-    PSYMBOL_INFO pSymbol = (PSYMBOL_INFO)frame_info_func;
-    pSymbol->SizeOfStruct = sizeof(SYMBOL_INFO);
-    pSymbol->MaxNameLen = MAX_SYM_NAME;
-    jl_in_stackwalk = 1;
-    if (SymFromAddr(GetCurrentProcess(), dwAddress, &dwDisplacement64,
-                    pSymbol)) {
-        // SymFromAddr returned success
-        // errors are ignored, but are hopefully patched up by
-        // using llvm to read the object (below)
-        if (name)
-            jl_copy_str(name, pSymbol->Name);
-        if (saddr)
-            *saddr = (void*)(uintptr_t)pSymbol->Address;
+    if (object && (needs_saddr || needs_name)) {
+        size_t distance = (size_t)-1;
+        SymRef sym_found;
+        for (auto sym: object->symbols()) {
+            auto addr = sym.getAddress();
+            if (!addr)
+                continue;
+            size_t symptr = addr.get();
+            if (symptr > pointer + slide)
+                continue;
+            size_t new_dist = pointer + slide - symptr;
+            if (new_dist > distance)
+                continue;
+            distance = new_dist;
+            sym_found = sym;
+        }
+        if (distance != (size_t)-1) {
+            if (needs_saddr) {
+                auto addr = sym_found.getAddress();
+                assert(addr);
+                *saddr = (void*)(uintptr_t)(addr.get() - slide);
+                needs_saddr = false;
+            }
+            if (needs_name) {
+                if (auto name_or_err = sym_found.getName()) {
+                    auto nameref = name_or_err.get();
+                    size_t len = nameref.size();
+                    *name = (char*)realloc(*name, len + 1);
+                    (*name)[len] = 0;
+                    memcpy(*name, nameref.data(), len);
+                    needs_name = false;
+                }
+            }
+        }
     }
-    else if (saddr) {
-        *saddr = NULL;
+#ifdef _OS_WINDOWS_
+    // For ntdll and msvcrt since we are currently only parsing DWARF debug info through LLVM
+    if (!insysimage && needs_name) {
+        static char frame_info_func[
+            sizeof(SYMBOL_INFO) +
+            MAX_SYM_NAME * sizeof(TCHAR)];
+        DWORD64 dwDisplacement64 = 0;
+        DWORD64 dwAddress = pointer;
+        PSYMBOL_INFO pSymbol = (PSYMBOL_INFO)frame_info_func;
+        pSymbol->SizeOfStruct = sizeof(SYMBOL_INFO);
+        pSymbol->MaxNameLen = MAX_SYM_NAME;
+        jl_in_stackwalk = 1;
+        if (SymFromAddr(GetCurrentProcess(), dwAddress, &dwDisplacement64, pSymbol)) {
+            // errors are ignored
+            jl_copy_str(name, pSymbol->Name);
+        }
+        jl_in_stackwalk = 0;
     }
-
-    // If we didn't find the filename before in the debug
-    // info, use the dll name
-    if (filename && !*filename)
-        jl_copy_str(filename, fname.data());
-
-    jl_in_stackwalk = 0;
-
-#else // ifdef _OS_WINDOWS_
-    Dl_info dlinfo;
-    int dladdr_success;
-    uint64_t fbase;
-#ifdef __GLIBC__
-    struct link_map *extra_info;
-    dladdr_success = dladdr1((void*)pointer, &dlinfo, (void**)&extra_info, RTLD_DL_LINKMAP) != 0;
-#else
-    dladdr_success = dladdr((void*)pointer, &dlinfo) != 0;
-#endif
-    if (!dladdr_success || !dlinfo.dli_fname)
-        return false;
-
-#ifdef __GLIBC__
-    // dlinfo.dli_fbase is not the right value for the main executable on linux
-    fbase = (uintptr_t)extra_info->l_addr;
-#else
-    fbase = (uintptr_t)dlinfo.dli_fbase;
 #endif
-    StringRef fname;
-    if (saddr)
-        *saddr = dlinfo.dli_saddr;
-    bool insysimage = (fbase == jl_sysimage_base);
-    if (isSysImg)
-        *isSysImg = insysimage;
-    if (onlySysImg && !insysimage) {
-        return false;
-    }
-    // In case we fail with the debug info lookup, we at least still
-    // have the function name, even if we don't have line numbers
-    if (name)
-        jl_copy_str(name, dlinfo.dli_sname);
-    if (filename)
-        jl_copy_str(filename, dlinfo.dli_fname);
-    fname = dlinfo.dli_fname;
-#endif // ifdef _OS_WINDOWS_
+}
 
+static objfileentry_t &find_object_file(uint64_t fbase, StringRef fname)
+{
     int isdarwin = 0, islinux = 0, iswindows = 0;
 #if defined(_OS_DARWIN_)
     isdarwin = 1;
@@ -1151,23 +825,13 @@ bool jl_dylib_DI_for_fptr(size_t pointer, const llvm::object::ObjectFile **obj,
 #endif
     (void)iswindows;
 
-#if JL_LLVM_VERSION < 30500
-    if (iswindows) {
-        return true;
-    }
-#endif
-
 // GOAL: Read debuginfo from file
     // TODO: need read/write lock here for objfilemap synchronization
     obfiletype::iterator it = objfilemap.find(fbase);
-    if (it != objfilemap.end()) {
+    if (it != objfilemap.end())
         // Return cached value
-        *obj = it->second.obj;
-        *context = it->second.ctx;
-        *slide = it->second.slide;
-        *section_slide = it->second.section_slide;
-        return true;
-    }
+        return it->second;
+    auto &entry = objfilemap[fbase]; // default initialized
 
 // GOAL: Assign errorobj
     StringRef objpath;
@@ -1175,43 +839,20 @@ bool jl_dylib_DI_for_fptr(size_t pointer, const llvm::object::ObjectFile **obj,
     uint8_t uuid[16], uuid2[16];
     if (isdarwin) {
         size_t msize = (size_t)(((uint64_t)-1) - fbase);
-#if JL_LLVM_VERSION >= 30600
         std::unique_ptr<MemoryBuffer> membuf = MemoryBuffer::getMemBuffer(
                 StringRef((const char *)fbase, msize), "", false);
         auto origerrorobj = llvm::object::ObjectFile::createObjectFile(
-            membuf->getMemBufferRef(), sys::fs::file_magic::unknown);
-#elif JL_LLVM_VERSION >= 30500
-        MemoryBuffer *membuf = MemoryBuffer::getMemBuffer(
-            StringRef((const char *)fbase, msize), "", false);
-        std::unique_ptr<MemoryBuffer> buf(membuf);
-        auto origerrorobj = llvm::object::ObjectFile::createObjectFile(
-            buf, sys::fs::file_magic::unknown);
-#else
-        MemoryBuffer *membuf = MemoryBuffer::getMemBuffer(
-            StringRef((const char *)fbase, msize), "", false);
-        std::unique_ptr<llvm::object::ObjectFile> origerrorobj(llvm::object::ObjectFile::createObjectFile(
-            membuf));
-#endif
-        if (!origerrorobj) {
-            objfileentry_t entry = {};
-            objfilemap[fbase] = entry;
-            return true;
-        }
+            membuf->getMemBufferRef(), llvm_file_magic::unknown);
+        if (!origerrorobj)
+            return entry;
 
         llvm::object::MachOObjectFile *morigobj = (llvm::object::MachOObjectFile*)
-#if JL_LLVM_VERSION >= 30600
             origerrorobj.get().get();
-#else
-            origerrorobj.get();
-#endif
 
         // First find the uuid of the object file (we'll use this to make sure we find the
         // correct debug symbol file).
-        if (!getObjUUID(morigobj, uuid)) {
-            objfileentry_t entry = {};
-            objfilemap[fbase] = entry;
-            return true;
-        }
+        if (!getObjUUID(morigobj, uuid))
+            return entry;
 
         // On OS X debug symbols are not contained in the dynamic library.
         // For now we only support .dSYM files in the same directory
@@ -1228,22 +869,13 @@ bool jl_dylib_DI_for_fptr(size_t pointer, const llvm::object::ObjectFile **obj,
         // On Windows we need to mmap another copy since reading the in-memory copy seems to return object_error:unexpected_eof
         objpath = fname;
     }
-#if JL_LLVM_VERSION >= 30500
     auto errorobj = llvm::object::ObjectFile::createObjectFile(objpath);
-#else
-    std::unique_ptr<llvm::object::ObjectFile> errorobj(llvm::object::ObjectFile::createObjectFile(objpath));
-#endif
 
-// GOAL: Assign *obj, *context, *slide (if above succeeded)
+// GOAL: Find obj, context, slide (if above succeeded)
     if (errorobj) {
-#if JL_LLVM_VERSION >= 30600
         auto *debugobj = errorobj->getBinary();
-#else
-        auto *debugobj = errorobj.get();
-#endif
 
         if (islinux) {
-#if JL_LLVM_VERSION >= 30600
             // if the file has a .gnu_debuglink section,
             // try to load its companion file instead
             // in the expected locations
@@ -1251,16 +883,11 @@ bool jl_dylib_DI_for_fptr(size_t pointer, const llvm::object::ObjectFile **obj,
             debug_link_info info = getDebuglink(*debugobj);
             if (!info.filename.empty()) {
                 size_t sep = fname.rfind('/');
-#if JL_LLVM_VERSION >= 30900
                 Expected<object::OwningBinary<object::ObjectFile>>
                     DebugInfo(errorCodeToError(std::make_error_code(std::errc::no_such_file_or_directory)));
                 // Can't find a way to construct an empty Expected object
                 // that can be ignored.
                 ignoreError(DebugInfo);
-#else
-                ErrorOr<object::OwningBinary<object::ObjectFile>>
-                    DebugInfo(std::errc::no_such_file_or_directory);
-#endif
                 if (fname.substr(sep + 1) != info.filename) {
                     debuginfopath = fname.substr(0, sep + 1);
                     debuginfopath += info.filename;
@@ -1290,75 +917,133 @@ bool jl_dylib_DI_for_fptr(size_t pointer, const llvm::object::ObjectFile **obj,
                     ignoreError(DebugInfo);
                 }
             }
-#endif
         }
 
         if (isdarwin) {
             // verify the UUID matches
             if (!getObjUUID((llvm::object::MachOObjectFile*)debugobj, uuid2) ||
                     memcmp(uuid, uuid2, sizeof(uuid)) != 0) {
-                objfileentry_t entry = {};
-                objfilemap[fbase] = entry;
-                return true;
+                return entry;
             }
         }
 
+        int64_t slide = 0;
+        int64_t section_slide = 0;
         if (auto *OF = dyn_cast<const object::COFFObjectFile>(debugobj)) {
             assert(iswindows);
-#if JL_LLVM_VERSION >= 30800
-            *slide = OF->getImageBase() - fbase;
-            *section_slide = 0; // Since LLVM 3.8+ addresses are adjusted correctly
-#elif JL_LLVM_VERSION >= 30500
-            const llvm::object::pe32plus_header *pe32plus;
-            OF->getPE32PlusHeader(pe32plus);
-            if (pe32plus != NULL) {
-                *slide = pe32plus->ImageBase - fbase;
-                *section_slide = -(int64_t)pe32plus->ImageBase;
-            }
-            else {
-                const llvm::object::pe32_header *pe32;
-                OF->getPE32Header(pe32);
-                if (pe32 == NULL) {
-                    objfileentry_t entry = {};
-                    objfilemap[fbase] = entry;
-                    return true;
-                }
-                else {
-                    *slide = pe32->ImageBase - fbase;
-                    *section_slide = -(int64_t)pe32->ImageBase;
-                }
-            }
-#endif
+            slide = OF->getImageBase() - fbase;
+            section_slide = 0; // Since LLVM 3.8+ addresses are adjusted correctly
         }
         else {
-            *slide = -(int64_t)fbase;
+            slide = -(int64_t)fbase;
         }
 
-#if JL_LLVM_VERSION >= 30700
-        *context = new DWARFContextInMemory(*debugobj);
-#elif JL_LLVM_VERSION >= 30600
-        *context = DIContext::getDWARFContext(*debugobj);
-#else
-        *context = DIContext::getDWARFContext(debugobj);
-#endif
-        *obj = debugobj;
-#if JL_LLVM_VERSION >= 30600
+        auto context = new DWARFContextInMemory(*debugobj);
         auto binary = errorobj->takeBinary();
         binary.first.release();
         binary.second.release();
-#else
-        errorobj.release();
-#endif
+        // update cache
+        entry = {debugobj, context, slide, section_slide};
     }
     else {
         // TODO: report the error instead of silently consuming it?
         //       jl_error might run into the same error again...
         ignoreError(errorobj);
     }
+    return entry;
+}
 
-    // update cache
-    objfileentry_t entry = {*obj, *context, *slide, *section_slide};
-    objfilemap[fbase] = entry;
+extern "C" void jl_refresh_dbg_module_list(void);
+bool jl_dylib_DI_for_fptr(size_t pointer, const llvm::object::ObjectFile **obj, llvm::DIContext **context, int64_t *slide, int64_t *section_slide,
+    bool onlySysImg, bool *isSysImg, void **saddr, char **name, char **filename)
+{
+    *obj = NULL;
+    *context = NULL;
+    *slide = 0;
+    *section_slide = 0;
+    // On Windows and FreeBSD, `dladdr` (or its equivalent) returns the closest exported symbol
+    // without checking the size.
+    // This causes the lookup to return incorrect non-NULL result for local functions
+    // when better result is available through other methods.
+    // macOS's `dladdr` returns local symbols and Linux's `dladdr`
+    // checks the symbol size so they do not have this problem.
+    // On systems with an untrusted dladdr, the result cannot be used for sysimg
+    // (it's always wrong) and should in general be used only as the last fallback.
+#if defined(_OS_FREEBSD_) || defined(_OS_WINDOWS_)
+    bool untrusted_dladdr = true;
+#else
+    bool untrusted_dladdr = false;
+#endif
+
+// GOAL: Determine containing Library
+// Assigning fname, fbase
+#ifdef _OS_WINDOWS_
+    IMAGEHLP_MODULE64 ModuleInfo;
+    ModuleInfo.SizeOfStruct = sizeof(IMAGEHLP_MODULE64);
+    jl_refresh_dbg_module_list();
+    jl_in_stackwalk = 1;
+    bool isvalid = SymGetModuleInfo64(GetCurrentProcess(), (DWORD64)pointer, &ModuleInfo);
+    jl_in_stackwalk = 0;
+    if (!isvalid) return false;
+
+    StringRef fname = ModuleInfo.LoadedImageName;
+    if (fname.empty()) // empirically, LoadedImageName might be missing
+        fname = ModuleInfo.ImageName;
+    DWORD64 fbase = ModuleInfo.BaseOfImage;
+    bool insysimage = (fbase == jl_sysimage_base);
+    if (isSysImg)
+        *isSysImg = insysimage;
+    if (onlySysImg && !insysimage)
+        return false;
+    // If we didn't find the filename before in the debug
+    // info, use the dll name
+    if (filename && !*filename)
+        jl_copy_str(filename, fname.data());
+    if (saddr)
+        *saddr = NULL;
+
+#else // ifdef _OS_WINDOWS_
+    Dl_info dlinfo;
+    int dladdr_success;
+    uint64_t fbase;
+#ifdef __GLIBC__
+    struct link_map *extra_info;
+    dladdr_success = dladdr1((void*)pointer, &dlinfo, (void**)&extra_info, RTLD_DL_LINKMAP) != 0;
+#else
+    dladdr_success = dladdr((void*)pointer, &dlinfo) != 0;
+#endif
+    if (!dladdr_success || !dlinfo.dli_fname)
+        return false;
+
+#ifdef __GLIBC__
+    // dlinfo.dli_fbase is not the right value for the main executable on linux
+    fbase = (uintptr_t)extra_info->l_addr;
+#else
+    fbase = (uintptr_t)dlinfo.dli_fbase;
+#endif
+    StringRef fname;
+    bool insysimage = (fbase == jl_sysimage_base);
+    if (saddr && !(insysimage && untrusted_dladdr))
+        *saddr = dlinfo.dli_saddr;
+    if (isSysImg)
+        *isSysImg = insysimage;
+    if (onlySysImg && !insysimage)
+        return false;
+    // In case we fail with the debug info lookup, we at least still
+    // have the function name, even if we don't have line numbers
+    if (name && !(insysimage && untrusted_dladdr))
+        jl_copy_str(name, dlinfo.dli_sname);
+    if (filename)
+        jl_copy_str(filename, dlinfo.dli_fname);
+    fname = dlinfo.dli_fname;
+#endif // ifdef _OS_WINDOWS_
+    auto &entry = find_object_file(fbase, fname);
+    *obj = entry.obj;
+    *context = entry.ctx;
+    *slide = entry.slide;
+    *section_slide = entry.section_slide;
+    get_function_name_and_base(entry.obj, insysimage, saddr, name, pointer, entry.slide,
+                               untrusted_dladdr);
     return true;
 }
 
@@ -1397,56 +1082,24 @@ static int jl_getDylibFunctionInfo(jl_frame_t **frames, size_t pointer, int skip
         return 1;
     }
     frame0->fromC = !isSysImg;
-    if (isSysImg && 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 defined(_OS_WINDOWS_) && defined(_CPU_X86_64_)
-        if (!saddr) {
-            DWORD64 ImageBase;
-            PRUNTIME_FUNCTION fn = RtlLookupFunctionEntry(pointer, &ImageBase, NULL);
-            if (fn)
-                saddr = (void*)(ImageBase + fn->BeginAddress);
-        }
-#endif
-        if (saddr) {
-            for (size_t i = 0; i < sysimg_fvars_n; i++) {
-                if (saddr == sysimg_fvars[i]) {
-                    frame0->linfo = sysimg_fvars_linfo[i];
-                    break;
-                }
+    if (isSysImg && sysimg_fvars_base && saddr) {
+        for (size_t i = 0; i < sysimg_fvars_n; i++) {
+            if (saddr == sysimg_fvars(i)) {
+                frame0->linfo = sysimg_fvars_linfo[i];
+                break;
             }
         }
-        return lookup_pointer(context, frames, pointer+slide, isSysImg, noInline);
     }
-    return lookup_pointer(context, frames, pointer+slide, isSysImg, noInline);
+    return lookup_pointer(context, frames, pointer + slide, isSysImg, noInline);
 }
 
 int jl_DI_for_fptr(uint64_t fptr, uint64_t *symsize, int64_t *slide, int64_t *section_slide,
                       const object::ObjectFile **object,
-#ifdef USE_MCJIT
                       llvm::DIContext **context
-#else
-                      std::vector<JITEvent_EmittedFunctionDetails::LineStart> *lines
-#endif
                       )
 {
     int found = 0;
     *slide = 0;
-#ifndef USE_MCJIT
-    std::map<size_t, FuncInfo, revcomp> &fmap = jl_jit_events->getMap();
-    std::map<size_t, FuncInfo, revcomp>::iterator fit = fmap.lower_bound(fptr);
-
-    if (fit != fmap.end() && fptr < fit->first + fit->second.lengthAdr) {
-        if (symsize)
-            *symsize = fit->second.lengthAdr;
-        *lines = fit->second.lines;
-        found = 1;
-    }
-#else // MCJIT version
     std::map<size_t, ObjectInfo, revcomp> &objmap = jl_jit_events->getObjectMap();
     std::map<size_t, ObjectInfo, revcomp>::iterator fit = objmap.lower_bound(fptr);
 
@@ -1457,20 +1110,14 @@ int jl_DI_for_fptr(uint64_t fptr, uint64_t *symsize, int64_t *slide, int64_t *se
             *section_slide = fit->second.slide;
         *object = fit->second.object;
         if (context) {
-#if JL_LLVM_VERSION >= 30700
             *context = fit->second.context;
-#else
-            *context = DIContext::getDWARFContext(*fit->second.object);
-#endif
         }
         found = 1;
     }
-#endif
     uv_rwlock_rdunlock(&threadsafe);
     return found;
 }
 
-#ifdef USE_MCJIT
 extern "C"
 JL_DLLEXPORT jl_value_t *jl_get_dobj_data(uint64_t fptr)
 {
@@ -1519,8 +1166,6 @@ JL_DLLEXPORT uint64_t jl_get_section_start(uint64_t fptr)
     return ret;
 }
 
-#endif
-
 // Set *name and *filename to either NULL or malloc'd string
 int jl_getFunctionInfo(jl_frame_t **frames_out, size_t pointer, int skipC, int noInline)
 {
@@ -1531,7 +1176,6 @@ int jl_getFunctionInfo(jl_frame_t **frames_out, size_t pointer, int skipC, int n
     frames[0].line = -1;
     *frames_out = frames;
 
-#ifdef USE_MCJIT
     llvm::DIContext *context;
     const llvm::object::ObjectFile *object;
     uint64_t symsize;
@@ -1541,112 +1185,15 @@ int jl_getFunctionInfo(jl_frame_t **frames_out, size_t pointer, int skipC, int n
         int nf = lookup_pointer(context, frames_out, pointer+slide, 1, noInline);
         return nf;
     }
-#else // !USE_MCJIT
-// Without MCJIT we use the FuncInfo structure containing address maps
-    std::map<size_t, FuncInfo, revcomp> &info = jl_jit_events->getMap();
-    std::map<size_t, FuncInfo, revcomp>::iterator it = info.lower_bound(pointer);
-    if (it != info.end() && (uintptr_t)(*it).first + (*it).second.lengthAdr >= pointer) {
-        // We do this to hide the jlcall wrappers when getting julia backtraces,
-        // but it is still good to have them for regular lookup of C frames.
-        if (skipC && (*it).second.lines.empty()) {
-            // Technically not true, but we don't want them
-            // in julia backtraces, so close enough
-            frames[0].fromC = 1;
-            uv_rwlock_rdunlock(&threadsafe);
-            return 1;
-        }
-
-        jl_copy_str(&frames[0].func_name, (*it).second.func->getName().str().c_str());
-        jl_copy_str(&frames[0].file_name, "");
-
-        if ((*it).second.lines.empty()) {
-            frames[0].fromC = 1;
-            uv_rwlock_rdunlock(&threadsafe);
-            return 1;
-        }
-
-        frames[0].linfo = (*it).second.linfo;
-        std::vector<JITEvent_EmittedFunctionDetails::LineStart>::iterator vit =
-            (*it).second.lines.begin();
-        JITEvent_EmittedFunctionDetails::LineStart prev = *vit;
-        LLVMContext &Ctx = (*it).second.func->getContext();
-
-        DISubprogram debugscope(prev.Loc.getScope(Ctx));
-        jl_copy_str(&frames[0].file_name, debugscope.getFilename().str().c_str());
-        // The DISubprogram has the un-mangled name, so use that if
-        // available. However, the scope need not be the current subprogram.
-        if (debugscope.getName().data() != NULL) {
-            jl_copy_str(&frames[0].func_name, debugscope.getName().str().c_str());
-        }
-        else {
-            char *oldname = frames[0].func_name;
-            std::pair<char *, bool> demangled = jl_demangle(oldname);
-            frames[0].func_name = demangled.first;
-            frames[0].fromC = !demangled.second;
-            free(oldname);
-        }
-
-        // find nearest line info
-        ++vit;
-        while (vit != (*it).second.lines.end()) {
-            if (pointer <= (*vit).Address) {
-                break;
-            }
-            prev = *vit;
-            ++vit;
-        }
-
-        // read out inlining and line number information
-        int n_frames = 1;
-        if (!noInline) {
-            MDNode *inlinedAt = prev.Loc.getInlinedAt(Ctx);
-            while (inlinedAt != NULL) {
-                DebugLoc inlineloc = DebugLoc::getFromDILocation(inlinedAt);
-                inlinedAt = inlineloc.getInlinedAt(Ctx);
-                n_frames++;
-            }
-            if (n_frames > 1) {
-                frames = (jl_frame_t*)calloc(sizeof(jl_frame_t), n_frames);
-                memcpy(&frames[n_frames - 1], *frames_out, sizeof(jl_frame_t));
-                free(*frames_out);
-                *frames_out = frames;
-            }
-        }
-        DebugLoc inlineloc = prev.Loc;
-        for (int i = 0; i < n_frames; i++) {
-            frames[i].inlined = i != n_frames - 1;
-            frames[i].line = inlineloc.getLine();
-            DISubprogram locscope(inlineloc.getScope(Ctx));
-            jl_copy_str(&frames[i].file_name, locscope.getFilename().str().c_str());
-            jl_copy_str(&frames[i].func_name, locscope.getName().str().c_str());
-            MDNode *inlinedAt = inlineloc.getInlinedAt(Ctx);
-            inlineloc = DebugLoc::getFromDILocation(inlinedAt);
-        }
-
-        uv_rwlock_rdunlock(&threadsafe);
-        return n_frames;
-    }
-    uv_rwlock_rdunlock(&threadsafe);
-#endif // USE_MCJIT
     return jl_getDylibFunctionInfo(frames_out, pointer, skipC, noInline);
 }
 
 extern "C" jl_method_instance_t *jl_gdblookuplinfo(void *p)
 {
-#ifndef USE_MCJIT
-    std::map<size_t, FuncInfo, revcomp> &info = jl_jit_events->getMap();
-    std::map<size_t, FuncInfo, revcomp>::iterator it = info.lower_bound((size_t)p);
-    jl_method_instance_t *li = NULL;
-    if (it != info.end() && (uintptr_t)(*it).first + (*it).second.lengthAdr >= (uintptr_t)p)
-        li = (*it).second.linfo;
-    uv_rwlock_rdunlock(&threadsafe);
-    return li;
-#else
     return jl_jit_events->lookupLinfo((size_t)p);
-#endif
 }
 
-#if JL_LLVM_VERSION >= 30700 && (defined(_OS_LINUX_) || (defined(_OS_DARWIN_) && defined(LLVM_SHLIB)))
+#if (defined(_OS_LINUX_) || (defined(_OS_DARWIN_) && defined(LLVM_SHLIB)))
 extern "C" void __register_frame(void*);
 extern "C" void __deregister_frame(void*);
 
@@ -1673,7 +1220,7 @@ static void processFDEs(const char *EHFrameAddr, size_t EHFrameSize, callback f)
 }
 #endif
 
-#if defined(_OS_DARWIN_) && JL_LLVM_VERSION >= 30700 && defined(LLVM_SHLIB)
+#if defined(_OS_DARWIN_) && defined(LLVM_SHLIB)
 
 /*
  * We use a custom unwinder, so we need to make sure that when registering dynamic
@@ -1713,7 +1260,7 @@ void deregister_eh_frames(uint8_t *Addr, size_t Size)
     });
 }
 
-#elif defined(_OS_LINUX_) && JL_LLVM_VERSION >= 30700 && \
+#elif defined(_OS_LINUX_) && \
     defined(JL_UNW_HAS_FORMAT_IP) && !defined(_CPU_ARM_)
 #include <type_traits>
 
@@ -2055,7 +1602,6 @@ void deregister_eh_frames(uint8_t *Addr, size_t Size)
 
 #endif
 
-#ifdef USE_MCJIT
 extern "C"
 uint64_t jl_getUnwindInfo(uint64_t dwAddr)
 {
@@ -2069,109 +1615,3 @@ uint64_t jl_getUnwindInfo(uint64_t dwAddr)
     uv_rwlock_rdunlock(&threadsafe);
     return ipstart;
 }
-#else
-extern "C"
-uint64_t jl_getUnwindInfo(uint64_t dwAddr)
-{
-    // Might be called from unmanaged thread
-    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() && (uintptr_t)(*it).first + (*it).second.lengthAdr > dwAddr) {
-        ipstart = (uint64_t)(uintptr_t)(*it).first;
-    }
-    uv_rwlock_rdunlock(&threadsafe);
-    return ipstart;
-}
-#endif
-
-
-#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)
-class JITMemoryManagerWin : public JITMemoryManager {
-private:
-    JITMemoryManager *JMM;
-public:
-    JITMemoryManagerWin() : JITMemoryManager()
-    {
-        JMM = JITMemoryManager::CreateDefaultMemManager();
-    }
-    virtual void setMemoryWritable() { return JMM->setMemoryWritable(); }
-    virtual void setMemoryExecutable() { return JMM->setMemoryExecutable(); }
-    virtual void setPoisonMemory(bool poison) { return JMM->setPoisonMemory(poison); }
-    virtual void AllocateGOT() { JMM->AllocateGOT(); HasGOT = true; }
-    virtual uint8_t *getGOTBase() const { return JMM->getGOTBase(); }
-    virtual uint8_t *startFunctionBody(const Function *F, uintptr_t &ActualSize)
-    {
-        if (ActualSize == 0)
-            ActualSize += 64;
-        ActualSize += 48;
-        uint8_t *mem = JMM->startFunctionBody(F,ActualSize);
-        ActualSize -= 48;
-        return mem;
-    }
-    virtual uint8_t *allocateStub(const GlobalValue *F, unsigned StubSize, unsigned Alignment)
-    {
-        return JMM->allocateStub(F,StubSize,Alignment);
-    }
-    virtual void endFunctionBody(const Function *F, uint8_t *FunctionStart, uint8_t *FunctionEnd)
-    {
-        FunctionEnd[0] = 0;
-        JMM->endFunctionBody(F,FunctionStart,FunctionEnd+48);
-    }
-    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,
-                                         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); }
-    virtual void deallocateExceptionTable(void *ET) { return JMM->deallocateExceptionTable(ET); }
-    virtual bool CheckInvariants(std::string &str) { return JMM->CheckInvariants(str); }
-    virtual size_t GetDefaultCodeSlabSize() { return JMM->GetDefaultCodeSlabSize(); }
-    virtual size_t GetDefaultDataSlabSize() { return JMM->GetDefaultDataSlabSize(); }
-    virtual size_t GetDefaultStubSlabSize() { return JMM->GetDefaultStubSlabSize(); }
-    virtual unsigned GetNumCodeSlabs() { return JMM->GetNumCodeSlabs(); }
-    virtual unsigned GetNumDataSlabs() { return JMM->GetNumDataSlabs(); }
-    virtual unsigned GetNumStubSlabs() { return JMM->GetNumStubSlabs(); }
-
-#if JL_LLVM_VERSION >= 30500
-    virtual uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
-                                         unsigned SectionID, llvm::StringRef SectionName)
-    {
-        uint8_t *mem = JMM->allocateCodeSection(Size+48, Alignment, SectionID, SectionName);
-        mem[Size] = 0;
-        return mem;
-    }
-    virtual uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
-                                         unsigned SectionID, llvm::StringRef SectionName, bool IsReadOnly)
-    {
-        return JMM->allocateDataSection(Size,Alignment,SectionID,SectionName,IsReadOnly);
-    }
-#else
-    virtual uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment, unsigned SectionID)
-    {
-        uint8_t *mem = JMM->allocateCodeSection(Size+48, Alignment, SectionID);
-        mem[Size] = 0;
-        return mem;
-    }
-    virtual uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
-                                         unsigned SectionID, bool IsReadOnly)
-    {
-        return JMM->allocateDataSection(Size,Alignment,SectionID,IsReadOnly);
-    }
-#endif
-    virtual void *getPointerToNamedFunction(const std::string &Name, bool AbortOnFailure = true)
-    {
-        return JMM->getPointerToNamedFunction(Name,AbortOnFailure);
-    }
-    virtual bool applyPermissions(std::string *ErrMsg = 0) { return JMM->applyPermissions(ErrMsg); }
-    virtual void registerEHFrames(StringRef SectionData) { return JMM->registerEHFrames(SectionData); }
-};
-JITMemoryManager *createJITMemoryManagerWin()
-{
-    return new JITMemoryManagerWin();
-}
-#endif
diff --git a/src/debuginfo.h b/src/debuginfo.h
new file mode 100644
index 00000000000000..4acf509e8fd383
--- /dev/null
+++ b/src/debuginfo.h
@@ -0,0 +1,11 @@
+// This file is a part of Julia. License is MIT: https://julialang.org/license
+
+// Declarations for debuginfo.cpp
+
+extern int jl_DI_for_fptr(uint64_t fptr, uint64_t *symsize, int64_t *slide, int64_t *section_slide,
+                      const object::ObjectFile **object,
+                      llvm::DIContext **context);
+
+extern bool jl_dylib_DI_for_fptr(size_t pointer, const object::ObjectFile **object, llvm::DIContext **context,
+        int64_t *slide, int64_t *section_slide,
+        bool onlySysImg, bool *isSysImg, void **saddr, char **name, char **filename);
diff --git a/src/disasm.cpp b/src/disasm.cpp
index d0a07dc5d9f83e..219836e4a59b8a 100644
--- a/src/disasm.cpp
+++ b/src/disasm.cpp
@@ -28,8 +28,13 @@
 
 #include "llvm-version.h"
 #include <llvm/Object/ObjectFile.h>
+#if JL_LLVM_VERSION >= 50000
+#include <llvm/BinaryFormat/MachO.h>
+#include <llvm/BinaryFormat/COFF.h>
+#else
 #include <llvm/Support/MachO.h>
 #include <llvm/Support/COFF.h>
+#endif
 #include <llvm/MC/MCInst.h>
 #include <llvm/MC/MCStreamer.h>
 #include <llvm/MC/MCSubtargetInfo.h>
@@ -44,79 +49,386 @@
 #include <llvm/MC/MCExpr.h>
 #include <llvm/MC/MCInstrAnalysis.h>
 #include <llvm/MC/MCSymbol.h>
-#if JL_LLVM_VERSION >= 30500
-#  include <llvm/AsmParser/Parser.h>
-#  if JL_LLVM_VERSION >= 30900
-#    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/AsmParser/Parser.h>
+#include <llvm/MC/MCDisassembler/MCDisassembler.h>
+#include <llvm/MC/MCDisassembler/MCExternalSymbolizer.h>
 #include <llvm/ADT/Triple.h>
 #include <llvm/Support/MemoryBuffer.h>
-#if JL_LLVM_VERSION < 30600
-#include <llvm/Support/MemoryObject.h>
-#endif
 #include <llvm/Support/SourceMgr.h>
 #include <llvm/Support/TargetRegistry.h>
 #include <llvm/Support/Host.h>
 #include "llvm/Support/TargetSelect.h"
 #include <llvm/Support/raw_ostream.h>
 #include "llvm/Support/FormattedStream.h"
-#if JL_LLVM_VERSION < 30500
-#include <llvm/Support/system_error.h>
-#endif
 #include <llvm/ExecutionEngine/JITEventListener.h>
 #include <llvm/IR/LLVMContext.h>
 #include <llvm/DebugInfo/DIContext.h>
-#if JL_LLVM_VERSION >= 30700
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
-#endif
-#if JL_LLVM_VERSION >= 30500
 #include <llvm/IR/DebugInfo.h>
-#else
-#include <llvm/DebugInfo.h>
-#endif
+#include <llvm/IR/Function.h>
+#include <llvm/IR/Module.h>
+#include <llvm/IR/IntrinsicInst.h>
+#include "llvm/IR/AssemblyAnnotationWriter.h"
+#include "fix_llvm_assert.h"
 
 #include "julia.h"
 #include "julia_internal.h"
 
 using namespace llvm;
+#include "debuginfo.h"
 
-extern JL_DLLEXPORT LLVMContext &jl_LLVMContext;
+// helper class for tracking inlining context while printing debug info
+class DILineInfoPrinter {
+    std::vector<DILineInfo> context;
+    char LineStart;
+    bool bracket_outer;
+public:
+    DILineInfoPrinter(char LineStart, bool bracket_outer)
+        : LineStart(LineStart),
+          bracket_outer(bracket_outer) {};
+    void emit_finish(raw_ostream &Out);
+    void emit_lineinfo(raw_ostream &Out, std::vector<DILineInfo> &DI);
+
+    template<class T>
+    void emit_lineinfo(std::string &Out, T &DI)
+    {
+        raw_string_ostream OS(Out);
+        emit_lineinfo(OS, DI);
+    }
 
-namespace {
-#if JL_LLVM_VERSION >= 30600
-#define FuncMCView ArrayRef<uint8_t>
-#else
-class FuncMCView : public MemoryObject {
-private:
-    const char *Fptr;
-    const size_t Fsize;
+    void emit_lineinfo(raw_ostream &Out, DILineInfo &DI)
+    {
+        std::vector<DILineInfo> DIvec(1);
+        DIvec[0] = DI;
+        emit_lineinfo(Out, DIvec);
+    }
+
+    void emit_lineinfo(raw_ostream &Out, DIInliningInfo &DI)
+    {
+        uint32_t nframes = DI.getNumberOfFrames();
+        std::vector<DILineInfo> DIvec(nframes);
+        for (uint32_t i = 0; i < DI.getNumberOfFrames(); i++) {
+            DIvec[i] = DI.getFrame(i);
+        }
+        emit_lineinfo(Out, DIvec);
+    }
+
+    void emit_finish(std::string &Out)
+    {
+        raw_string_ostream OS(Out);
+        emit_finish(OS);
+    }
+};
+
+void DILineInfoPrinter::emit_finish(raw_ostream &Out)
+{
+    uint32_t npops = context.size();
+    if (!bracket_outer && npops > 0)
+        npops--;
+    if (npops) {
+        Out << LineStart;
+        while (npops--)
+            Out << '}';
+        Out << '\n';
+    }
+    context.clear();
+}
+
+void DILineInfoPrinter::emit_lineinfo(raw_ostream &Out, std::vector<DILineInfo> &DI)
+{
+    bool update_line_only = false;
+    uint32_t nctx = context.size();
+    uint32_t nframes = DI.size();
+    if (nframes == 0)
+        return; // just skip over lines with no debug info at all
+    if (nctx > nframes)
+        context.resize(nframes);
+    for (uint32_t i = 0; i < nctx && i < nframes; i++) {
+        const DILineInfo &CtxLine = context.at(i);
+        const DILineInfo &FrameLine = DI.at(nframes - 1 - i);
+        if (CtxLine != FrameLine) {
+            if (CtxLine.FileName == FrameLine.FileName &&
+                    CtxLine.FunctionName == FrameLine.FunctionName) {
+                update_line_only = true;
+            }
+            context.resize(i);
+            break;
+        }
+    }
+    uint32_t npops = nctx - context.size() - update_line_only;
+    if (npops) {
+        Out << LineStart;
+        while (npops--)
+            Out << '}';
+        Out << '\n';
+    }
+    if (update_line_only) {
+        DILineInfo frame = DI.at(nframes - 1 - context.size());
+        if (frame.Line != UINT_MAX && frame.Line != 0)
+            Out << LineStart << " Location: " << frame.FileName << ":" << frame.Line << '\n';
+        context.push_back(frame);
+    }
+    for (uint32_t i = context.size(); i < nframes; i++) {
+        DILineInfo frame = DI.at(nframes - 1 - i);
+        context.push_back(frame);
+        Out << LineStart << " Function " << frame.FunctionName;
+        if (bracket_outer || i != 0)
+            Out << " {";
+        Out << "\n" << LineStart << " Location: " << frame.FileName;
+        if (frame.Line != UINT_MAX && frame.Line != 0)
+            Out << ":" << frame.Line;
+        Out << "\n";
+    }
+}
+
+
+// adaptor class for printing line numbers before llvm IR lines
+class LineNumberAnnotatedWriter : public AssemblyAnnotationWriter {
+    DILocation *InstrLoc = nullptr;
+    DILineInfoPrinter LinePrinter{';', false};
+    DenseMap<const Instruction *, DILocation *> DebugLoc;
+    DenseMap<const Function *, DISubprogram *> Subprogram;
 public:
-    FuncMCView(const void *fptr, size_t size) : Fptr((const char*)fptr), Fsize(size) {}
-    uint64_t getBase() const { return 0; }
-    uint64_t getExtent() const { return Fsize; }
-    int readByte(uint64_t Addr, uint8_t *Byte) const {
-        if (Addr >= getExtent())
-            return -1;
-        *Byte = Fptr[Addr];
-        return 0;
+    LineNumberAnnotatedWriter() {}
+    virtual void emitFunctionAnnot(const Function *, formatted_raw_ostream &);
+    virtual void emitInstructionAnnot(const Instruction *, formatted_raw_ostream &);
+    virtual void emitBasicBlockEndAnnot(const BasicBlock *, formatted_raw_ostream &);
+    // virtual void printInfoComment(const Value &, formatted_raw_ostream &) {}
+
+    void addSubprogram(const Function *F, DISubprogram *SP)
+    {
+        Subprogram[F] = SP;
     }
 
-    // ArrayRef-like accessors:
-    const char operator[] (const size_t idx) const { return Fptr[idx]; }
-    uint64_t size() const { return Fsize; }
-    const uint8_t *data() const { return (const uint8_t*)Fptr; }
-    FuncMCView slice(unsigned N) const { return FuncMCView(Fptr+N, Fsize-N); }
+    void addDebugLoc(const Instruction *I, DILocation *Loc)
+    {
+        DebugLoc[I] = Loc;
+    }
 };
-#endif
+
+void LineNumberAnnotatedWriter::emitFunctionAnnot(
+      const Function *F, formatted_raw_ostream &Out)
+{
+    InstrLoc = nullptr;
+    DISubprogram *FuncLoc = F->getSubprogram();
+    if (!FuncLoc) {
+        auto SP = Subprogram.find(F);
+        if (SP != Subprogram.end())
+            FuncLoc = SP->second;
+    }
+    if (!FuncLoc)
+        return;
+    std::vector<DILineInfo> DIvec(1);
+    DILineInfo &DI = DIvec.back();
+    DI.FunctionName = FuncLoc->getName();
+    DI.FileName = FuncLoc->getFilename();
+    DI.Line = FuncLoc->getLine();
+    LinePrinter.emit_lineinfo(Out, DIvec);
+}
+
+void LineNumberAnnotatedWriter::emitInstructionAnnot(
+      const Instruction *I, formatted_raw_ostream &Out)
+{
+    DILocation *NewInstrLoc = I->getDebugLoc();
+    if (!NewInstrLoc) {
+        auto Loc = DebugLoc.find(I);
+        if (Loc != DebugLoc.end())
+            NewInstrLoc = Loc->second;
+    }
+    if (!NewInstrLoc || NewInstrLoc == InstrLoc)
+        return;
+    InstrLoc = NewInstrLoc;
+    std::vector<DILineInfo> DIvec;
+    do {
+        DIvec.emplace_back();
+        DILineInfo &DI = DIvec.back();
+        DIScope *scope = NewInstrLoc->getScope();
+        if (scope)
+            DI.FunctionName = scope->getName();
+        DI.FileName = NewInstrLoc->getFilename();
+        DI.Line = NewInstrLoc->getLine();
+        NewInstrLoc = NewInstrLoc->getInlinedAt();
+    } while (NewInstrLoc);
+    LinePrinter.emit_lineinfo(Out, DIvec);
+}
+
+void LineNumberAnnotatedWriter::emitBasicBlockEndAnnot(
+        const BasicBlock *BB, formatted_raw_ostream &Out)
+{
+    if (BB == &BB->getParent()->back())
+        LinePrinter.emit_finish(Out);
+}
+
+// print an llvm IR acquired from jl_get_llvmf
+// warning: this takes ownership of, and destroys, f->getParent()
+extern "C" JL_DLLEXPORT
+jl_value_t *jl_dump_function_ir(void *f, bool strip_ir_metadata, bool dump_module)
+{
+    std::string code;
+    llvm::raw_string_ostream stream(code);
+
+    Function *llvmf = dyn_cast_or_null<Function>((Function*)f);
+    if (!llvmf || (!llvmf->isDeclaration() && !llvmf->getParent()))
+        jl_error("jl_dump_function_ir: Expected Function* in a temporary Module");
+
+    JL_LOCK(&codegen_lock); // Might GC
+    LineNumberAnnotatedWriter AAW;
+    if (!llvmf->getParent()) {
+        // print the function declaration as-is
+        llvmf->print(stream, &AAW);
+        delete llvmf;
+    }
+    else {
+        Module *m = llvmf->getParent();
+        if (strip_ir_metadata) {
+            // strip metadata from all instructions in all functions in the module
+            Instruction *deletelast = nullptr; // can't actually delete until the iterator advances
+            for (Function &f2 : m->functions()) {
+                AAW.addSubprogram(&f2, f2.getSubprogram());
+                for (BasicBlock &f2_bb : f2) {
+                    for (Instruction &inst : f2_bb) {
+                        if (deletelast) {
+                            deletelast->eraseFromParent();
+                            deletelast = nullptr;
+                        }
+                        // remove dbg.declare and dbg.value calls
+                        if (isa<DbgDeclareInst>(inst) || isa<DbgValueInst>(inst)) {
+                            deletelast = &inst;
+                            continue;
+                        }
+
+                        // iterate over all metadata kinds and set to NULL to remove
+                        SmallVector<std::pair<unsigned, MDNode*>, 4> MDForInst;
+                        inst.getAllMetadataOtherThanDebugLoc(MDForInst);
+                        for (const auto &md_iter : MDForInst) {
+                            inst.setMetadata(md_iter.first, NULL);
+                        }
+                        // record debug location before erasing it
+                        AAW.addDebugLoc(&inst, inst.getDebugLoc());
+                        inst.setDebugLoc(DebugLoc());
+                    }
+                    if (deletelast) {
+                        deletelast->eraseFromParent();
+                        deletelast = nullptr;
+                    }
+                }
+            }
+            for (GlobalObject &g2 : m->global_objects()) {
+                g2.clearMetadata();
+            }
+        }
+        if (dump_module) {
+            m->print(stream, &AAW);
+        }
+        else {
+            llvmf->print(stream, &AAW);
+        }
+        delete m;
+    }
+    JL_UNLOCK(&codegen_lock); // Might GC
+
+    return jl_pchar_to_string(stream.str().data(), stream.str().size());
+}
+
+static void jl_dump_asm_internal(
+        uintptr_t Fptr, size_t Fsize, int64_t slide,
+        const object::ObjectFile *object,
+        DIContext *di_ctx,
+        raw_ostream &rstream,
+        const char* asm_variant);
+
+// This isn't particularly fast, but neither is printing assembly, and they're only used for interactive mode
+static uint64_t compute_obj_symsize(const object::ObjectFile *obj, uint64_t offset)
+{
+    // Scan the object file for the closest symbols above and below offset in the .text section
+    uint64_t lo = 0;
+    uint64_t hi = 0;
+    bool setlo = false;
+    for (const object::SectionRef &Section : obj->sections()) {
+        uint64_t SAddr, SSize;
+        if (!Section.isText()) continue;
+        SAddr = Section.getAddress();
+        SSize = Section.getSize();
+        if (offset < SAddr || offset >= SAddr + SSize) continue;
+        assert(hi == 0);
+
+        // test for lower and upper symbol bounds relative to other symbols
+        hi = SAddr + SSize;
+        object::section_iterator ESection = obj->section_end();
+        for (const object::SymbolRef &Sym : obj->symbols()) {
+            uint64_t Addr;
+            object::section_iterator Sect = ESection;
+            auto SectOrError = Sym.getSection();
+            assert(SectOrError);
+            Sect = SectOrError.get();
+            if (Sect == ESection) continue;
+            if (Sect != Section) continue;
+            auto AddrOrError = Sym.getAddress();
+            assert(AddrOrError);
+            Addr = AddrOrError.get();
+            if (Addr <= offset && Addr >= lo) {
+                // test for lower bound on symbol
+                lo = Addr;
+                setlo = true;
+            }
+            if (Addr > offset && Addr < hi) {
+                // test for upper bound on symbol
+                hi = Addr;
+            }
+        }
+    }
+    if (setlo)
+        return hi - lo;
+    return 0;
+}
+
+// print a native disassembly for the function starting at fptr
+extern "C" JL_DLLEXPORT
+jl_value_t *jl_dump_fptr_asm(uint64_t fptr, int raw_mc, const char* asm_variant)
+{
+    assert(fptr != 0);
+    jl_ptls_t ptls = jl_get_ptls_states();
+    std::string code;
+    llvm::raw_string_ostream stream(code);
+
+    // Find debug info (line numbers) to print alongside
+    uint64_t symsize = 0;
+    int64_t slide = 0, section_slide = 0;
+    llvm::DIContext *context = NULL;
+    const object::ObjectFile *object = NULL;
+    if (!jl_DI_for_fptr(fptr, &symsize, &slide, &section_slide, &object, &context)) {
+        if (!jl_dylib_DI_for_fptr(fptr, &object, &context, &slide, &section_slide, false,
+            NULL, NULL, NULL, NULL)) {
+                jl_printf(JL_STDERR, "WARNING: Unable to find function pointer\n");
+                return jl_pchar_to_string("", 0);
+        }
+    }
+    if (symsize == 0 && object != NULL)
+        symsize = compute_obj_symsize(object, fptr + slide + section_slide);
+    if (symsize == 0) {
+        jl_printf(JL_STDERR, "WARNING: Could not determine size of symbol\n");
+        return jl_pchar_to_string("", 0);
+    }
+
+    if (raw_mc) {
+        return (jl_value_t*)jl_pchar_to_array((char*)fptr, symsize);
+    }
+
+    // Dump assembly code
+    int8_t gc_state = jl_gc_safe_enter(ptls);
+    jl_dump_asm_internal(
+            fptr, symsize, slide,
+            object, context,
+            stream,
+            asm_variant);
+    jl_gc_safe_leave(ptls, gc_state);
+
+    return jl_pchar_to_string(stream.str().data(), stream.str().size());
+}
+
+
+namespace {
+#define FuncMCView ArrayRef<uint8_t>
 
 // Look up a symbol, and return a const char* to its name when the
 // address matches. We currently just use "L<address>" as name for the
@@ -174,33 +486,16 @@ const char *SymbolTable::lookupLocalPC(size_t addr) {
 StringRef SymbolTable::getSymbolNameAt(uint64_t offset) const
 {
     if (object == NULL) return StringRef();
-#if JL_LLVM_VERSION >= 30700
     object::section_iterator ESection = object->section_end();
     for (const object::SymbolRef &Sym : object->symbols()) {
-#else
-    llvm::error_code err;
-    object::section_iterator ESection = object->end_sections();
-    for (object::symbol_iterator I = object->begin_symbols(), E = object->end_symbols();
-            !err && I != E; I.increment(err)) {
-        object::SymbolRef Sym = *I;
-#endif
         uint64_t Addr, SAddr;
         object::section_iterator Sect = ESection;
-#if JL_LLVM_VERSION >= 30800
         auto SectOrError = Sym.getSection();
         assert(SectOrError);
         Sect = SectOrError.get();
-#else
-        if (Sym.getSection(Sect)) continue;
-#endif
         if (Sect == ESection) continue;
-#if JL_LLVM_VERSION >= 30500
         SAddr = Sect->getAddress();
         if (SAddr == 0) continue;
-#else
-        if (Sym.getAddress(SAddr) || SAddr == 0) continue;
-#endif
-#if JL_LLVM_VERSION >= 30700
         auto AddrOrError = Sym.getAddress();
         assert(AddrOrError);
         Addr = AddrOrError.get();
@@ -209,14 +504,6 @@ StringRef SymbolTable::getSymbolNameAt(uint64_t offset) const
             if (sNameOrError)
                 return sNameOrError.get();
         }
-#else
-        if (Sym.getAddress(Addr)) continue;
-        if (Addr == offset) {
-            StringRef Name;
-            if (!Sym.getName(Name))
-                return Name;
-        }
-#endif
     }
     return StringRef();
 }
@@ -252,13 +539,8 @@ void SymbolTable::createSymbols()
             name << global;
         }
 
-#if JL_LLVM_VERSION >= 30700
         MCSymbol *symb = Ctx.getOrCreateSymbol(StringRef(name.str()));
         assert(symb->isUndefined());
-#else
-        MCSymbol *symb = Ctx.GetOrCreateSymbol(StringRef(name.str()));
-        symb->setVariableValue(MCConstantExpr::Create(rel, Ctx));
-#endif
         isymb->second = symb;
     }
 }
@@ -298,11 +580,7 @@ static const char *SymbolLookup(void *DisInfo, uint64_t ReferenceValue, uint64_t
         else if (*ReferenceType == LLVMDisassembler_ReferenceType_In_PCrel_Load) {
             const char *symbolName = SymTab->lookupSymbolName(addr, false);
             if (symbolName) {
-#if JL_LLVM_VERSION >= 30700
                 *ReferenceType = LLVMDisassembler_ReferenceType_Out_LitPool_SymAddr;
-#else
-                *ReferenceType = LLVMDisassembler_ReferenceType_Out_LitPool_CstrAddr;
-#endif
                 *ReferenceName = symbolName;
                 return NULL;
             }
@@ -346,30 +624,12 @@ static int OpInfoLookup(void *DisInfo, uint64_t PC, uint64_t Offset, uint64_t Si
 }
 } // namespace
 
-extern "C" {
-JL_DLLEXPORT LLVMDisasmContextRef jl_LLVMCreateDisasm(const char *TripleName, void *DisInfo, int TagType, LLVMOpInfoCallback GetOpInfo, LLVMSymbolLookupCallback SymbolLookUp)
-{
-    return LLVMCreateDisasm(TripleName, DisInfo, TagType, GetOpInfo, SymbolLookUp);
-}
-
-JL_DLLEXPORT size_t jl_LLVMDisasmInstruction(LLVMDisasmContextRef DC, uint8_t *Bytes, uint64_t BytesSize, uint64_t PC, char *OutString, size_t OutStringSize)
-{
-    return LLVMDisasmInstruction(DC, Bytes, BytesSize, PC, OutString, OutStringSize);
-}
-
-void jl_dump_asm_internal(uintptr_t Fptr, size_t Fsize, int64_t slide,
-#ifndef USE_MCJIT
-                          std::vector<JITEvent_EmittedFunctionDetails::LineStart> lineinfo,
-#endif
-                          const object::ObjectFile *object,
-                          DIContext *di_ctx,
-#if JL_LLVM_VERSION >= 30700
-                          raw_ostream &rstream,
-#else
-                          formatted_raw_ostream &stream,
-#endif
-                          const char* asm_variant="att"
-                          )
+static void jl_dump_asm_internal(
+        uintptr_t Fptr, size_t Fsize, int64_t slide,
+        const object::ObjectFile *object,
+        DIContext *di_ctx,
+        raw_ostream &rstream,
+        const char* asm_variant)
 {
     // GC safe
     // Get the host information
@@ -390,58 +650,24 @@ void jl_dump_asm_internal(uintptr_t Fptr, size_t Fsize, int64_t slide,
     const Target *TheTarget = TargetRegistry::lookupTarget(TripleName, err);
 
     // Set up required helpers and streamer
-#if JL_LLVM_VERSION >= 30500
     std::unique_ptr<MCStreamer> Streamer;
-#else
-    OwningPtr<MCStreamer> Streamer;
-#endif
     SourceMgr SrcMgr;
 
-#if JL_LLVM_VERSION >= 30500
     std::unique_ptr<MCAsmInfo> MAI(TheTarget->createMCAsmInfo(*TheTarget->createMCRegInfo(TripleName),TripleName));
-#elif JL_LLVM_VERSION >= 30400
-    llvm::OwningPtr<MCAsmInfo> MAI(TheTarget->createMCAsmInfo(*TheTarget->createMCRegInfo(TripleName),TripleName));
-#else
-    llvm::OwningPtr<MCAsmInfo> MAI(TheTarget->createMCAsmInfo(TripleName));
-#endif
     assert(MAI && "Unable to create target asm info!");
 
-#if JL_LLVM_VERSION >= 30500
     std::unique_ptr<MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TripleName));
-#else
-    llvm::OwningPtr<MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TripleName));
-#endif
     assert(MRI && "Unable to create target register info!");
 
-#if JL_LLVM_VERSION >= 30500
     std::unique_ptr<MCObjectFileInfo> MOFI(new MCObjectFileInfo());
-#else
-    OwningPtr<MCObjectFileInfo> MOFI(new MCObjectFileInfo());
-#endif
-#if JL_LLVM_VERSION >= 30400
     MCContext Ctx(MAI.get(), MRI.get(), MOFI.get(), &SrcMgr);
-#else
-    MCContext Ctx(*MAI, *MRI, MOFI.get(), &SrcMgr);
-#endif
-#if JL_LLVM_VERSION >= 30900
     MOFI->InitMCObjectFileInfo(TheTriple, /* PIC */ false,
                                CodeModel::Default, Ctx);
-#elif JL_LLVM_VERSION >= 30700
-    MOFI->InitMCObjectFileInfo(TheTriple, Reloc::Default, CodeModel::Default, Ctx);
-#else
-    MOFI->InitMCObjectFileInfo(TripleName, Reloc::Default, CodeModel::Default, Ctx);
-#endif
 
     // Set up Subtarget and Disassembler
-#if JL_LLVM_VERSION >= 30500
     std::unique_ptr<MCSubtargetInfo>
         STI(TheTarget->createMCSubtargetInfo(TripleName, MCPU, Features.getString()));
     std::unique_ptr<MCDisassembler> DisAsm(TheTarget->createMCDisassembler(*STI, Ctx));
-#else
-    OwningPtr<MCSubtargetInfo>
-        STI(TheTarget->createMCSubtargetInfo(TripleName, MCPU, Features.getString()));
-    OwningPtr<MCDisassembler> DisAsm(TheTarget->createMCDisassembler(*STI));
-#endif
     if (!DisAsm) {
         jl_printf(JL_STDERR, "ERROR: no disassembler for target %s\n",
                   TripleName.c_str());
@@ -454,75 +680,38 @@ void jl_dump_asm_internal(uintptr_t Fptr, size_t Fsize, int64_t slide,
     }
     bool ShowEncoding = false;
 
-#if JL_LLVM_VERSION >= 30500
     std::unique_ptr<MCInstrInfo> MCII(TheTarget->createMCInstrInfo());
     std::unique_ptr<MCInstrAnalysis>
         MCIA(TheTarget->createMCInstrAnalysis(MCII.get()));
-#else
-    OwningPtr<MCInstrInfo> MCII(TheTarget->createMCInstrInfo());
-    OwningPtr<MCInstrAnalysis>
-        MCIA(TheTarget->createMCInstrAnalysis(MCII.get()));
-#endif
-#if JL_LLVM_VERSION >= 30700
     MCInstPrinter *IP =
         TheTarget->createMCInstPrinter(TheTriple, OutputAsmVariant, *MAI, *MCII, *MRI);
-#else
-    MCInstPrinter *IP =
-        TheTarget->createMCInstPrinter(OutputAsmVariant, *MAI, *MCII, *MRI, *STI);
-#endif
     //IP->setPrintImmHex(true); // prefer hex or decimal immediates
     MCCodeEmitter *CE = 0;
     MCAsmBackend *MAB = 0;
     if (ShowEncoding) {
-#if JL_LLVM_VERSION >= 30700
         CE = TheTarget->createMCCodeEmitter(*MCII, *MRI, Ctx);
-#else
-        CE = TheTarget->createMCCodeEmitter(*MCII, *MRI, *STI, Ctx);
-#endif
 #if JL_LLVM_VERSION >= 40000
         MCTargetOptions Options;
         MAB = TheTarget->createMCAsmBackend(*MRI, TripleName, MCPU, Options);
-#elif JL_LLVM_VERSION >= 30400
-        MAB = TheTarget->createMCAsmBackend(*MRI, TripleName, MCPU);
 #else
-        MAB = TheTarget->createMCAsmBackend(TripleName, MCPU);
+        MAB = TheTarget->createMCAsmBackend(*MRI, TripleName, MCPU);
 #endif
     }
 
-#if JL_LLVM_VERSION >= 30700
     // 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
-#if JL_LLVM_VERSION < 30500
-                                                /*useLoc*/ true,
-                                                /*useCFI*/ true,
-#endif
                                                 /*useDwarfDirectory*/ true,
                                                 IP, CE, MAB, /*ShowInst*/ false));
-#if JL_LLVM_VERSION >= 30600
     Streamer->InitSections(true);
-#else
-    Streamer->InitSections();
-#endif
 
     // Make the MemoryObject wrapper
-#if JL_LLVM_VERSION >= 30600
     ArrayRef<uint8_t> memoryObject(const_cast<uint8_t*>((const uint8_t*)Fptr),Fsize);
-#else
-    FuncMCView memoryObject((const uint8_t*)Fptr, Fsize);
-#endif
     SymbolTable DisInfo(Ctx, object, slide, memoryObject);
 
-#ifndef USE_MCJIT
-    typedef std::vector<JITEvent_EmittedFunctionDetails::LineStart> LInfoVec;
-#endif
-
     DILineInfoTable di_lineinfo;
     if (di_ctx)
          di_lineinfo = di_ctx->getLineInfoForAddressRange(Fptr+slide, Fsize);
@@ -539,72 +728,30 @@ void jl_dump_asm_internal(uintptr_t Fptr, size_t Fsize, int64_t slide,
             // MCIA->evaluateBranch. (It should be possible to rewrite
             // this routine to handle this case correctly as well.)
             // Could add OpInfoLookup here
-#if JL_LLVM_VERSION >= 30500
             DisAsm->setSymbolizer(std::unique_ptr<MCSymbolizer>(new MCExternalSymbolizer(
                         Ctx,
                         std::unique_ptr<MCRelocationInfo>(new MCRelocationInfo(Ctx)),
                         OpInfoLookup,
                         SymbolLookup,
                         &DisInfo)));
-#elif JL_LLVM_VERSION >= 30400
-            OwningPtr<MCRelocationInfo> relinfo(new MCRelocationInfo(Ctx));
-            DisAsm->setupForSymbolicDisassembly(OpInfoLookup, SymbolLookup, &DisInfo, &Ctx,
-                                                relinfo);
-#else
-            DisAsm->setupForSymbolicDisassembly(OpInfoLookup, SymbolLookup, &DisInfo, &Ctx);
-#endif
         }
 
         uint64_t nextLineAddr = -1;
         DILineInfoTable::iterator di_lineIter = di_lineinfo.begin();
         DILineInfoTable::iterator di_lineEnd = di_lineinfo.end();
-#ifndef USE_MCJIT
-        LInfoVec::iterator lineIter = lineinfo.begin();
-        LInfoVec::iterator lineEnd  = lineinfo.end();
-#endif
+        DILineInfoPrinter dbgctx{';', true};
         if (pass != 0) {
             if (di_ctx) {
                 // Set up the line info
                 if (di_lineIter != di_lineEnd) {
-#if JL_LLVM_VERSION >= 30700
-                    std::ostringstream buf;
-                    buf << "Filename: " << di_lineIter->second.FileName << "\n";
-                    Streamer->EmitRawText(buf.str());
-#elif JL_LLVM_VERSION >= 30500
-                    stream << "Filename: " << di_lineIter->second.FileName << "\n";
-#else
-                    stream << "Filename: " << di_lineIter->second.getFileName() << "\n";
-#endif
-#if JL_LLVM_VERSION >= 30500
+                    std::string buf;
+                    dbgctx.emit_lineinfo(buf, di_lineIter->second);
+                    Streamer->EmitRawText(buf);
                     if (di_lineIter->second.Line <= 0)
-#else
-                    if (di_lineIter->second.getLine() <= 0)
-#endif
                         ++di_lineIter;
                     nextLineAddr = di_lineIter->first;
                 }
             }
-#ifndef USE_MCJIT
-            else {
-            // Set up the line info
-                if (lineIter != lineEnd) {
-                    DebugLoc Loc = (*lineIter).Loc;
-                    MDNode *outer = Loc.getInlinedAt(jl_LLVMContext);
-                    while (outer) {
-                        Loc = DebugLoc::getFromDILocation(outer);
-                        outer = Loc.getInlinedAt(jl_LLVMContext);
-                    }
-                    StringRef FileName;
-                    DISubprogram debugscope = DISubprogram(Loc.getScope(jl_LLVMContext));
-                    stream << "Filename: " << debugscope.getFilename() << "\n";
-                    if (Loc.getLine() > 0)
-                        stream << "Source line: " << Loc.getLine() << "\n";
-#if JL_LLVM_VERSION >= 30500
-                    nextLineAddr = (*lineIter).Address;
-#endif
-                }
-            }
-#endif
         }
 
         uint64_t Index = 0;
@@ -613,47 +760,30 @@ void jl_dump_asm_internal(uintptr_t Fptr, size_t Fsize, int64_t slide,
         // Do the disassembly
         for (Index = 0; Index < Fsize; Index += insSize) {
 
-            if (nextLineAddr != (uint64_t)-1 && Index + Fptr + slide == nextLineAddr) {
+            if (pass != 0 && nextLineAddr != (uint64_t)-1 && Index + Fptr + slide == nextLineAddr) {
                 if (di_ctx) {
-#if JL_LLVM_VERSION >= 30700
-                    std::ostringstream buf;
-                    buf << "Source line: " << di_lineIter->second.Line << "\n";
-                    Streamer->EmitRawText(buf.str());
-#elif JL_LLVM_VERSION >= 30500
-                    stream << "Source line: " << di_lineIter->second.Line << "\n";
-#else
-                    stream << "Source line: " << di_lineIter->second.getLine() << "\n";
-#endif
-                    nextLineAddr = (++di_lineIter)->first;
-                }
-#ifndef USE_MCJIT
-                else {
-                    DebugLoc Loc = (*lineIter).Loc;
-                    MDNode *outer = Loc.getInlinedAt(jl_LLVMContext);
-                    while (outer) {
-                        Loc = DebugLoc::getFromDILocation(outer);
-                        outer = Loc.getInlinedAt(jl_LLVMContext);
+                    std::string buf;
+                    DILineInfoSpecifier infoSpec(DILineInfoSpecifier::FileLineInfoKind::Default,
+                                                 DILineInfoSpecifier::FunctionNameKind::ShortName);
+                    DIInliningInfo dbg = di_ctx->getInliningInfoForAddress(Index + Fptr + slide, infoSpec);
+                    if (dbg.getNumberOfFrames()) {
+                        dbgctx.emit_lineinfo(buf, dbg);
+                    }
+                    else {
+                        dbgctx.emit_lineinfo(buf, di_lineIter->second);
                     }
-                    stream << "Source line: " << Loc.getLine() << "\n";
-                    nextLineAddr = (*++lineIter).Address;
+                    Streamer->EmitRawText(buf);
+                    nextLineAddr = (++di_lineIter)->first;
                 }
-#endif
             }
 
             DisInfo.setIP(Fptr+Index);
             if (pass != 0) {
                 // Uncomment this to output addresses for all instructions
                 // stream << Index << ": ";
-#if JL_LLVM_VERSION >= 30700
                 MCSymbol *symbol = DisInfo.lookupSymbol(Fptr+Index);
                 if (symbol)
                     Streamer->EmitLabel(symbol);
-                    // emitInstructionAnnot
-#else
-                const char *symbolName = DisInfo.lookupSymbolName(Fptr + Index, true);
-                if (symbolName)
-                    stream << symbolName << ":";
-#endif
             }
 
             MCInst Inst;
@@ -697,21 +827,13 @@ void jl_dump_asm_internal(uintptr_t Fptr, size_t Fsize, int64_t slide,
                     // Pass 0: Record all branch targets
                     if (MCIA && (MCIA->isBranch(Inst) || MCIA->isCall(Inst))) {
                         uint64_t addr;
-#if JL_LLVM_VERSION >= 30400
                         if (MCIA->evaluateBranch(Inst, Fptr+Index, insSize, addr))
-#else
-                        if ((addr = MCIA->evaluateBranch(Inst, Fptr+Index, insSize)) != (uint64_t)-1)
-#endif
                             DisInfo.insertAddress(addr);
                     }
                 }
                 else {
                     // Pass 1: Output instruction
-#if JL_LLVM_VERSION >= 30500
                     Streamer->EmitInstruction(Inst, *STI);
-#else
-                    Streamer->EmitInstruction(Inst);
-#endif
                 }
                 break;
             }
@@ -720,6 +842,27 @@ void jl_dump_asm_internal(uintptr_t Fptr, size_t Fsize, int64_t slide,
         DisInfo.setIP(Fptr);
         if (pass == 0)
             DisInfo.createSymbols();
+
+        if (pass != 0 && di_ctx) {
+            std::string buf;
+            dbgctx.emit_finish(buf);
+            Streamer->EmitRawText(buf);
+        }
     }
 }
+
+extern "C" JL_DLLEXPORT
+LLVMDisasmContextRef jl_LLVMCreateDisasm(
+        const char *TripleName, void *DisInfo, int TagType,
+        LLVMOpInfoCallback GetOpInfo, LLVMSymbolLookupCallback SymbolLookUp)
+{
+    return LLVMCreateDisasm(TripleName, DisInfo, TagType, GetOpInfo, SymbolLookUp);
+}
+
+extern "C" JL_DLLEXPORT
+JL_DLLEXPORT size_t jl_LLVMDisasmInstruction(
+        LLVMDisasmContextRef DC, uint8_t *Bytes, uint64_t BytesSize,
+        uint64_t PC, char *OutString, size_t OutStringSize)
+{
+    return LLVMDisasmInstruction(DC, Bytes, BytesSize, PC, OutString, OutStringSize);
 }
diff --git a/src/dlload.c b/src/dlload.c
index 860aeda708f6fe..d7232408f268c7 100644
--- a/src/dlload.c
+++ b/src/dlload.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -134,12 +134,15 @@ static void *jl_load_dynamic_library_(const char *modname, unsigned flags, int t
     if (modname == NULL) {
 #ifdef _OS_WINDOWS_
         if (!GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
-                                (LPCWSTR)(&jl_load_dynamic_library),
+                                (LPCWSTR)(uintptr_t)(&jl_load_dynamic_library),
                                 (HMODULE*)&handle)) {
             jl_error("could not load base module");
         }
 #else
-        handle = dlopen(NULL, RTLD_NOW);
+        Dl_info info;
+        if (!dladdr((void*)(uintptr_t)&jl_load_dynamic_library, &info) || !info.dli_fname)
+            jl_error("could not load base module");
+        handle = dlopen(info.dli_fname, RTLD_NOW);
 #endif
         goto done;
     }
@@ -240,9 +243,9 @@ JL_DLLEXPORT void *jl_dlsym(void *handle, const char *symbol)
 const char *jl_dlfind_win32(const char *f_name)
 {
     if (jl_dlsym_e(jl_exe_handle, f_name))
-        return (const char*)1;
+        return JL_EXE_LIBNAME;
     if (jl_dlsym_e(jl_dl_handle, f_name))
-        return (const char*)2;
+        return JL_DL_LIBNAME;
     if (jl_dlsym_e(jl_kernel32_handle, f_name))
         return "kernel32";
     if (jl_dlsym_e(jl_ntdll_handle, f_name))
diff --git a/src/dump.c b/src/dump.c
index 04dba7dbe638eb..9dae4d87626250 100644
--- a/src/dump.c
+++ b/src/dump.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 /*
   saving and restoring system images
@@ -43,7 +43,7 @@ static jl_value_t *deser_symbols[256];
 // left shift by 1
 // (not used in MODE_AST)
 static htable_t backref_table;
-int backref_table_numel;
+static int backref_table_numel;
 static arraylist_t backref_list;
 
 // list of (jl_value_t **loc, size_t pos) entries
@@ -62,23 +62,13 @@ static arraylist_t reinit_list;
 // (only used by the incremental serializer in MODE_MODULE)
 static jl_array_t *serializer_worklist;
 
+// inverse of backedges tree
+// (only used by the incremental serializer in MODE_MODULE)
+htable_t edges_map;
+
 // list of modules being deserialized with __init__ methods
 // (not used in MODE_AST)
-jl_array_t *jl_module_init_order;
-
-// hash of definitions for predefined function pointers
-static htable_t fptr_to_id;
-// array of definitions for the predefined function pointers
-// (reverse of fptr_to_id)
-static const jl_fptr_t id_to_fptrs[] = {
-  NULL, NULL,
-  jl_f_throw, jl_f_is, jl_f_typeof, jl_f_issubtype, jl_f_isa,
-  jl_f_typeassert, jl_f__apply, jl_f__apply_pure, jl_f_isdefined,
-  jl_f_tuple, jl_f_svec, jl_f_intrinsic_call, jl_f_invoke_kwsorter,
-  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,
-  NULL };
+extern jl_array_t *jl_module_init_order;
 
 static const intptr_t LongSymbol_tag   = 23;
 static const intptr_t LongSvec_tag     = 24;
@@ -106,10 +96,6 @@ typedef enum _DUMP_MODES {
     // compressing / decompressing an AST Expr in a MethodInstance
     MODE_AST,
 
-    // jl_restore_system_image
-    // restoring an entire system image from disk
-    MODE_SYSTEM_IMAGE,
-
     // jl_restore_new_module
     // restoring a single module from disk for integration
     // into the currently running system image / environment
@@ -129,6 +115,9 @@ typedef struct {
 static jl_value_t *jl_idtable_type = NULL;
 static arraylist_t builtin_typenames;
 
+// mark symbols for gen_sysimg_symtab.jl
+//#define GEN_SYMTAB_MODE
+
 #define write_uint8(s, n) ios_putc((n), (s))
 #define read_uint8(s) ((uint8_t)ios_getc(s))
 #define write_int8(s, n) write_uint8(s, n)
@@ -199,269 +188,12 @@ static void write_float64(ios_t *s, double x)
 
 // --- Static Compile ---
 
-#define jl_serialize_value(s, v) jl_serialize_value_(s,(jl_value_t*)(v))
-static void jl_serialize_value_(jl_serializer_state *s, jl_value_t *v);
+#define jl_serialize_value(s, v) jl_serialize_value_((s), (jl_value_t*)(v), 0)
+static void jl_serialize_value_(jl_serializer_state *s, jl_value_t *v, int as_literal);
 static jl_value_t *jl_deserialize_value(jl_serializer_state *s, jl_value_t **loc);
-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;
-static void *jl_sysimg_handle = NULL;
-static uint64_t sysimage_base = 0;
-
-JL_DLLEXPORT int jl_running_on_valgrind(void)
-{
-    return RUNNING_ON_VALGRIND;
-}
-
-static int jl_load_sysimg_so(void)
-{
-#ifndef _OS_WINDOWS_
-    Dl_info dlinfo;
-#endif
-    // attempt to load the pre-compiled sysimage from jl_sysimg_handle
-    if (jl_sysimg_handle == 0)
-        return -1;
-
-    int imaging_mode = jl_generating_output() && !jl_options.incremental;
-    // 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"
-                     "Please delete or regenerate sys.{so,dll,dylib}.");
-#ifdef HAVE_CPUID
-        uint32_t info[4];
-        jl_cpuid((int32_t*)info, 1);
-        if (strcmp(cpu_target, "native") == 0) {
-            if (!RUNNING_ON_VALGRIND) {
-                uint64_t saved_cpuid = *(uint64_t*)jl_dlsym(jl_sysimg_handle, "jl_sysimg_cpu_cpuid");
-                if (saved_cpuid != (((uint64_t)info[2])|(((uint64_t)info[3])<<32)))
-                    jl_error("Target architecture mismatch. Please delete or regenerate sys.{so,dll,dylib}.");
-            }
-        }
-        else if (strcmp(cpu_target,"core2") == 0) {
-            int HasSSSE3 = (info[2] & 1<<9);
-            if (!HasSSSE3)
-                jl_error("The current host does not support SSSE3, but the system image was compiled for Core2.\n"
-                         "Please delete or regenerate sys.{so,dll,dylib}.");
-        }
-#endif
-
-#ifdef _OS_WINDOWS_
-        sysimage_base = (intptr_t)jl_sysimg_handle;
-#else
-        if (dladdr((void*)sysimg_gvars, &dlinfo) != 0) {
-            sysimage_base = (intptr_t)dlinfo.dli_fbase;
-        }
-        else {
-            sysimage_base = 0;
-        }
-#endif
-    }
-    const char *sysimg_data = (const char*)jl_dlsym_e(jl_sysimg_handle, "jl_system_image_data");
-    if (sysimg_data) {
-        size_t len = *(size_t*)jl_dlsym(jl_sysimg_handle, "jl_system_image_size");
-        jl_restore_system_image_data(sysimg_data, len);
-        return 0;
-    }
-    return -1;
-}
-
-static jl_value_t *jl_deserialize_gv(jl_serializer_state *s, jl_value_t *v)
-{
-    // Restore the GlobalVariable reference to this jl_value_t via the sysimg_gvars table
-    int32_t gvname_index = read_int32(s->s)-1;
-    if (sysimg_gvars != NULL && gvname_index >= 0 && s->mode == MODE_SYSTEM_IMAGE) {
-        *sysimg_gvars[gvname_index] = v;
-    }
-    return v;
-}
-
-static void jl_serialize_gv(jl_serializer_state *s, jl_value_t *v)
-{
-    // write the index of the literal_pointer_val into the system image
-    write_int32(s->s, jl_get_llvm_gv(v));
-}
-
-static void jl_serialize_globalvals(jl_serializer_state *s)
-{
-    size_t i, len = backref_table.size;
-    void **p = backref_table.table;
-    for(i=0; i < len; i+=2) {
-        char *offs = (char*)p[i+1];
-        if (offs != HT_NOTFOUND) {
-            uintptr_t pos = offs - (char*)HT_NOTFOUND - 1;
-            int32_t gv = jl_get_llvm_gv((jl_value_t*)p[i]);
-            if (gv != 0) {
-                write_int32(s->s, pos + 1);
-                write_int32(s->s, gv);
-            }
-        }
-    }
-    write_int32(s->s, 0);
-}
-
-static void jl_deserialize_globalvals(jl_serializer_state *s)
-{
-    while (1) {
-        intptr_t key = read_int32(s->s);
-        if (key == 0) break;
-        jl_deserialize_gv(s, (jl_value_t*)backref_list.items[key - 1]);
-    }
-}
-
-static void jl_serialize_gv_syms(jl_serializer_state *s, jl_sym_t *v)
-{
-    // since symbols are static, they might not have had a
-    // reference anywhere in the code image other than here
-    void *bp = ptrhash_get(&backref_table, v);
-    if (bp == HT_NOTFOUND) {
-        int32_t gv = jl_get_llvm_gv((jl_value_t*)v);
-        if (gv != 0) {
-            jl_serialize_value(s, v);
-            write_int32(s->s, gv);
-        }
-    }
-    if (v->left) jl_serialize_gv_syms(s, v->left);
-    if (v->right) jl_serialize_gv_syms(s, v->right);
-}
-
-static void jl_serialize_gv_others(jl_serializer_state *s)
-{
-    // ensures all objects referenced in the code have
-    // references in the system image to their global variable
-    // since codegen knows that some integer boxes are static,
-    // they might not have had a reference anywhere in the code
-    // image other than here
-    int32_t i;
-    for (i = -512; i < 512; i++) {
-        jl_value_t *v32 = jl_box_int32(i);
-        void *bp32 = ptrhash_get(&backref_table, v32);
-        if (bp32 == HT_NOTFOUND) {
-            int32_t gv32 = jl_get_llvm_gv(v32);
-            if (gv32 != 0) {
-                jl_serialize_value(s, v32);
-                write_int32(s->s, gv32);
-            }
-        }
-    }
-    for (i = -512; i < 512; i++) {
-        jl_value_t *v64 = jl_box_int64(i);
-        void *bp64 = ptrhash_get(&backref_table, v64);
-        if (bp64 == HT_NOTFOUND) {
-            int32_t gv64 = jl_get_llvm_gv(v64);
-            if (gv64 != 0) {
-                jl_serialize_value(s, v64);
-                write_int32(s->s, gv64);
-            }
-        }
-    }
-    jl_serialize_gv_syms(s, jl_get_root_symbol());
-    jl_serialize_value(s, NULL); // signal the end of this list
-}
-
-static void jl_deserialize_gv_others(jl_serializer_state *s)
-{
-    while (1) {
-        jl_value_t *v = jl_deserialize_value(s, NULL);
-        if (!v) break;
-        jl_deserialize_gv(s, v);
-    }
-}
-
-static struct delayed_fptrs_t {
-    jl_method_instance_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_method_instance_t *li, int32_t func, int32_t cfunc)
-{
-    // can't restore the fptrs until after the system image is fully restored,
-    // since it will try to decompress the function AST to determine the argument types
-    if (cfunc || func) {
-        if (delayed_fptrs_max < delayed_fptrs_n + 1) {
-            if (delayed_fptrs_max == 0)
-                // 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
-        }
-        delayed_fptrs[delayed_fptrs_n].li = li;
-        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;
-    }
-}
-
-void jl_register_fptrs(uint64_t sysimage_base, void **fptrs, jl_method_instance_t **linfos, size_t n);
-
-static void jl_update_all_fptrs(void)
-{
-    //jl_printf(JL_STDOUT, "delayed_fptrs_n: %d\n", delayed_fptrs_n);
-    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_method_instance_t **linfos = (jl_method_instance_t**)malloc(sizeof(jl_method_instance_t*) * sysimg_fvars_max);
-    for (i = 0; i < delayed_fptrs_n; i++) {
-        jl_method_instance_t *li = delayed_fptrs[i].li;
-        assert(li->def);
-        int32_t cfunc = delayed_fptrs[i].cfunc - 1;
-        if (cfunc >= 0) {
-            jl_fptr_to_llvm((jl_fptr_t)fvars[cfunc], li, 1);
-            linfos[cfunc] = li;
-        }
-        int32_t func = delayed_fptrs[i].func - 1;
-        if (func >= 0) {
-            jl_fptr_to_llvm((jl_fptr_t)fvars[func], li, 0);
-            linfos[func] = 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;
-}
 
 // --- serialize ---
 
-static uint16_t jl_fptr_id(void *fptr)
-{
-    void **pbp = ptrhash_bp(&fptr_to_id, fptr);
-    if (*pbp == HT_NOTFOUND || fptr == NULL)
-        return 1;
-    else
-        return *(intptr_t*)pbp;
-}
-
 static int module_in_worklist(jl_module_t *mod)
 {
     int i, l = jl_array_len(serializer_worklist);
@@ -532,43 +264,33 @@ static int type_recursively_external(jl_datatype_t *dt)
 static void jl_serialize_datatype(jl_serializer_state *s, jl_datatype_t *dt)
 {
     int tag = 0;
-    if (s->mode == MODE_MODULE) {
-        int internal = module_in_worklist(dt->name->module);
-        if (!internal && jl_unwrap_unionall(dt->name->wrapper) == (jl_value_t*)dt) {
-            tag = 6; // external primary type
-        }
-        else if (dt->uid == 0) {
-            tag = 0; // normal struct
-        }
-        else if (internal) {
-            if (jl_unwrap_unionall(dt->name->wrapper) == (jl_value_t*)dt) // comes up often since functions create types
-                tag = 5; // internal, and not in the typename cache (just needs uid reassigned)
-            else
-                tag = 10; // anything else that's internal (just needs uid reassigned and possibly recaching)
-        }
-        else if (type_recursively_external(dt)) {
-            tag = 7; // external type that can be immediately recreated (with apply_type)
-        }
-        else if (type_in_worklist(dt)) {
-            tag = 10; // external, but definitely new (still needs uid and caching, but not full unique-ing)
-        }
-        else {
-            // this'll need a uid and unique-ing later
-            // flag this in the backref table as special
-            uintptr_t *bp = (uintptr_t*)ptrhash_bp(&backref_table, dt);
-            assert(*bp != (uintptr_t)HT_NOTFOUND);
-            *bp |= 1;
-            tag = 10;
-        }
+    int internal = module_in_worklist(dt->name->module);
+    if (!internal && jl_unwrap_unionall(dt->name->wrapper) == (jl_value_t*)dt) {
+        tag = 6; // external primary type
+    }
+    else if (dt->uid == 0) {
+        tag = 0; // normal struct
+    }
+    else if (internal) {
+        if (jl_unwrap_unionall(dt->name->wrapper) == (jl_value_t*)dt) // comes up often since functions create types
+            tag = 5; // internal, and not in the typename cache (just needs uid reassigned)
+        else
+            tag = 10; // anything else that's internal (just needs uid reassigned and possibly recaching)
+    }
+    else if (type_recursively_external(dt)) {
+        tag = 7; // external type that can be immediately recreated (with apply_type)
+    }
+    else if (type_in_worklist(dt)) {
+        tag = 10; // external, but definitely new (still needs uid and caching, but not full unique-ing)
+    }
+    else {
+        // this'll need a uid and unique-ing later
+        // flag this in the backref table as special
+        uintptr_t *bp = (uintptr_t*)ptrhash_bp(&backref_table, dt);
+        assert(*bp != (uintptr_t)HT_NOTFOUND);
+        *bp |= 1;
+        tag = 10;
     }
-    else if (dt == jl_int32_type)
-        tag = 2;
-    else if (dt == jl_bool_type)
-        tag = 3;
-    else if (dt == jl_int64_type)
-        tag = 4;
-    else if (dt == jl_uint8_type)
-        tag = 8;
 
     if (strncmp(jl_symbol_name(dt->name->name), "#kw#", 4) == 0) {
         /* XXX: yuck, but the auto-generated kw types from the serializer isn't a real type, so we *must* be very careful */
@@ -609,9 +331,6 @@ static void jl_serialize_datatype(jl_serializer_state *s, jl_datatype_t *dt)
     write_int32(s->s, dt->depth);
     if (!dt->abstract) {
         write_uint16(s->s, dt->ninitialized);
-        if (s->mode != MODE_MODULE) {
-            write_int32(s->s, dt->uid);
-        }
     }
 
     if (has_layout) {
@@ -631,6 +350,8 @@ static void jl_serialize_datatype(jl_serializer_state *s, jl_datatype_t *dt)
             write_int32(s->s, nf);
             uint32_t alignment = ((uint32_t*)dt->layout)[1];
             write_int32(s->s, alignment);
+            if (dt->layout->npointers && nf)
+                write_int32(s->s, ((uint32_t*)dt->layout)[-1]);
             size_t fieldsize = jl_fielddesc_size(dt->layout->fielddesc_type);
             ios_write(s->s, (char*)(&dt->layout[1]), nf * fieldsize);
         }
@@ -649,11 +370,9 @@ static void jl_serialize_module(jl_serializer_state *s, jl_module_t *m)
     writetag(s->s, jl_module_type);
     jl_serialize_value(s, m->name);
     int ref_only = 0;
-    if (s->mode == MODE_MODULE) {
-        if (!module_in_worklist(m))
-            ref_only = 1;
-        write_int8(s->s, ref_only);
-    }
+    if (!module_in_worklist(m))
+        ref_only = 1;
+    write_int8(s->s, ref_only);
     jl_serialize_value(s, m->parent);
     if (ref_only) {
         assert(m->parent != m);
@@ -670,7 +389,6 @@ static void jl_serialize_module(jl_serializer_state *s, jl_module_t *m)
                 jl_serialize_value(s, b->globalref);
                 jl_serialize_value(s, b->owner);
                 write_int8(s->s, (b->deprecated<<3) | (b->constp<<2) | (b->exportp<<1) | (b->imported));
-                jl_serialize_gv(s, (jl_value_t*)b);
             }
         }
     }
@@ -694,9 +412,10 @@ static int is_ast_node(jl_value_t *v)
 {
     // TODO: this accidentally copies QuoteNode(Expr(...)) and QuoteNode(svec(...))
     return jl_is_symbol(v) || jl_is_slot(v) || jl_is_ssavalue(v) ||
-        jl_is_expr(v) || jl_is_newvarnode(v) || jl_is_svec(v) || jl_is_tuple(v) ||
-        jl_is_uniontype(v) || jl_is_int32(v) || jl_is_int64(v) ||
-        jl_is_bool(v) || jl_is_quotenode(v) || jl_is_gotonode(v) ||
+        jl_is_uniontype(v) || jl_is_expr(v) || jl_is_newvarnode(v) ||
+        jl_is_svec(v) || jl_is_tuple(v) || ((jl_datatype_t*)jl_typeof(v))->instance ||
+        jl_is_int32(v) || jl_is_int64(v) || jl_is_bool(v) ||
+        jl_is_quotenode(v) || jl_is_gotonode(v) ||
         jl_is_labelnode(v) || jl_is_linenode(v) || jl_is_globalref(v);
 }
 
@@ -711,7 +430,7 @@ static int literal_val_id(jl_serializer_state *s, jl_value_t *v)
     return jl_array_len(s->tree_literal_values) - 1;
 }
 
-static void jl_serialize_value_(jl_serializer_state *s, jl_value_t *v)
+static void jl_serialize_value_(jl_serializer_state *s, jl_value_t *v, int as_literal)
 {
     if (v == NULL) {
         write_uint8(s->s, Null_tag);
@@ -734,7 +453,7 @@ static void jl_serialize_value_(jl_serializer_state *s, jl_value_t *v)
 
     if (s->mode == MODE_AST) {
         // compressing tree
-        if (!is_ast_node(v)) {
+        if (!as_literal && !is_ast_node(v)) {
             writetag(s->s, (jl_value_t*)LiteralVal_tag);
             int id = literal_val_id(s, v);
             assert(id >= 0 && id < UINT16_MAX);
@@ -762,29 +481,24 @@ static void jl_serialize_value_(jl_serializer_state *s, jl_value_t *v)
             arraylist_push(&reinit_list, (void*)pos);
             arraylist_push(&reinit_list, (void*)1);
         }
-        if (s->mode == MODE_MODULE) {
-            if (jl_is_module(v)) {
-                jl_module_t *m = (jl_module_t*)v;
-                if (module_in_worklist(m) && !module_in_worklist(m->parent)) {
-                    // will need to reinsert this into parent bindings, later (in case of any errors during reinsert)
-                    arraylist_push(&reinit_list, (void*)pos);
-                    arraylist_push(&reinit_list, (void*)2);
-                }
-            }
-        }
-        if (s->mode == MODE_MODULE) {
-            // TypeMapLevels need to be rehashed
-            if (jl_is_mtable(v)) {
-                arraylist_push(&reinit_list, (void*)pos);
-                arraylist_push(&reinit_list, (void*)3);
-            }
-            if (jl_is_method(v) && jl_typeof(((jl_method_t*)v)->specializations.unknown) == (jl_value_t*)jl_typemap_level_type) {
+        if (jl_is_module(v)) {
+            jl_module_t *m = (jl_module_t*)v;
+            if (module_in_worklist(m) && !module_in_worklist(m->parent)) {
+                // will need to reinsert this into parent bindings, later (in case of any errors during reinsert)
                 arraylist_push(&reinit_list, (void*)pos);
-                arraylist_push(&reinit_list, (void*)4);
+                arraylist_push(&reinit_list, (void*)2);
             }
         }
-        if (s->mode == MODE_MODULE)
-            pos <<= 1;
+        // TypeMapLevels need to be rehashed
+        if (jl_is_mtable(v)) {
+            arraylist_push(&reinit_list, (void*)pos);
+            arraylist_push(&reinit_list, (void*)3);
+        }
+        if (jl_is_method(v) && jl_typeof(((jl_method_t*)v)->specializations.unknown) == (jl_value_t*)jl_typemap_level_type) {
+            arraylist_push(&reinit_list, (void*)pos);
+            arraylist_push(&reinit_list, (void*)4);
+        }
+        pos <<= 1;
         ptrhash_put(&backref_table, v, (char*)HT_NOTFOUND + pos + 1);
     }
 
@@ -813,7 +527,14 @@ static void jl_serialize_value_(jl_serializer_state *s, jl_value_t *v)
             writetag(s->s, (jl_value_t*)LongSymbol_tag);
             write_int32(s->s, l);
         }
+#ifdef GEN_SYMTAB_MODE
+        write_uint8(s->s, 0);
+        ios_write(s->s, "JJJ", 3);
+#endif
         ios_write(s->s, jl_symbol_name((jl_sym_t*)v), l);
+#ifdef GEN_SYMTAB_MODE
+        write_uint8(s->s, 0);
+#endif
     }
     else if (jl_is_globalref(v)) {
         if (s->mode == MODE_AST && jl_globalref_mod(v) == s->tree_enclosing_module) {
@@ -889,37 +610,25 @@ static void jl_serialize_value_(jl_serializer_state *s, jl_value_t *v)
         jl_method_t *m = (jl_method_t*)v;
         int internal = 1;
         int external_mt = 0;
-        if (s->mode == MODE_MODULE) {
-            internal = module_in_worklist(m->module);
-            if (!internal) {
-                // flag this in the backref table as special
-                uintptr_t *bp = (uintptr_t*)ptrhash_bp(&backref_table, v);
-                assert(*bp != (uintptr_t)HT_NOTFOUND);
-                *bp |= 1;
-            }
+        internal = module_in_worklist(m->module);
+        if (!internal) {
+            // flag this in the backref table as special
+            uintptr_t *bp = (uintptr_t*)ptrhash_bp(&backref_table, v);
+            assert(*bp != (uintptr_t)HT_NOTFOUND);
+            *bp |= 1;
         }
         jl_serialize_value(s, (jl_value_t*)m->sig);
-        if (s->mode == MODE_MODULE) {
-            write_uint8(s->s, internal);
-            if (!internal)
-                return;
-            jl_datatype_t *gf = jl_first_argument_datatype((jl_value_t*)m->sig);
-            assert(jl_is_datatype(gf) && gf->name->mt);
-            external_mt = !module_in_worklist(gf->name->mt->module);
-        }
+        write_uint8(s->s, internal);
+        if (!internal)
+            return;
+        jl_datatype_t *gf = jl_first_argument_datatype((jl_value_t*)m->sig);
+        assert(jl_is_datatype(gf) && gf->name->mt);
+        external_mt = !module_in_worklist(gf->name->mt->module);
         union jl_typemap_t *tf = &m->specializations;
         jl_serialize_value(s, tf->unknown);
         jl_serialize_value(s, (jl_value_t*)m->name);
-        write_int8(s->s, m->isstaged);
         jl_serialize_value(s, (jl_value_t*)m->file);
         write_int32(s->s, m->line);
-        if (s->mode != MODE_MODULE) {
-            write_int32(s->s, m->min_world);
-            write_int32(s->s, m->max_world);
-        }
-        else {
-            assert(m->max_world == ~(size_t)0 && "method replacement cannot be handled by incremental serializer");
-        }
         if (external_mt)
             jl_serialize_value(s, jl_nothing);
         else
@@ -927,6 +636,7 @@ static void jl_serialize_value_(jl_serializer_state *s, jl_value_t *v)
         write_int8(s->s, m->called);
         write_int32(s->s, m->nargs);
         write_int8(s->s, m->isva);
+        write_int8(s->s, m->pure);
         jl_serialize_value(s, (jl_value_t*)m->module);
         jl_serialize_value(s, (jl_value_t*)m->sparam_syms);
         jl_serialize_value(s, (jl_value_t*)m->roots);
@@ -939,68 +649,54 @@ static void jl_serialize_value_(jl_serializer_state *s, jl_value_t *v)
         writetag(s->s, jl_method_instance_type);
         jl_method_instance_t *li = (jl_method_instance_t*)v;
         int internal = 0;
-        if (s->mode == MODE_MODULE) {
-            if (li->max_world == 0 && li->min_world == 0) {
-                internal = 1; // not world-tracked
-            }
-            else if (!li->def || module_in_worklist(li->def->module)) {
-                if (li->max_world == ~(size_t)0) {
-                    internal = 2; // update world on deserialization
-                }
-                else {
-                    internal = 3; // garbage object :(
-                }
+        if (li->max_world == 0 && li->min_world == 0) {
+            internal = 1; // not world-tracked
+        }
+        else if (!jl_is_method(li->def.method) || module_in_worklist(li->def.method->module)) {
+            if (li->max_world == ~(size_t)0) {
+                internal = 2; // update world on deserialization
             }
-            if (!internal) {
-                // also flag this in the backref table as special
-                uintptr_t *bp = (uintptr_t*)ptrhash_bp(&backref_table, v);
-                assert(*bp != (uintptr_t)HT_NOTFOUND);
-                *bp |= 1;
+            else {
+                internal = 3; // garbage object :(
             }
         }
+        if (!internal) {
+            // also flag this in the backref table as special
+            uintptr_t *bp = (uintptr_t*)ptrhash_bp(&backref_table, v);
+            assert(*bp != (uintptr_t)HT_NOTFOUND);
+            *bp |= 1;
+        }
         jl_serialize_value(s, (jl_value_t*)li->specTypes);
-        if (s->mode == MODE_MODULE && !internal)
-            jl_serialize_value(s, (jl_value_t*)li->def->sig);
+        if (!internal)
+            jl_serialize_value(s, (jl_value_t*)li->def.method->sig);
         else
-            jl_serialize_value(s, (jl_value_t*)li->def);
-        if (s->mode == MODE_MODULE) {
-            write_uint8(s->s, internal);
-            if (!internal)
-                return;
-        }
+            jl_serialize_value(s, li->def.value);
+        write_uint8(s->s, internal);
+        if (!internal)
+            return;
         jl_serialize_value(s, li->inferred);
         jl_serialize_value(s, li->inferred_const);
         jl_serialize_value(s, li->rettype);
         jl_serialize_value(s, (jl_value_t*)li->sparam_vals);
-        jl_serialize_value(s, (jl_value_t*)li->backedges);
-        if (s->mode != MODE_MODULE) {
-            write_int32(s->s, li->min_world);
-            write_int32(s->s, li->max_world);
-        }
-        if (li->def) {
-            uint16_t id = jl_fptr_id((void*)(uintptr_t)li->fptr);
-            if (li->jlcall_api == 2) {
-                write_int8(s->s, 2);
-            }
-            else if (id >= 2) {
-                write_int8(s->s, -li->jlcall_api);
-                write_uint16(s->s, id);
-            }
-            else if (li->functionObjectsDecls.functionObject) {
-                int jlcall_api = jl_jlcall_api(li->functionObjectsDecls.functionObject);
-                assert(jlcall_api);
-                // save functionObject pointers
-                write_int8(s->s, jlcall_api);
-                write_int32(s->s, jl_assign_functionID(li->functionObjectsDecls.functionObject));
-                write_int32(s->s, jl_assign_functionID(li->functionObjectsDecls.specFunctionObject));
-            }
-            else {
-                write_int8(s->s, 0);
+        jl_array_t *backedges = li->backedges;
+        if (s->mode == MODE_MODULE && backedges) {
+            // filter backedges to only contain pointers
+            // to items that we will actually store (internal == 2)
+            size_t ins, i, l = jl_array_len(backedges);
+            jl_method_instance_t **b_edges = (jl_method_instance_t**)jl_array_data(backedges);
+            for (ins = i = 0; i < l; i++) {
+                jl_method_instance_t *backedge = b_edges[i];
+                if (module_in_worklist(backedge->def.method->module)) {
+                    b_edges[ins++] = backedge;
+                }
             }
+            if (ins != l)
+                jl_array_del_end(backedges, l - ins);
+            if (ins == 0)
+                backedges = NULL;
         }
-        else {
-            write_int8(s->s, li->jlcall_api);
-        }
+        jl_serialize_value(s, (jl_value_t*)backedges);
+        write_uint8(s->s, li->jlcall_api == 2 ? 2 : 0);
     }
     else if (jl_typeis(v, jl_module_type)) {
         jl_serialize_module(s, (jl_module_t*)v);
@@ -1056,6 +752,7 @@ static void jl_serialize_value_(jl_serializer_state *s, jl_value_t *v)
                 jl_serialize_value(s, t);
                 return;
             }
+            assert(!t->instance && "detected singleton construction corruption");
             if (t->size <= 255) {
                 writetag(s->s, (jl_value_t*)SmallDataType_tag);
                 write_uint8(s->s, t->size);
@@ -1065,52 +762,50 @@ static void jl_serialize_value_(jl_serializer_state *s, jl_value_t *v)
                 write_int32(s->s, t->size);
             }
             jl_serialize_value(s, t);
-            if (s->mode == MODE_MODULE) {
-                if (t == jl_typename_type) {
-                    if (module_in_worklist(((jl_typename_t*)v)->module)) {
-                        write_uint8(s->s, 0);
-                    }
-                    else {
-                        write_uint8(s->s, 1);
-                        jl_typename_t *tn = (jl_typename_t*)v;
-                        jl_serialize_value(s, tn->module);
-                        jl_serialize_value(s, tn->name);
-                        return;
-                    }
+            if (t == jl_typename_type) {
+                if (module_in_worklist(((jl_typename_t*)v)->module)) {
+                    write_uint8(s->s, 0);
                 }
-                if (t == jl_unionall_type) {
-                    jl_datatype_t *d = (jl_datatype_t*)jl_unwrap_unionall(v);
-                    if (jl_is_datatype(d) && d->name->wrapper == v &&
-                        !module_in_worklist(d->name->module)) {
-                        write_uint8(s->s, 1);
-                        jl_serialize_value(s, d->name->module);
-                        jl_serialize_value(s, d->name->name);
-                        return;
-                    }
-                    else {
-                        write_uint8(s->s, 0);
-                    }
+                else {
+                    write_uint8(s->s, 1);
+                    jl_typename_t *tn = (jl_typename_t*)v;
+                    jl_serialize_value(s, tn->module);
+                    jl_serialize_value(s, tn->name);
+                    return;
                 }
-                if (t == jl_typemap_level_type) {
-                    // perform some compression on the typemap levels
-                    // (which will need to be rehashed during deserialization anyhow)
-                    jl_typemap_level_t *node = (jl_typemap_level_t*)v;
-                    assert( // make sure this type has the expected ordering
-                        offsetof(jl_typemap_level_t, arg1) == 0 * sizeof(jl_value_t*) &&
-                        offsetof(jl_typemap_level_t, targ) == 2 * sizeof(jl_value_t*) &&
-                        offsetof(jl_typemap_level_t, linear) == 4 * sizeof(jl_value_t*) &&
-                        offsetof(jl_typemap_level_t, any) == 5 * sizeof(jl_value_t*) &&
-                        offsetof(jl_typemap_level_t, key) == 6 * sizeof(jl_value_t*) &&
-                        sizeof(jl_typemap_level_t) == 7 * sizeof(jl_value_t*));
-                    jl_serialize_value(s, jl_nothing);
-                    jl_serialize_value(s, node->arg1.values);
-                    jl_serialize_value(s, jl_nothing);
-                    jl_serialize_value(s, node->targ.values);
-                    jl_serialize_value(s, node->linear);
-                    jl_serialize_value(s, node->any.unknown);
-                    jl_serialize_value(s, node->key);
+            }
+            if (t == jl_unionall_type) {
+                jl_datatype_t *d = (jl_datatype_t*)jl_unwrap_unionall(v);
+                if (jl_is_datatype(d) && d->name->wrapper == v &&
+                    !module_in_worklist(d->name->module)) {
+                    write_uint8(s->s, 1);
+                    jl_serialize_value(s, d->name->module);
+                    jl_serialize_value(s, d->name->name);
                     return;
                 }
+                else {
+                    write_uint8(s->s, 0);
+                }
+            }
+            if (t == jl_typemap_level_type) {
+                // perform some compression on the typemap levels
+                // (which will need to be rehashed during deserialization anyhow)
+                jl_typemap_level_t *node = (jl_typemap_level_t*)v;
+                assert( // make sure this type has the expected ordering
+                    offsetof(jl_typemap_level_t, arg1) == 0 * sizeof(jl_value_t*) &&
+                    offsetof(jl_typemap_level_t, targ) == 2 * sizeof(jl_value_t*) &&
+                    offsetof(jl_typemap_level_t, linear) == 4 * sizeof(jl_value_t*) &&
+                    offsetof(jl_typemap_level_t, any) == 5 * sizeof(jl_value_t*) &&
+                    offsetof(jl_typemap_level_t, key) == 6 * sizeof(jl_value_t*) &&
+                    sizeof(jl_typemap_level_t) == 7 * sizeof(jl_value_t*));
+                jl_serialize_value(s, jl_nothing);
+                jl_serialize_value(s, node->arg1.values);
+                jl_serialize_value(s, jl_nothing);
+                jl_serialize_value(s, node->targ.values);
+                jl_serialize_value(s, node->linear);
+                jl_serialize_value(s, node->any.unknown);
+                jl_serialize_value(s, node->key);
+                return;
             }
             size_t nf = jl_datatype_nfields(t);
             if (nf == 0 && jl_datatype_size(t)>0) {
@@ -1138,60 +833,73 @@ static void jl_serialize_value_(jl_serializer_state *s, jl_value_t *v)
     }
 }
 
-static void jl_serialize_missing_backedges_to_mod(jl_serializer_state *s, jl_methtable_t *mt)
+static void jl_collect_missing_backedges_to_mod(jl_methtable_t *mt)
 {
     jl_array_t *backedges = mt->backedges;
     if (backedges) {
         size_t i, l = jl_array_len(backedges);
         for (i = 1; i < l; i += 2) {
             jl_method_instance_t *caller = (jl_method_instance_t*)jl_array_ptr_ref(backedges, i);
-            if (caller->max_world == ~(size_t)0 && module_in_worklist(caller->def->module)) {
-                jl_serialize_value(s, caller);
-                jl_serialize_value(s, jl_array_ptr_ref(backedges, i - 1));
+            if (caller->max_world == ~(size_t)0) {
+                jl_value_t *missing_callee = jl_array_ptr_ref(backedges, i - 1);
+                jl_array_t **edges = (jl_array_t**)ptrhash_bp(&edges_map, (void*)caller);
+                if (*edges == HT_NOTFOUND)
+                    *edges = jl_alloc_vec_any(0);
+                jl_array_ptr_1d_push(*edges, missing_callee);
             }
         }
     }
 }
 
-static int jl_serialize_backedges_to_mod(jl_typemap_entry_t *ml, void *closure)
+// the intent of this function is to invert the backedges tree
+// for anything that points to a method not part of the worklist
+static void collect_backedges(jl_method_instance_t *callee)
 {
-    jl_serializer_state *s = (jl_serializer_state*)closure;
-    jl_method_instance_t *callee = ml->func.linfo;
     jl_array_t *backedges = callee->backedges;
     if (backedges) {
         assert(callee->max_world == ~(size_t)0);
         size_t i, l = jl_array_len(backedges);
         for (i = 0; i < l; i++) {
             jl_method_instance_t *caller = (jl_method_instance_t*)jl_array_ptr_ref(backedges, i);
-            if (caller->max_world == ~(size_t)0 && module_in_worklist(caller->def->module)) {
-                jl_serialize_value(s, caller);
-                jl_serialize_value(s, callee);
+            if (caller->max_world == ~(size_t)0) {
+                jl_array_t **edges = (jl_array_t**)ptrhash_bp(&edges_map, caller);
+                if (*edges == HT_NOTFOUND)
+                    *edges = jl_alloc_vec_any(0);
+                jl_array_ptr_1d_push(*edges, (jl_value_t*)callee);
             }
         }
     }
+}
+
+
+static int jl_collect_backedges_to_mod(jl_typemap_entry_t *ml, void *closure)
+{
+    (void)(jl_array_t*)closure;
+    jl_method_instance_t *callee = ml->func.linfo;
+    collect_backedges(callee);
     return 1;
 }
 
-static int jl_serialize_methcache_from_mod(jl_typemap_entry_t *ml, void *closure)
+static int jl_collect_methcache_from_mod(jl_typemap_entry_t *ml, void *closure)
 {
-    jl_serializer_state *s = (jl_serializer_state*)closure;
+    jl_array_t *s = (jl_array_t*)closure;
     jl_method_t *m = ml->func.method;
     if (module_in_worklist(m->module)) {
-        jl_serialize_value(s, m);
-        jl_serialize_value(s, ml->simplesig);
+        jl_array_ptr_1d_push(s, (jl_value_t*)m);
+        jl_array_ptr_1d_push(s, (jl_value_t*)ml->simplesig);
     }
     else {
-        jl_typemap_visitor(m->specializations, jl_serialize_backedges_to_mod, closure);
+        jl_typemap_visitor(m->specializations, jl_collect_backedges_to_mod, closure);
     }
     return 1;
 }
 
-static void jl_serialize_methtable_from_mod(jl_serializer_state *s, jl_typename_t *tn)
+static void jl_collect_methtable_from_mod(jl_array_t *s, jl_typename_t *tn)
 {
-    jl_typemap_visitor(tn->mt->defs, jl_serialize_methcache_from_mod, (void*)s);
+    jl_typemap_visitor(tn->mt->defs, jl_collect_methcache_from_mod, (void*)s);
 }
 
-static void jl_serialize_lambdas_from_mod(jl_serializer_state *s, jl_module_t *m)
+static void jl_collect_lambdas_from_mod(jl_array_t *s, jl_module_t *m)
 {
     if (module_in_worklist(m))
         return;
@@ -1209,8 +917,8 @@ static void jl_serialize_lambdas_from_mod(jl_serializer_state *s, jl_module_t *m
                         if (mt != NULL &&
                                 (jl_value_t*)mt != jl_nothing &&
                                 (mt != jl_type_type_mt || tn == jl_type_typename)) {
-                            jl_serialize_methtable_from_mod(s, tn);
-                            jl_serialize_missing_backedges_to_mod(s, mt);
+                            jl_collect_methtable_from_mod(s, tn);
+                            jl_collect_missing_backedges_to_mod(mt);
                         }
                     }
                 }
@@ -1218,7 +926,7 @@ static void jl_serialize_lambdas_from_mod(jl_serializer_state *s, jl_module_t *m
                     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);
+                        jl_collect_lambdas_from_mod(s, (jl_module_t*)b->value);
                     }
                 }
             }
@@ -1226,6 +934,53 @@ static void jl_serialize_lambdas_from_mod(jl_serializer_state *s, jl_module_t *m
     }
 }
 
+// flatten the backedge map reachable from caller into callees
+static void jl_collect_backedges_to(jl_method_instance_t *caller, jl_array_t *direct_callees, arraylist_t *to_restore)
+{
+    jl_array_t **pcallees = (jl_array_t**)ptrhash_bp(&edges_map, (void*)caller),
+                *callees = *pcallees;
+    if (callees != HT_NOTFOUND) {
+        arraylist_push(to_restore, (void*)callees);
+        arraylist_push(to_restore, (void*)pcallees);
+        *pcallees = (jl_array_t*) HT_NOTFOUND;
+        jl_array_ptr_1d_append(direct_callees, callees);
+        size_t i, l = jl_array_len(callees);
+        for (i = 0; i < l; i++) {
+            jl_value_t *c = jl_array_ptr_ref(callees, i);
+            if (jl_is_method_instance(c)) {
+                jl_collect_backedges_to((jl_method_instance_t*)c, direct_callees, to_restore);
+            }
+        }
+    }
+}
+
+static void jl_collect_backedges(jl_array_t *s)
+{
+    arraylist_t to_restore;
+    arraylist_new(&to_restore, 0);
+    size_t i;
+    void **table = edges_map.table;
+    for (i = 0; i < edges_map.size; i += 2) {
+        jl_method_instance_t *caller = (jl_method_instance_t*)table[i];
+        jl_array_t *callees = (jl_array_t*)table[i + 1];
+        if (callees != HT_NOTFOUND && module_in_worklist(caller->def.method->module)) {
+            size_t i, l = jl_array_len(callees); // length may change during iteration
+            for (i = 0; i < l; i++) {           // only consider the initial list
+                jl_value_t *c = jl_array_ptr_ref(callees, i);
+                if (jl_is_method_instance(c)) {
+                    jl_collect_backedges_to((jl_method_instance_t*)c, callees, &to_restore);
+                }
+            }
+            jl_array_ptr_1d_push(s, (jl_value_t*)caller);
+            jl_array_ptr_1d_push(s, (jl_value_t*)callees);
+            while (to_restore.len) {
+                void **pp = (void**)arraylist_pop(&to_restore);
+                *pp = arraylist_pop(&to_restore);
+            }
+        }
+    }
+}
+
 // serialize information about all of the modules accessible directly from Main
 static void write_mod_list(ios_t *s)
 {
@@ -1337,17 +1092,6 @@ static void write_dependency_list(ios_t *s)
 
 // --- deserialize ---
 
-static jl_fptr_t jl_deserialize_fptr(jl_serializer_state *s)
-{
-    int fptr = read_uint16(s->s);
-    if (fptr < 2)
-        return NULL;
-
-    if (fptr >= sizeof(id_to_fptrs)/sizeof(*id_to_fptrs))
-        jl_error("unknown function pointer ID");
-    return id_to_fptrs[fptr];
-}
-
 static jl_value_t *jl_deserialize_datatype(jl_serializer_state *s, int pos, jl_value_t **loc)
 {
     int tag = read_uint8(s->s);
@@ -1366,7 +1110,7 @@ static jl_value_t *jl_deserialize_datatype(jl_serializer_state *s, int pos, jl_v
     }
     if (tag == 9) {
         jl_datatype_t *primarydt = (jl_datatype_t*)jl_deserialize_value(s, NULL);
-        jl_value_t *dtv = jl_typeof(jl_get_kwsorter(primarydt->name));
+        jl_value_t *dtv = jl_typeof(jl_get_kwsorter((jl_value_t*)primarydt));
         backref_list.items[pos] = dtv;
         return dtv;
     }
@@ -1374,15 +1118,7 @@ static jl_value_t *jl_deserialize_datatype(jl_serializer_state *s, int pos, jl_v
     uint8_t flags = read_uint8(s->s);
     uint8_t depth = read_int32(s->s);
     jl_datatype_t *dt = NULL;
-    if (tag == 2)
-        dt = jl_int32_type;
-    else if (tag == 3)
-        dt = jl_bool_type;
-    else if (tag == 4)
-        dt = jl_int64_type;
-    else if (tag == 8)
-        dt = jl_uint8_type;
-    else if (tag == 0 || tag == 5 || tag == 10)
+    if (tag == 0 || tag == 5 || tag == 10)
         dt = jl_new_uninitialized_datatype();
     else {
         assert(0 && "corrupt deserialization state");
@@ -1409,7 +1145,7 @@ static jl_value_t *jl_deserialize_datatype(jl_serializer_state *s, int pos, jl_v
     dt->layout = NULL;
     if (!dt->abstract) {
         dt->ninitialized = read_uint16(s->s);
-        dt->uid = (s->mode != MODE_MODULE) ? read_int32(s->s) : 0;
+        dt->uid = 0;
     }
     else {
         dt->ninitialized = 0;
@@ -1440,10 +1176,16 @@ static jl_value_t *jl_deserialize_datatype(jl_serializer_state *s, int pos, jl_v
             } header;
             header.buffer.nf = nf;
             header.buffer.alignment = alignment;
+            int has_padding = header.layout.npointers && nf;
             uint8_t fielddesc_type = header.layout.fielddesc_type;
             size_t fielddesc_size = nf > 0 ? jl_fielddesc_size(fielddesc_type) : 0;
             jl_datatype_layout_t *layout = (jl_datatype_layout_t*)jl_gc_perm_alloc(
-                    sizeof(jl_datatype_layout_t) + nf * fielddesc_size);
+                    sizeof(jl_datatype_layout_t) + nf * fielddesc_size +
+                    (has_padding ? sizeof(uint32_t) : 0), 0, 4, 0);
+            if (has_padding) {
+                layout = (jl_datatype_layout_t*)(((char*)layout) + sizeof(uint32_t));
+                jl_datatype_layout_n_nonptr(layout) = read_int32(s->s);
+            }
             *layout = header.layout;
             ios_read(s->s, (char*)&layout[1], nf * fielddesc_size);
             dt->layout = layout;
@@ -1494,10 +1236,8 @@ static jl_value_t *jl_deserialize_value(jl_serializer_state *s, jl_value_t **loc
         assert(s->tree_literal_values == NULL && s->mode != MODE_AST);
         uintptr_t offs = (tag == BackRef_tag) ? read_int32(s->s) : read_uint16(s->s);
         int isflagref = 0;
-        if (s->mode == MODE_MODULE) {
-            isflagref = !!(offs & 1);
-            offs >>= 1;
-        }
+        isflagref = !!(offs & 1);
+        offs >>= 1;
         // 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];
@@ -1548,7 +1288,13 @@ static jl_value_t *jl_deserialize_value_symbol(jl_serializer_state *s, jl_value_
     else
         len = read_int32(s->s);
     char *name = (char*)(len >= 256 ? malloc(len + 1) : alloca(len + 1));
+#ifdef GEN_SYMTAB_MODE
+    (void)read_uint8(s->s); (void)read_uint8(s->s); (void)read_uint8(s->s); (void)read_uint8(s->s);
+#endif
     ios_read(s->s, name, len);
+#ifdef GEN_SYMTAB_MODE
+    (void)read_uint8(s->s);
+#endif
     name[len] = '\0';
     jl_value_t *sym = (jl_value_t*)jl_symbol(name);
     if (len >= 256)
@@ -1638,35 +1384,26 @@ static jl_value_t *jl_deserialize_value_method(jl_serializer_state *s, jl_value_
         arraylist_push(&backref_list, m);
     m->sig = (jl_value_t*)jl_deserialize_value(s, (jl_value_t**)&m->sig);
     jl_gc_wb(m, m->sig);
-    if (s->mode == MODE_MODULE) {
-        int internal = read_uint8(s->s);
-        if (!internal) {
-            assert(loc != NULL && loc != HT_NOTFOUND);
-            arraylist_push(&flagref_list, loc);
-            arraylist_push(&flagref_list, (void*)pos);
-            return (jl_value_t*)m;
-        }
+    int internal = read_uint8(s->s);
+    if (!internal) {
+        assert(loc != NULL && loc != HT_NOTFOUND);
+        arraylist_push(&flagref_list, loc);
+        arraylist_push(&flagref_list, (void*)pos);
+        return (jl_value_t*)m;
     }
     m->specializations.unknown = jl_deserialize_value(s, (jl_value_t**)&m->specializations);
     jl_gc_wb(m, m->specializations.unknown);
     m->name = (jl_sym_t*)jl_deserialize_value(s, NULL);
     jl_gc_wb(m, m->name);
-    m->isstaged = read_int8(s->s);
     m->file = (jl_sym_t*)jl_deserialize_value(s, NULL);
     m->line = read_int32(s->s);
-    if (s->mode != MODE_MODULE) {
-        m->min_world = read_int32(s->s);
-        m->max_world = read_int32(s->s);
-    }
-    else {
-        m->min_world = jl_world_counter;
-        m->max_world = ~(size_t)0;
-    }
+    m->min_world = jl_world_counter;
     m->ambig = jl_deserialize_value(s, (jl_value_t**)&m->ambig);
     jl_gc_wb(m, m->ambig);
     m->called = read_int8(s->s);
     m->nargs = read_int32(s->s);
     m->isva = read_int8(s->s);
+    m->pure = read_int8(s->s);
     m->module = (jl_module_t*)jl_deserialize_value(s, (jl_value_t**)&m->module);
     jl_gc_wb(m, m->module);
     m->sparam_syms = (jl_svec_t*)jl_deserialize_value(s, (jl_value_t**)&m->sparam_syms);
@@ -1674,7 +1411,7 @@ static jl_value_t *jl_deserialize_value_method(jl_serializer_state *s, jl_value_
     m->roots = (jl_array_t*)jl_deserialize_value(s, (jl_value_t**)&m->roots);
     if (m->roots)
         jl_gc_wb(m, m->roots);
-    m->source = (jl_code_info_t*)jl_deserialize_value(s, (jl_value_t**)&m->source);
+    m->source = jl_deserialize_value(s, &m->source);
     if (m->source)
         jl_gc_wb(m, m->source);
     m->unspecialized = (jl_method_instance_t*)jl_deserialize_value(s, (jl_value_t**)&m->unspecialized);
@@ -1704,19 +1441,16 @@ static jl_value_t *jl_deserialize_value_method_instance(jl_serializer_state *s,
     li->specTypes = (jl_value_t*)jl_deserialize_value(s, (jl_value_t**)&li->specTypes);
     if (li->specTypes)
         jl_gc_wb(li, li->specTypes);
-    li->def = (jl_method_t*)jl_deserialize_value(s, (jl_value_t**)&li->def);
-    if (li->def)
-        jl_gc_wb(li, li->def);
+    li->def.value = jl_deserialize_value(s, &li->def.value);
+    if (li->def.value)
+        jl_gc_wb(li, li->def.value);
 
-    int internal = 0;
-    if (s->mode == MODE_MODULE) {
-        internal = read_uint8(s->s);
-        if (!internal) {
-            assert(loc != NULL && loc != HT_NOTFOUND);
-            arraylist_push(&flagref_list, loc);
-            arraylist_push(&flagref_list, (void*)pos);
-            return (jl_value_t*)li;
-        }
+    int internal = read_uint8(s->s);
+    if (!internal) {
+        assert(loc != NULL && loc != HT_NOTFOUND);
+        arraylist_push(&flagref_list, loc);
+        arraylist_push(&flagref_list, (void*)pos);
+        return (jl_value_t*)li;
     }
 
     li->inferred = jl_deserialize_value(s, &li->inferred);
@@ -1732,11 +1466,7 @@ static jl_value_t *jl_deserialize_value_method_instance(jl_serializer_state *s,
     if (li->backedges)
         jl_gc_wb(li, li->backedges);
     li->unspecialized_ducttape = NULL;
-    if (s->mode != MODE_MODULE) {
-        li->min_world = read_int32(s->s);
-        li->max_world = read_int32(s->s);
-    }
-    else if (internal == 1) {
+    if (internal == 1) {
         li->min_world = 0;
         li->max_world = 0;
     }
@@ -1755,23 +1485,8 @@ static jl_value_t *jl_deserialize_value_method_instance(jl_serializer_state *s,
     li->functionObjectsDecls.functionObject = NULL;
     li->functionObjectsDecls.specFunctionObject = NULL;
     li->inInference = 0;
-    int8_t jlcall_api = read_int8(s->s);
-    if (jlcall_api == 2 || jlcall_api == 0 || li->def == NULL) {
-        li->fptr = NULL;
-        li->jlcall_api = jlcall_api;
-    }
-    else if (jlcall_api < 0) {
-        li->fptr = jl_deserialize_fptr(s);
-        li->jlcall_api = -jlcall_api;
-    }
-    else {
-        int32_t cfunc_llvm, func_llvm;
-        func_llvm = read_int32(s->s);
-        cfunc_llvm = read_int32(s->s);
-        jl_delayed_fptrs(li, func_llvm, cfunc_llvm);
-        li->fptr = NULL;
-        li->jlcall_api = jlcall_api;
-    }
+    li->fptr = NULL;
+    li->jlcall_api = read_int8(s->s);
     li->compile_traced = 0;
     return (jl_value_t*)li;
 }
@@ -1783,14 +1498,12 @@ static jl_value_t *jl_deserialize_value_module(jl_serializer_state *s)
     if (usetable)
         arraylist_push(&backref_list, NULL);
     jl_sym_t *mname = (jl_sym_t*)jl_deserialize_value(s, NULL);
-    if (s->mode == MODE_MODULE) {
-        int ref_only = read_uint8(s->s);
-        if (ref_only) {
-            jl_value_t *m_ref = jl_get_global((jl_module_t*)jl_deserialize_value(s, NULL), mname);
-            if (usetable)
-                backref_list.items[pos] = m_ref;
-            return m_ref;
-        }
+    int ref_only = read_uint8(s->s);
+    if (ref_only) {
+        jl_value_t *m_ref = jl_get_global((jl_module_t*)jl_deserialize_value(s, NULL), mname);
+        if (usetable)
+            backref_list.items[pos] = m_ref;
+        return m_ref;
     }
     jl_module_t *m = jl_new_module(mname);
     if (usetable)
@@ -1815,7 +1528,6 @@ static jl_value_t *jl_deserialize_value_module(jl_serializer_state *s)
         b->constp = (flags>>2) & 1;
         b->exportp = (flags>>1) & 1;
         b->imported = (flags) & 1;
-        jl_deserialize_gv(s, (jl_value_t*)b);
     }
     size_t i = m->usings.len;
     size_t ni = read_int32(s->s);
@@ -1827,6 +1539,7 @@ static jl_value_t *jl_deserialize_value_module(jl_serializer_state *s)
     }
     m->istopmod = read_uint8(s->s);
     m->uuid = read_uint64(s->s);
+    m->primary_world = jl_world_counter;
     m->counter = read_int32(s->s);
     return (jl_value_t*)m;
 }
@@ -1851,18 +1564,19 @@ static jl_value_t *jl_deserialize_value_globalref(jl_serializer_state *s)
 
 static jl_value_t *jl_deserialize_value_singleton(jl_serializer_state *s, jl_value_t **loc)
 {
-    int usetable = (s->mode != MODE_AST);
+    if (s->mode == MODE_AST) {
+        jl_datatype_t *dt = (jl_datatype_t*)jl_deserialize_value(s, NULL);
+        return dt->instance;
+    }
     jl_value_t *v = (jl_value_t*)jl_gc_alloc(s->ptls, 0, NULL);
-    if (usetable) {
-        uintptr_t pos = backref_list.len;
-        arraylist_push(&backref_list, (void*)v);
-        if (s->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 && loc != HT_NOTFOUND);
-            arraylist_push(&flagref_list, loc);
-            arraylist_push(&flagref_list, (void*)pos);
-        }
+    uintptr_t pos = backref_list.len;
+    arraylist_push(&backref_list, (void*)v);
+    if (s->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 && loc != HT_NOTFOUND);
+        arraylist_push(&flagref_list, loc);
+        arraylist_push(&flagref_list, (void*)pos);
     }
     jl_datatype_t *dt = (jl_datatype_t*)jl_deserialize_value(s, (jl_value_t**)HT_NOTFOUND); // no loc, since if dt is replaced, then dt->instance would be also
     jl_set_typeof(v, dt);
@@ -1885,21 +1599,19 @@ static void jl_deserialize_struct(jl_serializer_state *s, jl_value_t *v, size_t
             }
         }
     }
-    if (s->mode == MODE_MODULE) {
-        if (dt == jl_typename_type) {
-            jl_typename_t *tn = (jl_typename_t*)v;
-            tn->cache = jl_emptysvec; // the cache is refilled later (tag 5)
-            tn->linearcache = jl_emptysvec; // the cache is refilled later (tag 5)
-        }
-        if (dt == jl_typemap_entry_type) {
-            if (((jl_typemap_entry_t*)v)->max_world == ~(size_t)0) {
-                // update world validity to reflect current state of the counter
-                ((jl_typemap_entry_t*)v)->min_world = jl_world_counter;
-            }
-            else {
-                // garbage entry - delete it :(
-                ((jl_typemap_entry_t*)v)->min_world = ((jl_typemap_entry_t*)v)->max_world - 1;
-            }
+    if (dt == jl_typename_type) {
+        jl_typename_t *tn = (jl_typename_t*)v;
+        tn->cache = jl_emptysvec; // the cache is refilled later (tag 5)
+        tn->linearcache = jl_emptysvec; // the cache is refilled later (tag 5)
+    }
+    if (dt == jl_typemap_entry_type) {
+        if (((jl_typemap_entry_t*)v)->max_world == ~(size_t)0) {
+            // update world validity to reflect current state of the counter
+            ((jl_typemap_entry_t*)v)->min_world = jl_world_counter;
+        }
+        else {
+            // garbage entry - delete it :(
+            ((jl_typemap_entry_t*)v)->min_world = ((jl_typemap_entry_t*)v)->max_world - 1;
         }
     }
 }
@@ -2067,94 +1779,100 @@ static jl_value_t *jl_deserialize_value_(jl_serializer_state *s, jl_value_t *vta
     }
 }
 
-typedef struct _linkedlist_t {
-    struct _linkedlist_t *next;
-    union {
-        struct {
-            jl_method_t *meth;
-            jl_tupletype_t *simpletype;
-        };
-        struct {
-            jl_method_instance_t *caller;
-            jl_value_t *callee;
-        };
-    } def[100];
-    size_t count;
-} linkedlist_t;
-
-static void jl_deserialize_methods_from_mod(jl_serializer_state *s, linkedlist_t *list)
+static void jl_insert_methods(jl_array_t *list)
 {
-    list->count = 0;
-    list->next = NULL;
-    while (1) {
-        if (list->count == sizeof(list->def) / sizeof(list->def[0])) {
-            list->next = (linkedlist_t*)malloc(sizeof(linkedlist_t));
-            list = list->next;
-            list->count = 0;
-            list->next = NULL;
-        }
-        // using a linked list so that we can take these addresses
-        // and have them remain constant (arraylist reallocates)
-        jl_value_t **loc_meth = (jl_value_t**)&list->def[list->count].meth;
-        jl_value_t **loc_styp = (jl_value_t**)&list->def[list->count].simpletype;
-        *loc_meth = jl_deserialize_value(s, loc_meth);
-        if (*loc_meth == NULL)
-            return;
-        *loc_styp = jl_deserialize_value(s, loc_styp);
-        list->count++;
+    size_t i, l = jl_array_len(list);
+    for (i = 0; i < l; i += 2) {
+        jl_method_t *meth = (jl_method_t*)jl_array_ptr_ref(list, i);
+        jl_tupletype_t *simpletype = (jl_tupletype_t*)jl_array_ptr_ref(list, i + 1);
+        assert(jl_is_method(meth));
+        jl_datatype_t *gf = jl_first_argument_datatype((jl_value_t*)meth->sig);
+        assert(jl_is_datatype(gf) && gf->name->mt);
+        jl_method_table_insert(gf->name->mt, meth, simpletype);
     }
 }
 
-static void jl_insert_methods(linkedlist_t *list)
+static size_t lowerbound_dependent_world_set(size_t world, arraylist_t *dependent_worlds)
 {
-    while (list) {
-        size_t i;
-        for (i = 0; i < list->count; i++) {
-            if (jl_is_method(list->def[i].meth)) {
-                jl_method_t *meth = list->def[i].meth;
-                jl_datatype_t *gf = jl_first_argument_datatype((jl_value_t*)meth->sig);
-                assert(jl_is_datatype(gf) && gf->name->mt);
-                jl_method_table_insert(gf->name->mt, meth, list->def[i].simpletype);
-            }
-        }
-        list = list->next;
+    size_t i, l = dependent_worlds->len;
+    if (world <= (size_t)dependent_worlds->items[l - 1])
+        return world;
+    for (i = 0; i < l; i++) {
+        size_t depworld = (size_t)dependent_worlds->items[i];
+        if (depworld <= world)
+            return depworld;
     }
+    abort(); // unreachable
 }
 
-static void jl_insert_backedges(linkedlist_t *list)
+void jl_method_instance_delete(jl_method_instance_t *mi);
+static void jl_insert_backedges(jl_array_t *list, arraylist_t *dependent_worlds)
 {
-    while (list) {
-        size_t i;
-        for (i = 0; i < list->count; i++) {
-            if (!jl_is_method(list->def[i].meth)) {
-                jl_method_instance_t *caller = list->def[i].caller;
-                assert(jl_is_method_instance(caller));
-                jl_value_t *callee = list->def[i].callee;
+    size_t i, l = jl_array_len(list);
+    for (i = 0; i < l; i += 2) {
+        jl_method_instance_t *caller = (jl_method_instance_t*)jl_array_ptr_ref(list, i);
+        assert(jl_is_method_instance(caller));
+        assert(caller->min_world == jl_world_counter); // caller should be new
+        jl_array_t *callees = (jl_array_t*)jl_array_ptr_ref(list, i + 1);
+        assert(jl_is_array(callees));
+        int valid = 1;
+        size_t j;
+        for (j = 0; valid && j < jl_array_len(callees); j++) {
+            jl_value_t *callee = jl_array_ptr_ref(callees, j);
+            jl_method_instance_t *callee_mi = (jl_method_instance_t*)callee;
+            jl_value_t *sig;
+            if (jl_is_method_instance(callee)) {
+                sig = callee_mi->specTypes;
+                assert(!module_in_worklist(callee_mi->def.method->module));
+                assert(callee_mi->max_world == ~(size_t)0);
+            }
+            else {
+                sig = callee;
+            }
+            // verify that this backedge doesn't intersect with any new methods
+            size_t min_valid = 0;
+            size_t max_valid = ~(size_t)0;
+            jl_value_t *matches = jl_matching_methods((jl_tupletype_t*)sig, 50, 1, jl_world_counter, &min_valid, &max_valid);
+            if (matches == jl_false)
+                valid = 0;
+            size_t k;
+            for (k = 0; valid && k < jl_array_len(matches); k++) {
+                jl_method_t *m = (jl_method_t*)jl_svecref(jl_array_ptr_ref(matches, k), 2);
+                if (lowerbound_dependent_world_set(m->min_world, dependent_worlds) != m->min_world) {
+                    // intersection has a new method and is now probably no good, just invalidate everything now
+                    valid = 0;
+                }
+            }
+        }
+        if (valid) {
+            // if this callee is still valid, add all the backedges
+            for (j = 0; j < jl_array_len(callees); j++) {
+                jl_value_t *callee = jl_array_ptr_ref(callees, j);
                 if (jl_is_method_instance(callee)) {
                     jl_method_instance_add_backedge((jl_method_instance_t*)callee, caller);
                 }
                 else {
-                    jl_datatype_t *gf = jl_first_argument_datatype(callee);
-                    assert(jl_is_datatype(gf) && gf->name->mt);
-                    jl_method_table_add_backedge(gf->name->mt, callee, (jl_value_t*)caller);
+                    jl_datatype_t *ftype = jl_first_argument_datatype(callee);
+                    jl_methtable_t *mt = ftype->name->mt;
+                    assert(jl_is_datatype(ftype) && mt);
+                    jl_method_table_add_backedge(mt, callee, (jl_value_t*)caller);
                 }
             }
         }
-        list = list->next;
+        else {
+            // otherwise delete it
+            jl_method_instance_delete(caller);
+        }
     }
 }
 
 
-static void free_linkedlist(linkedlist_t *list)
+static int size_isgreater(const void *a, const void *b)
 {
-    while (list) {
-        linkedlist_t *prev = list;
-        list = list->next;
-        free(prev);
-    }
+    return *(size_t*)b - *(size_t*)a;
 }
 
-static jl_value_t *read_verify_mod_list(ios_t *s)
+static jl_value_t *read_verify_mod_list(ios_t *s, arraylist_t *dependent_worlds)
 {
     if (!jl_main_module->uuid) {
         return jl_get_exceptionf(jl_errorexception_type,
@@ -2191,7 +1909,6 @@ static jl_value_t *read_verify_mod_list(ios_t *s)
                     "Requiring \"%s\" did not define a corresponding module.", name);
         }
         if (!jl_is_module(m)) {
-            ios_close(s);
             return jl_get_exceptionf(jl_errorexception_type,
                 "Invalid module path (%s does not name a module).", name);
         }
@@ -2199,6 +1916,8 @@ static jl_value_t *read_verify_mod_list(ios_t *s)
             return jl_get_exceptionf(jl_errorexception_type,
                 "Module %s uuid did not match cache file.", name);
         }
+        if (m->primary_world > jl_main_module->primary_world)
+            arraylist_push(dependent_worlds, (void*)m->primary_world);
     }
 }
 
@@ -2282,7 +2001,8 @@ static void jl_reinit_item(jl_value_t *v, int how, arraylist_t *tracee_list)
             case 3: { // rehash MethodTable
                 jl_methtable_t *mt = (jl_methtable_t*)v;
                 jl_typemap_rehash(mt->defs, 0);
-                jl_typemap_rehash(mt->cache, (mt == jl_type_typename->mt) ? 0 : 1);
+                // TODO: consider reverting this when we can split on Type{...} better
+                jl_typemap_rehash(mt->cache, 1); //(mt == jl_type_typename->mt) ? 0 : 1);
                 if (tracee_list)
                     arraylist_push(tracee_list, mt);
                 break;
@@ -2340,256 +2060,16 @@ static void jl_init_restored_modules(jl_array_t *init_order)
 
 // --- entry points ---
 
-// remove cached types not referenced in the stream
-static void jl_prune_type_cache(jl_svec_t *cache)
-{
-    size_t l = jl_svec_len(cache), ins = 0, i;
-    for(i=0; i < l; i++) {
-        jl_value_t *ti = jl_svecref(cache, i);
-        if (ti == NULL) break;
-        if (ptrhash_get(&backref_table, ti) != HT_NOTFOUND || jl_get_llvm_gv(ti) != 0)
-            jl_svecset(cache, ins++, ti);
-    }
-    if (i > ins)
-        memset(&jl_svec_data(cache)[ins], 0, (i-ins)*sizeof(jl_value_t*));
-}
-
-static void jl_save_system_image_to_stream(ios_t *f)
-{
-    jl_gc_collect(1); // full
-    jl_gc_collect(0); // incremental (sweep finalizers)
-    JL_TIMING(SYSIMG_DUMP);
-    int en = jl_gc_enable(0);
-    htable_reset(&backref_table, 250000);
-    arraylist_new(&reinit_list, 0);
-    backref_table_numel = 0;
-    jl_serializer_state s = {
-        f, MODE_SYSTEM_IMAGE,
-        NULL, NULL,
-        jl_get_ptls_states()
-    };
-
-    // 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));
-        }
-    }
-
-    jl_idtable_type = jl_base_module ? jl_get_global(jl_base_module, jl_symbol("ObjectIdDict")) : NULL;
-
-    jl_serialize_value(&s, jl_main_module);
-    jl_serialize_value(&s, jl_top_module);
-    jl_serialize_value(&s, jl_typeinf_func);
-    write_uint64(f, jl_typeinf_world);
-
-    // deserialize method tables of builtin types
-    jl_serialize_value(&s, jl_type_typename->mt);
-    jl_serialize_value(&s, jl_intrinsic_type->name->mt);
-    jl_serialize_value(&s, jl_sym_type->name->mt);
-    jl_serialize_value(&s, jl_array_typename->mt);
-    jl_serialize_value(&s, jl_module_type->name->mt);
-
-    jl_prune_type_cache(jl_tuple_typename->cache);
-    jl_prune_type_cache(jl_tuple_typename->linearcache);
-    jl_prune_type_cache(jl_type_typename->cache);
-
-    intptr_t i;
-    for (i = 0; i < builtin_typenames.len; i++) {
-        jl_serialize_value(&s, ((jl_typename_t*)builtin_typenames.items[i])->cache);
-        jl_serialize_value(&s, ((jl_typename_t*)builtin_typenames.items[i])->linearcache);
-    }
-
-    // ensure everything in deser_tag is reassociated with its GlobalValue
-    for (i = 2; i < 255; i++) {
-        jl_serialize_gv(&s, deser_tag[i]);
-    }
-
-    jl_serialize_globalvals(&s);
-    jl_serialize_gv_others(&s); // serialize things that might not have visible gc roots roots with GlobalValue references
-
-    write_int32(f, jl_get_t_uid_ctr());
-    write_int32(f, jl_get_gs_ctr());
-    write_int32(f, jl_world_counter);
-    jl_finalize_serializer(&s); // done with f and s
-
-    htable_reset(&backref_table, 0);
-    arraylist_free(&reinit_list);
-
-    jl_gc_enable(en);
-}
-
-JL_DLLEXPORT void jl_save_system_image(const char *fname)
-{
-    ios_t f;
-    if (ios_file(&f, fname, 1, 1, 1, 1) == NULL) {
-        jl_errorf("cannot open system image file \"%s\" for writing", fname);
-    }
-    JL_SIGATOMIC_BEGIN();
-    jl_save_system_image_to_stream(&f);
-    ios_close(&f);
-    JL_SIGATOMIC_END();
-}
-
-JL_DLLEXPORT ios_t *jl_create_system_image(void)
-{
-    ios_t *f = (ios_t*)malloc(sizeof(ios_t));
-    ios_mem(f, 1000000);
-    jl_save_system_image_to_stream(f);
-    return f;
-}
-
-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()
-JL_DLLEXPORT void jl_preload_sysimg_so(const char *fname)
-{
-    // If passed NULL, don't even bother
-    if (!fname)
-        return;
-
-    // First, get "sys" from "sys.ji"
-    char *fname_shlib = (char*)alloca(strlen(fname)+1);
-    strcpy(fname_shlib, fname);
-    char *fname_shlib_dot = strrchr(fname_shlib, '.');
-    if (fname_shlib_dot != NULL) {
-        if (!strcmp(fname_shlib_dot, ".ji"))
-            return;  // .ji extension => load .ji file only
-        *fname_shlib_dot = 0;
-    }
-
-    // Get handle to sys.so
-    jl_sysimg_handle = jl_load_dynamic_library_e(fname_shlib, JL_RTLD_LOCAL | JL_RTLD_NOW);
-
-    // set cpu target if unspecified by user and available from sysimg
-    // otherwise default to native.
-    if (jl_sysimg_handle && jl_options.cpu_target == NULL)
-        jl_options.cpu_target = (const char *)jl_dlsym(jl_sysimg_handle, "jl_sysimg_cpu_target");
-}
-
-static void jl_restore_system_image_from_stream(ios_t *f)
-{
-    JL_TIMING(SYSIMG_LOAD);
-    jl_ptls_t ptls = jl_get_ptls_states();
-    int en = jl_gc_enable(0);
-    arraylist_new(&backref_list, 250000);
-    jl_serializer_state s = {
-        f, MODE_SYSTEM_IMAGE,
-        NULL, NULL,
-        jl_get_ptls_states()
-    };
-
-    jl_main_module = (jl_module_t*)jl_deserialize_value(&s, NULL);
-    jl_top_module = (jl_module_t*)jl_deserialize_value(&s, NULL);
-    jl_internal_main_module = jl_main_module;
-    jl_typeinf_func = (jl_function_t*)jl_deserialize_value(&s, NULL);
-    jl_typeinf_world = read_uint64(f);
-
-    jl_type_type_mt = (jl_methtable_t*)jl_deserialize_value(&s, NULL);
-    jl_type_typename->mt = jl_type_type_mt;
-    jl_unionall_type->name->mt = jl_type_type_mt;
-    jl_uniontype_type->name->mt = jl_type_type_mt;
-    jl_datatype_type->name->mt = jl_type_type_mt;
-    jl_intrinsic_type->name->mt = (jl_methtable_t*)jl_deserialize_value(&s, NULL);
-    jl_sym_type->name->mt = (jl_methtable_t*)jl_deserialize_value(&s, NULL);
-    jl_array_typename->mt = (jl_methtable_t*)jl_deserialize_value(&s, NULL);
-    jl_module_type->name->mt = (jl_methtable_t*)jl_deserialize_value(&s, NULL);
-
-    intptr_t i;
-    for(i=0; i < builtin_typenames.len; i++) {
-        jl_typename_t *tn = (jl_typename_t*)builtin_typenames.items[i];
-        tn->cache = (jl_svec_t*)jl_deserialize_value(&s, NULL); jl_gc_wb(tn, tn->cache);
-        tn->linearcache = (jl_svec_t*)jl_deserialize_value(&s, NULL); jl_gc_wb(tn, tn->linearcache);
-        jl_resort_type_cache(tn->cache);
-    }
-
-    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,
-                                                 jl_symbol("Base"));
-    ptls->current_module = jl_base_module; // run start_image in Base
-
-    // ensure everything in deser_tag is reassociated with its GlobalValue
-    for (i = 2; i < 255; i++) {
-        jl_deserialize_gv(&s, deser_tag[i]);
-    }
-    jl_deserialize_globalvals(&s);
-    jl_deserialize_gv_others(&s);
-
-    int uid_ctr = read_int32(f);
-    int gs_ctr = read_int32(f);
-    jl_world_counter = read_int32(f);
-    jl_module_init_order = jl_finalize_deserializer(&s, NULL); // done with s and f
-
-    jl_set_t_uid_ctr(uid_ctr);
-    jl_set_gs_ctr(gs_ctr);
-
-    jl_get_builtins();
-    jl_get_builtin_hooks();
-    if (jl_base_module) {
-        jl_get_system_hooks();
-    }
-    jl_boot_file_loaded = 1;
-    jl_init_box_caches();
-
-    //jl_printf(JL_STDERR, "backref_list.len = %d\n", backref_list.len);
-    arraylist_free(&backref_list);
-
-    jl_gc_reset_alloc_count();
-    jl_gc_enable(en);
-    jl_update_all_fptrs();
-}
-
-JL_DLLEXPORT void jl_restore_system_image(const char *fname)
-{
-    char *dot = (char*) strrchr(fname, '.');
-    int is_ji = (dot && !strcmp(dot, ".ji"));
-
-    if (!is_ji) {
-        int err = jl_load_sysimg_so();
-        if (err != 0) {
-            if (jl_sysimg_handle == 0)
-                jl_errorf("System image file \"%s\" not found.", fname);
-            jl_errorf("Library \"%s\" does not contain a valid system image.", fname);
-        }
-    }
-    else {
-        ios_t f;
-        if (ios_file(&f, fname, 1, 0, 0, 0) == NULL)
-            jl_errorf("System image file \"%s\" not found.", fname);
-        JL_SIGATOMIC_BEGIN();
-        jl_restore_system_image_from_stream(&f);
-        ios_close(&f);
-        JL_SIGATOMIC_END();
-    }
-}
-
-JL_DLLEXPORT void jl_restore_system_image_data(const char *buf, size_t len)
-{
-    ios_t f;
-    JL_SIGATOMIC_BEGIN();
-    ios_static_buffer(&f, (char*)buf, len);
-    jl_restore_system_image_from_stream(&f);
-    ios_close(&f);
-    JL_SIGATOMIC_END();
-}
-
-JL_DLLEXPORT jl_array_t *jl_compress_ast(jl_method_t *m, jl_array_t *ast)
+JL_DLLEXPORT jl_array_t *jl_compress_ast(jl_method_t *m, jl_code_info_t *code)
 {
     JL_TIMING(AST_COMPRESS);
     JL_LOCK(&m->writelock); // protect the roots array (Might GC)
     assert(jl_is_method(m));
-    assert(jl_is_array(ast));
+    assert(jl_is_code_info(code));
     ios_t dest;
     ios_mem(&dest, 0);
     int en = jl_gc_enable(0); // Might GC
+    size_t i;
 
     if (m->roots == NULL) {
         m->roots = jl_alloc_vec_any(0);
@@ -2600,16 +2080,33 @@ JL_DLLEXPORT jl_array_t *jl_compress_ast(jl_method_t *m, jl_array_t *ast)
         m->roots, m->module,
         jl_get_ptls_states()
     };
-    size_t i, nstmts = jl_array_len(ast);
-    assert(nstmts < INT32_MAX);
-    write_int32(&dest, nstmts);
-    for (i = 0; i < nstmts; i++) {
-        jl_serialize_value(&s, jl_array_ptr_ref(ast, i));
+
+    uint8_t flags = (code->inferred << 3)
+                  | (code->inlineable << 2)
+                  | (code->propagate_inbounds << 1)
+                  | (code->pure << 0);
+    write_uint8(s.s, flags);
+
+    size_t nsyms = jl_array_len(code->slotnames);
+    assert(nsyms >= m->nargs && nsyms < INT32_MAX); // required by generated functions
+    write_int32(s.s, nsyms);
+    for (i = 0; i < nsyms; i++) {
+        jl_sym_t *name = (jl_sym_t*)jl_array_ptr_ref(code->slotnames, i);
+        assert(jl_is_symbol(name));
+        char *namestr = jl_symbol_name(name);
+        size_t namelen = strlen(namestr);
+        ios_write(s.s, namestr, namelen + 1); // include nul-byte
     }
 
-    //jl_printf(JL_STDERR, "%d bytes, %d values\n", dest.size, vals->length);
+    size_t nf = jl_datatype_nfields(jl_code_info_type);
+    for (i = 0; i < nf - 5; i++) {
+        jl_serialize_value_(&s, jl_get_nth_field((jl_value_t*)code, i), 1);
+    }
 
+    ios_putc('\0', s.s);
+    ios_flush(s.s);
     jl_array_t *v = jl_take_buffer(&dest);
+    ios_close(s.s);
     if (jl_array_len(m->roots) == 0) {
         m->roots = NULL;
     }
@@ -2620,17 +2117,21 @@ JL_DLLEXPORT jl_array_t *jl_compress_ast(jl_method_t *m, jl_array_t *ast)
     return v;
 }
 
-JL_DLLEXPORT jl_array_t *jl_uncompress_ast(jl_method_t *m, jl_array_t *data)
+JL_DLLEXPORT jl_code_info_t *jl_uncompress_ast(jl_method_t *m, jl_array_t *data)
 {
+    if (jl_is_code_info(data))
+        return (jl_code_info_t*)data;
     JL_TIMING(AST_UNCOMPRESS);
+    jl_ptls_t ptls = jl_get_ptls_states();
     JL_LOCK(&m->writelock); // protect the roots array (Might GC)
     assert(jl_is_method(m));
-    assert(jl_is_array(data));
-    jl_array_t *bytes = (jl_array_t*)data;
+    assert(jl_typeis(data, jl_array_uint8_type));
+    assert(jl_array_len(data) > 2 && ((uint8_t*)data->data)[jl_array_len(data) - 1] == 0);
+    size_t i;
     ios_t src;
     ios_mem(&src, 0);
-    ios_setbuf(&src, (char*)bytes->data, jl_array_len(bytes), 0);
-    src.size = jl_array_len(bytes);
+    ios_setbuf(&src, (char*)data->data, jl_array_len(data), 0);
+    src.size = jl_array_len(data);
     int en = jl_gc_enable(0); // Might GC
     jl_serializer_state s = {
         &src, MODE_AST,
@@ -2638,16 +2139,102 @@ JL_DLLEXPORT jl_array_t *jl_uncompress_ast(jl_method_t *m, jl_array_t *data)
         jl_get_ptls_states()
     };
 
-    size_t i, nstmts = read_int32(&src);
-    jl_array_t *ast = jl_alloc_vec_any(nstmts);
-    JL_GC_PUSH1(&ast);
-    for (i = 0; i < nstmts; i++) {
-        jl_array_ptr_set(ast, i, jl_deserialize_value(&s, NULL));
-    }
+    jl_code_info_t *code =
+        (jl_code_info_t*)jl_gc_alloc(ptls, sizeof(jl_code_info_t),
+                                       jl_code_info_type);
+    uint8_t flags = read_uint8(s.s);
+    code->inferred = !!(flags & (1 << 3));
+    code->inlineable = !!(flags & (1 << 2));
+    code->propagate_inbounds = !!(flags & (1 << 1));
+    code->pure = !!(flags & (1 << 0));
+
+    size_t nslots = read_int32(&src);
+    jl_array_t *syms = jl_alloc_vec_any(nslots);
+    code->slotnames = syms;
+    for (i = 0; i < nslots; i++) {
+        char *namestr = s.s->buf + s.s->bpos;
+        size_t namelen = strlen(namestr);
+        jl_sym_t *name = jl_symbol_n(namestr, namelen);
+        jl_array_ptr_set(syms, i, name);
+        ios_skip(s.s, namelen + 1);
+    }
+
+    size_t nf = jl_datatype_nfields(jl_code_info_type);
+    for (i = 0; i < nf - 5; i++) {
+        assert(jl_field_isptr(jl_code_info_type, i));
+        jl_value_t **fld = (jl_value_t**)((char*)jl_data_ptr(code) + jl_field_offset(jl_code_info_type, i));
+        *fld = jl_deserialize_value(&s, fld);
+    }
+
+    assert(ios_getc(s.s) == '\0' && ios_getc(s.s) == -1);
+    ios_close(s.s);
+    JL_GC_PUSH1(&code);
     jl_gc_enable(en);
     JL_UNLOCK(&m->writelock); // Might GC
     JL_GC_POP();
-    return ast;
+    return code;
+}
+
+JL_DLLEXPORT uint8_t jl_ast_flag_inferred(jl_array_t *data)
+{
+    if (jl_is_code_info(data))
+        return ((jl_code_info_t*)data)->inferred;
+    assert(jl_typeis(data, jl_array_uint8_type));
+    assert(jl_array_len(data) > 2 && ((uint8_t*)data->data)[jl_array_len(data) - 1] == 0);
+    uint8_t flags = ((uint8_t*)data->data)[0];
+    return !!(flags & (1 << 3));
+}
+
+JL_DLLEXPORT uint8_t jl_ast_flag_inlineable(jl_array_t *data)
+{
+    if (jl_is_code_info(data))
+        return ((jl_code_info_t*)data)->inlineable;
+    assert(jl_typeis(data, jl_array_uint8_type));
+    assert(jl_array_len(data) > 2 && ((uint8_t*)data->data)[jl_array_len(data) - 1] == 0);
+    uint8_t flags = ((uint8_t*)data->data)[0];
+    return !!(flags & (1 << 2));
+}
+
+JL_DLLEXPORT uint8_t jl_ast_flag_pure(jl_array_t *data)
+{
+    if (jl_is_code_info(data))
+        return ((jl_code_info_t*)data)->pure;
+    assert(jl_typeis(data, jl_array_uint8_type));
+    assert(jl_array_len(data) > 2 && ((uint8_t*)data->data)[jl_array_len(data) - 1] == 0);
+    uint8_t flags = ((uint8_t*)data->data)[0];
+    return !!(flags & (1 << 0));
+}
+
+JL_DLLEXPORT void jl_fill_argnames(jl_array_t *data, jl_array_t *names)
+{
+    size_t i, nargs = jl_array_len(names);
+    if (jl_is_code_info(data)) {
+        jl_code_info_t *func = (jl_code_info_t*)data;
+        assert(jl_array_len(func->slotnames) >= nargs);
+        for (i = 0; i < nargs; i++) {
+            jl_value_t *name = jl_array_ptr_ref(func->slotnames, i);
+            jl_array_ptr_set(names, i, name);
+        }
+    }
+    else {
+        uint8_t *d = (uint8_t*)data->data;
+#ifndef NDEBUG
+        assert(jl_typeis(data, jl_array_uint8_type));
+        int b3 = d[1];
+        int b2 = d[2];
+        int b1 = d[3];
+        int b0 = d[4];
+        int nslots = b0 | (b1<<8) | (b2<<16) | (b3<<24);
+        assert(nslots >= nargs);
+#endif
+        char *namestr = (char*)d + 5;
+        for (i = 0; i < nargs; i++) {
+            size_t namelen = strlen(namestr);
+            jl_sym_t *name = jl_symbol_n(namestr, namelen);
+            jl_array_ptr_set(names, i, name);
+            namestr += namelen + 1;
+        }
+    }
 }
 
 JL_DLLEXPORT int jl_save_incremental(const char *fname, jl_array_t *worklist)
@@ -2666,24 +2253,31 @@ JL_DLLEXPORT int jl_save_incremental(const char *fname, jl_array_t *worklist)
                         // best to keep it early (before any actual initialization)
 
     arraylist_new(&reinit_list, 0);
+    htable_new(&edges_map, 0);
     htable_new(&backref_table, 5000);
     ptrhash_put(&backref_table, jl_main_module, (char*)HT_NOTFOUND + 1);
     backref_table_numel = 1;
     jl_idtable_type = jl_base_module ? jl_get_global(jl_base_module, jl_symbol("ObjectIdDict")) : NULL;
 
-    int en = jl_gc_enable(0);
+    int en = jl_gc_enable(0); // edges map is not gc-safe
+    jl_array_t *lambdas = jl_alloc_vec_any(0);
+    jl_array_t *edges = jl_alloc_vec_any(0);
+    jl_collect_lambdas_from_mod(lambdas, jl_main_module);
+    jl_collect_backedges(edges);
+
     jl_serializer_state s = {
         &f, MODE_MODULE,
         NULL, NULL,
         jl_get_ptls_states()
     };
     jl_serialize_value(&s, worklist);
-    jl_serialize_lambdas_from_mod(&s, jl_main_module);
-    jl_serialize_value(&s, NULL); // signal end of lambdas
+    jl_serialize_value(&s, lambdas);
+    jl_serialize_value(&s, edges);
     jl_finalize_serializer(&s); // done with f
     serializer_worklist = NULL;
 
     jl_gc_enable(en);
+    htable_reset(&edges_map, 0);
     htable_reset(&backref_table, 0);
     arraylist_free(&reinit_list);
     ios_close(&f);
@@ -2696,6 +2290,15 @@ JL_DLLEXPORT int jl_save_incremental(const char *fname, jl_array_t *worklist)
     return 0;
 }
 
+#ifndef NDEBUG
+// skip the performance optimizations of jl_types_equal and just use subtyping directly
+// one of these types is invalid - that's why we're doing the recache type operation
+static int jl_invalid_types_equal(jl_datatype_t *a, jl_datatype_t *b)
+{
+    return jl_subtype((jl_value_t*)a, (jl_value_t*)b) && jl_subtype((jl_value_t*)b, (jl_value_t*)a);
+}
+#endif
+
 static jl_datatype_t *jl_recache_type(jl_datatype_t *dt, size_t start, jl_value_t *v)
 {
     if (v == NULL)
@@ -2710,7 +2313,7 @@ static jl_datatype_t *jl_recache_type(jl_datatype_t *dt, size_t start, jl_value_
                 if (p->uid == -1 || p->uid == 0) {
                     jl_datatype_t *cachep = jl_recache_type(p, start, NULL);
                     if (p != cachep) {
-                        assert(jl_types_equal((jl_value_t*)p, (jl_value_t*)cachep));
+                        assert(jl_invalid_types_equal(p, cachep));
                         jl_svecset(tt, i, cachep);
                     }
                 }
@@ -2739,7 +2342,7 @@ static jl_datatype_t *jl_recache_type(jl_datatype_t *dt, size_t start, jl_value_
         else {
             dt->uid = 0;
             t = (jl_datatype_t*)jl_cache_type_(dt);
-            assert(jl_types_equal((jl_value_t*)t, (jl_value_t*)dt));
+            assert(jl_invalid_types_equal(t, dt));
         }
     }
     else {
@@ -2862,26 +2465,39 @@ static void jl_update_backref_list(jl_value_t *old, jl_value_t *_new, size_t sta
     }
 }
 
-jl_method_t *jl_recache_method(jl_method_t *m, size_t start)
+// repeatedly look up older methods until we come to one that existed
+// at the time this module was serialized
+static jl_method_t *jl_lookup_method_worldset(jl_methtable_t *mt, jl_datatype_t *sig, arraylist_t *dependent_worlds)
+{
+    size_t world = jl_world_counter;
+    jl_method_t *_new;
+    while (1) {
+        _new = (jl_method_t*)jl_methtable_lookup(mt, sig, world);
+        assert(_new && jl_is_method(_new));
+        world = lowerbound_dependent_world_set(_new->min_world, dependent_worlds);
+        if (world == _new->min_world)
+            return _new;
+    }
+}
+
+static jl_method_t *jl_recache_method(jl_method_t *m, size_t start, arraylist_t *dependent_worlds)
 {
     jl_datatype_t *sig = (jl_datatype_t*)m->sig;
     jl_datatype_t *ftype = jl_first_argument_datatype((jl_value_t*)sig);
     jl_methtable_t *mt = ftype->name->mt;
     jl_set_typeof(m, (void*)(intptr_t)0x30); // invalidate the old value to help catch errors
-    jl_method_t *_new = (jl_method_t*)jl_methtable_lookup(mt, sig, /*TODO*/jl_world_counter);
-    assert(_new && jl_is_method(_new));
+    jl_method_t *_new = jl_lookup_method_worldset(mt, sig, dependent_worlds);
     jl_update_backref_list((jl_value_t*)m, (jl_value_t*)_new, start);
     return _new;
 }
 
-jl_method_instance_t *jl_recache_method_instance(jl_method_instance_t *li, size_t start)
+static jl_method_instance_t *jl_recache_method_instance(jl_method_instance_t *li, size_t start, arraylist_t *dependent_worlds)
 {
-    jl_datatype_t *sig = (jl_datatype_t*)li->def;
+    jl_datatype_t *sig = (jl_datatype_t*)li->def.value;
     assert(jl_is_datatype(sig) || jl_is_unionall(sig));
     jl_datatype_t *ftype = jl_first_argument_datatype((jl_value_t*)sig);
     jl_methtable_t *mt = ftype->name->mt;
-    jl_method_t *m = (jl_method_t*)jl_methtable_lookup(mt, sig, /*TODO*/jl_world_counter);
-    assert(m && jl_is_method(m));
+    jl_method_t *m = jl_lookup_method_worldset(mt, sig, dependent_worlds);
 
     jl_datatype_t *argtypes = (jl_datatype_t*)li->specTypes;
     jl_set_typeof(li, (void*)(intptr_t)0x40); // invalidate the old value to help catch errors
@@ -2890,12 +2506,12 @@ jl_method_instance_t *jl_recache_method_instance(jl_method_instance_t *li, size_
     //assert(ti != jl_bottom_type); (void)ti;
     if (ti == jl_bottom_type)
         env = jl_emptysvec; // the intersection may fail now if the type system had made an incorrect subtype env in the past
-    jl_method_instance_t *_new = jl_specializations_get_linfo(m, (jl_value_t*)argtypes, env, /*TODO*/jl_world_counter);
+    jl_method_instance_t *_new = jl_specializations_get_linfo(m, (jl_value_t*)argtypes, env, jl_world_counter);
     jl_update_backref_list((jl_value_t*)li, (jl_value_t*)_new, start);
     return _new;
 }
 
-static void jl_recache_other(void)
+static void jl_recache_other(arraylist_t *dependent_worlds)
 {
     size_t i = 0;
     while (i < flagref_list.len) {
@@ -2905,11 +2521,11 @@ static void jl_recache_other(void)
         i += 2;
         if (jl_is_method(o)) {
             // lookup the real Method based on the placeholder sig
-            _new = (jl_value_t*)jl_recache_method((jl_method_t*)o, i);
+            _new = (jl_value_t*)jl_recache_method((jl_method_t*)o, i, dependent_worlds);
         }
         else if (jl_is_method_instance(o)) {
             // lookup the real MethodInstance based on the placeholder specTypes
-            _new = (jl_value_t*)jl_recache_method_instance((jl_method_instance_t*)o, i);
+            _new = (jl_value_t*)jl_recache_method_instance((jl_method_instance_t*)o, i, dependent_worlds);
         }
         else {
             abort();
@@ -2930,6 +2546,7 @@ static int trace_method(jl_typemap_entry_t *entry, void *closure)
 
 static jl_value_t *_jl_restore_incremental(ios_t *f)
 {
+    jl_ptls_t ptls = jl_get_ptls_states();
     if (ios_eof(f) || !jl_read_verify_header(f)) {
         ios_close(f);
         return jl_get_exceptionf(jl_errorexception_type,
@@ -2945,33 +2562,41 @@ static jl_value_t *_jl_restore_incremental(ios_t *f)
         ios_skip(f, deplen);
     }
 
+    // list of world counters of incremental dependencies
+    arraylist_t dependent_worlds;
+    arraylist_new(&dependent_worlds, 0);
+
     // verify that the system state is valid
-    jl_value_t *verify_error = read_verify_mod_list(f);
+    jl_value_t *verify_error = read_verify_mod_list(f, &dependent_worlds);
     if (verify_error) {
+        arraylist_free(&dependent_worlds);
         ios_close(f);
         return verify_error;
     }
 
     // prepare to deserialize
+    int en = jl_gc_enable(0);
+    jl_gc_enable_finalizers(ptls, 0);
+    ++jl_world_counter; // reserve a world age for the deserialization
+
     arraylist_new(&backref_list, 4000);
     arraylist_push(&backref_list, jl_main_module);
     arraylist_new(&flagref_list, 0);
+    arraylist_push(&dependent_worlds, (void*)jl_world_counter);
+    arraylist_push(&dependent_worlds, (void*)jl_main_module->primary_world);
+    qsort(dependent_worlds.items, dependent_worlds.len, sizeof(size_t), size_isgreater);
 
-    int en = jl_gc_enable(0);
-    ++jl_world_counter; // reserve a world age for the deserialization
     jl_serializer_state s = {
         f, MODE_MODULE,
         NULL, NULL,
-        jl_get_ptls_states()
+        ptls
     };
-    jl_array_t *restored = NULL;
-    jl_array_t *init_order = NULL;
-    restored = (jl_array_t*)jl_deserialize_value(&s, (jl_value_t**)&restored);
+    jl_array_t *restored = (jl_array_t*)jl_deserialize_value(&s, (jl_value_t**)&restored);
     serializer_worklist = restored;
 
     // get list of external generic functions
-    linkedlist_t external_methods;
-    jl_deserialize_methods_from_mod(&s, &external_methods);
+    jl_value_t *external_methods = jl_deserialize_value(&s, &external_methods);
+    jl_value_t *external_backedges = jl_deserialize_value(&s, &external_backedges);
 
     arraylist_t *tracee_list = NULL;
     if (jl_newmeth_tracer)
@@ -2980,19 +2605,22 @@ static jl_value_t *_jl_restore_incremental(ios_t *f)
     // at this point, the AST is fully reconstructed, but still completely disconnected
     // now all of the interconnects will be created
     jl_recache_types(); // make all of the types identities correct
-    init_order = jl_finalize_deserializer(&s, tracee_list); // done with f and s (needs to be after recache types)
-    jl_insert_methods(&external_methods); // hook up methods of external generic functions (needs to be after recache types)
-    jl_recache_other(); // make all of the other objects identities correct (needs to be after insert methods)
-    jl_insert_backedges(&external_methods); // restore external backedges (needs to be after recache other)
-    free_linkedlist(external_methods.next);
-    serializer_worklist = NULL;
+    jl_insert_methods((jl_array_t*)external_methods); // hook up methods of external generic functions (needs to be after recache types)
+    jl_recache_other(&dependent_worlds); // make all of the other objects identities correct (needs to be after insert methods)
+    jl_array_t *init_order = jl_finalize_deserializer(&s, tracee_list); // done with f and s (needs to be after recache)
 
-    JL_GC_PUSH2(&init_order, &restored);
-    jl_gc_enable(en);
+    JL_GC_PUSH3(&init_order, &restored, &external_backedges);
+    jl_gc_enable(en); // subtyping can allocate a lot, not valid before recache-other
+
+    jl_insert_backedges((jl_array_t*)external_backedges, &dependent_worlds); // restore external backedges (needs to be last)
+
+    serializer_worklist = NULL;
     arraylist_free(&flagref_list);
     arraylist_free(&backref_list);
+    arraylist_free(&dependent_worlds);
     ios_close(f);
 
+    jl_gc_enable_finalizers(ptls, 1); // make sure we don't run any Julia code concurrently before this point
     if (tracee_list) {
         jl_methtable_t *mt;
         while ((mt = (jl_methtable_t*)arraylist_pop(tracee_list)) != NULL)
@@ -3030,7 +2658,6 @@ void jl_init_serializer(void)
     jl_ptls_t ptls = jl_get_ptls_states();
     htable_new(&ser_tag, 0);
     htable_new(&common_symbol_tag, 0);
-    htable_new(&fptr_to_id, sizeof(id_to_fptrs)/sizeof(*id_to_fptrs));
     htable_new(&backref_table, 0);
 
     void *tags[] = { jl_symbol_type, jl_ssavalue_type, jl_datatype_type, jl_slotnumber_type,
@@ -3045,7 +2672,7 @@ void jl_init_serializer(void)
 
                      jl_emptysvec, jl_emptytuple, jl_false, jl_true, jl_nothing, jl_any_type,
                      call_sym, invoke_sym, goto_ifnot_sym, return_sym, body_sym, line_sym,
-                     lambda_sym, jl_symbol("tuple"), assign_sym,
+                     lambda_sym, jl_symbol("tuple"), assign_sym, isdefined_sym,
 
                      // empirical list of very common symbols
                      #include "common_symbols1.inc"
@@ -3090,7 +2717,7 @@ void jl_init_serializer(void)
                      jl_voidpointer_type, jl_newvarnode_type, jl_abstractstring_type,
                      jl_array_symbol_type, jl_anytuple_type, jl_tparam0(jl_anytuple_type),
                      jl_emptytuple_type, jl_array_uint8_type, jl_symbol_type->name,
-                     jl_ssavalue_type->name, jl_tuple_typename, jl_code_info_type, jl_bottomtype_type,
+                     jl_ssavalue_type->name, jl_tuple_typename, jl_code_info_type, jl_typeofbottom_type,
                      ((jl_datatype_t*)jl_unwrap_unionall((jl_value_t*)jl_ref_type))->name,
                      jl_pointer_typename, jl_simplevector_type->name, jl_datatype_type->name,
                      jl_uniontype_type->name, jl_array_typename, jl_expr_type->name,
@@ -3103,7 +2730,7 @@ void jl_init_serializer(void)
                      jl_abstractslot_type->name, jl_slotnumber_type->name, jl_unionall_type->name,
                      jl_intrinsic_type->name, jl_task_type->name, jl_labelnode_type->name,
                      jl_linenumbernode_type->name, jl_builtin_type->name, jl_gotonode_type->name,
-                     jl_quotenode_type->name, jl_globalref_type->name, jl_bottomtype_type->name,
+                     jl_quotenode_type->name, jl_globalref_type->name, jl_typeofbottom_type->name,
                      jl_string_type->name, jl_abstractstring_type->name,
 
                      ptls->root_task,
@@ -3125,12 +2752,6 @@ void jl_init_serializer(void)
     assert(i <= Null_tag);
     VALUE_TAGS = (intptr_t)ptrhash_get(&ser_tag, jl_emptysvec);
 
-    i=2;
-    while (id_to_fptrs[i] != NULL) {
-        ptrhash_put(&fptr_to_id, (void*)id_to_fptrs[i], (void*)i);
-        i += 1;
-    }
-
     i=2;
     while (common_symbols[i-2] != NULL) {
         ptrhash_put(&common_symbol_tag, common_symbols[i-2], (void*)i);
diff --git a/src/file_constants.h b/src/file_constants.h
index 27f6b0bc4cdded..846404befd2fdf 100644
--- a/src/file_constants.h
+++ b/src/file_constants.h
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include <sys/types.h>
 #include <sys/stat.h>
diff --git a/src/fix_llvm_assert.h b/src/fix_llvm_assert.h
new file mode 100644
index 00000000000000..776b127c15846d
--- /dev/null
+++ b/src/fix_llvm_assert.h
@@ -0,0 +1,16 @@
+// This file is a part of Julia. License is MIT: https://julialang.org/license
+
+// Include this file after every blocks of LLVM includes to set the assertion back.
+
+#ifdef NDEBUG
+#  ifndef JL_NDEBUG
+#    undef NDEBUG
+#    include <assert.h>
+// Set NDEBUG back so that we can include another LLVM header right after
+#    define NDEBUG
+#  endif
+#else
+#  ifdef JL_NDEBUG
+#    undef JL_NDEBUG
+#  endif
+#endif
diff --git a/src/flisp/cvalues.c b/src/flisp/cvalues.c
index 9116835dfc721e..7da97f7b28c543 100644
--- a/src/flisp/cvalues.c
+++ b/src/flisp/cvalues.c
@@ -780,7 +780,7 @@ value_t cbuiltin(fl_context_t *fl_ctx, const char *name, builtin_t f)
     cv->type = fl_ctx->builtintype;
     cv->data = &cv->_space[0];
     cv->len = sizeof(value_t);
-    *(void**)cv->data = (void*)f;
+    *(void**)cv->data = (void*)(uintptr_t)f;
 
     value_t sym = symbol(fl_ctx, name);
     ((symbol_t*)ptr(sym))->dlcache = cv;
diff --git a/src/flisp/equalhash.h b/src/flisp/equalhash.h
index e4d0379c35f21b..88b8ad9e0aa1ef 100644
--- a/src/flisp/equalhash.h
+++ b/src/flisp/equalhash.h
@@ -1,5 +1,5 @@
-#ifndef EQUALHASH_H
-#define EQUALHASH_H
+#ifndef JL_EQUALHASH_H
+#define JL_EQUALHASH_H
 
 #include "htable.h"
 
diff --git a/src/flisp/flisp.c b/src/flisp/flisp.c
index fd9cbd641f7c3c..fe25401f074210 100644
--- a/src/flisp/flisp.c
+++ b/src/flisp/flisp.c
@@ -1020,7 +1020,7 @@ static uint32_t process_keys(fl_context_t *fl_ctx, value_t kwtable,
   - allocate vararg array
   - push closed env, set up new environment
 */
-static value_t apply_cl(fl_context_t *fl_ctx, uint32_t nargs)
+JL_EXTENSION static value_t apply_cl(fl_context_t *fl_ctx, uint32_t nargs)
 {
     VM_LABELS;
     VM_APPLY_LABELS;
@@ -1173,7 +1173,7 @@ static value_t apply_cl(fl_context_t *fl_ctx, uint32_t nargs)
             }
             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_apply_v = ((builtin_t)(uintptr_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;
@@ -1223,7 +1223,7 @@ static value_t apply_cl(fl_context_t *fl_ctx, uint32_t nargs)
             }
             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_apply_v = ((builtin_t)(uintptr_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;
diff --git a/src/flisp/flisp.h b/src/flisp/flisp.h
index ff114048d48b15..c5c122afda7a7f 100644
--- a/src/flisp/flisp.h
+++ b/src/flisp/flisp.h
@@ -248,7 +248,7 @@ typedef struct _fltype_t {
     cvinitfunc_t init;
 } fltype_t;
 
-typedef struct {
+JL_EXTENSION typedef struct {
     fltype_t *type;
     void *data;
     size_t len;            // length of *data in bytes
diff --git a/src/flisp/opcodes.h b/src/flisp/opcodes.h
index d888627689e8ec..38d046bf2cda76 100644
--- a/src/flisp/opcodes.h
+++ b/src/flisp/opcodes.h
@@ -1,5 +1,5 @@
-#ifndef OPCODES_H
-#define OPCODES_H
+#ifndef JL_OPCODES_H
+#define JL_OPCODES_H
 
 enum {
     OP_NOP=0, OP_DUP, OP_POP, OP_CALL, OP_TCALL, OP_JMP, OP_BRF, OP_BRT,
diff --git a/src/flisp/print.c b/src/flisp/print.c
index d12cbf0f37338e..4df26309b55ffa 100644
--- a/src/flisp/print.c
+++ b/src/flisp/print.c
@@ -448,6 +448,7 @@ void fl_print_child(fl_context_t *fl_ctx, ios_t *f, value_t v)
     case TAG_CVALUE:
     case TAG_CPRIM:
         if (v == UNBOUND) { outs(fl_ctx, "#<undefined>", f); break; }
+        JL_FALLTHROUGH;
     case TAG_VECTOR:
     case TAG_CONS:
         if (print_circle_prefix(fl_ctx, f, v)) break;
@@ -641,10 +642,10 @@ static void cvalue_printdata(fl_context_t *fl_ctx, ios_t *f, void *data,
             if (init == 0) {
 #if defined(RTLD_SELF)
                 jl_static_print = (size_t (*)(ios_t*, void*))
-                    dlsym(RTLD_SELF, "jl_static_show");
+                    (uintptr_t)dlsym(RTLD_SELF, "jl_static_show");
 #elif defined(RTLD_DEFAULT)
                 jl_static_print = (size_t (*)(ios_t*, void*))
-                    dlsym(RTLD_DEFAULT, "jl_static_show");
+                    (uintptr_t)dlsym(RTLD_DEFAULT, "jl_static_show");
 #elif defined(_OS_WINDOWS_)
                 HMODULE handle;
                 if (GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS |
@@ -652,7 +653,7 @@ static void cvalue_printdata(fl_context_t *fl_ctx, ios_t *f, void *data,
                                        (LPCWSTR)(&cvalue_printdata),
                                        &handle)) {
                     jl_static_print = (size_t (*)(ios_t*, void*))
-                        GetProcAddress(handle, "jl_static_show");
+                        (uintptr_t)GetProcAddress(handle, "jl_static_show");
                 }
 #endif
                 init = 1;
@@ -747,8 +748,7 @@ static void cvalue_print(fl_context_t *fl_ctx, ios_t *f, value_t v)
         void *fptr = *(void**)data;
         label = (value_t)ptrhash_get(&fl_ctx->reverse_dlsym_lookup_table, cv);
         if (label == (value_t)HT_NOTFOUND) {
-            fl_ctx->HPOS += ios_printf(f, "#<builtin @0x%08zx>",
-                                  (size_t)(builtin_t)fptr);
+            fl_ctx->HPOS += ios_printf(f, "#<builtin @0x%08zx>", (size_t)fptr);
         }
         else {
             if (fl_ctx->print_princ) {
diff --git a/src/flisp/read.c b/src/flisp/read.c
index 6eec757a842949..2b57688cd86be8 100644
--- a/src/flisp/read.c
+++ b/src/flisp/read.c
@@ -516,7 +516,12 @@ static value_t read_string(fl_context_t *fl_ctx)
                     i += u8_wc_toutf8(&buf[i], wc);
             }
             else {
-                buf[i++] = read_escape_control_char((char)c);
+                char esc = read_escape_control_char((char)c);
+                if (esc == (char)c && !strchr("\\'\"$`", esc)) {
+                    free(buf);
+                    lerror(fl_ctx, fl_ctx->ParseError, "read: invalid escape sequence");
+                }
+                buf[i++] = esc;
             }
         }
         else {
diff --git a/src/gc-debug.c b/src/gc-debug.c
index d1502b6459542f..0e59a5594575ee 100644
--- a/src/gc-debug.c
+++ b/src/gc-debug.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include "gc.h"
 #include <inttypes.h>
@@ -14,17 +14,12 @@
 extern "C" {
 #endif
 
-// Useful function in debugger to find page/region metadata
+// Useful function in debugger to find page metadata
 jl_gc_pagemeta_t *jl_gc_page_metadata(void *data)
 {
     return page_metadata(data);
 }
 
-region_t *jl_gc_find_region(void *ptr)
-{
-    return find_region(ptr);
-}
-
 // Find the memory block in the pool that owns the byte pointed to by p.
 // For end of object pointer (which is always the case for pointer to a
 // singleton object), this usually returns the same pointer which points to
@@ -32,21 +27,19 @@ region_t *jl_gc_find_region(void *ptr)
 // the end of the page.
 JL_DLLEXPORT jl_taggedvalue_t *jl_gc_find_taggedvalue_pool(char *p, size_t *osize_p)
 {
-    region_t *r = find_region(p);
-    // Not in the pool
-    if (!r)
+    if (!page_metadata(p))
+        // Not in the pool
         return NULL;
+    struct jl_gc_metadata_ext info = page_metadata_ext(p);
     char *page_begin = gc_page_data(p) + GC_PAGE_OFFSET;
     // In the page header
     if (p < page_begin)
         return NULL;
     size_t ofs = p - page_begin;
-    int pg_idx = page_index(r, page_begin);
     // Check if this is a free page
-    if (!(r->allocmap[pg_idx / 32] & (uint32_t)(1 << (pg_idx % 32))))
+    if (!(info.pagetable0->allocmap[info.pagetable0_i32] & (uint32_t)(1 << info.pagetable0_i)))
         return NULL;
-    jl_gc_pagemeta_t *pagemeta = &r->meta[pg_idx];
-    int osize = pagemeta->osize;
+    int osize = info.meta->osize;
     // Shouldn't be needed, just in case
     if (osize == 0)
         return NULL;
@@ -104,6 +97,61 @@ void add_lostval_parent(jl_value_t *parent)
 // the error is caught at the first long collection
 static arraylist_t bits_save[4];
 
+static void gc_clear_mark_page(jl_gc_pagemeta_t *pg, int bits)
+{
+    jl_ptls_t ptls2 = jl_all_tls_states[pg->thread_n];
+    jl_gc_pool_t *pool = &ptls2->heap.norm_pools[pg->pool_n];
+    jl_taggedvalue_t *pv = (jl_taggedvalue_t*)(pg->data + GC_PAGE_OFFSET);
+    char *lim = (char*)pv + GC_PAGE_SZ - GC_PAGE_OFFSET - pool->osize;
+    while ((char*)pv <= lim) {
+        if (!gc_verifying)
+            arraylist_push(&bits_save[pv->bits.gc], pv);
+        pv->bits.gc = bits;
+        pv = (jl_taggedvalue_t*)((char*)pv + pool->osize);
+    }
+}
+
+static void gc_clear_mark_pagetable0(pagetable0_t *pagetable0, int bits)
+{
+    for (int pg_i = 0; pg_i < REGION0_PG_COUNT / 32; pg_i++) {
+        uint32_t line = pagetable0->allocmap[pg_i];
+        if (line) {
+            for (int j = 0; j < 32; j++) {
+                if ((line >> j) & 1) {
+                    gc_clear_mark_page(pagetable0->meta[pg_i * 32 + j], bits);
+                }
+            }
+        }
+    }
+}
+
+static void gc_clear_mark_pagetable1(pagetable1_t *pagetable1, int bits)
+{
+    for (int pg_i = 0; pg_i < REGION1_PG_COUNT / 32; pg_i++) {
+        uint32_t line = pagetable1->allocmap0[pg_i];
+        if (line) {
+            for (int j = 0; j < 32; j++) {
+                if ((line >> j) & 1) {
+                    gc_clear_mark_pagetable0(pagetable1->meta0[pg_i * 32 + j], bits);
+                }
+            }
+        }
+    }
+}
+
+static void gc_clear_mark_pagetable(int bits)
+{
+    for (int pg_i = 0; pg_i < (REGION2_PG_COUNT + 31) / 32; pg_i++) {
+        uint32_t line = memory_map.allocmap1[pg_i];
+        if (line) {
+            for (int j = 0; j < 32; j++) {
+                if ((line >> j) & 1) {
+                    gc_clear_mark_pagetable1(memory_map.meta1[pg_i * 32 + j], bits);
+                }
+            }
+        }
+    }
+}
 // set all mark bits to bits
 // record the state of the region and can replay it in restore()
 // restore _must_ be called as this will overwrite parts of the
@@ -120,7 +168,8 @@ static void clear_mark(int bits)
         v = jl_all_tls_states[i]->heap.big_objects;
         while (v != NULL) {
             void *gcv = &v->header;
-            if (!gc_verifying) arraylist_push(&bits_save[v->bits.gc], gcv);
+            if (!gc_verifying)
+                arraylist_push(&bits_save[v->bits.gc], gcv);
             v->bits.gc = bits;
             v = v->next;
         }
@@ -129,42 +178,19 @@ static void clear_mark(int bits)
     v = big_objects_marked;
     while (v != NULL) {
         void *gcv = &v->header;
-        if (!gc_verifying) arraylist_push(&bits_save[v->bits.gc], gcv);
+        if (!gc_verifying)
+            arraylist_push(&bits_save[v->bits.gc], gcv);
         v->bits.gc = bits;
         v = v->next;
     }
 
-    jl_taggedvalue_t *pv;
-    for (int h = 0; h < REGION_COUNT; h++) {
-        region_t *region = &regions[h];
-        if (!region->pages)
-            break;
-        for (int pg_i = 0; pg_i < region->pg_cnt / 32; pg_i++) {
-            uint32_t line = region->allocmap[pg_i];
-            if (line) {
-                for (int j = 0; j < 32; j++) {
-                    if ((line >> j) & 1) {
-                        jl_gc_pagemeta_t *pg = page_metadata(region->pages[pg_i*32 + j].data + GC_PAGE_OFFSET);
-                        jl_ptls_t ptls2 = jl_all_tls_states[pg->thread_n];
-                        jl_gc_pool_t *pool = &ptls2->heap.norm_pools[pg->pool_n];
-                        pv = (jl_taggedvalue_t*)(pg->data + GC_PAGE_OFFSET);
-                        char *lim = (char*)pv + GC_PAGE_SZ - GC_PAGE_OFFSET - pool->osize;
-                        while ((char*)pv <= lim) {
-                            if (!gc_verifying) arraylist_push(&bits_save[pv->bits.gc], pv);
-                            pv->bits.gc = bits;
-                            pv = (jl_taggedvalue_t*)((char*)pv + pool->osize);
-                        }
-                    }
-                }
-            }
-        }
-    }
+    gc_clear_mark_pagetable(bits);
 }
 
 static void restore(void)
 {
-    for(int b = 0; b < 4; b++) {
-        for(int i = 0; i < bits_save[b].len; i++) {
+    for (int b = 0; b < 4; b++) {
+        for (int i = 0; i < bits_save[b].len; i++) {
             ((jl_taggedvalue_t*)bits_save[b].items[i])->bits.gc = b;
         }
     }
@@ -172,18 +198,21 @@ static void restore(void)
 
 static void gc_verify_track(jl_ptls_t ptls)
 {
+    jl_gc_mark_cache_t *gc_cache = &ptls->gc_cache;
     do {
+        gc_mark_sp_t sp;
+        gc_mark_sp_init(gc_cache, &sp);
         arraylist_push(&lostval_parents_done, lostval);
         jl_printf(JL_STDERR, "Now looking for %p =======\n", lostval);
         clear_mark(GC_CLEAN);
-        mark_all_roots(ptls);
-        gc_mark_object_list(ptls, &to_finalize, 0);
+        gc_mark_queue_all_roots(ptls, &sp);
+        gc_mark_queue_finlist(gc_cache, &sp, &to_finalize, 0);
         for (int i = 0;i < jl_n_threads;i++) {
             jl_ptls_t ptls2 = jl_all_tls_states[i];
-            gc_mark_object_list(ptls, &ptls2->finalizers, 0);
+            gc_mark_queue_finlist(gc_cache, &sp, &ptls2->finalizers, 0);
         }
-        gc_mark_object_list(ptls, &finalizer_list_marked, 0);
-        visit_mark_stack(ptls);
+        gc_mark_queue_finlist(gc_cache, &sp, &finalizer_list_marked, 0);
+        gc_mark_loop(ptls, sp);
         if (lostval_parents.len == 0) {
             jl_printf(JL_STDERR, "Could not find the missing link. We missed a toplevel root. This is odd.\n");
             break;
@@ -217,19 +246,22 @@ static void gc_verify_track(jl_ptls_t ptls)
 
 void gc_verify(jl_ptls_t ptls)
 {
+    jl_gc_mark_cache_t *gc_cache = &ptls->gc_cache;
+    gc_mark_sp_t sp;
+    gc_mark_sp_init(gc_cache, &sp);
     lostval = NULL;
     lostval_parents.len = 0;
     lostval_parents_done.len = 0;
     clear_mark(GC_CLEAN);
     gc_verifying = 1;
-    mark_all_roots(ptls);
-    gc_mark_object_list(ptls, &to_finalize, 0);
+    gc_mark_queue_all_roots(ptls, &sp);
+    gc_mark_queue_finlist(gc_cache, &sp, &to_finalize, 0);
     for (int i = 0;i < jl_n_threads;i++) {
         jl_ptls_t ptls2 = jl_all_tls_states[i];
-        gc_mark_object_list(ptls, &ptls2->finalizers, 0);
+        gc_mark_queue_finlist(gc_cache, &sp, &ptls2->finalizers, 0);
     }
-    gc_mark_object_list(ptls, &finalizer_list_marked, 0);
-    visit_mark_stack(ptls);
+    gc_mark_queue_finlist(gc_cache, &sp, &finalizer_list_marked, 0);
+    gc_mark_loop(ptls, sp);
     int clean_len = bits_save[GC_CLEAN].len;
     for(int i = 0; i < clean_len + bits_save[GC_OLD].len; i++) {
         jl_taggedvalue_t *v = (jl_taggedvalue_t*)bits_save[i >= clean_len ? GC_OLD : GC_CLEAN].items[i >= clean_len ? i - clean_len : i];
@@ -259,6 +291,115 @@ void gc_verify(jl_ptls_t ptls)
 #ifdef MEMFENCE
 static uint8_t freelist_map[GC_PAGE_SZ / sizeof(void*) / 8];
 static int freelist_zerod;
+
+static void gc_verify_tags_page(jl_gc_pagemeta_t *pg)
+{
+    // for all pages in use
+    int p_n = pg->pool_n;
+    int t_n = pg->thread_n;
+    jl_ptls_t ptls2 = jl_all_tls_states[t_n];
+    jl_gc_pool_t *p = &ptls2->heap.norm_pools[p_n];
+    int osize = pg->osize;
+    char *data = pg->data;
+    char *page_begin = data + GC_PAGE_OFFSET;
+    jl_taggedvalue_t *v = (jl_taggedvalue_t*)page_begin;
+    char *lim = data + GC_PAGE_SZ - osize;
+    // reset the freelist map to zero
+    if (!freelist_zerod) {
+        memset(freelist_map, 0, sizeof(freelist_map));
+        freelist_zerod = 1;
+    }
+    // check for p in new newpages list
+    jl_taggedvalue_t *halfpages = p->newpages;
+    while (halfpages) {
+        char *cur_page = gc_page_data((char*)halfpages - 1);
+        if (cur_page == data) {
+            lim = (char*)halfpages - 1;
+            break;
+        }
+        halfpages = *(jl_taggedvalue_t**)cur_page;
+    }
+    // compute the freelist_map
+    if (pg->nfree) {
+        jl_taggedvalue_t *next = NULL;
+        if (gc_page_data(p->freelist) == data) {
+            // currently allocating on this page
+            next = p->freelist;
+            assert(page_metadata(next)->osize == osize);
+            freelist_zerod = 0;
+        }
+        else if (pg->fl_begin_offset != (uint16_t)-1) {
+            // part of free list exists on this page
+            next = page_pfl_beg(pg);
+            freelist_zerod = 0;
+        }
+        assert(halfpages || next);
+        while (gc_page_data(next) == data) {
+            int obj_idx = (((char*)next) - page_begin) / sizeof(void*);
+            freelist_map[obj_idx / 8] |= 1 << (obj_idx % 7);
+            next = next->next;
+        }
+    }
+    // validate all of the tags on the page
+    while ((char*)v <= lim) {
+        int obj_idx = (((char*)v) - page_begin) / sizeof(void*);
+        int in_freelist = freelist_map[obj_idx / 8] & (1 << (obj_idx % 7));
+        if (!in_freelist) {
+            jl_value_t *dt = jl_typeof(jl_valueof(v));
+            if (dt != (jl_value_t*)jl_buff_tag &&
+                    // the following are used by the deserializer to invalidate objects
+                    v->header != 0x10 && v->header != 0x20 &&
+                    v->header != 0x30 && v->header != 0x40 &&
+                    v->header != 0x50 && v->header != 0x60) {
+                assert(jl_typeof(dt) == (jl_value_t*)jl_datatype_type);
+            }
+        }
+        v = (jl_taggedvalue_t*)((char*)v + osize);
+    }
+}
+
+static void gc_verify_tags_pagetable0(pagetable0_t *pagetable0)
+{
+    for (int pg_i = 0; pg_i < REGION0_PG_COUNT / 32; pg_i++) {
+        uint32_t line = pagetable0->allocmap[pg_i];
+        if (line) {
+            for (int j = 0; j < 32; j++) {
+                if ((line >> j) & 1) {
+                    gc_verify_tags_page(pagetable0->meta[pg_i * 32 + j]);
+                }
+            }
+        }
+    }
+}
+
+static void gc_verify_tags_pagetable1(pagetable1_t *pagetable1)
+{
+    for (int pg_i = 0; pg_i < REGION1_PG_COUNT / 32; pg_i++) {
+        uint32_t line = pagetable1->allocmap0[pg_i];
+        if (line) {
+            for (int j = 0; j < 32; j++) {
+                if ((line >> j) & 1) {
+                    gc_verify_tags_pagetable0(pagetable1->meta0[pg_i * 32 + j]);
+                }
+            }
+        }
+    }
+}
+
+static void gc_verify_tags_pagetable(void)
+{
+    for (int pg_i = 0; pg_i < (REGION2_PG_COUNT + 31) / 32; pg_i++) {
+        uint32_t line = memory_map.allocmap1[pg_i];
+        if (line) {
+            for (int j = 0; j < 32; j++) {
+                if ((line >> j) & 1) {
+                    gc_verify_tags_pagetable1(memory_map.meta1[pg_i * 32 + j]);
+                }
+            }
+        }
+    }
+}
+
 void gc_verify_tags(void)
 {
     // verify the freelist chains look valid
@@ -289,83 +430,9 @@ void gc_verify_tags(void)
         }
     }
 
-
     // verify that all the objects on every page are either valid julia objects
     // or are part of the freelist or are on the allocated half of a page
-    for (int region_i = 0; region_i < REGION_COUNT; region_i++) {
-        if (!regions[region_i].pages)
-            break;
-        region_t *region = &regions[region_i];
-        for (int pg_i = 0; pg_i <= region->ub; pg_i++) {
-            uint32_t line = region->allocmap[pg_i];
-            if (line) {
-                for (int j = 0; j < 32; j++) {
-                    if ((line >> j) & 1) {
-                        // for all pages in use
-                        jl_gc_pagemeta_t *pg = &region->meta[pg_i*32 + j];
-                        int p_n = pg->pool_n;
-                        int t_n = pg->thread_n;
-                        jl_ptls_t ptls2 = jl_all_tls_states[t_n];
-                        jl_gc_pool_t *p = &ptls2->heap.norm_pools[p_n];
-                        int osize = pg->osize;
-                        char *data = pg->data;
-                        char *page_begin = data + GC_PAGE_OFFSET;
-                        jl_taggedvalue_t *v = (jl_taggedvalue_t*)page_begin;
-                        char *lim = data + GC_PAGE_SZ - osize;
-                        // reset the freelist map to zero
-                        if (!freelist_zerod) {
-                            memset(freelist_map, 0, sizeof(freelist_map));
-                            freelist_zerod = 1;
-                        }
-                        // check for p in new newpages list
-                        jl_taggedvalue_t *halfpages = p->newpages;
-                        while (halfpages) {
-                            char *cur_page = gc_page_data((char*)halfpages - 1);
-                            if (cur_page == data) {
-                                lim = (char*)halfpages - 1;
-                                break;
-                            }
-                            halfpages = *(jl_taggedvalue_t**)cur_page;
-                        }
-                        // compute the freelist_map
-                        if (pg->nfree) {
-                            jl_taggedvalue_t *next = NULL;
-                            if (gc_page_data(p->freelist) == data) {
-                                // currently allocating on this page
-                                next = p->freelist;
-                                assert(page_metadata(next)->osize == osize);
-                                freelist_zerod = 0;
-                            }
-                            else if (pg->fl_begin_offset != (uint16_t)-1) {
-                                // part of free list exists on this page
-                                next = page_pfl_beg(pg);
-                                freelist_zerod = 0;
-                            }
-                            assert(halfpages || next);
-                            while (gc_page_data(next) == data) {
-                                int obj_idx = (((char*)next) - page_begin) / sizeof(void*);
-                                freelist_map[obj_idx / 8] |= 1 << (obj_idx % 7);
-                                next = next->next;
-                            }
-                        }
-                        // validate all of the tags on the page
-                        while ((char*)v <= lim) {
-                            int obj_idx = (((char*)v) - page_begin) / sizeof(void*);
-                            int in_freelist = freelist_map[obj_idx / 8] & (1 << (obj_idx % 7));
-                            if (!in_freelist) {
-                                jl_value_t *dt = jl_typeof(jl_valueof(v));
-                                // 0x10 (type) and 0x20 (singleton) are used by the incremental serializer to invalidate objects
-                                if (dt != (jl_value_t*)jl_buff_tag && v->header != 0x10 && v->header != 0x20) {
-                                    assert(jl_typeof(dt) == (jl_value_t*)jl_datatype_type);
-                                }
-                            }
-                            v = (jl_taggedvalue_t*)((char*)v + osize);
-                        }
-                    }
-                }
-            }
-        }
-    }
+    gc_verify_tags_pagetable();
 }
 #endif
 
@@ -585,7 +652,7 @@ void objprofile_count(void *ty, int old, int sz)
 
 void objprofile_reset(void)
 {
-    for(int g=0; g < 3; g++) {
+    for (int g = 0; g < 3; g++) {
         htable_reset(&obj_counts[g], 0);
         htable_reset(&obj_sizes[g], 0);
     }
@@ -666,7 +733,9 @@ void gc_settime_postmark_end(void)
 #endif
 
 #ifdef GC_FINAL_STATS
-#include <malloc.h>
+#ifdef _OS_LINUX_
+#include <malloc.h> // for mallinfo
+#endif
 static double process_t0;
 static size_t max_pg_count = 0;
 static size_t total_freed_bytes = 0;
@@ -694,10 +763,55 @@ void gc_final_pause_end(int64_t t0, int64_t tend)
     total_mark_time += gc_premark_end - t0;
 }
 
+static void gc_stats_pagetable0(pagetable0_t *pagetable0, unsigned *p0)
+{
+    for (int pg_i = 0; pg_i < REGION0_PG_COUNT / 32; pg_i++) {
+        uint32_t line = pagetable0->allocmap[pg_i] | pagetable0->freemap[pg_i];
+        if (line) {
+            for (int j = 0; j < 32; j++) {
+                if ((line >> j) & 1) {
+                    (*p0)++;
+                }
+            }
+        }
+    }
+}
+
+static void gc_stats_pagetable1(pagetable1_t *pagetable1, unsigned *p1, unsigned *p0)
+{
+    for (int pg_i = 0; pg_i < REGION1_PG_COUNT / 32; pg_i++) {
+        uint32_t line = pagetable1->allocmap0[pg_i] | pagetable1->freemap0[pg_i];
+        if (line) {
+            for (int j = 0; j < 32; j++) {
+                if ((line >> j) & 1) {
+                    (*p1)++;
+                    gc_stats_pagetable0(pagetable1->meta0[pg_i * 32 + j], p0);
+                }
+            }
+        }
+    }
+}
+
+static void gc_stats_pagetable(unsigned *p2, unsigned *p1, unsigned *p0)
+{
+    for (int pg_i = 0; pg_i < (REGION2_PG_COUNT + 31) / 32; pg_i++) {
+        uint32_t line = memory_map.allocmap1[pg_i] | memory_map.freemap1[pg_i];
+        if (line) {
+            for (int j = 0; j < 32; j++) {
+                if ((line >> j) & 1) {
+                    (*p2)++;
+                    gc_stats_pagetable1(memory_map.meta1[pg_i * 32 + j], p1, p0);
+                }
+            }
+        }
+    }
+}
+
 void jl_print_gc_stats(JL_STREAM *s)
 {
-    double gct = gc_num.total_time / 1e9;
+#ifdef _OS_LINUX_
     malloc_stats();
+#endif
     double ptime = jl_clock_now() - process_t0;
     jl_printf(s, "exec time\t%.5f sec\n", ptime);
     if (gc_num.pause > 0) {
@@ -713,14 +827,20 @@ void jl_print_gc_stats(JL_STREAM *s)
                   (int)(total_sweep_time * 100 / gc_num.total_time),
                   (int)(total_fin_time * 100 / gc_num.total_time));
     }
-    int i = 0;
-    while (i < REGION_COUNT && regions[i].pages) i++;
-    jl_printf(s, "max allocated regions : %d\n", i);
+    unsigned p2 = 0, p1 = 0, p0 = 0;
+    gc_stats_pagetable(&p2, &p1, &p0);
+    jl_printf(s, "page table max utilization : %u (%.1f%%) - %u (%.1f%%) - %u (%.1f%%)\n",
+              p2, p2 * 100.0 / REGION2_PG_COUNT,
+              p1, p1 * 100.0 / REGION1_PG_COUNT / p2,
+              p0, p0 * 100.0 / REGION0_PG_COUNT / p1);
+#ifdef _OS_LINUX_
+    double gct = gc_num.total_time / 1e9;
     struct mallinfo mi = mallinfo();
-    jl_printf(s, "malloc size\t%d MB\n", mi.uordblks/1024/1024);
-    jl_printf(s, "max page alloc\t%ld MB\n", max_pg_count*GC_PAGE_SZ/1024/1024);
+    jl_printf(s, "malloc size\t%d MB\n", mi.uordblks / 1024 / 1024);
+    jl_printf(s, "max page alloc\t%ld MB\n", max_pg_count * GC_PAGE_SZ / 1024 / 1024);
     jl_printf(s, "total freed\t%" PRIuPTR " b\n", total_freed_bytes);
-    jl_printf(s, "free rate\t%.1f MB/sec\n", (total_freed_bytes/gct)/1024/1024);
+    jl_printf(s, "free rate\t%.1f MB/sec\n", (total_freed_bytes / gct) / 1024 / 1024);
+#endif
 }
 #else
 void jl_print_gc_stats(JL_STREAM *s)
@@ -765,6 +885,14 @@ void gc_time_pool_end(int sweep_full)
               sweep_full ? "full" : "quick");
 }
 
+void gc_time_sysimg_end(uint64_t t0)
+{
+    double sweep_pool_sec = (jl_hrtime() - t0) / 1e9;
+    jl_printf(JL_STDOUT,
+              "GC sweep sysimg end %.2f ms\n",
+              sweep_pool_sec * 1000);
+}
+
 static int64_t big_total;
 static int64_t big_freed;
 static int64_t big_reset;
@@ -788,7 +916,7 @@ void gc_time_count_big(int old_bits, int bits)
 void gc_time_big_end(void)
 {
     double t_ms = jl_ns2ms(jl_hrtime() - big_sweep_start);
-    jl_printf(JL_STDOUT, "GC sweep big %.2f "
+    jl_printf(JL_STDOUT, "GC sweep big %.2f ms "
               "(freed %" PRId64 " / %" PRId64 " with %" PRId64 " rst)\n",
               t_ms, big_freed, big_total, big_reset);
 }
@@ -812,8 +940,8 @@ void gc_time_count_mallocd_array(int bits)
 
 void gc_time_mallocd_array_end(void)
 {
-    double t_ms = jl_ns2ms(jl_hrtime() - big_sweep_start);
-    jl_printf(JL_STDOUT, "GC sweep arrays %.2f "
+    double t_ms = jl_ns2ms(jl_hrtime() - mallocd_array_sweep_start);
+    jl_printf(JL_STDOUT, "GC sweep arrays %.2f ms "
               "(freed %" PRId64 " / %" PRId64 ")\n",
               t_ms, mallocd_array_freed, mallocd_array_total);
 }
@@ -845,7 +973,7 @@ void gc_time_sweep_pause(uint64_t gc_end_t, int64_t actual_allocd,
     int pct = actual_allocd ? (gc_num.freed * 100) / actual_allocd : -1;
     jl_printf(JL_STDOUT, "GC sweep pause %.2f ms live %" PRId64 " kB "
               "(freed %" PRId64 " kB EST %" PRId64 " kB "
-              "[error %" PRId64 "] = %d%% of allocd b %ld) "
+              "[error %" PRId64 "] = %d%% of allocd b %" PRIu64 ") "
               "(%.2f ms in post_mark) %s | next in %" PRId64 " kB\n",
               jl_ns2ms(sweep_pause), live_bytes / 1024,
               gc_num.freed / 1024, estimate_freed / 1024,
@@ -1016,14 +1144,42 @@ static void gc_count_pool_page(jl_gc_pagemeta_t *pg)
     }
 }
 
-static void gc_count_pool_region(region_t *region)
+static void gc_count_pool_pagetable0(pagetable0_t *pagetable0)
 {
-    for (int pg_i = 0; pg_i < region->pg_cnt / 32; pg_i++) {
-        uint32_t line = region->allocmap[pg_i];
+    for (int pg_i = 0; pg_i < REGION0_PG_COUNT / 32; pg_i++) {
+        uint32_t line = pagetable0->allocmap[pg_i];
         if (line) {
             for (int j = 0; j < 32; j++) {
                 if ((line >> j) & 1) {
-                    gc_count_pool_page(&region->meta[pg_i*32 + j]);
+                    gc_count_pool_page(pagetable0->meta[pg_i * 32 + j]);
+                }
+            }
+        }
+    }
+}
+
+static void gc_count_pool_pagetable1(pagetable1_t *pagetable1)
+{
+    for (int pg_i = 0; pg_i < REGION1_PG_COUNT / 32; pg_i++) {
+        uint32_t line = pagetable1->allocmap0[pg_i];
+        if (line) {
+            for (int j = 0; j < 32; j++) {
+                if ((line >> j) & 1) {
+                    gc_count_pool_pagetable0(pagetable1->meta0[pg_i * 32 + j]);
+                }
+            }
+        }
+    }
+}
+
+static void gc_count_pool_pagetable(void)
+{
+    for (int pg_i = 0; pg_i < (REGION2_PG_COUNT + 31) / 32; pg_i++) {
+        uint32_t line = memory_map.allocmap1[pg_i];
+        if (line) {
+            for (int j = 0; j < 32; j++) {
+                if ((line >> j) & 1) {
+                    gc_count_pool_pagetable1(memory_map.meta1[pg_i * 32 + j]);
                 }
             }
         }
@@ -1034,11 +1190,7 @@ void gc_count_pool(void)
 {
     memset(&poolobj_sizes, 0, sizeof(poolobj_sizes));
     empty_pages = 0;
-    for (int i = 0; i < REGION_COUNT; i++) {
-        if (!regions[i].pages)
-            break;
-        gc_count_pool_region(&regions[i]);
-    }
+    gc_count_pool_pagetable();
     jl_safe_printf("****** Pool stat: ******\n");
     for (int i = 0;i < 4;i++)
         jl_safe_printf("bits(%d): %"  PRId64 "\n", i, poolobj_sizes[i]);
@@ -1048,6 +1200,180 @@ void gc_count_pool(void)
     jl_safe_printf("************************\n");
 }
 
+int gc_slot_to_fieldidx(void *obj, void *slot)
+{
+    jl_datatype_t *vt = (jl_datatype_t*)jl_typeof(obj);
+    int nf = (int)jl_datatype_nfields(vt);
+    for (int i = 0; i < nf; i++) {
+        void *fieldaddr = (char*)obj + jl_field_offset(vt, i);
+        if (fieldaddr >= slot) {
+            return i;
+        }
+    }
+    return -1;
+}
+
+int gc_slot_to_arrayidx(void *obj, void *_slot)
+{
+    char *slot = (char*)_slot;
+    jl_datatype_t *vt = (jl_datatype_t*)jl_typeof(obj);
+    char *start = NULL;
+    size_t len = 0;
+    if (vt == jl_module_type) {
+        jl_module_t *m = (jl_module_t*)obj;
+        start = (char*)m->usings.items;
+        len = m->usings.len;
+    }
+    else if (vt == jl_simplevector_type) {
+        start = (char*)jl_svec_data(obj);
+        len = jl_svec_len(obj);
+    }
+    else if (vt->name == jl_array_typename) {
+        jl_array_t *a = (jl_array_t*)obj;
+        if (!a->flags.ptrarray)
+            return -1;
+        start = (char*)a->data;
+        len = jl_array_len(a);
+    }
+    if (slot < start || slot >= start + sizeof(void*) * len)
+        return -1;
+    return (slot - start) / sizeof(void*);
+}
+
+// Print a backtrace from the bottom (start) of the mark stack up to `sp`
+// `pc_offset` will be added to `sp` for convenience in the debugger.
+NOINLINE void gc_mark_loop_unwind(jl_ptls_t ptls, gc_mark_sp_t sp, int pc_offset)
+{
+    jl_jmp_buf *old_buf = ptls->safe_restore;
+    jl_jmp_buf buf;
+    ptls->safe_restore = &buf;
+    if (jl_setjmp(buf, 0) != 0) {
+        jl_printf((JL_STREAM*)STDERR_FILENO,
+                  "\n!!! ERROR when unwinding gc mark loop -- ABORTING !!!\n");
+        ptls->safe_restore = old_buf;
+        return;
+    }
+    void **top = sp.pc + pc_offset;
+    char *data_top = sp.data;
+    sp.data = ptls->gc_cache.data_stack;
+    sp.pc = ptls->gc_cache.pc_stack;
+    int isroot = 1;
+    while (sp.pc < top) {
+        void *pc = *sp.pc;
+        const char *prefix = isroot ? "r--" : " `-";
+        isroot = 0;
+        if (pc == gc_mark_label_addrs[GC_MARK_L_marked_obj]) {
+            gc_mark_marked_obj_t *data = gc_repush_markdata(&sp, gc_mark_marked_obj_t);
+            if ((char*)data > data_top) {
+                jl_safe_printf("Mark stack unwind overflow -- ABORTING !!!\n");
+                break;
+            }
+            jl_safe_printf("%p: Root object: %p :: %p (bits: %d)\n        of type ",
+                           (void*)data, (void*)data->obj, (void*)data->tag, (int)data->bits);
+            jl_((void*)data->tag);
+            isroot = 1;
+        }
+        else if (pc == gc_mark_label_addrs[GC_MARK_L_scan_only]) {
+            gc_mark_marked_obj_t *data = gc_repush_markdata(&sp, gc_mark_marked_obj_t);
+            if ((char*)data > data_top) {
+                jl_safe_printf("Mark stack unwind overflow -- ABORTING !!!\n");
+                break;
+            }
+            jl_safe_printf("%p: Queued root: %p :: %p (bits: %d)\n        of type ",
+                           (void*)data, (void*)data->obj, (void*)data->tag, (int)data->bits);
+            jl_((void*)data->tag);
+            isroot = 1;
+        }
+        else if (pc == gc_mark_label_addrs[GC_MARK_L_finlist]) {
+            gc_mark_finlist_t *data = gc_repush_markdata(&sp, gc_mark_finlist_t);
+            if ((char*)data > data_top) {
+                jl_safe_printf("Mark stack unwind overflow -- ABORTING !!!\n");
+                break;
+            }
+            jl_safe_printf("%p: Finalizer list from %p to %p\n",
+                           (void*)data, (void*)data->begin, (void*)data->end);
+            isroot = 1;
+        }
+        else if (pc == gc_mark_label_addrs[GC_MARK_L_objarray]) {
+            gc_mark_objarray_t *data = gc_repush_markdata(&sp, gc_mark_objarray_t);
+            if ((char*)data > data_top) {
+                jl_safe_printf("Mark stack unwind overflow -- ABORTING !!!\n");
+                break;
+            }
+            jl_safe_printf("%p:  %s Array in object %p :: %p -- [%p, %p)\n        of type ",
+                           (void*)data, prefix, (void*)data->parent, ((void**)data->parent)[-1],
+                           (void*)data->begin, (void*)data->end);
+            jl_(jl_typeof(data->parent));
+        }
+        else if (pc == gc_mark_label_addrs[GC_MARK_L_obj8]) {
+            gc_mark_obj8_t *data = gc_repush_markdata(&sp, gc_mark_obj8_t);
+            if ((char*)data > data_top) {
+                jl_safe_printf("Mark stack unwind overflow -- ABORTING !!!\n");
+                break;
+            }
+            jl_datatype_t *vt = (jl_datatype_t*)jl_typeof(data->parent);
+            jl_fielddesc8_t *desc = (jl_fielddesc8_t*)jl_dt_layout_fields(vt->layout);
+            jl_safe_printf("%p:  %s Object (8bit) %p :: %p -- [%d, %d)\n        of type ",
+                           (void*)data, prefix, (void*)data->parent, ((void**)data->parent)[-1],
+                           (int)(data->begin - desc), (int)(data->end - desc));
+            jl_(jl_typeof(data->parent));
+        }
+        else if (pc == gc_mark_label_addrs[GC_MARK_L_obj16]) {
+            gc_mark_obj16_t *data = gc_repush_markdata(&sp, gc_mark_obj16_t);
+            if ((char*)data > data_top) {
+                jl_safe_printf("Mark stack unwind overflow -- ABORTING !!!\n");
+                break;
+            }
+            jl_datatype_t *vt = (jl_datatype_t*)jl_typeof(data->parent);
+            jl_fielddesc16_t *desc = (jl_fielddesc16_t*)jl_dt_layout_fields(vt->layout);
+            jl_safe_printf("%p:  %s Object (16bit) %p :: %p -- [%d, %d)\n        of type ",
+                           (void*)data, prefix, (void*)data->parent, ((void**)data->parent)[-1],
+                           (int)(data->begin - desc), (int)(data->end - desc));
+            jl_(jl_typeof(data->parent));
+        }
+        else if (pc == gc_mark_label_addrs[GC_MARK_L_obj32]) {
+            gc_mark_obj32_t *data = gc_repush_markdata(&sp, gc_mark_obj32_t);
+            if ((char*)data > data_top) {
+                jl_safe_printf("Mark stack unwind overflow -- ABORTING !!!\n");
+                break;
+            }
+            jl_datatype_t *vt = (jl_datatype_t*)jl_typeof(data->parent);
+            jl_fielddesc32_t *desc = (jl_fielddesc32_t*)jl_dt_layout_fields(vt->layout);
+            jl_safe_printf("%p:  %s Object (32bit) %p :: %p -- [%d, %d)\n        of type ",
+                           (void*)data, prefix, (void*)data->parent, ((void**)data->parent)[-1],
+                           (int)(data->begin - desc), (int)(data->end - desc));
+            jl_(jl_typeof(data->parent));
+        }
+        else if (pc == gc_mark_label_addrs[GC_MARK_L_stack]) {
+            gc_mark_stackframe_t *data = gc_repush_markdata(&sp, gc_mark_stackframe_t);
+            if ((char*)data > data_top) {
+                jl_safe_printf("Mark stack unwind overflow -- ABORTING !!!\n");
+                break;
+            }
+            jl_safe_printf("%p:  %s Stack frame %p -- %d of %d (%s)\n",
+                           (void*)data, prefix, (void*)data->s, (int)data->i,
+                           (int)data->nroots >> 1,
+                           (data->nroots & 1) ? "indirect" : "direct");
+        }
+        else if (pc == gc_mark_label_addrs[GC_MARK_L_module_binding]) {
+            // module_binding
+            gc_mark_binding_t *data = gc_repush_markdata(&sp, gc_mark_binding_t);
+            if ((char*)data > data_top) {
+                jl_safe_printf("Mark stack unwind overflow -- ABORTING !!!\n");
+                break;
+            }
+            jl_safe_printf("%p:  %s Module (bindings) %p (bits %d) -- [%p, %p)\n",
+                           (void*)data, prefix, (void*)data->parent, (int)data->bits,
+                           (void*)data->begin, (void*)data->end);
+        }
+        else {
+            jl_safe_printf("Unknown pc %p --- ABORTING !!!\n", pc);
+            break;
+        }
+    }
+    ptls->safe_restore = old_buf;
+}
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/gc-pages.c b/src/gc-pages.c
index ca549e81074bcb..b0b3feca52c6e9 100644
--- a/src/gc-pages.c
+++ b/src/gc-pages.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include "gc.h"
 #ifndef _OS_WINDOWS_
@@ -9,190 +9,287 @@
 extern "C" {
 #endif
 
-// A region is contiguous storage for up to DEFAULT_REGION_PG_COUNT naturally aligned GC_PAGE_SZ pages
-// It uses a very naive allocator (see jl_gc_alloc_page & jl_gc_free_page)
-#if defined(_P64)
-#define DEFAULT_REGION_PG_COUNT (16 * 8 * 4096) // 8 GB
+// Try to allocate memory in chunks to permit faster allocation
+// and improve memory locality of the pools
+#ifdef _P64
+#define DEFAULT_BLOCK_PG_ALLOC (4096) // 64 MB
 #else
-#define DEFAULT_REGION_PG_COUNT (8 * 4096) // 512 MB
+#define DEFAULT_BLOCK_PG_ALLOC (1024) // 16 MB
 #endif
-#define MIN_REGION_PG_COUNT 64 // 1 MB
+#define MIN_BLOCK_PG_ALLOC (1) // 16 KB
 
-static int region_pg_cnt = DEFAULT_REGION_PG_COUNT;
-static jl_mutex_t pagealloc_lock;
+static int block_pg_cnt = DEFAULT_BLOCK_PG_ALLOC;
 static size_t current_pg_count = 0;
 
 void jl_gc_init_page(void)
 {
-#ifndef _OS_WINDOWS_
-    struct rlimit rl;
-    if (getrlimit(RLIMIT_AS, &rl) == 0) {
-        // This is not 100% precise and not the most efficient implementation
-        // but should be close enough and fast enough for the normal case.
-        while (rl.rlim_cur < region_pg_cnt * sizeof(jl_gc_page_t) * 2 &&
-               region_pg_cnt >= MIN_REGION_PG_COUNT) {
-            region_pg_cnt /= 2;
-        }
-    }
-#endif
+    if (GC_PAGE_SZ * block_pg_cnt < jl_page_size)
+        block_pg_cnt = jl_page_size / GC_PAGE_SZ; // exact division
 }
 
 #ifndef MAP_NORESERVE // not defined in POSIX, FreeBSD, etc.
 #define MAP_NORESERVE (0)
 #endif
 
-// Try to allocate a memory block for a region with `pg_cnt` pages.
+// Try to allocate a memory block for multiple pages
 // Return `NULL` if allocation failed. Result is aligned to `GC_PAGE_SZ`.
-static char *jl_gc_try_alloc_region(int pg_cnt)
+static char *jl_gc_try_alloc_pages(int pg_cnt)
 {
-    const size_t pages_sz = sizeof(jl_gc_page_t) * pg_cnt;
-    const size_t freemap_sz = sizeof(uint32_t) * pg_cnt / 32;
-    const size_t meta_sz = sizeof(jl_gc_pagemeta_t) * pg_cnt;
-    size_t alloc_size = pages_sz + freemap_sz + meta_sz;
+    size_t pages_sz = GC_PAGE_SZ * pg_cnt;
 #ifdef _OS_WINDOWS_
-    char *mem = (char*)VirtualAlloc(NULL, alloc_size + GC_PAGE_SZ,
+    char *mem = (char*)VirtualAlloc(NULL, pages_sz + GC_PAGE_SZ,
                                     MEM_RESERVE, PAGE_READWRITE);
     if (mem == NULL)
         return NULL;
 #else
     if (GC_PAGE_SZ > jl_page_size)
-        alloc_size += GC_PAGE_SZ;
-    char *mem = (char*)mmap(0, alloc_size, PROT_READ | PROT_WRITE,
+        pages_sz += GC_PAGE_SZ;
+    char *mem = (char*)mmap(0, pages_sz, PROT_READ | PROT_WRITE,
                             MAP_NORESERVE | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
     if (mem == MAP_FAILED)
         return NULL;
 #endif
-    if (GC_PAGE_SZ > jl_page_size) {
+    if (GC_PAGE_SZ > jl_page_size)
         // round data pointer up to the nearest gc_page_data-aligned
         // boundary if mmap didn't already do so.
         mem = (char*)gc_page_data(mem + GC_PAGE_SZ - 1);
-    }
     return mem;
 }
 
-// Allocate the memory for a `region_t`. Starts with `region_pg_cnt` number
+// Allocate the memory for a new page. Starts with `block_pg_cnt` number
 // of pages. Decrease 4x every time so that there are enough space for a few.
-// more regions (or other allocations). The final page count is recorded
+// more chunks (or other allocations). The final page count is recorded
 // and will be used as the starting count next time. If the page count is
-// smaller `MIN_REGION_PG_COUNT` a `jl_memory_exception` is thrown.
-// Assume `pagealloc_lock` is acquired, the lock is released before the
+// smaller `MIN_BLOCK_PG_ALLOC` a `jl_memory_exception` is thrown.
+// Assumes `gc_perm_lock` is acquired, the lock is released before the
 // exception is thrown.
-static void jl_gc_alloc_region(region_t *region)
+static jl_gc_pagemeta_t *jl_gc_alloc_new_page(void)
 {
-    int pg_cnt = region_pg_cnt;
+    // try to allocate a large block of memory (or a small one)
+    unsigned pg, pg_cnt = block_pg_cnt;
     char *mem = NULL;
     while (1) {
-        if (__likely((mem = jl_gc_try_alloc_region(pg_cnt))))
+        if (__likely((mem = jl_gc_try_alloc_pages(pg_cnt))))
             break;
-        if (pg_cnt >= MIN_REGION_PG_COUNT * 4) {
+        size_t min_block_pg_alloc = MIN_BLOCK_PG_ALLOC;
+        if (GC_PAGE_SZ * min_block_pg_alloc < jl_page_size)
+            min_block_pg_alloc = jl_page_size / GC_PAGE_SZ; // exact division
+        if (pg_cnt >= 4 * min_block_pg_alloc) {
             pg_cnt /= 4;
-            region_pg_cnt = pg_cnt;
+            block_pg_cnt = pg_cnt;
         }
-        else if (pg_cnt > MIN_REGION_PG_COUNT) {
-            region_pg_cnt = pg_cnt = MIN_REGION_PG_COUNT;
+        else if (pg_cnt > min_block_pg_alloc) {
+            block_pg_cnt = pg_cnt = min_block_pg_alloc;
         }
         else {
-            JL_UNLOCK_NOGC(&pagealloc_lock);
+            JL_UNLOCK_NOGC(&gc_perm_lock);
             jl_throw(jl_memory_exception);
         }
     }
-    const size_t pages_sz = sizeof(jl_gc_page_t) * pg_cnt;
-    const size_t allocmap_sz = sizeof(uint32_t) * pg_cnt / 32;
-    region->pages = (jl_gc_page_t*)mem;
-    region->allocmap = (uint32_t*)(mem + pages_sz);
-    region->meta = (jl_gc_pagemeta_t*)(mem + pages_sz +allocmap_sz);
-    region->lb = 0;
-    region->ub = 0;
-    region->pg_cnt = pg_cnt;
-#ifdef _OS_WINDOWS_
-    VirtualAlloc(region->allocmap, pg_cnt / 8, MEM_COMMIT, PAGE_READWRITE);
-    VirtualAlloc(region->meta, pg_cnt * sizeof(jl_gc_pagemeta_t),
-                 MEM_COMMIT, PAGE_READWRITE);
+
+    // now need to insert these pages into the pagetable metadata
+    // if any allocation fails, this just stops recording more pages from that point
+    // and will free (munmap) the remainder
+    jl_gc_pagemeta_t *page_meta =
+        (jl_gc_pagemeta_t*)jl_gc_perm_alloc_nolock(pg_cnt * sizeof(jl_gc_pagemeta_t), 1,
+                                                   sizeof(void*), 0);
+    pg = 0;
+    if (page_meta) {
+        for (; pg < pg_cnt; pg++) {
+            struct jl_gc_metadata_ext info;
+            uint32_t msk;
+            unsigned i;
+            pagetable1_t **ppagetable1;
+            pagetable0_t **ppagetable0;
+            jl_gc_pagemeta_t **pmeta;
+
+            char *ptr = mem + (GC_PAGE_SZ * pg);
+            page_meta[pg].data = ptr;
+
+            // create & store the level 2 / outermost info
+            i = REGION_INDEX(ptr);
+            info.pagetable_i = i % 32;
+            info.pagetable_i32 = i / 32;
+            msk = (1 << info.pagetable_i);
+            if ((memory_map.freemap1[info.pagetable_i32] & msk) == 0)
+                memory_map.freemap1[info.pagetable_i32] |= msk; // has free
+            info.pagetable1 = *(ppagetable1 = &memory_map.meta1[i]);
+            if (!info.pagetable1) {
+                info.pagetable1 = (pagetable1_t*)jl_gc_perm_alloc_nolock(sizeof(pagetable1_t), 1,
+                                                                         sizeof(void*), 0);
+                *ppagetable1 = info.pagetable1;
+                if (!info.pagetable1)
+                    break;
+            }
+
+            // create & store the level 1 info
+            i = REGION1_INDEX(ptr);
+            info.pagetable1_i = i % 32;
+            info.pagetable1_i32 = i / 32;
+            msk = (1 << info.pagetable1_i);
+            if ((info.pagetable1->freemap0[info.pagetable1_i32] & msk) == 0)
+                info.pagetable1->freemap0[info.pagetable1_i32] |= msk; // has free
+            info.pagetable0 = *(ppagetable0 = &info.pagetable1->meta0[i]);
+            if (!info.pagetable0) {
+                info.pagetable0 = (pagetable0_t*)jl_gc_perm_alloc_nolock(sizeof(pagetable0_t), 1,
+                                                                         sizeof(void*), 0);
+                *ppagetable0 = info.pagetable0;
+                if (!info.pagetable0)
+                    break;
+            }
+
+            // create & store the level 0 / page info
+            i = REGION0_INDEX(ptr);
+            info.pagetable0_i = i % 32;
+            info.pagetable0_i32 = i / 32;
+            msk = (1 << info.pagetable0_i);
+            info.pagetable0->freemap[info.pagetable0_i32] |= msk; // is free
+            pmeta = &info.pagetable0->meta[i];
+            info.meta = (*pmeta = &page_meta[pg]);
+        }
+    }
+
+    if (pg < pg_cnt) {
+#ifndef _OS_WINDOWS_
+        // Trim the allocation to only cover the region
+        // that we successfully created the metadata for.
+        // This is not supported by the Windows kernel,
+        // so we have to just skip it there and just lose these virtual addresses.
+        munmap(mem + LLT_ALIGN(GC_PAGE_SZ * pg, jl_page_size),
+               GC_PAGE_SZ * pg_cnt - LLT_ALIGN(GC_PAGE_SZ * pg, jl_page_size));
 #endif
+        if (pg == 0) {
+            JL_UNLOCK_NOGC(&gc_perm_lock);
+            jl_throw(jl_memory_exception);
+        }
+    }
+    return page_meta;
 }
 
-NOINLINE void *jl_gc_alloc_page(void)
+// get a new page, either from the freemap
+// or from the kernel if none are available
+NOINLINE jl_gc_pagemeta_t *jl_gc_alloc_page(void)
 {
-    int i;
-    region_t *region;
-    int region_i = 0;
-    JL_LOCK_NOGC(&pagealloc_lock);
-    while (region_i < REGION_COUNT) {
-        region = &regions[region_i];
-        if (region->pages == NULL)
-            jl_gc_alloc_region(region);
-        for (i = region->lb; i < region->pg_cnt / 32; i++) {
-            if (~region->allocmap[i])
-                break;
-        }
-        if (i == region->pg_cnt / 32) {
-            // region full
-            region_i++;
-            continue;
+    struct jl_gc_metadata_ext info;
+    JL_LOCK_NOGC(&gc_perm_lock);
+
+    // scan over memory_map page-table for existing allocated but unused pages
+    for (info.pagetable_i32 = memory_map.lb; info.pagetable_i32 < (REGION2_PG_COUNT + 31) / 32; info.pagetable_i32++) {
+        uint32_t freemap1 = memory_map.freemap1[info.pagetable_i32];
+        for (info.pagetable_i = 0; freemap1; info.pagetable_i++, freemap1 >>= 1) {
+            unsigned next = ffs_u32(freemap1);
+            info.pagetable_i += next;
+            freemap1 >>= next;
+            info.pagetable1 = memory_map.meta1[info.pagetable_i + info.pagetable_i32 * 32];
+            // repeat over page-table level 1
+            for (info.pagetable1_i32 = info.pagetable1->lb; info.pagetable1_i32 < REGION1_PG_COUNT / 32; info.pagetable1_i32++) {
+                uint32_t freemap0 = info.pagetable1->freemap0[info.pagetable1_i32];
+                for (info.pagetable1_i = 0; freemap0; info.pagetable1_i++, freemap0 >>= 1) {
+                    unsigned next = ffs_u32(freemap0);
+                    info.pagetable1_i += next;
+                    freemap0 >>= next;
+                    info.pagetable0 = info.pagetable1->meta0[info.pagetable1_i + info.pagetable1_i32 * 32];
+                    // repeat over page-table level 0
+                    for (info.pagetable0_i32 = info.pagetable0->lb; info.pagetable0_i32 < REGION0_PG_COUNT / 32; info.pagetable0_i32++) {
+                        uint32_t freemap = info.pagetable0->freemap[info.pagetable0_i32];
+                        if (freemap) {
+                            info.pagetable0_i = ffs_u32(freemap);
+                            info.meta = info.pagetable0->meta[info.pagetable0_i + info.pagetable0_i32 * 32];
+                            assert(info.meta->data);
+                            // new pages available starting at min of lb and pagetable_i32
+                            if (memory_map.lb < info.pagetable_i32)
+                                memory_map.lb = info.pagetable_i32;
+                            if (info.pagetable1->lb < info.pagetable1_i32)
+                                info.pagetable1->lb = info.pagetable1_i32;
+                            if (info.pagetable0->lb < info.pagetable0_i32)
+                                info.pagetable0->lb = info.pagetable0_i32;
+                            goto have_free_page; // break out of all of these loops
+                        }
+                    }
+                    info.pagetable1->freemap0[info.pagetable1_i32] &= ~(uint32_t)(1 << info.pagetable1_i); // record that this was full
+                }
+            }
+            memory_map.freemap1[info.pagetable_i32] &= ~(uint32_t)(1 << info.pagetable_i); // record that this was full
         }
-        break;
     }
-    if (__unlikely(region_i >= REGION_COUNT)) {
-        JL_UNLOCK_NOGC(&pagealloc_lock);
-        jl_throw(jl_memory_exception);
+
+    // no existing pages found, allocate a new one
+    {
+        jl_gc_pagemeta_t *meta = jl_gc_alloc_new_page();
+        info = page_metadata_ext(meta->data);
+        assert(meta == info.meta);
+        // new pages are now available starting at max of lb and pagetable_i32
+        if (memory_map.lb > info.pagetable_i32)
+            memory_map.lb = info.pagetable_i32;
+        if (info.pagetable1->lb > info.pagetable1_i32)
+            info.pagetable1->lb = info.pagetable1_i32;
+        if (info.pagetable0->lb > info.pagetable0_i32)
+            info.pagetable0->lb = info.pagetable0_i32;
     }
-    if (region->lb < i)
-        region->lb = i;
-    if (region->ub < i)
-        region->ub = i;
-
-#if defined(_COMPILER_MINGW_)
-    int j = __builtin_ffs(~region->allocmap[i]) - 1;
-#elif defined(_COMPILER_MICROSOFT_)
-    unsigned long j;
-    _BitScanForward(&j, ~region->allocmap[i]);
-#else
-    int j = ffs(~region->allocmap[i]) - 1;
-#endif
 
-    region->allocmap[i] |= (uint32_t)(1 << j);
-    void *ptr = region->pages[i * 32 + j].data;
+have_free_page:
+    // in-use pages are now ending at min of ub and pagetable_i32
+    if (memory_map.ub < info.pagetable_i32)
+        memory_map.ub = info.pagetable_i32;
+    if (info.pagetable1->ub < info.pagetable1_i32)
+        info.pagetable1->ub = info.pagetable1_i32;
+    if (info.pagetable0->ub < info.pagetable0_i32)
+        info.pagetable0->ub = info.pagetable0_i32;
+
+    // mark this entry as in-use and not free
+    info.pagetable0->freemap[info.pagetable0_i32] &= ~(uint32_t)(1 << info.pagetable0_i);
+    info.pagetable0->allocmap[info.pagetable0_i32] |= (uint32_t)(1 << info.pagetable0_i);
+    info.pagetable1->allocmap0[info.pagetable1_i32] |= (uint32_t)(1 << info.pagetable1_i);
+    memory_map.allocmap1[info.pagetable_i32] |= (uint32_t)(1 << info.pagetable_i);
+
 #ifdef _OS_WINDOWS_
-    VirtualAlloc(ptr, GC_PAGE_SZ, MEM_COMMIT, PAGE_READWRITE);
+    VirtualAlloc(info.meta->data, GC_PAGE_SZ, MEM_COMMIT, PAGE_READWRITE);
 #endif
     current_pg_count++;
     gc_final_count_page(current_pg_count);
-    JL_UNLOCK_NOGC(&pagealloc_lock);
-    return ptr;
+    JL_UNLOCK_NOGC(&gc_perm_lock);
+    return info.meta;
 }
 
+// return a page to the freemap allocator
 void jl_gc_free_page(void *p)
 {
-    int pg_idx = -1;
-    int i;
-    region_t *region = regions;
-    for (i = 0; i < REGION_COUNT && regions[i].pages != NULL; i++) {
-        region = &regions[i];
-        pg_idx = page_index(region, p);
-        if (pg_idx >= 0 && pg_idx < region->pg_cnt) {
-            break;
-        }
-    }
-    assert(i < REGION_COUNT && region->pages != NULL);
-    uint32_t msk = (uint32_t)(1 << (pg_idx % 32));
-    assert(region->allocmap[pg_idx/32] & msk);
-    region->allocmap[pg_idx/32] ^= msk;
-    free(region->meta[pg_idx].ages);
+    // update the allocmap and freemap to indicate this contains a free entry
+    struct jl_gc_metadata_ext info = page_metadata_ext(p);
+    uint32_t msk;
+    msk = (uint32_t)(1 << info.pagetable0_i);
+    assert(!(info.pagetable0->freemap[info.pagetable0_i32] & msk));
+    assert(info.pagetable0->allocmap[info.pagetable0_i32] & msk);
+    info.pagetable0->allocmap[info.pagetable0_i32] &= ~msk;
+    info.pagetable0->freemap[info.pagetable0_i32] |= msk;
+
+    msk = (uint32_t)(1 << info.pagetable1_i);
+    assert(info.pagetable1->allocmap0[info.pagetable1_i32] & msk);
+    if ((info.pagetable1->freemap0[info.pagetable1_i32] & msk) == 0)
+        info.pagetable1->freemap0[info.pagetable1_i32] |= msk;
+
+    msk = (uint32_t)(1 << info.pagetable_i);
+    assert(memory_map.allocmap1[info.pagetable_i32] & msk);
+    if ((memory_map.freemap1[info.pagetable_i32] & msk) == 0)
+        memory_map.freemap1[info.pagetable_i32] |= msk;
+
+    free(info.meta->ages);
+    info.meta->ages = NULL;
+
     // tell the OS we don't need these pages right now
     size_t decommit_size = GC_PAGE_SZ;
     if (GC_PAGE_SZ < jl_page_size) {
         // ensure so we don't release more memory than intended
-        size_t n_pages = (GC_PAGE_SZ + jl_page_size - 1) / GC_PAGE_SZ;
+        size_t n_pages = jl_page_size / GC_PAGE_SZ; // exact division
         decommit_size = jl_page_size;
-        p = (void*)((uintptr_t)region->pages[pg_idx].data & ~(jl_page_size - 1)); // round down to the nearest page
-        pg_idx = page_index(region, p);
-        if (pg_idx + n_pages > region->pg_cnt)
-            goto no_decommit;
-        for (; n_pages--; pg_idx++) {
-            msk = (uint32_t)(1 << ((pg_idx % 32)));
-            if (region->allocmap[pg_idx / 32] & msk) {
+        void *otherp = (void*)((uintptr_t)p & ~(jl_page_size - 1)); // round down to the nearest physical page
+        p = otherp;
+        while (n_pages--) {
+            struct jl_gc_metadata_ext info = page_metadata_ext(otherp);
+            msk = (uint32_t)(1 << info.pagetable0_i);
+            if (info.pagetable0->allocmap[info.pagetable0_i32] & msk)
                 goto no_decommit;
-            }
+            otherp = (void*)((char*)otherp + GC_PAGE_SZ);
         }
     }
 #ifdef _OS_WINDOWS_
@@ -200,9 +297,15 @@ void jl_gc_free_page(void *p)
 #else
     madvise(p, decommit_size, MADV_DONTNEED);
 #endif
+
 no_decommit:
-    if (region->lb > pg_idx / 32)
-        region->lb = pg_idx / 32;
+    // new pages are now available starting at max of lb and pagetable_i32
+    if (memory_map.lb > info.pagetable_i32)
+        memory_map.lb = info.pagetable_i32;
+    if (info.pagetable1->lb > info.pagetable1_i32)
+        info.pagetable1->lb = info.pagetable1_i32;
+    if (info.pagetable0->lb > info.pagetable0_i32)
+        info.pagetable0->lb = info.pagetable0_i32;
     current_pg_count--;
 }
 
diff --git a/src/gc.c b/src/gc.c
index 2b5e61f57d10f7..3e59fdeb534d07 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include "gc.h"
 
@@ -48,7 +48,7 @@ static jl_mutex_t gc_cache_lock;
 jl_gc_num_t gc_num = {0,0,0,0,0,0,0,0,0,0,0,0,0,0};
 static size_t last_long_collect_interval;
 
-region_t regions[REGION_COUNT];
+pagetable_t memory_map;
 
 // List of marked big objects.  Not per-thread.  Accessed only by master thread.
 bigval_t *big_objects_marked = NULL;
@@ -140,7 +140,7 @@ static void finalize_object(arraylist_t *list, jl_value_t *o,
             void *f = items[i + 1];
             move = 1;
             if (gc_ptr_tag(v, 1)) {
-                ((void (*)(void*))f)(o);
+                ((void (*)(void*))(uintptr_t)f)(o);
             }
             else {
                 arraylist_push(copied_list, o);
@@ -190,8 +190,20 @@ static void jl_gc_run_finalizers_in_list(jl_ptls_t ptls, arraylist_t *list)
     jl_value_t **items = (jl_value_t**)list->items;
     jl_gc_push_arraylist(ptls, list);
     JL_UNLOCK_NOGC(&finalizers_lock);
+    // from jl_apply_with_saved_exception_state; to hoist state saving out of the loop
+    jl_value_t *exc = ptls->exception_in_transit;
+    jl_array_t *bt = NULL;
+    JL_GC_PUSH2(&exc, &bt);
+    if (ptls->bt_size > 0)
+        bt = (jl_array_t*)jl_get_backtrace();
     for (size_t i = 2;i < len;i += 2)
         run_finalizer(ptls, items[i], items[i + 1]);
+    ptls->exception_in_transit = exc;
+    if (bt != NULL) {
+        ptls->bt_size = jl_array_len(bt);
+        memcpy(ptls->bt_data, bt->data, ptls->bt_size * sizeof(void*));
+    }
+    JL_GC_POP();
     JL_GC_POP();
 }
 
@@ -248,7 +260,7 @@ static void schedule_all_finalizers(arraylist_t *flist)
             schedule_finalization(v, f);
         }
         else {
-            ((void (*)(void*))f)(gc_ptr_clear_tag(v, 1));
+            ((void (*)(void*))(uintptr_t)f)(gc_ptr_clear_tag(v, 1));
         }
     }
     flist->len = 0;
@@ -404,7 +416,7 @@ static int mark_reset_age = 0;
 #define PROMOTE_AGE 1
 // this cannot be increased as is without changing :
 // - sweep_page which is specialized for 1bit age
-// - the size of the age storage in region_t
+// - the size of the age storage in jl_gc_pagemeta_t
 
 
 static int64_t scanned_bytes; // young bytes scanned while marking
@@ -501,7 +513,7 @@ STATIC_INLINE void gc_queue_big_marked(jl_ptls_t ptls, bigval_t *hdr,
 }
 
 // `gc_setmark_tag` can be called concurrently on multiple threads.
-// In all cases, the functions atomically sets the mark bits and returns
+// In all cases, the function atomically sets the mark bits and returns
 // the GC bits set as well as if the tag was unchanged by this thread.
 // All concurrent calls on the same object are guaranteed to be setting the
 // bits to the same value.
@@ -590,7 +602,7 @@ STATIC_INLINE void gc_setmark_pool_(jl_ptls_t ptls, jl_taggedvalue_t *o,
 STATIC_INLINE void gc_setmark_pool(jl_ptls_t ptls, jl_taggedvalue_t *o,
                                    uint8_t mark_mode)
 {
-    gc_setmark_pool_(ptls, o, mark_mode, page_metadata(o));
+    gc_setmark_pool_(ptls, o, mark_mode, jl_assume(page_metadata(o)));
 }
 
 STATIC_INLINE void gc_setmark(jl_ptls_t ptls, jl_taggedvalue_t *o,
@@ -604,8 +616,7 @@ STATIC_INLINE void gc_setmark(jl_ptls_t ptls, jl_taggedvalue_t *o,
     }
 }
 
-inline void gc_setmark_buf(jl_ptls_t ptls, void *o,
-                           uint8_t mark_mode, size_t minsz)
+STATIC_INLINE void gc_setmark_buf_(jl_ptls_t ptls, void *o, uint8_t mark_mode, size_t minsz)
 {
     jl_taggedvalue_t *buf = jl_astaggedvalue(o);
     uintptr_t tag = buf->header;
@@ -618,7 +629,7 @@ inline void gc_setmark_buf(jl_ptls_t ptls, void *o,
     // sure.
     if (__likely(gc_setmark_tag(buf, mark_mode, tag, &bits)) && !gc_verifying) {
         if (minsz <= GC_MAX_SZCLASS) {
-            jl_gc_pagemeta_t *page = page_metadata(o);
+            jl_gc_pagemeta_t *page = page_metadata(buf);
             if (page) {
                 gc_setmark_pool_(ptls, buf, bits, page);
                 return;
@@ -628,6 +639,42 @@ inline void gc_setmark_buf(jl_ptls_t ptls, void *o,
     }
 }
 
+void gc_setmark_buf(jl_ptls_t ptls, void *o, uint8_t mark_mode, size_t minsz)
+{
+    gc_setmark_buf_(ptls, o, mark_mode, minsz);
+}
+
+void jl_gc_force_mark_old(jl_ptls_t ptls, jl_value_t *v)
+{
+    jl_taggedvalue_t *o = jl_astaggedvalue(v);
+    jl_datatype_t *dt = (jl_datatype_t*)jl_typeof(v);
+    size_t dtsz = jl_datatype_size(dt);
+    if (o->bits.gc == GC_OLD_MARKED)
+        return;
+    o->bits.gc = GC_OLD_MARKED;
+    if (dt == jl_simplevector_type) {
+        size_t l = jl_svec_len(v);
+        dtsz = l * sizeof(void*) + sizeof(jl_svec_t);
+    }
+    else if (dt->name == jl_array_typename) {
+        jl_array_t *a = (jl_array_t*)v;
+        if (!a->flags.pooled)
+            dtsz = GC_MAX_SZCLASS + 1;
+    }
+    else if (dt == jl_module_type) {
+        dtsz = sizeof(jl_module_t);
+    }
+    else if (dt == jl_task_type) {
+        dtsz = sizeof(jl_task_t);
+    }
+    else if (dt == jl_symbol_type) {
+        return;
+    }
+    gc_setmark(ptls, o, GC_OLD_MARKED, dtsz);
+    if (dt->layout->npointers != 0)
+        jl_gc_queue_root(v);
+}
+
 #define should_collect() (__unlikely(gc_num.allocd>0))
 
 static inline int maybe_collect(jl_ptls_t ptls)
@@ -690,6 +737,7 @@ JL_DLLEXPORT jl_value_t *jl_gc_big_alloc(jl_ptls_t ptls, size_t sz)
 {
     maybe_collect(ptls);
     size_t offs = offsetof(bigval_t, header);
+    static_assert(sizeof(bigval_t) % JL_HEAP_ALIGNMENT == 0, "");
     size_t allocsz = LLT_ALIGN(sz + offs, JL_CACHE_BYTE_ALIGNMENT);
     if (allocsz < sz)  // overflow in adding offs, size was "negative"
         jl_throw(jl_memory_exception);
@@ -875,11 +923,7 @@ static NOINLINE jl_taggedvalue_t *add_page(jl_gc_pool_t *p)
     // Do not pass in `ptls` as argument. This slows down the fast path
     // in pool_alloc significantly
     jl_ptls_t ptls = jl_get_ptls_states();
-    char *data = (char*)jl_gc_alloc_page();
-    if (data == NULL)
-        jl_throw(jl_memory_exception);
-    jl_gc_pagemeta_t *pg = page_metadata(data + GC_PAGE_OFFSET);
-    pg->data = data;
+    jl_gc_pagemeta_t *pg = jl_gc_alloc_page();
     pg->osize = p->osize;
     pg->ages = (uint8_t*)malloc(GC_PAGE_SZ / 8 / p->osize + 1);
     pg->thread_n = ptls->tid;
@@ -920,7 +964,7 @@ JL_DLLEXPORT jl_value_t *jl_gc_pool_alloc(jl_ptls_t ptls, int pool_offset,
         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
-            jl_gc_pagemeta_t *pg = page_metadata(v);
+            jl_gc_pagemeta_t *pg = jl_assume(page_metadata(v));
             assert(pg->osize == p->osize);
             pg->nfree = 0;
             pg->has_young = 1;
@@ -937,7 +981,7 @@ JL_DLLEXPORT jl_value_t *jl_gc_pool_alloc(jl_ptls_t ptls, int pool_offset,
         if (v) {
             // like the freelist case,
             // but only update the page metadata when it is full
-            jl_gc_pagemeta_t *pg = page_metadata((char*)v - 1);
+            jl_gc_pagemeta_t *pg = jl_assume(page_metadata((char*)v - 1));
             assert(pg->osize == p->osize);
             pg->nfree = 0;
             pg->has_young = 1;
@@ -1082,37 +1126,94 @@ static jl_taggedvalue_t **sweep_page(jl_gc_pool_t *p, jl_gc_pagemeta_t *pg, jl_t
     return pfl;
 }
 
-static void sweep_pool_region(jl_taggedvalue_t ***pfl, int region_i, int sweep_full)
+// the actual sweeping over all allocated pages in a memory pool
+static inline void sweep_pool_page(jl_taggedvalue_t ***pfl, jl_gc_pagemeta_t *pg, int sweep_full)
 {
-    region_t *region = &regions[region_i];
+    int p_n = pg->pool_n;
+    int t_n = pg->thread_n;
+    jl_ptls_t ptls2 = jl_all_tls_states[t_n];
+    jl_gc_pool_t *p = &ptls2->heap.norm_pools[p_n];
+    int osize = pg->osize;
+    pfl[t_n * JL_GC_N_POOLS + p_n] = sweep_page(p, pg, pfl[t_n * JL_GC_N_POOLS + p_n], sweep_full, osize);
+}
 
-    // the actual sweeping
-    int ub = 0;
-    int lb = region->lb;
-    for (int pg_i = 0; pg_i <= region->ub; pg_i++) {
-        uint32_t line = region->allocmap[pg_i];
-        if (line) {
+// sweep over a pagetable0 for all allocated pages
+static inline int sweep_pool_pagetable0(jl_taggedvalue_t ***pfl, pagetable0_t *pagetable0, int sweep_full)
+{
+    unsigned ub = 0;
+    unsigned alloc = 0;
+    for (unsigned pg_i = 0; pg_i <= pagetable0->ub; pg_i++) {
+        uint32_t line = pagetable0->allocmap[pg_i];
+        unsigned j;
+        if (!line)
+            continue;
+        ub = pg_i;
+        alloc = 1;
+        for (j = 0; line; j++, line >>= 1) {
+            unsigned next = ffs_u32(line);
+            j += next;
+            line >>= next;
+            jl_gc_pagemeta_t *pg = pagetable0->meta[pg_i * 32 + j];
+            sweep_pool_page(pfl, pg, sweep_full);
+        }
+    }
+    pagetable0->ub = ub;
+    return alloc;
+}
+
+// sweep over pagetable1 for all pagetable0 that may contain allocated pages
+static inline int sweep_pool_pagetable1(jl_taggedvalue_t ***pfl, pagetable1_t *pagetable1, int sweep_full)
+{
+    unsigned ub = 0;
+    unsigned alloc = 0;
+    for (unsigned pg_i = 0; pg_i <= pagetable1->ub; pg_i++) {
+        uint32_t line = pagetable1->allocmap0[pg_i];
+        unsigned j;
+        for (j = 0; line; j++, line >>= 1) {
+            unsigned next = ffs_u32(line);
+            j += next;
+            line >>= next;
+            pagetable0_t *pagetable0 = pagetable1->meta0[pg_i * 32 + j];
+            if (pagetable0 && !sweep_pool_pagetable0(pfl, pagetable0, sweep_full))
+                pagetable1->allocmap0[pg_i] &= ~(1 << j); // no allocations found, remember that for next time
+        }
+        if (pagetable1->allocmap0[pg_i]) {
             ub = pg_i;
-            for (int j = 0; j < 32; j++) {
-                if ((line >> j) & 1) {
-                    jl_gc_pagemeta_t *pg = &region->meta[pg_i*32 + j];
-                    int p_n = pg->pool_n;
-                    int t_n = pg->thread_n;
-                    jl_ptls_t ptls2 = jl_all_tls_states[t_n];
-                    jl_gc_pool_t *p = &ptls2->heap.norm_pools[p_n];
-                    int osize = pg->osize;
-                    pfl[t_n * JL_GC_N_POOLS + p_n] = sweep_page(p, pg, pfl[t_n * JL_GC_N_POOLS + p_n], sweep_full, osize);
-                }
-            }
+            alloc = 1;
         }
-        else if (pg_i < lb) {
-            lb = pg_i;
+    }
+    pagetable1->ub = ub;
+    return alloc;
+}
+
+// sweep over all memory for all pagetable1 that may contain allocated pages
+static void sweep_pool_pagetable(jl_taggedvalue_t ***pfl, int sweep_full)
+{
+    if (REGION2_PG_COUNT == 1) { // compile-time optimization
+        pagetable1_t *pagetable1 = memory_map.meta1[0];
+        sweep_pool_pagetable1(pfl, pagetable1, sweep_full);
+        return;
+    }
+    unsigned ub = 0;
+    for (unsigned pg_i = 0; pg_i <= memory_map.ub; pg_i++) {
+        uint32_t line = memory_map.allocmap1[pg_i];
+        unsigned j;
+        for (j = 0; line; j++, line >>= 1) {
+            unsigned next = ffs_u32(line);
+            j += next;
+            line >>= next;
+            pagetable1_t *pagetable1 = memory_map.meta1[pg_i * 32 + j];
+            if (pagetable1 && !sweep_pool_pagetable1(pfl, pagetable1, sweep_full))
+                memory_map.allocmap1[pg_i] &= ~(1 << j); // no allocations found, remember that for next time
+        }
+        if (memory_map.allocmap1[pg_i]) {
+            ub = pg_i;
         }
     }
-    region->ub = ub;
-    region->lb = lb;
+    memory_map.ub = ub;
 }
 
+// sweep over all memory that is being used and not in a pool
 static void gc_sweep_other(jl_ptls_t ptls, int sweep_full)
 {
     sweep_malloced_arrays();
@@ -1135,11 +1236,14 @@ static void gc_pool_sync_nfree(jl_gc_pagemeta_t *pg, jl_taggedvalue_t *last)
     pg->nfree = nfree;
 }
 
+// setup the data-structures for a sweep over all memory pools
 static void gc_sweep_pool(int sweep_full)
 {
     gc_time_pool_start();
     lazy_freed_pages = 0;
 
+    // allocate enough space to hold the end of the free list chain
+    // for every thread and pool size
     jl_taggedvalue_t ***pfl = (jl_taggedvalue_t ***) alloca(jl_n_threads * JL_GC_N_POOLS * sizeof(jl_taggedvalue_t**));
 
     // update metadata of pages that were pointed to by freelist or newpages from a pool
@@ -1150,7 +1254,7 @@ static void gc_sweep_pool(int sweep_full)
             jl_gc_pool_t *p = &ptls2->heap.norm_pools[i];
             jl_taggedvalue_t *last = p->freelist;
             if (last) {
-                jl_gc_pagemeta_t *pg = page_metadata(last);
+                jl_gc_pagemeta_t *pg = jl_assume(page_metadata(last));
                 gc_pool_sync_nfree(pg, last);
                 pg->has_young = 1;
             }
@@ -1160,7 +1264,7 @@ static void gc_sweep_pool(int sweep_full)
             last = p->newpages;
             if (last) {
                 char *last_p = (char*)last;
-                jl_gc_pagemeta_t *pg = page_metadata(last_p - 1);
+                jl_gc_pagemeta_t *pg = jl_assume(page_metadata(last_p - 1));
                 assert(last_p - gc_page_data(last_p - 1) >= GC_PAGE_OFFSET);
                 pg->nfree = (GC_PAGE_SZ - (last_p - gc_page_data(last_p - 1))) / p->osize;
                 pg->has_young = 1;
@@ -1169,12 +1273,8 @@ static void gc_sweep_pool(int sweep_full)
         }
     }
 
-    for (int i = 0; i < REGION_COUNT; i++) {
-        if (!regions[i].pages)
-            break;
-        sweep_pool_region(pfl, i, sweep_full);
-    }
-
+    // the actual sweeping
+    sweep_pool_pagetable(pfl, sweep_full);
 
     // null out terminal pointers of free lists
     for (int t_i = 0; t_i < jl_n_threads; t_i++) {
@@ -1186,27 +1286,16 @@ static void gc_sweep_pool(int sweep_full)
     gc_time_pool_end(sweep_full);
 }
 
-// mark phase
-
-static jl_value_t **mark_stack = NULL;
-static jl_value_t **mark_stack_base = NULL;
-static size_t mark_stack_size = 0;
-static size_t mark_sp = 0;
-
-static void grow_mark_stack(void)
+static void gc_sweep_perm_alloc(void)
 {
-    size_t newsz = mark_stack_size>0 ? mark_stack_size*2 : 32000;
-    size_t offset = mark_stack - mark_stack_base;
-    mark_stack_base = (jl_value_t**)realloc(mark_stack_base, newsz*sizeof(void*));
-    if (mark_stack_base == NULL) {
-        jl_printf(JL_STDERR, "Couldn't grow mark stack to : %" PRIuPTR "\n",
-                  (uintptr_t)newsz);
-        exit(1);
-    }
-    mark_stack = mark_stack_base + offset;
-    mark_stack_size = newsz;
+    uint64_t t0 = jl_hrtime();
+    gc_sweep_sysimg();
+    gc_time_sysimg_end(t0);
 }
 
+
+// mark phase
+
 JL_DLLEXPORT void jl_gc_queue_root(jl_value_t *ptr)
 {
     jl_ptls_t ptls = jl_get_ptls_states();
@@ -1238,86 +1327,19 @@ void gc_queue_binding(jl_binding_t *bnd)
     arraylist_push(&ptls->heap.rem_bindings, bnd);
 }
 
-static void gc_scan_obj_(jl_ptls_t ptls, jl_value_t *v, int d,
-                         uintptr_t tag, uint8_t bits);
-static void gc_mark_obj(jl_ptls_t ptls, jl_value_t *v,
-                        uintptr_t tag, uint8_t bits);
+
 #ifdef JL_DEBUG_BUILD
 static void *volatile gc_findval; // for usage from gdb, for finding the gc-root for a value
 #endif
-// Returns whether the object is young
-STATIC_INLINE int gc_push_root(jl_ptls_t ptls, void *v, int d) // v isa jl_value_t*
-{
-#ifdef JL_DEBUG_BUILD
-    if (v == gc_findval)
-        jl_raise_debugger();
-#endif
-    assert(v != NULL);
-    jl_taggedvalue_t *o = jl_astaggedvalue(v);
-    verify_val(v);
-    uintptr_t tag = o->header;
-    if (!gc_marked(tag)) {
-        uint8_t bits;
-        if (__likely(gc_setmark_tag(o, GC_MARKED, tag, &bits))) {
-            tag = tag & ~(uintptr_t)15;
-            if (!gc_verifying)
-                gc_mark_obj(ptls, (jl_value_t*)v, tag, bits);
-            gc_scan_obj_(ptls, (jl_value_t*)v, d, tag, bits);
-        }
-        return !gc_old(bits);
-    }
-    return !gc_old(tag);
-}
 
-// TODO rename this as it is misleading now
-void jl_gc_setmark(jl_ptls_t ptls, jl_value_t *v)
+static void *sysimg_base;
+static void *sysimg_end;
+void jl_gc_set_permalloc_region(void *start, void *end)
 {
-    jl_taggedvalue_t *o = jl_astaggedvalue(v);
-    uintptr_t tag = o->header;
-    if (!gc_marked(tag)) {
-        uint8_t bits;
-        if (__likely(gc_setmark_tag(o, GC_MARKED, tag, &bits)) && !gc_verifying) {
-            gc_setmark_pool(ptls, o, bits);
-        }
-    }
+    sysimg_base = start;
+    sysimg_end = end;
 }
 
-NOINLINE static int gc_mark_module(jl_ptls_t ptls, jl_module_t *m,
-                                   int d, int8_t bits)
-{
-    size_t i;
-    int refyoung = 0;
-    void **table = m->bindings.table;
-    for(i=1; i < m->bindings.size; i+=2) {
-        if (table[i] != HT_NOTFOUND) {
-            jl_binding_t *b = (jl_binding_t*)table[i];
-            gc_setmark_buf(ptls, b, bits, sizeof(jl_binding_t));
-            void *vb = jl_astaggedvalue(b);
-            verify_parent1("module", m, &vb, "binding_buff");
-            (void)vb;
-            if (b->value != NULL) {
-                verify_parent2("module", m, &b->value, "binding(%s)",
-                               jl_symbol_name(b->name));
-                refyoung |= gc_push_root(ptls, b->value, d);
-            }
-            if (b->globalref != NULL)
-                refyoung |= gc_push_root(ptls, b->globalref, d);
-        }
-    }
-    // this is only necessary because bindings for "using" modules
-    // are added only when accessed. therefore if a module is replaced
-    // after "using" it but before accessing it, this array might
-    // contain the only reference.
-    for(i=0; i < m->usings.len; i++) {
-        refyoung |= gc_push_root(ptls, m->usings.items[i], d);
-    }
-
-    if (m->parent) {
-        refyoung |= gc_push_root(ptls, m->parent, d);
-    }
-
-    return refyoung;
-}
 
 // Handle the case where the stack is only partially copied.
 STATIC_INLINE uintptr_t gc_get_stack_addr(void *_addr, uintptr_t offset,
@@ -1336,342 +1358,921 @@ STATIC_INLINE uintptr_t gc_read_stack(void *_addr, uintptr_t offset,
     return *(uintptr_t*)real_addr;
 }
 
-static void gc_mark_stack(jl_ptls_t ptls, jl_gcframe_t *s, uintptr_t offset,
-                          uintptr_t lb, uintptr_t ub, int d)
+JL_NORETURN NOINLINE void gc_assert_datatype_fail(jl_ptls_t ptls, jl_datatype_t *vt,
+                                                  gc_mark_sp_t sp)
 {
-    while (s != NULL) {
-        jl_value_t ***rts = (jl_value_t***)(((void**)s) + 2);
-        size_t nroots = gc_read_stack(&s->nroots, offset, lb, ub);
-        size_t nr = nroots >> 1;
-        if (nroots & 1) {
-            for (size_t i = 0; i < nr; i++) {
-                void **slot = (void**)gc_read_stack(&rts[i], offset, lb, ub);
-                void *obj = (void*)gc_read_stack(slot, offset, lb, ub);
-                if (obj != NULL) {
-                    gc_push_root(ptls, obj, d);
-                }
-            }
+    jl_printf(JL_STDOUT, "GC error (probable corruption) :\n");
+    gc_debug_print_status();
+    jl_(vt);
+    gc_debug_critical_error();
+    gc_mark_loop_unwind(ptls, sp, 0);
+    abort();
+}
+
+// This stores the label address in the mark loop function.
+// We can't directly store that to a global array so we need some hack to get that.
+// See the call to `gc_mark_loop` in init with a `NULL` `ptls`.
+void *gc_mark_label_addrs[_GC_MARK_L_MAX];
+
+// Double the mark stack (both pc and data) with the lock held.
+static void NOINLINE gc_mark_stack_resize(jl_gc_mark_cache_t *gc_cache, gc_mark_sp_t *sp)
+{
+    char *old_data = gc_cache->data_stack;
+    void **pc_stack = sp->pc_start;
+    size_t stack_size = (char*)sp->pc_end - (char*)pc_stack;
+    JL_LOCK_NOGC(&gc_cache->stack_lock);
+    gc_cache->data_stack = (char*)realloc(old_data, stack_size * 2 * sizeof(gc_mark_data_t));
+    sp->data += gc_cache->data_stack - old_data;
+
+    sp->pc_start = gc_cache->pc_stack = (void**)realloc(pc_stack, stack_size * 2 * sizeof(void*));
+    gc_cache->pc_stack_end = sp->pc_end = sp->pc_start + stack_size * 2;
+    sp->pc += sp->pc_start - pc_stack;
+    JL_UNLOCK_NOGC(&gc_cache->stack_lock);
+}
+
+// Push a work item to the stack. The type of the work item is marked with `pc`.
+// The data needed is in `data` and is of size `data_size`.
+// If there isn't enough space on the stack, the stack will be resized with the stack
+// lock held. The caller should invalidate any local cache of the stack addresses that's not
+// in `gc_cache` or `sp`
+// The `sp` will be updated on return if `inc` is true.
+STATIC_INLINE void gc_mark_stack_push(jl_gc_mark_cache_t *gc_cache, gc_mark_sp_t *sp,
+                                      void *pc, void *data, size_t data_size, int inc)
+{
+    assert(data_size <= sizeof(gc_mark_data_t));
+    if (__unlikely(sp->pc == sp->pc_end))
+        gc_mark_stack_resize(gc_cache, sp);
+    *sp->pc = pc;
+    memcpy(sp->data, data, data_size);
+    if (inc) {
+        sp->data += data_size;
+        sp->pc++;
+    }
+}
+
+// Check if the reference is non-NULL and atomically set the mark bit.
+// Update `*nptr`, which is the `nptr` field of the parent item, if the object is young.
+// Return the tag (with GC bits cleared) and the GC bits in `*ptag` and `*pbits`.
+// Return whether the object needs to be scanned / have metadata updated.
+STATIC_INLINE int gc_try_setmark(jl_value_t *obj, uintptr_t *nptr,
+                                 uintptr_t *ptag, uint8_t *pbits)
+{
+    if (!obj)
+        return 0;
+    jl_taggedvalue_t *o = jl_astaggedvalue(obj);
+    uintptr_t tag = o->header;
+    if (!gc_marked(tag)) {
+        uint8_t bits;
+        int res = gc_setmark_tag(o, GC_MARKED, tag, &bits);
+        if (!gc_old(bits))
+            *nptr = *nptr | 1;
+        *ptag = tag & ~(uintptr_t)0xf;
+        *pbits = bits;
+        return __likely(res);
+    }
+    else if (!gc_old(tag)) {
+        *nptr = *nptr | 1;
+    }
+    return 0;
+}
+
+// Queue a finalizer list to be scanned in the mark loop. Start marking from index `start`.
+void gc_mark_queue_finlist(jl_gc_mark_cache_t *gc_cache, gc_mark_sp_t *sp,
+                           arraylist_t *list, size_t start)
+{
+    size_t len = list->len;
+    if (len <= start)
+        return;
+    jl_value_t **items = (jl_value_t**)list->items;
+    gc_mark_finlist_t markdata = {items + start, items + len};
+    gc_mark_stack_push(gc_cache, sp, gc_mark_label_addrs[GC_MARK_L_finlist],
+                       &markdata, sizeof(markdata), 1);
+}
+
+// Queue a object to be scanned. The object should already be marked and the GC metadata
+// should already be updated for it. Only scanning of the object should be performed.
+STATIC_INLINE void gc_mark_queue_scan_obj(jl_gc_mark_cache_t *gc_cache, gc_mark_sp_t *sp,
+                                          jl_value_t *obj)
+{
+    jl_taggedvalue_t *o = jl_astaggedvalue(obj);
+    uintptr_t tag = o->header;
+    uint8_t bits = tag & 0xf;
+    tag = tag & ~(uintptr_t)0xf;
+    gc_mark_marked_obj_t data = {obj, tag, bits};
+    gc_mark_stack_push(gc_cache, sp, gc_mark_label_addrs[GC_MARK_L_scan_only],
+                       &data, sizeof(data), 1);
+}
+
+// Mark and queue a object to be scanned.
+// The object will be marked atomically which can also happen concurrently.
+// It will be queued if the object wasn't marked already (or concurrently by another thread)
+// Returns whether the object is young.
+STATIC_INLINE int gc_mark_queue_obj(jl_gc_mark_cache_t *gc_cache, gc_mark_sp_t *sp, void *_obj)
+{
+    jl_value_t *obj = (jl_value_t*)jl_assume(_obj);
+    uintptr_t nptr = 0;
+    uintptr_t tag = 0;
+    uint8_t bits = 0;
+    if (!gc_try_setmark(obj, &nptr, &tag, &bits))
+        return (int)nptr;
+    gc_mark_marked_obj_t data = {obj, tag, bits};
+    gc_mark_stack_push(gc_cache, sp, gc_mark_label_addrs[GC_MARK_L_marked_obj],
+                       &data, sizeof(data), 1);
+    return (int)nptr;
+}
+
+// Check if `nptr` is tagged for `old + refyoung`,
+// Push the object to the remset and update the `nptr` counter if necessary.
+STATIC_INLINE void gc_mark_push_remset(jl_ptls_t ptls, jl_value_t *obj, uintptr_t nptr)
+{
+    if (__unlikely((nptr & 0x3) == 0x3)) {
+        ptls->heap.remset_nptr += nptr >> 2;
+        arraylist_t *remset = ptls->heap.remset;
+        size_t len = remset->len;
+        if (__unlikely(len >= remset->max)) {
+            arraylist_push(remset, obj);
         }
         else {
-            for (size_t i=0; i < nr; i++) {
-                void *obj = (void*)gc_read_stack(&rts[i], offset, lb, ub);
-                if (obj) {
-                    gc_push_root(ptls, obj, d);
-                }
-            }
+            remset->len = len + 1;
+            remset->items[len] = obj;
         }
-        s = (jl_gcframe_t*)gc_read_stack(&s->prev, offset, lb, ub);
     }
 }
 
-static void gc_mark_task_stack(jl_ptls_t ptls, jl_task_t *ta, int d, int8_t bits)
+// Scan a dense array of object references, see `gc_mark_objarray_t`
+STATIC_INLINE int gc_mark_scan_objarray(jl_ptls_t ptls, gc_mark_sp_t *sp,
+                                        gc_mark_objarray_t *objary,
+                                        jl_value_t **begin, jl_value_t **end,
+                                        jl_value_t **pnew_obj, uintptr_t *ptag, uint8_t *pbits)
 {
-    gc_scrub_record_task(ta);
-    int stkbuf = (ta->stkbuf != (void*)(intptr_t)-1 && ta->stkbuf != NULL);
-    int16_t tid = ta->tid;
-    jl_ptls_t ptls2 = jl_all_tls_states[tid];
-    if (stkbuf) {
-#ifdef COPY_STACKS
-        gc_setmark_buf(ptls, ta->stkbuf, bits, ta->bufsz);
-#else
-        // stkbuf isn't owned by julia for the root task
-        if (ta != ptls2->root_task) {
-            gc_setmark_buf(ptls, ta->stkbuf, bits, ta->ssize);
+    (void)jl_assume(objary == (gc_mark_objarray_t*)sp->data);
+    for (; begin < end; begin++) {
+        *pnew_obj = *begin;
+        if (*pnew_obj)
+            verify_parent2("obj array", objary->parent, begin, "elem(%d)",
+                           gc_slot_to_arrayidx(objary->parent, begin));
+        if (!gc_try_setmark(*pnew_obj, &objary->nptr, ptag, pbits))
+            continue;
+        begin++;
+        // Found an object to mark
+        if (begin < end) {
+            // Haven't done with this one yet. Update the content and push it back
+            objary->begin = begin;
+            gc_repush_markdata(sp, gc_mark_objarray_t);
         }
-#endif
-    }
-    if (ta == ptls2->current_task) {
-        gc_mark_stack(ptls, ptls2->pgcstack, 0, 0, (uintptr_t)-1, d);
-    }
-    else if (stkbuf) {
-        uintptr_t offset = 0;
-        uintptr_t lb = 0;
-        uintptr_t ub = (uintptr_t)-1;
-#ifdef COPY_STACKS
-        ub = (uintptr_t)ptls2->stackbase;
-        lb = ub - ta->ssize;
-        offset = (uintptr_t)ta->stkbuf - lb;
-#endif
-        gc_mark_stack(ptls, ta->gcstack, offset, lb, ub, d);
+        else {
+            // Finished scaning this one, finish up by checking the GC invariance
+            // and let the next item replacing the current one directly.
+            gc_mark_push_remset(ptls, objary->parent, objary->nptr);
+        }
+        return 1;
     }
+    gc_mark_push_remset(ptls, objary->parent, objary->nptr);
+    return 0;
 }
 
-NOINLINE static void gc_mark_task(jl_ptls_t ptls, jl_task_t *ta,
-                                  int d, int8_t bits)
+// Scan an object with 8bits field descriptors. see `gc_mark_obj8_t`
+STATIC_INLINE int gc_mark_scan_obj8(jl_ptls_t ptls, gc_mark_sp_t *sp, gc_mark_obj8_t *obj8,
+                                    char *parent, jl_fielddesc8_t *begin, jl_fielddesc8_t *end,
+                                    jl_value_t **pnew_obj, uintptr_t *ptag, uint8_t *pbits)
 {
-    if (ta->parent) gc_push_root(ptls, ta->parent, d);
-    gc_push_root(ptls, ta->tls, d);
-    gc_push_root(ptls, ta->consumers, d);
-    gc_push_root(ptls, ta->donenotify, d);
-    gc_push_root(ptls, ta->exception, d);
-    if (ta->backtrace) gc_push_root(ptls, ta->backtrace, d);
-    if (ta->start)  gc_push_root(ptls, ta->start, d);
-    if (ta->result) gc_push_root(ptls, ta->result, d);
-    gc_mark_task_stack(ptls, ta, d, bits);
+    (void)jl_assume(obj8 == (gc_mark_obj8_t*)sp->data);
+    (void)jl_assume(begin < end);
+    for (; begin < end; begin++) {
+        if (!begin->isptr)
+            continue;
+        jl_value_t **slot = (jl_value_t**)(parent + begin->offset);
+        *pnew_obj = *slot;
+        if (*pnew_obj)
+            verify_parent2("object", parent, slot, "field(%d)",
+                           gc_slot_to_fieldidx(parent, slot));
+        if (!gc_try_setmark(*pnew_obj, &obj8->nptr, ptag, pbits))
+            continue;
+        begin++;
+        // Found an object to mark
+        if (begin < end) {
+            // Haven't done with this one yet. Update the content and push it back
+            obj8->begin = begin;
+            gc_repush_markdata(sp, gc_mark_obj8_t);
+        }
+        else {
+            // Finished scaning this one, finish up by checking the GC invariance
+            // and let the next item replacing the current one directly.
+            gc_mark_push_remset(ptls, obj8->parent, obj8->nptr);
+        }
+        return 1;
+    }
+    gc_mark_push_remset(ptls, obj8->parent, obj8->nptr);
+    return 0;
 }
 
-void gc_mark_object_list(jl_ptls_t ptls, arraylist_t *list, size_t start)
+// Scan an object with 16bits field descriptors. see `gc_mark_obj16_t`
+STATIC_INLINE int gc_mark_scan_obj16(jl_ptls_t ptls, gc_mark_sp_t *sp, gc_mark_obj16_t *obj16,
+                                     char *parent, jl_fielddesc16_t *begin, jl_fielddesc16_t *end,
+                                     jl_value_t **pnew_obj, uintptr_t *ptag, uint8_t *pbits)
 {
-    void **items = list->items;
-    size_t len = list->len;
-    for (size_t i = start;i < len;i++) {
-        void *v = items[i];
-        if (__unlikely(!v))
+    (void)jl_assume(obj16 == (gc_mark_obj16_t*)sp->data);
+    (void)jl_assume(begin < end);
+    for (; begin < end; begin++) {
+        if (!begin->isptr)
             continue;
-        if (gc_ptr_tag(v, 1)) {
-            v = gc_ptr_clear_tag(v, 1);
-            i++;
-            assert(i < len);
+        jl_value_t **slot = (jl_value_t**)(parent + begin->offset);
+        *pnew_obj = *slot;
+        if (*pnew_obj)
+            verify_parent2("object", parent, slot, "field(%d)",
+                           gc_slot_to_fieldidx(parent, slot));
+        if (!gc_try_setmark(*pnew_obj, &obj16->nptr, ptag, pbits))
+            continue;
+        begin++;
+        // Found an object to mark
+        if (begin < end) {
+            // Haven't done with this one yet. Update the content and push it back
+            obj16->begin = begin;
+            gc_repush_markdata(sp, gc_mark_obj16_t);
+        }
+        else {
+            // Finished scaning this one, finish up by checking the GC invariance
+            // and let the next item replacing the current one directly.
+            gc_mark_push_remset(ptls, obj16->parent, obj16->nptr);
         }
-        gc_push_root(ptls, v, 0);
+        return 1;
     }
+    gc_mark_push_remset(ptls, obj16->parent, obj16->nptr);
+    return 0;
 }
 
-STATIC_INLINE void gc_assert_datatype(jl_datatype_t *vt)
+// Scan an object with 32bits field descriptors. see `gc_mark_obj32_t`
+STATIC_INLINE int gc_mark_scan_obj32(jl_ptls_t ptls, gc_mark_sp_t *sp, gc_mark_obj32_t *obj32,
+                                     char *parent, jl_fielddesc32_t *begin, jl_fielddesc32_t *end,
+                                     jl_value_t **pnew_obj, uintptr_t *ptag, uint8_t *pbits)
 {
-    if (__likely(jl_is_datatype(vt)))
-        return;
-    jl_printf(JL_STDOUT, "GC error (probable corruption) :\n");
-    gc_debug_print_status();
-    jl_(vt);
-    gc_debug_critical_error();
-    abort();
+    (void)jl_assume(obj32 == (gc_mark_obj32_t*)sp->data);
+    (void)jl_assume(begin < end);
+    for (; begin < end; begin++) {
+        if (!begin->isptr)
+            continue;
+        jl_value_t **slot = (jl_value_t**)(parent + begin->offset);
+        *pnew_obj = *slot;
+        if (*pnew_obj)
+            verify_parent2("object", parent, slot, "field(%d)",
+                           gc_slot_to_fieldidx(parent, slot));
+        if (!gc_try_setmark(*pnew_obj, &obj32->nptr, ptag, pbits))
+            continue;
+        begin++;
+        // Found an object to mark
+        if (begin < end) {
+            // Haven't done with this one yet. Update the content and push it back
+            obj32->begin = begin;
+            gc_repush_markdata(sp, gc_mark_obj32_t);
+        }
+        else {
+            // Finished scaning this one, finish up by checking the GC invariance
+            // and let the next item replacing the current one directly.
+            gc_mark_push_remset(ptls, obj32->parent, obj32->nptr);
+        }
+        return 1;
+    }
+    gc_mark_push_remset(ptls, obj32->parent, obj32->nptr);
+    return 0;
 }
 
-// for chasing down unwanted references
-/*
-static jl_value_t *lookforme = NULL;
-JL_DLLEXPORT void jl_gc_lookfor(jl_value_t *v) { lookforme = v; }
-*/
-
-#define MAX_MARK_DEPTH 400
-// Scan a marked object `v` and recursively mark its children.
-// The object will be queued on the mark stack when recursion depth
-// becomes too high.
-// It does so assuming that the tag of the (marked) object is `tag`.
-// If `v` is `GC_OLD_MARKED` and some of its children are `GC_MARKED` (young),
-// `v` is added to the remset
-static void gc_scan_obj_(jl_ptls_t ptls, jl_value_t *v, int d,
-                         uintptr_t tag, uint8_t bits)
-{
-    assert(v != NULL);
-    assert(gc_marked(bits));
-    jl_datatype_t *vt = (jl_datatype_t*)tag;
-#ifdef JL_DEBUG_BUILD
-    gc_assert_datatype(vt); // should have checked in `gc_mark_obj`
+#ifdef __GNUC__
+#  define gc_mark_laddr(name) (&&name)
+#  define gc_mark_jmp(ptr) goto *(ptr)
+#else
+#define gc_mark_laddr(name) ((void*)(uintptr_t)GC_MARK_L_##name)
+#define gc_mark_jmp(ptr) do {                   \
+        switch ((int)(uintptr_t)ptr) {          \
+        case GC_MARK_L_marked_obj:              \
+            goto marked_obj;                    \
+        case GC_MARK_L_scan_only:               \
+            goto scan_only;                     \
+        case GC_MARK_L_finlist:                 \
+            goto finlist;                       \
+        case GC_MARK_L_objarray:                \
+            goto objarray;                      \
+        case GC_MARK_L_obj8:                    \
+            goto obj8;                          \
+        case GC_MARK_L_obj16:                   \
+            goto obj16;                         \
+        case GC_MARK_L_obj32:                   \
+            goto obj32;                         \
+        case GC_MARK_L_stack:                   \
+            goto stack;                         \
+        case GC_MARK_L_module_binding:          \
+            goto module_binding;                \
+        default:                                \
+            abort();                            \
+        }                                       \
+    } while (0)
 #endif
-    int refyoung = 0, nptr = 0;
 
-    assert(vt != jl_symbol_type);
-    // weakref should not be marked
-    if (vt == jl_weakref_type)
-        return;
-    // fast path
-    if (vt->layout->npointers == 0)
+// This is the main marking loop.
+// It uses an iterative (mostly) Depth-first search (DFS) to mark all the objects.
+// Instead of using the native stack, two stacks are manually maintained,
+// one (fixed-size) pc stack which stores the return address and one (variable-size)
+// data stack which stores the local variables needed by the scanning code.
+// Using a manually maintained stack has a few advantages
+//
+// 1. We can resize the stack as we go and never worry about stack overflow
+//    This is especitally useful when enters the GC in a deep call stack.
+//    It also removes the very deep GC call stack in a profile.
+// 2. We can minimize the number of local variables to save on the stack.
+//    This includes minimizing the sizes of the stack frames and only saving variables
+//    that have been changed before making "function calls" (i.e. `goto mark;`)
+// 3. We can perform end-of-loop tail-call optimization for common cases.
+// 4. The marking can be interrupted more easily since all the states are maintained
+//    in a well-defined format already.
+//    This will be useful if we want to have incremental marking again.
+// 5. The frames can be stolen by another thread more easily and it is not necessary
+//    to copy works to be stolen to another queue. Useful for parallel marking.
+//    (Will still require synchronization in stack popping of course.)
+// 6. A flat function (i.e. no or very few function calls) also give the compiler
+//    opportunity to keep more states in registers that doesn't have to be spilled as often.
+//
+// We use two stacks so that the thief on another thread can steal the fixed sized pc stack
+// and use that to figure out the size of the struct on the variable size data stack.
+//
+// The main disadvantages are that we bypass some stack-based CPU optimizations including the
+// stack engine and return address prediction.
+// Using two stacks also double the number of operations on the stack pointer
+// though we still only need to use one of them (the pc stack pointer) for bounds check.
+// In general, it seems that the reduction of stack memory ops and instructions count
+// have a larger possitive effect on the performance. =)
+
+// As a general guide we do not want to make non-inlined function calls in this function
+// if possible since a large number of registers has to be spilled when that happens.
+// This is especially true on on X86 which doesn't have many (any?)
+// callee saved general purpose registers.
+// (OTOH, the spill will likely make use of the stack engine which is otherwise idle so
+//  the performance impact is minimum as long as it's not in the hottest path)
+
+// There are three external entry points to the loop, corresponding to label
+// `marked_obj`, `scan_only` and `finlist` (see the corresponding functions
+// `gc_mark_queue_obj`, `gc_mark_queue_scan_obj` and `gc_mark_queue_finlist` above).
+// The scanning of the object starts with `goto mark`, which updates the metadata and scans
+// the object whose information is stored in `new_obj`, `tag` and `bits`.
+// The branches in `mark` will dispatch the object to one of the scan "loop"s to be scanned
+// as either a normal julia object or one of the special objects with specific storage format.
+// Each of the scan "loop" will preform a DFS of the object in the following way
+//
+// 1. When encountering an pointer (julia object reference) slots, load, preform NULL check
+//    and atomically set the mark bits to determine if the object needs to be scanned.
+// 2. If yes, it'll push itself back onto the mark stack (after updating fields that are changed)
+//    using `gc_repush_markdata` to increment the stack pointers.
+//    This step can also be replaced by a tail call by finishing up the marking of the current
+//    object when the end of the current object is reached.
+// 3. Jump to `mark`. The marking of the current object will be resumed after the child is
+//    scanned by popping the stack frame back.
+//
+// Some of the special object scannings use BFS to simplify the code (Task and Module).
+
+// The jumps from the dispatch to the scan "loop"s are done by first pushing a frame
+// to the stacks while only increment the data stack pointer before jumping to the loop
+// This way the scan "loop" gets exactly what it expects after a stack pop.
+// Additional optimizations are done for some of the common cases by skipping
+// the unnecessary data stack pointer increment and the load from the stack
+// (i.e. store to load forwaring). See `objary_loaded`, `obj8_loaded` and `obj16_loaded`.
+JL_EXTENSION NOINLINE void gc_mark_loop(jl_ptls_t ptls, gc_mark_sp_t sp)
+{
+    if (__unlikely(ptls == NULL)) {
+        gc_mark_label_addrs[GC_MARK_L_marked_obj] = gc_mark_laddr(marked_obj);
+        gc_mark_label_addrs[GC_MARK_L_scan_only] = gc_mark_laddr(scan_only);
+        gc_mark_label_addrs[GC_MARK_L_finlist] = gc_mark_laddr(finlist);
+        gc_mark_label_addrs[GC_MARK_L_objarray] = gc_mark_laddr(objarray);
+        gc_mark_label_addrs[GC_MARK_L_obj8] = gc_mark_laddr(obj8);
+        gc_mark_label_addrs[GC_MARK_L_obj16] = gc_mark_laddr(obj16);
+        gc_mark_label_addrs[GC_MARK_L_obj32] = gc_mark_laddr(obj32);
+        gc_mark_label_addrs[GC_MARK_L_stack] = gc_mark_laddr(stack);
+        gc_mark_label_addrs[GC_MARK_L_module_binding] = gc_mark_laddr(module_binding);
         return;
-    d++;
-    if (d >= MAX_MARK_DEPTH)
-        goto queue_the_root;
+    }
 
-    // some values have special representations
-    if (vt == jl_simplevector_type) {
-        size_t l = jl_svec_len(v);
-        jl_value_t **data = jl_svec_data(v);
-        nptr += l;
-        for(size_t i=0; i < l; i++) {
-            jl_value_t *elt = data[i];
-            if (elt != NULL) {
-                verify_parent2("svec", v, &data[i], "elem(%d)", (int)i);
-                refyoung |= gc_push_root(ptls, elt, d);
+    jl_value_t *new_obj = NULL;
+    uintptr_t tag = 0;
+    uint8_t bits = 0;
+    int meta_updated = 0;
+
+    gc_mark_objarray_t *objary;
+    jl_value_t **objary_begin;
+    jl_value_t **objary_end;
+
+    gc_mark_obj8_t *obj8;
+    char *obj8_parent;
+    jl_fielddesc8_t *obj8_begin;
+    jl_fielddesc8_t *obj8_end;
+
+    gc_mark_obj16_t *obj16;
+    char *obj16_parent;
+    jl_fielddesc16_t *obj16_begin;
+    jl_fielddesc16_t *obj16_end;
+
+pop:
+    if (sp.pc == sp.pc_start) {
+        // TODO: stealing form another thread
+        return;
+    }
+    sp.pc--;
+    gc_mark_jmp(*sp.pc); // computed goto
+
+marked_obj: {
+        // An object that has been marked and needs have metadata updated and scanned.
+        gc_mark_marked_obj_t *obj = gc_pop_markdata(&sp, gc_mark_marked_obj_t);
+        new_obj = obj->obj;
+        tag = obj->tag;
+        bits = obj->bits;
+        goto mark;
+    }
+
+scan_only: {
+        // An object that has been marked and needs to be scanned.
+        gc_mark_marked_obj_t *obj = gc_pop_markdata(&sp, gc_mark_marked_obj_t);
+        new_obj = obj->obj;
+        tag = obj->tag;
+        bits = obj->bits;
+        meta_updated = 1;
+        goto mark;
+    }
+
+objarray:
+    objary = gc_pop_markdata(&sp, gc_mark_objarray_t);
+    objary_begin = objary->begin;
+    objary_end = objary->end;
+objarray_loaded:
+    if (gc_mark_scan_objarray(ptls, &sp, objary, objary_begin, objary_end,
+                              &new_obj, &tag, &bits))
+        goto mark;
+    goto pop;
+
+obj8:
+    obj8 = gc_pop_markdata(&sp, gc_mark_obj8_t);
+    obj8_parent = (char*)obj8->parent;
+    obj8_begin = obj8->begin;
+    obj8_end = obj8->end;
+obj8_loaded:
+    if (gc_mark_scan_obj8(ptls, &sp, obj8, obj8_parent, obj8_begin, obj8_end,
+                          &new_obj, &tag, &bits))
+        goto mark;
+    goto pop;
+
+obj16:
+    obj16 = gc_pop_markdata(&sp, gc_mark_obj16_t);
+    obj16_parent = (char*)obj16->parent;
+    obj16_begin = obj16->begin;
+    obj16_end = obj16->end;
+obj16_loaded:
+    if (gc_mark_scan_obj16(ptls, &sp, obj16, obj16_parent, obj16_begin, obj16_end,
+                           &new_obj, &tag, &bits))
+        goto mark;
+    goto pop;
+
+obj32: {
+        gc_mark_obj32_t *obj32 = gc_pop_markdata(&sp, gc_mark_obj32_t);
+        char *parent = (char*)obj32->parent;
+        jl_fielddesc32_t *begin = obj32->begin;
+        jl_fielddesc32_t *end = obj32->end;
+        if (gc_mark_scan_obj32(ptls, &sp, obj32, parent, begin, end, &new_obj, &tag, &bits))
+            goto mark;
+        goto pop;
+    }
+
+stack: {
+        // Scan the stack. see `gc_mark_stackframe_t`
+        // The task object this stack belongs to is being scanned separately as a normal
+        // 8bit field descriptor object.
+        gc_mark_stackframe_t *stack = gc_pop_markdata(&sp, gc_mark_stackframe_t);
+        jl_gcframe_t *s = stack->s;
+        uint32_t i = stack->i;
+        uint32_t nroots = stack->nroots;
+        uintptr_t offset = stack->offset;
+        uintptr_t lb = stack->lb;
+        uintptr_t ub = stack->ub;
+        uint32_t nr = nroots >> 1;
+        uintptr_t nptr = 0;
+        while (1) {
+            jl_value_t ***rts = (jl_value_t***)(((void**)s) + 2);
+            for (; i < nr; i++) {
+                if (nroots & 1) {
+                    void **slot = (void**)gc_read_stack(&rts[i], offset, lb, ub);
+                    new_obj = (jl_value_t*)gc_read_stack(slot, offset, lb, ub);
+                }
+                else {
+                    new_obj = (jl_value_t*)gc_read_stack(&rts[i], offset, lb, ub);
+                }
+                if (!gc_try_setmark(new_obj, &nptr, &tag, &bits))
+                    continue;
+                i++;
+                if (i < nr) {
+                    // Haven't done with this one yet. Update the content and push it back
+                    stack->i = i;
+                    gc_repush_markdata(&sp, gc_mark_stackframe_t);
+                }
+                else if ((s = (jl_gcframe_t*)gc_read_stack(&s->prev, offset, lb, ub))) {
+                    stack->s = s;
+                    stack->i = 0;
+                    uintptr_t new_nroots = gc_read_stack(&s->nroots, offset, lb, ub);
+                    assert(new_nroots <= UINT32_MAX);
+                    stack->nroots = (uint32_t)new_nroots;
+                    gc_repush_markdata(&sp, gc_mark_stackframe_t);
+                }
+                goto mark;
+            }
+            s = (jl_gcframe_t*)gc_read_stack(&s->prev, offset, lb, ub);
+            if (s != 0) {
+                stack->s = s;
+                i = 0;
+                uintptr_t new_nroots = gc_read_stack(&s->nroots, offset, lb, ub);
+                assert(new_nroots <= UINT32_MAX);
+                nroots = stack->nroots = (uint32_t)new_nroots;
+                nr = nroots >> 1;
+                continue;
             }
+            goto pop;
         }
     }
-    else if (vt->name == jl_array_typename) {
-        jl_array_t *a = (jl_array_t*)v;
-        jl_array_flags_t flags = a->flags;
-        if (flags.how == 3) {
-            jl_value_t *owner = jl_array_data_owner(a);
-            refyoung |= gc_push_root(ptls, owner, d);
-            goto ret;
-        }
-        else if (flags.how == 1) {
-            void *val_buf = jl_astaggedvalue((char*)a->data -
-                                             a->offset * a->elsize);
-            verify_parent1("array", v, &val_buf,
-                           "buffer ('loc' addr is meaningless)");
-            (void)val_buf;
-            gc_setmark_buf(ptls, (char*)a->data - a->offset * a->elsize,
-                           bits, array_nbytes(a));
-        }
-        if (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
-                // copying the whole array into the mark queue
-                goto queue_the_root;
+
+module_binding: {
+        // Scan a module. see `gc_mark_binding_t`
+        // Other fields of the module will be scanned after the bindings are scanned
+        gc_mark_binding_t *binding = gc_pop_markdata(&sp, gc_mark_binding_t);
+        jl_binding_t **begin = binding->begin;
+        jl_binding_t **end = binding->end;
+        uint8_t mbits = binding->bits;
+        for (; begin < end; begin += 2) {
+            jl_binding_t *b = *begin;
+            if (b == (jl_binding_t*)HT_NOTFOUND)
+                continue;
+            if ((void*)b >= sysimg_base && (void*)b < sysimg_end) {
+                jl_taggedvalue_t *buf = jl_astaggedvalue(b);
+                uintptr_t tag = buf->header;
+                uint8_t bits;
+                if (!gc_marked(tag))
+                    gc_setmark_tag(buf, GC_OLD_MARKED, tag, &bits);
             }
             else {
-                nptr += l;
-                void *data = a->data;
-                for (size_t i=0; i < l; i++) {
-                    jl_value_t *elt = ((jl_value_t**)data)[i];
-                    if (elt != NULL) {
-                        verify_parent2("array", v, &((jl_value_t**)data)[i], "elem(%d)", (int)i);
-                        refyoung |= gc_push_root(ptls, elt, d);
+                gc_setmark_buf_(ptls, b, mbits, sizeof(jl_binding_t));
+            }
+            void *vb = jl_astaggedvalue(b);
+            verify_parent1("module", binding->parent, &vb, "binding_buff");
+            (void)vb;
+            jl_value_t *value = b->value;
+            jl_value_t *globalref = b->globalref;
+            if (value) {
+                verify_parent2("module", binding->parent,
+                               &b->value, "binding(%s)", jl_symbol_name(b->name));
+                if (gc_try_setmark(value, &binding->nptr, &tag, &bits)) {
+                    new_obj = value;
+                    begin += 2;
+                    binding->begin = begin;
+                    gc_repush_markdata(&sp, gc_mark_binding_t);
+                    uintptr_t gr_tag;
+                    uint8_t gr_bits;
+                    if (gc_try_setmark(globalref, &binding->nptr, &gr_tag, &gr_bits)) {
+                        gc_mark_marked_obj_t data = {globalref, gr_tag, gr_bits};
+                        gc_mark_stack_push(&ptls->gc_cache, &sp, gc_mark_laddr(marked_obj),
+                                           &data, sizeof(data), 1);
                     }
+                    goto mark;
                 }
             }
+            if (gc_try_setmark(globalref, &binding->nptr, &tag, &bits)) {
+                begin += 2;
+                binding->begin = begin;
+                gc_repush_markdata(&sp, gc_mark_binding_t);
+                new_obj = globalref;
+                goto mark;
+            }
         }
-    }
-    else if (vt == jl_module_type) {
-        // should increase nptr here
-        refyoung |= gc_mark_module(ptls, (jl_module_t*)v, d, bits);
-    }
-    else if (vt == jl_task_type) {
-        // ditto nptr
-        gc_mark_task(ptls, (jl_task_t*)v, d, bits);
-        // tasks should always be remarked since we do not trigger the write barrier
-        // for stores to stack slots
-        refyoung = 1;
-    }
-    else {
-        int nf = (int)jl_datatype_nfields(vt);
-        uint32_t npointers = vt->layout->npointers;
-        nptr += (npointers & 0xff) << (npointers & 0x300);
-        for(int i=0; i < nf; i++) {
-            if (jl_field_isptr(vt, i)) {
-                jl_value_t **slot = (jl_value_t**)((char*)v +
-                                                   jl_field_offset(vt, i));
-                jl_value_t *fld = *slot;
-                if (fld) {
-                    verify_parent2("object", v, slot, "field(%d)", i);
-                    refyoung |= gc_push_root(ptls, fld, d);
-                }
+        jl_module_t *m = binding->parent;
+        int scanparent = gc_try_setmark((jl_value_t*)m->parent, &binding->nptr, &tag, &bits);
+        size_t nusings = m->usings.len;
+        if (nusings) {
+            // this is only necessary because bindings for "using" modules
+            // are added only when accessed. therefore if a module is replaced
+            // after "using" it but before accessing it, this array might
+            // contain the only reference.
+            objary_begin = (jl_value_t**)m->usings.items;
+            objary_end = objary_begin + nusings;
+            gc_mark_objarray_t data = {(jl_value_t*)m, objary_begin, objary_end, binding->nptr};
+            gc_mark_stack_push(&ptls->gc_cache, &sp, gc_mark_laddr(objarray),
+                               &data, sizeof(data), 0);
+            if (!scanparent) {
+                objary = (gc_mark_objarray_t*)sp.data;
+                goto objarray_loaded;
             }
+            sp.data += sizeof(data);
+            sp.pc++;
+        }
+        else {
+            gc_mark_push_remset(ptls, (jl_value_t*)m, binding->nptr);
+        }
+        if (scanparent) {
+            new_obj = (jl_value_t*)m->parent;
+            goto mark;
         }
+        goto pop;
     }
 
-ret:
-    if ((bits == GC_OLD_MARKED) && refyoung && !gc_verifying) {
-        ptls->heap.remset_nptr += nptr;
-        // v is an old object referencing young objects
-        arraylist_push(ptls->heap.remset, v);
+finlist: {
+        // Scan a finalizer list. see `gc_mark_finlist_t`
+        gc_mark_finlist_t *finlist = gc_pop_markdata(&sp, gc_mark_finlist_t);
+        jl_value_t **begin = finlist->begin;
+        jl_value_t **end = finlist->end;
+        for (; begin < end; begin++) {
+            new_obj = *begin;
+            if (__unlikely(!new_obj))
+                continue;
+            if (gc_ptr_tag(new_obj, 1)) {
+                new_obj = (jl_value_t*)gc_ptr_clear_tag(new_obj, 1);
+                begin++;
+                assert(begin < end);
+            }
+            uintptr_t nptr = 0;
+            if (!gc_try_setmark(new_obj, &nptr, &tag, &bits))
+                continue;
+            begin++;
+            // Found an object to mark
+            if (begin < end) {
+                // Haven't done with this one yet. Update the content and push it back
+                finlist->begin = begin;
+                gc_repush_markdata(&sp, gc_mark_finlist_t);
+            }
+            goto mark;
+        }
+        goto pop;
     }
-    return;
-
-queue_the_root:
-    if (mark_sp >= mark_stack_size)
-        grow_mark_stack();
-    mark_stack[mark_sp++] = (jl_value_t*)v;
-}
-
-STATIC_INLINE void gc_scan_obj(jl_ptls_t ptls, jl_value_t *v, int d,
-                               uintptr_t tag)
-{
-    gc_scan_obj_(ptls, v, d, tag & ~(uintptr_t)15, tag & 0xf);
-}
 
-// Update the metadata of a marked object (without scanning it).
-static void gc_mark_obj(jl_ptls_t ptls, jl_value_t *v,
-                        uintptr_t tag, uint8_t bits)
-{
-    assert(v != NULL);
-    assert(gc_marked(bits));
-    jl_taggedvalue_t *o = jl_astaggedvalue(v);
-    jl_datatype_t *vt = (jl_datatype_t*)(tag & ~(uintptr_t)15);
-    gc_assert_datatype(vt);
-    // Symbols are always marked
-    assert(vt != jl_symbol_type);
-
-    // some values have special representations
-    if (vt == jl_simplevector_type) {
-        size_t l = jl_svec_len(v);
-        gc_setmark(ptls, o, bits, l * sizeof(void*) + sizeof(jl_svec_t));
-    }
-    else if (vt->name == jl_array_typename) {
-        jl_array_t *a = (jl_array_t*)v;
-        jl_array_flags_t flags = a->flags;
-        if (flags.pooled)
-            gc_setmark_pool(ptls, o, bits);
-        else
-            gc_setmark_big(ptls, o, bits);
-        if (flags.how == 2) {
-            objprofile_count(jl_malloc_tag, bits == GC_OLD_MARKED,
-                             array_nbytes(a));
-            if (bits == GC_OLD_MARKED) {
-                ptls->gc_cache.perm_scanned_bytes += array_nbytes(a);
+mark: {
+        // Generic scanning entry point.
+        // Expects `new_obj`, `tag` and `bits` to be set correctly.
+#ifdef JL_DEBUG_BUILD
+        if (new_obj == gc_findval)
+            jl_raise_debugger();
+#endif
+        jl_taggedvalue_t *o = jl_astaggedvalue(new_obj);
+        jl_datatype_t *vt = (jl_datatype_t*)tag;
+        int foreign_alloc = 0;
+        int update_meta = __likely(!meta_updated && !gc_verifying);
+        if (update_meta && (void*)o >= sysimg_base && (void*)o < sysimg_end) {
+            foreign_alloc = 1;
+            update_meta = 0;
+        }
+        meta_updated = 0;
+        // Symbols are always marked
+        assert(vt != jl_symbol_type);
+        if (vt == jl_simplevector_type) {
+            size_t l = jl_svec_len(new_obj);
+            jl_value_t **data = jl_svec_data(new_obj);
+            size_t dtsz = l * sizeof(void*) + sizeof(jl_svec_t);
+            if (update_meta)
+                gc_setmark(ptls, o, bits, dtsz);
+            else if (foreign_alloc)
+                objprofile_count(vt, bits == GC_OLD_MARKED, dtsz);
+            uintptr_t nptr = (l << 2) | (bits & GC_OLD);
+            objary_begin = data;
+            objary_end = data + l;
+            gc_mark_objarray_t markdata = {new_obj, objary_begin, objary_end, nptr};
+            gc_mark_stack_push(&ptls->gc_cache, &sp, gc_mark_laddr(objarray),
+                               &markdata, sizeof(markdata), 0);
+            objary = (gc_mark_objarray_t*)sp.data;
+            goto objarray_loaded;
+        }
+        else if (vt->name == jl_array_typename) {
+            jl_array_t *a = (jl_array_t*)new_obj;
+            jl_array_flags_t flags = a->flags;
+            if (update_meta) {
+                if (flags.pooled)
+                    gc_setmark_pool(ptls, o, bits);
+                else
+                    gc_setmark_big(ptls, o, bits);
+            }
+            else if (foreign_alloc)
+                objprofile_count(vt, bits == GC_OLD_MARKED, sizeof(jl_array_t));
+            if (flags.how == 1) {
+                void *val_buf = jl_astaggedvalue((char*)a->data - a->offset * a->elsize);
+                verify_parent1("array", new_obj, &val_buf, "buffer ('loc' addr is meaningless)");
+                (void)val_buf;
+                gc_setmark_buf_(ptls, (char*)a->data - a->offset * a->elsize,
+                                bits, array_nbytes(a));
+            }
+            else if (flags.how == 2) {
+                if (update_meta || foreign_alloc) {
+                    objprofile_count(jl_malloc_tag, bits == GC_OLD_MARKED,
+                                     array_nbytes(a));
+                    if (bits == GC_OLD_MARKED) {
+                        ptls->gc_cache.perm_scanned_bytes += array_nbytes(a);
+                    }
+                    else {
+                        ptls->gc_cache.scanned_bytes += array_nbytes(a);
+                    }
+                }
+            }
+            else if (flags.how == 3) {
+                jl_value_t *owner = jl_array_data_owner(a);
+                uintptr_t nptr = (1 << 2) | (bits & GC_OLD);
+                int markowner = gc_try_setmark(owner, &nptr, &tag, &bits);
+                gc_mark_push_remset(ptls, new_obj, nptr);
+                if (markowner) {
+                    new_obj = owner;
+                    goto mark;
+                }
+                goto pop;
+            }
+            if (!flags.ptrarray || a->data == NULL)
+                goto pop;
+            size_t l = jl_array_len(a);
+            uintptr_t nptr = (l << 2) | (bits & GC_OLD);
+            objary_begin = (jl_value_t**)a->data;
+            objary_end = objary_begin + l;
+            gc_mark_objarray_t markdata = {new_obj, objary_begin, objary_end, nptr};
+            gc_mark_stack_push(&ptls->gc_cache, &sp, gc_mark_laddr(objarray),
+                               &markdata, sizeof(markdata), 0);
+            objary = (gc_mark_objarray_t*)sp.data;
+            goto objarray_loaded;
+        }
+        else if (vt == jl_module_type) {
+            if (update_meta)
+                gc_setmark(ptls, o, bits, sizeof(jl_module_t));
+            else if (foreign_alloc)
+                objprofile_count(vt, bits == GC_OLD_MARKED, sizeof(jl_module_t));
+            jl_module_t *m = (jl_module_t*)new_obj;
+            jl_binding_t **table = (jl_binding_t**)m->bindings.table;
+            size_t bsize = m->bindings.size;
+            uintptr_t nptr = ((bsize + m->usings.len + 1) << 2) | (bits & GC_OLD);
+            gc_mark_binding_t markdata = {m, table + 1, table + bsize, nptr, bits};
+            gc_mark_stack_push(&ptls->gc_cache, &sp, gc_mark_laddr(module_binding),
+                               &markdata, sizeof(markdata), 0);
+            sp.data += sizeof(markdata);
+            goto module_binding;
+        }
+        else if (vt == jl_task_type) {
+            if (update_meta)
+                gc_setmark(ptls, o, bits, sizeof(jl_task_t));
+            else if (foreign_alloc)
+                objprofile_count(vt, bits == GC_OLD_MARKED, sizeof(jl_task_t));
+            jl_task_t *ta = (jl_task_t*)new_obj;
+            gc_scrub_record_task(ta);
+            int stkbuf = (ta->stkbuf != (void*)(intptr_t)-1 && ta->stkbuf != NULL);
+            int16_t tid = ta->tid;
+            jl_ptls_t ptls2 = jl_all_tls_states[tid];
+            if (stkbuf) {
+#ifdef COPY_STACKS
+                gc_setmark_buf_(ptls, ta->stkbuf, bits, ta->bufsz);
+#else
+                // stkbuf isn't owned by julia for the root task
+                if (ta != ptls2->root_task) {
+                    gc_setmark_buf_(ptls, ta->stkbuf, bits, ta->ssize);
+                }
+#endif
+            }
+            jl_gcframe_t *s = NULL;
+            size_t nroots;
+            uintptr_t offset = 0;
+            uintptr_t lb = 0;
+            uintptr_t ub = (uintptr_t)-1;
+            if (ta == ptls2->current_task) {
+                s = ptls2->pgcstack;
+            }
+            else if (stkbuf) {
+                s = ta->gcstack;
+#ifdef COPY_STACKS
+                ub = (uintptr_t)ptls2->stackbase;
+                lb = ub - ta->ssize;
+                offset = (uintptr_t)ta->stkbuf - lb;
+#endif
+            }
+            if (s) {
+                nroots = gc_read_stack(&s->nroots, offset, lb, ub);
+                assert(nroots <= UINT32_MAX);
+                gc_mark_stackframe_t stackdata = {s, 0, (uint32_t)nroots, offset, lb, ub};
+                gc_mark_stack_push(&ptls->gc_cache, &sp, gc_mark_laddr(stack),
+                                   &stackdata, sizeof(stackdata), 1);
+            }
+            const jl_datatype_layout_t *layout = jl_task_type->layout;
+            assert(layout->fielddesc_type == 0);
+            size_t nfields = layout->nfields;
+            assert(nfields > 0);
+            obj8_begin = (jl_fielddesc8_t*)jl_dt_layout_fields(layout);
+            obj8_end = obj8_begin + nfields;
+            gc_mark_obj8_t markdata = {new_obj, obj8_begin, obj8_end, (9 << 2) | 1 | bits};
+            gc_mark_stack_push(&ptls->gc_cache, &sp, gc_mark_laddr(obj8),
+                               &markdata, sizeof(markdata), 0);
+            obj8 = (gc_mark_obj8_t*)sp.data;
+            obj8_parent = (char*)ta;
+            goto obj8_loaded;
+        }
+        else if (vt == jl_string_type) {
+            size_t dtsz = jl_string_len(new_obj) + sizeof(size_t) + 1;
+            if (update_meta)
+                gc_setmark(ptls, o, bits, dtsz);
+            else if (foreign_alloc)
+                objprofile_count(vt, bits == GC_OLD_MARKED, dtsz);
+            goto pop;
+        }
+        else {
+            if (__unlikely(!jl_is_datatype(vt)))
+                gc_assert_datatype_fail(ptls, vt, sp);
+            size_t dtsz = jl_datatype_size(vt);
+            if (update_meta)
+                gc_setmark(ptls, o, bits, dtsz);
+            else if (foreign_alloc)
+                objprofile_count(vt, bits == GC_OLD_MARKED, dtsz);
+            if (vt == jl_weakref_type)
+                goto pop;
+            const jl_datatype_layout_t *layout = vt->layout;
+            uint32_t npointers = layout->npointers;
+            if (npointers == 0)
+                goto pop;
+            uintptr_t nptr = ((npointers & 0xff) << (npointers & 0x300)) << 2;
+            nptr = nptr | (bits & GC_OLD);
+            uint32_t offsets = jl_datatype_layout_n_nonptr(layout);
+            size_t nfields = layout->nfields;
+            nfields -= offsets & 0xffff;
+            size_t first = offsets >> 16;
+            if (layout->fielddesc_type == 0) {
+                jl_fielddesc8_t *desc = (jl_fielddesc8_t*)jl_dt_layout_fields(layout);
+                obj8_parent = (char*)new_obj;
+                obj8_begin = desc + first;
+                obj8_end = desc + nfields;
+                assert(obj8_begin < obj8_end);
+                gc_mark_obj8_t markdata = {new_obj, obj8_begin, obj8_end, nptr};
+                gc_mark_stack_push(&ptls->gc_cache, &sp, gc_mark_laddr(obj8),
+                                   &markdata, sizeof(markdata), 0);
+                obj8 = (gc_mark_obj8_t*)sp.data;
+                goto obj8_loaded;
+            }
+            else if (layout->fielddesc_type == 1) {
+                jl_fielddesc16_t *desc = (jl_fielddesc16_t*)jl_dt_layout_fields(layout);
+                obj16_parent = (char*)new_obj;
+                obj16_begin = desc + first;
+                obj16_end = desc + nfields;
+                assert(obj16_begin < obj16_end);
+                gc_mark_obj16_t markdata = {new_obj, obj16_begin, obj16_end, nptr};
+                gc_mark_stack_push(&ptls->gc_cache, &sp, gc_mark_laddr(obj16),
+                                   &markdata, sizeof(markdata), 0);
+                obj16 = (gc_mark_obj16_t*)sp.data;
+                goto obj16_loaded;
             }
             else {
-                ptls->gc_cache.scanned_bytes += array_nbytes(a);
+                // This is very uncommon
+                // Do not do store to load forwarding to save some code size
+                assert(layout->fielddesc_type == 2);
+                jl_fielddesc32_t *desc = (jl_fielddesc32_t*)jl_dt_layout_fields(layout);
+                assert(first < nfields);
+                gc_mark_obj32_t markdata = {new_obj, desc + first, desc + nfields, nptr};
+                gc_mark_stack_push(&ptls->gc_cache, &sp, gc_mark_laddr(obj32),
+                                   &markdata, sizeof(markdata), 0);
+                sp.data += sizeof(markdata);
+                goto obj32;
             }
         }
     }
-    else if (vt == jl_module_type) {
-        gc_setmark(ptls, o, bits, sizeof(jl_module_t));
-    }
-    else if (vt == jl_task_type) {
-        gc_setmark(ptls, o, bits, sizeof(jl_task_t));
-    }
-    else if (vt == jl_string_type) {
-        gc_setmark(ptls, o, bits, jl_string_len(v) + sizeof(size_t) + 1);
-    }
-    else {
-        gc_setmark(ptls, o, bits, jl_datatype_size(vt));
-    }
-}
-
-void visit_mark_stack(jl_ptls_t ptls)
-{
-    while (mark_sp > 0 && !should_timeout()) {
-        jl_value_t *v = mark_stack[--mark_sp];
-        assert(jl_astaggedvalue(v)->bits.gc);
-        gc_scan_obj(ptls, v, 0, jl_astaggedvalue(v)->header);
-    }
-    assert(!mark_sp);
 }
 
 extern jl_array_t *jl_module_init_order;
 extern jl_typemap_entry_t *call_cache[N_CALL_CACHE];
 extern jl_array_t *jl_all_methods;
 
-static void jl_gc_mark_thread_local(jl_ptls_t ptls, jl_ptls_t ptls2)
+static void jl_gc_queue_thread_local(jl_gc_mark_cache_t *gc_cache, gc_mark_sp_t *sp,
+                                     jl_ptls_t ptls2)
 {
     // `current_module` might not have a value when the thread is not
     // running.
     if (ptls2->current_module)
-        gc_push_root(ptls, ptls2->current_module, 0);
-    gc_push_root(ptls, ptls2->current_task, 0);
-    gc_push_root(ptls, ptls2->root_task, 0);
-    gc_push_root(ptls, ptls2->exception_in_transit, 0);
-    gc_push_root(ptls, ptls2->task_arg_in_transit, 0);
+        gc_mark_queue_obj(gc_cache, sp, ptls2->current_module);
+    gc_mark_queue_obj(gc_cache, sp, ptls2->current_task);
+    gc_mark_queue_obj(gc_cache, sp, ptls2->root_task);
+    gc_mark_queue_obj(gc_cache, sp, ptls2->exception_in_transit);
 }
 
 // mark the initial root set
-static void mark_roots(jl_ptls_t ptls)
+static void mark_roots(jl_gc_mark_cache_t *gc_cache, gc_mark_sp_t *sp)
 {
     // modules
-    gc_push_root(ptls, jl_main_module, 0);
-    gc_push_root(ptls, jl_internal_main_module, 0);
+    gc_mark_queue_obj(gc_cache, sp, jl_main_module);
+    gc_mark_queue_obj(gc_cache, sp, jl_internal_main_module);
 
     // invisible builtin values
     if (jl_an_empty_vec_any != NULL)
-        gc_push_root(ptls, jl_an_empty_vec_any, 0);
+        gc_mark_queue_obj(gc_cache, sp, jl_an_empty_vec_any);
     if (jl_module_init_order != NULL)
-        gc_push_root(ptls, jl_module_init_order, 0);
-    gc_push_root(ptls, jl_cfunction_list.unknown, 0);
-    gc_push_root(ptls, jl_anytuple_type_type, 0);
-    gc_push_root(ptls, jl_ANY_flag, 0);
+        gc_mark_queue_obj(gc_cache, sp, jl_module_init_order);
+    gc_mark_queue_obj(gc_cache, sp, jl_cfunction_list.unknown);
+    gc_mark_queue_obj(gc_cache, sp, jl_anytuple_type_type);
+    gc_mark_queue_obj(gc_cache, sp, jl_ANY_flag);
     for (size_t i = 0; i < N_CALL_CACHE; i++)
         if (call_cache[i])
-            gc_push_root(ptls, call_cache[i], 0);
+            gc_mark_queue_obj(gc_cache, sp, call_cache[i]);
     if (jl_all_methods != NULL)
-        gc_push_root(ptls, jl_all_methods, 0);
+        gc_mark_queue_obj(gc_cache, sp, jl_all_methods);
 
-    // gc_push_root(ptls, jl_unprotect_stack_func, 0);
+#ifndef COPY_STACKS
+    gc_mark_queue_obj(gc_cache, sp, jl_unprotect_stack_func);
+#endif
 
     // constants
-    gc_push_root(ptls, jl_typetype_type, 0);
-    gc_push_root(ptls, jl_emptytuple_type, 0);
+    gc_mark_queue_obj(gc_cache, sp, jl_typetype_type);
+    gc_mark_queue_obj(gc_cache, sp, jl_emptytuple_type);
 }
 
 // find unmarked objects that need to be finalized from the finalizer list "list".
@@ -1712,7 +2313,7 @@ static void sweep_finalizer_list(arraylist_t *list)
         if (isfreed) {
             // schedule finalizer or execute right away if it is not julia code
             if (is_cptr) {
-                ((void (*)(void*))fin)(jl_data_ptr(v));
+                ((void (*)(void*))(uintptr_t)fin)(jl_data_ptr(v));
                 continue;
             }
             schedule_finalization(v, fin);
@@ -1805,14 +2406,12 @@ static void jl_gc_premark(jl_ptls_t ptls2)
     }
 }
 
-static void jl_gc_mark_remset(jl_ptls_t ptls, jl_ptls_t ptls2)
+static void jl_gc_queue_remset(jl_gc_mark_cache_t *gc_cache, gc_mark_sp_t *sp, jl_ptls_t ptls2)
 {
     size_t len = ptls2->heap.last_remset->len;
     void **items = ptls2->heap.last_remset->items;
-    for (size_t i = 0; i < len; i++) {
-        jl_value_t *item = (jl_value_t*)items[i];
-        gc_scan_obj(ptls, item, 0, jl_astaggedvalue(item)->header);
-    }
+    for (size_t i = 0; i < len; i++)
+        gc_mark_queue_scan_obj(gc_cache, sp, (jl_value_t*)items[i]);
     int n_bnd_refyoung = 0;
     len = ptls2->heap.rem_bindings.len;
     items = ptls2->heap.rem_bindings.items;
@@ -1821,7 +2420,7 @@ static void jl_gc_mark_remset(jl_ptls_t ptls, jl_ptls_t ptls2)
         // A null pointer can happen here when the binding is cleaned up
         // as an exception is thrown after it was already queued (#10221)
         if (!ptr->value) continue;
-        if (gc_push_root(ptls, ptr->value, 0)) {
+        if (gc_mark_queue_obj(gc_cache, sp, ptr->value)) {
             items[n_bnd_refyoung] = ptr;
             n_bnd_refyoung++;
         }
@@ -1829,22 +2428,15 @@ static void jl_gc_mark_remset(jl_ptls_t ptls, jl_ptls_t ptls2)
     ptls2->heap.rem_bindings.len = n_bnd_refyoung;
 }
 
-static void jl_gc_mark_ptrfree(jl_ptls_t ptls)
-{
-    // Pointer-free objects, can be marked concurrently
-    jl_mark_box_caches(ptls);
-    jl_gc_setmark(ptls, (jl_value_t*)jl_emptysvec);
-    jl_gc_setmark(ptls, jl_emptytuple);
-    jl_gc_setmark(ptls, jl_true);
-    jl_gc_setmark(ptls, jl_false);
-}
-
 // Only one thread should be running in this function
 static int _jl_gc_collect(jl_ptls_t ptls, int full)
 {
+    jl_gc_mark_cache_t *gc_cache = &ptls->gc_cache;
+    gc_mark_sp_t sp;
+    gc_mark_sp_init(gc_cache, &sp);
+
     uint64_t t0 = jl_hrtime();
     int64_t last_perm_scanned_bytes = perm_scanned_bytes;
-    assert(mark_sp == 0);
 
     // 1. fix GC bits of objects in the remset.
     for (int t_i = 0; t_i < jl_n_threads; t_i++)
@@ -1853,14 +2445,15 @@ static int _jl_gc_collect(jl_ptls_t ptls, int full)
     for (int t_i = 0; t_i < jl_n_threads; t_i++) {
         jl_ptls_t ptls2 = jl_all_tls_states[t_i];
         // 2.1. mark every object in the `last_remsets` and `rem_binding`
-        jl_gc_mark_remset(ptls, ptls2);
+        jl_gc_queue_remset(gc_cache, &sp, ptls2);
         // 2.2. mark every thread local root
-        jl_gc_mark_thread_local(ptls, ptls2);
+        jl_gc_queue_thread_local(gc_cache, &sp, ptls2);
     }
 
     // 3. walk roots
-    mark_roots(ptls);
-    visit_mark_stack(ptls);
+    mark_roots(gc_cache, &sp);
+    gc_mark_loop(ptls, sp);
+    gc_mark_sp_init(gc_cache, &sp);
     gc_num.since_sweep += gc_num.allocd + (int64_t)gc_num.interval;
     gc_settime_premark_end();
     gc_time_mark_pause(t0, scanned_bytes, perm_scanned_bytes);
@@ -1882,19 +2475,20 @@ static int _jl_gc_collect(jl_ptls_t ptls, int full)
     }
     for (int i = 0;i < jl_n_threads;i++) {
         jl_ptls_t ptls2 = jl_all_tls_states[i];
-        gc_mark_object_list(ptls, &ptls2->finalizers, 0);
+        gc_mark_queue_finlist(gc_cache, &sp, &ptls2->finalizers, 0);
     }
-    gc_mark_object_list(ptls, &finalizer_list_marked, orig_marked_len);
+    gc_mark_queue_finlist(gc_cache, &sp, &finalizer_list_marked, orig_marked_len);
     // "Flush" the mark stack before flipping the reset_age bit
     // so that the objects are not incorrectly resetted.
-    visit_mark_stack(ptls);
+    gc_mark_loop(ptls, sp);
+    gc_mark_sp_init(gc_cache, &sp);
     mark_reset_age = 1;
     // Reset the age and old bit for any unmarked objects referenced by the
     // `to_finalize` list. These objects are only reachable from this list
     // and should not be referenced by any old objects so this won't break
     // the GC invariant.
-    gc_mark_object_list(ptls, &to_finalize, 0);
-    visit_mark_stack(ptls);
+    gc_mark_queue_finlist(gc_cache, &sp, &to_finalize, 0);
+    gc_mark_loop(ptls, sp);
     mark_reset_age = 0;
     gc_settime_postmark_end();
 
@@ -1956,6 +2550,8 @@ static int _jl_gc_collect(jl_ptls_t ptls, int full)
     gc_scrub();
     gc_verify_tags();
     gc_sweep_pool(sweep_full);
+    if (sweep_full)
+        gc_sweep_perm_alloc();
     // 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.
@@ -2015,14 +2611,13 @@ JL_DLLEXPORT void jl_gc_collect(int full)
     JL_TIMING(GC);
     // Now we are ready to wait for other threads to hit the safepoint,
     // we can do a few things that doesn't require synchronization.
-    jl_gc_mark_ptrfree(ptls);
+    // TODO (concurrently queue objects)
     // no-op for non-threading
     jl_gc_wait_for_the_world();
 
     if (!jl_gc_disable_counter) {
         JL_LOCK_NOGC(&finalizers_lock);
         if (_jl_gc_collect(ptls, full)) {
-            jl_gc_mark_ptrfree(ptls);
             int ret = _jl_gc_collect(ptls, 0);
             (void)ret;
             assert(!ret);
@@ -2045,12 +2640,12 @@ JL_DLLEXPORT void jl_gc_collect(int full)
     }
 }
 
-void mark_all_roots(jl_ptls_t ptls)
+void gc_mark_queue_all_roots(jl_ptls_t ptls, gc_mark_sp_t *sp)
 {
+    jl_gc_mark_cache_t *gc_cache = &ptls->gc_cache;
     for (size_t i = 0; i < jl_n_threads; i++)
-        jl_gc_mark_thread_local(ptls, jl_all_tls_states[i]);
-    mark_roots(ptls);
-    jl_gc_mark_ptrfree(ptls);
+        jl_gc_queue_thread_local(gc_cache, sp, jl_all_tls_states[i]);
+    mark_roots(gc_cache, sp);
 }
 
 // allocator entry points
@@ -2060,8 +2655,8 @@ JL_DLLEXPORT jl_value_t *(jl_gc_alloc)(jl_ptls_t ptls, size_t sz, void *ty)
     return jl_gc_alloc_(ptls, sz, ty);
 }
 
-// Per-thread initialization (when threading is fully implemented)
-void jl_mk_thread_heap(jl_ptls_t ptls)
+// Per-thread initialization
+void jl_init_thread_heap(jl_ptls_t ptls)
 {
     jl_thread_heap_t *heap = &ptls->heap;
     jl_gc_pool_t *p = heap->norm_pools;
@@ -2083,6 +2678,16 @@ void jl_mk_thread_heap(jl_ptls_t ptls)
     arraylist_new(heap->remset, 0);
     arraylist_new(heap->last_remset, 0);
     arraylist_new(&ptls->finalizers, 0);
+
+    jl_gc_mark_cache_t *gc_cache = &ptls->gc_cache;
+    gc_cache->perm_scanned_bytes = 0;
+    gc_cache->scanned_bytes = 0;
+    gc_cache->nbig_obj = 0;
+    JL_MUTEX_INIT(&gc_cache->stack_lock);
+    size_t init_size = 1024;
+    gc_cache->pc_stack = (void**)malloc(init_size * sizeof(void*));
+    gc_cache->pc_stack_end = gc_cache->pc_stack + init_size;
+    gc_cache->data_stack = (char*)malloc(init_size * sizeof(gc_mark_data_t));
 }
 
 // System-wide initializations
@@ -2099,17 +2704,20 @@ void jl_gc_init(void)
     gc_num.allocd = -default_collect_interval;
 
 #ifdef _P64
-    // on a big memory machine, set max_collect_interval to totalmem/ncores/2
-    size_t maxmem = (uv_get_total_memory()/jl_cpu_cores())/2;
+    // on a big memory machine, set max_collect_interval to totalmem * nthreads / ncores / 2
+    size_t maxmem = (uv_get_total_memory() * jl_n_threads) / jl_cpu_cores() / 2;
     if (maxmem > max_collect_interval)
         max_collect_interval = maxmem;
 #endif
+    gc_mark_sp_t sp = {NULL, NULL, NULL, NULL};
+    gc_mark_loop(NULL, sp);
 }
 
+// allocation wrappers that track allocation and let collection run
+
 JL_DLLEXPORT void *jl_gc_counted_malloc(size_t sz)
 {
     jl_ptls_t ptls = jl_get_ptls_states();
-    sz += JL_SMALL_BYTE_ALIGNMENT;
     maybe_collect(ptls);
     gc_num.allocd += sz;
     gc_num.malloc++;
@@ -2122,7 +2730,6 @@ JL_DLLEXPORT void *jl_gc_counted_malloc(size_t sz)
 JL_DLLEXPORT void *jl_gc_counted_calloc(size_t nm, size_t sz)
 {
     jl_ptls_t ptls = jl_get_ptls_states();
-    nm += JL_SMALL_BYTE_ALIGNMENT;
     maybe_collect(ptls);
     gc_num.allocd += nm*sz;
     gc_num.malloc++;
@@ -2132,23 +2739,27 @@ JL_DLLEXPORT void *jl_gc_counted_calloc(size_t nm, size_t sz)
     return b;
 }
 
-JL_DLLEXPORT void jl_gc_counted_free(void *p, size_t sz)
+JL_DLLEXPORT void jl_gc_counted_free_with_size(void *p, size_t sz)
 {
     free(p);
-    gc_num.freed += sz + JL_SMALL_BYTE_ALIGNMENT;
+    gc_num.freed += sz;
     gc_num.freecall++;
 }
 
+// older name for jl_gc_counted_free_with_size
+JL_DLLEXPORT void jl_gc_counted_free(void *p, size_t sz)
+{
+    jl_gc_counted_free_with_size(p, sz);
+}
+
 JL_DLLEXPORT void *jl_gc_counted_realloc_with_old_size(void *p, size_t old, size_t sz)
 {
     jl_ptls_t ptls = jl_get_ptls_states();
-    old += JL_SMALL_BYTE_ALIGNMENT;
-    sz += JL_SMALL_BYTE_ALIGNMENT;
     maybe_collect(ptls);
     if (sz < old)
-       gc_num.freed += (old - sz);
+        gc_num.freed += (old - sz);
     else
-       gc_num.allocd += (sz - old);
+        gc_num.allocd += (sz - old);
     gc_num.realloc++;
     void *b = realloc(p, sz);
     if (b == NULL)
@@ -2156,18 +2767,20 @@ JL_DLLEXPORT void *jl_gc_counted_realloc_with_old_size(void *p, size_t old, size
     return b;
 }
 
+// allocation wrappers that save the size of allocations, to allow using
+// jl_gc_counted_* functions with a libc-compatible API.
+
 JL_DLLEXPORT void *jl_malloc(size_t sz)
 {
-    int64_t *p = (int64_t *)jl_gc_counted_malloc(sz);
+    int64_t *p = (int64_t *)jl_gc_counted_malloc(sz + JL_SMALL_BYTE_ALIGNMENT);
     p[0] = sz;
     return (void *)(p + 2);
 }
 
 JL_DLLEXPORT void *jl_calloc(size_t nm, size_t sz)
 {
-    int64_t *p;
     size_t nmsz = nm*sz;
-    p = (int64_t *)jl_gc_counted_calloc(nmsz, 1);
+    int64_t *p = (int64_t *)jl_gc_counted_calloc(nmsz + JL_SMALL_BYTE_ALIGNMENT, 1);
     p[0] = nmsz;
     return (void *)(p + 2);
 }
@@ -2177,7 +2790,7 @@ JL_DLLEXPORT void jl_free(void *p)
     if (p != NULL) {
         int64_t *pp = (int64_t *)p - 2;
         size_t sz = pp[0];
-        jl_gc_counted_free(pp, sz);
+        jl_gc_counted_free_with_size(pp, sz + JL_SMALL_BYTE_ALIGNMENT);
     }
 }
 
@@ -2191,13 +2804,15 @@ JL_DLLEXPORT void *jl_realloc(void *p, size_t sz)
     }
     else {
         pp = (int64_t *)p - 2;
-        szold = pp[0];
+        szold = pp[0] + JL_SMALL_BYTE_ALIGNMENT;
     }
-    int64_t *pnew = (int64_t *)jl_gc_counted_realloc_with_old_size(pp, szold, sz);
+    int64_t *pnew = (int64_t *)jl_gc_counted_realloc_with_old_size(pp, szold, sz + JL_SMALL_BYTE_ALIGNMENT);
     pnew[0] = sz;
     return (void *)(pnew + 2);
 }
 
+// allocating blocks for Arrays and Strings
+
 JL_DLLEXPORT void *jl_gc_managed_malloc(size_t sz)
 {
     jl_ptls_t ptls = jl_get_ptls_states();
@@ -2266,7 +2881,8 @@ jl_value_t *jl_gc_realloc_string(jl_value_t *s, size_t sz)
         return snew;
     }
     size_t newsz = sz + sizeof(size_t) + 1;
-    size_t offs = offsetof(bigval_t, header);
+    size_t offs = sizeof(bigval_t);
+    size_t oldsz = LLT_ALIGN(strsz + offs, JL_CACHE_BYTE_ALIGNMENT);
     size_t allocsz = LLT_ALIGN(newsz + offs, JL_CACHE_BYTE_ALIGNMENT);
     if (allocsz < sz)  // overflow in adding offs, size was "negative"
         jl_throw(jl_memory_exception);
@@ -2278,9 +2894,7 @@ jl_value_t *jl_gc_realloc_string(jl_value_t *s, size_t sz)
     // the old pointer to be left alone if we can't grow in place.
     // for now it's up to the caller to make sure there are no references to the
     // old pointer.
-    bigval_t *newbig =
-        (bigval_t*)gc_managed_realloc_(ptls, hdr, allocsz, LLT_ALIGN(strsz+offs, JL_CACHE_BYTE_ALIGNMENT),
-                                       1, s, 0);
+    bigval_t *newbig = (bigval_t*)gc_managed_realloc_(ptls, hdr, allocsz, oldsz, 1, s, 0);
     newbig->sz = allocsz;
     newbig->age = 0;
     gc_big_object_link(newbig, &ptls->heap.big_objects);
@@ -2295,51 +2909,68 @@ jl_value_t *jl_gc_realloc_string(jl_value_t *s, size_t sz)
 // 20k limit for pool allocation. At most 1% fragmentation
 #define GC_PERM_POOL_LIMIT (20 * 1024)
 jl_mutex_t gc_perm_lock = {0, 0};
-static char *gc_perm_pool = NULL;
-static size_t gc_perm_size = 0;
+static uintptr_t gc_perm_pool = 0;
+static uintptr_t gc_perm_end = 0;
+
+static void *gc_perm_alloc_large(size_t sz, int zero, unsigned align, unsigned offset)
+{
+    // `align` must be power of two
+    assert(offset == 0 || offset < align);
+    const size_t malloc_align = sizeof(void*) == 8 ? 16 : 4;
+    if (align > 1 && (offset != 0 || align > malloc_align))
+        sz += align - 1;
+    uintptr_t base = (uintptr_t)(zero ? calloc(1, sz) : malloc(sz));
+    unsigned diff = (offset - base) % align;
+    return (void*)(base + diff);
+}
+
+STATIC_INLINE void *gc_try_perm_alloc_pool(size_t sz, unsigned align, unsigned offset)
+{
+    uintptr_t pool = LLT_ALIGN(gc_perm_pool + offset, (uintptr_t)align) - offset;
+    uintptr_t end = pool + sz;
+    if (end > gc_perm_end)
+        return NULL;
+    gc_perm_pool = end;
+    return (void*)jl_assume(pool);
+}
 
 // **NOT** a safepoint
-void *jl_gc_perm_alloc_nolock(size_t sz)
+void *jl_gc_perm_alloc_nolock(size_t sz, int zero, unsigned align, unsigned offset)
 {
     // The caller should have acquired `gc_perm_lock`
+    assert(align < GC_PERM_POOL_LIMIT);
 #ifndef MEMDEBUG
     if (__unlikely(sz > GC_PERM_POOL_LIMIT))
 #endif
-        return malloc(sz);
-    sz = LLT_ALIGN(sz, JL_SMALL_BYTE_ALIGNMENT);
-    if (__unlikely(sz > gc_perm_size)) {
+        return gc_perm_alloc_large(sz, zero, align, offset);
+    void *ptr = gc_try_perm_alloc_pool(sz, align, offset);
+    if (__likely(ptr))
+        return ptr;
 #ifdef _OS_WINDOWS_
-        void *pool = VirtualAlloc(NULL,
-                                  GC_PERM_POOL_SIZE + JL_SMALL_BYTE_ALIGNMENT,
-                                  MEM_COMMIT, PAGE_READWRITE);
-        if (__unlikely(pool == NULL))
-            return NULL;
-        pool = (void*)LLT_ALIGN((uintptr_t)pool, JL_SMALL_BYTE_ALIGNMENT);
+    void *pool = VirtualAlloc(NULL, GC_PERM_POOL_SIZE, MEM_COMMIT, PAGE_READWRITE);
+    if (__unlikely(pool == NULL))
+        return NULL;
 #else
-        void *pool = mmap(0, GC_PERM_POOL_SIZE, PROT_READ | PROT_WRITE,
-                          MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
-        if (__unlikely(pool == MAP_FAILED))
-            return NULL;
+    void *pool = mmap(0, GC_PERM_POOL_SIZE, PROT_READ | PROT_WRITE,
+                      MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+    if (__unlikely(pool == MAP_FAILED))
+        return NULL;
 #endif
-        gc_perm_pool = (char*)pool;
-        gc_perm_size = GC_PERM_POOL_SIZE;
-    }
-    assert(((uintptr_t)gc_perm_pool) % JL_SMALL_BYTE_ALIGNMENT == 0);
-    void *p = gc_perm_pool;
-    gc_perm_size -= sz;
-    gc_perm_pool += sz;
-    return p;
+    gc_perm_pool = (uintptr_t)pool;
+    gc_perm_end = gc_perm_pool + GC_PERM_POOL_SIZE;
+    return gc_try_perm_alloc_pool(sz, align, offset);
 }
 
 // **NOT** a safepoint
-void *jl_gc_perm_alloc(size_t sz)
+void *jl_gc_perm_alloc(size_t sz, int zero, unsigned align, unsigned offset)
 {
+    assert(align < GC_PERM_POOL_LIMIT);
 #ifndef MEMDEBUG
     if (__unlikely(sz > GC_PERM_POOL_LIMIT))
 #endif
-        return malloc(sz);
+        return gc_perm_alloc_large(sz, zero, align, offset);
     JL_LOCK_NOGC(&gc_perm_lock);
-    void *p = jl_gc_perm_alloc_nolock(sz);
+    void *p = jl_gc_perm_alloc_nolock(sz, zero, align, offset);
     JL_UNLOCK_NOGC(&gc_perm_lock);
     return p;
 }
diff --git a/src/gc.h b/src/gc.h
index f49bc4f13be875..3817e717d0d343 100644
--- a/src/gc.h
+++ b/src/gc.h
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 /*
   allocation and garbage collection
@@ -6,8 +6,8 @@
   . pool-allocates small objects, keeps big objects on a simple list
 */
 
-#ifndef JULIA_GC_H
-#define JULIA_GC_H
+#ifndef JL_GC_H
+#define JL_GC_H
 
 #include <stdlib.h>
 #include <string.h>
@@ -32,11 +32,7 @@ extern "C" {
 
 #define GC_PAGE_LG2 14 // log2(size of a page)
 #define GC_PAGE_SZ (1 << GC_PAGE_LG2) // 16k
-#define GC_PAGE_OFFSET (JL_SMALL_BYTE_ALIGNMENT - (sizeof(jl_taggedvalue_t) % JL_SMALL_BYTE_ALIGNMENT))
-
-// 8G * 32768 = 2^48
-// It's really unlikely that we'll actually allocate that much though...
-#define REGION_COUNT 32768
+#define GC_PAGE_OFFSET (JL_HEAP_ALIGNMENT - (sizeof(jl_taggedvalue_t) % JL_HEAP_ALIGNMENT))
 
 #define jl_malloc_tag ((void*)0xdeadaa01)
 #define jl_singleton_tag ((void*)0xdeadaa02)
@@ -78,9 +74,144 @@ typedef struct {
     int         full_sweep;
 } jl_gc_num_t;
 
+typedef struct {
+    void **pc; // Current stack address for the pc (up growing)
+    char *data; // Current stack address for the data (up growing)
+    void **pc_start; // Cached value of `gc_cache->pc_stack`
+    void **pc_end; // Cached value of `gc_cache->pc_stack_end`
+} gc_mark_sp_t;
+
+enum {
+    GC_MARK_L_marked_obj,
+    GC_MARK_L_scan_only,
+    GC_MARK_L_finlist,
+    GC_MARK_L_objarray,
+    GC_MARK_L_obj8,
+    GC_MARK_L_obj16,
+    GC_MARK_L_obj32,
+    GC_MARK_L_stack,
+    GC_MARK_L_module_binding,
+    _GC_MARK_L_MAX
+};
+
+// Pop a data struct from the mark data stack (i.e. decrease the stack pointer)
+// This should be used after dispatch and therefore the pc stack pointer is already popped from
+// the stack.
+STATIC_INLINE void *gc_pop_markdata_(gc_mark_sp_t *sp, size_t size)
+{
+    char *data = sp->data - size;
+    sp->data = data;
+    return data;
+}
+#define gc_pop_markdata(sp, type) ((type*)gc_pop_markdata_(sp, sizeof(type)))
+
+// Re-push a frame to the mark stack (both data and pc)
+// The data and pc are expected to be on the stack (or updated in place) already.
+// Mainly useful to pause the current scanning in order to scan an new object.
+STATIC_INLINE void *gc_repush_markdata_(gc_mark_sp_t *sp, size_t size)
+{
+    char *data = sp->data;
+    sp->pc++;
+    sp->data = data + size;
+    return data;
+}
+#define gc_repush_markdata(sp, type) ((type*)gc_repush_markdata_(sp, sizeof(type)))
+
+/**
+ * The `nptr` member of marking data records the number of pointers slots referenced by
+ * an object to be used in the full collection heuristics as well as whether the object
+ * references young objects.
+ * `nptr >> 2` is the number of pointers fields referenced by the object.
+ * The lowest bit of `nptr` is set if the object references young object.
+ * The 2nd lowest bit of `nptr` is the GC old bits of the object after marking.
+ * A `0x3` in the low bits means that the object needs to be in the remset.
+ */
+
+// An generic object that's marked and needs to be scanned
+// The metadata might need update too (depend on the PC)
+typedef struct {
+    jl_value_t *obj; // The object
+    uintptr_t tag; // The tag with the GC bits masked out
+    uint8_t bits; // The GC bits after tagging (`bits & 1 == 1`)
+} gc_mark_marked_obj_t;
+
+// An object array. This can come from an array, svec, or the using array or a module
+typedef struct {
+    jl_value_t *parent; // The parent object to trigger write barrier on.
+    jl_value_t **begin; // The first slot to be scanned.
+    jl_value_t **end; // The end address (after the last slot to be scanned)
+    uintptr_t nptr; // See notes about `nptr` above.
+} gc_mark_objarray_t;
+
+// A normal object with 8bits field descriptors
+typedef struct {
+    jl_value_t *parent; // The parent object to trigger write barrier on.
+    jl_fielddesc8_t *begin; // Current field descriptor.
+    jl_fielddesc8_t *end; // End of field descriptor.
+    uintptr_t nptr; // See notes about `nptr` above.
+} gc_mark_obj8_t;
+
+// A normal object with 16bits field descriptors
+typedef struct {
+    jl_value_t *parent; // The parent object to trigger write barrier on.
+    jl_fielddesc16_t *begin; // Current field descriptor.
+    jl_fielddesc16_t *end; // End of field descriptor.
+    uintptr_t nptr; // See notes about `nptr` above.
+} gc_mark_obj16_t;
+
+// A normal object with 32bits field descriptors
+typedef struct {
+    jl_value_t *parent; // The parent object to trigger write barrier on.
+    jl_fielddesc32_t *begin; // Current field descriptor.
+    jl_fielddesc32_t *end; // End of field descriptor.
+    uintptr_t nptr; // See notes about `nptr` above.
+} gc_mark_obj32_t;
+
+// Stack frame
+typedef struct {
+    jl_gcframe_t *s; // The current stack frame
+    uint32_t i; // The current slot index in the frame
+    uint32_t nroots; // `nroots` fields in the frame
+    // Parameters to mark the copy_stack range.
+    uintptr_t offset;
+    uintptr_t lb;
+    uintptr_t ub;
+} gc_mark_stackframe_t;
+
+// Module bindings. This is also the beginning of module scanning.
+// The loop will start marking other references in a module after the bindings are marked
+typedef struct {
+    jl_module_t *parent; // The parent module to trigger write barrier on.
+    jl_binding_t **begin; // The first slot to be scanned.
+    jl_binding_t **end; // The end address (after the last slot to be scanned)
+    uintptr_t nptr; // See notes about `nptr` above.
+    uint8_t bits; // GC bits of the module (the bits to mark the binding buffer with)
+} gc_mark_binding_t;
+
+// Finalizer list
+typedef struct {
+    jl_value_t **begin;
+    jl_value_t **end;
+} gc_mark_finlist_t;
+
+// This is used to determine the max size of the data objects on the data stack.
+// We'll use this size to determine the size of the data stack corresponding to a
+// PC stack size. Since the data objects are not all of the same size, we'll waste
+// some memory on the data stack this way but that size is unlikely going to be significant.
+typedef union {
+    gc_mark_marked_obj_t marked;
+    gc_mark_objarray_t objarray;
+    gc_mark_obj8_t obj8;
+    gc_mark_obj16_t obj16;
+    gc_mark_obj32_t obj32;
+    gc_mark_stackframe_t stackframe;
+    gc_mark_binding_t binding;
+    gc_mark_finlist_t finlist;
+} gc_mark_data_t;
+
 // layout for big (>2k) objects
 
-typedef struct _bigval_t {
+JL_EXTENSION typedef struct _bigval_t {
     struct _bigval_t *next;
     struct _bigval_t **prev; // pointer to the next field of the prev entry
     union {
@@ -147,33 +278,90 @@ typedef struct {
     uint8_t *ages;
 } jl_gc_pagemeta_t;
 
-typedef struct {
-    char data[GC_PAGE_SZ];
-} jl_gc_page_t
-#if !defined(_COMPILER_MICROSOFT_) && !(defined(_COMPILER_MINGW_) && defined(_COMPILER_CLANG_))
-__attribute__((aligned(GC_PAGE_SZ)))
+// Page layout:
+//  Newpage freelist: sizeof(void*)
+//  Padding: GC_PAGE_OFFSET - sizeof(void*)
+//  Blocks: osize * n
+//    Tag: sizeof(jl_taggedvalue_t)
+//    Data: <= osize - sizeof(jl_taggedvalue_t)
+
+// Memory map:
+//  The complete address space is divided up into a multi-level page table.
+//  The three levels have similar but slightly different structures:
+//    - pagetable0_t: the bottom/leaf level (covers the contiguous addresses)
+//    - pagetable1_t: the middle level
+//    - pagetable2_t: the top/leaf level (covers the entire virtual address space)
+//  Corresponding to these similar structures is a large amount of repetitive
+//  code that is nearly the same but not identical. It could be made less
+//  repetitive with C macros, but only at the cost of debuggability. The specialized
+//  structure of this representation allows us to partially unroll and optimize
+//  various conditions at each level.
+
+//  The following constants define the branching factors at each level.
+//  The constants and GC_PAGE_LG2 must therefore sum to sizeof(void*).
+//  They should all be multiples of 32 (sizeof(uint32_t)) except that REGION2_PG_COUNT may also be 1.
+#ifdef _P64
+#define REGION0_PG_COUNT (1 << 16)
+#define REGION1_PG_COUNT (1 << 16)
+#define REGION2_PG_COUNT (1 << 18)
+#define REGION0_INDEX(p) (((uintptr_t)(p) >> 14) & 0xFFFF) // shift by GC_PAGE_LG2
+#define REGION1_INDEX(p) (((uintptr_t)(p) >> 30) & 0xFFFF)
+#define REGION_INDEX(p)  (((uintptr_t)(p) >> 46) & 0x3FFFF)
+#else
+#define REGION0_PG_COUNT (1 << 8)
+#define REGION1_PG_COUNT (1 << 10)
+#define REGION2_PG_COUNT (1 << 0)
+#define REGION0_INDEX(p) (((uintptr_t)(p) >> 14) & 0xFF) // shift by GC_PAGE_LG2
+#define REGION1_INDEX(p) (((uintptr_t)(p) >> 22) & 0x3FF)
+#define REGION_INDEX(p)  (0)
 #endif
-;
+
+// define the representation of the levels of the page-table (0 to 2)
+typedef struct {
+    jl_gc_pagemeta_t *meta[REGION0_PG_COUNT];
+    uint32_t allocmap[REGION0_PG_COUNT / 32];
+    uint32_t freemap[REGION0_PG_COUNT / 32];
+    // store a lower bound of the first free page in each region
+    int lb;
+    // an upper bound of the last non-free page
+    int ub;
+} pagetable0_t;
 
 typedef struct {
-    // Page layout:
-    //  Newpage freelist: sizeof(void*)
-    //  Padding: GC_PAGE_OFFSET - sizeof(void*)
-    //  Blocks: osize * n
-    //    Tag: sizeof(jl_taggedvalue_t)
-    //    Data: <= osize - sizeof(jl_taggedvalue_t)
-    jl_gc_page_t *pages; // [pg_cnt]; must be first, to preserve page alignment
-    uint32_t *allocmap; // [pg_cnt / 32]
-    jl_gc_pagemeta_t *meta; // [pg_cnt]
-    int pg_cnt;
+    pagetable0_t *meta0[REGION1_PG_COUNT];
+    uint32_t allocmap0[REGION1_PG_COUNT / 32];
+    uint32_t freemap0[REGION1_PG_COUNT / 32];
     // store a lower bound of the first free page in each region
     int lb;
     // an upper bound of the last non-free page
     int ub;
-} region_t;
+} pagetable1_t;
+
+typedef struct {
+    pagetable1_t *meta1[REGION2_PG_COUNT];
+    uint32_t allocmap1[(REGION2_PG_COUNT + 31) / 32];
+    uint32_t freemap1[(REGION2_PG_COUNT + 31) / 32];
+    // store a lower bound of the first free page in each region
+    int lb;
+    // an upper bound of the last non-free page
+    int ub;
+} pagetable_t;
+
+STATIC_INLINE unsigned ffs_u32(uint32_t bitvec)
+{
+#if defined(_COMPILER_MINGW_)
+    return __builtin_ffs(bitvec) - 1;
+#elif defined(_COMPILER_MICROSOFT_)
+    unsigned long j;
+    _BitScanForward(&j, bitvec);
+    return j;
+#else
+    return ffs(bitvec) - 1;
+#endif
+}
 
 extern jl_gc_num_t gc_num;
-extern region_t regions[REGION_COUNT];
+extern pagetable_t memory_map;
 extern bigval_t *big_objects_marked;
 extern arraylist_t finalizer_list_marked;
 extern arraylist_t to_finalize;
@@ -200,11 +388,6 @@ STATIC_INLINE jl_taggedvalue_t *page_pfl_end(jl_gc_pagemeta_t *p)
     return (jl_taggedvalue_t*)(p->data + p->fl_end_offset);
 }
 
-STATIC_INLINE int page_index(region_t *region, void *data)
-{
-    return (gc_page_data(data) - region->pages->data) / GC_PAGE_SZ;
-}
-
 STATIC_INLINE int gc_marked(uintptr_t bits)
 {
     return (bits & GC_MARKED) != 0;
@@ -232,31 +415,50 @@ STATIC_INLINE void *gc_ptr_clear_tag(void *v, uintptr_t mask)
 
 NOINLINE uintptr_t gc_get_stack_ptr(void);
 
-STATIC_INLINE region_t *find_region(void *ptr)
+STATIC_INLINE jl_gc_pagemeta_t *page_metadata(void *_data)
 {
-    for (int i = 0; i < REGION_COUNT && regions[i].pages; i++) {
-        region_t *region = &regions[i];
-        char *begin = region->pages->data;
-        char *end = begin + region->pg_cnt * sizeof(jl_gc_page_t);
-        if ((char*)ptr >= begin && (char*)ptr <= end) {
-            return region;
-        }
-    }
-    return NULL;
+    uintptr_t data = ((uintptr_t)_data);
+    unsigned i;
+    i = REGION_INDEX(data);
+    pagetable1_t *r1 = memory_map.meta1[i];
+    if (!r1)
+        return NULL;
+    i = REGION1_INDEX(data);
+    pagetable0_t *r0 = r1->meta0[i];
+    if (!r0)
+        return NULL;
+    i = REGION0_INDEX(data);
+    return r0->meta[i];
 }
 
-STATIC_INLINE jl_gc_pagemeta_t *page_metadata(void *_data)
+struct jl_gc_metadata_ext {
+    pagetable1_t *pagetable1;
+    pagetable0_t *pagetable0;
+    jl_gc_pagemeta_t *meta;
+    unsigned pagetable_i32, pagetable_i;
+    unsigned pagetable1_i32, pagetable1_i;
+    unsigned pagetable0_i32, pagetable0_i;
+};
+
+STATIC_INLINE struct jl_gc_metadata_ext page_metadata_ext(void *_data)
 {
-    uintptr_t data = ((uintptr_t)_data) - 1;
-    for (int i = 0; i < REGION_COUNT && regions[i].pages; i++) {
-        region_t *region = &regions[i];
-        uintptr_t begin = (uintptr_t)region->pages->data;
-        uintptr_t offset = data - begin;
-        if (offset < region->pg_cnt * sizeof(jl_gc_page_t)) {
-            return &region->meta[offset >> GC_PAGE_LG2];
-        }
-    }
-    return NULL;
+    uintptr_t data = (uintptr_t)_data;
+    struct jl_gc_metadata_ext info;
+    unsigned i;
+    i = REGION_INDEX(data);
+    info.pagetable_i = i % 32;
+    info.pagetable_i32 = i / 32;
+    info.pagetable1 = memory_map.meta1[i];
+    i = REGION1_INDEX(data);
+    info.pagetable1_i = i % 32;
+    info.pagetable1_i32 = i / 32;
+    info.pagetable0 = info.pagetable1->meta0[i];
+    i = REGION0_INDEX(data);
+    info.pagetable0_i = i % 32;
+    info.pagetable0_i32 = i / 32;
+    info.meta = info.pagetable0->meta[i];
+    assert(info.meta);
+    return info;
 }
 
 STATIC_INLINE void gc_big_object_unlink(const bigval_t *hdr)
@@ -276,16 +478,26 @@ STATIC_INLINE void gc_big_object_link(bigval_t *hdr, bigval_t **list)
     *list = hdr;
 }
 
-void mark_all_roots(jl_ptls_t ptls);
-void gc_mark_object_list(jl_ptls_t ptls, arraylist_t *list, size_t start);
-void visit_mark_stack(jl_ptls_t ptls);
+STATIC_INLINE void gc_mark_sp_init(jl_gc_mark_cache_t *gc_cache, gc_mark_sp_t *sp)
+{
+    sp->pc = gc_cache->pc_stack;
+    sp->data = gc_cache->data_stack;
+    sp->pc_start = gc_cache->pc_stack;
+    sp->pc_end = gc_cache->pc_stack_end;
+}
+
+void gc_mark_queue_all_roots(jl_ptls_t ptls, gc_mark_sp_t *sp);
+void gc_mark_queue_finlist(jl_gc_mark_cache_t *gc_cache, gc_mark_sp_t *sp,
+                           arraylist_t *list, size_t start);
+void gc_mark_loop(jl_ptls_t ptls, gc_mark_sp_t sp);
 void gc_debug_init(void);
-void jl_mark_box_caches(jl_ptls_t ptls);
+
+extern void *gc_mark_label_addrs[_GC_MARK_L_MAX];
 
 // GC pages
 
 void jl_gc_init_page(void);
-NOINLINE void *jl_gc_alloc_page(void);
+NOINLINE jl_gc_pagemeta_t *jl_gc_alloc_page(void);
 void jl_gc_free_page(void *p);
 
 // GC debug
@@ -310,6 +522,7 @@ void gc_final_pause_end(int64_t t0, int64_t tend);
 void gc_time_pool_start(void);
 void gc_time_count_page(int freedall, int pg_skpd);
 void gc_time_pool_end(int sweep_full);
+void gc_time_sysimg_end(uint64_t t0);
 
 void gc_time_big_start(void);
 void gc_time_count_big(int old_bits, int bits);
@@ -331,7 +544,8 @@ STATIC_INLINE void gc_time_count_page(int freedall, int pg_skpd)
     (void)freedall;
     (void)pg_skpd;
 }
-#define gc_time_pool_end(sweep_full)
+#define gc_time_pool_end(sweep_full) (void)(sweep_full)
+#define gc_time_sysimg_end(t0) (void)(t0)
 #define gc_time_big_start()
 STATIC_INLINE void gc_time_count_big(int old_bits, int bits)
 {
@@ -394,10 +608,13 @@ extern int gc_verifying;
 #else
 #define gc_verify(ptls)
 #define verify_val(v)
-#define verify_parent1(ty,obj,slot,arg1)
-#define verify_parent2(ty,obj,slot,arg1,arg2)
+#define verify_parent1(ty,obj,slot,arg1) do {} while (0)
+#define verify_parent2(ty,obj,slot,arg1,arg2) do {} while (0)
 #define gc_verifying (0)
 #endif
+int gc_slot_to_fieldidx(void *_obj, void *slot);
+int gc_slot_to_arrayidx(void *_obj, void *begin);
+NOINLINE void gc_mark_loop_unwind(jl_ptls_t ptls, gc_mark_sp_t sp, int pc_offset);
 
 #ifdef GC_DEBUG_ENV
 JL_DLLEXPORT extern jl_gc_debug_env_t jl_gc_debug_env;
diff --git a/src/gen_sysimg_symtab.jl b/src/gen_sysimg_symtab.jl
index 193aa947ee8c03..4df1ac3c7df67f 100644
--- a/src/gen_sysimg_symtab.jl
+++ b/src/gen_sysimg_symtab.jl
@@ -1,27 +1,26 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # script to generate tables of common symbols from a system image
 # steps to rerun this:
 #   1. empty the contents of common_symbols*.inc
-#   2. modify dump.c to write and read a '\0' after every symbol name
+#   2. modify dump.c to write symbols in a clearly marked format (#define GEN_SYMTAB_MODE)
 #   3. build sys.ji
 #   4. cd src && ../julia gen_sysimg_symtab.jl ../usr/lib/julia/sys.ji
 
 fname = ARGS[1]
 
-io,_ = open(pipeline(`strings -n 3 $fname`,
-                     `tr -d "() \t+-"`,
-                     `grep -v '^$'`,  # rm empty lines
-                     `grep -v '\\'`,  # avoid backslashes
+io,_ = open(pipeline(`strings -n 4 $fname`,
+                     `tr -d "() \t"`,
+                     `grep JJJ`,
                      `sort`, `uniq -c`, `sort -g -r`,
                      `head -n 315`))  # 63 + 252
 
 function outputline(io, line)
     row = split(line, " ", keep=false)
-    println(io, "jl_symbol(\"", row[2], "\"),")
+    println(io, "jl_symbol(\"", row[2][4:end], "\"),")
 end
 
 lines = eachline(io)
 
-open(f->foreach(l->outputline(f,l), take(lines,63)), "common_symbols1.inc", "w")
+open(f->foreach(l->outputline(f,l), Base.Iterators.take(lines,63)), "common_symbols1.inc", "w")
 open(f->foreach(l->outputline(f,l), lines), "common_symbols2.inc", "w")
diff --git a/src/gf.c b/src/gf.c
index c2f0a10bd07991..03252c18222767 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -1,12 +1,12 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 /*
   Generic Functions
   . method table and lookup
-  . GF constructor, add_method
+  . GF constructor
   . dispatch
   . static parameter inference
-  . method specialization, invoking type inference
+  . method specialization and caching, invoking type inference
 */
 #include <stdlib.h>
 #include <string.h>
@@ -17,7 +17,7 @@
 #include <unistd.h>
 #endif
 
-// ::ANY has no effect if the number of overlapping methods is greater than this
+// @nospecialize has no effect if the number of overlapping methods is greater than this
 #define MAX_UNSPECIALIZED_CONFLICTS 32
 
 #ifdef __cplusplus
@@ -134,7 +134,8 @@ const struct jl_typemap_info tfunc_cache = {
 
 static int8_t jl_cachearg_offset(jl_methtable_t *mt)
 {
-    return (mt == jl_type_type_mt) ? 0 : 1;
+    // TODO: consider reverting this when we can split on Type{...} better
+    return 1; //(mt == jl_type_type_mt) ? 0 : 1;
 }
 
 /// ----- Insertion logic for special entries ----- ///
@@ -142,7 +143,7 @@ static int8_t jl_cachearg_offset(jl_methtable_t *mt)
 // get or create the MethodInstance for a specialization
 JL_DLLEXPORT jl_method_instance_t *jl_specializations_get_linfo(jl_method_t *m, jl_value_t *type, jl_svec_t *sparams, size_t world)
 {
-    assert(world >= m->min_world && world <= m->max_world && "typemap lookup is corrupted");
+    assert(world >= m->min_world && "typemap lookup is corrupted");
     JL_LOCK(&m->writelock);
     jl_typemap_entry_t *sf =
         jl_typemap_assoc_by_type(m->specializations, (jl_tupletype_t*)type, NULL, 1, /*subtype*/0, /*offs*/0, world);
@@ -163,8 +164,7 @@ JL_DLLEXPORT jl_method_instance_t *jl_specializations_get_linfo(jl_method_t *m,
         li->min_world = world;
     }
     if (world == jl_world_counter) {
-        assert(m->max_world == ~(size_t)0 && "method validity shouldn't be scheduled to terminate at a fixed future age");
-        li->max_world = m->max_world;
+        li->max_world = ~(size_t)0;
     }
     else {
         li->max_world = world;
@@ -214,14 +214,15 @@ void jl_mk_builtin_func(jl_datatype_t *dt, const char *name, jl_fptr_t fptr)
     li->max_world = ~(size_t)0;
 
     JL_GC_PUSH1(&li);
-    li->def = jl_new_method_uninit();
-    jl_gc_wb(li, li->def);
-    li->def->name = sname;
-    li->def->module = jl_core_module;
-    li->def->isva = 1;
-    li->def->nargs = 2;
-    li->def->sig = (jl_value_t*)jl_anytuple_type;
-    li->def->sparam_syms = jl_emptysvec;
+    jl_method_t *m = jl_new_method_uninit();
+    li->def.method = m;
+    jl_gc_wb(li, m);
+    m->name = sname;
+    m->module = jl_core_module;
+    m->isva = 1;
+    m->nargs = 2;
+    m->sig = (jl_value_t*)jl_anytuple_type;
+    m->sparam_syms = jl_emptysvec;
 
     jl_methtable_t *mt = dt->name->mt;
     jl_typemap_insert(&mt->cache, (jl_value_t*)mt, jl_anytuple_type,
@@ -238,50 +239,45 @@ jl_code_info_t *jl_type_infer(jl_method_instance_t **pli, size_t world, int forc
     JL_TIMING(INFERENCE);
     if (jl_typeinf_func == NULL)
         return NULL;
-    jl_code_info_t *src = NULL;
 #ifdef ENABLE_INFERENCE
     jl_method_instance_t *li = *pli;
-    jl_module_t *mod = NULL;
-    if (li->def != NULL)
-        mod = li->def->module;
-    static int inInference = 0;
-    int lastIn = inInference;
-    size_t last_age = jl_get_ptls_states()->world_age;
-    inInference = 1;
-    if (force ||
-        (last_age != jl_typeinf_world &&
-         mod != jl_gf_mtable(jl_typeinf_func)->module &&
-         (mod != jl_core_module || !lastIn))) { // avoid any potential recursion in calling jl_typeinf_func on itself
-        assert(li->inInference == 0 && "unexpectedly asked to infer a method that is already being inferred");
-        jl_value_t **fargs;
-        JL_GC_PUSHARGS(fargs, 3);
-        fargs[0] = (jl_value_t*)jl_typeinf_func;
-        fargs[1] = (jl_value_t*)li;
-        fargs[2] = jl_box_ulong(world);
+    if (li->inInference && !force)
+        return NULL;
+
+    jl_value_t **fargs;
+    JL_GC_PUSHARGS(fargs, 3);
+    fargs[0] = (jl_value_t*)jl_typeinf_func;
+    fargs[1] = (jl_value_t*)li;
+    fargs[2] = jl_box_ulong(world);
 #ifdef TRACE_INFERENCE
+    if (li->specTypes != (jl_value_t*)jl_emptytuple_type) {
         jl_printf(JL_STDERR,"inference on ");
         jl_static_show_func_sig(JL_STDERR, (jl_value_t*)li->specTypes);
         jl_printf(JL_STDERR, "\n");
+    }
 #endif
-        jl_get_ptls_states()->world_age = jl_typeinf_world;
-        jl_svec_t *linfo_src_rettype = (jl_svec_t*)jl_apply(fargs, 3);
-        jl_get_ptls_states()->world_age = last_age;
-        assert((li->def || li->inInference == 0) && "inference failed on a toplevel expr");
-        if (jl_is_svec(linfo_src_rettype) && jl_svec_len(linfo_src_rettype) == 3 &&
+    jl_ptls_t ptls = jl_get_ptls_states();
+    size_t last_age = ptls->world_age;
+    ptls->world_age = jl_typeinf_world;
+    li->inInference = 1;
+    jl_svec_t *linfo_src_rettype = (jl_svec_t*)jl_apply_with_saved_exception_state(fargs, 3, 0);
+    ptls->world_age = last_age;
+    li->inInference = 0;
+
+    jl_code_info_t *src = NULL;
+    if (linfo_src_rettype &&
+            jl_is_svec(linfo_src_rettype) && jl_svec_len(linfo_src_rettype) == 3 &&
             jl_is_method_instance(jl_svecref(linfo_src_rettype, 0)) &&
             jl_is_code_info(jl_svecref(linfo_src_rettype, 1))) {
-            *pli = (jl_method_instance_t*)jl_svecref(linfo_src_rettype, 0);
-            src = (jl_code_info_t*)jl_svecref(linfo_src_rettype, 1);
-        }
-        JL_GC_POP();
+        *pli = (jl_method_instance_t*)jl_svecref(linfo_src_rettype, 0);
+        src = (jl_code_info_t*)jl_svecref(linfo_src_rettype, 1);
     }
-    inInference = lastIn;
+    JL_GC_POP();
 #endif
     return src;
 }
 
-
-static int jl_is_rettype_inferred(jl_method_instance_t *li)
+int jl_is_rettype_inferred(jl_method_instance_t *li)
 {
     if (!li->inferred)
         return 0;
@@ -290,11 +286,11 @@ static int jl_is_rettype_inferred(jl_method_instance_t *li)
     return 1;
 }
 
-
 struct set_world {
     jl_method_instance_t *replaced;
     size_t world;
 };
+
 static int set_max_world2(jl_typemap_entry_t *entry, void *closure0)
 {
     struct set_world *closure = (struct set_world*)closure0;
@@ -304,6 +300,7 @@ static int set_max_world2(jl_typemap_entry_t *entry, void *closure0)
     }
     return 1;
 }
+
 static int set_min_world2(jl_typemap_entry_t *entry, void *closure0)
 {
     struct set_world *closure = (struct set_world*)closure0;
@@ -313,13 +310,14 @@ static int set_min_world2(jl_typemap_entry_t *entry, void *closure0)
     }
     return 1;
 }
+
 static void update_world_bound(jl_method_instance_t *replaced, jl_typemap_visitor_fptr fptr, size_t world)
 {
     struct set_world update;
     update.replaced = replaced;
     update.world = world;
 
-    jl_method_t *m = replaced->def;
+    jl_method_t *m = replaced->def.method;
     // update the world-valid in the specializations caches
     jl_typemap_visitor(m->specializations, fptr, (void*)&update);
     // update the world-valid in the invoke cache
@@ -331,7 +329,6 @@ static void update_world_bound(jl_method_instance_t *replaced, jl_typemap_visito
     jl_typemap_visitor(gf->name->mt->cache, fptr, (void*)&update);
 }
 
-
 JL_DLLEXPORT jl_method_instance_t* jl_set_method_inferred(
         jl_method_instance_t *li, jl_value_t *rettype,
         jl_value_t *inferred_const, jl_value_t *inferred,
@@ -341,14 +338,14 @@ JL_DLLEXPORT jl_method_instance_t* jl_set_method_inferred(
     assert(min_world <= max_world && "attempting to set invalid world constraints");
     assert(li->inInference && "shouldn't be caching an inference result for a MethodInstance that wasn't being inferred");
     if (min_world != li->min_world || max_world != li->max_world) {
-        if (li->def == NULL) {
+        if (!jl_is_method(li->def.method)) {
             // thunks don't have multiple references, so just update in-place
             li->min_world = min_world;
             li->max_world = max_world;
         }
         else {
-            JL_LOCK(&li->def->writelock);
-            assert(min_world >= li->def->min_world && max_world <= li->def->max_world);
+            JL_LOCK(&li->def.method->writelock);
+            assert(min_world >= li->def.method->min_world);
             int isinferred =  jl_is_rettype_inferred(li);
             if (!isinferred && li->min_world >= min_world && li->max_world <= max_world) {
                 // expand the current (uninferred) entry to cover the full inferred range
@@ -359,12 +356,12 @@ JL_DLLEXPORT jl_method_instance_t* jl_set_method_inferred(
                 if (li->min_world != min_world) {
                     li->min_world = min_world;
                     update.world = min_world;
-                    jl_typemap_visitor(li->def->specializations, set_min_world2, (void*)&update);
+                    jl_typemap_visitor(li->def.method->specializations, set_min_world2, (void*)&update);
                 }
                 if (li->max_world != max_world) {
                     li->max_world = max_world;
                     update.world = max_world;
-                    jl_typemap_visitor(li->def->specializations, set_max_world2, (void*)&update);
+                    jl_typemap_visitor(li->def.method->specializations, set_max_world2, (void*)&update);
                 }
             }
             else {
@@ -375,7 +372,7 @@ JL_DLLEXPORT jl_method_instance_t* jl_set_method_inferred(
                 if (li->max_world >= min_world && li->min_world <= max_world) {
                     // there is a non-zero overlap between [li->min, li->max] and [min, max]
                     // there are now 4 regions left to consider
-                    // TODO: also take into account li->def->world range when computing preferred division
+                    // TODO: also take into account li->def.method->world range when computing preferred division
                     if (li->max_world > max_world) {
                         // prefer making it applicable to future ages,
                         // as those are more likely to be useful
@@ -393,15 +390,15 @@ JL_DLLEXPORT jl_method_instance_t* jl_set_method_inferred(
                 }
 
                 // build a new entry to describe the new (inferred) applicability
-                li = jl_get_specialized(li->def, li->specTypes, li->sparam_vals);
+                li = jl_get_specialized(li->def.method, li->specTypes, li->sparam_vals);
                 li->min_world = min_world;
                 li->max_world = max_world;
-                jl_typemap_insert(&li->def->specializations, (jl_value_t*)li->def,
+                jl_typemap_insert(&li->def.method->specializations, li->def.value,
                         (jl_tupletype_t*)li->specTypes, NULL, jl_emptysvec,
                         (jl_value_t*)li, 0, &tfunc_cache,
                         li->min_world, li->max_world, NULL);
             }
-            JL_UNLOCK(&li->def->writelock);
+            JL_UNLOCK(&li->def.method->writelock);
         }
     }
 
@@ -425,7 +422,6 @@ JL_DLLEXPORT jl_method_instance_t* jl_set_method_inferred(
     return li;
 }
 
-
 static int get_spec_unspec_list(jl_typemap_entry_t *l, void *closure)
 {
     if (jl_is_method_instance(l->func.value) && !jl_is_rettype_inferred(l->func.linfo))
@@ -439,32 +435,32 @@ static int get_method_unspec_list(jl_typemap_entry_t *def, void *closure)
     return 1;
 }
 
-
-static void jl_reset_mt_caches(jl_module_t *m, jl_array_t *unspec)
+void jl_foreach_mtable_in_module(
+        jl_module_t *m,
+        void (*visit)(jl_methtable_t *mt, void *env),
+        void *env)
 {
-    // removes all method caches
     size_t i;
     void **table = m->bindings.table;
-    for(i=1; i < m->bindings.size; i+=2) {
+    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->owner == m && b->value && b->constp) {
-                if (jl_is_datatype(b->value)) {
-                    jl_typename_t *tn = ((jl_datatype_t*)b->value)->name;
+                jl_value_t *v = jl_unwrap_unionall(b->value);
+                if (jl_is_datatype(v)) {
+                    jl_typename_t *tn = ((jl_datatype_t*)v)->name;
                     if (tn->module == m && tn->name == b->name) {
                         jl_methtable_t *mt = tn->mt;
                         if (mt != NULL && (jl_value_t*)mt != jl_nothing) {
-                            if (mt->defs.unknown != jl_nothing) // make sure not to reset builtin functions
-                                mt->cache.unknown = jl_nothing;
-                            jl_typemap_visitor(mt->defs, get_method_unspec_list, (void*)unspec);
+                            visit(mt, env);
                         }
                     }
                 }
-                else if (jl_is_module(b->value)) {
-                    jl_module_t *child = (jl_module_t*)b->value;
+                else if (jl_is_module(v)) {
+                    jl_module_t *child = (jl_module_t*)v;
                     if (child != m && child->parent == m && child->name == b->name) {
                         // this is the original/primary binding for the submodule
-                        jl_reset_mt_caches((jl_module_t*)b->value, unspec);
+                        jl_foreach_mtable_in_module(child, visit, env);
                     }
                 }
             }
@@ -472,6 +468,15 @@ static void jl_reset_mt_caches(jl_module_t *m, jl_array_t *unspec)
     }
 }
 
+static void reset_mt_caches(jl_methtable_t *mt, void *env)
+{
+    // removes all method caches
+    if (mt->defs.unknown != jl_nothing) // make sure not to reset builtin functions
+        mt->cache.unknown = jl_nothing;
+    jl_typemap_visitor(mt->defs, get_method_unspec_list, env);
+}
+
+
 jl_function_t *jl_typeinf_func = NULL;
 size_t jl_typeinf_world = 0;
 
@@ -484,7 +489,7 @@ JL_DLLEXPORT void jl_set_typeinf_func(jl_value_t *f)
     // TODO: also reinfer if max_world != ~(size_t)0
     jl_array_t *unspec = jl_alloc_vec_any(0);
     JL_GC_PUSH1(&unspec);
-    jl_reset_mt_caches(jl_main_module, unspec);
+    jl_foreach_mtable_in_module(jl_main_module, reset_mt_caches, (void*)unspec);
     size_t i, l;
     for (i = 0, l = jl_array_len(unspec); i < l; i++) {
         jl_method_instance_t *li = (jl_method_instance_t*)jl_array_ptr_ref(unspec, i);
@@ -575,7 +580,6 @@ static void jl_cacheable_sig(
     int *const need_guard_entries,
     int *const makesimplesig)
 {
-    int8_t isstaged = definition->isstaged;
     assert(jl_is_tuple_type(type));
     size_t i, np = jl_nparams(type);
     for (i = 0; i < np; i++) {
@@ -588,7 +592,7 @@ static void jl_cacheable_sig(
             continue;
         }
 
-        if (isstaged) {
+        if (definition->generator) {
             // staged functions can't be optimized
             continue;
         }
@@ -596,6 +600,7 @@ static void jl_cacheable_sig(
         // avoid specializing on an argument of type Tuple
         // unless matching a declared type of `::Type`
         if (jl_is_type_type(elt) && jl_is_tuple_type(jl_tparam0(elt)) &&
+            !jl_has_free_typevars(decl_i) &&
             (!jl_subtype(decl_i, (jl_value_t*)jl_type_type) || jl_is_kind(decl_i))) { // Type{Tuple{...}}
             elt = (jl_value_t*)jl_anytuple_type_type; // Type{T} where T<:Tuple
             if (!*newparams) *newparams = jl_svec_copy(type->parameters);
@@ -605,8 +610,9 @@ static void jl_cacheable_sig(
 
         int notcalled_func = (i > 0 && i <= 8 && !(definition->called & (1 << (i - 1))) &&
                               jl_subtype(elt, (jl_value_t*)jl_function_type));
-        if (decl_i == jl_ANY_flag) {
-            // don't specialize on slots marked ANY
+        if (i > 0 && i <= sizeof(definition->nospecialize) * 8 &&
+            (definition->nospecialize & (1 << (i - 1))) &&
+            decl_i == (jl_value_t*)jl_any_type) { // TODO: nospecialize with other types
             if (!*newparams) *newparams = jl_svec_copy(type->parameters);
             jl_svecset(*newparams, i, (jl_value_t*)jl_any_type);
             *need_guard_entries = 1;
@@ -661,7 +667,7 @@ static void jl_cacheable_sig(
                  !jl_has_free_typevars(decl_i)) {
             /*
               here's a fairly simple heuristic: if this argument slot's
-              declared type is general (Type, Any, or ANY),
+              declared type is general (Type or Any),
               then don't specialize for every Type that got passed.
 
               Since every type x has its own type Type{x}, this would be
@@ -691,7 +697,7 @@ JL_DLLEXPORT int jl_is_cacheable_sig(
     // compute whether this type signature is a possible return value from jl_cacheable_sig
     //return jl_cacheable_sig(type, NULL, definition->sig, definition, NULL, NULL);
 
-    if (definition->isstaged)
+    if (definition->generator)
         // staged functions can't be optimized
         // so assume the caller was intelligent about calling us
         return 1;
@@ -708,9 +714,10 @@ JL_DLLEXPORT int jl_is_cacheable_sig(
             continue;
         if (jl_is_kind(elt)) // kind slots always need guard entries (checking for subtypes of Type)
             continue;
-        if (decl_i == jl_ANY_flag) {
-            // don't specialize on slots marked ANY
-            if (elt != (jl_value_t*)jl_any_type && elt != jl_ANY_flag)
+        if (i > 0 && i <= sizeof(definition->nospecialize) * 8 &&
+            (definition->nospecialize & (1 << (i - 1))) &&
+            decl_i == (jl_value_t*)jl_any_type) { // TODO: nospecialize with other types
+            if (elt != (jl_value_t*)jl_any_type)
                 return 0;
             continue;
         }
@@ -728,6 +735,7 @@ JL_DLLEXPORT int jl_is_cacheable_sig(
         // avoid specializing on an argument of type Tuple
         // unless matching a declared type of `::Type`
         if (jl_is_type_type(elt) && jl_is_tuple_type(jl_tparam0(elt)) &&
+            !jl_has_free_typevars(decl_i) &&
             (!jl_subtype(decl_i, (jl_value_t*)jl_type_type) || jl_is_kind(decl_i))) { // Type{Tuple{...}}
             if (!jl_types_equal(elt, (jl_value_t*)jl_anytuple_type_type))
                 return 0;
@@ -766,11 +774,17 @@ JL_DLLEXPORT int jl_is_cacheable_sig(
                 if (jl_is_vararg_type(declt))
                     declt = jl_unwrap_vararg(declt);
                 jl_value_t *di = jl_type_intersection(declt, (jl_value_t*)jl_typetype_type);
+                JL_GC_PUSH1(&di);
                 assert(di != (jl_value_t*)jl_bottom_type);
-                if (jl_is_kind(di))
+                if (jl_is_kind(di)) {
+                    JL_GC_POP();
                     return 0;
-                else if (!jl_subtype(di, elt) || !jl_subtype(elt, di))
+                }
+                else if (!jl_subtype(di, elt) || !jl_subtype(elt, di)) {
+                    JL_GC_POP();
                     return 0;
+                }
+                JL_GC_POP();
             }
             else {
                 return 0;
@@ -781,7 +795,7 @@ JL_DLLEXPORT int jl_is_cacheable_sig(
                  !jl_has_free_typevars(decl_i)) {
             /*
               here's a fairly simple heuristic: if this argument slot's
-              declared type is general (Type, Any, or ANY),
+              declared type is general (Type or Any),
               then don't specialize for every Type that got passed.
 
               Since every type x has its own type Type{x}, this would be
@@ -834,7 +848,7 @@ static jl_method_instance_t *cache_method(jl_methtable_t *mt, union jl_typemap_t
     // in general, here we want to find the biggest type that's not a
     // supertype of any other method signatures. so far we are conservative
     // and the types we find should be bigger.
-    if (!definition->isstaged && jl_nparams(type) > mt->max_args
+    if (definition->generator == NULL && jl_nparams(type) > mt->max_args
         && jl_va_tuple_kind((jl_datatype_t*)decl) == JL_VARARG_UNBOUND) {
         size_t i, nspec = mt->max_args + 2;
         jl_svec_t *limited = jl_alloc_svec(nspec);
@@ -901,7 +915,7 @@ static jl_method_instance_t *cache_method(jl_methtable_t *mt, union jl_typemap_t
     }
 
     size_t min_valid = definition->min_world;
-    size_t max_valid = definition->max_world;
+    size_t max_valid = ~(size_t)0;
     int cache_with_orig = 0;
     jl_svec_t* guardsigs = jl_emptysvec;
     jl_tupletype_t *origtype = type; // backup the prior value of `type`
@@ -1035,6 +1049,13 @@ static jl_method_instance_t *jl_mt_assoc_by_type(jl_methtable_t *mt, jl_datatype
         JL_GC_POP();
         return NULL;
     }
+#ifdef TRACE_COMPILE
+    if (!jl_has_free_typevars((jl_value_t*)tt)) {
+        jl_printf(JL_STDERR, "precompile(");
+        jl_static_show(JL_STDERR, (jl_value_t*)tt);
+        jl_printf(JL_STDERR, ")\n");
+    }
+#endif
     sig = join_tsig(tt, entry->sig);
     jl_method_instance_t *nf;
     if (!cache) {
@@ -1067,12 +1088,6 @@ void print_func_loc(JL_STREAM *s, jl_method_t *m)
   however, (AbstractArray, AbstractMatrix, Foo) and (AbstractMatrix, AbstractArray, Bar) are fine
   since Foo and Bar are disjoint, so there would be no confusion over
   which one to call.
-
-  There is also this kind of ambiguity: foo{T,S}(T, S) vs. foo(Any,Any)
-  In this case jl_types_equal() is true, but one is jl_type_morespecific
-  or jl_type_match_morespecific than the other.
-  To check this, jl_types_equal_generic needs to be more sophisticated
-  so (T,T) is not equivalent to (Any,Any). (TODO)
 */
 struct ambiguous_matches_env {
     struct typemap_intersection_env match;
@@ -1101,8 +1116,23 @@ static int check_ambiguous_visitor(jl_typemap_entry_t *oldentry, struct typemap_
     //     or !jl_type_morespecific(sig, type) [after]
     // based on their sort order in the typemap
     // now we are checking that the reverse is true
-    if (!jl_type_morespecific((jl_value_t*)(closure->after ? type : sig),
-                              (jl_value_t*)(closure->after ? sig : type))) {
+    int msp;
+    if (closure->match.issubty) {
+        assert(closure->after);
+        msp = 1;
+    }
+    else if (closure->after) {
+        assert(!jl_subtype((jl_value_t*)sig, (jl_value_t*)type));
+        msp = jl_type_morespecific_no_subtype((jl_value_t*)type, (jl_value_t*)sig);
+    }
+    else {
+        if (jl_subtype((jl_value_t*)sig, (jl_value_t*)type))
+            msp = 1;
+        else
+            msp = jl_type_morespecific_no_subtype((jl_value_t*)sig, (jl_value_t*)type);
+    }
+
+    if (!msp) {
         // see if the intersection is covered by another existing method
         // that will resolve the ambiguity (by being more specific than either)
         // (if type-morespecific made a mistake, this also might end up finding
@@ -1135,10 +1165,10 @@ static int check_ambiguous_visitor(jl_typemap_entry_t *oldentry, struct typemap_
             jl_static_show_func_sig(s, isect);
             jl_printf(s, "\nbefore the new definition.\n");
         }
-        return 1;  // there may be multiple ambiguities, keep going
     }
-    else if (closure->after) {
+    if (!msp || closure->after) {
         // record that this method definition is being partially replaced
+        // (either with a real definition, or an ambiguity error)
         if (closure->shadowed == NULL) {
             closure->shadowed = oldentry->func.value;
         }
@@ -1155,8 +1185,7 @@ static int check_ambiguous_visitor(jl_typemap_entry_t *oldentry, struct typemap_
     return 1;
 }
 
-static jl_value_t *check_ambiguous_matches(union jl_typemap_t defs,
-                                           jl_typemap_entry_t *newentry)
+static jl_value_t *check_ambiguous_matches(union jl_typemap_t defs, jl_typemap_entry_t *newentry)
 {
     jl_tupletype_t *type = newentry->sig;
     jl_tupletype_t *ttypes = (jl_tupletype_t*)jl_unwrap_unionall((jl_value_t*)type);
@@ -1174,7 +1203,7 @@ static jl_value_t *check_ambiguous_matches(union jl_typemap_t defs,
     env.match.type = (jl_value_t*)type;
     env.match.va = va;
     env.match.ti = NULL;
-    env.match.env = NULL;
+    env.match.env = jl_emptysvec;
     env.defs = defs;
     env.newentry = newentry;
     env.shadowed = NULL;
@@ -1216,33 +1245,44 @@ static void update_max_args(jl_methtable_t *mt, jl_value_t *type)
         mt->max_args = na;
 }
 
+static int JL_DEBUG_METHOD_INVALIDATION = 0;
 
 // invalidate cached methods that had an edge to a replaced method
-static void invalidate_method_instance(jl_method_instance_t *replaced, size_t max_world)
+static void invalidate_method_instance(jl_method_instance_t *replaced, size_t max_world, int depth)
 {
-    JL_LOCK_NOGC(&replaced->def->writelock);
+    if (!jl_is_method(replaced->def.method))
+        return;
+    JL_LOCK_NOGC(&replaced->def.method->writelock);
     jl_array_t *backedges = replaced->backedges;
     if (replaced->max_world > max_world) {
         // recurse to all backedges to update their valid range also
-        assert(replaced->min_world <= max_world && "attempting to set invalid world constraints");
+        assert(replaced->min_world - 1 <= max_world && "attempting to set invalid world constraints");
+        if (JL_DEBUG_METHOD_INVALIDATION) {
+            int d0 = depth;
+            while (d0-- > 0)
+                jl_uv_puts(JL_STDOUT, " ", 1);
+            jl_static_show(JL_STDOUT, (jl_value_t*)replaced);
+            jl_uv_puts(JL_STDOUT, "\n", 1);
+        }
         replaced->max_world = max_world;
         update_world_bound(replaced, set_max_world2, max_world);
         if (backedges) {
             size_t i, l = jl_array_len(backedges);
             for (i = 0; i < l; i++) {
                 jl_method_instance_t *replaced = (jl_method_instance_t*)jl_array_ptr_ref(backedges, i);
-                invalidate_method_instance(replaced, max_world);
+                invalidate_method_instance(replaced, max_world, depth + 1);
             }
         }
     }
     replaced->backedges = NULL;
-    JL_UNLOCK_NOGC(&replaced->def->writelock);
+    JL_UNLOCK_NOGC(&replaced->def.method->writelock);
 }
 
 // invalidate cached methods that overlap this definition
 struct invalidate_conflicting_env {
     struct typemap_intersection_env match;
     size_t max_world;
+    int invalidated;
 };
 static int invalidate_backedges(jl_typemap_entry_t *oldentry, struct typemap_intersection_env *closure0)
 {
@@ -1251,7 +1291,7 @@ static int invalidate_backedges(jl_typemap_entry_t *oldentry, struct typemap_int
         struct set_world def;
         def.replaced = oldentry->func.linfo;
         def.world = closure->max_world;
-        jl_method_t *m = def.replaced->def;
+        jl_method_t *m = def.replaced->def.method;
 
         // truncate the max-valid in the invoke cache
         if (m->invokes.unknown != NULL)
@@ -1262,17 +1302,18 @@ static int invalidate_backedges(jl_typemap_entry_t *oldentry, struct typemap_int
         jl_typemap_visitor(gf->name->mt->cache, set_max_world2, (void*)&def);
 
         // invalidate backedges
-        JL_LOCK_NOGC(&def.replaced->def->writelock);
+        JL_LOCK_NOGC(&def.replaced->def.method->writelock);
         jl_array_t *backedges = def.replaced->backedges;
         if (backedges) {
             size_t i, l = jl_array_len(backedges);
             jl_method_instance_t **replaced = (jl_method_instance_t**)jl_array_data(backedges);
             for (i = 0; i < l; i++) {
-                invalidate_method_instance(replaced[i], closure->max_world);
+                invalidate_method_instance(replaced[i], closure->max_world, 0);
             }
         }
+        closure->invalidated = 1;
         def.replaced->backedges = NULL;
-        JL_UNLOCK_NOGC(&def.replaced->def->writelock);
+        JL_UNLOCK_NOGC(&def.replaced->def.method->writelock);
     }
     return 1;
 }
@@ -1281,7 +1322,7 @@ static int invalidate_backedges(jl_typemap_entry_t *oldentry, struct typemap_int
 JL_DLLEXPORT void jl_method_instance_add_backedge(jl_method_instance_t *callee, jl_method_instance_t *caller)
 {
     assert(callee->min_world <= caller->min_world && callee->max_world >= caller->max_world);
-    JL_LOCK(&callee->def->writelock);
+    JL_LOCK(&callee->def.method->writelock);
     if (!callee->backedges) {
         // lazy-init the backedges array
         callee->backedges = jl_alloc_vec_any(1);
@@ -1298,7 +1339,7 @@ JL_DLLEXPORT void jl_method_instance_add_backedge(jl_method_instance_t *callee,
             jl_array_ptr_1d_push(callee->backedges, (jl_value_t*)caller);
         }
     }
-    JL_UNLOCK(&callee->def->writelock);
+    JL_UNLOCK(&callee->def.method->writelock);
 }
 
 // add a backedge from a non-existent signature to caller
@@ -1330,6 +1371,13 @@ JL_DLLEXPORT void jl_method_table_add_backedge(jl_methtable_t *mt, jl_value_t *t
     JL_UNLOCK(&mt->writelock);
 }
 
+void jl_method_instance_delete(jl_method_instance_t *mi)
+{
+    invalidate_method_instance(mi, mi->min_world - 1, 0);
+    if (JL_DEBUG_METHOD_INVALIDATION)
+        jl_uv_puts(JL_STDOUT, "<<<\n", 4);
+}
+
 JL_DLLEXPORT void jl_method_table_insert(jl_methtable_t *mt, jl_method_t *method, jl_tupletype_t *simpletype)
 {
     assert(jl_is_method(method));
@@ -1337,12 +1385,13 @@ JL_DLLEXPORT void jl_method_table_insert(jl_methtable_t *mt, jl_method_t *method
     jl_value_t *type = method->sig;
     jl_value_t *oldvalue = NULL;
     struct invalidate_conflicting_env env;
+    env.invalidated = 0;
     env.max_world = method->min_world - 1;
     JL_GC_PUSH1(&oldvalue);
     JL_LOCK(&mt->writelock);
     jl_typemap_entry_t *newentry = jl_typemap_insert(&mt->defs, (jl_value_t*)mt,
             (jl_tupletype_t*)type, simpletype, jl_emptysvec, (jl_value_t*)method, 0, &method_defs,
-            method->min_world, method->max_world, &oldvalue);
+            method->min_world, ~(size_t)0, &oldvalue);
     if (oldvalue) {
         method->ambig = ((jl_method_t*)oldvalue)->ambig;
         method_overwrite(newentry, (jl_method_t*)oldvalue);
@@ -1355,9 +1404,10 @@ JL_DLLEXPORT void jl_method_table_insert(jl_methtable_t *mt, jl_method_t *method
             size_t ins = 0;
             for (i = 1; i < na; i += 2) {
                 jl_value_t *backedgetyp = backedges[i - 1];
-                if (jl_type_intersection(backedgetyp, (jl_value_t*)type) != (jl_value_t*)jl_bottom_type) {
+                if (!jl_has_empty_intersection(backedgetyp, (jl_value_t*)type)) {
                     jl_method_instance_t *backedge = (jl_method_instance_t*)backedges[i];
-                    invalidate_method_instance(backedge, env.max_world);
+                    invalidate_method_instance(backedge, env.max_world, 0);
+                    env.invalidated = 1;
                 }
                 else {
                     backedges[ins++] = backedges[i - 1];
@@ -1384,6 +1434,7 @@ JL_DLLEXPORT void jl_method_table_insert(jl_methtable_t *mt, jl_method_t *method
         env.match.va = va;
         env.match.type = (jl_value_t*)type;
         env.match.fptr = invalidate_backedges;
+        env.match.env = NULL;
 
         if (jl_is_method(oldvalue)) {
             jl_typemap_intersection_visitor(((jl_method_t*)oldvalue)->specializations, 0, &env.match);
@@ -1397,6 +1448,13 @@ JL_DLLEXPORT void jl_method_table_insert(jl_methtable_t *mt, jl_method_t *method
             }
         }
     }
+    if (env.invalidated && JL_DEBUG_METHOD_INVALIDATION) {
+        jl_uv_puts(JL_STDOUT, ">> ", 3);
+        jl_static_show(JL_STDOUT, (jl_value_t*)method);
+        jl_uv_puts(JL_STDOUT, " ", 1);
+        jl_static_show(JL_STDOUT, (jl_value_t*)type);
+        jl_uv_puts(JL_STDOUT, "\n", 1);
+    }
     update_max_args(mt, type);
     JL_UNLOCK(&mt->writelock);
     JL_GC_POP();
@@ -1544,7 +1602,8 @@ jl_method_instance_t *jl_method_lookup(jl_methtable_t *mt, jl_value_t **args, si
 //
 // lim is the max # of methods to return. if there are more, returns jl_false.
 // -1 for no limit.
-JL_DLLEXPORT jl_value_t *jl_matching_methods(jl_tupletype_t *types, int lim, int include_ambiguous, size_t world, size_t *min_valid, size_t *max_valid)
+JL_DLLEXPORT jl_value_t *jl_matching_methods(jl_tupletype_t *types, int lim, int include_ambiguous,
+                                             size_t world, size_t *min_valid, size_t *max_valid)
 {
     jl_value_t *unw = jl_unwrap_unionall((jl_value_t*)types);
     if (jl_is_tuple_type(unw) && jl_tparam0(unw) == jl_bottom_type)
@@ -1566,8 +1625,8 @@ jl_llvm_functions_t jl_compile_for_dispatch(jl_method_instance_t **pli, size_t w
     if (jl_options.compile_enabled == JL_OPTIONS_COMPILE_OFF ||
         jl_options.compile_enabled == JL_OPTIONS_COMPILE_MIN) {
         // copy fptr from the template method definition
-        jl_method_t *def = li->def;
-        if (def && !def->isstaged && def->unspecialized) {
+        jl_method_t *def = li->def.method;
+        if (jl_is_method(def) && def->unspecialized) {
             if (def->unspecialized->jlcall_api == 2) {
                 li->functionObjectsDecls.functionObject = NULL;
                 li->functionObjectsDecls.specFunctionObject = NULL;
@@ -1598,8 +1657,8 @@ jl_llvm_functions_t jl_compile_for_dispatch(jl_method_instance_t **pli, size_t w
         return decls;
 
     jl_code_info_t *src = NULL;
-    if (li->def && !jl_is_rettype_inferred(li) && !li->inInference &&
-             jl_symbol_name(li->def->name)[0] != '@') {
+    if (jl_is_method(li->def.method) && !jl_is_rettype_inferred(li) &&
+             jl_symbol_name(li->def.method->name)[0] != '@') {
         // don't bother with typeinf on macros or toplevel thunks
         // but try to infer everything else
         src = jl_type_infer(pli, world, 0);
@@ -1648,7 +1707,7 @@ jl_method_instance_t *jl_get_specialization1(jl_tupletype_t *types, size_t world
     jl_method_instance_t *sf = jl_method_lookup_by_type(mt, types, 1, 1, 1, world);
     assert(sf == NULL || (sf->min_world <= world && sf->max_world >= world));
     JL_GC_PUSH1(&sf);
-    if (sf != NULL && jl_has_call_ambiguities(types, sf->def)) {
+    if (sf != NULL && jl_has_call_ambiguities(types, sf->def.method)) {
         sf = NULL;
     }
     JL_GC_POP();
@@ -1680,10 +1739,8 @@ JL_DLLEXPORT int jl_has_call_ambiguities(jl_tupletype_t *types, jl_method_t *m)
     if (m->ambig == jl_nothing) return 0;
     for (size_t i = 0; i < jl_array_len(m->ambig); i++) {
         jl_method_t *mambig = (jl_method_t*)jl_array_ptr_ref(m->ambig, i);
-        if (jl_type_intersection((jl_value_t*)mambig->sig,
-                                 (jl_value_t*)types) != (jl_value_t*)jl_bottom_type) {
+        if (!jl_has_empty_intersection((jl_value_t*)mambig->sig, (jl_value_t*)types))
             return 1;
-        }
     }
     return 0;
 }
@@ -1706,345 +1763,6 @@ jl_tupletype_t *jl_argtype_with_function(jl_function_t *f, jl_tupletype_t *types
     return (jl_tupletype_t*)tt;
 }
 
-#if 0  // TODO restore this for jb/subtype
-static int tupletype_any_bottom(jl_value_t *sig)
-{
-    sig = jl_unwrap_unionall(sig);
-    assert(jl_is_tuple_type(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 int _compile_all_tvar_union(jl_tupletype_t *methsig, jl_svec_t *tvars)
-{
-    // 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_tvar_t**)&tvars;
-        tvarslen = 1;
-    }
-    else {
-        tvs = (jl_tvar_t**)jl_svec_data(tvars);
-        tvarslen = jl_svec_len(tvars);
-        if (tvarslen == 0) {
-            if (jl_is_concrete_type((jl_value_t*)methsig)) {
-                // usually can create a specialized version of the function,
-                // if the signature is already a concrete type
-                if (jl_compile_hint(methsig)) {
-                    return 1;
-                }
-            }
-            return 0;
-        }
-    }
-
-    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_concrete_type(sig)) {
-            if (jl_compile_hint((jl_tupletype_t*)sig)) {
-                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_concrete_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;
-}
-#endif
-#if 0
-static int _compile_all_union(jl_tupletype_t *sig, jl_svec_t *tvars)
-{
-    // f(::Union{...}, ...) is a common pattern
-    // and expanding the Union may give a leaf function
-    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(sig, tvars);
-
-    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(methsig, tvars))
-        //    complete = 0;
-    }
-
-    JL_GC_POP();
-    return complete;
-}
-#endif
-
-static void _compile_all_deq(jl_array_t *found)
-{
-    int found_i, found_l = jl_array_len(found);
-    jl_printf(JL_STDERR, "found %d uncompiled methods for compile-all\n", (int)found_l);
-    jl_method_instance_t *linfo = NULL;
-    jl_code_info_t *src = NULL;
-    JL_GC_PUSH2(&linfo, &src);
-    for (found_i = 0; found_i < found_l; found_i++) {
-        if (found_i % (1 + found_l / 300) == 0 || found_i == found_l - 1) // show 300 progress steps, to show progress without overwhelming log files
-            jl_printf(JL_STDERR, " %d / %d\r", found_i + 1, found_l);
-        jl_typemap_entry_t *ml = (jl_typemap_entry_t*)jl_array_ptr_ref(found, found_i);
-        jl_method_t *m = ml->func.method;
-        jl_method_instance_t *linfo = m->unspecialized;
-        if (!linfo) {
-            linfo = jl_get_specialized(m, (jl_value_t*)ml->sig, jl_emptysvec);
-            m->unspecialized = linfo;
-            jl_gc_wb(m, linfo);
-        }
-
-        //// infer this function now, if necessary
-        //if (linfo->jlcall_api == 2)
-        //    continue;
-        //src = jl_type_infer(&linfo, jl_world_counter, 1);
-        //if (linfo->jlcall_api == 2)
-        //    continue;
-
-        // keep track of whether all possible signatures have been cached (and thus whether it can skip trying to compile the template function)
-        // this is necessary because many intrinsics try to call static_eval and thus are not compilable unspecialized
-        int complete = 0;//_compile_all_union(ml->sig, ml->tvars);
-        if (complete) {
-            if (linfo->fptr == NULL && linfo->functionObjectsDecls.functionObject == NULL)
-                // indicate that this method doesn't need to be compiled, because it was fully covered above
-                // TODO: do this some other way
-                linfo->fptr = (jl_fptr_t)(uintptr_t)-1;
-        }
-        else {
-            jl_compile_linfo(&linfo, src, jl_world_counter, &jl_default_cgparams);
-            assert(linfo->functionObjectsDecls.functionObject != NULL);
-        }
-    }
-    JL_GC_POP();
-    jl_printf(JL_STDERR, "\n");
-}
-
-static int _compile_all_enq(jl_typemap_entry_t *ml, void *env)
-{
-    jl_array_t *found = (jl_array_t*)env;
-    // method definition -- compile template field
-    jl_method_t *m = ml->func.method;
-    if (!m->unspecialized ||
-            (m->unspecialized->functionObjectsDecls.functionObject == NULL &&
-             m->unspecialized->jlcall_api != 2 &&
-             m->unspecialized->fptr == NULL)) {
-        // found a lambda that still needs to be compiled
-        jl_array_ptr_1d_push(found, (jl_value_t*)ml);
-    }
-    return 1;
-}
-
-static void _compile_all_enq_module(jl_module_t *m, jl_array_t *found)
-{
-    // scan through all types reachable from 'v' and
-    // record all jl_method_instance_t objects and signatures in their method tables
-    size_t i, sz = m->bindings.size;
-    for(i=1; i < sz; i+=2) {
-        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_datatype(v)) {
-                    jl_typename_t *tn = ((jl_datatype_t*)v)->name;
-                    if (tn->module == m && tn->name == b->name) {
-                        jl_methtable_t *mt = tn->mt;
-                        if (mt != NULL && (jl_value_t*)mt != jl_nothing) {
-                            jl_typemap_visitor(mt->defs, _compile_all_enq, (void*)found);
-                        }
-                    }
-                }
-                else if (jl_is_module(v)) {
-                    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);
-                    }
-                }
-            }
-        }
-    }
-}
-
-static void jl_compile_all_defs(void)
-{
-    // this "found" array will contain
-    // TypeMapEntries for Methods and MethodInstances that need to be compiled
-    jl_array_t *m = jl_alloc_vec_any(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();
-}
-
-static int _precompile_enq_tfunc(jl_typemap_entry_t *l, void *closure)
-{
-    if (jl_is_method_instance(l->func.value) &&
-            l->func.linfo->functionObjectsDecls.functionObject == NULL &&
-            l->func.linfo->jlcall_api != 2)
-        jl_array_ptr_1d_push((jl_array_t*)closure, (jl_value_t*)l->sig);
-    return 1;
-}
-
-static int _precompile_enq_spec(jl_typemap_entry_t *def, void *closure)
-{
-    jl_typemap_visitor(def->func.method->specializations, _precompile_enq_tfunc, closure);
-    return 1;
-}
-
-static void _precompile_enq_module(jl_module_t *m, jl_array_t *unspec)
-{
-    // removes all method caches
-    size_t i;
-    void **table = m->bindings.table;
-    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->owner == m && b->value && b->constp) {
-                if (jl_is_datatype(b->value)) {
-                    jl_typename_t *tn = ((jl_datatype_t*)b->value)->name;
-                    if (tn->module == m && tn->name == b->name) {
-                        jl_methtable_t *mt = tn->mt;
-                        if (mt != NULL && (jl_value_t*)mt != jl_nothing) {
-                            jl_typemap_visitor(mt->defs, _precompile_enq_spec, (void*)unspec);
-                        }
-                    }
-                }
-                else 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
-                        _precompile_enq_module((jl_module_t*)b->value, unspec);
-                    }
-                }
-            }
-        }
-    }
-}
-
-static void jl_compile_specializations(void)
-{
-    // this "found" array will contain function
-    // type signatures that were inferred but haven't been compiled
-    jl_array_t *m = jl_alloc_vec_any(0);
-    JL_GC_PUSH1(&m);
-    _precompile_enq_module(jl_main_module, m);
-    size_t i, l;
-    for (i = 0, l = jl_array_len(m); i < l; i++) {
-        jl_compile_hint((jl_tupletype_t*)jl_array_ptr_ref(m, i));
-    }
-    JL_GC_POP();
-}
-
-void jl_precompile(int all) {
-    if (all)
-        jl_compile_all_defs();
-    jl_compile_specializations();
-}
-
 #ifdef JL_TRACE
 static int trace_en = 0;
 static int error_en = 1;
@@ -2067,17 +1785,6 @@ static jl_value_t *verify_type(jl_value_t *v)
     return v;
 }
 
-STATIC_INLINE uint32_t int32hash_fast(uint32_t a)
-{
-//    a = (a+0x7ed55d16) + (a<<12);
-//    a = (a^0xc761c23c) ^ (a>>19);
-//    a = (a+0x165667b1) + (a<<5);
-//    a = (a+0xd3a2646c) ^ (a<<9);
-//    a = (a+0xfd7046c5) + (a<<3);
-//    a = (a^0xb55a4f09) ^ (a>>16);
-    return a;  // identity hashing seems to work well enough here
-}
-
 STATIC_INLINE int sig_match_fast(jl_value_t **args, jl_value_t **sig, size_t i, size_t n)
 {
     // NOTE: This function is a huge performance hot spot!!
@@ -2099,7 +1806,8 @@ jl_typemap_entry_t *call_cache[N_CALL_CACHE];
 static uint8_t pick_which[N_CALL_CACHE];
 #ifdef JL_GF_PROFILE
 size_t ncalls;
-void call_cache_stats() {
+void call_cache_stats()
+{
     int pick_which_stat[4] = {0, 0, 0, 0};
     int i, count = 0;
     for (i = 0; i < N_CALL_CACHE; i++) {
@@ -2115,11 +1823,8 @@ void call_cache_stats() {
 }
 #endif
 
-#ifdef _COMPILER_MICROSOFT_
-#define __builtin_return_address(n) _ReturnAddress()
-#endif
-
-JL_DLLEXPORT jl_value_t *jl_apply_generic(jl_value_t **args, uint32_t nargs)
+STATIC_INLINE jl_method_instance_t *jl_lookup_generic_(jl_value_t **args, uint32_t nargs,
+                                                       uint32_t callsite, size_t world)
 {
 #ifdef JL_GF_PROFILE
     ncalls++;
@@ -2129,7 +1834,6 @@ JL_DLLEXPORT jl_value_t *jl_apply_generic(jl_value_t **args, uint32_t nargs)
     if (traceen)
         show_call(args[0], &args[1], nargs-1);
 #endif
-    size_t world = jl_get_ptls_states()->world_age;
 
     /*
       search order:
@@ -2141,7 +1845,6 @@ JL_DLLEXPORT jl_value_t *jl_apply_generic(jl_value_t **args, uint32_t nargs)
       if no generic match, use the concrete one even if inexact
       otherwise instantiate the generic method and use it
     */
-    uint32_t callsite = int32hash_fast((uintptr_t)__builtin_return_address(0));
     // compute the entry hashes
     // use different parts of the value
     // so that a collision across all of
@@ -2207,8 +1910,22 @@ JL_DLLEXPORT jl_value_t *jl_apply_generic(jl_value_t **args, uint32_t nargs)
 
 #ifdef JL_TRACE
     if (traceen)
-        jl_printf(JL_STDOUT, " at %s:%d\n", jl_symbol_name(mfunc->def->file), mfunc->def->line);
+        jl_printf(JL_STDOUT, " at %s:%d\n", jl_symbol_name(mfunc->def.method->file), mfunc->def.method->line);
 #endif
+    return mfunc;
+}
+
+jl_method_instance_t *jl_lookup_generic(jl_value_t **args, uint32_t nargs, uint32_t callsite,
+                                        size_t world)
+{
+    return jl_lookup_generic_(args, nargs, callsite, world);
+}
+
+JL_DLLEXPORT jl_value_t *jl_apply_generic(jl_value_t **args, uint32_t nargs)
+{
+    jl_method_instance_t *mfunc = jl_lookup_generic_(args, nargs,
+                                                     jl_int32hash_fast(jl_return_address()),
+                                                     jl_get_ptls_states()->world_age);
     jl_value_t *res = jl_call_method_internal(mfunc, args, nargs);
     return verify_type(res);
 }
@@ -2389,12 +2106,12 @@ jl_function_t *jl_new_generic_function_with_supertype(jl_sym_t *name, jl_module_
     }
     jl_sym_t *tname = jl_symbol(prefixed);
     free(prefixed);
-    jl_datatype_t *ftype = (jl_datatype_t*)jl_new_datatype(tname, st, jl_emptysvec, jl_emptysvec, jl_emptysvec, 0, 0, 0);
+    jl_datatype_t *ftype = (jl_datatype_t*)jl_new_datatype(
+            tname, module, st, jl_emptysvec, jl_emptysvec, jl_emptysvec, 0, 0, 0);
     assert(jl_is_datatype(ftype));
     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);
+    ftype->name->mt->name = name;
+    jl_gc_wb(ftype->name->mt, name);
     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);
@@ -2402,8 +2119,12 @@ jl_function_t *jl_new_generic_function_with_supertype(jl_sym_t *name, jl_module_
     return (jl_function_t*)f;
 }
 
-JL_DLLEXPORT jl_function_t *jl_get_kwsorter(jl_typename_t *tn)
+JL_DLLEXPORT jl_function_t *jl_get_kwsorter(jl_value_t *ty)
 {
+    jl_datatype_t *dt = (jl_datatype_t*)jl_argument_datatype(ty);
+    if ((jl_value_t*)dt == jl_nothing)
+        jl_error("cannot get keyword sorter for abstract type");
+    jl_typename_t *tn = dt->name;
     jl_methtable_t *mt = tn->mt;
     if (!mt->kwsorter) {
         JL_LOCK(&mt->writelock);
@@ -2538,16 +2259,6 @@ static int ml_matches_visitor(jl_typemap_entry_t *ml, struct typemap_intersectio
                 break;
             }
         }
-        // don't analyze slots declared with ANY
-        // TODO
-        /*
-        l = jl_nparams(ml->sig);
-        size_t m = jl_nparams(ti);
-        for(i=0; i < l && i < m; i++) {
-            if (jl_tparam(ml->sig, i) == jl_ANY_flag)
-                jl_tupleset(ti, i, jl_any_type);
-        }
-        */
     }
     if (!skip) {
         /*
@@ -2571,12 +2282,13 @@ static int ml_matches_visitor(jl_typemap_entry_t *ml, struct typemap_intersectio
         // add it to the results.
         if (return_this_match && meth->ambig != jl_nothing && (!closure->include_ambiguous || done)) {
             jl_svec_t *env = NULL;
-            JL_GC_PUSH1(&env);
+            jl_value_t *mti = NULL;
+            JL_GC_PUSH2(&env, &mti);
             for (size_t j = 0; j < jl_array_len(meth->ambig); j++) {
                 jl_method_t *mambig = (jl_method_t*)jl_array_ptr_ref(meth->ambig, j);
                 env = jl_emptysvec;
-                jl_value_t *mti = jl_type_intersection_env((jl_value_t*)closure->match.type,
-                                                           (jl_value_t*)mambig->sig, &env);
+                mti = jl_type_intersection_env((jl_value_t*)closure->match.type,
+                                               (jl_value_t*)mambig->sig, &env);
                 if (mti != (jl_value_t*)jl_bottom_type) {
                     if (closure->include_ambiguous) {
                         assert(done);
@@ -2589,8 +2301,8 @@ static int ml_matches_visitor(jl_typemap_entry_t *ml, struct typemap_intersectio
                             if (len == 0) {
                                 closure->t = (jl_value_t*)jl_alloc_vec_any(0);
                             }
-                            jl_array_ptr_1d_push((jl_array_t*)closure->t,
-                                                 (jl_value_t*)jl_svec(3, mti, env, mambig));
+                            mti = (jl_value_t*)jl_svec(3, mti, env, mambig);
+                            jl_array_ptr_1d_push((jl_array_t*)closure->t, mti);
                             len++;
                         }
                     }
diff --git a/src/init.c b/src/init.c
index 7081cf62b56dd9..89169eecc2374d 100644
--- a/src/init.c
+++ b/src/init.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 /*
   init.c
@@ -139,7 +139,7 @@ static void jl_find_stack_bottom(void)
 
     // When using the sanitizers, increase stack size because they bloat
     // stack usage
-    const rlim_t kStackSize = 32 * 1024 * 1024;   // 32MB stack
+    const rlim_t kStackSize = 64 * 1024 * 1024;   // 64MiB stack
     int result;
 
     result = getrlimit(RLIMIT_STACK, &rl);
@@ -177,7 +177,7 @@ static void jl_uv_exitcleanup_walk(uv_handle_t *handle, void *arg)
 
 void jl_write_coverage_data(void);
 void jl_write_malloc_log(void);
-static void julia_save(void);
+void jl_write_compiler_output(void);
 
 static struct uv_shutdown_queue_item *next_shutdown_queue_item(struct uv_shutdown_queue_item *item)
 {
@@ -190,10 +190,52 @@ void jl_init_timing(void);
 void jl_destroy_timing(void);
 void jl_uv_call_close_callback(jl_value_t *val);
 
+static void jl_close_item_atexit(uv_handle_t *handle)
+{
+    if (handle->type != UV_FILE && uv_is_closing(handle))
+        return;
+    switch(handle->type) {
+    case UV_PROCESS:
+        // cause Julia to forget about the Process object
+        if (handle->data)
+            jl_uv_call_close_callback((jl_value_t*)handle->data);
+        // and make libuv think it is already dead
+        ((uv_process_t*)handle)->pid = 0;
+        // fall-through
+    case UV_TTY:
+    case UV_UDP:
+    case UV_TCP:
+    case UV_NAMED_PIPE:
+    case UV_POLL:
+    case UV_TIMER:
+    case UV_ASYNC:
+    case UV_FS_EVENT:
+    case UV_FS_POLL:
+    case UV_IDLE:
+    case UV_PREPARE:
+    case UV_CHECK:
+    case UV_SIGNAL:
+    case UV_FILE:
+        // These will be shutdown as appropriate by jl_close_uv
+        jl_close_uv(handle);
+        break;
+    case UV_HANDLE:
+    case UV_STREAM:
+    case UV_UNKNOWN_HANDLE:
+    case UV_HANDLE_TYPE_MAX:
+    case UV_RAW_FD:
+    case UV_RAW_HANDLE:
+    default:
+        assert(0);
+    }
+}
+
 JL_DLLEXPORT void jl_atexit_hook(int exitcode)
 {
     jl_ptls_t ptls = jl_get_ptls_states();
-    if (exitcode == 0) julia_save();
+
+    if (exitcode == 0)
+        jl_write_compiler_output();
     jl_print_gc_stats(JL_STDERR);
     if (jl_options.code_coverage)
         jl_write_coverage_data();
@@ -203,10 +245,10 @@ JL_DLLEXPORT void jl_atexit_hook(int exitcode)
         jl_value_t *f = jl_get_global(jl_base_module, jl_symbol("_atexit"));
         if (f != NULL) {
             JL_TRY {
-                size_t last_age = jl_get_ptls_states()->world_age;
-                jl_get_ptls_states()->world_age = jl_get_world_counter();
+                size_t last_age = ptls->world_age;
+                ptls->world_age = jl_get_world_counter();
                 jl_apply(&f, 1);
-                jl_get_ptls_states()->world_age = last_age;
+                ptls->world_age = last_age;
             }
             JL_CATCH {
                 jl_printf(JL_STDERR, "\natexit hook threw an error: ");
@@ -231,62 +273,33 @@ JL_DLLEXPORT void jl_atexit_hook(int exitcode)
     struct uv_shutdown_queue queue = {NULL, NULL};
     uv_walk(loop, jl_uv_exitcleanup_walk, &queue);
     struct uv_shutdown_queue_item *item = queue.first;
-    while (item) {
-        JL_TRY {
-            while (item) {
-                uv_handle_t *handle = item->h;
-                if (handle->type != UV_FILE && uv_is_closing(handle)) {
+    if (ptls->current_task != NULL) {
+        while (item) {
+            JL_TRY {
+                while (item) {
+                    jl_close_item_atexit(item->h);
                     item = next_shutdown_queue_item(item);
-                    continue;
-                }
-                switch(handle->type) {
-                case UV_PROCESS:
-                    // cause Julia to forget about the Process object
-                    if (handle->data)
-                        jl_uv_call_close_callback((jl_value_t*)handle->data);
-                    // and make libuv think it is already dead
-                    ((uv_process_t*)handle)->pid = 0;
-                    // fall-through
-                case UV_TTY:
-                case UV_UDP:
-                case UV_TCP:
-                case UV_NAMED_PIPE:
-                case UV_POLL:
-                case UV_TIMER:
-                case UV_ASYNC:
-                case UV_FS_EVENT:
-                case UV_FS_POLL:
-                case UV_IDLE:
-                case UV_PREPARE:
-                case UV_CHECK:
-                case UV_SIGNAL:
-                case UV_FILE:
-                    // These will be shutdown as appropriate by jl_close_uv
-                    jl_close_uv(handle);
-                    break;
-                case UV_HANDLE:
-                case UV_STREAM:
-                case UV_UNKNOWN_HANDLE:
-                case UV_HANDLE_TYPE_MAX:
-                case UV_RAW_FD:
-                case UV_RAW_HANDLE:
-                default:
-                    assert(0);
                 }
+            }
+            JL_CATCH {
+                //error handling -- continue cleanup, as much as possible
+                uv_unref(item->h);
+                jl_printf(JL_STDERR, "error during exit cleanup: close: ");
+                jl_static_show(JL_STDERR, ptls->exception_in_transit);
                 item = next_shutdown_queue_item(item);
             }
         }
-        JL_CATCH {
-            //error handling -- continue cleanup, as much as possible
-            uv_unref(item->h);
-            jl_printf(JL_STDERR, "error during exit cleanup: close: ");
-            jl_static_show(JL_STDERR, ptls->exception_in_transit);
+    }
+    else {
+        while (item) {
+            jl_close_item_atexit(item->h);
             item = next_shutdown_queue_item(item);
         }
     }
+
     // force libuv to spin until everything has finished closing
     loop->stop_flag = 0;
-    while (uv_run(loop,UV_RUN_DEFAULT)) {}
+    while (uv_run(loop, UV_RUN_DEFAULT)) { }
 
     jl_destroy_timing();
 #ifdef ENABLE_TIMINGS
@@ -299,8 +312,8 @@ void jl_get_builtins(void);
 
 JL_DLLEXPORT void *jl_dl_handle;
 void *jl_RTLD_DEFAULT_handle;
-#ifdef _OS_WINDOWS_
 JL_DLLEXPORT void *jl_exe_handle;
+#ifdef _OS_WINDOWS_
 void *jl_ntdll_handle;
 void *jl_kernel32_handle;
 void *jl_crtdll_handle;
@@ -317,9 +330,15 @@ static void *init_stdio_handle(uv_file fd,int readable)
 #ifndef _OS_WINDOWS_
     // Duplicate the file descriptor so we can later dup it over if we want to redirect
     // STDIO without having to worry about closing the associated libuv object.
+    // This also helps limit the impact other libraries can cause on our file handle.
     // On windows however, libuv objects remember streams by their HANDLE, so this is
     // unnecessary.
     fd = dup(fd);
+#else
+    if (type == UV_FILE) {
+        fd = _dup(fd);
+        _setmode(fd, _O_BINARY);
+    }
 #endif
     //jl_printf(JL_STDOUT, "%d: %d -- %d\n", fd, type, 0);
     switch(type) {
@@ -334,11 +353,17 @@ static void *init_stdio_handle(uv_file fd,int readable)
         case UV_UNKNOWN_HANDLE:
             // dup the descriptor with a new one pointing at the bit bucket ...
 #if defined(_OS_WINDOWS_)
-            _dup2(_open("NUL", O_RDWR | O_BINARY, _S_IREAD | _S_IWRITE), fd);
+            fd = _open("NUL", O_RDWR | O_BINARY, _S_IREAD | _S_IWRITE);
 #else
-            dup2(open("/dev/null", O_RDWR, S_IRUSR | S_IWUSR /* 0600 */ | S_IRGRP | S_IROTH /* 0644 */), fd);
+            {
+                int nullfd;
+                nullfd = open("/dev/null", O_RDWR, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH /* 0666 */);
+                dup2(nullfd, fd);
+                close(nullfd);
+            }
 #endif
             // ...and continue on as in the UV_FILE case
+            JL_FALLTHROUGH;
         case UV_FILE:
             file = (jl_uv_file_t*)malloc(sizeof(jl_uv_file_t));
             file->loop = jl_io_loop;
@@ -527,9 +552,11 @@ void _julia_init(JL_IMAGE_SEARCH rel)
                                     // best to call this first, since it also initializes libuv
     jl_init_signal_async();
     restore_signals();
+
     jl_resolve_sysimg_location(rel);
     // loads sysimg if available, and conditionally sets jl_options.cpu_target
-    jl_preload_sysimg_so(jl_options.image_file);
+    if (jl_options.image_file)
+        jl_preload_sysimg_so(jl_options.image_file);
     if (jl_options.cpu_target == NULL)
         jl_options.cpu_target = "native";
 
@@ -541,11 +568,6 @@ 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 = jl_load_dynamic_library(NULL, JL_RTLD_DEFAULT);
-#ifdef RTLD_DEFAULT
-    jl_RTLD_DEFAULT_handle = RTLD_DEFAULT;
-#else
-    jl_RTLD_DEFAULT_handle = jl_dl_handle;
-#endif
 #ifdef _OS_WINDOWS_
     jl_ntdll_handle = jl_dlopen("ntdll.dll", 0); // bypass julia's pathchecking for system dlls
     jl_kernel32_handle = jl_dlopen("kernel32.dll", 0);
@@ -564,6 +586,13 @@ void _julia_init(JL_IMAGE_SEARCH rel)
     HMODULE jl_dbghelp = (HMODULE) jl_dlopen("dbghelp.dll", 0);
     if (jl_dbghelp)
         hSymRefreshModuleList = (BOOL (WINAPI*)(HANDLE)) jl_dlsym(jl_dbghelp, "SymRefreshModuleList");
+#else
+    jl_exe_handle = jl_dlopen(NULL, JL_RTLD_NOW);
+#ifdef RTLD_DEFAULT
+    jl_RTLD_DEFAULT_handle = RTLD_DEFAULT;
+#else
+    jl_RTLD_DEFAULT_handle = jl_exe_handle;
+#endif
 #endif
 
 #if defined(JL_USE_INTEL_JITEVENTS)
@@ -635,11 +664,11 @@ void _julia_init(JL_IMAGE_SEARCH rel)
         jl_internal_main_module = jl_main_module;
 
         ptls->current_module = jl_core_module;
-        for (int t = 0;t < jl_n_threads;t++) {
-            jl_all_tls_states[t]->root_task->current_module = ptls->current_module;
+        for (int t = 0; t < jl_n_threads; t++) {
+            jl_all_tls_states[t]->root_task->current_module = jl_core_module;
         }
 
-        jl_load("boot.jl");
+        jl_load(jl_core_module, "boot.jl");
         jl_get_builtin_hooks();
         jl_boot_file_loaded = 1;
         jl_init_box_caches();
@@ -684,8 +713,8 @@ void _julia_init(JL_IMAGE_SEARCH rel)
         jl_add_standard_imports(jl_main_module);
     }
     ptls->current_module = jl_main_module;
-    for (int t = 0;t < jl_n_threads;t++) {
-        jl_all_tls_states[t]->root_task->current_module = ptls->current_module;
+    for (int t = 0; t < jl_n_threads; t++) {
+        jl_all_tls_states[t]->root_task->current_module = jl_main_module;
     }
 
     // This needs to be after jl_start_threads
@@ -710,74 +739,6 @@ void _julia_init(JL_IMAGE_SEARCH rel)
         jl_install_sigint_handler();
 }
 
-extern int asprintf(char **str, const char *fmt, ...);
-
-JL_DLLEXPORT int jl_generating_output(void)
-{
-    return jl_options.outputo || jl_options.outputbc || jl_options.outputji;
-}
-
-void jl_precompile(int all);
-
-static void julia_save(void)
-{
-    if (!jl_generating_output())
-        return;
-
-    if (!jl_options.incremental)
-        jl_precompile(jl_options.compile_enabled == JL_OPTIONS_COMPILE_ALL);
-
-    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_vec_any(0);
-    int i, l = jl_array_len(worklist);
-    for (i = 0; i < l; i++) {
-        jl_value_t *m = jl_arrayref(worklist, i);
-        if (jl_get_global((jl_module_t*)m, jl_symbol("__init__"))) {
-            jl_array_ptr_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);
-        if (jl_options.outputbc)
-            jl_printf(JL_STDERR, "WARNING: incremental output to a .bc file is not implemented\n");
-        if (jl_options.outputo)
-            jl_printf(JL_STDERR, "WARNING: incremental output to a .o file is not implemented\n");
-    }
-    else {
-        ios_t *s = NULL;
-        if (jl_options.outputo || jl_options.outputbc)
-            s = jl_create_system_image();
-
-        if (jl_options.outputji) {
-            if (s == NULL) {
-                jl_save_system_image(jl_options.outputji);
-            }
-            else {
-                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, (size_t)s->size);
-                ios_close(&f);
-            }
-        }
-
-        if (jl_options.outputo || jl_options.outputbc)
-            jl_dump_native(jl_options.outputbc,
-                           jl_options.outputo,
-                           (const char*)s->buf, (size_t)s->size);
-    }
-    JL_GC_POP();
-}
-
 static jl_value_t *core(const char *name)
 {
     return jl_get_global(jl_core_module, jl_symbol(name));
@@ -814,13 +775,17 @@ void jl_get_builtin_hooks(void)
     jl_floatingpoint_type = (jl_datatype_t*)core("AbstractFloat");
     jl_number_type = (jl_datatype_t*)core("Number");
     jl_signed_type = (jl_datatype_t*)core("Signed");
+    jl_datatype_t *jl_unsigned_type = (jl_datatype_t*)core("Unsigned");
+    jl_datatype_t *jl_integer_type = (jl_datatype_t*)core("Integer");
+    jl_bool_type->super = jl_integer_type;
+    jl_uint8_type->super = jl_unsigned_type;
+    jl_int32_type->super = jl_signed_type;
+    jl_int64_type->super = jl_signed_type;
 
     jl_errorexception_type = (jl_datatype_t*)core("ErrorException");
     jl_stackovf_exception  = jl_new_struct_uninit((jl_datatype_t*)core("StackOverflowError"));
     jl_diverror_exception  = jl_new_struct_uninit((jl_datatype_t*)core("DivideError"));
-    jl_domain_exception    = jl_new_struct_uninit((jl_datatype_t*)core("DomainError"));
     jl_overflow_exception  = jl_new_struct_uninit((jl_datatype_t*)core("OverflowError"));
-    jl_inexact_exception   = jl_new_struct_uninit((jl_datatype_t*)core("InexactError"));
     jl_undefref_exception  = jl_new_struct_uninit((jl_datatype_t*)core("UndefRefError"));
     jl_undefvarerror_type  = (jl_datatype_t*)core("UndefVarError");
     jl_interrupt_exception = jl_new_struct_uninit((jl_datatype_t*)core("InterruptException"));
@@ -852,7 +817,7 @@ void jl_get_builtins(void)
 {
     jl_builtin_throw = core("throw");           jl_builtin_is = core("===");
     jl_builtin_typeof = core("typeof");         jl_builtin_sizeof = core("sizeof");
-    jl_builtin_issubtype = core("issubtype");   jl_builtin_isa = core("isa");
+    jl_builtin_issubtype = core("<:");          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");
diff --git a/src/interpreter.c b/src/interpreter.c
index db8f1475591735..c1ebb4ff6f3d61 100644
--- a/src/interpreter.c
+++ b/src/interpreter.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include <stdlib.h>
 #include <setjmp.h>
@@ -24,18 +24,12 @@ typedef struct {
 static jl_value_t *eval(jl_value_t *e, interpreter_state *s);
 static jl_value_t *eval_body(jl_array_t *stmts, interpreter_state *s, int start, int toplevel);
 
-jl_value_t *jl_eval_module_expr(jl_expr_t *ex);
+jl_value_t *jl_eval_module_expr(jl_module_t *m, jl_expr_t *ex);
 int jl_is_toplevel_only_expr(jl_value_t *e);
 
-jl_value_t *jl_interpret_toplevel_expr(jl_value_t *e)
-{
-    size_t last_age = jl_get_ptls_states()->world_age;
-    jl_get_ptls_states()->world_age = jl_world_counter;
-    jl_value_t *ret = eval(e, NULL);
-    jl_get_ptls_states()->world_age = last_age;
-    return ret;
-}
-
+// deprecated: do not use this method in new code
+// it uses special scoping / evaluation / error rules
+// which should instead be handled in lowering
 jl_value_t *jl_interpret_toplevel_expr_in(jl_module_t *m, jl_value_t *e,
                                           jl_code_info_t *src,
                                           jl_svec_t *sparam_vals)
@@ -85,7 +79,7 @@ static jl_value_t *do_invoke(jl_value_t **args, size_t nargs, interpreter_state
     for (i = 1; i < nargs; i++)
         argv[i - 1] = eval(args[i], s);
     jl_method_instance_t *meth = (jl_method_instance_t*)args[0];
-    assert(jl_is_method_instance(meth) && !meth->inInference);
+    assert(jl_is_method_instance(meth));
     jl_value_t *result = jl_call_method_internal(meth, argv, nargs - 1);
     JL_GC_POP();
     return result;
@@ -111,17 +105,18 @@ static int equiv_type(jl_datatype_t *dta, jl_datatype_t *dtb)
           dta->mutabl == dtb->mutabl &&
           dta->size == dtb->size &&
           dta->ninitialized == dtb->ninitialized &&
-          jl_egal((jl_value_t*)dta->name->names, (jl_value_t*)dtb->name->names) &&
+          jl_egal((jl_value_t*)jl_field_names(dta), (jl_value_t*)jl_field_names(dtb)) &&
           jl_nparams(dta) == jl_nparams(dtb) &&
           jl_field_count(dta) == jl_field_count(dtb)))
         return 0;
     jl_value_t *a=NULL, *b=NULL;
+    int ok = 1;
+    size_t i, nf = jl_field_count(dta);
     JL_GC_PUSH2(&a, &b);
     a = jl_rewrap_unionall((jl_value_t*)dta->super, dta->name->wrapper);
     b = jl_rewrap_unionall((jl_value_t*)dtb->super, dtb->name->wrapper);
     if (!jl_types_equal(a, b))
         goto no;
-    int ok = 1;
     JL_TRY {
         a = jl_apply_type(dtb->name->wrapper, jl_svec_data(dta->parameters), jl_nparams(dta));
     }
@@ -130,8 +125,6 @@ static int equiv_type(jl_datatype_t *dta, jl_datatype_t *dtb)
     }
     if (!ok) goto no;
     assert(jl_is_datatype(a));
-    if (!jl_egal((jl_value_t*)((jl_datatype_t*)a)->types, (jl_value_t*)dta->types))
-        goto no;
     a = dta->name->wrapper;
     b = dtb->name->wrapper;
     while (jl_is_unionall(a)) {
@@ -143,6 +136,19 @@ static int equiv_type(jl_datatype_t *dta, jl_datatype_t *dtb)
         a = jl_instantiate_unionall(ua, (jl_value_t*)ub->var);
         b = ub->body;
     }
+    assert(jl_is_datatype(a) && jl_is_datatype(b));
+    for (i=0; i < nf; i++) {
+        jl_value_t *ta = jl_svecref(((jl_datatype_t*)a)->types, i);
+        jl_value_t *tb = jl_svecref(((jl_datatype_t*)b)->types, i);
+        if (jl_has_free_typevars(ta)) {
+            if (!jl_has_free_typevars(tb) || !jl_egal(ta, tb))
+                goto no;
+        }
+        else if (jl_has_free_typevars(tb) || jl_typeof(ta) != jl_typeof(tb) ||
+                 !jl_types_equal(ta, tb)) {
+            goto no;
+        }
+    }
     JL_GC_POP();
     return 1;
  no:
@@ -188,45 +194,70 @@ static int jl_source_nssavalues(jl_code_info_t *src)
 static jl_value_t *eval(jl_value_t *e, interpreter_state *s)
 {
     jl_ptls_t ptls = jl_get_ptls_states();
-    jl_code_info_t *src = s==NULL ? NULL : s->src;
+    jl_code_info_t *src = s->src;
     if (jl_is_ssavalue(e)) {
         ssize_t id = ((jl_ssavalue_t*)e)->id;
-        if (id >= jl_source_nssavalues(src) || id < 0 || s->locals == NULL)
+        if (src == NULL || id >= jl_source_nssavalues(src) || id < 0 || s->locals == NULL)
             jl_error("access to invalid SSAValue");
         else
             return s->locals[jl_source_nslots(src) + id];
     }
     if (jl_is_slot(e)) {
         ssize_t n = jl_slot_number(e);
-        if (n > jl_source_nslots(src) || n < 1 || s->locals == NULL)
+        if (src == NULL || n > jl_source_nslots(src) || n < 1 || s->locals == NULL)
             jl_error("access to invalid slot number");
-        jl_value_t *v = s->locals[n-1];
+        jl_value_t *v = s->locals[n - 1];
         if (v == NULL)
             jl_undefined_var_error((jl_sym_t*)jl_array_ptr_ref(src->slotnames, n - 1));
         return v;
     }
     if (jl_is_globalref(e)) {
-        jl_sym_t *s = jl_globalref_name(e);
-        jl_value_t *v = jl_get_global(jl_globalref_mod(e), s);
-        if (v == NULL)
-            jl_undefined_var_error(s);
-        return v;
+        return jl_eval_global_var(jl_globalref_mod(e), jl_globalref_name(e));
     }
     if (jl_is_quotenode(e))
         return jl_fieldref(e,0);
-    jl_module_t *modu = (s == NULL ? ptls->current_module : s->module);
+    jl_module_t *modu = s->module;
     if (jl_is_symbol(e)) {  // bare symbols appear in toplevel exprs not wrapped in `thunk`
-        jl_value_t *v = jl_get_global(modu, (jl_sym_t*)e);
-        if (v == NULL)
-            jl_undefined_var_error((jl_sym_t*)e);
-        return v;
+        return jl_eval_global_var(modu, (jl_sym_t*)e);
     }
     if (!jl_is_expr(e))
         return e;
     jl_expr_t *ex = (jl_expr_t*)e;
     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 (ex->head == isdefined_sym) {
+        jl_value_t *sym = args[0];
+        int defined = 0;
+        if (jl_is_slot(sym)) {
+            ssize_t n = jl_slot_number(sym);
+            if (src == NULL || n > jl_source_nslots(src) || n < 1 || s->locals == NULL)
+                jl_error("access to invalid slot number");
+            defined = s->locals[n - 1] != NULL;
+        }
+        else if (jl_is_globalref(sym)) {
+            defined = jl_boundp(jl_globalref_mod(sym), jl_globalref_name(sym));
+        }
+        else if (jl_is_symbol(sym)) {
+            defined = jl_boundp(modu, (jl_sym_t*)sym);
+        }
+        else if (jl_is_expr(sym) && ((jl_expr_t*)sym)->head == static_parameter_sym) {
+            ssize_t n = jl_unbox_long(args[0]);
+            assert(n > 0);
+            if (s->sparam_vals && n <= jl_svec_len(s->sparam_vals)) {
+                jl_value_t *sp = jl_svecref(s->sparam_vals, n - 1);
+                defined = !jl_is_typevar(sp);
+            }
+            else {
+                // static parameter val unknown needs to be an error for ccall
+                jl_error("could not determine static parameter value");
+            }
+        }
+        else {
+            assert(0 && "malformed isdefined expression");
+        }
+        return defined ? jl_true : jl_false;
+    }
+    else if (ex->head == call_sym) {
         return do_call(args, nargs, s);
     }
     else if (ex->head == invoke_sym) {
@@ -279,7 +310,7 @@ static jl_value_t *eval(jl_value_t *e, interpreter_state *s)
                 bp = &b->value;
                 bp_owner = (jl_value_t*)modu;
             }
-            jl_value_t *gf = jl_generic_function_def(fname, bp, bp_owner, b);
+            jl_value_t *gf = jl_generic_function_def(fname, modu, bp, bp_owner, b);
             if (jl_expr_nargs(ex) == 1)
                 return gf;
         }
@@ -288,7 +319,7 @@ static jl_value_t *eval(jl_value_t *e, interpreter_state *s)
         JL_GC_PUSH2(&atypes, &meth);
         atypes = eval(args[1], s);
         meth = eval(args[2], s);
-        jl_method_def((jl_svec_t*)atypes, (jl_code_info_t*)meth, args[3]);
+        jl_method_def((jl_svec_t*)atypes, (jl_code_info_t*)meth, s->module, args[3]);
         JL_GC_POP();
         return jl_nothing;
     }
@@ -335,7 +366,7 @@ static jl_value_t *eval(jl_value_t *e, interpreter_state *s)
             name = (jl_value_t*)jl_globalref_name(name);
         }
         assert(jl_is_symbol(name));
-        dt = jl_new_abstracttype(name, NULL, (jl_svec_t*)para);
+        dt = jl_new_abstracttype(name, modu, NULL, (jl_svec_t*)para);
         w = dt->name->wrapper;
         jl_binding_t *b = jl_get_binding_wr(modu, (jl_sym_t*)name);
         temp = b->value;
@@ -383,7 +414,7 @@ static jl_value_t *eval(jl_value_t *e, interpreter_state *s)
         if (nb < 1 || nb>=(1<<23) || (nb&7) != 0)
             jl_errorf("invalid number of bits in type %s",
                       jl_symbol_name((jl_sym_t*)name));
-        dt = jl_new_primitivetype(name, NULL, (jl_svec_t*)para, nb);
+        dt = jl_new_primitivetype(name, modu, NULL, (jl_svec_t*)para, nb);
         w = dt->name->wrapper;
         jl_binding_t *b = jl_get_binding_wr(modu, (jl_sym_t*)name);
         temp = b->value;
@@ -425,7 +456,7 @@ static jl_value_t *eval(jl_value_t *e, interpreter_state *s)
         assert(jl_is_symbol(name));
         assert(jl_is_svec(para));
         temp = eval(args[2], s);  // field names
-        dt = jl_new_datatype((jl_sym_t*)name, NULL, (jl_svec_t*)para,
+        dt = jl_new_datatype((jl_sym_t*)name, modu, NULL, (jl_svec_t*)para,
                              (jl_svec_t*)temp, NULL,
                              0, args[5]==jl_true ? 1 : 0, jl_unbox_long(args[6]));
         w = dt->name->wrapper;
@@ -458,14 +489,7 @@ static jl_value_t *eval(jl_value_t *e, interpreter_state *s)
             b->value = temp;
             jl_rethrow();
         }
-        if (dt->name->names == jl_emptysvec)
-            dt->layout = jl_void_type->layout; // reuse the same layout for all singletons
-        else if (jl_is_concrete_type((jl_value_t*)dt))
-            jl_compute_field_offsets(dt);
-        if (para == (jl_value_t*)jl_emptysvec && jl_is_datatype_make_singleton(dt)) {
-            dt->instance = jl_gc_alloc(ptls, 0, dt);
-            jl_gc_wb(dt, dt->instance);
-        }
+        jl_compute_field_offsets(dt);
 
         b->value = temp;
         if (temp == NULL || !equiv_type(dt, (jl_datatype_t*)jl_unwrap_unionall(temp))) {
@@ -476,10 +500,10 @@ static jl_value_t *eval(jl_value_t *e, interpreter_state *s)
         return (jl_value_t*)jl_nothing;
     }
     else if (ex->head == module_sym) {
-        return jl_eval_module_expr(ex);
+        return jl_eval_module_expr(s->module, ex);
     }
     else if (ex->head == thunk_sym) {
-        return jl_toplevel_eval((jl_value_t*)ex);
+        return jl_toplevel_eval(s->module, (jl_value_t*)ex);
     }
     else if (ex->head == error_sym || ex->head == jl_incomplete_sym) {
         if (nargs == 0)
@@ -496,19 +520,24 @@ static jl_value_t *eval(jl_value_t *e, interpreter_state *s)
     return (jl_value_t*)jl_nothing;
 }
 
-jl_value_t *jl_toplevel_eval_body(jl_array_t *stmts)
+jl_value_t *jl_toplevel_eval_body(jl_module_t *m, jl_array_t *stmts)
 {
     size_t last_age = jl_get_ptls_states()->world_age;
-    jl_value_t *ret = eval_body(stmts, NULL, 0, 1);
+    interpreter_state s;
+    s.src = NULL;
+    s.module = m;
+    s.locals = NULL;
+    s.sparam_vals = NULL;
+    jl_value_t *ret = eval_body(stmts, &s, 0, 1);
     jl_get_ptls_states()->world_age = last_age;
     return ret;
 }
 
 static jl_value_t *eval_body(jl_array_t *stmts, interpreter_state *s, int start, int toplevel)
 {
-    jl_ptls_t ptls = jl_get_ptls_states();
     jl_handler_t __eh;
-    size_t i=start, ns = jl_array_len(stmts);
+    size_t i = start;
+    size_t ns = jl_array_len(stmts);
 
     while (1) {
         if (i >= ns)
@@ -525,7 +554,7 @@ static jl_value_t *eval_body(jl_array_t *stmts, interpreter_state *s, int start,
             if (head == return_sym) {
                 jl_value_t *ex = jl_exprarg(stmt, 0);
                 if (toplevel && jl_is_toplevel_only_expr(ex))
-                    return jl_toplevel_eval(ex);
+                    return jl_toplevel_eval(s->module, ex);
                 else
                     return eval(ex, s);
             }
@@ -550,7 +579,7 @@ static jl_value_t *eval_body(jl_array_t *stmts, interpreter_state *s, int start,
                         sym = (jl_value_t*)jl_globalref_name(sym);
                     }
                     else {
-                        m = (s == NULL ? ptls->current_module : s->module);
+                        m = s->module;
                     }
                     assert(jl_is_symbol(sym));
                     JL_GC_PUSH1(&rhs);
@@ -581,7 +610,7 @@ static jl_value_t *eval_body(jl_array_t *stmts, interpreter_state *s, int start,
                 }
                 else {
 #ifdef _OS_WINDOWS_
-                    if (ptls->exception_in_transit == jl_stackovf_exception)
+                    if (jl_get_ptls_states()->exception_in_transit == jl_stackovf_exception)
                         _resetstkoflw();
 #endif
                     i = jl_unbox_long(jl_exprarg(stmt, 0)) - 1;
@@ -593,7 +622,7 @@ static jl_value_t *eval_body(jl_array_t *stmts, interpreter_state *s, int start,
                 jl_pop_handler(hand_n_leave);
             }
             else if (toplevel && jl_is_toplevel_only_expr(stmt)) {
-                jl_toplevel_eval(stmt);
+                jl_toplevel_eval(s->module, stmt);
             }
             else {
                 eval(stmt, s);
@@ -623,24 +652,29 @@ static jl_value_t *eval_body(jl_array_t *stmts, interpreter_state *s, int start,
 jl_value_t *jl_interpret_call(jl_method_instance_t *lam, jl_value_t **args, uint32_t nargs)
 {
     if (lam->jlcall_api == 2)
-        return lam->inferred;
+        return lam->inferred_const;
     jl_code_info_t *src = (jl_code_info_t*)lam->inferred;
-    if (src == NULL || !jl_is_code_info(src)) {
-        if (lam->def->isstaged) {
+    if (!src || (jl_value_t*)src == jl_nothing) {
+        if (lam->def.method->source) {
+            src = (jl_code_info_t*)lam->def.method->source;
+        }
+        else {
+            assert(lam->def.method->generator);
             src = jl_code_for_staged(lam);
             lam->inferred = (jl_value_t*)src;
             jl_gc_wb(lam, src);
         }
-        else {
-            src = lam->def->source;
-        }
     }
-    jl_array_t *stmts = src->code;
-    if (!jl_typeis(stmts, jl_array_any_type)) {
-        stmts = jl_uncompress_ast(lam->def, stmts);
-        src->code = stmts;
-        jl_gc_wb(src, stmts);
+    if (src && (jl_value_t*)src != jl_nothing) {
+        src = jl_uncompress_ast(lam->def.method, (jl_array_t*)src);
+        lam->inferred = (jl_value_t*)src;
+        jl_gc_wb(lam, src);
     }
+    if (!src || !jl_is_code_info(src)) {
+        jl_error("source missing for method called in interpreter");
+    }
+
+    jl_array_t *stmts = src->code;
     assert(jl_typeis(stmts, jl_array_any_type));
     jl_value_t **locals;
     JL_GC_PUSHARGS(locals, jl_source_nslots(src) + jl_source_nssavalues(src) + 2);
@@ -648,12 +682,12 @@ jl_value_t *jl_interpret_call(jl_method_instance_t *lam, jl_value_t **args, uint
     locals[1] = (jl_value_t*)stmts;
     interpreter_state s;
     s.src = src;
-    s.module = lam->def->module;
+    s.module = lam->def.method->module;
     s.locals = locals + 2;
     s.sparam_vals = lam->sparam_vals;
     size_t i;
-    for (i = 0; i < lam->def->nargs; i++) {
-        if (lam->def->isva && i == lam->def->nargs - 1)
+    for (i = 0; i < lam->def.method->nargs; i++) {
+        if (lam->def.method->isva && i == lam->def.method->nargs - 1)
             s.locals[i] = jl_f_tuple(NULL, &args[i], nargs - i);
         else
             s.locals[i] = args[i];
@@ -663,9 +697,8 @@ jl_value_t *jl_interpret_call(jl_method_instance_t *lam, jl_value_t **args, uint
     return r;
 }
 
-jl_value_t *jl_interpret_toplevel_thunk(jl_code_info_t *src)
+jl_value_t *jl_interpret_toplevel_thunk(jl_module_t *m, jl_code_info_t *src)
 {
-    jl_ptls_t ptls = jl_get_ptls_states();
     jl_array_t *stmts = src->code;
     assert(jl_typeis(stmts, jl_array_any_type));
     jl_value_t **locals;
@@ -673,7 +706,7 @@ jl_value_t *jl_interpret_toplevel_thunk(jl_code_info_t *src)
     interpreter_state s;
     s.src = src;
     s.locals = locals;
-    s.module = ptls->current_module;
+    s.module = m;
     s.sparam_vals = jl_emptysvec;
     size_t last_age = jl_get_ptls_states()->world_age;
     jl_value_t *r = eval_body(stmts, &s, 0, 1);
diff --git a/src/intrinsics.cpp b/src/intrinsics.cpp
index 12d74f05367fb0..b35186138eac4d 100644
--- a/src/intrinsics.cpp
+++ b/src/intrinsics.cpp
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 namespace JL_I {
 #include "intrinsics.h"
@@ -12,22 +12,22 @@ static bool float_func[num_intrinsics];
 static void jl_init_intrinsic_functions_codegen(Module *m)
 {
     std::vector<Type *> args1(0); \
-    args1.push_back(T_pjlvalue); \
+    args1.push_back(T_prjlvalue); \
     std::vector<Type *> args2(0); \
-    args2.push_back(T_pjlvalue); \
-    args2.push_back(T_pjlvalue); \
+    args2.push_back(T_prjlvalue); \
+    args2.push_back(T_prjlvalue); \
     std::vector<Type *> args3(0); \
-    args3.push_back(T_pjlvalue); \
-    args3.push_back(T_pjlvalue); \
-    args3.push_back(T_pjlvalue); \
+    args3.push_back(T_prjlvalue); \
+    args3.push_back(T_prjlvalue); \
+    args3.push_back(T_prjlvalue); \
     std::vector<Type *> args4(0); \
-    args4.push_back(T_pjlvalue); \
-    args4.push_back(T_pjlvalue); \
-    args4.push_back(T_pjlvalue); \
-    args4.push_back(T_pjlvalue);
+    args4.push_back(T_prjlvalue); \
+    args4.push_back(T_prjlvalue); \
+    args4.push_back(T_prjlvalue); \
+    args4.push_back(T_prjlvalue);
 
 #define ADD_I(name, nargs) do { \
-        Function *func = Function::Create(FunctionType::get(T_pjlvalue, args##nargs, false), \
+        Function *func = Function::Create(FunctionType::get(T_prjlvalue, args##nargs, false), \
                                           Function::ExternalLinkage, "jl_"#name, m); \
         runtime_func[name] = func; \
         add_named_global(func, &jl_##name); \
@@ -70,8 +70,6 @@ static void jl_init_intrinsic_functions_codegen(Module *m)
     float_func[trunc_llvm] = true;
     float_func[rint_llvm] = true;
     float_func[sqrt_llvm] = true;
-    float_func[sqrt_llvm_fast] = true;
-    float_func[powi_llvm] = true;
 }
 
 extern "C"
@@ -138,14 +136,14 @@ static Type *INTT(Type *t)
     return IntegerType::get(jl_LLVMContext, nb);
 }
 
-static Value *uint_cnvt(Type *to, Value *x)
+static Value *uint_cnvt(jl_codectx_t &ctx, Type *to, Value *x)
 {
     Type *t = x->getType();
     if (t == to)
         return x;
     if (to->getPrimitiveSizeInBits() < x->getType()->getPrimitiveSizeInBits())
-        return builder.CreateTrunc(x, to);
-    return builder.CreateZExt(x, to);
+        return ctx.builder.CreateTrunc(x, to);
+    return ctx.builder.CreateZExt(x, to);
 }
 
 #if JL_LLVM_VERSION >= 40000
@@ -155,8 +153,10 @@ static Value *uint_cnvt(Type *to, Value *x)
 #endif
 static Constant *julia_const_to_llvm(void *ptr, jl_value_t *bt)
 {
-    // assume `jl_isbits(bt)`.
+    // assumes `jl_isbits(bt)`.
     // `ptr` can point to a inline field, do not read the tag from it.
+    // make sure to return exactly the type specified by
+    // julia_type_to_llvm as this will be assumed by the callee.
     if (bt == (jl_value_t*)jl_bool_type)
         return ConstantInt::get(T_int8, (*(uint8_t*)ptr) ? 1 : 0);
 
@@ -178,22 +178,22 @@ static Constant *julia_const_to_llvm(void *ptr, jl_value_t *bt)
         }
         case 2: {
             uint16_t data16 = *(uint16_t*)ptr;
-#ifndef DISABLE_FLOAT16
-            if (jl_is_floattype(bt))
-                return ConstantFP::get(jl_LLVMContext, LLVM_FP(APFloat::IEEEhalf,APInt(16,data16)));
-#endif
             return ConstantInt::get(T_int16, data16);
         }
         case 4: {
             uint32_t data32 = *(uint32_t*)ptr;
-            if (jl_is_floattype(bt))
-                return ConstantFP::get(jl_LLVMContext, LLVM_FP(APFloat::IEEEsingle,APInt(32,data32)));
+            if (bt == (jl_value_t*)jl_float32_type)
+                return ConstantFP::get(jl_LLVMContext,
+                        LLVM_FP(APFloat::IEEEsingle,
+                            APInt(32, data32)));
             return ConstantInt::get(T_int32, data32);
         }
         case 8: {
             uint64_t data64 = *(uint64_t*)ptr;
-            if (jl_is_floattype(bt))
-                return ConstantFP::get(jl_LLVMContext, LLVM_FP(APFloat::IEEEdouble,APInt(64,data64)));
+            if (bt == (jl_value_t*)jl_float64_type)
+                return ConstantFP::get(jl_LLVMContext,
+                        LLVM_FP(APFloat::IEEEdouble,
+                            APInt(64, data64)));
             return ConstantInt::get(T_int64, data64);
         }
         default:
@@ -213,10 +213,6 @@ static Constant *julia_const_to_llvm(void *ptr, jl_value_t *bt)
             else
 #endif
             val = APInt(8*nb, ArrayRef<uint64_t>(data, nw));
-            if (nb == 16 && jl_is_floattype(bt)) {
-                return ConstantFP::get(jl_LLVMContext,LLVM_FP(APFloat::IEEEquad,val));
-                // If we have a floating point type that's not hardware supported, just treat it like an integer for LLVM purposes
-            }
             return ConstantInt::get(IntegerType::get(jl_LLVMContext,8*nb),val);
         }
     }
@@ -260,7 +256,7 @@ static Constant *julia_const_to_llvm(jl_value_t *e)
 static jl_cgval_t ghostValue(jl_value_t *ty);
 
 // emit code to unpack a raw value from a box into registers or a stack slot
-static Value *emit_unbox(Type *to, const jl_cgval_t &x, jl_value_t *jt, Value *dest, bool volatile_store)
+static Value *emit_unbox(jl_codectx_t &ctx, Type *to, const jl_cgval_t &x, jl_value_t *jt, Value *dest, bool volatile_store)
 {
     assert(to != T_void);
     // TODO: fully validate that x.typ == jt?
@@ -271,7 +267,7 @@ static Value *emit_unbox(Type *to, const jl_cgval_t &x, jl_value_t *jt, Value *d
         if (type_is_ghost(to)) {
             return NULL;
         }
-        //emit_error("emit_unbox: a type mismatch error in occurred during codegen", ctx);
+        //emit_error(ctx, "emit_unbox: a type mismatch error in occurred during codegen");
         return UndefValue::get(to); // type mismatch error
     }
 
@@ -283,57 +279,53 @@ static Value *emit_unbox(Type *to, const jl_cgval_t &x, jl_value_t *jt, Value *d
         bool frompointer = ty->isPointerTy();
         bool topointer = to->isPointerTy();
         if (frompointer && topointer) {
-            unboxed = emit_bitcast(unboxed, to);
+            unboxed = emit_bitcast(ctx, unboxed, to);
         }
         else if (frompointer) {
             Type *INTT_to = INTT(to);
-            unboxed = builder.CreatePtrToInt(unboxed, INTT_to);
+            unboxed = ctx.builder.CreatePtrToInt(unboxed, INTT_to);
             if (INTT_to != to)
-                unboxed = builder.CreateBitCast(unboxed, to);
+                unboxed = ctx.builder.CreateBitCast(unboxed, to);
         }
         else if (topointer) {
             Type *INTT_to = INTT(to);
             if (to != INTT_to)
-                unboxed = builder.CreateBitCast(unboxed, INTT_to);
-            unboxed = builder.CreateIntToPtr(unboxed, to);
+                unboxed = ctx.builder.CreateBitCast(unboxed, INTT_to);
+            unboxed = ctx.builder.CreateIntToPtr(unboxed, to);
         }
         else if (ty == T_int1 && to == T_int8) {
             // bools may be stored internally as int8
-            unboxed = builder.CreateZExt(unboxed, T_int8);
+            unboxed = ctx.builder.CreateZExt(unboxed, T_int8);
         }
-        else {
-            unboxed = builder.CreateBitCast(unboxed, to);
+        else if (ty != to) {
+            unboxed = ctx.builder.CreateBitCast(unboxed, to);
         }
         if (!dest)
             return unboxed;
-        builder.CreateStore(unboxed, dest, volatile_store);
+        ctx.builder.CreateStore(unboxed, dest, volatile_store);
         return NULL;
     }
 
     // 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;
+    Value *p = x.constant ? literal_pointer_val(ctx, x.constant) : x.V;
     Type *ptype = (to == T_int1 ? T_pint8 : to->getPointerTo());
     if (p->getType() != ptype)
-        p = emit_bitcast(p, ptype);
+        p = emit_bitcast(ctx, p, ptype);
 
     Value *unboxed = NULL;
     if (to == T_int1)
-        unboxed = builder.CreateTrunc(tbaa_decorate(x.tbaa, builder.CreateLoad(p)), T_int1);
+        unboxed = ctx.builder.CreateTrunc(tbaa_decorate(x.tbaa, ctx.builder.CreateLoad(p)), T_int1);
     else if (jt == (jl_value_t*)jl_bool_type)
-        unboxed = builder.CreateZExt(builder.CreateTrunc(tbaa_decorate(x.tbaa, builder.CreateLoad(p)), T_int1), to);
+        unboxed = ctx.builder.CreateZExt(ctx.builder.CreateTrunc(tbaa_decorate(x.tbaa, ctx.builder.CreateLoad(p)), T_int1), to);
     if (unboxed) {
         if (!dest)
             return unboxed;
-        builder.CreateStore(unboxed, dest);
+        ctx.builder.CreateStore(unboxed, dest);
         return NULL;
     }
 
     int alignment;
-    if (x.isboxed) {
-         // julia's gc gives 16-byte aligned addresses
-        alignment = 16;
-    }
-    else if (jt) {
+    if (jt) {
         alignment = julia_alignment(p, jt, 0);
     }
     else {
@@ -350,15 +342,15 @@ static Value *emit_unbox(Type *to, const jl_cgval_t &x, jl_value_t *jt, Value *d
         // x.tbaa ∪ tbaa_stack = tbaa_root if x.tbaa != tbaa_stack
         if (tbaa != tbaa_stack)
             tbaa = NULL;
-        builder.CreateMemCpy(dest, p, jl_datatype_size(jt), alignment, volatile_store, tbaa);
+        ctx.builder.CreateMemCpy(dest, p, jl_datatype_size(jt), alignment, volatile_store, tbaa);
         return NULL;
     }
     else {
         Instruction *load;
         if (alignment)
-            load = builder.CreateAlignedLoad(p, alignment);
+            load = ctx.builder.CreateAlignedLoad(p, alignment);
         else
-            load = builder.CreateLoad(p);
+            load = ctx.builder.CreateLoad(p);
         return tbaa_decorate(x.tbaa, load);
     }
 }
@@ -374,19 +366,19 @@ static jl_value_t *staticeval_bitstype(const jl_cgval_t &targ)
     return NULL;
 }
 
-static jl_cgval_t emit_runtime_call(JL_I::intrinsic f, const jl_cgval_t *argv, size_t nargs, jl_codectx_t *ctx)
+static jl_cgval_t emit_runtime_call(jl_codectx_t &ctx, JL_I::intrinsic f, const jl_cgval_t *argv, size_t nargs)
 {
     Value *func = prepare_call(runtime_func[f]);
     Value **argvalues = (Value**)alloca(sizeof(Value*) * nargs);
     for (size_t i = 0; i < nargs; ++i) {
-        argvalues[i] = boxed(argv[i], ctx);
+        argvalues[i] = boxed(ctx, argv[i]);
     }
-    Value *r = builder.CreateCall(func, makeArrayRef(argvalues, nargs));
-    return mark_julia_type(r, true, (jl_value_t*)jl_any_type, ctx);
+    Value *r = ctx.builder.CreateCall(func, makeArrayRef(argvalues, nargs));
+    return mark_julia_type(ctx, r, true, (jl_value_t*)jl_any_type);
 }
 
 // put a bits type tag on some value (despite the name, this doesn't necessarily actually change anything about the value however)
-static jl_cgval_t generic_bitcast(const jl_cgval_t *argv, jl_codectx_t *ctx)
+static jl_cgval_t generic_bitcast(jl_codectx_t &ctx, const jl_cgval_t *argv)
 {
     // Give the arguments names //
     const jl_cgval_t &bt_value = argv[0];
@@ -395,7 +387,7 @@ static jl_cgval_t generic_bitcast(const jl_cgval_t *argv, jl_codectx_t *ctx)
 
     // it's easier to throw a good error from C than llvm
     if (!bt)
-        return emit_runtime_call(bitcast, argv, 2, ctx);
+        return emit_runtime_call(ctx, bitcast, argv, 2);
 
     Type *llvmt = bitstype_to_llvm(bt);
     int nb = jl_datatype_size(bt);
@@ -405,25 +397,26 @@ static jl_cgval_t generic_bitcast(const jl_cgval_t *argv, jl_codectx_t *ctx)
     Type *vxt = julia_type_to_llvm(v.typ, &isboxed);
 
     if (!jl_is_primitivetype(v.typ) || jl_datatype_size(v.typ) != nb) {
-        Value *typ = emit_typeof_boxed(v, ctx);
+        Value *typ = emit_typeof_boxed(ctx, v);
         if (!jl_is_primitivetype(v.typ)) {
             if (isboxed) {
-                Value *isbits = emit_datatype_isbitstype(typ);
-                error_unless(isbits, "bitcast: expected primitive type value for second argument", ctx);
+                Value *isbits = emit_datatype_isbitstype(ctx, typ);
+                error_unless(ctx, isbits, "bitcast: expected primitive type value for second argument");
             }
             else {
-                emit_error("bitcast: expected primitive type value for second argument", ctx);
+                emit_error(ctx, "bitcast: expected primitive type value for second argument");
                 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)),
-                            "bitcast: argument size does not match size of target type", ctx);
+                Value *size = emit_datatype_size(ctx, typ);
+                error_unless(ctx,
+                        ctx.builder.CreateICmpEQ(size, ConstantInt::get(T_int32, nb)),
+                        "bitcast: argument size does not match size of target type");
             }
             else {
-                emit_error("bitcast: argument size does not match size of target type", ctx);
+                emit_error(ctx, "bitcast: argument size does not match size of target type");
                 return jl_cgval_t();
             }
         }
@@ -441,42 +434,44 @@ static jl_cgval_t generic_bitcast(const jl_cgval_t *argv, jl_codectx_t *ctx)
         // but if the v.typ is not well known, use llvmt
         if (isboxed)
             vxt = llvmt;
-        vx = tbaa_decorate(v.tbaa, builder.CreateLoad(data_pointer(v, ctx,
-                                                                   vxt == T_int1 ? T_pint8 : vxt->getPointerTo())));
+        vx = tbaa_decorate(v.tbaa, ctx.builder.CreateLoad(
+                    data_pointer(ctx, v, vxt == T_int1 ? T_pint8 : vxt->getPointerTo())));
     }
 
     vxt = vx->getType();
     if (vxt != llvmt) {
         if (llvmt == T_int1)
-            vx = builder.CreateTrunc(vx, llvmt);
+            vx = ctx.builder.CreateTrunc(vx, llvmt);
         else if (vxt == T_int1 && llvmt == T_int8)
-            vx = builder.CreateZExt(vx, llvmt);
+            vx = ctx.builder.CreateZExt(vx, llvmt);
         else if (vxt->isPointerTy() && !llvmt->isPointerTy())
-            vx = builder.CreatePtrToInt(vx, llvmt);
+            vx = ctx.builder.CreatePtrToInt(vx, llvmt);
         else if (!vxt->isPointerTy() && llvmt->isPointerTy())
-            vx = builder.CreateIntToPtr(vx, llvmt);
+            vx = ctx.builder.CreateIntToPtr(vx, llvmt);
         else
-            vx = emit_bitcast(vx, llvmt);
+            vx = emit_bitcast(ctx, vx, llvmt);
     }
 
-    if (jl_is_concrete_type(bt))
-        return mark_julia_type(vx, false, bt, ctx);
-    else
-        return mark_julia_type(
-            init_bits_value(emit_allocobj(ctx, nb, boxed(bt_value, ctx)),
-                            vx, tbaa_immut),
-            true, bt, ctx);
+    if (jl_is_concrete_type(bt)) {
+        return mark_julia_type(ctx, vx, false, bt);
+    }
+    else {
+        Value *box = emit_allocobj(ctx, nb, boxed(ctx, bt_value));
+        init_bits_value(ctx, box, vx, tbaa_immut);
+        return mark_julia_type(ctx, box, true, bt);
+    }
 }
 
 static jl_cgval_t generic_cast(
-        intrinsic f, Value *(*generic)(Type*, Value*, jl_codectx_t*),
-        const jl_cgval_t *argv, jl_codectx_t *ctx, bool toint, bool fromint)
+        jl_codectx_t &ctx,
+        intrinsic f, Value *(*generic)(jl_codectx_t&, Type*, Value*),
+        const jl_cgval_t *argv, bool toint, bool fromint)
 {
     const jl_cgval_t &targ = argv[0];
     const jl_cgval_t &v = argv[1];
     jl_value_t *jlto = staticeval_bitstype(targ);
     if (!jlto || !jl_is_primitivetype(v.typ))
-        return emit_runtime_call(f, argv, 2, ctx);
+        return emit_runtime_call(ctx, f, argv, 2);
     Type *to = bitstype_to_llvm(jlto);
     Type *vt = bitstype_to_llvm(v.typ);
     if (toint)
@@ -488,71 +483,53 @@ static jl_cgval_t generic_cast(
     else
         vt = FLOATT(vt);
     if (!to || !vt)
-        return emit_runtime_call(f, argv, 2, ctx);
-    Value *from = emit_unbox(vt, v, v.typ);
-    Value *ans = generic(to, from, ctx);
-    return mark_julia_type(ans, false, jlto, ctx);
-}
-
-static Value *generic_trunc(Type *to, Value *x, jl_codectx_t *ctx)
-{
-    return builder.CreateTrunc(x, to);
+        return emit_runtime_call(ctx, f, argv, 2);
+    Value *from = emit_unbox(ctx, vt, v, v.typ);
+    Value *ans = generic(ctx, to, from);
+    return mark_julia_type(ctx, ans, false, jlto);
 }
 
-static Value *generic_trunc_uchecked(Type *to, Value *x, jl_codectx_t *ctx)
+static Value *generic_trunc(jl_codectx_t &ctx, Type *to, Value *x)
 {
-    Value *ans = builder.CreateTrunc(x, to);
-    Value *back = builder.CreateZExt(ans, x->getType());
-    raise_exception_unless(builder.CreateICmpEQ(back, x),
-                           literal_pointer_val(jl_inexact_exception), ctx);
-    return ans;
+    return ctx.builder.CreateTrunc(x, to);
 }
 
-static Value *generic_trunc_schecked(Type *to, Value *x, jl_codectx_t *ctx)
+static Value *generic_sext(jl_codectx_t &ctx, Type *to, Value *x)
 {
-    Value *ans = builder.CreateTrunc(x, to);
-    Value *back = builder.CreateSExt(ans, x->getType());
-    raise_exception_unless(builder.CreateICmpEQ(back, x),
-                           literal_pointer_val(jl_inexact_exception), ctx);
-    return ans;
+    return ctx.builder.CreateSExt(x, to);
 }
 
-static Value *generic_sext(Type *to, Value *x, jl_codectx_t *ctx)
+static Value *generic_zext(jl_codectx_t &ctx, Type *to, Value *x)
 {
-    return builder.CreateSExt(x, to);
+    return ctx.builder.CreateZExt(x, to);
 }
 
-static Value *generic_zext(Type *to, Value *x, jl_codectx_t *ctx)
+static Value *generic_uitofp(jl_codectx_t &ctx, Type *to, Value *x)
 {
-    return builder.CreateZExt(x, to);
+    return ctx.builder.CreateUIToFP(x, to);
 }
 
-static Value *generic_uitofp(Type *to, Value *x, jl_codectx_t *ctx)
+static Value *generic_sitofp(jl_codectx_t &ctx, Type *to, Value *x)
 {
-    return builder.CreateUIToFP(x, to);
+    return ctx.builder.CreateSIToFP(x, to);
 }
 
-static Value *generic_sitofp(Type *to, Value *x, jl_codectx_t *ctx)
+static Value *generic_fptoui(jl_codectx_t &ctx, Type *to, Value *x)
 {
-    return builder.CreateSIToFP(x, to);
+    return ctx.builder.CreateFPToUI(x, to);
 }
 
-static Value *generic_fptoui(Type *to, Value *x, jl_codectx_t *ctx)
+static Value *generic_fptosi(jl_codectx_t &ctx, Type *to, Value *x)
 {
-    return builder.CreateFPToUI(x, to);
+    return ctx.builder.CreateFPToSI(x, to);
 }
 
-static Value *generic_fptosi(Type *to, Value *x, jl_codectx_t *ctx)
+static Value *generic_fptrunc(jl_codectx_t &ctx, Type *to, Value *x)
 {
-    return builder.CreateFPToSI(x, to);
+    return ctx.builder.CreateFPTrunc(x, to);
 }
 
-static Value *generic_fptrunc(Type *to, Value *x, jl_codectx_t *ctx)
-{
-    return builder.CreateFPTrunc(x, to);
-}
-
-static Value *generic_fpext(Type *to, Value *x, jl_codectx_t *ctx)
+static Value *generic_fpext(jl_codectx_t &ctx, Type *to, Value *x)
 {
 #ifdef JL_NEED_FLOATTEMP_VAR
     // Target platform might carry extra precision.
@@ -561,80 +538,81 @@ static Value *generic_fpext(Type *to, Value *x, jl_codectx_t *ctx)
     // understood that everything is implicitly rounded to 23 bits,
     // but if we start looking at more bits we need to actually do the
     // rounding first instead of carrying around incorrect low bits.
-    Value *jlfloattemp_var = emit_static_alloca(x->getType());
-    builder.CreateStore(x, jlfloattemp_var);
-    x  = builder.CreateLoad(jlfloattemp_var, true);
+    Value *jlfloattemp_var = emit_static_alloca(ctx, x->getType());
+    ctx.builder.CreateStore(x, jlfloattemp_var);
+    x  = ctx.builder.CreateLoad(jlfloattemp_var, true);
 #endif
-    return builder.CreateFPExt(x, to);
+    return ctx.builder.CreateFPExt(x, to);
 }
 
-static jl_cgval_t emit_runtime_pointerref(jl_cgval_t *argv, jl_codectx_t *ctx)
+static jl_cgval_t emit_runtime_pointerref(jl_codectx_t &ctx, jl_cgval_t *argv)
 {
-    return emit_runtime_call(pointerref, argv, 3, ctx);
+    return emit_runtime_call(ctx, pointerref, argv, 3);
 }
 
-static jl_cgval_t emit_pointerref(jl_cgval_t *argv, jl_codectx_t *ctx)
+static jl_cgval_t emit_pointerref(jl_codectx_t &ctx, jl_cgval_t *argv)
 {
     const jl_cgval_t &e = argv[0];
     const jl_cgval_t &i = argv[1];
     const jl_cgval_t &align = argv[2];
 
     if (align.constant == NULL || !jl_is_long(align.constant))
-        return emit_runtime_pointerref(argv, ctx);
+        return emit_runtime_pointerref(ctx, argv);
     unsigned align_nb = jl_unbox_long(align.constant);
 
     if (i.typ != (jl_value_t*)jl_long_type)
-        return emit_runtime_pointerref(argv, ctx);
+        return emit_runtime_pointerref(ctx, argv);
     jl_value_t *aty = e.typ;
     if (!jl_is_cpointer_type(aty))
-        return emit_runtime_pointerref(argv, ctx);
+        return emit_runtime_pointerref(ctx, argv);
     jl_value_t *ety = jl_tparam0(aty);
     if (jl_is_typevar(ety))
-        return emit_runtime_pointerref(argv, ctx);
+        return emit_runtime_pointerref(ctx, argv);
     if (!jl_is_datatype(ety))
         ety = (jl_value_t*)jl_any_type;
 
-    Value *idx = emit_unbox(T_size, i, (jl_value_t*)jl_long_type);
-    Value *im1 = builder.CreateSub(idx, ConstantInt::get(T_size, 1));
+    Value *idx = emit_unbox(ctx, T_size, i, (jl_value_t*)jl_long_type);
+    Value *im1 = ctx.builder.CreateSub(idx, ConstantInt::get(T_size, 1));
 
     if (!jl_isbits(ety)) {
         if (ety == (jl_value_t*)jl_any_type) {
-            Value *thePtr = emit_unbox(T_ppjlvalue, e, e.typ);
+            Value *thePtr = emit_unbox(ctx, T_pprjlvalue, e, e.typ);
             return mark_julia_type(
-                    builder.CreateAlignedLoad(builder.CreateGEP(thePtr, im1), align_nb),
+                    ctx,
+                    ctx.builder.CreateAlignedLoad(ctx.builder.CreateGEP(thePtr, im1), align_nb),
                     true,
-                    ety, ctx);
+                    ety);
         }
         if (!jl_is_structtype(ety) || jl_is_array_type(ety) || !jl_is_concrete_type(ety)) {
-            emit_error("pointerref: invalid pointer type", ctx);
+            emit_error(ctx, "pointerref: invalid pointer type");
             return jl_cgval_t();
         }
         assert(jl_is_datatype(ety));
         uint64_t size = jl_datatype_size(ety);
         Value *strct = emit_allocobj(ctx, size,
-                                     literal_pointer_val((jl_value_t*)ety));
-        im1 = builder.CreateMul(im1, ConstantInt::get(T_size,
-                    LLT_ALIGN(size, ((jl_datatype_t*)ety)->layout->alignment)));
-        Value *thePtr = emit_unbox(T_pint8, e, e.typ);
-        thePtr = builder.CreateGEP(emit_bitcast(thePtr, T_pint8), im1);
-        builder.CreateMemCpy(emit_bitcast(strct, T_pint8), thePtr, size, 1);
-        return mark_julia_type(strct, true, ety, ctx);
+                                     literal_pointer_val(ctx, (jl_value_t*)ety));
+        im1 = ctx.builder.CreateMul(im1, ConstantInt::get(T_size,
+                    LLT_ALIGN(size, jl_datatype_align(ety))));
+        Value *thePtr = emit_unbox(ctx, T_pint8, e, e.typ);
+        thePtr = ctx.builder.CreateGEP(emit_bitcast(ctx, thePtr, T_pint8), im1);
+        ctx.builder.CreateMemCpy(emit_bitcast(ctx, strct, T_pint8), thePtr, size, 1);
+        return mark_julia_type(ctx, strct, true, ety);
     }
 
     bool isboxed;
     Type *ptrty = julia_type_to_llvm(e.typ, &isboxed);
     assert(!isboxed);
-    Value *thePtr = emit_unbox(ptrty, e, e.typ);
-    return typed_load(thePtr, im1, ety, ctx, tbaa_data, align_nb);
+    Value *thePtr = emit_unbox(ctx, ptrty, e, e.typ);
+    return typed_load(ctx, thePtr, im1, ety, tbaa_data, true, align_nb);
 }
 
-static jl_cgval_t emit_runtime_pointerset(jl_cgval_t *argv, jl_codectx_t *ctx)
+static jl_cgval_t emit_runtime_pointerset(jl_codectx_t &ctx, jl_cgval_t *argv)
 {
-    return emit_runtime_call(pointerset, argv, 4, ctx);
+    return emit_runtime_call(ctx, pointerset, argv, 4);
 }
 
 // e[i] = x
-static jl_cgval_t emit_pointerset(jl_cgval_t *argv, jl_codectx_t *ctx)
+static jl_cgval_t emit_pointerset(jl_codectx_t &ctx, jl_cgval_t *argv)
 {
     const jl_cgval_t &e = argv[0];
     const jl_cgval_t &x = argv[1];
@@ -642,108 +620,114 @@ static jl_cgval_t emit_pointerset(jl_cgval_t *argv, jl_codectx_t *ctx)
     const jl_cgval_t &align = argv[3];
 
     if (align.constant == NULL || !jl_is_long(align.constant))
-        return emit_runtime_pointerset(argv, ctx);
+        return emit_runtime_pointerset(ctx, argv);
     unsigned align_nb = jl_unbox_long(align.constant);
 
     if (i.typ != (jl_value_t*)jl_long_type)
-        return emit_runtime_pointerset(argv, ctx);
+        return emit_runtime_pointerset(ctx, argv);
     jl_value_t *aty = e.typ;
     if (!jl_is_cpointer_type(aty))
-        return emit_runtime_pointerset(argv, ctx);
+        return emit_runtime_pointerset(ctx, argv);
     jl_value_t *ety = jl_tparam0(aty);
     if (jl_is_typevar(ety))
-        return emit_runtime_pointerset(argv, ctx);
+        return emit_runtime_pointerset(ctx, argv);
     if (align.constant == NULL || !jl_is_long(align.constant))
-        return emit_runtime_pointerset(argv, ctx);
+        return emit_runtime_pointerset(ctx, argv);
     if (!jl_is_datatype(ety))
         ety = (jl_value_t*)jl_any_type;
-    jl_value_t *xty = x.typ;
-    if (!jl_subtype(xty, ety))
-        emit_typecheck(x, ety, "pointerset: type mismatch in assign", ctx);
+    emit_typecheck(ctx, x, ety, "pointerset: type mismatch in assign");
 
-    Value *idx = emit_unbox(T_size, i, (jl_value_t*)jl_long_type);
-    Value *im1 = builder.CreateSub(idx, ConstantInt::get(T_size, 1));
+    Value *idx = emit_unbox(ctx, T_size, i, (jl_value_t*)jl_long_type);
+    Value *im1 = ctx.builder.CreateSub(idx, ConstantInt::get(T_size, 1));
 
     Value *thePtr;
     if (!jl_isbits(ety) && ety != (jl_value_t*)jl_any_type) {
         if (!jl_is_structtype(ety) || jl_is_array_type(ety) || !jl_is_concrete_type(ety)) {
-            emit_error("pointerset: invalid pointer type", ctx);
+            emit_error(ctx, "pointerset: invalid pointer type");
             return jl_cgval_t();
         }
-        thePtr = emit_unbox(T_pint8, e, e.typ);
+        thePtr = emit_unbox(ctx, T_pint8, e, e.typ);
         uint64_t size = jl_datatype_size(ety);
-        im1 = builder.CreateMul(im1, ConstantInt::get(T_size,
-                    LLT_ALIGN(size, ((jl_datatype_t*)ety)->layout->alignment)));
-        builder.CreateMemCpy(builder.CreateGEP(thePtr, im1),
-                             data_pointer(x, ctx, T_pint8), size, align_nb);
+        im1 = ctx.builder.CreateMul(im1, ConstantInt::get(T_size,
+                    LLT_ALIGN(size, jl_datatype_align(ety))));
+        ctx.builder.CreateMemCpy(ctx.builder.CreateGEP(thePtr, im1),
+                             data_pointer(ctx, x, T_pint8), size, align_nb);
     }
     else {
         bool isboxed;
         Type *ptrty = julia_type_to_llvm(e.typ, &isboxed);
         assert(!isboxed);
-        thePtr = emit_unbox(ptrty, e, e.typ);
-        typed_store(thePtr, im1, x, ety, ctx, tbaa_data, NULL, align_nb);
+        thePtr = emit_unbox(ctx, ptrty, e, e.typ);
+        if (ety == (jl_value_t*)jl_any_type) {
+            // unsafe_store to Ptr{Any} is allowed to implicitly drop GC roots.
+            Instruction *store = ctx.builder.CreateAlignedStore(
+              emit_pointer_from_objref(ctx, boxed(ctx, x, false)),
+                ctx.builder.CreateGEP(thePtr, im1), align_nb);
+            tbaa_decorate(tbaa_data, store);
+        } else {
+            typed_store(ctx, thePtr, im1, x, ety, tbaa_data, NULL, align_nb);
+        }
     }
-    return mark_julia_type(thePtr, false, aty, ctx);
+    return mark_julia_type(ctx, thePtr, false, aty);
 }
 
-static Value *emit_checked_srem_int(Value *x, Value *den, jl_codectx_t *ctx)
+static Value *emit_checked_srem_int(jl_codectx_t &ctx, Value *x, Value *den)
 {
     Type *t = den->getType();
-    raise_exception_unless(builder.CreateICmpNE(den, ConstantInt::get(t,0)),
-                           literal_pointer_val(jl_diverror_exception), ctx);
-    BasicBlock *m1BB = BasicBlock::Create(jl_LLVMContext,"minus1",ctx->f);
-    BasicBlock *okBB = BasicBlock::Create(jl_LLVMContext,"oksrem",ctx->f);
-    BasicBlock *cont = BasicBlock::Create(jl_LLVMContext,"after_srem",ctx->f);
+    raise_exception_unless(ctx,
+            ctx.builder.CreateICmpNE(den, ConstantInt::get(t, 0)),
+            literal_pointer_val(ctx, jl_diverror_exception));
+    BasicBlock *m1BB = BasicBlock::Create(jl_LLVMContext, "minus1", ctx.f);
+    BasicBlock *okBB = BasicBlock::Create(jl_LLVMContext, "oksrem", ctx.f);
+    BasicBlock *cont = BasicBlock::Create(jl_LLVMContext, "after_srem", ctx.f);
     PHINode *ret = PHINode::Create(t, 2);
-    builder.CreateCondBr(builder.CreateICmpEQ(den,ConstantInt::get(t,-1,true)),
+    ctx.builder.CreateCondBr(ctx.builder.CreateICmpEQ(den ,ConstantInt::get(t, -1, true)),
                          m1BB, okBB);
-    builder.SetInsertPoint(m1BB);
-    builder.CreateBr(cont);
-    builder.SetInsertPoint(okBB);
-    Value *sremval = builder.CreateSRem(x, den);
-    builder.CreateBr(cont);
-    builder.SetInsertPoint(cont);
+    ctx.builder.SetInsertPoint(m1BB);
+    ctx.builder.CreateBr(cont);
+    ctx.builder.SetInsertPoint(okBB);
+    Value *sremval = ctx.builder.CreateSRem(x, den);
+    ctx.builder.CreateBr(cont);
+    ctx.builder.SetInsertPoint(cont);
     ret->addIncoming(// rem(typemin, -1) is undefined
-                     ConstantInt::get(t,0), m1BB);
+                     ConstantInt::get(t, 0), m1BB);
     ret->addIncoming(sremval, okBB);
-    builder.Insert(ret);
+    ctx.builder.Insert(ret);
     return ret;
 }
 
-// Temporarily switch the builder to fast-math mode if requested
+// Temporarily switch the ctx.builder to fast-math mode if requested
 struct math_builder {
+    IRBuilder<> &ctxbuilder;
     FastMathFlags old_fmf;
-    math_builder(jl_codectx_t *ctx, bool always_fast = false):
-        old_fmf(builder.getFastMathFlags())
+    math_builder(jl_codectx_t &ctx, bool always_fast = false, bool contract = false)
+      : ctxbuilder(ctx.builder),
+        old_fmf(ctxbuilder.getFastMathFlags())
     {
+        FastMathFlags fmf;
         if (jl_options.fast_math != JL_OPTIONS_FAST_MATH_OFF &&
             (always_fast ||
              jl_options.fast_math == JL_OPTIONS_FAST_MATH_ON)) {
-            FastMathFlags fmf;
             fmf.setUnsafeAlgebra();
-#if JL_LLVM_VERSION >= 30800
-            builder.setFastMathFlags(fmf);
+        }
+#if JL_LLVM_VERSION >= 50000
+        if (contract)
+            fmf.setAllowContract(true);
 #else
-            builder.SetFastMathFlags(fmf);
+        assert(!contract);
 #endif
-        }
+        ctxbuilder.setFastMathFlags(fmf);
     }
-    IRBuilder<>& operator()() const { return builder; }
+    IRBuilder<>& operator()() const { return ctxbuilder; }
     ~math_builder() {
-#if JL_LLVM_VERSION >= 30800
-        builder.setFastMathFlags(old_fmf);
-#else
-        builder.SetFastMathFlags(old_fmf);
-#endif
+        ctxbuilder.setFastMathFlags(old_fmf);
     }
 };
 
-static Value *emit_untyped_intrinsic(intrinsic f, Value **argvalues, size_t nargs,
-                                     jl_codectx_t *ctx, jl_datatype_t **newtyp, jl_value_t *xtyp);
+static Value *emit_untyped_intrinsic(jl_codectx_t &ctx, intrinsic f, Value **argvalues, size_t nargs,
+                                     jl_datatype_t **newtyp, jl_value_t *xtyp);
 
-static jl_cgval_t emit_intrinsic(intrinsic f, jl_value_t **args, size_t nargs,
-                                 jl_codectx_t *ctx)
+static jl_cgval_t emit_intrinsic(jl_codectx_t &ctx, intrinsic f, jl_value_t **args, size_t nargs)
 {
     assert(f < num_intrinsics);
     if (f == cglobal && nargs == 1)
@@ -754,52 +738,48 @@ static jl_cgval_t emit_intrinsic(intrinsic f, jl_value_t **args, size_t nargs,
     }
 
     if (f == llvmcall)
-        return emit_llvmcall(args, nargs, ctx);
+        return emit_llvmcall(ctx, args, nargs);
     if (f == cglobal_auto || f == cglobal)
-        return emit_cglobal(args, nargs, ctx);
+        return emit_cglobal(ctx, args, nargs);
 
     jl_cgval_t *argv = (jl_cgval_t*)alloca(sizeof(jl_cgval_t) * nargs);
     for (size_t i = 0; i < nargs; ++i) {
-        argv[i] = emit_expr(args[i + 1], ctx);
+        argv[i] = emit_expr(ctx, args[i + 1]);
     }
 
     // this forces everything to use runtime-intrinsics (e.g. for testing)
-    // return emit_runtime_call(f, argv, nargs, ctx);
+    // return emit_runtime_call(ctx, f, argv, nargs);
 
     switch (f) {
     case arraylen:
-        return mark_julia_type(emit_arraylen(argv[0], args[1], ctx), false, jl_long_type, ctx);
+        return mark_julia_type(ctx, emit_arraylen(ctx, argv[0], args[1]), false, jl_long_type);
     case pointerref:
-        return emit_pointerref(argv, ctx);
+        return emit_pointerref(ctx, argv);
     case pointerset:
-        return emit_pointerset(argv, ctx);
+        return emit_pointerset(ctx, argv);
     case bitcast:
-        return generic_bitcast(argv, ctx);
+        return generic_bitcast(ctx, argv);
     case trunc_int:
-        return generic_cast(f, generic_trunc, argv, ctx, true, true);
-    case checked_trunc_uint:
-        return generic_cast(f, generic_trunc_uchecked, argv, ctx, true, true);
-    case checked_trunc_sint:
-        return generic_cast(f, generic_trunc_schecked, argv, ctx, true, true);
+        return generic_cast(ctx, f, generic_trunc, argv, true, true);
     case sext_int:
-        return generic_cast(f, generic_sext, argv, ctx, true, true);
+        return generic_cast(ctx, f, generic_sext, argv, true, true);
     case zext_int:
-        return generic_cast(f, generic_zext, argv, ctx, true, true);
+        return generic_cast(ctx, f, generic_zext, argv, true, true);
     case uitofp:
-        return generic_cast(f, generic_uitofp, argv, ctx, false, true);
+        return generic_cast(ctx, f, generic_uitofp, argv, false, true);
     case sitofp:
-        return generic_cast(f, generic_sitofp, argv, ctx, false, true);
+        return generic_cast(ctx, f, generic_sitofp, argv, false, true);
     case fptoui:
-        return generic_cast(f, generic_fptoui, argv, ctx, true, false);
+        return generic_cast(ctx, f, generic_fptoui, argv, true, false);
     case fptosi:
-        return generic_cast(f, generic_fptosi, argv, ctx, true, false);
+        return generic_cast(ctx, f, generic_fptosi, argv, true, false);
     case fptrunc:
-        return generic_cast(f, generic_fptrunc, argv, ctx, false, false);
+        return generic_cast(ctx, f, generic_fptrunc, argv, false, false);
     case fpext:
-        return generic_cast(f, generic_fpext, argv, ctx, false, false);
+        return generic_cast(ctx, f, generic_fpext, argv, false, false);
 
     case select_value: {
-        Value *isfalse = emit_condition(argv[0], "select_value", ctx); // emit the first argument
+        Value *isfalse = emit_condition(ctx, argv[0], "select_value"); // emit the first argument
         // emit X and Y arguments
         const jl_cgval_t &x = argv[1];
         const jl_cgval_t &y = argv[2];
@@ -821,60 +801,31 @@ static jl_cgval_t emit_intrinsic(intrinsic f, jl_value_t **args, size_t nargs,
         if (!isboxed) {
             if (type_is_ghost(llt1))
                 return x;
-            ifelse_result = builder.CreateSelect(isfalse,
-                    emit_unbox(llt1, y, t1),
-                    emit_unbox(llt1, x, t1));
+            ifelse_result = ctx.builder.CreateSelect(isfalse,
+                    emit_unbox(ctx, llt1, y, t1),
+                    emit_unbox(ctx, llt1, x, t1));
         }
         else {
-            ifelse_result = builder.CreateSelect(isfalse,
-                    boxed(y, ctx),
-                    boxed(x, ctx));
+            ifelse_result = ctx.builder.CreateSelect(isfalse,
+                    boxed(ctx, y),
+                    boxed(ctx, x));
         }
         jl_value_t *jt = (t1 == t2 ? t1 : (jl_value_t*)jl_any_type);
-        mark_gc_use(x);
-        mark_gc_use(y);
-        return mark_julia_type(ifelse_result, isboxed, jt, ctx);
+        return mark_julia_type(ctx, ifelse_result, isboxed, jt);
     }
 
     case not_int: {
         const jl_cgval_t &x = argv[0];
         if (!jl_is_primitivetype(x.typ))
-            return emit_runtime_call(f, argv, nargs, ctx);
+            return emit_runtime_call(ctx, f, argv, nargs);
         Type *xt = INTT(bitstype_to_llvm(x.typ));
-        Value *from = emit_unbox(xt, x, x.typ);
+        Value *from = emit_unbox(ctx, xt, x, x.typ);
         Value *ans;
         if (x.typ == (jl_value_t*)jl_bool_type)
-            ans = builder.CreateXor(from, ConstantInt::get(T_int8, 1, true));
+            ans = ctx.builder.CreateXor(from, ConstantInt::get(T_int8, 1, true));
         else
-            ans = builder.CreateXor(from, ConstantInt::get(xt, -1, true));
-        return mark_julia_type(ans, false, x.typ, ctx);
-    }
-
-    case powi_llvm: {
-        const jl_cgval_t &x = argv[0];
-        const jl_cgval_t &y = argv[1];
-        if (!jl_is_primitivetype(x.typ) || !jl_is_primitivetype(y.typ) || jl_datatype_size(y.typ) != 4)
-            return emit_runtime_call(f, argv, nargs, ctx);
-        Type *xt = FLOATT(bitstype_to_llvm(x.typ));
-        Type *yt = T_int32;
-        if (!xt)
-            return emit_runtime_call(f, argv, nargs, ctx);
-
-        Value *xv = emit_unbox(xt, x, x.typ);
-        Value *yv = emit_unbox(yt, y, y.typ);
-#if JL_LLVM_VERSION >= 30600
-        Value *powi = Intrinsic::getDeclaration(jl_Module, Intrinsic::powi, makeArrayRef(xt));
-#if JL_LLVM_VERSION >= 30700
-        Value *ans = builder.CreateCall(powi, {xv, yv});
-#else
-        Value *ans = builder.CreateCall2(powi, xv, yv);
-#endif
-#else
-        // issue #6506
-        Value *ans = builder.CreateCall2(prepare_call(xt == T_float64 ? jlpow_func : jlpowf_func),
-                xv, builder.CreateSIToFP(yv, xt));
-#endif
-        return mark_julia_type(ans, false, x.typ, ctx);
+            ans = ctx.builder.CreateXor(from, ConstantInt::get(xt, -1, true));
+        return mark_julia_type(ctx, ans, false, x.typ);
     }
 
     default: {
@@ -883,27 +834,27 @@ static jl_cgval_t emit_intrinsic(intrinsic f, jl_value_t **args, size_t nargs,
 
         // verify argument types
         if (!jl_is_primitivetype(xinfo.typ))
-            return emit_runtime_call(f, argv, nargs, ctx);
+            return emit_runtime_call(ctx, f, argv, nargs);
         Type *xtyp = bitstype_to_llvm(xinfo.typ);
         if (float_func[f])
             xtyp = FLOATT(xtyp);
         else
             xtyp = INTT(xtyp);
         if (!xtyp)
-            return emit_runtime_call(f, argv, nargs, ctx);
+            return emit_runtime_call(ctx, f, argv, nargs);
 
         Type **argt = (Type**)alloca(sizeof(Type*) * nargs);
         argt[0] = xtyp;
 
         if (f == shl_int || f == lshr_int || f == ashr_int) {
             if (!jl_is_primitivetype(argv[1].typ))
-                return emit_runtime_call(f, argv, nargs, ctx);
+                return emit_runtime_call(ctx, f, argv, nargs);
             argt[1] = INTT(bitstype_to_llvm(argv[1].typ));
         }
         else {
             for (size_t i = 1; i < nargs; ++i) {
                 if (xinfo.typ != argv[i].typ)
-                    return emit_runtime_call(f, argv, nargs, ctx);
+                    return emit_runtime_call(ctx, f, argv, nargs);
                 argt[i] = xtyp;
             }
         }
@@ -911,22 +862,22 @@ static jl_cgval_t emit_intrinsic(intrinsic f, jl_value_t **args, size_t nargs,
         // unbox the arguments
         Value **argvalues = (Value**)alloca(sizeof(Value*) * nargs);
         for (size_t i = 0; i < nargs; ++i) {
-            argvalues[i] = emit_unbox(argt[i], argv[i], argv[i].typ);
+            argvalues[i] = emit_unbox(ctx, argt[i], argv[i], argv[i].typ);
         }
 
         // call the intrinsic
         jl_value_t *newtyp = NULL;
-        Value *r = emit_untyped_intrinsic(f, argvalues, nargs, ctx, (jl_datatype_t**)&newtyp, xinfo.typ);
+        Value *r = emit_untyped_intrinsic(ctx, f, argvalues, nargs, (jl_datatype_t**)&newtyp, xinfo.typ);
         if (r->getType() == T_int1)
-            r = builder.CreateZExt(r, T_int8);
-        return mark_julia_type(r, false, newtyp ? newtyp : xinfo.typ, ctx);
+            r = ctx.builder.CreateZExt(r, T_int8);
+        return mark_julia_type(ctx, r, false, newtyp ? newtyp : xinfo.typ);
     }
     }
     assert(0 && "unreachable");
 }
 
-static Value *emit_untyped_intrinsic(intrinsic f, Value **argvalues, size_t nargs,
-                                     jl_codectx_t *ctx, jl_datatype_t **newtyp, jl_value_t *xtyp)
+static Value *emit_untyped_intrinsic(jl_codectx_t &ctx, intrinsic f, Value **argvalues, size_t nargs,
+                                     jl_datatype_t **newtyp, jl_value_t *xtyp)
 {
     Value *x = nargs > 0 ? argvalues[0] : NULL;
     Value *y = nargs > 1 ? argvalues[1] : NULL;
@@ -935,32 +886,18 @@ static Value *emit_untyped_intrinsic(intrinsic f, Value **argvalues, size_t narg
 
     switch (f) {
     case neg_int:
-#if JL_LLVM_VERSION >= 30700
-        return builder.CreateNeg(x);
-#else
-        return builder.CreateSub(ConstantInt::get(t, 0), x);
-#endif
-    case add_int: return builder.CreateAdd(x, y);
-    case sub_int: return builder.CreateSub(x, y);
-    case mul_int: return builder.CreateMul(x, y);
-    case sdiv_int: return builder.CreateSDiv(x, y);
-    case udiv_int: return builder.CreateUDiv(x, y);
-    case srem_int: return builder.CreateSRem(x, y);
-    case urem_int: return builder.CreateURem(x, 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
-#if JL_LLVM_VERSION >= 30500
+        return ctx.builder.CreateNeg(x);
+    case add_int: return ctx.builder.CreateAdd(x, y);
+    case sub_int: return ctx.builder.CreateSub(x, y);
+    case mul_int: return ctx.builder.CreateMul(x, y);
+    case sdiv_int: return ctx.builder.CreateSDiv(x, y);
+    case udiv_int: return ctx.builder.CreateUDiv(x, y);
+    case srem_int: return ctx.builder.CreateSRem(x, y);
+    case urem_int: return ctx.builder.CreateURem(x, y);
+
+// Implements IEEE negate. See issue #7868
     case neg_float: return math_builder(ctx)().CreateFSub(ConstantFP::get(t, -0.0), x);
     case neg_float_fast: return math_builder(ctx, true)().CreateFNeg(x);
-#else
-    case neg_float:
-        return math_builder(ctx)().CreateFMul(ConstantFP::get(t, -1.0), x);
-    case neg_float_fast:
-        return math_builder(ctx, true)().CreateFMul(ConstantFP::get(t, -1.0), x);
-#endif
     case add_float: return math_builder(ctx)().CreateFAdd(x, y);
     case sub_float: return math_builder(ctx)().CreateFSub(x, y);
     case mul_float: return math_builder(ctx)().CreateFMul(x, y);
@@ -975,24 +912,20 @@ static Value *emit_untyped_intrinsic(intrinsic f, Value **argvalues, size_t narg
         assert(y->getType() == x->getType());
         assert(z->getType() == y->getType());
         Value *fmaintr = Intrinsic::getDeclaration(jl_Module, Intrinsic::fma, makeArrayRef(t));
-#if JL_LLVM_VERSION >= 30700
-        return builder.CreateCall(fmaintr, {x, y, z});
-#else
-        return builder.CreateCall3(fmaintr, x, y, z);
-#endif
+        return ctx.builder.CreateCall(fmaintr, {x, y, z});
     }
     case muladd_float: {
-#if JL_LLVM_VERSION >= 30400
+#if JL_LLVM_VERSION >= 50000
+        // LLVM 5.0 can create FMA in the backend for contractable fmul and fadd
+        // Emitting fmul and fadd here since they are easier for other LLVM passes to
+        // optimize.
+        auto mathb = math_builder(ctx, false, true);
+        return mathb().CreateFAdd(mathb().CreateFMul(x, y), z);
+#else
         assert(y->getType() == x->getType());
         assert(z->getType() == y->getType());
         Value *muladdintr = Intrinsic::getDeclaration(jl_Module, Intrinsic::fmuladd, makeArrayRef(t));
-#if JL_LLVM_VERSION >= 30700
-        return builder.CreateCall(muladdintr, {x, y, z});
-#else
-        return builder.CreateCall3(muladdintr, x, y, z);
-#endif
-#else
-        return math_builder(ctx, true)().CreateFAdd(builder.CreateFMul(x, y), z);
+        return ctx.builder.CreateCall(muladdintr, {x, y, z});
 #endif
     }
 
@@ -1016,14 +949,10 @@ static Value *emit_untyped_intrinsic(intrinsic f, Value **argvalues, size_t narg
                  Intrinsic::smul_with_overflow :
                  Intrinsic::umul_with_overflow)))));
         Value *intr = Intrinsic::getDeclaration(jl_Module, intr_id, makeArrayRef(t));
-#if JL_LLVM_VERSION >= 30700
-        Value *res = builder.CreateCall(intr, {x, y});
-#else
-        Value *res = builder.CreateCall2(intr, x, y);
-#endif
-        Value *val = builder.CreateExtractValue(res, ArrayRef<unsigned>(0));
-        Value *obit = builder.CreateExtractValue(res, ArrayRef<unsigned>(1));
-        Value *obyte = builder.CreateZExt(obit, T_int8);
+        Value *res = ctx.builder.CreateCall(intr, {x, y});
+        Value *val = ctx.builder.CreateExtractValue(res, ArrayRef<unsigned>(0));
+        Value *obit = ctx.builder.CreateExtractValue(res, ArrayRef<unsigned>(1));
+        Value *obyte = ctx.builder.CreateZExt(obit, T_int8);
 
         jl_value_t *params[2];
         params[0] = xtyp;
@@ -1033,51 +962,44 @@ static Value *emit_untyped_intrinsic(intrinsic f, Value **argvalues, size_t narg
 
         Value *tupval;
         tupval = UndefValue::get(julia_type_to_llvm((jl_value_t*)tuptyp));
-        tupval = builder.CreateInsertValue(tupval, val, ArrayRef<unsigned>(0));
-        tupval = builder.CreateInsertValue(tupval, obyte, ArrayRef<unsigned>(1));
+        tupval = ctx.builder.CreateInsertValue(tupval, val, ArrayRef<unsigned>(0));
+        tupval = ctx.builder.CreateInsertValue(tupval, obyte, ArrayRef<unsigned>(1));
         return tupval;
     }
 
     case checked_sdiv_int: {
-        Value *typemin = builder.CreateShl(ConstantInt::get(t, 1), t->getPrimitiveSizeInBits() - 1);
-        raise_exception_unless(
-                builder.CreateAnd(
-                    builder.CreateICmpNE(y, ConstantInt::get(t, 0)),
-                    builder.CreateOr(
-                        builder.CreateICmpNE(y, ConstantInt::get(t, -1, true)),
-                        builder.CreateICmpNE(x, typemin))),
-                literal_pointer_val(jl_diverror_exception), ctx);
-
-        return builder.CreateSDiv(x, y);
+        Value *typemin = ctx.builder.CreateShl(ConstantInt::get(t, 1), t->getPrimitiveSizeInBits() - 1);
+        raise_exception_unless(ctx,
+                ctx.builder.CreateAnd(
+                    ctx.builder.CreateICmpNE(y, ConstantInt::get(t, 0)),
+                    ctx.builder.CreateOr(
+                        ctx.builder.CreateICmpNE(y, ConstantInt::get(t, -1, true)),
+                        ctx.builder.CreateICmpNE(x, typemin))),
+                literal_pointer_val(ctx, jl_diverror_exception));
+
+        return ctx.builder.CreateSDiv(x, y);
     }
     case checked_udiv_int:
-        raise_exception_unless(builder.CreateICmpNE(y, ConstantInt::get(t, 0)),
-                               literal_pointer_val(jl_diverror_exception), ctx);
-        return builder.CreateUDiv(x, y);
+        raise_exception_unless(ctx,
+                ctx.builder.CreateICmpNE(y, ConstantInt::get(t, 0)),
+                literal_pointer_val(ctx, jl_diverror_exception));
+        return ctx.builder.CreateUDiv(x, y);
 
     case checked_srem_int:
-        return emit_checked_srem_int(x, y, ctx);
+        return emit_checked_srem_int(ctx, x, y);
 
     case checked_urem_int:
-        raise_exception_unless(builder.CreateICmpNE(y, ConstantInt::get(t, 0)),
-                               literal_pointer_val(jl_diverror_exception), ctx);
-        return builder.CreateURem(x, y);
-
-    case check_top_bit:
-        // raise InexactError if argument's top bit is set
-        raise_exception_if(
-                builder.CreateTrunc(
-                    builder.CreateLShr(x, ConstantInt::get(t, t->getPrimitiveSizeInBits() - 1)),
-                    T_int1),
-                literal_pointer_val(jl_inexact_exception), ctx);
-        return x;
-
-    case eq_int:  *newtyp = jl_bool_type; return builder.CreateICmpEQ(x, y);
-    case ne_int:  *newtyp = jl_bool_type; return builder.CreateICmpNE(x, y);
-    case slt_int: *newtyp = jl_bool_type; return builder.CreateICmpSLT(x, y);
-    case ult_int: *newtyp = jl_bool_type; return builder.CreateICmpULT(x, y);
-    case sle_int: *newtyp = jl_bool_type; return builder.CreateICmpSLE(x, y);
-    case ule_int: *newtyp = jl_bool_type; return builder.CreateICmpULE(x, y);
+        raise_exception_unless(ctx,
+                ctx.builder.CreateICmpNE(y, ConstantInt::get(t, 0)),
+                literal_pointer_val(ctx, jl_diverror_exception));
+        return ctx.builder.CreateURem(x, y);
+
+    case eq_int:  *newtyp = jl_bool_type; return ctx.builder.CreateICmpEQ(x, y);
+    case ne_int:  *newtyp = jl_bool_type; return ctx.builder.CreateICmpNE(x, y);
+    case slt_int: *newtyp = jl_bool_type; return ctx.builder.CreateICmpSLT(x, y);
+    case ult_int: *newtyp = jl_bool_type; return ctx.builder.CreateICmpULT(x, y);
+    case sle_int: *newtyp = jl_bool_type; return ctx.builder.CreateICmpSLE(x, y);
+    case ule_int: *newtyp = jl_bool_type; return ctx.builder.CreateICmpULE(x, y);
 
     case eq_float: *newtyp = jl_bool_type; return math_builder(ctx)().CreateFCmpOEQ(x, y);
     case ne_float: *newtyp = jl_bool_type; return math_builder(ctx)().CreateFCmpUNE(x, y);
@@ -1092,105 +1014,88 @@ static Value *emit_untyped_intrinsic(intrinsic f, Value **argvalues, size_t narg
     case fpiseq: {
         *newtyp = jl_bool_type;
         Type *it = INTT(t);
-        Value *xi = builder.CreateBitCast(x, it);
-        Value *yi = builder.CreateBitCast(y, it);
-        return builder.CreateOr(builder.CreateAnd(builder.CreateFCmpUNO(x, x),
-                                                  builder.CreateFCmpUNO(y, y)),
-                                builder.CreateICmpEQ(xi, yi));
+        Value *xi = ctx.builder.CreateBitCast(x, it);
+        Value *yi = ctx.builder.CreateBitCast(y, it);
+        return ctx.builder.CreateOr(ctx.builder.CreateAnd(ctx.builder.CreateFCmpUNO(x, x),
+                                                  ctx.builder.CreateFCmpUNO(y, y)),
+                                ctx.builder.CreateICmpEQ(xi, yi));
     }
 
     case fpislt: {
         *newtyp = jl_bool_type;
         Type *it = INTT(t);
-        Value *xi = builder.CreateBitCast(x, it);
-        Value *yi = builder.CreateBitCast(y, it);
-        return builder.CreateOr(
-            builder.CreateAnd(
-                builder.CreateFCmpORD(x, x),
-                builder.CreateFCmpUNO(y, y)),
-            builder.CreateAnd(
-                builder.CreateFCmpORD(x, y),
-                builder.CreateOr(
-                    builder.CreateAnd(
-                        builder.CreateICmpSGE(xi, ConstantInt::get(it, 0)),
-                        builder.CreateICmpSLT(xi, yi)),
-                    builder.CreateAnd(
-                        builder.CreateICmpSLT(xi, ConstantInt::get(it, 0)),
-                        builder.CreateICmpUGT(xi, yi)))));
+        Value *xi = ctx.builder.CreateBitCast(x, it);
+        Value *yi = ctx.builder.CreateBitCast(y, it);
+        return ctx.builder.CreateOr(
+            ctx.builder.CreateAnd(
+                ctx.builder.CreateFCmpORD(x, x),
+                ctx.builder.CreateFCmpUNO(y, y)),
+            ctx.builder.CreateAnd(
+                ctx.builder.CreateFCmpORD(x, y),
+                ctx.builder.CreateOr(
+                    ctx.builder.CreateAnd(
+                        ctx.builder.CreateICmpSGE(xi, ConstantInt::get(it, 0)),
+                        ctx.builder.CreateICmpSLT(xi, yi)),
+                    ctx.builder.CreateAnd(
+                        ctx.builder.CreateICmpSLT(xi, ConstantInt::get(it, 0)),
+                        ctx.builder.CreateICmpUGT(xi, yi)))));
     }
 
-    case and_int: return builder.CreateAnd(x, y);
-    case or_int:  return builder.CreateOr(x, y);
-    case xor_int: return builder.CreateXor(x, y);
+    case and_int: return ctx.builder.CreateAnd(x, y);
+    case or_int:  return ctx.builder.CreateOr(x, y);
+    case xor_int: return ctx.builder.CreateXor(x, y);
 
     case shl_int:
-        return builder.CreateSelect(
-                builder.CreateICmpUGE(y, ConstantInt::get(y->getType(),
+        return ctx.builder.CreateSelect(
+                ctx.builder.CreateICmpUGE(y, ConstantInt::get(y->getType(),
                                                           t->getPrimitiveSizeInBits())),
                 ConstantInt::get(t, 0),
-                builder.CreateShl(x, uint_cnvt(t, y)));
+                ctx.builder.CreateShl(x, uint_cnvt(ctx, t, y)));
     case lshr_int:
-        return builder.CreateSelect(
-                builder.CreateICmpUGE(y, ConstantInt::get(y->getType(),
+        return ctx.builder.CreateSelect(
+                ctx.builder.CreateICmpUGE(y, ConstantInt::get(y->getType(),
                                                           t->getPrimitiveSizeInBits())),
                 ConstantInt::get(t, 0),
-                builder.CreateLShr(x, uint_cnvt(t, y)));
+                ctx.builder.CreateLShr(x, uint_cnvt(ctx, t, y)));
     case ashr_int:
-        return builder.CreateSelect(
-                builder.CreateICmpUGE(y, ConstantInt::get(y->getType(),
+        return ctx.builder.CreateSelect(
+                ctx.builder.CreateICmpUGE(y, ConstantInt::get(y->getType(),
                                                           t->getPrimitiveSizeInBits())),
-                builder.CreateAShr(x, ConstantInt::get(t, t->getPrimitiveSizeInBits() - 1)),
-                builder.CreateAShr(x, uint_cnvt(t, y)));
+                ctx.builder.CreateAShr(x, ConstantInt::get(t, t->getPrimitiveSizeInBits() - 1)),
+                ctx.builder.CreateAShr(x, uint_cnvt(ctx, t, y)));
 
     case bswap_int: {
         Value *bswapintr = Intrinsic::getDeclaration(jl_Module, Intrinsic::bswap, makeArrayRef(t));
-        return builder.CreateCall(bswapintr, x);
+        return ctx.builder.CreateCall(bswapintr, x);
     }
     case ctpop_int: {
         Value *ctpopintr = Intrinsic::getDeclaration(jl_Module, Intrinsic::ctpop, makeArrayRef(t));
-        return builder.CreateCall(ctpopintr, x);
+        return ctx.builder.CreateCall(ctpopintr, x);
     }
     case ctlz_int: {
         Value *ctlz = Intrinsic::getDeclaration(jl_Module, Intrinsic::ctlz, makeArrayRef(t));
         y = ConstantInt::get(T_int1, 0);
-#if JL_LLVM_VERSION >= 30700
-        return builder.CreateCall(ctlz, {x, y});
-#else
-        return builder.CreateCall2(ctlz, x, y);
-#endif
+        return ctx.builder.CreateCall(ctlz, {x, y});
     }
     case cttz_int: {
         Value *cttz = Intrinsic::getDeclaration(jl_Module, Intrinsic::cttz, makeArrayRef(t));
         y = ConstantInt::get(T_int1, 0);
-#if JL_LLVM_VERSION >= 30700
-        return builder.CreateCall(cttz, {x, y});
-#else
-        return builder.CreateCall2(cttz, x, y);
-#endif
+        return ctx.builder.CreateCall(cttz, {x, y});
     }
 
     case abs_float: {
-#if JL_LLVM_VERSION >= 30400
         Value *absintr = Intrinsic::getDeclaration(jl_Module, Intrinsic::fabs, makeArrayRef(t));
-        return builder.CreateCall(absintr, x);
-#else
-        Type *intt = INTT(t);
-        Value *bits = builder.CreateBitCast(x, intt);
-        Value *absbits =
-            builder.CreateAnd(bits,
-                              ConstantInt::get(intt, APInt::getSignedMaxValue(cast<IntegerType>(intt)->getBitWidth())));
-        return builder.CreateBitCast(absbits, t);
-#endif
+        return ctx.builder.CreateCall(absintr, x);
     }
     case copysign_float: {
-        Value *bits = builder.CreateBitCast(x, t);
-        Value *sbits = builder.CreateBitCast(y, t);
+        Value *bits = ctx.builder.CreateBitCast(x, t);
+        Value *sbits = ctx.builder.CreateBitCast(y, t);
         unsigned nb = cast<IntegerType>(t)->getBitWidth();
         APInt notsignbit = APInt::getSignedMaxValue(nb);
         APInt signbit0(nb, 0); signbit0.setBit(nb - 1);
-        return builder.CreateOr(
-                    builder.CreateAnd(bits, ConstantInt::get(t, notsignbit)),
-                    builder.CreateAnd(sbits, ConstantInt::get(t, signbit0)));
+        return ctx.builder.CreateOr(
+                    ctx.builder.CreateAnd(bits, ConstantInt::get(t, notsignbit)),
+                    ctx.builder.CreateAnd(sbits, ConstantInt::get(t, signbit0)));
     }
     case flipsign_int: {
         ConstantInt *cx = dyn_cast<ConstantInt>(x);
@@ -1202,34 +1107,30 @@ static Value *emit_untyped_intrinsic(intrinsic f, Value **argvalues, size_t narg
         }
         if (cy) {
             APInt iy = cy->getValue();
-            return iy.isNonNegative() ? x : builder.CreateSub(ConstantInt::get(t, 0), x);
+            return iy.isNonNegative() ? x : ctx.builder.CreateSub(ConstantInt::get(t, 0), x);
         }
-        Value *tmp = builder.CreateAShr(y, ConstantInt::get(t, cast<IntegerType>(t)->getBitWidth() - 1));
-        return builder.CreateXor(builder.CreateAdd(x, tmp), tmp);
+        Value *tmp = ctx.builder.CreateAShr(y, ConstantInt::get(t, cast<IntegerType>(t)->getBitWidth() - 1));
+        return ctx.builder.CreateXor(ctx.builder.CreateAdd(x, tmp), tmp);
     }
     case ceil_llvm: {
         Value *ceilintr = Intrinsic::getDeclaration(jl_Module, Intrinsic::ceil, makeArrayRef(t));
-        return builder.CreateCall(ceilintr, x);
+        return ctx.builder.CreateCall(ceilintr, x);
     }
     case floor_llvm: {
         Value *floorintr = Intrinsic::getDeclaration(jl_Module, Intrinsic::floor, makeArrayRef(t));
-        return builder.CreateCall(floorintr, x);
+        return ctx.builder.CreateCall(floorintr, x);
     }
     case trunc_llvm: {
         Value *truncintr = Intrinsic::getDeclaration(jl_Module, Intrinsic::trunc, makeArrayRef(t));
-        return builder.CreateCall(truncintr, x);
+        return ctx.builder.CreateCall(truncintr, x);
     }
     case rint_llvm: {
         Value *rintintr = Intrinsic::getDeclaration(jl_Module, Intrinsic::rint, makeArrayRef(t));
-        return builder.CreateCall(rintintr, x);
+        return ctx.builder.CreateCall(rintintr, x);
     }
-    case sqrt_llvm:
-        raise_exception_unless(builder.CreateFCmpUGE(x, ConstantFP::get(t, 0.0)),
-                               literal_pointer_val(jl_domain_exception), ctx);
-        // fall-through
-    case sqrt_llvm_fast: {
+    case sqrt_llvm: {
         Value *sqrtintr = Intrinsic::getDeclaration(jl_Module, Intrinsic::sqrt, makeArrayRef(t));
-        return builder.CreateCall(sqrtintr, x);
+        return ctx.builder.CreateCall(sqrtintr, x);
     }
 
     default:
@@ -1239,8 +1140,8 @@ static Value *emit_untyped_intrinsic(intrinsic f, Value **argvalues, size_t narg
     assert(0 && "unreachable");
 }
 
-#define BOX_F(ct,jl_ct)                                                 \
-    box_##ct##_func = boxfunc_llvm(ft1arg(T_pjlvalue, T_##jl_ct),       \
+#define BOX_F(ct,jl_ct)                                                  \
+    box_##ct##_func = boxfunc_llvm(ft1arg(T_prjlvalue, 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);
diff --git a/src/intrinsics.h b/src/intrinsics.h
index 058ccc68faaa87..80491639ac6b8a 100644
--- a/src/intrinsics.h
+++ b/src/intrinsics.h
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #define INTRINSICS \
     /*  wrap and unwrap */ \
@@ -66,10 +66,6 @@
     ADD_I(sitofp, 2) \
     ADD_I(fptrunc, 2) \
     ADD_I(fpext, 2) \
-    /*  checked conversion */ \
-    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) \
@@ -91,8 +87,6 @@
     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, 3) \
     ADD_I(pointerset, 4) \
diff --git a/src/jitlayers.cpp b/src/jitlayers.cpp
index d6f8895dba2751..5e4cc93ca5f7f7 100644
--- a/src/jitlayers.cpp
+++ b/src/jitlayers.cpp
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include "llvm-version.h"
 #include "platform.h"
@@ -8,23 +8,18 @@
 
 // analysis passes
 #include <llvm/Analysis/Passes.h>
-#if JL_LLVM_VERSION >= 30800
 #include <llvm/Analysis/BasicAliasAnalysis.h>
 #include <llvm/Analysis/TypeBasedAliasAnalysis.h>
-#endif
-#if JL_LLVM_VERSION >= 30700
 #include <llvm/Analysis/TargetTransformInfo.h>
 #include <llvm/Analysis/TargetLibraryInfo.h>
-#endif
-#if JL_LLVM_VERSION >= 30500
 #include <llvm/IR/Verifier.h>
-#else
-#include <llvm/Analysis/Verifier.h>
-#endif
 #if defined(USE_POLLY)
 #include <polly/RegisterPasses.h>
 #include <polly/LinkAllPasses.h>
 #include <polly/CodeGen/CodegenCleanup.h>
+#if defined(USE_POLLY_ACC)
+#include <polly/Support/LinkGPURuntime.h>
+#endif
 #endif
 
 #include <llvm/Transforms/IPO.h>
@@ -32,9 +27,7 @@
 #include <llvm/Transforms/Utils/BasicBlockUtils.h>
 #include <llvm/Transforms/Instrumentation.h>
 #include <llvm/Transforms/Vectorize.h>
-#if JL_LLVM_VERSION >= 30900
 #include <llvm/Transforms/Scalar/GVN.h>
-#endif
 #if JL_LLVM_VERSION >= 40000
 #include <llvm/Transforms/IPO/AlwaysInliner.h>
 #endif
@@ -48,19 +41,16 @@ namespace llvm {
 #else
 #  include <llvm/Bitcode/ReaderWriter.h>
 #endif
-#if JL_LLVM_VERSION >= 30500
 #include <llvm/Bitcode/BitcodeWriterPass.h>
-#endif
 
+#include <llvm/IR/LegacyPassManagers.h>
+#include <llvm/IR/IRPrintingPasses.h>
 #include <llvm/Transforms/Utils/Cloning.h>
 #include <llvm/ExecutionEngine/JITEventListener.h>
 
 // target support
 #include <llvm/ADT/Triple.h>
 #include <llvm/Support/TargetRegistry.h>
-#if JL_LLVM_VERSION < 30700
-#include <llvm/Target/TargetLibraryInfo.h>
-#endif
 #include <llvm/IR/DataLayout.h>
 #include <llvm/Support/DynamicLibrary.h>
 
@@ -70,15 +60,14 @@ namespace llvm {
 #include <llvm/ADT/StringMap.h>
 #include <llvm/ADT/StringSet.h>
 #include <llvm/ADT/SmallSet.h>
+#include "fix_llvm_assert.h"
 
 using namespace llvm;
 
 #include "julia.h"
 #include "julia_internal.h"
 #include "jitlayers.h"
-#ifdef USE_MCJIT
 RTDyldMemoryManager* createRTDyldMemoryManager(void);
-#endif
 
 static Type *T_void;
 static IntegerType *T_uint32;
@@ -104,74 +93,89 @@ void jl_init_jit(Type *T_pjlvalue_)
 // Except for parts of this file which were copied from LLVM, under the UIUC license (marked below).
 
 // this defines the set of optimization passes defined for Julia at various optimization levels
-#if JL_LLVM_VERSION >= 30700
-void addOptimizationPasses(legacy::PassManager *PM)
-#else
-void addOptimizationPasses(PassManager *PM)
-#endif
+void addOptimizationPasses(legacy::PassManagerBase *PM, int opt_level)
 {
-    PM->add(createLowerGCFramePass());
 #ifdef JL_DEBUG_BUILD
+    PM->add(createGCInvariantVerifierPass(true));
     PM->add(createVerifierPass());
 #endif
 
 #if defined(JL_ASAN_ENABLED)
-#   if JL_LLVM_VERSION >= 30700 && JL_LLVM_VERSION < 30800
-    // LLVM 3.7 BUG: ASAN pass doesn't properly initialize its dependencies
-    initializeTargetLibraryInfoWrapperPassPass(*PassRegistry::getPassRegistry());
-#   endif
     PM->add(createAddressSanitizerFunctionPass());
 #endif
 #if defined(JL_MSAN_ENABLED)
     PM->add(llvm::createMemorySanitizerPass(true));
 #endif
-    if (jl_options.opt_level == 0) {
+    if (opt_level == 0) {
+        PM->add(createCFGSimplificationPass()); // Clean up disgusting code
+#if JL_LLVM_VERSION < 50000
+        PM->add(createBarrierNoopPass());
+        PM->add(createLowerExcHandlersPass());
+        PM->add(createGCInvariantVerifierPass(false));
+        PM->add(createLateLowerGCFramePass());
         PM->add(createLowerPTLSPass(imaging_mode));
+        PM->add(createBarrierNoopPass());
+#endif
+        PM->add(createMemCpyOptPass()); // Remove memcpy / form memset
+#if JL_LLVM_VERSION >= 40000
+        PM->add(createAlwaysInlinerLegacyPass()); // Respect always_inline
+#else
+        PM->add(createAlwaysInlinerPass()); // Respect always_inline
+#endif
+#if JL_LLVM_VERSION >= 50000
+        PM->add(createBarrierNoopPass());
+        PM->add(createLowerExcHandlersPass());
+        PM->add(createGCInvariantVerifierPass(false));
+        PM->add(createLateLowerGCFramePass());
+        PM->add(createLowerPTLSPass(imaging_mode));
+#endif
         return;
     }
-#if JL_LLVM_VERSION >= 30700
+    PM->add(createPropagateJuliaAddrspaces());
     PM->add(createTargetTransformInfoWrapperPass(jl_TargetMachine->getTargetIRAnalysis()));
-#else
-    jl_TargetMachine->addAnalysisPasses(*PM);
-#endif
-#if JL_LLVM_VERSION >= 30800
     PM->add(createTypeBasedAAWrapperPass());
-#else
-    PM->add(createTypeBasedAliasAnalysisPass());
-#endif
     if (jl_options.opt_level >= 3) {
-#if JL_LLVM_VERSION >= 30800
         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
+    PM->add(createDeadInstEliminationPass());
+    PM->add(createPromoteMemoryToRegisterPass()); // Kill useless allocas
+
+    // Due to bugs and missing features LLVM < 5.0, does not properly propagate
+    // our invariants. We need to do GC rooting here. This reduces the
+    // effectiveness of the optimization, but should retain correctness.
+#if JL_LLVM_VERSION < 50000
+    PM->add(createLowerExcHandlersPass());
+    PM->add(createAllocOptPass());
+    PM->add(createLateLowerGCFramePass());
+    // Remove dead use of ptls
+    PM->add(createDeadCodeEliminationPass());
+    PM->add(createLowerPTLSPass(imaging_mode));
+#endif
+
+    PM->add(createMemCpyOptPass());
+
 #if JL_LLVM_VERSION >= 40000
     PM->add(createAlwaysInlinerLegacyPass()); // Respect always_inline
 #else
     PM->add(createAlwaysInlinerPass()); // Respect always_inline
 #endif
 
-#ifndef INSTCOMBINE_BUG
-    PM->add(createInstructionCombiningPass()); // Cleanup for scalarrepl.
+#if JL_LLVM_VERSION >= 50000
+    // Running `memcpyopt` between this and `sroa` seems to give `sroa` a hard time
+    // merging the `alloca` for the unboxed data and the `alloca` created by the `alloc_opt`
+    // pass.
+    PM->add(createAllocOptPass());
 #endif
-    // Let the InstCombine pass remove the unnecessary load of
-    // safepoint address first
-    PM->add(createLowerPTLSPass(imaging_mode));
+    PM->add(createInstructionCombiningPass()); // Cleanup for scalarrepl.
     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
@@ -197,24 +201,13 @@ void addOptimizationPasses(PassManager *PM)
     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 JL_LLVM_VERSION >= 30500
     PM->add(createSimpleLoopUnrollPass());     // Unroll small loops
-#else
-    PM->add(createLoopUnrollPass());           // Unroll small loops
-#endif
-#if JL_LLVM_VERSION < 30500 && !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
@@ -223,33 +216,46 @@ void addOptimizationPasses(PassManager *PM)
     // 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 JL_LLVM_VERSION >= 30500
+
+    // see if all of the constant folding has exposed more loops
+    // to simplification and deletion
+    // this helps significantly with cleaning up iteration
+    PM->add(createCFGSimplificationPass());     // Merge & remove BBs
+    PM->add(createLoopIdiomPass());
+    PM->add(createLoopDeletionPass());          // Delete dead loops
+    PM->add(createJumpThreadingPass());         // Thread jumps
+
     if (jl_options.opt_level >= 3) {
         PM->add(createSLPVectorizerPass());     // Vectorize straight-line code
     }
-#endif
 
     PM->add(createAggressiveDCEPass());         // Delete dead instructions
-#if JL_LLVM_VERSION >= 30500
     if (jl_options.opt_level >= 3)
         PM->add(createInstructionCombiningPass());   // Clean up after SLP loop vectorizer
     PM->add(createLoopVectorizePass());         // Vectorize loops
     PM->add(createInstructionCombiningPass());  // Clean up after loop vectorizer
+    // LowerPTLS removes an indirect call. As a result, it is likely to trigger
+    // LLVM's devirtualization heuristics, which would result in the entire
+    // pass pipeline being re-exectuted. Prevent this by inserting a barrier.
+#if JL_LLVM_VERSION >= 50000
+    PM->add(createBarrierNoopPass());
+    PM->add(createLowerExcHandlersPass());
+    PM->add(createGCInvariantVerifierPass(false));
+    PM->add(createLateLowerGCFramePass());
+    // Remove dead use of ptls
+    PM->add(createDeadCodeEliminationPass());
+    PM->add(createLowerPTLSPass(imaging_mode));
 #endif
-    //PM->add(createCFGSimplificationPass());     // Merge & remove BBs
+    PM->add(createCombineMulAddPass());
 }
 
-#ifdef USE_ORCJIT
-
-#if JL_LLVM_VERSION < 30800
-void notifyObjectLoaded(RTDyldMemoryManager *memmgr,
-                        llvm::orc::ObjectLinkingLayerBase::ObjSetHandleT H);
-#endif
+extern "C" JL_DLLEXPORT
+void jl_add_optimization_passes(LLVMPassManagerRef PM, int opt_level) {
+    addOptimizationPasses(unwrap(PM), opt_level);
+}
 
 // ------------------------ TEMPORARILY COPIED FROM LLVM -----------------
 // This must be kept in sync with gdb/gdb/jit.h .
@@ -317,12 +323,17 @@ void NotifyDebugger(jit_code_entry *JITCodeEntry)
 }
 // ------------------------ END OF TEMPORARY COPY FROM LLVM -----------------
 
-#if defined(_OS_LINUX_)
+#if defined(_OS_LINUX_) || defined(_OS_WINDOWS_)
 // Resolve non-lock free atomic functions in the libatomic library.
 // This is the library that provides support for c11/c++11 atomic operations.
 static uint64_t resolve_atomic(const char *name)
 {
-    static void *atomic_hdl = jl_load_dynamic_library_e("libatomic",
+#if defined(_OS_LINUX_)
+    static const char *const libatomic = "libatomic";
+#elif defined(_OS_WINDOWS_)
+    static const char *const libatomic = "libatomic-1";
+#endif
+    static void *atomic_hdl = jl_load_dynamic_library_e(libatomic,
                                                         JL_RTLD_LOCAL);
     static const char *const atomic_prefix = "__atomic_";
     if (!atomic_hdl)
@@ -347,20 +358,13 @@ JL_DLLEXPORT void ORCNotifyObjectEmitted(JITEventListener *Listener,
 
 // TODO: hook up RegisterJITEventListener, instead of hard-coding the GDB and JuliaListener targets
 template <typename ObjSetT, typename LoadResult>
-void JuliaOJIT::DebugObjectRegistrar::operator()(ObjectLinkingLayerBase::ObjSetHandleT H,
+void JuliaOJIT::DebugObjectRegistrar::operator()(RTDyldObjectLinkingLayerBase::ObjSetHandleT H,
                 const ObjSetT &Objects, const LoadResult &LOS)
 {
-#if JL_LLVM_VERSION < 30800
-    notifyObjectLoaded(JIT.MemMgr, H);
-#endif
     auto oit = Objects.begin();
     auto lit = LOS.begin();
     for (; oit != Objects.end(); ++oit, ++lit) {
-#if JL_LLVM_VERSION >= 30900
         const auto &Object = (*oit)->getBinary();
-#else
-        auto &Object = *oit;
-#endif
         auto &LO = *lit;
 
         OwningBinary<object::ObjectFile> SavedObject = LO->getObjectForDebug(*Object);
@@ -449,30 +453,19 @@ JuliaOJIT::JuliaOJIT(TargetMachine &TM)
 #else
                     M.dump();
 #endif
-#if JL_LLVM_VERSION >= 30900
                     std::string Buf;
                     raw_string_ostream OS(Buf);
                     logAllUnhandledErrors(Obj.takeError(), OS, "");
                     OS.flush();
                     llvm::report_fatal_error("FATAL: Unable to compile LLVM Module: '" + Buf + "'\n"
                         "The module's content was printed above. Please file a bug report");
-#else
-                    llvm::report_fatal_error("FATAL: Unable to compile LLVM Module.\n"
-                        "The module's content was printed above. Please file a bug report");
-#endif
                 }
 
                 return OwningObj(std::move(*Obj), std::move(ObjBuffer));
             }
         )
 {
-    if (!jl_generating_output()) {
-        addOptimizationPasses(&PM);
-    }
-    else {
-        PM.add(createLowerGCFramePass());
-        PM.add(createLowerPTLSPass(imaging_mode));
-    }
+    addOptimizationPasses(&PM, jl_generating_output() ? 0 : jl_options.opt_level);
     if (TM.addPassesToEmitMC(PM, Ctx, ObjStream))
         llvm_unreachable("Target does not support MC emission.");
 
@@ -512,7 +505,7 @@ void *JuliaOJIT::getPointerToGlobalIfAvailable(const GlobalValue *GV)
 
 void JuliaOJIT::addModule(std::unique_ptr<Module> M)
 {
-#ifndef NDEBUG
+#ifndef JL_NDEBUG
     // validate the relocations for M
     for (Module::iterator I = M->begin(), E = M->end(); I != E; ) {
         Function *F = &*I;
@@ -553,7 +546,7 @@ void JuliaOJIT::addModule(std::unique_ptr<Module> M)
                         // Step 2: Search the program symbols
                         if (uint64_t addr = SectionMemoryManager::getSymbolAddressInProcess(Name))
                             return JL_SymbolInfo(addr, JITSymbolFlags::Exported);
-#if defined(_OS_LINUX_)
+#if defined(_OS_LINUX_) || defined(_OS_WINDOWS_)
                         if (uint64_t addr = resolve_atomic(Name.c_str()))
                             return JL_SymbolInfo(addr, JITSymbolFlags::Exported);
 #endif
@@ -637,9 +630,6 @@ std::string JuliaOJIT::getMangledName(const GlobalValue *GV)
 }
 
 JuliaOJIT *jl_ExecutionEngine;
-#else
-ExecutionEngine *jl_ExecutionEngine;
-#endif
 
 // MSVC's link.exe requires each function declaration to have a Comdat section
 // So rather than litter the code with conditionals,
@@ -649,7 +639,7 @@ ExecutionEngine *jl_ExecutionEngine;
 template<class T> // for GlobalObject's
 static T *addComdat(T *G)
 {
-#if defined(_OS_WINDOWS_) && JL_LLVM_VERSION >= 30500
+#if defined(_OS_WINDOWS_)
     if (imaging_mode && !G->isDeclaration()) {
         // Add comdat information to make MSVC link.exe happy
         // it's valid to emit this for ld.exe too,
@@ -755,15 +745,9 @@ static void jl_merge_module(Module *dest, std::unique_ptr<Module> src)
     NamedMDNode *sNMD = src->getNamedMetadata("llvm.dbg.cu");
     if (sNMD) {
         NamedMDNode *dNMD = dest->getOrInsertNamedMetadata("llvm.dbg.cu");
-#if JL_LLVM_VERSION >= 30500
         for (NamedMDNode::op_iterator I = sNMD->op_begin(), E = sNMD->op_end(); I != E; ++I) {
             dNMD->addOperand(*I);
         }
-#else
-        for (unsigned i = 0, l = sNMD->getNumOperands(); i < l; i++) {
-            dNMD->addOperand(sNMD->getOperand(i));
-        }
-#endif
     }
 }
 
@@ -773,10 +757,9 @@ static void jl_merge_module(Module *dest, std::unique_ptr<Module> src)
 static StringMap<Module*> module_for_fname;
 static void jl_merge_recursive(Module *m, Module *collector);
 
-#if defined(USE_MCJIT) || defined(USE_ORCJIT)
 static void jl_add_to_ee(std::unique_ptr<Module> m)
 {
-#if defined(_CPU_X86_64_) && defined(_OS_WINDOWS_) && JL_LLVM_VERSION >= 30500
+#if defined(_CPU_X86_64_) && defined(_OS_WINDOWS_)
     // Add special values used by debuginfo to build the UnwindData table registration for Win64
     ArrayType *atype = ArrayType::get(T_uint32, 3); // want 4-byte alignment of 12-bytes of data
     (new GlobalVariable(*m, atype,
@@ -787,36 +770,17 @@ static void jl_add_to_ee(std::unique_ptr<Module> m)
         ConstantAggregateZero::get(atype), "__catchjmp"))->setSection(".text");
 #endif
     assert(jl_ExecutionEngine);
-#if JL_LLVM_VERSION >= 30600
     jl_ExecutionEngine->addModule(std::move(m));
-#else
-    jl_ExecutionEngine->addModule(m.release());
-#endif
 }
 
-void jl_finalize_function(Function *F)
+void jl_finalize_function(StringRef F)
 {
-    std::unique_ptr<Module> m(module_for_fname.lookup(F->getName()));
+    std::unique_ptr<Module> m(module_for_fname.lookup(F));
     if (m) {
         jl_merge_recursive(m.get(), m.get());
         jl_add_to_ee(std::move(m));
     }
 }
-#else
-static bool jl_try_finalize(Module *m)
-{
-    for (Module::iterator I = m->begin(), E = m->end(); I != E; ++I) {
-        Function *F = &*I;
-        if (F->isDeclaration() && !isIntrinsicFunction(F)) {
-            if (!jl_can_finalize_function(F))
-                return false;
-        }
-    }
-    jl_merge_recursive(m, shadow_output);
-    jl_merge_module(shadow_output, std::unique_ptr<Module>(m));
-    return true;
-}
-#endif
 
 static void jl_finalize_function(const std::string &F, Module *collector)
 {
@@ -850,31 +814,26 @@ static void jl_merge_recursive(Module *m, Module *collector)
 
 // see if any of the functions needed by F are still WIP
 static StringSet<> incomplete_fname;
-static bool jl_can_finalize_function(StringRef F, SmallSet<Module*, 16> &known)
+static bool can_finalize_function(StringRef F, SmallSet<Module*, 16> &known)
 {
     if (incomplete_fname.find(F) != incomplete_fname.end())
         return false;
     Module *M = module_for_fname.lookup(F);
-#if JL_LLVM_VERSION >= 30500
-    if (M && known.insert(M).second)
-#else
-    if (M && known.insert(M))
-#endif
-    {
+    if (M && known.insert(M).second) {
         for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I) {
             Function *F = &*I;
             if (F->isDeclaration() && !isIntrinsicFunction(F)) {
-                if (!jl_can_finalize_function(F->getName(), known))
+                if (!can_finalize_function(F->getName(), known))
                     return false;
             }
         }
     }
     return true;
 }
-bool jl_can_finalize_function(Function *F)
+bool jl_can_finalize_function(StringRef F)
 {
     SmallSet<Module*, 16> known;
-    return jl_can_finalize_function(F->getName(), known);
+    return can_finalize_function(F, known);
 }
 
 // let the JIT know this function is a WIP
@@ -887,9 +846,6 @@ void jl_init_function(Function *F)
 // and will add it to the execution engine when required (by jl_finalize_function)
 void jl_finalize_module(Module *m, bool shadow)
 {
-#if !defined(USE_ORCJIT)
-    jl_globalPM->run(*m);
-#endif
     // record the function names that are part of this Module
     // so it can be added to the JIT when needed
     for (Module::iterator I = m->begin(), E = m->end(); I != E; ++I) {
@@ -900,55 +856,30 @@ void jl_finalize_module(Module *m, bool shadow)
             module_for_fname[F->getName()] = m;
         }
     }
-#if defined(USE_ORCJIT) || defined(USE_MCJIT)
     // in the newer JITs, the shadow module is separate from the execution module
     if (shadow)
         jl_add_to_shadow(m);
-#else
-    bool changes = jl_try_finalize(m);
-    while (changes) {
-        // this definitely isn't the most efficient, but it's only for the old LLVM 3.3 JIT
-        changes = false;
-        for (StringMap<Module*>::iterator MI = module_for_fname.begin(), ME = module_for_fname.end(); MI != ME; ++MI) {
-            changes |= jl_try_finalize(MI->second);
-        }
-    }
-#endif
 }
 
 // helper function for adding a DLLImport (dlsym) address to the execution engine
 // (for values created locally or in the sysimage, jl_emit_and_add_to_shadow is generally preferable)
-#if JL_LLVM_VERSION >= 30500
 void add_named_global(GlobalObject *gv, void *addr, bool dllimport)
-#else
-void add_named_global(GlobalValue *gv, void *addr, bool dllimport)
-#endif
 {
 #ifdef _OS_WINDOWS_
     // setting JL_DLLEXPORT correctly only matters when building a binary
     // (global_proto will strip this from the JIT)
     if (dllimport && imaging_mode) {
         assert(gv->getLinkage() == GlobalValue::ExternalLinkage);
-#if JL_LLVM_VERSION >= 30500
         // add the __declspec(dllimport) attribute
         gv->setDLLStorageClass(GlobalValue::DLLImportStorageClass);
-#else
-        gv->setLinkage(GlobalValue::DLLImportLinkage);
-#if defined(_P64)
-        // __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
     }
 #endif // _OS_WINDOWS_
 
     jl_ExecutionEngine->addGlobalMapping(gv, addr);
 }
 
-static std::vector<Constant*> jl_sysimg_gvars;
-static std::vector<Constant*> jl_sysimg_fvars;
+static std::vector<GlobalValue*> jl_sysimg_gvars;
+static std::vector<GlobalValue*> jl_sysimg_fvars;
 static std::map<void*, jl_value_llvm> jl_value_to_llvm;
 
 // global variables to pointers are pretty common,
@@ -966,9 +897,7 @@ void* jl_emit_and_add_to_shadow(GlobalVariable *gv, void *gvarinit)
     PointerType *T = cast<PointerType>(gv->getType()->getElementType()); // pointer is the only supported type here
 
     GlobalVariable *shadowvar = NULL;
-#if defined(USE_MCJIT) || defined(USE_ORCJIT)
     if (imaging_mode)
-#endif
         shadowvar = global_proto(gv, shadow_output);
 
     if (shadowvar) {
@@ -977,7 +906,7 @@ void* jl_emit_and_add_to_shadow(GlobalVariable *gv, void *gvarinit)
         addComdat(shadowvar);
         if (imaging_mode && gvarinit) {
             // make the pointer valid for future sessions
-            jl_sysimg_gvars.push_back(ConstantExpr::getBitCast(shadowvar, T_psize));
+            jl_sysimg_gvars.push_back(shadowvar);
             jl_value_llvm gv_struct;
             gv_struct.gv = global_proto(gv);
             gv_struct.index = jl_sysimg_gvars.size();
@@ -986,13 +915,9 @@ void* jl_emit_and_add_to_shadow(GlobalVariable *gv, void *gvarinit)
     }
 
     // make the pointer valid for this session
-#if defined(USE_MCJIT) || defined(USE_ORCJIT)
     void *slot = calloc(1, sizeof(void*));
     jl_ExecutionEngine->addGlobalMapping(gv, slot);
     return slot;
-#else
-    return jl_ExecutionEngine->getPointerToGlobal(shadowvar);
-#endif
 }
 
 // Emit a slot in the system image to be filled at sysimg init time.
@@ -1000,7 +925,7 @@ void* jl_emit_and_add_to_shadow(GlobalVariable *gv, void *gvarinit)
 // Use as an optimization for runtime constant addresses to have one less
 // load. (Used only by threading).
 GlobalVariable *jl_emit_sysimg_slot(Module *m, Type *typ, const char *name,
-                                           uintptr_t init, size_t &idx)
+                                    uintptr_t init, size_t &idx)
 {
     assert(imaging_mode);
     // This is **NOT** a external variable or a normal global variable
@@ -1008,39 +933,28 @@ GlobalVariable *jl_emit_sysimg_slot(Module *m, Type *typ, const char *name,
     // in the global variable table.
     GlobalVariable *gv = new GlobalVariable(*m, typ, false,
                                             GlobalVariable::InternalLinkage,
-                                            ConstantPointerNull::get((PointerType*)typ), name);
+                                            Constant::getNullValue(typ), name);
     addComdat(gv);
     // make the pointer valid for this session
-#if defined(USE_MCJIT) || defined(USE_ORCJIT)
     auto p = new uintptr_t(init);
     jl_ExecutionEngine->addGlobalMapping(gv, (void*)p);
-#else
-    uintptr_t *p = (uintptr_t*)jl_ExecutionEngine->getPointerToGlobal(gv);
-    *p = init;
-#endif
-    jl_sysimg_gvars.push_back(ConstantExpr::getBitCast(gv, T_psize));
+    jl_sysimg_gvars.push_back(gv);
     idx = jl_sysimg_gvars.size();
     return gv;
 }
 
-void* jl_get_global(GlobalVariable *gv)
+void* jl_get_globalvar(GlobalVariable *gv)
 {
-#if defined(USE_MCJIT) || defined(USE_ORCJIT)
     void *p = (void*)(intptr_t)jl_ExecutionEngine->getPointerToGlobalIfAvailable(gv);
-#else
-    void *p = jl_ExecutionEngine->getPointerToGlobal(
-            shadow_output->getNamedValue(gv->getName()));
-#endif
     assert(p);
     return p;
 }
 
 // clones the contents of the module `m` to the shadow_output collector
-#if defined(USE_MCJIT) || defined(USE_ORCJIT)
 void jl_add_to_shadow(Module *m)
 {
 #ifndef KEEP_BODIES
-    if (!imaging_mode)
+    if (!imaging_mode && !jl_options.outputjitbc)
         return;
 #endif
     ValueToValueMapTy VMap;
@@ -1054,7 +968,6 @@ void jl_add_to_shadow(Module *m)
     }
     jl_merge_module(shadow_output, std::move(clone));
 }
-#endif
 
 #ifdef HAVE_CPUID
 extern "C" {
@@ -1062,23 +975,29 @@ extern "C" {
 }
 #endif
 
-static void jl_gen_llvm_globaldata(llvm::Module *mod, ValueToValueMapTy &VMap,
-                                   const char *sysimg_data, size_t sysimg_len)
+static void emit_offset_table(Module *mod, const std::vector<GlobalValue*> &vars, StringRef name)
 {
-    ArrayType *gvars_type = ArrayType::get(T_psize, jl_sysimg_gvars.size());
-    addComdat(new GlobalVariable(*mod,
-                                 gvars_type,
-                                 true,
-                                 GlobalVariable::ExternalLinkage,
-                                 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,
+    assert(!vars.empty());
+    addComdat(GlobalAlias::create(GlobalVariable::ExternalLinkage, name + "_base", vars[0]));
+    auto vbase = ConstantExpr::getPtrToInt(vars[0], T_size);
+    size_t nvars = vars.size();
+    std::vector<Constant*> offsets(nvars);
+    for (size_t i = 0; i < nvars; i++) {
+        auto ptrdiff = ConstantExpr::getSub(ConstantExpr::getPtrToInt(vars[i], T_size), vbase);
+        offsets[i] = sizeof(void*) == 8 ? ConstantExpr::getTrunc(ptrdiff, T_uint32) : ptrdiff;
+    }
+    ArrayType *vars_type = ArrayType::get(T_uint32, nvars);
+    addComdat(new GlobalVariable(*mod, vars_type, true,
                                  GlobalVariable::ExternalLinkage,
-                                 MapValue(ConstantArray::get(fvars_type, ArrayRef<Constant*>(jl_sysimg_fvars)), VMap),
-                                 "jl_sysimg_fvars"));
+                                 ConstantArray::get(vars_type, ArrayRef<Constant*>(offsets)),
+                                 name + "_offsets"));
+}
+
+
+static void jl_gen_llvm_globaldata(Module *mod, const char *sysimg_data, size_t sysimg_len)
+{
+    emit_offset_table(mod, jl_sysimg_gvars, "jl_sysimg_gvars");
+    emit_offset_table(mod, jl_sysimg_fvars, "jl_sysimg_fvars");
     addComdat(new GlobalVariable(*mod,
                                  T_size,
                                  true,
@@ -1092,6 +1011,12 @@ static void jl_gen_llvm_globaldata(llvm::Module *mod, ValueToValueMapTy &VMap,
                                  GlobalVariable::ExternalLinkage,
                                  ConstantInt::get(T_size, jltls_states_func_idx),
                                  "jl_ptls_states_getter_idx"));
+    addComdat(new GlobalVariable(*mod,
+                                 T_size,
+                                 true,
+                                 GlobalVariable::ExternalLinkage,
+                                 ConstantInt::get(T_size, jltls_offset_idx),
+                                 "jl_tls_offset_idx"));
 #endif
 
     Constant *feature_string = ConstantDataArray::getString(jl_LLVMContext, jl_options.cpu_target);
@@ -1102,6 +1027,16 @@ static void jl_gen_llvm_globaldata(llvm::Module *mod, ValueToValueMapTy &VMap,
                                  feature_string,
                                  "jl_sysimg_cpu_target"));
 
+    // reflect the address of the jl_RTLD_DEFAULT_handle variable
+    // back to the caller, so that we can check for consistency issues
+    GlobalValue *jlRTLD_DEFAULT_var = mod->getNamedValue("jl_RTLD_DEFAULT_handle");
+    addComdat(new GlobalVariable(*mod,
+                                 jlRTLD_DEFAULT_var->getType(),
+                                 true,
+                                 GlobalVariable::ExternalLinkage,
+                                 jlRTLD_DEFAULT_var,
+                                 "jl_RTLD_DEFAULT_handle_pointer"));
+
 #ifdef HAVE_CPUID
     // For native also store the cpuid
     if (strcmp(jl_options.cpu_target,"native") == 0) {
@@ -1120,9 +1055,9 @@ static void jl_gen_llvm_globaldata(llvm::Module *mod, ValueToValueMapTy &VMap,
     if (sysimg_data) {
         Constant *data = ConstantDataArray::get(jl_LLVMContext,
             ArrayRef<uint8_t>((const unsigned char*)sysimg_data, sysimg_len));
-        addComdat(new GlobalVariable(*mod, data->getType(), true,
+        addComdat(new GlobalVariable(*mod, data->getType(), false,
                                      GlobalVariable::ExternalLinkage,
-                                     data, "jl_system_image_data"));
+                                     data, "jl_system_image_data"))->setAlignment(64);
         Constant *len = ConstantInt::get(T_size, sysimg_len);
         addComdat(new GlobalVariable(*mod, len->getType(), true,
                                      GlobalVariable::ExternalLinkage,
@@ -1133,33 +1068,21 @@ static void jl_gen_llvm_globaldata(llvm::Module *mod, ValueToValueMapTy &VMap,
 // takes the running content that has collected in the shadow module and dump it to disk
 // this builds the object file portion of the sysimage files for fast startup
 extern "C"
-void jl_dump_native(const char *bc_fname, const char *obj_fname, const char *sysimg_data, size_t sysimg_len)
+void jl_dump_native(const char *bc_fname, const char *unopt_bc_fname, const char *obj_fname, const char *sysimg_data, size_t sysimg_len)
 {
     JL_TIMING(NATIVE_DUMP);
-    assert(imaging_mode);
     // We don't want to use MCJIT's target machine because
     // it uses the large code model and we may potentially
     // want less optimizations there.
     Triple TheTriple = Triple(jl_TargetMachine->getTargetTriple());
     // make sure to emit the native object format, even if FORCE_ELF was set in codegen
 #if defined(_OS_WINDOWS_)
-#if JL_LLVM_VERSION >= 30500
     TheTriple.setObjectFormat(Triple::COFF);
-#else
-    TheTriple.setEnvironment(Triple::UnknownEnvironment);
-#endif
 #elif defined(_OS_DARWIN_)
-#if JL_LLVM_VERSION >= 30500
     TheTriple.setObjectFormat(Triple::MachO);
-#else
-    TheTriple.setEnvironment(Triple::MachO);
-#endif
+    TheTriple.setOS(llvm::Triple::MacOSX);
 #endif
-#if JL_LLVM_VERSION >= 30500
     std::unique_ptr<TargetMachine>
-#else
-    OwningPtr<TargetMachine>
-#endif
     TM(jl_TargetMachine->getTarget().createTargetMachine(
         TheTriple.getTriple(),
         jl_TargetMachine->getTargetCPU(),
@@ -1167,52 +1090,41 @@ void jl_dump_native(const char *bc_fname, const char *obj_fname, const char *sys
         jl_TargetMachine->Options,
 #if defined(_OS_LINUX_) || defined(_OS_FREEBSD_)
         Reloc::PIC_,
-#elif JL_LLVM_VERSION >= 30900
-        Optional<Reloc::Model>(),
 #else
-        Reloc::Default,
+        Optional<Reloc::Model>(),
 #endif
-        CodeModel::Default,
+        // Use small model so that we can use signed 32bits offset in the function and GV tables
+        CodeModel::Small,
         CodeGenOpt::Aggressive // -O3 TODO: respect command -O0 flag?
         ));
 
-#if JL_LLVM_VERSION >= 30700
     legacy::PassManager PM;
-#else
-    PassManager PM;
-#endif
-#if JL_LLVM_VERSION < 30700
-    PM.add(new TargetLibraryInfo(Triple(TM->getTargetTriple())));
-#else
     PM.add(new TargetLibraryInfoWrapperPass(Triple(TM->getTargetTriple())));
-#endif
-
 
     // set up optimization passes
-#if JL_LLVM_VERSION >= 30700
-    // No DataLayout pass needed anymore.
-#elif JL_LLVM_VERSION >= 30600
-    PM.add(new DataLayoutPass());
-#elif JL_LLVM_VERSION >= 30500
-    PM.add(new DataLayoutPass(*jl_ExecutionEngine->getDataLayout()));
-#else
-    PM.add(new DataLayout(*jl_ExecutionEngine->getDataLayout()));
-#endif
-
-    addOptimizationPasses(&PM);
-
+    std::unique_ptr<raw_fd_ostream> unopt_bc_OS;
     std::unique_ptr<raw_fd_ostream> bc_OS;
     std::unique_ptr<raw_fd_ostream> obj_OS;
-#if JL_LLVM_VERSION >= 30700 // 3.7 simplified formatted output; just use the raw stream alone
-    std::unique_ptr<raw_fd_ostream> &bc_FOS = bc_OS;
-    std::unique_ptr<raw_fd_ostream> &obj_FOS = obj_OS;
-#else
-    std::unique_ptr<formatted_raw_ostream> bc_FOS;
-    std::unique_ptr<formatted_raw_ostream> obj_FOS;
-#endif
+
+    if (unopt_bc_fname) {
+        // call output handler directly to avoid special case handling of `-` filename
+        int FD;
+        std::error_code EC = sys::fs::openFileForWrite(unopt_bc_fname, FD, sys::fs::F_None);
+        unopt_bc_OS.reset(new raw_fd_ostream(FD, true));
+        std::string err;
+        if (EC)
+            err = "ERROR: failed to open --output-unopt-bc file '" + std::string(unopt_bc_fname) + "': " + EC.message();
+        if (!err.empty())
+            jl_safe_printf("%s\n", err.c_str());
+        else {
+            PM.add(createBitcodeWriterPass(*unopt_bc_OS.get()));
+        }
+    }
+
+    if (bc_fname || obj_fname)
+        addOptimizationPasses(&PM, jl_options.opt_level);
 
     if (bc_fname) {
-#if JL_LLVM_VERSION >= 30500
         // call output handler directly to avoid special case handling of `-` filename
         int FD;
         std::error_code EC = sys::fs::openFileForWrite(bc_fname, FD, sys::fs::F_None);
@@ -1220,22 +1132,14 @@ void jl_dump_native(const char *bc_fname, const char *obj_fname, const char *sys
         std::string err;
         if (EC)
             err = "ERROR: failed to open --output-bc file '" + std::string(bc_fname) + "': " + EC.message();
-#else
-        std::string err;
-        bc_OS.reset(new raw_fd_ostream(bc_fname, err, raw_fd_ostream::F_Binary));
-#endif
         if (!err.empty())
             jl_safe_printf("%s\n", err.c_str());
         else {
-#if JL_LLVM_VERSION < 30700
-            bc_FOS.reset(new formatted_raw_ostream(*bc_OS.get()));
-#endif
-            PM.add(createBitcodeWriterPass(*bc_FOS.get()));     // Unroll small loops
+            PM.add(createBitcodeWriterPass(*bc_OS.get()));
         }
     }
 
     if (obj_fname) {
-#if JL_LLVM_VERSION >= 30500
         // call output handler directly to avoid special case handling of `-` filename
         int FD;
         std::error_code EC = sys::fs::openFileForWrite(obj_fname, FD, sys::fs::F_None);
@@ -1243,60 +1147,41 @@ void jl_dump_native(const char *bc_fname, const char *obj_fname, const char *sys
         std::string err;
         if (EC)
             err = "ERROR: failed to open --output-o file '" + std::string(obj_fname) + "': " + EC.message();
-#else
-        std::string err;
-        obj_OS.reset(new raw_fd_ostream(obj_fname, err, raw_fd_ostream::F_Binary));
-#endif
         if (!err.empty())
             jl_safe_printf("%s\n", err.c_str());
         else {
-#if JL_LLVM_VERSION < 30700
-            obj_FOS.reset(new formatted_raw_ostream(*obj_OS.get()));
-#endif
-            if (TM->addPassesToEmitFile(PM, *obj_FOS.get(), TargetMachine::CGFT_ObjectFile, false)) {
+            if (TM->addPassesToEmitFile(PM, *obj_OS.get(), TargetMachine::CGFT_ObjectFile, false)) {
                 jl_safe_printf("ERROR: target does not support generation of object files\n");
             }
         }
     }
 
-    ValueToValueMapTy VMap;
-#if defined(USE_MCJIT) || defined(USE_ORCJIT)
-    // now copy the module (if using the old JIT), since PM.run may modify it
-    Module *clone = shadow_output;
-#else
-    Module *clone = CloneModule(shadow_output, VMap);
-#endif
-
-#if JL_LLVM_VERSION >= 30700
     // Reset the target triple to make sure it matches the new target machine
-    clone->setTargetTriple(TM->getTargetTriple().str());
-#if JL_LLVM_VERSION >= 30800
-    clone->setDataLayout(TM->createDataLayout());
+    shadow_output->setTargetTriple(TM->getTargetTriple().str());
+#if JL_LLVM_VERSION >= 40000
+    DataLayout DL = TM->createDataLayout();
+    DL.reset(DL.getStringRepresentation() + "-ni:10:11:12");
+    shadow_output->setDataLayout(DL);
 #else
-    clone->setDataLayout(TM->getDataLayout()->getStringRepresentation());
-#endif
+    shadow_output->setDataLayout(TM->createDataLayout());
 #endif
 
     // add metadata information
-    jl_gen_llvm_globaldata(clone, VMap, sysimg_data, sysimg_len);
+    if (imaging_mode)
+        jl_gen_llvm_globaldata(shadow_output, sysimg_data, sysimg_len);
 
     // do the actual work
-    PM.run(*clone);
-#if !defined(USE_MCJIT) && !defined(USE_ORCJIT)
-    delete clone;
-#endif
+    PM.run(*shadow_output);
     imaging_mode = false;
 }
 
-extern "C" int32_t jl_assign_functionID(void *function)
+extern "C" int32_t jl_assign_functionID(const char *fname)
 {
     // give the function an index in the constant lookup table
     assert(imaging_mode);
-    if (function == NULL)
+    if (fname == NULL)
         return 0;
-    jl_sysimg_fvars.push_back(ConstantExpr::getBitCast(
-                shadow_output->getNamedValue(((Function*)function)->getName()),
-                T_pvoidfunc));
+    jl_sysimg_fvars.push_back(shadow_output->getNamedValue(fname));
     return jl_sysimg_fvars.size();
 }
 
@@ -1317,7 +1202,7 @@ GlobalVariable *jl_get_global_for(const char *cname, void *addr, Module *M)
     // 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 prepare_global((llvm::GlobalVariable*)it->second.gv, M);
+        return prepare_global_in(M, (llvm::GlobalVariable*)it->second.gv);
 
     std::stringstream gvname;
     gvname << cname << globalUnique++;
@@ -1328,3 +1213,34 @@ GlobalVariable *jl_get_global_for(const char *cname, void *addr, Module *M)
     *(void**)jl_emit_and_add_to_shadow(gv, addr) = addr;
     return gv;
 }
+
+// An LLVM module pass that just runs all julia passes in order. Useful for
+// debugging
+extern "C" void jl_init_codegen(void);
+template <int OptLevel>
+class JuliaPipeline : public Pass {
+public:
+    static char ID;
+    // A bit of a hack, but works
+    struct TPMAdapter : public PassManagerBase {
+        PMTopLevelManager *TPM;
+        TPMAdapter(PMTopLevelManager *TPM) : TPM(TPM) {}
+        void add(Pass *P) { TPM->schedulePass(P); }
+    };
+    void preparePassManager(PMStack &Stack) override {
+        (void)jl_init_llvm();
+        PMTopLevelManager *TPM = Stack.top()->getTopLevelManager();
+        TPMAdapter Adapter(TPM);
+        addOptimizationPasses(&Adapter, OptLevel);
+    }
+    JuliaPipeline() : Pass(PT_PassManager, ID) {}
+    Pass *createPrinterPass(raw_ostream &O, const std::string &Banner) const override {
+        return createPrintModulePass(O, Banner);
+    }
+};
+template<> char JuliaPipeline<0>::ID = 0;
+template<> char JuliaPipeline<2>::ID = 0;
+template<> char JuliaPipeline<3>::ID = 0;
+static RegisterPass<JuliaPipeline<0>> X("juliaO0", "Runs the entire julia pipeline (at -O0)", false, false);
+static RegisterPass<JuliaPipeline<2>> Y("julia", "Runs the entire julia pipeline (at -O2)", false, false);
+static RegisterPass<JuliaPipeline<3>> Z("juliaO3", "Runs the entire julia pipeline (at -O3)", false, false);
diff --git a/src/jitlayers.h b/src/jitlayers.h
index 5c1c3d8a51f4fd..ee13e49f2cb6ea 100644
--- a/src/jitlayers.h
+++ b/src/jitlayers.h
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include <llvm/IR/LLVMContext.h>
 #include <llvm/IR/Constants.h>
@@ -6,36 +6,22 @@
 #include <llvm/IR/Value.h>
 
 #include <llvm/ExecutionEngine/SectionMemoryManager.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/ADT/DenseMapInfo.h>
-#include <llvm/Object/ObjectFile.h>
+#if JL_LLVM_VERSION >= 50000
+#  include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"
 #else
-#include <llvm/ExecutionEngine/JIT.h>
-#include <llvm/ExecutionEngine/JITMemoryManager.h>
-#include <llvm/ExecutionEngine/Interpreter.h>
-#include <llvm/ExecutionEngine/ExecutionEngine.h>
-#include <llvm/ExecutionEngine/JITEventListener.h>
+#  include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h"
 #endif
+#include "llvm/ExecutionEngine/ObjectMemoryBuffer.h"
 
-#if JL_LLVM_VERSION >= 30700
 #include "llvm/IR/LegacyPassManager.h"
 extern legacy::PassManager *jl_globalPM;
-#else
-#include <llvm/PassManager.h>
-extern PassManager *jl_globalPM;
-#endif
 
-#if JL_LLVM_VERSION >= 30500
 #include <llvm/Target/TargetMachine.h>
-#endif
+#include "fix_llvm_assert.h"
 
 extern "C" {
     extern int globalUnique;
@@ -50,24 +36,21 @@ extern Function *juliapersonality_func;
 
 #ifdef JULIA_ENABLE_THREADING
 extern size_t jltls_states_func_idx;
+extern size_t jltls_offset_idx;
 #endif
 
 typedef struct {Value *gv; int32_t index;} jl_value_llvm; // uses 1-based indexing
 
-#if JL_LLVM_VERSION >= 30700
-void addOptimizationPasses(legacy::PassManager *PM);
-#else
-void addOptimizationPasses(PassManager *PM);
-#endif
+void addOptimizationPasses(legacy::PassManagerBase *PM, int opt_level);
 void* jl_emit_and_add_to_shadow(GlobalVariable *gv, void *gvarinit = NULL);
 GlobalVariable *jl_emit_sysimg_slot(Module *m, Type *typ, const char *name,
-                                           uintptr_t init, size_t &idx);
-void* jl_get_global(GlobalVariable *gv);
+                                    uintptr_t init, size_t &idx);
+void* jl_get_globalvar(GlobalVariable *gv);
 GlobalVariable *jl_get_global_for(const char *cname, void *addr, Module *M);
 void jl_add_to_shadow(Module *m);
 void jl_init_function(Function *f);
-bool jl_can_finalize_function(Function *F);
-void jl_finalize_function(Function *F);
+bool jl_can_finalize_function(StringRef F);
+void jl_finalize_function(StringRef F);
 void jl_finalize_module(Module *m, bool shadow);
 
 // Connect Modules via prototypes, each owned by module `M`
@@ -78,55 +61,15 @@ static inline GlobalVariable *global_proto(GlobalVariable *G, Module *M = NULL)
             G->isConstant(), GlobalVariable::ExternalLinkage,
             NULL, G->getName(),  G->getThreadLocalMode());
     proto->copyAttributesFrom(G);
-#if JL_LLVM_VERSION >= 30500
     // DLLImport only needs to be set for the shadow module
     // it just gets annoying in the JIT
     proto->setDLLStorageClass(GlobalValue::DefaultStorageClass);
-#endif
     if (M)
         M->getGlobalList().push_back(proto);
     return proto;
 }
 
-static inline Function *function_proto(Function *F, Module *M = NULL)
-{
-    // Copy the declaration characteristics of the Function (not the body)
-    Function *NewF = Function::Create(F->getFunctionType(),
-                                      Function::ExternalLinkage,
-                                      F->getName(), M);
-
-    // Declarations are not allowed to have personality routines, but
-    // copyAttributesFrom sets them anyway. Temporarily unset the personality
-    // routine from `F`, since copying it and then resetting is more expensive
-    // as well as introducing an extra use from this unowned function, which
-    // can cause crashes in the LLVMContext's global destructor.
-#if JL_LLVM_VERSION >= 30700
-    llvm::Constant *OldPersonalityFn = nullptr;
-    if (F->hasPersonalityFn()) {
-        OldPersonalityFn = F->getPersonalityFn();
-        F->setPersonalityFn(nullptr);
-    }
-#endif
-
-     // 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);
-
-#if JL_LLVM_VERSION >= 30700
-    if (OldPersonalityFn)
-        F->setPersonalityFn(OldPersonalityFn);
-#endif
-
-#if JL_LLVM_VERSION >= 30500
-    // DLLImport only needs to be set for the shadow module
-    // it just gets annoying in the JIT
-    NewF->setDLLStorageClass(GlobalValue::DefaultStorageClass);
-#endif
-
-    return NewF;
-}
-
-static inline GlobalVariable *prepare_global(GlobalVariable *G, Module *M)
+static inline GlobalVariable *prepare_global_in(Module *M, GlobalVariable *G)
 {
     if (G->getParent() == M)
         return G;
@@ -137,15 +80,9 @@ static inline GlobalVariable *prepare_global(GlobalVariable *G, Module *M)
     return cast<GlobalVariable>(local);
 }
 
-#if JL_LLVM_VERSION >= 30500
 void add_named_global(GlobalObject *gv, void *addr, bool dllimport);
 template<typename T>
 static inline void add_named_global(GlobalObject *gv, T *addr, bool dllimport = true)
-#else
-void add_named_global(GlobalValue *gv, void *addr, bool dllimport);
-template<typename T>
-static inline void add_named_global(GlobalValue *gv, T *addr, bool dllimport = true)
-#endif
 {
     // cast through integer to avoid c++ pedantic warning about casting between
     // data and code pointers
@@ -153,7 +90,6 @@ static inline void add_named_global(GlobalValue *gv, T *addr, bool dllimport = t
 }
 
 void jl_init_jit(Type *T_pjlvalue_);
-#ifdef USE_ORCJIT
 #if JL_LLVM_VERSION >= 40000
 typedef JITSymbol JL_JITSymbol;
 // The type that is similar to SymbolInfo on LLVM 4.0 is actually
@@ -164,6 +100,14 @@ typedef JITSymbol JL_SymbolInfo;
 typedef orc::JITSymbol JL_JITSymbol;
 typedef RuntimeDyld::SymbolInfo JL_SymbolInfo;
 #endif
+#if JL_LLVM_VERSION >= 50000
+using orc::RTDyldObjectLinkingLayerBase;
+using orc::RTDyldObjectLinkingLayer;
+#else
+using RTDyldObjectLinkingLayerBase = orc::ObjectLinkingLayerBase;
+template <typename NotifyLoadedFtor>
+using RTDyldObjectLinkingLayer = orc::ObjectLinkingLayer<NotifyLoadedFtor>;
+#endif
 
 class JuliaOJIT {
     // Custom object emission notification handler for the JuliaOJIT
@@ -172,7 +116,7 @@ class JuliaOJIT {
     public:
         DebugObjectRegistrar(JuliaOJIT &JIT);
         template <typename ObjSetT, typename LoadResult>
-        void operator()(orc::ObjectLinkingLayerBase::ObjSetHandleT H, const ObjSetT &Objects,
+        void operator()(RTDyldObjectLinkingLayerBase::ObjSetHandleT H, const ObjSetT &Objects,
                         const LoadResult &LOS);
     private:
         void NotifyGDB(object::OwningBinary<object::ObjectFile> &DebugObj);
@@ -182,7 +126,7 @@ class JuliaOJIT {
     };
 
 public:
-    typedef orc::ObjectLinkingLayer<DebugObjectRegistrar> ObjLayerT;
+    typedef RTDyldObjectLinkingLayer<DebugObjectRegistrar> ObjLayerT;
     typedef orc::IRCompileLayer<ObjLayerT> CompileLayerT;
     typedef CompileLayerT::ModuleSetHandleT ModuleHandleT;
     typedef StringMap<void*> SymbolTableT;
@@ -223,17 +167,15 @@ class JuliaOJIT {
     SymbolTableT LocalSymbolTable;
 };
 extern JuliaOJIT *jl_ExecutionEngine;
-#else
-extern ExecutionEngine *jl_ExecutionEngine;
-#endif
-#if JL_LLVM_VERSION >= 30900
 JL_DLLEXPORT extern LLVMContext jl_LLVMContext;
-#else
-JL_DLLEXPORT extern LLVMContext &jl_LLVMContext;
-#endif
 
 Pass *createLowerPTLSPass(bool imaging_mode);
-Pass *createLowerGCFramePass();
+Pass *createCombineMulAddPass();
+Pass *createLateLowerGCFramePass();
+Pass *createLowerExcHandlersPass();
+Pass *createGCInvariantVerifierPass(bool Strong);
+Pass *createPropagateJuliaAddrspaces();
+Pass *createAllocOptPass();
 // Whether the Function is an llvm or julia intrinsic.
 static inline bool isIntrinsicFunction(Function *F)
 {
diff --git a/src/jl_uv.c b/src/jl_uv.c
index 6c8bbe3e90007d..c8ad59e7e4152a 100644
--- a/src/jl_uv.c
+++ b/src/jl_uv.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include "platform.h"
 
@@ -28,20 +28,6 @@
 #define write _write
 #endif
 
-#ifndef static_assert
-#  ifndef __cplusplus
-#    define static_assert(...)
-// Remove the following gcc special handling when we officially requires
-// gcc 4.7 (for c++11) and -std=gnu11
-#    ifdef __GNUC__
-#      if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
-#        undef static_assert
-#        define static_assert _Static_assert
-#      endif
-#    endif
-#  endif
-#endif
-
 #ifdef __cplusplus
 #include <cstring>
 extern "C" {
@@ -211,16 +197,18 @@ JL_DLLEXPORT void jl_close_uv(uv_handle_t *handle)
     }
 
     if (handle->type == UV_NAMED_PIPE || handle->type == UV_TCP) {
+        uv_stream_t *stream = (uv_stream_t*)handle;
 #ifdef _OS_WINDOWS_
-        if (((uv_stream_t*)handle)->stream.conn.shutdown_req) {
+        if (stream->stream.conn.shutdown_req) {
 #else
-        if (((uv_stream_t*)handle)->shutdown_req) {
+        if (stream->shutdown_req) {
 #endif
             // don't close the stream while attempting a graceful shutdown
             return;
         }
-        if (uv_is_writable((uv_stream_t*)handle)) {
+        if (uv_is_writable(stream) && stream->write_queue_size != 0) {
             // attempt graceful shutdown of writable streams to give them a chance to flush first
+            // TODO: introduce a uv_drain cb API instead of abusing uv_shutdown in this way
             uv_shutdown_t *req = (uv_shutdown_t*)malloc(sizeof(uv_shutdown_t));
             req->data = 0;
             /*
@@ -232,12 +220,12 @@ JL_DLLEXPORT void jl_close_uv(uv_handle_t *handle)
              * b) In case the stream is already closed, in which case uv_close would
              *    cause an assertion failure.
              */
-            uv_shutdown(req, (uv_stream_t*)handle, &jl_uv_shutdownCallback);
+            uv_shutdown(req, stream, &jl_uv_shutdownCallback);
             return;
         }
     }
 
-    if (!uv_is_closing((uv_handle_t*)handle)) {
+    if (!uv_is_closing(handle)) {
         // avoid double-closing the stream
         if (handle->type == UV_TTY)
             uv_tty_set_mode((uv_tty_t*)handle, UV_TTY_MODE_NORMAL);
@@ -369,7 +357,7 @@ JL_DLLEXPORT int jl_fs_write(int handle, const char *data, size_t len,
                              int64_t offset)
 {
     jl_ptls_t ptls = jl_get_ptls_states();
-    if (ptls->safe_restore)
+    if (ptls->safe_restore || ptls->tid != 0)
         return write(handle, data, len);
     uv_fs_t req;
     uv_buf_t buf[1];
@@ -419,13 +407,13 @@ JL_DLLEXPORT int jl_fs_close(int handle)
 }
 
 JL_DLLEXPORT int jl_uv_write(uv_stream_t *stream, const char *data, size_t n,
-                             uv_write_t *uvw, void *writecb)
+                             uv_write_t *uvw, uv_write_cb writecb)
 {
     uv_buf_t buf[1];
     buf[0].base = (char*)data;
     buf[0].len = n;
     JL_SIGATOMIC_BEGIN();
-    int err = uv_write(uvw,stream,buf,1,(uv_write_cb)writecb);
+    int err = uv_write(uvw, stream, buf, 1, writecb);
     JL_SIGATOMIC_END();
     return err;
 }
@@ -446,7 +434,7 @@ JL_DLLEXPORT void jl_uv_puts(uv_stream_t *stream, const char *str, size_t n)
         sizeof(((uv_stream_t*)0)->type) == sizeof(((ios_t*)0)->bm),
             "UV and ios layout mismatch");
 
-    uv_file fd = 0;
+    uv_file fd = -1;
 
     // Fallback for output during early initialisation...
     if (stream == (void*)STDOUT_FILENO || stream == (void*)STDERR_FILENO) {
@@ -457,7 +445,18 @@ JL_DLLEXPORT void jl_uv_puts(uv_stream_t *stream, const char *str, size_t n)
         fd = ((jl_uv_file_t*)stream)->file;
     }
 
-    if (fd) {
+    // Hack to make CoreIO thread-safer
+    jl_ptls_t ptls = jl_get_ptls_states();
+    if (ptls->tid != 0) {
+        if (stream == JL_STDOUT) {
+            fd = STDOUT_FILENO;
+        }
+        else if (stream == JL_STDERR) {
+            fd = STDERR_FILENO;
+        }
+    }
+
+    if (fd != -1) {
         // Write to file descriptor...
         jl_fs_write(fd, str, n, -1);
     }
@@ -826,6 +825,15 @@ JL_DLLEXPORT int jl_tcp_quickack(uv_tcp_t *handle, int on)
 
 #endif
 
+JL_DLLEXPORT int jl_has_so_reuseport(void)
+{
+#if defined(SO_REUSEPORT)
+    return 1;
+#else
+    return 0;
+#endif
+}
+
 JL_DLLEXPORT int jl_tcp_reuseport(uv_tcp_t *handle)
 {
 #if defined(SO_REUSEPORT)
@@ -836,7 +844,7 @@ JL_DLLEXPORT int jl_tcp_reuseport(uv_tcp_t *handle)
     }
     return 0;
 #else
-    return 1;
+    return -1;
 #endif
 }
 
@@ -944,15 +952,15 @@ void jl_work_notifier(uv_work_t *req, int status)
     free(baton);
 }
 
-JL_DLLEXPORT int jl_queue_work(void *work_func, void *work_args, void *work_retval,
-                               void *notify_func, int notify_idx)
+JL_DLLEXPORT int jl_queue_work(work_cb_t work_func, void *work_args, void *work_retval,
+                               notify_cb_t 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_func = work_func;
     baton->work_args = work_args;
     baton->work_retval = work_retval;
-    baton->notify_func = (notify_cb_t)notify_func;
+    baton->notify_func = notify_func;
     baton->notify_idx = notify_idx;
 
     uv_queue_work(jl_io_loop, &baton->req, jl_work_wrapper, jl_work_notifier);
diff --git a/src/jlapi.c b/src/jlapi.c
index 9e68c744e29a12..be3e74be8b5781 100644
--- a/src/jlapi.c
+++ b/src/jlapi.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 /*
   jlapi.c
@@ -12,6 +12,7 @@
 #include <string.h>
 #include <assert.h>
 #include "julia.h"
+#include "options.h"
 
 #ifdef __cplusplus
 #include <cfenv>
@@ -42,13 +43,25 @@ JL_DLLEXPORT void jl_init_with_image(const char *julia_home_dir,
     jl_options.julia_home = julia_home_dir;
     if (image_relative_path != NULL)
         jl_options.image_file = image_relative_path;
+    else
+        jl_options.image_file = jl_get_default_sysimg_path();
     julia_init(JL_IMAGE_JULIA_HOME);
     jl_exception_clear();
 }
 
-JL_DLLEXPORT void jl_init(const char *julia_home_dir)
+JL_DLLEXPORT void jl_init(void)
 {
-    jl_init_with_image(julia_home_dir, NULL);
+    char *libjldir = NULL;
+
+    void *hdl = (void*)jl_load_dynamic_library_e(NULL, JL_RTLD_DEFAULT);
+    if (hdl)
+        libjldir = dirname((char*)jl_pathname_for_handle(hdl));
+    if (libjldir)
+        jl_init_with_image(libjldir, jl_get_default_sysimg_path());
+    else {
+        printf("jl_init unable to find libjulia!\n");
+        abort();
+    }
 }
 
 JL_DLLEXPORT jl_value_t *jl_eval_string(const char *str)
@@ -61,13 +74,12 @@ JL_DLLEXPORT jl_value_t *jl_eval_string(const char *str)
         JL_GC_PUSH1(&ast);
         size_t last_age = jl_get_ptls_states()->world_age;
         jl_get_ptls_states()->world_age = jl_get_world_counter();
-        r = jl_toplevel_eval(ast);
+        r = jl_toplevel_eval_in(jl_main_module, ast);
         jl_get_ptls_states()->world_age = last_age;
         JL_GC_POP();
         jl_exception_clear();
     }
     JL_CATCH {
-        //jl_show(jl_stderr_obj(), jl_exception_in_transit);
         r = NULL;
     }
     return r;
diff --git a/src/jlfrontend.scm b/src/jlfrontend.scm
index 5c973bacd83f05..a556310a881d0e 100644
--- a/src/jlfrontend.scm
+++ b/src/jlfrontend.scm
@@ -50,6 +50,7 @@
                            (cdr e))))
               tab)))
 
+;; find variables that should be forced to be global in a toplevel expr
 (define (find-possible-globals e)
   (table.keys (find-possible-globals- e (table))))
 
@@ -59,19 +60,6 @@
 (define (some-gensym? x)
   (or (gensym? x) (memq x *gensyms*)))
 
-;; find variables that should be forced to be global in a toplevel expr
-(define (toplevel-expr-globals e)
-  (diff
-   (delete-duplicates
-    (append
-     ;; vars assigned at the outer level
-     (filter (lambda (x) (not (some-gensym? x))) (find-assigned-vars e '()))
-     ;; vars declared const or global outside any scope block
-     (find-decls 'const e)
-     (find-decls 'global e)
-     ;; vars assigned anywhere, if they have been defined as global
-     (filter defined-julia-global (find-possible-globals 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
@@ -81,11 +69,22 @@
     (if (and (pair? ex0) (eq? (car ex0) 'toplevel))
         ex0
         (let* ((ex (julia-expand0 ex0))
-               (gv (toplevel-expr-globals ex))
+               (lv (find-decls 'local ex))
+               (gv (diff (delete-duplicates
+                           (append (find-decls 'const ex) ;; convert vars declared const outside any scope block to outer-globals
+                                   (find-decls 'global ex) ;; convert vars declared global outside any scope block to outer-globals
+                                   ;; vars assigned at the outer level
+                                   (filter (lambda (x) (not (some-gensym? x)))
+                                           (find-assigned-vars ex '()))))
+                         lv))
+               ;; vars assigned anywhere, if they have not been explicitly defined
+               (existing-gv (filter (lambda (x) (and (not (or (memq x lv) (memq x gv))) (defined-julia-global x)))
+                                    (find-possible-globals ex)))
                (th (julia-expand1
                     `(lambda () ()
                              (scope-block
-                              (block ,@(map (lambda (v) `(implicit-global ,v)) gv)
+                              (block ,@(map (lambda (v) `(implicit-global ,v)) existing-gv)
+                                     ,@(map (lambda (v) `(implicit-global ,v)) gv)
                                      ,ex))))))
           (if (and (null? (cdadr (caddr th)))
                    (= 0 (cadddr (caddr th))))
@@ -120,19 +119,23 @@
 ;; called by jl_eval_module_expr
 (define (module-default-defs e)
   (jl-expand-to-thunk
-   (let ((name (caddr e))
-         (body (cadddr e)))
-     (let ((loc (cadr body)))
-       `(block
-         ,(let ((x (if (eq? name 'x) 'y 'x)))
-            `(= (call eval ,x)
-                (block
-                 ,loc
-                 (call (core eval) ,name ,x))))
-         (= (call eval m x)
-            (block
-             ,loc
-             (call (core eval) m x))))))))
+   (let* ((name (caddr e))
+          (body (cadddr e))
+          (loc (cadr body))
+          (x (if (eq? name 'x) 'y 'x)))
+     `(block
+       (= (call eval ,x)
+          (block
+           ,loc
+           (call (core eval) ,name ,x)))
+       (= (call eval m ,x)
+          (block
+           ,loc
+           (call (core eval) m ,x)))
+       (= (call include ,x)
+          (block
+           ,loc
+           (call (top include) ,name ,x)))))))
 
 ;; parse only, returning end position, no expansion.
 (define (jl-parse-one-string s pos0 greedy)
@@ -222,6 +225,11 @@
   (parser-wrap (lambda ()
                  (julia-expand-macros expr))))
 
+(define (jl-macroexpand-1 expr)
+  (reset-gensyms)
+  (parser-wrap (lambda ()
+                 (julia-expand-macros expr 1))))
+
 ; run whole frontend on a string. useful for testing.
 (define (fe str)
   (expand-toplevel-expr (julia-parse str)))
diff --git a/src/jloptions.c b/src/jloptions.c
index f87964aa5865f6..61698c7c38e3dc 100644
--- a/src/jloptions.c
+++ b/src/jloptions.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include <limits.h>
 
@@ -20,7 +20,7 @@ char *shlib_ext = ".so";
 #endif
 
 static char system_image_path[256] = "\0" JL_SYSTEM_IMAGE_PATH;
-static const char *get_default_sysimg_path(void)
+JL_DLLEXPORT const char *jl_get_default_sysimg_path(void)
 {
 #ifdef CPUID_SPECIFIC_BINARIES
     char *path = &system_image_path[1];
@@ -62,11 +62,13 @@ jl_options_t jl_options = { 0,    // quiet
                             JL_OPTIONS_POLLY_ON, // polly
                             JL_OPTIONS_FAST_MATH_DEFAULT,
                             0,    // worker
+                            NULL, // cookie
                             JL_OPTIONS_HANDLE_SIGNALS_ON,
                             JL_OPTIONS_USE_PRECOMPILED_YES,
                             JL_OPTIONS_USE_COMPILECACHE_YES,
                             NULL, // bind-to
                             NULL, // output-bc
+                            NULL, // output-unopt-bc
                             NULL, // output-o
                             NULL, // output-ji
                             0, // incremental
@@ -125,6 +127,11 @@ static const char opts[]  =
     // compiler output options
     " --output-o name           Generate an object file (including system image data)\n"
     " --output-ji name          Generate a system image data file (.ji)\n"
+// These are for compiler debugging purposes only and should not be otherwise
+// used, so don't show them here. See the devdocs for tips on using these
+// options for debugging the compiler.
+//  " --output-unopt-bc name    Generate unoptimized LLVM bitcode (.bc)\n"
+//  " --output-jit-bc name      Dump all IR generated by the frontend (not including system image)\n"
     " --output-bc name          Generate LLVM bitcode (.bc)\n"
     " --output-incremental=no   Generate an incremental output file (rather than complete)\n\n"
 
@@ -145,6 +152,8 @@ JL_DLLEXPORT void jl_parse_opts(int *argcp, char ***argvp)
            opt_code_coverage,
            opt_track_allocation,
            opt_check_bounds,
+           opt_output_jit_bc,
+           opt_output_unopt_bc,
            opt_output_bc,
            opt_depwarn,
            opt_inline,
@@ -186,6 +195,8 @@ JL_DLLEXPORT void jl_parse_opts(int *argcp, char ***argvp)
         { "optimize",        optional_argument, 0, 'O' },
         { "check-bounds",    required_argument, 0, opt_check_bounds },
         { "output-bc",       required_argument, 0, opt_output_bc },
+        { "output-unopt-bc", required_argument, 0, opt_output_unopt_bc },
+        { "output-jit-bc",   required_argument, 0, opt_output_jit_bc },
         { "output-o",        required_argument, 0, opt_output_o },
         { "output-ji",       required_argument, 0, opt_output_ji },
         { "output-incremental",required_argument, 0, opt_incremental },
@@ -195,7 +206,7 @@ JL_DLLEXPORT void jl_parse_opts(int *argcp, char ***argvp)
         { "math-mode",       required_argument, 0, opt_math_mode },
         { "handle-signals",  required_argument, 0, opt_handle_signals },
         // hidden command line options
-        { "worker",          required_argument, 0, opt_worker },
+        { "worker",          optional_argument, 0, opt_worker },
         { "bind-to",         required_argument, 0, opt_bind_to },
         { "lisp",            no_argument,       0, 1 },
         { 0, 0, 0, 0 }
@@ -203,7 +214,7 @@ JL_DLLEXPORT void jl_parse_opts(int *argcp, char ***argvp)
 
     // If CPUID specific binaries are enabled, this varies between runs, so initialize
     // it here, rather than as part of the static initialization above.
-    jl_options.image_file = get_default_sysimg_path();
+    jl_options.image_file = jl_get_default_sysimg_path();
 
     int codecov  = JL_LOG_NONE;
     int malloclog= JL_LOG_NONE;
@@ -434,6 +445,13 @@ JL_DLLEXPORT void jl_parse_opts(int *argcp, char ***argvp)
             jl_options.outputbc = optarg;
             if (!jl_options.image_file_specified) jl_options.image_file = NULL;
             break;
+        case opt_output_jit_bc:
+            jl_options.outputjitbc = optarg;
+            break;
+        case opt_output_unopt_bc:
+            jl_options.outputunoptbc = optarg;
+            if (!jl_options.image_file_specified) jl_options.image_file = NULL;
+            break;
         case opt_output_o:
             jl_options.outputo = optarg;
             if (!jl_options.image_file_specified) jl_options.image_file = NULL;
@@ -489,7 +507,8 @@ JL_DLLEXPORT void jl_parse_opts(int *argcp, char ***argvp)
                 jl_errorf("julia: invalid argument to --math-mode (%s)", optarg);
             break;
         case opt_worker:
-            jl_options.worker = strdup(optarg);
+            jl_options.worker = 1;
+            if (optarg != NULL) jl_options.cookie = strdup(optarg);
             break;
         case opt_bind_to:
             jl_options.bindto = strdup(optarg);
@@ -532,3 +551,8 @@ JL_DLLEXPORT void jl_set_ARGS(int argc, char **argv)
         }
     }
 }
+
+JL_DLLEXPORT ssize_t jl_sizeof_jl_options(void)
+{
+    return sizeof(jl_options_t);
+}
diff --git a/src/jltypes.c b/src/jltypes.c
index 2d022272e221aa..27527e73b70322 100644
--- a/src/jltypes.c
+++ b/src/jltypes.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 /*
   Types
@@ -45,7 +45,7 @@ jl_datatype_t *jl_datatype_type;
 jl_datatype_t *jl_function_type;
 jl_datatype_t *jl_builtin_type;
 
-jl_datatype_t *jl_bottomtype_type;
+jl_datatype_t *jl_typeofbottom_type;
 jl_value_t *jl_bottom_type;
 jl_unionall_t *jl_abstractarray_type;
 jl_unionall_t *jl_densearray_type;
@@ -121,7 +121,6 @@ jl_value_t *jl_segv_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;
@@ -146,7 +145,6 @@ static int typeenv_has(jl_typeenv_t *env, jl_tvar_t *v)
 static int has_free_typevars(jl_value_t *v, jl_typeenv_t *env)
 {
     if (jl_typeis(v, jl_tvar_type)) {
-        if (v == jl_ANY_flag) return 0;
         return !typeenv_has(env, (jl_tvar_t*)v);
     }
     if (jl_is_uniontype(v))
@@ -178,6 +176,41 @@ JL_DLLEXPORT int jl_has_free_typevars(jl_value_t *v)
     return has_free_typevars(v, NULL);
 }
 
+static void find_free_typevars(jl_value_t *v, jl_typeenv_t *env, jl_array_t *out)
+{
+    if (jl_typeis(v, jl_tvar_type)) {
+        if (!typeenv_has(env, (jl_tvar_t*)v))
+            jl_array_ptr_1d_push(out, v);
+    }
+    else if (jl_is_uniontype(v)) {
+        find_free_typevars(((jl_uniontype_t*)v)->a, env, out);
+        find_free_typevars(((jl_uniontype_t*)v)->b, env, out);
+    }
+    else if (jl_is_unionall(v)) {
+        jl_unionall_t *ua = (jl_unionall_t*)v;
+        jl_typeenv_t newenv = { ua->var, NULL, env };
+        find_free_typevars(ua->var->lb, env, out);
+        find_free_typevars(ua->var->ub, env, out);
+        find_free_typevars(ua->body, &newenv, out);
+    }
+    else if (jl_is_datatype(v)) {
+        if (!((jl_datatype_t*)v)->hasfreetypevars)
+            return;
+        size_t i;
+        for (i=0; i < jl_nparams(v); i++)
+            find_free_typevars(jl_tparam(v,i), env, out);
+    }
+}
+
+JL_DLLEXPORT jl_array_t *jl_find_free_typevars(jl_value_t *v)
+{
+    jl_array_t *out = jl_alloc_vec_any(0);
+    JL_GC_PUSH1(&out);
+    find_free_typevars(v, NULL, out);
+    JL_GC_POP();
+    return out;
+}
+
 // test whether a type has vars bound by the given environment
 static int jl_has_bound_typevars(jl_value_t *v, jl_typeenv_t *env)
 {
@@ -202,7 +235,7 @@ static int jl_has_bound_typevars(jl_value_t *v, jl_typeenv_t *env)
         return ans;
     }
     if (jl_is_datatype(v)) {
-        if (!((jl_datatype_t*)v)->hasfreetypevars && !(env && env->var == (jl_tvar_t*)jl_ANY_flag))
+        if (!((jl_datatype_t*)v)->hasfreetypevars)
             return 0;
         size_t i;
         for (i=0; i < jl_nparams(v); i++) {
@@ -307,6 +340,35 @@ static int count_union_components(jl_value_t **types, size_t n)
     return c;
 }
 
+int jl_count_union_components(jl_value_t *v)
+{
+    if (!jl_is_uniontype(v)) return 1;
+    jl_uniontype_t *u = (jl_uniontype_t*)v;
+    return jl_count_union_components(u->a) + jl_count_union_components(u->b);
+}
+
+// Return the `*pi`th element of a nested type union, according to a
+// standard traversal order. Anything that is not itself a `Union` is
+// considered an "element". `*pi` is destroyed in the process.
+static jl_value_t *nth_union_component(jl_value_t *v, int *pi)
+{
+    if (!jl_is_uniontype(v)) {
+        if (*pi == 0)
+            return v;
+        (*pi)--;
+        return NULL;
+    }
+    jl_uniontype_t *u = (jl_uniontype_t*)v;
+    jl_value_t *a = nth_union_component(u->a, pi);
+    if (a) return a;
+    return nth_union_component(u->b, pi);
+}
+
+jl_value_t *jl_nth_union_component(jl_value_t *v, int i)
+{
+    return nth_union_component(v, &i);
+}
+
 static void flatten_type_union(jl_value_t **types, size_t n, jl_value_t **out, size_t *idx)
 {
     size_t i;
@@ -604,8 +666,6 @@ static int is_cacheable(jl_datatype_t *type)
     assert(jl_is_datatype(type));
     jl_svec_t *t = type->parameters;
     if (jl_svec_len(t) == 0) return 0;
-    if (jl_has_typevar((jl_value_t*)type, (jl_tvar_t*)jl_ANY_flag))
-        return 0;
     // cache abstract types with no free type vars
     if (jl_is_abstracttype(type))
         return !jl_has_free_typevars((jl_value_t*)type);
@@ -683,15 +743,35 @@ static int within_typevar(jl_value_t *t, jl_value_t *vlb, jl_value_t *vub)
     return jl_subtype(vlb, lb) && jl_subtype(ub, vub);
 }
 
+typedef struct _jl_typestack_t jl_typestack_t;
+
+static jl_value_t *inst_datatype(jl_datatype_t *dt, jl_svec_t *p, jl_value_t **iparams, size_t ntp,
+                                 int cacheable, jl_typestack_t *stack);
+
 jl_value_t *jl_apply_type(jl_value_t *tc, jl_value_t **params, size_t n)
 {
     if (tc == (jl_value_t*)jl_anytuple_type)
         return (jl_value_t*)jl_apply_tuple_type_v(params, n);
     if (tc == (jl_value_t*)jl_uniontype_type)
         return (jl_value_t*)jl_type_union(params, n);
+    size_t i;
+    if (n > 1) {
+        // detect common case of applying a wrapper, where we know that all parameters will
+        // end up as direct parameters of a certain datatype, which can be optimized.
+        jl_value_t *u = jl_unwrap_unionall(tc);
+        if (jl_is_datatype(u) && n == jl_nparams((jl_datatype_t*)u) &&
+            ((jl_datatype_t*)u)->name->wrapper == tc) {
+            int cacheable = 1;
+            for(i=0; i < n; i++) {
+                if (jl_has_free_typevars(params[i])) {
+                    cacheable = 0; break;
+                }
+            }
+            return inst_datatype((jl_datatype_t*)u, NULL, params, n, cacheable, NULL);
+        }
+    }
     JL_GC_PUSH1(&tc);
     jl_value_t *tc0 = tc;
-    size_t i;
     for (i=0; i < n; i++) {
         if (!jl_is_unionall(tc0))
             jl_error("too many parameters for type");
@@ -761,12 +841,8 @@ JL_DLLEXPORT jl_value_t *jl_tupletype_fill(size_t n, jl_value_t *v)
     return p;
 }
 
-typedef struct _jl_typestack_t {
-    union {
-        jl_value_t *ua;
-        jl_datatype_t *tt;
-    };
-    jl_value_t *ua_new;
+JL_EXTENSION typedef struct _jl_typestack_t {
+    jl_datatype_t *tt;
     struct _jl_typestack_t *prev;
 } jl_typestack_t;
 
@@ -934,10 +1010,9 @@ static jl_value_t *normalize_vararg(jl_value_t *va)
     return va;
 }
 
-static jl_value_t *inst_datatype(jl_datatype_t *dt, jl_svec_t *p, jl_value_t **iparams, size_t ntp,
-                                 int cacheable, jl_typestack_t *stack, jl_typeenv_t *env)
+static jl_value_t *inst_datatype_inner(jl_datatype_t *dt, jl_svec_t *p, jl_value_t **iparams, size_t ntp,
+                                       int cacheable, jl_typestack_t *stack, jl_typeenv_t *env)
 {
-    jl_ptls_t ptls = jl_get_ptls_states();
     jl_typestack_t top;
     jl_typename_t *tn = dt->name;
     int istuple = (tn == jl_tuple_typename);
@@ -993,7 +1068,9 @@ static jl_value_t *inst_datatype(jl_datatype_t *dt, jl_svec_t *p, jl_value_t **i
     JL_GC_PUSH2(&p, &ndt);
 
     jl_value_t *last = iparams[ntp - 1];
+    int isvatuple = 0;
     if (istuple && ntp > 0 && jl_is_vararg_type(last)) {
+        isvatuple = 1;
         // normalize Tuple{..., Vararg{Int, 3}} to Tuple{..., Int, Int, Int}
         jl_value_t *va = jl_unwrap_unionall(last);
         jl_value_t *va0 = jl_tparam0(va), *va1 = jl_tparam1(va);
@@ -1083,16 +1160,6 @@ static jl_value_t *inst_datatype(jl_datatype_t *dt, jl_svec_t *p, jl_value_t **i
         jl_gc_wb(ndt, ndt->super);
     }
     jl_svec_t *ftypes = dt->types;
-    if (!istuple && ndt->name->names == jl_emptysvec) {
-        assert(ftypes == NULL || ftypes == jl_emptysvec);
-        ndt->size = dt->size;
-        ndt->layout = dt->layout;
-        ndt->types = jl_emptysvec;
-        if (jl_is_datatype_make_singleton(ndt)) {
-            ndt->instance = jl_gc_alloc(ptls, 0, ndt);
-            jl_gc_wb(ndt, ndt->instance);
-        }
-    }
     if (ftypes == NULL || dt->super == NULL) {
         // in the process of creating this type definition:
         // need to instantiate the super and types fields later
@@ -1100,27 +1167,24 @@ static jl_value_t *inst_datatype(jl_datatype_t *dt, jl_svec_t *p, jl_value_t **i
         arraylist_push(&partial_inst, ndt);
     }
     else {
-        if (ftypes != jl_emptysvec) {
-            assert(!ndt->abstract);
-            if (!istuple) {
-                // recursively instantiate the types of the fields
-                ndt->types = inst_all(ftypes, env, stack, 1);
-                jl_gc_wb(ndt, ndt->types);
-            }
-            if (cacheable) {
-                jl_compute_field_offsets(ndt);
-                if (jl_is_datatype_make_singleton(ndt)) {
-                    ndt->instance = jl_gc_alloc(ptls, 0, ndt);
-                    jl_gc_wb(ndt, ndt->instance);
-                }
-            }
-        }
-        else {
-            assert(ndt->name->names == jl_emptysvec);
+        assert(ftypes != jl_emptysvec || jl_field_names(ndt) == jl_emptysvec);
+        assert(ftypes == jl_emptysvec || !ndt->abstract);
+        if (!istuple) {
+            // recursively instantiate the types of the fields
+            ndt->types = inst_all(ftypes, env, stack, 1);
+            jl_gc_wb(ndt, ndt->types);
         }
     }
+    if (jl_is_primitivetype(dt)) {
+        ndt->size = dt->size;
+        ndt->layout = dt->layout;
+    }
+    else if (cacheable && ndt->types != NULL && !ndt->abstract) {
+        jl_compute_field_offsets(ndt);
+    }
+
     if (istuple)
-        ndt->ninitialized = ntp;
+        ndt->ninitialized = ntp - isvatuple;
     else
         ndt->ninitialized = dt->ninitialized;
 
@@ -1133,6 +1197,25 @@ static jl_value_t *inst_datatype(jl_datatype_t *dt, jl_svec_t *p, jl_value_t **i
     return (jl_value_t*)ndt;
 }
 
+// Build an environment mapping a TypeName's parameters to parameter values.
+// This is the environment needed for instantiating a type's supertype and field types.
+static jl_value_t *inst_datatype_env(jl_value_t *dt, jl_svec_t *p, jl_value_t **iparams, size_t ntp,
+                                     int cacheable, jl_typestack_t *stack, jl_typeenv_t *env, int c)
+{
+    if (jl_is_datatype(dt))
+        return inst_datatype_inner((jl_datatype_t*)dt, p, iparams, ntp, cacheable, stack, env);
+    assert(jl_is_unionall(dt));
+    jl_unionall_t *ua = (jl_unionall_t*)dt;
+    jl_typeenv_t e = { ua->var, iparams[c], env };
+    return inst_datatype_env(ua->body, p, iparams, ntp, cacheable, stack, &e, c+1);
+}
+
+static jl_value_t *inst_datatype(jl_datatype_t *dt, jl_svec_t *p, jl_value_t **iparams, size_t ntp,
+                                 int cacheable, jl_typestack_t *stack)
+{
+    return inst_datatype_env(dt->name->wrapper, p, iparams, ntp, cacheable, stack, NULL, 0);
+}
+
 static jl_tupletype_t *jl_apply_tuple_type_v_(jl_value_t **p, size_t np, jl_svec_t *params)
 {
     int cacheable = 1;
@@ -1141,7 +1224,7 @@ static jl_tupletype_t *jl_apply_tuple_type_v_(jl_value_t **p, size_t np, jl_svec
             cacheable = 0;
     }
     jl_datatype_t *ndt = (jl_datatype_t*)inst_datatype(jl_anytuple_type, params, p, np,
-                                                       cacheable, NULL, NULL);
+                                                       cacheable, NULL);
     return ndt;
 }
 
@@ -1157,12 +1240,12 @@ JL_DLLEXPORT jl_tupletype_t *jl_apply_tuple_type_v(jl_value_t **p, size_t np)
 
 jl_datatype_t *jl_inst_concrete_tupletype(jl_svec_t *p)
 {
-    return (jl_datatype_t*)inst_datatype(jl_anytuple_type, p, jl_svec_data(p), jl_svec_len(p), 1, NULL, NULL);
+    return (jl_datatype_t*)inst_datatype(jl_anytuple_type, p, jl_svec_data(p), jl_svec_len(p), 1, NULL);
 }
 
 jl_datatype_t *jl_inst_concrete_tupletype_v(jl_value_t **p, size_t np)
 {
-    return (jl_datatype_t*)inst_datatype(jl_anytuple_type, NULL, p, np, 1, NULL, NULL);
+    return (jl_datatype_t*)inst_datatype(jl_anytuple_type, NULL, p, np, 1, NULL);
 }
 
 static jl_svec_t *inst_all(jl_svec_t *p, jl_typeenv_t *env, jl_typestack_t *stack, int check)
@@ -1229,8 +1312,7 @@ static jl_value_t *inst_tuple_w_(jl_value_t *t, jl_typeenv_t *env, jl_typestack_
         if (cacheable && !jl_is_concrete_type(pi))
             cacheable = 0;
     }
-    jl_value_t *result = inst_datatype((jl_datatype_t*)tt, ip_heap, iparams, ntp, cacheable,
-                                       stack, env);
+    jl_value_t *result = inst_datatype((jl_datatype_t*)tt, ip_heap, iparams, ntp, cacheable, stack);
     JL_GC_POP();
     return result;
 }
@@ -1255,33 +1337,23 @@ static jl_value_t *inst_type_w_(jl_value_t *t, jl_typeenv_t *env, jl_typestack_t
         return (jl_value_t*)t;
     }
     if (jl_is_unionall(t)) {
-        jl_typestack_t *sp = stack;
-        while (sp != NULL) {
-            if (sp->ua == t)
-                return sp->ua_new;
-            sp = sp->prev;
-        }
         if (!jl_has_free_typevars(t))
             return t;
         jl_unionall_t *ua = (jl_unionall_t*)t;
         jl_value_t *res=NULL, *lb=ua->var->lb, *ub=ua->var->ub;
         JL_GC_PUSH3(&lb, &ub, &res);
         res = jl_new_struct(jl_unionall_type, ua->var, NULL);
-        jl_typestack_t top = { {t}, res, stack };
         if (jl_has_bound_typevars(ua->var->lb, env))
-            lb = inst_type_w_(ua->var->lb, env, &top, check);
+            lb = inst_type_w_(ua->var->lb, env, stack, check);
         if (jl_has_bound_typevars(ua->var->ub, env))
-            ub = inst_type_w_(ua->var->ub, env, &top, check);
+            ub = inst_type_w_(ua->var->ub, env, stack, check);
         if (lb != ua->var->lb || ub != ua->var->ub) {
             ((jl_unionall_t*)res)->var = jl_new_typevar(ua->var->name, lb, ub);
             jl_gc_wb(res, ((jl_unionall_t*)res)->var);
         }
         jl_typeenv_t newenv = { ua->var, (jl_value_t*)((jl_unionall_t*)res)->var, env };
-        jl_value_t *newbody = inst_type_w_(ua->body, &newenv, &top, check);
-        if (newbody == ua->body) {
-            res = t;
-        }
-        else if (newbody == (jl_value_t*)jl_emptytuple_type) {
+        jl_value_t *newbody = inst_type_w_(ua->body, &newenv, stack, check);
+        if (newbody == (jl_value_t*)jl_emptytuple_type) {
             // NTuple{0} => Tuple{} can make a typevar disappear
             res = (jl_value_t*)jl_emptytuple_type;
         }
@@ -1332,8 +1404,7 @@ static jl_value_t *inst_type_w_(jl_value_t *t, jl_typeenv_t *env, jl_typestack_t
     // if t's parameters are not bound in the environment, return it uncopied (#9378)
     if (!bound) { JL_GC_POP(); return (jl_value_t*)t; }
 
-    jl_value_t *result = inst_datatype((jl_datatype_t*)tt, NULL, iparams, ntp, cacheable,
-                                       stack, env);
+    jl_value_t *result = inst_datatype((jl_datatype_t*)tt, NULL, iparams, ntp, cacheable, stack);
     JL_GC_POP();
     return result;
 }
@@ -1363,12 +1434,14 @@ static jl_value_t *_jl_instantiate_type_in_env(jl_value_t *ty, jl_unionall_t *en
 
 JL_DLLEXPORT jl_value_t *jl_instantiate_type_in_env(jl_value_t *ty, jl_unionall_t *env, jl_value_t **vals)
 {
-    jl_value_t *typ;
-    JL_TRY {
-        typ = _jl_instantiate_type_in_env(ty, env, vals, NULL);
-    }
-    JL_CATCH {
-        typ = jl_bottom_type;
+    jl_value_t *typ = ty;
+    if (jl_is_unionall(env)) {
+        JL_TRY {
+            typ = _jl_instantiate_type_in_env(ty, env, vals, NULL);
+        }
+        JL_CATCH {
+            typ = jl_bottom_type;
+        }
     }
     return typ;
 }
@@ -1395,7 +1468,6 @@ jl_value_t *jl_wrap_vararg(jl_value_t *t, jl_value_t *n)
 
 void jl_reinstantiate_inner_types(jl_datatype_t *t) // can throw!
 {
-    jl_ptls_t ptls = jl_get_ptls_states();
     inside_typedef = 0;
     assert(jl_is_datatype(t));
     jl_typestack_t top;
@@ -1423,7 +1495,7 @@ void jl_reinstantiate_inner_types(jl_datatype_t *t) // can throw!
         jl_gc_wb(ndt, ndt->super);
     }
 
-    if (t->name->names != jl_emptysvec) {
+    if (t->types != jl_emptysvec) {
         for (j = 0; j < partial_inst.len; j++) {
             jl_datatype_t *ndt = (jl_datatype_t*)partial_inst.items[j];
             for (i = 0; i < n; i++)
@@ -1438,15 +1510,11 @@ void jl_reinstantiate_inner_types(jl_datatype_t *t) // can throw!
             }
             if (ndt->uid) { // cacheable
                 jl_compute_field_offsets(ndt);
-                if (jl_is_datatype_make_singleton(ndt)) {
-                    ndt->instance = jl_gc_alloc(ptls, 0, ndt);
-                    jl_gc_wb(ndt, ndt->instance);
-                }
             }
         }
     }
     else {
-        assert(t->types == jl_emptysvec);
+        assert(jl_field_names(t) == jl_emptysvec);
     }
     partial_inst.len = 0;
 }
@@ -1470,7 +1538,8 @@ extern void jl_init_int32_int64_cache(void);
 
 void jl_init_types(void)
 {
-    jl_ptls_t ptls = jl_get_ptls_states();
+    jl_module_t *core = NULL; // will need to be assigned later
+
     arraylist_new(&partial_inst, 0);
     // create base objects
     jl_datatype_type = jl_new_uninitialized_datatype();
@@ -1480,45 +1549,44 @@ void jl_init_types(void)
     jl_symbol_type = jl_sym_type;
     jl_simplevector_type = jl_new_uninitialized_datatype();
     jl_methtable_type = jl_new_uninitialized_datatype();
-    jl_nothing = jl_gc_alloc(ptls, 0, NULL);
+    jl_nothing = jl_gc_permobj(0, NULL);
 
     jl_default_cgparams.hooks.module_setup = jl_nothing;
     jl_default_cgparams.hooks.module_activation = jl_nothing;
     jl_default_cgparams.hooks.raise_exception = jl_nothing;
 
-    jl_emptysvec = (jl_svec_t*)jl_gc_alloc(ptls, sizeof(void*),
-                                           jl_simplevector_type);
+    jl_emptysvec = (jl_svec_t*)jl_gc_permobj(sizeof(void*), jl_simplevector_type);
     jl_svec_set_len_unsafe(jl_emptysvec, 0);
 
-    jl_any_type = (jl_datatype_t*)jl_new_abstracttype((jl_value_t*)jl_symbol("Any"), NULL, jl_emptysvec);
+    jl_any_type = (jl_datatype_t*)jl_new_abstracttype((jl_value_t*)jl_symbol("Any"), core, NULL, jl_emptysvec);
     jl_any_type->super = jl_any_type;
-    jl_type_type = (jl_unionall_t*)jl_new_abstracttype((jl_value_t*)jl_symbol("Type"), jl_any_type, jl_emptysvec);
+    jl_type_type = (jl_unionall_t*)jl_new_abstracttype((jl_value_t*)jl_symbol("Type"), core, jl_any_type, jl_emptysvec);
     jl_type_typename = ((jl_datatype_t*)jl_type_type)->name;
-    jl_type_type_mt = jl_new_method_table(jl_type_typename->name, ptls->current_module);
+    jl_type_type_mt = jl_new_method_table(jl_type_typename->name, core);
     jl_type_typename->mt = jl_type_type_mt;
 
     // initialize them. lots of cycles.
-    jl_datatype_type->name = jl_new_typename(jl_symbol("DataType"));
+    jl_datatype_type->name = jl_new_typename_in(jl_symbol("DataType"), core);
     jl_datatype_type->name->wrapper = (jl_value_t*)jl_datatype_type;
     jl_datatype_type->super = (jl_datatype_t*)jl_type_type;
     jl_datatype_type->parameters = jl_emptysvec;
-    jl_datatype_type->name->names = jl_svec(16,
-                                            jl_symbol("name"),
-                                            jl_symbol("super"),
-                                            jl_symbol("parameters"),
-                                            jl_symbol("types"),
-                                            jl_symbol("instance"),
-                                            jl_symbol("layout"),
-                                            jl_symbol("size"),
-                                            jl_symbol("ninitialized"),
-                                            jl_symbol("uid"),
-                                            jl_symbol("abstract"),
-                                            jl_symbol("mutable"),
-                                            jl_symbol("llvm::StructType"),
-                                            jl_symbol("llvm::DIType"),
-                                            jl_symbol("depth"),
-                                            jl_symbol("hasfreetypevars"),
-                                            jl_symbol("isconcrete"));
+    jl_datatype_type->name->names = jl_perm_symsvec(16,
+                                                    "name",
+                                                    "super",
+                                                    "parameters",
+                                                    "types",
+                                                    "instance",
+                                                    "layout",
+                                                    "size",
+                                                    "ninitialized",
+                                                    "uid",
+                                                    "abstract",
+                                                    "mutable",
+                                                    "llvm::StructType",
+                                                    "llvm::DIType",
+                                                    "depth",
+                                                    "hasfreetypevars",
+                                                    "isconcrete");
     jl_datatype_type->types = jl_svec(16,
                                       jl_typename_type,
                                       jl_datatype_type,
@@ -1538,15 +1606,15 @@ void jl_init_types(void)
     jl_datatype_type->mutabl = 1;
     jl_datatype_type->ninitialized = 4;
 
-    jl_typename_type->name = jl_new_typename(jl_symbol("TypeName"));
+    jl_typename_type->name = jl_new_typename_in(jl_symbol("TypeName"), core);
     jl_typename_type->name->wrapper = (jl_value_t*)jl_typename_type;
-    jl_typename_type->name->mt = jl_new_method_table(jl_typename_type->name->name, ptls->current_module);
+    jl_typename_type->name->mt = jl_new_method_table(jl_typename_type->name->name, core);
     jl_typename_type->super = jl_any_type;
     jl_typename_type->parameters = jl_emptysvec;
-    jl_typename_type->name->names = jl_svec(8, jl_symbol("name"), jl_symbol("module"),
-                                            jl_symbol("names"), jl_symbol("wrapper"),
-                                            jl_symbol("cache"), jl_symbol("linearcache"),
-                                            jl_symbol("hash"), jl_symbol("mt"));
+    jl_typename_type->name->names = jl_perm_symsvec(8, "name", "module",
+                                                    "names", "wrapper",
+                                                    "cache", "linearcache",
+                                                    "hash", "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);
@@ -1558,15 +1626,15 @@ void jl_init_types(void)
     jl_typename_type->mutabl = 1;
     jl_typename_type->ninitialized = 2;
 
-    jl_methtable_type->name = jl_new_typename(jl_symbol("MethodTable"));
+    jl_methtable_type->name = jl_new_typename_in(jl_symbol("MethodTable"), core);
     jl_methtable_type->name->wrapper = (jl_value_t*)jl_methtable_type;
-    jl_methtable_type->name->mt = jl_new_method_table(jl_methtable_type->name->name, ptls->current_module);
+    jl_methtable_type->name->mt = jl_new_method_table(jl_methtable_type->name->name, core);
     jl_methtable_type->super = jl_any_type;
     jl_methtable_type->parameters = jl_emptysvec;
-    jl_methtable_type->name->names = jl_svec(9, jl_symbol("name"), jl_symbol("defs"),
-                                             jl_symbol("cache"), jl_symbol("max_args"),
-                                             jl_symbol("kwsorter"), jl_symbol("module"),
-                                             jl_symbol("backedges"), jl_symbol(""), jl_symbol(""));
+    jl_methtable_type->name->names = jl_perm_symsvec(9, "name", "defs",
+                                                     "cache", "max_args",
+                                                     "kwsorter", "module",
+                                                     "backedges", "", "");
     jl_methtable_type->types = jl_svec(9, jl_sym_type, jl_any_type, jl_any_type, jl_any_type/*jl_long*/,
                                        jl_any_type, jl_any_type/*module*/,
                                        jl_any_type/*any vector*/, jl_any_type/*long*/, jl_any_type/*int32*/);
@@ -1578,9 +1646,9 @@ void jl_init_types(void)
     jl_methtable_type->mutabl = 1;
     jl_methtable_type->ninitialized = 4;
 
-    jl_sym_type->name = jl_new_typename(jl_symbol("Symbol"));
+    jl_sym_type->name = jl_new_typename_in(jl_symbol("Symbol"), core);
     jl_sym_type->name->wrapper = (jl_value_t*)jl_sym_type;
-    jl_sym_type->name->mt = jl_new_method_table(jl_sym_type->name->name, ptls->current_module);
+    jl_sym_type->name->mt = jl_new_method_table(jl_sym_type->name->name, core);
     jl_sym_type->super = jl_any_type;
     jl_sym_type->parameters = jl_emptysvec;
     jl_sym_type->name->names = jl_emptysvec;
@@ -1594,63 +1662,62 @@ void jl_init_types(void)
     jl_sym_type->mutabl = 1;
     jl_sym_type->ninitialized = 0;
 
-    jl_simplevector_type->name = jl_new_typename(jl_symbol("SimpleVector"));
+    jl_simplevector_type->name = jl_new_typename_in(jl_symbol("SimpleVector"), core);
     jl_simplevector_type->name->wrapper = (jl_value_t*)jl_simplevector_type;
-    jl_simplevector_type->name->mt = jl_new_method_table(jl_simplevector_type->name->name, ptls->current_module);
+    jl_simplevector_type->name->mt = jl_new_method_table(jl_simplevector_type->name->name, core);
     jl_simplevector_type->super = jl_any_type;
     jl_simplevector_type->parameters = jl_emptysvec;
-    jl_simplevector_type->name->names = jl_svec(1, jl_symbol("length"));
-    jl_simplevector_type->types = jl_svec(1, jl_any_type);
+    jl_simplevector_type->name->names = jl_emptysvec;
+    jl_simplevector_type->types = jl_emptysvec;
     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->mutabl = 1;
-    jl_simplevector_type->ninitialized = 1;
+    jl_simplevector_type->ninitialized = 0;
 
     // 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_void_type = jl_new_datatype(jl_symbol("Void"), core, jl_any_type, jl_emptysvec,
                                    jl_emptysvec, jl_emptysvec, 0, 0, 0);
-    jl_set_typeof(jl_nothing, jl_void_type);
+    jl_astaggedvalue(jl_nothing)->header = ((uintptr_t)jl_void_type) | GC_OLD_MARKED;
     jl_void_type->instance = jl_nothing;
 
     jl_datatype_t *type_type = (jl_datatype_t*)jl_type_type;
-    jl_bottomtype_type = jl_new_datatype(jl_symbol("BottomType"), type_type, jl_emptysvec,
+    jl_typeofbottom_type = jl_new_datatype(jl_symbol("TypeofBottom"), core, type_type, jl_emptysvec,
                                          jl_emptysvec, jl_emptysvec, 0, 0, 0);
-    jl_bottom_type = jl_new_struct(jl_bottomtype_type);
-    jl_bottomtype_type->instance = jl_bottom_type;
+    jl_bottom_type = jl_new_struct(jl_typeofbottom_type);
+    jl_typeofbottom_type->instance = jl_bottom_type;
 
-    jl_uniontype_type = jl_new_datatype(jl_symbol("Union"), type_type, jl_emptysvec,
-                                        jl_svec(2, jl_symbol("a"), jl_symbol("b")),
+    jl_uniontype_type = jl_new_datatype(jl_symbol("Union"), core, type_type, jl_emptysvec,
+                                        jl_perm_symsvec(2, "a", "b"),
                                         jl_svec(2, jl_any_type, jl_any_type),
                                         0, 0, 2);
 
-    jl_tvar_type = jl_new_datatype(jl_symbol("TypeVar"), jl_any_type, jl_emptysvec,
-                                   jl_svec(3, jl_symbol("name"),
-                                           jl_symbol("lb"), jl_symbol("ub")),
-                                   jl_svec(3, jl_sym_type,
-                                           jl_any_type, jl_any_type),
+    jl_tvar_type = jl_new_datatype(jl_symbol("TypeVar"), core, jl_any_type, jl_emptysvec,
+                                   jl_perm_symsvec(3, "name", "lb", "ub"),
+                                   jl_svec(3, jl_sym_type, jl_any_type, jl_any_type),
                                    0, 1, 3);
 
-    jl_unionall_type = jl_new_datatype(jl_symbol("UnionAll"), type_type, jl_emptysvec,
-                                       jl_svec(2, jl_symbol("var"), jl_symbol("body")),
+    jl_unionall_type = jl_new_datatype(jl_symbol("UnionAll"), core, type_type, jl_emptysvec,
+                                       jl_perm_symsvec(2, "var", "body"),
                                        jl_svec(2, jl_tvar_type, jl_any_type),
                                        0, 0, 2);
 
     vararg_sym = jl_symbol("Vararg");
     jl_svec_t *tv;
     tv = jl_svec2(tvar("T"),tvar("N"));
-    jl_vararg_type = (jl_unionall_t*)jl_new_abstracttype((jl_value_t*)vararg_sym, jl_any_type, tv)->name->wrapper;
+    jl_vararg_type = (jl_unionall_t*)jl_new_abstracttype((jl_value_t*)vararg_sym, core, jl_any_type, tv)->name->wrapper;
     jl_vararg_typename = ((jl_datatype_t*)jl_unwrap_unionall((jl_value_t*)jl_vararg_type))->name;
 
-    jl_anytuple_type = jl_new_datatype(jl_symbol("Tuple"), jl_any_type, jl_emptysvec,
+    jl_anytuple_type = jl_new_datatype(jl_symbol("Tuple"), core, jl_any_type, jl_emptysvec,
                                        jl_emptysvec, jl_emptysvec, 0, 0, 0);
     jl_tuple_typename = jl_anytuple_type->name;
     jl_anytuple_type->uid = 0;
     jl_anytuple_type->parameters = jl_svec(1, jl_wrap_vararg((jl_value_t*)jl_any_type, (jl_value_t*)NULL));
     jl_anytuple_type->types = jl_anytuple_type->parameters;
     jl_anytuple_type->layout = NULL;
+    jl_anytuple_type->instance = NULL;
     jl_anytuple_type->hasfreetypevars = 0;
     jl_anytuple_type->isconcrete = 0;
 
@@ -1660,56 +1727,58 @@ void jl_init_types(void)
     jl_type_typename->wrapper = jl_new_struct(jl_unionall_type, tttvar, (jl_value_t*)jl_type_type);
     jl_type_type = (jl_unionall_t*)jl_type_typename->wrapper;
 
+    jl_typeofbottom_type->super = jl_wrap_Type(jl_bottom_type);
+
     jl_emptytuple_type = jl_apply_tuple_type(jl_emptysvec);
     jl_emptytuple_type->uid = jl_assign_type_uid();
-    jl_emptytuple = jl_gc_alloc(ptls, 0, jl_emptytuple_type);
+    jl_emptytuple = jl_gc_permobj(0, jl_emptytuple_type);
     jl_emptytuple_type->instance = jl_emptytuple;
 
     // non-primitive definitions follow
     jl_int32_type = NULL;
-    jl_int32_type = jl_new_primitivetype((jl_value_t*)jl_symbol("Int32"),
+    jl_int32_type = jl_new_primitivetype((jl_value_t*)jl_symbol("Int32"), core,
                                          jl_any_type, jl_emptysvec, 32);
     jl_int64_type = NULL;
-    jl_int64_type = jl_new_primitivetype((jl_value_t*)jl_symbol("Int64"),
+    jl_int64_type = jl_new_primitivetype((jl_value_t*)jl_symbol("Int64"), core,
                                          jl_any_type, jl_emptysvec, 64);
 
     jl_uint8_type = NULL;
-    jl_uint8_type = jl_new_primitivetype((jl_value_t*)jl_symbol("UInt8"),
+    jl_uint8_type = jl_new_primitivetype((jl_value_t*)jl_symbol("UInt8"), core,
                                          jl_any_type, jl_emptysvec, 8);
 
-    jl_ssavalue_type = jl_new_datatype(jl_symbol("SSAValue"), jl_any_type, jl_emptysvec,
-                                       jl_svec1(jl_symbol("id")),
+    jl_ssavalue_type = jl_new_datatype(jl_symbol("SSAValue"), core, jl_any_type, jl_emptysvec,
+                                       jl_perm_symsvec(1, "id"),
                                        jl_svec1(jl_long_type), 0, 0, 1);
 
-    jl_abstractslot_type = jl_new_abstracttype((jl_value_t*)jl_symbol("Slot"), jl_any_type,
+    jl_abstractslot_type = jl_new_abstracttype((jl_value_t*)jl_symbol("Slot"), core, jl_any_type,
                                                jl_emptysvec);
 
-    jl_slotnumber_type = jl_new_datatype(jl_symbol("SlotNumber"), jl_abstractslot_type, jl_emptysvec,
-                                         jl_svec1(jl_symbol("id")),
+    jl_slotnumber_type = jl_new_datatype(jl_symbol("SlotNumber"), core, jl_abstractslot_type, jl_emptysvec,
+                                         jl_perm_symsvec(1, "id"),
                                          jl_svec1(jl_long_type), 0, 0, 1);
 
-    jl_typedslot_type = jl_new_datatype(jl_symbol("TypedSlot"), jl_abstractslot_type, jl_emptysvec,
-                                        jl_svec(2, jl_symbol("id"), jl_symbol("typ")),
+    jl_typedslot_type = jl_new_datatype(jl_symbol("TypedSlot"), core, jl_abstractslot_type, jl_emptysvec,
+                                        jl_perm_symsvec(2, "id", "typ"),
                                         jl_svec(2, jl_long_type, jl_any_type), 0, 0, 2);
 
     jl_init_int32_int64_cache();
 
     jl_bool_type = NULL;
-    jl_bool_type = jl_new_primitivetype((jl_value_t*)jl_symbol("Bool"),
+    jl_bool_type = jl_new_primitivetype((jl_value_t*)jl_symbol("Bool"), core,
                                         jl_any_type, jl_emptysvec, 8);
-    jl_false = jl_box8(jl_bool_type, 0);
-    jl_true  = jl_box8(jl_bool_type, 1);
+    jl_false = jl_permbox8(jl_bool_type, 0);
+    jl_true  = jl_permbox8(jl_bool_type, 1);
 
     jl_typemap_level_type =
-        jl_new_datatype(jl_symbol("TypeMapLevel"), jl_any_type, jl_emptysvec,
-                        jl_svec(7,
-                            jl_symbol("index_arg1"),
-                            jl_symbol("arg1"),
-                            jl_symbol("index_targ"),
-                            jl_symbol("targ"),
-                            jl_symbol("list"),
-                            jl_symbol("any"),
-                            jl_symbol("key")),
+        jl_new_datatype(jl_symbol("TypeMapLevel"), core, jl_any_type, jl_emptysvec,
+                        jl_perm_symsvec(7,
+                            "index_arg1",
+                            "arg1",
+                            "index_targ",
+                            "targ",
+                            "list",
+                            "any",
+                            "key"),
                         jl_svec(7,
                             jl_any_type,
                             jl_any_type,
@@ -1721,18 +1790,18 @@ void jl_init_types(void)
                         0, 1, 6);
 
     jl_typemap_entry_type =
-        jl_new_datatype(jl_symbol("TypeMapEntry"), jl_any_type, jl_emptysvec,
-                        jl_svec(10,
-                            jl_symbol("next"),
-                            jl_symbol("sig"),
-                            jl_symbol("simplesig"),
-                            jl_symbol("guardsigs"),
-                            jl_symbol("min_world"),
-                            jl_symbol("max_world"),
-                            jl_symbol("func"),
-                            jl_symbol("isconcretesig"),
-                            jl_symbol("issimplesig"),
-                            jl_symbol("va")),
+        jl_new_datatype(jl_symbol("TypeMapEntry"), core, jl_any_type, jl_emptysvec,
+                        jl_perm_symsvec(10,
+                            "next",
+                            "sig",
+                            "simplesig",
+                            "guardsigs",
+                            "min_world",
+                            "max_world",
+                            "func",
+                            "isconcretesig",
+                            "issimplesig",
+                            "va"),
                         jl_svec(10,
                             jl_any_type, // Union{TypeMapEntry, Void}
                             jl_type_type, // TupleType
@@ -1746,30 +1815,29 @@ void jl_init_types(void)
                             jl_bool_type),
                         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);
+    jl_function_type = jl_new_abstracttype((jl_value_t*)jl_symbol("Function"), core, jl_any_type, jl_emptysvec);
+    jl_builtin_type  = jl_new_abstracttype((jl_value_t*)jl_symbol("Builtin"), core, jl_function_type, jl_emptysvec);
 
     tv = jl_svec2(tvar("T"), tvar("N"));
     jl_abstractarray_type = (jl_unionall_t*)
-        jl_new_abstracttype((jl_value_t*)jl_symbol("AbstractArray"),
+        jl_new_abstracttype((jl_value_t*)jl_symbol("AbstractArray"), core,
                             jl_any_type, tv)->name->wrapper;
 
     tv = jl_svec2(tvar("T"), tvar("N"));
     jl_densearray_type = (jl_unionall_t*)
-        jl_new_abstracttype((jl_value_t*)jl_symbol("DenseArray"),
+        jl_new_abstracttype((jl_value_t*)jl_symbol("DenseArray"), core,
                             (jl_datatype_t*)jl_apply_type((jl_value_t*)jl_abstractarray_type, jl_svec_data(tv), 2),
                             tv)->name->wrapper;
 
     tv = jl_svec2(tvar("T"), tvar("N"));
     jl_array_type = (jl_unionall_t*)
-        jl_new_datatype(jl_symbol("Array"),
+        jl_new_datatype(jl_symbol("Array"), core,
                         (jl_datatype_t*)
                         jl_apply_type((jl_value_t*)jl_densearray_type, jl_svec_data(tv), 2),
                         tv,
                         jl_emptysvec, jl_emptysvec, 0, 1, 0)->name->wrapper;
     jl_array_typename = ((jl_datatype_t*)jl_unwrap_unionall((jl_value_t*)jl_array_type))->name;
-    static const jl_datatype_layout_t _jl_array_layout = { 0, sizeof(void*), 0, 1, 0 };
-    ((jl_datatype_t*)jl_unwrap_unionall((jl_value_t*)jl_array_type))->layout = &_jl_array_layout;
+    jl_compute_field_offsets((jl_datatype_t*)jl_unwrap_unionall((jl_value_t*)jl_array_type));
 
     jl_array_any_type = jl_apply_type2((jl_value_t*)jl_array_type, (jl_value_t*)jl_any_type, jl_box_long(1));
 
@@ -1778,172 +1846,169 @@ void jl_init_types(void)
     jl_array_uint8_type = jl_apply_type2((jl_value_t*)jl_array_type, (jl_value_t*)jl_uint8_type, jl_box_long(1));
 
     jl_expr_type =
-        jl_new_datatype(jl_symbol("Expr"),
+        jl_new_datatype(jl_symbol("Expr"), core,
                         jl_any_type, jl_emptysvec,
-                        jl_svec(3, jl_symbol("head"), jl_symbol("args"),
-                                jl_symbol("typ")),
+                        jl_perm_symsvec(3, "head", "args", "typ"),
                         jl_svec(3, jl_sym_type, jl_array_any_type,
                                  jl_any_type),
                         0, 1, 3);
 
     jl_linenumbernode_type =
-        jl_new_datatype(jl_symbol("LineNumberNode"), jl_any_type, jl_emptysvec,
-                        jl_svec(1, jl_symbol("line")),
-                        jl_svec(1, jl_long_type), 0, 0, 1);
+        jl_new_datatype(jl_symbol("LineNumberNode"), core, jl_any_type, jl_emptysvec,
+                        jl_perm_symsvec(2, "line", "file"),
+                        jl_svec(2, jl_long_type, jl_any_type), 0, 0, 2);
 
     jl_labelnode_type =
-        jl_new_datatype(jl_symbol("LabelNode"), jl_any_type, jl_emptysvec,
-                        jl_svec(1, jl_symbol("label")),
+        jl_new_datatype(jl_symbol("LabelNode"), core, jl_any_type, jl_emptysvec,
+                        jl_perm_symsvec(1, "label"),
                         jl_svec(1, jl_long_type), 0, 0, 1);
 
     jl_gotonode_type =
-        jl_new_datatype(jl_symbol("GotoNode"), jl_any_type, jl_emptysvec,
-                        jl_svec(1, jl_symbol("label")),
+        jl_new_datatype(jl_symbol("GotoNode"), core, jl_any_type, jl_emptysvec,
+                        jl_perm_symsvec(1, "label"),
                         jl_svec(1, jl_long_type), 0, 0, 1);
 
     jl_quotenode_type =
-        jl_new_datatype(jl_symbol("QuoteNode"), jl_any_type, jl_emptysvec,
-                        jl_svec(1, jl_symbol("value")),
+        jl_new_datatype(jl_symbol("QuoteNode"), core, jl_any_type, jl_emptysvec,
+                        jl_perm_symsvec(1, "value"),
                         jl_svec(1, jl_any_type), 0, 0, 1);
 
     jl_newvarnode_type =
-        jl_new_datatype(jl_symbol("NewvarNode"), jl_any_type, jl_emptysvec,
-                        jl_svec(1, jl_symbol("slot")),
+        jl_new_datatype(jl_symbol("NewvarNode"), core, jl_any_type, jl_emptysvec,
+                        jl_perm_symsvec(1, "slot"),
                         jl_svec(1, jl_slotnumber_type), 0, 0, 1);
 
     jl_module_type =
-        jl_new_datatype(jl_symbol("Module"), jl_any_type, jl_emptysvec,
-                        jl_svec(2, jl_symbol("name"), jl_symbol("parent")),
+        jl_new_datatype(jl_symbol("Module"), core, jl_any_type, jl_emptysvec,
+                        jl_perm_symsvec(2, "name", "parent"),
                         jl_svec(2, jl_sym_type, jl_any_type), 0, 1, 2);
 
     jl_globalref_type =
-        jl_new_datatype(jl_symbol("GlobalRef"), jl_any_type, jl_emptysvec,
-                        jl_svec(2, jl_symbol("mod"), jl_symbol("name")),
+        jl_new_datatype(jl_symbol("GlobalRef"), core, jl_any_type, jl_emptysvec,
+                        jl_perm_symsvec(2, "mod", "name"),
                         jl_svec(2, jl_module_type, jl_sym_type), 0, 0, 2);
 
     jl_code_info_type =
-        jl_new_datatype(jl_symbol("CodeInfo"),
+        jl_new_datatype(jl_symbol("CodeInfo"), core,
                         jl_any_type, jl_emptysvec,
+                        jl_perm_symsvec(9,
+                            "code",
+                            "slottypes",
+                            "ssavaluetypes",
+                            "slotflags",
+                            "slotnames",
+                            "inferred",
+                            "inlineable",
+                            "propagate_inbounds",
+                            "pure"),
                         jl_svec(9,
-                                jl_symbol("code"),
-                                jl_symbol("slottypes"),
-                                jl_symbol("ssavaluetypes"),
-                                jl_symbol("slotnames"),
-                                jl_symbol("slotflags"),
-                                jl_symbol("inferred"),
-                                jl_symbol("inlineable"),
-                                jl_symbol("propagate_inbounds"),
-                                jl_symbol("pure")),
-                        jl_svec(9,
-                                jl_any_type,
-                                jl_any_type,
-                                jl_any_type,
-                                jl_array_any_type,
-                                jl_array_uint8_type,
-                                jl_bool_type,
-                                jl_bool_type,
-                                jl_bool_type,
-                                jl_bool_type),
+                            jl_array_any_type,
+                            jl_any_type,
+                            jl_any_type,
+                            jl_array_uint8_type,
+                            jl_array_any_type,
+                            jl_bool_type,
+                            jl_bool_type,
+                            jl_bool_type,
+                            jl_bool_type),
                         0, 1, 9);
 
     jl_method_type =
-        jl_new_datatype(jl_symbol("Method"),
+        jl_new_datatype(jl_symbol("Method"), core,
                         jl_any_type, jl_emptysvec,
-                        jl_svec(20,
-                                jl_symbol("name"),
-                                jl_symbol("module"),
-                                jl_symbol("file"),
-                                jl_symbol("line"),
-                                jl_symbol("sig"),
-                                jl_symbol("min_world"),
-                                jl_symbol("max_world"),
-                                jl_symbol("ambig"),
-                                jl_symbol("specializations"),
-                                jl_symbol("sparam_syms"),
-                                jl_symbol("source"),
-                                jl_symbol("unspecialized"),
-                                jl_symbol("generator"),
-                                jl_symbol("roots"),
-                                jl_symbol("invokes"),
-                                jl_symbol("nargs"),
-                                jl_symbol("called"),
-                                jl_symbol("isva"),
-                                jl_symbol("isstaged"),
-                                jl_symbol("needs_sparam_vals_ducttape")),
-                        jl_svec(20,
-                                jl_sym_type,
-                                jl_module_type,
-                                jl_sym_type,
-                                jl_int32_type,
-                                jl_type_type,
-                                jl_long_type,
-                                jl_long_type,
-                                jl_any_type, // Union{Array, Void}
-                                jl_any_type, // TypeMap
-                                jl_simplevector_type,
-                                jl_code_info_type,
-                                jl_any_type, // jl_method_instance_type
-                                jl_any_type, // jl_method_instance_type
-                                jl_array_any_type,
-                                jl_any_type,
-                                jl_int32_type,
-                                jl_int32_type,
-                                jl_bool_type,
-                                jl_bool_type,
-                                jl_bool_type),
-                        0, 1, 10);
+                        jl_perm_symsvec(19,
+                            "name",
+                            "module",
+                            "file",
+                            "line",
+                            "sig",
+                            "min_world",
+                            "ambig",
+                            "specializations",
+                            "sparam_syms",
+                            "source",
+                            "unspecialized",
+                            "generator",
+                            "roots",
+                            "invokes",
+                            "nargs",
+                            "called",
+                            "nospecialize",
+                            "isva",
+                            "pure"),
+                        jl_svec(19,
+                            jl_sym_type,
+                            jl_module_type,
+                            jl_sym_type,
+                            jl_int32_type,
+                            jl_type_type,
+                            jl_long_type,
+                            jl_any_type, // Union{Array, Void}
+                            jl_any_type, // TypeMap
+                            jl_simplevector_type,
+                            jl_any_type,
+                            jl_any_type, // jl_method_instance_type
+                            jl_any_type, // jl_method_instance_type
+                            jl_array_any_type,
+                            jl_any_type,
+                            jl_int32_type,
+                            jl_int32_type,
+                            jl_int32_type,
+                            jl_bool_type,
+                            jl_bool_type),
+                        0, 1, 9);
 
     jl_method_instance_type =
-        jl_new_datatype(jl_symbol("MethodInstance"),
+        jl_new_datatype(jl_symbol("MethodInstance"), core,
                         jl_any_type, jl_emptysvec,
+                        jl_perm_symsvec(16,
+                            "def",
+                            "specTypes",
+                            "rettype",
+                            "sparam_vals",
+                            "backedges",
+                            "inferred",
+                            "inferred_const",
+                            "min_world",
+                            "max_world",
+                            "inInference",
+                            "jlcall_api",
+                            "",
+                            "fptr",
+                            "unspecialized_ducttape",
+                            "", ""),
                         jl_svec(16,
-                                jl_symbol("specTypes"),
-                                jl_symbol("rettype"),
-                                jl_symbol("sparam_vals"),
-                                jl_symbol("backedges"),
-                                jl_symbol("inferred"),
-                                jl_symbol("inferred_const"),
-                                jl_symbol("def"),
-                                jl_symbol("min_world"),
-                                jl_symbol("max_world"),
-                                jl_symbol("inInference"),
-                                jl_symbol("jlcall_api"),
-                                jl_symbol(""),
-                                jl_symbol("fptr"),
-                                jl_symbol("unspecialized_ducttape"),
-                                jl_symbol(""), jl_symbol("")),
-                        jl_svec(16,
-                                jl_any_type,
-                                jl_any_type,
-                                jl_simplevector_type,
-                                jl_any_type,
-                                jl_any_type,
-                                jl_any_type,
-                                jl_method_type,
-                                jl_long_type,
-                                jl_long_type,
-                                jl_bool_type,
-                                jl_uint8_type,
-                                jl_bool_type,
-                                jl_any_type, // void*
-                                jl_any_type, // void*
-                                jl_any_type, jl_any_type), // void*, void*
-                        0, 1, 3);
+                            jl_new_struct(jl_uniontype_type, jl_method_type, jl_module_type),
+                            jl_any_type,
+                            jl_any_type,
+                            jl_simplevector_type,
+                            jl_any_type,
+                            jl_any_type,
+                            jl_any_type,
+                            jl_long_type,
+                            jl_long_type,
+                            jl_bool_type,
+                            jl_uint8_type,
+                            jl_bool_type,
+                            jl_any_type, // void*
+                            jl_any_type, // void*
+                            jl_any_type, jl_any_type), // void*, void*
+                        0, 1, 4);
 
     // all kinds of types share a method table
     jl_unionall_type->name->mt = jl_uniontype_type->name->mt = jl_datatype_type->name->mt =
         jl_type_typename->mt;
 
-    jl_intrinsic_type = jl_new_primitivetype((jl_value_t*)jl_symbol("IntrinsicFunction"),
+    jl_intrinsic_type = jl_new_primitivetype((jl_value_t*)jl_symbol("IntrinsicFunction"), core,
                                              jl_builtin_type, jl_emptysvec, 32);
 
     tv = jl_svec1(tvar("T"));
     jl_ref_type = (jl_unionall_t*)
-        jl_new_abstracttype((jl_value_t*)jl_symbol("Ref"), jl_any_type, tv)->name->wrapper;
+        jl_new_abstracttype((jl_value_t*)jl_symbol("Ref"), core, jl_any_type, tv)->name->wrapper;
 
     tv = jl_svec1(tvar("T"));
     jl_pointer_type = (jl_unionall_t*)
-        jl_new_primitivetype((jl_value_t*)jl_symbol("Ptr"),
+        jl_new_primitivetype((jl_value_t*)jl_symbol("Ptr"), core,
                              (jl_datatype_t*)jl_apply_type((jl_value_t*)jl_ref_type, jl_svec_data(tv), 1), tv,
                              sizeof(void*)*8)->name->wrapper;
     jl_pointer_typename = ((jl_datatype_t*)jl_unwrap_unionall((jl_value_t*)jl_pointer_type))->name;
@@ -1963,10 +2028,11 @@ void jl_init_types(void)
 
     jl_ANY_flag = (jl_value_t*)tvar("ANY");
 
-    jl_abstractstring_type = jl_new_abstracttype((jl_value_t*)jl_symbol("AbstractString"), jl_any_type, jl_emptysvec);
-    jl_string_type = jl_new_datatype(jl_symbol("String"), jl_abstractstring_type, jl_emptysvec,
-                                     jl_svec1(jl_symbol("len")), jl_svec1(jl_long_type),
-                                     0, 1, 1);
+    jl_abstractstring_type = jl_new_abstracttype((jl_value_t*)jl_symbol("AbstractString"), core, jl_any_type, jl_emptysvec);
+    jl_string_type = jl_new_datatype(jl_symbol("String"), core, jl_abstractstring_type, jl_emptysvec,
+                                     jl_emptysvec, jl_emptysvec, 0, 1, 0);
+    jl_string_type->instance = NULL;
+    jl_compute_field_offsets(jl_string_type);
 
     // complete builtin type metadata
     jl_value_t *pointer_void = jl_apply_type1((jl_value_t*)jl_pointer_type, (jl_value_t*)jl_void_type);
@@ -1982,7 +2048,6 @@ void jl_init_types(void)
     jl_svecset(jl_datatype_type->types, 13, jl_int32_type);
     jl_svecset(jl_datatype_type->types, 14, jl_bool_type);
     jl_svecset(jl_datatype_type->types, 15, jl_bool_type);
-    jl_svecset(jl_simplevector_type->types, 0, jl_long_type);
     jl_svecset(jl_typename_type->types, 1, jl_module_type);
     jl_svecset(jl_typename_type->types, 6, jl_long_type);
     jl_svecset(jl_typename_type->types, 3, jl_type_type);
@@ -1995,8 +2060,8 @@ void jl_init_types(void)
     jl_svecset(jl_methtable_type->types, 7, jl_int32_type); // DWORD
 #endif
     jl_svecset(jl_methtable_type->types, 8, jl_int32_type); // uint32_t
+    jl_svecset(jl_method_type->types, 10, jl_method_instance_type);
     jl_svecset(jl_method_type->types, 11, jl_method_instance_type);
-    jl_svecset(jl_method_type->types, 12, jl_method_instance_type);
     jl_svecset(jl_method_instance_type->types, 12, jl_voidpointer_type);
     jl_svecset(jl_method_instance_type->types, 13, jl_voidpointer_type);
     jl_svecset(jl_method_instance_type->types, 14, jl_voidpointer_type);
@@ -2018,10 +2083,6 @@ void jl_init_types(void)
     jl_compute_field_offsets(jl_simplevector_type);
     jl_compute_field_offsets(jl_sym_type);
 
-    // TODO: don't modify layout objects
-    ((jl_datatype_layout_t*)jl_sym_type->layout)->npointers = 1;
-    ((jl_datatype_layout_t*)jl_simplevector_type->layout)->npointers = 1;
-
     jl_cfunction_list.unknown = jl_nothing;
 }
 
diff --git a/src/julia-parser.scm b/src/julia-parser.scm
index 0a0633a3fbcb34..20031400a74eb3 100644
--- a/src/julia-parser.scm
+++ b/src/julia-parser.scm
@@ -25,9 +25,11 @@
 (define prec-bitshift    (add-dots '(<< >> >>>)))
 (define prec-times       (add-dots '(* / ÷ % & ⋅ ∘ × |\\| ∩ ∧ ⊗ ⊘ ⊙ ⊚ ⊛ ⊠ ⊡ ⊓ ∗ ∙ ∤ ⅋ ≀ ⊼ ⋄ ⋆ ⋇ ⋉ ⋊ ⋋ ⋌ ⋏ ⋒ ⟑ ⦸ ⦼ ⦾ ⦿ ⧶ ⧷ ⨇ ⨰ ⨱ ⨲ ⨳ ⨴ ⨵ ⨶ ⨷ ⨸ ⨻ ⨼ ⨽ ⩀ ⩃ ⩄ ⩋ ⩍ ⩎ ⩑ ⩓ ⩕ ⩘ ⩚ ⩜ ⩞ ⩟ ⩠ ⫛ ⊍ ▷ ⨝ ⟕ ⟖ ⟗)))
 (define prec-rational    (add-dots '(//)))
+;; `where`
+;; unary
 (define prec-power       (add-dots '(^ ↑ ↓ ⇵ ⟰ ⟱ ⤈ ⤉ ⤊ ⤋ ⤒ ⤓ ⥉ ⥌ ⥍ ⥏ ⥑ ⥔ ⥕ ⥘ ⥙ ⥜ ⥝ ⥠ ⥡ ⥣ ⥥ ⥮ ⥯ ￪ ￬)))
 (define prec-decl        '(|::|))
-;; `where`
+;; `where` occurring after `::`
 (define prec-dot         '(|.|))
 
 (define prec-names '(prec-assignment
@@ -43,6 +45,9 @@
         ((not (length> l 8))
          (eval `(lambda (x)
                   (not (not (,(if (every symbol? l) 'memq 'memv) x (quote ,l)))))))
+        ((and (every symbol? l) (not (length> l 20)))
+         (eval `(lambda (x)
+                  (not (not (memq x (quote ,l)))))))
         (else
          (let ((t (table)))
            (for-each (lambda (x) (put! t x #t)) l)
@@ -68,6 +73,8 @@
 (define unary-ops (append! '(|<:| |>:|)
                            (add-dots '(+ - ! ~ ¬ √ ∛ ∜))))
 
+(define unary-op? (Set unary-ops))
+
 ; operators that are both unary and binary
 (define unary-and-binary-ops '(+ - $ & ~ |.+| |.-|))
 
@@ -124,6 +131,13 @@
 
 (define reserved-word? (Set reserved-words))
 
+(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)))))
+
 ;; Parser state variables
 
 ; disable range colon for parsing ternary conditional operator
@@ -146,6 +160,15 @@
                    (where-enabled #t))
                   ,@body))
 
+(define-macro (with-normal-context . body)
+  `(with-bindings ((range-colon-enabled #t)
+                   (space-sensitive #f)
+                   (where-enabled #t)
+                   (inside-vec #f)
+                   (end-symbol #f)
+                   (whitespace-newline #f))
+                  ,@body))
+
 (define-macro (without-range-colon . body)
   `(with-bindings ((range-colon-enabled #f))
                   ,@body))
@@ -292,7 +315,13 @@
     (if (eqv? (peek-char port) #\.)
         (begin (read-char port)
                (if (dot-opchar? (peek-char port))
-                   (io.ungetc port #\.)
+                   (begin
+                     (if (not (eqv? (peek-char port) #\.))
+                         (let ((num (get-output-string str)))
+                           (syntax-deprecation port
+                                               (string num #\. (peek-char port))
+                                               (string num " ." (peek-char port)))))
+                     (io.ungetc port #\.))
                    (begin (write-char #\. str)
                           (read-digs #f #t)
                           (if (eq? pred char-hex?)
@@ -345,10 +374,10 @@
             ((eq? pred char-bin?) (fix-uint-neg neg (sized-uint-literal n s 1)))
             (is-float32-literal   (numchk n s) (float n))
             (n (if (and (integer? n) (> n 9223372036854775807))
-                   `(macrocall @int128_str ,s)
+                   `(macrocall @int128_str (null) ,s)
                    n))
-            ((within-int128? s) `(macrocall @int128_str ,s))
-            (else `(macrocall @big_str ,s))))))
+            ((within-int128? s) `(macrocall @int128_str (null) ,s))
+            (else `(macrocall @big_str (null) ,s))))))
 
 (define (fix-uint-neg neg n)
   (if neg
@@ -364,7 +393,7 @@
           ((<= l 16)  (numchk n s) (uint16 n))
           ((<= l 32)  (numchk n s) (uint32 n))
           ((<= l 64)  (numchk n s) (uint64 n))
-          ((<= l 128) `(macrocall @uint128_str ,s))
+          ((<= l 128) `(macrocall @uint128_str (null) ,s))
           (else       (error "Hex or binary literal too large for UInt128")))))
 
 (define (sized-uint-oct-literal n s)
@@ -377,7 +406,7 @@
                 (else             (uint64 n)))
           (begin (if (equal? s "0o") (numchk n s))
                  (if (oct-within-uint128? s)
-                     `(macrocall @uint128_str ,s)
+                     `(macrocall @uint128_str (null) ,s)
                      (error "Octal literal too large for UInt128"))))))
 
 (define (strip-leading-0s s)
@@ -493,16 +522,17 @@
 
 ;; --- token stream ---
 
-(define (make-token-stream s) (vector #f s #t #f))
+(define (make-token-stream s) (vector #f s #t #f #f))
 (define-macro (ts:port s)       `(aref ,s 1))
 (define-macro (ts:last-tok s)   `(aref ,s 0))
 (define-macro (ts:set-tok! s t) `(aset! ,s 0 ,t))
-(define-macro (ts:space? s)     `(aref ,s 2))
 (define-macro (ts:pbtok s)      `(aref ,s 3))
-(define (ts:put-back! s t)
+(define (ts:space? s)           (aref s (if (ts:pbtok s) 4 2)))
+(define (ts:put-back! s t spc)
   (if (ts:pbtok s)
       (error "too many pushed-back tokens (internal error)")
-      (aset! s 3 t)))
+      (begin (aset! s 3 t)
+             (aset! s 4 spc))))
 
 (define (peek-token s)
   (or (ts:pbtok s)
@@ -570,112 +600,194 @@
                     (list 'call t ex (,self ,s))))
          ex)))
 
-(define (parse-cond s)
-  (let ((ex (parse-arrow s)))
-    (cond ((eq? (peek-token s) '?)
-           (begin (take-token s)
-                  (let ((then (without-range-colon (parse-eq* s))))
-                    (if (not (eq? (take-token s) ':))
-                        (error "colon expected in \"?\" expression")
-                        (list 'if ex then (parse-eq* s))))))
-          (else ex))))
+(define (line-number-node s)
+  `(line ,(input-port-line (ts:port s)) ,current-filename))
 
-(define (parse-where-chain s first)
-  (with-bindings ((where-enabled #f))
-   (let loop ((ex first)
-              (t 'where))
-     (if (eq? t 'where)
-         (begin (take-token s)
-                (let ((var (parse-comparison s)))
-                  (loop (if (and (pair? var) (eq? (car var) 'cell1d))
-                            (list* 'where ex (cdr var))  ;; form `x where {T,S}`
-                            (list 'where ex var))
-                        (peek-token s))))
-         ex))))
+;; parse a@b@c@... as (@ a b c ...) for some operator @
+;; ops: operators to look for
+;; head: the expression head to yield in the result, e.g. "a;b" => (block a b)
+;; closer?: predicate to identify tokens that stop parsing
+;;          however, this doesn't consume the closing token, just looks at it
+;; ow, my eyes!!
+(define (parse-Nary s down ops head closer? add-linenums)
+  (let ((t (require-token s)))
+    (if (closer? t)
+        (if add-linenums    ;; empty block
+            (list head (line-number-node s))
+            (list head))
+        (let loop ((ex
+                    ;; skip leading runs of operator
+                    (if (memv t ops)
+                        (if add-linenums
+                            (list (line-number-node s))
+                            '())
+                        (if add-linenums
+                            (let ((loc (line-number-node s)))
+                              ;; note: line-number must happen before (down s)
+                              (list (down s) loc))
+                            (list (down s)))))
+                   (first? #t)
+                   (t (peek-token s)))
+          (if (not (memv t ops))
+              (begin
+                (if (not (or (eof-object? t) (eqv? t #\newline) (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))
+                    ;; (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))
+                             (closer? (peek-token s))
+                             (memv (peek-token s) ops))
+                         (loop ex #f (peek-token s))
+                         (if (and add-linenums
+                                  (not (and (pair? (car ex))
+                                            (eq? (caar ex) 'line))))
+                             (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))))))))))
 
-(define (parse-where s)
-  (let ((ex (parse-call s)))
-    (if (and where-enabled
-             (eq? (peek-token s) 'where))
-        (parse-where-chain s ex)
-        ex)))
+;; the principal non-terminals follow, in increasing precedence order
 
-(define (invalid-initial-token? tok)
-  (or (eof-object? tok)
-      (memv tok '(#\) #\] #\} else elseif catch finally =))))
+(define (parse-block s (down parse-eq))
+  (parse-Nary s down '(#\newline #\;) 'block
+              (lambda (x) (memq x '(end else elseif catch finally))) #t))
 
-(define (line-number-node s)
-  `(line ,(input-port-line (ts:port s)) ,current-filename))
+;; ";" 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 (lambda (x) (eqv? x #\newline)) #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 (eventually-call ex)
+(define (parse-eq s) (parse-assignment s parse-comma))
+
+;; symbol tokens that do not simply parse to themselves when appearing alone as
+;; an element of an argument list
+(define non-standalone-symbol-token?
+  (Set (append operators reserved-words '(.... mutable primitive))))
+
+; parse-eq* is used where commas are special, for example in an argument list
+(define (parse-eq* s)
+  (let* ((t   (peek-token s))
+         (spc (ts:space? s)))
+    ;; optimization: skip checking the whole precedence stack if we have a simple
+    ;; token followed by a common closing token
+    (if (or (number? t) (and (symbol? t) (not (non-standalone-symbol-token? t))))
+        (begin (take-token s)
+               (let ((nxt (peek-token s)))
+                 (if (or (eqv? nxt #\,) (eqv? nxt #\) ) (eqv? nxt #\}) (eqv? nxt #\]))
+                     t
+                     (begin (ts:put-back! s t spc)
+                            (parse-assignment s parse-cond)))))
+        (parse-assignment s parse-cond))))
+
+(define (eventually-call? ex)
   (and (pair? ex)
        (or (eq? (car ex) 'call)
-           (and (eq? (car ex) 'where)
-                (eventually-call (cadr ex))))))
+           (and (or (eq? (car ex) 'where) (eq? (car ex) '|::|))
+                (eventually-call? (cadr ex))))))
 
-;; insert line/file for short-form function defs, otherwise leave alone
 (define (short-form-function-loc ex lno)
-  (if (and (pair? ex)
-           (eq? (car ex) '=)
-           (eventually-call (cadr ex)))
+  (if (eventually-call? (cadr ex))
       `(= ,(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 closer? allow-empty add-linenums)
-  (let ((t (require-token s)))
-  (if (invalid-initial-token? t)
-      (error (string "unexpected \"" t "\"")))
-  (if (closer? t)
-      (if add-linenums    ;; empty block
-          (list head (line-number-node s))
-          (list head))
-      (let loop ((ex
-                  ;; in allow-empty mode skip leading runs of operator
-                  (if (and allow-empty (memv t ops))
-                      (if add-linenums
-                          (list (line-number-node s))
-                          '())
-                      (if add-linenums
-                          (let ((loc (line-number-node s)))
-                            ;; note: line-number must happen before (down s)
-                            (list (down s) loc))
-                          (list (down s)))))
-                 (first? #t)
-                 (t (peek-token s)))
-        (if (not (memv t ops))
-            (begin
-              (if (not (or (eof-object? t) (eqv? t #\newline) (memv #\, ops)
-                           (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))
-                  ;; (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))
-                           (closer? (peek-token s))
-                           (and allow-empty
-                                (memv (peek-token s) ops))
-                           (and (eqv? (car ops) #\,)
-                                (eq? (peek-token s) '=)))
-                       (loop ex #f (peek-token s))
-                       (if (and add-linenums
-                                (not (and (pair? (car ex))
-                                          (eq? (caar ex) 'line))))
-                           (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))))))))))
+(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)
+          (cond ((eq? t '~)
+                 (if (and space-sensitive (ts:space? s)
+                          (not (eqv? (peek-char (ts:port s)) #\ )))
+                     (begin (ts:put-back! s t (ts:space? s))
+                            ex)
+                     (list 'call t ex (parse-assignment s down))))
+                ((eq? t '=>)  ;; ~ and => are the only non-syntactic assignment-precedence operators
+                 (list 'call t ex (parse-assignment s down)))
+                ((eq? t '=)
+                 ;; insert line/file for short-form function defs, otherwise leave alone
+                 (let ((lno (input-port-line (ts:port s))))
+                   (short-form-function-loc
+                    (list t ex (parse-assignment s down)) lno)))
+                (else
+                 (list t ex (parse-assignment s down))))))))
+
+; parse-comma is needed for commas outside parens, for example a = b,c
+(define (parse-comma s)
+  (let loop ((ex     (list (parse-cond s)))
+             (first? #t)
+             (t      (peek-token s)))
+    (if (not (eqv? t #\,))
+        (if (or (pair? (cdr ex)) (not first?))
+            ;; () => (tuple)
+            ;; (ex2 ex1) => (tuple ex1 ex2)
+            ;; (ex1,) => (tuple ex1)
+            (cons 'tuple (reverse! ex))
+            ;; (ex1) => ex1
+            (car ex))
+        (begin (take-token s)
+               (if (or (eof-object? (peek-token s)) (eq? (peek-token s) '=))
+                   (loop ex #f (peek-token s))
+                   (loop (cons (parse-cond s) ex) #f (peek-token s)))))))
+
+(define (parse-cond s)
+  (let ((ex (parse-arrow s)))
+    (cond ((eq? (peek-token s) '?)
+           (begin (if (not (ts:space? s))
+                      (syntax-deprecation s (string (deparse ex) "?") (string (deparse ex) " ?")))
+                  (take-token s) ; take the ?
+                  (let ((t (with-whitespace-newline (without-range-colon (peek-token s)))))
+                    (if (not (ts:space? s))
+                        (syntax-deprecation s (string (deparse ex) " ?" (deparse t)) (string (deparse ex) " ? " (deparse t)))))
+                  (let ((then (without-range-colon (parse-eq* s))))
+                    (if (not (eq? (peek-token s) ':))
+                        (error "colon expected in \"?\" expression"))
+                    (if (not (ts:space? s))
+                        (syntax-deprecation s (string (deparse ex) " ? " (deparse then) ":") (string (deparse ex) " ? " (deparse then) " :")))
+                    (take-token s) ; take the :
+                    (let ((t (with-whitespace-newline (peek-token s))))
+                      (if (not (ts:space? s))
+                          (syntax-deprecation s (string (deparse ex) " ? " (deparse then) " :" t) (string (deparse ex) " ? " (deparse then) " : " t))))
+                    (list 'if ex then (parse-eq* s)))))
+          (else ex))))
+
+(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))
+
+(define (parse-comparison s)
+  (let loop ((ex (parse-pipes s))
+             (first #t))
+    (let ((t (peek-token s)))
+      (cond ((is-prec-comparison? t)
+             (begin (take-token s)
+                    (if first
+                        (loop (list 'comparison ex t (parse-pipes s)) #f)
+                        (loop (append ex (list t (parse-pipes s))) #f))))
+            (first ex)
+            ((length= ex 4)
+             ;; only a single comparison; special chained syntax not required
+             (let ((op   (caddr ex))
+                   (arg1 (cadr ex))
+                   (arg2 (cadddr ex)))
+               (if (or (eq? op '|<:|) (eq? op '|>:|))
+                   `(,op ,arg1 ,arg2)
+                   `(call ,op ,arg1 ,arg2))))
+            (else ex)))))
+
+(define (parse-pipes s) (parse-LtoR s parse-range is-prec-pipe?))
 
 ; parse ranges and postfix ...
 ; colon is strange; 3 arguments with 2 colons yields one call:
@@ -703,7 +815,7 @@
              (if (and space-sensitive spc
                       (or (peek-token s) #t) (not (ts:space? s)))
                  ;; "a :b" in space sensitive mode
-                 (begin (ts:put-back! s ':)
+                 (begin (ts:put-back! s ': spc)
                         ex)
                  (let ((argument
                         (cond ((closing-token? (peek-token s))
@@ -725,69 +837,19 @@
              (list '... ex))
             (else ex)))))
 
-;; the principal non-terminals follow, in increasing precedence order
-
-(define (parse-block s (down parse-eq))
-  (parse-Nary s down '(#\newline #\;) 'block
-              (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 (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)
-                       (list 'call t ex (parse-assignment s down)))
-                   (if (eq? t '=>)  ;; ~ and => are the only non-syntactic assignment-precedence operators
-                       (list 'call t ex (parse-assignment s down))
-                       (list       t ex (parse-assignment s down))))))))
-
-(define (parse-eq s)
-  (let ((lno (input-port-line (ts:port s))))
-    (short-form-function-loc
-     (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-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 (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
 (define (parse-chain s down op)
   (let loop ((chain (list (down s))))
-    (let* ((t   (peek-token s))
-           (spc (ts:space? s)))
+    (let ((t (peek-token s)))
       (if (not (eq? t op))
           (reverse! chain)
-          (begin
+          (let ((spc (ts:space? s)))
             (take-token s)
             (cond ((and space-sensitive spc (memq t unary-and-binary-ops)
                         (not (eqv? (peek-char (ts:port s)) #\ )))
                    ;; here we have "x -y"
-                   (ts:put-back! s t)
+                   (ts:put-back! s t spc)
                    (reverse! chain))
                   (else
                    (loop (cons (down s) chain)))))))))
@@ -796,16 +858,15 @@
 ;; e.g. a+b+c => (call + a b c)
 (define (parse-with-chains s down ops chain-ops)
   (let loop ((ex (down s)))
-    (let* ((t   (peek-token s))
-           (spc (ts:space? s)))
+    (let ((t (peek-token s)))
       (if (not (ops t))
           ex
-          (begin
+          (let ((spc (ts:space? s)))
             (take-token s)
             (cond ((and space-sensitive spc (memq t unary-and-binary-ops)
                         (not (eqv? (peek-char (ts:port s)) #\ )))
                    ;; here we have "x -y"
-                   (ts:put-back! s t)
+                   (ts:put-back! s t spc)
                    ex)
                   ((memq t chain-ops)
                    (loop (list* 'call t ex
@@ -813,69 +874,166 @@
                   (else
                    (loop (list 'call t ex (down s))))))))))
 
-(define (parse-expr s) (parse-with-chains s parse-shift is-prec-plus? '(+ ++)))
-
-(define (parse-shift s) (parse-LtoR s parse-term is-prec-bitshift?))
-
-(define (parse-term s) (parse-with-chains s parse-rational is-prec-times? '(*)))
-
-(define (parse-rational s) (parse-LtoR s parse-unary is-prec-rational?))
-
-(define (parse-pipes s)    (parse-LtoR s parse-range is-prec-pipe?))
-
-(define (parse-comparison s)
-  (let loop ((ex (parse-pipes s))
-             (first #t))
+(define (parse-with-chains-warn s down ops chain-ops)
+  (let loop ((ex (down s))
+             (got #f))
     (let ((t (peek-token s)))
-      (cond ((is-prec-comparison? t)
-             (begin (take-token s)
-                    (if first
-                        (loop (list 'comparison ex t (parse-pipes s)) #f)
-                        (loop (append ex (list t (parse-pipes s))) #f))))
-            (first ex)
-            ((length= ex 4)
-             ;; only a single comparison; special chained syntax not required
-             (let ((op   (caddr ex))
-                   (arg1 (cadr ex))
-                   (arg2 (cadddr ex)))
-               (if (or (eq? op '|<:|) (eq? op '|>:|))
-                   `(,op ,arg1 ,arg2)
-                   `(call ,op ,arg1 ,arg2))))
-            (else ex)))))
+      (if (not (ops t))
+          (cons ex got)
+          (let ((spc (ts:space? s)))
+            (take-token s)
+            (cond ((and space-sensitive spc (memq t unary-and-binary-ops)
+                        (not (eqv? (peek-char (ts:port s)) #\ )))
+                   ;; here we have "x -y"
+                   (ts:put-back! s t spc)
+                   (cons ex got))
+                  ((memq t chain-ops)
+                   (loop (list* 'call t ex
+                                (parse-chain s down t))
+                         #t))
+                  (else
+                   (loop (list 'call t ex (down s))
+                         got))))))))
+
+(define (parse-expr s)     (parse-with-chains s parse-shift         is-prec-plus? '(+ ++)))
+
+(define (bitshift-warn s)
+  (syntax-deprecation s (string "call to `*` inside call to bitshift operator")
+                      "parenthesized call to `*`"))
+
+(define (parse-shift s)    #;(parse-LtoR        s parse-term          is-prec-bitshift?)
+  (let loop ((ex (parse-term s))
+             (t  (peek-token s))
+             (warn1 #f))
+    (let ((ex (car ex))
+          (warn (cdr ex)))
+      (if (is-prec-bitshift? t)
+          (begin (if warn (bitshift-warn s))
+                 (take-token s)
+                 (let ((nxt (parse-term s)))
+                   (loop (cons (list 'call t ex (car nxt)) (cdr nxt)) (peek-token s) (cdr nxt))))
+          (begin (if warn1 (bitshift-warn s))
+                 ex)))))
+
+(define (parse-term s)     (parse-with-chains-warn s parse-rational      is-prec-times? '(*)))
+(define (parse-rational s) (parse-LtoR        s parse-unary-subtype is-prec-rational?))
+
+;; parse `<: A where B` as `<: (A where B)` (issue #21545)
+(define (parse-unary-subtype s)
+  (let* ((op  (require-token s))
+         (spc (ts:space? s)))
+    (if (or (eq? op '|<:|) (eq? op '|>:|))
+        (begin (take-token s)
+               (let ((next (peek-token s)))
+                 (cond ((or (closing-token? next) (newline? next) (eq? next '=))
+                        op)  ; return operator by itself, as in (<:)
+                       ;; parse <:{T}(x::T) or <:(x::T) like other unary operators
+                       ((or (eqv? next #\{) (eqv? next #\( ))
+                        (ts:put-back! s op spc)
+                        (parse-where s parse-unary))
+                       (else
+                        (let ((arg (parse-where s parse-unary)))
+                          (if (and (pair? arg) (eq? (car arg) 'tuple))
+                              (cons op (cdr arg))
+                              (list op arg)))))))
+        (parse-where s parse-unary))))
 
-(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 (parse-where-chain s first)
+  (with-bindings ((where-enabled #f))
+   (let loop ((ex first)
+              (t 'where))
+     (if (eq? t 'where)
+         (begin (take-token s)
+                (let ((var (parse-comparison s)))
+                  (loop (if (and (pair? var) (eq? (car var) 'braces))
+                            (list* 'where ex (cdr var))  ;; form `x where {T,S}`
+                            (list 'where ex var))
+                        (peek-token s))))
+         ex))))
+
+(define (parse-where s down)
+  ;; `where` needs to be below unary for `+(x::T,y::T) where {T} = ...` to work
+  (let ((ex (down s)))
+    (if (and where-enabled
+             (eq? (peek-token s) 'where))
+        (parse-where-chain s ex)
+        ex)))
 
 (define (maybe-negate op num)
   (if (eq? op '-)
       (if (large-number? num)
-          (if (eqv? (caddr num) "-170141183460469231731687303715884105728")
-              `(macrocall @big_str "170141183460469231731687303715884105728")
-              `(,(car num) ,(cadr num) ,(string.tail (caddr num) 1)))
+          (if (eqv? (cadddr num) "-170141183460469231731687303715884105728")
+              `(macrocall @big_str (null) "170141183460469231731687303715884105728")
+              `(,(car num) ,(cadr num) ,(caddr num) ,(string.tail (cadddr num) 1)))
           (if (= num -9223372036854775808)
-              `(macrocall @int128_str "9223372036854775808")
+              `(macrocall @int128_str (null) "9223372036854775808")
               (- num)))
       num))
 
+;; operators handled by parse-unary at the start of an expression
+(define initial-operator?
+  ;; TODO: ? should probably not be listed here except for the syntax hack in osutils.jl
+  (Set (diff operators (append '(: |'| ?) syntactic-unary-operators syntactic-operators))))
+
+(define (parse-unary s)
+  (let* ((op  (require-token s))
+         (spc (ts:space? s)))
+    (if (initial-operator? op)
+        (begin
+          (take-token s)
+          (if (or (eq? op '-) (eq? op '+))
+              (let ((nch (peek-char (ts:port s))))
+                (if (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)))
+                      (if (is-prec-power? (peek-token s))
+                          ;; -2^x parsed as (- (^ 2 x))
+                          (begin (ts:put-back! s (maybe-negate op num) spc)
+                                 (list 'call op (parse-factor s)))
+                          num))
+                    (parse-unary-call s op #t spc)))
+              (parse-unary-call s op (unary-op? op) spc)))
+        (parse-juxtapose (parse-factor s) s))))
+
+(define (parse-unary-call s op un spc)
+  (let ((next (peek-token s)))
+    (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 un) (eqv? next #\( )))
+           (ts:put-back! s op spc)
+           (parse-factor s))
+          ((not un)
+           (error (string "\"" op "\" is not a unary operator")))
+          (else
+           (let* ((arg  (parse-unary s))
+                  (args (if (and (pair? arg) (eq? (car arg) 'tuple))
+                            (cons op (cdr arg))
+                            (list op arg))))
+             (if (or (eq? op '|<:|) (eq? op '|>:|))
+                 args
+                 (cons 'call args)))))))
+
 ;; given an expression and the next token, is there a juxtaposition
 ;; operator between them?
 (define (juxtapose? s expr t)
   (and (or (number? expr)
            (large-number? expr)
-           (not (number? t))    ;; disallow "x.3" and "sqrt(2)2"
+           (and (not (number? t))    ;; disallow "x.3" and "sqrt(2)2"
+                (not (eqv? t #\@)))  ;; disallow "x@time"
            ;; to allow x'y as a special case
            #;(and (pair? expr) (memq (car expr) '(|'| |.'|))
                 (not (memv t '(#\( #\[ #\{))))
            )
        (not (ts:space? s))
        (not (operator? t))
-       (not (initial-reserved-word? t))
        (not (closing-token? t))
        (not (newline? t))
+       (or (not (string? expr))  ;; issue #20575
+           (error "cannot juxtapose string literal"))
+       (not (initial-reserved-word? t))
        (not (and (pair? expr) (syntactic-unary-op? (car expr))))
        ;; TODO: this would disallow juxtaposition with 0, which is ambiguous
        ;; with e.g. hex literals `0x...`. however this is used for `0im`, which
@@ -894,69 +1052,18 @@
              `(call * ,ex ,(parse-unary s))))
           (else ex))))
 
-(define (invalid-identifier-name? ex)
-  (or (syntactic-op? ex) (eq? ex '....)))
-
-(define (parse-unary s)
-  (let ((t (require-token s)))
-    (if (closing-token? t)
-        (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)))
-           (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)))
-                   (if (is-prec-power? (peek-token s))
-                       ;; -2^x parsed as (- (^ 2 x))
-                       (begin (ts:put-back! s (maybe-negate op num))
-                              (list 'call op (parse-factor s)))
-                       num))
-                 (let ((next (peek-token s)))
-                   (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 #\( )))
-                          (ts:put-back! s op)
-                          (parse-factor s))
-                         ((not (memq op unary-ops))
-                          (error (string "\"" op "\" is not a unary operator")))
-                         (else
-                          (let ((arg (parse-unary s)))
-                            (if (and (pair? arg)
-                                     (eq? (car arg) 'tuple))
-                                (list* 'call op (cdr arg))
-                                (list  'call op arg)))))))))
-          (else
-           (parse-juxtapose (parse-factor s) s)))))
-
 ;; handle ^ and .^
-(define (parse-factor-h s down ops)
-  (let ((ex (down s))
-        (t (peek-token s)))
-    (cond ((not (ops t))
-           ex)
-          (else
-           (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)
-(define (parse-factor s)
-  (parse-factor-h s parse-decl is-prec-power?))
+(define (parse-factor s)       (parse-RtoL s parse-decl  is-prec-power? #f parse-factor-after))
+(define (parse-factor-after s) (parse-RtoL s parse-unary is-prec-power? #f parse-factor-after))
 
 (define (parse-decl s)
-  (let loop ((ex (parse-where s)))
+  (let loop ((ex (parse-call s)))
     (let ((t (peek-token s)))
       (case t
         ((|::|) (take-token s)
-         (loop (list t ex (parse-where s))))
+         (loop (list t ex (parse-where s parse-call))))
         ((->)   (take-token s)
          ;; -> is unusual: it binds tightly on the left and
          ;; loosely on the right.
@@ -965,24 +1072,26 @@
         (else
          ex)))))
 
-(define (parse-unary-prefix s)
-  (let ((op (peek-token s)))
-    (if (syntactic-unary-op? op)
-        (begin (take-token s)
-               (cond ((let ((next (peek-token s)))
-                        (or (closing-token? next) (newline? next))) op)
-                     ((memq op '(& |::|))  (list op (parse-where s)))
-                     (else                 (list op (parse-unary-prefix s)))))
-        (parse-atom s))))
-
 ;; parse function call, indexing, dot, and transpose expressions
 ;; also handles looking for syntactic reserved words
 (define (parse-call s)
   (let ((ex (parse-unary-prefix s)))
-    (if (or (initial-reserved-word? ex) (memq ex '(mutable primitive)))
+    (if (or (initial-reserved-word? ex) (eq? ex 'mutable) (eq? ex 'primitive))
         (parse-resword s ex)
         (parse-call-chain s ex #f))))
 
+(define (parse-unary-prefix s)
+  (let ((op (peek-token s)))
+    (if (syntactic-unary-op? op)
+        (begin (take-token s)
+               (cond ((and (memq op '(& $))
+                           (let ((next (peek-token s)))
+                             (or (closing-token? next) (newline? next))))
+                      op)
+                     ((memq op '(& |::|))  (list op (parse-where s parse-call)))
+                     (else                 (list op (parse-unary-prefix s)))))
+        (parse-atom s))))
+
 (define (parse-def s is-func)
   (let* ((ex (parse-unary-prefix s))
          (sig (if (or (and is-func (reserved-word? ex)) (initial-reserved-word? ex))
@@ -1020,34 +1129,32 @@
             ((#\( )
              (if (ts:space? s) (disallowed-space ex t))
              (take-token s)
-             (if macrocall?
-                 (let ((args (if (eqv? (require-token s) #\) )
-                                 (begin (take-token s) '())
-                                 (begin0 (with-normal-ops
-                                          (with-whitespace-newline
-                                           (parse-comma-separated s parse-eq* #t)))
-                                         (if (not (eqv? (require-token s) #\) ))
-                                             (error "missing ) in argument list"))
-                                         (take-token s)))))
-                   `(call ,ex ,@args))
-                 (loop (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)))))))
+             (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 macrocall?
+                   (map (lambda (x)  ;; parse `a=b` as `=` instead of `kw` in macrocall
+                          (if (and (pair? x) (eq? (car x) 'kw))
+                              `(= ,@(cdr x))
+                              x))
+                        c)
+                   (loop c))))
             ((#\[ )
              (if (ts:space? s) (disallowed-space ex t))
              (take-token s)
              ;; ref is syntax, so we can distinguish
              ;; a[i] = x  from
              ;; ref(a,i) = x
-             (let ((al (with-end-symbol (parse-cat s #\]))))
+             (let* ((es end-symbol)
+                    (al (with-end-symbol (parse-cat s #\] es))))
                (if (null? al)
                    (loop (list 'ref ex))
                    (case (car al)
@@ -1077,7 +1184,7 @@
                     (else
                      (let ((name (parse-atom s)))
                        (if (and (pair? name) (eq? (car name) 'macrocall))
-                           `(macrocall (|.| ,ex (quote ,(cadr name)))
+                           `(macrocall (|.| ,ex (quote ,(cadr name))) ; move macrocall outside by rewriting A.@B as @A.B
                                        ,@(cddr name))
                            `(|.| ,ex (quote ,name))))))))
             ((|.'| |'|)
@@ -1094,16 +1201,17 @@
                       (not (operator? ex))
                       (not (ts:space? s)))
                  ;; custom string and command literals; x"s" => @x_str "s"
-                 (let* ((macstr (begin (take-token s)
+                 (let* ((startloc  (line-number-node s))
+                        (macstr (begin (take-token s)
                                        (parse-raw-literal s t)))
                         (nxt (peek-token s))
                         (macname (macroify-name ex (macsuffix t))))
                    (if (and (symbol? nxt) (not (operator? nxt))
                             (not (ts:space? s)))
                        ;; string literal suffix, "s"x
-                       (loop `(macrocall ,macname ,macstr
+                       (loop `(macrocall ,macname ,startloc ,macstr
                                          ,(string (take-token s))))
-                       (loop `(macrocall ,macname ,macstr))))
+                       (loop `(macrocall ,macname ,startloc ,macstr))))
                  ex))
             (else ex))))))
 
@@ -1135,6 +1243,16 @@
            (and (eq? (car sig) 'where)
                 (valid-func-sig? paren (cadr sig))))))
 
+(define (unwrap-where x)
+  (if (and (pair? x) (eq? (car x) 'where))
+      (unwrap-where (cadr x))
+      x))
+
+(define (rewrap-where x w)
+  (if (and (pair? w) (eq? (car w) 'where))
+      (list 'where (rewrap-where x (cadr w)) (caddr w))
+      x))
+
 (define (parse-struct-def s mut? word)
   (if (reserved-word? (peek-token s))
       (error (string "invalid type name \"" (take-token s) "\"")))
@@ -1142,12 +1260,20 @@
     (begin0 (list 'type (if mut? 'true 'false) sig (parse-block s))
             (expect-end s word))))
 
+;; consume any number of line endings from a token stream
+(define (take-lineendings s)
+  (let ((nt (peek-token s)))
+    (if (or (newline? nt) (eqv? nt #\;))
+        (begin (take-token s)
+               (take-lineendings s))
+        s)))
+
 ;; parse expressions or blocks introduced by syntactic reserved words
 (define (parse-resword s word)
   (with-bindings
    ((expect-end-current-line (input-port-line (ts:port s))))
-   (with-normal-ops
-    (without-whitespace-newline
+   (with-normal-context
+    (begin
      (case word
        ((begin quote)
         (let ((loc  (begin (skip-ws-and-comments (ts:port s))
@@ -1211,23 +1337,12 @@
                 `(let ,ex ,@binds)))))
 
        ((global local)
-        (let* ((lno (input-port-line (ts:port s)))
-               (const (and (eq? (peek-token s) 'const)
+        (let* ((const (and (eq? (peek-token s) 'const)
                            (take-token s)))
-               (expr  (cons word
-			    (parse-comma-separated-assignments s))))
-          ;; issue #7314
-          (if (and (length> expr 2) (any assignment? (cdr expr)))
-              (if (every assignment? (cdr expr))
-                  (syntax-deprecation s (deparse expr)
-                                      (string word " "
-                                              (string.join (map deparse (map cadr (cdr expr))) ", ")
-                                              " = "
-                                              (string.join (map deparse (map caddr (cdr expr))) ", ")))
-                  (syntax-deprecation s (deparse expr)
-                                      (string.join (map (lambda (x) (string word " " (deparse x)))
-                                                        (cdr expr))
-                                                   "; "))))
+               (assgn (parse-eq s))
+               (expr  (if (and (pair? assgn) (eq? (car assgn) 'tuple))
+                          (cons word (cdr assgn))
+                          (list word assgn))))
           (if const
               `(const ,expr)
               expr)))
@@ -1248,18 +1363,19 @@
                          (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 (valid-func-sig? paren sig))
-                                    (error (string "expected \"(\" in " word " definition"))
-                                    sig)))
-                     (body  (parse-block s)))
+              (let* ((usig (unwrap-where sig))
+                     (def  (if (or (symbol? usig)
+                                   (and (pair? usig) (eq? (car usig) '|::|)
+                                        (symbol? (cadr usig))))
+                               (if paren
+                                   ;; in "function (x)" the (x) is a tuple
+                                   (rewrap-where `(tuple ,usig) sig)
+                                   ;; function foo  =>  syntax error
+                                   (error (string "expected \"(\" in " word " definition")))
+                               (if (not (valid-func-sig? paren sig))
+                                   (error (string "expected \"(\" in " word " definition"))
+                                   sig)))
+                     (body (parse-block s)))
                 (expect-end s word)
                 (list word def body)))))
 
@@ -1272,7 +1388,7 @@
                 (syntax-deprecation s (string "abstract " (deparse spec))
                                     (string "abstract type " (deparse spec) " end")))
             (begin0 (list 'abstract spec)
-                    (if ty (expect-end s "abstract type"))))))
+                    (if ty (expect-end (take-lineendings s) "abstract type"))))))
        ((struct)
         (begin (take-token s)
                (parse-struct-def s #f word)))
@@ -1288,14 +1404,13 @@
                    (let* ((spec (with-space-sensitive (parse-subtype-spec s)))
                           (nb   (with-space-sensitive (parse-cond s))))
                      (begin0 (list 'bitstype nb spec)
-                             (expect-end s "primitive type"))))))
+                             (expect-end (take-lineendings s) "primitive type"))))))
        ;; deprecated type keywords
        ((type)
-        ;; TODO fully deprecate post-0.6
-        ;;(syntax-deprecation s "type" "mutable struct")
+        (syntax-deprecation s "type" "mutable struct")  ;; retain in 0.7
         (parse-struct-def s #t word))
        ((immutable)
-        ;;(syntax-deprecation s "immutable" "struct")
+        (syntax-deprecation s "immutable" "struct")  ;; retain in 0.7
         (parse-struct-def s #f word))
        ((bitstype)
         (let* ((nb   (with-space-sensitive (parse-cond s)))
@@ -1305,7 +1420,7 @@
           (list 'bitstype nb spec)))
        ((typealias)
         (let ((lhs (with-space-sensitive (parse-call s)))
-              (rhs (parse-where s)))
+              (rhs (parse-where s parse-call)))
           (syntax-deprecation s (string "typealias " (deparse lhs) " " (deparse rhs))
                               (string (if (symbol? lhs) "const " "")
                                       (deparse lhs) " = " (deparse rhs)))
@@ -1436,7 +1551,7 @@
 
 (define (parse-import-dots s)
   (let loop ((l '())
-             (t (peek-token s)))
+             (t (require-token s)))  ;; skip newlines
     (cond ((eq? t '|.|)
            (begin (take-token s)
                   (loop (list* '|.| l) (peek-token s))))
@@ -1473,15 +1588,13 @@
         `(,word ,@(reverse path)))))))
 
 ;; parse comma-separated assignments, like "i=1:n,j=1:m,..."
-(define (parse-comma-separated s what (in-parens #f))
+(define (parse-comma-separated s what)
   (let loop ((exprs '()))
     (let ((r (what s)))
       (case (peek-token s)
         ((#\,)
          (take-token s)
-         (if (and in-parens (eqv? (require-token s) #\) ))
-             (reverse! (cons r exprs))
-             (loop (cons r exprs))))
+         (loop (cons r exprs)))
         (else   (reverse! (cons r exprs)))))))
 
 (define (parse-comma-separated-assignments s)
@@ -1566,6 +1679,7 @@
                       ((eqv? c #\;)     (loop (cons nxt lst)))
                       ((eqv? c closer)  (loop (cons nxt lst)))
                       ((eq? c 'for)
+                       (expect-space-before s 'for)
                        (take-token s)
                        (loop (cons (parse-generator s nxt) lst)))
                       ;; newline character isn't detectable here
@@ -1609,7 +1723,8 @@
                             (list `(filter ,(parse-cond s) ,@iters)))
                      iters)))
       (if (eq? (peek-token s) 'for)
-          (begin (take-token s)
+          (begin (expect-space-before s 'for)
+                 (take-token s)
                  `(flatten (generator ,(parse-generator s first) ,@iters)))
           `(generator ,first ,@iters)))))
 
@@ -1621,13 +1736,15 @@
          (take-token s))
      `(comprehension ,gen))))
 
-(define (parse-matrix s first closer gotnewline)
+(define (parse-matrix s first closer gotnewline last-end-symbol)
   (define (fix head v) (cons head (reverse v)))
   (define (update-outer v outer)
     (cond ((null? v)       outer)
           ((null? (cdr v)) (cons (car v) outer))
           (else            (cons (fix 'row v) outer))))
   (define semicolon (eqv? (peek-token s) #\;))
+  ;; if a [ ] expression is a cat expression, `end` is not special
+  (with-bindings ((end-symbol last-end-symbol))
   (let loop ((vec   (list first))
              (outer '()))
     (let ((t  (if (or (eqv? (peek-token s) #\newline) gotnewline)
@@ -1653,11 +1770,15 @@
              (if (and (not semicolon)
                       (length= outer 1)
                       (null? vec))
-                 (begin (take-token s)
+                 (begin (expect-space-before s 'for)
+                        (take-token s)
                         (parse-comprehension s (car outer) closer))
                  (error "invalid comprehension syntax")))
             (else
-             (loop (cons (parse-eq* s) vec) outer)))))))
+             (if (and (pair? vec) (not (ts:space? s)))
+                 (error (string "expected separator between arguments to \"[ ]\"; got \""
+                                (deparse (car vec)) t "\"")))
+             (loop (cons (parse-eq* s) vec) outer))))))))
 
 (define (peek-non-newline-token s)
   (let loop ((t (peek-token s)))
@@ -1666,7 +1787,11 @@
                (loop (peek-token s)))
         t)))
 
-(define (parse-cat s closer)
+(define (expect-space-before s t)
+  (if (not (ts:space? s))
+      (error (string "expected space before \"" t "\""))))
+
+(define (parse-cat s closer last-end-symbol)
   (with-normal-ops
    (with-inside-vec
     (if (eqv? (require-token s) closer)
@@ -1677,15 +1802,16 @@
           (cond ((or (eqv? t #\,) (eqv? t closer))
                  (parse-vect s first closer))
                 ((eq? t 'for)
+                 (expect-space-before s 'for)
                  (take-token s)
                  (parse-comprehension s first closer))
                 ((eqv? t #\newline)
                  (take-token s)
                  (if (memv (peek-token s) (list #\, closer))
                      (parse-vect s first closer)
-                     (parse-matrix s first closer #t)))
+                     (parse-matrix s first closer #t last-end-symbol)))
                 (else
-                 (parse-matrix s first closer #f))))))))
+                 (parse-matrix s first closer #f last-end-symbol))))))))
 
 (define (kw-to-= e) (if (kwarg? e) (cons '= (cdr e)) e))
 (define (=-to-kw e) (if (assignment? e) (cons 'kw (cdr e)) e))
@@ -1933,9 +2059,11 @@
      ;; process escape sequences using lisp read
      (read (open-input-string (string #\" s #\"))))))
 
-(define (check-identifier ex)
-  (if (invalid-identifier-name? ex)
-      (error (string "invalid identifier name \"" ex "\""))))
+(define-macro (check-identifier ex)
+  `(begin (if (or (syntactic-op? ,ex) (eq? ,ex '....))
+              (error (string "invalid identifier name \"" ,ex "\"")))
+          (if (eq? ,ex '?)
+              (syntax-deprecation s "`?` used as an identifier" "")))) ; merge with above check in v1.0
 
 ;; parse numbers, identifiers, parenthesized expressions, lists, vectors, etc.
 (define (parse-atom s (checked #t))
@@ -1988,19 +2116,25 @@
 
           ;; identifier
           ((symbol? t)
-           (if checked (check-identifier t))
+           (if checked
+               (begin (check-identifier t)
+                      (if (closing-token? t)
+                          (error (string "unexpected \"" (take-token s) "\"")))))
            (take-token s))
 
           ;; parens or tuple
           ((eqv? t #\( )
            (take-token s)
-           (with-normal-ops
-            (with-whitespace-newline
+           (with-bindings ((range-colon-enabled #t)
+                           (space-sensitive #f)
+                           (where-enabled #t)
+                           (whitespace-newline #t))
+            (let ((nxt (require-token s)))
              (cond
-              ((eqv? (require-token s) #\) )
+              ((eqv? nxt #\) )
                ;; empty tuple ()
                (begin (take-token s) '(tuple)))
-              ((syntactic-op? (peek-token s))
+              ((syntactic-op? nxt)
                ;; allow (=) etc.
                (let ((tok (take-token s)))
                  (if (not (eqv? (require-token s) #\) ))
@@ -2008,7 +2142,14 @@
                      (take-token s))
                  (if checked (check-identifier tok))
                  tok))
-              ((eqv? (peek-token s) #\;)
+              ;; allow :(::) as a special case
+              ((and (not checked) (eq? nxt '|::|)
+                    (let ((spc (ts:space? s)))
+                      (or (and (take-token s) (eqv? (require-token s) #\) ))
+                          (and (ts:put-back! s '|::| spc) #f))))
+               (take-token s)  ;; take #\)
+               '|::|)
+              ((eqv? nxt #\;)
                (arglist-to-tuple #t #f (parse-arglist s #\) )))
               (else
                ;; here we parse the first subexpression separately, so
@@ -2024,6 +2165,7 @@
                             ;; value in parentheses (x)
                             ex))
                        ((eq? t 'for)
+                        (expect-space-before s 'for)
                         (take-token s)
                         (let ((gen (parse-generator s ex)))
                           (if (eqv? (require-token s) #\) )
@@ -2041,32 +2183,22 @@
           ;; cat expression
           ((eqv? t #\[ )
            (take-token s)
-           (let ((vex (parse-cat s #\])))
+           (let ((vex (parse-cat s #\] end-symbol)))
              (if (null? vex) '(vect) vex)))
 
           ((eqv? t #\{ )
            (take-token s)
            (if (eqv? (require-token s) #\})
                (begin (take-token s)
-                      '(cell1d))
-               (let ((vex (parse-cat s #\})))
+                      '(braces))
+               (let ((vex (parse-cat s #\} end-symbol)))
                  (if (null? vex)
-                     '(cell1d)
+                     '(braces)
                      (case (car vex)
-                       ((vect) `(cell1d ,@(cdr vex)))
-                       ((hcat) `(cell2d 1 ,(length (cdr vex)) ,@(cdr vex)))
-                       ((comprehension)      (error "{a for a in b} syntax is discontinued"))
-                       (else
-                        (if (and (pair? (cadr vex)) (eq? (caadr vex) 'row))
-                            (let ((nr (length (cdr vex)))
-                                  (nc (length (cdadr vex))))
-                              (begin
-                                `(cell2d ,nr ,nc
-                                         ,@(apply append
-                                                  ;; transpose to storage order
-                                                  (apply map list
-                                                         (map cdr (cdr vex)))))))
-                            `(cell1d ,@(cdr vex)))))))))
+                       ((vect) `(braces ,@(cdr vex)))
+                       ((hcat) `(bracescat (row ,@(cdr vex))))
+                       ((comprehension) `(braces ,@(cdr vex)))
+                       (else   `(bracescat ,@(cdr vex))))))))
 
           ;; string literal
           ((eqv? t #\")
@@ -2082,30 +2214,36 @@
           ;; macro call
           ((eqv? t #\@)
            (take-token s)
+           (let ((nxt (peek-token s)))
+             (if (ts:space? s)
+                 (disallowed-space '@ nxt)))
            (with-space-sensitive
-            (let ((head (if (eq? (peek-token s) '|.|)
+            (let ((startloc  (line-number-node s))
+                  (head (if (eq? (peek-token s) '|.|)
                             (begin (take-token s) '__dot__)
                             (parse-unary-prefix s))))
-              (if (eq? head '__LINE__)
-                  (input-port-line (ts:port s))
-                  (begin
-                    (peek-token s)
-                    (if (ts:space? s)
-                        `(macrocall ,(macroify-name head)
-                                    ,@(parse-space-separated-exprs s))
-                        (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))))))))))
-
+              (peek-token s)
+              (if (ts:space? s)
+                  `(macrocall ,(macroify-name head)
+                              ,startloc
+                              ,@(parse-space-separated-exprs s))
+                  (let ((call (parse-call-chain s head #t)))
+                    (if (and (pair? call) (eq? (car call) 'call))
+                        `(macrocall ,(macroify-name (cadr call))
+                                    ,startloc
+                                    ,@(cddr call))
+                        `(macrocall ,(macroify-name call)
+                                    ,startloc
+                                    ,@(parse-space-separated-exprs s))))))))
           ;; command syntax
           ((eqv? t #\`)
            (take-token s)
-           `(macrocall @cmd ,(parse-raw-literal s #\`)))
+           `(macrocall @cmd ,(line-number-node s) ,(parse-raw-literal s #\`)))
 
           ((or (string? t) (number? t) (large-number? t)) (take-token s))
 
+          ((closing-token? t) (error (string "unexpected \"" (take-token s) "\"")))
+
           (else (error (string "invalid syntax: \"" (take-token s) "\""))))))
 
 (define (valid-modref? e)
@@ -2119,7 +2257,7 @@
         ((valid-modref? e)
          `(|.| ,(cadr e)
                (quote ,(apply macroify-name (cadr (caddr e)) suffixes))))
-        (else (error (string "invalid macro use \"@(" (deparse e) ")\"" )))))
+        (else (error (string "invalid macro usage \"@(" (deparse e) ")\"" )))))
 
 (define (simple-string-literal? e) (string? e))
 
@@ -2128,16 +2266,20 @@
       (and (pair? e) (eq? 'string (car e))) ; string interpolation
       (and (length= e 3) (eq? (car e) 'macrocall)
            (simple-string-literal? (caddr e))
+           (eq? (cadr e) '@doc_str))
+      (and (length= e 4) (eq? (car e) 'macrocall)
+           (simple-string-literal? (cadddr e))
            (eq? (cadr e) '@doc_str))))
 
 (define (parse-docstring s production)
-  (let* ((ex (production s)))
+  (let ((startloc (line-number-node s)) ; be sure to use the line number from the head of the docstring
+        (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))))
-        `(macrocall (core @doc) ,ex ,(production s))
+        `(macrocall (core @doc) ,startloc ,ex ,(production s))
         ex)))
 
 ;; --- main entry point ---
diff --git a/src/julia-syntax.scm b/src/julia-syntax.scm
index 452c2688c565e5..f597ed673ee3df 100644
--- a/src/julia-syntax.scm
+++ b/src/julia-syntax.scm
@@ -164,7 +164,7 @@
                   `(block ,body))))
     `(lambda ,argl ()
              (scope-block
-              ,(if (eq? rett 'Any)
+              ,(if (equal? rett '(core Any))
                    body
                    (let ((meta (take-while (lambda (x) (and (pair? x)
                                                             (memq (car x) '(line meta))))
@@ -228,15 +228,16 @@
 
 ;; extract static parameter names from a (method ...) expression
 (define (method-expr-static-parameters m)
-  (if (eq? (car (caddr m)) 'block)
-      (let ((lst '()))
-        (pattern-replace
-         (pattern-set
-          (pattern-lambda (= v (call (core (-/ TypeVar)) (quote T) ...))
-                          (begin (set! lst (cons T lst)) __)))
-         (butlast (cdr (caddr m))))
-        (reverse! lst))
-      '()))
+  (let ((type-ex (caddr m)))
+    (if (eq? (car type-ex) 'block)
+        ;; extract ssavalue labels of sparams from the svec-of-sparams argument to `method`
+        (let ((sp-ssavals (cddr (last (last type-ex)))))
+          (map (lambda (a)  ;; extract T from (= v (call (core TypeVar) (quote T) ...))
+                 (cadr (caddr (caddr a))))
+               (filter (lambda (e)
+                         (and (pair? e) (eq? (car e) '=) (member (cadr e) sp-ssavals)))
+                       (cdr type-ex))))
+        '())))
 
 ;; expressions of the form a.b.c... where everything is a symbol
 (define (sym-ref? e)
@@ -299,7 +300,7 @@
 
 ;; 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 (rett 'Any))
+(define (method-def-expr- name sparams argl body isstaged (rett '(core Any)))
   (if
    (any kwarg? argl)
    ;; has optional positional args
@@ -366,17 +367,23 @@
            `(block (method ,name) ,mdef (unnecessary ,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)))
-      (eq? x 'true) (eq? x 'false)))
+;; wrap expr in nested scopes assigning names to vals
+(define (scopenest names vals expr)
+  (if (null? names)
+      expr
+      `(let (block
+             ,(scopenest (cdr names) (cdr vals) expr))
+         (= ,(car names) ,(car vals)))))
 
 (define empty-vector-any '(call (core AnyVector) 0))
 
 (define (keywords-method-def-expr name sparams argl body isstaged rett)
   (let* ((kargl (cdar argl))  ;; keyword expressions (= k v)
+         (annotations (map (lambda (a) `(meta nospecialize ,(arg-name (cadr (caddr a)))))
+                           (filter nospecialize-meta? kargl)))
+         (kargl (map (lambda (a)
+                       (if (nospecialize-meta? a) (caddr a) a))
+                     kargl))
          (pargl (cdr argl))   ;; positional args
          (body  (if (and (pair? body) (eq? (car body) 'block))
                     body
@@ -428,24 +435,23 @@
           (rkw (if (null? restkw) '() (symbol (string (car restkw) "..."))))
           (mangled (symbol (string "#" (if name (undot-name name) 'call) "#"
                                    (string (current-julia-module-counter)))))
-          (flags (map (lambda (x) (gensy)) vals)))
+          (tempnames (map (lambda (x) (gensy)) keynames)))
       `(block
         ;; call with no keyword args
         ,(method-def-expr-
           name positional-sparams (append pargl vararg)
           `(block
             ,@prologue
-            ,@(if (not ordered-defaults)
-                  '()
-                  (append! (map (lambda (kwname) `(local ,kwname)) keynames)
-                           (map make-assignment keynames vals)))
-            ;; call mangled(vals..., [rest_kw,] pargs..., [vararg]...)
-            (return (call ,mangled
-                          ,@(if ordered-defaults keynames vals)
-                          ,@(if (null? restkw) '() (list empty-vector-any))
-                          ,@(map arg-name pargl)
-                          ,@(if (null? vararg) '()
-                                (list `(... ,(arg-name (car vararg))))))))
+            ,(let (;; call mangled(vals..., [rest_kw,] pargs..., [vararg]...)
+                   (ret `(return (call ,mangled
+                                       ,@(if ordered-defaults keynames vals)
+                                       ,@(if (null? restkw) '() (list empty-vector-any))
+                                       ,@(map arg-name pargl)
+                                       ,@(if (null? vararg) '()
+                                             (list `(... ,(arg-name (car vararg)))))))))
+               (if ordered-defaults
+                   (scopenest keynames vals ret)
+                   ret)))
           #f)
 
         ;; call with keyword args pre-sorted - original method code goes here
@@ -462,28 +468,24 @@
                      (decl-var (car not-optional)))
                  (car not-optional))
             ,@(cdr not-optional) ,@vararg)
-          `(block
-            ,@stmts) isstaged rett)
+          (insert-after-meta `(block
+                               ,@stmts)
+                             annotations)
+          isstaged rett)
 
         ;; call with unsorted keyword args. this sorts and re-dispatches.
         ,(method-def-expr-
           name
-          (filter ;; remove sparams that don't occur, to avoid printing the warning twice
-           (lambda (s) (expr-contains-eq (car s) (cons 'list argl)))
-           positional-sparams)
+          ;; remove sparams that don't occur, to avoid printing the warning twice
+          (filter-sparams (cons 'list argl) positional-sparams)
           `((|::|
              ;; if there are optional positional args, we need to be able to reference the function name
              ,(if (any kwarg? pargl) (gensy) UNUSED)
              (call (core kwftype) ,ftype)) (:: ,kw (core AnyVector)) ,@pargl ,@vararg)
           `(block
-            ;; initialize keyword args to their defaults, or set a flag telling
-            ;; whether this keyword needs to be set.
-            ,@(map (lambda (kwname) `(local ,kwname)) keynames)
-            ,@(map (lambda (name dflt flag)
-                     (if (const-default? dflt)
-                         `(= ,name ,dflt)
-                         `(= ,flag true)))
-                   keynames vals flags)
+            ;; temp variables that will be assigned if their corresponding keywords are passed.
+            ;; `isdefined` is then used to check whether default values should be evaluated.
+            ,@(map (lambda (v) `(local ,v)) tempnames)
             ,@(if (null? restkw) '()
                   `((= ,rkw ,empty-vector-any)))
             ;; for i = 1:(length(kw)>>1)
@@ -492,8 +494,8 @@
                   ;; ii = i*2 - 1
                   (= ,ii (call (top -) (call (top *) ,i 2) 1))
                   (= ,elt (call (core arrayref) ,kw ,ii))
-                  ,(foldl (lambda (kvf else)
-                            (let* ((k    (car kvf))
+                  ,(foldl (lambda (kn else)
+                            (let* ((k     (car kn))
                                    (rval0 `(call (core arrayref) ,kw
                                                  (call (top +) ,ii 1)))
                                    ;; note: if the "declared" type of a KW arg
@@ -506,17 +508,24 @@
                                                   (not (any (lambda (s)
                                                               (expr-contains-eq (car s) (caddr k)))
                                                             keyword-sparams)))
-                                             `(call (core typeassert)
-                                                    ,rval0
-                                                    ,(caddr k))
+                                             (let ((T (caddr k)))
+                                               `(call (core typeassert)
+                                                      ,rval0
+                                                      ;; work around `ANY` not being a type. if arg type
+                                                      ;; looks like `ANY`, test whether it is `ANY` at run
+                                                      ;; time and if so, substitute `Any`. issue #21510
+                                                      ,(if (or (eq? T 'ANY)
+                                                               (and (globalref? T)
+                                                                    (eq? (caddr T) 'ANY)))
+                                                           `(call (|.| (core Intrinsics) 'select_value)
+                                                                  (call (core ===) ,T (core ANY))
+                                                                  (core Any)
+                                                                  ,T)
+                                                           T)))
                                              rval0)))
-                              ;; if kw[ii] == 'k; k = kw[ii+1]::Type; end
-                              `(if (comparison ,elt === (quote ,(decl-var k)))
-                                   (block
-                                    (= ,(decl-var k) ,rval)
-                                    ,@(if (not (const-default? (cadr kvf)))
-                                          `((= ,(caddr kvf) false))
-                                          '()))
+                              ;; if kw[ii] == 'k; k_temp = kw[ii+1]::Type; end
+                              `(if (comparison ,elt === (quote ,(cdr kn)))
+                                   (= ,(decl-var k) ,rval)
                                    ,else)))
                           (if (null? restkw)
                               ;; if no rest kw, give error for unrecognized
@@ -525,24 +534,26 @@
                                            (list `(... ,(arg-name (car vararg))))))
                               ;; otherwise add to rest keywords
                               `(foreigncall 'jl_array_ptr_1d_push (core Void) (call (core svec) Any Any)
-                                      ,rkw 0 (tuple ,elt
-                                                  (call (core arrayref) ,kw
-                                                        (call (top +) ,ii 1))) 0))
-                          (map list vars vals flags))))
+                                            'ccall 2
+                                            ,rkw (tuple ,elt
+                                                        (call (core arrayref) ,kw
+                                                              (call (top +) ,ii 1)))))
+                          (map (lambda (k temp)
+                                 (cons (if (decl? k) `(,(car k) ,temp ,(caddr k)) temp)
+                                       (decl-var k)))
+                               vars tempnames))))
             ;; set keywords that weren't present to their default values
-            ,@(apply append
-                     (map (lambda (name dflt flag)
-                            (if (const-default? dflt)
-                                '()
-                                `((if ,flag (= ,name ,dflt)))))
-                          keynames vals flags))
-            ;; finally, call the core function
-            (return (call ,mangled
-                          ,@keynames
-                          ,@(if (null? restkw) '() (list rkw))
-                          ,@(map arg-name pargl)
-                          ,@(if (null? vararg) '()
-                                (list `(... ,(arg-name (car vararg))))))))
+            ,(scopenest keynames
+                        (map (lambda (v dflt) `(if (isdefined ,v)
+                                                   ,v
+                                                   ,dflt))
+                             tempnames vals)
+                        `(return (call ,mangled  ;; finally, call the core function
+                                       ,@keynames
+                                       ,@(if (null? restkw) '() (list rkw))
+                                       ,@(map arg-name pargl)
+                                       ,@(if (null? vararg) '()
+                                             (list `(... ,(arg-name (car vararg)))))))))
           #f)
         ;; return primary function
         ,(if (not (symbol? name))
@@ -556,16 +567,26 @@
                   (cdr body))
       '()))
 
+;; keep only sparams used by `expr` or other sparams
+(define (filter-sparams expr sparams)
+  (let loop ((filtered '())
+             (params   sparams))
+    (cond ((null? params)
+           (reverse! filtered))
+          ((or (expr-contains-eq (caar params) expr)
+               (any (lambda (v) (expr-contains-eq (caar params) v))
+                    (cdr params)))
+           (loop (cons (car params) filtered) (cdr params)))
+          (else
+           (loop filtered (cdr params))))))
+
 (define (optional-positional-defs name sparams req opt dfl body isstaged overall-argl rett)
   (let ((prologue (extract-method-prologue 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 (car sp)))
-                                                  passed))
-                                      sparams))
+                      (sp     (filter-sparams (cons 'list passed) sparams))
                       (vals   (list-tail dfl n))
                       (absent (list-tail opt n)) ;; absent arguments
                       (body
@@ -600,8 +621,9 @@
       argl))
 
 (define (check-kw-args kw)
-  (let ((invalid (filter (lambda (x) (not (or (kwarg? x)
-                                              (vararg? x))))
+  (let ((invalid (filter (lambda (x) (not (or (kwarg? x) (vararg? x)
+                                              (and (nospecialize-meta? x)
+                                                   (or (kwarg? (caddr x)) (vararg? (caddr x)))))))
                          kw)))
     (if (pair? invalid)
         (if (and (pair? (car invalid)) (eq? 'parameters (caar invalid)))
@@ -656,14 +678,21 @@
                      (block
                       ,@locs
                       (call new ,@field-names)))))
-    (if (and (null? params) (any (lambda (t) (not (eq? t 'Any))) field-types))
+    (if (and (null? params) (any (lambda (t) (not (equal? t '(core Any))))
+                                 field-types))
         (list
          ;; definition with field types for all arguments
-         `(function (call ,name
-                          ,@(map make-decl field-names field-types))
-                    (block
-                     ,@locs
-                     (call new ,@field-names)))
+         ;; only if any field type is not Any, checked at runtime
+         `(if ,(foldl (lambda (t u)
+                        `(&& ,u (call (core ===) (core Any) ,t)))
+                      `(call (core ===) (core Any) ,(car field-types))
+                      (cdr field-types))
+            (block)
+            (function (call ,name
+                            ,@(map make-decl field-names field-types))
+                      (block
+                        ,@locs
+                        (call new ,@field-names))))
          any-ctor)
         (list any-ctor))))
 
@@ -720,6 +749,11 @@
       `(,(car sig) ,item ,@(cdr sig))
       `(,item ,@sig)))
 
+(define (linenode-string lno)
+  (cond ((length= lno 2) (string " around line " (cadr lno)))
+        ((length= lno 3) (string " around " (caddr lno) ":" (cadr lno)))
+        (else "")))
+
 (define (ctor-signature name params bounds method-params sig)
   (if (null? params)
       (if (null? method-params)
@@ -748,29 +782,36 @@
          (curlyargs  (if curly? (cddr name) '()))
          (name       (if curly? (cadr name) name)))
     (cond ((not (eq? name Tname))
-           `(,keyword ,(with-wheres `(call (curly ,name ,@curlyargs) ,@sig) wheres)
+           `(,keyword ,(with-wheres `(call ,(if curly?
+                                                `(curly ,name ,@curlyargs)
+                                                name)
+                                           ,@sig)
+                                    wheres)
                       ;; pass '() in order to require user-specified parameters with
                       ;; new{...} inside a non-ctor inner definition.
                       ,(ctor-body body '())))
           (wheres
-           `(,keyword (where (call (curly ,name ,@curlyargs) ,@sig) ,@wheres)
+           `(,keyword ,(with-wheres `(call ,(if curly?
+                                                `(curly ,name ,@curlyargs)
+                                                name)
+                                           ,@sig)
+                                    wheres)
                       ,(ctor-body body curlyargs)))
           (else
            (let* ((temp   (ctor-signature name params bounds curlyargs sig))
                   (sig    (car temp))
                   (params (cdr temp)))
              (if (pair? params)
-                 (let* ((lnos (filter (lambda (e) (and (pair? e) (eq? (car e) 'line)))
-                                      body))
-                        (lno (if (null? lnos) '() (car lnos))))
-                   (syntax-deprecation #f
-                                       (string "inner constructor " name "(...)"
-                                               (cond ((length= lno 2) (string " around line " (cadr lno)))
-                                                     ((length= lno 3) (string " around " (caddr lno) ":" (cadr lno)))
-                                                     (else "")))
-                                       (deparse `(where (call (curly ,name ,@params) ...) ,@params)))))
+                 (syntax-deprecation #f
+                                     (string "inner constructor " name "(...)" (linenode-string (function-body-lineno body)))
+                                     (deparse `(where (call (curly ,name ,@params) ...) ,@params))))
              `(,keyword ,sig ,(ctor-body body params)))))))
 
+(define (function-body-lineno body)
+  (let ((lnos (filter (lambda (e) (and (pair? e) (eq? (car e) 'line)))
+                      body)))
+    (if (null? lnos) '() (car lnos))))
+
 ;; 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)
@@ -790,18 +831,18 @@
   (pattern-replace
    (pattern-set
     ;; definitions without `where`
-    (pattern-lambda (function       (call name . sig) body)
+    (pattern-lambda (function       (-$ (call name . sig) (|::| (call name . sig) _t)) body)
                     (ctor-def (car __) name Tname params bounds sig ctor-body body #f))
-    (pattern-lambda (stagedfunction (call name . sig) body)
+    (pattern-lambda (stagedfunction (-$ (call name . sig) (|::| (call name . sig) _t)) body)
                     (ctor-def (car __) name Tname params bounds sig ctor-body body #f))
-    (pattern-lambda (= (call name . sig) body)
+    (pattern-lambda (= (-$ (call name . sig) (|::| (call name . sig) _t)) body)
                     (ctor-def 'function name Tname params bounds sig ctor-body body #f))
     ;; definitions with `where`
-    (pattern-lambda (function       (where (call name . sig) . wheres) body)
+    (pattern-lambda (function       (where (-$ (call name . sig) (|::| (call name . sig) _t)) . wheres) body)
                     (ctor-def (car __) name Tname params bounds sig ctor-body body wheres))
-    (pattern-lambda (stagedfunction (where (call name . sig) . wheres) body)
+    (pattern-lambda (stagedfunction (where (-$ (call name . sig) (|::| (call name . sig) _t)) . wheres) body)
                     (ctor-def (car __) name Tname params bounds sig ctor-body body wheres))
-    (pattern-lambda (= (where (call name . sig) . wheres) body)
+    (pattern-lambda (= (where (-$ (call name . sig) (|::| (call name . sig) _t)) . wheres) body)
                     (ctor-def 'function name Tname params bounds sig ctor-body body wheres)))
 
    ;; flatten `where`s first
@@ -902,9 +943,9 @@
 ;; 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)
+                       (values name '() '(core Any))) ex)
       ((pattern-lambda (curly (-- name (-s)) . params)
-                       (values name params 'Any)) ex)
+                       (values name params '(core Any))) ex)
       ((pattern-lambda (|<:| (-- name (-s)) super)
                        (values name '() super)) ex)
       ((pattern-lambda (|<:| (curly (-- name (-s)) . params) super)
@@ -913,33 +954,44 @@
 
 ;; insert calls to convert() in ccall, and pull out expressions that might
 ;; need to be rooted before conversion.
-(define (lower-ccall name RT atypes args)
+(define (lower-ccall name RT atypes args cconv)
   (let loop ((F atypes)  ;; formals
              (A args)    ;; actuals
              (stmts '()) ;; initializers
-             (C '()))    ;; converted
-    (if (or (null? F) (null? A))
+             (C '())     ;; converted
+             (GC '()))   ;; GC roots
+    (if (and (null? F) (not (null? A))) (error "more arguments than types for ccall"))
+    (if (and (null? A) (not (or (null? F) (and (pair? F) (vararg? (car F)) (null? (cdr F)))))) (error "more types than arguments for ccall"))
+    (if (null? A)
         `(block
           ,.(reverse! stmts)
           (foreigncall ,name ,RT (call (core svec) ,@(dots->vararg atypes))
-                ,.(reverse! C)
-                ,@A))
+                       ',cconv
+                       ,(length C)
+                       ,.(reverse! C)
+                       ,@GC)) ; GC root ordering is arbitrary
         (let* ((a     (car A))
-               (isseq (and (pair? (car F)) (eq? (caar F) '...)))
+               (isseq (and (vararg? (car F))))
                (ty    (if isseq (cadar F) (car F))))
+          (if (and isseq (not (null? (cdr F)))) (error "only the trailing ccall argument type should have '...'"))
           (if (eq? ty 'Any)
-              (loop (if isseq F (cdr F)) (cdr A) stmts (list* 0 a C))
+              (loop (if isseq F (cdr F)) (cdr A) stmts (list* a C) GC)
               (let* ((g (make-ssavalue))
                      (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))))))))
+                      (list* (if isamp `(& ,ca) ca) C) (list* g GC))))))))
 
 (define (expand-function-def e)   ;; handle function or stagedfunction
+  (define (just-arglist? ex)
+    (and (pair? ex)
+         (or (memq (car ex) '(tuple block))
+             (and (eq? (car ex) 'where)
+                  (just-arglist? (cadr ex))))))
   (let ((name (cadr e)))
-    (if (and (pair? name) (memq (car name) '(tuple block)))
+    (if (just-arglist? name)
         (expand-forms (cons '-> (cdr e)))
         (expand-function-def- e))))
 
@@ -961,7 +1013,7 @@
                               (set! name (cadr w))))
                     #f))
          (dcl   (and (pair? name) (eq? (car name) '|::|)))
-         (rett  (if dcl (caddr name) 'Any))
+         (rett  (if dcl (caddr name) '(core Any)))
          (name  (if dcl (cadr name) name)))
     (cond ((and (length= e 2) (symbol? name))
            (if (or (eq? name 'true) (eq? name 'false))
@@ -979,10 +1031,17 @@
                                                 (string "function Base.broadcast(::typeof(" (deparse op_) "), ...)")))
                         op_))
                   (name (if op '(|.| Base (inert broadcast)) name))
+                  (annotations (map (lambda (a) `(meta nospecialize ,(arg-name a)))
+                                    (filter nospecialize-meta? argl)))
+                  (body (insert-after-meta (caddr e) annotations))
+                  (argl (map (lambda (a)
+                               (if (nospecialize-meta? a) (caddr a) a))
+                             argl))
                   (argl (if op (cons `(|::| (call (core Typeof) ,op)) argl) argl))
-                  (sparams (map analyze-typevar (cond (has-sp (cddr head))
-                                                      (where  where)
-                                                      (else   '()))))
+                  (raw-typevars (cond (has-sp (cddr head))
+                                      (where  where)
+                                      (else   '())))
+                  (sparams (map analyze-typevar raw-typevars))
                   (isstaged (eq? (car e) 'stagedfunction))
                   (adj-decl (lambda (n) (if (and (decl? n) (length= n 2))
                                             `(|::| |#self#| ,(cadr n))
@@ -998,8 +1057,16 @@
                                                                    (eq? (caar argl) 'parameters))))))
                   (name    (if (or (decl? name) (and (pair? name) (eq? (car name) 'curly)))
                                #f name)))
+             (if has-sp
+                 (syntax-deprecation #f
+                                     (string "parametric method syntax " (deparse (cadr e))
+                                             (linenode-string (function-body-lineno body)))
+                                     (deparse `(where (call ,name ,@(if (has-parameters? argl)
+                                                                        (cons (car argl) (cddr argl))
+                                                                        (cdr argl)))
+                                                      ,@raw-typevars))))
              (expand-forms
-              (method-def-expr name sparams argl (caddr e) isstaged rett))))
+              (method-def-expr name sparams argl body isstaged rett))))
           (else
            (error (string "invalid assignment location \"" (deparse name) "\""))))))
 
@@ -1061,6 +1128,18 @@
                    (eq? (caar binds) '=))
               ;; some kind of assignment
               (cond
+               ((eventually-call? (cadar binds))
+                ;; f()=c
+                (let ((asgn (butlast (expand-forms (car binds))))
+                      (name (assigned-name (cadar binds))))
+                  (if (not (symbol? name))
+                      (error "invalid let syntax"))
+                  (loop (cdr binds)
+                        `(scope-block
+                          (block
+                           (local-def ,name)
+                           ,asgn
+                           ,blk)))))
                ((or (symbol? (cadar binds))
                     (decl?   (cadar binds)))
                 (let ((vname (decl-var (cadar binds))))
@@ -1080,23 +1159,6 @@
                                (local-def ,(cadar binds))
                                (= ,vname ,(caddar binds))
                                ,blk))))))
-               ((and (pair? (cadar binds))
-                     (or (eq? (caadar binds) 'call)
-                         (and (eq? (caadar binds) 'comparison)
-                              (length= (cadar binds) 4))))
-                ;; 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-def ,name)
-                           ,asgn
-                           ,blk)))))
                ;; (a, b, c, ...) = rhs
                ((and (pair? (cadar binds))
                      (eq? (caadar binds) 'tuple))
@@ -1119,9 +1181,11 @@
                (error "macros cannot accept keyword arguments"))
            (expand-forms
             `(function (call ,(symbol (string #\@ (cadr (cadr e))))
+                             (|::| __source__ (core LineNumberNode))
+                             (|::| __module__ (core Module))
                              ,@(map (lambda (v)
                                       (if (symbol? v)
-                                          `(|::| ,v (core ANY))
+                                          `(meta nospecialize ,v)
                                           v))
                                     anames))
                        ,@(cddr e)))))
@@ -1231,7 +1295,8 @@
                         (= ,err true)))
                   (= ,finally-exception (the_exception))
                   ,finalb
-                  (if ,err (foreigncall 'jl_rethrow_other (core Void) (call (core svec) Any) ,finally-exception 0))
+                  (if ,err (foreigncall 'jl_rethrow_other (core Void) (call (core svec) Any)
+                                        'ccall 1 ,finally-exception))
                   ,(if hasret
                        (if ret
                            `(if ,ret (return ,retval) ,val)
@@ -1285,10 +1350,13 @@
       e
       (expand-forms (expand-decls (car e) (cdr e) #f))))
 
+;; given a complex assignment LHS, return the symbol that will ultimately be assigned to
 (define (assigned-name e)
-  (if (and (pair? e) (memq (car e) '(call curly)))
-      (assigned-name (cadr e))
-      e))
+  (cond ((atom? e) e)
+        ((or (memq (car e) '(call curly where))
+             (and (eq? (car e) '|::|) (eventually-call? e)))
+         (assigned-name (cadr e)))
+        (else e)))
 
 ;; local x, y=2, z => local x;local y;local z;y = 2
 (define (expand-decls what binds const?)
@@ -1344,7 +1412,7 @@
                     (cons (make-assignment L R) stmts)
                     after
                     (cons R elts))
-              (let ((temp (make-ssavalue)))
+              (let ((temp (if (eventually-call? L) (gensy) (make-ssavalue))))
                 (loop (cdr lhss)
                       (cons L assigned)
                       (cdr rhss)
@@ -1360,8 +1428,16 @@
       ,@(let loop ((lhs lhss)
                    (i   1))
           (if (null? lhs) '((null))
-              (cons `(= ,(car lhs)
-                        (call (core getfield) ,t ,i))
+              (cons (if (eventually-call? (car lhs))
+                        ;; if this is a function assignment, avoid putting our ssavalue
+                        ;; inside the function and instead create a capture-able variable.
+                        ;; issue #22032
+                        (let ((temp (gensy)))
+                          `(block
+                            (= ,temp (call (core getfield) ,t ,i))
+                            (= ,(car lhs) ,temp)))
+                        `(= ,(car lhs)
+                            (call (core getfield) ,t ,i)))
                     (loop (cdr lhs)
                           (+ i 1)))))
       ,t)))
@@ -1394,61 +1470,84 @@
             (reverse a))))))
 
 ;; lower function call containing keyword arguments
-(define (lower-kw-call f kw pa)
-  (let ((container (make-ssavalue)))
-    (let loop ((kw kw)
-               (initial-kw '()) ;; keyword args before any splats
-               (stmts '())
-               (has-kw #f))     ;; whether there are definitely >0 kwargs
-      (if (null? kw)
-          (if (null? stmts)
-              `(call (call (core kwfunc) ,f) (call (top vector_any) ,@(reverse initial-kw)) ,f ,@pa)
-              `(block
-                (= ,container (call (top vector_any) ,@(reverse initial-kw)))
-                ,@(reverse stmts)
-                ,(if has-kw
-                     `(call (call (core 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 (core kwfunc) ,f) ,container ,f ,@pa)))))))
-          (let ((arg (car kw)))
-            (cond ((and (pair? arg) (eq? (car arg) 'parameters))
-                   (error "more than one semicolon in argument list"))
-                  ((kwarg? arg)
-                   (if (not (symbol? (cadr arg)))
-                       (error (string "keyword argument is not a symbol: \""
-                                      (deparse (cadr arg)) "\"")))
-                   (if (vararg? (caddr arg))
-                       (error "splicing with \"...\" cannot be used for a keyword argument value"))
-                   (if (null? stmts)
-                       (loop (cdr kw) (list* (caddr arg) `(quote ,(cadr arg)) initial-kw) stmts #t)
-                       (loop (cdr kw) initial-kw
-                             (cons `(foreigncall 'jl_array_ptr_1d_push2 (core Void) (call (core svec) Any Any Any)
-                                           ,container 0
-                                           (|::| (quote ,(cadr arg)) (core Symbol)) 0
-                                           ,(caddr arg) 0)
-                                   stmts)
-                             #t)))
-                  (else
-                   (loop (cdr kw) initial-kw
-                         (cons (let* ((k (make-ssavalue))
-                                      (v (make-ssavalue))
-                                      (push-expr `(foreigncall 'jl_array_ptr_1d_push2 (core Void) (call (core svec) Any Any Any)
-                                                         ,container 0
-                                                         (|::| ,k (core Symbol)) 0
-                                                         ,v 0)))
-                                 (if (vararg? arg)
-                                     `(for (= (tuple ,k ,v) ,(cadr arg))
-                                           ,push-expr)
-                                     `(block (= (tuple ,k ,v) ,arg)
-                                             ,push-expr)))
-                               stmts)
-                         (or has-kw (not (vararg? arg)))))))))))
+(define (lower-kw-call fexpr kw0 pa)
+
+  ;; check for keyword arguments syntactically passed more than once
+  (let ((dups (has-dups (map cadr (filter kwarg? kw0)))))
+    (if dups
+        (error (string "keyword argument \"" (car dups) "\" repeated in call to \"" (deparse fexpr) "\""))))
+
+  (define (kwcall-unless-empty f pa kw-container-test kw-container)
+    (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) ,kw-container-test)
+            (call ,f ,@pa)
+            (call (call (core kwfunc) ,f) ,kw-container ,f ,@pa)))))
+
+  (let ((f (if (sym-ref? fexpr) fexpr (make-ssavalue))))
+    `(block
+      ,@(if (eq? f fexpr) '() `((= ,f, fexpr)))
+      ,(if ;; optimize splatting one existing container, `f(...; kw...)`
+        (and (length= kw0 1) (vararg? (car kw0)))
+        (let* ((container  (cadr (car kw0)))
+               (expr_stmts (remove-argument-side-effects `(call _ ,container)))
+               (container  (caddr (car expr_stmts)))
+               (stmts      (cdr expr_stmts)))
+          `(block
+            ,@stmts
+            ,(kwcall-unless-empty f pa container `(call (top as_kwargs) ,container))))
+        (let ((container (make-ssavalue)))
+          (let loop ((kw kw0)
+                     (initial-kw '()) ;; keyword args before any splats
+                     (stmts '())
+                     (has-kw #f))     ;; whether there are definitely >0 kwargs
+            (if (null? kw)
+                (if (null? stmts)
+                    `(call (call (core kwfunc) ,f) (call (top vector_any) ,@(reverse initial-kw)) ,f ,@pa)
+                    `(block
+                      (= ,container (call (top vector_any) ,@(reverse initial-kw)))
+                      ,@(reverse stmts)
+                      ,(if has-kw
+                           `(call (call (core kwfunc) ,f) ,container ,f ,@pa)
+                           (kwcall-unless-empty f pa container container))))
+                (let ((arg (car kw)))
+                  (cond ((and (pair? arg) (eq? (car arg) 'parameters))
+                         (error "more than one semicolon in argument list"))
+                        ((kwarg? arg)
+                         (if (not (symbol? (cadr arg)))
+                             (error (string "keyword argument is not a symbol: \""
+                                            (deparse (cadr arg)) "\"")))
+                         (if (vararg? (caddr arg))
+                             (error "splicing with \"...\" cannot be used for a keyword argument value"))
+                         (if (null? stmts)
+                             (loop (cdr kw) (list* (caddr arg) `(quote ,(cadr arg)) initial-kw) stmts #t)
+                             (loop (cdr kw) initial-kw
+                                   (cons `(foreigncall 'jl_array_ptr_1d_push2 (core Void) (call (core svec) Any Any Any)
+                                                       'ccall 3
+                                                       ,container
+                                                       (|::| (quote ,(cadr arg)) (core Symbol))
+                                                       ,(caddr arg))
+                                         stmts)
+                                   #t)))
+                        (else
+                         (loop (cdr kw) initial-kw
+                               (cons (let* ((k (make-ssavalue))
+                                            (v (make-ssavalue))
+                                            (push-expr `(foreigncall 'jl_array_ptr_1d_push2 (core Void) (call (core svec) Any Any Any)
+                                                                     'ccall 3
+                                                                     ,container
+                                                                     (|::| ,k (core Symbol))
+                                                                     ,v)))
+                                       (if (vararg? arg)
+                                           `(for (= (tuple ,k ,v) ,(cadr arg))
+                                                 ,push-expr)
+                                           `(block (= (tuple ,k ,v) ,arg)
+                                                   ,push-expr)))
+                                     stmts)
+                               (or has-kw (not (vararg? arg))))))))))))))
 
 ;; convert e.g. A'*B to Ac_mul_B(A,B)
 (define (expand-transposed-op e ops)
@@ -1586,7 +1685,7 @@
 
 ;; convert an operator parsed as (op a b) to (call op a b)
 (define (syntactic-op-to-call e)
-  `(call ,(car e) ,(expand-forms (cadr e)) ,(expand-forms (caddr e))))
+  `(call ,(car e) ,@(map expand-forms (cdr e))))
 
 ;; wrap `expr` in a function appropriate for consuming values from given ranges
 (define (func-for-generator-ranges expr range-exprs)
@@ -1684,9 +1783,12 @@
             `(fuse ,(to-lambda f args kws) ,args_))))
     (if (and (pair? e) (eq? (car e) '|.|))
         (let ((f (cadr e)) (x (caddr e)))
-          (if (or (eq? (car x) 'quote) (eq? (car x) 'inert) (eq? (car x) '$))
-              `(call (core getfield) ,f ,x)
-              (make-fuse f (cdr x))))
+          (cond ((or (eq? (car x) 'quote) (eq? (car x) 'inert) (eq? (car x) '$))
+                 `(call (core getfield) ,f ,x))
+                ((eq? (car x) 'tuple)
+                 (make-fuse f (cdr x)))
+                (else
+                 (error (string "invalid syntax " (deparse e))))))
         (if (and (pair? e) (eq? (car e) 'call) (dotop? (cadr e)))
             (make-fuse (undotop (cadr e)) (cddr e))
             e)))
@@ -1763,9 +1865,9 @@
     (if (null? params)
         (cons (reverse newparams) (reverse whereparams))
         (let ((p (car params)))
-          (if (and (list? p) (= (length p) 3) (eq? (car p) 'call) (or (eq? (cadr p) '|<:|) (eq? (cadr p) '|>:|)))
+          (if (and (length= p 2) (or (eq? (car p) '|<:|) (eq? (car p) '|>:|)))
               (let ((T (gensy)))
-                (extract (cdr params) (cons T newparams) (cons (list (cadr p) T (caddr p)) whereparams)))
+                (extract (cdr params) (cons T newparams) (cons (list (car p) T (cadr p)) whereparams)))
               (extract (cdr params) (cons p newparams) whereparams)))))
   (extract (cddr e) '() '()))
 
@@ -1816,24 +1918,23 @@
    'const  expand-const-decl
    'local  expand-local-or-global-decl
    'global expand-local-or-global-decl
+   'local-def expand-local-or-global-decl
 
    '=
    (lambda (e)
      (define lhs (cadr e))
-     (cond
-      ((and (pair? lhs)
+     (define (function-lhs? lhs)
+       (and (pair? lhs)
             (or (eq? (car lhs) 'call)
                 (eq? (car lhs) 'where)
                 (and (eq? (car lhs) '|::|)
                      (pair? (cadr lhs))
-                     (eq? (car (cadr lhs)) 'call))))
-       (expand-forms (cons 'function (cdr e))))
-      ((and (pair? lhs)
-            (eq? (car lhs) 'comparison)
-            (length= lhs 4))
-       ;; allow defining functions that use comparison syntax
-       (expand-forms (list* 'function
-                            `(call ,(caddr lhs) ,(cadr lhs) ,(cadddr lhs)) (cddr e))))
+                     (eq? (car (cadr lhs)) 'call)))))
+     (define (assignment-to-function lhs e)  ;; convert '= expr to 'function expr
+       (cons 'function (cdr e)))
+     (cond
+      ((function-lhs? lhs)
+       (expand-forms (assignment-to-function lhs e)))
       ((and (pair? lhs)
             (eq? (car lhs) 'curly))
        (expand-typealias (cadr e) (caddr e)))
@@ -1841,11 +1942,13 @@
        ;; chain of assignments - convert a=b=c to `b=c; a=c`
        (let loop ((lhss (list lhs))
                   (rhs  (caddr e)))
-         (if (assignment? rhs)
+         (if (and (assignment? rhs) (not (function-lhs? (cadr rhs))))
              (loop (cons (cadr rhs) lhss) (caddr rhs))
              (let ((rr (if (symbol-like? rhs) rhs (make-ssavalue))))
                (expand-forms
-                `(block ,.(if (eq? rr rhs) '() `((= ,rr ,rhs)))
+                `(block ,.(if (eq? rr rhs) '() `((= ,rr ,(if (assignment? rhs)
+                                                             (assignment-to-function (cadr rhs) rhs)
+                                                             rhs))))
                         ,@(map (lambda (l) `(= ,l ,rr))
                                lhss)
                         (unnecessary ,rr)))))))
@@ -1999,7 +2102,8 @@
          (let ((f (cadr e)))
            (cond ((dotop? f)
                   (expand-fuse-broadcast '() `(|.| ,(undotop f) (tuple ,@(cddr e)))))
-                 ((and (eq? f 'ccall) (length> e 4))
+                 ((eq? f 'ccall)
+                  (if (not (length> e 4)) (error "too few arguments to ccall"))
                   (let* ((cconv (cadddr e))
                          (have-cconv (memq cconv '(cdecl stdcall fastcall thiscall llvmcall)))
                          (after-cconv (if have-cconv (cddddr e) (cdddr e)))
@@ -2015,8 +2119,8 @@
                                   (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)
-                            (if have-cconv (append args (list (list cconv))) args)))))) ;; place (callingconv) at end of arglist
+                           (lower-ccall name RT (cdr argtypes) args
+                                        (if have-cconv cconv 'ccall))))))
                  ((and (pair? (caddr e))
                        (eq? (car (caddr e)) 'parameters))
                   ;; (call f (parameters . kwargs) ...)
@@ -2057,7 +2161,7 @@
 
                  ((and (eq? f '^) (length= e 4) (integer? (cadddr e)))
                   (expand-forms
-                   `(call ^ ,(caddr e) (call (core apply_type) (top Val) ,(cadddr e)))))
+                   `(call (top literal_pow) ^ ,(caddr e) (call (call (core apply_type) (top Val) ,(cadddr e))))))
 
                  ((and (eq? f '*) (length= e 4))
                   (expand-transposed-op
@@ -2083,8 +2187,13 @@
          (error "assignment not allowed inside tuple"))
      (expand-forms `(call (core tuple) ,@(cdr e))))
 
-   'cell1d (lambda (e) (error "{ } vector syntax is discontinued"))
-   'cell2d (lambda (e) (error "{ } matrix syntax is discontinued"))
+   '=>
+   (lambda (e)
+     (syntax-deprecation #f "Expr(:(=>), ...)" "Expr(:call, :(=>), ...)")
+     `(call => ,(expand-forms (cadr e)) ,(expand-forms (caddr e))))
+
+   'braces    (lambda (e) (error "{ } vector syntax is discontinued"))
+   'bracescat (lambda (e) (error "{ } matrix syntax is discontinued"))
 
    'string
    (lambda (e) (expand-forms `(call (top string) ,@(cdr e))))
@@ -2230,25 +2339,6 @@
    '|'|  (lambda (e) `(call ctranspose ,(expand-forms (cadr e))))
    '|.'| (lambda (e) `(call  transpose ,(expand-forms (cadr e))))
 
-   'ccall
-   (lambda (e)
-     (syntax-deprecation #f "Expr(:ccall)" "Expr(:call, :ccall)")
-     (if (length> e 3)
-         (let ((name (cadr e))
-               (RT   (caddr e))
-               (argtypes (cadddr e))
-               (args (cddddr e)))
-           (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,)\"")))
-             (expand-forms
-              (lower-ccall name RT (cdr argtypes) args))))
-         e))
-
    'generator
    (lambda (e)
      (let* ((expr  (cadr e))
@@ -2354,7 +2444,8 @@
         (else '())))
 
 (define (all-decl-vars e)  ;; map decl-var over every level of an assignment LHS
-  (cond ((decl? e)   (decl-var e))
+  (cond ((eventually-call? e) e)
+        ((decl? e)   (decl-var e))
         ((and (pair? e) (eq? (car e) 'tuple))
          (cons 'tuple (map all-decl-vars (cdr e))))
         (else e)))
@@ -2427,7 +2518,7 @@
 ;; 3. variables assigned inside this scope-block that don't exist in outer
 ;;    scopes
 ;; returns lambdas in the form (lambda (args...) (locals...) body)
-(define (resolve-scopes- e env implicitglobals lam renames newlam)
+(define (resolve-scopes- e env outerglobals implicitglobals lam renames newlam)
   (cond ((symbol? e) (let ((r (assq e renames)))
                        (if r (cdr r) e))) ;; return the renaming for e, or e
         ((or (not (pair? e)) (quoted? e) (memq (car e) '(toplevel global))) e)
@@ -2438,10 +2529,11 @@
          (let* ((lv (lam:vars e))
                 (env (append lv env))
                 (body (resolve-scopes- (lam:body e) env
-                                       ;; don't propagate implicit globals
-                                       ;; issue #7234
+                                       ;; don't propagate implicit or outer globals
+                                       '()
                                        '()
                                        e
+                                       ;; remove renames corresponding to local variables from the environment
                                        (filter (lambda (ren) (not (memq (car ren) lv)))
                                                renames)
                                        #t)))
@@ -2449,17 +2541,16 @@
         ((eq? (car e) 'scope-block)
          (let* ((blok (cadr e)) ;; body of scope-block expression
                 (other-locals (if lam (caddr lam) '())) ;; locals that are explicitly part of containing lambda expression
-                (iglo (find-decls 'implicit-global blok)) ;; implicitly defined globals used in blok
+                (iglo (find-decls 'implicit-global blok)) ;; globals defined implicitly outside blok
                 (glob (diff (find-global-decls blok) iglo)) ;; all globals declared in blok
                 (vars-def (check-dups (find-local-def-decls blok) '()))
                 (locals-declared (check-dups (find-local-decls blok) vars-def))
-                (locals-implicit (diff (implicit-locals
-                                         blok
-                                         ;; being declared global prevents a variable
-                                         ;; assignment from introducing a local
-                                         (append env glob implicitglobals iglo)
-                                         (append glob iglo))
-                                       vars-def))
+                (locals-implicit (implicit-locals
+                                   blok
+                                   ;; being declared global prevents a variable
+                                   ;; assignment from introducing a local
+                                   (append env glob iglo outerglobals locals-declared vars-def)
+                                   (append glob iglo)))
                 (vars (delete-duplicates (append! locals-declared locals-implicit)))
                 (all-vars (append vars vars-def))
                 (need-rename?
@@ -2478,26 +2569,22 @@
                 (renamed (map named-gensy need-rename))
                 (renamed-def (map named-gensy need-rename-def))
                 (new-env (append all-vars glob env)) ;; all variables declared in or outside blok
-                (new-iglo-table ;; initial list of implicit globals from outside blok which aren't part of the local vars
-                  (let ((tab (table)))
-                    (for-each (lambda (v) (if (not (memq v all-vars)) (put! tab v #t))) iglo)
-                    (for-each (lambda (v) (if (not (memq v all-vars)) (put! tab v #t))) implicitglobals)
-                    tab))
-                (new-iglo (table.keys ;; compute list of all globals used implicitly in blok
-                            (unbound-vars blok
-                                          new-env ;; list of everything else
-                                          new-iglo-table)))
+                ;; compute list of all globals used implicitly in blok (need renames)
+                (new-iglo (table.keys (unbound-vars blok
+                                                    new-env ;; list of everything else
+                                                    (table))))
                 ;; combine the list of new renamings with the inherited list
                 (new-renames (append (map cons need-rename renamed) ;; map from definition name -> gensym name
                                      (map cons need-rename-def renamed-def)
                                      (map (lambda (g) (cons g `(outerref ,g))) new-iglo)
                                      (filter (lambda (ren) ;; old renames list, with anything in vars removed
-                                               (not (or (memq (car ren) all-vars)
-                                                        (memq (car ren) iglo)
-                                                        (memq (car ren) implicitglobals)
-                                                        (memq (car ren) glob))))
+                                               (let ((var (car ren)))
+                                                 (not (or (memq var all-vars) ;; remove anything new
+                                                          (memq var implicitglobals) ;; remove anything only added implicitly in the last scope block
+                                                          (memq var glob))))) ;; remove anything that's now global
                                              renames)))
-                (body (resolve-scopes- blok new-env new-iglo lam new-renames #f))
+                (new-oglo (append iglo outerglobals)) ;; list of all outer-globals from outside blok
+                (body (resolve-scopes- blok new-env new-oglo new-iglo lam new-renames #f))
                 (real-new-vars (append (diff vars need-rename) renamed))
                 (real-new-vars-def (append (diff vars-def need-rename-def) renamed-def)))
                (for-each (lambda (v)
@@ -2506,7 +2593,7 @@
                          glob)
                (if lam ;; update in-place the list of local variables in lam
                    (set-car! (cddr lam)
-                             (append! (caddr lam) real-new-vars real-new-vars-def)))
+                             (append real-new-vars real-new-vars-def (caddr lam))))
                (insert-after-meta ;; return the new, expanded scope-block
                 (if (and (pair? body) (eq? (car body) 'block))
                     body
@@ -2517,18 +2604,18 @@
          (error "module expression not at top level"))
         ((eq? (car e) 'break-block)
          `(break-block ,(cadr e) ;; ignore type symbol of break-block expression
-                       ,(resolve-scopes- (caddr e) env implicitglobals lam renames #f))) ;; body of break-block expression
+                       ,(resolve-scopes- (caddr e) env outerglobals implicitglobals lam renames #f))) ;; body of break-block expression
         ((eq? (car e) 'with-static-parameters)
          `(with-static-parameters ;; ignore list of sparams in break-block expression
-            ,(resolve-scopes- (cadr e) env implicitglobals lam renames #f)
+            ,(resolve-scopes- (cadr e) env outerglobals implicitglobals lam renames #f)
             ,@(cddr e))) ;; body of break-block expression
         (else
          (cons (car e)
                (map (lambda (x)
-                      (resolve-scopes- x env implicitglobals lam renames #f))
+                      (resolve-scopes- x env outerglobals implicitglobals lam renames #f))
                     (cdr e))))))
 
-(define (resolve-scopes e) (resolve-scopes- e '() '() #f '() #f))
+(define (resolve-scopes e) (resolve-scopes- e '() '() '() #f '() #f))
 
 ;; pass 3: analyze variables
 
@@ -2631,7 +2718,7 @@
          ;; 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))
+               (begin (if (not (equal? (vinfo:type vi) '(core Any)))
                           (error (string "multiple type declarations for \""
                                          (cadr e) "\"")))
                       (if (assq (cadr e) captvars)
@@ -2698,7 +2785,7 @@ f(x) = yt(x)
                   (composite_type ,name (call (core svec))
                                   (call (core svec) ,@(map (lambda (v) `',v) fields))
                                   ,super
-                                  (call (core svec) ,@(map (lambda (v) 'Any) fields))
+                                  (call (core svec) ,@(map (lambda (v) '(core Any)) fields))
                                   false ,(length fields))
                   (return (null)))))))
 
@@ -2745,7 +2832,7 @@ f(x) = yt(x)
        (cl-convert (cadddr lam) fname lam (table) #f interp))))
 
 (define (convert-for-type-decl rhs t)
-  (if (eq? t 'Any)
+  (if (equal? t '(core Any))
       rhs
       `(call (core typeassert)
              (call (top convert) ,t ,rhs)
@@ -2761,16 +2848,16 @@ f(x) = yt(x)
          (cv (assq var (cadr (lam:vinfo lam))))
          (vt  (or (and vi (vinfo:type vi))
                   (and cv (vinfo:type cv))
-                  'Any))
+                  '(core 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))
+    (if (and (not closed) (not capt) (equal? vt '(core Any)))
         `(= ,var ,rhs0)
         (let* ((rhs1 (if (or (ssavalue? rhs0) (simple-atom? rhs0)
                              (equal? rhs0 '(the_exception)))
                          rhs0
                          (make-ssavalue)))
-               (rhs  (if (eq? vt 'Any)
+               (rhs  (if (equal? vt '(core Any))
                          rhs1
                          (convert-for-type-decl rhs1 (cl-convert vt fname lam #f #f interp))))
                (ex (cond (closed `(call (core setfield!)
@@ -2829,13 +2916,15 @@ f(x) = yt(x)
 
 ;; return `body` with `stmts` inserted after any meta nodes
 (define (insert-after-meta body stmts)
-  (let ((meta (take-while (lambda (x) (and (pair? x)
-                                           (memq (car x) '(line meta))))
-                          (cdr body))))
-    `(,(car body)
-      ,@meta
-      ,@stmts
-      ,@(list-tail body (+ 1 (length meta))))))
+  (if (null? stmts)
+      body
+      (let ((meta (take-while (lambda (x) (and (pair? x)
+                                               (memq (car x) '(line meta))))
+                              (cdr body))))
+        `(,(car body)
+          ,@meta
+          ,@stmts
+          ,@(list-tail body (+ 1 (length meta)))))))
 
 (define (add-box-inits-to-body lam body)
   (let ((args (map arg-name (lam:args lam)))
@@ -2890,21 +2979,21 @@ f(x) = yt(x)
                          (lambda (e)
                            (or (atom? e)
                                (memq (car e) '(quote top core line inert local local-def unnecessary
-                                               meta inbounds boundscheck simdloop
+                                               meta inbounds boundscheck simdloop decl
                                                implicit-global global globalref outerref
-                                               const = null method call))))
+                                               const = null method call foreigncall ssavalue))))
                          (lam:body lam))))
                (unused (map cadr (filter (lambda (x) (memq (car x) '(method =)))
                                          leading))))
-              ;; 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 (and (memq (car e) '(method =)) (memq (cadr e) unused))
-                              (let ((v (assq (cadr e) vi)))
-                                   (if v (vinfo:set-never-undef! v #t)))))
-                        leading)))
+          ;; 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 (and (memq (car e) '(method =)) (memq (cadr e) unused))
+                          (let ((v (assq (cadr e) vi)))
+                            (if v (vinfo:set-never-undef! v #t)))))
+                    leading)))
     (for-each (lambda (v)
                 (if (and (vinfo:sa v) (vinfo:never-undef v))
                     (set-car! (cddr v) (logand (caddr v) (lognot 5)))))
@@ -2949,7 +3038,7 @@ f(x) = yt(x)
                                    `(call (core getfield) ,fname (inert ,e)))))
                    (if (and (vinfo:asgn cv) (vinfo:capt cv))
                        (let ((val `(call (core getfield) ,access (inert contents))))
-                         (if (eq? (vinfo:type cv) 'Any)
+                         (if (equal? (vinfo:type cv) '(core Any))
                              val
                              `(call (core typeassert) ,val
                                     ,(cl-convert (vinfo:type cv) fname lam namemap toplevel interp))))
@@ -2957,7 +3046,7 @@ f(x) = yt(x)
                 (vi
                  (if (and (vinfo:asgn vi) (vinfo:capt vi))
                      (let ((val `(call (core getfield) ,e (inert contents))))
-                       (if (eq? (vinfo:type vi) 'Any)
+                       (if (equal? (vinfo:type vi) '(core Any))
                            val
                            `(call (core typeassert) ,val
                                   ,(cl-convert (vinfo:type vi) fname lam namemap toplevel interp))))
@@ -2990,6 +3079,24 @@ f(x) = yt(x)
                    (assq (cadr e) (cadr (lam:vinfo lam))))
                '(null)
                e))
+          ((isdefined) ;; convert isdefined expr to function for closure converted variables
+           (let* ((sym (cadr e))
+                  (vi (and (symbol? sym) (assq sym (car  (lam:vinfo lam)))))
+                  (cv (and (symbol? sym) (assq sym (cadr (lam:vinfo lam))))))
+             (cond ((eq? sym fname) e)
+                   ((memq sym (lam:sp lam)) e)
+                   (cv
+                    (if (and (vinfo:asgn cv) (vinfo:capt cv))
+                      (let ((access (if interp
+                                      `($ (call (core QuoteNode) ,sym))
+                                      `(call (core getfield) ,fname (inert ,sym)))))
+                          `(call (core isdefined) ,access (inert contents)))
+                      'true))
+                   (vi
+                    (if (and (vinfo:asgn vi) (vinfo:capt vi))
+                        `(call (core isdefined) ,sym (inert contents))
+                        e))
+                   (else e))))
           ((method)
            (let* ((name  (method-expr-name e))
                   (short (length= e 2))  ;; function f end
@@ -3039,10 +3146,10 @@ f(x) = yt(x)
                                (newlam    (renumber-slots-and-labels (linearize (car exprs)))))
                           `(toplevel-butlast
                             ,@top-stmts
-                            ,@sp-inits
-                            (method ,name ,(cl-convert sig fname lam namemap toplevel interp)
-                                    ,(julia-expand-macros `(quote ,newlam))
-                                    ,(last e))))))
+                            (block ,@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))
                         (type-name  (or exists
@@ -3205,6 +3312,7 @@ f(x) = yt(x)
   (let ((code '())
         (filename 'none)
         (first-line #t)
+        (current-loc #f)
         (rett #f)
         (arg-map #f)          ;; map arguments to new names if they are assigned
         (label-counter 0)     ;; counter for generating label addresses
@@ -3241,7 +3349,7 @@ f(x) = yt(x)
         (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)
+    (define (compile-args lst break-labels (linearize #t))
       (if (null? lst) '()
           (let ((temps? (or *very-linear-mode*
                             (any (lambda (e)
@@ -3258,9 +3366,9 @@ f(x) = yt(x)
               (if (null? lst)
                   (reverse! vals)
                   (let* ((arg (car lst))
-                         (aval (compile arg break-labels #t #f)))
+                         (aval (compile arg break-labels #t #f linearize)))
                     (loop (cdr lst)
-                          (cons (if (and temps? (not simple?)
+                          (cons (if (and temps? linearize (not simple?)
                                          (not (simple-atom? arg))  (not (ssavalue? arg))
                                          (not (simple-atom? aval)) (not (ssavalue? aval))
                                          (not (and (pair? arg)
@@ -3287,7 +3395,7 @@ f(x) = yt(x)
     ;; 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)
+    (define (compile e break-labels value tail (linearize-args #t))
       (if (or (not (pair? e)) (memq (car e) '(null ssavalue quote inert top core copyast the_exception $
                                                    globalref outerref cdecl stdcall fastcall thiscall llvmcall)))
           (let ((e1 (if (and arg-map (symbol? e))
@@ -3297,7 +3405,8 @@ f(x) = yt(x)
                                (and (pair? e) (or (eq? (car e) 'outerref)
                                                   (eq? (car e) 'globalref))
                                     (eq? (cadr e) '_))))
-                (syntax-deprecation #f "_ as an rvalue" ""))
+                (syntax-deprecation #f (string "_ as an rvalue" (linenode-string current-loc))
+                                    ""))
             (cond (tail  (emit-return e1))
                   (value e1)
                   ((or (eq? e1 'true) (eq? e1 'false)) #f)
@@ -3308,14 +3417,14 @@ f(x) = yt(x)
           (case (car e)
             ((call new foreigncall)
              (let* ((args (if (eq? (car e) 'foreigncall)
-                              ;; NOTE: 2nd and 3rd arguments of ccall must be left in place
+                              ;; NOTE: 2nd to 5th arguments of ccall must be left in place
                               ;;       the 1st should be compiled if an atom.
                               (append (list)
-                                      (cond (atom? (cadr e) (compile-args (list (cadr e)) break-labels))
+                                      (cond (atom? (cadr e) (compile-args (list (cadr e)) break-labels linearize-args))
                                             (else (cadr e)))
-                                      (list-head (cddr e) 2)
-                                      (compile-args (list-tail e 4) break-labels))
-                              (compile-args (cdr e) break-labels)))
+                                      (list-head (cddr e) 4)
+                                      (compile-args (list-tail e 6) break-labels linearize-args))
+                              (compile-args (cdr e) break-labels linearize-args)))
                     (callex (cons (car e) args)))
                (cond (tail (emit-return callex))
                      (value callex)
@@ -3493,7 +3602,8 @@ f(x) = yt(x)
                    (emit temp))))
 
             ((&)
-             (assert (and value (not tail)))
+             (if (or (not value) tail)
+                 (error "misplaced \"&\" expression"))
              `(& ,(compile (cadr e) break-labels value tail)))
 
             ((newvar)
@@ -3512,6 +3622,7 @@ f(x) = yt(x)
             ((local) #f)
             ((implicit-global) #f)
             ((const) (emit e))
+            ((isdefined) (if tail (emit-return e) e))
 
             ;; top level expressions returning values
             ((abstract_type bits_type composite_type thunk toplevel module)
@@ -3527,7 +3638,11 @@ f(x) = yt(x)
                ((composite_type)
                 (let* ((para (compile (caddr e) break-labels #t #f))
                        (supe (compile (list-ref e 4) break-labels #t #f))
-                       (ftys (compile (list-ref e 5) break-labels #t #f)))
+                       ;; composite_type has an unconventional evaluation rule that
+                       ;; needs to do work around the evaluation of the field types,
+                       ;; so the field type expressions need to be kept in place as
+                       ;; much as possible. (part of issue #21923)
+                       (ftys (compile (list-ref e 5) break-labels #t #f #f)))
                   (emit `(composite_type ,(cadr e) ,para ,(cadddr e) ,supe ,ftys ,@(list-tail e 6)))))
                (else
                 (emit e)))
@@ -3538,6 +3653,7 @@ f(x) = yt(x)
             ((import importall using export line meta inbounds boundscheck simdloop)
              (let ((have-ret? (and (pair? code) (pair? (car code)) (eq? (caar code) 'return))))
                (cond ((eq? (car e) 'line)
+                      (set! current-loc e)
                       (if first-line
                           (begin (set! first-line #f)
                                  (emit e))
@@ -3554,6 +3670,8 @@ f(x) = yt(x)
                '(null)))
             ((...)
              (error "\"...\" expression outside call"))
+            ((error)
+             (error (cadr e)))
             (else
              (error (string "invalid syntax " (deparse e)))))))
     ;; introduce new slots for assigned arguments
@@ -3683,6 +3801,9 @@ f(x) = yt(x)
           ((and (pair? e) (eq? (car e) 'outerref))
            (let ((idx (get sp-table (cadr e) #f)))
                 (if idx `(static_parameter ,idx) (cadr e))))
+          ((nospecialize-meta? e)
+           ;; convert nospecialize vars to slot numbers
+           `(meta nospecialize ,@(map renumber-slots (cddr e))))
           ((or (atom? e) (quoted? e)) e)
           ((ssavalue? e)
            (let ((idx (or (get ssavalue-table (cadr e) #f)
diff --git a/src/julia.expmap b/src/julia.expmap
index 238d8a4783bbe7..7934ace5765976 100644
--- a/src/julia.expmap
+++ b/src/julia.expmap
@@ -33,8 +33,6 @@
     julia_type_to_llvm;
     _IO_stdin_used;
     __ZN4llvm23createLowerSimdLoopPassEv;
-    LLVMAddLowerGCFramePass;
-    LLVMAddLowerPTLSPass;
 
     /* freebsd */
     environ;
diff --git a/src/julia.h b/src/julia.h
index 513940f8475b82..7112c5b3e17cfb 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #ifndef JULIA_H
 #define JULIA_H
@@ -42,13 +42,17 @@
 #if defined(__GNUC__)
 #  define JL_NORETURN __attribute__ ((noreturn))
 #  define JL_CONST_FUNC __attribute__((const))
+#  define JL_USED_FUNC __attribute__((used))
 #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)
+// Does MSVC have this?
+#  define JL_USED_FUNC
 #else
 #  define JL_NORETURN
 #  define JL_CONST_FUNC
+#  define JL_USED_FUNC
 #endif
 
 #define container_of(ptr, type, member) \
@@ -56,7 +60,9 @@
 
 typedef struct _jl_taggedvalue_t jl_taggedvalue_t;
 
-#include <julia_threads.h>
+#include "atomics.h"
+#include "tls.h"
+#include "julia_threads.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -74,7 +80,7 @@ struct _jl_taggedvalue_bits {
     uintptr_t gc:2;
 };
 
-struct _jl_taggedvalue_t {
+JL_EXTENSION struct _jl_taggedvalue_t {
     union {
         uintptr_t header;
         jl_taggedvalue_t *next;
@@ -140,7 +146,7 @@ typedef struct {
     uint16_t isaligned:1; // data allocated with memalign
 } jl_array_flags_t;
 
-typedef struct {
+JL_EXTENSION typedef struct {
     JL_DATA_TYPE
     void *data;
 #ifdef STORE_ARRAY_LEN
@@ -190,7 +196,7 @@ 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 jl_value_t *(*jl_fptr_linfo_t)(struct _jl_method_instance_t*, jl_value_t**, uint32_t, jl_svec_t*);
 
-typedef struct {
+JL_EXTENSION typedef struct {
     union {
         jl_fptr_t fptr;
         jl_fptr_t fptr1;
@@ -202,17 +208,17 @@ typedef struct {
 } jl_generic_fptr_t;
 
 typedef struct _jl_llvm_functions_t {
-    void *functionObject;     // jlcall llvm Function
-    void *specFunctionObject; // specialized llvm Function
+    const char *functionObject;     // jlcall llvm Function name
+    const char *specFunctionObject; // specialized llvm Function name
 } jl_llvm_functions_t;
 
 // This type describes a single function body
 typedef struct _jl_code_info_t {
-    jl_array_t *code;  // compressed uint8 array, or Any array of statements
+    jl_array_t *code;  // Any array of statements
     jl_value_t *slottypes; // types of variable slots (or `nothing`)
     jl_value_t *ssavaluetypes;  // types of ssa values (or count of them)
-    jl_array_t *slotnames; // names of local variables
     jl_array_t *slotflags;  // local var bit flags
+    jl_array_t *slotnames; // names of local variables
     uint8_t inferred;
     uint8_t inlineable;
     uint8_t propagate_inbounds;
@@ -231,7 +237,6 @@ typedef struct _jl_method_t {
     // method's type signature. redundant with TypeMapEntry->specTypes
     jl_value_t *sig;
     size_t min_world;
-    size_t max_world;
 
     // list of potentially-ambiguous methods (nothing = none, Vector{Any} of Methods otherwise)
     jl_value_t *ambig;
@@ -240,9 +245,9 @@ typedef struct _jl_method_t {
     union jl_typemap_t specializations;
 
     jl_svec_t *sparam_syms;  // symbols giving static parameter names
-    jl_code_info_t *source;  // original code template, null for builtins
+    jl_value_t *source;  // original code template (jl_code_info_t, but may be compressed), null for builtins
     struct _jl_method_instance_t *unspecialized;  // unspecialized executable method instance, or null
-    struct _jl_method_instance_t *generator;  // executable code-generating function if isstaged
+    struct _jl_method_instance_t *generator;  // executable code-generating function if available
     jl_array_t *roots;  // pointers in generated code (shared to reduce memory), or null
 
     // cache of specializations of this method for invoke(), i.e.
@@ -251,9 +256,10 @@ typedef struct _jl_method_t {
     union jl_typemap_t invokes;
 
     int32_t nargs;
-    int32_t called;  // bit flags: whether each of the first 8 arguments is called
+    int32_t called;        // bit flags: whether each of the first 8 arguments is called
+    int32_t nospecialize;  // bit flags: which arguments should not be specialized
     uint8_t isva;
-    uint8_t isstaged;
+    uint8_t pure;
 
 // hidden fields:
     uint8_t traced;
@@ -264,13 +270,17 @@ typedef struct _jl_method_t {
 // This type caches the data for a specType signature specialization of a Method
 typedef struct _jl_method_instance_t {
     JL_DATA_TYPE
+    union {
+        jl_value_t *value; // generic accessor
+        struct _jl_module_t *module; // this is a toplevel thunk
+        jl_method_t *method; // method this is specialized from
+    } def; // context for this lambda definition
     jl_value_t *specTypes;  // argument types this was specialized for
     jl_value_t *rettype; // return type for fptr
-    jl_svec_t *sparam_vals; // static parameter values, indexed by def->sparam_syms
+    jl_svec_t *sparam_vals; // static parameter values, indexed by def.method->sparam_syms
     jl_array_t *backedges;
     jl_value_t *inferred;  // inferred jl_code_info_t, or value of the function if jlcall_api == 2, or null
     jl_value_t *inferred_const; // inferred constant return value, or null
-    jl_method_t *def; // method this is specialized from, null if this is a toplevel thunk
     size_t min_world;
     size_t max_world;
     uint8_t inInference; // flags to tell if inference is running on this function
@@ -279,10 +289,8 @@ typedef struct _jl_method_instance_t {
     jl_fptr_t fptr; // jlcall entry point with api specified by jlcall_api
     jl_fptr_t unspecialized_ducttape; // if template can't be compiled due to intrinsics, an un-inferred fptr may get stored here, jlcall_api = 1
 
-    // 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
+    // names of declarations in the JIT,
+    // suitable for referencing in LLVM IR
     jl_llvm_functions_t functionObjectsDecls;
 } jl_method_instance_t;
 
@@ -391,10 +399,10 @@ typedef struct {
     jl_value_t *value;
     jl_value_t *globalref;  // cached GlobalRef for this binding
     struct _jl_module_t *owner;  // for individual imported bindings
-    unsigned constp:1;
-    unsigned exportp:1;
-    unsigned imported:1;
-    unsigned deprecated:1;
+    uint8_t constp:1;
+    uint8_t exportp:1;
+    uint8_t imported:1;
+    uint8_t deprecated:2; // 0=not deprecated, 1=renamed, 2=moved to another package
 } jl_binding_t;
 
 typedef struct _jl_module_t {
@@ -403,9 +411,10 @@ typedef struct _jl_module_t {
     struct _jl_module_t *parent;
     htable_t bindings;
     arraylist_t usings;  // modules with all bindings potentially imported
-    uint8_t istopmod;
     uint64_t uuid;
+    size_t primary_world;
     uint32_t counter;
+    uint8_t istopmod;
 } jl_module_t;
 
 // one Type-to-Value entry
@@ -418,7 +427,7 @@ typedef struct _jl_typemap_entry_t {
     size_t min_world;
     size_t max_world;
     union {
-        jl_value_t *value;
+        jl_value_t *value; // generic accessor
         jl_method_instance_t *linfo; // [nullable] for guard entries
         jl_method_t *method;
     } func;
@@ -466,7 +475,7 @@ typedef struct {
 // constants and type objects -------------------------------------------------
 
 // kinds
-extern JL_DLLEXPORT jl_datatype_t *jl_bottomtype_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_typeofbottom_type;
 extern JL_DLLEXPORT jl_datatype_t *jl_datatype_type;
 extern JL_DLLEXPORT jl_datatype_t *jl_uniontype_type;
 extern JL_DLLEXPORT jl_datatype_t *jl_unionall_type;
@@ -520,9 +529,7 @@ 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;
@@ -614,6 +621,10 @@ typedef struct _jl_gcframe_t {
   void *__gc_stkf[] = {(void*)11, jl_pgcstack, arg1, arg2, arg3, arg4, arg5};    \
   jl_pgcstack = (jl_gcframe_t*)__gc_stkf;
 
+#define JL_GC_PUSH6(arg1, arg2, arg3, arg4, arg5, arg6)                      \
+  void *__gc_stkf[] = {(void*)13, jl_pgcstack, arg1, arg2, arg3, arg4, arg5, arg6}; \
+  jl_pgcstack = (jl_gcframe_t*)__gc_stkf;
+
 #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);                  \
@@ -736,17 +747,18 @@ STATIC_INLINE void jl_array_uint8_set(void *a, size_t i, uint8_t x)
 #define jl_exprargset(e, n, v) jl_array_ptr_set(((jl_expr_t*)(e))->args, n, v)
 #define jl_expr_nargs(e) jl_array_len(((jl_expr_t*)(e))->args)
 
-#define jl_fieldref(s,i) jl_get_nth_field(((jl_value_t*)s),i)
+#define jl_fieldref(s,i) jl_get_nth_field(((jl_value_t*)(s)),i)
 #define jl_nfields(v)    jl_datatype_nfields(jl_typeof(v))
 
 // Not using jl_fieldref to avoid allocations
-#define jl_linenode_line(x) (((intptr_t*)x)[0])
-#define jl_labelnode_label(x) (((intptr_t*)x)[0])
-#define jl_slot_number(x) (((intptr_t*)x)[0])
-#define jl_typedslot_get_type(x) (((jl_value_t**)x)[1])
-#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_linenode_line(x) (((intptr_t*)(x))[0])
+#define jl_linenode_file(x) (((jl_value_t**)(x))[1])
+#define jl_labelnode_label(x) (((intptr_t*)(x))[0])
+#define jl_slot_number(x) (((intptr_t*)(x))[0])
+#define jl_typedslot_get_type(x) (((jl_value_t**)(x))[1])
+#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)
@@ -764,10 +776,18 @@ STATIC_INLINE void jl_array_uint8_set(void *a, size_t i, uint8_t x)
 #define jl_gf_name(f)   (jl_gf_mtable(f)->name)
 
 // struct type info
-#define jl_field_name(st,i)    (jl_sym_t*)jl_svecref(((jl_datatype_t*)st)->name->names, (i))
+STATIC_INLINE jl_svec_t *jl_field_names(jl_datatype_t *st)
+{
+    return st->name->names;
+}
+STATIC_INLINE jl_sym_t *jl_field_name(jl_datatype_t *st, size_t i)
+{
+    return (jl_sym_t*)jl_svecref(jl_field_names(st), i);
+}
 #define jl_field_type(st,i)    jl_svecref(((jl_datatype_t*)st)->types, (i))
 #define jl_field_count(st)     jl_svec_len(((jl_datatype_t*)st)->types)
 #define jl_datatype_size(t)    (((jl_datatype_t*)t)->size)
+#define jl_datatype_align(t)   (((jl_datatype_t*)t)->layout->alignment)
 #define jl_datatype_nbits(t)   ((((jl_datatype_t*)t)->size)*8)
 #define jl_datatype_nfields(t) (((jl_datatype_t*)(t))->layout->nfields)
 
@@ -820,6 +840,11 @@ static inline uint32_t jl_fielddesc_size(int8_t fielddesc_type)
 
 #undef DEFINE_FIELD_ACCESSORS
 
+static inline int jl_is_layout_opaque(const jl_datatype_layout_t *l)
+{
+    return l->nfields == 0 && l->npointers > 0;
+}
+
 // 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)
@@ -842,10 +867,6 @@ static inline uint32_t jl_fielddesc_size(int8_t fielddesc_type)
 #define jl_is_uint16(v)      jl_typeis(v,jl_uint16_type)
 #define jl_is_uint32(v)      jl_typeis(v,jl_uint32_type)
 #define jl_is_uint64(v)      jl_typeis(v,jl_uint64_type)
-#define jl_is_float(v)       jl_isa(v,(jl_value_t*)jl_floatingpoint_type)
-#define jl_is_floattype(v)   jl_subtype(v,(jl_value_t*)jl_floatingpoint_type)
-#define jl_is_float32(v)     jl_typeis(v,jl_float32_type)
-#define jl_is_float64(v)     jl_typeis(v,jl_float64_type)
 #define jl_is_bool(v)        jl_typeis(v,jl_bool_type)
 #define jl_is_symbol(v)      jl_typeis(v,jl_sym_type)
 #define jl_is_ssavalue(v)    jl_typeis(v,jl_ssavalue_type)
@@ -873,7 +894,7 @@ JL_DLLEXPORT int jl_subtype(jl_value_t *a, jl_value_t *b);
 STATIC_INLINE int jl_is_kind(jl_value_t *v)
 {
     return (v==(jl_value_t*)jl_uniontype_type || v==(jl_value_t*)jl_datatype_type ||
-            v==(jl_value_t*)jl_unionall_type || v==(jl_value_t*)jl_bottomtype_type);
+            v==(jl_value_t*)jl_unionall_type || v==(jl_value_t*)jl_typeofbottom_type);
 }
 
 STATIC_INLINE int jl_is_type(jl_value_t *v)
@@ -892,9 +913,8 @@ STATIC_INLINE int jl_is_primitivetype(void *v)
 STATIC_INLINE int jl_is_structtype(void *v)
 {
     return (jl_is_datatype(v) &&
-            (jl_field_count(v) > 0 ||
-             jl_datatype_size(v) == 0) &&
-            !((jl_datatype_t*)(v))->abstract);
+            !((jl_datatype_t*)(v))->abstract &&
+            !jl_is_primitivetype(v));
 }
 
 STATIC_INLINE int jl_isbits(void *t)   // corresponding to isbits() in julia
@@ -909,12 +929,6 @@ STATIC_INLINE int jl_is_datatype_singleton(jl_datatype_t *d)
     return (d->instance != NULL);
 }
 
-STATIC_INLINE int jl_is_datatype_make_singleton(jl_datatype_t *d)
-{
-    return (!d->abstract && jl_datatype_size(d) == 0 && d != jl_sym_type && d->name != jl_array_typename &&
-            d->uid != 0 && (d->name->names == jl_emptysvec || !d->mutabl));
-}
-
 STATIC_INLINE int jl_is_abstracttype(void *v)
 {
     return (jl_is_datatype(v) && ((jl_datatype_t*)(v))->abstract);
@@ -977,6 +991,7 @@ JL_DLLEXPORT int jl_isa(jl_value_t *a, jl_value_t *t);
 JL_DLLEXPORT int jl_types_equal(jl_value_t *a, jl_value_t *b);
 JL_DLLEXPORT jl_value_t *jl_type_union(jl_value_t **ts, size_t n);
 JL_DLLEXPORT jl_value_t *jl_type_intersection(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT int jl_has_empty_intersection(jl_value_t *x, jl_value_t *y);
 JL_DLLEXPORT jl_value_t *jl_type_unionall(jl_tvar_t *v, jl_value_t *body);
 JL_DLLEXPORT const char *jl_typename_str(jl_value_t *v);
 JL_DLLEXPORT const char *jl_typeof_str(jl_value_t *v);
@@ -984,7 +999,7 @@ JL_DLLEXPORT int jl_type_morespecific(jl_value_t *a, jl_value_t *b);
 jl_value_t *jl_unwrap_unionall(jl_value_t *v);
 jl_value_t *jl_rewrap_unionall(jl_value_t *t, jl_value_t *u);
 
-#ifdef NDEBUG
+#if defined(NDEBUG) && defined(JL_NDEBUG)
 STATIC_INLINE int jl_is_concrete_type_(jl_value_t *v)
 {
     return jl_is_datatype(v) && ((jl_datatype_t*)v)->isconcrete;
@@ -993,7 +1008,7 @@ STATIC_INLINE int jl_is_concrete_type_(jl_value_t *v)
 #endif
 
 // type constructors
-JL_DLLEXPORT jl_typename_t *jl_new_typename(jl_sym_t *name);
+JL_DLLEXPORT jl_typename_t *jl_new_typename_in(jl_sym_t *name, jl_module_t *inmodule);
 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_instantiate_unionall(jl_unionall_t *u, jl_value_t *p);
 JL_DLLEXPORT jl_value_t *jl_apply_type(jl_value_t *tc, jl_value_t **params, size_t n);
@@ -1001,14 +1016,19 @@ JL_DLLEXPORT jl_value_t *jl_apply_type1(jl_value_t *tc, jl_value_t *p1);
 JL_DLLEXPORT jl_value_t *jl_apply_type2(jl_value_t *tc, jl_value_t *p1, jl_value_t *p2);
 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_datatype(jl_sym_t *name, jl_datatype_t *super,
+JL_DLLEXPORT jl_datatype_t *jl_new_datatype(jl_sym_t *name,
+                                            jl_module_t *module,
+                                            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_primitivetype(jl_value_t *name,
+                                                 jl_module_t *module,
                                                  jl_datatype_t *super,
                                                  jl_svec_t *parameters, size_t nbits);
+jl_datatype_t *jl_new_abstracttype(jl_value_t *name, jl_module_t *module,
+                                   jl_datatype_t *super, jl_svec_t *parameters);
 
 // constructors
 JL_DLLEXPORT jl_value_t *jl_new_bits(jl_value_t *bt, void *data);
@@ -1031,14 +1051,15 @@ JL_DLLEXPORT jl_sym_t *jl_symbol_n(const char *str, size_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_DLLEXPORT jl_value_t *jl_generic_function_def(jl_sym_t *name,
+                                                 jl_module_t *module,
+                                                 jl_value_t **bp, jl_value_t *bp_owner,
                                                  jl_binding_t *bnd);
-JL_DLLEXPORT void jl_method_def(jl_svec_t *argdata, jl_code_info_t *f, jl_value_t *isstaged);
+JL_DLLEXPORT void jl_method_def(jl_svec_t *argdata, jl_code_info_t *f, jl_module_t *module, jl_value_t *isstaged);
 JL_DLLEXPORT jl_code_info_t *jl_code_for_staged(jl_method_instance_t *linfo);
 JL_DLLEXPORT jl_code_info_t *jl_copy_code_info(jl_code_info_t *src);
 JL_DLLEXPORT size_t jl_get_world_counter(void);
-JL_DLLEXPORT jl_function_t *jl_get_kwsorter(jl_typename_t *tn);
+JL_DLLEXPORT jl_function_t *jl_get_kwsorter(jl_value_t *ty);
 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);
@@ -1079,12 +1100,14 @@ JL_DLLEXPORT int jl_get_size(jl_value_t *val, size_t *pnt);
 #define jl_unbox_long(x) jl_unbox_int64(x)
 #define jl_is_long(x)    jl_is_int64(x)
 #define jl_long_type     jl_int64_type
+#define jl_ulong_type    jl_uint64_type
 #else
 #define jl_box_long(x)   jl_box_int32(x)
 #define jl_box_ulong(x)  jl_box_uint32(x)
 #define jl_unbox_long(x) jl_unbox_int32(x)
 #define jl_is_long(x)    jl_is_int32(x)
 #define jl_long_type     jl_int32_type
+#define jl_ulong_type    jl_uint32_type
 #endif
 
 // Each tuple can exist in one of 4 Vararg states:
@@ -1190,6 +1213,7 @@ 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_array_ptr_1d_push(jl_array_t *a, jl_value_t *item);
 JL_DLLEXPORT void jl_array_ptr_1d_push2(jl_array_t *a, jl_value_t *b, jl_value_t *c);
+JL_DLLEXPORT void jl_array_ptr_1d_append(jl_array_t *a, jl_array_t *a2);
 JL_DLLEXPORT jl_value_t *jl_apply_array_type(jl_value_t *type, size_t dim);
 // property access
 JL_DLLEXPORT void *jl_array_ptr(jl_array_t *a);
@@ -1231,6 +1255,7 @@ JL_DLLEXPORT void jl_module_import(jl_module_t *to, jl_module_t *from,
 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 int jl_module_exports_p(jl_module_t *m, jl_sym_t *var);
 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)
@@ -1308,16 +1333,25 @@ typedef enum {
     JL_IMAGE_JULIA_HOME = 1,
     //JL_IMAGE_LIBJULIA = 2,
 } JL_IMAGE_SEARCH;
+#ifdef JULIA_ENABLE_THREADING
+// this helps turn threading compilation mismatches into linker errors
+#define julia_init julia_init__threading
+#define jl_init jl_init__threading
+#define jl_init_with_image jl_init_with_image__threading
+#endif
 JL_DLLEXPORT void julia_init(JL_IMAGE_SEARCH rel);
-JL_DLLEXPORT void jl_init(const char *julia_home_dir);
+JL_DLLEXPORT void jl_init(void);
 JL_DLLEXPORT void jl_init_with_image(const char *julia_home_dir,
                                      const char *image_relative_path);
+JL_DLLEXPORT const char *jl_get_default_sysimg_path(void);
 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 const char *jl_pathname_for_handle(void *handle);
 
 JL_DLLEXPORT int jl_deserialize_verify_header(ios_t *s);
 JL_DLLEXPORT void jl_preload_sysimg_so(const char *fname);
+JL_DLLEXPORT void jl_set_sysimg_so(void *handle);
 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);
@@ -1333,8 +1367,8 @@ 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);
-JL_DLLEXPORT jl_value_t *jl_expand(jl_value_t *expr);
+                                             char *filename, jl_module_t *inmodule);
+JL_DLLEXPORT jl_value_t *jl_expand(jl_value_t *expr, jl_module_t *inmodule);
 JL_DLLEXPORT jl_value_t *jl_eval_string(const char *str);
 
 // external libraries
@@ -1366,9 +1400,9 @@ JL_DLLEXPORT const char *jl_lookup_soname(const char *pfx, size_t n);
 #endif
 
 // compiler
-JL_DLLEXPORT jl_value_t *jl_toplevel_eval(jl_value_t *v);
+JL_DLLEXPORT jl_value_t *jl_toplevel_eval(jl_module_t *m, 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_load(const char *fname);
+JL_DLLEXPORT jl_value_t *jl_load(jl_module_t *module, const char *fname);
 JL_DLLEXPORT jl_module_t *jl_base_relative_to(jl_module_t *m);
 
 // tracing
@@ -1383,8 +1417,12 @@ JL_DLLEXPORT void jl_register_newmeth_tracer(void (*callback)(jl_method_t *trace
 // AST access
 JL_DLLEXPORT jl_value_t *jl_copy_ast(jl_value_t *expr);
 
-JL_DLLEXPORT jl_array_t *jl_compress_ast(jl_method_t *m, jl_array_t *ast);
-JL_DLLEXPORT jl_array_t *jl_uncompress_ast(jl_method_t *m, jl_array_t *data);
+JL_DLLEXPORT jl_array_t *jl_compress_ast(jl_method_t *m, jl_code_info_t *code);
+JL_DLLEXPORT jl_code_info_t *jl_uncompress_ast(jl_method_t *m, jl_array_t *data);
+JL_DLLEXPORT uint8_t jl_ast_flag_inferred(jl_array_t *data);
+JL_DLLEXPORT uint8_t jl_ast_flag_inlineable(jl_array_t *data);
+JL_DLLEXPORT uint8_t jl_ast_flag_pure(jl_array_t *data);
+JL_DLLEXPORT void jl_fill_argnames(jl_array_t *data, jl_array_t *names);
 
 JL_DLLEXPORT int jl_is_operator(char *sym);
 JL_DLLEXPORT int jl_operator_precedence(char *sym);
@@ -1483,45 +1521,13 @@ typedef struct _jl_task_t {
 } jl_task_t;
 
 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_switchto(jl_task_t **pt);
 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);
 JL_DLLEXPORT void JL_NORETURN jl_no_exc_handler(jl_value_t *e);
 
-#ifdef JULIA_ENABLE_THREADING
-static inline void jl_lock_frame_push(jl_mutex_t *lock)
-{
-    jl_ptls_t ptls = jl_get_ptls_states();
-    // For early bootstrap
-    if (__unlikely(!ptls->current_task))
-        return;
-    arraylist_t *locks = &ptls->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*)lock;
-}
-static inline void jl_lock_frame_pop(void)
-{
-    jl_ptls_t ptls = jl_get_ptls_states();
-    if (__likely(ptls->current_task)) {
-        ptls->current_task->locks.len--;
-    }
-}
-#else
-static inline void jl_lock_frame_push(jl_mutex_t *lock)
-{
-    (void)lock;
-}
-static inline void jl_lock_frame_pop(void)
-{
-}
-#endif // ifndef JULIA_ENABLE_THREADING
+#include "locks.h"   // requires jl_task_t definition
 
 STATIC_INLINE void jl_eh_restore_state(jl_handler_t *eh)
 {
@@ -1654,7 +1660,6 @@ JL_DLLEXPORT JL_STREAM *jl_stdin_stream(void);
 JL_DLLEXPORT JL_STREAM *jl_stderr_stream(void);
 
 // showing and std streams
-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);
@@ -1691,12 +1696,15 @@ typedef struct {
     int8_t can_inline;
     int8_t polly;
     int8_t fast_math;
-    const char *worker;
+    int8_t worker;
+    const char *cookie;
     int8_t handle_signals;
     int8_t use_precompiled;
     int8_t use_compilecache;
     const char *bindto;
     const char *outputbc;
+    const char *outputunoptbc;
+    const char *outputjitbc;
     const char *outputo;
     const char *outputji;
     int8_t incremental;
@@ -1704,6 +1712,7 @@ typedef struct {
 } jl_options_t;
 
 extern JL_DLLEXPORT jl_options_t jl_options;
+JL_DLLEXPORT ssize_t jl_sizeof_jl_options(void);
 
 // Parse an argc/argv pair to extract general julia options, passing back out
 // any arguments that should be passed on to the script.
@@ -1761,7 +1770,7 @@ JL_DLLEXPORT int jl_generating_output(void);
 #define JL_OPTIONS_USE_COMPILECACHE_NO 0
 
 // Version information
-#include <julia_version.h>
+#include "julia_version.h"
 
 JL_DLLEXPORT extern int jl_ver_major(void);
 JL_DLLEXPORT extern int jl_ver_minor(void);
@@ -1786,7 +1795,6 @@ typedef struct {
 #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)
 
 
 // codegen interface ----------------------------------------------------------
@@ -1825,6 +1833,23 @@ typedef struct {
 } jl_cgparams_t;
 extern JL_DLLEXPORT jl_cgparams_t jl_default_cgparams;
 
+#if defined(JULIA_ENABLE_THREADING) && !defined(_OS_DARWIN_) && !defined(_OS_WINDOWS_)
+#define JULIA_DEFINE_FAST_TLS()                                                             \
+JL_DLLEXPORT JL_CONST_FUNC jl_ptls_t jl_get_ptls_states_static(void)                        \
+{                                                                                           \
+    static __attribute__((tls_model("local-exec"))) __thread jl_tls_states_t tls_states;    \
+    return &tls_states;                                                                     \
+}                                                                                           \
+__attribute__((constructor)) void jl_register_ptls_states_getter(void)                      \
+{                                                                                           \
+    /* We need to make sure this function is called before any reference to */              \
+    /* TLS variables. */                                                                    \
+    jl_set_ptls_states_getter(jl_get_ptls_states_static);                                   \
+}
+#else
+#define JULIA_DEFINE_FAST_TLS()
+#endif
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/julia_internal.h b/src/julia_internal.h
index fc0ede80978415..1ab41688974385 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -1,9 +1,9 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
-#ifndef JULIA_INTERNAL_H
-#define JULIA_INTERNAL_H
+#ifndef JL_INTERNAL_H
+#define JL_INTERNAL_H
 
-#include <options.h>
+#include "options.h"
 #include <uv.h>
 #if !defined(_MSC_VER) && !defined(__MINGW32__)
 #include <unistd.h>
@@ -12,6 +12,12 @@
 #define sleep(x) Sleep(1000*x)
 #endif
 
+#ifdef __has_builtin
+#  define jl_has_builtin(x) __has_builtin(x)
+#else
+#  define jl_has_builtin(x) 0
+#endif
+
 #if defined(__has_feature)
 #if __has_feature(address_sanitizer)
 #define JL_ASAN_ENABLED     // Clang flavor
@@ -26,12 +32,95 @@
 #endif
 #endif
 
+// Remove when C11 is required for C code.
+#ifndef static_assert
+#  ifndef __cplusplus
+// C11 should already have `static_assert` from `<assert.h>` so there's no need
+// to check C version.
+#    ifdef __GNUC__
+#      define static_assert _Static_assert
+#    else
+#      define static_assert(...)
+#    endif
+#  endif
+// For C++, C++11 or MSVC is required. Both provide `static_assert`.
+#endif
+
+#if jl_has_builtin(__builtin_assume)
+#define jl_assume(cond) (__extension__ ({               \
+                __typeof__(cond) cond_ = (cond);        \
+                __builtin_assume(!!(cond_));            \
+                cond_;                                  \
+            }))
+#elif defined(_COMPILER_MICROSOFT_) && defined(__cplusplus)
+template<typename T>
+static inline T
+jl_assume(T v)
+{
+    __assume(!!v);
+    return v;
+}
+#elif defined(_COMPILER_INTEL_)
+#define jl_assume(cond) (__extension__ ({               \
+                __typeof__(cond) cond_ = (cond);        \
+                __assume(!!(cond_));                    \
+                cond_;                                  \
+            }))
+#elif defined(__GNUC__)
+static inline void jl_assume_(int cond)
+{
+    if (!cond) {
+        __builtin_unreachable();
+    }
+}
+#define jl_assume(cond) (__extension__ ({               \
+                __typeof__(cond) cond_ = (cond);        \
+                jl_assume_(!!(cond_));                  \
+                cond_;                                  \
+            }))
+#else
+#define jl_assume(cond) (cond)
+#endif
+
+#if defined(__GLIBC__) && defined(JULIA_HAS_IFUNC_SUPPORT)
+// Make sure both the compiler and the glibc supports it.
+// Only enable this on known working glibc versions.
+#  if (defined(_CPU_X86_) || defined(_CPU_X86_64_)) && __GLIBC_PREREQ(2, 12)
+#    define JL_USE_IFUNC 1
+#  elif (defined(_CPU_ARM_) || defined(_CPU_AARCH64_)) && __GLIBC_PREREQ(2, 18)
+// This is the oldest tested version that supports ifunc.
+#    define JL_USE_IFUNC 1
+#  endif
+// TODO: PPC probably supports ifunc on some glibc versions too
+#endif
+// Make sure JL_USE_IFUNC is always defined to catch include errors.
+#ifndef JL_USE_IFUNC
+#  define JL_USE_IFUNC 0
+#endif
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 #include "timing.h"
 
+#ifdef _COMPILER_MICROSOFT_
+#  define jl_return_address() ((uintptr_t)_ReturnAddress())
+#else
+#  define jl_return_address() ((uintptr_t)__builtin_return_address(0))
+#endif
+
+STATIC_INLINE uint32_t jl_int32hash_fast(uint32_t a)
+{
+//    a = (a+0x7ed55d16) + (a<<12);
+//    a = (a^0xc761c23c) ^ (a>>19);
+//    a = (a+0x165667b1) + (a<<5);
+//    a = (a+0xd3a2646c) ^ (a<<9);
+//    a = (a+0xfd7046c5) + (a<<3);
+//    a = (a^0xb55a4f09) ^ (a>>16);
+    return a;  // identity hashing seems to work well enough here
+}
+
 #define GC_CLEAN  0 // freshly allocated
 #define GC_MARKED 1 // reachable and young
 #define GC_OLD    2 // if it is reachable it will be marked as old
@@ -56,19 +145,19 @@ JL_DLLEXPORT jl_value_t *jl_gc_pool_alloc(jl_ptls_t ptls, int pool_offset,
 JL_DLLEXPORT jl_value_t *jl_gc_big_alloc(jl_ptls_t ptls, size_t allocsz);
 int jl_gc_classify_pools(size_t sz, int *osize);
 extern jl_mutex_t gc_perm_lock;
-void *jl_gc_perm_alloc_nolock(size_t sz);
-void *jl_gc_perm_alloc(size_t sz);
+void *jl_gc_perm_alloc_nolock(size_t sz, int zero, unsigned align, unsigned offset);
+void *jl_gc_perm_alloc(size_t sz, int zero, unsigned align, unsigned offset);
+void jl_gc_force_mark_old(jl_ptls_t ptls, jl_value_t *v);
+void gc_sweep_sysimg(void);
+
 
 // pools are 16376 bytes large (GC_POOL_SZ - GC_PAGE_OFFSET)
 static const int jl_gc_sizeclasses[JL_GC_N_POOLS] = {
 #ifdef _P64
     8,
-#elif defined(_CPU_ARM_) || defined(_CPU_PPC_) || defined(_CPU_X86_)
+#elif defined(_CPU_ARM_) || defined(_CPU_PPC_)
     // ARM and PowerPC have max alignment of 8,
     // make sure allocation of size 8 has that alignment.
-    // for x86 alignment is important for atomic ops and
-    // the corresponding platform ABI. Once we can use
-    // libatomic on Windows this is no longer necessary.
     4, 8,
 #else
     4, 8, 12,
@@ -104,7 +193,7 @@ STATIC_INLINE int jl_gc_alignment(size_t sz)
 #ifdef _P64
     (void)sz;
     return 16;
-#elif defined(_CPU_ARM_) || defined(_CPU_PPC_) || defined(_CPU_X86_)
+#elif defined(_CPU_ARM_) || defined(_CPU_PPC_)
     return sz <= 4 ? 8 : 16;
 #else
     // szclass 8
@@ -125,7 +214,7 @@ STATIC_INLINE int JL_CONST_FUNC jl_gc_szclass(size_t sz)
     if (sz <=    8)
         return 0;
     const int N = 0;
-#elif defined(_CPU_ARM_) || defined(_CPU_PPC_) || defined(_CPU_X86_)
+#elif defined(_CPU_ARM_) || defined(_CPU_PPC_)
     if (sz <=    8)
         return (sz + 3) / 4 - 1;
     const int N = 1;
@@ -150,6 +239,8 @@ STATIC_INLINE int JL_CONST_FUNC jl_gc_szclass(size_t sz)
 #endif
 #define JL_SMALL_BYTE_ALIGNMENT 16
 #define JL_CACHE_BYTE_ALIGNMENT 64
+// JL_HEAP_ALIGNMENT is the maximum alignment that the GC can provide
+#define JL_HEAP_ALIGNMENT JL_SMALL_BYTE_ALIGNMENT
 #define GC_MAX_SZCLASS (2032-sizeof(void*))
 
 STATIC_INLINE jl_value_t *jl_gc_alloc_(jl_ptls_t ptls, size_t sz, void *ty)
@@ -192,73 +283,112 @@ STATIC_INLINE void *jl_gc_alloc_buf(jl_ptls_t ptls, size_t sz)
     return jl_gc_alloc(ptls, sz, (void*)jl_buff_tag);
 }
 
+STATIC_INLINE jl_value_t *jl_gc_permobj(size_t sz, void *ty)
+{
+    const size_t allocsz = sz + sizeof(jl_taggedvalue_t);
+    unsigned align = (sz == 0 ? sizeof(void*) : (allocsz <= sizeof(void*) * 2 ?
+                                                 sizeof(void*) * 2 : 16));
+    jl_taggedvalue_t *o = (jl_taggedvalue_t*)jl_gc_perm_alloc(allocsz, 0, align,
+                                                              sizeof(void*) % align);
+    uintptr_t tag = (uintptr_t)ty;
+    o->header = tag | GC_OLD_MARKED;
+    return jl_valueof(o);
+}
+jl_value_t *jl_permbox8(jl_datatype_t *t, int8_t x);
+jl_value_t *jl_permbox16(jl_datatype_t *t, int16_t x);
+jl_value_t *jl_permbox32(jl_datatype_t *t, int32_t x);
+jl_value_t *jl_permbox64(jl_datatype_t *t, int64_t x);
+jl_svec_t *jl_perm_symsvec(size_t n, ...);
+
+// Returns a int32 where the high 16 bits are a lower bound of the number of non-pointer fields
+// at the beginning of the type and the low 16 bits are a lower bound on the number of non-pointer
+// fields at the end of the type. This field only exists for a layout that has at least one
+// pointer fields.
+#define jl_datatype_layout_n_nonptr(layout) ((uint32_t*)(layout))[-1]
+
 jl_value_t *jl_gc_realloc_string(jl_value_t *s, size_t sz);
 
 jl_code_info_t *jl_type_infer(jl_method_instance_t **li, size_t world, int force);
-jl_generic_fptr_t jl_generate_fptr(jl_method_instance_t *li, void *F, size_t world);
-jl_llvm_functions_t jl_compile_linfo(jl_method_instance_t **pli, jl_code_info_t *src, size_t world, const jl_cgparams_t *params);
+jl_generic_fptr_t jl_generate_fptr(jl_method_instance_t *li, const char *F, size_t world);
+jl_llvm_functions_t jl_compile_linfo(
+        jl_method_instance_t **pli,
+        jl_code_info_t *src,
+        size_t world,
+        const jl_cgparams_t *params);
 jl_llvm_functions_t jl_compile_for_dispatch(jl_method_instance_t **li, size_t world);
 JL_DLLEXPORT int jl_compile_hint(jl_tupletype_t *types);
 jl_code_info_t *jl_new_code_info_from_ast(jl_expr_t *ast);
-jl_method_t *jl_new_method(jl_code_info_t *definition,
-                           jl_sym_t *name,
-                           jl_tupletype_t *sig,
-                           size_t nargs,
-                           int isva,
-                           jl_svec_t *tvars,
-                           int isstaged);
 
-// invoke (compiling if necessary) the jlcall function pointer for a method
-STATIC_INLINE jl_value_t *jl_call_method_internal(jl_method_instance_t *meth, jl_value_t **args, uint32_t nargs)
+STATIC_INLINE jl_value_t *jl_compile_method_internal(jl_generic_fptr_t *fptr,
+                                                     jl_method_instance_t *meth)
 {
-    jl_generic_fptr_t fptr;
-    fptr.fptr = meth->fptr;
-    fptr.jlcall_api = meth->jlcall_api;
-    if (fptr.jlcall_api == 2)
-        return meth->inferred;
-    if (__unlikely(fptr.fptr == NULL || fptr.jlcall_api == 0)) {
+    if (meth->jlcall_api == 2)
+        return jl_assume(meth->inferred_const);
+    fptr->fptr = meth->fptr;
+    fptr->jlcall_api = meth->jlcall_api;
+    if (__unlikely(fptr->fptr == NULL || fptr->jlcall_api == 0)) {
         size_t world = jl_get_ptls_states()->world_age;
         // first see if it likely needs to be compiled
-        void *F = meth->functionObjectsDecls.functionObject;
+        const char *F = meth->functionObjectsDecls.functionObject;
         if (!F) // ask codegen to try to turn it into llvm code
             F = jl_compile_for_dispatch(&meth, world).functionObject;
         if (meth->jlcall_api == 2)
-            return meth->inferred;
+            return jl_assume(meth->inferred_const);
         // if it hasn't been inferred, try using the unspecialized meth cache instead
         if (!meth->inferred) {
-            fptr.fptr = meth->unspecialized_ducttape;
-            fptr.jlcall_api = 1;
-            if (!fptr.fptr) {
-                if (meth->def && !meth->def->isstaged && meth->def->unspecialized) {
-                    fptr.fptr = meth->def->unspecialized->fptr;
-                    fptr.jlcall_api = meth->def->unspecialized->jlcall_api;
-                    if (fptr.jlcall_api == 2)
-                        return meth->def->unspecialized->inferred;
+            fptr->fptr = meth->unspecialized_ducttape;
+            fptr->jlcall_api = 1;
+            if (!fptr->fptr) {
+                if (jl_is_method(meth->def.method) && meth->def.method->unspecialized) {
+                    fptr->fptr = meth->def.method->unspecialized->fptr;
+                    fptr->jlcall_api = meth->def.method->unspecialized->jlcall_api;
+                    if (fptr->jlcall_api == 2) {
+                        return jl_assume(meth->def.method->unspecialized->inferred_const);
+                    }
                 }
             }
         }
-        if (!fptr.fptr || fptr.jlcall_api == 0) {
+        if (!fptr->fptr || fptr->jlcall_api == 0) {
             // ask codegen to make the fptr
-            fptr = jl_generate_fptr(meth, F, world);
-            if (fptr.jlcall_api == 2)
-                return meth->inferred;
+            *fptr = jl_generate_fptr(meth, F, world);
+            if (fptr->jlcall_api == 2)
+                return jl_assume(meth->inferred_const);
         }
     }
-    if (fptr.jlcall_api == 1)
-        return fptr.fptr1(args[0], &args[1], nargs-1);
-    else if (fptr.jlcall_api == 3)
-        return fptr.fptr3(meth->sparam_vals, args[0], &args[1], nargs-1);
-    else if (fptr.jlcall_api == 4)
-        return fptr.fptr4(meth, &args[0], nargs, meth->sparam_vals);
+    return NULL;
+}
+
+STATIC_INLINE jl_value_t *jl_call_fptr_internal(const jl_generic_fptr_t *fptr,
+                                                jl_method_instance_t *meth,
+                                                jl_value_t **args, uint32_t nargs)
+{
+    if (fptr->jlcall_api == 1)
+        return fptr->fptr1(args[0], &args[1], nargs-1);
+    else if (fptr->jlcall_api == 2)
+        return meth->inferred;
+    else if (fptr->jlcall_api == 3)
+        return fptr->fptr3(meth->sparam_vals, args[0], &args[1], nargs-1);
+    else if (fptr->jlcall_api == 4)
+        return fptr->fptr4(meth, &args[0], nargs, meth->sparam_vals);
     else
         abort();
 }
 
+// invoke (compiling if necessary) the jlcall function pointer for a method
+STATIC_INLINE jl_value_t *jl_call_method_internal(jl_method_instance_t *meth, jl_value_t **args, uint32_t nargs)
+{
+    jl_generic_fptr_t fptr;
+    jl_value_t *v = jl_compile_method_internal(&fptr, meth);
+    if (v)
+        return v;
+    (void)jl_assume(fptr.jlcall_api != 2);
+    return jl_call_fptr_internal(&fptr, meth, args, nargs);
+}
+
 jl_tupletype_t *jl_argtype_with_function(jl_function_t *f, jl_tupletype_t *types);
 
 JL_DLLEXPORT jl_value_t *jl_apply_2va(jl_value_t *f, jl_value_t **args, uint32_t nargs);
 
-void jl_gc_setmark(jl_ptls_t ptls, jl_value_t *v);
 void jl_gc_sync_total_bytes(void);
 void jl_gc_track_malloced_array(jl_ptls_t ptls, jl_array_t *a);
 void jl_gc_count_allocd(size_t sz);
@@ -304,7 +434,6 @@ JL_DLLEXPORT void jl_typeassert(jl_value_t *x, jl_value_t *t);
 #define JL_CALLABLE(name)                                               \
     JL_DLLEXPORT jl_value_t *name(jl_value_t *F, jl_value_t **args, uint32_t nargs)
 
-JL_CALLABLE(jl_unprotect_stack);
 JL_CALLABLE(jl_f_tuple);
 JL_CALLABLE(jl_f_intrinsic_call);
 extern jl_function_t *jl_unprotect_stack_func;
@@ -330,21 +459,21 @@ int jl_tuple_isa(jl_value_t **child, size_t cl, jl_datatype_t *pdt);
 
 int jl_has_intersect_type_not_kind(jl_value_t *t);
 int jl_subtype_invariant(jl_value_t *a, jl_value_t *b, int ta);
-jl_value_t *jl_type_match(jl_value_t *a, jl_value_t *b);
-jl_value_t *jl_type_match_morespecific(jl_value_t *a, jl_value_t *b);
 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);
 JL_DLLEXPORT void jl_method_table_insert(jl_methtable_t *mt, jl_method_t *method, jl_tupletype_t *simpletype);
 void jl_mk_builtin_func(jl_datatype_t *dt, const char *name, jl_fptr_t fptr);
 jl_value_t *jl_type_intersection_env_s(jl_value_t *a, jl_value_t *b, jl_svec_t **penv, int *issubty);
 jl_value_t *jl_type_intersection_env(jl_value_t *a, jl_value_t *b, jl_svec_t **penv);
+// specificity comparison assuming !(a <: b) and !(b <: a)
+JL_DLLEXPORT int jl_type_morespecific_no_subtype(jl_value_t *a, jl_value_t *b);
 jl_value_t *jl_instantiate_type_with(jl_value_t *t, jl_value_t **env, size_t n);
 JL_DLLEXPORT jl_value_t *jl_instantiate_type_in_env(jl_value_t *ty, jl_unionall_t *env, jl_value_t **vals);
 jl_value_t *jl_substitute_var(jl_value_t *t, jl_tvar_t *var, jl_value_t *val);
 jl_svec_t *jl_outer_unionall_vars(jl_value_t *u);
+int jl_count_union_components(jl_value_t *v);
+jl_value_t *jl_nth_union_component(jl_value_t *v, int i);
 jl_datatype_t *jl_new_uninitialized_datatype(void);
-jl_datatype_t *jl_new_abstracttype(jl_value_t *name, jl_datatype_t *super,
-                                   jl_svec_t *parameters);
 void jl_precompute_memoized_dt(jl_datatype_t *dt);
 jl_datatype_t *jl_wrap_Type(jl_value_t *t);  // x -> Type{x}
 jl_value_t *jl_wrap_vararg(jl_value_t *t, jl_value_t *n);
@@ -355,26 +484,30 @@ jl_function_t *jl_new_generic_function_with_supertype(jl_sym_t *name, jl_module_
 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, int expanded);
+jl_value_t *jl_toplevel_eval_flex(jl_module_t *m, jl_value_t *e, int fast, int expanded);
 
 jl_code_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,
-                              const char *content, size_t contentlen);
-jl_value_t *jl_interpret_toplevel_thunk(jl_code_info_t *src);
-jl_value_t *jl_interpret_toplevel_expr(jl_value_t *e);
+                              const char *content, size_t contentlen,
+                              jl_module_t *inmodule);
+jl_value_t *jl_interpret_toplevel_thunk(jl_module_t *m, jl_code_info_t *src);
 jl_value_t *jl_interpret_toplevel_expr_in(jl_module_t *m, jl_value_t *e,
                                           jl_code_info_t *src,
                                           jl_svec_t *sparam_vals);
 int jl_is_toplevel_only_expr(jl_value_t *e);
-jl_value_t *jl_call_scm_on_ast(const char *funcname, jl_value_t *expr);
+jl_value_t *jl_call_scm_on_ast(const char *funcname, jl_value_t *expr, jl_module_t *inmodule);
 
 jl_method_instance_t *jl_method_lookup_by_type(jl_methtable_t *mt, jl_tupletype_t *types,
                                                int cache, int inexact, int allow_exec, size_t world);
 jl_method_instance_t *jl_method_lookup(jl_methtable_t *mt, jl_value_t **args, size_t nargs, int cache, size_t world);
 jl_value_t *jl_gf_invoke(jl_tupletype_t *types, jl_value_t **args, size_t nargs);
+jl_method_instance_t *jl_lookup_generic(jl_value_t **args, uint32_t nargs, uint32_t callsite, size_t world);
+JL_DLLEXPORT jl_value_t *jl_matching_methods(jl_tupletype_t *types, int lim, int include_ambiguous,
+                                             size_t world, size_t *min_valid, size_t *max_valid);
 
 JL_DLLEXPORT jl_datatype_t *jl_first_argument_datatype(jl_value_t *argtypes);
+JL_DLLEXPORT jl_value_t *jl_argument_datatype(jl_value_t *argt);
 
 jl_value_t *jl_nth_slot_type(jl_value_t *sig, size_t i);
 void jl_compute_field_offsets(jl_datatype_t *st);
@@ -396,6 +529,7 @@ void jl_init_types(void);
 void jl_init_box_caches(void);
 void jl_init_frontend(void);
 void jl_init_primitives(void);
+void *jl_init_llvm(void);
 void jl_init_codegen(void);
 void jl_init_intrinsic_functions(void);
 void jl_init_intrinsic_properties(void);
@@ -407,13 +541,14 @@ void jl_gc_init(void);
 void jl_init_signal_async(void);
 void jl_init_debuginfo(void);
 void jl_init_runtime_ccall(void);
-void jl_mk_thread_heap(jl_ptls_t ptls);
+void jl_init_thread_heap(jl_ptls_t ptls);
 
 void _julia_init(JL_IMAGE_SEARCH rel);
 
 void jl_set_base_ctx(char *__stk);
 
 extern ssize_t jl_tls_offset;
+extern const int jl_tls_elf_support;
 void jl_init_threading(void);
 void jl_start_threads(void);
 void jl_shutdown_threading(void);
@@ -476,10 +611,12 @@ static inline void jl_set_gc_and_wait(void)
 }
 #endif
 
-void jl_dump_native(const char *bc_fname, const char *obj_fname, const char *sysimg_data, size_t sysimg_len);
+JL_DLLEXPORT jl_value_t *jl_dump_fptr_asm(uint64_t fptr, int raw_mc, const char* asm_variant);
+
+void jl_dump_native(const char *bc_fname, const char *unopt_bc_fname, const char *obj_fname, const char *sysimg_data, size_t sysimg_len);
 int32_t jl_get_llvm_gv(jl_value_t *p);
-int32_t jl_assign_functionID(/*llvm::Function*/void *function);
-int32_t jl_jlcall_api(/*llvm::Function*/const void *function);
+int32_t jl_assign_functionID(const char *fname);
+int32_t jl_jlcall_api(const char *fname);
 // the first argument to jl_idtable_rehash is used to return a value
 // make sure it is rooted if it is used after the function returns
 JL_DLLEXPORT jl_array_t *jl_idtable_rehash(jl_array_t *a, size_t newsz);
@@ -488,6 +625,7 @@ JL_DLLEXPORT jl_methtable_t *jl_new_method_table(jl_sym_t *name, jl_module_t *mo
 jl_method_instance_t *jl_get_specialization1(jl_tupletype_t *types, size_t world);
 JL_DLLEXPORT int jl_has_call_ambiguities(jl_tupletype_t *types, jl_method_t *m);
 jl_method_instance_t *jl_get_specialized(jl_method_t *m, jl_value_t *types, jl_svec_t *sp);
+int jl_is_rettype_inferred(jl_method_instance_t *li);
 JL_DLLEXPORT jl_value_t *jl_methtable_lookup(jl_methtable_t *mt, jl_tupletype_t *type, size_t world);
 JL_DLLEXPORT jl_method_instance_t *jl_specializations_get_linfo(jl_method_t *m, jl_value_t *type, jl_svec_t *sparams, size_t world);
 JL_DLLEXPORT void jl_method_instance_add_backedge(jl_method_instance_t *callee, jl_method_instance_t *caller);
@@ -526,7 +664,7 @@ typedef struct {
 } bt_cursor_t;
 #endif
 extern volatile int jl_in_stackwalk;
-#else
+#elif !defined(JL_DISABLE_LIBUNWIND)
 // This gives unwind only local unwinding options ==> faster code
 #  define UNW_LOCAL_ONLY
 #  include <libunwind.h>
@@ -538,17 +676,22 @@ typedef unw_cursor_t bt_cursor_t;
 // on a newer release
 #    define JL_UNW_HAS_FORMAT_IP 1
 #  endif
+#else
+// Unwinding is disabled
+typedef int bt_context_t;
+typedef int bt_cursor_t;
 #endif
 size_t rec_backtrace(uintptr_t *data, size_t maxsize);
 size_t rec_backtrace_ctx(uintptr_t *data, size_t maxsize, bt_context_t *ctx);
 #ifdef LIBOSXUNWIND
 size_t rec_backtrace_ctx_dwarf(uintptr_t *data, size_t maxsize, bt_context_t *ctx);
 #endif
+JL_DLLEXPORT jl_value_t *jl_get_backtrace(void);
+JL_DLLEXPORT jl_value_t *jl_apply_with_saved_exception_state(jl_value_t **args, uint32_t nargs, int drop_exceptions);
 void jl_critical_error(int sig, bt_context_t *context, uintptr_t *bt_data, size_t *bt_size);
 JL_DLLEXPORT void jl_raise_debugger(void);
 int jl_getFunctionInfo(jl_frame_t **frames, uintptr_t pointer, int skipC, int noInline);
 JL_DLLEXPORT void jl_gdblookup(uintptr_t ip);
-jl_value_t *jl_uncompress_ast_(jl_method_instance_t*, jl_value_t*, int);
 // *to is NULL or malloc'd pointer, from is allowed to be NULL
 STATIC_INLINE char *jl_copy_str(char **to, const char *from)
 {
@@ -581,6 +724,9 @@ extern void *jl_winsock_handle;
 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);
+// Windows only
+#define JL_EXE_LIBNAME ((const char*)1)
+#define JL_DL_LIBNAME ((const char*)2)
 const char *jl_dlfind_win32(const char *name);
 void *jl_dlopen_soname(const char *pfx, size_t n, unsigned flags);
 
@@ -660,10 +806,6 @@ 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_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);
@@ -680,7 +822,6 @@ 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);
@@ -690,6 +831,7 @@ 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_DLLEXPORT jl_value_t *(jl_array_data_owner)(jl_array_t *a);
+JL_DLLEXPORT int jl_array_isassigned(jl_array_t *a, size_t i);
 
 // -- synchronization utilities -- //
 
@@ -819,8 +961,8 @@ STATIC_INLINE void *jl_get_frame_addr(void)
 }
 
 JL_DLLEXPORT jl_array_t *jl_array_cconvert_cstring(jl_array_t *a);
+JL_DLLEXPORT void jl_depwarn_partial_indexing(size_t n);
 void jl_depwarn(const char *msg, jl_value_t *sym);
-void jl_depwarn_partial_indexing(size_t n);
 
 int isabspath(const char *in);
 
@@ -854,6 +996,10 @@ extern jl_sym_t *meta_sym; extern jl_sym_t *list_sym;
 extern jl_sym_t *inert_sym; extern jl_sym_t *static_parameter_sym;
 extern jl_sym_t *polly_sym; extern jl_sym_t *inline_sym;
 extern jl_sym_t *propagate_inbounds_sym;
+extern jl_sym_t *isdefined_sym; extern jl_sym_t *nospecialize_sym;
+
+void jl_register_fptrs(uint64_t sysimage_base, const char *base, const int32_t *offsets,
+                       jl_method_instance_t **linfos, size_t n);
 
 #ifdef __cplusplus
 }
diff --git a/src/julia_threads.h b/src/julia_threads.h
index 6a0e6923c17af4..24878589607730 100644
--- a/src/julia_threads.h
+++ b/src/julia_threads.h
@@ -1,8 +1,8 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 // Meant to be included in <julia.h>
-#ifndef JULIA_THREADS_H
-#define JULIA_THREADS_H
+#ifndef JL_THREADS_H
+#define JL_THREADS_H
 
 // threading ------------------------------------------------------------------
 
@@ -13,20 +13,11 @@
 // 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
-#ifndef _OS_WINDOWS_
-#  include <pthread.h>
-#endif
-#include <signal.h>
+// Recursive spin lock
+typedef struct {
+    volatile unsigned long owner;
+    uint32_t count;
+} jl_mutex_t;
 
 typedef struct {
     jl_taggedvalue_t *freelist;   // root of list of free objects
@@ -56,7 +47,7 @@ typedef struct {
     // variables for allocating objects from pools
 #ifdef _P64
 #  define JL_GC_N_POOLS 41
-#elif defined(_CPU_ARM_) || defined(_CPU_PPC_) || defined(_CPU_X86_)
+#elif defined(_CPU_ARM_) || defined(_CPU_PPC_)
 #  define JL_GC_N_POOLS 42
 #else
 #  define JL_GC_N_POOLS 43
@@ -82,6 +73,10 @@ typedef struct {
     // this makes sure that a single objects can only appear once in
     // the lists (the mark bit cannot be flipped to `0` without sweeping)
     void *big_obj[1024];
+    jl_mutex_t stack_lock;
+    void **pc_stack;
+    void **pc_stack_end;
+    char *data_stack;
 } jl_gc_mark_cache_t;
 
 // This includes all the thread local states we care about for a thread.
@@ -105,7 +100,6 @@ typedef struct _jl_tls_states_t {
     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;
@@ -138,8 +132,8 @@ typedef struct _jl_tls_states_t {
     arraylist_t finalizers;
     jl_gc_mark_cache_t gc_cache;
 } jl_tls_states_t;
-typedef jl_tls_states_t *jl_ptls_t;
 
+// Update codegen version in `ccall.cpp` after changing either `pause` or `wake`
 #ifdef __MIC__
 #  define jl_cpu_pause() _mm_delay_64(100)
 #  define jl_cpu_wake() ((void)0)
@@ -158,285 +152,14 @@ typedef jl_tls_states_t *jl_ptls_t;
 #  define JL_CPU_WAKE_NOOP 1
 #endif
 
-// Copied from libuv. Add `JL_CONST_FUNC` so that the compiler
-// can optimize this better.
-static inline unsigned long JL_CONST_FUNC jl_thread_self(void)
-{
-#ifdef _OS_WINDOWS_
-    return (unsigned long)GetCurrentThreadId();
-#else
-    return (unsigned long)pthread_self();
-#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 intrinsics 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 guarantee 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_relaxed(obj, arg)         \
-    __atomic_fetch_add(obj, arg, __ATOMIC_RELAXED)
-#  define jl_atomic_fetch_add(obj, arg)                 \
-    __atomic_fetch_add(obj, arg, __ATOMIC_SEQ_CST)
-#  define jl_atomic_fetch_and_relaxed(obj, arg)         \
-    __atomic_fetch_and(obj, arg, __ATOMIC_RELAXED)
-#  define jl_atomic_fetch_and(obj, arg)                 \
-    __atomic_fetch_and(obj, arg, __ATOMIC_SEQ_CST)
-#  define jl_atomic_fetch_or_relaxed(obj, arg)          \
-    __atomic_fetch_or(obj, arg, __ATOMIC_RELAXED)
-#  define jl_atomic_fetch_or(obj, arg)                  \
-    __atomic_fetch_or(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)
-#  define jl_atomic_exchange(obj, desired)              \
-    __atomic_exchange_n(obj, desired, __ATOMIC_SEQ_CST)
-#  define jl_atomic_exchange_relaxed(obj, desired)      \
-    __atomic_exchange_n(obj, desired, __ATOMIC_RELAXED)
-// 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) do {      \
-        jl_signal_fence();                              \
-        __atomic_store_n(obj, val, __ATOMIC_RELEASE);   \
-    } while (0)
-#  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()
-
-// add
-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);
-}
-#define jl_atomic_fetch_add_relaxed(obj, arg) jl_atomic_fetch_add(obj, arg)
-
-// and
-template<typename T, typename T2>
-static inline typename std::enable_if<sizeof(T) == 1, T>::type
-jl_atomic_fetch_and(T *obj, T2 arg)
-{
-    return (T)_InterlockedAnd8((volatile char*)obj, (char)arg);
-}
-template<typename T, typename T2>
-static inline typename std::enable_if<sizeof(T) == 2, T>::type
-jl_atomic_fetch_and(T *obj, T2 arg)
-{
-    return (T)_InterlockedAnd16((volatile short*)obj, (short)arg);
-}
-template<typename T, typename T2>
-static inline typename std::enable_if<sizeof(T) == 4, T>::type
-jl_atomic_fetch_and(T *obj, T2 arg)
-{
-    return (T)_InterlockedAnd((volatile LONG*)obj, (LONG)arg);
-}
-template<typename T, typename T2>
-static inline typename std::enable_if<sizeof(T) == 8, T>::type
-jl_atomic_fetch_and(T *obj, T2 arg)
-{
-    return (T)_InterlockedAnd64((volatile __int64*)obj, (__int64)arg);
-}
-#define jl_atomic_fetch_and_relaxed(obj, arg) jl_atomic_fetch_and(obj, arg)
-
-// or
-template<typename T, typename T2>
-static inline typename std::enable_if<sizeof(T) == 1, T>::type
-jl_atomic_fetch_or(T *obj, T2 arg)
-{
-    return (T)_InterlockedOr8((volatile char*)obj, (char)arg);
-}
-template<typename T, typename T2>
-static inline typename std::enable_if<sizeof(T) == 2, T>::type
-jl_atomic_fetch_or(T *obj, T2 arg)
-{
-    return (T)_InterlockedOr16((volatile short*)obj, (short)arg);
-}
-template<typename T, typename T2>
-static inline typename std::enable_if<sizeof(T) == 4, T>::type
-jl_atomic_fetch_or(T *obj, T2 arg)
-{
-    return (T)_InterlockedOr((volatile LONG*)obj, (LONG)arg);
-}
-template<typename T, typename T2>
-static inline typename std::enable_if<sizeof(T) == 8, T>::type
-jl_atomic_fetch_or(T *obj, T2 arg)
-{
-    return (T)_InterlockedOr64((volatile __int64*)obj, (__int64)arg);
-}
-#define jl_atomic_fetch_or_relaxed(obj, arg) jl_atomic_fetch_or(obj, 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 exchange
-template<typename T, typename T2>
-static inline typename std::enable_if<sizeof(T) == 1, T>::type
-jl_atomic_exchange(volatile T *obj, T2 val)
-{
-    return _InterlockedExchange8((volatile char*)obj, (char)val);
-}
-template<typename T, typename T2>
-static inline typename std::enable_if<sizeof(T) == 2, T>::type
-jl_atomic_exchange(volatile T *obj, T2 val)
-{
-    return _InterlockedExchange16((volatile short*)obj, (short)val);
-}
-template<typename T, typename T2>
-static inline typename std::enable_if<sizeof(T) == 4, T>::type
-jl_atomic_exchange(volatile T *obj, T2 val)
-{
-    return _InterlockedExchange((volatile LONG*)obj, (LONG)val);
-}
-template<typename T, typename T2>
-static inline typename std::enable_if<sizeof(T) == 8, T>::type
-jl_atomic_exchange(volatile T *obj, T2 val)
-{
-    return _InterlockedExchange64((volatile __int64*)obj, (__int64)val);
-}
-#define jl_atomic_exchange_relaxed(obj, val) jl_atomic_exchange(obj, val)
-// 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_ptls_t (jl_get_ptls_states)(void);
+// gc safepoint and gc states
 // 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
@@ -453,8 +176,6 @@ JL_DLLEXPORT JL_CONST_FUNC jl_ptls_t (jl_get_ptls_states)(void);
         (void)safepoint_load;                           \
     } while (0)
 #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(ptls) ((int8_t)0)
 STATIC_INLINE int8_t jl_gc_state_set(jl_ptls_t ptls, int8_t state,
                                      int8_t old_state)
@@ -464,10 +185,6 @@ STATIC_INLINE int8_t jl_gc_state_set(jl_ptls_t ptls, int8_t state,
     return old_state;
 }
 #else // ifndef JULIA_ENABLE_THREADING
-typedef jl_ptls_t (*jl_get_ptls_states_func)(void);
-#if !defined(_OS_DARWIN_) && !defined(_OS_WINDOWS_)
-JL_DLLEXPORT void jl_set_ptls_states_getter(jl_get_ptls_states_func f);
-#endif
 // Make sure jl_gc_state() is always a rvalue
 #define jl_gc_state(ptls) ((int8_t)ptls->gc_state)
 STATIC_INLINE int8_t jl_gc_state_set(jl_ptls_t ptls, int8_t state,
@@ -492,122 +209,7 @@ STATIC_INLINE int8_t jl_gc_state_save_and_set(jl_ptls_t ptls,
 #define jl_gc_safe_leave(ptls, state) ((void)jl_gc_state_set(ptls, (state), JL_GC_STATE_SAFE))
 JL_DLLEXPORT void (jl_gc_safepoint)(void);
 
-#define JL_SIGATOMIC_BEGIN() do {               \
-        jl_get_ptls_states()->defer_signal++;   \
-        jl_signal_fence();                      \
-    } while (0)
-#define JL_SIGATOMIC_END() do {                                 \
-        jl_signal_fence();                                      \
-        if (--jl_get_ptls_states()->defer_signal == 0) {        \
-            jl_sigint_safepoint(jl_get_ptls_states());          \
-        }                                                       \
-    } while (0)
-
-// Recursive spin lock
-typedef struct {
-    volatile unsigned long owner;
-    uint32_t count;
-} jl_mutex_t;
-
 JL_DLLEXPORT void jl_gc_enable_finalizers(jl_ptls_t ptls, int on);
-static inline void jl_lock_frame_push(jl_mutex_t *lock);
-static inline void jl_lock_frame_pop(void);
-
-// JL_LOCK and jl_mutex_lock are GC safe points while JL_LOCK_NOGC
-// and jl_mutex_lock_nogc are 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.
-// The JL_LOCK* and JL_UNLOCK* macros are no-op for non-threading build
-// while the jl_mutex_* functions are always locking and unlocking the locks.
-
-static inline void jl_mutex_wait(jl_mutex_t *lock, int safepoint)
-{
-    unsigned long self = jl_thread_self();
-    unsigned long owner = jl_atomic_load_acquire(&lock->owner);
-    if (owner == self) {
-        lock->count++;
-        return;
-    }
-    while (1) {
-        if (owner == 0 &&
-            jl_atomic_compare_exchange(&lock->owner, 0, self) == 0) {
-            lock->count = 1;
-            return;
-        }
-        if (safepoint) {
-            jl_ptls_t ptls = jl_get_ptls_states();
-            jl_gc_safepoint_(ptls);
-        }
-        jl_cpu_pause();
-        owner = lock->owner;
-    }
-}
-
-static inline void jl_mutex_lock_nogc(jl_mutex_t *lock)
-{
-    jl_mutex_wait(lock, 0);
-}
-
-static inline void jl_mutex_lock(jl_mutex_t *lock)
-{
-    jl_ptls_t ptls = jl_get_ptls_states();
-    JL_SIGATOMIC_BEGIN();
-    jl_mutex_wait(lock, 1);
-    jl_lock_frame_push(lock);
-    jl_gc_enable_finalizers(ptls, 0);
-}
-
-static inline void jl_mutex_unlock_nogc(jl_mutex_t *lock)
-{
-    assert(lock->owner == jl_thread_self() &&
-           "Unlocking a lock in a different thread.");
-    if (--lock->count == 0) {
-        jl_atomic_store_release(&lock->owner, 0);
-        jl_cpu_wake();
-    }
-}
-
-static inline void jl_mutex_unlock(jl_mutex_t *lock)
-{
-    jl_ptls_t ptls = jl_get_ptls_states();
-    jl_mutex_unlock_nogc(lock);
-    jl_gc_enable_finalizers(ptls, 1);
-    jl_lock_frame_pop();
-    JL_SIGATOMIC_END();
-}
-
-static inline void jl_mutex_init(jl_mutex_t *lock)
-{
-    lock->owner = 0;
-    lock->count = 0;
-}
-
-// Locks
-#ifdef JULIA_ENABLE_THREADING
-#define JL_MUTEX_INIT(m) jl_mutex_init(m)
-#define JL_LOCK(m) jl_mutex_lock(m)
-#define JL_UNLOCK(m) jl_mutex_unlock(m)
-#define JL_LOCK_NOGC(m) jl_mutex_lock_nogc(m)
-#define JL_UNLOCK_NOGC(m) jl_mutex_unlock_nogc(m)
-#else // JULIA_ENABLE_THREADING
-static inline void jl_mutex_check_type(jl_mutex_t *m)
-{
-    (void)m;
-}
-#define JL_MUTEX_INIT(m) jl_mutex_check_type(m)
-#define JL_LOCK(m) do {                                   \
-        JL_SIGATOMIC_BEGIN();                             \
-        jl_gc_enable_finalizers(jl_get_ptls_states(), 0); \
-        jl_mutex_check_type(m);                           \
-    } while (0)
-#define JL_UNLOCK(m) do {                                       \
-        jl_gc_enable_finalizers(jl_get_ptls_states(), 1);       \
-        jl_mutex_check_type(m);                                 \
-        JL_SIGATOMIC_END();                                     \
-    } while (0)
-#define JL_LOCK_NOGC(m) jl_mutex_check_type(m)
-#define JL_UNLOCK_NOGC(m) jl_mutex_check_type(m)
-#endif // JULIA_ENABLE_THREADING
 
 #ifdef __cplusplus
 }
diff --git a/src/llvm-alloc-opt.cpp b/src/llvm-alloc-opt.cpp
new file mode 100644
index 00000000000000..1cf949104367f0
--- /dev/null
+++ b/src/llvm-alloc-opt.cpp
@@ -0,0 +1,667 @@
+// This file is a part of Julia. License is MIT: https://julialang.org/license
+
+#define DEBUG_TYPE "alloc_opt"
+#undef DEBUG
+#include "llvm-version.h"
+
+#include <llvm/IR/Value.h>
+#include <llvm/IR/CFG.h>
+#include <llvm/IR/Dominators.h>
+#include <llvm/IR/Function.h>
+#include <llvm/IR/Instructions.h>
+#include <llvm/IR/IntrinsicInst.h>
+#include <llvm/IR/Module.h>
+#include <llvm/IR/Operator.h>
+#include <llvm/IR/IRBuilder.h>
+#include <llvm/Pass.h>
+#include <llvm/Support/Debug.h>
+
+#include "fix_llvm_assert.h"
+
+#include "codegen_shared.h"
+#include "julia.h"
+#include "julia_internal.h"
+
+#include <map>
+#include <set>
+
+using namespace llvm;
+
+extern std::pair<MDNode*,MDNode*> tbaa_make_child(const char *name, MDNode *parent=nullptr, bool isConstant=false);
+
+namespace {
+
+static void copyMetadata(Instruction *dest, const Instruction *src)
+{
+#if JL_LLVM_VERSION < 40000
+    if (!src->hasMetadata())
+        return;
+    SmallVector<std::pair<unsigned,MDNode*>,4> TheMDs;
+    src->getAllMetadataOtherThanDebugLoc(TheMDs);
+    for (const auto &MD : TheMDs)
+        dest->setMetadata(MD.first, MD.second);
+    dest->setDebugLoc(src->getDebugLoc());
+#else
+    dest->copyMetadata(*src);
+#endif
+}
+
+static bool isBundleOperand(CallInst *call, unsigned idx)
+{
+#if JL_LLVM_VERSION < 40000
+    return call->hasOperandBundles() && idx >= call->getBundleOperandsStartIndex() &&
+        idx < call->getBundleOperandsEndIndex();
+#else
+    return call->isBundleOperand(idx);
+#endif
+}
+
+/**
+ * Promote `julia.gc_alloc_obj` which do not have escaping root to a alloca.
+ * Uses that are not considered to escape the object (i.e. heap address) includes,
+ *
+ * * load
+ * * `pointer_from_objref`
+ * * `ccall` gcroot array (`jl_roots` operand bundle)
+ * * store (as address)
+ * * addrspacecast, bitcast, getelementptr
+ *
+ *     The results of these cast instructions will be scanned recursively.
+ *
+ * All other uses are considered to escape conservatively.
+ */
+
+struct AllocOpt : public FunctionPass {
+    static char ID;
+    AllocOpt()
+        : FunctionPass(ID)
+    {
+        llvm::initializeDominatorTreeWrapperPassPass(*PassRegistry::getPassRegistry());
+    }
+
+private:
+    LLVMContext *ctx;
+
+    const DataLayout *DL;
+
+    Function *alloc_obj;
+    Function *ptr_from_objref;
+    Function *lifetime_start;
+    Function *lifetime_end;
+
+    Type *T_int8;
+    Type *T_int32;
+    Type *T_int64;
+    Type *T_size;
+    Type *T_pint8;
+    Type *T_prjlvalue;
+    Type *T_pjlvalue;
+    Type *T_pprjlvalue;
+
+    MDNode *tbaa_tag;
+
+    struct CheckInstFrame {
+        Instruction *parent;
+        uint64_t offset;
+        Instruction::use_iterator use_it;
+        Instruction::use_iterator use_end;
+    };
+    typedef SmallVector<CheckInstFrame, 4> CheckInstStack;
+    struct ReplaceUsesFrame {
+        Instruction *orig_i;
+        Instruction *new_i;
+        ReplaceUsesFrame(Instruction *orig_i, Instruction *new_i)
+            : orig_i(orig_i),
+              new_i(new_i)
+        {}
+    };
+    typedef SmallVector<ReplaceUsesFrame,4> ReplaceUsesStack;
+
+    struct LifetimeMarker {
+        LifetimeMarker(AllocOpt &pass)
+            : pass(pass),
+              first_safepoint{},
+              stack{}
+        {}
+        // insert llvm.lifetime.* calls for `ptr` with size `sz`
+        // based on the use of `orig` given in `alloc_uses`.
+        void insert(Instruction *ptr, Constant *sz, Instruction *orig,
+                    const std::set<Instruction*> &alloc_uses);
+    private:
+        Instruction *getFirstSafepoint(BasicBlock *bb);
+        void insertEnd(Instruction *ptr, Constant *sz, Instruction *insert);
+        struct Frame {
+            BasicBlock *bb;
+            pred_iterator p_cur;
+            pred_iterator p_end;
+            Frame(BasicBlock *bb)
+                : bb(bb),
+                  p_cur(pred_begin(bb)),
+                  p_end(pred_end(bb))
+            {}
+        };
+        AllocOpt &pass;
+        std::map<BasicBlock*,Instruction*> first_safepoint;
+        SmallVector<Frame,4> stack;
+    };
+
+    bool doInitialization(Module &m) override;
+    bool runOnFunction(Function &F) override;
+    bool checkInst(Instruction *I, CheckInstStack &stack, std::set<Instruction*> &uses,
+                   bool &ignore_tag);
+    void replaceUsesWith(Instruction *orig_i, Instruction *new_i, ReplaceUsesStack &stack);
+    bool isSafepoint(Instruction *inst);
+    void getAnalysisUsage(AnalysisUsage &AU) const override
+    {
+        FunctionPass::getAnalysisUsage(AU);
+        AU.addRequired<DominatorTreeWrapperPass>();
+        AU.addPreserved<DominatorTreeWrapperPass>();
+        AU.setPreservesCFG();
+    }
+};
+
+Instruction *AllocOpt::LifetimeMarker::getFirstSafepoint(BasicBlock *bb)
+{
+    auto it = first_safepoint.find(bb);
+    if (it != first_safepoint.end())
+        return it->second;
+    Instruction *first = nullptr;
+    for (auto &I: *bb) {
+        if (pass.isSafepoint(&I)) {
+            first = &I;
+            break;
+        }
+    }
+    first_safepoint[bb] = first;
+    return first;
+}
+
+void AllocOpt::LifetimeMarker::insertEnd(Instruction *ptr, Constant *sz, Instruction *insert)
+{
+    BasicBlock::iterator it(insert);
+    BasicBlock::iterator begin(insert->getParent()->begin());
+    // Makes sure that the end is inserted before nearby start.
+    // We insert start before the allocation call, if it is the first safepoint we find for
+    // another instruction, it's better if we insert the end before the start instead of the
+    // allocation so that the two allocations do not have overlapping lifetime.
+    while (it != begin) {
+        --it;
+        if (auto II = dyn_cast<IntrinsicInst>(&*it)) {
+            if (II->getIntrinsicID() == Intrinsic::lifetime_start ||
+                II->getIntrinsicID() == Intrinsic::lifetime_end) {
+                insert = II;
+                continue;
+            }
+        }
+        break;
+    }
+    CallInst::Create(pass.lifetime_end, {sz, ptr}, "", insert);
+}
+
+void AllocOpt::LifetimeMarker::insert(Instruction *ptr, Constant *sz, Instruction *orig,
+                                      const std::set<Instruction*> &alloc_uses)
+{
+    CallInst::Create(pass.lifetime_start, {sz, ptr}, "", orig);
+    BasicBlock *def_bb = orig->getParent();
+    std::set<BasicBlock*> bbs{def_bb};
+    auto &DT = pass.getAnalysis<DominatorTreeWrapperPass>().getDomTree();
+    // Collect all BB where the allocation is live
+    for (auto use: alloc_uses) {
+        auto bb = use->getParent();
+        if (!bbs.insert(bb).second)
+            continue;
+        assert(stack.empty());
+        Frame cur{bb};
+        while (true) {
+            assert(cur.p_cur != cur.p_end);
+            auto pred = *cur.p_cur;
+            ++cur.p_cur;
+            if (bbs.insert(pred).second) {
+                if (cur.p_cur != cur.p_end)
+                    stack.push_back(cur);
+                cur = Frame(pred);
+            }
+            if (cur.p_cur == cur.p_end) {
+                if (stack.empty())
+                    break;
+                cur = stack.back();
+                stack.pop_back();
+            }
+        }
+    }
+#ifndef JL_NDEBUG
+    for (auto bb: bbs) {
+        if (bb == def_bb)
+            continue;
+        if (DT.dominates(orig, bb))
+            continue;
+        auto F = bb->getParent();
+#if JL_LLVM_VERSION >= 50000
+        F->print(llvm::dbgs(), nullptr, false, true);
+        orig->print(llvm::dbgs(), true);
+        jl_safe_printf("Does not dominate BB:\n");
+        bb->print(llvm::dbgs(), true);
+#else
+        F->dump();
+        orig->dump();
+        jl_safe_printf("Does not dominate BB:\n");
+        bb->dump();
+#endif
+        abort();
+    }
+#endif
+    // For each BB, find the first instruction(s) where the allocation is possibly dead.
+    // If all successors are live, then there isn't one.
+    // If all successors are dead, then it's the first instruction after the last use
+    // within the BB.
+    // If some successors are live and others are dead, it's the first instruction in
+    // the successors that are dead.
+    std::vector<Instruction*> first_dead;
+    for (auto bb: bbs) {
+        bool has_use = false;
+        for (auto succ: successors(bb)) {
+            // def_bb is the only bb in bbs that's not dominated by orig
+            if (succ != def_bb && bbs.count(succ)) {
+                has_use = true;
+                break;
+            }
+        }
+        if (has_use) {
+            for (auto succ: successors(bb)) {
+                if (!bbs.count(succ)) {
+                    first_dead.push_back(&*succ->begin());
+                }
+            }
+        }
+        else {
+            for (auto it = bb->rbegin(), end = bb->rend(); it != end; ++it) {
+                if (alloc_uses.count(&*it)) {
+                    --it;
+                    first_dead.push_back(&*it);
+                    break;
+                }
+            }
+        }
+    }
+    bbs.clear();
+    // There can/need only be one lifetime.end for each allocation in each bb, use bbs
+    // to record that.
+    // Iterate through the first dead and find the first safepoint following each of them.
+    while (!first_dead.empty()) {
+        auto I = first_dead.back();
+        first_dead.pop_back();
+        auto bb = I->getParent();
+        if (!bbs.insert(bb).second)
+            continue;
+        if (I == &*bb->begin()) {
+            // There's no use in or after this bb. If this bb is not dominated by
+            // the def then it has to be dead on entering this bb.
+            // Otherwise, there could be use that we don't track
+            // before hitting the next safepoint.
+            if (!DT.dominates(orig, bb)) {
+                insertEnd(ptr, sz, &*bb->getFirstInsertionPt());
+                continue;
+            }
+            else if (auto insert = getFirstSafepoint(bb)) {
+                insertEnd(ptr, sz, insert);
+            }
+        }
+        else {
+            assert(bb == def_bb || DT.dominates(orig, I));
+            BasicBlock::iterator it(I);
+            BasicBlock::iterator end = bb->end();
+            bool safepoint_found = false;
+            for (; it != end; ++it) {
+                auto insert = &*it;
+                if (pass.isSafepoint(insert)) {
+                    insertEnd(ptr, sz, insert);
+                    safepoint_found = true;
+                    break;
+                }
+            }
+            if (safepoint_found) {
+                continue;
+            }
+        }
+        for (auto succ: successors(bb)) {
+            first_dead.push_back(&*succ->begin());
+        }
+    }
+}
+
+bool AllocOpt::doInitialization(Module &M)
+{
+    ctx = &M.getContext();
+    DL = &M.getDataLayout();
+
+    alloc_obj = M.getFunction("julia.gc_alloc_obj");
+    if (!alloc_obj)
+        return false;
+
+    ptr_from_objref = M.getFunction("julia.pointer_from_objref");
+
+    T_prjlvalue = alloc_obj->getReturnType();
+    T_pjlvalue = PointerType::get(cast<PointerType>(T_prjlvalue)->getElementType(), 0);
+    T_pprjlvalue = PointerType::get(T_prjlvalue, 0);
+
+    T_int8 = Type::getInt8Ty(*ctx);
+    T_int32 = Type::getInt32Ty(*ctx);
+    T_int64 = Type::getInt64Ty(*ctx);
+    T_size = sizeof(void*) == 8 ? T_int64 : T_int32;
+    T_pint8 = PointerType::get(T_int8, 0);
+
+#if JL_LLVM_VERSION >= 50000
+    lifetime_start = Intrinsic::getDeclaration(&M, Intrinsic::lifetime_start, { T_pint8 });
+    lifetime_end = Intrinsic::getDeclaration(&M, Intrinsic::lifetime_end, { T_pint8 });
+#else
+    lifetime_start = Intrinsic::getDeclaration(&M, Intrinsic::lifetime_start);
+    lifetime_end = Intrinsic::getDeclaration(&M, Intrinsic::lifetime_end);
+#endif
+
+    MDNode *tbaa_data;
+    MDNode *tbaa_data_scalar;
+    std::tie(tbaa_data, tbaa_data_scalar) = tbaa_make_child("jtbaa_data");
+    tbaa_tag = tbaa_make_child("jtbaa_tag", tbaa_data_scalar).first;
+
+    return true;
+}
+
+bool AllocOpt::checkInst(Instruction *I, CheckInstStack &stack, std::set<Instruction*> &uses,
+                         bool &ignore_tag)
+{
+    uses.clear();
+    if (I->use_empty())
+        return true;
+    CheckInstFrame cur{I, 0, I->use_begin(), I->use_end()};
+    stack.clear();
+
+    // Recursion
+    auto push_inst = [&] (Instruction *inst) {
+        if (cur.use_it != cur.use_end)
+            stack.push_back(cur);
+        cur.parent = inst;
+        cur.use_it = inst->use_begin();
+        cur.use_end = inst->use_end();
+    };
+
+    auto check_inst = [&] (Instruction *inst, Use *use) {
+        if (isa<LoadInst>(inst))
+            return true;
+        if (auto call = dyn_cast<CallInst>(inst)) {
+            // TODO: on LLVM 5.0 we may need to handle certain llvm intrinsics
+            // including `memcpy`, `memset` etc. We might also need to handle
+            // `memcmp` by coverting to our own intrinsic and lower it after the gc root pass.
+            if (ptr_from_objref && ptr_from_objref == call->getCalledFunction())
+                return true;
+            auto opno = use->getOperandNo();
+            // Uses in `jl_roots` operand bundle are not counted as escaping, everything else is.
+            if (!isBundleOperand(call, opno))
+                return false;
+            return call->getOperandBundleForOperand(opno).getTagName() == "jl_roots";
+        }
+        if (auto store = dyn_cast<StoreInst>(inst)) {
+            // Only store value count
+            if (use->getOperandNo() != StoreInst::getPointerOperandIndex())
+                return false;
+            auto storev = store->getValueOperand();
+            // There's GC root in this object.
+            if (auto ptrtype = dyn_cast<PointerType>(storev->getType())) {
+                if (ptrtype->getAddressSpace() == AddressSpace::Tracked) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        if (isa<AddrSpaceCastInst>(inst) || isa<BitCastInst>(inst)) {
+            push_inst(inst);
+            return true;
+        }
+        if (auto gep = dyn_cast<GetElementPtrInst>(inst)) {
+            APInt apoffset(sizeof(void*) * 8, cur.offset, true);
+            if (ignore_tag && (!gep->accumulateConstantOffset(*DL, apoffset) ||
+                               apoffset.isNegative()))
+                ignore_tag = false;
+            push_inst(inst);
+            cur.offset = apoffset.getLimitedValue();
+            // Check overflow
+            if (cur.offset == UINT64_MAX)
+                ignore_tag = false;
+            return true;
+        }
+        return false;
+    };
+
+    while (true) {
+        assert(cur.use_it != cur.use_end);
+        auto use = &*cur.use_it;
+        auto inst = dyn_cast<Instruction>(use->getUser());
+        ++cur.use_it;
+        if (!inst)
+            return false;
+        if (!check_inst(inst, use))
+            return false;
+        uses.insert(inst);
+        if (cur.use_it == cur.use_end) {
+            if (stack.empty())
+                return true;
+            cur = stack.back();
+            stack.pop_back();
+        }
+    }
+}
+
+// This function needs to handle all cases `AllocOpt::checkInst` can handle.
+// This function should not erase any safepoint so that the lifetime marker can find and cache
+// all the original safepoints.
+void AllocOpt::replaceUsesWith(Instruction *orig_inst, Instruction *new_inst,
+                               ReplaceUsesStack &stack)
+{
+    auto simple_replace = [&] (Instruction *orig_i, Instruction *new_i) {
+        if (orig_i->user_empty()) {
+            if (orig_i != orig_inst)
+                orig_i->eraseFromParent();
+            return true;
+        }
+        Type *orig_t = orig_i->getType();
+        Type *new_t = new_i->getType();
+        if (orig_t == new_t) {
+            orig_i->replaceAllUsesWith(new_i);
+            if (orig_i != orig_inst)
+                orig_i->eraseFromParent();
+            return true;
+        }
+        return false;
+    };
+    if (simple_replace(orig_inst, new_inst))
+        return;
+    assert(stack.empty());
+    ReplaceUsesFrame cur{orig_inst, new_inst};
+    auto finish_cur = [&] () {
+        assert(cur.orig_i->user_empty());
+        if (cur.orig_i != orig_inst) {
+            cur.orig_i->eraseFromParent();
+        }
+    };
+    auto push_frame = [&] (Instruction *orig_i, Instruction *new_i) {
+        if (simple_replace(orig_i, new_i))
+            return;
+        stack.push_back(cur);
+        cur = {orig_i, new_i};
+    };
+    // Both `orig_i` and `new_i` should be pointer of the same type
+    // but possibly different address spaces. `new_i` is always in addrspace 0.
+    auto replace_inst = [&] (Instruction *user) {
+        Instruction *orig_i = cur.orig_i;
+        Instruction *new_i = cur.new_i;
+        if (isa<LoadInst>(user) || isa<StoreInst>(user)) {
+            user->replaceUsesOfWith(orig_i, new_i);
+        }
+        else if (auto call = dyn_cast<CallInst>(user)) {
+            if (ptr_from_objref && ptr_from_objref == call->getCalledFunction()) {
+                call->replaceAllUsesWith(new_i);
+                call->eraseFromParent();
+                return;
+            }
+            // remove from operand bundle
+            Type *new_t = new_i->getType();
+            user->replaceUsesOfWith(orig_i, ConstantPointerNull::get(cast<PointerType>(new_t)));
+        }
+        else if (isa<AddrSpaceCastInst>(user) || isa<BitCastInst>(user)) {
+            auto cast_t = PointerType::get(cast<PointerType>(user->getType())->getElementType(),
+                                           0);
+            auto replace_i = new_i;
+            Type *new_t = new_i->getType();
+            if (cast_t != new_t) {
+                replace_i = new BitCastInst(replace_i, cast_t, "", user);
+                replace_i->setDebugLoc(user->getDebugLoc());
+                replace_i->takeName(user);
+            }
+            push_frame(user, replace_i);
+        }
+        else if (auto gep = dyn_cast<GetElementPtrInst>(user)) {
+            SmallVector<Value *, 4> IdxOperands(gep->idx_begin(), gep->idx_end());
+            auto new_gep = GetElementPtrInst::Create(gep->getSourceElementType(),
+                                                     new_i, IdxOperands,
+                                                     gep->getName(), gep);
+            new_gep->setIsInBounds(gep->isInBounds());
+            new_gep->takeName(gep);
+            copyMetadata(new_gep, gep);
+            push_frame(gep, new_gep);
+        }
+        else {
+            abort();
+        }
+    };
+
+    while (true) {
+        replace_inst(cast<Instruction>(*cur.orig_i->user_begin()));
+        while (cur.orig_i->use_empty()) {
+            finish_cur();
+            if (stack.empty())
+                return;
+            cur = stack.back();
+            stack.pop_back();
+        }
+    }
+}
+
+bool AllocOpt::isSafepoint(Instruction *inst)
+{
+    auto call = dyn_cast<CallInst>(inst);
+    if (!call)
+        return false;
+    if (isa<IntrinsicInst>(call))
+        return false;
+    if (auto callee = call->getCalledFunction()) {
+        // Known functions emitted in codegen that are not safepoints
+        if (callee == ptr_from_objref || callee->getName() == "memcmp") {
+            return false;
+        }
+    }
+    return true;
+}
+
+bool AllocOpt::runOnFunction(Function &F)
+{
+    if (!alloc_obj)
+        return false;
+    SmallVector<std::pair<CallInst*,size_t>,6> allocs;
+    for (auto &bb: F) {
+        for (auto &I: bb) {
+            auto call = dyn_cast<CallInst>(&I);
+            if (!call)
+                continue;
+            auto callee = call->getCalledFunction();
+            if (!callee)
+                continue;
+            size_t sz;
+            if (callee == alloc_obj) {
+                assert(call->getNumArgOperands() == 3);
+                sz = (size_t)cast<ConstantInt>(call->getArgOperand(1))->getZExtValue();
+            }
+            else {
+                continue;
+            }
+            if (sz < IntegerType::MAX_INT_BITS / 8 && sz < INT32_MAX) {
+                allocs.push_back(std::make_pair(call, sz));
+            }
+        }
+    }
+
+    auto &entry = F.getEntryBlock();
+    CheckInstStack check_stack;
+    ReplaceUsesStack replace_stack;
+    std::set<Instruction*> alloc_uses;
+    LifetimeMarker lifetime(*this);
+    for (auto &it: allocs) {
+        bool ignore_tag = true;
+        auto orig = it.first;
+        size_t &sz = it.second;
+        if (!checkInst(orig, check_stack, alloc_uses, ignore_tag)) {
+            sz = UINT32_MAX;
+            continue;
+        }
+        // The allocation does not escape or get used in a phi node so none of the derived
+        // SSA from it are live when we run the allocation again.
+        // It is now safe to promote the allocation to an entry block alloca.
+        size_t align = 1;
+        // TODO make codegen handling of alignment consistent and pass that as a parameter
+        // to the allocation function directly.
+        if (!ignore_tag) {
+            align = sz <= 8 ? 8 : JL_SMALL_BYTE_ALIGNMENT;
+            sz += align;
+        }
+        else if (sz > 1) {
+            align = JL_SMALL_BYTE_ALIGNMENT;
+            while (sz < align) {
+                align = align / 2;
+            }
+        }
+        // No debug info for prolog instructions
+        IRBuilder<> prolog_builder(&entry.front());
+        AllocaInst *buff;
+        Instruction *ptr;
+        if (sz == 0) {
+            buff = prolog_builder.CreateAlloca(T_int8, 0);
+            ptr = buff;
+        }
+        else {
+            buff = prolog_builder.CreateAlloca(Type::getIntNTy(*ctx, sz * 8));
+            buff->setAlignment(align);
+            ptr = cast<Instruction>(prolog_builder.CreateBitCast(buff, T_pint8));
+        }
+        lifetime.insert(ptr, ConstantInt::get(T_int64, sz), orig, alloc_uses);
+        // Someone might be reading the tag, initialize it.
+        if (!ignore_tag) {
+            ptr = cast<Instruction>(prolog_builder.CreateConstGEP1_32(T_int8, ptr, align));
+            auto casti = prolog_builder.CreateBitCast(ptr, T_pprjlvalue);
+            auto tagaddr = prolog_builder.CreateGEP(T_prjlvalue, casti,
+                                                    ConstantInt::get(T_size, -1));
+            // Store should be created at the callsite and not in the prolog
+            auto store = new StoreInst(orig->getArgOperand(2), tagaddr, orig);
+            store->setMetadata(LLVMContext::MD_tbaa, tbaa_tag);
+            store->setDebugLoc(orig->getDebugLoc());
+        }
+        auto casti = cast<Instruction>(prolog_builder.CreateBitCast(ptr, T_pjlvalue));
+        casti->takeName(orig);
+        replaceUsesWith(orig, cast<Instruction>(casti), replace_stack);
+    }
+    for (auto it: allocs) {
+        if (it.second == UINT32_MAX)
+            continue;
+        it.first->eraseFromParent();
+    }
+    return true;
+}
+
+char AllocOpt::ID = 0;
+static RegisterPass<AllocOpt> X("AllocOpt", "Promote heap allocation to stack",
+                                false /* Only looks at CFG */,
+                                false /* Analysis Pass */);
+
+}
+
+Pass *createAllocOptPass()
+{
+    return new AllocOpt();
+}
diff --git a/src/llvm-gc-invariant-verifier.cpp b/src/llvm-gc-invariant-verifier.cpp
new file mode 100644
index 00000000000000..d29d763f1bc36a
--- /dev/null
+++ b/src/llvm-gc-invariant-verifier.cpp
@@ -0,0 +1,185 @@
+// This file is a part of Julia. License is MIT: https://julialang.org/license
+// This LLVM pass verifies invariants required for correct GC root placement.
+// See the devdocs for a description of these invariants.
+
+#include <llvm/ADT/BitVector.h>
+#include <llvm/ADT/PostOrderIterator.h>
+#include <llvm/Analysis/CFG.h>
+#include <llvm/IR/Value.h>
+#include <llvm/IR/Constants.h>
+#include <llvm/IR/Dominators.h>
+#include <llvm/IR/Function.h>
+#include <llvm/IR/Instructions.h>
+#include <llvm/IR/IntrinsicInst.h>
+#include <llvm/IR/InstVisitor.h>
+#include <llvm/IR/CallSite.h>
+#include <llvm/IR/Module.h>
+#include <llvm/IR/IRBuilder.h>
+#include <llvm/IR/Verifier.h>
+#include <llvm/Pass.h>
+#include <llvm/Support/Debug.h>
+
+#include "llvm-version.h"
+#include "codegen_shared.h"
+#include "julia.h"
+
+#define DEBUG_TYPE "verify_gc_invariants"
+#undef DEBUG
+
+using namespace llvm;
+
+struct GCInvariantVerifier : public FunctionPass, public InstVisitor<GCInvariantVerifier> {
+    static char ID;
+    bool Broken = false;
+    bool Strong;
+    GCInvariantVerifier(bool Strong = false) : FunctionPass(ID), Strong(Strong) {}
+
+private:
+    void Check(bool Cond, const char *message, Value *Val) {
+        if (!Cond) {
+            dbgs() << message << "\n\t" << *Val << "\n";
+            Broken = true;
+        }
+    }
+
+public:
+    void getAnalysisUsage(AnalysisUsage &AU) const override {
+        FunctionPass::getAnalysisUsage(AU);
+        AU.setPreservesAll();
+    }
+
+    bool runOnFunction(Function &F) override;
+    void visitAddrSpaceCastInst(AddrSpaceCastInst &I);
+    void visitStoreInst(StoreInst &SI);
+    void visitLoadInst(LoadInst &LI);
+    void visitReturnInst(ReturnInst &RI);
+    void visitGetElementPtrInst(GetElementPtrInst &GEP);
+    void visitIntToPtrInst(IntToPtrInst &IPI);
+    void visitPtrToIntInst(PtrToIntInst &PII);
+    void visitCallInst(CallInst &CI);
+};
+
+void GCInvariantVerifier::visitAddrSpaceCastInst(AddrSpaceCastInst &I) {
+    unsigned FromAS = cast<PointerType>(I.getSrcTy())->getAddressSpace();
+    unsigned ToAS = cast<PointerType>(I.getDestTy())->getAddressSpace();
+    if (FromAS == 0)
+        return;
+    Check(FromAS != AddressSpace::Tracked ||
+          ToAS   == AddressSpace::CalleeRooted ||
+          ToAS   == AddressSpace::Derived,
+          "Illegal address space cast from tracked ptr", &I);
+    Check(FromAS != AddressSpace::CalleeRooted &&
+          FromAS != AddressSpace::Derived,
+          "Illegal address space cast from decayed ptr", &I);
+}
+
+void GCInvariantVerifier::visitStoreInst(StoreInst &SI) {
+    Type *VTy = SI.getValueOperand()->getType();
+    if (VTy->isPointerTy()) {
+        /* We currently don't obey this for arguments. That's ok - they're
+           externally rooted. */
+        if (!isa<Argument>(SI.getValueOperand())) {
+            unsigned AS = cast<PointerType>(VTy)->getAddressSpace();
+            Check(AS != AddressSpace::CalleeRooted &&
+                  AS != AddressSpace::Derived,
+                  "Illegal store of decayed value", &SI);
+        }
+    }
+    VTy = SI.getPointerOperand()->getType();
+    if (VTy->isPointerTy()) {
+        unsigned AS = cast<PointerType>(VTy)->getAddressSpace();
+        Check(AS != AddressSpace::CalleeRooted,
+              "Illegal store to callee rooted value", &SI);
+    }
+}
+
+void GCInvariantVerifier::visitLoadInst(LoadInst &LI) {
+    Type *Ty = LI.getType();
+    if (Ty->isPointerTy()) {
+        unsigned AS = cast<PointerType>(Ty)->getAddressSpace();
+        Check(AS != AddressSpace::CalleeRooted &&
+              AS != AddressSpace::Derived,
+              "Illegal load of gc relevant value", &LI);
+    }
+    Ty = LI.getPointerOperand()->getType();
+    if (Ty->isPointerTy()) {
+        unsigned AS = cast<PointerType>(Ty)->getAddressSpace();
+        Check(AS != AddressSpace::CalleeRooted,
+              "Illegal store of callee rooted value", &LI);
+    }
+}
+
+static bool isSpecialAS(unsigned AS) {
+    return AddressSpace::FirstSpecial <= AS && AS <= AddressSpace::LastSpecial;
+}
+
+void GCInvariantVerifier::visitReturnInst(ReturnInst &RI) {
+    if (!RI.getReturnValue())
+        return;
+    Type *RTy = RI.getReturnValue()->getType();
+    if (!RTy->isPointerTy())
+        return;
+    unsigned AS = cast<PointerType>(RTy)->getAddressSpace();
+    Check(!isSpecialAS(AS) || AS == AddressSpace::Tracked,
+          "Only gc tracked values may be directly returned", &RI);
+}
+
+void GCInvariantVerifier::visitGetElementPtrInst(GetElementPtrInst &GEP) {
+    Type *Ty = GEP.getType();
+    if (!Ty->isPointerTy())
+        return;
+    unsigned AS = cast<PointerType>(Ty)->getAddressSpace();
+    if (!isSpecialAS(AS))
+        return;
+    /* We're actually ok with GEPs here, as long as they don't feed into any
+       uses. Upstream is currently still debating whether CAST(GEP) == GEP(CAST).
+       In the frontend, we always perform CAST(GEP), so while we can enforce
+       this invariant when we run directly after the frontend (Strong == 1),
+       the optimizer will introduce the other form. Thus, we need to allow it
+       while upstream hasn't decided whether the optimizer is allowed to
+       introduce these.
+       */
+    if (Strong) {
+        Check(AS != AddressSpace::Tracked,
+             "GC tracked values may not appear in GEP expressions."
+             " You may have to decay the value first", &GEP);
+    }
+}
+
+void GCInvariantVerifier::visitCallInst(CallInst &CI) {
+    CallingConv::ID CC = CI.getCallingConv();
+    if (CC == JLCALL_CC || CC == JLCALL_F_CC) {
+        for (Value *Arg : CI.arg_operands()) {
+            Type *Ty = Arg->getType();
+            Check(Ty->isPointerTy() && cast<PointerType>(Ty)->getAddressSpace() == AddressSpace::Tracked,
+                "Invalid derived pointer in jlcall", &CI);
+        }
+    }
+}
+
+/* These next two are caught by the regular verifier on LLVM 5.0+, but we
+   may want to run this on earlier LLVM versions. */
+void GCInvariantVerifier::visitIntToPtrInst(IntToPtrInst &IPI) {
+    Check(!isSpecialAS(IPI.getAddressSpace()),
+          "Illegal inttoptr", &IPI);
+}
+
+void GCInvariantVerifier::visitPtrToIntInst(PtrToIntInst &PII) {
+    Check(!isSpecialAS(PII.getPointerAddressSpace()),
+          "Illegal inttoptr", &PII);
+}
+
+bool GCInvariantVerifier::runOnFunction(Function &F) {
+    visit(F);
+    if (Broken) {
+        abort();
+    }
+    return false;
+}
+
+char GCInvariantVerifier::ID = 0;
+static RegisterPass<GCInvariantVerifier> X("GCInvariantVerifier", "GC Invariant Verification Pass", false, false);
+
+Pass *createGCInvariantVerifierPass(bool Strong) {
+    return new GCInvariantVerifier(Strong);
+}
diff --git a/src/llvm-gcroot.cpp b/src/llvm-gcroot.cpp
deleted file mode 100644
index 5a36eb594cf0f0..00000000000000
--- a/src/llvm-gcroot.cpp
+++ /dev/null
@@ -1,1259 +0,0 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
-
-#define DEBUG_TYPE "lower_gcroot"
-#undef DEBUG
-
-#include "llvm-version.h"
-#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/IR/Intrinsics.h>
-#if JL_LLVM_VERSION >= 30700
-#include <llvm/IR/LegacyPassManager.h>
-#else
-#include <llvm/PassManager.h>
-#endif
-#include <llvm/Support/raw_ostream.h>
-#include <llvm/Transforms/Utils/BasicBlockUtils.h>
-#if JL_LLVM_VERSION >= 30600
-#include <llvm/IR/DIBuilder.h>
-#include <llvm/IR/DebugInfoMetadata.h>
-#endif
-#include <llvm/IR/MDBuilder.h>
-
-#include <vector>
-#include <queue>
-#include <set>
-#include <functional>
-#include <utility>
-
-#include "julia.h"
-
-#if JL_LLVM_VERSION >= 30700
-#define LLVM37_param(x) (x),
-#else
-#define LLVM37_param(x)
-#endif
-
-using namespace llvm;
-
-extern std::pair<MDNode*,MDNode*> tbaa_make_child(const char *name, MDNode *parent=nullptr, bool isConstant=false);
-
-namespace {
-
-#ifndef NDEBUG
-static struct {
-    unsigned count;
-    unsigned locals;
-    unsigned temp;
-} jl_gc_frame_stats = {0};
-#endif
-
-typedef std::pair<CallInst*, unsigned> frame_register;
-struct liveness {
-    typedef unsigned id;
-    enum {
-        // an assignment to a gcroot exists in the basic-block
-        // (potentially no live-in from the predecessor basic-blocks)
-        assign = 1<<0,
-        // a use of a gcroot exists in the basic-block
-        // (potentially a "kill" and no live-out to the successor basic-blocks)
-        kill   = 1<<1,
-        // the gcroot is live over the entire basic-block
-        // (the assign/kill are not dominating of entry/exit)
-        live   = 1<<2
-
-        // 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)
-    };
-};
-
-static void tbaa_decorate_gcframe(Instruction *inst,
-                                  std::set<Instruction*> &visited,
-                                  MDNode *tbaa_gcframe)
-{
-    if (!visited.insert(inst).second)
-        return;
-#if JL_LLVM_VERSION >= 30500
-    Value::user_iterator I = inst->user_begin(), E = inst->user_end();
-#else
-    Value::use_iterator I = inst->use_begin(), E = inst->use_end();
-#endif
-    for (;I != E;++I) {
-        Instruction *user = dyn_cast<Instruction>(*I);
-        if (!user) {
-            continue;
-        }
-        else if (isa<GetElementPtrInst>(user)) {
-            if (__likely(user->getOperand(0) == inst)) {
-                tbaa_decorate_gcframe(user, visited, tbaa_gcframe);
-            }
-        }
-        else if (isa<StoreInst>(user)) {
-            if (user->getOperand(1) == inst) {
-                user->setMetadata(llvm::LLVMContext::MD_tbaa, tbaa_gcframe);
-            }
-        }
-        else if (isa<LoadInst>(user)) {
-            user->setMetadata(llvm::LLVMContext::MD_tbaa, tbaa_gcframe);
-        }
-        else if (isa<BitCastInst>(user)) {
-            tbaa_decorate_gcframe(user, visited, tbaa_gcframe);
-        }
-    }
-}
-
-static void tbaa_decorate_gcframe(Instruction *inst, MDNode *tbaa_gcframe)
-{
-    std::set<Instruction*> visited;
-    tbaa_decorate_gcframe(inst, visited, tbaa_gcframe);
-}
-
-class JuliaGCAllocator {
-public:
-    JuliaGCAllocator(Function &F, CallInst *ptlsStates,
-                     Type *T_pjlvalue, MDNode *tbaa) :
-        F(F),
-        M(*F.getParent()),
-        T_int1(Type::getInt1Ty(F.getContext())),
-        T_int8(Type::getInt8Ty(F.getContext())),
-        T_int32(Type::getInt32Ty(F.getContext())),
-        T_int64(Type::getInt64Ty(F.getContext())),
-        V_null(T_pjlvalue ? Constant::getNullValue(T_pjlvalue) : nullptr),
-        ptlsStates(ptlsStates),
-        gcframe(ptlsStates ? new AllocaInst(T_pjlvalue, ConstantInt::get(T_int32, 0)) : nullptr),
-        gcroot_func(M.getFunction("julia.gc_root_decl")),
-        gckill_func(M.getFunction("julia.gc_root_kill")),
-        jlcall_frame_func(M.getFunction("julia.jlcall_frame_decl")),
-        gcroot_flush_func(M.getFunction("julia.gcroot_flush")),
-        except_enter_func(M.getFunction("julia.except_enter")),
-        jlleave_func(M.getFunction("jl_pop_handler")),
-        tbaa_gcframe(tbaa)
-    {
-/* 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
- */
-        if (gcframe) {
-#ifdef JL_DEBUG_BUILD
-            gcframe->setName("gcrootframe");
-#endif
-            gcframe->insertAfter(ptlsStates);
-        }
-    }
-
-private:
-    Function &F;
-    Module &M;
-    Type *const T_int1;
-    Type *const T_int8;
-    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 jlcall_frame_func;
-    Function *const gcroot_flush_func;
-    Function *const except_enter_func;
-    Function *const jlleave_func;
-    MDNode *const tbaa_gcframe;
-
-    Instruction *get_pgcstack(Instruction *ptlsStates);
-    frame_register get_gcroot(Value *ptr);
-    void collapseRedundantRoots();
-    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);
-    unsigned find_space_for(CallInst *callInst,
-        std::map<BasicBlock*, std::map<frame_register, liveness::id> > &bb_uses,
-        std::map<BasicBlock*, SmallBitVector> &regs_used);
-    void rearrangeRoots();
-    void lowerHandlers();
-public:
-    void allocate_frame();
-};
-
-struct HandlerData {
-    // Pairs of <jl_pop_handle call inst>, number of pops left after popping
-    // this frame.
-    std::vector<std::pair<CallInst*,uint64_t>> leaves;
-    // enters that are directly nested in this frame
-    std::set<CallInst*> nested;
-    std::unique_ptr<std::vector<CallInst*>> parent_vec;
-    CallInst *parent{nullptr};
-    bool processed{false};
-#ifdef _COMPILER_MICROSOFT_
-    // MSVC 2013 seems to call the copy version instead of the move verion
-    // without this, which triggers compilation error since `std::unique_ptr`
-    // is not copyable.
-    HandlerData() = default;
-    HandlerData(HandlerData &&other)
-        : HandlerData()
-    {
-        operator=(std::move(other));
-    }
-    HandlerData(const HandlerData&) = delete;
-    HandlerData &operator=(HandlerData &&other)
-    {
-        std::swap(leaves, other.leaves);
-        std::swap(nested, other.nested);
-        std::swap(parent_vec, other.parent_vec);
-        std::swap(parent, other.parent);
-        std::swap(processed, other.processed);
-        return *this;
-    }
-    HandlerData &operator=(const HandlerData&) = delete;
-#endif
-};
-
-void JuliaGCAllocator::lowerHandlers()
-{
-    if (!except_enter_func)
-        return;
-    auto jlenter_func = M.getNamedValue("jl_enter_handler");
-    auto setjmp_func = M.getNamedValue(jl_setjmp_name);
-    // Collect all exception enters
-    std::map<CallInst*,HandlerData> handlers;
-    for (auto &BB: F) {
-        for (auto &I: BB) {
-            auto call = dyn_cast<CallInst>(&I);
-            if (call && call->getCalledValue() == except_enter_func) {
-                handlers[call] = HandlerData();
-            }
-        }
-    }
-
-    if (handlers.empty())
-        return;
-
-    typedef std::map<CallInst*,HandlerData>::iterator hdlr_iter_t;
-    // For each exception enter, compute the life time of the enter, find
-    // the corresponding leaves and collect a list of nested exception frames.
-    // This assumes the exception frames have simple structure. E.g.
-    // there's no recursion and different frames do not share the same leave.
-    std::function<void(hdlr_iter_t)> process_handler = [&] (hdlr_iter_t hdlr) {
-        auto enter = hdlr->first;
-        auto &data = hdlr->second;
-        if (data.processed)
-            return;
-        data.processed = true;
-        std::vector<BasicBlock::iterator> frontier = {
-            ++BasicBlock::iterator(enter)
-        };
-        // Start from the enter, the enter is live until it hits a leave
-        // or the control flow terminates.
-        std::set<Instruction*> visited;
-        auto add_inst = [&] (BasicBlock::iterator it) {
-            if (visited.insert(&*it).second) {
-                frontier.push_back(it);
-            }
-        };
-        while (!frontier.empty()) {
-            BasicBlock::iterator IT = frontier.back();
-            Instruction *I = &*IT;
-            ++IT;
-            frontier.pop_back();
-            if (I->isTerminator()) {
-                BasicBlock *bb = I->getParent();
-                for (auto S = succ_begin(bb), E = succ_end(bb); S != E; S++)
-                    add_inst(S->getFirstInsertionPt());
-                continue;
-            }
-            auto call = dyn_cast<CallInst>(I);
-            if (!call) {
-                add_inst(IT);
-                continue;
-            }
-            auto callee = call->getCalledValue();
-            if (callee == except_enter_func) {
-                // Nested frame, make sure the frame is processed and skip to
-                // its leaves.
-                auto other_it = handlers.find(call);
-                assert(other_it != handlers.end());
-                process_handler(other_it);
-                auto &other_data = other_it->second;
-                data.nested.insert(call);
-                // Record a reference to parent frame, there should be only
-                // one parent in most cases although more than one parent is
-                // also possible if LLVM split the enter call.
-                if (__unlikely(other_data.parent_vec)) {
-                    other_data.parent_vec->push_back(enter);
-                }
-                else if (__unlikely(other_data.parent)) {
-                    other_data.parent_vec.reset(
-                        new std::vector<CallInst*>{other_data.parent, enter});
-                }
-                else {
-                    other_data.parent = enter;
-                }
-                for (auto leave: other_it->second.leaves) {
-                    if (leave.second > 0) {
-                        data.leaves.push_back(std::make_pair(leave.first,
-                                                             leave.second - 1));
-                    }
-                    else {
-                        add_inst(++BasicBlock::iterator(leave.first));
-                    }
-                }
-            }
-            else if (callee == jlleave_func) {
-                // Leave, record how many pops are left on this leave.
-                assert(call->getNumArgOperands() == 1);
-                auto arg = cast<ConstantInt>(call->getArgOperand(0));
-                uint64_t pop_count = arg->getLimitedValue();
-                assert(pop_count >= 1);
-                data.leaves.push_back(std::make_pair(call, pop_count - 1));
-            }
-            else {
-                // Otherwise, go to the next instruction.
-                add_inst(IT);
-            }
-        }
-    };
-
-    // Make sure all frames are processed.
-    for (auto IT = handlers.begin(), E = handlers.end(); IT != E; ++IT)
-        process_handler(IT);
-
-    std::set<CallInst*> processing;
-    Value *handler_sz = ConstantInt::get(T_int32, sizeof(jl_handler_t));
-    // Now allocate the stack slots.
-    // At each iteration, we allocate a new handler and assign all the remaining
-    // frames that don't have a non-processed child to this handler.
-    Instruction *firstInst = &F.getEntryBlock().front();
-    while (!handlers.empty()) {
-        processing.clear();
-        auto buff = new AllocaInst(T_int8, handler_sz, "", firstInst);
-        buff->setAlignment(16);
-        // Collect the list of frames to process.
-        for (auto &hdlr: handlers) {
-            auto enter = hdlr.first;
-            auto &nested = hdlr.second.nested;
-            if (nested.empty()) {
-                processing.insert(enter);
-            }
-        }
-        // There shouldn't be loops so there has to be leafs
-        assert(!processing.empty());
-        for (auto enter: processing) {
-            // Lower the enter
-            auto new_enter = CallInst::Create(jlenter_func, buff, "", enter);
-#ifndef _OS_WINDOWS_
-            // For LLVM 3.3 compatibility
-            Value *args[] = {buff, ConstantInt::get(T_int32,0)};
-            auto sj = CallInst::Create(setjmp_func, args, "", enter);
-#else
-            auto sj = CallInst::Create(setjmp_func, buff, "", enter);
-#endif
-            // We need to mark this on the call site as well. See issue #6757
-            sj->setCanReturnTwice();
-#if JL_LLVM_VERSION >= 30600
-            if (auto dbg = enter->getMetadata(LLVMContext::MD_dbg)) {
-                new_enter->setMetadata(LLVMContext::MD_dbg, dbg);
-                sj->setMetadata(LLVMContext::MD_dbg, dbg);
-            }
-#else
-            (void)new_enter;
-#endif
-            // Remove it from all the parents.
-            auto it = handlers.find(enter);
-            if (__unlikely(it->second.parent_vec)) {
-                for (auto parent: *it->second.parent_vec) {
-                    handlers.find(parent)->second.nested.erase(enter);
-                }
-            }
-            else if (it->second.parent) {
-                handlers.find(it->second.parent)->second.nested.erase(enter);
-            }
-            // Delete it.
-            handlers.erase(it);
-            enter->replaceAllUsesWith(sj);
-            enter->eraseFromParent();
-        }
-    }
-}
-
-Instruction *JuliaGCAllocator::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 JuliaGCAllocator::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->getCalledValue() == jlcall_frame_func)
-                    frame.second = cast<ConstantInt>(gepInst->idx_begin()->get())->getZExtValue();
-                else
-                    frame.first = NULL;
-            }
-        }
-    }
-    return frame;
-}
-
-void JuliaGCAllocator::collapseRedundantRoots()
-{
-    for (BasicBlock::iterator I = gcframe->getParent()->begin(), E(gcframe); I != E; ) {
-        CallInst* callInst = dyn_cast<CallInst>(&*I);
-        ++I;
-        if (callInst && callInst->getCalledValue() == 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; ) {
-#if JL_LLVM_VERSION >= 30500
-                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; ) {
-#if JL_LLVM_VERSION >= 30500
-                    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();
-#if JL_LLVM_VERSION >= 30500
-                    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;
-#if JL_LLVM_VERSION >= 30500
-                    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->getCalledValue() == 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
-#if JL_LLVM_VERSION >= 30500
-                                    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->getCalledValue() == 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; ) {
-#if JL_LLVM_VERSION >= 30500
-                                    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 JuliaGCAllocator::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)
-{
-/* 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 JuliaGCAllocator::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;
-}
-
-void JuliaGCAllocator::rearrangeRoots()
-{
-    for (auto BB = F.begin(), E(F.end()); BB != E; BB++) {
-        auto terminst = BB->getTerminator();
-        if (!isa<ReturnInst>(terminst) && !isa<UnreachableInst>(terminst))
-            continue;
-        SmallVector<StoreInst*, 16> toRemove;
-        for (auto I = BB->rbegin(), E(BB->rend()); I != E; ++I) {
-            // Only handle the simplest case for now, give up if there's a call
-            // or load from the GC frame.
-            // (Assume we don't have loads that can alias GC frame
-            // unless the source address is a `julia.gc_root_decl`)
-            Instruction *inst = &*I;
-            if (isa<CallInst>(inst))
-                break;
-            if (LoadInst *loadInst = dyn_cast<LoadInst>(inst)) {
-                CallInst *loadAddr =
-                    dyn_cast<CallInst>(loadInst->getPointerOperand());
-                if (loadAddr && loadAddr->getCalledValue() == gcroot_func)
-                    break;
-                continue;
-            }
-            if (StoreInst *storeInst = dyn_cast<StoreInst>(inst)) {
-                CallInst *storeAddr =
-                    dyn_cast<CallInst>(storeInst->getPointerOperand());
-                if (storeAddr && storeAddr->getCalledValue() == gcroot_func)
-                    toRemove.push_back(storeInst);
-                continue;
-            }
-        }
-        for (auto inst: toRemove) {
-            CallInst *decl = cast<CallInst>(inst->getPointerOperand());
-            inst->eraseFromParent();
-            // TODO removing unused slot should probably be handled later
-            // when we allocate the frame
-            if (decl->use_empty()) {
-                decl->eraseFromParent();
-            }
-        }
-    }
-}
-
-void JuliaGCAllocator::allocate_frame()
-{
-    lowerHandlers();
-    if (!ptlsStates)
-        return;
-    Instruction *last_gcframe_inst = gcframe;
-    collapseRedundantRoots();
-    rearrangeRoots();
-
-/* # 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->getCalledValue() == 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) {
-#if JL_LLVM_VERSION >= 30500
-                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->getCalledValue() == 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->getCalledValue() == 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)) {
-                Value *callee = callInst->getCalledValue();
-                if (callee == gckill_func || callee == gcroot_flush_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->getCalledValue() == 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;
-            tbaa_decorate_gcframe(gcroot, tbaa_gcframe);
-            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);
-            gep->takeName(gcroot);
-            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)
- */
-#if JL_LLVM_VERSION >= 30600
-    DIBuilder dbuilder(M, false);
-#endif
-    unsigned argSpaceSize = 0;
-    for (BasicBlock::iterator I = gcframe->getParent()->begin(), E(gcframe); I != E; ) {
-        Instruction* inst = &*I;
-        ++I;
-        if (CallInst* callInst = dyn_cast<CallInst>(inst)) {
-            if (callInst->getCalledValue() == gcroot_func) {
-                unsigned offset = 2 + argSpaceSize++;
-                Instruction *argTempi = GetElementPtrInst::Create(LLVM37_param(NULL) gcframe, ArrayRef<Value*>(ConstantInt::get(T_int32, offset)));
-                argTempi->insertAfter(last_gcframe_inst);
-#if JL_LLVM_VERSION >= 30600
-                Metadata *md = ValueAsMetadata::getIfExists(callInst);
-                if (md) {
-                    Value *mdValue = MetadataAsValue::get(M.getContext(), md);
-                    for (User::use_iterator use = mdValue->use_begin(), usee = mdValue->use_end(); use != usee; ) {
-                        // need to recreate the dbg_declare accordingly -- sadly llvm can't handle this in RAUW
-                        User *user = use->getUser();
-                        ++use;
-                        if (CallInst* dbg = dyn_cast<CallInst>(user)) {
-                            Function *called = dbg->getCalledFunction();
-                            if (called && called->getIntrinsicID() == Intrinsic::dbg_declare) {
-                                DILocalVariable *dinfo = cast<DILocalVariable>(cast<MetadataAsValue>(dbg->getOperand(1))->getMetadata());
-                                DIExpression *expr = cast<DIExpression>(cast<MetadataAsValue>(dbg->getOperand(2))->getMetadata());
-                                SmallVector<uint64_t, 8> addr;
-                                addr.push_back(llvm::dwarf::DW_OP_plus);
-                                addr.push_back(offset * sizeof(void*));
-                                addr.append(expr->elements_begin(), expr->elements_end());
-                                expr = dbuilder.createExpression(addr);
-                                dbuilder.insertDeclare(gcframe, dinfo, expr,
-#if JL_LLVM_VERSION >= 30700
-                                                dbg->getDebugLoc(),
-#endif
-                                                dbg->getParent());
-                                dbg->eraseFromParent();
-                            }
-                        }
-                    }
-                }
-#endif
-                tbaa_decorate_gcframe(callInst, tbaa_gcframe);
-                callInst->replaceAllUsesWith(argTempi);
-                argTempi->takeName(callInst);
-                callInst->eraseFromParent();
-                // Initialize the slots for function variables to NULL
-                StoreInst *store = new StoreInst(V_null, argTempi);
-                store->setMetadata(llvm::LLVMContext::MD_tbaa, tbaa_gcframe);
-                store->insertAfter(argTempi);
-                last_gcframe_inst = store;
-            }
-        }
-        else if (AllocaInst *allocaInst = dyn_cast<AllocaInst>(inst)) {
-            if (allocaInst->getAllocatedType() == V_null->getType()) {
-                // TODO: this is overly aggressive at zeroing allocas that may not actually need to be zeroed
-                StoreInst *store = new StoreInst(V_null, allocaInst);
-                store->insertAfter(allocaInst);
-            }
-        }
-    }
-#if JL_LLVM_VERSION >= 30600
-    dbuilder.finalize();
-#endif
-
-    if (argSpaceSize + maxDepth == 0) {
-        // 0 roots; remove gc frame entirely
-        gcframe->eraseFromParent();
-    }
-    else {
-        // Initialize the slots for temporary variables to NULL
-        if (maxDepth > 0) {
-            BitCastInst *tempSlot_i8 = new BitCastInst(tempSlot, PointerType::get(T_int8, 0), "", last_gcframe_inst);
-            Type *argsT[2] = {tempSlot_i8->getType(), T_int32};
-            Function *memset = Intrinsic::getDeclaration(&M, Intrinsic::memset, makeArrayRef(argsT));
-            Value *args[5] = {
-                tempSlot_i8, // dest
-                ConstantInt::get(T_int8, 0), // val
-                ConstantInt::get(T_int32, sizeof(jl_value_t*)*maxDepth), // len
-                ConstantInt::get(T_int32, 0), // align
-                ConstantInt::get(T_int1, 0)}; // volatile
-            CallInst *zeroing = CallInst::Create(memset, makeArrayRef(args));
-            zeroing->setMetadata(llvm::LLVMContext::MD_tbaa, tbaa_gcframe);
-            zeroing->insertAfter(tempSlot_i8);
-            last_gcframe_inst = zeroing;
-        }
-
-        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);
-
-        Instruction *inst =
-            builder.CreateStore(ConstantInt::get(T_size, (argSpaceSize + maxDepth) << 1),
-                                builder.CreateBitCast(builder.CreateConstGEP1_32(gcframe, 0), T_size->getPointerTo()));
-        inst->setMetadata(llvm::LLVMContext::MD_tbaa, tbaa_gcframe);
-        inst = builder.CreateStore(builder.CreateLoad(builder.Insert(get_pgcstack(ptlsStates))),
-                                   builder.CreatePointerCast(builder.CreateConstGEP1_32(gcframe, 1), PointerType::get(T_ppjlvalue,0)));
-        inst->setMetadata(llvm::LLVMContext::MD_tbaa, tbaa_gcframe);
-        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);
-                inst = builder.CreateLoad(gcpop);
-                inst->setMetadata(llvm::LLVMContext::MD_tbaa, tbaa_gcframe);
-                inst = builder.CreateStore(builder.CreatePointerCast(inst, T_ppjlvalue),
-                                           builder.Insert(get_pgcstack(ptlsStates)));
-                inst->setMetadata(llvm::LLVMContext::MD_tbaa, tbaa_gcframe);
-            }
-        }
-    }
-
-#ifndef NDEBUG
-    jl_gc_frame_stats.count++;
-    jl_gc_frame_stats.locals += argSpaceSize;
-    jl_gc_frame_stats.temp += maxDepth;
-#endif
-}
-
-struct LowerGCFrame: public ModulePass {
-    static char ID;
-    LowerGCFrame() : ModulePass(ID)
-    {}
-
-private:
-    void runOnFunction(Module *M, Function &F, Function *ptls_getter,
-                       Type *T_pjlvalue, MDNode *tbaa_gcframe);
-    bool runOnModule(Module &M) override;
-};
-
-static void eraseFunction(Module &M, const char *name)
-{
-    if (Function *f = M.getFunction(name)) {
-        f->eraseFromParent();
-    }
-}
-
-static void ensure_enter_function(Module &M)
-{
-    auto T_int8  = Type::getInt8Ty(M.getContext());
-    auto T_pint8 = PointerType::get(T_int8, 0);
-    auto T_void = Type::getVoidTy(M.getContext());
-    auto T_int32 = Type::getInt32Ty(M.getContext());
-    if (!M.getNamedValue("jl_enter_handler")) {
-        std::vector<Type*> ehargs(0);
-        ehargs.push_back(T_pint8);
-        Function::Create(FunctionType::get(T_void, ehargs, false),
-                         Function::ExternalLinkage, "jl_enter_handler", &M);
-    }
-    if (!M.getNamedValue(jl_setjmp_name)) {
-        std::vector<Type*> args2(0);
-        args2.push_back(T_pint8);
-#ifndef _OS_WINDOWS_
-        args2.push_back(T_int32);
-#endif
-        Function::Create(FunctionType::get(T_int32, args2, false),
-                         Function::ExternalLinkage, jl_setjmp_name, &M)
-            ->addFnAttr(Attribute::ReturnsTwice);
-    }
-}
-
-bool LowerGCFrame::runOnModule(Module &M)
-{
-    MDNode *tbaa_gcframe = tbaa_make_child("jtbaa_gcframe").first;
-
-    Function *ptls_getter = M.getFunction("jl_get_ptls_states");
-    ensure_enter_function(M);
-    FunctionType *functype = nullptr;
-    Type *T_pjlvalue = nullptr;
-    if (ptls_getter) {
-        functype = ptls_getter->getFunctionType();
-        auto T_ppjlvalue =
-            cast<PointerType>(functype->getReturnType())->getElementType();
-        T_pjlvalue = cast<PointerType>(T_ppjlvalue)->getElementType();
-    }
-    for (auto F = M.begin(), E = M.end(); F != E; ++F) {
-        if (F->isDeclaration())
-            continue;
-        runOnFunction(&M, *F, ptls_getter, T_pjlvalue, tbaa_gcframe);
-    }
-
-    // Cleanup for GC frame lowering.
-    eraseFunction(M, "julia.gc_root_decl");
-    eraseFunction(M, "julia.gc_root_kill");
-    eraseFunction(M, "julia.jlcall_frame_decl");
-    eraseFunction(M, "julia.gcroot_flush");
-    eraseFunction(M, "julia.except_enter");
-    return true;
-}
-
-void LowerGCFrame::runOnFunction(Module *M, Function &F, Function *ptls_getter,
-                                 Type *T_pjlvalue, MDNode *tbaa_gcframe)
-{
-    CallInst *ptlsStates = nullptr;
-    for (auto I = F.getEntryBlock().begin(), E = F.getEntryBlock().end();
-         ptls_getter && I != E; ++I) {
-        if (CallInst *callInst = dyn_cast<CallInst>(&*I)) {
-            if (callInst->getCalledValue() == ptls_getter) {
-                ptlsStates = callInst;
-                break;
-            }
-        }
-    }
-    JuliaGCAllocator allocator(F, ptlsStates, T_pjlvalue, tbaa_gcframe);
-    allocator.allocate_frame();
-}
-
-char LowerGCFrame::ID = 0;
-
-static RegisterPass<LowerGCFrame> X("LowerGCFrame", "Lower GCFrame Pass",
-                                    false /* Only looks at CFG */,
-                                    false /* Analysis Pass */);
-}
-
-#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
-
-Pass *createLowerGCFramePass()
-{
-    return new LowerGCFrame();
-}
-
-extern "C" JL_DLLEXPORT
-void LLVMAddLowerGCFramePass(LLVMPassManagerRef PM) {
-    unwrap(PM)->add(createLowerGCFramePass());
-}
diff --git a/src/llvm-late-gc-lowering.cpp b/src/llvm-late-gc-lowering.cpp
new file mode 100644
index 00000000000000..72c0b684bfc397
--- /dev/null
+++ b/src/llvm-late-gc-lowering.cpp
@@ -0,0 +1,1474 @@
+// This file is a part of Julia. License is MIT: https://julialang.org/license
+
+#include <llvm/ADT/BitVector.h>
+#include <llvm/ADT/PostOrderIterator.h>
+#include <llvm/ADT/SetVector.h>
+#include "llvm/Analysis/CFG.h"
+#include <llvm/IR/Value.h>
+#include <llvm/IR/Constants.h>
+#include <llvm/IR/Dominators.h>
+#include <llvm/IR/Function.h>
+#include <llvm/IR/Instructions.h>
+#include <llvm/IR/IntrinsicInst.h>
+#include <llvm/IR/CallSite.h>
+#include <llvm/IR/Module.h>
+#include <llvm/IR/IRBuilder.h>
+#include <llvm/IR/Verifier.h>
+#include <llvm/Pass.h>
+#include <llvm/Support/Debug.h>
+
+#include "llvm-version.h"
+#include "codegen_shared.h"
+#include "julia.h"
+#include "julia_internal.h"
+
+#define DEBUG_TYPE "late_lower_gcroot"
+
+using namespace llvm;
+
+/* Julia GC Root Placement pass. For a general overview of the design of GC
+   root lowering, see the devdocs. This file is the actual implementation.
+
+   The actual algorithm is fairly straightforward. First recall the goal of this
+   pass:
+
+   Minimize the number of needed gc roots/stores to them subject to the constraint
+   that at every safepoint, any live gc-tracked pointer (i.e. for which there is
+   a path after this point that contains a use of this pointer) is in some gc slot.
+
+   In particular, in order to understand this algorithm, it is important to
+   realize that the only places where rootedness matters is at safepoints.
+
+   Now, the primary phases of the algorithm are:
+
+   1. Local Scan
+
+      During this step, each Basic Block is inspected and analyzed for local
+      properties. In particular, we want to determine the ordering of any of
+      the following activities:
+
+        - Any Def of a gc-tracked pointer. In general Defs are the results of
+          calls or loads from appropriate memory locations. Phi nodes and
+          selects do complicate this story slightly as described below.
+        - Any use of a gc-tracked or derived pointer. As described in the
+          devdocs, a use is in general one of
+              a) a load from a tracked/derived value
+              b) a store to a tracked/derived value
+              c) a store OF a tracked/derived value
+              d) a use of a value as a call operand (including operand bundles)
+        - Any safepoint
+
+      Crucially, we also perform pointer numbering during the local scan,
+      assigning every Def a unique integer and caching the integer for each
+      derived pointer. This allows us to operate only on the set of Defs (
+      represented by these integers) for the rest of the algorithm. We also
+      maintain some local utility information that is needed by later passes
+      (see the BBState struct for details).
+
+    2. Dataflow Computation
+
+      This computation operates entirely over the function's control flow graph
+      and does not look into a basic block. The algorithm is essentially
+      textbook iterative data flow for liveness computation. However, the
+      data flow equations are slightly more complicated because we also
+      forward propagate rootedness information in addition to backpropagating
+      liveness.
+
+    3. Live Set Computation
+
+      With the liveness information from the previous step, we can now compute,
+      for every safepoint, the set of values live at that particular safepoint.
+      There are three pieces of information being combined here:
+           i. Values that needed to be live due to local analysis (e.g. there
+              was a def, then a safepoint, then a use). This was computed during
+              local analysis.
+          ii. Values that are live across the basic block (i.e. they are live
+              at every safepoint within the basic block). This relies entirely
+              on the liveness information.
+         iii. Values that are now live-out from the basic block (i.e. they are
+              live at every safepoint following their def). During local
+              analysis, we keep, for every safepoint, those values that would
+              be live if they were live out. Here we can check if they are
+              actually live-out and make the appropriate additions to the live
+              set.
+
+       Lastly, we also explicitly compute, for each value, the list of values
+       that are simultaneously live at some safepoint. This is known as an
+       "interference graph" and is the input to the next step.
+
+    4. GC Root coloring
+
+      Two values which are not simultaneously live at a safepoint can share the
+      same slot. This is an important optimization, because otherwise long
+      functions would have exceptionally large GC slots, reducing performance
+      and bloating the size of the stack. Assigning values to these slots is
+      equivalent to doing graph coloring on the interference graph - the graph
+      where nodes are values and two values have an edge if they are
+      simultaneously live at a safepoint - which we computed in the previous
+      step. Now graph coloring in general is a hard problem. However, for SSA
+      form programs, (and most programs in general, by virtue of their
+      structure), the resulting interference graphs are chordal and can be
+      colored optimally in linear time by performing greedy coloring in a
+      perfect elimination order. Now, our interference graphs are likely not
+      entirely chordal due to some non-SSA corner cases. However, using the same
+      algorithm should still give a very good coloring while having sufficiently
+      low runtime.
+
+    5. JLCall frame optimizations
+
+      Unlike earlier iterations of the gc root placement logic, jlcall frames
+      are no longer treated as a special case and need not necessarily be sunk
+      into the gc frame. Additionally, we now emit lifetime
+      intrinsics, so regular stack slot coloring will merge any jlcall frames
+      not sunk into the gc frame. Nevertheless performing such sinking can still
+      be profitable. Since all arguments to a jlcall are guaranteed to be live
+      at that call in some gc slot, we can attempt to rearrange the slots within
+      the gc-frame, or re-use slots not assigned at that particular location
+      for the gcframe. However, even without this optimization, stack frames
+      are at most two times larger than optimal (because regular stack coloring
+      can merge the jlcall allocas).
+
+      N.B.: This step is not yet implemented.
+
+    6. Root placement
+
+      This performs the actual insertion of the GCFrame pushes/pops, zeros out
+      the gc frame and creates the stores to the gc frame according to the
+      stack slot assignment computed in the previous step. GC frames stores
+      are generally sunk right before the first safe point that use them
+      (this is beneficial for code where the primary path does not have
+      safepoints, but some other path - e.g. the error path does). However,
+      if the first safepoint is not dominated by the definition (this can
+      happen due to the non-ssa corner cases), the store is inserted right after
+      the definition.
+
+    7. Cleanup
+
+      This step performs necessary cleanup before passing the IR to codegen. In
+      particular, it removes any calls to julia_from_objref intrinsics and
+      removes the extra operand bundles from ccalls. In the future it could
+      also strip the addrspace information from all values as this
+      information is no longer needed.
+
+
+  There are a couple important special cases that deserve special attention:
+
+    A. PHIs and Selects
+
+      In general PHIs and selects are treated as separate defs for the purposes
+      of the algorithm and their operands as uses of those values. It is
+      important to consider however WHERE the uses of PHI's operands are
+      located. It is neither at the start of the basic block, because the values
+      do not dominate the block (so can't really consider them live-in), nor
+      at the end of the predecessor (because they are actually live out).
+      Instead it is best to think of those uses as living on the edge between
+      the appropriate predecessor and the block containing the PHI.
+
+      Another concern is PHIs of derived values. Since we cannot simply root
+      these values by storing them to a GC slot, we need to insert a new,
+      artificial PHI that tracks the base pointers for the derived values. E.g.
+      in:
+
+      A:
+        %Abase = load addrspace(10) *...
+        %Aderived = addrspacecast %Abase to addrspace(11)
+      B:
+        %Bbase = load addrspace(10) *...
+        %Bderived = addrspacecast %Bbase to addrspace(11)
+      C:
+        %phi = phi [%Aderived, %A
+                    %Bderived, %B]
+
+      we will insert another phi in C to track the relevant base pointers:
+
+        %philift = phi [%Abase, %A
+                        %Bbase, %B]
+
+      We then pretend, for the purposes of numbering that %phi was derived from
+      %philift. Note that in order to be able to do this, we need to be able to
+      perform this lifting either during numbering or instruction scanning.
+
+    B. Vectors of pointers/Union representations
+
+      Since this pass runs very late in the pass pipeline, it runs after the
+      various vectorization passes. As a result, we have to potentially deal
+      with vectors of gc-tracked pointers. For the purposes of most of the
+      algorithm, we simply assign every element of the vector a separate number
+      and no changes are needed. However, those parts of the algorithm that
+      look at IR need to be aware of the possibility of encountering vectors of
+      pointers.
+
+      Similarly, unions (e.g. in call returns) are represented as a struct of
+      a gc-tracked value and an argument selector. We simply assign a single
+      number to this struct and proceed as if it was a single pointer. However,
+      this again requires care at the IR level.
+
+    C. Non mem2reg'd allocas
+
+      Under some circumstances, allocas will still be present in the IR when
+      we get to this pass. We don't try very hard to handle this case, and
+      simply sink the alloca into the GCFrame.
+*/
+
+struct BBState {
+    // These do not get updated after local analysis
+    BitVector Defs;
+    BitVector PhiOuts;
+    //// Upward exposed uses that do not have a preceding safepoint
+    BitVector UpExposedUsesUnrooted;
+    //// All other uses
+    BitVector UpExposedUses;
+    //// Downward exposed uses that were not followed by a safepoint
+    BitVector DownExposedUnrooted;
+    // These get updated during dataflow
+    BitVector LiveIn;
+    BitVector LiveOut;
+    //// Incoming values that are unrooted - these are propagated forward. I.e.
+    //// they need not necessarily be LiveIn if there are no following uses,
+    //// but if they are they haven't been rooted yet.
+    BitVector UnrootedIn;
+    BitVector UnrootedOut;
+    std::vector<int> Safepoints;
+    int TopmostSafepoint = -1;
+    bool HasSafepoint = false;
+    // Have we gone through this basic block in our local scan yet?
+    bool Done = false;
+};
+
+struct State {
+    // The maximum assigned value number
+    int MaxPtrNumber;
+    // The maximum assigned safepoint number
+    int MaxSafepointNumber;
+    // Cache of numbers assigned to IR values. This includes caching of numbers
+    // for derived values
+    std::map<Value *, int> AllPtrNumbering;
+    std::map<Value *, std::vector<int>> AllVectorNumbering;
+    // Numbering of pointers. This only includes Defs
+    std::map<Value *, int> PtrNumbering;
+    // The reverse of the previous maps
+    std::map<int, Value *> ReversePtrNumbering;
+    // Neighbors in the coloring interference graph. I.e. for each value, the
+    // indices of other values that are used simultaneously at some safe point.
+    std::vector<SetVector<int>> Neighbors;
+    // The result of the local analysis
+    std::map<BasicBlock *, BBState> BBStates;
+
+    // Load refinement map. All uses of the keys can be combined with uses
+    // of the value (but not the other way around).
+    std::map<int, int> LoadRefinements;
+
+    // The assignment of numbers to safepoints. The indices in the map
+    // are indices into the next three maps which store safepoint properties
+    std::map<Instruction *, int> SafepointNumbering;
+
+    // Reverse mapping index -> safepoint
+    std::vector<Instruction *> ReverseSafepointNumbering;
+
+    // Instructions that can return twice. For now, all values live at these
+    // instructions will get their own, dedicated GC frame slots, because they
+    // have unobservable control flow, so we can't be sure where they're
+    // actually live. All of these are also considered safepoints.
+    std::vector<Instruction *> ReturnsTwice;
+
+    // The set of values live at a particular safepoint
+    std::vector<BitVector> LiveSets;
+    // Those values that - if live out from our parent basic block - are live
+    // at this safepoint.
+    std::vector<std::vector<int>> LiveIfLiveOut;
+    // We don't bother doing liveness on Allocas that were not mem2reg'ed.
+    // they just get directly sunk into the root array.
+    std::vector<AllocaInst *> Allocas;
+    State() : MaxPtrNumber(-1), MaxSafepointNumber(-1) {}
+};
+
+namespace llvm {
+    void initializeLateLowerGCFramePass(PassRegistry &Registry);
+}
+
+extern std::pair<MDNode*,MDNode*> tbaa_make_child(const char *name, MDNode *parent=nullptr, bool isConstant=false);
+struct LateLowerGCFrame: public FunctionPass {
+    static char ID;
+    LateLowerGCFrame() : FunctionPass(ID)
+    {
+        llvm::initializeDominatorTreeWrapperPassPass(*PassRegistry::getPassRegistry());
+        tbaa_gcframe = tbaa_make_child("jtbaa_gcframe").first;
+        MDNode *tbaa_data;
+        MDNode *tbaa_data_scalar;
+        std::tie(tbaa_data, tbaa_data_scalar) = tbaa_make_child("jtbaa_data");
+        tbaa_tag = tbaa_make_child("jtbaa_tag", tbaa_data_scalar).first;
+    }
+
+protected:
+    void getAnalysisUsage(AnalysisUsage &AU) const override {
+        FunctionPass::getAnalysisUsage(AU);
+        AU.addRequired<DominatorTreeWrapperPass>();
+        AU.addPreserved<DominatorTreeWrapperPass>();
+        AU.setPreservesCFG();
+    }
+
+private:
+    Type *T_prjlvalue;
+    Type *T_ppjlvalue;
+    Type *T_size;
+    Type *T_int8;
+    Type *T_int32;
+    Type *T_pint8;
+    Type *T_pjlvalue_der;
+    Type *T_ppjlvalue_der;
+    MDNode *tbaa_gcframe;
+    MDNode *tbaa_tag;
+    Function *ptls_getter;
+    Function *gc_flush_func;
+    Function *pointer_from_objref_func;
+    Function *alloc_obj_func;
+    Function *pool_alloc_func;
+    Function *big_alloc_func;
+    CallInst *ptlsStates;
+
+    void MaybeNoteDef(State &S, BBState &BBS, Value *Def, const std::vector<int> &SafepointsSoFar, int RefinedPtr = -2);
+    void NoteUse(State &S, BBState &BBS, Value *V, BitVector &Uses);
+    void NoteUse(State &S, BBState &BBS, Value *V) {
+        NoteUse(S, BBS, V, BBS.UpExposedUses);
+    }
+    int LiftPhi(State &S, PHINode *Phi);
+    int Number(State &S, Value *V);
+    std::vector<int> NumberVector(State &S, Value *Vec);
+    void NoteOperandUses(State &S, BBState &BBS, User &UI, BitVector &Uses);
+    void NoteOperandUses(State &S, BBState &BBS, User &UI){
+        NoteOperandUses(S, BBS, UI, BBS.UpExposedUses);
+    }
+    State LocalScan(Function &F);
+    void ComputeLiveness(Function &F, State &S);
+    void ComputeLiveSets(Function &F, State &S);
+    void PushGCFrame(AllocaInst *gcframe, unsigned NRoots, Instruction *InsertAfter);
+    void PopGCFrame(AllocaInst *gcframe, Instruction *InsertBefore);
+    std::vector<int> ColorRoots(const State &S);
+    void PlaceGCFrameStore(State &S, unsigned R, unsigned MinColorRoot, const std::vector<int> &Colors, Value *GCFrame, Instruction *InsertionPoint);
+    void PlaceGCFrameStores(Function &F, State &S, unsigned MinColorRoot, const std::vector<int> &Colors, Value *GCFrame);
+    void PlaceRootsAndUpdateCalls(Function &F, std::vector<int> &Colors, State &S, std::map<Value *, std::pair<int, int>>);
+    bool doInitialization(Module &M) override;
+    bool runOnFunction(Function &F) override;
+    Instruction *get_pgcstack(Instruction *ptlsStates);
+    bool CleanupIR(Function &F);
+    void NoteUseChain(State &S, BBState &BBS, User *TheUser);
+};
+
+static unsigned getValueAddrSpace(Value *V) {
+    return cast<PointerType>(V->getType())->getAddressSpace();
+}
+
+static bool isSpecialPtr(Type *Ty) {
+    PointerType *PTy = dyn_cast<PointerType>(Ty);
+    if (!PTy)
+        return false;
+    unsigned AS = PTy->getAddressSpace();
+    return AddressSpace::FirstSpecial <= AS && AS <= AddressSpace::LastSpecial;
+}
+
+static bool isSpecialPtrVec(Type *Ty) {
+    auto *VTy = dyn_cast<VectorType>(Ty);
+    if (!VTy)
+        return false;
+    return isSpecialPtr(VTy->getElementType());
+}
+
+static bool isUnionRep(Type *Ty) {
+    return Ty->isStructTy() && cast<StructType>(Ty)->getNumElements() == 2 &&
+        isSpecialPtr(cast<StructType>(Ty)->getTypeAtIndex((unsigned)0));
+}
+
+static Value *FindBaseValue(const State &S, Value *V, bool UseCache = true) {
+    Value *CurrentV = V;
+    while (true) {
+        if (UseCache) {
+            if (CurrentV->getType()->isPointerTy()) {
+                auto it = S.AllPtrNumbering.find(CurrentV);
+                if (it != S.AllPtrNumbering.end())
+                    return CurrentV;
+            } else {
+                auto it = S.AllVectorNumbering.find(CurrentV);
+                if (it != S.AllVectorNumbering.end())
+                    return CurrentV;
+            }
+        }
+        if (isa<BitCastInst>(CurrentV))
+            CurrentV = cast<BitCastInst>(CurrentV)->getOperand(0);
+        else if (isa<AddrSpaceCastInst>(CurrentV)) {
+            Value *NewV = cast<AddrSpaceCastInst>(CurrentV)->getOperand(0);
+            if (getValueAddrSpace(NewV) == 0)
+                break;
+            CurrentV = NewV;
+        }
+        else if (isa<GetElementPtrInst>(CurrentV))
+            CurrentV = cast<GetElementPtrInst>(CurrentV)->getOperand(0);
+        else if (isa<ExtractValueInst>(CurrentV)) {
+            Value *Operand = cast<ExtractValueInst>(CurrentV)->getOperand(0);
+            if (!isUnionRep(Operand->getType()))
+                break;
+            CurrentV = Operand;
+            continue;
+        } else
+            break;
+    }
+    assert(isa<LoadInst>(CurrentV) || isa<CallInst>(CurrentV) ||
+           isa<Argument>(CurrentV) || isa<SelectInst>(CurrentV) ||
+           isa<PHINode>(CurrentV) || isa<AddrSpaceCastInst>(CurrentV) ||
+           isa<Constant>(CurrentV) || isa<AllocaInst>(CurrentV) ||
+           isa<ExtractValueInst>(CurrentV));
+    return CurrentV;
+}
+
+static Value *MaybeExtractUnion(Value *Val, Instruction *InsertBefore) {
+    if (isUnionRep(Val->getType())) {
+        Val = ExtractValueInst::Create(Val, {(unsigned)0}, "", InsertBefore);
+    }
+    return Val;
+}
+
+static int LiftSelect(State &S, SelectInst *SI) {
+    Value *TrueBase = FindBaseValue(S, SI->getTrueValue(), false);
+    Value *FalseBase = FindBaseValue(S, SI->getFalseValue(), false);
+    TrueBase = MaybeExtractUnion(TrueBase, SI);
+    FalseBase = MaybeExtractUnion(FalseBase, SI);
+    if (getValueAddrSpace(TrueBase) != AddressSpace::Tracked)
+        TrueBase = ConstantPointerNull::get(cast<PointerType>(FalseBase->getType()));
+    if (getValueAddrSpace(FalseBase) != AddressSpace::Tracked)
+        FalseBase = ConstantPointerNull::get(cast<PointerType>(TrueBase->getType()));
+    if (getValueAddrSpace(TrueBase) != AddressSpace::Tracked)
+        return -1;
+    Value *SelectBase = SelectInst::Create(SI->getCondition(),
+        TrueBase, FalseBase, "gclift", SI);
+    int Number = ++S.MaxPtrNumber;
+    S.PtrNumbering[SelectBase] = S.AllPtrNumbering[SelectBase] =
+        S.AllPtrNumbering[SI] = Number;
+    S.ReversePtrNumbering[Number] = SelectBase;
+    return Number;
+}
+
+int LateLowerGCFrame::LiftPhi(State &S, PHINode *Phi)
+{
+    PHINode *lift = PHINode::Create(T_prjlvalue, Phi->getNumIncomingValues(), "gclift", Phi);
+    for (unsigned i = 0; i < Phi->getNumIncomingValues(); ++i) {
+        Value *Incoming = Phi->getIncomingValue(i);
+        Value *Base = FindBaseValue(S, Incoming, false);
+        if (getValueAddrSpace(Base) != AddressSpace::Tracked)
+            Base = ConstantPointerNull::get(cast<PointerType>(T_prjlvalue));
+        if (Base->getType() != T_prjlvalue)
+            Base = new BitCastInst(Base, T_prjlvalue, "", Phi->getIncomingBlock(i)->getTerminator());
+        lift->addIncoming(Base, Phi->getIncomingBlock(i));
+    }
+    int Number = ++S.MaxPtrNumber;
+    S.PtrNumbering[lift] = S.AllPtrNumbering[lift] =
+        S.AllPtrNumbering[Phi] = Number;
+    S.ReversePtrNumbering[Number] = lift;
+    return Number;
+}
+
+int LateLowerGCFrame::Number(State &S, Value *V) {
+    assert(isSpecialPtr(V->getType()) || isUnionRep(V->getType()));
+    Value *CurrentV = FindBaseValue(S, V);
+    auto it = S.AllPtrNumbering.find(CurrentV);
+    if (it != S.AllPtrNumbering.end())
+        return it->second;
+    int Number;
+    if (isa<Constant>(CurrentV) || isa<Argument>(CurrentV) ||
+        ((isa<AllocaInst>(CurrentV) || isa<AddrSpaceCastInst>(CurrentV)) &&
+         getValueAddrSpace(CurrentV) != AddressSpace::Tracked)) {
+        // We know this is rooted in the parent
+        Number = -1;
+    } else if (isa<SelectInst>(CurrentV) && getValueAddrSpace(CurrentV) != AddressSpace::Tracked) {
+        int Number = LiftSelect(S, cast<SelectInst>(CurrentV));
+        S.AllPtrNumbering[V] = Number;
+        return Number;
+    } else if (isa<PHINode>(CurrentV) && getValueAddrSpace(CurrentV) != AddressSpace::Tracked) {
+        int Number = LiftPhi(S, cast<PHINode>(CurrentV));
+        S.AllPtrNumbering[V] = Number;
+        return Number;
+    } else if (isa<ExtractValueInst>(CurrentV) && !isUnionRep(CurrentV->getType())) {
+        assert(false && "TODO: Extract");
+        abort();
+    } else {
+        assert(
+            (CurrentV->getType()->isPointerTy() &&
+                getValueAddrSpace(CurrentV) == AddressSpace::Tracked) ||
+            isUnionRep(CurrentV->getType()));
+        Number = ++S.MaxPtrNumber;
+        S.ReversePtrNumbering[Number] = CurrentV;
+    }
+    S.PtrNumbering[CurrentV] = S.AllPtrNumbering[CurrentV] = S.AllPtrNumbering[V] = Number;
+    return Number;
+}
+
+std::vector<int> LateLowerGCFrame::NumberVector(State &S, Value *V) {
+    auto it = S.AllVectorNumbering.find(V);
+    if (it != S.AllVectorNumbering.end())
+        return it->second;
+    Value *CurrentV = FindBaseValue(S, V);
+    it = S.AllVectorNumbering.find(CurrentV);
+    if (it != S.AllVectorNumbering.end())
+        return it->second;
+    if (isa<Constant>(CurrentV) ||
+        ((isa<Argument>(CurrentV) || isa<AllocaInst>(CurrentV) ||
+         isa<AddrSpaceCastInst>(CurrentV)) &&
+         getValueAddrSpace(CurrentV) != AddressSpace::Tracked)) {
+        S.AllVectorNumbering[V] = std::vector<int>{};
+    }
+    /* We (the frontend) don't insert either of these, but it would be legal -
+       though a bit strange, considering they're pointers - for the optimizer to
+       do so. All that's needed here is to NumberVector the previous vector/value
+       and lift the operation */
+    else if (isa<ShuffleVectorInst>(CurrentV)) {
+        assert(false && "TODO Shuffle");
+    } else if (isa<InsertElementInst>(CurrentV)) {
+        assert(false && "TODO Insert");
+    } else if (isa<LoadInst>(CurrentV)) {
+        // This is simple, we can just number them sequentially
+        std::vector<int> Numbers;
+        for (unsigned i = 0; i < cast<VectorType>(CurrentV->getType())->getNumElements(); ++i) {
+            int Num = ++S.MaxPtrNumber;
+            Numbers.push_back(Num);
+            S.ReversePtrNumbering[Num] = V;
+        }
+        S.AllVectorNumbering[V] = Numbers;
+    }
+    return S.AllVectorNumbering[CurrentV];
+}
+
+static void MaybeResize(BBState &BBS, unsigned Idx) {
+    if (BBS.Defs.size() <= Idx) {
+        BBS.Defs.resize(Idx + 1);
+        BBS.UpExposedUses.resize(Idx + 1);
+        BBS.UpExposedUsesUnrooted.resize(Idx + 1);
+        BBS.DownExposedUnrooted.resize(Idx + 1);
+        BBS.PhiOuts.resize(Idx + 1);
+    }
+}
+
+static bool HasBitSet(const BitVector &BV, unsigned Bit) {
+    return Bit < BV.size() && BV[Bit];
+}
+
+static void NoteDef(State &S, BBState &BBS, int Num, const std::vector<int> &SafepointsSoFar) {
+    assert(Num != -1);
+    MaybeResize(BBS, Num);
+    assert(BBS.Defs[Num] == 0 && "SSA Violation or misnumbering?");
+    BBS.Defs[Num] = 1;
+    BBS.UpExposedUses[Num] = 0;
+    BBS.UpExposedUsesUnrooted[Num] = 0;
+    if (!BBS.HasSafepoint)
+        BBS.DownExposedUnrooted[Num] = 1;
+    // This value could potentially be live at any following safe point
+    // if it ends up live out, so add it to the LiveIfLiveOut lists for all
+    // following safepoints.
+    for (int Safepoint : SafepointsSoFar) {
+        S.LiveIfLiveOut[Safepoint].push_back(Num);
+    }
+}
+
+void LateLowerGCFrame::MaybeNoteDef(State &S, BBState &BBS, Value *Def, const std::vector<int> &SafepointsSoFar, int RefinedPtr) {
+    int Num = -1;
+    Type *RT = Def->getType();
+    if (isSpecialPtr(RT)) {
+        assert(getValueAddrSpace(Def) == AddressSpace::Tracked &&
+            "Returned value of GC interest, but not tracked?");
+        Num = Number(S, Def);
+    }
+    else if (isUnionRep(RT)) {
+        // Probably a union return. Find the extractvalue
+        Num = Number(S, Def);
+    }
+    else if (isSpecialPtrVec(RT)) {
+        std::vector<int> Nums = NumberVector(S, Def);
+        for (int Num : Nums) {
+            NoteDef(S, BBS, Num, SafepointsSoFar);
+            if (RefinedPtr != -2)
+                S.LoadRefinements[Num] = RefinedPtr;
+        }
+        return;
+    }
+    else {
+        return;
+    }
+    NoteDef(S, BBS, Num, SafepointsSoFar);
+    if (RefinedPtr != -2)
+        S.LoadRefinements[Num] = RefinedPtr;
+}
+
+static int NoteSafepoint(State &S, BBState &BBS, CallInst *CI) {
+    int Number = ++S.MaxSafepointNumber;
+    S.SafepointNumbering[CI] = Number;
+    S.ReverseSafepointNumbering.push_back(CI);
+    // Note which pointers are upward exposed live here. They need to be
+    // considered live at this safepoint even when they have a def earlier
+    // in this BB (i.e. even when they don't participate in the dataflow
+    // computation)
+    BBS.UpExposedUses |= BBS.UpExposedUsesUnrooted;
+    BBS.UpExposedUsesUnrooted.reset();
+    S.LiveSets.push_back(BBS.UpExposedUses);
+    S.LiveIfLiveOut.push_back(std::vector<int>{});
+    return Number;
+}
+
+void LateLowerGCFrame::NoteUse(State &S, BBState &BBS, Value *V, BitVector &Uses) {
+    // Short circuit to avoid having to deal with vectors of constants, etc.
+    if (isa<Constant>(V))
+        return;
+    else if (isSpecialPtrVec(V->getType())) {
+        std::vector<int> Nums = NumberVector(S, V);
+        for (int Num : Nums) {
+            MaybeResize(BBS, Num);
+            Uses[Num] = 1;
+        }
+    }
+    else {
+        int Num = Number(S, V);
+        if (Num == -1)
+            return;
+        MaybeResize(BBS, Num);
+        Uses[Num] = 1;
+    }
+}
+
+void LateLowerGCFrame::NoteOperandUses(State &S, BBState &BBS, User &UI, BitVector &Uses) {
+    for (Use &U : UI.operands()) {
+        Value *V = U;
+        if (!isSpecialPtr(V->getType()))
+            continue;
+        NoteUse(S, BBS, V, Uses);
+    }
+}
+
+template <typename VisitInst, typename callback>
+void RecursivelyVisit(callback f, Value *V) {
+    for (Use &VU : V->uses()) {
+        User *TheUser = VU.getUser();
+        if (isa<VisitInst>(TheUser))
+            f(VU);
+        if (isa<CallInst>(TheUser) || isa<LoadInst>(TheUser) ||
+            isa<SelectInst>(TheUser) || isa<PHINode>(TheUser) ||
+            isa<StoreInst>(TheUser))
+            continue;
+        if (isa<GetElementPtrInst>(TheUser) || isa<BitCastInst>(TheUser) || isa<AddrSpaceCastInst>(TheUser)) {
+            RecursivelyVisit<VisitInst, callback>(f, TheUser);
+            continue;
+        }
+        V->dump();
+        TheUser->dump();
+        assert(false && "Unexpected instruction");
+    }
+}
+
+static void dumpBitVectorValues(State &S, BitVector &BV) {
+    bool first = true;
+    for (int Idx = BV.find_first(); Idx >= 0; Idx = BV.find_next(Idx)) {
+        if (!first)
+            dbgs() << ", ";
+        first = false;
+        S.ReversePtrNumbering[Idx]->printAsOperand(dbgs());
+    }
+}
+
+/* Debugging utility to dump liveness information */
+JL_USED_FUNC static void dumpLivenessState(Function &F, State &S) {
+    for (auto &BB : F) {
+        dbgs() << "Liveness analysis for BB " << BB.getName();
+        dbgs() << "\n\tDefs: ";
+        dumpBitVectorValues(S, S.BBStates[&BB].Defs);
+        dbgs() << "\n\tPhiOuts: ";
+        dumpBitVectorValues(S, S.BBStates[&BB].PhiOuts);
+        dbgs() << "\n\tUpExposedUsesUnrooted: ";
+        dumpBitVectorValues(S, S.BBStates[&BB].UpExposedUsesUnrooted);
+        dbgs() << "\n\tUpExposedUses: ";
+        dumpBitVectorValues(S, S.BBStates[&BB].UpExposedUses);
+        dbgs() << "\n\tDownExposedUnrooted: ";
+        dumpBitVectorValues(S, S.BBStates[&BB].DownExposedUnrooted);
+        dbgs() << "\n\tLiveIn: ";
+        dumpBitVectorValues(S, S.BBStates[&BB].LiveIn);
+        dbgs() << "\n\tLiveOut: ";
+        dumpBitVectorValues(S, S.BBStates[&BB].LiveOut);
+        dbgs() << "\n\tUnrootedIn: ";
+        dumpBitVectorValues(S, S.BBStates[&BB].UnrootedIn);
+        dbgs() << "\n\tUnrootedOut: ";
+        dumpBitVectorValues(S, S.BBStates[&BB].UnrootedOut);
+        dbgs() << "\n";
+    }
+}
+
+// Check if this is a load from an immutable value. The easiest
+// way to do so is to look at the tbaa and see if it derives from
+// jtbaa_immut.
+static bool isLoadFromImmut(LoadInst *LI)
+{
+    MDNode *TBAA = LI->getMetadata(LLVMContext::MD_tbaa);
+    if (!TBAA)
+        return false;
+    while (TBAA->getNumOperands() > 1) {
+        TBAA = cast<MDNode>(TBAA->getOperand(1).get());
+        if (cast<MDString>(TBAA->getOperand(0))->getString() == "jtbaa_immut") {
+            return true;
+        }
+    }
+    return false;
+}
+
+static bool LooksLikeFrameRef(Value *V) {
+    if (isSpecialPtr(V->getType()))
+        return false;
+    if (isa<GetElementPtrInst>(V))
+        return LooksLikeFrameRef(cast<GetElementPtrInst>(V)->getOperand(0));
+    return isa<Argument>(V);
+}
+
+State LateLowerGCFrame::LocalScan(Function &F) {
+    State S;
+    for (BasicBlock &BB : F) {
+        BBState &BBS = S.BBStates[&BB];
+        for (auto it = BB.rbegin(); it != BB.rend(); ++it) {
+            Instruction &I = *it;
+            if (CallInst *CI = dyn_cast<CallInst>(&I)) {
+                if (isa<IntrinsicInst>(CI)) {
+                    // Intrinsics are never GC uses/defs
+                    continue;
+                }
+                MaybeNoteDef(S, BBS, CI, BBS.Safepoints);
+                NoteOperandUses(S, BBS, I, BBS.UpExposedUses);
+                for (Use &U : CI->operands()) {
+                    Value *V = U;
+                    if (isUnionRep(V->getType())) {
+                        NoteUse(S, BBS, V);
+                        continue;
+                    }
+                }
+                if (CI->canReturnTwice()) {
+                    S.ReturnsTwice.push_back(CI);
+                }
+                if (auto callee = CI->getCalledFunction()) {
+                    // Known functions emitted in codegen that are not safepoints
+                    if (callee == pointer_from_objref_func || callee->getName() == "memcmp") {
+                        continue;
+                    }
+                }
+                int SafepointNumber = NoteSafepoint(S, BBS, CI);
+                BBS.HasSafepoint = true;
+                BBS.TopmostSafepoint = SafepointNumber;
+                BBS.Safepoints.push_back(SafepointNumber);
+            } else if (LoadInst *LI = dyn_cast<LoadInst>(&I)) {
+                // If this is a load from an immutable, we know that
+                // this object will always be rooted as long as the
+                // object we're loading from is, so we can refine uses
+                // of this object to uses of the object we're loading
+                // from.
+                int RefinedPtr = -2;
+                if (isLoadFromImmut(LI) && isSpecialPtr(LI->getPointerOperand()->getType())) {
+                    RefinedPtr = Number(S, LI->getPointerOperand());
+                } else if (LI->getType()->isPointerTy() &&
+                    isSpecialPtr(LI->getType()) &&
+                    LooksLikeFrameRef(LI->getPointerOperand())) {
+                    // Loads from a jlcall argument array
+                    RefinedPtr = -1;
+                }
+                MaybeNoteDef(S, BBS, LI, BBS.Safepoints, RefinedPtr);
+                NoteOperandUses(S, BBS, I, BBS.UpExposedUsesUnrooted);
+            } else if (SelectInst *SI = dyn_cast<SelectInst>(&I)) {
+                // We need to insert an extra select for the GC root
+                if (!isSpecialPtr(SI->getType()))
+                    continue;
+                if (getValueAddrSpace(SI) != AddressSpace::Tracked) {
+                    if (S.AllPtrNumbering.find(SI) != S.AllPtrNumbering.end())
+                        continue;
+                    LiftSelect(S, SI);
+                } else {
+                    MaybeNoteDef(S, BBS, SI, BBS.Safepoints);
+                    NoteOperandUses(S, BBS, I, BBS.UpExposedUsesUnrooted);
+                }
+            } else if (PHINode *Phi = dyn_cast<PHINode>(&I)) {
+                if (!isSpecialPtr(Phi->getType())) {
+                    continue;
+                }
+                // We need to insert an extra phi for the GC root
+                if (getValueAddrSpace(Phi) != AddressSpace::Tracked) {
+                    if (S.AllPtrNumbering.find(Phi) != S.AllPtrNumbering.end())
+                        continue;
+                    LiftPhi(S, Phi);
+                } else {
+                    MaybeNoteDef(S, BBS, Phi, BBS.Safepoints);
+                    for (unsigned i = 0; i < Phi->getNumIncomingValues(); ++i) {
+                        BBState &IncomingBBS = S.BBStates[Phi->getIncomingBlock(i)];
+                        NoteUse(S, IncomingBBS, Phi->getIncomingValue(i), IncomingBBS.PhiOuts);
+                    }
+                }
+            } else if (isa<StoreInst>(&I) || isa<ReturnInst>(&I)) {
+                NoteOperandUses(S, BBS, I, BBS.UpExposedUsesUnrooted);
+            } else if (auto *ASCI = dyn_cast<AddrSpaceCastInst>(&I)) {
+                if (getValueAddrSpace(ASCI) == AddressSpace::Tracked)
+                    MaybeNoteDef(S, BBS, ASCI, BBS.Safepoints);
+            } else if (auto *AI = dyn_cast<AllocaInst>(&I)) {
+                if (isSpecialPtr(AI->getAllocatedType()) && !AI->isArrayAllocation() &&
+                    cast<PointerType>(AI->getAllocatedType())->getAddressSpace() == AddressSpace::Tracked)
+                {
+                    S.Allocas.push_back(AI);
+                }
+            }
+        }
+        // Pre-seed the dataflow variables;
+        BBS.LiveIn = BBS.UpExposedUses;
+        BBS.LiveIn |= BBS.UpExposedUsesUnrooted;
+        BBS.UnrootedOut = BBS.DownExposedUnrooted;
+        BBS.Done = true;
+    }
+    return S;
+}
+
+/*
+ * DataFlow equations:
+ * LiveIn[BB] = UpExposedUses[BB] ∪ (LiveOut[BB] - Defs[BB])
+ * LiveOut[BB] =  PhiUses[BB] ∪ ∪_{Succ} LiveIn[Succ]
+ * UnrootedOut[BB] = DownExposedUnrooted[BB] ∪ (HasSafepoint ? {} : UnrootedIn[BB])
+ * UnrootedIn[BB] = ∪_{Pred} UnrootedOut[Pred]
+ *
+ * We'll perform textbook iterative dataflow to compute this. There are better
+ * algorithms. If this starts becoming a problem, we should use one of them.
+ */
+void LateLowerGCFrame::ComputeLiveness(Function &F, State &S) {
+    bool Converged = false;
+    /* Liveness is a reverse problem. Our problem is slightly more general,
+     * because the Unrooted* variables are forward problems. Nevertheless,
+     * we use reverse postorder in an attempt to speed convergence of the Live*
+     * variables, in anticipation of the live ranges being larger than the
+     * unrooted ranges (since those terminate at any safe point).
+     */
+    ReversePostOrderTraversal<Function *> RPOT(&F);
+    while (!Converged) {
+        bool AnyChanged = false;
+        for (BasicBlock *BB : RPOT) {
+            // This could all be done more efficiently, by only updating what
+            // changed - Let's get it working first though.
+            BBState &BBS = S.BBStates[BB];
+            BitVector NewLiveOut = BBS.PhiOuts;
+            for (BasicBlock *Succ : successors(BB)) {
+                NewLiveOut |= S.BBStates[Succ].LiveIn;
+            }
+            if (NewLiveOut != BBS.LiveOut) {
+                AnyChanged = true;
+                BBS.LiveOut = NewLiveOut;
+                MaybeResize(BBS, BBS.LiveOut.size() - 1);
+            }
+            BitVector NewLiveIn = BBS.LiveOut;
+            BitVector FlippedDefs = BBS.Defs;
+            FlippedDefs.flip();
+            NewLiveIn &= FlippedDefs;
+            NewLiveIn |= BBS.UpExposedUses;
+            NewLiveIn |= BBS.UpExposedUsesUnrooted;
+            if (NewLiveIn != BBS.LiveIn) {
+                AnyChanged = true;
+                BBS.LiveIn = NewLiveIn;
+            }
+            BitVector NewUnrootedIn;
+            for (BasicBlock *Pred : predecessors(BB))
+                NewUnrootedIn |= S.BBStates[Pred].UnrootedOut;
+            if (NewUnrootedIn != BBS.UnrootedIn) {
+                AnyChanged = true;
+                BBS.UnrootedIn = NewUnrootedIn;
+                if (!BBS.HasSafepoint) {
+                    BBS.UnrootedOut |= BBS.UnrootedIn;
+                }
+            }
+        }
+        Converged = !AnyChanged;
+    }
+    ComputeLiveSets(F, S);
+}
+
+// For debugging
+JL_USED_FUNC static void dumpSafepointsForBBName(Function &F, State &S, const char *BBName) {
+    for (auto it : S.SafepointNumbering) {
+        if (it.first->getParent()->getName() == BBName) {
+            dbgs() << "Live at " << *it.first << "\n";
+            BitVector &LS = S.LiveSets[it.second];
+            for (int Idx = LS.find_first(); Idx >= 0; Idx = LS.find_next(Idx)) {
+                dbgs() << "\t";
+                S.ReversePtrNumbering[Idx]->printAsOperand(dbgs());
+                dbgs() << "\n";
+            }
+        }
+    }
+}
+
+void LateLowerGCFrame::ComputeLiveSets(Function &F, State &S) {
+    // Iterate over all safe points. Add to live sets all those variables that
+    // are now live across their parent block.
+    for (auto it : S.SafepointNumbering) {
+        int idx = it.second;
+        Instruction *Safepoint = it.first;
+        BasicBlock *BB = Safepoint->getParent();
+        BBState &BBS = S.BBStates[BB];
+        BitVector LiveAcross = BBS.LiveIn;
+        LiveAcross &= BBS.LiveOut;
+        BitVector &LS = S.LiveSets[idx];
+        LS |= LiveAcross;
+        for (int Live : S.LiveIfLiveOut[idx]) {
+            if (HasBitSet(BBS.LiveOut, Live))
+                LS[Live] = 1;
+        }
+        // Apply refinements
+        for (int Idx = LS.find_first(); Idx >= 0; Idx = LS.find_next(Idx)) {
+            if (!S.LoadRefinements.count(Idx))
+                continue;
+            int RefinedPtr = S.LoadRefinements[Idx];
+            if (RefinedPtr == -1 || HasBitSet(LS, RefinedPtr))
+                LS[Idx] = 0;
+        }
+    }
+    // Compute the interference graph
+    for (int i = 0; i <= S.MaxPtrNumber; ++i) {
+        SetVector<int> Neighbors;
+        BitVector NeighborBits(S.MaxPtrNumber);
+        for (auto it : S.SafepointNumbering) {
+            const BitVector &LS = S.LiveSets[it.second];
+            if ((unsigned)i >= LS.size() || !LS[i])
+                continue;
+            NeighborBits |= LS;
+        }
+        for (int Idx = NeighborBits.find_first(); Idx >= 0; Idx = NeighborBits.find_next(Idx)) {
+            // We explicitly let i be a neighbor of itself, to distinguish
+            // between being the only value live at a safepoint, vs not
+            // being live at any safepoint.
+            Neighbors.insert(Idx);
+        }
+        S.Neighbors.push_back(Neighbors);
+    }
+}
+
+/* For chordal interference graphs, this class gives the vertices in a (reverse
+ * - depending on definition) perfect elimination ordering, in such a way that
+ * greedy coloring gives an optimal coloring. Since our roots are in SSA form,
+ * the interference should be chordal.
+ */
+struct PEOIterator {
+    struct Element {
+        unsigned weight;
+        unsigned pos;
+    };
+    std::vector<Element> Elements;
+    std::vector<std::vector<int>> Levels;
+    const std::vector<SetVector<int>> &Neighbors;
+    PEOIterator(const std::vector<SetVector<int>> &Neighbors) : Neighbors(Neighbors) {
+        // Initialize State
+        std::vector<int> FirstLevel;
+        for (unsigned i = 0; i < Neighbors.size(); ++i) {
+            FirstLevel.push_back(i);
+            Element E{0, i};
+            Elements.push_back(E);
+        }
+        Levels.push_back(FirstLevel);
+    }
+    int next() {
+        // Find the element in the highest bucket
+        int NextElement = -1;
+        while (NextElement == -1 && !Levels.empty()) {
+            std::vector<int> &LastLevel = Levels.back();
+            while (NextElement == -1 && !LastLevel.empty()) {
+                NextElement = LastLevel.back();
+                LastLevel.pop_back();
+            }
+            if (LastLevel.empty())
+                Levels.pop_back();
+        }
+        if (NextElement == -1)
+            return NextElement;
+        // Make sure not to try to re-use this later.
+        Elements[NextElement].weight = (unsigned)-1;
+        // Raise neighbors
+        for (int Neighbor : Neighbors[NextElement]) {
+            if (Neighbor == NextElement)
+                continue;
+            Element &NElement = Elements[Neighbor];
+            // Already processed. Don't re-enqueue
+            if (NElement.weight == (unsigned)-1)
+                continue;
+            // Kill old queue position
+            Levels[NElement.weight][NElement.pos] = -1;
+            // Raise the neighbor to the next level.
+            NElement.weight += 1;
+            if (NElement.weight >= Levels.size())
+                Levels.push_back(std::vector<int>{});
+            Levels[NElement.weight].push_back(Neighbor);
+            NElement.pos = Levels[NElement.weight].size()-1;
+        }
+        // As an enhancement, we might want to periodically compactify the whole
+        // data structure. This could be done here.
+        return NextElement;
+    }
+};
+
+JL_USED_FUNC static void dumpColorAssignments(const State &S, std::vector<int> &Colors)
+{
+    for (unsigned i = 0; i < Colors.size(); ++i) {
+        if (Colors[i] == -1)
+            continue;
+        dbgs() << "\tValue ";
+        S.ReversePtrNumbering.at(i)->printAsOperand(dbgs());
+        dbgs() << " assigned color " << Colors[i] << "\n";
+    }
+}
+
+std::vector<int> LateLowerGCFrame::ColorRoots(const State &S) {
+    std::vector<int> Colors;
+    Colors.resize(S.MaxPtrNumber + 1, -1);
+    PEOIterator Ordering(S.Neighbors);
+    int PreAssignedColors = 0;
+    /* First assign permanent slots to things that need them due
+       to returns_twice */
+    for (auto it : S.ReturnsTwice) {
+        int Num = S.SafepointNumbering.at(it);
+        const BitVector &LS = S.LiveSets[Num];
+        for (int Idx = LS.find_first(); Idx >= 0; Idx = LS.find_next(Idx)) {
+            if (Colors[Idx] == -1)
+                Colors[Idx] = PreAssignedColors++;
+        }
+    }
+    /* Greedy coloring */
+    int MaxAssignedColor = -1;
+    int ActiveElement = 1;
+    BitVector UsedColors;
+    while ((ActiveElement = Ordering.next()) != -1) {
+        if (Colors[ActiveElement] != -1)
+            continue;
+        UsedColors.resize(MaxAssignedColor + 2, false);
+        UsedColors.reset();
+        if (S.Neighbors[ActiveElement].empty()) {
+            // No need to color a value not live at any safe point
+            continue;
+        }
+        for (int Neighbor : S.Neighbors[ActiveElement]) {
+            int NeighborColor = Colors[Neighbor];
+            if (NeighborColor == -1)
+                continue;
+            if (NeighborColor < PreAssignedColors)
+                continue;
+            UsedColors[NeighborColor - PreAssignedColors] = 1;
+        }
+        int NewColor = UsedColors.flip().find_first();
+        if (NewColor > MaxAssignedColor)
+            MaxAssignedColor = NewColor;
+        NewColor += PreAssignedColors;
+        Colors[ActiveElement] = NewColor;
+    }
+    return Colors;
+}
+
+Instruction *LateLowerGCFrame::get_pgcstack(Instruction *ptlsStates)
+{
+    Constant *offset = ConstantInt::getSigned(T_int32, offsetof(jl_tls_states_t, pgcstack) / sizeof(void*));
+    return GetElementPtrInst::Create(nullptr,
+                                     ptlsStates,
+                                     ArrayRef<Value*>(offset),
+                                     "jl_pgcstack");
+}
+
+void LateLowerGCFrame::PushGCFrame(AllocaInst *gcframe, unsigned NRoots, Instruction *InsertAfter) {
+    IRBuilder<> builder(gcframe->getContext());
+    builder.SetInsertPoint(&*(++BasicBlock::iterator(InsertAfter)));
+    Instruction *inst =
+        builder.CreateStore(ConstantInt::get(T_size, NRoots << 1),
+                          builder.CreateBitCast(builder.CreateConstGEP1_32(gcframe, 0), T_size->getPointerTo()));
+    inst->setMetadata(llvm::LLVMContext::MD_tbaa, tbaa_gcframe);
+    Value *pgcstack = builder.Insert(get_pgcstack(ptlsStates));
+    inst = builder.CreateStore(builder.CreateLoad(pgcstack),
+                               builder.CreatePointerCast(builder.CreateConstGEP1_32(gcframe, 1), PointerType::get(T_ppjlvalue,0)));
+    inst->setMetadata(llvm::LLVMContext::MD_tbaa, tbaa_gcframe);
+    builder.CreateStore(gcframe, builder.CreateBitCast(pgcstack,
+        PointerType::get(PointerType::get(T_prjlvalue, 0), 0)));
+}
+
+void LateLowerGCFrame::PopGCFrame(AllocaInst *gcframe, Instruction *InsertBefore) {
+    IRBuilder<> builder(InsertBefore->getContext());
+    builder.SetInsertPoint(InsertBefore); // set insert *before* Ret
+    Instruction *gcpop =
+        (Instruction*)builder.CreateConstGEP1_32(gcframe, 1);
+    Instruction *inst = builder.CreateLoad(gcpop);
+    inst->setMetadata(llvm::LLVMContext::MD_tbaa, tbaa_gcframe);
+    inst = builder.CreateStore(inst,
+                               builder.CreateBitCast(
+                                 builder.Insert(get_pgcstack(ptlsStates)),
+                                 PointerType::get(T_prjlvalue, 0)));
+    inst->setMetadata(llvm::LLVMContext::MD_tbaa, tbaa_gcframe);
+}
+
+static void copyMetadata(Instruction *dest, const Instruction *src)
+{
+#if JL_LLVM_VERSION < 40000
+    if (!src->hasMetadata())
+        return;
+    SmallVector<std::pair<unsigned,MDNode*>,4> TheMDs;
+    src->getAllMetadataOtherThanDebugLoc(TheMDs);
+    for (const auto &MD : TheMDs)
+        dest->setMetadata(MD.first, MD.second);
+    dest->setDebugLoc(src->getDebugLoc());
+#else
+    dest->copyMetadata(*src);
+#endif
+}
+
+bool LateLowerGCFrame::CleanupIR(Function &F) {
+    bool ChangesMade = false;
+    // We create one alloca for all the jlcall frames that haven't been processed
+    // yet. LLVM would merge them anyway later, so might as well save it a bit
+    // of work
+    size_t maxframeargs = 0;
+    Instruction *StartOff = &*(F.getEntryBlock().begin());
+    PointerType *T_pprjlvalue = nullptr;
+    AllocaInst *Frame = nullptr;
+    if (T_prjlvalue) {
+        T_pprjlvalue = T_prjlvalue->getPointerTo();
+        Frame = new AllocaInst(T_prjlvalue, ConstantInt::get(T_int32, maxframeargs),
+#if JL_LLVM_VERSION >= 50000
+        0,
+#endif
+        "", StartOff);
+    }
+    for (BasicBlock &BB : F) {
+        for (auto it = BB.begin(); it != BB.end();) {
+            auto *CI = dyn_cast<CallInst>(&*it);
+            if (!CI) {
+                ++it;
+                continue;
+            }
+            CallingConv::ID CC = CI->getCallingConv();
+            auto callee = CI->getCalledValue();
+            if (gc_flush_func != nullptr && callee == gc_flush_func) {
+                /* No replacement */
+            } else if (pointer_from_objref_func != nullptr && callee == pointer_from_objref_func) {
+                auto *ASCI = new AddrSpaceCastInst(CI->getOperand(0),
+                    CI->getType(), "", CI);
+                ASCI->takeName(CI);
+                CI->replaceAllUsesWith(ASCI);
+            } else if (alloc_obj_func && callee == alloc_obj_func) {
+                assert(CI->getNumArgOperands() == 3);
+                auto sz = (size_t)cast<ConstantInt>(CI->getArgOperand(1))->getZExtValue();
+                // This is strongly architecture and OS dependent
+                int osize;
+                int offset = jl_gc_classify_pools(sz, &osize);
+                IRBuilder<> builder(CI);
+                builder.SetCurrentDebugLocation(CI->getDebugLoc());
+                auto ptls = CI->getArgOperand(0);
+                CallInst *newI;
+                if (offset < 0) {
+                    newI = builder.CreateCall(big_alloc_func,
+                                              {ptls, ConstantInt::get(T_size,
+                                                                      sz + sizeof(void*))});
+                }
+                else {
+                    auto pool_offs = ConstantInt::get(T_int32, offset);
+                    auto pool_osize = ConstantInt::get(T_int32, osize);
+                    newI = builder.CreateCall(pool_alloc_func, {ptls, pool_offs, pool_osize});
+                }
+                newI->setAttributes(CI->getAttributes());
+                newI->takeName(CI);
+                copyMetadata(newI, CI);
+                auto derived = builder.CreateAddrSpaceCast(newI, T_pjlvalue_der);
+                auto cast = builder.CreateBitCast(derived, T_ppjlvalue_der);
+                auto tagaddr = builder.CreateGEP(T_prjlvalue, cast,
+                                                 ConstantInt::get(T_size, -1));
+                auto store = builder.CreateStore(CI->getArgOperand(2), tagaddr);
+                store->setMetadata(LLVMContext::MD_tbaa, tbaa_tag);
+                CI->replaceAllUsesWith(newI);
+            } else if (CC == JLCALL_CC ||
+                       CC == JLCALL_F_CC) {
+                assert(T_prjlvalue);
+                size_t nframeargs = CI->getNumArgOperands() - (CC == JLCALL_F_CC);
+                SmallVector<Value *, 3> ReplacementArgs;
+                auto it = CI->arg_begin();
+                if (CC == JLCALL_F_CC)
+                    ReplacementArgs.push_back(*(it++));
+                maxframeargs = std::max(maxframeargs, nframeargs);
+                int slot = 0;
+                IRBuilder<> Builder (CI);
+                for (; it != CI->arg_end(); ++it) {
+                    Builder.CreateStore(*it, Builder.CreateGEP(T_prjlvalue, Frame,
+                        ConstantInt::get(T_int32, slot++)));
+                }
+                ReplacementArgs.push_back(nframeargs == 0 ?
+                    (llvm::Value*)ConstantPointerNull::get(T_pprjlvalue) :
+                    (llvm::Value*)Frame);
+                ReplacementArgs.push_back(ConstantInt::get(T_int32, nframeargs));
+                FunctionType *FTy = CC == JLCALL_F_CC ?
+                    FunctionType::get(T_prjlvalue, {T_prjlvalue,
+                        T_pprjlvalue, T_int32}, false) :
+                    FunctionType::get(T_prjlvalue,
+                        {T_pprjlvalue, T_int32}, false);
+                Value *newFptr = Builder.CreateBitCast(callee, FTy->getPointerTo());
+                CallInst *NewCall = CallInst::Create(newFptr, ReplacementArgs, "", CI);
+                NewCall->setTailCallKind(CI->getTailCallKind());
+                NewCall->setAttributes(CI->getAttributes());
+                NewCall->setDebugLoc(CI->getDebugLoc());
+                CI->replaceAllUsesWith(NewCall);
+            } else if (CI->getNumArgOperands() == CI->getNumOperands()) {
+                /* No operand bundle to lower */
+                ++it;
+                continue;
+            } else {
+                CallInst *NewCall = CallInst::Create(CI, None, CI);
+                NewCall->takeName(CI);
+                CI->replaceAllUsesWith(NewCall);
+            }
+            it = CI->eraseFromParent();
+            ChangesMade = true;
+        }
+    }
+    if (maxframeargs == 0 && Frame) {
+        Frame->eraseFromParent();
+    }
+    else if (Frame) {
+        Frame->setOperand(0, ConstantInt::get(T_int32, maxframeargs));
+    }
+    return ChangesMade;
+}
+
+static Value *GetPtrForNumber(State &S, unsigned Num, Instruction *InsertionPoint)
+{
+    Value *Val = S.ReversePtrNumbering[Num];
+    if (isSpecialPtrVec(Val->getType())) {
+        const std::vector<int> &AllNums = S.AllVectorNumbering[Val];
+        unsigned Idx = 0;
+        for (; Idx < AllNums.size(); ++Idx) {
+            if ((unsigned)AllNums[Idx] == Num)
+                break;
+        }
+        Val = ExtractElementInst::Create(Val, ConstantInt::get(
+            Type::getInt32Ty(Val->getContext()), Idx), "", InsertionPoint);
+    }
+    return Val;
+}
+
+static void AddInPredLiveOuts(BasicBlock *BB, BitVector &LiveIn, State &S)
+{
+    bool First = true;
+    std::set<BasicBlock *> Visited;
+    std::vector<BasicBlock *> WorkList;
+    WorkList.push_back(BB);
+    while (!WorkList.empty()) {
+        BB = &*WorkList.back();
+        WorkList.pop_back();
+        for (BasicBlock *Pred : predecessors(BB)) {
+            if (!Visited.insert(Pred).second)
+                continue;
+            if (!S.BBStates[Pred].HasSafepoint) {
+                WorkList.push_back(Pred);
+                continue;
+            } else {
+                int LastSP = S.BBStates[Pred].Safepoints.front();
+                if (First) {
+                    LiveIn |= S.LiveSets[LastSP];
+                    First = false;
+                } else {
+                    LiveIn &= S.LiveSets[LastSP];
+                }
+            }
+        }
+    }
+}
+
+void LateLowerGCFrame::PlaceGCFrameStore(State &S, unsigned R, unsigned MinColorRoot,
+                                         const std::vector<int> &Colors, Value *GCFrame,
+                                         Instruction *InsertionPoint) {
+    Value *Val = GetPtrForNumber(S, R, InsertionPoint);
+    Value *args[1] = {
+        ConstantInt::get(T_int32, Colors[R]+MinColorRoot)
+    };
+    GetElementPtrInst *gep = GetElementPtrInst::Create(T_prjlvalue, GCFrame, makeArrayRef(args));
+    gep->insertBefore(InsertionPoint);
+    Val = MaybeExtractUnion(Val, InsertionPoint);
+    // Pointee types don't have semantics, so the optimizer is
+    // free to rewrite them if convenient. We need to change
+    // it back here for the store.
+    if (Val->getType() != T_prjlvalue)
+        Val = new BitCastInst(Val, T_prjlvalue, "", InsertionPoint);
+    new StoreInst(Val, gep, InsertionPoint);
+}
+
+void LateLowerGCFrame::PlaceGCFrameStores(Function &F, State &S, unsigned MinColorRoot,
+                                          const std::vector<int> &Colors, Value *GCFrame)
+{
+    for (auto &BB : F) {
+        const BBState &BBS = S.BBStates[&BB];
+        if (!BBS.HasSafepoint) {
+            continue;
+        }
+        BitVector LiveIn;
+        AddInPredLiveOuts(&BB, LiveIn, S);
+        const BitVector *LastLive = &LiveIn;
+        for(auto rit = BBS.Safepoints.rbegin();
+              rit != BBS.Safepoints.rend(); ++rit ) {
+            const BitVector &NowLive = S.LiveSets[*rit];
+            for (int Idx = NowLive.find_first(); Idx >= 0; Idx = NowLive.find_next(Idx)) {
+                if (!HasBitSet(*LastLive, Idx)) {
+                    PlaceGCFrameStore(S, Idx, MinColorRoot, Colors, GCFrame,
+                      S.ReverseSafepointNumbering[*rit]);
+                }
+            }
+            LastLive = &NowLive;
+        }
+    }
+}
+
+void LateLowerGCFrame::PlaceRootsAndUpdateCalls(Function &F, std::vector<int> &Colors, State &S, std::map<Value *, std::pair<int, int>>) {
+    int MaxColor = -1;
+    for (auto C : Colors)
+        if (C > MaxColor)
+            MaxColor = C;
+    // Insert instructions for the actual gc frame
+    if (MaxColor != -1 || S.Allocas.size() != 0) {
+        unsigned NRoots = MaxColor + 1 + S.Allocas.size();
+        // Create GC Frame
+        AllocaInst *gcframe = new AllocaInst(T_prjlvalue,
+#if JL_LLVM_VERSION >= 50000
+           0,
+#endif
+        ConstantInt::get(T_int32, NRoots+2), "gcframe");
+        gcframe->insertBefore(&*F.getEntryBlock().begin());
+        // Zero out gcframe
+        BitCastInst *tempSlot_i8 = new BitCastInst(gcframe, Type::getInt8PtrTy(F.getContext()), "");
+        tempSlot_i8->insertAfter(gcframe);
+        Type *argsT[2] = {tempSlot_i8->getType(), T_int32};
+        Function *memset = Intrinsic::getDeclaration(F.getParent(), Intrinsic::memset, makeArrayRef(argsT));
+        Value *args[5] = {
+            tempSlot_i8, // dest
+            ConstantInt::get(Type::getInt8Ty(F.getContext()), 0), // val
+            ConstantInt::get(T_int32, sizeof(jl_value_t*)*(NRoots+2)), // len
+            ConstantInt::get(T_int32, 0), // align
+            ConstantInt::get(Type::getInt1Ty(F.getContext()), 0)}; // volatile
+        CallInst *zeroing = CallInst::Create(memset, makeArrayRef(args));
+        zeroing->setMetadata(llvm::LLVMContext::MD_tbaa, tbaa_gcframe);
+        zeroing->insertAfter(tempSlot_i8);
+        // Push GC Frame
+        PushGCFrame(gcframe, NRoots, ptlsStates);
+        // Replace Allocas
+        unsigned AllocaSlot = 2;
+        for (AllocaInst *AI : S.Allocas) {
+            Value *args[1] = {
+                ConstantInt::get(T_int32, AllocaSlot++)
+            };
+            GetElementPtrInst *gep = GetElementPtrInst::Create(T_prjlvalue, gcframe, makeArrayRef(args));
+            gep->insertAfter(gcframe);
+            gep->takeName(AI);
+            // Check for lifetime intrinsics on this alloca, we can't keep them
+            // because we're changing the semantics
+            std::vector<CallInst*> ToDelete;
+            RecursivelyVisit<IntrinsicInst>([&](Use &VU) {
+                IntrinsicInst *II = cast<IntrinsicInst>(VU.getUser());
+                if ((II->getIntrinsicID() != Intrinsic::lifetime_start &&
+                            II->getIntrinsicID() != Intrinsic::lifetime_end))
+                    return;
+                ToDelete.push_back(II);
+            }, AI);
+            for (CallInst *II : ToDelete)
+                II->eraseFromParent();
+            AI->replaceAllUsesWith(gep);
+            AI->eraseFromParent();
+        }
+        unsigned MinColorRoot = AllocaSlot;
+        // Insert GC frame stores
+        PlaceGCFrameStores(F, S, MinColorRoot, Colors, gcframe);
+        // Insert GCFrame pops
+        for(Function::iterator I = F.begin(), E = F.end(); I != E; ++I) {
+            if (isa<ReturnInst>(I->getTerminator())) {
+                PopGCFrame(gcframe, I->getTerminator());
+            }
+        }
+    }
+}
+
+static void addRetNoAlias(Function *F)
+{
+#if JL_LLVM_VERSION >= 50000
+    F->addAttribute(AttributeList::ReturnIndex, Attribute::NoAlias);
+#else
+    F->addAttribute(AttributeSet::ReturnIndex, Attribute::NoAlias);
+#endif
+}
+
+bool LateLowerGCFrame::doInitialization(Module &M) {
+    ptls_getter = M.getFunction("jl_get_ptls_states");
+    gc_flush_func = M.getFunction("julia.gcroot_flush");
+    pointer_from_objref_func = M.getFunction("julia.pointer_from_objref");
+    auto &ctx = M.getContext();
+    T_size = M.getDataLayout().getIntPtrType(ctx);
+    T_int8 = Type::getInt8Ty(ctx);
+    T_pint8 = PointerType::get(T_int8, 0);
+    T_int32 = Type::getInt32Ty(ctx);
+    if ((alloc_obj_func = M.getFunction("julia.gc_alloc_obj"))) {
+        T_prjlvalue = alloc_obj_func->getReturnType();
+        if (!(pool_alloc_func = M.getFunction("jl_gc_pool_alloc"))) {
+            std::vector<Type*> args(0);
+            args.push_back(T_pint8);
+            args.push_back(T_int32);
+            args.push_back(T_int32);
+            pool_alloc_func = Function::Create(FunctionType::get(T_prjlvalue, args, false),
+                                               Function::ExternalLinkage, "jl_gc_pool_alloc", &M);
+            addRetNoAlias(pool_alloc_func);
+        }
+        if (!(big_alloc_func = M.getFunction("jl_gc_big_alloc"))) {
+            std::vector<Type*> args(0);
+            args.push_back(T_pint8);
+            args.push_back(T_size);
+            big_alloc_func = Function::Create(FunctionType::get(T_prjlvalue, args, false),
+                                         Function::ExternalLinkage, "jl_gc_big_alloc", &M);
+            addRetNoAlias(big_alloc_func);
+        }
+        auto T_jlvalue = cast<PointerType>(T_prjlvalue)->getElementType();
+        auto T_pjlvalue = PointerType::get(T_jlvalue, 0);
+        T_ppjlvalue = PointerType::get(T_pjlvalue, 0);
+        T_pjlvalue_der = PointerType::get(T_jlvalue, AddressSpace::Derived);
+        T_ppjlvalue_der = PointerType::get(T_prjlvalue, AddressSpace::Derived);
+    }
+    else if (ptls_getter) {
+        auto functype = ptls_getter->getFunctionType();
+        T_ppjlvalue = cast<PointerType>(functype->getReturnType())->getElementType();
+        auto T_pjlvalue = cast<PointerType>(T_ppjlvalue)->getElementType();
+        auto T_jlvalue = cast<PointerType>(T_pjlvalue)->getElementType();
+        T_prjlvalue = PointerType::get(T_jlvalue, AddressSpace::Tracked);
+        T_pjlvalue_der = PointerType::get(T_jlvalue, AddressSpace::Derived);
+        T_ppjlvalue_der = PointerType::get(T_prjlvalue, AddressSpace::Derived);
+    }
+    else {
+        T_ppjlvalue = nullptr;
+        T_prjlvalue = nullptr;
+        T_pjlvalue_der = nullptr;
+        T_ppjlvalue_der = nullptr;
+    }
+    return false;
+}
+
+bool LateLowerGCFrame::runOnFunction(Function &F) {
+    DEBUG(dbgs() << "GC ROOT PLACEMENT: Processing function " << F.getName() << "\n");
+    if (!ptls_getter)
+        return CleanupIR(F);
+    ptlsStates = nullptr;
+    for (auto I = F.getEntryBlock().begin(), E = F.getEntryBlock().end();
+         ptls_getter && I != E; ++I) {
+        if (CallInst *callInst = dyn_cast<CallInst>(&*I)) {
+            if (callInst->getCalledValue() == ptls_getter) {
+                ptlsStates = callInst;
+                break;
+            }
+        }
+    }
+    if (!ptlsStates)
+        return CleanupIR(F);
+    State S = LocalScan(F);
+    ComputeLiveness(F, S);
+    std::vector<int> Colors = ColorRoots(S);
+    std::map<Value *, std::pair<int, int>> CallFrames; // = OptimizeCallFrames(S, Ordering);
+    PlaceRootsAndUpdateCalls(F, Colors, S, CallFrames);
+    CleanupIR(F);
+    return true;
+}
+
+char LateLowerGCFrame::ID = 0;
+static RegisterPass<LateLowerGCFrame> X("LateLowerGCFrame", "Late Lower GCFrame Pass", false, false);
+
+Pass *createLateLowerGCFramePass() {
+    return new LateLowerGCFrame();
+}
diff --git a/src/llvm-lower-handlers.cpp b/src/llvm-lower-handlers.cpp
new file mode 100644
index 00000000000000..4ef6f15a02aa53
--- /dev/null
+++ b/src/llvm-lower-handlers.cpp
@@ -0,0 +1,248 @@
+// This file is a part of Julia. License is MIT: https://julialang.org/license
+
+#include <assert.h>
+#include <llvm/ADT/DepthFirstIterator.h>
+#include <llvm/Analysis/CFG.h>
+#include <llvm/IR/Value.h>
+#include <llvm/IR/Constants.h>
+#include <llvm/IR/Function.h>
+#include <llvm/IR/Instructions.h>
+#include <llvm/IR/IntrinsicInst.h>
+#include <llvm/IR/Module.h>
+#include <llvm/Pass.h>
+#include <llvm/Support/Debug.h>
+
+#include "llvm-version.h"
+#include "julia.h"
+
+#define DEBUG_TYPE "lower_handlers"
+#undef DEBUG
+
+using namespace llvm;
+
+/* Lowers Julia Exception Handlers and colors EH frames.
+ *
+ *  Our task is to lower:
+ * call void @julia.except_enter()
+ * <...>
+ * call void jl_pop_handler(1)
+ *
+ * to
+ *
+ * call void @jl_enter_handler(jl_handler *%buff)
+ * <...>
+ * call void jl_pop_handler(1)
+ *
+ * Where buff is an appropriate stack slot handler.
+ *
+ * We make the following assumptions:
+ *  - All EH frames are completely nested.
+ *  - The exception nestedness of a BB is not dynamic. I.e. we don't allow
+ *    the following:
+ *                br i1 %cond, %left, %right
+ *                  /                \
+ *           except.enter         br mid
+ *           br mid                  |
+ *                 \                 /
+ *              br i1 %cond, %left2, %right2
+ *                 /                 \
+ *           jl_pop_hander          ret
+ *           ret
+ *
+ *    The frontend doesn't emit structures like this. However, the optimizer
+ *    could easily introduce them, so this pass should run early after IRGen.
+ *
+ * Because of these assumptions, the algorithm is very simple. We simply label
+ * the handler depth at every basic block using a DFS search. For each enter
+ * we encounter, we record the current depth and then allocate an exception
+ * handler frame for every level.
+ *
+ * As an additional optimization, we also insert lifetime intrinsics for the
+ * handler structures to tell LLVM that it is free to re-use the stack slot
+ * while the handler is not being used.
+ */
+struct LowerExcHandlers : public FunctionPass {
+    static char ID;
+    LowerExcHandlers() : FunctionPass(ID)
+    {}
+
+private:
+    Function *except_enter_func;
+    Function *leave_func;
+    Function *jlenter_func;
+    Function *setjmp_func;
+    Function *lifetime_start;
+    Function *lifetime_end;
+
+    bool doInitialization(Module &M) override;
+    bool runOnFunction(Function &F) override;
+};
+
+/*
+ * If the module doesn't have declarations for the jl_enter_handler and setjmp
+ * functions, insert them.
+ */
+static void ensure_enter_function(Module &M)
+{
+    auto T_int8  = Type::getInt8Ty(M.getContext());
+    auto T_pint8 = PointerType::get(T_int8, 0);
+    auto T_void = Type::getVoidTy(M.getContext());
+    auto T_int32 = Type::getInt32Ty(M.getContext());
+    if (!M.getNamedValue("jl_enter_handler")) {
+        std::vector<Type*> ehargs(0);
+        ehargs.push_back(T_pint8);
+        Function::Create(FunctionType::get(T_void, ehargs, false),
+                         Function::ExternalLinkage, "jl_enter_handler", &M);
+    }
+    if (!M.getNamedValue(jl_setjmp_name)) {
+        std::vector<Type*> args2(0);
+        args2.push_back(T_pint8);
+#ifndef _OS_WINDOWS_
+        args2.push_back(T_int32);
+#endif
+        Function::Create(FunctionType::get(T_int32, args2, false),
+                         Function::ExternalLinkage, jl_setjmp_name, &M)
+            ->addFnAttr(Attribute::ReturnsTwice);
+    }
+}
+
+bool LowerExcHandlers::doInitialization(Module &M) {
+    except_enter_func = M.getFunction("julia.except_enter");
+    if (!except_enter_func)
+        return false;
+    ensure_enter_function(M);
+    leave_func = M.getFunction("jl_pop_handler");
+    jlenter_func = M.getFunction("jl_enter_handler");
+    setjmp_func = M.getFunction(jl_setjmp_name);
+
+#if JL_LLVM_VERSION >= 50000
+    auto T_pint8 = Type::getInt8PtrTy(M.getContext(), 0);
+    lifetime_start = Intrinsic::getDeclaration(&M, Intrinsic::lifetime_start, { T_pint8 });
+    lifetime_end = Intrinsic::getDeclaration(&M, Intrinsic::lifetime_end, { T_pint8 });
+#else
+    lifetime_start = Intrinsic::getDeclaration(&M, Intrinsic::lifetime_start);
+    lifetime_end = Intrinsic::getDeclaration(&M, Intrinsic::lifetime_end);
+#endif
+    return true;
+}
+
+bool LowerExcHandlers::runOnFunction(Function &F) {
+    if (!except_enter_func)
+        return false; // No EH frames in this module
+
+    /* Step 1: EH Depth Numbering */
+    std::map<llvm::CallInst *, int> EnterDepth;
+    std::map<llvm::CallInst *, int> LeaveDepth;
+    std::map<BasicBlock *, int> ExitDepth;
+    int MaxDepth = 0;
+    // Compute EH Depth at each basic block using a DFS traversal.
+    for (df_iterator<BasicBlock *> I = df_begin(&F.getEntryBlock()),
+            E = df_end(&F.getEntryBlock()); I != E; ++I) {
+        auto *BB = *I;
+        int Depth = 0;
+        /* Here we use the assumption that all incoming edges have the same
+         * EH depth.
+         */
+        for (auto *Pred : predecessors(BB)) {
+            auto it = ExitDepth.find(Pred);
+            if (it != ExitDepth.end()) {
+                Depth = it->second;
+                break;
+            }
+        }
+        /* Compute the depth within the basic block */
+        for (auto &I : *BB) {
+            auto *CI = dyn_cast<CallInst>(&I);
+            if (!CI)
+                continue;
+            Function *Callee = CI->getCalledFunction();
+            if (!Callee)
+                continue;
+            if (Callee == except_enter_func)
+                EnterDepth[CI] = Depth++;
+            else if (Callee == leave_func) {
+                LeaveDepth[CI] = Depth;
+                Depth -= cast<ConstantInt>(CI->getArgOperand(0))->getLimitedValue();
+            }
+            assert(Depth >= 0);
+            if (Depth > MaxDepth)
+                MaxDepth = Depth;
+        }
+        /* Remember the depth at the BB boundary */
+        ExitDepth[BB] = Depth;
+    }
+
+    /* Step 2: EH Frame lowering */
+    // Allocate stack space for each handler. We allocate these as separate
+    // allocas so the optimizer can later merge and reaarange them if it wants
+    // to.
+    Value *handler_sz = ConstantInt::get(Type::getInt32Ty(F.getContext()),
+                                         sizeof(jl_handler_t));
+    Value *handler_sz64 = ConstantInt::get(Type::getInt64Ty(F.getContext()),
+                                           sizeof(jl_handler_t));
+    Instruction *firstInst = &F.getEntryBlock().front();
+    std::vector<AllocaInst *> buffs;
+    for (int i = 0; i < MaxDepth; ++i) {
+        auto *buff = new AllocaInst(Type::getInt8Ty(F.getContext()),
+#if JL_LLVM_VERSION >= 50000
+                                       0,
+#endif
+                                       handler_sz, "", firstInst);
+        buff->setAlignment(16);
+        buffs.push_back(buff);
+    }
+
+    // Lower enter funcs
+    for (auto it : EnterDepth) {
+        assert(it.second >= 0);
+        AllocaInst *buff = buffs[it.second];
+        CallInst *enter = it.first;
+        auto new_enter = CallInst::Create(jlenter_func, buff, "", enter);
+        Value *lifetime_args[] = {
+            handler_sz64,
+            buff
+        };
+        CallInst::Create(lifetime_start, lifetime_args, "", new_enter);
+#ifndef _OS_WINDOWS_
+        // For LLVM 3.3 compatibility
+        Value *args[] = {buff,
+                         ConstantInt::get(Type::getInt32Ty(F.getContext()), 0)};
+        auto sj = CallInst::Create(setjmp_func, args, "", enter);
+#else
+        auto sj = CallInst::Create(setjmp_func, buff, "", enter);
+#endif
+        // We need to mark this on the call site as well. See issue #6757
+        sj->setCanReturnTwice();
+        if (auto dbg = enter->getMetadata(LLVMContext::MD_dbg)) {
+            new_enter->setMetadata(LLVMContext::MD_dbg, dbg);
+            sj->setMetadata(LLVMContext::MD_dbg, dbg);
+        }
+        enter->replaceAllUsesWith(sj);
+        enter->eraseFromParent();
+    }
+    // Insert lifetime end intrinsics after every leave.
+    for (auto it : LeaveDepth) {
+        int StartDepth = it.second - 1;
+        int npops = cast<ConstantInt>(it.first->getArgOperand(0))->getLimitedValue();
+        for (int i = 0; i < npops; ++i) {
+            assert(StartDepth-i >= 0);
+            Value *lifetime_args[] = {
+                handler_sz64,
+                buffs[StartDepth-i]
+            };
+            auto LifetimeEnd = CallInst::Create(lifetime_end, lifetime_args);
+            LifetimeEnd->insertAfter(it.first);
+        }
+    }
+    return true;
+}
+
+char LowerExcHandlers::ID = 0;
+static RegisterPass<LowerExcHandlers> X("LowerExcHandlers", "Lower Julia Exception Handlers",
+                                         false /* Only looks at CFG */,
+                                         false /* Analysis Pass */);
+
+Pass *createLowerExcHandlersPass()
+{
+    return new LowerExcHandlers();
+}
diff --git a/src/llvm-muladd.cpp b/src/llvm-muladd.cpp
new file mode 100644
index 00000000000000..267efa0749dc71
--- /dev/null
+++ b/src/llvm-muladd.cpp
@@ -0,0 +1,123 @@
+// This file is a part of Julia. License is MIT: https://julialang.org/license
+
+#define DEBUG_TYPE "combine_muladd"
+#undef DEBUG
+#include "llvm-version.h"
+
+#include <llvm/IR/Value.h>
+#include <llvm/IR/Function.h>
+#include <llvm/IR/Instructions.h>
+#include <llvm/IR/IntrinsicInst.h>
+#include <llvm/IR/Module.h>
+#include <llvm/IR/Operator.h>
+#include <llvm/IR/IRBuilder.h>
+#include <llvm/Pass.h>
+#include <llvm/Support/Debug.h>
+#include "fix_llvm_assert.h"
+
+#include "julia.h"
+
+using namespace llvm;
+
+/**
+ * Combine
+ * ```
+ * %v0 = fmul ... %a, %b
+ * %v = fadd fast ... %v0, %c
+ * ```
+ * to
+ * `%v = call fast @llvm.fmuladd.<...>(... %a, ... %b, ... %c)`
+ * when `%v0` has no other use
+ */
+
+struct CombineMulAdd : public FunctionPass {
+    static char ID;
+    CombineMulAdd() : FunctionPass(ID)
+    {}
+
+private:
+    bool runOnFunction(Function &F) override;
+};
+
+// Return true if this function shouldn't be called again on the other operand
+// This will always return false on LLVM 5.0+
+static bool checkCombine(Module *m, Instruction *addOp, Value *maybeMul, Value *addend,
+                         bool negadd, bool negres)
+{
+    auto mulOp = dyn_cast<Instruction>(maybeMul);
+    if (!mulOp || mulOp->getOpcode() != Instruction::FMul)
+        return false;
+    if (!mulOp->hasOneUse())
+        return false;
+#if JL_LLVM_VERSION >= 50000
+    // On 5.0+ we only need to mark the mulOp as contract and the backend will do the work for us.
+    auto fmf = mulOp->getFastMathFlags();
+    fmf.setAllowContract(true);
+    mulOp->copyFastMathFlags(fmf);
+    return false;
+#else
+    IRBuilder<> builder(m->getContext());
+    builder.SetInsertPoint(addOp);
+    auto mul1 = mulOp->getOperand(0);
+    auto mul2 = mulOp->getOperand(1);
+    Value *muladdf = Intrinsic::getDeclaration(m, Intrinsic::fmuladd, addOp->getType());
+    if (negadd) {
+        auto newaddend = builder.CreateFNeg(addend);
+        // Might be a const
+        if (auto neginst = dyn_cast<Instruction>(newaddend))
+            neginst->setHasUnsafeAlgebra(true);
+        addend = newaddend;
+    }
+    Instruction *newv = builder.CreateCall(muladdf, {mul1, mul2, addend});
+    newv->setHasUnsafeAlgebra(true);
+    if (negres) {
+        // Shouldn't be a constant
+        newv = cast<Instruction>(builder.CreateFNeg(newv));
+        newv->setHasUnsafeAlgebra(true);
+    }
+    addOp->replaceAllUsesWith(newv);
+    addOp->eraseFromParent();
+    mulOp->eraseFromParent();
+    return true;
+#endif
+}
+
+bool CombineMulAdd::runOnFunction(Function &F)
+{
+    Module *m = F.getParent();
+    for (auto &BB: F) {
+        for (auto it = BB.begin(); it != BB.end();) {
+            auto &I = *it;
+            it++;
+            switch (I.getOpcode()) {
+            case Instruction::FAdd: {
+                if (!I.hasUnsafeAlgebra())
+                    continue;
+                checkCombine(m, &I, I.getOperand(0), I.getOperand(1), false, false) ||
+                    checkCombine(m, &I, I.getOperand(1), I.getOperand(0), false, false);
+                break;
+            }
+            case Instruction::FSub: {
+                if (!I.hasUnsafeAlgebra())
+                    continue;
+                checkCombine(m, &I, I.getOperand(0), I.getOperand(1), true, false) ||
+                    checkCombine(m, &I, I.getOperand(1), I.getOperand(0), true, true);
+                break;
+            }
+            default:
+                break;
+            }
+        }
+    }
+    return true;
+}
+
+char CombineMulAdd::ID = 0;
+static RegisterPass<CombineMulAdd> X("CombineMulAdd", "Combine mul and add to muladd",
+                                     false /* Only looks at CFG */,
+                                     false /* Analysis Pass */);
+
+Pass *createCombineMulAddPass()
+{
+    return new CombineMulAdd();
+}
diff --git a/src/llvm-propagate-addrspaces.cpp b/src/llvm-propagate-addrspaces.cpp
new file mode 100644
index 00000000000000..6e6d4a5f3032d2
--- /dev/null
+++ b/src/llvm-propagate-addrspaces.cpp
@@ -0,0 +1,205 @@
+// This file is a part of Julia. License is MIT: https://julialang.org/license
+
+#include <llvm/ADT/SmallPtrSet.h>
+#include <llvm/Analysis/CFG.h>
+#include <llvm/IR/Value.h>
+#include <llvm/IR/ValueMap.h>
+#include <llvm/IR/Constants.h>
+#include <llvm/IR/Dominators.h>
+#include <llvm/IR/Function.h>
+#include <llvm/IR/Instructions.h>
+#include <llvm/IR/IntrinsicInst.h>
+#include <llvm/IR/InstVisitor.h>
+#include <llvm/IR/CallSite.h>
+#include <llvm/IR/Module.h>
+#include <llvm/IR/IRBuilder.h>
+#include <llvm/IR/Verifier.h>
+#include <llvm/Pass.h>
+#include <llvm/Support/Debug.h>
+
+#include "llvm-version.h"
+#include "codegen_shared.h"
+#include "julia.h"
+
+#define DEBUG_TYPE "propagate_julia_addrspaces"
+
+using namespace llvm;
+
+/* This pass performs propagation of addrspace information that is legal from
+   the frontend definition, but illegal by general IR semantics. In particular,
+   this includes:
+      - Changing the address space of a load/store if the base pointer is
+        in an untracked address space
+      - Commuting GEPs and addrspace casts
+
+    This is most useful for removing superflous casts that can inhibit LLVM
+    optimizations.
+*/
+
+struct PropagateJuliaAddrspaces : public FunctionPass, public InstVisitor<PropagateJuliaAddrspaces> {
+    static char ID;
+    DenseMap<Value *, Value *> LiftingMap;
+    SmallPtrSet<Value *, 4> Visited;
+    std::vector<Instruction *> ToDelete;
+    std::vector<std::pair<Instruction *, Instruction *>> ToInsert;
+    PropagateJuliaAddrspaces() : FunctionPass(ID) {};
+
+public:
+    bool runOnFunction(Function &F) override;
+    Value *LiftPointer(Value *V, Type *LocTy = nullptr, Instruction *InsertPt=nullptr);
+    void visitStoreInst(StoreInst &SI);
+    void visitLoadInst(LoadInst &LI);
+    void visitMemSetInst(MemSetInst &MI);
+    void visitMemTransferInst(MemTransferInst &MTI);
+};
+
+bool PropagateJuliaAddrspaces::runOnFunction(Function &F) {
+    visit(F);
+    for (auto it : ToInsert)
+        it.first->insertBefore(it.second);
+    for (Instruction *I : ToDelete)
+        I->eraseFromParent();
+    ToInsert.clear();
+    ToDelete.clear();
+    LiftingMap.clear();
+    Visited.clear();
+    return true;
+}
+
+static unsigned getValueAddrSpace(Value *V) {
+    return cast<PointerType>(V->getType())->getAddressSpace();
+}
+
+static bool isSpecialAS(unsigned AS) {
+    return AddressSpace::FirstSpecial <= AS && AS <= AddressSpace::LastSpecial;
+}
+
+Value *PropagateJuliaAddrspaces::LiftPointer(Value *V, Type *LocTy, Instruction *InsertPt) {
+    SmallVector<Value *, 4> Stack;
+    Value *CurrentV = V;
+    // Follow pointer casts back, see if we're based on a pointer in
+    // an untracked address space, in which case we're allowed to drop
+    // intermediate addrspace casts.
+    while (true) {
+        Stack.push_back(CurrentV);
+        if (isa<BitCastInst>(CurrentV))
+            CurrentV = cast<BitCastInst>(CurrentV)->getOperand(0);
+        else if (isa<AddrSpaceCastInst>(CurrentV)) {
+            CurrentV = cast<AddrSpaceCastInst>(CurrentV)->getOperand(0);
+            if (!isSpecialAS(getValueAddrSpace(CurrentV)))
+                break;
+        }
+        else if (isa<GetElementPtrInst>(CurrentV)) {
+            if (LiftingMap.count(CurrentV)) {
+                CurrentV = LiftingMap[CurrentV];
+                break;
+            } else if (Visited.count(CurrentV)) {
+                return nullptr;
+            }
+            Visited.insert(CurrentV);
+            CurrentV = cast<GetElementPtrInst>(CurrentV)->getOperand(0);
+        } else
+            break;
+    }
+    if (!CurrentV->getType()->isPointerTy())
+        return nullptr;
+    if (isSpecialAS(getValueAddrSpace(CurrentV)))
+        return nullptr;
+    // Ok, we're allowed to change the address space of this load, go back and
+    // reconstitute any GEPs in the new address space.
+    for (Value *V : llvm::reverse(Stack)) {
+        GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(V);
+        if (!GEP)
+            continue;
+        if (LiftingMap.count(GEP)) {
+            CurrentV = LiftingMap[GEP];
+            continue;
+        }
+        GetElementPtrInst *NewGEP = cast<GetElementPtrInst>(GEP->clone());
+        ToInsert.push_back(std::make_pair(NewGEP, GEP));
+        Type *GEPTy = GEP->getSourceElementType();
+        Type *NewRetTy = cast<PointerType>(GEP->getType())->getElementType()->getPointerTo(getValueAddrSpace(CurrentV));
+        NewGEP->mutateType(NewRetTy);
+        if (cast<PointerType>(CurrentV->getType())->getElementType() != GEPTy) {
+            auto *BCI = new BitCastInst(CurrentV, GEPTy->getPointerTo());
+            ToInsert.push_back(std::make_pair(BCI, NewGEP));
+            CurrentV = BCI;
+        }
+        NewGEP->setOperand(GetElementPtrInst::getPointerOperandIndex(), CurrentV);
+        LiftingMap[GEP] = NewGEP;
+        CurrentV = NewGEP;
+    }
+    if (LocTy && cast<PointerType>(CurrentV->getType())->getElementType() != LocTy) {
+        auto *BCI = new BitCastInst(CurrentV, LocTy->getPointerTo());
+        ToInsert.push_back(std::make_pair(BCI, InsertPt));
+        CurrentV = BCI;
+    }
+    return CurrentV;
+}
+
+void PropagateJuliaAddrspaces::visitLoadInst(LoadInst &LI) {
+    unsigned AS = LI.getPointerAddressSpace();
+    if (!isSpecialAS(AS))
+        return;
+    Value *Replacement = LiftPointer(LI.getPointerOperand(), LI.getType(), &LI);
+    if (!Replacement)
+        return;
+    LI.setOperand(LoadInst::getPointerOperandIndex(), Replacement);
+}
+
+void PropagateJuliaAddrspaces::visitStoreInst(StoreInst &SI) {
+    unsigned AS = SI.getPointerAddressSpace();
+    if (!isSpecialAS(AS))
+        return;
+    Value *Replacement = LiftPointer(SI.getPointerOperand(), SI.getValueOperand()->getType(), &SI);
+    if (!Replacement)
+        return;
+    SI.setOperand(StoreInst::getPointerOperandIndex(), Replacement);
+}
+
+void PropagateJuliaAddrspaces::visitMemSetInst(MemSetInst &MI) {
+    unsigned AS = MI.getDestAddressSpace();
+    if (!isSpecialAS(AS))
+        return;
+    Value *Replacement = LiftPointer(MI.getRawDest());
+    if (!Replacement)
+        return;
+    Value *TheFn = Intrinsic::getDeclaration(MI.getModule(), Intrinsic::memset,
+        {Replacement->getType(), MI.getOperand(1)->getType()});
+    MI.setCalledFunction(TheFn);
+    MI.setArgOperand(0, Replacement);
+}
+
+void PropagateJuliaAddrspaces::visitMemTransferInst(MemTransferInst &MTI) {
+    unsigned DestAS = MTI.getDestAddressSpace();
+    unsigned SrcAS = MTI.getSourceAddressSpace();
+    if (!isSpecialAS(DestAS) && !isSpecialAS(SrcAS))
+        return;
+    Value *Dest = MTI.getRawDest();
+    if (isSpecialAS(DestAS)) {
+        Value *Replacement = LiftPointer(Dest, cast<PointerType>(Dest->getType())->getElementType(), &MTI);
+        if (Replacement)
+            Dest = Replacement;
+    }
+    Value *Src = MTI.getRawSource();
+    if (isSpecialAS(SrcAS)) {
+        Value *Replacement = LiftPointer(Src, cast<PointerType>(Src->getType())->getElementType(), &MTI);
+        if (Replacement)
+            Src = Replacement;
+    }
+    if (Dest == MTI.getRawDest() && Src == MTI.getRawSource())
+        return;
+    Value *TheFn = Intrinsic::getDeclaration(MTI.getModule(), MTI.getIntrinsicID(),
+        {Dest->getType(), Src->getType(),
+         MTI.getOperand(2)->getType()});
+    MTI.setCalledFunction(TheFn);
+    MTI.setArgOperand(0, Dest);
+    MTI.setArgOperand(1, Src);
+}
+
+char PropagateJuliaAddrspaces::ID = 0;
+static RegisterPass<PropagateJuliaAddrspaces> X("PropagateJuliaAddrspaces", "Propagate (non-)rootedness information", false, false);
+
+Pass *createPropagateJuliaAddrspaces() {
+    return new PropagateJuliaAddrspaces();
+}
diff --git a/src/llvm-ptls.cpp b/src/llvm-ptls.cpp
index 8e88d05460da38..391b3096b08e97 100644
--- a/src/llvm-ptls.cpp
+++ b/src/llvm-ptls.cpp
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #define DEBUG_TYPE "lower_ptls"
 #undef DEBUG
@@ -15,19 +15,16 @@
 #include <llvm/IR/Instructions.h>
 #include <llvm/IR/Constants.h>
 #include <llvm/IR/LLVMContext.h>
-#if JL_LLVM_VERSION >= 30700
-#include <llvm/IR/LegacyPassManager.h>
-#else
-#include <llvm/PassManager.h>
-#endif
 #include <llvm/IR/MDBuilder.h>
 
-#include "julia.h"
-#include "julia_internal.h"
-
-#if JL_LLVM_VERSION >= 30700 && defined(JULIA_ENABLE_THREADING)
+#if defined(JULIA_ENABLE_THREADING)
 #  include <llvm/IR/InlineAsm.h>
+#  include <llvm/Transforms/Utils/BasicBlockUtils.h>
 #endif
+#include "fix_llvm_assert.h"
+
+#include "julia.h"
+#include "julia_internal.h"
 
 using namespace llvm;
 
@@ -61,18 +58,94 @@ static void ensure_global(const char *name, Type *t, Module &M,
     // setting JL_DLLEXPORT correctly only matters when building a binary
     // (global_proto will strip this from the JIT)
     if (dllimport) {
-#if JL_LLVM_VERSION >= 30500
         // add the __declspec(dllimport) attribute
         proto->setDLLStorageClass(GlobalValue::DLLImportStorageClass);
-#else
-        proto->setLinkage(GlobalValue::DLLImportLinkage);
-#endif
     }
 #else // _OS_WINDOWS_
     (void)proto;
 #endif // _OS_WINDOWS_
 }
 
+#ifdef JULIA_ENABLE_THREADING
+static void setCallPtlsAttrs(CallInst *ptlsStates)
+{
+#if JL_LLVM_VERSION >= 50000
+    ptlsStates->addAttribute(AttributeList::FunctionIndex, Attribute::ReadNone);
+    ptlsStates->addAttribute(AttributeList::FunctionIndex, Attribute::NoUnwind);
+#else
+    ptlsStates->addAttribute(AttributeSet::FunctionIndex, Attribute::ReadNone);
+    ptlsStates->addAttribute(AttributeSet::FunctionIndex, Attribute::NoUnwind);
+#endif
+}
+
+static Instruction *emit_ptls_tp(LLVMContext &ctx, Value *offset, Type *T_ppjlvalue,
+                                 Instruction *insertBefore)
+{
+    auto T_int8 = Type::getInt8Ty(ctx);
+    auto T_pint8 = PointerType::get(T_int8, 0);
+#  if defined(_CPU_X86_64_) || defined(_CPU_X86_)
+    // Workaround LLVM bug by hiding the offset computation
+    // (and therefore the optimization opportunity) from LLVM.
+    // Ref https://github.com/JuliaLang/julia/issues/17288
+    static const std::string const_asm_str = [&] () {
+        std::stringstream stm;
+#  if defined(_CPU_X86_64_)
+        stm << "movq %fs:0, $0;\naddq $$" << jl_tls_offset << ", $0";
+#  else
+        stm << "movl %gs:0, $0;\naddl $$" << jl_tls_offset << ", $0";
+#  endif
+        return stm.str();
+    }();
+#  if defined(_CPU_X86_64_)
+    const char *dyn_asm_str = "movq %fs:0, $0;\naddq $1, $0";
+#  else
+    const char *dyn_asm_str = "movl %gs:0, $0;\naddl $1, $0";
+#  endif
+
+    // The add instruction clobbers flags
+    Value *tls;
+    if (offset) {
+        std::vector<Type*> args(0);
+        args.push_back(offset->getType());
+        auto tp = InlineAsm::get(FunctionType::get(T_pint8, args, false),
+                                 dyn_asm_str, "=&r,r,~{dirflag},~{fpsr},~{flags}", false);
+        tls = CallInst::Create(tp, offset, "ptls_i8", insertBefore);
+    }
+    else {
+        auto tp = InlineAsm::get(FunctionType::get(T_pint8, false),
+                                 const_asm_str.c_str(), "=r,~{dirflag},~{fpsr},~{flags}", false);
+        tls = CallInst::Create(tp, "ptls_i8", insertBefore);
+    }
+    return new BitCastInst(tls, PointerType::get(T_ppjlvalue, 0), "ptls", insertBefore);
+#  elif defined(_CPU_AARCH64_) || (defined(__ARM_ARCH) && __ARM_ARCH >= 7)
+    // AArch64/ARM doesn't seem to have this issue.
+    // (Possibly because there are many more registers and the offset is
+    // positive and small)
+    // It's also harder to emit the offset in a generic way on ARM/AArch64
+    // (need to generate one or two `add` with shift) so let llvm emit
+    // the add for now.
+#if defined(_CPU_AARCH64_)
+    const char *asm_str = "mrs $0, tpidr_el0";
+#else
+    const char *asm_str = "mrc p15, 0, $0, c13, c0, 3";
+#endif
+    if (!offset) {
+        auto T_size = (sizeof(size_t) == 8 ? Type::getInt64Ty(ctx) : Type::getInt32Ty(ctx));
+        offset = ConstantInt::getSigned(T_size, jl_tls_offset);
+    }
+    auto tp = InlineAsm::get(FunctionType::get(T_pint8, false), asm_str, "=r", false);
+    Value *tls = CallInst::Create(tp, "thread_ptr", insertBefore);
+    tls = GetElementPtrInst::Create(T_int8, tls, {offset}, "ptls_i8", insertBefore);
+    return new BitCastInst(tls, PointerType::get(T_ppjlvalue, 0), "ptls", insertBefore);
+#  else
+    (void)T_pint8;
+    assert(0 && "Cannot emit thread pointer for this architecture.");
+    return nullptr;
+#  endif
+}
+
+#endif
+
 void LowerPTLS::runOnFunction(LLVMContext &ctx, Module &M, Function *F,
                               Function *ptls_getter, Type *T_ppjlvalue, MDNode *tbaa_const)
 {
@@ -98,71 +171,49 @@ void LowerPTLS::runOnFunction(LLVMContext &ctx, Module &M, Function *F,
     if (imaging_mode) {
         GlobalVariable *GV = cast<GlobalVariable>(
             M.getNamedValue("jl_get_ptls_states.ptr"));
-        LoadInst *getter = new LoadInst(GV, "", ptlsStates);
+        if (jl_tls_elf_support) {
+            GlobalVariable *OffsetGV = cast<GlobalVariable>(
+                M.getNamedValue("jl_tls_offset.val"));
+            // if (offset != 0)
+            //     ptls = tp + offset;
+            // else
+            //     ptls = getter();
+            auto offset = new LoadInst(OffsetGV, "", ptlsStates);
+            offset->setMetadata(llvm::LLVMContext::MD_tbaa, tbaa_const);
+            auto cmp = new ICmpInst(ptlsStates, CmpInst::ICMP_NE, offset,
+                                    Constant::getNullValue(offset->getType()));
+            MDBuilder MDB(ctx);
+            SmallVector<uint32_t, 2> Weights{9, 1};
+            TerminatorInst *fastTerm;
+            TerminatorInst *slowTerm;
+            SplitBlockAndInsertIfThenElse(cmp, ptlsStates, &fastTerm, &slowTerm,
+                                          MDB.createBranchWeights(Weights));
+
+            auto fastTLS = emit_ptls_tp(ctx, offset, T_ppjlvalue, fastTerm);
+            auto phi = PHINode::Create(PointerType::get(T_ppjlvalue, 0), 2, "", ptlsStates);
+            ptlsStates->replaceAllUsesWith(phi);
+            ptlsStates->moveBefore(slowTerm);
+            auto getter = new LoadInst(GV, "", ptlsStates);
+            getter->setMetadata(llvm::LLVMContext::MD_tbaa, tbaa_const);
+            ptlsStates->setCalledFunction(getter);
+            setCallPtlsAttrs(ptlsStates);
+
+            phi->addIncoming(fastTLS, fastTLS->getParent());
+            phi->addIncoming(ptlsStates, ptlsStates->getParent());
+
+            return;
+        }
+        auto getter = new LoadInst(GV, "", ptlsStates);
         getter->setMetadata(llvm::LLVMContext::MD_tbaa, tbaa_const);
         ptlsStates->setCalledFunction(getter);
-        ptlsStates->addAttribute(AttributeSet::FunctionIndex,
-                                 Attribute::ReadNone);
-        ptlsStates->addAttribute(AttributeSet::FunctionIndex,
-                                 Attribute::NoUnwind);
+        setCallPtlsAttrs(ptlsStates);
     }
-#if JL_LLVM_VERSION >= 30700
     else if (jl_tls_offset != -1) {
-        auto T_int8 = Type::getInt8Ty(ctx);
-        auto T_pint8 = PointerType::get(T_int8, 0);
-        // Replace the function call with inline assembly if we know
-        // how to generate it.
-#  if defined(_CPU_X86_64_) || defined(_CPU_X86_)
-        // Workaround LLVM bug by hiding the offset computation
-        // (and therefore the optimization opportunity) from LLVM.
-        static const std::string asm_str = [&] () {
-            std::stringstream stm;
-#  if defined(_CPU_X86_64_)
-            stm << "movq %fs:0, $0;\naddq $$" << jl_tls_offset << ", $0";
-#  else
-            stm << "movl %gs:0, $0;\naddl $$" << jl_tls_offset << ", $0";
-#  endif
-            return stm.str();
-        }();
-        // The add instruction clobbers flags
-        auto tp = InlineAsm::get(FunctionType::get(T_pint8, false),
-                                 asm_str.c_str(),
-                                 "=r,~{dirflag},~{fpsr},~{flags}", false);
-        Value *tls = CallInst::Create(tp, "ptls_i8", ptlsStates);
-        tls = new BitCastInst(tls, PointerType::get(T_ppjlvalue, 0),
-                              "ptls", ptlsStates);
-#  elif defined(_CPU_AARCH64_)
-        // AArch64 doesn't seem to have this issue.
-        // (Possibly because there are many more registers and the offset is
-        // positive and small)
-        // It's also harder to emit the offset in a generic way on AArch64
-        // (need to generate one or two `add` with shift) so let llvm emit
-        // the add for now.
-        auto T_size = (sizeof(size_t) == 8 ? Type::getInt64Ty(ctx) :
-                       Type::getInt32Ty(ctx));
-        const char *asm_str = "mrs $0, tpidr_el0";
-        auto offset = ConstantInt::getSigned(T_size, jl_tls_offset);
-        auto tp = InlineAsm::get(FunctionType::get(T_pint8, false),
-                                 asm_str, "=r", false);
-        Value *tls = CallInst::Create(tp, "thread_ptr", ptlsStates);
-        tls = GetElementPtrInst::Create(T_int8, tls, {offset},
-                                        "ptls_i8", ptlsStates);
-        tls = new BitCastInst(tls, PointerType::get(T_ppjlvalue, 0),
-                              "ptls", ptlsStates);
-#  else
-        Value *tls = nullptr;
-        assert(0 && "Cannot emit thread pointer for this architecture.");
-#  endif
-        (void)T_pint8;
-        ptlsStates->replaceAllUsesWith(tls);
+        ptlsStates->replaceAllUsesWith(emit_ptls_tp(ctx, nullptr, T_ppjlvalue, ptlsStates));
         ptlsStates->eraseFromParent();
     }
-#endif
     else {
-        ptlsStates->addAttribute(AttributeSet::FunctionIndex,
-                                 Attribute::ReadNone);
-        ptlsStates->addAttribute(AttributeSet::FunctionIndex,
-                                 Attribute::NoUnwind);
+        setCallPtlsAttrs(ptlsStates);
     }
 #else
     ptlsStates->replaceAllUsesWith(M.getNamedValue("jl_tls_states"));
@@ -182,8 +233,11 @@ bool LowerPTLS::runOnModule(Module &M)
     auto T_ppjlvalue =
         cast<PointerType>(functype->getReturnType())->getElementType();
 #ifdef JULIA_ENABLE_THREADING
-    if (imaging_mode)
+    if (imaging_mode) {
         ensure_global("jl_get_ptls_states.ptr", functype->getPointerTo(), M);
+        ensure_global("jl_tls_offset.val",
+                      sizeof(size_t) == 8 ? Type::getInt64Ty(ctx) : Type::getInt32Ty(ctx), M);
+    }
 #else
     ensure_global("jl_tls_states", T_ppjlvalue, M, imaging_mode);
 #endif
@@ -210,8 +264,3 @@ Pass *createLowerPTLSPass(bool imaging_mode)
 {
     return new LowerPTLS(imaging_mode);
 }
-
-extern "C" JL_DLLEXPORT
-void LLVMAddLowerPTLSPass(LLVMPassManagerRef PM, int imaging_mode) {
-    unwrap(PM)->add(createLowerPTLSPass(imaging_mode != 0));
-}
diff --git a/src/llvm-simdloop.cpp b/src/llvm-simdloop.cpp
index a30a4091e60927..72dbe86ee6bebd 100644
--- a/src/llvm-simdloop.cpp
+++ b/src/llvm-simdloop.cpp
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #define DEBUG_TYPE "lower_simd_loop"
 #undef DEBUG
@@ -14,6 +14,8 @@
 #include <llvm/IR/LLVMContext.h>
 #include <llvm/IR/Metadata.h>
 #include <llvm/Support/Debug.h>
+#include "fix_llvm_assert.h"
+
 #include <cstdio>
 
 namespace llvm {
@@ -30,11 +32,7 @@ bool annotateSimdLoop(BasicBlock *incr)
     // Lazy initialization
     if (!simd_loop_mdkind) {
         simd_loop_mdkind = incr->getContext().getMDKindID("simd_loop");
-#if JL_LLVM_VERSION >= 30600
         simd_loop_md = MDNode::get(incr->getContext(), ArrayRef<Metadata*>());
-#else
-        simd_loop_md = MDNode::get(incr->getContext(), ArrayRef<Value*>());
-#endif
     }
     // Ideally, the decoration would go on the block itself, but LLVM 3.3 does not
     // support putting metadata on blocks.  So instead, put the decoration on the last
@@ -65,13 +63,15 @@ struct LowerSIMDLoop: public LoopPass {
     LowerSIMDLoop() : LoopPass(ID) {}
 
 private:
-    /*override*/ bool runOnLoop(Loop *, LPPassManager &LPM);
+    bool runOnLoop(Loop *, LPPassManager &LPM) override;
 
     /// Check if loop has "simd_loop" annotation.
     /// If present, the annotation is an MDNode attached to an instruction in the loop's latch.
     bool hasSIMDLoopMetadata( Loop *L) const;
 
-    /// If Phi is part of a reduction cycle of FAdd or FMul, mark the ops as permitting reassociation/commuting.
+    /// If Phi is part of a reduction cycle of FAdd, FSub, FMul or FDiv,
+    /// mark the ops as permitting reassociation/commuting.
+    /// As of LLVM 4.0, FDiv is not handled by the loop vectorizer
     void enableUnsafeAlgebraIfReduction(PHINode *Phi, Loop *L) const;
 };
 
@@ -85,6 +85,26 @@ bool LowerSIMDLoop::hasSIMDLoopMetadata(Loop *L) const
     return false;
 }
 
+static unsigned getReduceOpcode(Instruction *J, Instruction *operand)
+{
+    switch (J->getOpcode()) {
+    case Instruction::FSub:
+        if (J->getOperand(0) != operand)
+            return 0;
+        JL_FALLTHROUGH;
+    case Instruction::FAdd:
+        return Instruction::FAdd;
+    case Instruction::FDiv:
+        if (J->getOperand(0) != operand)
+            return 0;
+        JL_FALLTHROUGH;
+    case Instruction::FMul:
+        return Instruction::FMul;
+    default:
+        return 0;
+    }
+}
+
 void LowerSIMDLoop::enableUnsafeAlgebraIfReduction(PHINode *Phi, Loop *L) const
 {
     typedef SmallVector<Instruction*, 8> chainVector;
@@ -94,13 +114,8 @@ 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 JL_LLVM_VERSION >= 30500
         for (User *UI : I->users()) { /*}*/
             Instruction *U = cast<Instruction>(UI);
-#else
-        for (Value::use_iterator UI = I->use_begin(), UE = I->use_end(); UI != UE; ++UI) {
-            Instruction *U = cast<Instruction>(*UI);
-#endif
             if (L->contains(U)) {
                 if (J) {
                     DEBUG(dbgs() << "LSL: not a reduction var because op has two internal uses: " << *I << "\n");
@@ -113,21 +128,21 @@ void LowerSIMDLoop::enableUnsafeAlgebraIfReduction(PHINode *Phi, Loop *L) const
             DEBUG(dbgs() << "LSL: chain prematurely terminated at " << *I << "\n");
             return;
         }
-        if (J==Phi) {
+        if (J == Phi) {
             // Found the entire chain.
             break;
         }
         if (opcode) {
             // Check that arithmetic op matches prior arithmetic ops in the chain.
-            if (J->getOpcode()!=opcode) {
+            if (getReduceOpcode(J, I) != opcode) {
                 DEBUG(dbgs() << "LSL: chain broke at " << *J << " because of wrong opcode\n");
                 return;
             }
         }
         else {
             // First arithmetic op in the chain.
-            opcode = J->getOpcode();
-            if (opcode!=Instruction::FAdd && opcode!=Instruction::FMul) {
+            opcode = getReduceOpcode(J, I);
+            if (!opcode) {
                 DEBUG(dbgs() << "LSL: first arithmetic op in chain is uninteresting" << *J << "\n");
                 return;
             }
@@ -142,8 +157,10 @@ void LowerSIMDLoop::enableUnsafeAlgebraIfReduction(PHINode *Phi, Loop *L) const
 
 bool LowerSIMDLoop::runOnLoop(Loop *L, LPPassManager &LPM)
 {
-    if (!simd_loop_mdkind)
-        return false;           // Fast rejection test.
+    if (!simd_loop_mdkind) {
+        simd_loop_mdkind = L->getHeader()->getContext().getMDKindID("simd_loop");
+        simd_loop_md = MDNode::get(L->getHeader()->getContext(), ArrayRef<Metadata*>());
+    }
 
     if (!hasSIMDLoopMetadata(L))
         return false;
@@ -151,27 +168,14 @@ bool LowerSIMDLoop::runOnLoop(Loop *L, LPPassManager &LPM)
     DEBUG(dbgs() << "LSL: simd_loop found\n");
     BasicBlock *Lh = L->getHeader();
     DEBUG(dbgs() << "LSL: loop header: " << *Lh << "\n");
-#if JL_LLVM_VERSION >= 30400
     MDNode *n = L->getLoopID();
     if (!n) {
         // Loop does not have a LoopID yet, so give it one.
-#if JL_LLVM_VERSION >= 30600
         n = MDNode::get(Lh->getContext(), ArrayRef<Metadata*>(NULL));
-#else
-        n = MDNode::get(Lh->getContext(), ArrayRef<Value*>(NULL));
-#endif
         n->replaceOperandWith(0,n);
         L->setLoopID(n);
     }
-#else
-    MDNode *n = MDNode::get(Lh->getContext(), ArrayRef<Value*>());
-    L->getLoopLatch()->getTerminator()->setMetadata("llvm.loop.parallel", n);
-#endif
-#if JL_LLVM_VERSION >= 30600
     MDNode *m = MDNode::get(Lh->getContext(), ArrayRef<Metadata*>(n));
-#else
-    MDNode *m = MDNode::get(Lh->getContext(), ArrayRef<Value*>(n));
-#endif
 
     // Mark memory references so that Loop::isAnnotatedParallel will return true for this loop.
     for(Loop::block_iterator BBI = L->block_begin(), E=L->block_end(); BBI!=E; ++BBI)
diff --git a/src/llvm-version.h b/src/llvm-version.h
index 0149b4016cb22c..f164da886287e1 100644
--- a/src/llvm-version.h
+++ b/src/llvm-version.h
@@ -1,10 +1,7 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include <llvm/Config/llvm-config.h>
-
-#ifndef LLVM_VERSION_PATCH // for LLVM 3.3
-#define LLVM_VERSION_PATCH 0
-#endif
+#include "fix_llvm_assert.h"
 
 // The LLVM version used, JL_LLVM_VERSION, is represented as a 5-digit integer
 // of the form ABBCC, where A is the major version, B is minor, and C is patch.
@@ -12,26 +9,6 @@
 #define JL_LLVM_VERSION (LLVM_VERSION_MAJOR * 10000 + LLVM_VERSION_MINOR * 100 \
                         + LLVM_VERSION_PATCH)
 
-#if JL_LLVM_VERSION != 30300 && JL_LLVM_VERSION < 30701
-    #error Only LLVM versions 3.3 and >= 3.7.1 are supported by Julia
-#endif
-
-#if JL_LLVM_VERSION >= 30800
-    #define USE_ORCJIT
-// We enable ORCJIT only if we have our custom patches
-#elif JL_LLVM_VERSION >= 30700 && !defined(SYSTEM_LLVM)
-    #define USE_ORCJIT
-#endif
-
-#if JL_LLVM_VERSION >= 30400
-    #define USE_MCJIT
-#endif
-
-
-//temporary, since in some places USE_MCJIT may be used instead of the correct LLVM version test
-#ifdef USE_ORCJIT
-    #define USE_MCJIT
-#endif
-#ifdef USE_ORCMCJIT
-    #define USE_MCJIT
+#if JL_LLVM_VERSION < 30901
+    #error Only LLVM versions >= 3.9.1 are supported by Julia
 #endif
diff --git a/src/locks.h b/src/locks.h
new file mode 100644
index 00000000000000..3212eb3377534a
--- /dev/null
+++ b/src/locks.h
@@ -0,0 +1,177 @@
+// This file is a part of Julia. License is MIT: https://julialang.org/license
+
+#ifndef JL_LOCKS_H
+#define JL_LOCKS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Lock acquire and release primitives
+
+// JL_LOCK and jl_mutex_lock are GC safe points while JL_LOCK_NOGC
+// and jl_mutex_lock_nogc are 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.
+// The JL_LOCK* and JL_UNLOCK* macros are no-op for non-threading build
+// while the jl_mutex_* functions are always locking and unlocking the locks.
+
+static inline void jl_mutex_wait(jl_mutex_t *lock, int safepoint)
+{
+    unsigned long self = jl_thread_self();
+    unsigned long owner = jl_atomic_load_acquire(&lock->owner);
+    if (owner == self) {
+        lock->count++;
+        return;
+    }
+    while (1) {
+        if (owner == 0 &&
+            jl_atomic_compare_exchange(&lock->owner, 0, self) == 0) {
+            lock->count = 1;
+            return;
+        }
+        if (safepoint) {
+            jl_ptls_t ptls = jl_get_ptls_states();
+            jl_gc_safepoint_(ptls);
+        }
+        jl_cpu_pause();
+        owner = lock->owner;
+    }
+}
+
+static inline void jl_mutex_lock_nogc(jl_mutex_t *lock)
+{
+    jl_mutex_wait(lock, 0);
+}
+
+#ifdef JULIA_ENABLE_THREADING
+static inline void jl_lock_frame_push(jl_mutex_t *lock)
+{
+    jl_ptls_t ptls = jl_get_ptls_states();
+    // For early bootstrap
+    if (__unlikely(!ptls->current_task))
+        return;
+    arraylist_t *locks = &ptls->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*)lock;
+}
+static inline void jl_lock_frame_pop(void)
+{
+    jl_ptls_t ptls = jl_get_ptls_states();
+    if (__likely(ptls->current_task)) {
+        ptls->current_task->locks.len--;
+    }
+}
+#else
+static inline void jl_lock_frame_push(jl_mutex_t *lock)
+{
+    (void)lock;
+}
+static inline void jl_lock_frame_pop(void)
+{
+}
+#endif // ifndef JULIA_ENABLE_THREADING
+
+#define JL_SIGATOMIC_BEGIN() do {               \
+        jl_get_ptls_states()->defer_signal++;   \
+        jl_signal_fence();                      \
+    } while (0)
+#define JL_SIGATOMIC_END() do {                                 \
+        jl_signal_fence();                                      \
+        if (--jl_get_ptls_states()->defer_signal == 0) {        \
+            jl_sigint_safepoint(jl_get_ptls_states());          \
+        }                                                       \
+    } while (0)
+
+static inline void jl_mutex_lock(jl_mutex_t *lock)
+{
+    jl_ptls_t ptls = jl_get_ptls_states();
+    JL_SIGATOMIC_BEGIN();
+    jl_mutex_wait(lock, 1);
+    jl_lock_frame_push(lock);
+    jl_gc_enable_finalizers(ptls, 0);
+}
+
+/* Call this function for code that could be called from either a managed
+   or an unmanaged thread */
+static inline void jl_mutex_lock_maybe_nogc(jl_mutex_t *lock)
+{
+    jl_ptls_t ptls = jl_get_ptls_states();
+    if (ptls->safepoint) {
+        jl_mutex_lock(lock);
+    } else {
+        jl_mutex_lock_nogc(lock);
+    }
+}
+
+static inline void jl_mutex_unlock_nogc(jl_mutex_t *lock)
+{
+    assert(lock->owner == jl_thread_self() &&
+           "Unlocking a lock in a different thread.");
+    if (--lock->count == 0) {
+        jl_atomic_store_release(&lock->owner, 0);
+        jl_cpu_wake();
+    }
+}
+
+static inline void jl_mutex_unlock(jl_mutex_t *lock)
+{
+    jl_ptls_t ptls = jl_get_ptls_states();
+    jl_mutex_unlock_nogc(lock);
+    jl_gc_enable_finalizers(ptls, 1);
+    jl_lock_frame_pop();
+    JL_SIGATOMIC_END();
+}
+
+static inline void jl_mutex_unlock_maybe_nogc(jl_mutex_t *lock) {
+    jl_ptls_t ptls = jl_get_ptls_states();
+    if (ptls->safepoint) {
+        jl_mutex_unlock(lock);
+    } else {
+        jl_mutex_unlock_nogc(lock);
+    }
+}
+
+static inline void jl_mutex_init(jl_mutex_t *lock)
+{
+    lock->owner = 0;
+    lock->count = 0;
+}
+
+#ifdef JULIA_ENABLE_THREADING
+#define JL_MUTEX_INIT(m) jl_mutex_init(m)
+#define JL_LOCK(m) jl_mutex_lock(m)
+#define JL_UNLOCK(m) jl_mutex_unlock(m)
+#define JL_LOCK_NOGC(m) jl_mutex_lock_nogc(m)
+#define JL_UNLOCK_NOGC(m) jl_mutex_unlock_nogc(m)
+#else // JULIA_ENABLE_THREADING
+static inline void jl_mutex_check_type(jl_mutex_t *m)
+{
+    (void)m;
+}
+#define JL_MUTEX_INIT(m) jl_mutex_check_type(m)
+#define JL_LOCK(m) do {                                   \
+        JL_SIGATOMIC_BEGIN();                             \
+        jl_gc_enable_finalizers(jl_get_ptls_states(), 0); \
+        jl_mutex_check_type(m);                           \
+    } while (0)
+#define JL_UNLOCK(m) do {                                       \
+        jl_gc_enable_finalizers(jl_get_ptls_states(), 1);       \
+        jl_mutex_check_type(m);                                 \
+        JL_SIGATOMIC_END();                                     \
+    } while (0)
+#define JL_LOCK_NOGC(m) jl_mutex_check_type(m)
+#define JL_UNLOCK_NOGC(m) jl_mutex_check_type(m)
+#endif // JULIA_ENABLE_THREADING
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/macroexpand.scm b/src/macroexpand.scm
index 2258a8b41f4d17..c72746bb1e6146 100644
--- a/src/macroexpand.scm
+++ b/src/macroexpand.scm
@@ -46,6 +46,10 @@
                         (call (top append_any) ,@forms)))
                (loop (cdr p) (cons (julia-bq-bracket (car p) d) q)))))))
 
+(define (julia-bq-expand-hygienic x unhygienic)
+  (let ((expanded (julia-bq-expand x 0)))
+    (if unhygienic expanded `(escape ,expanded))))
+
 ;; hygiene
 
 ;; return the names of vars introduced by forms, instead of their transformations.
@@ -54,16 +58,15 @@
    ;; 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 (typevar-expr-name v))
-                                                    (lambda (e) '())))
-                                       sparams)))))
+    (cons 'varlist (append (safe-llist-positional-args (fix-arglist argl))
+                           (typevar-names sparams))))
 
    ;; function definition
-   (pattern-lambda (function (call name . argl) body)
-                   (cons 'varlist (llist-vars (fix-arglist argl))))
+   (pattern-lambda (function (-$ (call name . argl) (|::| (call name . argl) _t)) body)
+                   (cons 'varlist (safe-llist-positional-args (fix-arglist argl))))
+   (pattern-lambda (function (where (-$ (call name . argl) (|::| (call name . argl) _t)) . wheres) body)
+                   (cons 'varlist (append (safe-llist-positional-args (fix-arglist argl))
+                                          (typevar-names wheres))))
 
    (pattern-lambda (function (tuple . args) body)
                    `(-> (tuple ,@args) ,body))
@@ -71,8 +74,10 @@
    ;; 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)
+   (pattern-lambda (= (-$ (call name . argl) (|::| (call name . argl) _t)) body)
                    `(function (call ,name ,@argl) ,body))
+   (pattern-lambda (= (where (-$ (call name . argl) (|::| (call name . argl) _t)) . wheres) body)
+                   (cons 'function (cdr __)))
 
    ;; anonymous function
    (pattern-lambda (-> a b)
@@ -80,7 +85,11 @@
                                      (eq? (car a) 'tuple))
                                 (cdr a)
                                 (list a))))
-                     (cons 'varlist (llist-vars (fix-arglist a)))))
+                     (cons 'varlist (safe-llist-positional-args (fix-arglist a)))))
+
+   ;; where
+   (pattern-lambda (where ex . vars)
+                   (cons 'varlist (typevar-names vars)))
 
    ;; let
    (pattern-lambda (let ex . binds)
@@ -102,8 +111,7 @@
                              ;; a=b -> add argument
                              (loop (cdr binds)
                                    (cons (decl-var (cadar binds)) vars)))
-                            ((and (pair? (cadar binds))
-                                  (eq? (caadar binds) 'call))
+                            ((eventually-call? (cadar binds))
                              ;; f()=c
                              (let ((asgn (cadr (julia-expand0 (car binds)))))
                                (loop (cdr binds)
@@ -127,10 +135,10 @@
    ;; 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)))
+                          (typevar-names tvars)))
    (pattern-lambda (type mut (curly tn . tvars) body)
                    (list* 'varlist (cons (unescape tn) (unescape tn)) '(new . new)
-                          (map typevar-expr-name tvars)))
+                          (typevar-names tvars)))
    (pattern-lambda (type mut (<: tn super) body)
                    (list 'varlist (cons (unescape tn) (unescape tn)) '(new . new)))
    (pattern-lambda (type mut tn body)
@@ -141,15 +149,19 @@
 (define keywords-introduced-by-patterns
   (pattern-set
    (pattern-lambda (function (call (curly name . sparams) . argl) body)
-                   (cons 'varlist (llist-keywords (fix-arglist argl))))
+                   (cons 'varlist (safe-llist-keyword-args (fix-arglist argl))))
 
-   (pattern-lambda (function (call name . argl) body)
-                   (cons 'varlist (llist-keywords (fix-arglist argl))))
+   (pattern-lambda (function (-$ (call name . argl) (|::| (call name . argl) _t)) body)
+                   (cons 'varlist (safe-llist-keyword-args (fix-arglist argl))))
+   (pattern-lambda (function (where (-$ (call name . argl) (|::| (call name . argl) _t)) . wheres) body)
+                   (cons 'varlist (safe-llist-keyword-args (fix-arglist argl))))
 
    (pattern-lambda (= (call (curly name . sparams) . argl) body)
                    `(function (call (curly ,name . ,sparams) . ,argl) ,body))
-   (pattern-lambda (= (call name . argl) body)
+   (pattern-lambda (= (-$ (call name . argl) (|::| (call name . argl) _t)) body)
                    `(function (call ,name ,@argl) ,body))
+   (pattern-lambda (= (where (-$ (call name . argl) (|::| (call name . argl) _t)) . wheres) body)
+                   (cons 'function (cdr __)))
    ))
 
 (define (pair-with-gensyms v)
@@ -166,6 +178,75 @@
 
 (define (typevar-expr-name e) (car (analyze-typevar e)))
 
+;; get the list of names from a list of `where` variable expressions
+(define (typevar-names lst)
+  (apply nconc
+         (map (lambda (v) (trycatch
+                           (list (typevar-expr-name v))
+                           (lambda (e) '())))
+              lst)))
+
+;; get the name from a function formal argument expression, allowing `(escape x)`
+(define (try-arg-name v)
+  (cond ((and (symbol? v) (not (eq? v 'true)) (not (eq? v 'false)))
+         (list v))
+        ((atom? v) '())
+        (else
+         (case (car v)
+           ((... kw |::|) (try-arg-name (cadr v)))
+           ((escape) (list v))
+           ((hygienic-scope) (try-arg-name (cadr v)))
+           ((meta)  ;; allow certain per-argument annotations
+            (if (nospecialize-meta? v #t)
+                (try-arg-name (caddr v))
+                '()))
+           (else '())))))
+
+;; get names from a formal argument list, specifying whether to include escaped ones
+(define (safe-arg-names lst (escaped #f))
+  (apply nconc
+         (map (lambda (v)
+                (let ((vv (try-arg-name v)))
+                  (if (eq? escaped (and (pair? vv) (pair? (car vv)) (eq? (caar vv) 'escape)))
+                      (if escaped (list (cadar vv)) vv)
+                      '())))
+              lst)))
+
+;; arg names, looking only at positional args
+(define (safe-llist-positional-args lst (escaped #f))
+  (safe-arg-names
+   (filter (lambda (a) (not (and (pair? a)
+                                 (eq? (car a) 'parameters))))
+           lst)
+   escaped))
+
+;; arg names from keyword arguments, and positional arguments with escaped names
+(define (safe-llist-keyword-args lst)
+  (let ((kwargs (apply nconc
+                       (map cdr
+                            (filter (lambda (a) (and (pair? a) (eq? (car a) 'parameters)))
+                                    lst)))))
+    (append
+     (safe-arg-names kwargs #f)
+     (safe-arg-names kwargs #t)
+     ;; count escaped argument names as "keywords" to prevent renaming
+     (safe-llist-positional-args lst #t))))
+
+;; resolve-expansion-vars-with-new-env, but turn on `inarg` once we get inside
+;; the formal argument list. `e` in general might be e.g. `(f{T}(x)::T) where T`,
+;; and we want `inarg` to be true for the `(x)` part.
+(define (resolve-in-function-lhs e env m parent-scope inarg)
+  (define (recur x) (resolve-in-function-lhs x env m parent-scope inarg))
+  (define (other x) (resolve-expansion-vars-with-new-env x env m parent-scope inarg))
+  (case (car e)
+    ((where) `(where ,(recur (cadr e)) ,@(map other (cddr e))))
+    ((|::|)  `(|::| ,(recur (cadr e)) ,(other (caddr e))))
+    ((call)  `(call ,(other (cadr e))
+                    ,@(map (lambda (x)
+                             (resolve-expansion-vars-with-new-env x env m parent-scope #t))
+                           (cddr e))))
+    (else (other e))))
+
 (define (new-expansion-env-for x env (outermost #f))
   (let ((introduced (pattern-expand1 vars-introduced-by-patterns x)))
     (if (or (atom? x)
@@ -192,7 +273,7 @@
                             (diff (keywords-introduced-by x) globals))))
               env)))))))
 
-(define (resolve-expansion-vars-with-new-env x env m inarg (outermost #f))
+(define (resolve-expansion-vars-with-new-env x env m parent-scope inarg (outermost #f))
   (resolve-expansion-vars-
    x
    (if (and (pair? x) (eq? (car x) 'let))
@@ -200,9 +281,9 @@
        ;; the same expression
        env
        (new-expansion-env-for x env outermost))
-   m inarg))
+   m parent-scope inarg))
 
-(define (resolve-expansion-vars- e env m inarg)
+(define (resolve-expansion-vars- e env m parent-scope inarg)
   (cond ((or (eq? e 'true) (eq? e 'false) (eq? e 'end) (eq? e 'ccall))
          e)
         ((symbol? e)
@@ -215,7 +296,13 @@
         (else
          (case (car e)
            ((ssavalue) e)
-           ((escape) (cadr e))
+           ((escape) (if (null? parent-scope)
+              (julia-expand-macroscopes (cadr e))
+              (let* ((scope (car parent-scope))
+                     (env (car scope))
+                     (m (cadr scope))
+                     (parent-scope (cdr parent-scope)))
+                (resolve-expansion-vars-with-new-env (cadr e) env m parent-scope inarg))))
            ((global) (let ((arg (cadr e)))
                        (cond ((symbol? arg) e)
                              ((assignment? arg)
@@ -225,42 +312,35 @@
                              (else
                               `(global ,(resolve-expansion-vars-with-new-env arg env m inarg))))))
            ((using import importall export meta line inbounds boundscheck simdloop) (map unescape e))
-           ((macrocall)
-            (if (or (eq? (cadr e) '@label) (eq? (cadr e) '@goto)) e
-                `(macrocall ,.(map (lambda (x)
-                                     (resolve-expansion-vars-with-new-env x env m inarg))
-                                   (cdr e)))))
+           ((macrocall) e) ; invalid syntax anyways, so just act like it's quoted.
            ((symboliclabel) e)
            ((symbolicgoto) e)
            ((type)
-            `(type ,(cadr e) ,(resolve-expansion-vars- (caddr e) env m inarg)
+            `(type ,(cadr e) ,(resolve-expansion-vars- (caddr e) env m parent-scope 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)))
+                                    ,(resolve-expansion-vars- (caddr x) env m parent-scope inarg)))
                                  (else
-                                  (resolve-expansion-vars-with-new-env x env m inarg))))
+                                  (resolve-expansion-vars-with-new-env x env m parent-scope inarg))))
                          (cadddr e))))
 
            ((parameters)
             (cons 'parameters
                   (map (lambda (x)
-                         (resolve-expansion-vars- x env m #f))
+                         (resolve-expansion-vars- x env m parent-scope #f))
                        (cdr e))))
 
            ((= function)
-            (if (and (pair? (cadr e)) (eq? (caadr e) 'call))
+            (if (and (pair? (cadr e)) (function-def? e))
                 ;; 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) ,(resolve-in-function-lhs (cadr e) env m parent-scope inarg)
+                  ,(resolve-expansion-vars-with-new-env (caddr e) env m parent-scope inarg))
                 `(,(car e) ,@(map (lambda (x)
-                                    (resolve-expansion-vars-with-new-env x env m inarg))
+                                    (resolve-expansion-vars-with-new-env x env m parent-scope inarg))
                                   (cdr e)))))
 
            ((kw)
@@ -268,19 +348,19 @@
                      (eq? (caadr e) '|::|))
                 `(kw (|::|
                       ,(if inarg
-                           (resolve-expansion-vars- (cadr (cadr e)) env m inarg)
+                           (resolve-expansion-vars- (cadr (cadr e)) env m parent-scope 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))
+                           (unescape (cadr (cadr e))))
+                      ,(resolve-expansion-vars- (caddr (cadr e)) env m parent-scope inarg))
+                     ,(resolve-expansion-vars- (caddr e) env m parent-scope inarg))
                 `(kw ,(if inarg
-                          (resolve-expansion-vars- (cadr e) env m inarg)
-                          (cadr e))
-                     ,(resolve-expansion-vars- (caddr e) env m inarg))))
+                          (resolve-expansion-vars- (cadr e) env m parent-scope inarg)
+                          (unescape (cadr e)))
+                     ,(resolve-expansion-vars- (caddr e) env m parent-scope inarg))))
 
            ((let)
             (let* ((newenv (new-expansion-env-for e env))
-                   (body   (resolve-expansion-vars- (cadr e) newenv m inarg)))
+                   (body   (resolve-expansion-vars- (cadr e) newenv m parent-scope inarg)))
               `(let ,body
                  ,@(map
                     (lambda (bind)
@@ -288,17 +368,22 @@
                           (make-assignment
                            ;; expand binds in old env with dummy RHS
                            (cadr (resolve-expansion-vars- (make-assignment (cadr bind) 0)
-                                                          newenv m inarg))
+                                                          newenv m parent-scope inarg))
                            ;; expand initial values in old env
-                           (resolve-expansion-vars- (caddr bind) env m inarg))
+                           (resolve-expansion-vars- (caddr bind) env m parent-scope inarg))
                           bind))
                     (cddr e)))))
+           ((hygienic-scope) ; TODO: move this lowering to resolve-scopes, instead of reimplementing it here badly
+             (let ((parent-scope (cons (list env m) parent-scope))
+                   (body (cadr e))
+                   (m (caddr e)))
+              (resolve-expansion-vars-with-new-env body env m parent-scope inarg)))
 
            ;; todo: trycatch
            (else
             (cons (car e)
                   (map (lambda (x)
-                         (resolve-expansion-vars-with-new-env x env m inarg))
+                         (resolve-expansion-vars-with-new-env x env m parent-scope inarg))
                        (cdr e))))))))
 
 ;; decl-var that also identifies f in f()=...
@@ -308,6 +393,8 @@
         ((eq? (car e) 'call)   (decl-var* (cadr e)))
         ((eq? (car e) '=)      (decl-var* (cadr e)))
         ((eq? (car e) 'curly)  (decl-var* (cadr e)))
+        ((eq? (car e) '|::|)   (decl-var* (cadr e)))
+        ((eq? (car e) 'where)  (decl-var* (cadr e)))
         (else                  (decl-var e))))
 
 (define (decl-vars* e)
@@ -318,11 +405,12 @@
 (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)))))
+                          (eventually-call? (cadr e))))))
 
 (define (find-declared-vars-in-expansion e decl (outer #t))
   (cond ((or (not (pair? e)) (quoted? e)) '())
         ((eq? (car e) 'escape)  '())
+        ((eq? (car e) 'hygienic-scope)  '())
         ((eq? (car e) decl)     (map decl-var* (cdr e)))
         ((and (not outer) (function-def? e)) '())
         (else
@@ -333,13 +421,14 @@
 (define (find-assigned-vars-in-expansion e (outer #t))
   (cond ((or (not (pair? e)) (quoted? e))  '())
         ((eq? (car e) 'escape)  '())
+        ((eq? (car e) 'hygienic-scope)  '())
         ((and (not outer) (function-def? e))
          ;; pick up only function name
-         (let ((fname (cond ((eq? (car e) '=) (cadr (cadr e)))
+         (let ((fname (cond ((eq? (car e) '=) (decl-var* (cadr e)))
                             ((eq? (car e) 'function)
                              (cond ((atom? (cadr e))             (cadr e))
                                    ((eq? (car (cadr e)) 'tuple)  #f)
-                                   (else                         (cadr (cadr e)))))
+                                   (else                         (decl-var* (cadr e)))))
                             (else #f))))
            (if (symbol? fname)
                (list fname)
@@ -361,8 +450,8 @@
 (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 #t))
+  ;; and wrap globals in (globalref module var) for macro's home module
+  (resolve-expansion-vars-with-new-env e '() m '() #f #t))
 
 (define (find-symbolic-labels e)
   (let ((defs (table))
@@ -394,25 +483,46 @@
 
 ;; macro expander entry point
 
-(define (julia-expand-macros e)
-  (cond ((not (pair? e))     e)
+(define (julia-expand-macros e (max-depth -1))
+  (julia-expand-macroscopes
+    (julia-expand-macros- '() e max-depth)))
+
+(define (julia-expand-macros- m e max-depth)
+  (cond ((= max-depth 0)   e)
+        ((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)))
+         ;; backquote is essentially a built-in unhygienic macro at the moment
+         (julia-expand-macros- m (julia-bq-expand-hygienic (cadr e) (null? m)) max-depth))
         ((eq? (car e) 'inert) e)
         ((eq? (car e) 'macrocall)
          ;; expand macro
-         (let ((form (apply invoke-julia-macro (cadr e) (cddr e))))
+         (let ((form (apply invoke-julia-macro (if (null? m) 'false (car m)) (cdr 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
-             (rename-symbolic-labels
-              (julia-expand-macros
-               (resolve-expansion-vars form m))))))
+           (let ((form (car form)) ;; form is the expression returned from expand-macros
+                 (modu (cdr form))) ;; modu is the macro's def module
+             `(hygienic-scope
+               ,(julia-expand-macros- (cons modu m) (rename-symbolic-labels form) (- max-depth 1))
+               ,modu))))
+        ((eq? (car e) 'module) e)
+        ((eq? (car e) 'escape)
+         (let ((m (if (null? m) m (cdr m))))
+           `(escape ,(julia-expand-macros- m (cadr e) max-depth))))
+        (else
+         (map (lambda (ex)
+                (julia-expand-macros- m ex max-depth))
+              e))))
+
+;; TODO: delete this file and fold this operation into resolve-scopes
+(define (julia-expand-macroscopes e)
+  (cond ((not (pair? e)) e)
+        ((eq? (car e) 'inert) e)
         ((eq? (car e) 'module) e)
+        ((eq? (car e) 'hygienic-scope)
+           (let ((form (cadr e)) ;; form is the expression returned from expand-macros
+                 (modu (caddr e))) ;; m is the macro's def module
+             (resolve-expansion-vars form modu)))
         (else
-         (map julia-expand-macros e))))
+         (map julia-expand-macroscopes e))))
diff --git a/src/method.c b/src/method.c
index 70c8c3339bc2db..55600c3474246f 100644
--- a/src/method.c
+++ b/src/method.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 /*
   Defining and adding methods
@@ -69,30 +69,40 @@ jl_value_t *jl_resolve_globals(jl_value_t *expr, jl_module_t *module, jl_svec_t
             }
             size_t i = 0, nargs = jl_array_len(e->args);
             if (e->head == foreigncall_sym) {
-                JL_NARGSV(ccall method definition, 3); // (fptr, rt, at)
+                JL_NARGSV(ccall method definition, 5); // (fptr, rt, at, cc, narg)
                 jl_value_t *rt = jl_exprarg(e, 1);
                 jl_value_t *at = jl_exprarg(e, 2);
                 if (!jl_is_type(rt)) {
-                    rt = jl_interpret_toplevel_expr_in(module, rt, NULL, sparam_vals);
+                    JL_TRY {
+                        rt = jl_interpret_toplevel_expr_in(module, rt, NULL, sparam_vals);
+                    }
+                    JL_CATCH {
+                        if (jl_typeis(jl_exception_in_transit, jl_errorexception_type))
+                            jl_error("could not evaluate ccall return type (it might depend on a local variable)");
+                        else
+                            jl_rethrow();
+                    }
                     jl_exprargset(e, 1, rt);
                 }
                 if (!jl_is_svec(at)) {
-                    at = jl_interpret_toplevel_expr_in(module, at, NULL, sparam_vals);
+                    JL_TRY {
+                        at = jl_interpret_toplevel_expr_in(module, at, NULL, sparam_vals);
+                    }
+                    JL_CATCH {
+                        if (jl_typeis(jl_exception_in_transit, jl_errorexception_type))
+                            jl_error("could not evaluate ccall argument type (it might depend on a local variable)");
+                        else
+                            jl_rethrow();
+                    }
                     jl_exprargset(e, 2, at);
                 }
                 if (jl_is_svec(rt))
                     jl_error("ccall: missing return type");
                 JL_TYPECHK(ccall method definition, type, rt);
                 JL_TYPECHK(ccall method definition, simplevector, at);
-                size_t nargt = jl_svec_len(at);
-                int isVa = (nargt > 0 && jl_is_vararg_type(jl_svecref(at, nargt - 1)));
-                if (nargs % 2 == 0) // ignore calling-convention arg, if present
-                    nargs -= 1;
-                if ((!isVa && nargt    != (nargs - 2) / 2) ||
-                    ( isVa && nargt - 1 > (nargs - 2) / 2)) {
-                    jl_printf(JL_STDERR, "WARNING: ccall: wrong number of arguments to C function in %s\n",
-                            jl_symbol_name(module->name)); // TODO: make this an error
-                }
+                JL_TYPECHK(ccall method definition, quotenode, jl_exprarg(e, 3));
+                JL_TYPECHK(ccall method definition, symbol, *(jl_value_t**)jl_exprarg(e, 3));
+                JL_TYPECHK(ccall method definition, long, jl_exprarg(e, 4));
             }
             if (e->head == method_sym || e->head == abstracttype_sym || e->head == compositetype_sym ||
                 e->head == bitstype_sym || e->head == module_sym) {
@@ -194,7 +204,7 @@ JL_DLLEXPORT jl_method_instance_t *jl_new_method_instance_uninit(void)
     li->functionObjectsDecls.specFunctionObject = NULL;
     li->specTypes = NULL;
     li->inInference = 0;
-    li->def = NULL;
+    li->def.value = NULL;
     li->min_world = 0;
     li->max_world = 0;
     return li;
@@ -236,11 +246,11 @@ STATIC_INLINE jl_value_t *jl_call_staged(jl_svec_t *sparam_vals, jl_method_insta
     fptr.fptr = generator->fptr;
     fptr.jlcall_api = generator->jlcall_api;
     if (__unlikely(fptr.fptr == NULL || fptr.jlcall_api == 0)) {
-        size_t world = generator->def->min_world;
-        void *F = jl_compile_linfo(&generator, (jl_code_info_t*)generator->inferred, world, &jl_default_cgparams).functionObject;
+        size_t world = generator->def.method->min_world;
+        const char *F = jl_compile_linfo(&generator, (jl_code_info_t*)generator->inferred, world, &jl_default_cgparams).functionObject;
         fptr = jl_generate_fptr(generator, F, world);
     }
-    assert(jl_svec_len(generator->def->sparam_syms) == jl_svec_len(sparam_vals));
+    assert(jl_svec_len(generator->def.method->sparam_syms) == jl_svec_len(sparam_vals));
     if (fptr.jlcall_api == 1)
         return fptr.fptr1(args[0], &args[1], nargs-1);
     else if (fptr.jlcall_api == 3)
@@ -256,13 +266,12 @@ JL_DLLEXPORT jl_code_info_t *jl_code_for_staged(jl_method_instance_t *linfo)
     JL_TIMING(STAGED_FUNCTION);
     jl_tupletype_t *tt = (jl_tupletype_t*)linfo->specTypes;
     jl_svec_t *env = linfo->sparam_vals;
-    size_t i, l;
     jl_expr_t *ex = NULL;
     jl_value_t *linenum = NULL;
     jl_svec_t *sparam_vals = env;
-    jl_method_instance_t *generator = linfo->def->generator;
+    jl_method_instance_t *generator = linfo->def.method->generator;
+    assert(generator != NULL);
     assert(linfo != generator);
-    assert(linfo->def->isstaged);
     jl_code_info_t *func = NULL;
     JL_GC_PUSH4(&ex, &linenum, &sparam_vals, &func);
     jl_ptls_t ptls = jl_get_ptls_states();
@@ -271,58 +280,78 @@ JL_DLLEXPORT jl_code_info_t *jl_code_for_staged(jl_method_instance_t *linfo)
     jl_module_t *last_m = ptls->current_module;
     jl_module_t *task_last_m = ptls->current_task->current_module;
     size_t last_age = jl_get_ptls_states()->world_age;
-    assert(jl_svec_len(linfo->def->sparam_syms) == jl_svec_len(sparam_vals));
+    assert(jl_svec_len(linfo->def.method->sparam_syms) == jl_svec_len(sparam_vals));
     JL_TRY {
         ptls->in_pure_callback = 1;
         // need to eval macros in the right module
-        ptls->current_task->current_module = ptls->current_module = linfo->def->module;
+        ptls->current_task->current_module = ptls->current_module = linfo->def.method->module;
         // and the right world
-        ptls->world_age = generator->def->min_world;
+        ptls->world_age = generator->def.method->min_world;
 
         ex = jl_exprn(lambda_sym, 2);
 
-        int nargs = linfo->def->nargs;
-        jl_array_t *argnames = jl_alloc_vec_any(nargs);
+        jl_array_t *argnames = jl_alloc_vec_any(linfo->def.method->nargs);
         jl_array_ptr_set(ex->args, 0, argnames);
-        for (i = 0; i < nargs; i++)
-            jl_array_ptr_set(argnames, i, jl_array_ptr_ref(linfo->def->source->slotnames, i));
+        jl_fill_argnames((jl_array_t*)generator->inferred, argnames);
 
+        // build the rest of the body to pass to expand
         jl_expr_t *scopeblock = jl_exprn(jl_symbol("scope-block"), 1);
         jl_array_ptr_set(ex->args, 1, scopeblock);
-        jl_expr_t *body = jl_exprn(jl_symbol("block"), 2);
-        jl_array_ptr_set(((jl_expr_t*)jl_exprarg(ex,1))->args, 0, body);
-        linenum = jl_box_long(linfo->def->line);
-        jl_value_t *linenode = jl_new_struct(jl_linenumbernode_type, linenum);
+        jl_expr_t *body = jl_exprn(jl_symbol("block"), 3);
+        jl_array_ptr_set(((jl_expr_t*)jl_exprarg(ex, 1))->args, 0, body);
+
+        // add location meta
+        linenum = jl_box_long(linfo->def.method->line);
+        jl_value_t *linenode = jl_new_struct(jl_linenumbernode_type, linenum, linfo->def.method->file);
         jl_array_ptr_set(body->args, 0, linenode);
+        jl_expr_t *pushloc = jl_exprn(meta_sym, 3);
+        jl_array_ptr_set(body->args, 1, pushloc);
+        jl_array_ptr_set(pushloc->args, 0, jl_symbol("push_loc"));
+        jl_array_ptr_set(pushloc->args, 1, linfo->def.method->file); // file
+        jl_array_ptr_set(pushloc->args, 2, jl_symbol("@generated body")); // function
 
         // invoke code generator
         assert(jl_nparams(tt) == jl_array_len(argnames) ||
-               (linfo->def->isva && (jl_nparams(tt) >= jl_array_len(argnames) - 1)));
-        jl_array_ptr_set(body->args, 1,
-                jl_call_staged(sparam_vals, generator, jl_svec_data(tt->parameters), jl_nparams(tt)));
-
-        if (linfo->def->sparam_syms != jl_emptysvec) {
-            // mark this function as having the same static parameters as the generator
-            size_t i, nsp = jl_svec_len(linfo->def->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 ...)
-            for (i = 0; i < nsp; i++)
-                jl_exprarg(newast, i+1) = jl_svecref(linfo->def->sparam_syms, i);
-            ex = newast;
-        }
+               (linfo->def.method->isva && (jl_nparams(tt) >= jl_array_len(argnames) - 1)));
+        jl_value_t *generated_body = jl_call_staged(sparam_vals, generator, jl_svec_data(tt->parameters), jl_nparams(tt));
+        jl_array_ptr_set(body->args, 2, generated_body);
+
+        if (jl_is_code_info(generated_body)) {
+            func = (jl_code_info_t*)generated_body;
+        } else {
+            if (linfo->def.method->sparam_syms != jl_emptysvec) {
+                // mark this function as having the same static parameters as the generator
+                size_t i, nsp = jl_svec_len(linfo->def.method->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 ...)
+                for (i = 0; i < nsp; i++)
+                    jl_exprarg(newast, i+1) = jl_svecref(linfo->def.method->sparam_syms, i);
+                ex = newast;
+            }
 
-        func = (jl_code_info_t*)jl_expand((jl_value_t*)ex);
-        if (!jl_is_code_info(func)) {
-            if (jl_is_expr(func) && ((jl_expr_t*)func)->head == error_sym)
-                jl_interpret_toplevel_expr((jl_value_t*)func);
-            jl_error("generated function body is not pure. this likely means it contains a closure or comprehension.");
-        }
+            func = (jl_code_info_t*)jl_expand((jl_value_t*)ex, linfo->def.method->module);
+            if (!jl_is_code_info(func)) {
+                if (jl_is_expr(func) && ((jl_expr_t*)func)->head == error_sym)
+                    jl_interpret_toplevel_expr_in(linfo->def.method->module, (jl_value_t*)func, NULL, NULL);
+                jl_error("generated function body is not pure. this likely means it contains a closure or comprehension.");
+            }
+
+            jl_array_t *stmts = (jl_array_t*)func->code;
+            size_t i, l;
+            for (i = 0, l = jl_array_len(stmts); i < l; i++) {
+                jl_value_t *stmt = jl_array_ptr_ref(stmts, i);
+                stmt = jl_resolve_globals(stmt, linfo->def.method->module, env);
+                jl_array_ptr_set(stmts, i, stmt);
+            }
 
-        jl_array_t *stmts = (jl_array_t*)func->code;
-        for (i = 0, l = jl_array_len(stmts); i < l; i++) {
-            jl_array_ptr_set(stmts, i, jl_resolve_globals(jl_array_ptr_ref(stmts, i), linfo->def->module, env));
+            // add pop_loc meta
+            jl_array_ptr_1d_push(stmts, jl_nothing);
+            jl_expr_t *poploc = jl_exprn(meta_sym, 1);
+            jl_array_ptr_set(stmts, jl_array_len(stmts) - 1, poploc);
+            jl_array_ptr_set(poploc->args, 0, jl_symbol("pop_loc"));
         }
+
         ptls->in_pure_callback = last_in;
         jl_lineno = last_lineno;
         ptls->current_module = last_m;
@@ -355,11 +384,11 @@ jl_method_instance_t *jl_get_specialized(jl_method_t *m, jl_value_t *types, jl_s
 {
     assert(jl_svec_len(m->sparam_syms) == jl_svec_len(sp) || sp == jl_emptysvec);
     jl_method_instance_t *new_linfo = jl_new_method_instance_uninit();
-    new_linfo->def = m;
+    new_linfo->def.method = m;
     new_linfo->specTypes = types;
     new_linfo->sparam_vals = sp;
     new_linfo->min_world = m->min_world;
-    new_linfo->max_world = m->max_world;
+    new_linfo->max_world = ~(size_t)0;
     return new_linfo;
 }
 
@@ -375,10 +404,11 @@ static void jl_method_set_source(jl_method_t *m, jl_code_info_t *src)
             called |= (1 << (j - 1));
     }
     m->called = called;
+    m->pure = src->pure;
 
     jl_array_t *copy = NULL;
     jl_svec_t *sparam_vars = jl_outer_unionall_vars(m->sig);
-    JL_GC_PUSH2(&copy, &sparam_vars);
+    JL_GC_PUSH3(&copy, &sparam_vars, &src);
     assert(jl_typeis(src->code, jl_array_any_type));
     jl_array_t *stmts = (jl_array_t*)src->code;
     size_t i, n = jl_array_len(stmts);
@@ -386,27 +416,68 @@ static void jl_method_set_source(jl_method_t *m, jl_code_info_t *src)
     int set_lineno = 0;
     for (i = 0; i < n; i++) {
         jl_value_t *st = jl_array_ptr_ref(stmts, i);
-        if (jl_is_expr(st) && ((jl_expr_t*)st)->head == line_sym) {
+        if (jl_is_linenode(st)) {
+            if (!set_lineno) {
+                m->line = jl_linenode_line(st);
+                jl_value_t *file = jl_linenode_file(st);
+                if (jl_is_symbol(file))
+                    m->file = (jl_sym_t*)file;
+                st = jl_nothing;
+                set_lineno = 1;
+            }
+        }
+        else if (jl_is_expr(st) && ((jl_expr_t*)st)->head == line_sym) {
             if (!set_lineno) {
-                m->line = jl_unbox_long(jl_exprarg(st, 0));
-                m->file = (jl_sym_t*)jl_exprarg(st, 1);
+                switch (jl_expr_nargs(st)) {
+                case 2:
+                    m->file = (jl_sym_t*)jl_exprarg(st, 1);
+                    JL_FALLTHROUGH;
+                case 1:
+                    m->line = jl_unbox_long(jl_exprarg(st, 0));
+                    JL_FALLTHROUGH;
+                default: ;
+                }
                 st = jl_nothing;
                 set_lineno = 1;
             }
         }
+        else if (jl_is_expr(st) && ((jl_expr_t*)st)->head == meta_sym &&
+                 jl_expr_nargs(st) > 1 && jl_exprarg(st, 0) == (jl_value_t*)nospecialize_sym) {
+            for (size_t j=1; j < jl_expr_nargs(st); j++) {
+                jl_value_t *aj = jl_exprarg(st, j);
+                if (jl_is_slot(aj)) {
+                    int sn = (int)jl_slot_number(aj) - 2;
+                    if (sn >= 0) {  // @nospecialize on self is valid but currently ignored
+                        if (sn > (m->nargs - 2)) {
+                            jl_error("@nospecialize annotation applied to a non-argument");
+                        }
+                        else if (sn >= sizeof(m->nospecialize) * 8) {
+                            jl_printf(JL_STDERR,
+                                      "WARNING: @nospecialize annotation only supported on the first %d arguments.\n",
+                                      (int)(sizeof(m->nospecialize) * 8));
+                        }
+                        else {
+                            m->nospecialize |= (1 << sn);
+                        }
+                    }
+                }
+            }
+            st = jl_nothing;
+        }
         else {
             st = jl_resolve_globals(st, m->module, sparam_vars);
         }
         jl_array_ptr_set(copy, i, st);
     }
-    copy = jl_compress_ast(m, copy);
-    m->source = jl_copy_code_info(src);
+    src = jl_copy_code_info(src);
+    src->code = copy;
+    jl_gc_wb(src, copy);
+    m->source = (jl_value_t*)jl_compress_ast(m, src);
     jl_gc_wb(m, m->source);
-    m->source->code = copy;
     JL_GC_POP();
 }
 
-JL_DLLEXPORT jl_method_t *jl_new_method_uninit(void)
+JL_DLLEXPORT jl_method_t *jl_new_method_uninit(jl_module_t *module)
 {
     jl_ptls_t ptls = jl_get_ptls_states();
     jl_method_t *m =
@@ -416,7 +487,7 @@ JL_DLLEXPORT jl_method_t *jl_new_method_uninit(void)
     m->sparam_syms = NULL;
     m->ambig = jl_nothing;
     m->roots = NULL;
-    m->module = ptls->current_module;
+    m->module = module;
     m->source = NULL;
     m->unspecialized = NULL;
     m->generator = NULL;
@@ -424,25 +495,26 @@ JL_DLLEXPORT jl_method_t *jl_new_method_uninit(void)
     m->file = empty_sym;
     m->line = 0;
     m->called = 0xff;
+    m->nospecialize = 0;
     m->invokes.unknown = NULL;
-    m->isstaged = 0;
     m->isva = 0;
     m->nargs = 0;
     m->traced = 0;
     m->min_world = 1;
-    m->max_world = ~(size_t)0;
     JL_MUTEX_INIT(&m->writelock);
     return m;
 }
 
 jl_array_t *jl_all_methods;
-jl_method_t *jl_new_method(jl_code_info_t *definition,
-                           jl_sym_t *name,
-                           jl_tupletype_t *sig,
-                           size_t nargs,
-                           int isva,
-                           jl_svec_t *tvars,
-                           int isstaged)
+static jl_method_t *jl_new_method(
+        jl_code_info_t *definition,
+        jl_sym_t *name,
+        jl_module_t *inmodule,
+        jl_tupletype_t *sig,
+        size_t nargs,
+        int isva,
+        jl_svec_t *tvars,
+        int isstaged)
 {
     size_t i, l = jl_svec_len(tvars);
     jl_svec_t *sparam_syms = jl_alloc_svec_uninit(l);
@@ -453,11 +525,10 @@ jl_method_t *jl_new_method(jl_code_info_t *definition,
     jl_method_t *m = NULL;
     JL_GC_PUSH1(&root);
 
-    m = jl_new_method_uninit();
+    m = jl_new_method_uninit(inmodule);
     m->sparam_syms = sparam_syms;
     root = (jl_value_t*)m;
     m->min_world = ++jl_world_counter;
-    m->isstaged = isstaged;
     m->name = name;
     m->sig = (jl_value_t*)sig;
     m->isva = isva;
@@ -468,6 +539,7 @@ jl_method_t *jl_new_method(jl_code_info_t *definition,
         m->generator = jl_get_specialized(m, (jl_value_t*)jl_anytuple_type, jl_emptysvec);
         jl_gc_wb(m, m->generator);
         m->generator->inferred = (jl_value_t*)m->source;
+        m->source = NULL;
     }
 
 #ifdef RECORD_METHOD_ORDER
@@ -490,9 +562,8 @@ extern int jl_boot_file_loaded;
 
 void print_func_loc(JL_STREAM *s, jl_method_t *m);
 
-void jl_check_static_parameter_conflicts(jl_method_t *m, jl_svec_t *t)
+static void jl_check_static_parameter_conflicts(jl_method_t *m, jl_code_info_t *src, jl_svec_t *t)
 {
-    jl_code_info_t *src = m->source;
     size_t nvars = jl_array_len(src->slotnames);
 
     size_t i, n = jl_svec_len(t);
@@ -515,11 +586,12 @@ void jl_check_static_parameter_conflicts(jl_method_t *m, jl_svec_t *t)
 }
 
 // empty generic function def
-JL_DLLEXPORT jl_value_t *jl_generic_function_def(jl_sym_t *name, jl_value_t **bp, jl_value_t *bp_owner,
+JL_DLLEXPORT jl_value_t *jl_generic_function_def(jl_sym_t *name,
+                                                 jl_module_t *module,
+                                                 jl_value_t **bp, jl_value_t *bp_owner,
                                                  jl_binding_t *bnd)
 {
-    jl_ptls_t ptls = jl_get_ptls_states();
-    jl_value_t *gf=NULL;
+    jl_value_t *gf = NULL;
 
     assert(name && bp);
     if (bnd && bnd->value != NULL && !bnd->constp)
@@ -532,7 +604,6 @@ JL_DLLEXPORT jl_value_t *jl_generic_function_def(jl_sym_t *name, jl_value_t **bp
     if (bnd)
         bnd->constp = 1;
     if (*bp == NULL) {
-        jl_module_t *module = (bnd ? bnd->owner : ptls->current_module);
         gf = (jl_value_t*)jl_new_generic_function(name, module);
         *bp = gf;
         if (bp_owner) jl_gc_wb(bp_owner, gf);
@@ -576,9 +647,19 @@ JL_DLLEXPORT jl_datatype_t *jl_first_argument_datatype(jl_value_t *argtypes)
     return first_arg_datatype(argtypes, 0);
 }
 
+// get DataType implied by a single given type, or `nothing`
+JL_DLLEXPORT jl_value_t *jl_argument_datatype(jl_value_t *argt)
+{
+    jl_datatype_t *dt = first_arg_datatype(argt, 1);
+    if (dt == NULL)
+        return jl_nothing;
+    return (jl_value_t*)dt;
+}
+
 extern tracer_cb jl_newmeth_tracer;
 JL_DLLEXPORT void jl_method_def(jl_svec_t *argdata,
                                 jl_code_info_t *f,
+                                jl_module_t *module,
                                 jl_value_t *isstaged)
 {
     // argdata is svec(svec(types...), svec(typevars...))
@@ -594,6 +675,19 @@ JL_DLLEXPORT void jl_method_def(jl_svec_t *argdata,
     jl_methtable_t *mt;
     jl_sym_t *name;
     jl_method_t *m = NULL;
+    size_t i, na = jl_svec_len(atypes);
+    int32_t nospec = 0;
+    for (i=1; i < na; i++) {
+        jl_value_t *ti = jl_svecref(atypes, i);
+        if (ti == jl_ANY_flag ||
+            (jl_is_vararg_type(ti) && jl_tparam0(jl_unwrap_unionall(ti)) == jl_ANY_flag)) {
+            jl_depwarn("`x::ANY` is deprecated, use `@nospecialize(x)` instead.",
+                       (jl_value_t*)jl_symbol("ANY"));
+            if (i <= 32)
+                nospec |= (1 << (i - 1));
+            jl_svecset(atypes, i, jl_substitute_var(ti, (jl_tvar_t*)jl_ANY_flag, (jl_value_t*)jl_any_type));
+        }
+    }
     jl_value_t *argtype = (jl_value_t*)jl_apply_tuple_type(atypes);
     JL_GC_PUSH3(&f, &m, &argtype);
 
@@ -619,14 +713,15 @@ JL_DLLEXPORT void jl_method_def(jl_svec_t *argdata,
         jl_error("cannot add methods to a builtin function");
 
     int j;
-    for(j=(int)jl_svec_len(tvars)-1; j >= 0 ; j--) {
+    for (j = (int)jl_svec_len(tvars) - 1; j >= 0 ; j--) {
         jl_value_t *tv = jl_svecref(tvars,j);
         if (!jl_is_typevar(tv))
             jl_type_error_rt(jl_symbol_name(name), "method definition", (jl_value_t*)jl_tvar_type, tv);
         argtype = jl_new_struct(jl_unionall_type, tv, argtype);
     }
 
-    m = jl_new_method(f, name, (jl_tupletype_t*)argtype, nargs, isva, tvars, isstaged == jl_true);
+    m = jl_new_method(f, name, module, (jl_tupletype_t*)argtype, nargs, isva, tvars, isstaged == jl_true);
+    m->nospecialize |= nospec;
 
     if (jl_has_free_typevars(argtype)) {
         jl_exceptionf(jl_argumenterror_type,
@@ -636,9 +731,8 @@ JL_DLLEXPORT void jl_method_def(jl_svec_t *argdata,
                       m->line);
     }
 
-    jl_check_static_parameter_conflicts(m, tvars);
+    jl_check_static_parameter_conflicts(m, f, tvars);
 
-    size_t i, na = jl_svec_len(atypes);
     for (i = 0; i < na; i++) {
         jl_value_t *elt = jl_svecref(atypes, i);
         if (!jl_is_type(elt) && !jl_is_typevar(elt)) {
@@ -658,6 +752,12 @@ JL_DLLEXPORT void jl_method_def(jl_svec_t *argdata,
                               jl_symbol_name(m->file),
                               m->line);
         }
+        if (jl_is_vararg_type(elt) && i < na-1)
+            jl_exceptionf(jl_argumenterror_type,
+                          "Vararg on non-final argument in method definition for %s at %s:%d",
+                          jl_symbol_name(name),
+                          jl_symbol_name(m->file),
+                          m->line);
     }
 
     int ishidden = !!strchr(jl_symbol_name(name), '#');
diff --git a/src/module.c b/src/module.c
index 9c0492a99b3ee5..d0735a2d25c287 100644
--- a/src/module.c
+++ b/src/module.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 /*
   modules and top-level bindings
@@ -29,7 +29,9 @@ JL_DLLEXPORT jl_module_t *jl_new_module(jl_sym_t *name)
     m->istopmod = 0;
     static unsigned int mcounter; // simple counter backup, in case hrtime is not incrementing
     m->uuid = jl_hrtime() + (++mcounter);
-    if (!m->uuid) m->uuid++; // uuid 0 is invalid
+    if (!m->uuid)
+        m->uuid++; // uuid 0 is invalid
+    m->primary_world = 0;
     m->counter = 0;
     htable_new(&m->bindings, 0);
     arraylist_new(&m->usings, 0);
@@ -59,12 +61,11 @@ JL_DLLEXPORT jl_value_t *jl_f_new_module(jl_sym_t *name, uint8_t std_imports)
     return (jl_value_t*)m;
 }
 
-JL_DLLEXPORT void jl_set_istopmod(uint8_t isprimary)
+JL_DLLEXPORT void jl_set_istopmod(jl_module_t *self, uint8_t isprimary)
 {
-    jl_ptls_t ptls = jl_get_ptls_states();
-    ptls->current_module->istopmod = 1;
+    self->istopmod = 1;
     if (isprimary) {
-        jl_top_module = ptls->current_module;
+        jl_top_module = self;
         jl_append_any_func = NULL;
     }
 }
@@ -190,6 +191,7 @@ static jl_binding_t *jl_get_binding_(jl_module_t *m, jl_sym_t *var, modstack_t *
                     // couldn't resolve; try next using (see issue #6105)
                     continue;
                 if (owner != NULL && tempb->owner != b->owner &&
+                    !tempb->deprecated && !b->deprecated &&
                     !(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",
@@ -261,9 +263,8 @@ static int eq_bindings(jl_binding_t *a, jl_binding_t *b)
 // does module m explicitly import 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;
-    return (bto != HT_NOTFOUND && bto->imported);
+    jl_binding_t *b = (jl_binding_t*)ptrhash_get(&m->bindings, s);
+    return (b != HT_NOTFOUND && b->imported);
 }
 
 // NOTE: we use explici since explicit is a C++ keyword
@@ -280,6 +281,17 @@ static void module_import_(jl_module_t *to, jl_module_t *from, jl_sym_t *s,
                   jl_symbol_name(to->name));
     }
     else {
+        if (b->deprecated && to != jl_main_module && to != jl_base_module &&
+            jl_options.depwarn != JL_OPTIONS_DEPWARN_OFF) {
+            /* with #22763, external packages wanting to replace
+               deprecated Base bindings should simply export the new
+               binding */
+            jl_printf(JL_STDERR,
+                      "WARNING: importing deprecated binding %s.%s into %s.\n",
+                      jl_symbol_name(from->name), jl_symbol_name(s),
+                      jl_symbol_name(to->name));
+        }
+
         jl_binding_t **bp = (jl_binding_t**)ptrhash_bp(&to->bindings, s);
         jl_binding_t *bto = *bp;
         if (bto != HT_NOTFOUND) {
@@ -387,6 +399,7 @@ JL_DLLEXPORT void jl_module_using(jl_module_t *to, jl_module_t *from)
     }
 
     arraylist_push(&to->usings, from);
+    jl_gc_wb(to, from);
 }
 
 JL_DLLEXPORT void jl_module_export(jl_module_t *from, jl_sym_t *s)
@@ -411,23 +424,20 @@ 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_binding_t **bp = (jl_binding_t**)ptrhash_bp(&m->bindings, var);
-    if (*bp == HT_NOTFOUND) return 0;
-    return (*bp)->exportp || (*bp)->owner==m;
+    jl_binding_t *b = (jl_binding_t*)ptrhash_get(&m->bindings, var);
+    return b != HT_NOTFOUND && (b->exportp || b->owner==m);
 }
 
 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;
+    jl_binding_t *b = (jl_binding_t*)ptrhash_get(&m->bindings, var);
+    return b != HT_NOTFOUND && b->exportp;
 }
 
 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_binding_t *b = (jl_binding_t*)ptrhash_get(&m->bindings, var);
+    return b != HT_NOTFOUND && b->owner != NULL;
 }
 
 JL_DLLEXPORT jl_value_t *jl_get_global(jl_module_t *m, jl_sym_t *var)
@@ -459,16 +469,16 @@ JL_DLLEXPORT void jl_set_const(jl_module_t *m, jl_sym_t *var, jl_value_t *val)
 
 JL_DLLEXPORT int jl_is_const(jl_module_t *m, jl_sym_t *var)
 {
-    jl_ptls_t ptls = jl_get_ptls_states();
-    if (m == NULL) m = ptls->current_module;
     jl_binding_t *b = jl_get_binding(m, var);
     return b && b->constp;
 }
 
-JL_DLLEXPORT void jl_deprecate_binding(jl_module_t *m, jl_sym_t *var)
+// set the deprecated flag for a binding:
+//   0=not deprecated, 1=renamed, 2=moved to another package
+JL_DLLEXPORT void jl_deprecate_binding(jl_module_t *m, jl_sym_t *var, int flag)
 {
     jl_binding_t *b = jl_get_binding(m, var);
-    if (b) b->deprecated = 1;
+    if (b) b->deprecated = flag;
 }
 
 JL_DLLEXPORT int jl_is_binding_deprecated(jl_module_t *m, jl_sym_t *var)
@@ -482,7 +492,10 @@ extern int jl_lineno;
 
 void jl_binding_deprecation_warning(jl_binding_t *b)
 {
-    if (b->deprecated && jl_options.depwarn) {
+    // Only print a warning for deprecated == 1 (renamed).
+    // For deprecated == 2 (moved to a package) the binding is to a function
+    // that throws an error, so we don't want to print a warning too.
+    if (b->deprecated == 1 && jl_options.depwarn) {
         if (jl_options.depwarn != JL_OPTIONS_DEPWARN_ERROR)
             jl_printf(JL_STDERR, "WARNING: ");
         if (b->owner)
@@ -491,10 +504,25 @@ void jl_binding_deprecation_warning(jl_binding_t *b)
         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_module(v)/* || (jl_is_function(v) && jl_is_gf(v))*/)) {
-            jl_printf(JL_STDERR, ", use ");
-            jl_static_show(JL_STDERR, v);
-            jl_printf(JL_STDERR, " instead");
+        if (v) {
+            if (jl_is_type(v) || jl_is_module(v)) {
+                jl_printf(JL_STDERR, ", use ");
+                jl_static_show(JL_STDERR, v);
+                jl_printf(JL_STDERR, " instead");
+            }
+            else {
+                jl_methtable_t *mt = jl_gf_mtable(v);
+                if (mt != NULL && (mt->defs.unknown != jl_nothing ||
+                                   jl_isa(v, (jl_value_t*)jl_builtin_type))) {
+                    jl_printf(JL_STDERR, ", use ");
+                    if (mt->module != jl_core_module) {
+                        jl_static_show(JL_STDERR, (jl_value_t*)mt->module);
+                        jl_printf(JL_STDERR, ".");
+                    }
+                    jl_printf(JL_STDERR, "%s", jl_symbol_name(mt->name));
+                    jl_printf(JL_STDERR, " instead");
+                }
+            }
         }
         jl_printf(JL_STDERR, ".\n");
 
diff --git a/src/options.h b/src/options.h
index 93d1f8fb769394..aea15e51fd70e0 100644
--- a/src/options.h
+++ b/src/options.h
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #ifndef JL_OPTIONS_H
 #define JL_OPTIONS_H
@@ -89,6 +89,7 @@
 
 // print all signatures type inference is invoked on
 //#define TRACE_INFERENCE
+//#define TRACE_COMPILE
 
 // print all generic method dispatches (excludes inlined and specialized call
 // sites). this generally prints too much output to be useful.
diff --git a/src/precompile.c b/src/precompile.c
new file mode 100644
index 00000000000000..9843b3bedbdbe2
--- /dev/null
+++ b/src/precompile.c
@@ -0,0 +1,376 @@
+// This file is a part of Julia. License is MIT: https://julialang.org/license
+
+/*
+  precompile.c
+  Generating compiler output artifacts (object files, etc.)
+*/
+
+#include <stdlib.h>
+#include <assert.h>
+
+#include "julia.h"
+#include "julia_internal.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+JL_DLLEXPORT int jl_generating_output(void)
+{
+    return jl_options.outputo || jl_options.outputbc || jl_options.outputunoptbc || jl_options.outputji;
+}
+
+void jl_precompile(int all);
+
+void jl_write_compiler_output(void)
+{
+    if (!jl_generating_output()) {
+        if (jl_options.outputjitbc)
+            jl_dump_native(NULL, jl_options.outputjitbc, NULL, NULL, 0);
+        return;
+    }
+
+    if (!jl_options.incremental)
+        jl_precompile(jl_options.compile_enabled == JL_OPTIONS_COMPILE_ALL);
+
+    if (!jl_module_init_order) {
+        jl_printf(JL_STDERR, "WARNING: --output requested, but no modules defined during run\n");
+        return;
+    }
+
+    if (jl_options.outputjitbc) {
+        jl_printf(JL_STDERR, "WARNING: --output-jit-bc is meaningless with options for dumping sysimage data\n");
+    }
+
+    jl_array_t *worklist = jl_module_init_order;
+    JL_GC_PUSH1(&worklist);
+    jl_module_init_order = jl_alloc_vec_any(0);
+    int i, l = jl_array_len(worklist);
+    for (i = 0; i < l; i++) {
+        jl_value_t *m = jl_arrayref(worklist, i);
+        if (jl_get_global((jl_module_t*)m, jl_symbol("__init__"))) {
+            jl_array_ptr_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);
+        if (jl_options.outputbc || jl_options.outputunoptbc)
+            jl_printf(JL_STDERR, "WARNING: incremental output to a .bc file is not implemented\n");
+        if (jl_options.outputo)
+            jl_printf(JL_STDERR, "WARNING: incremental output to a .o file is not implemented\n");
+    }
+    else {
+        ios_t *s = NULL;
+        if (jl_options.outputo || jl_options.outputbc || jl_options.outputunoptbc)
+            s = jl_create_system_image();
+
+        if (jl_options.outputji) {
+            if (s == NULL) {
+                jl_save_system_image(jl_options.outputji);
+            }
+            else {
+                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, (size_t)s->size);
+                ios_close(&f);
+            }
+        }
+
+        if (jl_options.outputo || jl_options.outputbc || jl_options.outputunoptbc)
+            jl_dump_native(jl_options.outputbc,
+                           jl_options.outputunoptbc,
+                           jl_options.outputo,
+                           (const char*)s->buf, (size_t)s->size);
+    }
+    JL_GC_POP();
+}
+
+static int any_bottom_field(jl_value_t *typ)
+{
+    if (typ == jl_bottom_type)
+        return 1;
+    typ = jl_unwrap_unionall(typ);
+    if (jl_is_vararg_type(typ))
+        typ = jl_unwrap_vararg(typ);
+    if (!jl_is_datatype(typ))
+        return 0;
+    jl_svec_t *fields = ((jl_datatype_t*)typ)->types;
+    size_t i, l = jl_svec_len(fields);
+    if (l != ((jl_datatype_t*)typ)->ninitialized)
+        if (((jl_datatype_t*)typ)->name != jl_tuple_typename)
+            return 0;
+    for (i = 0; i < l; i++) {
+        jl_value_t *ft = jl_svecref(fields, i);
+        if (any_bottom_field(ft))
+            return 1;
+    }
+    return 0;
+}
+
+// f{<:Union{...}}(...) is a common pattern
+// and expanding the Union may give a leaf function
+static void _compile_all_tvar_union(jl_value_t *methsig)
+{
+    if (!jl_is_unionall(methsig) && jl_is_leaf_type(methsig)) {
+        // usually can create a specialized version of the function,
+        // if the signature is already a leaftype
+        if (jl_compile_hint((jl_tupletype_t*)methsig))
+            return;
+    }
+
+    int tvarslen = jl_subtype_env_size(methsig);
+    jl_value_t *sigbody = methsig;
+    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++) {
+        assert(jl_is_unionall(sigbody));
+        idx[i] = 0;
+        env[2 * i] = (jl_value_t*)((jl_unionall_t*)sigbody)->var;
+        env[2 * i + 1] = jl_bottom_type; // initialize the list with Union{}, since T<:Union{} is always a valid option
+        sigbody = ((jl_unionall_t*)sigbody)->body;
+    }
+
+    for (i = 0; i < tvarslen; /* incremented by inner loop */) {
+        jl_value_t *sig;
+        JL_TRY {
+            // TODO: wrap in UnionAll for each tvar in env[2*i + 1] ?
+            // currently doesn't matter much, since jl_compile_hint doesn't work on abstract types
+            sig = (jl_value_t*)jl_instantiate_type_with(sigbody, env, tvarslen);
+        }
+        JL_CATCH {
+            goto getnext; // sigh, we found an invalid type signature. should we warn the user?
+        }
+        if (any_bottom_field(sig))
+            goto getnext; // signature wouldn't be callable / is invalid -- skip it
+        if (jl_is_leaf_type(sig)) {
+            if (jl_compile_hint((jl_tupletype_t*)sig))
+                goto getnext; // success
+        }
+
+    getnext:
+        for (i = 0; i < tvarslen; i++) {
+            jl_tvar_t *tv = (jl_tvar_t*)env[2 * i];
+            if (jl_is_uniontype(tv->ub)) {
+                size_t l = jl_count_union_components(tv->ub);
+                size_t j = idx[i];
+                if (j == l) {
+                    env[2 * i + 1] = jl_bottom_type;
+                    idx[i] = 0;
+                }
+                else {
+                    jl_value_t *ty = jl_nth_union_component(tv->ub, 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;
+            }
+        }
+    }
+    JL_GC_POP();
+}
+
+// f(::Union{...}, ...) is a common pattern
+// and expanding the Union may give a leaf function
+static void _compile_all_union(jl_value_t *sig)
+{
+    jl_tupletype_t *sigbody = (jl_tupletype_t*)jl_unwrap_unionall(sig);
+    size_t count_unions = 0;
+    size_t i, l = jl_svec_len(sigbody->parameters);
+    jl_svec_t *p = NULL;
+    jl_value_t *methsig = NULL;
+
+    for (i = 0; i < l; i++) {
+        jl_value_t *ty = jl_svecref(sigbody->parameters, i);
+        if (jl_is_uniontype(ty))
+            ++count_unions;
+        else if (ty == jl_bottom_type)
+            return; // why does this method exist?
+        else if (!jl_is_leaf_type(ty) && !jl_has_free_typevars(ty))
+            return; // no amount of union splitting will make this a leaftype signature
+    }
+
+    if (count_unions == 0 || count_unions >= 6) {
+        _compile_all_tvar_union(sig);
+        return;
+    }
+
+    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(sigbody->parameters, i);
+            if (jl_is_uniontype(ty)) {
+                size_t l = jl_count_union_components(ty);
+                size_t j = idx[idx_ctr];
+                jl_svecset(p, i, jl_nth_union_component(ty, 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_value_t*)jl_apply_tuple_type(p);
+        methsig = jl_rewrap_unionall(methsig, sig);
+        _compile_all_tvar_union(methsig);
+    }
+
+    JL_GC_POP();
+}
+
+static void _compile_all_deq(jl_array_t *found)
+{
+    int found_i, found_l = jl_array_len(found);
+    jl_printf(JL_STDERR, "found %d uncompiled methods for compile-all\n", (int)found_l);
+    jl_method_instance_t *linfo = NULL;
+    jl_value_t *src = NULL;
+    JL_GC_PUSH2(&linfo, &src);
+    for (found_i = 0; found_i < found_l; found_i++) {
+        if (found_i % (1 + found_l / 300) == 0 || found_i == found_l - 1) // show 300 progress steps, to show progress without overwhelming log files
+            jl_printf(JL_STDERR, " %d / %d\r", found_i + 1, found_l);
+        jl_typemap_entry_t *ml = (jl_typemap_entry_t*)jl_array_ptr_ref(found, found_i);
+        jl_method_t *m = ml->func.method;
+        if (m->source == NULL)  // TODO: generic implementations of generated functions
+            continue;
+        linfo = m->unspecialized;
+        if (!linfo) {
+            linfo = jl_get_specialized(m, (jl_value_t*)m->sig, jl_emptysvec);
+            m->unspecialized = linfo;
+            jl_gc_wb(m, linfo);
+        }
+
+        if (linfo->jlcall_api == 2)
+            continue;
+        src = m->source;
+        // TODO: the `unspecialized` field is not yet world-aware, so we can't store
+        // an inference result there.
+        //src = jl_type_infer(&linfo, jl_world_counter, 1);
+        //m->unspecialized = linfo;
+        //jl_gc_wb(m, linfo);
+        //if (linfo->jlcall_api == 2)
+        //    continue;
+
+        // first try to create leaf signatures from the signature declaration and compile those
+        _compile_all_union((jl_value_t*)ml->sig);
+        // then also compile the generic fallback
+        jl_compile_linfo(&linfo, (jl_code_info_t*)src, jl_world_counter, &jl_default_cgparams);
+        assert(linfo->functionObjectsDecls.functionObject != NULL);
+    }
+    JL_GC_POP();
+    jl_printf(JL_STDERR, "\n");
+}
+
+static int compile_all_enq__(jl_typemap_entry_t *ml, void *env)
+{
+    jl_array_t *found = (jl_array_t*)env;
+    // method definition -- compile template field
+    jl_method_t *m = ml->func.method;
+    if (m->source &&
+        (!m->unspecialized ||
+         (m->unspecialized->functionObjectsDecls.functionObject == NULL &&
+          m->unspecialized->jlcall_api != 2 &&
+          m->unspecialized->fptr == NULL))) {
+        // found a lambda that still needs to be compiled
+        jl_array_ptr_1d_push(found, (jl_value_t*)ml);
+    }
+    return 1;
+}
+
+
+static void compile_all_enq_(jl_methtable_t *mt, void *env)
+{
+    jl_typemap_visitor(mt->defs, compile_all_enq__, env);
+}
+
+void jl_foreach_mtable_in_module(
+        jl_module_t *m,
+        void (*visit)(jl_methtable_t *mt, void *env),
+        void *env);
+
+static void jl_compile_all_defs(void)
+{
+    // this "found" array will contain
+    // TypeMapEntries for Methods and MethodInstances that need to be compiled
+    jl_array_t *m = jl_alloc_vec_any(0);
+    JL_GC_PUSH1(&m);
+    while (1) {
+        jl_foreach_mtable_in_module(jl_main_module, compile_all_enq_, m);
+        size_t changes = jl_array_len(m);
+        if (!changes)
+            break;
+        _compile_all_deq(m);
+        jl_array_del_end(m, changes);
+    }
+    JL_GC_POP();
+}
+
+static int precompile_enq_specialization_(jl_typemap_entry_t *l, void *closure)
+{
+    if (jl_is_method_instance(l->func.value) &&
+            l->func.linfo->functionObjectsDecls.functionObject == NULL &&
+            l->func.linfo->jlcall_api != 2)
+        jl_array_ptr_1d_push((jl_array_t*)closure, (jl_value_t*)l->sig);
+    return 1;
+}
+
+static int precompile_enq_all_specializations__(jl_typemap_entry_t *def, void *closure)
+{
+    jl_typemap_visitor(def->func.method->specializations, precompile_enq_specialization_, closure);
+    return 1;
+}
+
+static void precompile_enq_all_specializations_(jl_methtable_t *mt, void *env)
+{
+    jl_typemap_visitor(mt->defs, precompile_enq_all_specializations__, env);
+}
+
+static void jl_compile_specializations(void)
+{
+    // this "found" array will contain function
+    // type signatures that were inferred but haven't been compiled
+    jl_array_t *m = jl_alloc_vec_any(0);
+    JL_GC_PUSH1(&m);
+    jl_foreach_mtable_in_module(jl_main_module, precompile_enq_all_specializations_, m);
+    size_t i, l;
+    for (i = 0, l = jl_array_len(m); i < l; i++) {
+        jl_compile_hint((jl_tupletype_t*)jl_array_ptr_ref(m, i));
+    }
+    JL_GC_POP();
+}
+
+void jl_precompile(int all)
+{
+    if (all)
+        jl_compile_all_defs();
+    jl_compile_specializations();
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/rtutils.c b/src/rtutils.c
index 5ab199eb9e233f..75ef9e7b565d33 100644
--- a/src/rtutils.c
+++ b/src/rtutils.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 /*
   utility functions used by the runtime system, generated code, and Base library
@@ -236,6 +236,36 @@ JL_DLLEXPORT void jl_pop_handler(int n)
     jl_eh_restore_state(eh);
 }
 
+JL_DLLEXPORT jl_value_t *jl_apply_with_saved_exception_state(jl_value_t **args, uint32_t nargs, int drop_exceptions)
+{
+    jl_ptls_t ptls = jl_get_ptls_states();
+    jl_value_t *exc = ptls->exception_in_transit;
+    jl_array_t *bt = NULL;
+    JL_GC_PUSH2(&exc, &bt);
+    if (ptls->bt_size > 0)
+        bt = (jl_array_t*)jl_get_backtrace();
+    jl_value_t *v;
+    JL_TRY {
+        v = jl_apply(args, nargs);
+    }
+    JL_CATCH {
+        if (!drop_exceptions) {
+            jl_printf(JL_STDERR, "Internal error: encountered unexpected error in runtime:\n");
+            jl_static_show(JL_STDERR, ptls->exception_in_transit);
+            jl_printf(JL_STDERR, "\n");
+            jlbacktrace(); // written to STDERR_FILENO
+        }
+        v = NULL;
+    }
+    ptls->exception_in_transit = exc;
+    if (bt != NULL) {
+        ptls->bt_size = jl_array_len(bt);
+        memcpy(ptls->bt_data, bt->data, ptls->bt_size * sizeof(void*));
+    }
+    JL_GC_POP();
+    return v;
+}
+
 // misc -----------------------------------------------------------------------
 
 // perform f(args...) on stack
@@ -439,24 +469,6 @@ JL_DLLEXPORT jl_value_t *jl_stderr_obj(void)
     return stderr_obj;
 }
 
-static jl_function_t *jl_show_gf=NULL;
-
-JL_DLLEXPORT void jl_show(jl_value_t *stream, jl_value_t *v)
-{
-    if (jl_base_module) {
-        if (jl_show_gf == NULL) {
-            jl_show_gf = (jl_function_t*)jl_get_global(jl_base_module, jl_symbol("show"));
-        }
-        if (jl_show_gf==NULL || stream==NULL) {
-            jl_printf(JL_STDERR, " could not show value of type %s",
-                      jl_symbol_name(((jl_datatype_t*)jl_typeof(v))->name->name));
-            return;
-        }
-        jl_value_t *args[3] = {jl_show_gf,stream,v};
-        jl_apply(args, 3);
-    }
-}
-
 // toys for debugging ---------------------------------------------------------
 
 static size_t jl_show_svec(JL_STREAM *out, jl_svec_t *t, const char *head, const char *opn, const char *cls)
@@ -481,6 +493,22 @@ struct recur_list {
 
 static size_t jl_static_show_x(JL_STREAM *out, jl_value_t *v, struct recur_list *depth);
 
+JL_DLLEXPORT int jl_id_start_char(uint32_t wc);
+JL_DLLEXPORT int jl_id_char(uint32_t wc);
+
+JL_DLLEXPORT int jl_is_identifier(char *str)
+{
+    size_t i = 0;
+    uint32_t wc = u8_nextchar(str, &i);
+    if (!jl_id_start_char(wc))
+        return 0;
+    while ((wc = u8_nextchar(str, &i)) != 0) {
+        if (!jl_id_char(wc))
+            return 0;
+    }
+    return 1;
+}
+
 // `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.
@@ -491,10 +519,10 @@ static size_t jl_static_show_x_(JL_STREAM *out, jl_value_t *v, jl_datatype_t *vt
 {
     size_t n = 0;
     if ((uintptr_t)vt < 4096U) {
-        n += jl_printf(out, "<?#%p::%p>", v, vt);
+        n += jl_printf(out, "<?#%p::%p>", (void*)v, (void*)vt);
     }
     else if ((uintptr_t)v < 4096U) {
-        n += jl_printf(out, "<?#%p::", v);
+        n += jl_printf(out, "<?#%p::", (void*)v);
         n += jl_static_show_x(out, (jl_value_t*)vt, depth);
         n += jl_printf(out, ">");
     }
@@ -505,19 +533,21 @@ static size_t jl_static_show_x_(JL_STREAM *out, jl_value_t *v, jl_datatype_t *vt
     }
     else if (vt == jl_method_instance_type) {
         jl_method_instance_t *li = (jl_method_instance_t*)v;
-        if (li->def) {
-            n += jl_static_show_x(out, (jl_value_t*)li->def->module, depth);
+        if (jl_is_method(li->def.method)) {
+            jl_method_t *m = li->def.method;
+            n += jl_static_show_x(out, (jl_value_t*)m->module, depth);
             if (li->specTypes) {
                 n += jl_printf(out, ".");
                 n += jl_show_svec(out, ((jl_datatype_t*)jl_unwrap_unionall(li->specTypes))->parameters,
-                                  jl_symbol_name(li->def->name), "(", ")");
+                                  jl_symbol_name(m->name), "(", ")");
             }
             else {
-                n += jl_printf(out, ".%s(?)", jl_symbol_name(li->def->name));
+                n += jl_printf(out, ".%s(?)", jl_symbol_name(m->name));
             }
         }
         else {
-            n += jl_printf(out, "<toplevel thunk> -> ");
+            n += jl_static_show_x(out, (jl_value_t*)li->def.module, depth);
+            n += jl_printf(out, ".<toplevel thunk> -> ");
             n += jl_static_show_x(out, li->inferred, depth);
         }
     }
@@ -526,11 +556,49 @@ static size_t jl_static_show_x_(JL_STREAM *out, jl_value_t *v, jl_datatype_t *vt
     }
     else if (vt == jl_datatype_type) {
         jl_datatype_t *dv = (jl_datatype_t*)v;
-        if (dv->name->module != jl_core_module) {
+        jl_sym_t *globname = dv->name->mt != NULL ? dv->name->mt->name : NULL;
+        int globfunc = 0;
+        if (globname && !strchr(jl_symbol_name(globname), '#') &&
+            !strchr(jl_symbol_name(globname), '@') && dv->name->module &&
+            jl_binding_resolved_p(dv->name->module, globname)) {
+            jl_binding_t *b = jl_get_binding(dv->name->module, globname);
+            if (b && jl_typeof(b->value) == v)
+                globfunc = 1;
+        }
+        jl_sym_t *sym = globfunc ? globname : dv->name->name;
+        char *sn = jl_symbol_name(sym);
+        int hidden = !globfunc && strchr(sn, '#');
+        size_t i = 0;
+        int quote = 0;
+        if (hidden) {
+            n += jl_printf(out, "getfield(");
+        }
+        else if (globfunc) {
+            n += jl_printf(out, "typeof(");
+        }
+        if (dv->name->module != jl_core_module || !jl_module_exports_p(jl_core_module, sym)) {
             n += jl_static_show_x(out, (jl_value_t*)dv->name->module, depth);
-            n += jl_printf(out, ".");
+            if (!hidden) {
+                n += jl_printf(out, ".");
+                if (globfunc && !jl_id_start_char(u8_nextchar(sn, &i))) {
+                    n += jl_printf(out, ":(");
+                    quote = 1;
+                }
+            }
+        }
+        if (hidden) {
+            n += jl_printf(out, ", Symbol(\"");
+            n += jl_printf(out, "%s", sn);
+            n += jl_printf(out, "\"))");
+        }
+        else {
+            n += jl_printf(out, "%s", sn);
+            if (globfunc) {
+                n += jl_printf(out, ")");
+                if (quote)
+                    n += jl_printf(out, ")");
+            }
         }
-        n += jl_printf(out, "%s", jl_symbol_name(dv->name->name));
         if (dv->parameters && (jl_value_t*)dv != dv->name->wrapper &&
             (jl_has_free_typevars(v) ||
              (jl_value_t*)dv != (jl_value_t*)jl_tuple_type)) {
@@ -602,6 +670,9 @@ static size_t jl_static_show_x_(JL_STREAM *out, jl_value_t *v, jl_datatype_t *vt
         jl_uv_puts(out, jl_string_data(v), jl_string_len(v)); n += jl_string_len(v);
         n += jl_printf(out, "\"");
     }
+    else if (v == jl_bottom_type) {
+        n += jl_printf(out, "Union{}");
+    }
     else if (vt == jl_uniontype_type) {
         n += jl_printf(out, "Union{");
         while (jl_is_uniontype(v)) {
@@ -662,7 +733,15 @@ static size_t jl_static_show_x_(JL_STREAM *out, jl_value_t *v, jl_datatype_t *vt
         n += jl_printf(out, "%s", jl_symbol_name(m->name));
     }
     else if (vt == jl_sym_type) {
-        n += jl_printf(out, ":%s", jl_symbol_name((jl_sym_t*)v));
+        char *sn = jl_symbol_name((jl_sym_t*)v);
+        int quoted = !jl_is_identifier(sn) && jl_operator_precedence(sn) == 0;
+        if (quoted)
+            n += jl_printf(out, "Symbol(\"");
+        else
+            n += jl_printf(out, ":");
+        n += jl_printf(out, "%s", sn);
+        if (quoted)
+            n += jl_printf(out, "\")");
     }
     else if (vt == jl_ssavalue_type) {
         n += jl_printf(out, "SSAValue(%" PRIuPTR ")",
@@ -683,10 +762,16 @@ static size_t jl_static_show_x_(JL_STREAM *out, jl_value_t *v, jl_datatype_t *vt
         if (!jl_is_symbol(qv)) {
             n += jl_printf(out, "quote ");
         }
+        else {
+            n += jl_printf(out, ":(");
+        }
         n += jl_static_show_x(out, qv, depth);
         if (!jl_is_symbol(qv)) {
             n += jl_printf(out, " end");
         }
+        else {
+            n += jl_printf(out, ")");
+        }
     }
     else if (vt == jl_newvarnode_type) {
         n += jl_printf(out, "<newvar ");
@@ -694,7 +779,9 @@ static size_t jl_static_show_x_(JL_STREAM *out, jl_value_t *v, jl_datatype_t *vt
         n += jl_printf(out, ">");
     }
     else if (vt == jl_linenumbernode_type) {
-        n += jl_printf(out, "# line %" PRIuPTR, jl_linenode_line(v));
+        n += jl_printf(out, "#= ");
+        n += jl_static_show_x(out, jl_linenode_file(v), depth);
+        n += jl_printf(out, ":%" PRIuPTR " =#", jl_linenode_line(v));
     }
     else if (vt == jl_expr_type) {
         jl_expr_t *e = (jl_expr_t*)v;
@@ -778,14 +865,16 @@ static size_t jl_static_show_x_(JL_STREAM *out, jl_value_t *v, jl_datatype_t *vt
         if (nb > 0 && tlen == 0) {
             uint8_t *data = (uint8_t*)v;
             n += jl_printf(out, "0x");
-            for(int i=nb-1; i >= 0; --i)
+            for(int i = nb - 1; i >= 0; --i)
                 n += jl_printf(out, "%02" PRIx8, data[i]);
         }
         else {
-            for (size_t i = 0; i < tlen; i++) {
+            size_t i = 0;
+            if (vt == jl_typemap_entry_type)
+                i = 1;
+            for (; i < tlen; i++) {
                 if (!istuple) {
-                    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, "%s", jl_symbol_name(jl_field_name(vt, i)));
                     n += jl_printf(out, "=");
                 }
                 size_t offs = jl_field_offset(vt, i);
@@ -798,16 +887,20 @@ static size_t jl_static_show_x_(JL_STREAM *out, jl_value_t *v, jl_datatype_t *vt
                                            (jl_datatype_t*)jl_field_type(vt, i),
                                            depth);
                 }
-                if (istuple && tlen==1)
+                if (istuple && tlen == 1)
                     n += jl_printf(out, ",");
-                else if (i != tlen-1)
+                else if (i != tlen - 1)
                     n += jl_printf(out, ", ");
             }
+            if (vt == jl_typemap_entry_type) {
+                n += jl_printf(out, ", next=↩︎\n  ");
+                n += jl_static_show_x(out, jl_fieldref(v, 0), depth);
+            }
         }
         n += jl_printf(out, ")");
     }
     else {
-        n += jl_printf(out, "<?#%p::", v);
+        n += jl_printf(out, "<?#%p::", (void*)v);
         n += jl_static_show_x(out, (jl_value_t*)vt, depth);
         n += jl_printf(out, ">");
     }
@@ -816,8 +909,7 @@ static size_t jl_static_show_x_(JL_STREAM *out, jl_value_t *v, jl_datatype_t *vt
 
 static size_t jl_static_show_x(JL_STREAM *out, jl_value_t *v, struct recur_list *depth)
 {
-    // mimic jl_show, but never calling a julia method and
-    // never allocate through julia gc
+    // show values without calling a julia method or allocating through the GC
     if (v == NULL) {
         return jl_printf(out, "#<null>");
     }
@@ -924,7 +1016,7 @@ void jl_depwarn(const char *msg, jl_value_t *sym)
     JL_GC_POP();
 }
 
-void jl_depwarn_partial_indexing(size_t n)
+JL_DLLEXPORT void jl_depwarn_partial_indexing(size_t n)
 {
     static jl_value_t *depwarn_func = NULL;
     if (!depwarn_func && jl_base_module) {
@@ -932,7 +1024,7 @@ void jl_depwarn_partial_indexing(size_t n)
     }
     if (!depwarn_func) {
         jl_safe_printf("WARNING: Partial linear indexing is deprecated. Use "
-            "`reshape(A, Val{%zd})` to make the dimensionality of the array match "
+            "`reshape(A, Val(%zd))` to make the dimensionality of the array match "
             "the number of indices\n", n);
         return;
     }
diff --git a/src/runtime_ccall.cpp b/src/runtime_ccall.cpp
index 9800805e87106d..142ecd5b4620ec 100644
--- a/src/runtime_ccall.cpp
+++ b/src/runtime_ccall.cpp
@@ -1,12 +1,13 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
+#include "llvm-version.h"
 #include <map>
 #include <string>
 #include <cstdio>
 #include <llvm/Support/Host.h>
+#include "fix_llvm_assert.h"
 #include "julia.h"
 #include "julia_internal.h"
-#include "llvm-version.h"
 using namespace llvm;
 
 // --- library symbol lookup ---
@@ -139,9 +140,9 @@ void *jl_get_library(const char *f_lib)
 {
     void *hnd;
 #ifdef _OS_WINDOWS_
-    if ((intptr_t)f_lib == 1)
+    if (f_lib == JL_EXE_LIBNAME)
         return jl_exe_handle;
-    if ((intptr_t)f_lib == 2)
+    if (f_lib == JL_DL_LIBNAME)
         return jl_dl_handle;
 #endif
     if (f_lib == NULL)
@@ -174,23 +175,13 @@ void *jl_load_and_lookup(const char *f_lib, const char *f_name, void **hnd)
 extern "C" JL_DLLEXPORT
 jl_value_t *jl_get_cpu_name(void)
 {
-#if JL_LLVM_VERSION >= 30500
     StringRef HostCPUName = llvm::sys::getHostCPUName();
-#else
-    const std::string& HostCPUName = llvm::sys::getHostCPUName();
-#endif
     return jl_pchar_to_string(HostCPUName.data(), HostCPUName.size());
 }
 
 extern "C" JL_DLLEXPORT
 jl_value_t *jl_get_JIT(void)
 {
-#if defined(USE_ORCJIT)
     const std::string& HostJITName = "ORCJIT";
-#elif defined(USE_MCJIT)
-    const std::string& HostJITName = "MCJIT";
-#else
-    const std::string& HostJITName = "Unknown";
-#endif
     return jl_pchar_to_string(HostJITName.data(), HostJITName.size());
 }
diff --git a/src/runtime_intrinsics.c b/src/runtime_intrinsics.c
index f1a644196956b1..aefd70238c3ac2 100644
--- a/src/runtime_intrinsics.c
+++ b/src/runtime_intrinsics.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 // This is in implementation of the Julia intrinsic functions against boxed types
 // excluding the native function call interface (ccall, llvmcall)
@@ -46,7 +46,7 @@ JL_DLLEXPORT jl_value_t *jl_pointerref(jl_value_t *p, jl_value_t *i, jl_value_t
     else {
         if (!jl_is_datatype(ety))
             jl_error("pointerref: invalid pointer");
-        size_t nb = LLT_ALIGN(jl_datatype_size(ety), ((jl_datatype_t*)ety)->layout->alignment);
+        size_t nb = LLT_ALIGN(jl_datatype_size(ety), jl_datatype_align(ety));
         char *pp = (char*)jl_unbox_long(p) + (jl_unbox_long(i)-1)*nb;
         return jl_new_bits(ety, pp);
     }
@@ -67,7 +67,7 @@ JL_DLLEXPORT jl_value_t *jl_pointerset(jl_value_t *p, jl_value_t *x, jl_value_t
     else {
         if (!jl_is_datatype(ety))
             jl_error("pointerset: invalid pointer");
-        size_t nb = LLT_ALIGN(jl_datatype_size(ety), ((jl_datatype_t*)ety)->layout->alignment);
+        size_t nb = LLT_ALIGN(jl_datatype_size(ety), jl_datatype_align(ety));
         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");
@@ -378,15 +378,13 @@ static inline jl_value_t *jl_intrinsiclambda_u1(jl_value_t *ty, void *pa, unsign
 
 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) \
+#define cvt_iintrinsic(LLVMOP, 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); \
+    return jl_intrinsic_cvt(ty, a, #name, LLVMOP); \
 }
-#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)
+static inline jl_value_t *jl_intrinsic_cvt(jl_value_t *ty, jl_value_t *a, const char *name, intrinsic_cvt_t op)
 {
     jl_ptls_t ptls = jl_get_ptls_states();
     jl_value_t *aty = jl_typeof(a);
@@ -397,8 +395,6 @@ static inline jl_value_t *jl_intrinsic_cvt(jl_value_t *ty, jl_value_t *a, const
     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 = jl_gc_alloc(ptls, jl_datatype_size(ty), ty);
     op(aty == (jl_value_t*)jl_bool_type ? 1 : isize * host_char_bit, pa,
             osize * host_char_bit, jl_data_ptr(newv));
@@ -847,36 +843,6 @@ cvt_iintrinsic(LLVMFPtoUI, fptoui)
 un_fintrinsic_withtype(fpcvt,fptrunc)
 un_fintrinsic_withtype(fpcvt,fpext)
 
-// 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)
-
-JL_DLLEXPORT jl_value_t *jl_check_top_bit(jl_value_t *a)
-{
-    jl_value_t *ty = jl_typeof(a);
-    if (!jl_is_primitivetype(ty))
-        jl_error("check_top_bit: value is not a primitive type");
-    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 \
@@ -911,8 +877,6 @@ bi_iintrinsic_fast(jl_LLVMFlipSign, flipsign, flipsign_int,  )
 #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)
@@ -925,31 +889,6 @@ 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_ptls_t ptls = jl_get_ptls_states();
-    jl_value_t *ty = jl_typeof(a);
-    if (!jl_is_primitivetype(ty))
-        jl_error("powi_llvm: a is not a primitive type");
-    if (!jl_is_primitivetype(jl_typeof(b)) || jl_datatype_size(jl_typeof(b)) != 4)
-        jl_error("powi_llvm: b is not a 32-bit primitive type");
-    int sz = jl_datatype_size(ty);
-    jl_value_t *newv = jl_gc_alloc(ptls, sz, ty);
-    void *pa = jl_data_ptr(a), *pr = jl_data_ptr(newv);
-    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);
diff --git a/src/safepoint.c b/src/safepoint.c
index 2874266ebe4b51..43dad38f4fad49 100644
--- a/src/safepoint.c
+++ b/src/safepoint.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include "julia.h"
 #include "julia_internal.h"
@@ -110,6 +110,10 @@ void jl_safepoint_init(void)
 int jl_safepoint_start_gc(void)
 {
 #ifdef JULIA_ENABLE_THREADING
+    if (jl_n_threads == 1) {
+        jl_gc_running = 1;
+        return 1;
+    }
     // The thread should have set this already
     assert(jl_get_ptls_states()->gc_state == JL_GC_STATE_WAITING);
     jl_mutex_lock_nogc(&safepoint_lock);
@@ -139,6 +143,10 @@ void jl_safepoint_end_gc(void)
 {
     assert(jl_gc_running);
 #ifdef JULIA_ENABLE_THREADING
+    if (jl_n_threads == 1) {
+        jl_gc_running = 0;
+        return;
+    }
     jl_mutex_lock_nogc(&safepoint_lock);
     // Need to reset the page protection before resetting the flag since
     // the thread will trigger a segfault immediately after returning from
diff --git a/src/signal-handling.c b/src/signal-handling.c
index 78968c05ed91e6..d8d0bf553889d7 100644
--- a/src/signal-handling.c
+++ b/src/signal-handling.c
@@ -1,10 +1,15 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include <stdlib.h>
 #include <stddef.h>
 #include <stdio.h>
+#include <inttypes.h>
 #include "julia.h"
 #include "julia_internal.h"
+#ifndef _OS_WINDOWS_
+#include <unistd.h>
+#include <sys/mman.h>
+#endif
 
 #ifdef __cplusplus
 extern "C" {
@@ -88,12 +93,133 @@ JL_DLLEXPORT void jl_exit_on_sigint(int on)
     exit_on_sigint = on;
 }
 
+static uintptr_t jl_get_pc_from_ctx(const void *_ctx);
+void jl_show_sigill(void *_ctx);
+static size_t jl_safe_read_mem(const volatile char *ptr, char *out, size_t len)
+{
+    jl_ptls_t ptls = jl_get_ptls_states();
+    jl_jmp_buf *old_buf = ptls->safe_restore;
+    jl_jmp_buf buf;
+    ptls->safe_restore = &buf;
+    volatile size_t i = 0;
+    if (!jl_setjmp(buf, 0)) {
+        for (;i < len;i++) {
+            out[i] = ptr[i];
+        }
+    }
+    ptls->safe_restore = old_buf;
+    return i;
+}
+
 #if defined(_WIN32)
 #include "signals-win.c"
 #else
 #include "signals-unix.c"
 #endif
 
+static uintptr_t jl_get_pc_from_ctx(const void *_ctx)
+{
+#if defined(_OS_LINUX_) && defined(_CPU_X86_64_)
+    return ((ucontext_t*)_ctx)->uc_mcontext.gregs[REG_RIP];
+#elif defined(_OS_FREEBSD_) && defined(_CPU_X86_64_)
+    return ((ucontext_t*)_ctx)->uc_mcontext.mc_rip;
+#elif defined(_OS_LINUX_) && defined(_CPU_X86_)
+    return ((ucontext_t*)_ctx)->uc_mcontext.gregs[REG_EIP];
+#elif defined(_OS_FREEBSD_) && defined(_CPU_X86_)
+    return ((ucontext_t*)_ctx)->uc_mcontext.mc_eip;
+#elif defined(_OS_DARWIN_)
+    return ((ucontext64_t*)_ctx)->uc_mcontext64->__ss.__rip;
+#elif defined(_OS_WINDOWS_) && defined(_CPU_X86_)
+    return ((CONTEXT*)_ctx)->Eip;
+#elif defined(_OS_WINDOWS_) && defined(_CPU_X86_64_)
+    return ((CONTEXT*)_ctx)->Rip;
+#elif defined(_OS_LINUX_) && defined(_CPU_AARCH64_)
+    return ((ucontext_t*)_ctx)->uc_mcontext.pc;
+#elif defined(_OS_LINUX_) && defined(_CPU_ARM_)
+    return ((ucontext_t*)_ctx)->uc_mcontext.arm_pc;
+#else
+    // TODO for PPC
+    return 0;
+#endif
+}
+
+void jl_show_sigill(void *_ctx)
+{
+    char *pc = (char*)jl_get_pc_from_ctx(_ctx);
+    // unsupported platform
+    if (!pc)
+        return;
+#if defined(_CPU_X86_64_) || defined(_CPU_X86_)
+    uint8_t inst[15]; // max length of x86 instruction
+    size_t len = jl_safe_read_mem(pc, (char*)inst, sizeof(inst));
+    // ud2
+    if (len >= 2 && inst[0] == 0x0f && inst[1] == 0x0b) {
+        jl_safe_printf("Unreachable reached at %p\n", (void*)pc);
+    }
+    else {
+        jl_safe_printf("Invalid instruction at %p: ", (void*)pc);
+        for (int i = 0;i < len;i++) {
+            if (i == 0) {
+                jl_safe_printf("0x%02" PRIx8, inst[i]);
+            }
+            else {
+                jl_safe_printf(", 0x%02" PRIx8, inst[i]);
+            }
+        }
+        jl_safe_printf("\n");
+    }
+#elif defined(_OS_LINUX_) && defined(_CPU_AARCH64_)
+    uint32_t inst = 0;
+    size_t len = jl_safe_read_mem(pc, (char*)&inst, 4);
+    if (len < 4)
+        jl_safe_printf("Fault when reading instruction: %d bytes read\n", (int)len);
+    if (inst == 0xd4200020) { // brk #0x1
+        // The signal might actually be SIGTRAP instead, doesn't hurt to handle it here though.
+        jl_safe_printf("Unreachable reached at %p\n", pc);
+    }
+    else {
+        jl_safe_printf("Invalid instruction at %p: 0x%08" PRIx32 "\n", pc, inst);
+    }
+#elif defined(_OS_LINUX_) && defined(_CPU_ARM_)
+    ucontext_t *ctx = (ucontext_t*)_ctx;
+    if (ctx->uc_mcontext.arm_cpsr & (1 << 5)) {
+        // Thumb
+        uint16_t inst[2] = {0, 0};
+        size_t len = jl_safe_read_mem(pc, (char*)&inst, 4);
+        if (len < 2)
+            jl_safe_printf("Fault when reading Thumb instruction: %d bytes read\n", (int)len);
+        // LLVM and GCC uses different code for the trap...
+        if (inst[0] == 0xdefe || inst[0] == 0xdeff) {
+            // The signal might actually be SIGTRAP instead, doesn't hurt to handle it here though.
+            jl_safe_printf("Unreachable reached in Thumb mode at %p: 0x%04" PRIx16 "\n",
+                           (void*)pc, inst[0]);
+        }
+        else {
+            jl_safe_printf("Invalid Thumb instruction at %p: 0x%04" PRIx16 ", 0x%04" PRIx16 "\n",
+                           (void*)pc, inst[0], inst[1]);
+        }
+    }
+    else {
+        uint32_t inst = 0;
+        size_t len = jl_safe_read_mem(pc, (char*)&inst, 4);
+        if (len < 4)
+            jl_safe_printf("Fault when reading instruction: %d bytes read\n", (int)len);
+        // LLVM and GCC uses different code for the trap...
+        if (inst == 0xe7ffdefe || inst == 0xe7f000f0) {
+            // The signal might actually be SIGTRAP instead, doesn't hurt to handle it here though.
+            jl_safe_printf("Unreachable reached in ARM mode at %p: 0x%08" PRIx32 "\n",
+                           (void*)pc, inst);
+        }
+        else {
+            jl_safe_printf("Invalid ARM instruction at %p: 0x%08" PRIx32 "\n", (void*)pc, inst);
+        }
+    }
+#else
+    // TODO for PPC
+    (void)_ctx;
+#endif
+}
+
 // what to do on a critical error
 void jl_critical_error(int sig, bt_context_t *context, uintptr_t *bt_data, size_t *bt_size)
 {
diff --git a/src/signals-mach.c b/src/signals-mach.c
index cd7cb1b8265578..8534eb6e8bafe6 100644
--- a/src/signals-mach.c
+++ b/src/signals-mach.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include <mach/clock.h>
 #include <mach/clock_types.h>
@@ -141,10 +141,12 @@ static void jl_throw_in_thread(int tid, mach_port_t thread, jl_value_t *exceptio
     kern_return_t ret = thread_get_state(thread, x86_THREAD_STATE64, (thread_state_t)&state, &count);
     HANDLE_MACH_ERROR("thread_get_state", ret);
     jl_ptls_t ptls2 = jl_all_tls_states[tid];
-
-    ptls2->bt_size = rec_backtrace_ctx(ptls2->bt_data, JL_MAX_BT_SIZE,
-                                       (bt_context_t*)&state);
-    ptls2->exception_in_transit = exception;
+    if (!ptls2->safe_restore) {
+        assert(exception);
+        ptls2->bt_size = rec_backtrace_ctx(ptls2->bt_data, JL_MAX_BT_SIZE,
+                                           (bt_context_t*)&state);
+        ptls2->exception_in_transit = exception;
+    }
     jl_call_in_state(ptls2, &state, &jl_rethrow);
     ret = thread_set_state(thread, x86_THREAD_STATE64,
                            (thread_state_t)&state, count);
@@ -214,6 +216,10 @@ kern_return_t catch_exception_raise(mach_port_t            exception_port,
         }
         return KERN_SUCCESS;
     }
+    if (ptls2->safe_restore) {
+        jl_throw_in_thread(tid, thread, jl_stackovf_exception);
+        return KERN_SUCCESS;
+    }
 #ifdef SEGV_EXCEPTION
     if (1) {
 #else
diff --git a/src/signals-unix.c b/src/signals-unix.c
index d49485625a87ff..2b69f43d6a972b 100644
--- a/src/signals-unix.c
+++ b/src/signals-unix.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include <signal.h>
 #include <sys/types.h>
@@ -117,7 +117,7 @@ static void jl_call_in_ctx(jl_ptls_t ptls, void (*fptr)(void), void *_ctx)
     ucontext_t *ctx = (ucontext_t*)_ctx;
     uintptr_t target = (uintptr_t)fptr;
     // Apparently some glibc's sigreturn target is running in thumb state.
-    // Mimic a `bx` instruction by settting the T(5) bit of CPSR
+    // Mimic a `bx` instruction by setting the T(5) bit of CPSR
     // depending on the target address.
     uintptr_t cpsr = ctx->uc_mcontext.arm_cpsr;
     // Thumb mode function pointer should have the lowest bit set
@@ -177,6 +177,8 @@ void sigdie_handler(int sig, siginfo_t *info, void *context)
     jl_ptls_t ptls = jl_get_ptls_states();
     sigset_t sset;
     uv_tty_reset_mode();
+    if (sig == SIGILL)
+        jl_show_sigill(context);
     jl_critical_error(sig, jl_to_bt_context(context),
                       ptls->bt_data, &ptls->bt_size);
     sigfillset(&sset);
@@ -282,6 +284,7 @@ static void allocate_segv_handler(void)
     }
 }
 
+#if !defined(JL_DISABLE_LIBUNWIND)
 static unw_context_t *volatile signal_context;
 static pthread_mutex_t in_signal_lock;
 static pthread_cond_t exit_signal_cond;
@@ -308,6 +311,7 @@ static void jl_thread_resume(int tid, int sig)
     assert(jl_atomic_load_acquire(&ptls2->signal_request) == 0);
     pthread_mutex_unlock(&in_signal_lock);
 }
+#endif
 
 // Throw jl_interrupt_exception if the master thread is in a signal async region
 // or if SIGINT happens too often.
@@ -358,6 +362,7 @@ void usr2_handler(int sig, siginfo_t *info, void *ctx)
 {
     jl_ptls_t ptls = jl_get_ptls_states();
     sig_atomic_t request = jl_atomic_exchange(&ptls->signal_request, 0);
+#if !defined(JL_DISABLE_LIBUNWIND)
     if (request == 1) {
         signal_context = jl_to_bt_context(ctx);
 
@@ -370,7 +375,9 @@ void usr2_handler(int sig, siginfo_t *info, void *ctx)
         pthread_cond_broadcast(&signal_caught_cond);
         pthread_mutex_unlock(&in_signal_lock);
     }
-    else if (request == 2) {
+    else
+#endif
+    if (request == 2) {
         jl_unblock_signal(sig);
         int force = jl_check_force_sigint();
         if (force || (!ptls->defer_signal && ptls->io_wait)) {
@@ -482,7 +489,7 @@ void jl_install_thread_signal_handler(jl_ptls_t ptls)
     void *signal_stack = alloc_sigstack(sig_stack_size);
     stack_t ss;
     ss.ss_flags = 0;
-    ss.ss_size = sig_stack_size;
+    ss.ss_size = sig_stack_size - 16;
     ss.ss_sp = signal_stack;
     if (sigaltstack(&ss, NULL) < 0) {
         jl_errorf("fatal error: sigaltstack: %s", strerror(errno));
@@ -524,9 +531,7 @@ static void *signal_listener(void *arg)
     static uintptr_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;
@@ -589,9 +594,11 @@ static void *signal_listener(void *arg)
 #endif
 
         bt_size = 0;
+#if !defined(JL_DISABLE_LIBUNWIND)
+        unw_context_t *signal_context;
         // sample each thread, round-robin style in reverse order
         // (so that thread zero gets notified last)
-        for (i = jl_n_threads; i-- > 0; ) {
+        for (int i = jl_n_threads; i-- > 0; ) {
             // notify thread to stop
             jl_thread_suspend_and_get_state(i, &signal_context);
 
@@ -622,6 +629,7 @@ static void *signal_listener(void *arg)
             // notify thread to resume
             jl_thread_resume(i, sig);
         }
+#endif
 
         // this part is async with the running of the rest of the program
         // and must be thread-safe, but not necessarily signal-handler safe
@@ -645,7 +653,7 @@ void restore_signals(void)
     jl_sigsetset(&sset);
     sigprocmask(SIG_SETMASK, &sset, 0);
 
-#if !defined(HAVE_MACH)
+#if !defined(HAVE_MACH) && !defined(JL_DISABLE_LIBUNWIND)
     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) {
diff --git a/src/signals-win.c b/src/signals-win.c
index c8901e153ef3c2..0672da59a17cbf 100644
--- a/src/signals-win.c
+++ b/src/signals-win.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 // Windows
 
@@ -86,8 +86,12 @@ void __cdecl crt_sig_handler(int sig, int num)
         }
         break;
     default: // SIGSEGV, (SSIGTERM, IGILL)
+        if (ptls->safe_restore)
+            jl_rethrow();
         memset(&Context, 0, sizeof(Context));
         RtlCaptureContext(&Context);
+        if (sig == SIGILL)
+            jl_show_sigill(&Context);
         jl_critical_error(sig, &Context, ptls->bt_data, &ptls->bt_size);
         raise(sig);
     }
@@ -105,7 +109,6 @@ void restore_signals(void)
 void jl_throw_in_ctx(jl_value_t *excpt, CONTEXT *ctxThread, int bt)
 {
     jl_ptls_t ptls = jl_get_ptls_states();
-    assert(excpt != NULL);
 #if defined(_CPU_X86_64_)
     DWORD64 Rsp = (ctxThread->Rsp&(DWORD64)-16) - 8;
 #elif defined(_CPU_X86_)
@@ -113,9 +116,12 @@ void jl_throw_in_ctx(jl_value_t *excpt, CONTEXT *ctxThread, int bt)
 #else
 #error WIN16 not supported :P
 #endif
-    ptls->bt_size = bt ? rec_backtrace_ctx(ptls->bt_data, JL_MAX_BT_SIZE,
-                                           ctxThread) : 0;
-    ptls->exception_in_transit = excpt;
+    if (!ptls->safe_restore) {
+        assert(excpt != NULL);
+        ptls->bt_size = bt ? rec_backtrace_ctx(ptls->bt_data, JL_MAX_BT_SIZE,
+                                               ctxThread) : 0;
+        ptls->exception_in_transit = excpt;
+    }
 #if defined(_CPU_X86_64_)
     *(DWORD64*)Rsp = 0;
     ctxThread->Rsp = Rsp;
@@ -220,12 +226,20 @@ static LONG WINAPI _exception_handler(struct _EXCEPTION_POINTERS *ExceptionInfo,
                     }
                     return EXCEPTION_CONTINUE_EXECUTION;
                 }
+                if (ptls->safe_restore) {
+                    jl_throw_in_ctx(NULL, ExceptionInfo->ContextRecord, in_ctx);
+                    return EXCEPTION_CONTINUE_EXECUTION;
+                }
                 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;
                 }
         }
+        if (ExceptionInfo->ExceptionRecord->ExceptionCode == EXCEPTION_ILLEGAL_INSTRUCTION) {
+            jl_safe_printf("\n");
+            jl_show_sigill(ExceptionInfo->ContextRecord);
+        }
         jl_safe_printf("\nPlease submit a bug report with steps to reproduce this fault, and any error messages that follow (in their entirety). Thanks.\nException: ");
         switch (ExceptionInfo->ExceptionRecord->ExceptionCode) {
             case EXCEPTION_ACCESS_VIOLATION:
diff --git a/src/simplevector.c b/src/simplevector.c
index 9322692059840c..69247924a6ee96 100644
--- a/src/simplevector.c
+++ b/src/simplevector.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include <stdlib.h>
 #include <string.h>
@@ -19,6 +19,19 @@ JL_DLLEXPORT jl_svec_t *jl_svec(size_t n, ...)
     return jv;
 }
 
+jl_svec_t *jl_perm_symsvec(size_t n, ...)
+{
+    if (n == 0) return jl_emptysvec;
+    jl_svec_t *jv = (jl_svec_t*)jl_gc_permobj((n + 1) * sizeof(void*), jl_simplevector_type);
+    jl_svec_set_len_unsafe(jv, n);
+    va_list args;
+    va_start(args, n);
+    for (size_t i = 0; i < n; i++)
+        jl_svecset(jv, i, jl_symbol(va_arg(args, const char*)));
+    va_end(args);
+    return jv;
+}
+
 JL_DLLEXPORT jl_svec_t *jl_svec1(void *a)
 {
     jl_ptls_t ptls = jl_get_ptls_states();
diff --git a/src/stackwalk.c b/src/stackwalk.c
index d3b8cf12a2f133..1f1cd043c42966 100644
--- a/src/stackwalk.c
+++ b/src/stackwalk.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 /*
   stackwalk.c
@@ -13,8 +13,10 @@
 // returning from the callee function will invalidate the context
 #ifdef _OS_WINDOWS_
 #define jl_unw_get(context) RtlCaptureContext(context)
-#else
+#elif !defined(JL_DISABLE_LIBUNWIND)
 #define jl_unw_get(context) unw_getcontext(context)
+#else
+void jl_unw_get(void *context) {};
 #endif
 
 #ifdef __cplusplus
@@ -302,7 +304,7 @@ static int jl_unw_step(bt_cursor_t *cursor, uintptr_t *ip, uintptr_t *sp)
 #endif
 }
 
-#else
+#elif !defined(JL_DISABLE_LIBUNWIND)
 // stacktrace using libunwind
 
 static int jl_unw_init(bt_cursor_t *cursor, bt_context_t *context)
@@ -338,6 +340,18 @@ size_t rec_backtrace_ctx_dwarf(uintptr_t *data, size_t maxsize,
     return n > maxsize ? maxsize : n;
 }
 #endif
+
+#else
+// stacktraces are disabled
+static int jl_unw_init(bt_cursor_t *cursor, bt_context_t *context)
+{
+    return 0;
+}
+
+static int jl_unw_step(bt_cursor_t *cursor, uintptr_t *ip, uintptr_t *sp)
+{
+    return 0;
+}
 #endif
 
 JL_DLLEXPORT jl_value_t *jl_lookup_code_address(void *ip, int skipC)
diff --git a/src/staticdata.c b/src/staticdata.c
new file mode 100644
index 00000000000000..f2ab5700293ed5
--- /dev/null
+++ b/src/staticdata.c
@@ -0,0 +1,1694 @@
+// This file is a part of Julia. License is MIT: https://julialang.org/license
+
+/*
+  saving and restoring system images
+*/
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#include "julia.h"
+#include "julia_internal.h"
+#include "builtin_proto.h"
+
+#ifndef _OS_WINDOWS_
+#include <dlfcn.h>
+#endif
+
+#ifndef _COMPILER_MICROSOFT_
+#include "valgrind.h"
+#else
+#define RUNNING_ON_VALGRIND 0
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// TODO: put WeakRefs on the weak_refs list during deserialization
+// TODO: handle finalizers
+
+// hash of definitions for predefined tagged object
+static htable_t sertag_table;
+static htable_t symbol_table;
+static uintptr_t nsym_tag;
+// array of definitions for the predefined tagged object types
+// (reverse of sertag_table and symbol_table)
+static arraylist_t deser_tag;
+static arraylist_t deser_sym;
+
+// table of all objects that are serialized
+static htable_t backref_table;
+static int backref_table_numel;
+static arraylist_t layout_table;
+
+// list of (size_t pos, (void *f)(jl_value_t*)) entries
+// for the serializer to mark values in need of rework by function f
+// during deserialization later
+static arraylist_t reinit_list;
+
+// list of modules being deserialized with __init__ methods
+// (not used in MODE_AST)
+jl_array_t *jl_module_init_order;
+
+// hash of definitions for predefined function pointers
+static htable_t fptr_to_id;
+// array of definitions for the predefined function pointers
+// (reverse of fptr_to_id)
+static const jl_fptr_t id_to_fptrs[] = {
+    NULL, NULL,
+    jl_f_throw, jl_f_is, jl_f_typeof, jl_f_issubtype, jl_f_isa,
+    jl_f_typeassert, jl_f__apply, jl_f__apply_pure, jl_f__apply_latest, jl_f_isdefined,
+    jl_f_tuple, jl_f_svec, jl_f_intrinsic_call, jl_f_invoke_kwsorter,
+    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_f_sizeof, jl_f__expr,
+    NULL };
+
+typedef enum _DUMP_MODES {
+    // not in the serializer at all, or
+    // something is seriously wrong
+    MODE_INVALID = 0,
+
+    // jl_restore_system_image
+    // restoring an entire system image from disk
+    MODE_SYSTEM_IMAGE,
+} DUMP_MODES;
+
+typedef struct {
+    ios_t *s;
+    ios_t *const_data;
+    ios_t *symbols;
+    ios_t *relocs;
+    ios_t *gvar_record;
+    ios_t *fptr_record;
+    arraylist_t relocs_list;
+    arraylist_t gctags_list;
+    DUMP_MODES mode;
+    jl_ptls_t ptls;
+} jl_serializer_state;
+
+static jl_value_t *jl_idtable_type = NULL;
+static arraylist_t builtin_typenames;
+
+enum RefTags {
+    DataRef,
+    ConstDataRef,
+    TagRef,
+    SymbolRef,
+    BindingRef
+};
+
+// this supports up to 1 GB images and 16 RefTags
+// if a larger size is required, will need to add support for writing larger relocations in many cases below
+#define RELOC_TAG_OFFSET 28
+
+
+/* read and write in network (bigendian) order: */
+
+#define write_uint8(s, n) ios_putc((n), (s))
+#define read_uint8(s) ((uint8_t)ios_getc((s)))
+
+static void write_uint32(ios_t *s, uint32_t i)
+{
+    write_uint8(s, (i >> 24) & 0xff);
+    write_uint8(s, (i >> 16) & 0xff);
+    write_uint8(s, (i >> 8) & 0xff);
+    write_uint8(s, i        & 0xff);
+}
+
+static uint32_t read_uint32(ios_t *s)
+{
+    uint32_t b3 = read_uint8(s);
+    uint32_t b2 = read_uint8(s);
+    uint32_t b1 = read_uint8(s);
+    uint32_t b0 = read_uint8(s);
+    return b0 | (b1 << 8) | (b2 << 16) | (b3 << 24);
+}
+
+
+// --- Static Compile ---
+
+#ifdef HAVE_CPUID
+extern void jl_cpuid(int32_t CPUInfo[4], int32_t InfoType);
+#endif
+
+extern int globalUnique;
+static void *jl_sysimg_handle = NULL;
+static uint64_t sysimage_base = 0;
+static uintptr_t *sysimg_gvars_base = NULL;
+static const int32_t *sysimg_gvars_offsets = NULL;
+static const char *sysimg_fvars_base = NULL;
+static const int32_t *sysimg_fvars_offsets = NULL;
+
+static inline uintptr_t *sysimg_gvars(uintptr_t *base, size_t idx)
+{
+    return base + sysimg_gvars_offsets[idx] / sizeof(base[0]);
+}
+
+static inline uintptr_t sysimg_fvars(const char *base, size_t idx)
+{
+    return (uintptr_t)(base + sysimg_fvars_offsets[idx]);
+}
+
+JL_DLLEXPORT int jl_running_on_valgrind(void)
+{
+    return RUNNING_ON_VALGRIND;
+}
+
+static void jl_load_sysimg_so(void)
+{
+#ifndef _OS_WINDOWS_
+    Dl_info dlinfo;
+#endif
+    int imaging_mode = jl_generating_output() && !jl_options.incremental;
+    // 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_base = (uintptr_t*)jl_dlsym(jl_sysimg_handle, "jl_sysimg_gvars_base");
+        sysimg_gvars_offsets = (const int32_t*)jl_dlsym(jl_sysimg_handle,
+                                                        "jl_sysimg_gvars_offsets");
+        sysimg_fvars_base = (const char*)jl_dlsym(jl_sysimg_handle, "jl_sysimg_fvars_base");
+        sysimg_fvars_offsets = (const int32_t*)jl_dlsym(jl_sysimg_handle,
+                                                        "jl_sysimg_fvars_offsets");
+        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(sysimg_gvars_base, tls_getter_idx - 1) =
+            (uintptr_t)jl_get_ptls_states_getter();
+        size_t tls_offset_idx = *(size_t*)jl_dlsym(jl_sysimg_handle,
+                                                   "jl_tls_offset_idx");
+        *sysimg_gvars(sysimg_gvars_base, tls_offset_idx - 1) =
+            (uintptr_t)(jl_tls_offset == -1 ? 0 : jl_tls_offset);
+#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"
+                     "Please delete or regenerate sys.{so,dll,dylib}.");
+#ifdef HAVE_CPUID
+        uint32_t info[4];
+        jl_cpuid((int32_t*)info, 1);
+        if (strcmp(cpu_target, "native") == 0) {
+            if (!RUNNING_ON_VALGRIND) {
+                uint64_t saved_cpuid = *(uint64_t*)jl_dlsym(jl_sysimg_handle, "jl_sysimg_cpu_cpuid");
+                if (saved_cpuid != (((uint64_t)info[2])|(((uint64_t)info[3])<<32)))
+                    jl_error("Target architecture mismatch. Please delete or regenerate sys.{so,dll,dylib}.");
+            }
+        }
+        else if (strcmp(cpu_target,"core2") == 0) {
+            int HasSSSE3 = (info[2] & 1<<9);
+            if (!HasSSSE3)
+                jl_error("The current host does not support SSSE3, but the system image was compiled for Core2.\n"
+                         "Please delete or regenerate sys.{so,dll,dylib}.");
+        }
+#endif
+
+#ifdef _OS_WINDOWS_
+        sysimage_base = (intptr_t)jl_sysimg_handle;
+#else
+        if (dladdr((void*)sysimg_gvars_base, &dlinfo) != 0) {
+            sysimage_base = (intptr_t)dlinfo.dli_fbase;
+        }
+        else {
+            sysimage_base = 0;
+        }
+#endif
+    }
+    const char *sysimg_data = (const char*)jl_dlsym(jl_sysimg_handle, "jl_system_image_data");
+    size_t len = *(size_t*)jl_dlsym(jl_sysimg_handle, "jl_system_image_size");
+    jl_restore_system_image_data(sysimg_data, len);
+}
+
+
+// --- serializer ---
+
+static uintptr_t jl_fptr_id(void *fptr)
+{
+    void **pbp = ptrhash_bp(&fptr_to_id, fptr);
+    if (*pbp == HT_NOTFOUND || fptr == NULL)
+        return 1;
+    else
+        return *(uintptr_t*)pbp;
+}
+
+
+#define jl_serialize_value(s, v) jl_serialize_value_(s,(jl_value_t*)(v))
+static void jl_serialize_value_(jl_serializer_state *s, jl_value_t *v);
+
+
+static void jl_serialize_module(jl_serializer_state *s, jl_module_t *m)
+{
+    jl_serialize_value(s, m->name);
+    jl_serialize_value(s, m->parent);
+    size_t i;
+    void **table = m->bindings.table;
+    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->owner == m || m != jl_main_module) {
+                jl_serialize_value(s, b->name);
+                jl_serialize_value(s, b->value);
+                jl_serialize_value(s, b->globalref);
+                jl_serialize_value(s, b->owner);
+            }
+        }
+    }
+
+    if (m != jl_main_module) {
+        for (i = 0; i < m->usings.len; i++) {
+            jl_serialize_value(s, (jl_value_t*)m->usings.items[i]);
+        }
+    }
+}
+
+
+static void jl_serialize_value_(jl_serializer_state *s, jl_value_t *v)
+{
+    if (v == NULL || jl_is_symbol(v)) {
+        return;
+    }
+
+    void *builtin = ptrhash_get(&sertag_table, v);
+    if (builtin != HT_NOTFOUND) {
+        return;
+    }
+
+    void **bp = ptrhash_bp(&backref_table, v);
+    if (*bp != HT_NOTFOUND) {
+        return;
+    }
+
+    size_t item = ++backref_table_numel;
+    assert(item < ((uintptr_t)1 << RELOC_TAG_OFFSET) && "too many items to serialize");
+    char *pos = (char*)HT_NOTFOUND + item;
+    *bp = (void*)pos;
+
+    // some values have special representations
+    jl_datatype_t *t = (jl_datatype_t*)jl_typeof(v);
+    jl_serialize_value(s, t);
+
+    if (t->layout->npointers == 0) {
+        // skip it
+    }
+    else if (jl_is_svec(v)) {
+        size_t i, l = jl_svec_len(v);
+        jl_value_t **data = jl_svec_data(v);
+        for (i = 0; i < l; i++) {
+            jl_serialize_value(s, data[i]);
+        }
+    }
+    else if (jl_is_array(v)) {
+        jl_array_t *ar = (jl_array_t*)v;
+        jl_serialize_value(s, jl_typeof(ar));
+        if (ar->flags.ptrarray) {
+            size_t i, l = jl_array_len(ar);
+            for (i = 0; i < l; i++) {
+                jl_serialize_value(s, jl_array_ptr_ref(ar, i));
+            }
+        }
+    }
+    else if (jl_typeis(v, jl_module_type)) {
+        jl_serialize_module(s, (jl_module_t*)v);
+    }
+    else if (jl_typeis(v, jl_task_type)) {
+        jl_error("Task cannot be serialized");
+    }
+    else {
+        char *data = (char*)jl_data_ptr(v);
+        size_t i, nf = jl_datatype_nfields(t);
+        for (i = 0; i < nf; i++) {
+            if (jl_field_isptr(t, i)) {
+                char *slot = data + jl_field_offset(t, i);
+                jl_value_t *fld = *(jl_value_t**)slot;
+                jl_serialize_value(s, fld);
+            }
+        }
+    }
+}
+
+static void ios_ensureroom(ios_t *s, size_t newsize)
+{
+    size_t prevsize = s->size;
+    if (prevsize < newsize) {
+        ios_trunc(s, newsize);
+        assert(s->size == newsize);
+        memset(&s->buf[prevsize], 0, newsize - prevsize);
+    }
+}
+
+static void record_gvar(jl_serializer_state *s, int gid, uintptr_t reloc_id)
+{
+    if (gid == 0)
+        return;
+    ios_ensureroom(s->gvar_record, gid * sizeof(uint32_t));
+    ios_seek(s->gvar_record, (gid - 1) * sizeof(uint32_t));
+    assert(reloc_id < UINT32_MAX);
+    write_uint32(s->gvar_record, reloc_id);
+}
+
+
+static void write_padding(ios_t *s, size_t nb)
+{
+    static const char zeros[16] = {0};
+    while (nb > 16) {
+        ios_write(s, zeros, 16);
+        nb -= 16;
+    }
+    if (nb != 0)
+        ios_write(s, zeros, nb);
+}
+
+
+static void write_pointer(ios_t *s)
+{
+    assert((ios_pos(s) & (sizeof(void*) - 1)) == 0 && "stream misaligned for writing a word-sized value");
+    write_padding(s, sizeof(void*));
+}
+
+
+#define backref_id(s, v) _backref_id(s, (jl_value_t*)(v))
+static uintptr_t _backref_id(jl_serializer_state *s, jl_value_t *v)
+{
+    assert(v != NULL && "cannot get backref to NULL object");
+    void *idx = HT_NOTFOUND;
+    if (jl_is_symbol(v)) {
+        void **pidx = ptrhash_bp(&symbol_table, v);
+        idx = *pidx;
+        if (idx == HT_NOTFOUND) {
+            size_t l = strlen(jl_symbol_name((jl_sym_t*)v));
+            write_uint32(s->symbols, l);
+            ios_write(s->symbols, jl_symbol_name((jl_sym_t*)v), l + 1);
+            size_t offset = ++nsym_tag;
+            assert(offset < ((uintptr_t)1 << RELOC_TAG_OFFSET) && "too many symbols");
+            idx = (void*)((char*)HT_NOTFOUND + ((uintptr_t)SymbolRef << RELOC_TAG_OFFSET) + offset);
+            *pidx = idx;
+        }
+    }
+    else {
+        idx = ptrhash_get(&sertag_table, v);
+    }
+    if (idx == HT_NOTFOUND) {
+        idx = ptrhash_get(&backref_table, v);
+        assert(idx != HT_NOTFOUND && "object missed during jl_serialize_value pass");
+    }
+    return (char*)idx - 1 - (char*)HT_NOTFOUND;
+}
+
+
+static void write_pointerfield(jl_serializer_state *s, jl_value_t *fld)
+{
+    if (fld != NULL) {
+        arraylist_push(&s->relocs_list, (void*)(uintptr_t)ios_pos(s->s));
+        arraylist_push(&s->relocs_list, (void*)backref_id(s, fld));
+    }
+    write_pointer(s->s);
+}
+
+static void write_gctaggedfield(jl_serializer_state *s, uintptr_t ref)
+{
+    arraylist_push(&s->gctags_list, (void*)(uintptr_t)ios_pos(s->s));
+    arraylist_push(&s->gctags_list, (void*)ref);
+    write_pointer(s->s);
+}
+
+
+static void jl_write_module(jl_serializer_state *s, uintptr_t item, jl_module_t *m)
+{
+    size_t reloc_offset = ios_pos(s->s);
+    size_t tot = sizeof(jl_module_t);
+    ios_write(s->s, (char*)m, tot);
+
+    jl_module_t *newm = (jl_module_t*)&s->s->buf[reloc_offset];
+    newm->name = NULL;
+    arraylist_push(&s->relocs_list, (void*)(reloc_offset + offsetof(jl_module_t, name)));
+    arraylist_push(&s->relocs_list, (void*)backref_id(s, m->name));
+    newm->parent = NULL;
+    arraylist_push(&s->relocs_list, (void*)(reloc_offset + offsetof(jl_module_t, parent)));
+    arraylist_push(&s->relocs_list, (void*)backref_id(s, m->parent));
+    newm->primary_world = jl_world_counter;
+
+    // write out the bindings table as a list
+    // immediately after jl_module_t
+    // (the ptrhash will need to be recreated on load)
+    size_t count = 0;
+    size_t i;
+    void **table = m->bindings.table;
+    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->owner == m || m != jl_main_module) {
+                write_gctaggedfield(s, (uintptr_t)BindingRef << RELOC_TAG_OFFSET);
+                tot += sizeof(void*);
+                size_t binding_reloc_offset = ios_pos(s->s);
+                record_gvar(s, jl_get_llvm_gv((jl_value_t*)b), ((uintptr_t)DataRef << RELOC_TAG_OFFSET) + binding_reloc_offset);
+                write_pointerfield(s, (jl_value_t*)b->name);
+                write_pointerfield(s, b->value);
+                write_pointerfield(s, b->globalref);
+                write_pointerfield(s, (jl_value_t*)b->owner);
+                size_t flag_offset = offsetof(jl_binding_t, owner) + sizeof(b->owner);
+                ios_write(s->s, (char*)b + flag_offset, sizeof(*b) - flag_offset);
+                tot += sizeof(jl_binding_t);
+                count += 1;
+            }
+        }
+    }
+    assert(ios_pos(s->s) - reloc_offset == tot);
+    newm = (jl_module_t*)&s->s->buf[reloc_offset];
+    newm->bindings.size = count; // stash the count in newm->size
+    newm->bindings.table = NULL;
+    memset(&newm->bindings._space, 0, sizeof(newm->bindings._space));
+
+    // write out the usings list
+    memset(&newm->usings._space, 0, sizeof(newm->usings._space));
+    if (m == jl_main_module) {
+        newm->usings.len = 1;
+        newm->usings.max = AL_N_INLINE;
+        newm->usings.items = (void**)offsetof(jl_module_t, usings._space);
+        arraylist_push(&s->relocs_list, (void*)(reloc_offset + offsetof(jl_module_t, usings.items)));
+        arraylist_push(&s->relocs_list, (void*)(((uintptr_t)DataRef << RELOC_TAG_OFFSET) + item));
+        arraylist_push(&s->relocs_list, (void*)(reloc_offset + offsetof(jl_module_t, usings._space[0])));
+        arraylist_push(&s->relocs_list, (void*)backref_id(s, jl_core_module));
+    }
+    else {
+        if (newm->usings.items == &newm->usings._space[0]) {
+            m->usings.max = AL_N_INLINE;
+            newm->usings.items = (void**)offsetof(jl_module_t, usings._space);
+            arraylist_push(&s->relocs_list, (void*)(reloc_offset + offsetof(jl_module_t, usings.items)));
+            arraylist_push(&s->relocs_list, (void*)(((uintptr_t)DataRef << RELOC_TAG_OFFSET) + item));
+            size_t i;
+            for (i = 0; i < m->usings.len; i++) {
+                arraylist_push(&s->relocs_list, (void*)(reloc_offset + offsetof(jl_module_t, usings._space[i])));
+                arraylist_push(&s->relocs_list, (void*)backref_id(s, m->usings._space[i]));
+            }
+        }
+        else {
+            newm->usings.items = (void**)tot;
+            arraylist_push(&s->relocs_list, (void*)(reloc_offset + offsetof(jl_module_t, usings.items)));
+            arraylist_push(&s->relocs_list, (void*)(((uintptr_t)DataRef << RELOC_TAG_OFFSET) + item));
+            size_t i;
+            for (i = 0; i < m->usings.len; i++) {
+                write_pointerfield(s, (jl_value_t*)m->usings.items[i]);
+                tot += sizeof(void*);
+            }
+            for (; i < m->usings.max; i++) {
+                write_pointer(s->s);
+                tot += sizeof(void*);
+            }
+            newm = (jl_module_t*)&s->s->buf[reloc_offset];
+        }
+    }
+}
+
+#if 0
+static size_t jl_sort_size(jl_datatype_t *dt)
+{
+    if (dt == jl_simplevector_type)
+        return SIZE_MAX - 5;
+    if (dt == jl_string_type)
+        return SIZE_MAX - 4;
+    if (dt->name == jl_array_typename)
+        return SIZE_MAX - 3;
+    if (dt == jl_datatype_type)
+        return SIZE_MAX - 2;
+    if (dt == jl_module_type)
+        return SIZE_MAX - 1;
+    return jl_datatype_size(dt);
+}
+#endif
+
+static int sysimg_sort_order(const void *pa, const void *pb)
+{
+    uintptr_t sa = ((uintptr_t*)pa)[1];
+    uintptr_t sb = ((uintptr_t*)pb)[1];
+    return (sa > sb ? 1 : (sa < sb ? -1 : 0));
+#if 0
+    jl_value_t *a = *(jl_value_t**)pa;
+    jl_datatype_t *tya = (jl_datatype_t*)jl_typeof(a);
+    size_t sa = jl_sort_size(tya);
+    jl_value_t *b = *(jl_value_t**)pb;
+    jl_datatype_t *tyb = (jl_datatype_t*)jl_typeof(b);
+    size_t sb = jl_sort_size(tyb);
+    if (sa == sb) {
+        sa = tya->uid;
+        sb = tyb->uid;
+    }
+    return (sa > sb ? 1 : (sa < sb ? -1 : 0));
+#endif
+}
+
+jl_value_t *jl_find_ptr = NULL;
+static void jl_write_values(jl_serializer_state *s)
+{
+    arraylist_t objects_list;
+    arraylist_new(&objects_list, backref_table_numel * 2);
+
+    arraylist_new(&layout_table, 0);
+    arraylist_grow(&layout_table, backref_table_numel);
+    memset(layout_table.items, 0, backref_table_numel * sizeof(void*));
+
+    size_t i, len = backref_table.size;
+    void **p = backref_table.table;
+    for (i = 0; i < len; i += 2) {
+        char *reloc_id = (char*)p[i + 1];
+        if (reloc_id != HT_NOTFOUND) {
+            jl_value_t *v = (jl_value_t*)p[i];
+            uintptr_t item = reloc_id - 1 - (char*)HT_NOTFOUND;
+            objects_list.items[objects_list.len++] = (void*)v;
+            objects_list.items[objects_list.len++] = (void*)item;
+        }
+    }
+    assert(backref_table_numel * 2 == objects_list.len);
+    qsort(objects_list.items, backref_table_numel, sizeof(void*) * 2, sysimg_sort_order);
+
+    for (i = 0, len = backref_table_numel * 2; i < len; i += 2) {
+        jl_value_t *v = (jl_value_t*)objects_list.items[i];
+        uintptr_t item = (uintptr_t)objects_list.items[i + 1];
+        jl_datatype_t *t = (jl_datatype_t*)jl_typeof(v);
+        assert((t->instance == NULL || t->instance == v) && "detected singleton construction corruption");
+        // realign stream to expected gc alignment (16 bytes)
+        uintptr_t skip_header_pos = ios_pos(s->s) + sizeof(jl_taggedvalue_t);
+        write_padding(s->s, LLT_ALIGN(skip_header_pos, 16) - skip_header_pos);
+        // write header
+        write_gctaggedfield(s, backref_id(s, t));
+        size_t reloc_offset = ios_pos(s->s);
+        assert(item < layout_table.len && layout_table.items[item] == NULL);
+        layout_table.items[item] = (void*)reloc_offset;
+        record_gvar(s, jl_get_llvm_gv(v), ((uintptr_t)DataRef << RELOC_TAG_OFFSET) + reloc_offset);
+
+        // write data
+        if (jl_is_cpointer(v)) {
+            write_pointer(s->s);
+        }
+        else if (jl_is_array(v)) {
+#define JL_ARRAY_ALIGN(jl_value, nbytes) LLT_ALIGN(jl_value, nbytes)
+            jl_array_t *ar = (jl_array_t*)v;
+            int ndimwords = jl_array_ndimwords(ar->flags.ndims);
+            size_t tsz = JL_ARRAY_ALIGN(sizeof(jl_array_t) + ndimwords * sizeof(size_t), JL_CACHE_BYTE_ALIGNMENT);
+            // copy header
+            ios_write(s->s, (char*)v, tsz);
+            // make some header modifications in-place
+            jl_array_t *newa = (jl_array_t*)&s->s->buf[reloc_offset];
+            size_t alen = jl_array_len(ar);
+            size_t tot = alen * ar->elsize;
+            if (newa->flags.ndims == 1)
+                newa->maxsize = alen;
+            newa->offset = 0;
+            newa->flags.how = 0;
+            newa->flags.pooled = 0;
+            newa->flags.isshared = 0;
+
+            // write data
+            if (!ar->flags.ptrarray) {
+                uintptr_t data = LLT_ALIGN(ios_pos(s->const_data), 16);
+                // realign stream to max(data-align(array), sizeof(void*))
+                write_padding(s->const_data, data - ios_pos(s->const_data));
+                // write data and relocations
+                newa->data = NULL; // relocation offset
+                data /= sizeof(void*);
+                assert(data < ((uintptr_t)1 << RELOC_TAG_OFFSET) && "offset to constant data too large");
+                arraylist_push(&s->relocs_list, (void*)(reloc_offset + offsetof(jl_array_t, data))); // relocation location
+                arraylist_push(&s->relocs_list, (void*)(((uintptr_t)ConstDataRef << RELOC_TAG_OFFSET) + data)); // relocation target
+                if (ar->elsize == 1)
+                    tot += 1;
+                ios_write(s->const_data, (char*)jl_array_data(ar), tot);
+            }
+            else {
+                newa->data = (void*)tsz; // relocation offset
+                arraylist_push(&s->relocs_list, (void*)(reloc_offset + offsetof(jl_array_t, data))); // relocation location
+                arraylist_push(&s->relocs_list, (void*)(((uintptr_t)DataRef << RELOC_TAG_OFFSET) + item)); // relocation target
+                size_t i;
+                for (i = 0; i < alen; i++) {
+                    write_pointerfield(s, jl_array_ptr_ref(v, i));
+                }
+            }
+        }
+        else if (jl_typeis(v, jl_module_type)) {
+            jl_write_module(s, item, (jl_module_t*)v);
+            // will need to recreate the binding table for this
+            arraylist_push(&reinit_list, (void*)item);
+            arraylist_push(&reinit_list, (void*)5);
+        }
+        else if (jl_typeis(v, jl_task_type)) {
+            jl_error("Task cannot be serialized");
+        }
+        else if (jl_is_svec(v)) {
+            ios_write(s->s, (char*)v, sizeof(void*));
+            size_t i, l = jl_svec_len(v);
+            assert(l > 0);
+            for (i = 0; i < l; i++) {
+                write_pointerfield(s, jl_svecref(v, i));
+            }
+        }
+        else if (jl_is_string(v)) {
+            ios_write(s->s, (char*)v, sizeof(void*));
+            ios_write(s->s, jl_string_data(v), jl_string_len(v));
+            write_uint8(s->s, '\0'); // null-terminated strings for easier C-compatibility
+        }
+        else if (jl_datatype_nfields(t) == 0) {
+            assert(t->layout->npointers == 0);
+            if (t->size > 0)
+                ios_write(s->s, (char*)v, t->size);
+        }
+        else {
+            size_t i, nf = jl_datatype_nfields(t);
+            size_t tot = 0;
+            for (i = 0; i < nf; i++) {
+                size_t offset = jl_field_offset(t, i);
+                char *slot = (char*)v + offset;
+                write_padding(s->s, offset - tot);
+                tot = offset;
+                size_t fsz = jl_field_size(t, i);
+                if (jl_field_isptr(t, i) > 0) {
+                    write_pointerfield(s, *(jl_value_t**)slot);
+                }
+                else if (t->mutabl && jl_is_cpointer_type(jl_field_type(t, i))) {
+                    write_pointer(s->s);
+                }
+                else if (fsz > 0) {
+                    ios_write(s->s, slot, fsz);
+                }
+                tot += fsz;
+            }
+
+            if (jl_is_method(v)) {
+                write_padding(s->s, sizeof(jl_method_t) - tot);
+            }
+            else if (jl_is_method_instance(v)) {
+                jl_method_instance_t *m = (jl_method_instance_t*)v;
+                jl_method_instance_t *newm = (jl_method_instance_t*)&s->s->buf[reloc_offset];
+                newm->fptr = NULL;
+                newm->unspecialized_ducttape = NULL;
+                if (jl_is_method(m->def.method)) {
+                    uintptr_t fptr_id = jl_fptr_id((void*)(uintptr_t)m->fptr);
+                    if (m->jlcall_api == 2) {
+                    }
+                    else if (fptr_id >= 2) {
+                        //write_int8(s->s, -li->jlcall_api);
+                        //write_uint16(s->s, fptr_id);
+                        newm->fptr = (jl_fptr_t)fptr_id;
+                        arraylist_push(&reinit_list, (void*)item);
+                        arraylist_push(&reinit_list, (void*)6);
+                    }
+                    else if (m->functionObjectsDecls.functionObject) {
+                        int jlcall_api = jl_jlcall_api(m->functionObjectsDecls.functionObject);
+                        assert(jlcall_api);
+                        newm->jlcall_api = jlcall_api;
+                        // save functionObject pointers
+                        int cfunc = jl_assign_functionID(m->functionObjectsDecls.specFunctionObject);
+                        int func = jl_assign_functionID(m->functionObjectsDecls.functionObject);
+                        assert(reloc_offset < INT32_MAX);
+                        if (cfunc != 0) {
+                            ios_ensureroom(s->fptr_record, cfunc * sizeof(void*));
+                            ios_seek(s->fptr_record, (cfunc - 1) * sizeof(void*));
+                            write_uint32(s->fptr_record, ~reloc_offset);
+#ifdef _P64
+                            write_padding(s->fptr_record, 4);
+#endif
+                        }
+                        if (func != 0) {
+                            ios_ensureroom(s->fptr_record, func * sizeof(void*));
+                            ios_seek(s->fptr_record, (func - 1) * sizeof(void*));
+                            write_uint32(s->fptr_record, reloc_offset);
+#ifdef _P64
+                            write_padding(s->fptr_record, 4);
+#endif
+                        }
+                    }
+                    else {
+                        newm->jlcall_api = 0;
+                    }
+                }
+                newm->functionObjectsDecls.functionObject = NULL;
+                newm->functionObjectsDecls.specFunctionObject = NULL;
+            }
+            else if (jl_is_datatype(v)) {
+                jl_datatype_t *dt = (jl_datatype_t*)v;
+                jl_datatype_t *newdt = (jl_datatype_t*)&s->s->buf[reloc_offset];
+                newdt->struct_decl = NULL;
+                newdt->ditype = NULL;
+                if (dt->layout != NULL) {
+                    size_t nf = dt->layout->nfields;
+                    size_t fieldsize = jl_fielddesc_size(dt->layout->fielddesc_type);
+                    int has_padding = dt->layout->npointers && nf;
+                    char *flddesc = (char*)dt->layout;
+                    size_t fldsize = sizeof(jl_datatype_layout_t) + nf * fieldsize;
+                    uintptr_t layout_unaligned = LLT_ALIGN(ios_pos(s->const_data), sizeof(uint32_t));
+                    uintptr_t layout = LLT_ALIGN(ios_pos(s->const_data), sizeof(void*));
+                    if (has_padding) {
+                        if (layout == layout_unaligned) {
+                            layout += sizeof(void*);
+                            layout_unaligned = layout - sizeof(uint32_t);
+                        }
+                        flddesc -= sizeof(uint32_t);
+                        fldsize += sizeof(uint32_t);
+                        write_padding(s->const_data, layout_unaligned - ios_pos(s->const_data)); // realign stream
+                    }
+                    else {
+                        write_padding(s->const_data, layout - ios_pos(s->const_data)); // realign stream
+                    }
+                    newdt->layout = NULL; // relocation offset
+                    layout /= sizeof(void*);
+                    arraylist_push(&s->relocs_list, (void*)(reloc_offset + offsetof(jl_datatype_t, layout))); // relocation location
+                    arraylist_push(&s->relocs_list, (void*)(((uintptr_t)ConstDataRef << RELOC_TAG_OFFSET) + layout)); // relocation target
+                    ios_write(s->const_data, flddesc, fldsize);
+                }
+            }
+            else if (jl_typeof(v) == jl_idtable_type) {
+                // will need to rehash this, later (after types are fully constructed)
+                arraylist_push(&reinit_list, (void*)item);
+                arraylist_push(&reinit_list, (void*)1);
+            }
+            else {
+                write_padding(s->s, t->size - tot);
+            }
+        }
+    }
+}
+
+
+static void jl_write_gv_syms(jl_serializer_state *s, jl_sym_t *v)
+{
+    // since symbols are static, they might not have had a
+    // reference anywhere in the code image other than here
+    int32_t gv = jl_get_llvm_gv((jl_value_t*)v);
+    if (gv != 0) {
+        uintptr_t item = backref_id(s, v);
+        assert(item >> RELOC_TAG_OFFSET == SymbolRef);
+        record_gvar(s, gv, item);
+    }
+    if (v->left)
+        jl_write_gv_syms(s, v->left);
+    if (v->right)
+        jl_write_gv_syms(s, v->right);
+}
+
+
+static inline uint32_t load_uint32_be(uintptr_t *base)
+{
+    uint32_t v = **(uint32_t**)base;
+    *base += 4;
+    return ntohl(v);
+}
+
+
+static void jl_read_symbols(jl_serializer_state *s)
+{
+    assert(deser_sym.len == nsym_tag);
+    uintptr_t base = (uintptr_t)&s->symbols->buf[0];
+    uintptr_t end = base + s->symbols->size;
+    while (base < end) {
+        uint32_t len = load_uint32_be(&base);
+        const char *str = (const char*)base;
+        base += len + 1;
+        //printf("symbol %3d: %s\n", len, str);
+        jl_sym_t *sym = jl_symbol_n(str, len);
+        arraylist_push(&deser_sym, (void*)sym);
+    }
+}
+
+
+static uintptr_t get_reloc_for_item(uintptr_t reloc_item, size_t reloc_offset)
+{
+    enum RefTags tag = (enum RefTags)(reloc_item >> RELOC_TAG_OFFSET);
+    if (tag == DataRef) {
+        // need to compute the final relocation offset via the layout table
+        assert(reloc_item < layout_table.len);
+        uintptr_t reloc_base = (uintptr_t)layout_table.items[reloc_item];
+        assert(reloc_base != 0 && "layout offset missing for relocation item");
+        // write reloc_offset into s->s at pos
+        return reloc_base + reloc_offset;
+    }
+    else {
+        // just write the item reloc_id directly
+#ifndef NDEBUG
+        assert(reloc_offset == 0 && "offsets for relocations to builtin objects should be precomposed in the reloc_item");
+        size_t offset = (reloc_item & (((uintptr_t)1 << RELOC_TAG_OFFSET) - 1));
+        switch (tag) {
+        case ConstDataRef:
+            break;
+        case TagRef:
+            assert(offset >= 2 && offset < deser_tag.len && deser_tag.items[offset] && "corrupt relocation item id");
+            break;
+        case SymbolRef:
+            assert(offset < nsym_tag && "corrupt relocation item id");
+            break;
+        case BindingRef:
+            assert(offset == 0 && "corrupt relocation offset");
+            break;
+        case DataRef:
+        default:
+            assert("corrupt relocation item id");
+        }
+#endif
+        return reloc_item; // pre-composed relocation + offset
+    }
+}
+
+
+static inline uintptr_t get_item_for_reloc(jl_serializer_state *s, uintptr_t base, size_t size, uint32_t reloc_id)
+{
+    enum RefTags tag = (enum RefTags)(reloc_id >> RELOC_TAG_OFFSET);
+    size_t offset = (reloc_id & (((uintptr_t)1 << RELOC_TAG_OFFSET) - 1));
+    switch (tag) {
+    case DataRef:
+        assert(offset < size);
+        return base + offset;
+    case ConstDataRef:
+        return (uintptr_t)deser_tag.items[0] + (offset * sizeof(void*));
+    case TagRef:
+        assert(offset < deser_tag.len && deser_tag.items[offset] && "corrupt relocation item id");
+        return (uintptr_t)deser_tag.items[offset];
+    case SymbolRef:
+        assert(offset < deser_sym.len && deser_sym.items[offset] && "corrupt relocation item id");
+        return (uintptr_t)deser_sym.items[offset];
+    case BindingRef:
+        return jl_buff_tag | GC_OLD_MARKED;
+    }
+    abort();
+}
+
+
+static void jl_write_skiplist(ios_t *s, char *base, size_t size, arraylist_t *list)
+{
+    size_t i;
+    for (i = 0; i < list->len; i += 2) {
+        size_t pos = (size_t)list->items[i];
+        size_t item = (size_t)list->items[i + 1];
+        uintptr_t *pv = (uintptr_t*)(base + pos);
+        assert(pos < size && pos != 0);
+        *pv = get_reloc_for_item(item, *pv);
+        // record pos in relocations list
+        // TODO: save space by using delta-compression
+        assert(pos < UINT32_MAX);
+        write_uint32(s, pos);
+    }
+    write_uint32(s, 0);
+}
+
+
+static void jl_write_relocations(jl_serializer_state *s)
+{
+    char *base = &s->s->buf[0];
+    jl_write_skiplist(s->relocs, base, s->s->size, &s->gctags_list);
+    jl_write_skiplist(s->relocs, base, s->s->size, &s->relocs_list);
+}
+
+
+static void jl_read_relocations(jl_serializer_state *s, uint8_t bits)
+{
+    uintptr_t base = (uintptr_t)&s->s->buf[0];
+    size_t size = s->s->size;
+    while (1) {
+        uintptr_t val = (uintptr_t)&s->relocs->buf[s->relocs->bpos];
+        uint32_t offset = load_uint32_be(&val);
+        s->relocs->bpos += sizeof(uint32_t);
+        if (offset == 0)
+            break;
+        uintptr_t *pv = (uintptr_t*)(base + offset);
+        uintptr_t v = *pv;
+        v = get_item_for_reloc(s, base, size, v);
+        *pv = v | bits;
+    }
+}
+
+static char* sysimg_base;
+static char* sysimg_relocs;
+void gc_sweep_sysimg(void)
+{
+    uintptr_t base = (uintptr_t)sysimg_base;
+    uintptr_t relocs = (uintptr_t)sysimg_relocs;
+    if (relocs == 0)
+        return;
+    while (1) {
+        uint32_t offset = load_uint32_be(&relocs);
+        if (offset == 0)
+            break;
+        jl_taggedvalue_t *o = (jl_taggedvalue_t*)(base + offset);
+        o->bits.gc = GC_OLD;
+    }
+}
+
+#define jl_write_value(s, v) _jl_write_value((s), (jl_value_t*)(v))
+static void _jl_write_value(jl_serializer_state *s, jl_value_t *v)
+{
+    if (v == NULL) {
+        write_uint32(s->s, 0);
+        return;
+    }
+    uintptr_t item = backref_id(s, v);
+    uintptr_t reloc = get_reloc_for_item(item, 0);
+    assert(reloc < UINT32_MAX);
+    write_uint32(s->s, reloc);
+}
+
+
+static jl_value_t *jl_read_value(jl_serializer_state *s)
+{
+    uintptr_t base = (uintptr_t)&s->s->buf[0];
+    size_t size = s->s->size;
+    uintptr_t val = base + s->s->bpos;
+    uint32_t offset = load_uint32_be(&val);
+    s->s->bpos += sizeof(uint32_t);
+    if (offset == 0)
+        return NULL;
+    return (jl_value_t*)get_item_for_reloc(s, base, size, offset);
+}
+
+
+static void jl_update_all_fptrs(jl_serializer_state *s)
+{
+    const char *fvars_base = sysimg_fvars_base;
+    // make these NULL now so we skip trying to restore GlobalVariable pointers later
+    sysimg_gvars_base = NULL;
+    sysimg_fvars_base = NULL;
+    int sysimg_fvars_max = s->fptr_record->size / sizeof(void*);
+    size_t i;
+    uintptr_t base = (uintptr_t)&s->s->buf[0];
+    jl_method_instance_t **linfos = (jl_method_instance_t**)&s->fptr_record->buf[0];
+    for (i = 0; i < sysimg_fvars_max; i++) {
+        uintptr_t val = (uintptr_t)&linfos[i];
+        uint32_t offset = load_uint32_be(&val);
+        if (offset != 0) {
+            int cfunc = 0;
+            if (offset & ((uintptr_t)1 << (8 * sizeof(uint32_t) - 1))) {
+                // if high bit is set, this is cfunc, not func
+                cfunc = 1;
+                offset = ~offset;
+            }
+            jl_method_instance_t *li = (jl_method_instance_t*)(base + offset);
+            if (fvars_base == NULL) {
+                li->jlcall_api = 0;
+            }
+            else {
+                assert(jl_is_method(li->def.method) && li->jlcall_api && li->jlcall_api != 2);
+                linfos[i] = li;
+                jl_fptr_to_llvm((jl_fptr_t)sysimg_fvars(fvars_base, i), li, cfunc);
+            }
+        }
+    }
+    if (fvars_base) {
+        jl_register_fptrs(sysimage_base, fvars_base, sysimg_fvars_offsets, linfos, sysimg_fvars_max);
+    }
+}
+
+
+static void jl_update_all_gvars(jl_serializer_state *s)
+{
+    if (sysimg_gvars_base == NULL)
+        return;
+    size_t gvname_index = 0;
+    uintptr_t base = (uintptr_t)&s->s->buf[0];
+    size_t size = s->s->size;
+    uintptr_t gvars = (uintptr_t)&s->gvar_record->buf[0];
+    uintptr_t end = gvars + s->gvar_record->size;
+    while (gvars < end) {
+        uint32_t offset = load_uint32_be(&gvars);
+        if (offset) {
+            uintptr_t v = get_item_for_reloc(s, base, size, offset);
+            *sysimg_gvars(sysimg_gvars_base, gvname_index) = v;
+        }
+        gvname_index += 1;
+    }
+}
+
+
+static void jl_finalize_serializer(jl_serializer_state *s)
+{
+    size_t i, l;
+    // save module initialization order
+    if (jl_module_init_order != NULL) {
+        l = jl_array_len(jl_module_init_order);
+        for (i = 0; i < l; i++) {
+            // verify that all these modules were saved
+            assert(ptrhash_get(&backref_table, jl_array_ptr_ref(jl_module_init_order, i)) != HT_NOTFOUND);
+        }
+    }
+    jl_write_value(s, jl_module_init_order);
+
+    // record list of reinitialization functions
+    l = reinit_list.len;
+    for (i = 0; i < l; i += 2) {
+        size_t item = (size_t)reinit_list.items[i];
+        size_t reloc_offset = (size_t)layout_table.items[item];
+        assert(reloc_offset != 0);
+        write_uint32(s->s, (uint32_t)reloc_offset);
+        write_uint32(s->s, (uint32_t)((uintptr_t)reinit_list.items[i + 1]));
+    }
+    write_uint32(s->s, 0);
+}
+
+
+void jl_typemap_rehash(union jl_typemap_t ml, int8_t offs);
+static void jl_reinit_item(jl_value_t *v, int how, arraylist_t *tracee_list)
+{
+    jl_ptls_t ptls = jl_get_ptls_states();
+    JL_TRY {
+        switch (how) {
+            case 1: { // rehash ObjectIdDict
+                jl_array_t **a = (jl_array_t**)v;
+                assert(jl_is_array(*a));
+                // Assume *a don't need a write barrier
+                *a = 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;
+                assert(jl_is_module(mod));
+                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.",
+                                  jl_symbol_name(mod->name)); // this also throws
+                    }
+                    if (jl_generating_output() && jl_options.incremental) {
+                        jl_errorf("Cannot replace module %s during incremental precompile.", jl_symbol_name(mod->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;
+            }
+            case 3: { // rehash MethodTable
+                jl_methtable_t *mt = (jl_methtable_t*)v;
+                assert(jl_is_mtable(mt));
+                jl_typemap_rehash(mt->defs, 0);
+                // TODO: consider reverting this when we can split on Type{...} better
+                jl_typemap_rehash(mt->cache, 1); //(mt == jl_type_typename->mt) ? 0 : 1);
+                if (tracee_list)
+                    arraylist_push(tracee_list, mt);
+                break;
+            }
+            case 4: { // rehash specializations tfunc
+                jl_method_t *m = (jl_method_t*)v;
+                assert(jl_is_method(m));
+                jl_typemap_rehash(m->specializations, 0);
+                break;
+            }
+            case 5: { // rebuild the binding table for module v
+                jl_module_t *mod = (jl_module_t*)v;
+                assert(jl_is_module(mod));
+                size_t nbindings = mod->bindings.size;
+                htable_new(&mod->bindings, nbindings);
+                struct binding {
+                    uintptr_t tag;
+                    jl_binding_t b;
+                } *b;
+                b = (struct binding*)&mod[1];
+                while (nbindings > 0) {
+                    ptrhash_put(&mod->bindings, (char*)b->b.name, &b->b);
+                    b += 1;
+                    nbindings -= 1;
+                }
+                break;
+            }
+            case 6: { // assign the real fptr for m
+                jl_method_instance_t *m = (jl_method_instance_t*)v;
+                uintptr_t fptr_id = (uintptr_t)m->fptr;
+                assert(fptr_id <= sizeof(id_to_fptrs) / sizeof(*id_to_fptrs) &&
+                       fptr_id >= 2 && "unknown function pointer ID");
+                m->fptr = id_to_fptrs[fptr_id];
+                break;
+            }
+            default:
+                assert(0 && "corrupt deserialization state");
+                abort();
+        }
+    }
+    JL_CATCH {
+        jl_printf(JL_STDERR, "WARNING: error while reinitializing value ");
+        jl_static_show(JL_STDERR, v);
+        jl_printf(JL_STDERR, ":\n");
+        jl_static_show(JL_STDERR, ptls->exception_in_transit);
+        jl_printf(JL_STDERR, "\n");
+    }
+}
+
+
+static jl_array_t *jl_finalize_deserializer(jl_serializer_state *s, arraylist_t *tracee_list)
+{
+    jl_array_t *init_order = (jl_array_t*)jl_read_value(s);
+
+    // run reinitialization functions
+    uintptr_t base = (uintptr_t)&s->s->buf[0];
+    while (1) {
+        size_t offset = read_uint32(s->s);
+        if (offset == 0)
+            break;
+        jl_value_t *v = (jl_value_t*)(base + offset);
+        jl_reinit_item(v, read_uint32(s->s), tracee_list);
+    }
+    return init_order;
+}
+
+
+
+// --- helper functions ---
+
+// remove cached types not referenced in the stream
+static void jl_prune_type_cache(jl_svec_t *cache)
+{
+    size_t l = jl_svec_len(cache), ins = 0, i;
+    for (i = 0; i < l; i++) {
+        jl_value_t *ti = jl_svecref(cache, i);
+        if (ti == NULL)
+            break;
+        if (ptrhash_get(&backref_table, ti) != HT_NOTFOUND || jl_get_llvm_gv(ti) != 0)
+            jl_svecset(cache, ins++, ti);
+        else if (jl_is_datatype(ti)) {
+            jl_value_t *singleton = ((jl_datatype_t*)ti)->instance;
+            if (singleton && (ptrhash_get(&backref_table, singleton) != HT_NOTFOUND || jl_get_llvm_gv(singleton) != 0))
+                jl_svecset(cache, ins++, ti);
+        }
+    }
+    if (i > ins) {
+        memset(&jl_svec_data(cache)[ins], 0, (i - ins) * sizeof(jl_value_t*));
+    }
+}
+
+
+// --- entry points ---
+
+static void jl_init_serializer2(int);
+static void jl_cleanup_serializer2(void);
+
+static void jl_save_system_image_to_stream(ios_t *f)
+{
+    jl_gc_collect(1); // full
+    jl_gc_collect(0); // incremental (sweep finalizers)
+    JL_TIMING(SYSIMG_DUMP);
+    int en = jl_gc_enable(0);
+    jl_init_serializer2(1);
+    htable_reset(&backref_table, 250000);
+    arraylist_new(&reinit_list, 0);
+    backref_table_numel = 0;
+    ios_t sysimg, const_data, symbols, relocs, gvar_record, fptr_record;
+    ios_mem(&sysimg,     1000000);
+    ios_mem(&const_data,  100000);
+    ios_mem(&symbols,     100000);
+    ios_mem(&relocs,      100000);
+    ios_mem(&gvar_record, 100000);
+    ios_mem(&fptr_record, 100000);
+    jl_serializer_state s;
+    s.s = &sysimg;
+    s.const_data = &const_data;
+    s.symbols = &symbols;
+    s.relocs = &relocs;
+    s.gvar_record = &gvar_record;
+    s.fptr_record = &fptr_record;
+    s.mode = MODE_SYSTEM_IMAGE;
+    s.ptls = jl_get_ptls_states();
+    arraylist_new(&s.relocs_list, 0);
+    arraylist_new(&s.gctags_list, 0);
+
+    // 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));
+        }
+    }
+
+    jl_idtable_type = jl_base_module ? jl_get_global(jl_base_module, jl_symbol("ObjectIdDict")) : NULL;
+
+    { // step 1: record values (recursively) that need to go in the image
+        jl_serialize_value(&s, jl_core_module);
+        jl_serialize_value(&s, jl_main_module);
+        jl_serialize_value(&s, jl_top_module);
+        jl_serialize_value(&s, jl_typeinf_func);
+        jl_serialize_value(&s, jl_module_init_order);
+
+        // serialize method tables of builtin types
+        jl_serialize_value(&s, jl_type_typename->mt);
+        jl_serialize_value(&s, jl_intrinsic_type->name->mt);
+        jl_serialize_value(&s, jl_sym_type->name->mt);
+        jl_serialize_value(&s, jl_array_typename->mt);
+        jl_serialize_value(&s, jl_module_type->name->mt);
+
+        jl_prune_type_cache(jl_tuple_typename->cache);
+        jl_prune_type_cache(jl_tuple_typename->linearcache);
+        jl_prune_type_cache(jl_type_typename->cache);
+
+        uintptr_t i;
+        for (i = 0; i < builtin_typenames.len; i++) {
+            jl_serialize_value(&s, ((jl_typename_t*)builtin_typenames.items[i])->cache);
+            jl_serialize_value(&s, ((jl_typename_t*)builtin_typenames.items[i])->linearcache);
+        }
+    }
+
+    { // step 2: build all the sysimg sections
+        write_padding(&sysimg, sizeof(uint32_t));
+        jl_write_values(&s);
+        jl_write_relocations(&s);
+        jl_write_gv_syms(&s, jl_get_root_symbol());
+        // ensure everything in deser_tag are reassociated with their GlobalValue
+        uintptr_t i;
+        for (i = 0; i < deser_tag.len; i++) {
+            jl_value_t *v = (jl_value_t*)deser_tag.items[i];
+            record_gvar(&s, jl_get_llvm_gv(v), ((uintptr_t)TagRef << RELOC_TAG_OFFSET) + i);
+        }
+    }
+
+    // step 3: combine all of the sections into one file
+    write_uint32(f, sysimg.size - sizeof(uint32_t));
+    ios_seek(&sysimg, sizeof(uint32_t));
+    ios_copyall(f, &sysimg);
+    ios_close(&sysimg);
+
+    write_uint32(f, const_data.size);
+    // realign stream to max-alignment for data
+    write_padding(f, LLT_ALIGN(ios_pos(f), 16) - ios_pos(f));
+    ios_seek(&const_data, 0);
+    ios_copyall(f, &const_data);
+    ios_close(&const_data);
+
+    write_uint32(f, symbols.size);
+    ios_seek(&symbols, 0);
+    ios_copyall(f, &symbols);
+    ios_close(&symbols);
+
+    write_uint32(f, relocs.size);
+    ios_seek(&relocs, 0);
+    ios_copyall(f, &relocs);
+    ios_close(&relocs);
+
+    write_uint32(f, gvar_record.size);
+    ios_seek(&gvar_record, 0);
+    ios_copyall(f, &gvar_record);
+    ios_close(&gvar_record);
+
+    write_uint32(f, fptr_record.size);
+    ios_seek(&fptr_record, 0);
+    ios_copyall(f, &fptr_record);
+    ios_close(&fptr_record);
+
+    { // step 4: record locations of special roots
+        s.s = f;
+        jl_finalize_serializer(&s);
+        jl_write_value(&s, jl_main_module);
+        jl_write_value(&s, jl_top_module);
+        jl_write_value(&s, jl_typeinf_func);
+        write_uint32(f, jl_typeinf_world);
+        jl_write_value(&s, jl_type_typename->mt);
+        jl_write_value(&s, jl_intrinsic_type->name->mt);
+        jl_write_value(&s, jl_sym_type->name->mt);
+        jl_write_value(&s, jl_array_typename->mt);
+        jl_write_value(&s, jl_module_type->name->mt);
+        uintptr_t i;
+        for (i = 0; i < builtin_typenames.len; i++) {
+            jl_write_value(&s, ((jl_typename_t*)builtin_typenames.items[i])->cache);
+            jl_write_value(&s, ((jl_typename_t*)builtin_typenames.items[i])->linearcache);
+        }
+        write_uint32(f, jl_get_t_uid_ctr());
+        write_uint32(f, jl_get_gs_ctr());
+        write_uint32(f, jl_world_counter);
+    }
+
+    arraylist_free(&layout_table);
+    arraylist_free(&reinit_list);
+    arraylist_free(&s.relocs_list);
+    arraylist_free(&s.gctags_list);
+    jl_cleanup_serializer2();
+
+    jl_gc_enable(en);
+}
+
+JL_DLLEXPORT ios_t *jl_create_system_image(void)
+{
+    ios_t *f = (ios_t*)malloc(sizeof(ios_t));
+    ios_mem(f, 0);
+    jl_save_system_image_to_stream(f);
+    return f;
+}
+
+JL_DLLEXPORT size_t ios_write_direct(ios_t *dest, ios_t *src);
+JL_DLLEXPORT void jl_save_system_image(const char *fname)
+{
+    ios_t f;
+    if (ios_file(&f, fname, 1, 1, 1, 1) == NULL) {
+        jl_errorf("cannot open system image file \"%s\" for writing", fname);
+    }
+    JL_SIGATOMIC_BEGIN();
+    jl_save_system_image_to_stream(&f);
+    ios_close(&f);
+    JL_SIGATOMIC_END();
+}
+
+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);
+extern void jl_gc_set_permalloc_region(void *start, void *end);
+
+// Takes in a path of the form "usr/lib/julia/sys.so" (jl_restore_system_image should be passed the same string)
+JL_DLLEXPORT void jl_preload_sysimg_so(const char *fname)
+{
+    if (jl_sysimg_handle)
+        return; // embedded target already called jl_set_sysimg_so
+
+    char *dot = (char*) strrchr(fname, '.');
+    int is_ji = (dot && !strcmp(dot, ".ji"));
+
+    // Get handle to sys.so
+    if (!is_ji) // .ji extension => load .ji file only
+        jl_set_sysimg_so(jl_load_dynamic_library(fname, JL_RTLD_LOCAL | JL_RTLD_NOW));
+}
+
+// Allow passing in a module handle directly, rather than a path
+JL_DLLEXPORT void jl_set_sysimg_so(void *handle)
+{
+    // set cpu target if unspecified by user and available from sysimg
+    // otherwise default to native.
+    void* *jl_RTLD_DEFAULT_handle_pointer = (void**)jl_dlsym_e(handle, "jl_RTLD_DEFAULT_handle_pointer");
+    if (!jl_RTLD_DEFAULT_handle_pointer || (void*)&jl_RTLD_DEFAULT_handle != *jl_RTLD_DEFAULT_handle_pointer)
+        jl_error("System image file failed consistency check: maybe opened the wrong version?");
+    if (jl_options.cpu_target == NULL)
+        jl_options.cpu_target = (const char *)jl_dlsym(handle, "jl_sysimg_cpu_target");
+    jl_sysimg_handle = handle;
+}
+
+static void jl_restore_system_image_from_stream(ios_t *f)
+{
+    JL_TIMING(SYSIMG_LOAD);
+    jl_ptls_t ptls = jl_get_ptls_states();
+    int en = jl_gc_enable(0);
+    jl_init_serializer2(0);
+    ios_t sysimg, const_data, symbols, relocs, gvar_record, fptr_record;
+    jl_serializer_state s;
+    s.s = &sysimg;
+    s.const_data = &const_data;
+    s.symbols = &symbols;
+    s.relocs = &relocs;
+    s.gvar_record = &gvar_record;
+    s.fptr_record = &fptr_record;
+    s.mode = MODE_SYSTEM_IMAGE;
+    s.ptls = jl_get_ptls_states();
+    arraylist_new(&s.relocs_list, 0);
+    arraylist_new(&s.gctags_list, 0);
+
+    // step 1: read section map and apply relocations
+    assert(ios_pos(f) == 0 && f->bm == bm_mem);
+    size_t sizeof_sysimg = read_uint32(f);
+    ios_static_buffer(&sysimg, f->buf, sizeof_sysimg + sizeof(uint32_t));
+    ios_skip(f, sizeof_sysimg);
+
+    size_t sizeof_constdata = read_uint32(f);
+    // realign stream to max-alignment for data
+    ios_seek(f, LLT_ALIGN(ios_pos(f), 16));
+    ios_static_buffer(&const_data, f->buf + f->bpos, sizeof_constdata);
+    ios_skip(f, sizeof_constdata);
+
+    size_t sizeof_symbols = read_uint32(f);
+    ios_static_buffer(&symbols, f->buf + f->bpos, sizeof_symbols);
+    ios_skip(f, sizeof_symbols);
+
+    size_t sizeof_relocations = read_uint32(f);
+    assert(!ios_eof(f));
+    ios_static_buffer(&relocs, f->buf + f->bpos, sizeof_relocations);
+    ios_skip(f, sizeof_relocations);
+
+    size_t sizeof_gvar_record = read_uint32(f);
+    assert(!ios_eof(f));
+    ios_static_buffer(&gvar_record, f->buf + f->bpos, sizeof_gvar_record);
+    ios_skip(f, sizeof_gvar_record);
+
+    size_t sizeof_fptr_record = read_uint32(f);
+    assert(!ios_eof(f));
+    ios_static_buffer(&fptr_record, f->buf + f->bpos, sizeof_fptr_record);
+    ios_skip(f, sizeof_fptr_record);
+
+    assert(!ios_eof(f));
+    jl_read_symbols(&s);
+    ios_close(&symbols);
+
+    sysimg_base = &sysimg.buf[0];
+    sysimg_relocs = &relocs.buf[0];
+    jl_gc_set_permalloc_region((void*)sysimg_base, (void*)(sysimg_base + sysimg.size));
+
+    deser_tag.items[0] = (void*)const_data.buf;
+    jl_read_relocations(&s, GC_OLD_MARKED); // gctags
+    size_t sizeof_tags = ios_pos(&relocs);
+    jl_read_relocations(&s, 0); // general relocs
+    ios_close(&relocs);
+    ios_close(&const_data);
+    ios_close(&sysimg);
+
+    if (0) {
+        printf("sysimg size breakdown:\n"
+               "     sys data: %8u\n"
+               "  isbits data: %8u\n"
+               "      symbols: %8u\n"
+               "    tags list: %8u\n"
+               "   reloc list: %8u\n"
+               "    gvar list: %8u\n"
+               "    fptr list: %8u\n",
+            (unsigned)sizeof_sysimg,
+            (unsigned)sizeof_constdata,
+            (unsigned)sizeof_symbols,
+            (unsigned)sizeof_tags,
+            (unsigned)(sizeof_relocations - sizeof_tags),
+            (unsigned)sizeof_gvar_record,
+            (unsigned)sizeof_fptr_record);
+    }
+
+    // step 2: get special values
+    s.s = f;
+    jl_module_init_order = jl_finalize_deserializer(&s, NULL);
+    jl_main_module = (jl_module_t*)jl_read_value(&s);
+    jl_top_module = (jl_module_t*)jl_read_value(&s);
+    jl_internal_main_module = jl_main_module;
+
+    jl_typeinf_func = (jl_function_t*)jl_read_value(&s);
+    jl_typeinf_world = read_uint32(f);
+    jl_type_type_mt = (jl_methtable_t*)jl_read_value(&s);
+    jl_type_typename->mt = jl_type_type_mt;
+    jl_unionall_type->name->mt = jl_type_type_mt;
+    jl_uniontype_type->name->mt = jl_type_type_mt;
+    jl_datatype_type->name->mt = jl_type_type_mt;
+    jl_intrinsic_type->name->mt = (jl_methtable_t*)jl_read_value(&s);
+    jl_sym_type->name->mt = (jl_methtable_t*)jl_read_value(&s);
+    jl_array_typename->mt = (jl_methtable_t*)jl_read_value(&s);
+    jl_module_type->name->mt = (jl_methtable_t*)jl_read_value(&s);
+
+    uintptr_t i;
+    for (i = 0; i < builtin_typenames.len; i++) {
+        jl_typename_t *tn = (jl_typename_t*)builtin_typenames.items[i];
+        tn->cache = (jl_svec_t*)jl_read_value(&s);
+        jl_gc_wb(tn, tn->cache);
+        tn->linearcache = (jl_svec_t*)jl_read_value(&s);
+        jl_gc_wb(tn, tn->linearcache);
+        jl_resort_type_cache(tn->cache);
+    }
+
+    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, jl_symbol("Base"));
+    ptls->current_module = jl_base_module; // run start_image in Base
+
+    uint32_t uid_ctr = read_uint32(f);
+    uint32_t gs_ctr = read_uint32(f);
+    jl_world_counter = read_uint32(f);
+
+    jl_set_t_uid_ctr(uid_ctr);
+    jl_set_gs_ctr(gs_ctr);
+
+    jl_get_builtins();
+    jl_get_builtin_hooks();
+    if (jl_base_module) {
+        jl_get_system_hooks();
+    }
+    jl_boot_file_loaded = 1;
+    jl_init_box_caches();
+
+    jl_update_all_gvars(&s);
+    ios_close(&gvar_record);
+    jl_update_all_fptrs(&s);
+    ios_close(&fptr_record);
+
+    jl_gc_reset_alloc_count();
+    jl_gc_enable(en);
+    jl_cleanup_serializer2();
+}
+
+// TODO: need to enforce that the alignment of the buffer is suitable for vectors
+JL_DLLEXPORT void jl_restore_system_image(const char *fname)
+{
+#ifndef NDEBUG
+    char *dot = fname ? (char*)strrchr(fname, '.') : NULL;
+    int is_ji = (dot && !strcmp(dot, ".ji"));
+    assert((is_ji || jl_sysimg_handle) && "System image file not preloaded");
+#endif
+
+    if (jl_sysimg_handle) {
+        // load the pre-compiled sysimage from jl_sysimg_handle
+        jl_load_sysimg_so();
+    }
+    else {
+        ios_t f;
+        if (ios_file(&f, fname, 1, 0, 0, 0) == NULL)
+            jl_errorf("System image file \"%s\" not found.", fname);
+        ios_bufmode(&f, bm_none);
+        JL_SIGATOMIC_BEGIN();
+        ios_seek_end(&f);
+        size_t len = ios_pos(&f);
+        char *sysimg = (char*)jl_gc_perm_alloc(len, 0, 64, 0);
+        ios_seek(&f, 0);
+        if (ios_readall(&f, sysimg, len) != len)
+            jl_errorf("Error reading system image file.");
+        ios_close(&f);
+        ios_static_buffer(&f, sysimg, len);
+        jl_restore_system_image_from_stream(&f);
+        ios_close(&f);
+        JL_SIGATOMIC_END();
+    }
+}
+
+JL_DLLEXPORT void jl_restore_system_image_data(const char *buf, size_t len)
+{
+    ios_t f;
+    JL_SIGATOMIC_BEGIN();
+    ios_static_buffer(&f, (char*)buf, len);
+    jl_restore_system_image_from_stream(&f);
+    ios_close(&f);
+    JL_SIGATOMIC_END();
+}
+
+// --- init ---
+
+static void jl_init_serializer2(int for_serialize)
+{
+    jl_ptls_t ptls = jl_get_ptls_states();
+    arraylist_new(&builtin_typenames, 0);
+    if (for_serialize) {
+        htable_new(&sertag_table, 0);
+        htable_new(&symbol_table, 0);
+        htable_new(&fptr_to_id, sizeof(id_to_fptrs) / sizeof(*id_to_fptrs));
+        htable_new(&backref_table, 0);
+    }
+    else {
+        arraylist_new(&deser_tag, 0);
+        arraylist_new(&deser_sym, 0);
+    }
+    uintptr_t i;
+
+    void *tags[] = { ptls->root_task,
+                     jl_symbol_type, jl_ssavalue_type, jl_datatype_type, jl_slotnumber_type,
+                     jl_simplevector_type, jl_array_type, jl_typedslot_type,
+                     jl_expr_type, jl_globalref_type, jl_string_type,
+                     jl_module_type, jl_tvar_type, jl_method_instance_type, jl_method_type,
+                     jl_emptysvec, jl_emptytuple, jl_false, jl_true, jl_nothing, jl_any_type,
+                     call_sym, invoke_sym, goto_ifnot_sym, return_sym, body_sym, line_sym,
+                     lambda_sym, jl_symbol("tuple"), assign_sym,
+                     jl_labelnode_type, jl_linenumbernode_type,
+                     jl_gotonode_type, jl_quotenode_type,
+                     jl_type_type, jl_bottom_type, jl_ref_type, jl_pointer_type,
+                     jl_vararg_type, jl_abstractarray_type,
+                     jl_densearray_type, jl_void_type, jl_function_type, jl_typeofbottom_type,
+                     jl_unionall_type, jl_typename_type, jl_builtin_type, jl_code_info_type,
+                     jl_task_type, jl_uniontype_type, jl_typetype_type, jl_abstractstring_type,
+                     jl_ANY_flag, jl_array_any_type, jl_intrinsic_type, jl_abstractslot_type,
+                     jl_methtable_type, jl_typemap_level_type, jl_typemap_entry_type,
+                     jl_voidpointer_type, jl_newvarnode_type,
+                     jl_array_symbol_type, jl_anytuple_type, jl_tparam0(jl_anytuple_type),
+                     jl_emptytuple_type, jl_array_uint8_type,
+                     jl_symbol_type->name, jl_ssavalue_type->name, jl_tuple_typename,
+                     ((jl_datatype_t*)jl_unwrap_unionall((jl_value_t*)jl_ref_type))->name,
+                     jl_pointer_typename, jl_simplevector_type->name,
+                     jl_datatype_type->name, jl_uniontype_type->name, jl_array_typename,
+                     jl_expr_type->name, jl_typename_type->name, jl_type_typename,
+                     jl_methtable_type->name, jl_typemap_level_type->name, jl_typemap_entry_type->name, jl_tvar_type->name,
+                     ((jl_datatype_t*)jl_unwrap_unionall((jl_value_t*)jl_abstractarray_type))->name,
+                     ((jl_datatype_t*)jl_unwrap_unionall((jl_value_t*)jl_densearray_type))->name,
+                     jl_vararg_typename, jl_void_type->name, jl_method_instance_type->name, jl_method_type->name,
+                     jl_module_type->name, jl_function_type->name, jl_typedslot_type->name,
+                     jl_abstractslot_type->name, jl_slotnumber_type->name,
+                     jl_unionall_type->name, jl_intrinsic_type->name, jl_task_type->name,
+                     jl_labelnode_type->name, jl_linenumbernode_type->name, jl_builtin_type->name,
+                     jl_gotonode_type->name, jl_quotenode_type->name,
+                     jl_globalref_type->name, jl_typeofbottom_type->name,
+                     jl_string_type->name, jl_abstractstring_type->name,
+
+                     jl_int32_type, jl_int64_type, jl_bool_type, jl_uint8_type,
+
+                     // empirical list of very common symbols
+                     #include "common_symbols1.inc"
+
+                     NULL };
+
+    arraylist_push(&deser_tag, NULL);
+    arraylist_push(&deser_tag, NULL);
+    for (i = 0; tags[i] != NULL; i++) {
+        void *v = tags[i];
+        if (!for_serialize) {
+            // some builtins are only rooted through a type cache or Main.Core binding,
+            // but were allocated young, so we force the gc to change their tag here
+            jl_gc_force_mark_old(ptls, (jl_value_t*)v);
+        }
+        if (jl_is_symbol(v)) {
+            arraylist_push(&deser_sym, v);
+            if (for_serialize)
+                ptrhash_put(&symbol_table, v, (void*)((char*)HT_NOTFOUND + ((uintptr_t)SymbolRef << RELOC_TAG_OFFSET) + deser_sym.len));
+        }
+        else {
+            arraylist_push(&deser_tag, v);
+            if (for_serialize)
+                ptrhash_put(&sertag_table, v, (void*)((char*)HT_NOTFOUND + ((uintptr_t)TagRef << RELOC_TAG_OFFSET) + deser_tag.len));
+        }
+    }
+    assert(i + 1 == sizeof(tags) / sizeof(tags[0]));
+    assert(!for_serialize || ptrhash_get(&sertag_table, ptls->root_task) == (char*)HT_NOTFOUND + ((uintptr_t)TagRef << RELOC_TAG_OFFSET) + 3);
+    nsym_tag = deser_sym.len;
+
+    // this also ensures all objects referenced in the code have
+    // references in the system image to their global variable
+    // since codegen knows that some integer boxes are static,
+    // they might not have had a reference anywhere in the code
+    // image other than here
+#define NBOX_C 1024
+    for (i = 0; i < NBOX_C; i++) {
+        jl_value_t *v32 = jl_box_int32(i - NBOX_C / 2);
+        arraylist_push(&deser_tag, v32);
+        if (for_serialize)
+            ptrhash_put(&sertag_table, v32, (void*)((char*)HT_NOTFOUND + ((uintptr_t)TagRef << RELOC_TAG_OFFSET) + deser_tag.len));
+
+        jl_value_t *v64 = jl_box_int64(i - NBOX_C / 2);
+        arraylist_push(&deser_tag, v64);
+        if (for_serialize)
+            ptrhash_put(&sertag_table, v64, (void*)((char*)HT_NOTFOUND + ((uintptr_t)TagRef << RELOC_TAG_OFFSET) + deser_tag.len));
+    }
+
+    if (for_serialize) {
+        i = 2;
+        while (id_to_fptrs[i] != NULL) {
+            ptrhash_put(&fptr_to_id, (void*)(uintptr_t)id_to_fptrs[i], (void*)i);
+            i += 1;
+        }
+    }
+
+    arraylist_push(&builtin_typenames, jl_array_typename);
+    arraylist_push(&builtin_typenames, ((jl_datatype_t*)jl_ref_type->body)->name);
+    arraylist_push(&builtin_typenames, jl_pointer_typename);
+    arraylist_push(&builtin_typenames, jl_type_typename);
+    arraylist_push(&builtin_typenames, ((jl_datatype_t*)jl_unwrap_unionall((jl_value_t*)jl_abstractarray_type))->name);
+    arraylist_push(&builtin_typenames, ((jl_datatype_t*)jl_unwrap_unionall((jl_value_t*)jl_densearray_type))->name);
+    arraylist_push(&builtin_typenames, jl_tuple_typename);
+    arraylist_push(&builtin_typenames, jl_vararg_typename);
+}
+
+static void jl_cleanup_serializer2(void)
+{
+    htable_reset(&sertag_table, 0);
+    htable_reset(&symbol_table, 0);
+    htable_reset(&fptr_to_id, 0);
+    htable_reset(&backref_table, 0);
+    arraylist_free(&deser_tag);
+    arraylist_free(&deser_sym);
+    arraylist_free(&builtin_typenames);
+    nsym_tag = 0;
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/subtype.c b/src/subtype.c
index 7f6639b7f53f72..adf1e0776f9394 100644
--- a/src/subtype.c
+++ b/src/subtype.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 /*
   subtyping predicate
@@ -39,10 +39,12 @@ extern "C" {
 // Union type decision points are discovered while the algorithm works.
 // If a new Union decision is encountered, the `more` flag is set to tell
 // the forall/exists loop to grow the stack.
+// TODO: the stack probably needs to be artifically large because of some
+// deeper problem (see #21191) and could be shrunk once that is fixed
 typedef struct {
     int depth;
     int more;
-    uint32_t stack[10];  // stack of bits represented as a bit vector
+    uint32_t stack[100];  // stack of bits represented as a bit vector
 } jl_unionstate_t;
 
 // Linked list storing the type variable environment. A new jl_varbinding_t
@@ -74,6 +76,9 @@ typedef struct _varbinding {
     // when this variable's integer value is compared to that of another,
     // it equals `other + offset`. used by vararg length parameters.
     int offset;
+    // array of typevars that our bounds depend on, whose UnionAlls need to be
+    // moved outside ours.
+    jl_array_t *innervars;
     struct _varbinding *prev;
 } jl_varbinding_t;
 
@@ -88,6 +93,7 @@ typedef struct {
     int invdepth;             // current number of invariant constructors we're nested in
     int ignore_free;          // treat free vars as black boxes; used during intersection
     int intersection;         // true iff subtype is being called from intersection
+    int emptiness_only;       // true iff intersection only needs to test for emptiness
 } jl_stenv_t;
 
 // state manipulation utilities
@@ -132,14 +138,15 @@ static void save_env(jl_stenv_t *e, jl_value_t **root, jl_savedenv_t *se)
         len++;
         v = v->prev;
     }
-    *root = (jl_value_t*)jl_alloc_svec(len*2);
+    *root = (jl_value_t*)jl_alloc_svec(len*3);
     se->buf = (int8_t*)(len ? malloc(len*2) : NULL);
-    int i=0; v = e->vars;
+    int i=0, j=0; v = e->vars;
     while (v != NULL) {
-        jl_svecset(*root, i, v->lb); se->buf[i] = v->occurs_inv;
-        i++;
-        jl_svecset(*root, i, v->ub); se->buf[i] = v->occurs_cov;
-        i++;
+        jl_svecset(*root, i++, v->lb);
+        jl_svecset(*root, i++, v->ub);
+        jl_svecset(*root, i++, (jl_value_t*)v->innervars);
+        se->buf[j++] = v->occurs_inv;
+        se->buf[j++] = v->occurs_cov;
         v = v->prev;
     }
     se->rdepth = e->Runions.depth;
@@ -148,14 +155,16 @@ static void save_env(jl_stenv_t *e, jl_value_t **root, jl_savedenv_t *se)
 static void restore_env(jl_stenv_t *e, jl_value_t *root, jl_savedenv_t *se)
 {
     jl_varbinding_t *v = e->vars;
-    int i = 0;
+    int i = 0, j = 0;
     while (v != NULL) {
         if (root) v->lb = jl_svecref(root, i);
-        v->occurs_inv = se->buf[i];
         i++;
         if (root) v->ub = jl_svecref(root, i);
-        v->occurs_cov = se->buf[i];
         i++;
+        if (root) v->innervars = (jl_array_t*)jl_svecref(root, i);
+        i++;
+        v->occurs_inv = se->buf[j++];
+        v->occurs_cov = se->buf[j++];
         v = v->prev;
     }
     e->Runions.depth = se->rdepth;
@@ -232,6 +241,99 @@ static int obviously_unequal(jl_value_t *a, jl_value_t *b)
     return 0;
 }
 
+int jl_obviously_unequal(jl_value_t *a, jl_value_t *b)
+{
+    return obviously_unequal(a, b);
+}
+
+static int obviously_disjoint(jl_value_t *a, jl_value_t *b, int specificity)
+{
+    if (a == b || a == (jl_value_t*)jl_any_type || b == (jl_value_t*)jl_any_type)
+        return 0;
+    if (jl_is_concrete_type(a) && !((jl_datatype_t*)a)->abstract &&
+        jl_is_concrete_type(b) && !((jl_datatype_t*)b)->abstract &&
+        // TODO: remove these 2 lines if and when Tuple{Union{}} === Union{}
+        (((jl_datatype_t*)a)->name != jl_tuple_typename ||
+         ((jl_datatype_t*)b)->name != jl_tuple_typename))
+        return 1;
+    if (jl_is_unionall(a)) a = jl_unwrap_unionall(a);
+    if (jl_is_unionall(b)) b = jl_unwrap_unionall(b);
+    if (jl_is_datatype(a) && jl_is_datatype(b)) {
+        jl_datatype_t *ad = (jl_datatype_t*)a, *bd = (jl_datatype_t*)b;
+        if (ad->name != bd->name) {
+            jl_datatype_t *temp = ad;
+            while (temp != jl_any_type && temp->name != bd->name)
+                temp = temp->super;
+            if (temp == jl_any_type) {
+                temp = bd;
+                while (temp != jl_any_type && temp->name != ad->name)
+                    temp = temp->super;
+                if (temp == jl_any_type)
+                    return 1;
+                bd = temp;
+            }
+            else {
+                ad = temp;
+            }
+            if (specificity) {
+                // account for declared subtypes taking priority (issue #21710)
+                return 0;
+            }
+        }
+        int istuple = (ad->name == jl_tuple_typename);
+        size_t np;
+        if (istuple) {
+            size_t na = jl_nparams(ad), nb = jl_nparams(bd);
+            if (jl_is_va_tuple(ad)) {
+                na -= 1;
+                if (jl_is_va_tuple(bd))
+                    nb -= 1;
+            }
+            else if (jl_is_va_tuple(bd)) {
+                nb -= 1;
+            }
+            else if (!specificity && na != nb) {
+                // note: some disjoint types (e.g. tuples of different lengths) can be more specific
+                return 1;
+            }
+            np = na < nb ? na : nb;
+        }
+        else {
+            np = jl_nparams(ad);
+        }
+        size_t i;
+        for(i=0; i < np; i++) {
+            jl_value_t *ai = jl_tparam(ad,i);
+            jl_value_t *bi = jl_tparam(bd,i);
+            if (jl_is_typevar(ai) || jl_is_typevar(bi))
+                continue;
+            if (jl_is_type(ai)) {
+                if (jl_is_type(bi)) {
+                    if (istuple && (ai == jl_bottom_type || bi == jl_bottom_type))
+                        ; // TODO: this can return 1 if and when Tuple{Union{}} === Union{}
+                    else if (obviously_disjoint(ai, bi, specificity))
+                        return 1;
+                }
+                else if (!specificity) {
+                    // Tuple{1} is more specific than Tuple{Any}
+                    return 1;
+                }
+            }
+            else if (jl_is_type(bi)) {
+                if (!specificity)
+                    return 1;
+            }
+            else if (!jl_egal(ai, bi)) {
+                return 1;
+            }
+        }
+    }
+    else if (a == jl_bottom_type || b == jl_bottom_type) {
+        return 1;
+    }
+    return 0;
+}
+
 static int in_union(jl_value_t *u, jl_value_t *x)
 {
     if (u == x) return 1;
@@ -385,6 +487,12 @@ static int var_gt(jl_tvar_t *b, jl_value_t *a, jl_stenv_t *e, int param)
     record_var_occurrence(bb, e, param);
     if (!bb->right)  // check ∀b . b>:a
         return subtype_ufirst(a, bb->lb, e);
+    if (bb->lb == bb->ub) {
+        if (jl_is_typevar(bb->lb) && !jl_is_type(a) && !jl_is_typevar(a))
+            return var_gt((jl_tvar_t*)bb->lb, a, e, param);
+        if (jl_is_typevar(a) && !jl_is_type(bb->lb) && !jl_is_typevar(bb->lb))
+            return var_lt((jl_tvar_t*)a, bb->lb, e, param);
+    }
     if (!((bb->ub == (jl_value_t*)jl_any_type && !jl_is_type(a) && !jl_is_typevar(a)) || subtype_ufirst(a, bb->ub, e)))
         return 0;
     bb->lb = simple_join(bb->lb, a);
@@ -414,7 +522,14 @@ static int is_leaf_bound(jl_value_t *v)
         }
         return 1;
     }
-    return 0;
+    return !jl_is_type(v) && !jl_is_typevar(v);
+}
+
+static int is_leaf_typevar(jl_value_t *v)
+{
+    if (jl_is_typevar(v))
+        return is_leaf_typevar(((jl_tvar_t*)v)->lb);
+    return is_leaf_bound(v);
 }
 
 static jl_value_t *widen_Type(jl_value_t *t)
@@ -437,14 +552,16 @@ static int subtype_unionall(jl_value_t *t, jl_unionall_t *u, jl_stenv_t *e, int8
     // if the var for this unionall (based on identity) already appears somewhere
     // in the environment, rename to get a fresh var.
     while (btemp != NULL) {
-        if (btemp->var == u->var || jl_has_typevar(btemp->lb, u->var) ||
-            jl_has_typevar(btemp->ub, u->var)) {
+        if (btemp->var == u->var ||
+            // outer var can only refer to inner var if bounds changed
+            (btemp->lb != btemp->var->lb && jl_has_typevar(btemp->lb, u->var)) ||
+            (btemp->ub != btemp->var->ub && jl_has_typevar(btemp->ub, u->var))) {
             u = rename_unionall(u);
             break;
         }
         btemp = btemp->prev;
     }
-    jl_varbinding_t vb = { u->var, u->var->lb, u->var->ub, R, NULL, 0, 0, 0, 0, e->invdepth, 0, e->vars };
+    jl_varbinding_t vb = { u->var, u->var->lb, u->var->ub, R, NULL, 0, 0, 0, 0, e->invdepth, 0, NULL, e->vars };
     JL_GC_PUSH3(&u, &vb.lb, &vb.ub);
     e->vars = &vb;
     int ans;
@@ -475,6 +592,7 @@ static int subtype_unionall(jl_value_t *t, jl_unionall_t *u, jl_stenv_t *e, int8
             // multiple union members), consider the value unknown.
             if (!oldval || !jl_is_typevar(oldval) || !jl_is_long(val))
                 e->envout[e->envidx] = val;
+            // TODO: substitute the value (if any) of this variable into previous envout entries
         }
     }
     else {
@@ -486,7 +604,8 @@ static int subtype_unionall(jl_value_t *t, jl_unionall_t *u, jl_stenv_t *e, int8
     //  ( Tuple{Int, Int}    <: Tuple{T, T} where T) but
     // !( Tuple{Int, String} <: Tuple{T, T} where T)
     // Then check concreteness by checking that the lower bound is not an abstract type.
-    if (ans && (vb.concrete || (!vb.occurs_inv && vb.occurs_cov > 1))) {
+    if (ans && (vb.concrete || (!vb.occurs_inv && vb.occurs_cov > 1)) &&
+        is_leaf_typevar((jl_value_t*)u->var)) {
         if (jl_is_typevar(vb.lb)) {
             // TODO test case that demonstrates the need for this?
             /*
@@ -520,7 +639,8 @@ static int subtype_unionall(jl_value_t *t, jl_unionall_t *u, jl_stenv_t *e, int8
     btemp = e->vars;
     while (btemp != NULL) {
         jl_value_t *vi = btemp->ub;
-        if (vi != (jl_value_t*)vb.var && jl_has_typevar(vi, vb.var)) {
+        // TODO: this takes a significant amount of time
+        if (vi != (jl_value_t*)vb.var && btemp->var->ub != vi && jl_has_typevar(vi, vb.var)) {
             btemp->ub = jl_new_struct(jl_unionall_type, vb.var, vi);
             btemp->lb = jl_bottom_type;
         }
@@ -585,11 +705,11 @@ static int subtype_tuple(jl_datatype_t *xd, jl_datatype_t *yd, jl_stenv_t *e, in
     jl_value_t *lastx=NULL, *lasty=NULL;
     while (i < lx) {
         jl_value_t *xi = jl_tparam(xd, i);
-        if (jl_is_vararg_type(xi)) vx = 1;
+        if (i == lx-1 && vvx) vx = 1;
         jl_value_t *yi = NULL;
         if (j < ly) {
             yi = jl_tparam(yd, j);
-            if (jl_is_vararg_type(yi)) vy = 1;
+            if (j == ly-1 && vvy) vy = 1;
         }
         if (vx && !vy) {
             if (!check_vararg_length(xi, ly+1-lx, e))
@@ -670,8 +790,6 @@ static int forall_exists_equal(jl_value_t *x, jl_value_t *y, jl_stenv_t *e);
 // diagonal rule (record_var_occurrence).
 static int subtype(jl_value_t *x, jl_value_t *y, jl_stenv_t *e, int param)
 {
-    if (x == jl_ANY_flag) x = (jl_value_t*)jl_any_type;
-    if (y == jl_ANY_flag) y = (jl_value_t*)jl_any_type;
     if (jl_is_uniontype(x)) {
         if (x == y) return 1;
         x = pick_union_element(x, e, 0);
@@ -761,23 +879,11 @@ static int subtype(jl_value_t *x, jl_value_t *y, jl_stenv_t *e, int param)
             }
             return 0;
         }
-        if (jl_is_type_type(y) && !jl_is_type_type(x)) {
+        if (jl_is_type_type(y) && !jl_is_type_type(x) && x != (jl_value_t*)jl_typeofbottom_type) {
             jl_value_t *tp0 = jl_tparam0(yd);
-            if (!jl_is_typevar(tp0))
+            if (!jl_is_typevar(tp0) || !jl_is_kind(x))
                 return 0;
-            if (!jl_is_kind(x)) return 0;
-            jl_varbinding_t *yy = lookup(e, (jl_tvar_t*)tp0);
-            jl_value_t *ub = yy ? yy->ub : ((jl_tvar_t*)tp0)->ub;
-            int ans;
-            if (ub == (jl_value_t*)jl_any_type) {
-                ans = subtype((jl_value_t*)jl_type_type, y, e, param);
-            }
-            else {
-                e->invdepth++;
-                ans = forall_exists_equal(x, jl_tparam0(yd), e);
-                e->invdepth--;
-            }
-            return ans;
+            return subtype((jl_value_t*)jl_type_type, y, e, param);
         }
         while (xd != jl_any_type && xd->name != yd->name) {
             if (xd->super == NULL)
@@ -785,9 +891,9 @@ static int subtype(jl_value_t *x, jl_value_t *y, jl_stenv_t *e, int param)
             xd = xd->super;
         }
         if (xd == jl_any_type) return 0;
-        if (jl_is_tuple_type(xd))
+        if (xd->name == jl_tuple_typename)
             return subtype_tuple(xd, yd, e, param);
-        if (jl_is_vararg_type((jl_value_t*)xd)) {
+        if (xd->name == jl_vararg_typename) {
             // Vararg: covariant in first parameter, invariant in second
             jl_value_t *xp1=jl_tparam0(xd), *xp2=jl_tparam1(xd), *yp1=jl_tparam0(yd), *yp2=jl_tparam1(yd);
             // in Vararg{T1} <: Vararg{T2}, need to check subtype twice to
@@ -904,6 +1010,7 @@ static void init_stenv(jl_stenv_t *e, jl_value_t **env, int envsz)
     e->invdepth = 0;
     e->ignore_free = 0;
     e->intersection = 0;
+    e->emptiness_only = 0;
     e->Lunions.depth = 0;      e->Runions.depth = 0;
     e->Lunions.more = 0;       e->Runions.more = 0;
 }
@@ -1104,25 +1211,61 @@ static jl_value_t *set_var_to_const(jl_varbinding_t *bb, jl_value_t *v, jl_varbi
     return v;
 }
 
+static int try_subtype_in_env(jl_value_t *a, jl_value_t *b, jl_stenv_t *e)
+{
+    jl_value_t *root=NULL; jl_savedenv_t se; int ret=0;
+    JL_GC_PUSH1(&root);
+    save_env(e, &root, &se);
+    if (subtype_in_env(a, b, e))
+        ret = 1;
+    else
+        restore_env(e, root, &se);
+    free(se.buf);
+    JL_GC_POP();
+    return ret;
+}
+
+static int var_occurs_inside(jl_value_t *v, jl_tvar_t *var, int inside, int want_inv);
+
 static jl_value_t *intersect_var(jl_tvar_t *b, jl_value_t *a, jl_stenv_t *e, int8_t R, int param)
 {
     jl_varbinding_t *bb = lookup(e, b);
     if (bb == NULL)
         return R ? intersect_ufirst(a, b->ub, e, 0) : intersect_ufirst(b->ub, a, e, 0);
+    if (bb->lb == bb->ub && jl_is_typevar(bb->lb))
+        return intersect(a, bb->lb, e, param);
     if (!jl_is_type(a) && !jl_is_typevar(a))
         return set_var_to_const(bb, a, NULL);
     int d = bb->depth0;
     jl_value_t *root=NULL; jl_savedenv_t se;
     if (param == 2) {
-        if (bb->lb == bb->ub && jl_is_typevar(bb->lb))
-            return intersect(a, bb->ub, e, param);
         jl_value_t *ub = R ? intersect_ufirst(a, bb->ub, e, d) : intersect_ufirst(bb->ub, a, e, d);
-        JL_GC_PUSH1(&ub);
-        if (!subtype_in_env(bb->lb, a, e)) {
+        JL_GC_PUSH2(&ub, &root);
+        save_env(e, &root, &se);
+        int issub = subtype_in_env(bb->lb, ub, e);
+        restore_env(e, root, &se);
+        free(se.buf);
+        if (!issub) {
             JL_GC_POP();
             return jl_bottom_type;
         }
         if (ub != (jl_value_t*)b) {
+            if (jl_has_free_typevars(ub)) {
+                // constraint X == Ref{X} is unsatisfiable. also check variables set equal to X.
+                if (var_occurs_inside(ub, b, 0, 0)) {
+                    JL_GC_POP();
+                    return jl_bottom_type;
+                }
+                jl_varbinding_t *btemp = e->vars;
+                while (btemp != NULL) {
+                    if (btemp->lb == (jl_value_t*)b && btemp->ub == (jl_value_t*)b &&
+                        var_occurs_inside(ub, btemp->var, 0, 0)) {
+                        JL_GC_POP();
+                        return jl_bottom_type;
+                    }
+                    btemp = btemp->prev;
+                }
+            }
             bb->ub = ub;
             bb->lb = ub;
         }
@@ -1130,17 +1273,9 @@ static jl_value_t *intersect_var(jl_tvar_t *b, jl_value_t *a, jl_stenv_t *e, int
         return ub;
     }
     else if (bb->constraintkind == 0) {
-        if (!jl_is_typevar(a)) {
-            jl_value_t *ret=NULL;
-            JL_GC_PUSH1(&root);
-            save_env(e, &root, &se);
-            if (subtype_in_env(bb->ub, a, e))
-                ret = (jl_value_t*)b;
-            else
-                restore_env(e, root, &se);
-            free(se.buf);
-            JL_GC_POP();
-            if (ret) return ret;
+        if (!jl_is_typevar(bb->ub) && !jl_is_typevar(a)) {
+            if (try_subtype_in_env(bb->ub, a, e))
+                return (jl_value_t*)b;
         }
         return R ? intersect_ufirst(a, bb->ub, e, d) : intersect_ufirst(bb->ub, a, e, d);
     }
@@ -1171,8 +1306,17 @@ static jl_value_t *intersect_var(jl_tvar_t *b, jl_value_t *a, jl_stenv_t *e, int
     if (jl_is_typevar(a))
         return (jl_value_t*)b;
     if (ub == a) {
-        bb->ub = ub;
-        return (jl_value_t*)b;
+        if (bb->lb == jl_bottom_type ||
+            // if the var has an equality constraint then make sure bounds stay consistent.
+            // TODO: try to use this check in more cases
+            bb->ub != bb->lb || try_subtype_in_env(bb->lb, ub, e)) {
+            bb->ub = ub;
+            return (jl_value_t*)b;
+        }
+        return ub;
+    }
+    else if (bb->ub == bb->lb) {
+        return ub;
     }
     root = NULL;
     JL_GC_PUSH2(&root, &ub);
@@ -1189,28 +1333,31 @@ static jl_value_t *intersect_var(jl_tvar_t *b, jl_value_t *a, jl_stenv_t *e, int
     return ii;
 }
 
-static int var_occurs_invariant(jl_value_t *v, jl_tvar_t *var, int inv)
+// test whether `var` occurs inside constructors. `want_inv` tests only inside
+// invariant constructors. `inside` means we are currently inside a constructor of the
+// requested kind.
+static int var_occurs_inside(jl_value_t *v, jl_tvar_t *var, int inside, int want_inv)
 {
     if (v == (jl_value_t*)var) {
-        return inv;
+        return inside;
     }
     else if (jl_is_uniontype(v)) {
-        return var_occurs_invariant(((jl_uniontype_t*)v)->a, var, inv) ||
-            var_occurs_invariant(((jl_uniontype_t*)v)->b, var, inv);
+        return var_occurs_inside(((jl_uniontype_t*)v)->a, var, inside, want_inv) ||
+            var_occurs_inside(((jl_uniontype_t*)v)->b, var, inside, want_inv);
     }
     else if (jl_is_unionall(v)) {
         jl_unionall_t *ua = (jl_unionall_t*)v;
         if (ua->var == var)
             return 0;
-        if (var_occurs_invariant(ua->var->lb, var, inv) || var_occurs_invariant(ua->var->ub, var, inv))
+        if (var_occurs_inside(ua->var->lb, var, inside, want_inv) || var_occurs_inside(ua->var->ub, var, inside, want_inv))
             return 1;
-        return var_occurs_invariant(ua->body, var, inv);
+        return var_occurs_inside(ua->body, var, inside, want_inv);
     }
     else if (jl_is_datatype(v)) {
         size_t i;
-        int invar = inv || !jl_is_tuple_type(v);
+        int ins = inside || !want_inv || !jl_is_tuple_type(v);
         for (i=0; i < jl_nparams(v); i++) {
-            if (var_occurs_invariant(jl_tparam(v,i), var, invar))
+            if (var_occurs_inside(jl_tparam(v,i), var, ins, want_inv))
                 return 1;
         }
     }
@@ -1220,30 +1367,56 @@ static int var_occurs_invariant(jl_value_t *v, jl_tvar_t *var, int inv)
 // Caller might not have rooted `res`
 static jl_value_t *finish_unionall(jl_value_t *res, jl_varbinding_t *vb, jl_stenv_t *e)
 {
-    jl_value_t *varval = NULL, *root = NULL;
-    JL_GC_PUSH2(&res, &root);
+    jl_value_t *varval = NULL;
+    jl_tvar_t *newvar = vb->var;
+    JL_GC_PUSH2(&res, &newvar);
     // try to reduce var to a single value
     if (obviously_egal(vb->lb, vb->ub)) {
         // given x<:T<:x, substitute x for T
         varval = vb->ub;
     }
-    else if (!var_occurs_invariant(res, vb->var, 0) && is_leaf_bound(vb->ub)) {
+    else if (!var_occurs_inside(res, vb->var, 0, 1) && is_leaf_bound(vb->ub)) {
         // replace T<:x with x in covariant position when possible
         varval = vb->ub;
     }
 
+    if (!varval && (vb->lb != vb->var->lb || vb->ub != vb->var->ub))
+        newvar = jl_new_typevar(vb->var->name, vb->lb, vb->ub);
+
     // remove/replace/rewrap free occurrences of this var in the environment
     jl_varbinding_t *btemp = e->vars;
+    int wrap = 1;
     while (btemp != NULL) {
         if (jl_has_typevar(btemp->lb, vb->var)) {
             if (vb->lb == (jl_value_t*)btemp->var) {
                 JL_GC_POP();
                 return jl_bottom_type;
             }
-            if (varval)
-                btemp->lb = jl_substitute_var(btemp->lb, vb->var, varval);
+            if (varval) {
+                JL_TRY {
+                    btemp->lb = jl_substitute_var(btemp->lb, vb->var, varval);
+                }
+                JL_CATCH {
+                    res = jl_bottom_type;
+                }
+            }
             else if (btemp->lb == (jl_value_t*)vb->var)
                 btemp->lb = vb->lb;
+            else if (btemp->depth0 == vb->depth0 && !jl_has_typevar(vb->lb, btemp->var) &&
+                     !jl_has_typevar(vb->ub, btemp->var) && jl_has_typevar(btemp->ub, vb->var)) {
+                // if our variable is T, and some outer variable has constraint S = Ref{T},
+                // move the `where T` outside `where S` instead of putting it here. issue #21243.
+                if (btemp->innervars == NULL)
+                    btemp->innervars = jl_alloc_array_1d(jl_array_any_type, 0);
+                if (newvar != vb->var) {
+                    btemp->lb = jl_substitute_var(btemp->lb, vb->var, (jl_value_t*)newvar);
+                    btemp->ub = jl_substitute_var(btemp->ub, vb->var, (jl_value_t*)newvar);
+                }
+                jl_array_ptr_1d_push(btemp->innervars, (jl_value_t*)newvar);
+                wrap = 0;
+                btemp = btemp->prev;
+                continue;
+            }
             else
                 btemp->lb = jl_new_struct(jl_unionall_type, vb->var, btemp->lb);
             assert((jl_value_t*)btemp->var != btemp->lb);
@@ -1253,8 +1426,14 @@ static jl_value_t *finish_unionall(jl_value_t *res, jl_varbinding_t *vb, jl_sten
                 JL_GC_POP();
                 return jl_bottom_type;
             }
-            if (varval)
-                btemp->ub = jl_substitute_var(btemp->ub, vb->var, varval);
+            if (varval) {
+                JL_TRY {
+                    btemp->ub = jl_substitute_var(btemp->ub, vb->var, varval);
+                }
+                JL_CATCH {
+                    res = jl_bottom_type;
+                }
+            }
             else if (btemp->ub == (jl_value_t*)vb->var)
                 btemp->ub = vb->ub;
             else
@@ -1266,29 +1445,39 @@ static jl_value_t *finish_unionall(jl_value_t *res, jl_varbinding_t *vb, jl_sten
 
     // if `v` still occurs, re-wrap body in `UnionAll v` or eliminate the UnionAll
     if (jl_has_typevar(res, vb->var)) {
-        res = jl_new_struct(jl_unionall_type, vb->var, res);
         if (varval) {
             JL_TRY {
                 // you can construct `T{x} where x` even if T's parameter is actually
                 // limited. in that case we might get an invalid instantiation here.
-                res = jl_instantiate_unionall((jl_unionall_t*)res, varval);
+                res = jl_substitute_var(res, vb->var, varval);
             }
             JL_CATCH {
                 res = jl_bottom_type;
             }
         }
         else {
-            varval = root = (jl_value_t*)jl_new_typevar(vb->var->name, vb->lb, vb->ub);
-            res = jl_instantiate_unionall((jl_unionall_t*)res, root);
-            res = jl_new_struct(jl_unionall_type, (jl_tvar_t*)root, res);
+            if (newvar != vb->var)
+                res = jl_substitute_var(res, vb->var, (jl_value_t*)newvar);
+            varval = (jl_value_t*)newvar;
+            if (wrap)
+                res = jl_new_struct(jl_unionall_type, (jl_tvar_t*)newvar, res);
+        }
+    }
+
+    if (res != jl_bottom_type && vb->innervars != NULL) {
+        int i;
+        for(i=0; i < jl_array_len(vb->innervars); i++) {
+            jl_tvar_t *var = (jl_tvar_t*)jl_arrayref(vb->innervars, i);
+            if (jl_has_typevar(res, var))
+                res = jl_new_struct(jl_unionall_type, (jl_tvar_t*)var, res);
         }
     }
 
     if (vb->right && e->envidx < e->envsz) {
         jl_value_t *oldval = e->envout[e->envidx];
-        if (!varval)
+        if (!varval || (!is_leaf_bound(varval) && !vb->occurs_inv))
             e->envout[e->envidx] = (jl_value_t*)vb->var;
-        else if (!oldval || !jl_is_typevar(oldval) || !jl_is_long(varval))
+        else if (!(oldval && jl_is_typevar(oldval) && jl_is_long(varval)))
             e->envout[e->envidx] = varval;
     }
 
@@ -1322,14 +1511,14 @@ static jl_value_t *intersect_unionall_(jl_value_t *t, jl_unionall_t *u, jl_stenv
     else {
         res = intersect(u->body, t, e, param);
     }
-    vb->concrete |= (!vb->occurs_inv && vb->occurs_cov > 1);
+    vb->concrete |= (!vb->occurs_inv && vb->occurs_cov > 1 && is_leaf_typevar((jl_value_t*)u->var));
 
     // handle the "diagonal dispatch" rule, which says that a type var occurring more
     // than once, and only in covariant position, is constrained to concrete types. E.g.
     //  ( Tuple{Int, Int}    <: Tuple{T, T} where T) but
     // !( Tuple{Int, String} <: Tuple{T, T} where T)
     // Then check concreteness by checking that the lower bound is not an abstract type.
-    if (res != jl_bottom_type && (vb->concrete || (!vb->occurs_inv && vb->occurs_cov > 1))) {
+    if (res != jl_bottom_type && vb->concrete) {
         if (jl_is_typevar(vb->lb)) {
         }
         else if (!is_leaf_bound(vb->lb)) {
@@ -1358,8 +1547,8 @@ static jl_value_t *intersect_unionall(jl_value_t *t, jl_unionall_t *u, jl_stenv_
 {
     jl_value_t *res=NULL, *res2=NULL, *save=NULL, *save2=NULL;
     jl_savedenv_t se, se2;
-    jl_varbinding_t vb = { u->var, u->var->lb, u->var->ub, R, NULL, 0, 0, 0, 0, e->invdepth, 0, e->vars };
-    JL_GC_PUSH5(&res, &save2, &vb.lb, &vb.ub, &save);
+    jl_varbinding_t vb = { u->var, u->var->lb, u->var->ub, R, NULL, 0, 0, 0, 0, e->invdepth, 0, NULL, e->vars };
+    JL_GC_PUSH6(&res, &save2, &vb.lb, &vb.ub, &save, &vb.innervars);
     save_env(e, &save, &se);
     res = intersect_unionall_(t, u, e, R, param, &vb);
     if (res != jl_bottom_type) {
@@ -1536,8 +1725,10 @@ static jl_value_t *intersect_sub_datatype(jl_datatype_t *xd, jl_datatype_t *yd,
             for(i=0; i<envsz; i++) {
                 // if a parameter is not constrained by the supertype, use the original
                 // parameter value from `x`. this is detected by the value in `env` being
-                // the exact typevar from the type's `wrapper`.
-                if (env[i] == (jl_value_t*)((jl_unionall_t*)wr)->var)
+                // the exact typevar from the type's `wrapper`, or a free typevar.
+                jl_value_t *ei = env[i];
+                if (ei == (jl_value_t*)((jl_unionall_t*)wr)->var ||
+                    (jl_is_typevar(ei) && lookup(e, (jl_tvar_t*)ei) == NULL))
                     env[i] = jl_tparam(xd,i);
                 wr = ((jl_unionall_t*)wr)->body;
             }
@@ -1599,7 +1790,7 @@ static jl_value_t *intersect_type_type(jl_value_t *x, jl_value_t *y, jl_stenv_t
     if (!jl_is_typevar(p0))
         return (jl_typeof(p0) == y) ? x : jl_bottom_type;
     if (!jl_is_kind(y)) return jl_bottom_type;
-    if (y == (jl_value_t*)jl_bottomtype_type && ((jl_tvar_t*)p0)->lb == jl_bottom_type)
+    if (y == (jl_value_t*)jl_typeofbottom_type && ((jl_tvar_t*)p0)->lb == jl_bottom_type)
         return (jl_value_t*)jl_wrap_Type(jl_bottom_type);
     if (((jl_tvar_t*)p0)->ub == (jl_value_t*)jl_any_type)
         return y;
@@ -1621,8 +1812,6 @@ static jl_value_t *intersect_type_type(jl_value_t *x, jl_value_t *y, jl_stenv_t
 static jl_value_t *intersect(jl_value_t *x, jl_value_t *y, jl_stenv_t *e, int param)
 {
     if (x == y) return y;
-    if (x == jl_ANY_flag) x = (jl_value_t*)jl_any_type;
-    if (y == jl_ANY_flag) y = (jl_value_t*)jl_any_type;
     if (jl_is_typevar(x)) {
         if (jl_is_typevar(y)) {
             jl_varbinding_t *xx = lookup(e, (jl_tvar_t*)x);
@@ -1705,8 +1894,6 @@ static jl_value_t *intersect(jl_value_t *x, jl_value_t *y, jl_stenv_t *e, int pa
         record_var_occurrence(lookup(e, (jl_tvar_t*)y), e, param);
         return intersect_var((jl_tvar_t*)y, x, e, 1, param);
     }
-    if (y == (jl_value_t*)jl_any_type) return x;
-    if (x == (jl_value_t*)jl_any_type) return y;
     if (!jl_has_free_typevars(x) && !jl_has_free_typevars(y)) {
         if (jl_subtype(x, y)) return x;
         if (jl_subtype(y, x)) return y;
@@ -1723,6 +1910,8 @@ static jl_value_t *intersect(jl_value_t *x, jl_value_t *y, jl_stenv_t *e, int pa
             return intersect_unionall(y, (jl_unionall_t*)x, e, 0, param);
         return intersect_union(x, (jl_uniontype_t*)y, e, 1, param);
     }
+    if (y == (jl_value_t*)jl_any_type) return x;
+    if (x == (jl_value_t*)jl_any_type) return y;
     if (jl_is_unionall(x)) {
         if (jl_is_unionall(y)) {
             jl_value_t *a=NULL, *b=jl_bottom_type, *res=NULL;
@@ -1782,11 +1971,11 @@ static jl_value_t *intersect(jl_value_t *x, jl_value_t *y, jl_stenv_t *e, int pa
                 if (ii == jl_bottom_type) return jl_bottom_type;
                 if (jl_is_typevar(xp1)) {
                     jl_varbinding_t *xb = lookup(e, (jl_tvar_t*)xp1);
-                    if (xb) xb->concrete = 1;
+                    if (xb && is_leaf_typevar((jl_value_t*)xb->var)) xb->concrete = 1;
                 }
                 if (jl_is_typevar(yp1)) {
                     jl_varbinding_t *yb = lookup(e, (jl_tvar_t*)yp1);
-                    if (yb) yb->concrete = 1;
+                    if (yb && is_leaf_typevar((jl_value_t*)yb->var)) yb->concrete = 1;
                 }
                 JL_GC_PUSH2(&ii, &i2);
                 // Vararg{T,N} <: Vararg{T2,N2}; equate N and N2
@@ -1841,6 +2030,8 @@ static jl_value_t *intersect_all(jl_value_t *x, jl_value_t *y, jl_stenv_t *e)
     int lastset = 0, niter = 0;
     jl_value_t *ii = intersect(x, y, e, 0);
     while (e->Runions.more) {
+        if (e->emptiness_only && ii != jl_bottom_type)
+            return ii;
         e->Runions.depth = 0;
         int set = e->Runions.more - 1;
         e->Runions.more = 0;
@@ -1871,14 +2062,28 @@ static jl_value_t *intersect_all(jl_value_t *x, jl_value_t *y, jl_stenv_t *e)
 
 // type intersection entry points
 
-JL_DLLEXPORT jl_value_t *jl_intersect_types(jl_value_t *x, jl_value_t *y)
+static jl_value_t *intersect_types(jl_value_t *x, jl_value_t *y, int emptiness_only)
 {
     jl_stenv_t e;
+    if (obviously_disjoint(x, y, 0))
+        return jl_bottom_type;
     init_stenv(&e, NULL, 0);
     e.intersection = 1;
+    e.emptiness_only = emptiness_only;
     return intersect_all(x, y, &e);
 }
 
+JL_DLLEXPORT jl_value_t *jl_intersect_types(jl_value_t *x, jl_value_t *y)
+{
+    return intersect_types(x, y, 0);
+}
+
+// TODO: this can probably be done more efficiently
+JL_DLLEXPORT int jl_has_empty_intersection(jl_value_t *x, jl_value_t *y)
+{
+    return intersect_types(x, y, 1) == jl_bottom_type;
+}
+
 // return a SimpleVector of all vars from UnionAlls wrapping a given type
 jl_svec_t *jl_outer_unionall_vars(jl_value_t *u)
 {
@@ -1899,12 +2104,16 @@ jl_svec_t *jl_outer_unionall_vars(jl_value_t *u)
 // sets *issubty to 1 iff `a` is a subtype of `b`
 jl_value_t *jl_type_intersection_env_s(jl_value_t *a, jl_value_t *b, jl_svec_t **penv, int *issubty)
 {
+    if (issubty) *issubty = 0;
+    if (obviously_disjoint(a, b, 0)) {
+        if (issubty && a == jl_bottom_type) *issubty = 1;
+        return jl_bottom_type;
+    }
     int szb = jl_subtype_env_size(b);
     int sz = 0, i = 0;
     jl_value_t **env, **ans;
     JL_GC_PUSHARGS(env, szb+1);
     ans = &env[szb]; *ans = jl_bottom_type;
-    if (issubty) *issubty = 0;
     if (jl_subtype_env(a, b, env, szb)) {
         *ans = a; sz = szb;
         if (issubty) *issubty = 1;
@@ -1933,18 +2142,9 @@ jl_value_t *jl_type_intersection_env_s(jl_value_t *a, jl_value_t *b, jl_svec_t *
         else {
             sz = szb;
             // TODO: compute better `env` directly during intersection.
-            // we assume that if the intersection is a concrete type, we have
-            // full information in `env`. however the intersection algorithm
-            // does not yet provide that in all cases so use subtype.
-            if (szb > 0 && jl_is_concrete_type(*ans) && !jl_types_equal(b, (jl_value_t*)jl_type_type)) {
-                if (jl_subtype_env(*ans, b, env, szb)) {
-                    for(i=0; i < sz; i++) {
-                        if (jl_is_typevar(env[i])) {
-                            *ans = jl_bottom_type; goto bot;
-                        }
-                    }
-                }
-                else {
+            // for now, we attempt to compute env by using subtype on the intersection result
+            if (szb > 0 && !jl_types_equal(b, (jl_value_t*)jl_type_type)) {
+                if (!jl_subtype_env(*ans, b, env, szb)) {
                     sz = 0;
                 }
             }
@@ -1990,67 +2190,11 @@ JL_DLLEXPORT jl_svec_t *jl_env_from_type_intersection(jl_value_t *a, jl_value_t
 
 // specificity comparison
 
-static jl_datatype_t *jl_fix_vararg_bound(jl_datatype_t *tt, int nfix)
-{
-    assert(jl_is_va_tuple(tt));
-    assert(nfix >= 0);
-    jl_svec_t *tp = tt->parameters;
-    size_t ntp = jl_svec_len(tp);
-    jl_value_t *env[2] = { jl_tparam1(jl_unwrap_unionall(jl_tparam(tt, ntp-1))), jl_box_long(nfix) };
-    JL_GC_PUSH2(&env[0], &env[1]);
-    jl_datatype_t *ret = (jl_datatype_t*)jl_instantiate_type_with((jl_value_t*)tt, env, 1);
-    JL_GC_POP();
-    return ret;
-}
-
-/*
-Simplification of varargs tuple types:
- JL_TUPLE_FIXED: tuples of known length (e.g., JL_VARARG_NONE or JL_VARARG_INT)
- JL_TUPLE_VAR:   tuples of unknown length (e.g., JL_VARARG_BOUND or JL_VARARG_UNBOUND)
-
-In some cases, JL_VARARG_BOUND tuples get described as JL_TUPLE_FIXED,
-if the constraints on length are already known.
-
-lenr = "representation length" (the number of parameters)
-lenf = "full length" (including the Vararg length, if known)
-
-In general, lenf >= lenr-1. The lower bound is achieved only for a Vararg of length 0.
-*/
-typedef enum {
-    JL_TUPLE_FIXED = 0,
-    JL_TUPLE_VAR   = 1
-} jl_tuple_lenkind_t;
-
-static size_t tuple_vararg_params(jl_svec_t *a, jl_vararg_kind_t *kind, jl_tuple_lenkind_t *lenkind)
-{
-    jl_value_t **data = jl_svec_data(a); size_t lenr = jl_svec_len(a);
-    size_t lenf = lenr;
-    if (lenr == 0) {
-        *kind = JL_VARARG_NONE;
-        *lenkind = JL_TUPLE_FIXED;
-        return lenf;
-    }
-    *lenkind = JL_TUPLE_VAR;
-    jl_value_t *last = data[lenr-1];
-    *kind = jl_vararg_kind(last);
-    if (*kind == JL_VARARG_NONE || *kind == JL_VARARG_INT)
-        *lenkind = JL_TUPLE_FIXED;
-    if (*kind == JL_VARARG_INT || *kind == JL_VARARG_BOUND) {
-        jl_value_t *N = jl_tparam1(jl_unwrap_unionall(last));
-        if (jl_is_long(N)) {
-            lenf += jl_unbox_long(N)-1;
-            *lenkind = JL_TUPLE_FIXED;
-        }
-    }
-    return lenf;
-}
-
 static int eq_msp(jl_value_t *a, jl_value_t *b, jl_typeenv_t *env)
 {
-    // equate ANY and Any for specificity purposes, #16153
-    if ((a == (jl_value_t*)jl_any_type && b == jl_ANY_flag) ||
-        (b == (jl_value_t*)jl_any_type && a == jl_ANY_flag))
-        return 1;
+    if (!(jl_is_type(a) || jl_is_typevar(a)) ||
+        !(jl_is_type(b) || jl_is_typevar(b)))
+        return jl_egal(a, b);
     JL_GC_PUSH2(&a, &b);
     jl_typeenv_t *e = env;
     while (e != NULL) {
@@ -2063,114 +2207,148 @@ static int eq_msp(jl_value_t *a, jl_value_t *b, jl_typeenv_t *env)
     return eq;
 }
 
+static int sub_msp(jl_value_t *a, jl_value_t *b, jl_typeenv_t *env)
+{
+    JL_GC_PUSH2(&a, &b);
+    while (env != NULL) {
+        a = jl_type_unionall(env->var, a);
+        b = jl_type_unionall(env->var, b);
+        env = env->prev;
+    }
+    int sub = jl_subtype(a, b);
+    JL_GC_POP();
+    return sub;
+}
+
 static int type_morespecific_(jl_value_t *a, jl_value_t *b, int invariant, jl_typeenv_t *env);
 
 static int num_occurs(jl_tvar_t *v, jl_typeenv_t *env);
 
+static jl_value_t *nth_tuple_elt(jl_datatype_t *t, size_t i)
+{
+    size_t len = jl_field_count(t);
+    if (len == 0)
+        return NULL;
+    if (i < len-1)
+        return jl_tparam(t, i);
+    jl_value_t *last = jl_unwrap_unionall(jl_tparam(t, len-1));
+    if (jl_is_vararg_type(last)) {
+        jl_value_t *n = jl_tparam1(last);
+        if (jl_is_long(n) && i >= len-1+jl_unbox_long(n))
+            return NULL;
+        return jl_tparam0(last);
+    }
+    if (i == len-1)
+        return jl_tparam(t, i);
+    return NULL;
+}
+
 static int tuple_morespecific(jl_datatype_t *cdt, jl_datatype_t *pdt, int invariant, jl_typeenv_t *env)
 {
-    size_t clenr = jl_nparams(cdt);
-    jl_value_t **child = jl_svec_data(cdt->parameters);
-    size_t plenr = jl_nparams(pdt);
-    jl_value_t **parent = jl_svec_data(pdt->parameters);
-    size_t plenf, clenf;
-    jl_vararg_kind_t ckind, pkind;
-    jl_tuple_lenkind_t clenkind, plenkind;
-    clenf = tuple_vararg_params(cdt->parameters, &ckind, &clenkind);
-    plenf = tuple_vararg_params(pdt->parameters, &pkind, &plenkind);
-    size_t ci=0, pi=0;
-    int cseq=0, pseq=0, cdiag=0, pdiag=0;
+    size_t plen = jl_nparams(pdt);
+    if (plen == 0) return 0;
+    size_t clen = jl_nparams(cdt);
+    if (clen == 0) return 1;
+    int i = 0;
+    int cva = jl_vararg_kind(jl_tparam(cdt,clen-1)) > JL_VARARG_INT;
+    int pva = jl_vararg_kind(jl_tparam(pdt,plen-1)) > JL_VARARG_INT;
+    int cdiag = 0, pdiag = 0;
     int some_morespecific = 0;
-    jl_value_t *ce=NULL, *pe=NULL;
     while (1) {
-        if (!cseq)
-            cseq = (ci<clenr) && clenkind != JL_TUPLE_FIXED && jl_is_vararg_type(child[ci]);
-        if (!pseq)
-            pseq = (pi<plenr) && plenkind != JL_TUPLE_FIXED && jl_is_vararg_type(parent[pi]);
-
-        if (ci >= clenf && !cseq) {
-            if (pseq && plenr <= clenr+1) return 1;
+        if (cva && pva && i >= clen && i >= plen)
             break;
+
+        jl_value_t *ce = nth_tuple_elt(cdt, i);
+        jl_value_t *pe = nth_tuple_elt(pdt, i);
+
+        if (ce == NULL) {
+            if (pe == NULL) break;
+            return 1;
         }
-        if (pi >= plenf && !pseq) {
-            if (!(cseq || clenf >= plenf)) return 0;
+        if (pe == NULL) {
+            if (!cva && !some_morespecific)
+                return 0;
             break;
         }
 
-        if (ci < clenr) {
-            ce = child[ci];
-            if (jl_is_vararg_type(ce)) ce = jl_unwrap_vararg(ce);
-        }
-        if (pi < plenr) {
-            pe = parent[pi];
-            if (jl_is_vararg_type(pe)) pe = jl_unwrap_vararg(pe);
+        if (type_morespecific_(pe, ce, invariant, env)) {
+            assert(!type_morespecific_(ce, pe, invariant, env));
+            return 0;
         }
 
-        int cms = type_morespecific_(ce, pe, invariant, env);
-        int pms = type_morespecific_(pe, ce, invariant, env);
-
-        if (!cms && pms) return 0;
-
         if (!cdiag && jl_is_typevar(ce) && num_occurs((jl_tvar_t*)ce,env) > 1)
             cdiag = 1;
         if (!pdiag && jl_is_typevar(pe) && num_occurs((jl_tvar_t*)pe,env) > 1)
             pdiag = 1;
 
         // in Tuple{a,b...} and Tuple{c,d...} allow b and d to be disjoint
-        if (cseq && pseq && (some_morespecific || (cdiag && !pdiag))) return 1;
-
-        int eqv = eq_msp(ce,pe,env);
+        if (cva && pva && i >= clen-1 && i >= plen-1 && (some_morespecific || (cdiag && !pdiag)))
+            return 1;
 
-        if (!cms && !eqv) return 0;
+        int cms = type_morespecific_(ce, pe, invariant, env);
+        int eqv = !cms && eq_msp(ce, pe, env);
 
-        if (cms && !pms)
-            some_morespecific = 1;
+        if (!cms && !eqv)
+            return 0;
 
-        if (cms && ci==clenr-1 && pi==plenr-1 && clenr == plenr && !cseq && pseq) {
-            // make Vararg{X, 1} more specific than Vararg{X, N}
-            if (jl_is_vararg_type(child[ci]) && eqv)
-                return 1;
-        }
+        // Tuple{..., T} not more specific than Tuple{..., Vararg{S}} if S is diagonal
+        if (eqv && i == clen-1 && clen == plen && !cva && pva && jl_is_typevar(ce) && jl_is_typevar(pe) && !cdiag && pdiag)
+            return 0;
 
-        if (cseq && pseq) {
-            if (clenr > plenr && (!pdiag || cdiag))
-                return 1;
-            break;
-        }
-        ci++;
-        pi++;
+        if (cms) some_morespecific = 1;
+        i++;
     }
+    if (cva && pva && clen > plen && (!pdiag || cdiag))
+        return 1;
+    if (cva && !pva && !some_morespecific)
+        return 0;
     return some_morespecific || (cdiag && !pdiag);
 }
 
+static size_t tuple_full_length(jl_value_t *t)
+{
+    size_t n = jl_nparams(t);
+    if (n == 0) return 0;
+    jl_value_t *last = jl_unwrap_unionall(jl_tparam(t,n-1));
+    if (jl_is_vararg_type(last)) {
+        jl_value_t *N = jl_tparam1(last);
+        if (jl_is_long(N))
+            n += jl_unbox_long(N)-1;
+    }
+    return n;
+}
+
 // Called when a is a bound-vararg and b is not a vararg. Sets the vararg length
 // in a to match b, as long as this makes some earlier argument more specific.
 static int args_morespecific_fix1(jl_value_t *a, jl_value_t *b, int swap, jl_typeenv_t *env)
 {
-    jl_datatype_t *tta = (jl_datatype_t*)a;
-    jl_datatype_t *ttb = (jl_datatype_t*)b;
-    size_t n = jl_nparams(tta);
-    jl_datatype_t *newtta = jl_fix_vararg_bound(tta, jl_nparams(ttb)-n+1);
+    size_t n = jl_nparams(a);
+    int taillen = tuple_full_length(b)-n+1;
+    if (taillen <= 0)
+        return -1;
+    assert(jl_is_va_tuple((jl_datatype_t*)a));
+    jl_datatype_t *new_a = NULL;
+    jl_value_t *e[2] = { jl_tparam1(jl_unwrap_unionall(jl_tparam(a, n-1))), jl_box_long(taillen) };
+    JL_GC_PUSH2(&new_a, &e[1]);
+    new_a = (jl_datatype_t*)jl_instantiate_type_with((jl_value_t*)a, e, 1);
     int changed = 0;
     for (size_t i = 0; i < n-1; i++) {
-        if (jl_tparam(tta, i) != jl_tparam(newtta, i)) {
+        if (jl_tparam(a, i) != jl_tparam(new_a, i)) {
             changed = 1;
             break;
         }
     }
+    int ret = -1;
     if (changed) {
-        JL_GC_PUSH1(&newtta);
-        int ret;
-        if (jl_types_equal(b, (jl_value_t*)newtta))
+        if (eq_msp(b, (jl_value_t*)new_a, env))
             ret = swap;
         else if (swap)
-            ret = type_morespecific_(b, (jl_value_t*)newtta, 0, env);
+            ret = type_morespecific_(b, (jl_value_t*)new_a, 0, env);
         else
-            ret = type_morespecific_((jl_value_t*)newtta, b, 0, env);
-        JL_GC_POP();
-        return ret;
+            ret = type_morespecific_((jl_value_t*)new_a, b, 0, env);
     }
-    return -1;
+    JL_GC_POP();
+    return ret;
 }
 
 static int partially_morespecific(jl_value_t *a, jl_value_t *b, int invariant, jl_typeenv_t *env)
@@ -2210,11 +2388,10 @@ static int count_occurs(jl_value_t *t, jl_tvar_t *v)
 
 static int num_occurs(jl_tvar_t *v, jl_typeenv_t *env)
 {
-    jl_typeenv_t *e = env;
-    while (e != NULL) {
-        if (e->var == v)
-            return (int)(ssize_t)e->val;
-        e = e->prev;
+    while (env != NULL) {
+        if (env->var == v)
+            return (int)(ssize_t)env->val;
+        env = env->prev;
     }
     return 0;
 }
@@ -2223,6 +2400,7 @@ static int type_morespecific_(jl_value_t *a, jl_value_t *b, int invariant, jl_ty
 {
     if (a == b)
         return 0;
+
     if (jl_is_unionall(a)) {
         jl_unionall_t *ua = (jl_unionall_t*)a;
         jl_typeenv_t newenv = { ua->var, 0x0, env };
@@ -2235,38 +2413,29 @@ static int type_morespecific_(jl_value_t *a, jl_value_t *b, int invariant, jl_ty
         newenv.val = (jl_value_t*)(intptr_t)count_occurs(ub->body, ub->var);
         return type_morespecific_(a, ub->body, invariant, &newenv);
     }
-    size_t i;
+
     if (jl_is_tuple_type(a) && jl_is_tuple_type(b)) {
-        jl_datatype_t *tta = (jl_datatype_t*)a;
-        jl_datatype_t *ttb = (jl_datatype_t*)b;
-        size_t alenf, blenf;
-        jl_vararg_kind_t akind, bkind;
-        jl_tuple_lenkind_t alenkind, blenkind;
-        alenf = tuple_vararg_params(tta->parameters, &akind, &alenkind);
-        blenf = tuple_vararg_params(ttb->parameters, &bkind, &blenkind);
         // When one is JL_VARARG_BOUND and the other has fixed length,
         // allow the argument length to fix the tvar
+        jl_vararg_kind_t akind = jl_va_tuple_kind((jl_datatype_t*)a);
+        jl_vararg_kind_t bkind = jl_va_tuple_kind((jl_datatype_t*)b);
         int ans = -1;
-        if (akind == JL_VARARG_BOUND && blenkind == JL_TUPLE_FIXED && blenf >= alenf)
+        if (akind == JL_VARARG_BOUND && bkind < JL_VARARG_BOUND)
             ans = args_morespecific_fix1(a, b, 0, env);
-        if (bkind == JL_VARARG_BOUND && alenkind == JL_TUPLE_FIXED && alenf >= blenf)
+        if (bkind == JL_VARARG_BOUND && akind < JL_VARARG_BOUND)
             ans = args_morespecific_fix1(b, a, 1, env);
-        if (ans != -1) return ans;
+        if (ans != -1)
+            return ans;
         return tuple_morespecific((jl_datatype_t*)a, (jl_datatype_t*)b, invariant, env);
     }
 
     if (jl_is_uniontype(a)) {
-        if (jl_subtype(b, a)) {
-            // fixes issue #4413
-            if (!jl_subtype(a, b))
-                return 0;
-        }
-        else if (jl_subtype(a, b)) {
+        if (sub_msp(b, a, env))
+            return 0;
+        else if (sub_msp(a, b, env))
             return 1;
-        }
-        // Union a is more specific than b if some element of a is
-        // more specific than b, and b is not more specific than any
-        // element of a.
+        // Union a is more specific than b if some element of a is more specific than b,
+        // and b is not more specific than any element of a.
         jl_uniontype_t *u = (jl_uniontype_t*)a;
         if (partially_morespecific(u->a, b, invariant, env) && !type_morespecific_(b, u->a, invariant, env)) {
             if (partially_morespecific(b, a, invariant, env))
@@ -2282,63 +2451,82 @@ static int type_morespecific_(jl_value_t *a, jl_value_t *b, int invariant, jl_ty
     }
 
     if (jl_is_type_type(a) && !invariant) {
+        if (b == (jl_value_t*)jl_typeofbottom_type)
+            return 0;
         jl_value_t *tp0a = jl_tparam0(a);
         if (jl_is_typevar(tp0a)) {
             jl_value_t *ub = ((jl_tvar_t*)tp0a)->ub;
-            if (jl_is_kind(b) && !jl_subtype((jl_value_t*)jl_any_type, ub))
+            if (jl_is_kind(b) && !sub_msp((jl_value_t*)jl_any_type, ub, env))
                 return 1;
         }
-        else {
-            if (jl_isa(tp0a, b))
+        else if (tp0a == jl_bottom_type) {
+            if (sub_msp(b, (jl_value_t*)jl_type_type, env))
                 return 1;
         }
+        else if (b == (jl_value_t*)jl_datatype_type || b == (jl_value_t*)jl_unionall_type ||
+                 b == (jl_value_t*)jl_uniontype_type) {
+            return 1;
+        }
     }
 
     if (jl_is_uniontype(b)) {
-        if (invariant)
-            return 0;
         jl_uniontype_t *u = (jl_uniontype_t*)b;
         if (type_morespecific_(a, u->a, invariant, env) || type_morespecific_(a, u->b, invariant, env))
-            return 1;
+            return !type_morespecific_(b, a, invariant, env);
         return 0;
     }
 
-    if (!invariant && (jl_datatype_t*)b == jl_any_type) return 1;
+    if (!invariant) {
+        if ((jl_datatype_t*)a == jl_any_type) return 0;
+        if ((jl_datatype_t*)b == jl_any_type) return 1;
+    }
 
     if (jl_is_datatype(a) && jl_is_datatype(b)) {
-        if ((jl_datatype_t*)a == jl_any_type) return 0;
-        jl_datatype_t *tta = (jl_datatype_t*)a;
-        jl_datatype_t *ttb = (jl_datatype_t*)b;
-        int super=0;
-        while (tta != (jl_datatype_t*)jl_any_type) {
+        jl_datatype_t *tta = (jl_datatype_t*)a, *ttb = (jl_datatype_t*)b;
+        int super = 0;
+        while (tta != jl_any_type) {
             if (tta->name == ttb->name) {
                 if (super) {
-                    if (tta->name != jl_type_typename)
-                        return 1;
-                }
-                if (super && ttb->name == jl_type_typename && jl_is_typevar(jl_tparam0(b))) {
-                    if (type_morespecific_(a, jl_tparam0(b), 1, env))
-                        return 1;
+                    if (tta->name != jl_type_typename) return 1;
+                    jl_value_t *tp0 = jl_tparam0(b);
+                    if (jl_is_typevar(tp0)) {
+                        if (sub_msp((jl_value_t*)jl_any_type, ((jl_tvar_t*)tp0)->ub, env))
+                            return 1;
+                    }
                 }
                 assert(jl_nparams(tta) == jl_nparams(ttb));
-                int ascore=0, bscore=0, ascore1=0, bscore1=0;
-                for(i=0; i < jl_nparams(tta); i++) {
+                int ascore=0, bscore=0, ascore1=0, bscore1=0, adiag=0, bdiag=0;
+                for(size_t i=0; i < jl_nparams(tta); i++) {
                     jl_value_t *apara = jl_tparam(tta,i);
                     jl_value_t *bpara = jl_tparam(ttb,i);
-                    int ams = type_morespecific_(apara, bpara, 1, env);
-                    ascore += ams;
-                    if (!ams)
-                        bscore += type_morespecific_(bpara, apara, 1, env);
+                    if (type_morespecific_(apara, bpara, 1, env))
+                        ascore += 1;
+                    else if (type_morespecific_(bpara, apara, 1, env))
+                        bscore += 1;
                     if (jl_is_typevar(bpara) && !jl_is_typevar(apara) && !jl_is_type(apara))
-                        ascore1 += 1;
-                    if (jl_is_typevar(apara) && !jl_is_typevar(bpara) && !jl_is_type(bpara))
-                        bscore1 += 1;
+                        ascore1 = 1;
+                    else if (jl_is_typevar(apara) && !jl_is_typevar(bpara) && !jl_is_type(bpara))
+                        bscore1 = 1;
+                    if (!adiag && jl_is_typevar(apara)) {
+                        for(int j=i+1; j < jl_nparams(tta); j++) {
+                            if (jl_has_typevar(jl_tparam(tta,j), (jl_tvar_t*)apara)) {
+                                adiag = 1; break;
+                            }
+                        }
+                    }
+                    if (!bdiag && jl_is_typevar(bpara)) {
+                        for(int j=i+1; j < jl_nparams(ttb); j++) {
+                            if (jl_has_typevar(jl_tparam(ttb,j), (jl_tvar_t*)bpara)) {
+                                bdiag = 1; break;
+                            }
+                        }
+                    }
                 }
-                if (bscore1 == 0 && ascore1 > 0)
+                if (ascore1 > bscore1)
                     return 1;
-                if (ascore1 == 0 && bscore1 > 0)
+                if (bscore1 > ascore1 || bscore > ascore || bdiag > adiag)
                     return 0;
-                return ascore > bscore;
+                return ascore > bscore || adiag > bdiag;
             }
             else if (invariant) {
                 return 0;
@@ -2357,30 +2545,25 @@ static int type_morespecific_(jl_value_t *a, jl_value_t *b, int invariant, jl_ty
                     ( type_morespecific_((jl_value_t*)((jl_tvar_t*)b)->lb,
                                          (jl_value_t*)((jl_tvar_t*)a)->lb, 0, env) &&
                      !type_morespecific_((jl_value_t*)((jl_tvar_t*)b)->ub,
-                                         (jl_value_t*)((jl_tvar_t*)a)->ub, 0, env))) &&
-                num_occurs((jl_tvar_t*)a, env) >= num_occurs((jl_tvar_t*)b, env);
+                                         (jl_value_t*)((jl_tvar_t*)a)->ub, 0, env)));
         }
         if (!jl_is_type(b))
             return 0;
         if (invariant) {
-            if (num_occurs((jl_tvar_t*)a, env) < 2)
-                return 0;
             if (eq_msp(((jl_tvar_t*)a)->ub, b, env))
-                return 1;
+                return num_occurs((jl_tvar_t*)a, env) >= 2;
+            return 0;
         }
         return type_morespecific_((jl_value_t*)((jl_tvar_t*)a)->ub, b, 0, env);
     }
     if (jl_is_typevar(b)) {
         if (!jl_is_type(a))
             return 1;
-        if (invariant)
-            return type_morespecific_(a, (jl_value_t*)((jl_tvar_t*)b)->ub, 0, env);
-        if (!(jl_subtype(a, (jl_value_t*)((jl_tvar_t*)b)->ub) &&
-              jl_subtype((jl_value_t*)((jl_tvar_t*)b)->lb, a)))
-            return 0;
-        if (eq_msp(a, b, env))
-            return 0;
-        return 1;
+        if (invariant) {
+            if (eq_msp(((jl_tvar_t*)b)->ub, a, env))
+                return num_occurs((jl_tvar_t*)b, env) < 2;
+        }
+        return type_morespecific_(a, (jl_value_t*)((jl_tvar_t*)b)->ub, 0, env);
     }
 
     return 0;
@@ -2388,11 +2571,18 @@ static int type_morespecific_(jl_value_t *a, jl_value_t *b, int invariant, jl_ty
 
 JL_DLLEXPORT int jl_type_morespecific(jl_value_t *a, jl_value_t *b)
 {
+    if (obviously_disjoint(a, b, 1))
+        return 0;
     if (jl_subtype(b, a)) return 0;
     if (jl_subtype(a, b)) return 1;
     return type_morespecific_(a, b, 0, NULL);
 }
 
+JL_DLLEXPORT int jl_type_morespecific_no_subtype(jl_value_t *a, jl_value_t *b)
+{
+    return type_morespecific_(a, b, 0, NULL);
+}
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/support/Makefile b/src/support/Makefile
index e6ba7b0cd9371f..b20c27540dfd0d 100644
--- a/src/support/Makefile
+++ b/src/support/Makefile
@@ -7,7 +7,7 @@ override CXXFLAGS += $(JCXXFLAGS)
 override CPPFLAGS += $(JCPPFLAGS)
 
 SRCS := hashing timefuncs ptrhash operators utf8 ios htable bitvector \
-	int2str libsupportinit arraylist strtod crc32c
+	int2str libsupportinit arraylist strtod
 ifeq ($(OS),WINNT)
 SRCS += asprintf wsasocketpair strptime
 ifeq ($(ARCH),i686)
diff --git a/src/support/MurmurHash3.c b/src/support/MurmurHash3.c
index cbdd6b35d4def2..a89ac1ee9af36d 100644
--- a/src/support/MurmurHash3.c
+++ b/src/support/MurmurHash3.c
@@ -129,8 +129,8 @@ void MurmurHash3_x86_32 ( const void * key, int len,
 
   switch(len & 3)
   {
-  case 3: k1 ^= tail[2] << 16;
-  case 2: k1 ^= tail[1] << 8;
+  case 3: k1 ^= tail[2] << 16; JL_FALLTHROUGH;
+  case 2: k1 ^= tail[1] << 8; JL_FALLTHROUGH;
   case 1: k1 ^= tail[0];
           k1 *= c1; k1 = ROTL32(k1,15); k1 *= c2; h1 ^= k1;
   };
@@ -204,26 +204,29 @@ void MurmurHash3_x86_128 ( const void * key, const int len,
 
   switch(len & 15)
   {
-  case 15: k4 ^= tail[14] << 16;
-  case 14: k4 ^= tail[13] << 8;
+  case 15: k4 ^= tail[14] << 16; JL_FALLTHROUGH;
+  case 14: k4 ^= tail[13] << 8; JL_FALLTHROUGH;
   case 13: k4 ^= tail[12] << 0;
            k4 *= c4; k4  = ROTL32(k4,18); k4 *= c1; h4 ^= k4;
+           JL_FALLTHROUGH;
 
-  case 12: k3 ^= tail[11] << 24;
-  case 11: k3 ^= tail[10] << 16;
-  case 10: k3 ^= tail[ 9] << 8;
+  case 12: k3 ^= tail[11] << 24; JL_FALLTHROUGH;
+  case 11: k3 ^= tail[10] << 16; JL_FALLTHROUGH;
+  case 10: k3 ^= tail[ 9] << 8; JL_FALLTHROUGH;
   case  9: k3 ^= tail[ 8] << 0;
            k3 *= c3; k3  = ROTL32(k3,17); k3 *= c4; h3 ^= k3;
+           JL_FALLTHROUGH;
 
-  case  8: k2 ^= tail[ 7] << 24;
-  case  7: k2 ^= tail[ 6] << 16;
-  case  6: k2 ^= tail[ 5] << 8;
+  case  8: k2 ^= tail[ 7] << 24; JL_FALLTHROUGH;
+  case  7: k2 ^= tail[ 6] << 16; JL_FALLTHROUGH;
+  case  6: k2 ^= tail[ 5] << 8; JL_FALLTHROUGH;
   case  5: k2 ^= tail[ 4] << 0;
            k2 *= c2; k2  = ROTL32(k2,16); k2 *= c3; h2 ^= k2;
+           JL_FALLTHROUGH;
 
-  case  4: k1 ^= tail[ 3] << 24;
-  case  3: k1 ^= tail[ 2] << 16;
-  case  2: k1 ^= tail[ 1] << 8;
+  case  4: k1 ^= tail[ 3] << 24; JL_FALLTHROUGH;
+  case  3: k1 ^= tail[ 2] << 16; JL_FALLTHROUGH;
+  case  2: k1 ^= tail[ 1] << 8; JL_FALLTHROUGH;
   case  1: k1 ^= tail[ 0] << 0;
            k1 *= c1; k1  = ROTL32(k1,15); k1 *= c2; h1 ^= k1;
   };
@@ -293,22 +296,23 @@ void MurmurHash3_x64_128 ( const void * key, const int len,
 
   switch(len & 15)
   {
-  case 15: k2 ^= ((uint64_t)(tail[14])) << 48;
-  case 14: k2 ^= ((uint64_t)(tail[13])) << 40;
-  case 13: k2 ^= ((uint64_t)(tail[12])) << 32;
-  case 12: k2 ^= ((uint64_t)(tail[11])) << 24;
-  case 11: k2 ^= ((uint64_t)(tail[10])) << 16;
-  case 10: k2 ^= ((uint64_t)(tail[ 9])) << 8;
+  case 15: k2 ^= ((uint64_t)(tail[14])) << 48; JL_FALLTHROUGH;
+  case 14: k2 ^= ((uint64_t)(tail[13])) << 40; JL_FALLTHROUGH;
+  case 13: k2 ^= ((uint64_t)(tail[12])) << 32; JL_FALLTHROUGH;
+  case 12: k2 ^= ((uint64_t)(tail[11])) << 24; JL_FALLTHROUGH;
+  case 11: k2 ^= ((uint64_t)(tail[10])) << 16; JL_FALLTHROUGH;
+  case 10: k2 ^= ((uint64_t)(tail[ 9])) << 8; JL_FALLTHROUGH;
   case  9: k2 ^= ((uint64_t)(tail[ 8])) << 0;
            k2 *= c2; k2  = ROTL64(k2,33); k2 *= c1; h2 ^= k2;
-
-  case  8: k1 ^= ((uint64_t)(tail[ 7])) << 56;
-  case  7: k1 ^= ((uint64_t)(tail[ 6])) << 48;
-  case  6: k1 ^= ((uint64_t)(tail[ 5])) << 40;
-  case  5: k1 ^= ((uint64_t)(tail[ 4])) << 32;
-  case  4: k1 ^= ((uint64_t)(tail[ 3])) << 24;
-  case  3: k1 ^= ((uint64_t)(tail[ 2])) << 16;
-  case  2: k1 ^= ((uint64_t)(tail[ 1])) << 8;
+           JL_FALLTHROUGH;
+
+  case  8: k1 ^= ((uint64_t)(tail[ 7])) << 56; JL_FALLTHROUGH;
+  case  7: k1 ^= ((uint64_t)(tail[ 6])) << 48; JL_FALLTHROUGH;
+  case  6: k1 ^= ((uint64_t)(tail[ 5])) << 40; JL_FALLTHROUGH;
+  case  5: k1 ^= ((uint64_t)(tail[ 4])) << 32; JL_FALLTHROUGH;
+  case  4: k1 ^= ((uint64_t)(tail[ 3])) << 24; JL_FALLTHROUGH;
+  case  3: k1 ^= ((uint64_t)(tail[ 2])) << 16; JL_FALLTHROUGH;
+  case  2: k1 ^= ((uint64_t)(tail[ 1])) << 8; JL_FALLTHROUGH;
   case  1: k1 ^= ((uint64_t)(tail[ 0])) << 0;
            k1 *= c1; k1  = ROTL64(k1,31); k1 *= c2; h1 ^= k1;
   };
diff --git a/src/support/MurmurHash3.h b/src/support/MurmurHash3.h
index 7f29e4d50c220e..e3e7da9df62fa2 100644
--- a/src/support/MurmurHash3.h
+++ b/src/support/MurmurHash3.h
@@ -2,8 +2,8 @@
 // MurmurHash3 was written by Austin Appleby, and is placed in the public
 // domain. The author hereby disclaims copyright to this source code.
 
-#ifndef MURMURHASH3_H
-#define MURMURHASH3_H
+#ifndef JL_MURMURHASH3_H
+#define JL_MURMURHASH3_H
 
 //-----------------------------------------------------------------------------
 // Platform-specific functions and macros
diff --git a/src/support/arraylist.c b/src/support/arraylist.c
index 7b7229a63bd36b..bb8bf77bd1af4c 100644
--- a/src/support/arraylist.c
+++ b/src/support/arraylist.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include <stdlib.h>
 #include <stdio.h>
diff --git a/src/support/arraylist.h b/src/support/arraylist.h
index 3440367e908490..3c4ed8a2ef21c7 100644
--- a/src/support/arraylist.h
+++ b/src/support/arraylist.h
@@ -1,7 +1,7 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
-#ifndef ARRAYLIST_H
-#define ARRAYLIST_H
+#ifndef JL_ARRAYLIST_H
+#define JL_ARRAYLIST_H
 
 #define AL_N_INLINE 29
 
diff --git a/src/support/bitvector.c b/src/support/bitvector.c
index de13c8e2857325..d72006cc1bfa5c 100644
--- a/src/support/bitvector.c
+++ b/src/support/bitvector.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 /*
   bit vector primitives
diff --git a/src/support/bitvector.h b/src/support/bitvector.h
index 10bbdfaea83f53..3ac38d820767c4 100644
--- a/src/support/bitvector.h
+++ b/src/support/bitvector.h
@@ -1,7 +1,7 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
-#ifndef BITVECTOR_H
-#define BITVECTOR_H
+#ifndef JL_BITVECTOR_H
+#define JL_BITVECTOR_H
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/src/support/crc32c.c b/src/support/crc32c.c
deleted file mode 100644
index 064c2c9d97f7eb..00000000000000
--- a/src/support/crc32c.c
+++ /dev/null
@@ -1,412 +0,0 @@
-/* crc32c.c -- compute CRC-32C using the Intel crc32 instruction
- * Copyright (C) 2013 Mark Adler
- * Version 1.1  1 Aug 2013  Mark Adler
- *
- * Code retrieved in August 2016 from August 2013 post by Mark Adler on
- *    http://stackoverflow.com/questions/17645167/implementing-sse-4-2s-crc32c-in-software
- * Modified for use in libjulia:
- *    - exported function renamed to jl_crc32c, DLL exports added.
- *    - removed main() function
- *    - changed initialization to a single jl_crc23_init(0) call.
- *    - protect sse code with #ifdef (correct architecture and compiler)
- *    - added header file
- *    - precompute crc32c tables and store in a generated .c file
- */
-
-/*
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the author be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-
-  Mark Adler
-  madler@alumni.caltech.edu
-*/
-
-/* Use hardware CRC instruction on Intel SSE 4.2 processors.  This computes a
-   CRC-32C, *not* the CRC-32 used by Ethernet and zip, gzip, etc.  A software
-   version is provided as a fall-back, as well as for speed comparisons. */
-
-/* Version history:
-   1.0  10 Feb 2013  First version
-   1.1   1 Aug 2013  Correct comments on why three crc instructions in parallel
-*/
-
-#include "crc32c.h"
-
-#if defined(_CPU_X86_64_) && !defined(_COMPILER_MICROSOFT_)
-#  define HW_CRC
-#endif
-
-/* CRC-32C (iSCSI) polynomial in reversed bit order. */
-#define POLY 0x82f63b78
-
-/* Block sizes for three-way parallel crc computation.  LONG and SHORT must
-   both be powers of two.  The associated string constants must be set
-   accordingly, for use in constructing the assembler instructions. */
-#define LONG 8192
-#define LONGx1 "8192"
-#define LONGx2 "16384"
-#define SHORT 256
-#define SHORTx1 "256"
-#define SHORTx2 "512"
-
-#ifndef GEN_CRC32C_TABLES
-#include "crc32c-tables.c"
-
-/* Table-driven software version as a fall-back.  This is about 15 times slower
-   than using the hardware instructions.  This computes a little-endian
-   CRC32c, equivalent to the little-endian CRC of the Intel instructions,
-   regardless of the endianness of the machine this is running on.  */
-static uint32_t crc32c_sw(uint32_t crci, const void *buf, size_t len)
-{
-    const unsigned char *next = (const unsigned char *) buf;
-    uint64_t crc;
-
-    /* pthread_once(&crc32c_once_sw, crc32c_init_sw); */
-    crc = crci ^ 0xffffffff;
-    while (len && ((uintptr_t)next & 7) != 0) {
-        crc = crc32c_table[0][(crc ^ *next++) & 0xff] ^ (crc >> 8);
-        len--;
-    }
-    while (len >= 8) {
-        crc ^= *(uint64_t *)next;
-                crc = crc32c_table[7][crc & 0xff] ^
-                    crc32c_table[6][(crc >> 8) & 0xff] ^
-                    crc32c_table[5][(crc >> 16) & 0xff] ^
-                    crc32c_table[4][(crc >> 24) & 0xff] ^
-                    crc32c_table[3][(crc >> 32) & 0xff] ^
-                    crc32c_table[2][(crc >> 40) & 0xff] ^
-                    crc32c_table[1][(crc >> 48) & 0xff] ^
-                    crc32c_table[0][crc >> 56];
-                next += 8;
-                len -= 8;
-    }
-    while (len) {
-        crc = crc32c_table[0][(crc ^ *next++) & 0xff] ^ (crc >> 8);
-        len--;
-    }
-    return (uint32_t)crc ^ 0xffffffff;
-}
-
-#ifdef HW_CRC
-
-/* Apply the zeros operator table to crc. */
-static inline uint32_t crc32c_shift(const uint32_t zeros[][256], uint32_t crc)
-{
-    return zeros[0][crc & 0xff] ^ zeros[1][(crc >> 8) & 0xff] ^
-        zeros[2][(crc >> 16) & 0xff] ^ zeros[3][crc >> 24];
-}
-
-/* Compute CRC-32C using the Intel hardware instruction. */
-static uint32_t crc32c_hw(uint32_t crc, const void *buf, size_t len)
-{
-    const unsigned char *next = (const unsigned char *) buf;
-    const unsigned char *end;
-    uint64_t crc0, crc1, crc2;      /* need to be 64 bits for crc32q */
-
-    /* populate shift tables the first time through */
-    /* pthread_once(&crc32c_once_hw, crc32c_init_hw); */
-
-    /* pre-process the crc */
-    crc0 = crc ^ 0xffffffff;
-
-    /* compute the crc for up to seven leading bytes to bring the data pointer
-       to an eight-byte boundary */
-    while (len && ((uintptr_t)next & 7) != 0) {
-        __asm__("crc32b\t" "(%1), %0"
-                : "=r"(crc0)
-                : "r"(next), "0"(crc0));
-        next++;
-        len--;
-    }
-
-    /* compute the crc on sets of LONG*3 bytes, executing three independent crc
-       instructions, each on LONG bytes -- this is optimized for the Nehalem,
-       Westmere, Sandy Bridge, and Ivy Bridge architectures, which have a
-       throughput of one crc per cycle, but a latency of three cycles */
-    while (len >= LONG*3) {
-        crc1 = 0;
-        crc2 = 0;
-        end = next + LONG;
-        do {
-            __asm__("crc32q\t" "(%3), %0\n\t"
-                                        "crc32q\t" LONGx1 "(%3), %1\n\t"
-                                        "crc32q\t" LONGx2 "(%3), %2"
-                    : "=r"(crc0), "=r"(crc1), "=r"(crc2)
-                    : "r"(next), "0"(crc0), "1"(crc1), "2"(crc2));
-            next += 8;
-        } while (next < end);
-        crc0 = crc32c_shift(crc32c_long, crc0) ^ crc1;
-        crc0 = crc32c_shift(crc32c_long, crc0) ^ crc2;
-        next += LONG*2;
-        len -= LONG*3;
-    }
-
-    /* do the same thing, but now on SHORT*3 blocks for the remaining data less
-       than a LONG*3 block */
-    while (len >= SHORT*3) {
-        crc1 = 0;
-        crc2 = 0;
-        end = next + SHORT;
-        do {
-            __asm__("crc32q\t" "(%3), %0\n\t"
-                                        "crc32q\t" SHORTx1 "(%3), %1\n\t"
-                                        "crc32q\t" SHORTx2 "(%3), %2"
-                    : "=r"(crc0), "=r"(crc1), "=r"(crc2)
-                    : "r"(next), "0"(crc0), "1"(crc1), "2"(crc2));
-            next += 8;
-        } while (next < end);
-        crc0 = crc32c_shift(crc32c_short, crc0) ^ crc1;
-        crc0 = crc32c_shift(crc32c_short, crc0) ^ crc2;
-        next += SHORT*2;
-        len -= SHORT*3;
-    }
-
-    /* compute the crc on the remaining eight-byte units less than a SHORT*3
-       block */
-    end = next + (len - (len & 7));
-    while (next < end) {
-        __asm__("crc32q\t" "(%1), %0"
-                : "=r"(crc0)
-                : "r"(next), "0"(crc0));
-        next += 8;
-    }
-    len &= 7;
-
-    /* compute the crc for up to seven trailing bytes */
-    while (len) {
-        __asm__("crc32b\t" "(%1), %0"
-                : "=r"(crc0)
-                : "r"(next), "0"(crc0));
-        next++;
-        len--;
-    }
-
-    /* return a post-processed crc */
-    return (uint32_t)crc0 ^ 0xffffffff;
-}
-
-/* Check for SSE 4.2.  SSE 4.2 was first supported in Nehalem processors
-   introduced in November, 2008.  This does not check for the existence of the
-   cpuid instruction itself, which was introduced on the 486SL in 1992, so this
-   will fail on earlier x86 processors.  cpuid works on all Pentium and later
-   processors. */
-#define SSE42(have) \
-    do { \
-        uint32_t eax, ecx; \
-        eax = 1; \
-        __asm__("cpuid" \
-                : "=c"(ecx) \
-                : "a"(eax) \
-                : "%ebx", "%edx"); \
-        (have) = (ecx >> 20) & 1; \
-    } while (0)
-
-static int sse42 = 0;
-
-#endif /* ifdef HW_CRC */
-
-/* jl_crc32c_init must be called before jl_crc32c.  Passing 1
-   can be used to force the use of the software implementation,
-   which is useful for testing purposes. */
-JL_DLLEXPORT void jl_crc32c_init(int force_sw)
-{
-#ifdef HW_CRC
-    if (force_sw)
-        sse42 = 0; /* useful for testing purposes */
-    else
-        SSE42(sse42);
-#endif
-}
-
-/* Compute a CRC-32C.  If the crc32 instruction is available, use the hardware
-   version.  Otherwise, use the software version. */
-JL_DLLEXPORT uint32_t jl_crc32c(uint32_t crc, const void *buf, size_t len)
-{
-    return
-#ifdef HW_CRC
-    sse42 ? crc32c_hw(crc, buf, len) :
-#endif
-    crc32c_sw(crc, buf, len);
-}
-
-/*****************************************************************************/
-/*****************************************************************************/
-/*****************************************************************************/
-
-/* Compile with -DGEN_CRC32C_TABLES to generate header file containing
-   precomputed hardware and software tables */
-
-#else /* ifdef GEN_CRC32C_TABLES */
-
-/* Table for a quadword-at-a-time software crc. */
-static uint32_t crc32c_table[8][256];
-
-/* Construct table for software CRC-32C calculation. */
-static void crc32c_init_sw(void)
-{
-    uint32_t n, crc, k;
-
-    for (n = 0; n < 256; n++) {
-        crc = n;
-        crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
-        crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
-        crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
-        crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
-        crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
-        crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
-        crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
-        crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
-        crc32c_table[0][n] = crc;
-    }
-    for (n = 0; n < 256; n++) {
-        crc = crc32c_table[0][n];
-        for (k = 1; k < 8; k++) {
-            crc = crc32c_table[0][crc & 0xff] ^ (crc >> 8);
-            crc32c_table[k][n] = crc;
-        }
-    }
-}
-
-/* Tables for hardware crc that shift a crc by LONG and SHORT zeros. */
-static uint32_t crc32c_long[4][256];
-static uint32_t crc32c_short[4][256];
-
-/* Multiply a matrix times a vector over the Galois field of two elements,
-   GF(2).  Each element is a bit in an unsigned integer.  mat must have at
-   least as many entries as the power of two for most significant one bit in
-   vec. */
-static inline uint32_t gf2_matrix_times(uint32_t *mat, uint32_t vec)
-{
-    uint32_t sum;
-
-    sum = 0;
-    while (vec) {
-        if (vec & 1)
-            sum ^= *mat;
-        vec >>= 1;
-        mat++;
-    }
-    return sum;
-}
-
-/* Multiply a matrix by itself over GF(2).  Both mat and square must have 32
-   rows. */
-static inline void gf2_matrix_square(uint32_t *square, uint32_t *mat)
-{
-    int n;
-
-    for (n = 0; n < 32; n++)
-        square[n] = gf2_matrix_times(mat, mat[n]);
-}
-
-/* Construct an operator to apply len zeros to a crc.  len must be a power of
-   two.  If len is not a power of two, then the result is the same as for the
-   largest power of two less than len.  The result for len == 0 is the same as
-   for len == 1.  A version of this routine could be easily written for any
-   len, but that is not needed for this application. */
-static void crc32c_zeros_op(uint32_t *even, size_t len)
-{
-    int n;
-    uint32_t row;
-    uint32_t odd[32];       /* odd-power-of-two zeros operator */
-
-    /* put operator for one zero bit in odd */
-    odd[0] = POLY;              /* CRC-32C polynomial */
-    row = 1;
-    for (n = 1; n < 32; n++) {
-        odd[n] = row;
-        row <<= 1;
-    }
-
-    /* put operator for two zero bits in even */
-    gf2_matrix_square(even, odd);
-
-    /* put operator for four zero bits in odd */
-    gf2_matrix_square(odd, even);
-
-    /* first square will put the operator for one zero byte (eight zero bits),
-       in even -- next square puts operator for two zero bytes in odd, and so
-       on, until len has been rotated down to zero */
-    do {
-        gf2_matrix_square(even, odd);
-        len >>= 1;
-        if (len == 0)
-            return;
-        gf2_matrix_square(odd, even);
-        len >>= 1;
-    } while (len);
-
-    /* answer ended up in odd -- copy to even */
-    for (n = 0; n < 32; n++)
-        even[n] = odd[n];
-}
-
-/* Take a length and build four lookup tables for applying the zeros operator
-   for that length, byte-by-byte on the operand. */
-static void crc32c_zeros(uint32_t zeros[][256], size_t len)
-{
-    uint32_t n;
-    uint32_t op[32];
-
-    crc32c_zeros_op(op, len);
-    for (n = 0; n < 256; n++) {
-        zeros[0][n] = gf2_matrix_times(op, n);
-        zeros[1][n] = gf2_matrix_times(op, n << 8);
-        zeros[2][n] = gf2_matrix_times(op, n << 16);
-        zeros[3][n] = gf2_matrix_times(op, n << 24);
-    }
-}
-
-/* Initialize tables for shifting crcs. */
-static void crc32c_init_hw(void)
-{
-    crc32c_zeros(crc32c_long, LONG);
-    crc32c_zeros(crc32c_short, SHORT);
-}
-
-#include <stdio.h>
-
-static void print_array(const char *name, int m, int n, const uint32_t *a)
-{
-    int i, j;
-    printf("static const uint32_t %s[%d][%d] = {\n", name, m, n);
-    for (i = 0; i < m; ++i) {
-        printf("    { %u", a[i*n+0]);
-        for (j = 1; j < n; ++j) printf(",%u", a[i*n+j]);
-        printf(" }%s", i == m-1 ? "\n" : ",\n");
-    }
-    printf("};\n");
-}
-
-int main(void)
-{
-    printf("/* Pregenerated tables for crc32c.c, produced by compiling with -DGEN_CRC32C_TABLES. */\n"
-           "#if POLY != 0x%x\n#  error \"tables generated for different polynomial\"\n#endif\n\n", POLY);
-    crc32c_init_sw();
-    print_array("crc32c_table", 8, 256, &crc32c_table[0][0]);
-    crc32c_init_hw();
-    printf("\n#ifdef HW_CRC\n");
-    print_array("crc32c_long", 4, 256, &crc32c_long[0][0]);
-    print_array("crc32c_short", 4, 256, &crc32c_short[0][0]);
-    printf("#endif /* HW_CRC */\n");
-    return 0;
-}
-
-#endif /* GEN_CRC32C_TABLES */
-
-/*****************************************************************************/
-/*****************************************************************************/
-/*****************************************************************************/
diff --git a/src/support/crc32c.h b/src/support/crc32c.h
deleted file mode 100644
index fbec8256168e4c..00000000000000
--- a/src/support/crc32c.h
+++ /dev/null
@@ -1,17 +0,0 @@
-#ifndef CRC32C_H
-#define CRC32C_H 1
-
-#include "dtypes.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-JL_DLLEXPORT void jl_crc32c_init(int force_sw);
-JL_DLLEXPORT uint32_t jl_crc32c(uint32_t crc, const void *buf, size_t len);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* CRC32C_H */
diff --git a/src/support/dirpath.h b/src/support/dirpath.h
index 782bf8adf9a1b5..0657cc26de0b1b 100644
--- a/src/support/dirpath.h
+++ b/src/support/dirpath.h
@@ -1,7 +1,7 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
-#ifndef DIRPATH_H
-#define DIRPATH_H
+#ifndef JL_DIRPATH_H
+#define JL_DIRPATH_H
 
 #ifdef _OS_WINDOWS_
 #define PATHSEPSTRING "\\"
diff --git a/src/support/dtypes.h b/src/support/dtypes.h
index 56b5ddfb93612b..ae1224d69dad95 100644
--- a/src/support/dtypes.h
+++ b/src/support/dtypes.h
@@ -1,7 +1,7 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
-#ifndef DTYPES_H
-#define DTYPES_H
+#ifndef JL_DTYPES_H
+#define JL_DTYPES_H
 
 #include <stddef.h>
 #include <stddef.h> // double include of stddef.h fixes #3421
@@ -166,9 +166,11 @@ STATIC_INLINE unsigned int next_power_of_two(unsigned int val)
 #ifdef __GNUC__
 #define __unlikely(x) __builtin_expect(!!(x), 0)
 #define __likely(x)   __builtin_expect(!!(x), 1)
+#define JL_EXTENSION __extension__
 #else
 #define __unlikely(x) (x)
 #define __likely(x)   (x)
+#define JL_EXTENSION
 #endif
 
 #define DBL_MAXINT 9007199254740992LL
@@ -204,4 +206,20 @@ typedef enum { T_INT8, T_UINT8, T_INT16, T_UINT16, T_INT32, T_UINT32,
 # define T_SIZE T_UINT32
 #endif
 
+#if defined(__GNUC__) && __GNUC__ >= 7
+#define JL_FALLTHROUGH __attribute__((fallthrough))
+#elif defined(__cplusplus) && defined(__clang_major__) && \
+    defined(__clang_minor__) && (__clang_major__ > 4 || __clang_minor__ >= 5)
+// We require at least clang 3.x
+#define JL_FALLTHROUGH [[clang::fallthrough]]
+#else
+#define JL_FALLTHROUGH
+#endif
+
+#if defined(__GNUC__)
+#define JL_UNUSED __attribute__((__unused__))
+#else
+#define JL_UNUSED
+#endif
+
 #endif /* DTYPES_H */
diff --git a/src/support/hashing.c b/src/support/hashing.c
index da76f3a7938677..632eb2ae12c193 100644
--- a/src/support/hashing.c
+++ b/src/support/hashing.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 /*
   Hashing
diff --git a/src/support/hashing.h b/src/support/hashing.h
index 5f9b41d6f700d3..7fcbf4a323e842 100644
--- a/src/support/hashing.h
+++ b/src/support/hashing.h
@@ -1,7 +1,7 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
-#ifndef HASHING_H
-#define HASHING_H
+#ifndef JL_HASHING_H
+#define JL_HASHING_H
 
 #include "utils.h"
 #include "dtypes.h"
diff --git a/src/support/htable.c b/src/support/htable.c
index 3e1c9022ca6c7d..b5ae094e448dd0 100644
--- a/src/support/htable.c
+++ b/src/support/htable.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 /*
   functions common to all hash table instantiations
diff --git a/src/support/htable.h b/src/support/htable.h
index eb5bfd259a6845..2b79eef12dc867 100644
--- a/src/support/htable.h
+++ b/src/support/htable.h
@@ -1,7 +1,7 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
-#ifndef HTABLE_H
-#define HTABLE_H
+#ifndef JL_HTABLE_H
+#define JL_HTABLE_H
 
 #define HT_N_INLINE 32
 
diff --git a/src/support/htable.inc b/src/support/htable.inc
index 3e504672162df6..12be2b99b0c3d6 100644
--- a/src/support/htable.inc
+++ b/src/support/htable.inc
@@ -189,7 +189,7 @@ int HTNAME##_remove(htable_t *h, void *key)                             \
                                                                         \
 void HTNAME##_adjoin(htable_t *h, void *key, void *val)                 \
 {                                                                       \
-    return HTNAME##_adjoin_r(h, key, val, NULL);                        \
+    HTNAME##_adjoin_r(h, key, val, NULL);                               \
 }
 
 #define HTIMPL_R(HTNAME, HFUNC, EQFUNC) _HTIMPL_EX(HTNAME, HFUNC, EQFUNC, )
diff --git a/src/support/int2str.c b/src/support/int2str.c
index 0c74546af18afe..13152ee36ccf23 100644
--- a/src/support/int2str.c
+++ b/src/support/int2str.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include <stdlib.h>
 #include "dtypes.h"
diff --git a/src/support/ios.c b/src/support/ios.c
index 32cba8fceb6188..719f3fa0a307f8 100644
--- a/src/support/ios.c
+++ b/src/support/ios.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include <stdlib.h>
 #include <stdarg.h>
@@ -426,6 +426,7 @@ size_t ios_write(ios_t *s, const char *data, size_t n)
     else {
         ios_flush(s);
         if (n > MOST_OF(s->maxsize)) {
+            s->fpos = -1;
             _os_write_all(s->fd, data, n, &wrote);
             return wrote;
         }
@@ -873,19 +874,30 @@ static void _ios_init(ios_t *s)
 /* stream object initializers. we do no allocation. */
 
 #if !defined(_OS_WINDOWS_)
+/*
+ * NOTE: we do not handle system call restart in this function,
+ * please do it manually:
+ *
+ *  do
+ *      open_cloexec(...)
+ *  while (-1 == fd && _enonfatal(errno))
+ */
 static int open_cloexec(const char *path, int flags, mode_t mode)
 {
 #ifdef O_CLOEXEC
-    static int no_cloexec=0;
+    static int no_cloexec = 0;
 
     if (!no_cloexec) {
         set_io_wait_begin(1);
         int fd = open(path, flags | O_CLOEXEC, mode);
         set_io_wait_begin(0);
+
         if (fd != -1)
             return fd;
         if (errno != EINVAL)
             return -1;
+
+        /* O_CLOEXEC not supported. */
         no_cloexec = 1;
     }
 #endif
@@ -917,12 +929,15 @@ ios_t *ios_file(ios_t *s, const char *fname, int rd, int wr, int create, int tru
 #else
     // The mode of the created file is (mode & ~umask), which resolves with
     // default umask to u=rw,g=r,o=r
-    fd = open_cloexec(fname, flags,
-                      S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
+    do
+        fd = open_cloexec(fname, flags,
+                          S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
+    while (-1 == fd && _enonfatal(errno));
 #endif
-    s = ios_fd(s, fd, 1, 1);
     if (fd == -1)
         goto open_file_err;
+
+    s = ios_fd(s, fd, 1, 1);
     if (!rd)
         s->readable = 0;
     if (!wr)
diff --git a/src/support/ios.h b/src/support/ios.h
index 02480237a33891..55edd3d8213b7a 100644
--- a/src/support/ios.h
+++ b/src/support/ios.h
@@ -1,7 +1,7 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
-#ifndef IOS_H
-#define IOS_H
+#ifndef JL_IOS_H
+#define JL_IOS_H
 
 #include <stdarg.h>
 #include "uv.h"
diff --git a/src/support/libsupport.h b/src/support/libsupport.h
index 0e8071740f36da..f5267baf28e86b 100644
--- a/src/support/libsupport.h
+++ b/src/support/libsupport.h
@@ -1,7 +1,7 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
-#ifndef LIBSUPPORT_H
-#define LIBSUPPORT_H
+#ifndef JL_LIBSUPPORT_H
+#define JL_LIBSUPPORT_H
 
 #include "platform.h"
 
@@ -18,7 +18,6 @@
 #include "bitvector.h"
 #include "dirpath.h"
 #include "strtod.h"
-#include "crc32c.h"
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/src/support/libsupportinit.c b/src/support/libsupportinit.c
index 78add620116c54..fe14d52711f665 100644
--- a/src/support/libsupportinit.c
+++ b/src/support/libsupportinit.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include <locale.h>
 #include "libsupport.h"
@@ -20,8 +20,6 @@ void libsupport_init(void)
 
         ios_init_stdstreams();
 
-        jl_crc32c_init(0);
-
         isInitialized=1;
     }
 }
diff --git a/src/support/operators.c b/src/support/operators.c
index 161fd987f96b87..d1099e5d1d6ff6 100644
--- a/src/support/operators.c
+++ b/src/support/operators.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include <limits.h>
 #include <assert.h>
diff --git a/src/support/platform.h b/src/support/platform.h
index c0e95343c855dd..e28fdb1cf832a4 100644
--- a/src/support/platform.h
+++ b/src/support/platform.h
@@ -1,7 +1,7 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
-#ifndef PLATFORM_H
-#define PLATFORM_H
+#ifndef JL_PLATFORM_H
+#define JL_PLATFORM_H
 
 /*
  * This file provides convenient macros to be used to identify the platform
diff --git a/src/support/ptrhash.c b/src/support/ptrhash.c
index c61f2dd6c16513..b32ed8afe42f87 100644
--- a/src/support/ptrhash.c
+++ b/src/support/ptrhash.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 /*
   pointer hash table
diff --git a/src/support/ptrhash.h b/src/support/ptrhash.h
index 6929d02d7d615d..2026dd32a647e6 100644
--- a/src/support/ptrhash.h
+++ b/src/support/ptrhash.h
@@ -1,7 +1,7 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
-#ifndef PTRHASH_H
-#define PTRHASH_H
+#ifndef JL_PTRHASH_H
+#define JL_PTRHASH_H
 
 #include "htable.h"
 
diff --git a/src/support/strtod.c b/src/support/strtod.c
index 1dc2b961576ca0..fe617da2490d26 100644
--- a/src/support/strtod.c
+++ b/src/support/strtod.c
@@ -20,22 +20,21 @@ static locale_t c_locale;
 
 locale_t get_c_locale(void)
 {
-  if(!c_locale_initialized)
-  {
-    c_locale_initialized = 1;
-    c_locale = newlocale(LC_ALL_MASK, "C", NULL);
-  }
-  return c_locale;
+    if (!c_locale_initialized) {
+        c_locale_initialized = 1;
+        c_locale = newlocale(LC_ALL_MASK, "C", NULL);
+    }
+    return c_locale;
 }
 
 JL_DLLEXPORT double jl_strtod_c(const char *nptr, char **endptr)
 {
-  return strtod_l(nptr, endptr, get_c_locale());
+    return strtod_l(nptr, endptr, get_c_locale());
 }
 
 JL_DLLEXPORT float jl_strtof_c(const char *nptr, char **endptr)
 {
-  return strtof_l(nptr, endptr, get_c_locale());
+    return strtof_l(nptr, endptr, get_c_locale());
 }
 
 
@@ -58,7 +57,7 @@ JL_DLLEXPORT float jl_strtof_c(const char *nptr, char **endptr)
 
 int case_insensitive_match(const char *s, const char *t)
 {
-    while(*t && tolower(*s) == *t) {
+    while (*t && tolower(*s) == *t) {
         s++;
         t++;
     }
@@ -147,84 +146,75 @@ JL_DLLEXPORT double jl_strtod_c(const char *nptr, char **endptr)
     }
 
     /* This code path is used for hex floats */
-    if (*p == '0' && (*(p+1) == 'x' || *(p+1) == 'X'))
-    {
-      digits_pos = p;
-      p += 2;
-      /* Check that what's left begins with a digit or decimal point */
-      if (!isxdigit(*p) && *p != '.')
-          goto invalid_string;
-
-
-      if (decimal_point[0] != '.' ||
-          decimal_point[1] != 0)
-      {
-          /* Look for a '.' in the input; if present, it'll need to be
-             swapped for the current locale's decimal point before we
-             call strtod.  On the other hand, if we find the current
-             locale's decimal point then the input is invalid. */
-          while (isxdigit(*p))
-              p++;
-
-          if (*p == '.')
-          {
-              decimal_point_pos = p++;
-
-              /* locate end of number */
-              while (isxdigit(*p))
-                  p++;
-
-              if (*p == 'p' || *p == 'P')
-                  p++;
-              if (*p == '+' || *p == '-')
-                  p++;
-              while (isdigit(*p))
-                  p++;
-              end = p;
-          }
-          else if (strncmp(p, decimal_point, decimal_point_len) == 0)
-              goto invalid_string;
-          /* For the other cases, we need not convert the decimal
-             point */
-      }
-    } else
-    {
-      /* Check that what's left begins with a digit or decimal point */
-      if (!isdigit(*p) && *p != '.')
-          goto invalid_string;
-
-      digits_pos = p;
-      if (decimal_point[0] != '.' ||
-          decimal_point[1] != 0)
-      {
-          /* Look for a '.' in the input; if present, it'll need to be
-             swapped for the current locale's decimal point before we
-             call strtod.  On the other hand, if we find the current
-             locale's decimal point then the input is invalid. */
-          while (isdigit(*p))
-              p++;
-
-          if (*p == '.')
-          {
-              decimal_point_pos = p++;
-
-              /* locate end of number */
-              while (isdigit(*p))
-                  p++;
-
-              if (*p == 'e' || *p == 'E')
-                  p++;
-              if (*p == '+' || *p == '-')
-                  p++;
-              while (isdigit(*p))
-                  p++;
-              end = p;
-          }
-          else if (strncmp(p, decimal_point, decimal_point_len) == 0)
+    if (*p == '0' && (*(p+1) == 'x' || *(p+1) == 'X')) {
+        digits_pos = p;
+        p += 2;
+        /* Check that what's left begins with a digit or decimal point */
+        if (!isxdigit(*p) && *p != '.')
+            goto invalid_string;
+
+
+        if (decimal_point[0] != '.' || decimal_point[1] != 0) {
+            /* Look for a '.' in the input; if present, it'll need to be
+               swapped for the current locale's decimal point before we
+               call strtod.  On the other hand, if we find the current
+               locale's decimal point then the input is invalid. */
+            while (isxdigit(*p))
+                p++;
+
+            if (*p == '.') {
+                decimal_point_pos = p++;
+
+                /* locate end of number */
+                while (isxdigit(*p))
+                    p++;
+
+                if (*p == 'p' || *p == 'P')
+                    p++;
+                if (*p == '+' || *p == '-')
+                    p++;
+                while (isdigit(*p))
+                    p++;
+                end = p;
+            }
+            else if (strncmp(p, decimal_point, decimal_point_len) == 0)
+                goto invalid_string;
+            /* For the other cases, we need not convert the decimal point */
+        }
+    }
+    else {
+        /* Check that what's left begins with a digit or decimal point */
+        if (!isdigit(*p) && *p != '.')
             goto invalid_string;
-          /* For the other cases, we need not convert the decimal
-             point */
-      }
+
+        digits_pos = p;
+        if (decimal_point[0] != '.' || decimal_point[1] != 0) {
+            /* Look for a '.' in the input; if present, it'll need to be
+               swapped for the current locale's decimal point before we
+               call strtod.  On the other hand, if we find the current
+               locale's decimal point then the input is invalid. */
+            while (isdigit(*p))
+                p++;
+
+            if (*p == '.') {
+                decimal_point_pos = p++;
+
+                /* locate end of number */
+                while (isdigit(*p))
+                    p++;
+
+                if (*p == 'e' || *p == 'E')
+                    p++;
+                if (*p == '+' || *p == '-')
+                    p++;
+                while (isdigit(*p))
+                    p++;
+                end = p;
+            }
+            else if (strncmp(p, decimal_point, decimal_point_len) == 0)
+                goto invalid_string;
+            /* For the other cases, we need not convert the decimal point */
+        }
     }
 
     if (decimal_point_pos) {
@@ -263,7 +253,6 @@ JL_DLLEXPORT double jl_strtod_c(const char *nptr, char **endptr)
         }
 
         free(copy);
-
     }
     else {
         val = strtod(digits_pos, &fail_pos);
@@ -278,7 +267,7 @@ JL_DLLEXPORT double jl_strtod_c(const char *nptr, char **endptr)
 
     return val;
 
-  invalid_string:
+invalid_string:
     *endptr = (char*)nptr;
     errno = EINVAL;
     return -1.0;
@@ -287,7 +276,7 @@ JL_DLLEXPORT double jl_strtod_c(const char *nptr, char **endptr)
 
 JL_DLLEXPORT float jl_strtof_c(const char *nptr, char **endptr)
 {
-  return (float) jl_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 a63d22447f5377..7234f0acf89ed2 100644
--- a/src/support/strtod.h
+++ b/src/support/strtod.h
@@ -1,7 +1,7 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
-#ifndef STRTOD_H
-#define STRTOD_H
+#ifndef JL_STRTOD_H
+#define JL_STRTOD_H
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/src/support/timefuncs.c b/src/support/timefuncs.c
index 4548577de719f6..031967638ec9e9 100644
--- a/src/support/timefuncs.c
+++ b/src/support/timefuncs.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include <stdlib.h>
 #include <stdio.h>
diff --git a/src/support/timefuncs.h b/src/support/timefuncs.h
index 45d22184d29b10..db3d0fccd97a9b 100644
--- a/src/support/timefuncs.h
+++ b/src/support/timefuncs.h
@@ -1,7 +1,7 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
-#ifndef TIMEFUNCS_H
-#define TIMEFUNCS_H
+#ifndef JL_TIMEFUNCS_H
+#define JL_TIMEFUNCS_H
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/src/support/utf8.c b/src/support/utf8.c
index ea371d1a316899..28c779b73b58ba 100644
--- a/src/support/utf8.c
+++ b/src/support/utf8.c
@@ -109,11 +109,11 @@ size_t u8_toucs(uint32_t *dest, size_t sz, const char *src, size_t srcsz)
         ch = 0;
         switch (nb) {
             /* these fall through deliberately */
-        case 5: ch += (unsigned char)*src++; ch <<= 6;
-        case 4: ch += (unsigned char)*src++; ch <<= 6;
-        case 3: ch += (unsigned char)*src++; ch <<= 6;
-        case 2: ch += (unsigned char)*src++; ch <<= 6;
-        case 1: ch += (unsigned char)*src++; ch <<= 6;
+        case 5: ch += (unsigned char)*src++; ch <<= 6; JL_FALLTHROUGH;
+        case 4: ch += (unsigned char)*src++; ch <<= 6; JL_FALLTHROUGH;
+        case 3: ch += (unsigned char)*src++; ch <<= 6; JL_FALLTHROUGH;
+        case 2: ch += (unsigned char)*src++; ch <<= 6; JL_FALLTHROUGH;
+        case 1: ch += (unsigned char)*src++; ch <<= 6; JL_FALLTHROUGH;
         case 0: ch += (unsigned char)*src++;
         }
         ch -= offsetsFromUTF8[nb];
@@ -167,9 +167,9 @@ size_t u8_toutf8(char *dest, size_t sz, const uint32_t *src, size_t srcsz)
             if (dest >= dest_end-2)
                 break;
             // invalid: use replacement char \ufffd
-            *dest++ = 0xef;
-            *dest++ = 0xbf;
-            *dest++ = 0xbd;
+            *dest++ = (char)0xef;
+            *dest++ = (char)0xbf;
+            *dest++ = (char)0xbd;
         }
         i++;
     }
@@ -200,9 +200,9 @@ size_t u8_wc_toutf8(char *dest, uint32_t ch)
         dest[3] = (ch & 0x3F) | 0x80;
         return 4;
     }
-    dest[0] = 0xef;
-    dest[1] = 0xbf;
-    dest[2] = 0xbd;
+    dest[0] = (char)0xef;
+    dest[1] = (char)0xbf;
+    dest[2] = (char)0xbd;
     return 3;
 }
 
@@ -252,11 +252,11 @@ size_t u8_strwidth(const char *s)
             ch = 0;
             switch (nb) {
                 /* these fall through deliberately */
-            case 5: ch += (unsigned char)*s++; ch <<= 6;
-            case 4: ch += (unsigned char)*s++; ch <<= 6;
-            case 3: ch += (unsigned char)*s++; ch <<= 6;
-            case 2: ch += (unsigned char)*s++; ch <<= 6;
-            case 1: ch += (unsigned char)*s++; ch <<= 6;
+            case 5: ch += (unsigned char)*s++; ch <<= 6; JL_FALLTHROUGH;
+            case 4: ch += (unsigned char)*s++; ch <<= 6; JL_FALLTHROUGH;
+            case 3: ch += (unsigned char)*s++; ch <<= 6; JL_FALLTHROUGH;
+            case 2: ch += (unsigned char)*s++; ch <<= 6; JL_FALLTHROUGH;
+            case 1: ch += (unsigned char)*s++; ch <<= 6; JL_FALLTHROUGH;
             case 0: ch += (unsigned char)*s++;
             }
             ch -= offsetsFromUTF8[nb];
diff --git a/src/support/utf8.h b/src/support/utf8.h
index 8593b35c8d3aef..ba5085a2b34f3b 100644
--- a/src/support/utf8.h
+++ b/src/support/utf8.h
@@ -1,7 +1,7 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
-#ifndef UTF8_H
-#define UTF8_H
+#ifndef JL_UTF8_H
+#define JL_UTF8_H
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/src/support/utils.h b/src/support/utils.h
index 1d48da321162e3..4d77a1bb9fb9b7 100644
--- a/src/support/utils.h
+++ b/src/support/utils.h
@@ -1,7 +1,7 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
-#ifndef UTILS_H
-#define UTILS_H
+#ifndef JL_UTILS_H
+#define JL_UTILS_H
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/src/support/wsasocketpair.c b/src/support/wsasocketpair.c
index 72cf35daed8ab3..77ce3cbc96c986 100644
--- a/src/support/wsasocketpair.c
+++ b/src/support/wsasocketpair.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 // This is a compatibility implementation of the unix "socketpair"
 // function using the Windows Sockets 2 API.
diff --git a/src/symbol.c b/src/symbol.c
index 4950b1163a1a64..7be4136fa70d13 100644
--- a/src/symbol.c
+++ b/src/symbol.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 /*
   Symbol table
@@ -15,7 +15,7 @@
 extern "C" {
 #endif
 
-static jl_sym_t *volatile symtab = NULL;
+static jl_sym_t *symtab = NULL;
 
 static uintptr_t hash_symbol(const char *str, size_t len)
 {
@@ -32,9 +32,9 @@ static jl_sym_t *mk_symbol(const char *str, size_t len)
     jl_sym_t *sym;
     size_t nb = symbol_nbytes(len);
 
-    jl_taggedvalue_t *tag = (jl_taggedvalue_t*)jl_gc_perm_alloc_nolock(nb);
+    jl_taggedvalue_t *tag = (jl_taggedvalue_t*)jl_gc_perm_alloc_nolock(nb, 0, sizeof(void*), 0);
     sym = (jl_sym_t*)jl_valueof(tag);
-    // set to old marked since we don't need write barrier on it.
+    // set to old marked so that we won't look at it in the GC or write barrier.
     tag->header = ((uintptr_t)jl_sym_type) | GC_OLD_MARKED;
     sym->left = sym->right = NULL;
     sym->hash = hash_symbol(str, len);
@@ -43,10 +43,9 @@ static jl_sym_t *mk_symbol(const char *str, size_t len)
     return sym;
 }
 
-static jl_sym_t *symtab_lookup(jl_sym_t *volatile *ptree, const char *str,
-                               size_t len, jl_sym_t *volatile **slot)
+static jl_sym_t *symtab_lookup(jl_sym_t **ptree, const char *str, size_t len, jl_sym_t ***slot)
 {
-    jl_sym_t *node = jl_atomic_load_acquire(ptree);
+    jl_sym_t *node = jl_atomic_load_acquire(ptree); // consume
     uintptr_t h = hash_symbol(str, len);
 
     // Tree nodes sorted by major key of (int(hash)) and minor key of (str).
@@ -64,7 +63,7 @@ static jl_sym_t *symtab_lookup(jl_sym_t *volatile *ptree, const char *str,
             ptree = &node->left;
         else
             ptree = &node->right;
-        node = jl_atomic_load_acquire(ptree);
+        node = jl_atomic_load_acquire(ptree); // consume
     }
     if (slot != NULL)
         *slot = ptree;
@@ -73,7 +72,7 @@ static jl_sym_t *symtab_lookup(jl_sym_t *volatile *ptree, const char *str,
 
 static jl_sym_t *_jl_symbol(const char *str, size_t len)
 {
-    jl_sym_t *volatile *slot;
+    jl_sym_t **slot;
     jl_sym_t *node = symtab_lookup(&symtab, str, len, &slot);
     if (node == NULL) {
         JL_LOCK_NOGC(&gc_perm_lock);
diff --git a/src/sys.c b/src/sys.c
index e391c469de3fb6..ea2a6b1e69a935 100644
--- a/src/sys.c
+++ b/src/sys.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 /*
   sys.c
@@ -668,7 +668,7 @@ JL_DLLEXPORT const char *jl_pathname_for_handle(void *handle)
 
 #ifdef __APPLE__
     // Iterate through all images currently in memory
-    for (int32_t i = _dyld_image_count(); i >= 0 ; i--) {
+    for (int32_t i = _dyld_image_count() - 1; i >= 0 ; i--) {
         // dlopen() each image, check handle
         const char *image_name = _dyld_get_image_name(i);
         void *probe_lib = jl_load_dynamic_library(image_name, JL_RTLD_DEFAULT);
@@ -768,11 +768,13 @@ JL_DLLEXPORT size_t jl_maxrss(void)
     GetProcessMemoryInfo( GetCurrentProcess( ), &counter, sizeof(counter) );
     return (size_t)counter.PeakWorkingSetSize;
 
+// FIXME: `rusage` is available on OpenBSD, DragonFlyBSD and NetBSD as well.
+//        All of them return `ru_maxrss` in kilobytes.
 #elif defined(_OS_LINUX_) || defined(_OS_DARWIN_) || defined (_OS_FREEBSD_)
     struct rusage rusage;
     getrusage( RUSAGE_SELF, &rusage );
 
-#if defined(_OS_LINUX_)
+#if defined(_OS_LINUX_) || defined(_OS_FREEBSD_)
     return (size_t)(rusage.ru_maxrss * 1024);
 #else
     return (size_t)rusage.ru_maxrss;
diff --git a/src/table.c b/src/table.c
index 37738f9816d711..fc136403ad93f5 100644
--- a/src/table.c
+++ b/src/table.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #define hash_size(h) (jl_array_len(h)/2)
 
diff --git a/src/task.c b/src/task.c
index be99b9afdda9a5..8387310fbf3960 100644
--- a/src/task.c
+++ b/src/task.c
@@ -1,9 +1,19 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 /*
   task.c
   lightweight processes (symmetric coroutines)
 */
+
+//// enable this for ifndef COPY_STACKS to work on linux
+//#ifdef _FORTIFY_SOURCE
+//// disable __longjmp_chk validation so that we can jump between stacks
+//#pragma push_macro("_FORTIFY_SOURCE")
+//#undef _FORTIFY_SOURCE
+//#include <setjmp.h>
+//#pragma pop_macro("_FORTIFY_SOURCE")
+//#endif
+
 #include "platform.h"
 
 #include <stdlib.h>
@@ -200,10 +210,16 @@ static void JL_NORETURN finish_task(jl_task_t *t, jl_value_t *resultval)
 #ifdef COPY_STACKS
     t->stkbuf = (void*)(intptr_t)-1;
 #endif
+    // ensure that state is cleared
+    ptls->in_finalizer = 0;
+    ptls->in_pure_callback = 0;
+    jl_get_ptls_states()->world_age = jl_world_counter;
     if (ptls->tid != 0) {
         // For now, only thread 0 runs the task scheduler.
         // The others return to the thread loop
-        jl_switchto(ptls->root_task, jl_nothing);
+        ptls->root_task->result = jl_nothing;
+        jl_task_t *task = ptls->root_task;
+        jl_switchto(&task);
         gc_debug_critical_error();
         abort();
     }
@@ -224,15 +240,6 @@ static void JL_NORETURN finish_task(jl_task_t *t, jl_value_t *resultval)
     abort();
 }
 
-static void throw_if_exception_set(jl_task_t *t)
-{
-    if (t->exception != NULL && t->exception != jl_nothing) {
-        jl_value_t *exc = t->exception;
-        t->exception = jl_nothing;
-        jl_throw(exc);
-    }
-}
-
 static void record_backtrace(void)
 {
     jl_ptls_t ptls = jl_get_ptls_states();
@@ -246,7 +253,7 @@ static void NOINLINE JL_NORETURN start_task(void)
     jl_task_t *t = ptls->current_task;
     jl_value_t *res;
     t->started = 1;
-    if (t->exception != NULL && t->exception != jl_nothing) {
+    if (t->exception != jl_nothing) {
         record_backtrace();
         res = t->exception;
     }
@@ -266,7 +273,6 @@ static void NOINLINE JL_NORETURN start_task(void)
             jl_gc_wb(t, res);
         }
     }
-    jl_get_ptls_states()->world_age = jl_world_counter; // TODO
     finish_task(t, res);
     gc_debug_critical_error();
     abort();
@@ -298,8 +304,7 @@ JL_DLLEXPORT void julia_init(JL_IMAGE_SEARCH rel)
 
 static void ctx_switch(jl_ptls_t ptls, jl_task_t *t, jl_jmp_buf *where)
 {
-    if (t == ptls->current_task)
-        return;
+    assert(t != ptls->current_task);
 #ifdef ENABLE_TIMINGS
     jl_timing_block_t *blk = ptls->current_task->timing_stack;
     if (blk)
@@ -390,18 +395,18 @@ static void ctx_switch(jl_ptls_t ptls, jl_task_t *t, jl_jmp_buf *where)
 #endif
 }
 
-JL_DLLEXPORT jl_value_t *jl_switchto(jl_task_t *t, jl_value_t *arg)
+JL_DLLEXPORT void jl_switchto(jl_task_t **pt)
 {
     jl_ptls_t ptls = jl_get_ptls_states();
+    jl_task_t *t = *pt;
     if (t == ptls->current_task) {
-        throw_if_exception_set(t);
-        return arg;
+        return;
     }
     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;
+        ptls->current_task->exception = t->exception;
+        ptls->current_task->result = t->result;
+        return;
     }
     if (ptls->in_finalizer)
         jl_error("task switch not allowed from inside gc finalizer");
@@ -409,17 +414,13 @@ JL_DLLEXPORT jl_value_t *jl_switchto(jl_task_t *t, jl_value_t *arg)
         jl_error("task switch not allowed from inside staged nor pure functions");
     sig_atomic_t defer_signal = ptls->defer_signal;
     int8_t gc_state = jl_gc_unsafe_enter(ptls);
-    ptls->task_arg_in_transit = arg;
+    *pt = ptls->current_task; // clear the gc-root for the target task
     ctx_switch(ptls, t, &t->ctx);
-    jl_value_t *val = ptls->task_arg_in_transit;
-    ptls->task_arg_in_transit = jl_nothing;
-    throw_if_exception_set(ptls->current_task);
     jl_gc_unsafe_leave(ptls, gc_state);
     sig_atomic_t other_defer_signal = ptls->defer_signal;
     ptls->defer_signal = defer_signal;
     if (other_defer_signal && !defer_signal)
         jl_sigint_safepoint(ptls);
-    return val;
 }
 
 #ifndef COPY_STACKS
@@ -625,7 +626,7 @@ JL_DLLEXPORT jl_task_t *jl_new_task(jl_function_t *start, size_t ssize)
     stk += pagesz;
 
     init_task(t, stk);
-    //jl_gc_add_finalizer((jl_value_t*)t, jl_unprotect_stack_func);
+    jl_gc_add_finalizer((jl_value_t*)t, jl_unprotect_stack_func);
     JL_GC_POP();
 #endif
 
@@ -635,17 +636,15 @@ JL_DLLEXPORT jl_task_t *jl_new_task(jl_function_t *start, size_t ssize)
     return t;
 }
 
-JL_CALLABLE(jl_unprotect_stack)
-{
 #ifndef COPY_STACKS
-    jl_task_t *t = (jl_task_t*)args[0];
+static void jl_unprotect_stack(jl_task_t *t)
+{
     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, pagesz - 1, PROT_READ|PROT_WRITE);
-#endif
-    return jl_nothing;
 }
+#endif
 
 JL_DLLEXPORT jl_value_t *jl_get_current_task(void)
 {
@@ -661,18 +660,19 @@ void jl_init_tasks(void)
     _probe_arch();
     jl_task_type = (jl_datatype_t*)
         jl_new_datatype(jl_symbol("Task"),
+                        NULL,
                         jl_any_type,
                         jl_emptysvec,
-                        jl_svec(9,
-                                jl_symbol("parent"),
-                                jl_symbol("storage"),
-                                jl_symbol("state"),
-                                jl_symbol("consumers"),
-                                jl_symbol("donenotify"),
-                                jl_symbol("result"),
-                                jl_symbol("exception"),
-                                jl_symbol("backtrace"),
-                                jl_symbol("code")),
+                        jl_perm_symsvec(9,
+                                        "parent",
+                                        "storage",
+                                        "state",
+                                        "consumers",
+                                        "donenotify",
+                                        "result",
+                                        "exception",
+                                        "backtrace",
+                                        "code"),
                         jl_svec(9,
                                 jl_any_type,
                                 jl_any_type,
@@ -690,7 +690,9 @@ void jl_init_tasks(void)
     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);
+#ifndef COPY_STACKS
+    jl_unprotect_stack_func = jl_box_voidpointer(&jl_unprotect_stack);
+#endif
 }
 
 // Initialize a root task using the given stack.
@@ -728,7 +730,6 @@ void jl_init_root_task(void *stack, size_t ssize)
     ptls->root_task = ptls->current_task;
 
     ptls->exception_in_transit = (jl_value_t*)jl_nothing;
-    ptls->task_arg_in_transit = (jl_value_t*)jl_nothing;
 }
 
 JL_DLLEXPORT int jl_is_task_started(jl_task_t *t)
diff --git a/src/threadgroup.c b/src/threadgroup.c
index 57e995065a3217..f2158423acc0e4 100644
--- a/src/threadgroup.c
+++ b/src/threadgroup.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 /*
   threading infrastructure
@@ -116,7 +116,7 @@ int ti_threadgroup_size(ti_threadgroup_t *tg, int16_t *tgsize)
     return 0;
 }
 
-int ti_threadgroup_fork(ti_threadgroup_t *tg, int16_t ext_tid, void **bcast_val)
+int ti_threadgroup_fork(ti_threadgroup_t *tg, int16_t ext_tid, void **bcast_val, int init)
 {
     uint8_t *group_sense = &tg->group_sense;
     int16_t tid = tg->tid_map[ext_tid];
@@ -147,13 +147,14 @@ int ti_threadgroup_fork(ti_threadgroup_t *tg, int16_t ext_tid, void **bcast_val)
                 }
                 spin_ns = uv_hrtime() - spin_start;
                 // In case uv_hrtime is not monotonic, we'll sleep earlier
-                if (spin_ns >= tg->sleep_threshold) {
+                if (init || spin_ns >= tg->sleep_threshold) {
                     uv_mutex_lock(&tg->alarm_lock);
                     if (jl_atomic_load_acquire(group_sense) != thread_sense) {
                         uv_cond_wait(&tg->alarm, &tg->alarm_lock);
                     }
                     uv_mutex_unlock(&tg->alarm_lock);
                     spin_start = 0;
+                    init = 0;
                     continue;
                 }
             }
diff --git a/src/threadgroup.h b/src/threadgroup.h
index 72e76d2dcfc8a7..82fc59785cd05f 100644
--- a/src/threadgroup.h
+++ b/src/threadgroup.h
@@ -1,7 +1,7 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
-#ifndef THREADGROUP_H
-#define THREADGROUP_H
+#ifndef JL_THREADGROUP_H
+#define JL_THREADGROUP_H
 
 #include <stdint.h>
 #include "uv.h"
@@ -37,7 +37,7 @@ 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);
+                        void **bcast_val, int init);
 int ti_threadgroup_join(ti_threadgroup_t *tg, int16_t ext_tid);
 int ti_threadgroup_destroy(ti_threadgroup_t *tg);
 
diff --git a/src/threading.c b/src/threading.c
index b0182146017da4..cce22976db1ad1 100644
--- a/src/threading.c
+++ b/src/threading.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 /*
   threading infrastructure
@@ -22,14 +22,19 @@
 #include "julia.h"
 #include "julia_internal.h"
 
+// Ref https://www.uclibc.org/docs/tls.pdf
+// For variant 1 JL_ELF_TLS_INIT_SIZE is the size of the thread control block (TCB)
+// For variant 2 JL_ELF_TLS_INIT_SIZE is 0
 #ifdef _OS_LINUX_
 #  if defined(_CPU_X86_64_) || defined(_CPU_X86_)
 #    define JL_ELF_TLS_VARIANT 2
 #    define JL_ELF_TLS_INIT_SIZE 0
-#  endif
-#  if defined(_CPU_AARCH64_)
+#  elif defined(_CPU_AARCH64_)
 #    define JL_ELF_TLS_VARIANT 1
 #    define JL_ELF_TLS_INIT_SIZE 16
+#  elif defined(__ARM_ARCH) && __ARM_ARCH >= 7
+#    define JL_ELF_TLS_VARIANT 1
+#    define JL_ELF_TLS_INIT_SIZE 8
 #  endif
 #endif
 
@@ -144,24 +149,14 @@ jl_get_ptls_states_func jl_get_ptls_states_getter(void)
 // However, since the detection of the static version in `ifunc`
 // is not guaranteed to be reliable, we still need to fallback to the wrapper
 // version as the symbol address if we didn't find the static version in `ifunc`.
-#if defined(__GLIBC__) && defined(JULIA_HAS_IFUNC_SUPPORT)
-// Make sure both the compiler and the glibc supports it.
-// Only enable this on known working glibc versions.
-#  if (defined(_CPU_X86_) || defined(_CPU_X86_64_)) && __GLIBC_PREREQ(2, 12)
-#    define JL_TLS_USE_IFUNC
-#  elif (defined(_CPU_ARM_) || defined(_CPU_AARCH64_)) && __GLIBC_PREREQ(2, 18)
-// This is the oldest tested version that supports ifunc.
-#    define JL_TLS_USE_IFUNC
-#  endif
-// TODO: PPC probably supports ifunc on some glibc versions too
-#endif
+
 // fallback provided for embedding
 static JL_CONST_FUNC jl_ptls_t jl_get_ptls_states_fallback(void)
 {
     static __thread jl_tls_states_t tls_states;
     return &tls_states;
 }
-#ifdef JL_TLS_USE_IFUNC
+#if JL_USE_IFUNC
 JL_DLLEXPORT JL_CONST_FUNC __attribute__((weak))
 jl_ptls_t jl_get_ptls_states_static(void);
 #endif
@@ -178,7 +173,7 @@ static jl_ptls_t jl_get_ptls_states_init(void)
     // make sure the tls states callback is finalized before adding
     // multiple threads
     jl_get_ptls_states_func cb = jl_get_ptls_states_fallback;
-#ifdef JL_TLS_USE_IFUNC
+#if JL_USE_IFUNC
     if (jl_get_ptls_states_static)
         cb = jl_get_ptls_states_static;
 #endif
@@ -205,7 +200,7 @@ JL_DLLEXPORT void jl_set_ptls_states_getter(jl_get_ptls_states_func f)
     }
 }
 
-#ifdef JL_TLS_USE_IFUNC
+#if JL_USE_IFUNC
 static jl_get_ptls_states_func jl_get_ptls_states_resolve(void)
 {
     if (jl_tls_states_cb != jl_get_ptls_states_init)
@@ -263,12 +258,11 @@ static void ti_initthread(int16_t tid)
 #ifndef _OS_WINDOWS_
     ptls->system_id = pthread_self();
 #endif
+    assert(ptls->world_age == 0);
+    ptls->world_age = 1; // OK to run Julia code on this thread
     ptls->tid = tid;
     ptls->pgcstack = NULL;
     ptls->gc_state = 0; // GC unsafe
-    ptls->gc_cache.perm_scanned_bytes = 0;
-    ptls->gc_cache.scanned_bytes = 0;
-    ptls->gc_cache.nbig_obj = 0;
     // Conditionally initialize the safepoint address. See comment in
     // `safepoint.c`
     if (tid == 0) {
@@ -287,7 +281,7 @@ static void ti_initthread(int16_t tid)
         abort();
     }
     ptls->bt_data = (uintptr_t*)bt_data;
-    jl_mk_thread_heap(ptls);
+    jl_init_thread_heap(ptls);
     jl_install_thread_signal_handler(ptls);
 
     jl_all_tls_states[tid] = ptls;
@@ -298,7 +292,7 @@ static void ti_init_master_thread(void)
 #ifdef _OS_WINDOWS_
     if (!DuplicateHandle(GetCurrentProcess(), GetCurrentThread(),
                          GetCurrentProcess(), &hMainThread, 0,
-                         TRUE, DUPLICATE_SAME_ACCESS)) {
+                         FALSE, DUPLICATE_SAME_ACCESS)) {
         jl_printf(JL_STDERR, "WARNING: failed to access handle to main thread\n");
         hMainThread = INVALID_HANDLE_VALUE;
     }
@@ -307,14 +301,29 @@ static void ti_init_master_thread(void)
 }
 
 // all threads call this function to run user code
-static jl_value_t *ti_run_fun(jl_svec_t *args)
+static jl_value_t *ti_run_fun(const jl_generic_fptr_t *fptr, jl_method_instance_t *mfunc,
+                              jl_value_t **args, uint32_t nargs)
 {
     jl_ptls_t ptls = jl_get_ptls_states();
     JL_TRY {
-        jl_apply(jl_svec_data(args), jl_svec_len(args));
+        (void)jl_assume(fptr->jlcall_api != 2);
+        jl_call_fptr_internal(fptr, mfunc, args, nargs);
     }
     JL_CATCH {
-        return ptls->exception_in_transit;
+        // Lock this output since we know it'll likely happen on multiple threads
+        static jl_mutex_t lock;
+        JL_LOCK_NOGC(&lock);
+        jl_jmp_buf *old_buf = ptls->safe_restore;
+        jl_jmp_buf buf;
+        if (!jl_setjmp(buf, 0)) {
+            // Set up the safe_restore context so that the printing uses the thread safe version
+            ptls->safe_restore = &buf;
+            jl_printf(JL_STDERR, "\nError thrown in threaded loop on thread %d: ",
+                      (int)ptls->tid);
+            jl_static_show(JL_STDERR, ptls->exception_in_transit);
+        }
+        ptls->safe_restore = old_buf;
+        JL_UNLOCK_NOGC(&lock);
     }
     return jl_nothing;
 }
@@ -376,13 +385,16 @@ void ti_threadfun(void *arg)
     // free the thread argument here
     free(ta);
 
+    int init = 1;
+
     // work loop
     for (; ;) {
 #if PROFILE_JL_THREADING
         uint64_t tstart = uv_hrtime();
 #endif
 
-        ti_threadgroup_fork(tg, ptls->tid, (void **)&work);
+        ti_threadgroup_fork(tg, ptls->tid, (void **)&work, init);
+        init = 0;
 
 #if PROFILE_JL_THREADING
         uint64_t tfork = uv_hrtime();
@@ -406,7 +418,7 @@ void ti_threadfun(void *arg)
                 JL_GC_PUSH1(&last_m);
                 ptls->current_module = work->current_module;
                 ptls->world_age = work->world_age;
-                ti_run_fun(work->args);
+                ti_run_fun(&work->fptr, work->mfunc, work->args, work->nargs);
                 ptls->current_module = last_m;
                 ptls->world_age = last_age;
                 JL_GC_POP();
@@ -438,15 +450,16 @@ void ti_reset_timings(void);
 ssize_t jl_tls_offset = -1;
 
 #ifdef JL_ELF_TLS_VARIANT
+const int jl_tls_elf_support = 1;
 // Optimize TLS access in codegen if the TLS buffer is using a IE or LE model.
 // To detect such case, we find the size of the TLS segment in the main
-// executable and the TIB pointer and then see if the TLS pointer on the
+// executable and the thread pointer (TP) and then see if the TLS pointer on the
 // current thread is in the right range.
 // This can in principle be extended to the case where the TLS buffer is
 // in the shared library but is part of the static buffer but that seems harder
 // to detect.
 #  if JL_ELF_TLS_VARIANT == 1
-// In Variant 1, the static TLS buffer comes after a fixed size TIB.
+// In Variant 1, the static TLS buffer comes after a fixed size TCB.
 // The alignment needs to be applied to the original size.
 static inline size_t jl_add_tls_size(size_t orig_size, size_t size, size_t align)
 {
@@ -461,7 +474,7 @@ static inline ssize_t jl_check_tls_bound(void *tp, void *ptls, size_t tls_size)
     return offset;
 }
 #  elif JL_ELF_TLS_VARIANT == 2
-// In Variant 2, the static TLS buffer comes before a unknown size TIB.
+// In Variant 2, the static TLS buffer comes before a unknown size TCB.
 // The alignment needs to be applied to the new size.
 static inline size_t jl_add_tls_size(size_t orig_size, size_t size, size_t align)
 {
@@ -517,6 +530,8 @@ static void jl_check_tls(void)
     asm("movl %%gs:0, %0" : "=r"(tp));
 #elif defined(_CPU_AARCH64_)
     asm("mrs %0, tpidr_el0" : "=r"(tp));
+#elif defined(__ARM_ARCH) && __ARM_ARCH >= 7
+    asm("mrc p15, 0, %0, c13, c0, 3" : "=r"(tp));
 #else
 #  error "Cannot emit thread pointer for this architecture."
 #endif
@@ -525,6 +540,8 @@ static void jl_check_tls(void)
         return;
     jl_tls_offset = offset;
 }
+#else
+const int jl_tls_elf_support = 0;
 #endif
 
 // interface to Julia; sets up to make the runtime thread-safe
@@ -630,7 +647,7 @@ void jl_shutdown_threading(void)
     ti_threadwork_t *work = &threadwork;
 
     work->command = TI_THREADWORK_DONE;
-    ti_threadgroup_fork(tgworld, ptls->tid, (void **)&work);
+    ti_threadgroup_fork(tgworld, ptls->tid, (void **)&work, 0);
 
     sleep(1);
 
@@ -645,31 +662,36 @@ void jl_shutdown_threading(void)
 #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)
+JL_DLLEXPORT jl_value_t *jl_threading_run(jl_value_t *_args)
 {
     jl_ptls_t ptls = jl_get_ptls_states();
     // 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);
+    uint32_t nargs;
+    jl_value_t **args;
+    if (!jl_is_svec(_args)) {
+        nargs = 1;
+        args = &_args;
+    }
+    else {
+        nargs = jl_svec_len(_args);
+        args = jl_svec_data(_args);
+    }
 
     int8_t gc_state = jl_gc_unsafe_enter(ptls);
-    JL_GC_PUSH1(&argtypes);
-    argtypes = arg_type_tuple(jl_svec_data(args), jl_svec_len(args));
-    jl_compile_hint(argtypes);
 
     threadwork.command = TI_THREADWORK_RUN;
-    // TODO jb/functions: lookup and store jlcall fptr here
-    threadwork.fun = NULL;
+    threadwork.mfunc = jl_lookup_generic(args, nargs,
+                                         jl_int32hash_fast(jl_return_address()), ptls->world_age);
+    // Ignore constant return value for now.
+    if (jl_compile_method_internal(&threadwork.fptr, threadwork.mfunc))
+        return jl_nothing;
     threadwork.args = args;
+    threadwork.nargs = nargs;
     threadwork.ret = jl_nothing;
     threadwork.current_module = ptls->current_module;
     threadwork.world_age = ptls->world_age;
@@ -681,7 +703,7 @@ JL_DLLEXPORT jl_value_t *jl_threading_run(jl_svec_t *args)
 
     // fork the world thread group
     ti_threadwork_t *tw = &threadwork;
-    ti_threadgroup_fork(tgworld, ptls->tid, (void **)&tw);
+    ti_threadgroup_fork(tgworld, ptls->tid, (void **)&tw, 0);
 
 #if PROFILE_JL_THREADING
     uint64_t tfork = uv_hrtime();
@@ -689,7 +711,7 @@ JL_DLLEXPORT jl_value_t *jl_threading_run(jl_svec_t *args)
 #endif
 
     // this thread must do work too (TODO: reduction?)
-    tw->ret = ti_run_fun(args);
+    tw->ret = ti_run_fun(&threadwork.fptr, threadwork.mfunc, args, nargs);
 
 #if PROFILE_JL_THREADING
     uint64_t trun = uv_hrtime();
@@ -704,7 +726,6 @@ JL_DLLEXPORT jl_value_t *jl_threading_run(jl_svec_t *args)
     join_ns[ptls->tid] += (tjoin - trun);
 #endif
 
-    JL_GC_POP();
     jl_gc_unsafe_leave(ptls, gc_state);
 
     return tw->ret;
@@ -766,10 +787,25 @@ JL_DLLEXPORT void jl_threading_profile(void)
 
 #else // !JULIA_ENABLE_THREADING
 
-JL_DLLEXPORT jl_value_t *jl_threading_run(jl_svec_t *args)
+JL_DLLEXPORT jl_value_t *jl_threading_run(jl_value_t *_args)
 {
-    JL_TYPECHK(jl_threading_run, simplevector, (jl_value_t*)args);
-    return ti_run_fun(args);
+    uint32_t nargs;
+    jl_value_t **args;
+    if (!jl_is_svec(_args)) {
+        nargs = 1;
+        args = &_args;
+    }
+    else {
+        nargs = jl_svec_len(_args);
+        args = jl_svec_data(_args);
+    }
+    jl_method_instance_t *mfunc = jl_lookup_generic(args, nargs,
+                                                    jl_int32hash_fast(jl_return_address()),
+                                                    jl_get_ptls_states()->world_age);
+    jl_generic_fptr_t fptr;
+    if (jl_compile_method_internal(&fptr, mfunc))
+        return jl_nothing;
+    return ti_run_fun(&fptr, mfunc, args, nargs);
 }
 
 void jl_init_threading(void)
diff --git a/src/threading.h b/src/threading.h
index b21863a3e5338a..17d0a1c9efbab7 100644
--- a/src/threading.h
+++ b/src/threading.h
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #ifndef THREADING_H
 #define THREADING_H
@@ -38,12 +38,14 @@ enum {
 
 // 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;
-    size_t        world_age;
+    uint8_t command;
+    jl_method_instance_t *mfunc;
+    jl_generic_fptr_t fptr;
+    jl_value_t **args;
+    uint32_t nargs;
+    jl_value_t *ret;
+    jl_module_t *current_module;
+    size_t world_age;
 } ti_threadwork_t;
 
 // thread function
diff --git a/src/timing.c b/src/timing.c
index 6c23e5c97eac22..a9ee6d7685a102 100644
--- a/src/timing.c
+++ b/src/timing.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include <inttypes.h>
 #include "julia.h"
diff --git a/src/timing.h b/src/timing.h
index e9677cc7da9bef..dfd676d66e4bd5 100644
--- a/src/timing.h
+++ b/src/timing.h
@@ -1,4 +1,7 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
+
+#ifndef JL_TIMING_H
+#define JL_TIMING_H
 
 #ifndef ENABLE_TIMINGS
 #define JL_TIMING(owner)
@@ -151,3 +154,5 @@ struct jl_timing_block_cpp_t {
 
 #endif
 #endif
+
+#endif
diff --git a/src/tls.h b/src/tls.h
new file mode 100644
index 00000000000000..678867d4c7b358
--- /dev/null
+++ b/src/tls.h
@@ -0,0 +1,44 @@
+// This file is a part of Julia. License is MIT: https://julialang.org/license
+
+#ifndef JL_TLS_H
+#define JL_TLS_H
+
+// Thread-local storage access
+
+// Copied from libuv. Add `JL_CONST_FUNC` so that the compiler
+// can optimize this better.
+static inline unsigned long JL_CONST_FUNC jl_thread_self(void)
+{
+#ifdef _OS_WINDOWS_
+    return (unsigned long)GetCurrentThreadId();
+#else
+    return (unsigned long)pthread_self();
+#endif
+}
+
+typedef struct _jl_tls_states_t *jl_ptls_t;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+JL_DLLEXPORT int16_t jl_threadid(void);
+JL_DLLEXPORT void jl_threading_profile(void);
+
+JL_DLLEXPORT JL_CONST_FUNC jl_ptls_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)
+#else // ifndef JULIA_ENABLE_THREADING
+typedef jl_ptls_t (*jl_get_ptls_states_func)(void);
+#if !defined(_OS_DARWIN_) && !defined(_OS_WINDOWS_)
+JL_DLLEXPORT void jl_set_ptls_states_getter(jl_get_ptls_states_func f);
+#endif
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/toplevel.c b/src/toplevel.c
index 8d70905d9e4946..c90f335ea8b116 100644
--- a/src/toplevel.c
+++ b/src/toplevel.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 /*
   evaluating top-level expressions, loading source files
@@ -54,8 +54,10 @@ JL_DLLEXPORT jl_module_t *jl_new_main_module(void)
 
     jl_main_module = jl_new_module(jl_symbol("Main"));
     jl_main_module->parent = jl_main_module;
-    if (old_main) // don't block continued loading of incremental caches
+    if (old_main) { // don't block continued loading of incremental caches
+        jl_main_module->primary_world = old_main->primary_world;
         jl_main_module->uuid = old_main->uuid;
+    }
     ptls->current_module = jl_main_module;
 
     jl_core_module->parent = jl_main_module;
@@ -119,7 +121,7 @@ static void jl_module_load_time_initialize(jl_module_t *m)
 }
 
 extern void jl_get_system_hooks(void);
-jl_value_t *jl_eval_module_expr(jl_expr_t *ex)
+jl_value_t *jl_eval_module_expr(jl_module_t *parent_module, jl_expr_t *ex)
 {
     jl_ptls_t ptls = jl_get_ptls_states();
     static arraylist_t module_stack;
@@ -139,7 +141,6 @@ jl_value_t *jl_eval_module_expr(jl_expr_t *ex)
     if (!jl_is_symbol(name)) {
         jl_type_error("module", (jl_value_t*)jl_sym_type, (jl_value_t*)name);
     }
-    jl_module_t *parent_module = ptls->current_module;
     jl_binding_t *b = jl_get_binding_wr(parent_module, name);
     jl_declare_constant(b);
     if (b->value != NULL) {
@@ -189,18 +190,18 @@ jl_value_t *jl_eval_module_expr(jl_expr_t *ex)
     JL_TRY {
         if (std_imports) {
             // add `eval` function
-            defaultdefs = jl_call_scm_on_ast("module-default-defs", (jl_value_t*)ex);
+            defaultdefs = jl_call_scm_on_ast("module-default-defs", (jl_value_t*)ex, newm);
             ptls->world_age = jl_world_counter;
-            jl_toplevel_eval_flex(defaultdefs, 0, 1);
+            jl_toplevel_eval_flex(newm, defaultdefs, 0, 1);
             defaultdefs = NULL;
         }
 
         for (int i = 0; i < jl_array_len(exprs); i++) {
             // process toplevel form
             ptls->world_age = jl_world_counter;
-            form = jl_expand(jl_array_ptr_ref(exprs, i));
+            form = jl_expand(jl_array_ptr_ref(exprs, i), newm);
             ptls->world_age = jl_world_counter;
-            (void)jl_toplevel_eval_flex(form, 1, 1);
+            (void)jl_toplevel_eval_flex(newm, form, 1, 1);
         }
     }
     JL_CATCH {
@@ -239,7 +240,7 @@ jl_value_t *jl_eval_module_expr(jl_expr_t *ex)
 
     arraylist_push(&module_stack, newm);
 
-    if (outermost == NULL || ptls->current_module == jl_main_module) {
+    if (outermost == NULL || parent_module == jl_main_module) {
         JL_TRY {
             size_t i, l = module_stack.len;
             for (i = stackidx; i < l; i++) {
@@ -341,25 +342,26 @@ static int jl_eval_expr_with_compiler_p(jl_value_t *e, int compileloops, jl_modu
 
 static jl_value_t *require_func=NULL;
 
-static jl_module_t *eval_import_path_(jl_array_t *args, int retrying)
+static jl_module_t *eval_import_path_(jl_module_t *from, jl_array_t *args, int retrying)
 {
-    jl_ptls_t ptls = jl_get_ptls_states();
     // in .A.B.C, first find a binding for A in the chain of module scopes
     // following parent links. then evaluate the rest of the path from there.
     // in A.B, look for A in Main first.
-    jl_sym_t *var = (jl_sym_t*)jl_array_ptr_ref(args,0);
-    size_t i=1;
-    if (!jl_is_symbol(var)) jl_type_error("import or using", (jl_value_t*)jl_sym_type, (jl_value_t*)var);
-    jl_module_t *m;
+    jl_sym_t *var = (jl_sym_t*)jl_array_ptr_ref(args, 0);
+    size_t i = 1;
+    if (!jl_is_symbol(var))
+        jl_type_error("import or using", (jl_value_t*)jl_sym_type, (jl_value_t*)var);
 
+    jl_module_t *m;
     if (var != dot_sym) {
         m = jl_main_module;
     }
     else {
-        m = ptls->current_module;
+        m = from;
         while (1) {
-            var = (jl_sym_t*)jl_array_ptr_ref(args,i);
-            if (!jl_is_symbol(var)) jl_type_error("import or using", (jl_value_t*)jl_sym_type, (jl_value_t*)var);
+            var = (jl_sym_t*)jl_array_ptr_ref(args, i);
+            if (!jl_is_symbol(var))
+                jl_type_error("import or using", (jl_value_t*)jl_sym_type, (jl_value_t*)var);
             i++;
             if (var != dot_sym) {
                 if (i == jl_array_len(args))
@@ -399,13 +401,14 @@ static jl_module_t *eval_import_path_(jl_array_t *args, int retrying)
                 if (require_func != NULL) {
                     jl_value_t *reqargs[2] = {require_func, (jl_value_t*)var};
                     jl_apply(reqargs, 2);
-                    return eval_import_path_(args, 1);
+                    return eval_import_path_(from, args, 1);
                 }
             }
         }
         if (retrying && require_func) {
-            jl_printf(JL_STDERR, "WARNING: requiring \"%s\" in module \"%s\" did not define a corresponding module.\n", jl_symbol_name(var),
-                      jl_symbol_name(ptls->current_module->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(from->name));
             return NULL;
         }
         else {
@@ -423,12 +426,12 @@ static jl_module_t *eval_import_path_(jl_array_t *args, int retrying)
     return m;
 }
 
-static jl_module_t *eval_import_path(jl_array_t *args)
+static jl_module_t *eval_import_path(jl_module_t *from, jl_array_t *args)
 {
-    return eval_import_path_(args, 0);
+    return eval_import_path_(from, args, 0);
 }
 
-jl_value_t *jl_toplevel_eval_body(jl_array_t *stmts);
+jl_value_t *jl_toplevel_eval_body(jl_module_t *m, jl_array_t *stmts);
 
 int jl_is_toplevel_only_expr(jl_value_t *e)
 {
@@ -448,6 +451,7 @@ static jl_method_instance_t *jl_new_thunk(jl_code_info_t *src, jl_module_t *modu
     jl_method_instance_t *li = jl_new_method_instance_uninit();
     li->inferred = (jl_value_t*)src;
     li->specTypes = (jl_value_t*)jl_emptytuple_type;
+    li->def.module = module;
     jl_array_t *stmts = (jl_array_t*)src->code;
     size_t i, l;
     JL_GC_PUSH1(&li);
@@ -458,69 +462,70 @@ static jl_method_instance_t *jl_new_thunk(jl_code_info_t *src, jl_module_t *modu
     return li;
 }
 
-jl_value_t *jl_toplevel_eval_flex(jl_value_t *e, int fast, int expanded)
+jl_value_t *jl_toplevel_eval_flex(jl_module_t *m, jl_value_t *e, int fast, int expanded)
 {
     jl_ptls_t ptls = jl_get_ptls_states();
-    //jl_show(ex);
-    //jl_printf(JL_STDOUT, "\n");
     if (!jl_is_expr(e)) {
         if (jl_is_linenode(e)) {
             jl_lineno = jl_linenode_line(e);
             return jl_nothing;
         }
-        return jl_interpret_toplevel_expr(e);
+        return jl_interpret_toplevel_expr_in(m, e, NULL, NULL);
     }
 
     jl_expr_t *ex = (jl_expr_t*)e;
     if (ex->head == error_sym || ex->head == jl_incomplete_sym) {
         // expression types simple enough not to need expansion
-        return jl_interpret_toplevel_expr(e);
+        return jl_interpret_toplevel_expr_in(m, e, NULL, NULL);
     }
     else if (ex->head == module_sym) {
-        return jl_eval_module_expr(ex);
+        return jl_eval_module_expr(m, ex);
     }
     else if (ex->head == importall_sym) {
-        jl_module_t *m = eval_import_path(ex->args);
-        if (m==NULL) return jl_nothing;
-        jl_sym_t *name = (jl_sym_t*)jl_array_ptr_ref(ex->args, jl_array_len(ex->args)-1);
+        jl_module_t *import = eval_import_path(m, ex->args);
+        if (import == NULL)
+            return jl_nothing;
+        jl_sym_t *name = (jl_sym_t*)jl_array_ptr_ref(ex->args, jl_array_len(ex->args) - 1);
         if (!jl_is_symbol(name))
             jl_error("syntax: malformed \"importall\" statement");
-        m = (jl_module_t*)jl_eval_global_var(m, name);
-        if (!jl_is_module(m))
+        import = (jl_module_t*)jl_eval_global_var(import, name);
+        if (!jl_is_module(import))
             jl_errorf("invalid %s statement: name exists but does not refer to a module", jl_symbol_name(ex->head));
-        jl_module_importall(ptls->current_module, m);
+        jl_module_importall(m, import);
         return jl_nothing;
     }
     else if (ex->head == using_sym) {
-        jl_module_t *m = eval_import_path(ex->args);
-        if (m==NULL) return jl_nothing;
-        jl_sym_t *name = (jl_sym_t*)jl_array_ptr_ref(ex->args, jl_array_len(ex->args)-1);
+        jl_module_t *import = eval_import_path(m, ex->args);
+        if (import == NULL)
+            return jl_nothing;
+        jl_sym_t *name = (jl_sym_t*)jl_array_ptr_ref(ex->args, jl_array_len(ex->args) - 1);
         if (!jl_is_symbol(name))
             jl_error("syntax: malformed \"using\" statement");
-        jl_module_t *u = (jl_module_t*)jl_eval_global_var(m, name);
+        jl_module_t *u = (jl_module_t*)jl_eval_global_var(import, name);
         if (jl_is_module(u)) {
-            jl_module_using(ptls->current_module, u);
+            jl_module_using(m, u);
         }
         else {
-            jl_module_use(ptls->current_module, m, name);
+            jl_module_use(m, import, name);
         }
         return jl_nothing;
     }
     else if (ex->head == import_sym) {
-        jl_module_t *m = eval_import_path(ex->args);
-        if (m==NULL) return jl_nothing;
-        jl_sym_t *name = (jl_sym_t*)jl_array_ptr_ref(ex->args, jl_array_len(ex->args)-1);
+        jl_module_t *import = eval_import_path(m, ex->args);
+        if (import == NULL)
+            return jl_nothing;
+        jl_sym_t *name = (jl_sym_t*)jl_array_ptr_ref(ex->args, jl_array_len(ex->args) - 1);
         if (!jl_is_symbol(name))
             jl_error("syntax: malformed \"import\" statement");
-        jl_module_import(ptls->current_module, m, name);
+        jl_module_import(m, import, name);
         return jl_nothing;
     }
     else if (ex->head == export_sym) {
-        for(size_t i=0; i < jl_array_len(ex->args); i++) {
+        for (size_t i = 0; i < jl_array_len(ex->args); i++) {
             jl_sym_t *name = (jl_sym_t*)jl_array_ptr_ref(ex->args, i);
             if (!jl_is_symbol(name))
                 jl_error("syntax: malformed \"export\" statement");
-            jl_module_export(ptls->current_module, name);
+            jl_module_export(m, name);
         }
         return jl_nothing;
     }
@@ -538,7 +543,7 @@ jl_value_t *jl_toplevel_eval_flex(jl_value_t *e, int fast, int expanded)
     if (!expanded && ex->head != body_sym && ex->head != thunk_sym && ex->head != return_sym &&
         ex->head != method_sym && ex->head != toplevel_sym) {
         // not yet expanded
-        ex = (jl_expr_t*)jl_expand(e);
+        ex = (jl_expr_t*)jl_expand(e, m);
     }
     jl_sym_t *head = jl_is_expr(ex) ? ex->head : NULL;
 
@@ -548,7 +553,7 @@ jl_value_t *jl_toplevel_eval_flex(jl_value_t *e, int fast, int expanded)
         int i;
         for (i = 0; i < jl_array_len(ex->args); i++) {
             ptls->world_age = jl_world_counter; // eval each statement in the newest world age
-            res = jl_toplevel_eval_flex(jl_array_ptr_ref(ex->args, i), fast, 0);
+            res = jl_toplevel_eval_flex(m, jl_array_ptr_ref(ex->args, i), fast, 0);
         }
         ptls->world_age = last_age;
         JL_GC_POP();
@@ -559,22 +564,22 @@ jl_value_t *jl_toplevel_eval_flex(jl_value_t *e, int fast, int expanded)
         thk = (jl_code_info_t*)jl_exprarg(ex,0);
         assert(jl_is_code_info(thk));
         assert(jl_typeis(thk->code, jl_array_any_type));
-        ewc = jl_eval_with_compiler_p(thk, (jl_array_t*)thk->code, fast, ptls->current_module);
+        ewc = jl_eval_with_compiler_p(thk, (jl_array_t*)thk->code, fast, m);
     }
     else {
-        if (head && jl_eval_expr_with_compiler_p((jl_value_t*)ex, fast, ptls->current_module)) {
+        if (head && jl_eval_expr_with_compiler_p((jl_value_t*)ex, fast, m)) {
             thk = jl_wrap_expr((jl_value_t*)ex);
             ewc = 1;
         }
         else {
             if (head == body_sym) {
-                result = jl_toplevel_eval_body(ex->args);
+                result = jl_toplevel_eval_body(m, ex->args);
             }
             else if (jl_is_toplevel_only_expr((jl_value_t*)ex)) {
-                result = jl_toplevel_eval((jl_value_t*)ex);
+                result = jl_toplevel_eval(m, (jl_value_t*)ex);
             }
             else {
-                result = jl_interpret_toplevel_expr((jl_value_t*)ex);
+                result = jl_interpret_toplevel_expr_in(m, (jl_value_t*)ex, NULL, NULL);
             }
             JL_GC_POP();
             return result;
@@ -582,28 +587,27 @@ jl_value_t *jl_toplevel_eval_flex(jl_value_t *e, int fast, int expanded)
     }
 
     if (ewc) {
-        li = jl_new_thunk(thk, ptls->current_module);
+        li = jl_new_thunk(thk, m);
         size_t world = jl_get_ptls_states()->world_age;
         jl_type_infer(&li, world, 0);
         jl_value_t *dummy_f_arg = NULL;
         result = jl_call_method_internal(li, &dummy_f_arg, 1);
     }
     else {
-        result = jl_interpret_toplevel_thunk(thk);
+        result = jl_interpret_toplevel_thunk(m, thk);
     }
     JL_GC_POP();
     return result;
 }
 
-JL_DLLEXPORT jl_value_t *jl_toplevel_eval(jl_value_t *v)
+JL_DLLEXPORT jl_value_t *jl_toplevel_eval(jl_module_t *m, jl_value_t *v)
 {
-    return jl_toplevel_eval_flex(v, 1, 0);
+    return jl_toplevel_eval_flex(m, v, 1, 0);
 }
 
-JL_DLLEXPORT jl_value_t *jl_load(const char *fname)
+JL_DLLEXPORT jl_value_t *jl_load(jl_module_t *module, const char *fname)
 {
-    jl_ptls_t ptls = jl_get_ptls_states();
-    if (ptls->current_module->istopmod) {
+    if (module->istopmod) {
         jl_printf(JL_STDOUT, "%s\r\n", fname);
 #ifdef _OS_WINDOWS_
         uv_run(uv_default_loop(), (uv_run_mode)1);
@@ -613,14 +617,14 @@ JL_DLLEXPORT jl_value_t *jl_load(const char *fname)
     if (jl_stat(fname, (char*)&stbuf) != 0 || (stbuf.st_mode & S_IFMT) != S_IFREG) {
         jl_errorf("could not open file %s", fname);
     }
-    return jl_parse_eval_all(fname, NULL, 0);
+    return jl_parse_eval_all(fname, NULL, 0, module);
 }
 
 // load from filename given as a String object
-JL_DLLEXPORT jl_value_t *jl_load_(jl_value_t *str)
+JL_DLLEXPORT jl_value_t *jl_load_(jl_module_t *module, jl_value_t *str)
 {
     // assume String has a hidden '\0' at the end
-    return jl_load((const char*)jl_string_data(str));
+    return jl_load(module, (const char*)jl_string_data(str));
 }
 
 #ifdef __cplusplus
diff --git a/src/typemap.c b/src/typemap.c
index dc12a24d817ec4..ad2a64b3dd9f37 100644
--- a/src/typemap.c
+++ b/src/typemap.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include <stdlib.h>
 #include <string.h>
@@ -19,7 +19,7 @@ extern "C" {
 // compute whether the specificity of this type is equivalent to Any in the sort order
 static int jl_is_any(jl_value_t *t1)
 {
-    return (t1 == (jl_value_t*)jl_any_type || t1 == jl_ANY_flag ||
+    return (t1 == (jl_value_t*)jl_any_type ||
             (jl_is_typevar(t1) &&
              ((jl_tvar_t*)t1)->ub == (jl_value_t*)jl_any_type));
 }
@@ -59,18 +59,17 @@ static int sig_match_by_type_simple(jl_value_t **types, size_t n, jl_tupletype_t
                         return 0;
                 }
                 else {
-                    if (!jl_types_equal(jl_tparam0(a), tp0))
+                    if (!(jl_typeof(jl_tparam0(a)) == jl_typeof(tp0) && jl_types_equal(jl_tparam0(a), tp0)))
                         return 0;
                 }
             }
             else if (!jl_is_kind(a) || !jl_is_typevar(tp0) || ((jl_tvar_t*)tp0)->ub != (jl_value_t*)jl_any_type) {
                 // manually unroll jl_subtype(a, decl)
-                // where `a` can be a subtype like TypeConstructor
-                // and decl is Type{T}
+                // where `a` can be a subtype and decl is Type{T}
                 return 0;
             }
         }
-        else if (decl == (jl_value_t*)jl_any_type || decl == jl_ANY_flag) {
+        else if (decl == (jl_value_t*)jl_any_type) {
         }
         else {
             if (jl_is_type_type(a)) // decl is not Type, because it would be caught above
@@ -123,8 +122,7 @@ static inline int sig_match_simple(jl_value_t **args, size_t n, jl_value_t **sig
     for (i = 0; i < lensig; i++) {
         jl_value_t *decl = sig[i];
         jl_value_t *a = args[i];
-        if (decl == (jl_value_t*)jl_any_type || decl == jl_ANY_flag ||
-            ((jl_value_t*)jl_typeof(a) == decl)) {
+        if (decl == (jl_value_t*)jl_any_type || ((jl_value_t*)jl_typeof(a) == decl)) {
             /*
               we are only matching concrete types here, and those types are
               hash-consed, so pointer comparison should work.
@@ -142,8 +140,18 @@ static inline int sig_match_simple(jl_value_t **args, size_t n, jl_value_t **sig
                     return 0;
             }
             else {
-                if (a!=tp0 && !jl_types_equal(a,tp0))
-                    return 0;
+                if (a != tp0) {
+                    if (jl_typeof(a) != jl_typeof(tp0))
+                        return 0;
+                    jl_datatype_t *da = (jl_datatype_t*)a;
+                    jl_datatype_t *dt = (jl_datatype_t*)tp0;
+                    while (jl_is_unionall(da)) da = (jl_datatype_t*)((jl_unionall_t*)da)->body;
+                    while (jl_is_unionall(dt)) dt = (jl_datatype_t*)((jl_unionall_t*)dt)->body;
+                    if (jl_is_datatype(da) && jl_is_datatype(dt) && da->name != dt->name)
+                        return 0;
+                    if (!jl_types_equal(a, tp0))
+                        return 0;
+                }
             }
         }
         else {
@@ -326,7 +334,7 @@ static union jl_typemap_t *mtcache_hash_bp(struct jl_ordereddict_t *pa, jl_value
     if (jl_is_datatype(ty)) {
         uintptr_t uid = ((jl_datatype_t*)ty)->uid;
         if (!uid || jl_is_kind(ty) || jl_has_free_typevars(ty))
-            // be careful not to put non-concrete types or DataType/TypeConstructor in the cache here,
+            // be careful not to put non-concrete types or DataType/UnionAll in the cache here,
             // since they should have a lower priority and need to go into the sorted list
             return NULL;
         if (pa->values == (void*)jl_nothing) {
@@ -515,7 +523,7 @@ int jl_typemap_intersection_visitor(union jl_typemap_t map, int offs,
                 else {
                     // else an array scan is required to check subtypes
                     // first, fast-path: optimized pre-intersection test to see if `ty` could intersect with any Type
-                    if (typetype || jl_type_intersection((jl_value_t*)jl_type_type, ty) != jl_bottom_type)
+                    if (typetype || !jl_has_empty_intersection((jl_value_t*)jl_type_type, ty))
                         if (!jl_typemap_intersection_array_visitor(&cache->targ, ty, 1, offs, closure)) return 0;
                 }
             }
@@ -641,15 +649,34 @@ static jl_typemap_entry_t *jl_typemap_assoc_by_type_(jl_typemap_entry_t *ml, jl_
     return NULL;
 }
 
+int jl_obviously_unequal(jl_value_t *a, jl_value_t *b);
+
 static jl_typemap_entry_t *jl_typemap_lookup_by_type_(jl_typemap_entry_t *ml, jl_tupletype_t *types, size_t world)
 {
     for (; ml != (void*)jl_nothing; ml = ml->next) {
         if (world < ml->min_world || world > ml->max_world)
             continue;
         // TODO: more efficient
-        if (jl_types_equal((jl_value_t*)types, (jl_value_t*)ml->sig)) {
-            return ml;
+        jl_value_t *a = (jl_value_t*)types;
+        jl_value_t *b = (jl_value_t*)ml->sig;
+        while (jl_is_unionall(a)) a = ((jl_unionall_t*)a)->body;
+        while (jl_is_unionall(b)) b = ((jl_unionall_t*)b)->body;
+        size_t na = jl_nparams(a), nb = jl_nparams(b);
+        assert(na > 0 && nb > 0);
+        if (!jl_is_vararg_type(jl_tparam(a,na-1)) && !jl_is_vararg_type(jl_tparam(b,nb-1))) {
+            if (na != nb)
+                continue;
         }
+        if (na > 1 && nb > 1) {
+            if (jl_obviously_unequal(jl_tparam(a,1), jl_tparam(b,1)))
+                continue;
+            if (na > 2 && nb > 2) {
+                if (jl_obviously_unequal(jl_tparam(a,2), jl_tparam(b,2)))
+                    continue;
+            }
+        }
+        if (jl_types_equal((jl_value_t*)types, (jl_value_t*)ml->sig))
+            return ml;
     }
     return NULL;
 }
@@ -792,7 +819,7 @@ jl_typemap_entry_t *jl_typemap_entry_assoc_exact(jl_typemap_entry_t *ml, jl_valu
             if (ml->guardsigs != jl_emptysvec) {
                 for (i = 0, l = jl_svec_len(ml->guardsigs); i < l; i++) {
                     // checking guard entries require a more
-                    // expensive subtype check, since guard entries added for ANY might be
+                    // expensive subtype check, since guard entries added for @nospecialize might be
                     // abstract. this fixed issue #12967.
                     if (jl_tuple_isa(args, n, (jl_tupletype_t*)jl_svecref(ml->guardsigs, i))) {
                         goto nomatch;
@@ -949,8 +976,10 @@ static void jl_typemap_level_insert_(jl_typemap_level_t *cache, jl_typemap_entry
         t1 = jl_tparam(ttypes, offs);
     }
     // If the type at `offs` is Any, put it in the Any list
-    if (t1 && jl_is_any(t1))
-        return jl_typemap_insert_generic(&cache->any, (jl_value_t*)cache, newrec, (jl_value_t*)jl_any_type, offs+1, tparams);
+    if (t1 && jl_is_any(t1)) {
+        jl_typemap_insert_generic(&cache->any, (jl_value_t*)cache, newrec, (jl_value_t*)jl_any_type, offs+1, tparams);
+        return;
+    }
     // Don't put Varargs in the optimized caches (too hard to handle in lookup and bp)
     if (t1 && !isva) {
         // if t1 != jl_typetype_type and the argument is Type{...}, this
@@ -1006,7 +1035,7 @@ jl_typemap_entry_t *jl_typemap_insert(union jl_typemap_t *cache, jl_value_t *par
     newrec->max_world = max_world;
     // compute the complexity of this type signature
     newrec->va = jl_is_va_tuple((jl_datatype_t*)ttype);
-    newrec->issimplesig = !jl_is_unionall(type); // a TypeVar environment needs an complex matching test
+    newrec->issimplesig = !jl_is_unionall(type); // a TypeVar environment needs a complex matching test
     newrec->isconcretesig = newrec->issimplesig && !newrec->va; // entirely concrete types don't need to be sorted
     JL_GC_PUSH1(&newrec);
     assert(jl_is_tuple_type(ttype));
@@ -1017,6 +1046,8 @@ jl_typemap_entry_t *jl_typemap_insert(union jl_typemap_t *cache, jl_value_t *par
             newrec->isconcretesig = 0; // Type{} may have a higher priority than DataType
         else if (decl == (jl_value_t*)jl_unionall_type)
             newrec->isconcretesig = 0; // Type{} may have a higher priority than UnionAll
+        else if (decl == (jl_value_t*)jl_uniontype_type)
+            newrec->isconcretesig = 0; // Type{} may have a higher priority than Union
         else if (jl_is_type_type(decl))
             newrec->isconcretesig = 0; // Type{} may need special processing to compute the match
         else if (jl_is_vararg_type(decl))
diff --git a/src/uv_constants.h b/src/uv_constants.h
index 569966d6ec5a2a..873e2af28b44fb 100644
--- a/src/uv_constants.h
+++ b/src/uv_constants.h
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include "uv.h"
 #define XX(uc,lc) :UV_##uc,
diff --git a/test/TestHelpers.jl b/test/TestHelpers.jl
index c7393ba0f09a8c..4f99773aa2a7ab 100644
--- a/test/TestHelpers.jl
+++ b/test/TestHelpers.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module TestHelpers
 
@@ -20,6 +20,10 @@ Base.Terminals.raw!(t::FakeTerminal, raw::Bool) = t.raw = raw
 Base.Terminals.size(t::FakeTerminal) = (24, 80)
 
 function open_fake_pty()
+    @static if Sys.iswindows()
+        error("Unable to create a fake PTY in Windows")
+    end
+
     const O_RDWR = Base.Filesystem.JL_O_RDWR
     const O_NOCTTY = Base.Filesystem.JL_O_NOCTTY
 
@@ -41,9 +45,68 @@ end
 
 function with_fake_pty(f)
     slave, master = open_fake_pty()
-    f(slave, master)
-    ccall(:close,Cint,(Cint,),slave) # XXX: this causes the kernel to throw away all unread data on the pty
-    close(master)
+    try
+        f(slave, master)
+    finally
+        ccall(:close,Cint,(Cint,),slave) # XXX: this causes the kernel to throw away all unread data on the pty
+        close(master)
+    end
+end
+
+function challenge_prompt(code::AbstractString, challenges; timeout::Integer=10, debug::Bool=true)
+    output_file = tempname()
+    wrapped_code = """
+    result = let
+        $code
+    end
+    open("$output_file", "w") do fp
+        serialize(fp, result)
+    end
+    """
+    cmd = `$(Base.julia_cmd()) --startup-file=no -e $wrapped_code`
+    try
+        challenge_prompt(cmd, challenges, timeout=timeout, debug=debug)
+        return open(output_file, "r") do fp
+            deserialize(fp)
+        end
+    finally
+        isfile(output_file) && rm(output_file)
+    end
+    return nothing
+end
+
+function challenge_prompt(cmd::Cmd, challenges; timeout::Integer=10, debug::Bool=true)
+    function format_output(output)
+        debug ? "Process output found:\n\"\"\"\n$(read(seekstart(out), String))\n\"\"\"" : ""
+    end
+    out = IOBuffer()
+    with_fake_pty() do slave, master
+        p = spawn(detach(cmd), slave, slave, slave)
+        # Kill the process if it takes too long. Typically occurs when process is waiting for input
+        @async begin
+            sleep(timeout)
+            kill(p)
+            close(master)
+        end
+        try
+            for (challenge, response) in challenges
+                process_exited(p) && error("Too few prompts. $(format_output(out))")
+
+                write(out, readuntil(master, challenge))
+                if !isopen(master)
+                    error("Could not locate challenge: \"$challenge\". $(format_output(out))")
+                end
+                write(master, response)
+            end
+            wait(p)
+        finally
+            kill(p)
+        end
+        # Determine if the process was explicitly killed
+        killed = process_exited(p) && (p.exitcode != 0 || p.termsignal != 0)
+        killed && error("Too many prompts. $(format_output(out))")
+    end
+    nothing
 end
 
 # OffsetArrays (arrays with indexing that doesn't start at 1)
@@ -63,19 +126,19 @@ struct OffsetArray{T,N,AA<:AbstractArray} <: AbstractArray{T,N}
 end
 OffsetVector{T,AA<:AbstractArray} = OffsetArray{T,1,AA}
 
-OffsetArray{T,N}(A::AbstractArray{T,N}, offsets::NTuple{N,Int}) = OffsetArray{T,N,typeof(A)}(A, offsets)
-OffsetArray{T,N}(A::AbstractArray{T,N}, offsets::Vararg{Int,N}) = OffsetArray(A, offsets)
+OffsetArray(A::AbstractArray{T,N}, offsets::NTuple{N,Int}) where {T,N} = OffsetArray{T,N,typeof(A)}(A, offsets)
+OffsetArray(A::AbstractArray{T,N}, offsets::Vararg{Int,N}) where {T,N} = OffsetArray(A, offsets)
 
-(::Type{OffsetArray{T,N}}){T,N}(inds::Indices{N}) = OffsetArray{T,N,Array{T,N}}(Array{T,N}(map(length, inds)), map(indsoffset, inds))
-(::Type{OffsetArray{T}}){T,N}(inds::Indices{N}) = OffsetArray{T,N}(inds)
+(::Type{OffsetArray{T,N}})(inds::Indices{N}) where {T,N} = OffsetArray{T,N,Array{T,N}}(Array{T,N}(map(length, inds)), map(indsoffset, inds))
+(::Type{OffsetArray{T}})(inds::Indices{N}) where {T,N} = OffsetArray{T,N}(inds)
 
-Base.IndexStyle{T<:OffsetArray}(::Type{T}) = Base.IndexStyle(parenttype(T))
-parenttype{T,N,AA}(::Type{OffsetArray{T,N,AA}}) = AA
+Base.IndexStyle(::Type{T}) where {T<:OffsetArray} = Base.IndexStyle(parenttype(T))
+parenttype(::Type{OffsetArray{T,N,AA}}) where {T,N,AA} = AA
 parenttype(A::OffsetArray) = parenttype(typeof(A))
 
 Base.parent(A::OffsetArray) = A.parent
 
-errmsg(A) = error("size not supported for arrays with indices $(indices(A)); see http://docs.julialang.org/en/latest/devdocs/offset-arrays/")
+errmsg(A) = error("size not supported for arrays with indices $(indices(A)); see https://docs.julialang.org/en/latest/devdocs/offset-arrays/")
 Base.size(A::OffsetArray) = errmsg(A)
 Base.size(A::OffsetArray, d) = errmsg(A)
 Base.eachindex(::IndexCartesian, A::OffsetArray) = CartesianRange(indices(A))
@@ -88,7 +151,7 @@ Base.eachindex(::IndexLinear, A::OffsetVector) = indices(A, 1)
 @inline Base.indices(A::OffsetArray) = _indices(indices(parent(A)), A.offsets)  # would rather use ntuple, but see #15276
 @inline _indices(inds, offsets) = (inds[1]+offsets[1], _indices(tail(inds), tail(offsets))...)
 _indices(::Tuple{}, ::Tuple{}) = ()
-Base.indices1{T}(A::OffsetArray{T,0}) = 1:1  # we only need to specialize this one
+Base.indices1(A::OffsetArray{T,0}) where {T} = 1:1  # we only need to specialize this one
 
 function Base.similar(A::OffsetArray, T::Type, dims::Dims)
     B = similar(parent(A), T, dims)
@@ -102,7 +165,7 @@ Base.similar(f::Union{Function,Type}, shape::Tuple{UnitRange,Vararg{UnitRange}})
 
 Base.reshape(A::AbstractArray, inds::Tuple{UnitRange,Vararg{UnitRange}}) = OffsetArray(reshape(A, map(length, inds)), map(indsoffset, inds))
 
-@inline function Base.getindex{T,N}(A::OffsetArray{T,N}, I::Vararg{Int,N})
+@inline function Base.getindex(A::OffsetArray{T,N}, I::Vararg{Int,N}) where {T,N}
     checkbounds(A, I...)
     @inbounds ret = parent(A)[offset(A.offsets, I)...]
     ret
@@ -119,7 +182,7 @@ end
     @inbounds ret = parent(A)[i]
     ret
 end
-@inline function Base.setindex!{T,N}(A::OffsetArray{T,N}, val, I::Vararg{Int,N})
+@inline function Base.setindex!(A::OffsetArray{T,N}, val, I::Vararg{Int,N}) where {T,N}
     checkbounds(A, I...)
     @inbounds parent(A)[offset(A.offsets, I)...] = val
     val
@@ -135,14 +198,34 @@ end
     val
 end
 
+@inline function Base.deleteat!(A::OffsetArray, i::Int)
+    checkbounds(A, i)
+    @inbounds deleteat!(parent(A), offset(A.offsets, (i,))[1])
+end
+
+@inline function Base.deleteat!(A::OffsetArray{T,N}, I::Vararg{Int, N}) where {T,N}
+    checkbounds(A, I...)
+    @inbounds deleteat!(parent(A), offset(A.offsets, I)...)
+end
+
+@inline function Base.deleteat!(A::OffsetArray, i::UnitRange{Int})
+    checkbounds(A, first(i))
+    checkbounds(A, last(i))
+    first_idx = offset(A.offsets, (first(i),))[1]
+    last_idx = offset(A.offsets, (last(i),))[1]
+    @inbounds deleteat!(parent(A), first_idx:last_idx)
+end
+
 # Computing a shifted index (subtracting the offset)
-offset{N}(offsets::NTuple{N,Int}, inds::NTuple{N,Int}) = _offset((), offsets, inds)
+offset(offsets::NTuple{N,Int}, inds::NTuple{N,Int}) where {N} = _offset((), offsets, inds)
 _offset(out, ::Tuple{}, ::Tuple{}) = out
 @inline _offset(out, offsets, inds) = _offset((out..., inds[1]-offsets[1]), Base.tail(offsets), Base.tail(inds))
 
 indsoffset(r::Range) = first(r) - 1
 indsoffset(i::Integer) = 0
 
+Base.resize!(A::OffsetVector, nl::Integer) = (resize!(A.parent, nl); A)
+
 end
 
 end
diff --git a/test/abstractarray.jl b/test/abstractarray.jl
index b97c51066b798c..5a0fc7ff2204e2 100644
--- a/test/abstractarray.jl
+++ b/test/abstractarray.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 A = rand(5,4,3)
 @testset "Bounds checking" begin
@@ -202,28 +202,28 @@ end
 T24Linear(::Type{T}, dims::Int...) where T = T24Linear(T, dims)
 T24Linear(::Type{T}, dims::NTuple{N,Int}) where {T,N} = T24Linear{T,N,dims}()
 
-Base.convert{T,N  }(::Type{T24Linear     }, X::AbstractArray{T,N}) = convert(T24Linear{T,N}, X)
-Base.convert{T,N,_}(::Type{T24Linear{T  }}, X::AbstractArray{_,N}) = convert(T24Linear{T,N}, X)
-Base.convert{T,N  }(::Type{T24Linear{T,N}}, X::AbstractArray     ) = T24Linear{T,N,size(X)}(X...)
+Base.convert(::Type{T24Linear     }, X::AbstractArray{T,N}) where {T,N  } = convert(T24Linear{T,N}, X)
+Base.convert(::Type{T24Linear{T  }}, X::AbstractArray{_,N}) where {T,N,_} = convert(T24Linear{T,N}, X)
+Base.convert(::Type{T24Linear{T,N}}, X::AbstractArray     ) where {T,N  } = T24Linear{T,N,size(X)}(X...)
 
-Base.size{T,N,dims}(::T24Linear{T,N,dims}) = dims
+Base.size(::T24Linear{T,N,dims}) where {T,N,dims} = dims
 import Base: IndexLinear
-Base.IndexStyle{A<:T24Linear}(::Type{A}) = IndexLinear()
+Base.IndexStyle(::Type{A}) where {A<:T24Linear} = IndexLinear()
 Base.getindex(A::T24Linear, i::Int) = getfield(A, i)
-Base.setindex!{T}(A::T24Linear{T}, v, i::Int) = setfield!(A, i, convert(T, v))
+Base.setindex!(A::T24Linear{T}, v, i::Int) where {T} = setfield!(A, i, convert(T, v))
 
 # A custom linear slow sparse-like array that relies upon Dict for its storage
 struct TSlow{T,N} <: AbstractArray{T,N}
     data::Dict{NTuple{N,Int}, T}
     dims::NTuple{N,Int}
 end
-TSlow{T}(::Type{T}, dims::Int...) = TSlow(T, dims)
-TSlow{T,N}(::Type{T}, dims::NTuple{N,Int}) = TSlow{T,N}(Dict{NTuple{N,Int}, T}(), dims)
+TSlow(::Type{T}, dims::Int...) where {T} = TSlow(T, dims)
+TSlow(::Type{T}, dims::NTuple{N,Int}) where {T,N} = TSlow{T,N}(Dict{NTuple{N,Int}, T}(), dims)
 
-Base.convert{T,N  }(::Type{TSlow{T,N}}, X::TSlow{T,N}) = X
-Base.convert{T,N  }(::Type{TSlow     }, X::AbstractArray{T,N}) = convert(TSlow{T,N}, X)
-Base.convert{T,N,_}(::Type{TSlow{T  }}, X::AbstractArray{_,N}) = convert(TSlow{T,N}, X)
-Base.convert{T,N  }(::Type{TSlow{T,N}}, X::AbstractArray     ) = begin
+Base.convert(::Type{TSlow{T,N}}, X::TSlow{T,N})         where {T,N  } = X
+Base.convert(::Type{TSlow     }, X::AbstractArray{T,N}) where {T,N  } = convert(TSlow{T,N}, X)
+Base.convert(::Type{TSlow{T  }}, X::AbstractArray{_,N}) where {T,N,_} = convert(TSlow{T,N}, X)
+Base.convert(::Type{TSlow{T,N}}, X::AbstractArray     ) where {T,N  } = begin
     A = TSlow(T, size(X))
     for I in CartesianRange(size(X))
         A[I.I...] = X[I.I...]
@@ -232,32 +232,32 @@ Base.convert{T,N  }(::Type{TSlow{T,N}}, X::AbstractArray     ) = begin
 end
 
 Base.size(A::TSlow) = A.dims
-Base.similar{T}(A::TSlow, ::Type{T}, dims::Dims) = TSlow(T, dims)
+Base.similar(A::TSlow, ::Type{T}, dims::Dims) where {T} = TSlow(T, dims)
 import Base: IndexCartesian
-Base.IndexStyle{A<:TSlow}(::Type{A}) = IndexCartesian()
+Base.IndexStyle(::Type{A}) where {A<:TSlow} = IndexCartesian()
 # Until #11242 is merged, we need to define each dimension independently
-Base.getindex{T}(A::TSlow{T,0}) = get(A.data, (), zero(T))
-Base.getindex{T}(A::TSlow{T,1}, i1::Int) = get(A.data, (i1,), zero(T))
-Base.getindex{T}(A::TSlow{T,2}, i1::Int, i2::Int) = get(A.data, (i1,i2), zero(T))
-Base.getindex{T}(A::TSlow{T,3}, i1::Int, i2::Int, i3::Int) =
+Base.getindex(A::TSlow{T,0}) where {T} = get(A.data, (), zero(T))
+Base.getindex(A::TSlow{T,1}, i1::Int) where {T} = get(A.data, (i1,), zero(T))
+Base.getindex(A::TSlow{T,2}, i1::Int, i2::Int) where {T} = get(A.data, (i1,i2), zero(T))
+Base.getindex(A::TSlow{T,3}, i1::Int, i2::Int, i3::Int) where {T} =
     get(A.data, (i1,i2,i3), zero(T))
-Base.getindex{T}(A::TSlow{T,4}, i1::Int, i2::Int, i3::Int, i4::Int) =
+Base.getindex(A::TSlow{T,4}, i1::Int, i2::Int, i3::Int, i4::Int) where {T} =
     get(A.data, (i1,i2,i3,i4), zero(T))
-Base.getindex{T}(A::TSlow{T,5}, i1::Int, i2::Int, i3::Int, i4::Int, i5::Int) =
+Base.getindex(A::TSlow{T,5}, i1::Int, i2::Int, i3::Int, i4::Int, i5::Int) where {T} =
     get(A.data, (i1,i2,i3,i4,i5), zero(T))
 
-Base.setindex!{T}(A::TSlow{T,0}, v) = (A.data[()] = v)
-Base.setindex!{T}(A::TSlow{T,1}, v, i1::Int) = (A.data[(i1,)] = v)
-Base.setindex!{T}(A::TSlow{T,2}, v, i1::Int, i2::Int) = (A.data[(i1,i2)] = v)
-Base.setindex!{T}(A::TSlow{T,3}, v, i1::Int, i2::Int, i3::Int) =
+Base.setindex!(A::TSlow{T,0}, v) where {T} = (A.data[()] = v)
+Base.setindex!(A::TSlow{T,1}, v, i1::Int) where {T} = (A.data[(i1,)] = v)
+Base.setindex!(A::TSlow{T,2}, v, i1::Int, i2::Int) where {T} = (A.data[(i1,i2)] = v)
+Base.setindex!(A::TSlow{T,3}, v, i1::Int, i2::Int, i3::Int) where {T} =
     (A.data[(i1,i2,i3)] = v)
-Base.setindex!{T}(A::TSlow{T,4}, v, i1::Int, i2::Int, i3::Int, i4::Int) =
+Base.setindex!(A::TSlow{T,4}, v, i1::Int, i2::Int, i3::Int, i4::Int) where {T} =
     (A.data[(i1,i2,i3,i4)] = v)
-Base.setindex!{T}(A::TSlow{T,5}, v, i1::Int, i2::Int, i3::Int, i4::Int, i5::Int) =
+Base.setindex!(A::TSlow{T,5}, v, i1::Int, i2::Int, i3::Int, i4::Int, i5::Int) where {T} =
     (A.data[(i1,i2,i3,i4,i5)] = v)
 
 const can_inline = Base.JLOptions().can_inline != 0
-function test_scalar_indexing{T}(::Type{T}, shape, ::Type{TestAbstractArray})
+function test_scalar_indexing(::Type{T}, shape, ::Type{TestAbstractArray}) where T
     N = prod(shape)
     A = reshape(collect(1:N), shape)
     B = T(A)
@@ -341,7 +341,7 @@ function test_scalar_indexing{T}(::Type{T}, shape, ::Type{TestAbstractArray})
     @test C == B == A
     C = T(Int, shape)
     i=0
-    C2 = reshape(C, Val{2})
+    C2 = reshape(C, Val(2))
     for i2 = 1:size(C2, 2)
         for i1 = 1:size(C2, 1)
             i += 1
@@ -351,7 +351,7 @@ function test_scalar_indexing{T}(::Type{T}, shape, ::Type{TestAbstractArray})
     @test C == B == A
     C = T(Int, shape)
     i=0
-    C3 = reshape(C, Val{3})
+    C3 = reshape(C, Val(3))
     for i3 = 1:size(C3, 3)
         for i2 = 1:size(C3, 2)
             for i1 = 1:size(C3, 1)
@@ -367,7 +367,7 @@ function test_scalar_indexing{T}(::Type{T}, shape, ::Type{TestAbstractArray})
     @test A == B
 end
 
-function test_vector_indexing{T}(::Type{T}, shape, ::Type{TestAbstractArray})
+function test_vector_indexing(::Type{T}, shape, ::Type{TestAbstractArray}) where T
     @testset "test_vector_indexing{$(T)}" begin
         N = prod(shape)
         A = reshape(collect(1:N), shape)
@@ -410,7 +410,7 @@ function test_vector_indexing{T}(::Type{T}, shape, ::Type{TestAbstractArray})
     end
 end
 
-function test_primitives{T}(::Type{T}, shape, ::Type{TestAbstractArray})
+function test_primitives(::Type{T}, shape, ::Type{TestAbstractArray}) where T
     N = prod(shape)
     A = reshape(collect(1:N), shape)
     B = T(A)
@@ -481,7 +481,7 @@ Base.IndexStyle(::UnimplementedSlowArray) = Base.IndexCartesian()
 
 mutable struct UnimplementedArray{T, N} <: AbstractArray{T, N} end
 
-function test_getindex_internals{T}(::Type{T}, shape, ::Type{TestAbstractArray})
+function test_getindex_internals(::Type{T}, shape, ::Type{TestAbstractArray}) where T
     N = prod(shape)
     A = reshape(collect(1:N), shape)
     B = T(A)
@@ -501,7 +501,7 @@ function test_getindex_internals(::Type{TestAbstractArray})
     @test_throws ErrorException Base.unsafe_getindex(V, 1, 1)
 end
 
-function test_setindex!_internals{T}(::Type{T}, shape, ::Type{TestAbstractArray})
+function test_setindex!_internals(::Type{T}, shape, ::Type{TestAbstractArray}) where T
     N = prod(shape)
     A = reshape(collect(1:N), shape)
     B = T(A)
@@ -616,17 +616,17 @@ end
 mutable struct TSlowNIndexes{T,N} <: AbstractArray{T,N}
     data::Array{T,N}
 end
-Base.IndexStyle{A<:TSlowNIndexes}(::Type{A}) = Base.IndexCartesian()
+Base.IndexStyle(::Type{A}) where {A<:TSlowNIndexes} = Base.IndexCartesian()
 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]
+Base.getindex(A::TSlowNIndexes{T,2}, i::Int, j::Int) where {T} = A.data[i,j]
 
 
 mutable struct GenericIterator{N} end
-Base.start{N}(::GenericIterator{N}) = 1
-Base.next{N}(::GenericIterator{N}, i) = (i, i + 1)
-Base.done{N}(::GenericIterator{N}, i) = i > N ? true : false
-Base.iteratorsize{N}(::Type{GenericIterator{N}}) = Base.SizeUnknown()
+Base.start(::GenericIterator{N}) where {N} = 1
+Base.next(::GenericIterator{N}, i) where {N} = (i, i + 1)
+Base.done(::GenericIterator{N}, i) where {N} = i > N ? true : false
+Base.iteratorsize(::Type{GenericIterator{N}}) where {N} = Base.SizeUnknown()
 
 function test_map(::Type{TestAbstractArray})
     empty_pool = WorkerPool([myid()])
@@ -836,3 +836,7 @@ end
 @testset "dispatch loop introduced in #19305" begin
     @test [(1:2) zeros(2,2); ones(3,3)] == [[1,2] zeros(2,2); ones(3,3)] == [reshape([1,2],2,1) zeros(2,2); ones(3,3)]
 end
+
+@testset "checkbounds_indices method ambiguities #20989" begin
+    @test Base.checkbounds_indices(Bool, (1:1,), ([CartesianIndex(1)],))
+end
diff --git a/test/ambiguous.jl b/test/ambiguous.jl
index fa6cc8c54e3554..3dd0c85951d59d 100644
--- a/test/ambiguous.jl
+++ b/test/ambiguous.jl
@@ -1,7 +1,7 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # DO NOT ALTER ORDER OR SPACING OF METHODS BELOW
-const lineoffset = @__LINE__ + 0 # XXX: __LINE__ at the end of a line is off-by-one
+const lineoffset = @__LINE__
 ambig(x, y) = 1
 ambig(x::Integer, y) = 2
 ambig(x, y::Integer) = 3
@@ -9,9 +9,8 @@ ambig(x::Int, y::Int) = 4
 ambig(x::Number, y) = 5
 # END OF LINE NUMBER SENSITIVITY
 
-const curmod = current_module()
-const curmod_name = fullname(curmod)
-const curmod_str = curmod === Main ? "Main" : join(curmod_name, ".")
+# For curmod_*
+include("testenv.jl")
 
 ambigs = Any[[], [3], [2,5], [], [3]]
 
@@ -60,6 +59,8 @@ let err = try
                            startswith(str, "  ambig(x::Integer, y) in $curmod_str at")
     @test ambig_checkline(lines[2])
     @test ambig_checkline(lines[3])
+    @test lines[4] == "Possible fix, define"
+    @test lines[5] == "  ambig(::Integer, ::Integer)"
 end
 
 ## Other ways of accessing functions
@@ -84,6 +85,16 @@ cfunction(ambig, Int, (UInt8, Int))  # test for a crash (doesn't throw an error)
 ambig(x, y::Integer) = 3
 @test_throws MethodError ambig(2, 0x03)
 
+# Method overwriting by an ambiguity should also invalidate the method cache (#21963)
+ambig(x::Union{Char, Int8}) = 'r'
+@test ambig('c') == 'r'
+@test ambig(Int8(1)) == 'r'
+@test_throws MethodError ambig(Int16(1))
+ambig(x::Union{Char, Int16}) = 's'
+@test_throws MethodError ambig('c')
+@test ambig(Int8(1)) == 'r'
+@test ambig(Int16(1)) == 's'
+
 # Automatic detection of ambiguities
 module Ambig1
 ambig(x, y) = 1
@@ -133,9 +144,10 @@ ambs = detect_ambiguities(Ambig5)
 @test length(ambs) == 2
 
 # Test that Core and Base are free of ambiguities
-# TODO jb/subtype: we now detect a lot more
-@test_broken detect_ambiguities(Core, Base; imported=true) == []
 # not using isempty so this prints more information when it fails
+@test detect_ambiguities(Core, Base; imported=true, ambiguous_bottom=false) == []
+# some ambiguities involving Union{} type parameters are expected, but not required
+@test !isempty(detect_ambiguities(Core, Base; imported=true, ambiguous_bottom=true))
 
 amb_1(::Int8, ::Int) = 1
 amb_1(::Integer, x) = 2
@@ -169,8 +181,8 @@ let ms = methods(amb_4).ms
     @test Base.isambiguous(ms[3], ms[4])
 end
 
-g16493{T<:Number}(x::T, y::Integer) = 0
-g16493{T}(x::Complex{T}, y) = 1
+g16493(x::T, y::Integer) where {T<:Number} = 0
+g16493(x::Complex{T}, y) where {T} = 1
 let ms = methods(g16493, (Complex, Any))
     @test length(ms) == 1
     @test first(ms).sig == (Tuple{typeof(g16493), Complex{T}, Any} where T)
@@ -179,8 +191,8 @@ end
 # issue #17350
 module Ambig6
 struct ScaleMinMax{To,From} end
-map1{To<:Union{Float32,Float64},From<:Real}(mapi::ScaleMinMax{To,From}, val::From) = 1
-map1{To<:Union{Float32,Float64},From<:Real}(mapi::ScaleMinMax{To,From}, val::Union{Real,Complex}) = 2
+map1(mapi::ScaleMinMax{To,From}, val::From) where {To<:Union{Float32,Float64},From<:Real} = 1
+map1(mapi::ScaleMinMax{To,From}, val::Union{Real,Complex}) where {To<:Union{Float32,Float64},From<:Real} = 2
 end
 
 @test isempty(detect_ambiguities(Ambig6))
@@ -197,17 +209,17 @@ struct MyArray{T,N} <: AbstractArray{T,N}
     data::Array{T,N}
 end
 
-foo{T,N}(::Type{Array{T,N}}, A::MyArray{T,N}) = A.data
-foo{T<:AbstractFloat,N}(::Type{Array{T,N}}, A::MyArray{T,N}) = A.data
-foo{S<:AbstractFloat,N,T<:AbstractFloat}(::Type{Array{S,N}}, A::AbstractArray{T,N}) = copy!(Array{S}(size(A)), A)
-foo{S<:AbstractFloat,N,T<:AbstractFloat}(::Type{Array{S,N}}, A::MyArray{T,N}) = copy!(Array{S}(size(A)), A.data)
+foo(::Type{Array{T,N}}, A::MyArray{T,N}) where {T,N} = A.data
+foo(::Type{Array{T,N}}, A::MyArray{T,N}) where {T<:AbstractFloat,N} = A.data
+foo(::Type{Array{S,N}}, A::AbstractArray{T,N}) where {S<:AbstractFloat,N,T<:AbstractFloat} = copy!(Array{S}(size(A)), A)
+foo(::Type{Array{S,N}}, A::MyArray{T,N}) where {S<:AbstractFloat,N,T<:AbstractFloat} = copy!(Array{S}(size(A)), A.data)
 end
 
 @test isempty(detect_ambiguities(Ambig17648))
 
 module Ambig8
 using Base: DimsInteger, Indices
-g18307{T<:Integer}(::Union{Indices,Dims}, I::AbstractVector{T}...) = 1
+g18307(::Union{Indices,Dims}, I::AbstractVector{T}...) where {T<:Integer} = 1
 g18307(::DimsInteger) = 2
 g18307(::DimsInteger, I::Integer...) = 3
 end
@@ -222,4 +234,15 @@ catch err
     end
 end
 
+module Ambig9
+f(x::Complex{<:Integer}) = 1
+f(x::Complex{<:Rational}) = 2
+end
+@test !Base.isambiguous(methods(Ambig9.f)..., ambiguous_bottom=false)
+@test Base.isambiguous(methods(Ambig9.f)..., ambiguous_bottom=true)
+@test !Base.isambiguous(methods(Ambig9.f)...)
+@test length(detect_ambiguities(Ambig9, ambiguous_bottom=false)) == 0
+@test length(detect_ambiguities(Ambig9, ambiguous_bottom=true)) == 1
+@test length(detect_ambiguities(Ambig9)) == 0
+
 nothing # don't return a module from the remote include
diff --git a/test/arrayops.jl b/test/arrayops.jl
index a0248d8a47e661..f03d310a9504aa 100644
--- a/test/arrayops.jl
+++ b/test/arrayops.jl
@@ -1,6 +1,8 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Array test
+isdefined(Main, :TestHelpers) || @eval Main include("TestHelpers.jl")
+using TestHelpers.OAs
 
 @testset "basics" begin
     @test length([1, 2, 3]) == 3
@@ -14,31 +16,31 @@
     @test length((1,)) == 1
     @test length((1,2)) == 2
 
-    @test isequal(1.+[1,2,3], [2,3,4])
-    @test isequal([1,2,3].+1, [2,3,4])
-    @test isequal(1.-[1,2,3], [0,-1,-2])
-    @test isequal([1,2,3].-1, [0,1,2])
+    @test isequal(1 .+ [1,2,3], [2,3,4])
+    @test isequal([1,2,3] .+ 1, [2,3,4])
+    @test isequal(1 .- [1,2,3], [0,-1,-2])
+    @test isequal([1,2,3] .- 1, [0,1,2])
 
     @test isequal(5*[1,2,3], [5,10,15])
     @test isequal([1,2,3]*5, [5,10,15])
-    @test isequal(1./[1,2,5], [1.0,0.5,0.2])
+    @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(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(-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)
-    @test isequal(1.<<1, 2)
-    @test isequal([1,2,5].<<[1,2,5], [2,8,160])
-    @test isequal([10,20,50].>>[1,2,5], [5,5,1])
+    @test isequal(1 .<< [1,2,5], [2,4,32])
+    @test isequal(128 .>> [1,2,5], [64,32,4])
+    @test isequal(2 .>> 1, 1)
+    @test isequal(1 .<< 1, 2)
+    @test isequal([1,2,5] .<< [1,2,5], [2,8,160])
+    @test isequal([10,20,50] .>> [1,2,5], [5,5,1])
 
 
     a = ones(2,2)
@@ -105,6 +107,7 @@ end
         @test_throws MethodError convert(Array{Int,2}, r)
         @test convert(Array{Int}, r) == [2,3,4]
         @test Base.unsafe_convert(Ptr{Int}, r) == Base.unsafe_convert(Ptr{Int}, s)
+        @test isa(r, StridedArray)  # issue #22411
     end
     @testset "linearslow" begin
         s = view(a, :, [2,3,5])
@@ -127,12 +130,12 @@ end
         @test length(reshape(s, length(s))) == 0
     end
 end
-@testset "reshape(a, Val{N})" begin
+@testset "reshape(a, Val(N))" begin
     a = ones(Int,3,3)
     s = view(a, 1:2, 1:2)
     for N in (1,3)
-        @test isa(reshape(a, Val{N}), Array{Int,N})
-        @test isa(reshape(s, Val{N}), Base.ReshapedArray{Int,N})
+        @test isa(reshape(a, Val(N)), Array{Int,N})
+        @test isa(reshape(s, Val(N)), Base.ReshapedArray{Int,N})
     end
 end
 @testset "reshape with colon" begin
@@ -221,7 +224,7 @@ end
     @test A[2:6] == [2:6;]
     @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 reshape(A, Val{2})[:,3:9] == reshape(11:45,5,7)
+    @test reshape(A, Val(2))[:,3:9] == reshape(11:45,5,7)
     rng = (2,2:3,2:2:5)
     tmp = zeros(Int,map(maximum,rng)...)
     tmp[rng...] = A[rng...]
@@ -255,12 +258,35 @@ end
     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(reshape(1:27, 3, 3, 3), Val{2})[1,:], [1,  4,  7,  10,  13,  16,  19,  22,  25])
+    @test isequal(reshape(reshape(1:27, 3, 3, 3), Val(2))[1,:], [1,  4,  7,  10,  13,  16,  19,  22,  25])
 
     a = [3, 5, -7, 6]
     b = [4, 6, 2, -7, 1]
     ind = findin(a, b)
     @test ind == [3,4]
+    @test findin(a, Int[]) == Int[]
+    @test findin(Int[], a) == Int[]
+
+    a = [1,2,3,4,5]
+    b = [2,3,4,6]
+    @test findin(a, b) == [2,3,4]
+    @test findin(b, a) == [1,2,3]
+    @test findin(a, Int[]) == Int[]
+    @test findin(Int[], a) == Int[]
+
+    a = collect(1:3:15)
+    b = collect(2:4:10)
+    @test findin(a, b) == [4]
+    @test findin([a[1:4]; a[4:end]], b) == [4,5]
+
+    @test findin([1.0, NaN, 2.0], NaN) == [2]
+    @test findin([1.0, 2.0, NaN], NaN) == [3]
+
+    @testset "findin for uncomparable element types" begin
+        a = [1 + 1im, 1 - 1im]
+        @test findin(a, 1 + 1im) == [1]
+        @test findin(a, a)       == [1,2]
+    end
 
     rt = Base.return_types(setindex!, Tuple{Array{Int32, 3}, UInt8, Vector{Int}, Int16, UnitRange{Int}})
     @test length(rt) == 1 && rt[1] == Array{Int32, 3}
@@ -790,6 +816,11 @@ end
     R = repeat(1:2, inner=(3,), outer=(2,))
     @test R == [1, 1, 1, 2, 2, 2, 1, 1, 1, 2, 2, 2]
 
+    # Arrays of arrays
+    @test repeat([[1], [2]], inner=2) == [[1], [1], [2], [2]]
+    @test repeat([[1], [2]], outer=2) == [[1], [2], [1], [2]]
+    @test repeat([[1], [2]], inner=2, outer=2) == [[1], [1], [2], [2], [1], [1], [2], [2]]
+
     @test size(repeat([1], inner=(0,))) == (0,)
     @test size(repeat([1], outer=(0,))) == (0,)
     @test size(repeat([1 1], inner=(0, 1))) == (0, 2)
@@ -834,6 +865,8 @@ end
     @test isequal(c[1,:], cv2)
     @test isequal(c[3,:], cv)
     @test isequal(c[:,4], [2.0,2.0,2.0,2.0]*1000)
+
+    @test repeat(BitMatrix(eye(2)), inner = (2,1), outer = (1,2)) == repeat(eye(2), inner = (2,1), outer = (1,2))
 end
 
 @testset "indexing with bools" begin
@@ -949,6 +982,14 @@ end
     m = mapslices(x->fill!(x, 0), o, 2)
     @test m == zeros(3, 4)
     @test o == ones(3, 4)
+
+    # issue #18524
+    m = mapslices(x->tuple(x), [1 2; 3 4], 1)
+    @test m[1,1] == ([1,3],)
+    @test m[1,2] == ([2,4],)
+
+    # issue #21123
+    @test mapslices(nnz, speye(3), 1) == [1 1 1]
 end
 
 @testset "single multidimensional index" begin
@@ -1004,11 +1045,6 @@ end
     @test m == zeros(3, 4)
     @test o == ones(3, 4)
 
-    # issue #18524
-    m = mapslices(x->tuple(x), [1 2; 3 4], 1)
-    @test m[1,1] == ([1,3],)
-    @test m[1,2] == ([2,4],)
-
     asr = sortrows(a, rev=true)
     @test lexless(asr[2,:],asr[1,:])
     @test lexless(asr[3,:],asr[2,:])
@@ -1076,6 +1112,35 @@ end
     end
 end
 
+@testset "filter!" begin
+    # base case w/ Vector
+    a = collect(1:10)
+    filter!(x -> x > 5, a)
+    @test a == collect(6:10)
+
+    # different subtype of AbstractVector
+    ba = rand(10) .> 0.5
+    @test isa(ba, BitArray)
+    filter!(x -> x, ba)
+    @test all(ba)
+
+    # empty array
+    ea = []
+    filter!(x -> x > 5, ea)
+    @test isempty(ea)
+
+    # non-1-indexed array
+    oa = OffsetArray(collect(1:10), -5)
+    filter!(x -> x > 5, oa)
+    @test oa == OffsetArray(collect(6:10), -5)
+
+    # empty non-1-indexed array
+    eoa = OffsetArray([], -5)
+    filter!(x -> x > 5, eoa)
+    @test isempty(eoa)
+end
+
+
 @testset "deleteat!" begin
     for idx in Any[1, 2, 5, 9, 10, 1:0, 2:1, 1:1, 2:2, 1:2, 2:4, 9:8, 10:9, 9:9, 10:10,
                    8:9, 9:10, 6:9, 7:10]
@@ -1123,8 +1188,8 @@ end
             @test [1,2] ⊙ [3,4] == 11
         end
 
-        @test_throws DomainError (10.^[-1])[1] == 0.1
-        @test (10.^[-1.])[1] == 0.1
+        @test_throws DomainError (10 .^ [-1])[1] == 0.1
+        @test (10 .^ [-1.])[1] == 0.1
     end
 end
 
@@ -1187,9 +1252,6 @@ A = [[i i; i i] for i=1:2]
 @test cumsum(A) == Any[[1 1; 1 1], [3 3; 3 3]]
 @test cumprod(A) == Any[[1 1; 1 1], [4 4; 4 4]]
 
-isdefined(Main, :TestHelpers) || @eval Main include("TestHelpers.jl")
-using TestHelpers.OAs
-
 @testset "prepend/append" begin
     # PR #4627
     A = [1,2]
@@ -1417,11 +1479,11 @@ end
         @test a[:, [CartesianIndex()], :, :] == (@view a[:, [CartesianIndex()], :, :]) == reshape(a, 3, 1, 4, 5)
         @test a[:, :, [CartesianIndex()], :] == (@view a[:, :, [CartesianIndex()], :]) == reshape(a, 3, 4, 1, 5)
         @test a[:, :, :, [CartesianIndex()]] == (@view a[:, :, :, [CartesianIndex()]]) == reshape(a, 3, 4, 5, 1)
-        a2 = reshape(a, Val{2})
+        a2 = reshape(a, Val(2))
         @test a2[[CartesianIndex()], :, :]   == (@view a2[[CartesianIndex()], :, :])   == reshape(a, 1, 3, 20)
         @test a2[:, [CartesianIndex()], :]   == (@view a2[:, [CartesianIndex()], :])   == reshape(a, 3, 1, 20)
         @test a2[:, :, [CartesianIndex()]]   == (@view a2[:, :, [CartesianIndex()]])   == reshape(a, 3, 20, 1)
-        a1 = reshape(a, Val{1})
+        a1 = reshape(a, Val(1))
         @test a1[[CartesianIndex()], :]      == (@view a1[[CartesianIndex()], :])      == reshape(a, 1, 60)
         @test a1[:, [CartesianIndex()]]      == (@view a1[:, [CartesianIndex()]])      == reshape(a, 60, 1)
 
@@ -1487,9 +1549,10 @@ end
     @test a[1,2] == 7
     @test 2*CartesianIndex{3}(1,2,3) == CartesianIndex{3}(2,4,6)
 
-    R = CartesianRange(CartesianIndex{2}(2,3),CartesianIndex{2}(5,5))
+    R = CartesianRange(2:5, 3:5)
     @test eltype(R) <: CartesianIndex{2}
     @test eltype(typeof(R)) <: CartesianIndex{2}
+    @test eltype(CartesianRange{2}) <: CartesianIndex{2}
     indexes = collect(R)
     @test indexes[1] == CartesianIndex{2}(2,3)
     @test indexes[2] == CartesianIndex{2}(3,3)
@@ -1511,10 +1574,15 @@ end
     @test @inferred(convert(NTuple{2,UnitRange}, R)) === (2:5, 3:5)
     @test @inferred(convert(Tuple{Vararg{UnitRange}}, R)) === (2:5, 3:5)
 
-    @test CartesianRange((3:5,-7:7)) == CartesianRange(CartesianIndex{2}(3,-7),CartesianIndex{2}(5,7))
-    @test CartesianRange((3,-7:7)) == CartesianRange(CartesianIndex{2}(3,-7),CartesianIndex{2}(3,7))
+    @test CartesianRange((3:5,-7:7)) == CartesianRange(3:5,-7:7)
+    @test CartesianRange((3,-7:7)) == CartesianRange(3:3,-7:7)
 end
 
+# All we really care about is that we have an optimized
+# implementation, but the seed is a useful way to check that.
+@test hash(CartesianIndex()) == Base.IteratorsMD.cartindexhash_seed
+@test hash(CartesianIndex(1, 2)) != hash((1, 2))
+
 @testset "itr, start, done, next" begin
     r = 2:3
     itr = eachindex(r)
@@ -1638,16 +1706,16 @@ module RetTypeDecl
     struct MeterUnits{T,P} <: Number
         val::T
     end
-    MeterUnits{T}(val::T, pow::Int) = MeterUnits{T,pow}(val)
+    MeterUnits(val::T, pow::Int) where {T} = MeterUnits{T,pow}(val)
 
     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,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)
-    broadcast{T}(::typeof(*), x::MeterUnits{T,1}, y::MeterUnits{T,1}) = MeterUnits{T,2}(x.val*y.val)
-    convert{T,pow}(::Type{MeterUnits{T,pow}}, y::Real) = MeterUnits{T,pow}(convert(T,y))
+    (+)(x::MeterUnits{T,pow}, y::MeterUnits{T,pow}) where {T,pow} = MeterUnits{T,pow}(x.val+y.val)
+    (*)(x::Int, y::MeterUnits{T,pow}) where {T,pow} = MeterUnits{typeof(x*one(T)),pow}(x*y.val)
+    (*)(x::MeterUnits{T,1}, y::MeterUnits{T,1}) where {T} = MeterUnits{T,2}(x.val*y.val)
+    broadcast(::typeof(*), x::MeterUnits{T,1}, y::MeterUnits{T,1}) where {T} = MeterUnits{T,2}(x.val*y.val)
+    convert(::Type{MeterUnits{T,pow}}, y::Real) where {T,pow} = MeterUnits{T,pow}(convert(T,y))
 
     @test @inferred(m+[m,m]) == [m+m,m+m]
     @test @inferred([m,m]+m) == [m+m,m+m]
@@ -1682,7 +1750,7 @@ struct LinSlowMatrix{T} <: DenseArray{T,2}
 end
 
 # This is the default, but just to be sure
-Base.IndexStyle{A<:LinSlowMatrix}(::Type{A}) = Base.IndexCartesian()
+Base.IndexStyle(::Type{A}) where {A<:LinSlowMatrix} = Base.IndexCartesian()
 
 Base.size(A::LinSlowMatrix) = size(A.data)
 
@@ -2022,6 +2090,28 @@ end
     @test accumulate(op, [10 20 30], 2) == [10 op(10, 20) op(op(10, 20), 30)] == [10 40 110]
 end
 
+struct F21666{T <: Base.TypeArithmetic}
+    x::Float32
+end
+
+Base.TypeArithmetic(::Type{F21666{T}}) where {T} = T()
+Base.:+(x::F, y::F) where {F <: F21666} = F(x.x + y.x)
+Base.convert(::Type{Float64}, x::F21666) = Float64(x.x)
+@testset "Exactness of cumsum # 21666" begin
+    # test that cumsum uses more stable algorithm
+    # for types with unknown/rounding arithmetic
+    # we make v pretty large, because stable algorithm may have a large base case
+    v = zeros(300); v[1] = 2; v[200:end] = eps(Float32)
+
+    f_rounds = Float64.(cumsum(F21666{Base.ArithmeticRounds}.(v)))
+    f_unknown = Float64.(cumsum(F21666{Base.ArithmeticUnknown}.(v)))
+    f_truth = cumsum(v)
+    f_inexact = Float64.(accumulate(+, Float32.(v)))
+    @test f_rounds == f_unknown
+    @test f_rounds != f_inexact
+    @test norm(f_truth - f_rounds) < norm(f_truth - f_inexact)
+end
+
 @testset "zeros and ones" begin
     @test ones([1,2], Float64, (2,3)) == ones(2,3)
     @test ones(2) == ones(Int, 2) == ones([2,3], Float32, 2) ==  [1,1]
@@ -2049,12 +2139,11 @@ end
     zs = zeros(SparseMatrixCSC([1 2; 3 4]), Complex{Float64}, (2,3))
     test_zeros(zs, SparseMatrixCSC{Complex{Float64}}, (2, 3))
 
-    @testset "#19265" begin
-        @test_throws MethodError zeros(Float64, [1.])
-        x = [1.]
-        test_zeros(zeros(x, Float64), Vector{Float64}, (1,))
-        @test x == [1.]
-    end
+    # #19265"
+    @test_throws ErrorException zeros(Float64, [1.]) # TODO change to MethodError, when v0.6 deprecations are done
+    x = [1.]
+    test_zeros(zeros(x, Float64), Vector{Float64}, (1,))
+    @test x == [1.]
 
     # exotic indexing
     oarr = zeros(randn(3), UInt16, 1:3, -1:0)
@@ -2069,3 +2158,29 @@ end
 Base.:*(a::T11053, b::Real) = T11053(a.a*b)
 Base.:(==)(a::T11053, b::T11053) = a.a == b.a
 @test [T11053(1)] * 5 == [T11053(1)] .* 5 == [T11053(5.0)]
+
+#15907
+@test typeof(Array{Int,0}()) == Array{Int,0}
+
+# check a == b for arrays of Union type (#22403)
+let TT = Union{UInt8, Int8}
+    a = TT[0x0, 0x1]
+    b = TT[0x0, 0x0]
+    pa = pointer(a)
+    pb = pointer(b)
+    resize!(a, 1) # sets a[2] = 0
+    resize!(b, 1)
+    @assert pointer(a) == pa
+    @assert pointer(b) == pb
+    unsafe_store!(pa, 0x1, 2) # reset a[2] to 1
+    @test length(a) == length(b) == 1
+    @test a[1] == b[1] == 0x0
+    @test a == b
+end
+
+let a = Vector{Int}[[1]],
+    b = Vector{Float64}[[2.0]],
+    c = Vector{Char}[['a']]
+    @test eltype([a;b]) == Vector{Float64}
+    @test eltype([a;c]) == Vector
+end
diff --git a/test/asmvariant.jl b/test/asmvariant.jl
index bf1b9116d37e09..27209997511c81 100644
--- a/test/asmvariant.jl
+++ b/test/asmvariant.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base.Test
 
diff --git a/test/backtrace.jl b/test/backtrace.jl
index 8fbcf9003dea34..c0ffa9a915c7ca 100644
--- a/test/backtrace.jl
+++ b/test/backtrace.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 bt = backtrace()
 have_backtrace = false
@@ -26,12 +26,15 @@ end
 
 # same-file inline
 eval(Expr(:function, Expr(:call, :test_inline_1),
-          Expr(:block, Expr(:line, 42, Symbol("backtrace.jl")),
-                       Expr(:block, Expr(:meta, :push_loc, Symbol("backtrace.jl"), :inlfunc),
+          Expr(:block, Expr(:line, 99, Symbol("backtrace.jl")),
+                       Expr(:block, Expr(:line, 42),
+                                    Expr(:meta, :push_loc, Symbol("backtrace.jl"), :inlfunc),
                                     Expr(:line, 37),
                                     Expr(:call, :throw, "foo"),
-                                    Expr(:meta, :pop_loc)))))
+                                    Expr(:meta, :pop_loc),
+                                    Expr(:line, 99)))))
 
+@test functionloc(test_inline_1) == ("backtrace.jl", 99)
 try
     test_inline_1()
     error("unexpected")
@@ -46,14 +49,16 @@ catch err
 end
 
 # different-file inline
-const absfilepath = is_windows() ? "C:\\foo\\bar\\baz.jl" : "/foo/bar/baz.jl"
+const absfilepath = Sys.iswindows() ? "C:\\foo\\bar\\baz.jl" : "/foo/bar/baz.jl"
 eval(Expr(:function, Expr(:call, :test_inline_2),
-          Expr(:block, Expr(:line, 99, Symbol("backtrace.jl")),
+          Expr(:block, Expr(:line, 81, Symbol("backtrace.jl")),
                        Expr(:block, Expr(:meta, :push_loc, Symbol(absfilepath)),
                                     Expr(:line, 111),
                                     Expr(:call, :throw, "foo"),
-                                    Expr(:meta, :pop_loc)))))
+                                    Expr(:meta, :pop_loc),
+                                    Expr(:line, 99)))))
 
+@test functionloc(test_inline_2) == ("backtrace.jl", 81)
 try
     test_inline_2()
     error("unexpected")
@@ -61,7 +66,7 @@ catch err
     lkup = get_bt_frames(:test_inline_2, catch_backtrace())
     @test length(lkup) == 2
     @test endswith(string(lkup[2].file), "backtrace.jl")
-    @test lkup[2].line == 99
+    @test lkup[2].line == 81
     @test string(lkup[1].file) == absfilepath
     @test lkup[1].line == 111
 end
diff --git a/test/base64.jl b/test/base64.jl
index 1055cc1c302f90..e36fbae6bb491a 100644
--- a/test/base64.jl
+++ b/test/base64.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 const inputText = "Man is distinguished, not only by his reason, but by this singular passion from other animals, which is a lust of the mind, that by a perseverance of delight in the continued and indefatigable generation of knowledge, exceeds the short vehemence of any carnal pleasure."
 const encodedMaxLine76 =
@@ -18,7 +18,7 @@ end
 
 open(fname, "r") do f
     ipipe = Base64DecodePipe(f)
-    @test readstring(ipipe) == inputText
+    @test read(ipipe, String) == inputText
     @test close(ipipe) === nothing
 end
 rm(fname)
@@ -28,16 +28,19 @@ rm(fname)
 
 # Decode with max line chars = 76 and padding
 ipipe = Base64DecodePipe(IOBuffer(encodedMaxLine76))
-@test readstring(ipipe) == inputText
+@test read(ipipe, String) == inputText
 
 # Decode with max line chars = 76 and no padding
 ipipe = Base64DecodePipe(IOBuffer(encodedMaxLine76[1:end-1]))
-@test readstring(ipipe) == inputText
+@test read(ipipe, String) == inputText
 
 # Decode with two padding characters ("==")
 ipipe = Base64DecodePipe(IOBuffer(string(encodedMaxLine76[1:end-2],"==")))
-@test readstring(ipipe) == inputText[1:end-1]
+@test read(ipipe, String) == inputText[1:end-1]
 
 # Test incorrect format
 ipipe = Base64DecodePipe(IOBuffer(encodedMaxLine76[1:end-3]))
-@test_throws ArgumentError readstring(ipipe)
+@test_throws ArgumentError read(ipipe, String)
+
+# issue #21314
+@test base64decode(chomp("test")) == base64decode("test")
diff --git a/test/bigfloat.jl b/test/bigfloat.jl
index 64b09a7c4de588..4966c1b7a1c6e8 100644
--- a/test/bigfloat.jl
+++ b/test/bigfloat.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 @test big(2.0)^big(3) == 8
 
@@ -7,5 +7,10 @@ for T in [Int8, UInt8, Int16, UInt16, Int32, UInt32, Int64, UInt64, Int128, UInt
     @test big(2.0)^T(3) == 8
 end
 
+for x in (2f0, pi, 7.8, big(e))
+    @test big(typeof(x)) == typeof(big(x))
+    @test big(typeof(complex(x, x))) == typeof(big(complex(x, x)))
+end
+
 # issue 15659
 @test (setprecision(53) do; big(1/3); end) < 1//3
diff --git a/test/bigint.jl b/test/bigint.jl
index aecb932708f756..341d692bf4d2a4 100644
--- a/test/bigint.jl
+++ b/test/bigint.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 a = parse(BigInt,"123456789012345678901234567890")
 b = parse(BigInt,"123456789012345678901234567891")
@@ -57,6 +57,10 @@ end
 
 @test typeof(BigInt(BigInt(1))) == BigInt
 
+for x in (Int16(0), 1, 3//4, big(5//6), big(9))
+    @test big(typeof(x)) == typeof(big(x))
+    @test big(typeof(complex(x, x))) == typeof(big(complex(x, x)))
+end
 
 # Signed addition
 @test a+Int8(1) == b
@@ -274,15 +278,20 @@ ndigits_mismatch(n) = ndigits(n) != ndigits(BigInt(n))
 @test !any(ndigits_mismatch, 8192:9999)
 
 # The following should not crash (#16579)
-ndigits(rand(big.(-999:999)), rand(63:typemax(Int)))
-ndigits(rand(big.(-999:999)), big(2)^rand(2:999))
+ndigits(big(rand(Int)), rand(63:typemax(Int)))
+ndigits(big(rand(Int)), big(2)^rand(2:999))
 
-for i in big.([-20:-1;1:20])
-    for b in -10:1
-        @test_throws DomainError ndigits(i, b)
+for x in big.([-20:20; rand(Int)])
+    for b in -1:1
+        @test_throws DomainError ndigits(x, b)
     end
 end
 
+@test Base.ndigits0zpb(big(0), big(rand(2:100))) == 0
+
+# digits with BigInt bases (#16844)
+@test digits(big(2)^256, big(2)^128) == [0, 0, 1]
+
 # conversion from float
 @test BigInt(2.0) == BigInt(2.0f0) == BigInt(big(2.0)) == 2
 @test_throws InexactError convert(BigInt, 2.1)
@@ -333,6 +342,12 @@ let padding = 4, low = big(4), high = big(2^20)
     @test hex(-high, padding) == "-100000"
 end
 
+# respect 0-padding on big(0)
+for f in (bin, oct, dec, hex)
+    @test f(big(0), 0) == ""
+end
+@test base(rand(2:62), big(0), 0) == ""
+
 @test isqrt(big(4)) == 2
 @test isqrt(big(5)) == 2
 
diff --git a/test/bitarray.jl b/test/bitarray.jl
index 8fa43dde997938..b1b5655e0d4598 100644
--- a/test/bitarray.jl
+++ b/test/bitarray.jl
@@ -1,14 +1,11 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
-module BitArrayTests
-
-using Base.Test
 using Base: findprevnot, findnextnot
 
-tc{N}(r1::NTuple{N,Any}, r2::NTuple{N,Any}) = all(x->tc(x...), [zip(r1,r2)...])
-tc{N}(r1::BitArray{N}, r2::Union{BitArray{N},Array{Bool,N}}) = true
+tc(r1::NTuple{N,Any}, r2::NTuple{N,Any}) where {N} = all(x->tc(x...), [zip(r1,r2)...])
+tc(r1::BitArray{N}, r2::Union{BitArray{N},Array{Bool,N}}) where {N} = true
 tc(r1::RowVector{Bool,BitVector}, r2::Union{RowVector{Bool,BitVector},RowVector{Bool,Vector{Bool}}}) = true
-tc{T}(r1::T, r2::T) = true
+tc(r1::T, r2::T) where {T} = true
 tc(r1,r2) = false
 
 bitcheck(b::BitArray) = Base._check_bitarray_consistency(b)
@@ -143,6 +140,10 @@ timesofar("conversions")
         @check_bit_operation reshape(b1, (n2,n1)) BitMatrix
         @test_throws DimensionMismatch reshape(b1, (1,n1))
 
+        @test @inferred(reshape(b1, n1*n2)) == @inferred(reshape(b1, (n1*n2,))) == @inferred(reshape(b1, Val(1))) == @inferred(reshape(b1, :))
+        @test @inferred(reshape(b1, n1, n2)) === @inferred(reshape(b1, Val(2))) === b1
+        @test @inferred(reshape(b1, n2, :)) == @inferred(reshape(b1, (n2, n1))) != @inferred(reshape(b1, Val(2)))
+
         b1 = bitrand(s1, s2, s3, s4)
         @check_bit_operation reshape(b1, (s3,s1,s2,s4)) BitArray{4}
         @test_throws DimensionMismatch reshape(b1, (1,n1))
@@ -231,7 +232,9 @@ timesofar("constructors")
             x = rand(Bool)
             @check_bit_operation setindex!(b1, x, 1:j) T
             b2 = bitrand(j)
-            @check_bit_operation setindex!(b1, b2, 1:j) T
+            for bb in (b2, view(b2, 1:j), view(Array{Any}(b2), :))
+                @check_bit_operation setindex!(b1, bb, 1:j) T
+            end
             x = rand(Bool)
             @check_bit_operation setindex!(b1, x, j+1:l) T
             b2 = bitrand(l-j)
@@ -381,7 +384,9 @@ timesofar("constructors")
 
         for (b2, k1, k2) in Channel(gen_setindex_data)
             # println(typeof(b2), " ", typeof(k1), " ", typeof(k2)) # uncomment to debug
-            @check_bit_operation setindex!(b1, b2, k1, k2) BitMatrix
+            for bb in ((b2 isa AbstractArray) ? (b2, view(b2, :), view(Array{Any}(b2), :)) : (b2,))
+                @check_bit_operation setindex!(b1, bb, k1, k2) BitMatrix
+            end
         end
 
         m1, m2 = rand_m1m2()
@@ -1459,5 +1464,3 @@ end
 end
 
 timesofar("I/O")
-
-end # module
diff --git a/test/boundscheck.jl b/test/boundscheck.jl
index 80181e21f734dd..a1ca1b8051536a 100644
--- a/test/boundscheck.jl
+++ b/test/boundscheck.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # run boundscheck tests on separate workers launched with --check-bounds={default,yes,no}
 
diff --git a/test/boundscheck_exec.jl b/test/boundscheck_exec.jl
index da04b49b9e60e9..df2deea73cb519 100644
--- a/test/boundscheck_exec.jl
+++ b/test/boundscheck_exec.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module TestBoundsCheck
 
@@ -204,9 +204,19 @@ function V1()
 end
 
 if bc_opt == bc_default || bc_opt == bc_off
-    @test V1() == nothing
+    @test V1() === nothing
 else
     @test_throws BoundsError V1()
 end
 
+# This tests both the bounds check elision and the behavior of `jl_array_isassigned`
+# For `isbits` array the `ccall` should return a constant `true` and does not access
+# the array
+inbounds_isassigned(a, i) = @inbounds return isassigned(a, i)
+if bc_opt == bc_default || bc_opt == bc_off
+    @test inbounds_isassigned(Int[], 2) == true
+else
+    @test inbounds_isassigned(Int[], 2) == false
+end
+
 end
diff --git a/test/broadcast.jl b/test/broadcast.jl
index 324fa60d8666bc..aa84edb2c700fa 100644
--- a/test/broadcast.jl
+++ b/test/broadcast.jl
@@ -1,23 +1,23 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 module TestBroadcastInternals
 
 using Base.Broadcast: broadcast_indices, check_broadcast_indices,
-                      check_broadcast_shape, newindex, _bcs, _bcsm
+                      check_broadcast_shape, newindex, _bcs
 using Base: Test, OneTo
 
-@test @inferred(_bcs((), (3,5), (3,5))) == (3,5)
-@test @inferred(_bcs((), (3,1), (3,5))) == (3,5)
-@test @inferred(_bcs((), (3,),  (3,5))) == (3,5)
-@test @inferred(_bcs((), (3,5), (3,)))  == (3,5)
-@test_throws DimensionMismatch _bcs((), (3,5), (4,5))
-@test_throws DimensionMismatch _bcs((), (3,5), (3,4))
-@test @inferred(_bcs((), (-1:1, 2:5), (-1:1, 2:5))) == (-1:1, 2:5)
-@test @inferred(_bcs((), (-1:1, 2:5), (1, 2:5)))    == (-1:1, 2:5)
-@test @inferred(_bcs((), (-1:1, 1),   (1, 2:5)))    == (-1:1, 2:5)
-@test @inferred(_bcs((), (-1:1,),     (-1:1, 2:5))) == (-1:1, 2:5)
-@test_throws DimensionMismatch _bcs((), (-1:1, 2:6), (-1:1, 2:5))
-@test_throws DimensionMismatch _bcs((), (-1:1, 2:5), (2, 2:5))
+@test @inferred(_bcs((3,5), (3,5))) == (3,5)
+@test @inferred(_bcs((3,1), (3,5))) == (3,5)
+@test @inferred(_bcs((3,),  (3,5))) == (3,5)
+@test @inferred(_bcs((3,5), (3,)))  == (3,5)
+@test_throws DimensionMismatch _bcs((3,5), (4,5))
+@test_throws DimensionMismatch _bcs((3,5), (3,4))
+@test @inferred(_bcs((-1:1, 2:5), (-1:1, 2:5))) == (-1:1, 2:5)
+@test @inferred(_bcs((-1:1, 2:5), (1, 2:5)))    == (-1:1, 2:5)
+@test @inferred(_bcs((-1:1, 1),   (1, 2:5)))    == (-1:1, 2:5)
+@test @inferred(_bcs((-1:1,),     (-1:1, 2:5))) == (-1:1, 2:5)
+@test_throws DimensionMismatch _bcs((-1:1, 2:6), (-1:1, 2:5))
+@test_throws DimensionMismatch _bcs((-1:1, 2:5), (2, 2:5))
 
 @test @inferred(broadcast_indices(zeros(3,4), zeros(3,4))) == (OneTo(3),OneTo(4))
 @test @inferred(broadcast_indices(zeros(3,4), zeros(3)))   == (OneTo(3),OneTo(4))
@@ -70,7 +70,7 @@ function as_sub(x::AbstractMatrix)
     end
     y
 end
-function as_sub{T}(x::AbstractArray{T,3})
+function as_sub(x::AbstractArray{T,3}) where T
     y = similar(x, eltype(x), tuple(([size(x)...]*2)...))
     y = view(y, 2:2:size(y,1), 2:2:size(y,2), 2:2:size(y,3))
     for k=1:size(x,3)
@@ -200,7 +200,7 @@ end
 
 # issue #4883
 @test isa(broadcast(tuple, [1 2 3], ["a", "b", "c"]), Matrix{Tuple{Int,String}})
-@test isa(broadcast((x,y)->(x==1?1.0:x,y), [1 2 3], ["a", "b", "c"]), Matrix{Tuple{Real,String}})
+@test isa(broadcast((x,y)->(x==1 ? 1.0 : x, y), [1 2 3], ["a", "b", "c"]), Matrix{Tuple{Real,String}})
 let a = length.(["foo", "bar"])
     @test isa(a, Vector{Int})
     @test a == [3, 3]
@@ -312,12 +312,12 @@ end
 
 # make sure scalars are inlined, which causes f.(x,scalar) to lower to a "thunk"
 import Base.Meta: isexpr
-@test isexpr(expand(:(f.(x,y))), :call)
-@test isexpr(expand(:(f.(x,1))), :thunk)
-@test isexpr(expand(:(f.(x,1.0))), :thunk)
-@test isexpr(expand(:(f.(x,$π))), :thunk)
-@test isexpr(expand(:(f.(x,"hello"))), :thunk)
-@test isexpr(expand(:(f.(x,$("hello")))), :thunk)
+@test isexpr(expand(Main, :(f.(x,y))), :call)
+@test isexpr(expand(Main, :(f.(x,1))), :thunk)
+@test isexpr(expand(Main, :(f.(x,1.0))), :thunk)
+@test isexpr(expand(Main, :(f.(x,$π))), :thunk)
+@test isexpr(expand(Main, :(f.(x,"hello"))), :thunk)
+@test isexpr(expand(Main, :(f.(x,$("hello")))), :thunk)
 
 # PR #17623: Fused binary operators
 @test [true] .* [true] == [true]
@@ -346,7 +346,7 @@ end
 let f17314 = x -> x < 0 ? false : x
     @test eltype(broadcast(f17314, 1:3)) === Int
     @test eltype(broadcast(f17314, -1:1)) === Integer
-    @test eltype(broadcast(f17314, Int[])) === Union{Bool,Int}
+    @test eltype(broadcast(f17314, Int[])) == Union{Bool,Int}
 end
 let io = IOBuffer()
     broadcast(x->print(io,x), 1:5) # broadcast with side effects
@@ -419,9 +419,10 @@ struct Array19745{T,N} <: AbstractArray{T,N}
     data::Array{T,N}
 end
 Base.getindex(A::Array19745, i::Integer...) = A.data[i...]
+Base.setindex!(A::Array19745, v::Any, i::Integer...) = setindex!(A.data, v, i...)
 Base.size(A::Array19745) = size(A.data)
 
-Base.Broadcast._containertype{T<:Array19745}(::Type{T}) = Array19745
+Base.Broadcast._containertype(::Type{T}) where {T<:Array19745} = Array19745
 
 Base.Broadcast.promote_containertype(::Type{Array19745}, ::Type{Array19745}) = Array19745
 Base.Broadcast.promote_containertype(::Type{Array19745}, ::Type{Array})      = Array19745
@@ -435,8 +436,12 @@ Base.Broadcast.broadcast_indices(::Type{Array19745}, A::Ref) = ()
 getfield19745(x::Array19745) = x.data
 getfield19745(x)             = x
 
-Base.Broadcast.broadcast_c(f, ::Type{Array19745}, A, Bs...) =
-    Array19745(Base.Broadcast.broadcast_c(f, Array, getfield19745(A), map(getfield19745, Bs)...))
+function Base.Broadcast.broadcast_c(f, ::Type{Array19745}, A, Bs...)
+    T     = Base.Broadcast._broadcast_eltype(f, A, Bs...)
+    shape = Base.Broadcast.broadcast_indices(A, Bs...)
+    dest = Array19745(Array{T}(Base.index_lengths(shape...)))
+    return broadcast!(f, dest, A, Bs...)
+end
 
 @testset "broadcasting for custom AbstractArray" begin
     a  = randn(10)
@@ -494,3 +499,24 @@ end
     A[1:3,1:3] .= [ones(2,2)]
     @test all(A[1:3,1:3] .== [ones(2,2)])
 end
+
+# Test that broadcast does not confuse eltypes. See also
+# https://github.com/JuliaLang/julia/issues/21325
+@testset "eltype confusion (#21325)" begin
+    foo(x::Char, y::Int) = 0
+    foo(x::String, y::Int) = "hello"
+    @test broadcast(foo, "x", [1, 2, 3]) == ["hello", "hello", "hello"]
+
+    @test isequal(
+        [Set([1]), Set([2])] .∪ Set([3]),
+        [Set([1, 3]), Set([2, 3])])
+
+    @test isequal(@inferred(broadcast(foo, "world", Nullable(1))),
+                  Nullable("hello"))
+end
+
+# Issue #21291
+let t = (0, 1, 2)
+    o = 1
+    @test @inferred(broadcast(+, t, o)) == (1, 2, 3)
+end
diff --git a/test/cartesian.jl b/test/cartesian.jl
index 3180a4f4dccfc7..be2605d2001439 100644
--- a/test/cartesian.jl
+++ b/test/cartesian.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 @test Base.Cartesian.exprresolve(:(1 + 3)) == 4
 ex = Base.Cartesian.exprresolve(:(if 5 > 4; :x; else :y; end))
diff --git a/test/ccall.jl b/test/ccall.jl
index 2e8c067474646a..560705055554f1 100644
--- a/test/ccall.jl
+++ b/test/ccall.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 import Base.copy, Base.==
 
@@ -139,7 +139,7 @@ end
 copy(a::Struct1) = Struct1(a.x, a.y)
 copy(a::Struct1I) = a
 
-function test_struct1{Struct}(::Type{Struct})
+function test_struct1(::Type{Struct}) where {Struct}
     a = Struct(352.39422f23, 19.287577)
     b = Float32(123.456)
 
@@ -223,7 +223,7 @@ struct Struct4I
     z::Int32
 end
 
-function test_struct4{Struct}(::Type{Struct})
+function test_struct4(::Type{Struct}) where {Struct}
     a = Struct(-512275808,882558299,-2133022131)
     b = Int32(42)
 
@@ -253,7 +253,7 @@ struct Struct5I
     a::Int32
 end
 
-function test_struct5{Struct}(::Type{Struct})
+function test_struct5(::Type{Struct}) where {Struct}
     a = Struct(1771319039, 406394736, -1269509787, -745020976)
     b = Int32(42)
 
@@ -282,7 +282,7 @@ struct Struct6I
     z::Int64
 end
 
-function test_struct6{Struct}(::Type{Struct})
+function test_struct6(::Type{Struct}) where {Struct}
     a = Struct(-654017936452753226, -5573248801240918230, -983717165097205098)
     b = Int64(42)
 
@@ -308,7 +308,7 @@ struct Struct7I
     y::Cchar
 end
 
-function test_struct7{Struct}(::Type{Struct})
+function test_struct7(::Type{Struct}) where {Struct}
     a = Struct(-384082741977533896, 'h')
     b = Int8(42)
 
@@ -333,7 +333,7 @@ struct Struct8I
     y::Cchar
 end
 
-function test_struct8{Struct}(::Type{Struct})
+function test_struct8(::Type{Struct}) where {Struct}
     a = Struct(-384082896, 'h')
     b = Int8(42)
 
@@ -358,7 +358,7 @@ struct Struct9I
     y::Int16
 end
 
-function test_struct9{Struct}(::Type{Struct})
+function test_struct9(::Type{Struct}) where {Struct}
     a = Struct(-394092996, -3840)
     b = Int16(42)
 
@@ -387,7 +387,7 @@ struct Struct10I
     a::Cchar
 end
 
-function test_struct10{Struct}(::Type{Struct})
+function test_struct10(::Type{Struct}) where {Struct}
     a = Struct('0', '1', '2', '3')
     b = Int8(2)
 
@@ -412,7 +412,7 @@ struct Struct11I
     x::Complex64
 end
 
-function test_struct11{Struct}(::Type{Struct})
+function test_struct11(::Type{Struct}) where {Struct}
     a = Struct(0.8877077f0 + 0.4591081f0im)
     b = Float32(42)
 
@@ -436,7 +436,7 @@ struct Struct12I
     y::Complex64
 end
 
-function test_struct12{Struct}(::Type{Struct})
+function test_struct12(::Type{Struct}) where {Struct}
     a = Struct(0.8877077f5 + 0.4591081f2im, 0.0004842868f0 - 6982.3265f3im)
     b = Float32(42)
 
@@ -459,7 +459,7 @@ struct Struct13I
     x::Complex128
 end
 
-function test_struct13{Struct}(::Type{Struct})
+function test_struct13(::Type{Struct}) where {Struct}
     a = Struct(42968.97560380495 - 803.0576845153616im)
     b = Float64(42)
 
@@ -483,7 +483,7 @@ struct Struct14I
     y::Float32
 end
 
-function test_struct14{Struct}(::Type{Struct})
+function test_struct14(::Type{Struct}) where {Struct}
     a = Struct(0.024138331f0, 0.89759064f32)
     b = Float32(42)
 
@@ -508,7 +508,7 @@ struct Struct15I
     y::Float64
 end
 
-function test_struct15{Struct}(::Type{Struct})
+function test_struct15(::Type{Struct}) where {Struct}
     a = Struct(4.180997967273657, -0.404218594294923)
     b = Float64(42)
 
@@ -541,7 +541,7 @@ struct Struct16I
     c::Float64
 end
 
-function test_struct16{Struct}(::Type{Struct})
+function test_struct16(::Type{Struct}) where {Struct}
     a = Struct(0.1604656f0, 0.6297606f0, 0.83588994f0,
                0.6460273620993535, 0.9472692581106656, 0.47328535437352093)
     b = Float32(42)
@@ -571,7 +571,7 @@ struct Struct17I
     b::Int16
 end
 
-function test_struct17{Struct}(::Type{Struct})
+function test_struct17(::Type{Struct}) where {Struct}
     a = Struct(2, 10)
     b = Int8(2)
 
@@ -598,7 +598,7 @@ struct Struct18I
     c::Int8
 end
 
-function test_struct18{Struct}(::Type{Struct})
+function test_struct18(::Type{Struct}) where {Struct}
     a = Struct(2, 10, -3)
     b = Int8(2)
 
@@ -638,7 +638,7 @@ end
 copy(a::Struct_Big) = Struct_Big(a.x, a.y, a.z)
 copy(a::Struct_BigI) = a
 
-function test_struct_big{Struct}(::Type{Struct})
+function test_struct_big(::Type{Struct}) where {Struct}
     a = Struct(424,-5,Int8('Z'))
     a2 = copy(a)
 
@@ -888,7 +888,7 @@ let A = [1]
 end
 
 # Pointer finalizer at exit (PR #19911)
-let result = readstring(`$(Base.julia_cmd()) --startup-file=no -e "A = Ref{Cint}(42); finalizer(A, cglobal((:c_exit_finalizer, \"$libccalltest\"), Void))"`)
+let result = read(`$(Base.julia_cmd()) --startup-file=no -e "A = Ref{Cint}(42); finalizer(A, cglobal((:c_exit_finalizer, \"$libccalltest\"), Void))"`, String)
     @test result == "c_exit_finalizer: 42, 0"
 end
 
@@ -1236,3 +1236,70 @@ for i in 1:100
     @test_spill_n 9 int32args float32args
     @test_spill_n 10 int32args float32args
 end
+
+# issue #20835
+@test_throws(ErrorException("could not evaluate ccall argument type (it might depend on a local variable)"),
+             eval(:(f20835(x) = ccall(:fn, Void, (Ptr{typeof(x)},), x))))
+@test_throws(UndefVarError(:Something_not_defined_20835),
+             eval(:(f20835(x) = ccall(:fn, Something_not_defined_20835, (Ptr{typeof(x)},), x))))
+
+@noinline f21104at(::Type{T}) where {T} = ccall(:fn, Void, (Nullable{T},), 0)
+@noinline f21104rt(::Type{T}) where {T} = ccall(:fn, Nullable{T}, ())
+@test code_llvm(DevNull, f21104at, (Type{Float64},)) === nothing
+@test code_llvm(DevNull, f21104rt, (Type{Float64},)) === nothing
+@test_throws(ErrorException("ccall: the type of argument 1 doesn't correspond to a C type"),
+             f21104at(Float64))
+@test_throws(ErrorException("ccall: return type doesn't correspond to a C type"),
+             f21104rt(Float64))
+
+# test for malformed syntax errors
+@test Expr(:error, "more arguments than types for ccall") == expand(@__MODULE__, :(ccall(:fn, A, (), x)))
+@test Expr(:error, "more arguments than types for ccall") == expand(@__MODULE__, :(ccall(:fn, A, (B,), x, y)))
+@test Expr(:error, "more arguments than types for ccall") == expand(@__MODULE__, :(ccall(:fn, A, (B,), x, y, z)))
+@test Expr(:error, "more arguments than types for ccall") == expand(@__MODULE__, :(ccall(:fn, A, (B,), x, y)))
+@test Expr(:error, "more arguments than types for ccall") == expand(@__MODULE__, :(ccall(:fn, A, (B,), x, y, z)))
+@test Expr(:error, "more arguments than types for ccall") == expand(@__MODULE__, :(ccall(:fn, A, (B, C), x, y, z)))
+@test Expr(:error, "more types than arguments for ccall") == expand(@__MODULE__, :(ccall(:fn, A, (B,),)))
+@test Expr(:error, "more types than arguments for ccall") == expand(@__MODULE__, :(ccall(:fn, A, (B, C), )))
+@test Expr(:error, "more types than arguments for ccall") == expand(@__MODULE__, :(ccall(:fn, A, (B..., C...), )))
+@test Expr(:error, "only the trailing ccall argument type should have '...'") == expand(@__MODULE__, :(ccall(:fn, A, (B..., C...), x)))
+@test Expr(:error, "only the trailing ccall argument type should have '...'") == expand(@__MODULE__, :(ccall(:fn, A, (B..., C...), x, y, z)))
+@test Expr(:error, "more types than arguments for ccall") == expand(@__MODULE__, :(ccall(:fn, A, (B, C...), )))
+
+# cfunction on non-function singleton
+struct CallableSingleton
+end
+(::CallableSingleton)(x, y) = x + y
+@test ccall(cfunction(CallableSingleton(), Int, Tuple{Int,Int}),
+            Int, (Int, Int), 1, 2) === 3
+
+# 19805
+mutable struct callinfos_19805{FUNC_FT<:Function}
+    f :: FUNC_FT
+end
+
+evalf_callback_19805(ci::callinfos_19805{FUNC_FT}) where {FUNC_FT} = ci.f(0.5)::Float64
+
+evalf_callback_c_19805(ci::callinfos_19805{FUNC_FT}) where {FUNC_FT} = cfunction(
+    evalf_callback_19805, Float64, (callinfos_19805{FUNC_FT},))
+
+@test_throws(ErrorException("ccall: the type of argument 1 doesn't correspond to a C type"),
+             evalf_callback_c_19805( callinfos_19805(sin) ))
+
+# test Ref{abstract_type} calling parameter passes a heap box
+abstract type Abstract22734 end
+struct Bits22734 <: Abstract22734
+    x::Int
+    y::Float64
+end
+function cb22734(ptr::Ptr{Void})
+    gc()
+    obj = unsafe_pointer_to_objref(ptr)::Bits22734
+    obj.x + obj.y
+end
+ptr22734 = cfunction(cb22734, Float64, Tuple{Ptr{Void}})
+function caller22734(ptr)
+    obj = Bits22734(12, 20)
+    ccall(ptr, Float64, (Ref{Abstract22734},), obj)
+end
+@test caller22734(ptr22734) === 32.0
diff --git a/test/channels.jl b/test/channels.jl
index d3260f57920a11..fb6e5234edd2fd 100644
--- a/test/channels.jl
+++ b/test/channels.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Test various constructors
 c=Channel(1)
@@ -217,3 +217,135 @@ end
     end
     @test isready(rr1)
 end
+
+
+# test for yield/wait/event failures
+@noinline garbage_finalizer(f) = finalizer("gar" * "bage", f)
+let t, run = Ref(0)
+    gc_enable(false)
+    # test for finalizers trying to yield leading to failed attempts to context switch
+    garbage_finalizer((x) -> (run[] += 1; sleep(1)))
+    garbage_finalizer((x) -> (run[] += 1; yield()))
+    garbage_finalizer((x) -> (run[] += 1; yieldto(@task () -> ())))
+    t = @task begin
+        gc_enable(true)
+        gc()
+    end
+    oldstderr = STDERR
+    local newstderr, errstream
+    try
+        newstderr = redirect_stderr()
+        errstream = @async read(newstderr[1], String)
+        yield(t)
+    finally
+        redirect_stderr(oldstderr)
+        close(newstderr[2])
+    end
+    wait(t)
+    @test run[] == 3
+    @test wait(errstream) == """
+        error in running finalizer: ErrorException("task switch not allowed from inside gc finalizer")
+        error in running finalizer: ErrorException("task switch not allowed from inside gc finalizer")
+        error in running finalizer: ErrorException("task switch not allowed from inside gc finalizer")
+        """
+    # test for invalid state in Workqueue during yield
+    t = @schedule nothing
+    t.state = :invalid
+    try
+        newstderr = redirect_stderr()
+        errstream = @async read(newstderr[1], String)
+        yield()
+    finally
+        redirect_stderr(oldstderr)
+        close(newstderr[2])
+    end
+    @test wait(errstream) == "\nWARNING: Workqueue inconsistency detected: shift!(Workqueue).state != :queued\n"
+end
+
+# schedule_and_wait tests
+let t = @schedule(nothing),
+    ct = current_task(),
+    testobject = "testobject"
+    @test length(Base.Workqueue) == 1
+    @test Base.schedule_and_wait(ct, 8) == 8
+    @test isempty(Base.Workqueue)
+    @test Base.schedule_and_wait(ct, testobject) === testobject
+end
+
+# throwto tests
+let t = @task(nothing),
+    ct = current_task(),
+    testerr = ErrorException("expected")
+    @async Base.throwto(t, testerr)
+    @test try
+        wait(t)
+        false
+    catch ex
+        ex
+    end === testerr
+end
+
+# Timer / AsyncCondition triggering and race #12719
+let tc = Ref(0),
+    t = Timer(0) do t
+        tc[] += 1
+    end
+    @test isopen(t)
+    Base.process_events(false)
+    @test !isopen(t)
+    @test tc[] == 0
+    yield()
+    @test tc[] == 1
+end
+let tc = Ref(0),
+    t = Timer(0) do t
+        tc[] += 1
+    end
+    @test isopen(t)
+    close(t)
+    @test !isopen(t)
+    sleep(0.1)
+    @test tc[] == 0
+end
+let tc = Ref(0),
+    async = Base.AsyncCondition() do async
+        tc[] += 1
+    end
+    @test isopen(async)
+    ccall(:uv_async_send, Void, (Ptr{Void},), async)
+    Base.process_events(false) # schedule event
+    ccall(:uv_async_send, Void, (Ptr{Void},), async)
+    Sys.iswindows() && Base.process_events(false) # schedule event (windows?)
+    @test tc[] == 0
+    yield() # consume event
+    @test tc[] == 1
+    sleep(0.1) # no further events
+    @test tc[] == 1
+    ccall(:uv_async_send, Void, (Ptr{Void},), async)
+    ccall(:uv_async_send, Void, (Ptr{Void},), async)
+    close(async)
+    @test !isopen(async)
+    @test tc[] == 1
+    Base.process_events(false) # schedule event & then close
+    Sys.iswindows() && Base.process_events(false) # schedule event (windows?)
+    yield() # consume event & then close
+    @test tc[] == 2
+    sleep(0.1) # no further events
+    @test tc[] == 2
+end
+let tc = Ref(0),
+    async = Base.AsyncCondition() do async
+        tc[] += 1
+    end
+    @test isopen(async)
+    ccall(:uv_async_send, Void, (Ptr{Void},), async)
+    close(async)
+    @test !isopen(async)
+    Base.process_events(false) # schedule event & then close
+    Sys.iswindows() && Base.process_events(false) # schedule event (windows)
+    @test tc[] == 0
+    yield() # consume event & then close
+    @test tc[] == 1
+    sleep(0.1)
+    @test tc[] == 1
+end
diff --git a/test/char.jl b/test/char.jl
index 8a8a2f825cbd30..c40f60de3be235 100644
--- a/test/char.jl
+++ b/test/char.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #tests for /base/char.jl
 
diff --git a/test/checked.jl b/test/checked.jl
index 3e98a7b2ea445c..43e897ea807fbc 100644
--- a/test/checked.jl
+++ b/test/checked.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Checked integer arithmetic
 
diff --git a/test/choosetests.jl b/test/choosetests.jl
index dff7ae807b7fb9..7558b74179bc4f 100644
--- a/test/choosetests.jl
+++ b/test/choosetests.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 @doc """
 
@@ -20,7 +20,7 @@ function choosetests(choices = [])
         "printf", "char", "strings", "triplequote", "unicode", "intrinsics",
         "dates", "dict", "hashing", "iobuffer", "staged", "offsetarray",
         "arrayops", "tuple", "reduce", "reducedim", "random", "abstractarray",
-        "intfuncs", "simdloop", "vecelement", "blas", "sparse",
+        "intfuncs", "simdloop", "vecelement", "sparse",
         "bitarray", "copy", "math", "fastmath", "functional", "iterators",
         "operators", "path", "ccall", "parse", "loading", "bigint",
         "bigfloat", "sorting", "statistics", "spawn", "backtrace",
@@ -35,7 +35,7 @@ function choosetests(choices = [])
         "enums", "cmdlineargs", "i18n", "workspace", "libdl", "int",
         "checked", "intset", "floatfuncs", "compile", "distributed", "inline",
         "boundscheck", "error", "ambiguous", "cartesian", "asmvariant", "osutils",
-        "channels"
+        "channels", "iostream", "specificity", "codegen"
     ]
     profile_skipped = false
     if startswith(string(Sys.ARCH), "arm")
@@ -45,10 +45,6 @@ function choosetests(choices = [])
         profile_skipped = true
     end
 
-    if Base.USE_GPL_LIBS
-        testnames = [testnames, "fft", "dsp"; ]
-    end
-
     if isdir(joinpath(JULIA_HOME, Base.DOCDIR, "examples"))
         push!(testnames, "examples")
     end
@@ -115,7 +111,7 @@ function choosetests(choices = [])
         prepend!(tests, sparsetests)
     end
 
-    #do subarray before sparse but after linalg
+    # do subarray before sparse but after linalg
     if "subarray" in skip_tests
         filter!(x -> x != "subarray", tests)
     elseif "subarray" in tests
@@ -130,7 +126,8 @@ function choosetests(choices = [])
                    "linalg/diagonal", "linalg/pinv", "linalg/givens",
                    "linalg/cholesky", "linalg/lu", "linalg/symmetric",
                    "linalg/generic", "linalg/uniformscaling", "linalg/lq",
-                   "linalg/hessenberg", "linalg/rowvector", "linalg/conjarray"]
+                   "linalg/hessenberg", "linalg/rowvector", "linalg/conjarray",
+                   "linalg/blas"]
     if Base.USE_GPL_LIBS
         push!(linalgtests, "linalg/arnoldi")
     end
@@ -143,6 +140,14 @@ function choosetests(choices = [])
         prepend!(tests, linalgtests)
     end
 
+    # do ambiguous first to avoid failing if ambiguities are introduced by other tests
+    if "ambiguous" in skip_tests
+        filter!(x -> x != "ambiguous", tests)
+    elseif "ambiguous" in tests
+        filter!(x -> x != "ambiguous", tests)
+        prepend!(tests, ["ambiguous"])
+    end
+
     net_required_for = ["socket", "distributed", "libgit2"]
     net_on = true
     try
diff --git a/test/cmdlineargs.jl b/test/cmdlineargs.jl
index 170b3b8c63a8b1..13696f95abaad4 100644
--- a/test/cmdlineargs.jl
+++ b/test/cmdlineargs.jl
@@ -1,7 +1,7 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 catcmd = `cat`
-if is_windows()
+if Sys.iswindows()
     try # use busybox-w32 on windows
         success(`busybox`)
         catcmd = `busybox cat`
@@ -10,15 +10,15 @@ end
 
 let exename = `$(Base.julia_cmd()) --precompiled=yes --startup-file=no`
     # --version
-    let v = split(readstring(`$exename -v`), "julia version ")[end]
+    let v = split(read(`$exename -v`, String), "julia version ")[end]
         @test Base.VERSION_STRING == chomp(v)
     end
-    @test readstring(`$exename -v`) == readstring(`$exename --version`)
+    @test read(`$exename -v`, String) == read(`$exename --version`, String)
 
     # --help
     let header = "julia [switches] -- [programfile] [args...]"
-        @test startswith(readstring(`$exename -h`), header)
-        @test startswith(readstring(`$exename --help`), header)
+        @test startswith(read(`$exename -h`, String), header)
+        @test startswith(read(`$exename --help`, String), header)
     end
 
     # --quiet
@@ -40,8 +40,8 @@ let exename = `$(Base.julia_cmd()) --precompiled=yes --startup-file=no`
     @test !success(`$exename -i -e "exit(1)"`)
 
     # --print
-    @test readstring(`$exename -E "1+1"`) == "2\n"
-    @test readstring(`$exename --print="1+1"`) == "2\n"
+    @test read(`$exename -E "1+1"`, String) == "2\n"
+    @test read(`$exename --print="1+1"`, String) == "2\n"
     @test !success(`$exename -E`)
     @test !success(`$exename --print`)
 
@@ -62,8 +62,8 @@ let exename = `$(Base.julia_cmd()) --precompiled=yes --startup-file=no`
     @test !success(`$exename --load`)
 
     # --cpu-target
-    # NOTE: this test only holds true when there is a sys.{dll,dylib,so} shared library present.
-    if Libdl.dlopen_e(splitext(unsafe_string(Base.JLOptions().image_file))[1]) != C_NULL
+    # NOTE: this test only holds true if image_file is a shared library.
+    if Libdl.dlopen_e(unsafe_string(Base.JLOptions().image_file)) != C_NULL
         @test !success(`$exename -C invalidtarget --precompiled=yes`)
         @test !success(`$exename --cpu-target=invalidtarget --precompiled=yes`)
     else
@@ -133,19 +133,19 @@ let exename = `$(Base.julia_cmd()) --precompiled=yes --startup-file=no`
 
     # -g
     @test readchomp(`$exename -E "Base.JLOptions().debug_level" -g`) == "2"
-    let code = readstring(`$exename -g0 -e "code_llvm(STDOUT, +, (Int64, Int64), false, true)"`)
+    let code = read(`$exename -g0 -e "code_llvm(STDOUT, +, (Int64, Int64), false, true)"`, String)
         @test contains(code, "llvm.module.flags")
         @test !contains(code, "llvm.dbg.cu")
         @test !contains(code, "int.jl")
         @test !contains(code, "Int64")
     end
-    let code = readstring(`$exename -g1 -e "code_llvm(STDOUT, +, (Int64, Int64), false, true)"`)
+    let code = read(`$exename -g1 -e "code_llvm(STDOUT, +, (Int64, Int64), false, true)"`, String)
         @test contains(code, "llvm.module.flags")
         @test contains(code, "llvm.dbg.cu")
         @test contains(code, "int.jl")
         @test !contains(code, "Int64")
     end
-    let code = readstring(`$exename -g2 -e "code_llvm(STDOUT, +, (Int64, Int64), false, true)"`)
+    let code = read(`$exename -g2 -e "code_llvm(STDOUT, +, (Int64, Int64), false, true)"`, String)
         @test contains(code, "llvm.module.flags")
         @test contains(code, "llvm.dbg.cu")
         @test contains(code, "int.jl")
@@ -207,7 +207,7 @@ let exename = `$(Base.julia_cmd()) --precompiled=yes --startup-file=no`
 
         let out  = Pipe(),
             proc = spawn(pipeline(`$exename -E "$code" --depwarn=no`, stderr=out))
-            output = @async readstring(out)
+            output = @async read(out, String)
 
             wait(proc)
             close(out.in)
@@ -248,53 +248,73 @@ let exename = `$(Base.julia_cmd()) --precompiled=yes --startup-file=no`
     # 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
-            write(testfile, """
-                println(ARGS)
+    mktempdir() do dir
+        testfile = joinpath(dir, tempname())
+        # write a julia source file that just prints ARGS to STDOUT
+        write(testfile, """
+            println(ARGS)
             """)
-            @test readchomp(`$exename $testfile foo -bar --baz`) ==
-                "String[\"foo\", \"-bar\", \"--baz\"]"
-            @test readchomp(`$exename $testfile -- foo -bar --baz`) ==
-                "String[\"foo\", \"-bar\", \"--baz\"]"
+        cp(testfile, joinpath(dir, ".juliarc.jl"))
+
+        withenv((Sys.iswindows() ? "USERPROFILE" : "HOME") => dir) do
+            output = "String[\"foo\", \"-bar\", \"--baz\"]"
+            @test readchomp(`$exename $testfile foo -bar --baz`) == output
+            @test readchomp(`$exename $testfile -- foo -bar --baz`) == output
             @test readchomp(`$exename -L $testfile -e 'exit(0)' -- foo -bar --baz`) ==
-                "String[\"foo\", \"-bar\", \"--baz\"]"
-            @test split(readchomp(`$exename -L $testfile $testfile`), '\n') ==
-                ["String[\"$(escape(testfile))\"]", "String[]"]
+                output
+            @test readchomp(`$exename --startup-file=yes -e 'exit(0)' -- foo -bar --baz`) ==
+                output
+
+            output = "String[]\nString[]"
+            @test readchomp(`$exename -L $testfile $testfile`) == output
+            @test readchomp(`$exename --startup-file=yes $testfile`) == output
+
             @test !success(`$exename --foo $testfile`)
-            @test readchomp(`$exename -L $testfile -e 'exit(0)' -- foo -bar -- baz`) == "String[\"foo\", \"-bar\", \"--\", \"baz\"]"
-        finally
-            rm(testfile)
+            @test readchomp(`$exename -L $testfile -e 'exit(0)' -- foo -bar -- baz`) ==
+                "String[\"foo\", \"-bar\", \"--\", \"baz\"]"
         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))\")
+    # test the program name remains constant
+    mktempdir() do dir
+        a = joinpath(dir, "a.jl")
+        b = joinpath(dir, "b.jl")
+        c = joinpath(dir, ".juliarc.jl")
+
+        write(a, """
+            println(@__FILE__)
+            println(PROGRAM_FILE)
+            include(\"$(escape_string(b))\")
             """)
-            write(b, """
-                println(@__FILE__)
-                println(PROGRAM_FILE)
-                println(length(ARGS))
+        write(b, """
+            println(@__FILE__)
+            println(PROGRAM_FILE)
             """)
-            @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)
+        cp(b, c)
+
+        readsplit(cmd) = split(readchomp(cmd), '\n')
+
+        withenv((Sys.iswindows() ? "USERPROFILE" : "HOME") => dir) do
+            @test readsplit(`$exename $a`) ==
+                [a, a,
+                 b, a]
+            @test readsplit(`$exename -L $b -e 'exit(0)'`) ==
+                [realpath(b), ""]
+            @test readsplit(`$exename -L $b $a`) ==
+                [realpath(b), a,
+                 a, a,
+                 b, a]
+            @test readsplit(`$exename --startup-file=yes -e 'exit(0)'`) ==
+                [c, ""]
+            @test readsplit(`$exename --startup-file=yes -L $b -e 'exit(0)'`) ==
+                [c, "",
+                 realpath(b), ""]
+            @test readsplit(`$exename --startup-file=yes -L $b $a`) ==
+                [c, a,
+                 realpath(b), a,
+                 a, a,
+                 b, a]
         end
     end
 
@@ -322,7 +342,7 @@ let exename = `$(Base.julia_cmd()) --precompiled=yes --startup-file=no`
     # issue #12671, starting from a non-directory
     # rm(dir) fails on windows with Permission denied
     # and was an upstream bug in llvm <= v3.3
-    if !is_windows() && VersionNumber(Base.libllvm_version) > v"3.3"
+    if !Sys.iswindows() && Base.libllvm_version > v"3.3"
         testdir = mktempdir()
         cd(testdir) do
             rm(testdir)
@@ -331,6 +351,43 @@ let exename = `$(Base.julia_cmd()) --precompiled=yes --startup-file=no`
     end
 end
 
+
+# Find the path of libjulia (or libjulia-debug, as the case may be)
+# to use as a dummy shlib to open
+libjulia = abspath(Libdl.dlpath((ccall(:jl_is_debugbuild, Cint, ()) != 0) ? "libjulia-debug" : "libjulia"))
+
+# test error handling code paths of running --sysimage
+let exename = joinpath(JULIA_HOME, Base.julia_exename()),
+    sysname = unsafe_string(Base.JLOptions().image_file)
+    for nonexist_image in (
+            joinpath(@__DIR__, "nonexistent"),
+            "$sysname.nonexistent",
+            )
+        let stderr = Pipe(),
+            p = spawn(pipeline(`$exename --sysimage=$nonexist_image`, stderr=stderr))
+            close(stderr.in)
+            let s = read(stderr, String)
+                @test contains(s, "ERROR: could not load library \"$nonexist_image\"\n")
+                @test !contains(s, "Segmentation fault")
+                @test !contains(s, "EXCEPTION_ACCESS_VIOLATION")
+            end
+            @test !success(p)
+            @test !Base.process_signaled(p)
+            @test p.exitcode == 1
+        end
+    end
+    let stderr = Pipe(),
+        p = spawn(pipeline(`$exename --sysimage=$libjulia`, stderr=stderr))
+        close(stderr.in)
+        let s = read(stderr, String)
+            @test s == "ERROR: System image file failed consistency check: maybe opened the wrong version?\n"
+        end
+        @test !success(p)
+        @test !Base.process_signaled(p)
+        @test p.exitcode == 1
+    end
+end
+
 let exename = `$(Base.julia_cmd()) --precompiled=yes`
     # --startup-file
     let JL_OPTIONS_STARTUPFILE_ON = 1,
@@ -364,15 +421,9 @@ end
 
 # backtrace contains type and line number info (esp. on windows #17179)
 for precomp in ("yes", "no")
-    bt = readstring(pipeline(ignorestatus(`$(Base.julia_cmd()) --startup-file=no --precompiled=$precomp
-        -E 'include("____nonexistent_file")'`), stderr=catcmd))
-    @test contains(bt, "include_from_node1")
-    if is_windows() && Sys.WORD_SIZE == 32 && precomp == "yes"
-        # fixme, issue #17251
-        @test_broken contains(bt, "include_from_node1(::String) at $(joinpath(".","loading.jl"))")
-    else
-        @test contains(bt, "include_from_node1(::String) at $(joinpath(".","loading.jl"))")
-    end
+    bt = read(pipeline(ignorestatus(`$(Base.julia_cmd()) --startup-file=no --precompiled=$precomp
+        -E 'include("____nonexistent_file")'`), stderr=catcmd), String)
+    @test contains(bt, "include_relative(::Module, ::String) at $(joinpath(".", "loading.jl"))")
     lno = match(r"at \.[\/\\]loading\.jl:(\d+)", bt)
     @test length(lno.captures) == 1
     @test parse(Int, lno.captures[1]) > 0
diff --git a/test/codegen.jl b/test/codegen.jl
new file mode 100644
index 00000000000000..5c8c44e4fd2410
--- /dev/null
+++ b/test/codegen.jl
@@ -0,0 +1,247 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
+# tests for codegen and optimizations
+
+const opt_level = Base.JLOptions().opt_level
+const coverage = (Base.JLOptions().code_coverage > 0) || (Base.JLOptions().malloc_log > 0)
+const Iptr = sizeof(Int) == 8 ? "i64" : "i32"
+
+# `_dump_function` might be more efficient but it doesn't really matter here...
+get_llvm(@nospecialize(f), @nospecialize(t), strip_ir_metadata=true, dump_module=false) =
+    sprint(code_llvm, f, t, strip_ir_metadata, dump_module)
+
+if opt_level > 0
+    # Make sure getptls call is removed at IR level with optimization on
+    @test !contains(get_llvm(identity, Tuple{String}), " call ")
+end
+
+jl_string_ptr(s::String) = ccall(:jl_string_ptr, Ptr{UInt8}, (Any,), s)
+core_sizeof(o) = Core.sizeof(o)
+function test_loads_no_call(ir, load_types)
+    in_function = false
+    load_idx = 1
+    for line in eachline(IOBuffer(ir))
+        if !in_function
+            if startswith(line, "define ")
+                in_function = true
+            end
+            continue
+        end
+        @test !contains(line, " call ")
+        load_split = split(line, " load ", limit=2)
+        if !coverage && length(load_split) >= 2
+            @test load_idx <= length(load_types)
+            if load_idx <= length(load_types)
+                @test startswith(load_split[2], "$(load_types[load_idx]),")
+            end
+            load_idx += 1
+        end
+        if startswith(line, "}")
+            break
+        end
+    end
+    if !coverage
+        @test load_idx == length(load_types) + 1
+    end
+end
+
+# This function tests if functions are output when compiled if jl_dump_compiles is enabled.
+# Have to go through pains with recursive function (eval probably not required) to make sure
+# that inlining won't happen.
+function test_jl_dump_compiles()
+    tfile = tempname()
+    io = open(tfile, "w")
+    ccall(:jl_dump_compiles, Void, (Ptr{Void},), io.handle)
+    eval(@noinline function test_jl_dump_compiles_internal(x)
+        if x > 0
+            test_jl_dump_compiles_internal(x-1)
+        end
+        end)
+    test_jl_dump_compiles_internal(1)
+    ccall(:jl_dump_compiles, Void, (Ptr{Void},), C_NULL)
+    close(io)
+    tstats = stat(tfile)
+    tempty = tstats.size == 0
+    rm(tfile)
+    @test tempty == false
+end
+
+# This function tests if a toplevel thunk is output if jl_dump_compiles is enabled.
+# The eval statement creates the toplevel thunk.
+function test_jl_dump_compiles_toplevel_thunks()
+    tfile = tempname()
+    io = open(tfile, "w")
+    ccall(:jl_dump_compiles, Void, (Ptr{Void},), io.handle)
+    eval(expand(Main, :(for i in 1:10 end)))
+    ccall(:jl_dump_compiles, Void, (Ptr{Void},), C_NULL)
+    close(io)
+    tstats = stat(tfile)
+    tempty = tstats.size == 0
+    rm(tfile)
+    @test tempty == true
+end
+
+if opt_level > 0
+    # Make sure `jl_string_ptr` is inlined
+    @test !contains(get_llvm(jl_string_ptr, Tuple{String}), " call ")
+    s = "aaa"
+    @test jl_string_ptr(s) == pointer_from_objref(s) + sizeof(Int)
+    # String
+    test_loads_no_call(get_llvm(core_sizeof, Tuple{String}), [Iptr])
+    # String
+    test_loads_no_call(get_llvm(core_sizeof, Tuple{SimpleVector}), [Iptr])
+    # Array
+    test_loads_no_call(get_llvm(core_sizeof, Tuple{Vector{Int}}), [Iptr])
+    # As long as the eltype is known we don't need to load the elsize
+    test_loads_no_call(get_llvm(core_sizeof, Tuple{Array{Any}}), [Iptr])
+    # Check that we load the elsize
+    test_loads_no_call(get_llvm(core_sizeof, Tuple{Vector}), [Iptr, "i16"])
+
+    test_jl_dump_compiles()
+    test_jl_dump_compiles_toplevel_thunks()
+end
+
+# Make sure we will not elide the allocation
+@noinline create_ref1() = Ref(1)
+function pointer_not_safepoint()
+    a = create_ref1()
+    unsafe_store!(Ptr{Int}(pointer_from_objref(a)), 3)
+    return a[]
+end
+@test pointer_not_safepoint() == 3
+
+# The current memcmp threshold is 512bytes, make sure this struct has the same size on
+# 32bits and 64bits
+struct LargeStruct
+    x::NTuple{1024,Int8}
+    LargeStruct() = new()
+end
+
+const large_struct = LargeStruct()
+@noinline create_ref_struct() = Ref(large_struct)
+function compare_large_struct(a)
+    b = create_ref_struct()
+    if a[] === b[]
+        b[].x[1]
+    else
+        a[].x[2]
+    end
+end
+
+mutable struct MutableStruct
+    a::Int
+    MutableStruct() = new()
+end
+
+breakpoint_mutable(a::MutableStruct) = ccall(:jl_breakpoint, Void, (Ref{MutableStruct},), a)
+
+# Allocation with uninitialized field as gcroot
+mutable struct BadRef
+    x::MutableStruct
+    y::MutableStruct
+    BadRef(x) = new(x)
+end
+Base.cconvert(::Type{Ptr{BadRef}}, a::MutableStruct) = BadRef(a)
+Base.unsafe_convert(::Type{Ptr{BadRef}}, ar::BadRef) = Ptr{BadRef}(pointer_from_objref(ar.x))
+
+breakpoint_badref(a::MutableStruct) = ccall(:jl_breakpoint, Void, (Ptr{BadRef},), a)
+
+struct PtrStruct
+    a::Ptr{Void}
+    b::Int
+end
+
+mutable struct RealStruct
+    a::Float64
+    b::Int
+end
+
+function Base.cconvert(::Type{Ref{PtrStruct}}, a::RealStruct)
+    (a, Ref(PtrStruct(pointer_from_objref(a), a.b)))
+end
+Base.unsafe_convert(::Type{Ref{PtrStruct}}, at::Tuple) =
+    Base.unsafe_convert(Ref{PtrStruct}, at[2])
+
+breakpoint_ptrstruct(a::RealStruct) =
+    ccall(:jl_breakpoint, Void, (Ref{PtrStruct},), a)
+
+if opt_level > 0
+    @test !contains(get_llvm(isequal, Tuple{Nullable{BigFloat}, Nullable{BigFloat}}), "%gcframe")
+    @test !contains(get_llvm(pointer_not_safepoint, Tuple{}), "%gcframe")
+    compare_large_struct_ir = get_llvm(compare_large_struct, Tuple{typeof(create_ref_struct())})
+    @test contains(compare_large_struct_ir, "call i32 @memcmp")
+    @test !contains(compare_large_struct_ir, "%gcframe")
+
+    @test contains(get_llvm(MutableStruct, Tuple{}), "jl_gc_pool_alloc")
+    breakpoint_mutable_ir = get_llvm(breakpoint_mutable, Tuple{MutableStruct})
+    @test !contains(breakpoint_mutable_ir, "%gcframe")
+    @test !contains(breakpoint_mutable_ir, "jl_gc_pool_alloc")
+
+    breakpoint_badref_ir = get_llvm(breakpoint_badref, Tuple{MutableStruct})
+    @test !contains(breakpoint_badref_ir, "%gcframe")
+    @test !contains(breakpoint_badref_ir, "jl_gc_pool_alloc")
+
+    breakpoint_ptrstruct_ir = get_llvm(breakpoint_ptrstruct, Tuple{RealStruct})
+    @test !contains(breakpoint_ptrstruct_ir, "%gcframe")
+    @test !contains(breakpoint_ptrstruct_ir, "jl_gc_pool_alloc")
+end
+
+function two_breakpoint(a::Float64)
+    ccall(:jl_breakpoint, Void, (Ref{Float64},), a)
+    ccall(:jl_breakpoint, Void, (Ref{Float64},), a)
+end
+
+if opt_level > 0
+    breakpoint_f64_ir = get_llvm((a)->ccall(:jl_breakpoint, Void, (Ref{Float64},), a),
+                                 Tuple{Float64})
+    @test !contains(breakpoint_f64_ir, "jl_gc_pool_alloc")
+    breakpoint_any_ir = get_llvm((a)->ccall(:jl_breakpoint, Void, (Ref{Any},), a),
+                                 Tuple{Float64})
+    @test contains(breakpoint_any_ir, "jl_gc_pool_alloc")
+    two_breakpoint_ir = get_llvm(two_breakpoint, Tuple{Float64})
+    @test !contains(two_breakpoint_ir, "jl_gc_pool_alloc")
+    @test contains(two_breakpoint_ir, "llvm.lifetime.end")
+end
+
+# Issue 22770
+let was_gced = false
+    @noinline make_tuple(x) = tuple(x)
+    @noinline use(x) = ccall(:jl_breakpoint, Void, ())
+    @noinline assert_not_gced() = @assert !was_gced
+
+    function foo22770()
+        b = Ref(2)
+        finalizer(b, x->(global was_gced; was_gced=true))
+        y = make_tuple(b)
+        x = y[1]
+        a = Ref(1)
+        use(x); use(a); use(y)
+        c = Ref(3)
+        gc(); assert_not_gced();
+        use(x)
+        use(c)
+    end
+    foo22770()
+end
+
+function egal_svecs()
+    a = Core.svec(:a, :b)
+    b = Core.svec(:a, :b)
+    a === b
+end
+@test egal_svecs()
+@test Core.svec(:a, :b) === Core.svec(:a, :b)
+
+# issue #22582
+function issue22582!(a::AbstractArray, b)
+    len = length(a)
+    if b
+        ccall(:jl_array_grow_end, Void, (Any, Csize_t), a, 1)
+    end
+    return len
+end
+let c = [1,2,3]
+    len1 = length(c)
+    len2 = issue22582!(c, true)
+    @test len1 == len2
+end
diff --git a/test/combinatorics.jl b/test/combinatorics.jl
index eaa9e5884f5629..c8fdeedf6df95a 100644
--- a/test/combinatorics.jl
+++ b/test/combinatorics.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 @testset "binomial" begin
     @test binomial(5,-1) == 0
@@ -67,4 +67,34 @@ end
         @test factorial(Int32(12)) === Int32(479001600)
         @test_throws OverflowError factorial(Int32(13))
     end
+
+    _fact_table64 =
+        Int64[1,2,6,24,120,720,5040,40320,362880,3628800,39916800,479001600,6227020800,
+              87178291200,1307674368000,20922789888000,355687428096000,6402373705728000,
+              121645100408832000,2432902008176640000]
+
+    _fact_table128 =
+        UInt128[0x00000000000000000000000000000001, 0x00000000000000000000000000000002,
+                0x00000000000000000000000000000006, 0x00000000000000000000000000000018,
+                0x00000000000000000000000000000078, 0x000000000000000000000000000002d0,
+                0x000000000000000000000000000013b0, 0x00000000000000000000000000009d80,
+                0x00000000000000000000000000058980, 0x00000000000000000000000000375f00,
+                0x00000000000000000000000002611500, 0x0000000000000000000000001c8cfc00,
+                0x0000000000000000000000017328cc00, 0x0000000000000000000000144c3b2800,
+                0x00000000000000000000013077775800, 0x00000000000000000000130777758000,
+                0x00000000000000000001437eeecd8000, 0x00000000000000000016beecca730000,
+                0x000000000000000001b02b9306890000, 0x000000000000000021c3677c82b40000,
+                0x0000000000000002c5077d36b8c40000, 0x000000000000003ceea4c2b3e0d80000,
+                0x000000000000057970cd7e2933680000, 0x00000000000083629343d3dcd1c00000,
+                0x00000000000cd4a0619fb0907bc00000, 0x00000000014d9849ea37eeac91800000,
+                0x00000000232f0fcbb3e62c3358800000, 0x00000003d925ba47ad2cd59dae000000,
+                0x0000006f99461a1e9e1432dcb6000000, 0x00000d13f6370f96865df5dd54000000,
+                0x0001956ad0aae33a4560c5cd2c000000, 0x0032ad5a155c6748ac18b9a580000000,
+                0x0688589cc0e9505e2f2fee5580000000, 0xde1bc4d19efcac82445da75b00000000]
+
+    for expected in Any[_fact_table64, _fact_table128]
+        for (n, factn) in enumerate(expected)
+            @test factorial(oftype(factn, n)) === factn
+        end
+    end
 end
diff --git a/test/compile.jl b/test/compile.jl
index 91b0f1e4192f86..48f8d3104e7d5a 100644
--- a/test/compile.jl
+++ b/test/compile.jl
@@ -1,8 +1,9 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base.Test
 
 Foo_module = :Foo4b3a94a1a081a8cb
+Foo2_module = :F2oo4b3a94a1a081a8cb
 FooBase_module = :FooBase4b3a94a1a081a8cb
 @eval module ConflictingBindings
     export $Foo_module, $FooBase_module
@@ -21,6 +22,7 @@ insert!(LOAD_PATH, 1, dir)
 insert!(Base.LOAD_CACHE_PATH, 1, dir)
 try
     Foo_file = joinpath(dir, "$Foo_module.jl")
+    Foo2_file = joinpath(dir, "$Foo2_module.jl")
     FooBase_file = joinpath(dir, "$FooBase_module.jl")
 
     write(FooBase_file,
@@ -28,6 +30,24 @@ try
           __precompile__(true)
 
           module $FooBase_module
+              import Base: hash, >
+              struct fmpz end
+              struct typeA end
+              >(x::fmpz, y::Int) = Base.cmp(x, y) > 0
+              function hash(a::typeA, h::UInt)
+                  d = den(a)
+                  return h
+              end
+          end
+          """)
+    write(Foo2_file,
+          """
+          __precompile__(true)
+
+          module $Foo2_module
+              export override
+              override(x::Integer) = 2
+              override(x::AbstractFloat) = Float64(override(1))
           end
           """)
     write(Foo_file,
@@ -35,7 +55,14 @@ try
           __precompile__(true)
 
           module $Foo_module
-              using $FooBase_module
+              using $FooBase_module, $FooBase_module.typeA
+              import $Foo2_module: $Foo2_module, override
+              import $FooBase_module.hash
+
+              struct typeB
+                  y::typeA
+              end
+              hash(x::typeB) = hash(x.y)
 
               # test that docs get reconnected
               @doc "foo function" foo(x) = x + 1
@@ -85,9 +112,9 @@ try
                   pool::NominalPool{T, R, NominalValue{T, R}}
               end
               (::Union{Type{NominalValue}, Type{OrdinalValue}})() = 1
-              (::Union{Type{NominalValue{T}}, Type{OrdinalValue{T}}}){T}() = 2
-              (::Type{Vector{NominalValue{T, R}}}){T, R}() = 3
-              (::Type{Vector{NominalValue{T, T}}}){T}() = 4
+              (::Union{Type{NominalValue{T}}, Type{OrdinalValue{T}}})() where {T} = 2
+              (::Type{Vector{NominalValue{T, R}}})() where {T, R} = 3
+              (::Type{Vector{NominalValue{T, T}}})() where {T} = 4
               (::Type{Vector{NominalValue{Int, Int}}})() = 5
 
               # more tests for method signature involving a complicated type
@@ -98,9 +125,9 @@ try
               struct Value18343{T, R}
                   pool::Pool18343{R, Value18343{T, R}}
               end
-              Base.convert{S}(::Type{Nullable{S}}, ::Value18343{Nullable}) = 2
+              Base.convert(::Type{Nullable{S}}, ::Value18343{Nullable}) where {S} = 2
               Base.convert(::Type{Nullable{Value18343}}, ::Value18343{Nullable}) = 2
-              Base.convert{T}(::Type{Ref}, ::Value18343{T}) = 3
+              Base.convert(::Type{Ref}, ::Value18343{T}) where {T} = 3
 
 
               let some_method = @which Base.include("string")
@@ -109,6 +136,9 @@ try
                       ccall(:jl_specializations_get_linfo, Ref{Core.MethodInstance}, (Any, Any, Any, UInt),
                           some_method, Tuple{typeof(Base.include), String}, Core.svec(), typemax(UInt))
               end
+
+              g() = override(1.0)
+              Base.Test.@test g() === 2.0 # compile this
           end
           """)
     @test_throws ErrorException Core.kwfunc(Base.nothing) # make sure `nothing` didn't have a kwfunc (which would invalidate the attempted test)
@@ -116,19 +146,40 @@ try
     # Issue #12623
     @test __precompile__(true) === nothing
 
+    # Issue #21307
+    Base.require(Foo2_module)
+    @eval let Foo2_module = $(QuoteNode(Foo2_module)), # use @eval to see the results of loading the compile
+              Foo = getfield(Main, Foo2_module)
+        Foo.override(::Int) = 'a'
+        Foo.override(::Float32) = 'b'
+    end
+
     Base.require(Foo_module)
-    cachefile = joinpath(dir, "$Foo_module.ji")
 
+    @eval let Foo_module = $(QuoteNode(Foo_module)), # use @eval to see the results of loading the compile
+              Foo = getfield(Main, Foo_module)
+        @test Foo.foo(17) == 18
+        @test Foo.Bar.bar(17) == 19
+
+        # Issue #21307
+        @test Foo.g() === 97.0
+        @test Foo.override(1.0e0) == Float64('a')
+        @test Foo.override(1.0f0) == 'b'
+        @test Foo.override(UInt(1)) == 2
+    end
+
+    cachefile = joinpath(dir, "$Foo_module.ji")
     # use _require_from_serialized to ensure that the test fails if
     # the module doesn't reload from the image:
-    @test_warn "WARNING: replacing module Foo4b3a94a1a081a8cb.\nWARNING: Method definition " begin
-        @test isa(Base._require_from_serialized(myid(), Foo_module, cachefile, #=broadcast-load=#false), Array{Any,1})
+    @test_warn "WARNING: replacing module $Foo_module." begin
+        @test isa(Base._require_from_serialized(Foo_module, cachefile), Array{Any,1})
     end
 
     let Foo = getfield(Main, Foo_module)
         @test_throws MethodError Foo.foo(17) # world shouldn't be visible yet
     end
     @eval let Foo_module = $(QuoteNode(Foo_module)), # use @eval to see the results of loading the compile
+              Foo2_module = $(QuoteNode(Foo2_module)),
               FooBase_module = $(QuoteNode(FooBase_module)),
               Foo = getfield(Main, Foo_module),
               dir = $(QuoteNode(dir)),
@@ -137,17 +188,23 @@ try
         @test Foo.foo(17) == 18
         @test Foo.Bar.bar(17) == 19
 
+        # Issue #21307
+        @test Foo.g() === 97.0
+        @test Foo.override(1.0e0) == Float64('a')
+        @test Foo.override(1.0f0) == 'b'
+        @test Foo.override(UInt(1)) == 2
+
         # issue #12284:
         @test stringmime("text/plain", Base.Docs.doc(Foo.foo)) == "foo function\n"
         @test stringmime("text/plain", Base.Docs.doc(Foo.Bar.bar)) == "bar function\n"
 
-        modules, deps = Base.parse_cache_header(cachefile)
+        modules, deps, required_modules = Base.parse_cache_header(cachefile)
         @test modules == Dict(Foo_module => Base.module_uuid(Foo))
         @test map(x -> x[1],  sort(deps)) == [Foo_file, joinpath(dir, "bar.jl"), joinpath(dir, "foo.jl")]
 
         modules, deps1 = Base.cache_dependencies(cachefile)
-        @test sort(modules) == Any[(s, Base.module_uuid(getfield(Foo, s))) for s in
-                                   [:Base, :Core, FooBase_module, :Main]]
+        @test modules == Dict(s => Base.module_uuid(getfield(Foo, s)) for s in
+                                    [:Base, :Core, Foo2_module, FooBase_module, :Main])
         @test deps == deps1
 
         @test current_task()(0x01, 0x4000, 0x30031234) == 2
@@ -229,7 +286,7 @@ try
     @test !isdefined(Main, :FooBar1)
 
     relFooBar_file = joinpath(dir, "subfolder", "..", "FooBar.jl")
-    @test Base.stale_cachefile(relFooBar_file, joinpath(dir, "FooBar.ji")) == !is_windows() # `..` is not a symlink on Windows
+    @test Base.stale_cachefile(relFooBar_file, joinpath(dir, "FooBar.ji")) == !Sys.iswindows() # `..` is not a symlink on Windows
     mkdir(joinpath(dir, "subfolder"))
     @test !Base.stale_cachefile(relFooBar_file, joinpath(dir, "FooBar.ji"))
 
@@ -267,6 +324,12 @@ try
     @test !Base.stale_cachefile(FooBar_file, joinpath(dir2, "FooBar.ji"))
     @test !Base.stale_cachefile(FooBar1_file, joinpath(dir2, "FooBar1.ji"))
 
+    # test checksum
+    open(joinpath(dir2, "FooBar1.ji"), "a") do f
+        write(f, 0x076cac96) # append 4 random bytes
+    end
+    @test Base.stale_cachefile(FooBar1_file, joinpath(dir2, "FooBar1.ji"))
+
     # test behavior of precompile modules that throw errors
     write(FooBar_file,
           """
@@ -282,6 +345,41 @@ try
         isa(exc, ErrorException) || rethrow(exc)
         !isempty(search(exc.msg, "ERROR: LoadError: break me")) && rethrow(exc)
     end
+
+    # Test transitive dependency for #21266
+    FooBarT_file = joinpath(dir, "FooBarT.jl")
+    write(FooBarT_file,
+          """
+          __precompile__(true)
+          module FooBarT
+          end
+          """)
+    FooBarT1_file = joinpath(dir, "FooBarT1.jl")
+    write(FooBarT1_file,
+          """
+          __precompile__(true)
+          module FooBarT1
+              using FooBarT
+          end
+          """)
+    FooBarT2_file = joinpath(dir, "FooBarT2.jl")
+    write(FooBarT2_file,
+          """
+          __precompile__(true)
+          module FooBarT2
+              using FooBarT1
+          end
+          """)
+    Base.compilecache("FooBarT2")
+    write(FooBarT1_file,
+          """
+          __precompile__(true)
+          module FooBarT1
+          end
+          """)
+    rm(FooBarT_file)
+    @test Base.stale_cachefile(FooBarT2_file, joinpath(dir2, "FooBarT2.ji"))
+    @test Base.require(:FooBarT2) === nothing
 finally
     splice!(Base.LOAD_CACHE_PATH, 1:2)
     splice!(LOAD_PATH, 1)
@@ -333,10 +431,112 @@ let dir = mktempdir(),
     end
 end
 
+# test loading a package with conflicting namespace
+let dir = mktempdir()
+    Test_module = :Test6c92f26
+    try
+        write(joinpath(dir, "Iterators.jl"),
+              """
+              module Iterators
+                   __precompile__(true)
+              end
+              """)
+
+        write(joinpath(dir, "$Test_module.jl"),
+              """
+              module $Test_module
+                   __precompile__(true)
+                   using Iterators
+              end
+              """)
+
+        testcode = """
+            insert!(LOAD_PATH, 1, $(repr(dir)))
+            insert!(Base.LOAD_CACHE_PATH, 1, $(repr(dir)))
+            using $Test_module
+        """
+
+        exename = `$(Base.julia_cmd()) --startup-file=no`
+        let fname = tempname()
+            try
+                @test readchomp(pipeline(`$exename -E $(testcode)`, stderr=fname)) == "nothing"
+                @test Test.ismatch_warn("WARNING: replacing module $Test_module.\n", read(fname, String))
+            finally
+                rm(fname, force=true)
+            end
+        end
+        # Loading $Test_module from the cache should not bring `Base.Iterators`
+        # into `Main`, since that would lead to a namespace conflict with
+        # the module `Iterators` defined above.
+        let fname = tempname()
+            try
+                @test readchomp(pipeline(`$exename -E $(testcode)`, stderr=fname)) == "nothing"
+                # e.g `@test_nowarn`
+                @test Test.ismatch_warn(r"^(?!.)"s, read(fname, String))
+            finally
+                rm(fname, force=true)
+            end
+        end
+    finally
+        rm(dir, recursive=true)
+    end
+end
+
+let dir = mktempdir()
+    try
+        insert!(LOAD_PATH, 1, dir)
+        insert!(Base.LOAD_CACHE_PATH, 1, dir)
+
+        loaded_modules = Channel{Symbol}(32)
+        callback = (mod::Symbol) -> put!(loaded_modules, mod)
+        push!(Base.package_callbacks, callback)
+
+        Test1_module = :Teste4095a81
+        Test2_module = :Teste4095a82
+        Test3_module = :Teste4095a83
+
+        write(joinpath(dir, "$(Test1_module).jl"),
+              """
+              module $(Test1_module)
+                  __precompile__(true)
+              end
+              """)
+
+        Base.compilecache("$(Test1_module)")
+        write(joinpath(dir, "$(Test2_module).jl"),
+              """
+              module $(Test2_module)
+                  __precompile__(true)
+                  using $(Test1_module)
+              end
+              """)
+        Base.compilecache("$(Test2_module)")
+        @test !Base.isbindingresolved(Main, Test2_module)
+        Base.require(Test2_module)
+        @test Base.isbindingresolved(Main, Test2_module)
+        @test take!(loaded_modules) == Test1_module
+        @test take!(loaded_modules) == Test2_module
+        write(joinpath(dir, "$(Test3_module).jl"),
+              """
+              module $(Test3_module)
+                  using $(Test3_module)
+              end
+              """)
+        Base.require(Test3_module)
+        @test take!(loaded_modules) == Test3_module
+    finally
+        pop!(Base.package_callbacks)
+        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")
-    sleep(2); touch(file_name)
+    sleep(2)
+    touch(file_name)
     code = """module $(module_name)\nend\n"""
     write(file_name, code)
     reload(module_name)
@@ -345,4 +545,64 @@ let module_name = string("a",randstring())
     rm(file_name)
 end
 
+# Issue #19960
+let
+    test_workers = addprocs(1)
+    push!(test_workers, myid())
+    save_cwd = pwd()
+    temp_path = mktempdir()
+    try
+        cd(temp_path)
+        load_path = mktempdir(temp_path)
+        load_cache_path = mktempdir(temp_path)
+
+        ModuleA = :Issue19960A
+        ModuleB = :Issue19960B
+
+        write(joinpath(load_path, "$ModuleA.jl"),
+            """
+            __precompile__(true)
+            module $ModuleA
+                export f
+                f() = myid()
+            end
+            """)
+
+        write(joinpath(load_path, "$ModuleB.jl"),
+            """
+            __precompile__(true)
+            module $ModuleB
+                using $ModuleA
+                export g
+                g() = f()
+            end
+            """)
+
+        @everywhere test_workers begin
+            unshift!(LOAD_PATH, $load_path)
+            unshift!(Base.LOAD_CACHE_PATH, $load_cache_path)
+        end
+        try
+            @eval using $ModuleB
+            uuid = Base.module_uuid(getfield(Main, ModuleB))
+            for wid in test_workers
+                @test Base.Distributed.remotecall_eval(Main, wid, :( Base.module_uuid($ModuleB) )) == uuid
+                if wid != myid() # avoid world-age errors on the local proc
+                    @test remotecall_fetch(g, wid) == wid
+                end
+            end
+        finally
+            @everywhere test_workers begin
+                shift!(LOAD_PATH)
+                shift!(Base.LOAD_CACHE_PATH)
+            end
+        end
+    finally
+        cd(save_cwd)
+        rm(temp_path, recursive=true)
+        pop!(test_workers) # remove myid
+        rmprocs(test_workers)
+    end
+end
+
 end # !withenv
diff --git a/test/complex.jl b/test/complex.jl
index 6df11be21f99b5..e1428a826573e1 100644
--- a/test/complex.jl
+++ b/test/complex.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 @test reim(2 + 3im) == (2, 3)
 
@@ -883,6 +883,7 @@ end
     @test exp2(1.0+0.0im) == 2.0+0.0im
     #wolframalpha
     @test exp2(1.0+3.0im) ≈ -0.9739888359315627962096198412+1.74681016354974281701922im
+    @test exp2(im) ≈ 0.7692389013639721 + 0.6389612763136348im
 end
 
 @testset "exp10" begin
@@ -890,6 +891,7 @@ end
     @test exp10(1.0+0.0im) == 10.0+0.0im
     #wolframalpha
     @test exp10(1.0+2.0im) ≈ -1.0701348355877020772086517528518239460495529361-9.9425756941378968736161937190915602112878340717im
+    @test exp10(im) ≈ -0.6682015101903132 + 0.7439803369574931im
 end
 
 @testset "round and float, PR #8291" begin
@@ -943,3 +945,45 @@ end
 
 # issue #19240
 @test big(1)/(10+10im) ≈ (5-5im)/big(100) ≈ big"0.05" - big"0.05"*im
+
+@testset "Complex Irrationals, issue #21204" begin
+    for x in (pi, e, catalan) # No need to test all of them
+        z = Complex(x, x)
+        @test typeof(z) == Complex{typeof(x)}
+        @test exp(z) ≈ exp(x) * cis(x)
+        @test log1p(z) ≈ log(1 + z)
+        @test exp2(z) ≈ exp(z * log(2))
+        @test exp10(z) ≈ exp(z * log(10))
+    end
+end
+
+@testset "expm1 type stability" begin
+    x = @inferred expm1(0.1im)
+    @test x isa Complex128
+    x = @inferred expm1(0.1f0im)
+    @test x isa Complex64
+end
+
+@testset "array printing with exponent format" begin
+    a = [1.0 + 1e-10im, 2.0e-15 - 2.0e-5im, 1.0e-15 + 2im, 1.0 + 2e-15im]
+    @test sprint((io, x) -> show(io, MIME("text/plain"), x), a) ==
+        join([
+            "4-element Array{Complex{Float64},1}:",
+            "     1.0 + 1.0e-10im",
+            " 2.0e-15 - 2.0e-5im ",
+            " 1.0e-15 + 2.0im    ",
+            "     1.0 + 2.0e-15im"], "\n")
+end
+
+@testset "corner cases of division, issue #22983" begin
+    # These results abide by ISO/IEC 10967-3:2006(E) and
+    # mathematical definition of division of complex numbers.
+    for T in (Float32, Float64, BigFloat)
+        @test isequal(one(T) / zero(Complex{T}), one(Complex{T}) / zero(Complex{T}))
+        @test isequal(one(T) / zero(Complex{T}), Complex{T}(NaN, NaN))
+        @test isequal(one(Complex{T}) / zero(T), Complex{T}(Inf, NaN))
+        @test isequal(one(Complex{T}) / one(Complex{T}), one(Complex{T}))
+        @test isequal(one(T) / complex(one(T),  zero(T)), Complex(one(T), -zero(T)))
+        @test isequal(one(T) / complex(one(T), -zero(T)), Complex(one(T),  zero(T)))
+    end
+end
diff --git a/test/copy.jl b/test/copy.jl
index 015e3b3e507bf7..ae7ce7d58b7db2 100644
--- a/test/copy.jl
+++ b/test/copy.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 mainres = ([4, 5, 3],
            [1, 5, 3])
@@ -48,6 +48,20 @@ for (dest, src, bigsrc, emptysrc, res) in [
     @test_throws BoundsError copy!(dest, 1, src(), 2, 2)
 end
 
+let A = reshape(1:6, 3, 2), B = similar(A)
+    RA = CartesianRange(indices(A))
+    copy!(B, RA, A, RA)
+    @test B == A
+end
+let A = reshape(1:6, 3, 2), B = zeros(8,8)
+    RA = CartesianRange(indices(A))
+    copy!(B, CartesianRange((5:7,2:3)), A, RA)
+    @test B[5:7,2:3] == A
+    B[5:7,2:3] = 0
+    @test all(x->x==0, B)
+end
+
+
 # test behavior of shallow and deep copying
 let a = Any[[1]], q = QuoteNode([1])
     ca = copy(a); dca = @inferred(deepcopy(a))
@@ -128,4 +142,3 @@ end
         @test bar2.fooDict[bar2.foo] != nothing
     end
 end
-
diff --git a/test/core.jl b/test/core.jl
index c9c5d809df66f9..df919f11c182ce 100644
--- a/test/core.jl
+++ b/test/core.jl
@@ -1,12 +1,12 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # test core language features
 const Bottom = Union{}
-const curmod = current_module()
-const curmod_name = fullname(curmod)
-const curmod_prefix = "$(["$m." for m in curmod_name]...)"
 
-f47{T}(x::Vector{Vector{T}}) = 0
+# For curmod_*
+include("testenv.jl")
+
+f47(x::Vector{Vector{T}}) where {T} = 0
 @test_throws MethodError f47(Array{Vector}(0))
 @test f47(Array{Vector{Int}}(0)) == 0
 
@@ -20,62 +20,28 @@ f47{T}(x::Vector{Vector{T}}) = 0
 @test_throws TypeError (Array{T} where T<:Vararg{Int})
 @test_throws TypeError (Array{T} where T<:Vararg{Int,2})
 
-# issue #8652
-args_morespecific(a, b) = ccall(:jl_type_morespecific, Cint, (Any,Any), a, b) != 0
-let
-    a  = Tuple{Type{T1}, T1} where T1<:Integer
-    b2 = Tuple{Type{T2}, Integer} where T2<:Integer
-    @test args_morespecific(a, b2)
-    @test !args_morespecific(b2, a)
-    a  = Tuple{Type{T1}, Ptr{T1}} where T1<:Integer
-    b2 = Tuple{Type{T2}, Ptr{Integer}} where T2<:Integer
-    @test args_morespecific(a, b2)
-    @test !args_morespecific(b2, a)
+# issue #12939
+module Issue12939
+abstract type Abs; end
+struct Foo <: Abs; end
+struct Bar; val::Int64; end
+struct Baz; val::Int64; end
+f(::Type{T}, x::T) where {T} = T(3)
+f(::Type{Bar}, x::T) where {T <: Abs} = Bar(2)
+f(::Type{Bar}, x) = Bar(1)
+f(::Type{Baz}, x) = Baz(1)
+f(::Type{Baz}, x::T) where {T <: Abs} = Baz(2)
 end
 
-# issue #11534
-let
-    t1 = Tuple{AbstractArray, Tuple{Vararg{RangeIndex}}}
-    t2 = Tuple{Array, T} where T<:Tuple{Vararg{RangeIndex}}
-    @test !args_morespecific(t1, t2)
-    @test  args_morespecific(t2, t1)
-end
-
-let
-    a = Tuple{Array{T,N}, Vararg{Int,N}} where T where N
-    b = Tuple{Array,Int}
-    @test  args_morespecific(a, b)
-    @test !args_morespecific(b, a)
-    a = Tuple{Array, Vararg{Int,N}} where N
-    @test !args_morespecific(a, b)
-    @test  args_morespecific(b, a)
-end
-
-# another specificity issue
-_z_z_z_(x, y) = 1
-_z_z_z_(::Int, ::Int, ::Vector) = 2
-_z_z_z_(::Int, c...) = 3
-@test _z_z_z_(1, 1, []) == 2
-
-@test  args_morespecific(Tuple{T,Vararg{T}} where T<:Number,  Tuple{Number,Number,Vararg{Number}})
-@test !args_morespecific(Tuple{Number,Number,Vararg{Number}}, Tuple{T,Vararg{T}} where T<:Number)
-
-@test args_morespecific(Tuple{Array{T} where T<:Union{Float32,Float64,Complex64,Complex128}, Any},
-                        Tuple{Array{T} where T<:Real, Any})
-
-# with bound varargs
-
-_bound_vararg_specificity_1{T,N}(::Type{Array{T,N}}, d::Vararg{Int, N}) = 0
-_bound_vararg_specificity_1{T}(::Type{Array{T,1}}, d::Int) = 1
-@test _bound_vararg_specificity_1(Array{Int,1}, 1) == 1
-@test _bound_vararg_specificity_1(Array{Int,2}, 1, 1) == 0
+@test Issue12939.f(Issue12939.Baz,Issue12939.Foo()) === Issue12939.Baz(2)
+@test Issue12939.f(Issue12939.Bar,Issue12939.Foo()) === Issue12939.Bar(2)
 
 # issue #11840
 TT11840{T} = Tuple{T,T}
 f11840(::Type) = "Type"
 f11840(::DataType) = "DataType"
 f11840(::UnionAll) = "UnionAll"
-f11840{T<:Tuple}(::Type{T}) = "Tuple"
+f11840(::Type{T}) where {T<:Tuple} = "Tuple"
 @test f11840(Type) == "UnionAll"
 @test f11840(Type.body) == "DataType"
 @test f11840(Union{Int,Int8}) == "Type"
@@ -84,7 +50,7 @@ f11840{T<:Tuple}(::Type{T}) = "Tuple"
 
 g11840(::DataType) = 1
 g11840(::Type) = 2
-g11840{T<:Tuple}(sig::Type{T}) = 3
+g11840(sig::Type{T}) where {T<:Tuple} = 3
 @test g11840(Vector.body) == 1
 @test g11840(Vector) == 2
 @test g11840(Vector.body) == 1
@@ -97,7 +63,7 @@ g11840b(::Type) = 2
 # FIXME (needs a test): how to compute that the guard entry is still required,
 # even though Type{Vector} ∩ DataType = Bottom and this method would set
 # cache_with_orig = true
-g11840b{T<:Tuple}(sig::Type{T}) = 3
+g11840b(sig::Type{T}) where {T<:Tuple} = 3
 @test g11840b(Vector) == 2
 @test g11840b(Vector.body) == 1
 @test g11840b(Vector) == 2
@@ -108,7 +74,7 @@ g11840b{T<:Tuple}(sig::Type{T}) = 3
 h11840(::DataType) = '1'
 h11840(::Type) = '2'
 h11840(::UnionAll) = '3'
-h11840{T<:Tuple}(::Type{T}) = '4'
+h11840(::Type{T}) where {T<:Tuple} = '4'
 @test h11840(Vector) == '3'
 @test h11840(Vector.body) == '1'
 @test h11840(Vector) == '3'
@@ -159,7 +125,7 @@ end
 @test promote_type(Bool,Bottom) === Bool
 
 # ntuples
-nttest1{n}(x::NTuple{n,Int}) = n
+nttest1(x::NTuple{n,Int}) where {n} = n
 @test nttest1(()) == 0
 @test nttest1((1,2)) == 2
 @test NTuple <: Tuple
@@ -170,6 +136,8 @@ nttest1{n}(x::NTuple{n,Int}) = n
 
 # #17198
 @test_throws MethodError convert(Tuple{Int}, (1.0, 2.0, 3.0))
+# #21238
+@test_throws MethodError convert(Tuple{Int,Int,Int}, (1, 2))
 
 # type declarations
 
@@ -199,6 +167,26 @@ abstract type Sup2a_ end
 abstract type Sup2b_{A <: Sup2a_, B} <: Sup2a_ end
 @test_throws ErrorException @eval abstract type Qux2_{T} <: Sup2b_{Qux2_{Int}, T} end # wrapped in eval to avoid #16793
 
+# issue #21923
+struct A21923{T,N}; v::Vector{A21923{T}}; end
+@test fieldtype(A21923,1) == Vector{A21923{T}} where T
+struct B21923{T,N}; v::Vector{B21923{T,M} where M}; end
+@test fieldtype(B21923, 1) == Vector{B21923{T,M} where M} where T
+struct C21923{T,N}; v::C21923{T,M} where M; end
+@test fieldtype(C21923, 1) == C21923
+struct D21923{T,N}; v::D21923{T}; end
+@test fieldtype(D21923, 1) == D21923
+
+# issue #22624, more circular definitions
+struct T22624{A,B,C}; v::Vector{T22624{Int64,A}}; end
+let elT = T22624.body.body.body.types[1].parameters[1]
+    @test elT == T22624{Int64, T22624.var, C} where C
+    elT2 = elT.body.types[1].parameters[1]
+    @test elT2 == T22624{Int64, Int64, C} where C
+    @test elT2.body.types[1].parameters[1] === elT2
+    @test isleaftype(elT2.body.types[1])
+end
+
 # issue #3890
 mutable struct A3890{T1}
     x::Matrix{Complex{T1}}
@@ -263,7 +251,7 @@ let
     @test foo() === convert(Int8,100)
 end
 
-function bar{T}(x::T)
+function bar(x::T) where T
     local z::Complex{T}
     z = x
     z
@@ -292,21 +280,21 @@ fib(n) = n < 2 ? n : fib(n-1) + fib(n-2)
 @test fib(20) == 6765
 
 # static parameters
-sptest1{T}(x::T, y::T) = 42
-sptest1{T,S}(x::T, y::S) = 43
+sptest1(x::T, y::T) where {T} = 42
+sptest1(x::T, y::S) where {T,S} = 43
 @test sptest1(1,2) == 42
 @test sptest1(1,"b") == 43
 
-sptest2{T}(x::T) = T
+sptest2(x::T) where {T} = T
 @test ===(sptest2(:a),Symbol)
 
-sptest3{T}(x::T) = y->T
+sptest3(x::T) where {T} = y->T
 let m = sptest3(:a)
     @test ===(m(0),Symbol)
 end
 
-sptest4{T}(x::T, y::T) = 42
-sptest4{T}(x::T, y) = 44
+sptest4(x::T, y::T) where {T} = 42
+sptest4(x::T, y) where {T} = 44
 @test sptest4(1,2) == 42
 @test sptest4(1, "cat") == 44
 
@@ -382,16 +370,27 @@ glotest()
 @test loc_x == 10
 
 # issue #7234
+f7234_cnt = 0
 begin
     glob_x2 = 24
-    f7234_a() = (glob_x2 += 1)
+    function f7234_a()
+        global f7234_cnt += 1
+        glob_x2 += 1
+        global f7234_cnt += -10000
+    end
 end
 @test_throws UndefVarError f7234_a()
+@test f7234_cnt == 1
 begin
     global glob_x2 = 24
-    f7234_b() = (glob_x2 += 1)
+    function f7234_b()
+        global f7234_cnt += 1
+        glob_x2 += 1
+        global f7234_cnt += -10000
+    end
 end
 @test_throws UndefVarError f7234_b()
+@test f7234_cnt == 2
 # existing globals can be inherited by non-function blocks
 for i = 1:2
     glob_x2 += 1
@@ -430,16 +429,23 @@ end
 @test h19333() == 4
 
 # let - new variables, including undefinedness
+let_undef_cnt = 0
 function let_undef()
     first = true
     for i = 1:2
-        let x
-            if first; x=1; first=false; end
-            x+1
+        let x # new x
+            if first # not defined on second pass
+                x = 1
+                first = false
+            end
+            global let_undef_cnt += 1
+            x + 1
+            global let_undef_cnt += 23
         end
     end
 end
 @test_throws UndefVarError let_undef()
+@test let_undef_cnt == 25
 
 # const implies local in a local scope block
 function const_implies_local()
@@ -465,6 +471,77 @@ end
 @test a[2](10) == 12
 @test a[3](10) == 13
 
+# issue #22032
+let a = [], fs = []
+    for f() in 1:3
+        push!(a, f())
+        push!(fs, f)
+    end
+    @test a == [1,2,3]
+    @test [f() for f in fs] == [1,2,3]
+end
+let t = (22,33)
+    (g(), x) = t
+    @test g() == 22
+    @test x == 33
+end
+
+# issue #23091
+let (f(), x) = (1, 2)
+    @test f() == 1
+    @test x == 2
+end
+
+# issue #21900
+f21900_cnt = 0
+function f21900()
+    for i = 1:1
+        x = 0
+    end
+    global f21900_cnt += 1
+    x
+    global f21900_cnt += -1000
+    nothing
+end
+@test_throws UndefVarError f21900()
+@test f21900_cnt == 1
+
+@test_throws UndefVarError @eval begin
+    for i21900 = 1:10
+        for j21900 = 1:10
+            foo21900 = 10
+        end
+        bar21900 = 0
+        bar21900 = foo21900 + 1
+    end
+end
+@test !@isdefined(foo21900)
+@test !@isdefined(bar21900)
+bar21900 = 0
+@test_throws UndefVarError @eval begin
+    for i21900 = 1:10
+        for j21900 = 1:10
+            foo21900 = 10
+        end
+        bar21900 = -1
+        bar21900 = foo21900 + 1
+    end
+end
+@test bar21900 == -1
+@test !@isdefined foo21900
+foo21900 = 0
+@test nothing === @eval begin
+    for i21900 = 1:10
+        for j21900 = 1:10
+            foo21900 = 10
+        end
+        bar21900 = -1
+        bar21900 = foo21900 + 1
+    end
+end
+@test foo21900 == 10
+@test bar21900 == 11
+
 # ? syntax
 @test (true ? 1 : false ? 2 : 3) == 1
 
@@ -533,21 +610,21 @@ let
     @test_throws MethodError foo2(1)
     @test_throws MethodError foo2(1,2,3)
 
-    fooN{T,N}(A::Array{T,N}, x::Vararg{Any,N}) = -1
+    fooN(A::Array{T,N}, x::Vararg{Any,N}) where {T,N} = -1
     @test fooN([1,2], 1) == -1
     @test_throws MethodError fooN([1,2], 1, 2) == -1
     @test fooN([1 2; 3 4], 1, 2) == -1
     @test_throws MethodError fooN([1 2; 3 4], 1)
     @test_throws MethodError fooN([1 2; 3 4], 1, 2, 3)
 
-    bar{T}(x::Tuple{T,T,T,T})=1
+    bar(x::Tuple{T,T,T,T}) where {T} = 1
     bar(x::Tuple{Any,Any,Any,Any})=2
     @test bar((1,1,1,1)) == 1
     @test bar((1,1,1,"a")) == 2
     @test bar((:a,:a,:a,:a)) == 1
 
     baz(::Type{Rational}) = 1
-    baz{T}(::Type{Rational{T}}) = 2
+    baz(::Type{Rational{T}}) where {T} = 2
     @test baz(Rational) == 1
     @test baz(Rational{Int}) == 2
 end
@@ -566,15 +643,15 @@ end
 let
     local x
     x = MyArray{1}()
-    foob(x::AbstractArray)=0
-    foob{T}(x::AbstractVector{T})=1
+    foob(x::AbstractArray) = 0
+    foob(x::AbstractVector{T}) where {T} = 1
     @test foob(x) == 1
 end
 
 let
     local f, g, a
-    f{T}(a::Vector{Vector{T}}) = a
-    g{T}(a::Vector{Vector{T}}) = a
+    f(a::Vector{Vector{T}}) where {T} = a
+    g(a::Vector{Vector{T}}) where {T} = a
     a = Vector{Int}[]
     @test ===(f(a), a)
     @test ===(g(a), a)
@@ -584,34 +661,19 @@ mutable struct _AA{T}; a::T; end
 _AoA{T} = _AA{_AA{T}}
 let
     local g, a
-    g{T}(a::_AA{_AA{T}}) = a
+    g(a::_AA{_AA{T}}) where {T} = a
     a = _AA(_AA(1))
     @test ===(g(a),a)
 end
 
-# Method specificity
-begin
-    local f, A
-    f{T}(dims::Tuple{}, A::AbstractArray{T,0}) = 1
-    f{T,N}(dims::NTuple{N,Int}, A::AbstractArray{T,N}) = 2
-    f{T,M,N}(dims::NTuple{M,Int}, A::AbstractArray{T,N}) = 3
-    A = zeros(2,2)
-    @test f((1,2,3), A) == 3
-    @test f((1,2), A) == 2
-    @test f((), reshape([1])) == 1
-    f{T,N}(dims::NTuple{N,Int}, A::AbstractArray{T,N}) = 4
-    @test f((1,2), A) == 4
-    @test f((1,2,3), A) == 3
-end
-
-# dispatch using Val{T}. See discussion in #9452 for instances vs types
+# dispatch using Val{T}. See discussion in #9452, #22475 for instances vs types
 let
     local firstlast
-    firstlast(::Type{Val{true}}) = "First"
-    firstlast(::Type{Val{false}}) = "Last"
+    firstlast(::Val{true}) = "First"
+    firstlast(::Val{false}) = "Last"
 
-    @test firstlast(Val{true}) == "First"
-    @test firstlast(Val{false}) == "Last"
+    @test firstlast(Val(true)) == "First"
+    @test firstlast(Val(false)) == "Last"
 end
 
 # x::Vararg{Any} declarations
@@ -693,6 +755,7 @@ end
 let didthrow =
     try
         include_string(
+            @__MODULE__,
             """
             module TestInitError
                 __init__() = error()
@@ -798,16 +861,16 @@ end
 let
     local MatOrNot, my_func, M
     MatOrNot{T} = Union{AbstractMatrix{T}, Vector{Union{}}}
-    my_func{T<:Real}(A::MatOrNot{T}, B::MatOrNot{T}, C::MatOrNot{T}) = 0
+    my_func(A::MatOrNot{T}, B::MatOrNot{T}, C::MatOrNot{T}) where {T<:Real} = 0
     M = [ 2. 1. ; 1. 1. ]
     @test my_func(Union{}[], M, M) == 0
 end
 
 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
-    my_func{T}(P::Vector{T}, x::T) = 2
+    my_func(P::Vector{T}, Q::Vector{T}) where {T} = 0
+    my_func(x::T, P::Vector{T}) where {T} = 1
+    my_func(P::Vector{T}, x::T) where {T} = 2
     a = Int[3]
     c = Vector[a]
 
@@ -845,7 +908,7 @@ end
 
 import Base.*
 
-*{m1, m2, s1, s2, kg1, kg2}(x::SI{m1, s1, kg1}, y::SI{m2, s2, kg2}) = SI{m1 + m2, s1 + s2, kg1 + kg2}(x.value * y.value)
+*(x::SI{m1, s1, kg1}, y::SI{m2, s2, kg2}) where {m1, m2, s1, s2, kg1, kg2} = SI{m1 + m2, s1 + s2, kg1 + kg2}(x.value * y.value)
 
 let
     local a,b
@@ -906,7 +969,15 @@ let
     @test aa == a
     aa = unsafe_wrap(Array, pointer(a), UInt16(length(a)))
     @test aa == a
+    aaa = unsafe_wrap(Array, pointer(a), (1, 1))
+    @test size(aaa) == (1, 1)
+    @test aaa[1] == a[1]
     @test_throws InexactError unsafe_wrap(Array, pointer(a), -3)
+    # Misaligned pointer
+    res = @test_throws ArgumentError unsafe_wrap(Array, pointer(a) + 1, length(a))
+    @test contains(res.value.msg, "is not properly aligned to $(sizeof(Int)) bytes")
+    res = @test_throws ArgumentError unsafe_wrap(Array, pointer(a) + 1, (1, 1))
+    @test contains(res.value.msg, "is not properly aligned to $(sizeof(Int)) bytes")
 end
 
 struct FooBar2515
@@ -953,7 +1024,7 @@ end
 let
     local f1442
     f1442(::DataType) = 1
-    f1442{T}(::Type{S1442{T}}) = 2
+    f1442(::Type{S1442{T}}) where {T} = 2
 
     @test f1442(S1442{Int}) == 2
     @test f1442(DataType) == 1
@@ -977,7 +1048,7 @@ mutable struct Body <: Component
     Body() = new(0, 0)
 end
 
-function NewEntity{T<:Component}(components::Type{T}...)
+function NewEntity(components::Type{T}...) where T<:Component
     map((c)->c(), components)
 end
 
@@ -1014,12 +1085,12 @@ end
 
 # issue #1632
 let
-    f1632{R,S}(::R, ::S) = 1
-    f1632{T}(  ::T, ::T) = 2
+    f1632(::R, ::S) where {R,S} = 1
+    f1632(::T, ::T) where {T} = 2
     @test f1632(1, 2) == 2
     @test f1632(:a, 2) == 1
-    g1632{T}(  ::T, ::T) = 2
-    g1632{R,S}(::R, ::S) = 1
+    g1632(::T, ::T) where {T} = 2
+    g1632(::R, ::S) where {R,S} = 1
     @test g1632(1, 2) == 2
     @test g1632(:a, 2) == 1
 end
@@ -1042,7 +1113,7 @@ end
 
 # issue #2169
 let
-    i2169{T}(a::Array{T}) = typemin(T)
+    i2169(a::Array{T}) where {T} = typemin(T)
     @test invoke(i2169, Tuple{Array} ,Int8[1]) === Int8(-128)
 end
 
@@ -1077,8 +1148,8 @@ struct Foo2517; end
 mutable struct X1474{a,b} end
 let
     local Y
-    Y{A,B}(::Type{X1474{A,B}}) = 1
-    Y{A}(::Type{X1474{A}}) = 2
+    Y(::Type{X1474{A,B}}) where {A,B} = 1
+    Y(::Type{X1474{A}}) where {A} = 2
     Y(::Type{X1474}) = 3
     @test Y(X1474) == 3
     @test Y(X1474{Int}) == 2
@@ -1090,7 +1161,7 @@ mutable struct Node2562{T}
     value::T
     Node2562{T}(value::T) where T = new(value)
 end
-Node2562{T}(value::T, args...) = Node2562{T}(value, args...)
+Node2562(value::T, args...) where {T} = Node2562{T}(value, args...)
 makenode2562(value) = Node2562(value)
 @test isa(Node2562(0), Node2562)
 @test isa(makenode2562(0), Node2562)
@@ -1237,7 +1308,7 @@ mutable struct Baz4129
     b::Bar4129
 end
 
-foo4129(a::Baz4129,c::Foo4129,b::Bar4129,x::ANY,y) = (a,b,c,x,y)
+foo4129(a::Baz4129,c::Foo4129,b::Bar4129,@nospecialize(x),y) = (a,b,c,x,y)
 foo4129(a::Baz4129,b::Bar41291,args...) = foo4129(a,b.f,b,args...)
 foo4129(a::Baz4129,b::Bar41292,args...) = foo4129(a,b.f,b,args...)
 foo4129(a::Baz4129,args...)         = foo4129(a,a.b,args...)
@@ -1291,7 +1362,7 @@ end
 @test isa(Foo4376{Float32}(Foo4376{Int}(2)), Foo4376{Float32})
 
 mutable struct _0_test_ctor_syntax_
-    _0_test_ctor_syntax_{T<:AbstractString}(files::Vector{T},step) = 0
+    _0_test_ctor_syntax_(files::Vector{T},step) where {T<:AbstractString} = 0
 end
 
 # issue #4413
@@ -1310,7 +1381,7 @@ g4413(::Union{A4413, B4413, C4413}) = "ABC"
 # what happens here: the method cache logic wants to widen the type of a
 # tuple argument, but it shouldn't do that for an argument that a static
 # parameter depends on.
-f4482{T}(x::T) = T
+f4482(x::T) where {T} = T
 @test f4482((Ptr,Ptr)) === Tuple{UnionAll,UnionAll}
 @test f4482((Ptr,))    === Tuple{UnionAll,}
 
@@ -1356,10 +1427,11 @@ end
 
 # issue #4505
 let
-    g4505{X}(::X) = 0
+    g4505(::X) where {X} = 0
     @test g4505(0) == 0
 end
-@test !isdefined(:g4505)
+@test !@isdefined g4505
+@test !isdefined(@__MODULE__, :g4505)
 
 # issue #4681
 # ccall should error if convert() returns something of the wrong type
@@ -1392,9 +1464,9 @@ mutable struct SIQ{A,B} <: Number
     x::A
 end
 import Base: promote_rule
-promote_rule{T,T2,S,S2}(A::Type{SIQ{T,T2}},B::Type{SIQ{S,S2}}) = SIQ{promote_type(T,S)}
+promote_rule(A::Type{SIQ{T,T2}},B::Type{SIQ{S,S2}}) where {T,T2,S,S2} = SIQ{promote_type(T,S)}
 @test_throws ErrorException promote_type(SIQ{Int},SIQ{Float64})
-f4731{T}(x::T...) = 0
+f4731(x::T...) where {T} = 0
 f4731(x...) = ""
 g4731() = f4731()
 @test f4731() == ""
@@ -1402,9 +1474,9 @@ g4731() = f4731()
 
 # issue #4675
 f4675(x::StridedArray...) = 1
-f4675{T}(x::StridedArray{T}...) = 2
+f4675(x::StridedArray{T}...) where {T} = 2
 @test f4675(zeros(50,50), zeros(50,50)) == 2
-g4675{T}(x::StridedArray{T}...) = 2
+g4675(x::StridedArray{T}...) where {T} = 2
 g4675(x::StridedArray...) = 1
 @test g4675(zeros(50,50), zeros(50,50)) == 2
 
@@ -1423,7 +1495,7 @@ end # module
 abstract type IT4805{N, T} end
 
 let
-    test0{T <: Int64}(::Type{IT4805{1, T}}, x) = x
+    test0(::Type{IT4805{1, T}}, x) where {T <: Int64} = x
     test1() = test0(IT4805{1, Int64}, 1)
     test2() = test0(IT4805{1+0, Int64}, 1)
     test3(n) = test0(IT4805{n, Int64}, 1)
@@ -1490,7 +1562,7 @@ let
 end
 
 # issue #5254
-f5254{T}(::Type{T}, b::T) = 0
+f5254(::Type{T}, b::T) where {T} = 0
 f5254(a, b) = 1
 @test f5254(Bottom, 1) == 1
 
@@ -1513,7 +1585,7 @@ end
 
 # issue #5319
 cnvt(T, x) = convert_default(T, x, cnvt)
-cnvt{S, T, N}(::Type{Array{S, N}}, x::Array{T, N}) = convert(Array{S}, x)
+cnvt(::Type{Array{S, N}}, x::Array{T, N}) where {S, T, N} = convert(Array{S}, x)
 
 function tighttypes!(adf)
     T = Bottom
@@ -1586,7 +1658,7 @@ end
 
 # issue #5584
 # this is an intermittent memory bug, but this code is very likely to trigger it
-mapshape_5584{N}(s1::NTuple{N,Int}, s2::NTuple{N,Int}) =
+mapshape_5584(s1::NTuple{N,Int}, s2::NTuple{N,Int}) where {N} =
     (s1 == s2 || error("Argument dimensions are not map-compatible."); s1)
 function f5584()
     for i = 1:1000000
@@ -1657,14 +1729,20 @@ test5536(a::Union{Real, AbstractArray}) = "Non-splatting"
 @test test5536(5) == "Non-splatting"
 
 # multiline comments (#6139 and others raised in #6128) and embedded NUL chars (#10994)
-@test 3 == include_string("1 + 2") == include_string("1 + #==# 2") == include_string("1 + #===# 2") == include_string("1 + #= #= blah =# =# 2") == include_string("1 + #= #= #= nested =# =# =# 2") == include_string("1 + #= \0 =# 2")
-@test_throws LoadError include_string("#=")
-@test_throws LoadError include_string("#= #= #= =# =# =")
+@test 3 ==
+    include_string(@__MODULE__, "1 + 2") ==
+    include_string(@__MODULE__, "1 + #==# 2") ==
+    include_string(@__MODULE__, "1 + #===# 2") ==
+    include_string(@__MODULE__, "1 + #= #= blah =# =# 2") ==
+    include_string(@__MODULE__, "1 + #= #= #= nested =# =# =# 2") ==
+    include_string(@__MODULE__, "1 + #= \0 =# 2")
+@test_throws LoadError include_string(@__MODULE__, "#=")
+@test_throws LoadError include_string(@__MODULE__, "#= #= #= =# =# =")
 
 # issue #6142
 import Base: +
 mutable struct A6142 <: AbstractMatrix{Float64}; end
-+{TJ}(x::A6142, y::UniformScaling{TJ}) = "UniformScaling method called"
++(x::A6142, y::UniformScaling{TJ}) where {TJ} = "UniformScaling method called"
 +(x::A6142, y::AbstractArray) = "AbstractArray method called"
 @test A6142() + I == "UniformScaling method called"
 +(x::A6142, y::Range) = "Range method called" #16324 ambiguity
@@ -1676,7 +1754,7 @@ g6175(i, I...) = tuple(length(i), g6175(I...)...)
 @test g6175(1:5) === (5,)
 
 # issue #6242
-f6242{N}(x::NTuple{N,Int})=(N==0 ? 1 : ntuple(n->x[n],N))
+f6242(x::NTuple{N,Int}) where {N} = (N==0 ? 1 : ntuple(n->x[n],N))
 @test f6242(()) === 1
 
 # issue #6292
@@ -1695,10 +1773,10 @@ mutable struct type_1{T <: Number} <: Number
     x::Vector{T}
     type_1{T}(x::Vector{T}) where T<:Number = new(x)
 end
-type_1{T <: Number}(x::Vector{T}) = type_1{T}(x)
-type_1{T <: Number}(c::T) = type_1{T}([c])
-Base.convert{T<:Number, S<:Number}(::Type{type_1{T}}, x::S) = type_1(convert(T, x))
-+{T <: Number}(a::type_1{T}, b::type_1{T}) = a
+type_1(x::Vector{T}) where {T <: Number} = type_1{T}(x)
+type_1(c::T) where {T <: Number} = type_1{T}([c])
+Base.convert(::Type{type_1{T}}, x::S) where {T<:Number, S<:Number} = type_1(convert(T, x))
++(a::type_1{T}, b::type_1{T}) where {T <: Number} = a
 
 function func1_6404(v1::Integer)
     e1 = type_1([type_2{Int,v1}(0)])
@@ -1750,7 +1828,7 @@ end
 module A5876
 macro x()
     quote
-        function $(esc(:f5876)){T}(::Type{T})
+        function $(esc(:f5876))(::Type{T}) where T
             T
         end
         42
@@ -1775,7 +1853,7 @@ macro m20524(ex)
 end
 @m20524 ((a,(b20524,c)) = (8,(1,5)); (a,b20524,c))
 @test f20524() === (8,1,5)
-@test !isdefined(:b20524)  # should not assign to a global
+@test !@isdefined b20524 # should not assign to a global
 
 # issue #6387
 primitive type Date6387{C} 64 end
@@ -1789,7 +1867,7 @@ end
 
 obj6387 = ObjMember(DateRange6387{Int64}())
 
-function v6387{T}(r::Range{T})
+function v6387(r::Range{T}) where T
     a = Array{T}(1)
     a[1] = Core.Intrinsics.bitcast(Date6387{Int64}, Int64(1))
     return a
@@ -1862,14 +1940,14 @@ end
 @test ttt7049(init="a") == "init=a"
 
 # issue #7074
-let z{T<:Union{Float64,Complex{Float64},Float32,Complex{Float32}}}(A::StridedMatrix{T}) = T,
+let z(A::StridedMatrix{T}) where {T<:Union{Float64,Complex{Float64},Float32,Complex{Float32}}} = T,
     S = zeros(Complex,2,2)
     @test_throws MethodError z(S)
 end
 
 # issue #7062
-f7062{t,n}(::Type{Array{t}}  , ::Array{t,n}) = (t,n,1)
-f7062{t,n}(::Type{Array{t,n}}, ::Array{t,n}) = (t,n,2)
+f7062(::Type{Array{t}}  , ::Array{t,n}) where {t,n} = (t,n,1)
+f7062(::Type{Array{t,n}}, ::Array{t,n}) where {t,n} = (t,n,2)
 @test f7062(Array{Int,1}, [1,2,3]) === (Int,1,2)
 @test f7062(Array{Int}  , [1,2,3]) === (Int,1,1)
 
@@ -1911,8 +1989,8 @@ mutable struct A7652
 end
 a7652 = A7652(0)
 t_a7652 = A7652
-f7652() = issubtype(fieldtype(t_a7652, :a), Int)
-@test f7652() == issubtype(fieldtype(A7652, :a), Int) == true
+f7652() = fieldtype(t_a7652, :a) <: Int
+@test f7652() == (fieldtype(A7652, :a) <: Int) == true
 g7652() = fieldtype(DataType, :types)
 @test g7652() == fieldtype(DataType, :types) == SimpleVector
 @test fieldtype(t_a7652, 1) == Int
@@ -1990,19 +2068,6 @@ let x = Issue2403(20)
     @test issue2403func(x) == 34
 end
 
-# a method specificity issue
-c99991{T}(::Type{T},x::T) = 0
-c99991{T}(::Type{UnitRange{T}},x::StepRangeLen{T}) = 1
-c99991{T}(::Type{UnitRange{T}},x::Range{T}) = 2
-@test c99991(UnitRange{Float64}, 1.0:2.0) == 1
-@test c99991(UnitRange{Int}, 1:2) == 2
-
-# issue #17016, method specificity involving vararg tuples
-T_17016{N} = Tuple{Any,Any,Vararg{Any,N}}
-f17016(f, t::T_17016) = 0
-f17016(f, t1::Tuple) = 1
-@test f17016(0, (1,2,3)) == 0
-
 # issue #8798
 let
     const npy_typestrs = Dict("b1"=>Bool,
@@ -2090,7 +2155,7 @@ let x = [1,2,3]
 end
 
 # sig 2 is SIGINT per the POSIX.1-1990 standard
-if !is_windows()
+if !Sys.iswindows()
     ccall(:jl_exit_on_sigint, Void, (Cint,), 0)
     @test_throws InterruptException begin
         ccall(:kill, Void, (Cint, Cint,), getpid(), 2)
@@ -2207,7 +2272,7 @@ end
 # issue caused by commit 189b00aef0376d1a998d36115cd11b17464d26ce and worked around
 # by commit 24c64b86bd4e793dbfe9d85c067dc0579b320d14
 let
-    g{T}(x::T...) = T
+    g(x::T...) where {T} = T
     g(x...) = 0
     @test g((),Int) == 0
     @test g((),()) == Tuple{}
@@ -2276,7 +2341,7 @@ for m in methods(g10373)
 end
 
 # issue #7221
-f7221{T<:Number}(::T) = 1
+f7221(::T) where {T<:Number} = 1
 f7221(::BitArray) = 2
 f7221(::AbstractVecOrMat) = 3
 @test f7221(trues(1)) == 2
@@ -2828,7 +2893,7 @@ end
 @test f11357() === 1
 
 # issue #11355
-function f11355{T<:Tuple}(sig::Type{T})
+function f11355(sig::Type{T}) where T<:Tuple
     f11355(sig.parameters[1])
 end
 function f11355(arg::DataType)
@@ -2962,7 +3027,7 @@ f11858(Any[Type{Foo11858}, Type{Bar11858}, typeof(g11858)])
 # issue 11904
 @noinline throw_error() = error()
 foo11904(x::Int) = x
-@inline function foo11904{S}(x::Nullable{S})
+@inline function foo11904(x::Nullable{S}) where S
     if isbits(S)
         Nullable(foo11904(x.value), x.hasvalue)
     else
@@ -3056,7 +3121,7 @@ f12092(x::Int, y::Int...) = 2
 
 # issue #12063
 # NOTE: should have > MAX_TUPLETYPE_LEN arguments
-f12063{T}(tt, g, p, c, b, v, cu::T, d::AbstractArray{T, 2}, ve) = 1
+f12063(tt, g, p, c, b, v, cu::T, d::AbstractArray{T, 2}, ve) where {T} = 1
 f12063(args...) = 2
 g12063() = f12063(0, 0, 0, 0, 0, 0, 0.0, spzeros(0,0), Int[])
 @test g12063() == 1
@@ -3078,7 +3143,7 @@ struct Vec8010{T}
     y::T
 end
 Vec8010(a::AbstractVector) = Vec8010(ntuple(x->a[x],2)...)
-Base.convert{T}(::Type{Vec8010{T}},x::AbstractVector) = Vec8010(x)
+Base.convert(::Type{Vec8010{T}},x::AbstractVector) where {T} = Vec8010(x)
 Base.convert(::Type{Void},x::AbstractVector) = Vec8010(x)
 struct MyType8010
      m::Vec8010{Float32}
@@ -3158,17 +3223,17 @@ PossiblyInvalidUnion{T} = Union{T,Int}
 @test split(string(gensym("abc")),'#')[3] == "abc"
 
 # issue #13007
-call13007{T,N}(::Type{Array{T,N}}) = 0
+call13007(::Type{Array{T,N}}) where {T,N} = 0
 call13007(::Type{Array}) = 1
 @test length(Base._methods(call13007, Tuple{Type{x} where x<:Array}, 4, typemax(UInt))) == 2
 
 # detecting cycles during type intersection, e.g. #1631
-cycle_in_solve_tvar_constraints{S}(::Type{Nullable{S}}, x::S) = 0
-cycle_in_solve_tvar_constraints{T}(::Type{T}, x::Val{T}) = 1
+cycle_in_solve_tvar_constraints(::Type{Nullable{S}}, x::S) where {S} = 0
+cycle_in_solve_tvar_constraints(::Type{T}, x::Val{T}) where {T} = 1
 @test length(methods(cycle_in_solve_tvar_constraints)) == 2
 
 # issue #12967
-foo12967(x, ::ANY) = 1
+foo12967(x, @nospecialize y) = 1
 TupleType12967{T<:Tuple} = Type{T}
 foo12967(x, ::TupleType12967) = 2
 @test foo12967(1, Int) == 1
@@ -3206,7 +3271,7 @@ end
 @test EmptyIIOtherField13175(EmptyImmutable13175(), 1.0) != EmptyIIOtherField13175(EmptyImmutable13175(), 2.0)
 
 # issue #13183
-gg13183{X}(x::X...) = 1==0 ? gg13183(x, x) : 0
+gg13183(x::X...) where {X} = 1==0 ? gg13183(x, x) : 0
 @test gg13183(5) == 0
 
 # issue 8932 (llvm return type legalizer error)
@@ -3275,7 +3340,7 @@ end
 @test_throws MethodError Array{Type{Int64}}([Float32])
 abstract type A11327 end
 abstract type B11327 <: A11327 end
-f11327{T}(::Type{T},x::T) = x
+f11327(::Type{T},x::T) where {T} = x
 @test_throws MethodError f11327(Type{A11327},B11327)
 
 # issue #8487
@@ -3334,7 +3399,7 @@ end
 @test_throws ErrorException eval(Expr(:body, :(1)))
 
 # issue #14339
-f14339{T<:Union{}}(x::T, y::T) = 0
+f14339(x::T, y::T) where {T<:Union{}} = 0
 @test_throws MethodError f14339(1, 2)
 
 # Make sure jlcall objects are rooted
@@ -3399,7 +3464,7 @@ end
 @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
+let foo(x::Union{T,Void},y::Union{T,Void}) where {T} = 1
     @test foo(1, nothing) === 1
     @test_throws MethodError foo(nothing, nothing)  # can't determine T
 end
@@ -3443,7 +3508,7 @@ f14245() = (v = []; push!(v, length(v)); v)
 @test f14245()[1] == 0
 
 # issue #9677
-@generated function foo9677{T,N}(x::AbstractArray{T,N})
+@generated function foo9677(x::AbstractArray{T,N}) where {T,N}
     quote
         x=$N
         y=x+1
@@ -3574,11 +3639,11 @@ let ex = quote
 end
 
 # issue #15180
-function f15180{T}(x::T)
+function f15180(x::T) where T
     X = Array{T}(1)
     X[1] = x
-    @noinline ef{J}(::J) = (J,X[1]) # Use T
-    ef{J}(::J, ::Int) = (T,J)
+    @noinline ef(::J) where {J} = (J,X[1]) # Use T
+    ef(::J, ::Int) where {J} = (T,J)
     return ef
 end
 @test map(f15180(1), [1,2]) == [(Int,1),(Int,1)]
@@ -3693,16 +3758,16 @@ let
     k15283 = j15283+=1
 end
 @test j15283 == 1
-@test !isdefined(:k15283)
+@test !@isdefined k15283
 
 # issue #15264
 module Test15264
-    mod1{T}(x::T) = x < 1 ? x : mod1(x-1)
+    mod1(x::T) where {T} = x < 1 ? x : mod1(x-1)
 end
 @test Test15264.mod1 !== Base.mod1
 
 module M15455
-function rpm_provides{T}(r::T)
+function rpm_provides(r::T) where T
     push!([], select(r,T))
 end
 select(a,b) = 0
@@ -3716,7 +3781,7 @@ end
 # Make sure arrayset can handle `Array{T}` (where `T` is a type and not a
 # `TypeVar`) without crashing
 let
-    function arrayset_unknown_dim{T}(::Type{T}, n)
+    function arrayset_unknown_dim(::Type{T}, n) where T
         Base.arrayset(reshape(Vector{T}(1), ones(Int, n)...), 2, 1)
     end
     arrayset_unknown_dim(Any, 1)
@@ -3731,7 +3796,7 @@ module TestSharedArrayResize
 using Base.Test
 # Attempting to change the shape of a shared array should unshare it and
 # not modify the original data
-function test_shared_array_resize{T}(::Type{T})
+function test_shared_array_resize(::Type{T}) where T
     len = 100
     a = Vector{T}(len)
     function test_unshare(f)
@@ -3814,7 +3879,7 @@ end
 
 # Copy of `#undef`
 copy!(Vector{Any}(10), Vector{Any}(10))
-function test_copy_alias{T}(::Type{T})
+function test_copy_alias(::Type{T}) where T
     ary = T[1:100;]
     unsafe_copy!(ary, 1, ary, 11, 90)
     @test ary == [11:100; 91:100]
@@ -3867,7 +3932,7 @@ end
 # issue #15809 --- TODO: this code should be disallowed
 function f15809()
     global g15809
-    g15809{T}(x::T) = T
+    g15809(x::T) where {T} = T
 end
 f15809()
 @test g15809(2) === Int
@@ -3921,7 +3986,7 @@ function metadata_matches(ast::CodeInfo)
     @test boundscheck_cnt[] == 0
 end
 
-function test_metadata_matches(f::ANY, tt::ANY)
+function test_metadata_matches(@nospecialize(f), @nospecialize(tt))
     metadata_matches(code_typed(f, tt)[1][1])
 end
 
@@ -4129,16 +4194,16 @@ end
 
 # issue #16153
 f16153(x) = 1
-f16153(x::ANY, y...) = 2
+f16153(@nospecialize(x), y...) = 2
 @test f16153("") == 1
-ff16153(x::ANY, y...) = 2
+ff16153(@nospecialize(x), y...) = 2
 ff16153(x) = 1
 @test ff16153("") == 1
-g16153(x::ANY, y...) = 1
-g16153(x::ANY, y::ANY) = 2
+g16153(@nospecialize(x), y...) = 1
+g16153(@nospecialize(x), @nospecialize(y)) = 2
 @test g16153(1, 1) == 2
-gg16153(x::ANY, y::ANY) = 2
-gg16153(x::ANY, y...) = 1
+gg16153(@nospecialize(x), @nospecialize(y)) = 2
+gg16153(@nospecialize(x), y...) = 1
 @test gg16153(1, 1) == 2
 
 # don't remove global variable accesses even if we "know" their type
@@ -4211,7 +4276,7 @@ function f1090(x)::Int
 end
 @test f1090(1) === 1
 @test f1090(2) === 2
-g1090{T}(x::T)::T = x+1.0
+(g1090(x::T)::T) where {T} = x+1.0
 @test g1090(1) === 2
 @test g1090(Float32(3)) === Float32(4)
 
@@ -4262,8 +4327,8 @@ end
 @test C16767.body.types[1].types[1].parameters[1].types[1] === A16767{C16767{:a}}
 
 # issue #16340
-function f16340{T}(x::T)
-    function g{T}(y::T)
+function f16340(x::T) where T
+    function g(y::T) where T
         return (T,T)
     end
     return g
@@ -4282,7 +4347,7 @@ end
 
 # issue #17147
 f17147(::Tuple) = 1
-f17147{N}(::Vararg{Tuple,N}) = 2
+f17147(::Vararg{Tuple,N}) where {N} = 2
 @test f17147((), ()) == 2
 
 # issue #17449, argument evaluation order
@@ -4303,7 +4368,7 @@ end
 @test h17449(true) === :k
 
 # make sure lowering agrees on sp order
-function captsp{T, S}(x::T, y::S)
+function captsp(x::T, y::S) where {T, S}
     subf(x2::Int) = T
     subf(x2::UInt) = S
     return subf(Int(1)), subf(UInt(1))
@@ -4311,7 +4376,7 @@ end
 @test captsp(1, 2.0) == (Int, Float64)
 
 # issue #15068
-function sp_innersig{T}(x::T)
+function sp_innersig(x::T) where {T}
    subf(x2::T) = (x, x2, :a)
    subf(x2) = (x, x2, :b)
    return (subf(one(T)), subf(unsigned(one(T))))
@@ -4490,13 +4555,13 @@ end
 gc_enable(true)
 
 # issue #18710
-bad_tvars{T}() = 1
+bad_tvars() where {T} = 1
 @test_throws ErrorException @which(bad_tvars())
 @test_throws MethodError bad_tvars()
 
 # issue #19059 - test for lowering of `let` with assignment not adding Box in simple cases
 contains_Box(e::GlobalRef) = (e.name === :Box)
-contains_Box(e::ANY) = false
+contains_Box(@nospecialize(e)) = false
 contains_Box(e::Expr) = any(contains_Box, e.args)
 
 function let_noBox()
@@ -4631,7 +4696,7 @@ end
 end
 
 # issue #19599
-f19599{T}(x::((S)->Vector{S})(T)...) = 1
+f19599(x::((S)->Vector{S})(T)...) where {T} = 1
 @test f19599([1],[1]) == 1
 @test_throws MethodError f19599([1],[1.0])
 
@@ -4656,11 +4721,11 @@ end # module SOE
 @test_nowarn begin
     local p15240
     p15240 = ccall(:jl_realloc, Ptr{Void}, (Ptr{Void}, Csize_t), C_NULL, 10)
-    ccall(:jl_free, Void, (Ptr{Void}, ), p15240)
+    ccall(:jl_free, Void, (Ptr{Void},), p15240)
 end
 
 # issue #19963
-@test_nowarn ccall(:jl_free, Void, (Ptr{Void}, ), C_NULL)
+@test_nowarn ccall(:jl_free, Void, (Ptr{Void},), C_NULL)
 
 # Wrong string size on 64bits for large string.
 if Sys.WORD_SIZE == 64
@@ -4753,3 +4818,299 @@ end
     x::Vector{S}
     y::Vector{T}
 end
+
+# issue #20999, allow more type redefinitions
+struct T20999
+    x::Array{T} where T<:Real
+end
+
+struct T20999
+    x::Array{T} where T<:Real
+end
+
+@test_throws ErrorException struct T20999
+    x::Array{T} where T<:Integer
+end
+
+let a = Array{Core.TypeofBottom, 1}(2)
+    @test a[1] == Union{}
+    @test a == [Union{}, Union{}]
+end
+
+# issue #21178
+struct F21178{A,B} end
+b21178(::F1,::F2) where {B1,B2,F1<:F21178{B1,<:Any},F2<:F21178{B2}} = F1,F2,B1,B2
+@test b21178(F21178{1,2}(),F21178{1,2}()) == (F21178{1,2}, F21178{1,2}, 1, 1)
+
+# issue #21172
+a21172 = f21172(x) = 2x
+@test f21172(8) == 16
+@test a21172 === f21172
+
+# issue #21271
+f21271() = convert(Tuple{Type{Int}, Type{Float64}}, (Int, Float64))::Tuple{Type{Int}, Type{Float64}}
+f21271(x) = x::Tuple{Type{Int}, Type{Float64}}
+@test_throws TypeError f21271()
+@test_throws TypeError f21271((Int, Float64))
+
+# issue #21397
+bar21397(x::T) where {T} = T
+foo21397(x) = bar21397(x)
+@test foo21397(Tuple) == DataType
+
+# issue 21216
+primitive type FP128test <: AbstractFloat 128 end
+struct FP128align <: AbstractFloat
+    i::Int # cause forced misalignment
+    fp::FP128test
+end
+let ni128 = sizeof(FP128test) ÷ sizeof(Int),
+    ns128 = sizeof(FP128align) ÷ sizeof(Int),
+    nbit = sizeof(Int) * 8,
+    arr = Vector{FP128align}(2),
+    offset = Base.datatype_alignment(FP128test) ÷ sizeof(Int),
+    little,
+    expected,
+    arrint = reinterpret(Int, arr)
+
+    @test length(arrint) == 2 * ns128
+    arrint .= 1:(2 * ns128)
+    @test sizeof(FP128test) == 16
+    @test arr[1].i == 1
+    @test arr[2].i == 1 + ns128
+    expected = UInt128(0)
+    for little in ni128:-1:1
+        little += offset
+        expected = (expected << nbit) + little
+    end
+    @test arr[1].fp == reinterpret(FP128test, expected)
+    expected = UInt128(0)
+    for little in ni128:-1:1
+        little += offset + ns128
+        expected = (expected << nbit) + little
+    end
+    @test reinterpret(UInt128, arr[2].fp) == expected
+end
+
+# issue #21516
+struct T21516
+    x::Vector{Float64}
+    y::Vector{Float64}
+    # check that this definition works
+    T21516(x::Vector{T}, y::Vector{T}) where {T<:Real} = new(float.(x), float.(y))
+end
+@test isa(T21516([1],[2]).x, Vector{Float64})
+
+# let with type declaration
+let letvar::Int = 2
+    letvar = 3.0
+    @test letvar === 3
+end
+
+# issue #21568
+f21568() = 0
+function foo21568()
+    y = 1
+    global f21568
+    f21568(x::AbstractArray{T,1}) where {T<:Real} = y
+end
+foo21568()
+@test f21568([0]) == 1
+
+# issue #21719
+mutable struct T21719{V}
+    f
+    tol::Float64
+    goal::V
+end
+g21719(f, goal; tol = 1e-6) = T21719(f, tol, goal)
+@test isa(g21719(identity, 1.0; tol=0.1), T21719)
+
+# reinterpret alignment requirement
+let arr8 = zeros(UInt8, 16),
+    arr64 = zeros(UInt64, 2),
+    arr64_8 = reinterpret(UInt8, arr64),
+    arr64_i
+
+    # Not allowed to reinterpret arrays allocated as UInt8 array to a Int32 array
+    res = @test_throws ArgumentError reinterpret(Int32, arr8)
+    @test res.value.msg == "reinterpret from alignment 1 bytes to alignment 4 bytes not allowed"
+    # OK to reinterpret arrays allocated as UInt64 array to a Int64 array even though
+    # it is passed as a UInt8 array
+    arr64_i = reinterpret(Int64, arr64_8)
+    @test arr8 == arr64_8
+    arr64_i[2] = 1234
+    @test arr64[2] == 1234
+end
+
+# Alignment of perm boxes
+for i in 1:10
+    # Int64 box should be 16bytes aligned even on 32bits
+    ptr1 = ccall(:jl_box_int64, UInt, (Int64,), i)
+    ptr2 = ccall(:jl_box_int64, UInt, (Int64,), i)
+    @test ptr1 === ptr2
+    @test ptr1 % 16 == 0
+end
+
+# issue #21581
+global function f21581()::Int
+    return 2.0
+end
+@test f21581() === 2
+global g21581()::Int = 2.0
+@test g21581() === 2
+module M21581
+macro bar()
+    :(foo21581(x)::Int = x)
+end
+M21581.@bar
+end
+@test M21581.foo21581(1) === 1
+
+module N21581
+macro foo(var)
+    quote
+        function f(x::T = 1) where T
+            ($(esc(var)), x)
+        end
+        f()
+    end
+end
+end
+let x = 8
+    @test @N21581.foo(x) === (8, 1)
+end
+
+# issue #22122
+let
+    global @inline function f22122(x::T) where {T}
+        T
+    end
+end
+@test f22122(1) === Int
+
+# issue #22256
+mutable struct Bar22256{AParameter}
+    inner::Int
+end
+mutable struct Foo22256
+    bar::Bar22256
+end
+setbar22256_inner(a) = (a.bar.inner = 3; nothing)
+let a_foo = Foo22256(Bar22256{true}(2))
+    @test a_foo.bar.inner == 2
+    setbar22256_inner(a_foo)
+    @test a_foo.bar.inner == 3
+end
+
+# macro hygiene scope (#22307)
+macro a22307()
+    return esc(:a22307)
+end
+macro b22307()
+    return :(@a22307)
+end
+function c22307()
+    a22307 = 1
+    return @b22307
+end
+a22307 = 2
+@test c22307() == 2
+
+# issue #22026
+module M22026
+
+macro foo(TYP)
+    quote
+        global foofunction
+        foofunction(x::Type{T}) where {T<:Number} = x
+    end
+end
+struct Foo end
+@foo Foo
+
+macro foo2()
+    quote
+        global foofunction2
+        (foofunction2(x::T)::Float32) where {T<:Number} = 2x
+    end
+end
+
+@foo2
+
+end
+@test M22026.foofunction(Int16) === Int16
+@test M22026.foofunction2(3) === 6.0f0
+
+# tests for isdefined behavior and code generation
+global undefined_variable
+@test @isdefined Test
+@test !@isdefined undefined_variable
+@test !@isdefined undefined_variable2
+@test let local_undef, local_def = 1
+    !@isdefined local_undef
+    @isdefined local_def
+end
+f_isdefined_latedef() = @isdefined f_isdefined_def
+@test !f_isdefined_latedef()
+f_isdefined(x) = @isdefined x
+f_isdefined_undef() = @isdefined x_isundef
+f_isdefined_def() = @isdefined f_isdefined_def
+@test f_isdefined(1)
+@test f_isdefined("")
+@test !f_isdefined_undef()
+@test f_isdefined_def()
+@test f_isdefined_latedef()
+f_isdefined_defvarI() = (x = rand(Int); @isdefined x)
+f_isdefined_defvarS() = (x = randstring(1); @isdefined x)
+@test f_isdefined_defvarI()
+@test f_isdefined_defvarS()
+f_isdefined_undefvar() = (local x; @isdefined x)
+@test !f_isdefined_undefvar()
+f_isdefined_unionvar(y, t) = (t > 0 && (x = (t == 1 ? 1 : y)); @isdefined x)
+@test f_isdefined_unionvar(nothing, 1)
+@test f_isdefined_unionvar("", 1)
+@test f_isdefined_unionvar(1.0, 1)
+@test f_isdefined_unionvar(1, 1)
+@test !f_isdefined_unionvar(nothing, 0)
+@test !f_isdefined_unionvar("", 0)
+@test !f_isdefined_unionvar(1.0, 0)
+@test !f_isdefined_unionvar(1, 0)
+f_isdefined_splat(x...) = @isdefined x
+@test f_isdefined_splat(1, 2, 3)
+@test let err = @macroexpand @isdefined :x
+    isa(err, Expr) && err.head === :error && isa(err.args[1], MethodError)
+end
+f_isdefined_cl_1(y) = (local x; for i = 1:y; x = 2; end; () -> x; @isdefined x)
+f_isdefined_cl_2(y) = (local x; for i = 1:y; x = 2; end; () -> @isdefined x)
+f_isdefined_cl_3() = (x = 2; () -> x; @isdefined x)
+f_isdefined_cl_4() = (local x; () -> x; @isdefined x)
+f_isdefined_cl_5() = (x = 2; () -> @isdefined x)
+f_isdefined_cl_6() = (local x; () -> @isdefined x)
+@test f_isdefined_cl_1(1)
+@test !f_isdefined_cl_1(0)
+@test f_isdefined_cl_2(1)()
+@test !f_isdefined_cl_2(0)()
+@test f_isdefined_cl_3()
+@test !f_isdefined_cl_4()
+@test f_isdefined_cl_5()()
+@test !f_isdefined_cl_6()()
+f_isdefined_tv(::T) where {T} = @isdefined T
+@test f_isdefined_tv(1)
+f_isdefined_va(::T...) where {T} = @isdefined T
+@test_throws MethodError f_isdefined_va()
+@test f_isdefined_va(1, 2, 3)
+
+mutable struct MyStruct22929
+    x::MyStruct22929
+    MyStruct22929() = new()
+end
+isdefined_22929_1(x) = isdefined(x, 1)
+isdefined_22929_x(x) = isdefined(x, :x)
+m22929_1 = MyStruct22929()
+m22929_2 = MyStruct22929()
+m22929_2.x = m22929_1
+@test !isdefined_22929_1(m22929_1)
+@test !isdefined_22929_x(m22929_1)
+@test isdefined_22929_1(m22929_2)
+@test isdefined_22929_x(m22929_2)
diff --git a/test/datafmt.jl b/test/datafmt.jl
index 9057c1790872f2..207cfa2183c0b3 100644
--- a/test/datafmt.jl
+++ b/test/datafmt.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # countlines
 @test countlines(IOBuffer("\n")) == 1
@@ -94,7 +94,7 @@ 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"
+    @test read(io, String) == "0.1, 0.3, 0.5\n"
 end
 
 let x = [0.1 0.3 0.5], io = IOBuffer()
@@ -272,3 +272,13 @@ let fn = tempname()
     readdlm(fn)[] == "Julia"
     rm(fn)
 end
+
+# issue #21180
+let data = "\"721\",\"1438\",\"1439\",\"…\",\"1\""
+    @test readcsv(IOBuffer(data)) == Any[721  1438  1439  "…"  1]
+end
+
+# issue #21207
+let data = "\"1\",\"灣\"\"灣灣灣灣\",\"3\""
+    @test readcsv(IOBuffer(data)) == Any[1 "灣\"灣灣灣灣" 3]
+end
diff --git a/test/dates/accessors.jl b/test/dates/accessors.jl
index 3ce9048f3b1b36..4e6ab4a6eba796 100644
--- a/test/dates/accessors.jl
+++ b/test/dates/accessors.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # yearmonthday is the opposite of totaldays
 # taking Rata Die Day # and returning proleptic Gregorian date
@@ -205,4 +205,4 @@ tr = [b, b, b, b, b, b, b, b, b, b]
 @test Dates.second.(tr) == repmat([3], 10)
 @test Dates.millisecond.(tr) == repmat([4], 10)
 @test Dates.microsecond.(tr) == repmat([5], 10)
-@test Dates.nanosecond.(tr) == repmat([6], 10)
\ No newline at end of file
+@test Dates.nanosecond.(tr) == repmat([6], 10)
diff --git a/test/dates/adjusters.jl b/test/dates/adjusters.jl
index 46c7045d2221e5..5d94dc821adb69 100644
--- a/test/dates/adjusters.jl
+++ b/test/dates/adjusters.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #trunc
 dt = Dates.Date(2012, 12, 21)
diff --git a/test/dates/arithmetic.jl b/test/dates/arithmetic.jl
index d5db8f895cd449..98732fe3fe204d 100644
--- a/test/dates/arithmetic.jl
+++ b/test/dates/arithmetic.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Time arithmetic
 a = Dates.Time(23, 59, 59)
diff --git a/test/dates/conversions.jl b/test/dates/conversions.jl
index 26124cbc82460c..a043b95f4dcc61 100644
--- a/test/dates/conversions.jl
+++ b/test/dates/conversions.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Test conversion to and from unix
 @test Dates.unix2datetime(Dates.datetime2unix(DateTime(2000, 1, 1))) == DateTime(2000, 1, 1)
@@ -48,7 +48,7 @@
 @test typeof(Dates.today()) <: Dates.Date
 @test typeof(Dates.now(Dates.UTC)) <: Dates.DateTime
 
-if is_apple()
+if Sys.isapple()
     withenv("TZ" => "UTC") do
         @test abs(Dates.now() - now(Dates.UTC)) < Dates.Second(1)
     end
diff --git a/test/dates/io.jl b/test/dates/io.jl
index 7a3790478c2fc5..4a34d878596378 100644
--- a/test/dates/io.jl
+++ b/test/dates/io.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Test string/show representation of Date
 @test string(Dates.Date(1, 1, 1)) == "0001-01-01" # January 1st, 1 AD/CE
@@ -29,10 +29,13 @@
 # DateTime parsing
 # Useful reference for different locales: http://library.princeton.edu/departments/tsd/katmandu/reference/months.html
 
-let str = "1996/02/15 24:00", format = "yyyy/mm/dd HH:MM"
-    expected = (1996, 2, 15, 24, 0, 0, 0)
-    @test get(Dates.tryparse_internal(DateTime, str, Dates.DateFormat(format))) == expected
-    @test_throws ArgumentError Dates.DateTime(str, Dates.DateFormat(format))
+# Allow parsing of strings which are not representable as a TimeType
+let str = "02/15/1996 24:00", df = Dates.DateFormat("mm/dd/yyyy HH:MM")
+    parsed = Any[
+        Dates.Month(2), Dates.Day(15), Dates.Year(1996), Dates.Hour(24), Dates.Minute(0)
+    ]
+    @test Dates.parse_components(str, df) == parsed
+    @test_throws ArgumentError Dates.parse(DateTime, str, df)
 end
 
 # DateFormat printing
@@ -76,18 +79,18 @@ b2 = "96/Feb/1"
 b3 = "96/2/15"
 @test_throws ArgumentError Dates.DateTime(b3, f)
 try
-    Dates.tryparse_internal(DateTime, "2012/02/20T09:09:31.25i90", dateformat"yyyy/mm/ddTHH:MM:SS.s", true)
+    Dates.parse(DateTime, "2012/2/20T9:9:31.25i90", dateformat"yyyy/mm/ddTHH:MM:SS.s")
     @test false
 catch err
     @test isa(err, ArgumentError)
     @test err.msg == "Found extra characters at the end of date time string"
 end
 try
-    Dates.tryparse_internal(DateTime, "2012/02/20T09:09:3i90", dateformat"yyyy/mm/ddTHH:MM:SS.s", true)
+    Dates.parse(DateTime, "2012/2/20T9:9:3i90", dateformat"yyyy/mm/ddTHH:MM:SS.s")
     @test false
 catch err
     @test isa(err, ArgumentError)
-    @test err.msg == "Unable to parse date time. Expected token Delim(.) at char 19"
+    @test err.msg == "Unable to parse date time. Expected directive Delim(.) at char 16"
 end
 
 f = "yy:dd:mm"
@@ -375,32 +378,109 @@ let f = "YY"
 end
 
 # Issue: https://github.com/quinnj/TimeZones.jl/issues/19
-let ds = "2015-07-24T05:38:19.591Z",
-    dt = Dates.DateTime(2015, 7, 24, 5, 38, 19, 591),
+let
+    const Zulu = String
 
-    format = "yyyy-mm-ddTHH:MM:SS.sssZ",
+    function Dates.tryparsenext(d::Dates.DatePart{'Z'}, str, i, len)
+        Dates.tryparsenext_word(str, i, len, Dates.min_width(d), Dates.max_width(d))
+    end
+
+    str = "2015-07-24T05:38:19.591Z"
+    dt = Dates.DateTime(2015, 7, 24, 5, 38, 19, 591)
+    parsed = Any[
+        Dates.Year(2015), Dates.Month(7), Dates.Day(24),
+        Dates.Hour(5), Dates.Minute(38), Dates.Second(19), Dates.Millisecond(591)
+    ]
+
+    format = "yyyy-mm-ddTHH:MM:SS.sssZ"
     escaped_format = "yyyy-mm-dd\\THH:MM:SS.sss\\Z"
 
-    # Typically 'Z' isn't treated as a slot so it doesn't have to be escaped
-    @test DateTime(ds, format) == dt
-    @test DateTime(ds, escaped_format) == dt
+    # Typically 'Z' isn't treated as a specifier so it doesn't have to be escaped
+    @test Dates.parse_components(str, Dates.DateFormat(format)) == parsed
+    @test Dates.parse_components(str, Dates.DateFormat(escaped_format)) == parsed
 
     try
-        # Make 'Z' into a slot
-        Dates.SLOT_RULE['Z'] = Dates.TimeZone
+        # Make 'Z' into a specifier
+        Dates.CONVERSION_SPECIFIERS['Z'] = Zulu
+        Dates.CONVERSION_DEFAULTS[Zulu] = ""
 
-        @test_throws MethodError DateTime(ds, format)
-        @test DateTime(ds, escaped_format) == dt
+        @test Dates.parse_components(str, Dates.DateFormat(format)) == [parsed; Zulu("Z")]
+        @test Dates.parse_components(str, Dates.DateFormat(escaped_format)) == parsed
     finally
-        delete!(Dates.SLOT_RULE, 'Z')
+        delete!(Dates.CONVERSION_SPECIFIERS, 'Z')
+        delete!(Dates.CONVERSION_DEFAULTS, Zulu)
     end
 
     # Ensure that the default behaviour has been restored
-    @test DateTime(ds, format) == dt
-    @test DateTime(ds, escaped_format) == dt
+    @test Dates.parse_components(str, Dates.DateFormat(format)) == parsed
+    @test Dates.parse_components(str, Dates.DateFormat(escaped_format)) == parsed
 end
 
 # Issue 10817
 @test Dates.Date("Apr 01 2014", "uuu dd yyyy") == Dates.Date(2014, 4, 1)
 @test_throws ArgumentError Dates.Date("Apr 01 xx 2014", "uuu dd zz yyyy")
 @test_throws ArgumentError Dates.Date("Apr 01 xx 2014", "uuu dd    yyyy")
+
+# Issue 21001
+for (ms, str) in zip([0, 1, 20, 300, 450, 678], ["0", "001", "02", "3", "45", "678"])
+    dt = DateTime(2000, 1, 1, 0, 0, 0, ms)
+    @test Dates.format(dt, "s") == str
+    @test Dates.format(dt, "ss") == rpad(str, 2, '0')
+    @test Dates.format(dt, "sss") == rpad(str, 3, '0')
+    @test Dates.format(dt, "ssss") == rpad(str, 4, '0')
+end
+
+# Issue #21504
+@test isnull(tryparse(Dates.Date, "0-1000"))
+
+# Issue #22100
+@testset "parse milliseconds" begin
+    @test Dates.DateTime("2017-Mar-17 00:00:00.0000", "y-u-d H:M:S.s") == Dates.DateTime(2017, 3, 17)
+    @test Dates.parse_components(".1", Dates.DateFormat(".s")) == [Dates.Millisecond(100)]
+    @test Dates.parse_components(".12", Dates.DateFormat(".s")) == [Dates.Millisecond(120)]
+    @test Dates.parse_components(".123", Dates.DateFormat(".s")) == [Dates.Millisecond(123)]
+    @test Dates.parse_components(".1230", Dates.DateFormat(".s")) == [Dates.Millisecond(123)]
+    @test_throws InexactError Dates.parse_components(".1234", Dates.DateFormat(".s"))
+
+    # Ensure that no overflow occurs when using Int32 literals: Int32(10)^10
+    @test Dates.parse_components("." * rpad(999, 10, '0'), Dates.DateFormat(".s")) == [Dates.Millisecond(999)]
+end
+
+# Time Parsing
+let
+    time_tuple(t::Dates.Time) = (
+        Dates.hour(t), Dates.minute(t), Dates.second(t),
+        Dates.millisecond(t), Dates.microsecond(t), Dates.nanosecond(t)
+    )
+
+    ## default ISOTimeFormat
+    t = Dates.Time("01")
+    @test time_tuple(t) == (1, 0, 0, 0, 0, 0)
+    t = Dates.Time("01:23")
+    @test time_tuple(t) == (1, 23, 0, 0, 0, 0)
+    t = Dates.Time("01:23:45")
+    @test time_tuple(t) == (1, 23, 45, 0, 0, 0)
+    t = Dates.Time("01:23:45.678")
+    @test time_tuple(t) == (1, 23, 45, 678, 0, 0)
+
+    ## string format
+    t = Dates.Time("23:56:12.1", "HH:MM:SS.s")
+    @test time_tuple(t) == (23, 56, 12, 100, 0, 0)
+
+    ## precomputed DateFormat
+    t = Dates.Time("04:09:45.012", DateFormat("HH:MM:SS.s"))
+    @test time_tuple(t) == (4, 9, 45, 12, 0, 0)
+    t = Dates.Time("21 07", DateFormat("HH MM"))
+    @test time_tuple(t) == (21, 7, 0, 0, 0, 0)
+    t = Dates.Time("4.02", DateFormat("H.MM"))
+    @test time_tuple(t) == (4, 2, 0, 0, 0, 0)
+    t = Dates.Time("1725", DateFormat("HHMM"))
+    @test time_tuple(t) == (17, 25, 0, 0, 0, 0)
+
+    ## exceptions
+    @test_throws ArgumentError Dates.Time("24:00")  # invalid hours
+    @test_throws ArgumentError Dates.Time("00:60")  # invalid minutes
+    @test_throws ArgumentError Dates.Time("00:00:60")  # invalid seconds
+    @test_throws ArgumentError Dates.Time("20:03:20", DateFormat("HH:MM"))  # too much precision
+    @test_throws ArgumentError Dates.Time("10:33:51", DateFormat("YYYY-MM-DD HH:MM:SS"))  # Time can't hold year/month/day
+end
diff --git a/test/dates/periods.jl b/test/dates/periods.jl
index f951790b856961..86cf2167333050 100644
--- a/test/dates/periods.jl
+++ b/test/dates/periods.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Period testing
 @test -Dates.Year(1) == Dates.Year(-1)
@@ -234,6 +234,26 @@ test = ((((((((dt + y) - m) + w) - d) + h) - mi) + s) - ms)
 @test !(Dates.Millisecond(-1) > Dates.Millisecond(1))
 @test Dates.Millisecond(1) == Dates.Millisecond(1)
 @test_throws MethodError Dates.Year(1) < Dates.Millisecond(1)
+@test_throws MethodError Dates.Millisecond(1) < Dates.Year(1)
+@test_throws MethodError Dates.Year(1) == Dates.Millisecond(1)
+@test_throws MethodError Dates.Millisecond(1) == Dates.Year(1)
+
+# Allow comparisons with new Period subtypes
+let
+    # https://en.wikipedia.org/wiki/Swatch_Internet_Time
+    struct Beat <: Dates.Period
+        value::Int64
+    end
+
+    Dates.value(b::Beat) = b.value
+    Dates.toms(b::Beat) = Dates.value(b) * 86400
+    Dates._units(b::Beat) = " beat" * (abs(Dates.value(b)) == 1 ? "" : "s")
+    Base.promote_rule(::Type{Dates.Day}, ::Type{Beat}) = Dates.Millisecond
+    Base.convert(::Type{T}, b::Beat) where {T<:Dates.Millisecond} = T(Dates.toms(b))
+
+    @test Beat(1000) == Dates.Day(1)
+    @test Beat(1) < Dates.Day(1)
+end
 
 @test Dates.Year("1") == y
 @test Dates.Month("1") == m
@@ -374,3 +394,24 @@ cpa = [1y + 1s 1m + 1s 1w + 1s 1d + 1s; 1h + 1s 1mi + 1s 2m + 1s 1s + 1ms]
 
 @test [1y + 1s 1m + 1s; 1w + 1s 1d + 1s] + [1y + 1h 1y + 1mi; 1y + 1s 1y + 1ms] == [2y + 1h + 1s 1y + 1m + 1mi + 1s; 1y + 1w + 2s 1y + 1d + 1s + 1ms]
 @test [1y + 1s 1m + 1s; 1w + 1s 1d + 1s] - [1y + 1h 1y + 1mi; 1y + 1s 1y + 1ms] == [1s-1h 1m + 1s-1y-1mi; 1w-1y 1d + 1s-1y-1ms]
+
+# Equality and hashing between FixedPeriod types
+let types = (Dates.Week, Dates.Day, Dates.Hour, Dates.Minute,
+             Dates.Second, Dates.Millisecond, Dates.Microsecond, Dates.Nanosecond)
+    for i in 1:length(types), j in i:length(types), x in (0, 1, 235, -4677, 15250)
+        T = types[i]
+        U = types[j]
+        y = T(x)
+        z = convert(U, y)
+        @test y == z
+        @test hash(y) == hash(z)
+    end
+end
+
+# Equality and hashing between OtherPeriod types
+for x in (0, 1, 235, -4677, 15250)
+    y = Dates.Year(x)
+    z = convert(Dates.Month, y)
+    @test y == z
+    @test hash(y) == hash(z)
+end
diff --git a/test/dates/query.jl b/test/dates/query.jl
index 967e04c391be76..7931612c8fd548 100644
--- a/test/dates/query.jl
+++ b/test/dates/query.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Name functions
 Jan = Dates.DateTime(2013, 1, 1) # Tuesday
diff --git a/test/dates/ranges.jl b/test/dates/ranges.jl
index 622382b9c6da35..74b2a1983db6f3 100644
--- a/test/dates/ranges.jl
+++ b/test/dates/ranges.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 let
     for T in (Dates.Date, Dates.DateTime)
@@ -11,7 +11,9 @@ let
             for pos_step in (P(1), P(2), P(50), P(2048), P(10000))
                 # empty range
                 dr = f1:pos_step:l1
-                @test length(dr) == 0
+                len = length(dr)
+                @test len == 0
+                @test isa(len, Int64)
                 @test isempty(dr)
                 @test first(dr) == f1
                 @test last(dr) < f1
@@ -36,7 +38,7 @@ let
                     dr = f:pos_step:l
                     len = length(dr)
                     @test len > 0
-                    @test typeof(len) <: Int64
+                    @test isa(len, Int64)
                     @test !isempty(dr)
                     @test first(dr) == f
                     @test last(dr) <= l
@@ -63,7 +65,9 @@ let
             for neg_step in (P(-1), P(-2), P(-50), P(-2048), P(-10000))
                 # empty range
                 dr = l1:neg_step:f1
-                @test length(dr) == 0
+                len = length(dr)
+                @test len == 0
+                @test isa(len, Int64)
                 @test isempty(dr)
                 @test first(dr) == l1
                 @test last(dr) > l1
@@ -88,7 +92,7 @@ let
                     dr = l:neg_step:f
                     len = length(dr)
                     @test len > 0
-                    @test typeof(len) <: Int64
+                    @test isa(len, Int64)
                     @test !isempty(dr)
                     @test first(dr) == l
                     @test last(dr) >= f
@@ -117,7 +121,9 @@ let
                 for pos_step in (P(1), P(2), P(50), P(2048), P(10000))
                     # empty range
                     dr = f1:pos_step:l1
-                    @test length(dr) == 0
+                    len = length(dr)
+                    @test len == 0
+                    @test isa(len, Int64)
                     @test isempty(dr)
                     @test first(dr) == f1
                     @test last(dr) < f1
@@ -142,7 +148,7 @@ let
                         dr = f:pos_step:l
                         len = length(dr)
                         @test len > 0
-                        @test typeof(len) <: Int64
+                        @test isa(len, Int64)
                         @test !isempty(dr)
                         @test first(dr) == f
                         @test last(dr) <= l
@@ -169,7 +175,9 @@ let
                 for neg_step in (P(-1), P(-2), P(-50), P(-2048), P(-10000))
                     # empty range
                     dr = l1:neg_step:f1
-                    @test length(dr) == 0
+                    len = length(dr)
+                    @test len == 0
+                    @test isa(len, Int64)
                     @test isempty(dr)
                     @test first(dr) == l1
                     @test last(dr) > l1
@@ -194,7 +202,7 @@ let
                         dr = l:neg_step:f
                         len = length(dr)
                         @test len > 0
-                        @test typeof(len) <: Int64
+                        @test isa(len, Int64)
                         @test !isempty(dr)
                         @test first(dr) == l
                         @test last(dr) >= f
diff --git a/test/dates/rounding.jl b/test/dates/rounding.jl
index d6faed688eeed6..e32f592a0f3012 100644
--- a/test/dates/rounding.jl
+++ b/test/dates/rounding.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Test conversion to and from the rounding epoch (ISO 8601 year 0000)
 @test Dates.epochdays2date(-1) == Dates.Date(-1, 12, 31)
diff --git a/test/dates/types.jl b/test/dates/types.jl
index 0b32a6753ca558..21d7918225a4af 100644
--- a/test/dates/types.jl
+++ b/test/dates/types.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Date internal algorithms
 @test Dates.totaldays(0, 2, 28) == -307
diff --git a/test/deprecation_exec.jl b/test/deprecation_exec.jl
new file mode 100644
index 00000000000000..a747f30dde1a10
--- /dev/null
+++ b/test/deprecation_exec.jl
@@ -0,0 +1,75 @@
+using Base.Test
+
+module DeprecationTests # to test @deprecate
+    f() = true
+
+    # test the Symbol path of @deprecate
+    @deprecate f1 f
+    @deprecate f2 f false # test that f2 is not exported
+
+    # test the Expr path of @deprecate
+    @deprecate f3() f()
+    @deprecate f4() f() false # test that f4 is not exported
+    @deprecate f5(x::T) where T f()
+
+    # test deprecation of a constructor
+    struct A{T} end
+    @deprecate A{T}(x::S) where {T, S} f()
+
+    # test that @deprecate_moved can be overridden by an import
+    Base.@deprecate_moved foo1234 "Foo"
+    Base.@deprecate_moved bar "Bar" false
+end # module
+module Foo1234
+    export foo1234
+    foo1234(x) = x+1
+end
+
+# issue #21972
+struct T21972
+    @noinline function T21972()
+        Base.depwarn("something", :T21972)
+        new()
+    end
+end
+
+@testset "@deprecate" begin
+    using .DeprecationTests
+    using .Foo1234
+    @test foo1234(3) == 4
+    @test_throws ErrorException DeprecationTests.bar(3)
+
+    # 22845
+    ex = :(module M22845; import ..DeprecationTests: bar;
+                          bar(x::Number) = x + 3; end)
+    @test_warn "importing deprecated binding" eval(ex)
+    @test @test_nowarn(DeprecationTests.bar(4)) == 7
+
+    # enable when issue #22043 is fixed
+    # @test @test_warn "f1 is deprecated, use f instead." f1()
+    # @test @test_nowarn f1()
+
+    # @test_throws UndefVarError f2() # not exported
+    # @test @test_warn "f2 is deprecated, use f instead." DeprecationTests.f2()
+    # @test @test_nowarn DeprecationTests.f2()
+
+    # @test @test_warn "f3() is deprecated, use f() instead." f3()
+    # @test @test_nowarn f3()
+
+    # @test_throws UndefVarError f4() # not exported
+    # @test @test_warn "f4() is deprecated, use f() instead." DeprecationTests.f4()
+    # @test @test_nowarn DeprecationTests.f4()
+
+    # @test @test_warn "f5(x::T) where T is deprecated, use f() instead." f5(1)
+    # @test @test_nowarn f5(1)
+
+    # @test @test_warn "A{T}(x::S) where {T, S} is deprecated, use f() instead." A{Int}(1.)
+    # @test @test_nowarn A{Int}(1.)
+
+    # issue #21972
+    @noinline function f21972()
+        T21972()
+    end
+    @test_warn "deprecated" f21972()
+    @test_nowarn f21972()
+end
diff --git a/test/dict.jl b/test/dict.jl
index 1ec266ec2f1941..2f0a43ce9afd6b 100644
--- a/test/dict.jl
+++ b/test/dict.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Pair
 p = Pair(10,20)
@@ -161,7 +161,7 @@ end
 let
     local bar
     bestkey(d, key) = key
-    bestkey{K<:AbstractString,V}(d::Associative{K,V}, key) = string(key)
+    bestkey(d::Associative{K,V}, key) where {K<:AbstractString,V} = string(key)
     bar(x) = bestkey(x, :y)
     @test bar(Dict(:x => [1,2,5])) == :y
     @test bar(Dict("x" => [1,2,5])) == "y"
@@ -301,7 +301,7 @@ let d = Dict((1=>2) => (3=>45), (3=>10) => (10=>11))
 
     # Check explicitly for the expected strings, since the CPU bitness effects
     # dictionary ordering.
-    result = String(buf)
+    result = String(take!(buf))
     @test contains(result, "Dict")
     @test contains(result, "(1=>2)=>(3=>45)")
     @test contains(result, "(3=>10)=>(10=>11)")
@@ -314,8 +314,9 @@ let sbuff = IOBuffer(),
     io = Base.IOContext(Base.IOContext(sbuff, :limit => true), :displaysize => (10, 20))
 
     Base.show(io, MIME("text/plain"), Dict(Alpha()=>1))
-    @test !contains(String(sbuff), "…")
-    @test endswith(String(sbuff), "α => 1")
+    local str = String(take!(sbuff))
+    @test !contains(str, "…")
+    @test endswith(str, "α => 1")
 end
 
 # issue #2540
@@ -394,6 +395,9 @@ let
     ca = empty!(ca)
     @test length(ca) == 0
     @test length(a) == 2
+
+    d = Dict('a'=>1, 'b'=>1, 'c'=> 3)
+    @test a != d
 end
 
 @test length(ObjectIdDict(1=>2, 1.0=>3)) == 2
@@ -484,7 +488,7 @@ let d = ImmutableDict{String, String}(),
     @test (k1 => v2) in d3
     @test (k1 => v1) in d4
     @test (k1 => v2) in d4
-    @test !in(k2 => "value2", d4, ===)
+    @test in(k2 => "value2", d4, ===)
     @test in(k2 => v2, d4, ===)
     @test in(k2 => NaN, dnan, isequal)
     @test in(k2 => NaN, dnan, ===)
@@ -615,11 +619,13 @@ Dict(1 => rand(2,3), 'c' => "asdf") # just make sure this does not trigger a dep
     wkd[C] = 4
     dd = convert(Dict{Any,Any},wkd)
     @test WeakKeyDict(dd) == wkd
+    @test convert(WeakKeyDict{Any, Any}, dd) == wkd
     @test isa(WeakKeyDict(dd), WeakKeyDict{Any,Any})
     @test WeakKeyDict(A=>2, B=>3, C=>4) == wkd
     @test isa(WeakKeyDict(A=>2, B=>3, C=>4), WeakKeyDict{Array{Int,1},Int})
     @test WeakKeyDict(a=>i+1 for (i,a) in enumerate([A,B,C]) ) == wkd
     @test WeakKeyDict([(A,2), (B,3), (C,4)]) == wkd
+    @test WeakKeyDict(Pair(A,2), Pair(B,3), Pair(C,4)) == wkd
     @test copy(wkd) == wkd
 
     @test length(wkd) == 3
@@ -634,6 +640,7 @@ Dict(1 => rand(2,3), 'c' => "asdf") # just make sure this does not trigger a dep
     @test B ∉ keys(wkd)
     @test 3 ∉ values(wkd)
     @test length(wkd) == 1
+    @test WeakKeyDict(Pair(A, 2)) == wkd
     @test !isempty(wkd)
 
     wkd = empty!(wkd)
@@ -642,6 +649,8 @@ Dict(1 => rand(2,3), 'c' => "asdf") # just make sure this does not trigger a dep
     @test length(wkd) == 0
     @test isempty(wkd)
     @test isa(wkd, WeakKeyDict)
+
+    @test_throws ArgumentError WeakKeyDict([1, 2, 3])
 end
 
 @testset "issue #19995, hash of dicts" begin
@@ -682,3 +691,45 @@ let
         @test pair[1] == tupl[1] && pair[2] == tupl[2]
     end
 end
+
+@testset "Dict merge" begin
+    d1 = Dict("A" => 1, "B" => 2)
+    d2 = Dict("B" => 3.0, "C" => 4.0)
+    @test @inferred merge(d1, d2) == Dict("A" => 1, "B" => 3, "C" => 4)
+    # merge with combiner function
+    @test @inferred merge(+, d1, d2) == Dict("A" => 1, "B" => 5, "C" => 4)
+    @test @inferred merge(*, d1, d2) == Dict("A" => 1, "B" => 6, "C" => 4)
+    @test @inferred merge(-, d1, d2) == Dict("A" => 1, "B" => -1, "C" => 4)
+end
+
+@testset "Dict merge!" begin
+    d1 = Dict("A" => 1, "B" => 2)
+    d2 = Dict("B" => 3, "C" => 4)
+    @inferred merge!(d1, d2)
+    @test d1 == Dict("A" => 1, "B" => 3, "C" => 4)
+    # merge! with combiner function
+    @inferred merge!(+, d1, d2)
+    @test d1 == Dict("A" => 1, "B" => 6, "C" => 8)
+    @inferred merge!(*, d1, d2)
+    @test d1 == Dict("A" => 1, "B" => 18, "C" => 32)
+    @inferred merge!(-, d1, d2)
+    @test d1 == Dict("A" => 1, "B" => 15, "C" => 28)
+end
+
+@testset "misc error/io" begin
+    d = Dict('a'=>1, 'b'=>1, 'c'=> 3)
+    @test_throws ErrorException 'a' in d
+    key_str = sprint(show, keys(d))
+    @test 'a' ∈ key_str
+    @test 'b' ∈ key_str
+    @test 'c' ∈ key_str
+end
+
+@testset "Dict pop!" begin
+    d = Dict(1=>2, 3=>4)
+    @test pop!(d, 1) == 2
+    @test_throws KeyError pop!(d, 1)
+    @test pop!(d, 1, 0) == 0
+    @test pop!(d) == (3=>4)
+    @test_throws ArgumentError pop!(d)
+end
diff --git a/test/dimensionful.jl b/test/dimensionful.jl
index 5abc866329c677..999f362cc27a71 100644
--- a/test/dimensionful.jl
+++ b/test/dimensionful.jl
@@ -1,3 +1,5 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
 # Here we implement a minimal dimensionful type Furlong, which is used
 # to test dimensional correctness of various functions in Base.  Furlong
 # is exported by the TestHelpers module.
@@ -8,21 +10,21 @@ struct Furlong{p,T<:Number} <: Number
     Furlong{p,T}(v::Number) where {p,T} = new(v)
     Furlong{p,T}(x::Furlong{p}) where {p,T} = new(x.val)
 end
-Furlong{T<:Number}(x::T) = Furlong{1,T}(x)
-(::Type{T}){p,T}(x::Furlong{p,T}) = x.val
-(::Type{Furlong{p}}){p}(v::Number) = Furlong{p,typeof(v)}(v)
-Base.convert{T,p,S}(::Type{Furlong{p,T}}, x::Furlong{p,S}) = Furlong{p,T}(convert(T,x.val))
-Base.convert{T}(::Type{Furlong{0,T}}, x::Furlong{0}) = Furlong{0,T}(convert(T, x.val))
-Base.convert{T<:Number}(::Type{T}, x::Furlong{0}) = convert(T, x.val)
-Base.convert{T}(::Type{Furlong{0,T}}, x::Number) = Furlong{0,T}(convert(T, x))
+Furlong(x::T) where {T<:Number} = Furlong{1,T}(x)
+(::Type{T})(x::Furlong{p,T}) where {p,T} = x.val
+(::Type{Furlong{p}})(v::Number) where {p} = Furlong{p,typeof(v)}(v)
+Base.convert(::Type{Furlong{p,T}}, x::Furlong{p,S}) where {T,p,S} = Furlong{p,T}(convert(T,x.val))
+Base.convert(::Type{Furlong{0,T}}, x::Furlong{0}) where {T} = Furlong{0,T}(convert(T, x.val))
+Base.convert(::Type{T}, x::Furlong{0}) where {T<:Number} = convert(T, x.val)
+Base.convert(::Type{Furlong{0,T}}, x::Number) where {T} = Furlong{0,T}(convert(T, x))
 
-Base.promote_type{p,T,S}(::Type{Furlong{p,T}}, ::Type{Furlong{p,S}}) =
+Base.promote_type(::Type{Furlong{p,T}}, ::Type{Furlong{p,S}}) where {p,T,S} =
     (Base.@_pure_meta; Furlong{p,promote_type(T,S)})
 
-Base.one{p,T}(x::Furlong{p,T}) = one(T)
-Base.one{p,T}(::Type{Furlong{p,T}}) = one(T)
-Base.zero{p,T}(x::Furlong{p,T}) = Furlong{p,T}(zero(T))
-Base.zero{p,T}(::Type{Furlong{p,T}}) = Furlong{p,T}(zero(T))
+Base.one(x::Furlong{p,T}) where {p,T} = one(T)
+Base.one(::Type{Furlong{p,T}}) where {p,T} = one(T)
+Base.zero(x::Furlong{p,T}) where {p,T} = Furlong{p,T}(zero(T))
+Base.zero(::Type{Furlong{p,T}}) where {p,T} = Furlong{p,T}(zero(T))
 Base.iszero(x::Furlong) = iszero(x.val)
 
 # convert Furlong exponent p to a canonical form.  This
@@ -30,48 +32,48 @@ Base.iszero(x::Furlong) = iszero(x.val)
 # at compile time (in generated functions), not runtime
 canonical_p(p) = isinteger(p) ? Int(p) : Rational{Int}(p)
 
-Base.abs{p}(x::Furlong{p}) = Furlong{p}(abs(x.val))
-@generated Base.abs2{p}(x::Furlong{p}) = :(Furlong{$(canonical_p(2p))}(abs2(x.val)))
-@generated Base.inv{p}(x::Furlong{p}) = :(Furlong{$(canonical_p(-p))}(inv(x.val)))
+Base.abs(x::Furlong{p}) where {p} = Furlong{p}(abs(x.val))
+@generated Base.abs2(x::Furlong{p}) where {p} = :(Furlong{$(canonical_p(2p))}(abs2(x.val)))
+@generated Base.inv(x::Furlong{p}) where {p} = :(Furlong{$(canonical_p(-p))}(inv(x.val)))
 Base.sylvester(a::Furlong,b::Furlong,c::Furlong) = -c / (a + b)
 
 for f in (:isfinite, :isnan, :isreal)
     @eval Base.$f(x::Furlong) = $f(x.val)
 end
 for f in (:real,:imag,:complex,:middle,:+,:-)
-    @eval Base.$f{p}(x::Furlong{p}) = Furlong{p}($f(x.val))
+    @eval Base.$f(x::Furlong{p}) where {p} = Furlong{p}($f(x.val))
 end
 
 import Base: +, -, ==, !=, <, <=, isless, isequal, *, /, //, div, rem, mod, ^,
              middle, hypot
 for op in (:+, :-, :middle, :hypot)
-    @eval function $op{p}(x::Furlong{p}, y::Furlong{p})
+    @eval function $op(x::Furlong{p}, y::Furlong{p}) where {p}
         v = $op(x.val, y.val)
         Furlong{p}(v)
     end
 end
 for op in (:(==), :(!=), :<, :<=, :isless, :isequal)
-    @eval $op{p}(x::Furlong{p}, y::Furlong{p}) = $op(x.val, y.val)
+    @eval $op(x::Furlong{p}, y::Furlong{p}) where {p} = $op(x.val, y.val)
 end
 # generated functions to allow type inference of the value of the exponent:
 for (f,op) in ((:_plus,:+),(:_minus,:-),(:_times,:*),(:_div,://))
-    @eval @generated function $f{T,p,q}(v::T, ::Furlong{p}, ::Union{Furlong{q},Type{Val{q}}})
+    @eval @generated function $f(v::T, ::Furlong{p}, ::Union{Furlong{q},Val{q}}) where {T,p,q}
         s = $op(p, q)
         :(Furlong{$(canonical_p(s)),$T}(v))
     end
 end
 for (op,eop) in ((:*, :_plus), (:/, :_minus), (://, :_minus), (:div, :_minus))
     @eval begin
-        $op{p,q}(x::Furlong{p}, y::Furlong{q}) =
+        $op(x::Furlong{p}, y::Furlong{q}) where {p,q} =
             $eop($op(x.val, y.val),x,y)
-        $op{p,S<:Number}(x::Furlong{p}, y::S) = $op(x,Furlong{0,S}(y))
-        $op{p,S<:Number}(x::S, y::Furlong{p}) = $op(Furlong{0,S}(x),y)
+        $op(x::Furlong{p}, y::S) where {p,S<:Number} = $op(x,Furlong{0,S}(y))
+        $op(x::S, y::Furlong{p}) where {p,S<:Number} = $op(Furlong{0,S}(x),y)
     end
 end
 for op in (:rem, :mod)
     @eval begin
-        $op{p}(x::Furlong{p}, y::Furlong) = Furlong{p}($op(x.val, y.val))
-        $op{p}(x::Furlong{p}, y::Number) = Furlong{p}($op(x.val, y))
+        $op(x::Furlong{p}, y::Furlong) where {p} = Furlong{p}($op(x.val, y.val))
+        $op(x::Furlong{p}, y::Number) where {p} = Furlong{p}($op(x.val, y))
     end
 end
-Base.sqrt(x::Furlong) = _div(sqrt(x.val), x, Val{2})
+Base.sqrt(x::Furlong) = _div(sqrt(x.val), x, Val(2))
diff --git a/test/distributed.jl b/test/distributed.jl
index a3a2cb8cbad8c2..fc3bac479dab58 100644
--- a/test/distributed.jl
+++ b/test/distributed.jl
@@ -1,17 +1,10 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Run the distributed test outside of the main driver since it needs its own
 # set of dedicated workers.
 
-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
-
-cmd = `$(Base.julia_cmd()) $inline_flag $cov_flag --check-bounds=yes --startup-file=no --depwarn=error distributed_exec.jl`
+include("testenv.jl")
+cmd = `$test_exename $test_exeflags distributed_exec.jl`
 
 if !success(pipeline(cmd; stdout=STDOUT, stderr=STDERR)) && ccall(:jl_running_on_valgrind,Cint,()) == 0
     error("Distributed test failed, cmd : $cmd")
diff --git a/test/distributed_exec.jl b/test/distributed_exec.jl
index 1b683c2ab9e201..46d331ce53f504 100644
--- a/test/distributed_exec.jl
+++ b/test/distributed_exec.jl
@@ -1,14 +1,7 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://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
+include("testenv.jl")
 
 # Test a few "remote" invocations when no workers are present
 @test remote(myid)() == 1
@@ -17,7 +10,11 @@ end
         1
     end
 
-addprocs(4; exeflags=`$cov_flag $inline_flag --check-bounds=yes --startup-file=no --depwarn=error`)
+addprocs_with_testenv(4)
+@test nprocs() == 5
+
+id_me = myid()
+id_other = filter(x -> x != id_me, procs())[rand(1:(nprocs()-1))]
 
 # Test remote()
 let
@@ -78,10 +75,6 @@ let
     @test count == 0
 end
 
-
-id_me = myid()
-id_other = filter(x -> x != id_me, procs())[rand(1:(nprocs()-1))]
-
 # Test Futures
 function testf(id)
     f=Future(id)
@@ -234,9 +227,30 @@ test_indexing(Future(id_other))
 test_indexing(RemoteChannel())
 test_indexing(RemoteChannel(id_other))
 
+# Test ser/deser to non-ClusterSerializer objects.
+function test_regular_io_ser(ref::Base.Distributed.AbstractRemoteRef)
+    io = IOBuffer()
+    serialize(io, ref)
+    seekstart(io)
+    ref2 = deserialize(io)
+    for fld in fieldnames(typeof(ref))
+        v = getfield(ref2, fld)
+        if isa(v, Number)
+            @test v === zero(typeof(v))
+        elseif isa(v, Nullable)
+            @test v === Nullable{Any}()
+        else
+            error(string("Add test for field ", fld))
+        end
+    end
+end
+
+test_regular_io_ser(Future())
+test_regular_io_ser(RemoteChannel())
+
 dims = (20,20,20)
 
-if is_linux()
+if Sys.islinux()
     S = SharedArray{Int64,3}(dims)
     @test startswith(S.segname, "/jl")
     @test !ispath("/dev/shm" * S.segname)
@@ -329,12 +343,8 @@ Atrue = reshape(1:30, sz)
 S = @inferred(SharedArray{Int,2}(fn, 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
+@everywhere procs(S) begin
+    $fill!($S.loc_subarr_1d, $myid())
 end
 check_pids_all(S)
 
@@ -422,9 +432,7 @@ remotecall_fetch(setindex!, pids_d[findfirst(id->(id != myid()), pids_d)], d, 1.
 @test s != d
 copy!(d, s)
 @everywhere setid!(A) = A[localindexes(A)] = myid()
-@sync for p in procs(ds)
-    @async remotecall_wait(setid!, p, ds)
-end
+@everywhere procs(ds) setid!($ds)
 @test d == s
 @test ds != s
 @test first(ds) == first(procs(ds))
@@ -508,6 +516,18 @@ d = SharedArray{Int}(10)
 finalize(d)
 @test_throws BoundsError d[1]
 
+# Issue 22139
+aorig = a1 = SharedArray{Float64}((3, 3))
+a1 = remotecall_fetch(fill!, id_other, a1, 1.0)
+@test object_id(aorig) == object_id(a1)
+id = a1.id
+aorig = nothing
+a1 = remotecall_fetch(fill!, id_other, a1, 1.0)
+gc(); gc()
+a1 = remotecall_fetch(fill!, id_other, a1, 1.0)
+@test haskey(Base.sa_refs, id)
+finalize(a1)
+@test !haskey(Base.sa_refs, id)
 
 # Test @parallel load balancing - all processors should get either M or M+1
 # iterations out of the loop range for some M.
@@ -613,9 +633,16 @@ catch ex
     @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))
+    # test start, next, and done
+    for (i, i_ex) in enumerate(ex)
+        @test i == parse(Int, i_ex.ex.msg)
+    end
+    # test showerror
+    err_str = sprint(showerror, ex)
+    err_one_str = sprint(showerror, ex.exceptions[1])
+    @test err_str == err_one_str * "\n\n...and 4 more exception(s).\n"
 end
+@test sprint(showerror, CompositeException()) == "CompositeException()\n"
 
 function test_remoteexception_thrown(expr)
     try
@@ -856,9 +883,9 @@ function testmap_equivalence(f, c...)
 end
 
 testmap_equivalence(identity, (1,2,3,4))
-testmap_equivalence(x->x>0?1.0:0.0, sparse(eye(5)))
+testmap_equivalence(x->x>0 ? 1.0 : 0.0, sparse(eye(5)))
 testmap_equivalence((x,y,z)->x+y+z, 1,2,3)
-testmap_equivalence(x->x?false:true, BitArray(10,10))
+testmap_equivalence(x->x ? false : true, BitArray(10,10))
 testmap_equivalence(x->"foobar", BitArray(10,10))
 testmap_equivalence((x,y,z)->string(x,y,z), BitArray(10), ones(10), "1234567890")
 
@@ -886,7 +913,6 @@ wp = CachingPool(workers())
 clear!(wp)
 @test length(wp.map_obj2ref) == 0
 
-
 # The below block of tests are usually run only on local development systems, since:
 # - tests which print errors
 # - addprocs tests are memory intensive
@@ -896,19 +922,6 @@ clear!(wp)
 DoFullTest = Bool(parse(Int,(get(ENV, "JULIA_TESTFULL", "0"))))
 
 if DoFullTest
-    # 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")
 
@@ -922,7 +935,7 @@ if DoFullTest
     # Test sending fake data to workers. The worker processes will print an
     # error message but should not terminate.
     for w in Base.Distributed.PGRP.workers
-        if isa(w, Base.Worker)
+        if isa(w, Base.Distributed.Worker)
             s = connect(get(w.config.host), get(w.config.port))
             write(s, randstring(32))
         end
@@ -930,7 +943,7 @@ if DoFullTest
     @test workers() == all_w
     @test all([p == remotecall_fetch(myid, p) for p in all_w])
 
-if is_unix() # aka have ssh
+if Sys.isunix() # aka have ssh
     function test_n_remove_pids(new_pids)
         for p in new_pids
             w_in_remote = sort(remotecall_fetch(workers, p))
@@ -945,11 +958,14 @@ if is_unix() # aka have ssh
             end
         end
 
-        remotecall_fetch(plst->rmprocs(plst; waitfor=5.0), 1, new_pids)
+        remotecall_fetch(rmprocs, 1, 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")
+    print("Please ensure: \n")
+    print("1) sshd is running locally with passwordless login enabled.\n")
+    print("2) Env variable USER is defined and is the ssh user.\n")
+    print("3) Port 9300 is not in use.\n")
 
     sshflags = `-o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -o LogLevel=ERROR `
     #Issue #9951
@@ -962,32 +978,48 @@ if is_unix() # aka have ssh
     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
+    new_pids = addprocs_with_testenv(hosts; sshflags=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, ["localhost", ("127.0.0.1", :auto), "localhost"], sshflags) do h, sf
-        addprocs(h; sshflags=sf)
-    end)
+    new_pids = addprocs_with_testenv(["localhost", ("127.0.0.1", :auto), "localhost"]; sshflags=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, [("localhost", 2), ("127.0.0.1", 2), "localhost"], sshflags) do h, sf
-        addprocs(h; sshflags=sf)
-    end)
+    new_pids = addprocs_with_testenv([("localhost", 2), ("127.0.0.1", 2), "localhost"]; sshflags=sshflags)
     @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)
+    new_pids = addprocs_with_testenv([("localhost", num_workers)]; tunnel=true, sshflags=sshflags)
     @test length(new_pids) == num_workers
     test_n_remove_pids(new_pids)
+
+    print("\nAll supported formats for hostname\n")
+    h1 = "localhost"
+    user = ENV["USER"]
+    h2 = "$user@$h1"
+    h3 = "$h2:22"
+    h4 = "$h3 $(string(getipaddr()))"
+    h5 = "$h4:9300"
+
+    new_pids = addprocs_with_testenv([h1, h2, h3, h4, h5]; sshflags=sshflags)
+    @test length(new_pids) == 5
+    test_n_remove_pids(new_pids)
+
+    print("\nkeyword arg exename\n")
+    for exename in [`$(joinpath(JULIA_HOME, Base.julia_exename()))`, "$(joinpath(JULIA_HOME, Base.julia_exename()))"]
+        for addp_func in [()->addprocs_with_testenv(["localhost"]; exename=exename, exeflags=test_exeflags, sshflags=sshflags),
+                          ()->addprocs_with_testenv(1; exename=exename, exeflags=test_exeflags)]
+
+            new_pids = addp_func()
+            @test length(new_pids) == 1
+            test_n_remove_pids(new_pids)
+        end
+    end
+
 end # unix-only
 end # full-test
 
@@ -1167,6 +1199,50 @@ for p in procs()
     @test p == remotecall_fetch(new_bar, p)
 end
 
+# @everywhere (remotecall_eval) behaviors (#22589)
+let (p, p2) = filter!(p -> p != myid(), procs())
+    @test (myid() + 1) == @everywhere myid() (myid() + 1)
+    @test (p * 2) == @everywhere p (myid() * 2)
+    @test 1 == @everywhere p defined_on_p = 1
+    @test !@isdefined defined_on_p
+    @test !isdefined(Main, :defined_on_p)
+    @test remotecall_fetch(isdefined, p, Main, :defined_on_p)
+    @test !remotecall_fetch(isdefined, p2, Main, :defined_on_p)
+    @test nothing === @everywhere [p, p] defined_on_p += 1
+    @test 3 === @everywhere p defined_on_p
+    let ref = Ref(0)
+        @test nothing ===
+            @everywhere [myid(), p, myid(), myid(), p] begin
+                Test.@test Main === @__MODULE__
+                $ref[] += 1
+            end
+        @test ref[] == 3
+    end
+    function test_throw_on(procs, msg)
+        try
+            @everywhere procs error($msg)
+            error("test failed to throw")
+        catch excpt
+            if procs isa Int
+                ex = Any[excpt]
+            else
+                ex = Any[ (ex::CapturedException).ex for ex in (excpt::CompositeException).exceptions ]
+            end
+            for (p, ex) in zip(procs, ex)
+                if procs isa Int || p != myid()
+                    @test (ex::RemoteException).pid == p
+                    ex = ((ex::RemoteException).captured::CapturedException).ex
+                end
+                @test (ex::ErrorException).msg == msg
+            end
+        end
+    end
+    test_throw_on(p, "everywhere on p")
+    test_throw_on(myid(), "everywhere on myid")
+    test_throw_on([p, myid()], "everywhere on myid and p")
+    test_throw_on([p2, p], "everywhere on p and p2")
+end
+
 # Test addprocs enable_threaded_blas parameter
 
 const get_num_threads = function() # anonymous so it will be serialized when called
@@ -1182,7 +1258,7 @@ const get_num_threads = function() # anonymous so it will be serialized when cal
         end
 
         # OSX BLAS looks at an environment variable
-        if is_apple()
+        if Sys.isapple()
             return ENV["VECLIB_MAXIMUM_THREADS"]
         end
     end
@@ -1211,7 +1287,7 @@ function test_add_procs_threaded_blas()
     master_blas_thread_count = get_num_threads()
 
     # Test with default enable_threaded_blas false
-    processes_added = addprocs(2)
+    processes_added = addprocs_with_testenv(2)
     for proc_id in processes_added
         test_blas_config(proc_id, false)
     end
@@ -1226,7 +1302,7 @@ function test_add_procs_threaded_blas()
     end
     rmprocs(processes_added)
 
-    processes_added = addprocs(2, enable_threaded_blas=true)
+    processes_added = addprocs_with_testenv(2, enable_threaded_blas=true)
     for proc_id in processes_added
         test_blas_config(proc_id, true)
     end
@@ -1247,7 +1323,7 @@ test_add_procs_threaded_blas()
 #19687
 # ensure no race conditions between rmprocs and addprocs
 for i in 1:5
-    p = addprocs(1)[1]
+    p = addprocs_with_testenv(1)[1]
     @spawnat p sleep(5)
     rmprocs(p; waitfor=0)
 end
@@ -1255,7 +1331,7 @@ end
 # Test if a wait has been called on rmprocs(...;waitfor=0), further remotecalls
 # don't throw errors.
 for i in 1:5
-    p = addprocs(1)[1]
+    p = addprocs_with_testenv(1)[1]
     np = nprocs()
     @spawnat p sleep(5)
     wait(rmprocs(p; waitfor=0))
@@ -1267,10 +1343,83 @@ end
 
 # Test that an exception is thrown if workers are unable to be removed within requested time.
 if DoFullTest
-    pids=addprocs(4);
+    pids=addprocs_with_testenv(4);
     @test_throws ErrorException rmprocs(pids; waitfor=0.001);
+    # wait for workers to be removed
+    while any(x -> (x in procs()), pids)
+        sleep(0.1)
+    end
+end
+
+# Test addprocs/rmprocs from master node only
+for f in [ ()->addprocs(1; exeflags=test_exeflags), ()->rmprocs(workers()) ]
+    try
+        remotecall_fetch(f, id_other)
+        error("Unexpected")
+    catch ex
+        @test isa(ex, RemoteException)
+        @test ex.captured.ex.msg == "Only process 1 can add and remove workers"
+    end
+end
+
+# Test the following addprocs error conditions
+# - invalid host name - github issue #20372
+# - julia exe exiting with an error
+# - timeout reading host:port from worker STDOUT
+# - host:port not found in worker STDOUT in the first 1000 lines
+
+struct ErrorSimulator <: ClusterManager
+    mode
 end
 
+function Base.launch(manager::ErrorSimulator, params::Dict, launched::Array, c::Condition)
+    exename = params[:exename]
+    dir = params[:dir]
+
+    cmd = `$(Base.julia_cmd(exename)) --startup-file=no`
+    if manager.mode == :timeout
+        cmd = `$cmd -e "sleep(10)"`
+    elseif manager.mode == :ntries
+        cmd = `$cmd -e "[println(x) for x in 1:1001]"`
+    elseif manager.mode == :exit
+        cmd = `$cmd -e "exit(-1)"`
+    else
+        error("Unknown mode")
+    end
+    io = open(detach(setenv(cmd, dir=dir)))
+
+    wconfig = WorkerConfig()
+    wconfig.process = io
+    wconfig.io = io.out
+    push!(launched, wconfig)
+    notify(c)
+end
+
+testruns = Any[]
+
+if DoFullTest
+    append!(testruns, [(()->addprocs_with_testenv(["errorhost20372"]), "Unable to read host:port string from worker. Launch command exited with error?", ())])
+end
+
+append!(testruns, [
+    (()->addprocs_with_testenv(ErrorSimulator(:exit)), "Unable to read host:port string from worker. Launch command exited with error?", ()),
+    (()->addprocs_with_testenv(ErrorSimulator(:ntries)), "Unexpected output from worker launch command. Host:port string not found.", ()),
+    (()->addprocs_with_testenv(ErrorSimulator(:timeout)), "Timed out waiting to read host:port string from worker.", ("JULIA_WORKER_TIMEOUT"=>"1",))
+])
+
+for (addp_testf, expected_errstr, env) in testruns
+    try
+        withenv(env...) do
+            addp_testf()
+        end
+        error("Unexpected")
+    catch ex
+        @test isa(ex, CompositeException)
+        @test ex.exceptions[1].ex.msg == expected_errstr
+    end
+end
+
+
 # Auto serialization of globals from Main.
 # bitstypes
 global v1 = 1
@@ -1288,6 +1437,34 @@ for i in 1:5
     @test remotecall_fetch(()->v2, id_other) == v2
 end
 
+# Different global bindings to the same object
+global v3 = ones(10)
+global v4 = v3
+@test remotecall_fetch(()->v3, id_other) == remotecall_fetch(()->v4, id_other)
+@test remotecall_fetch(()->isdefined(Main, :v3), id_other)
+@test remotecall_fetch(()->isdefined(Main, :v4), id_other)
+
+# Global references to Types and Modules should work if they are locally defined
+global v5 = Int
+global v6 = Base.Distributed
+@test remotecall_fetch(()->v5, id_other) === Int
+@test remotecall_fetch(()->v6, id_other) === Base.Distributed
+
+struct FooStructLocal end
+module FooModLocal end
+v5 = FooStructLocal
+v6 = FooModLocal
+@test_throws RemoteException remotecall_fetch(()->v5, id_other)
+@test_throws RemoteException remotecall_fetch(()->v6, id_other)
+
+@everywhere struct FooStructEverywhere end
+@everywhere module FooModEverywhere end
+v5 = FooStructEverywhere
+v6 = FooModEverywhere
+@test remotecall_fetch(()->v5, id_other) === FooStructEverywhere
+@test remotecall_fetch(()->v6, id_other) === FooModEverywhere
+
+
 # Test that a global is not being repeatedly serialized when
 # a) referenced multiple times in the closure
 # b) hash value has not changed.
@@ -1421,6 +1598,32 @@ if true
 end
 @test x == map(_->sin(2), 1:2)
 
+let thrown = false
+    try
+        remotecall_fetch(sqrt, 2, -1)
+    catch e
+        thrown = true
+        b = IOBuffer()
+        showerror(b, e)
+        @test contains(String(take!(b)), "sqrt will only return")
+    end
+    @test thrown
+end
+
+#19463
+function foo19463()
+    w1 = workers()[1]
+    w2 = workers()[2]
+    w3 = workers()[3]
+
+    b1 = () -> 1
+    b2 = () -> fetch(@spawnat w1 b1()) + 1
+    b3 = () -> fetch(@spawnat w2 b2()) + 1
+    b4 = () -> fetch(@spawnat w3 b3()) + 1
+    b4()
+end
+@test foo19463() == 4
+
 # Testing clear!
 function setup_syms(n, pids)
     syms = []
@@ -1430,7 +1633,7 @@ function setup_syms(n, pids)
         eval(:(global $sym = rand()))
         for p in pids
             eval(:(@test $sym == remotecall_fetch(()->$sym, $p)))
-            eval(:(@test remotecall_fetch(isdefined, $p, Symbol($symstr))))
+            eval(:(@test remotecall_fetch(isdefined, $p, Main, Symbol($symstr))))
         end
         push!(syms, sym)
     end
@@ -1478,4 +1681,145 @@ catch ex
     @test isa(ex.captured.ex.exceptions[1].ex, ErrorException)
     @test contains(ex.captured.ex.exceptions[1].ex.msg, "BoundsError")
     @test ex.captured.ex.exceptions[2].ex == UndefVarError(:DontExistOn1)
-end
\ No newline at end of file
+end
+
+@test let
+    # creates a new worker in the same folder and tries to include file
+    tmp_file, temp_file_stream = mktemp()
+    close(temp_file_stream)
+    tmp_file = relpath(tmp_file)
+    try
+        proc = addprocs_with_testenv(1)
+        include(tmp_file)
+        remotecall_fetch(include, proc[1], tmp_file)
+        rmprocs(proc)
+        rm(tmp_file)
+        return true
+    catch e
+        println(e)
+        rm(tmp_file, force=true)
+        return false
+    end
+end == true
+
+let
+    # creates a new worker in a different folder and tries to include file
+    tmp_dir = mktempdir()
+    tmp_dir2 = joinpath(tmp_dir, "2")
+    tmp_file = joinpath(tmp_dir2, "testfile")
+    tmp_file2 = joinpath(tmp_dir2, "testfile2")
+    proc = addprocs_with_testenv(1, dir=tmp_dir)
+    try
+        mkdir(tmp_dir2)
+        write(tmp_file, "23.32 + 32 + myid() + include(\"testfile2\")")
+        write(tmp_file2, "myid() * 2")
+        @test_throws(ErrorException("could not open file $(abspath("testfile"))"),
+                     include("testfile"))
+        @test_throws(ErrorException("could not open file $(abspath("testfile2"))"),
+                     include("testfile2"))
+        @test_throws(ErrorException("could not open file $(abspath("2", "testfile"))"),
+                     include(joinpath("2", "testfile")))
+        @test include(tmp_file) == 58.32
+        @test remotecall_fetch(include, proc[1], joinpath("2", "testfile")) == 55.32 + proc[1] * 3
+    finally
+        rmprocs(proc)
+        rm(tmp_file, force=true)
+        rm(tmp_file2, force=true)
+        rm(tmp_dir2, force=true)
+        rm(tmp_dir, force=true)
+    end
+end
+# cookie and comand line option `--worker` tests. remove workers, set cookie and test
+struct WorkerArgTester <: ClusterManager
+    worker_opt
+    write_cookie
+end
+
+function Base.launch(manager::WorkerArgTester, params::Dict, launched::Array, c::Condition)
+    dir = params[:dir]
+    exename = params[:exename]
+    exeflags = params[:exeflags]
+
+    cmd = `$exename $exeflags --bind-to $(Base.Distributed.LPROC.bind_addr) $(manager.worker_opt)`
+    cmd = pipeline(detach(setenv(cmd, dir=dir)))
+    io = open(cmd, "r+")
+    manager.write_cookie && Base.Distributed.write_cookie(io)
+
+    wconfig = WorkerConfig()
+    wconfig.process = io
+    wconfig.io = io.out
+    push!(launched, wconfig)
+
+    notify(c)
+end
+Base.manage(::WorkerArgTester, ::Integer, ::WorkerConfig, ::Symbol) = nothing
+
+nprocs()>1 && rmprocs(workers())
+
+npids = addprocs_with_testenv(WorkerArgTester(`--worker`, true))
+@test remotecall_fetch(myid, npids[1]) == npids[1]
+rmprocs(npids)
+
+Base.cluster_cookie("")  # An empty string is a valid cookie
+npids = addprocs_with_testenv(WorkerArgTester(`--worker=`, false))
+@test remotecall_fetch(myid, npids[1]) == npids[1]
+rmprocs(npids)
+
+Base.cluster_cookie("foobar") # custom cookie
+npids = addprocs_with_testenv(WorkerArgTester(`--worker=foobar`, false))
+@test remotecall_fetch(myid, npids[1]) == npids[1]
+
+# Issue # 22865
+# Must be run on a new cluster, i.e., all workers must be in the same state.
+rmprocs(workers())
+p1,p2 = addprocs_with_testenv(2)
+@everywhere f22865(p) = remotecall_fetch(x->x.*2, p, ones(2))
+@test ones(2).*2 == remotecall_fetch(f22865, p1, p2)
+
+function reuseport_tests()
+    # Run the test on all processes.
+    results = asyncmap(procs()) do p
+        remotecall_fetch(p) do
+            ports_lower = []        # ports of pids lower than myid()
+            ports_higher = []       # ports of pids higher than myid()
+            for w in Base.Distributed.PGRP.workers
+                w.id == myid() && continue
+                port = Base._sockname(w.r_stream, true)[2]
+                if (w.id == 1)
+                    # master connects to workers
+                    push!(ports_higher, port)
+                elseif w.id < myid()
+                    push!(ports_lower, port)
+                elseif w.id > myid()
+                    push!(ports_higher, port)
+                end
+            end
+            @assert (length(ports_lower) + length(ports_higher)) == nworkers()
+            for portset in [ports_lower, ports_higher]
+                if (length(portset) > 0) && (length(unique(portset)) != 1)
+                    warn("SO_REUSEPORT TESTS FAILED. UNSUPPORTED/OLDER UNIX VERSION?")
+                    return 0
+                end
+            end
+            return myid()
+        end
+    end
+
+    # Ensure that the code has indeed been successfully executed everywhere
+    @test all(p -> p in results, procs())
+end
+
+# Test that the client port is reused. SO_REUSEPORT may not be supported on
+# all UNIX platforms, Linux kernels prior to 3.9 and older versions of OSX
+if ccall(:jl_has_so_reuseport, Int32, ()) == 1
+    rmprocs(workers())
+    addprocs_with_testenv(4; lazy=false)
+    reuseport_tests()
+else
+    info("SO_REUSEPORT is unsupported, skipping reuseport tests.")
+end
+
+# Run topology tests last after removing all workers, since a given
+# cluster at any time only supports a single topology.
+rmprocs(workers())
+include("topology.jl")
diff --git a/test/docs.jl b/test/docs.jl
index 21467e68ffae52..8401ab762ad772 100644
--- a/test/docs.jl
+++ b/test/docs.jl
@@ -1,10 +1,9 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 import Base.Docs: meta, @var, DocStr, parsedoc
 
-const curmod = current_module()
-const curmod_name = fullname(curmod)
-const curmod_prefix = "$(["$m." for m in curmod_name]...)"
+# For curmod_*
+include("testenv.jl")
 
 # Test helpers.
 function docstrings_equal(d1, d2)
@@ -35,6 +34,20 @@ macro macro_doctest() end
 
 @test (@doc @macro_doctest) !== nothing
 
+# test that random stuff interpolated into docstrings doesn't break search or other methods here
+doc"""
+break me:
+
+    code
+
+$:asymbol # a symbol
+$1 # a number
+$string # a function
+$$latex literal$$
+### header!
+"""
+function break_me_docs end
+
 # issue #11548
 
 module ModuleMacroDoc
@@ -49,7 +62,7 @@ end
 
 # General tests for docstrings.
 
-const LINE_NUMBER = @__LINE__+1
+const LINE_NUMBER = @__LINE__() + 1
 "DocsTest"
 module DocsTest
 
@@ -122,7 +135,7 @@ const K = :K
 
 t(x::AbstractString) = x
 t(x::Int, y) = y
-t{S <: Integer}(x::S) = x
+t(x::S) where {S <: Integer} = x
 
 "t-1"
 t(::AbstractString)
@@ -482,24 +495,27 @@ end
 
 # Issue #16359. Error message for invalid doc syntax.
 
-for each in [ # valid syntax
-        :(f()),
-        :(f(x)),
-        :(f(x::Int)),
-        :(f(x...)),
-        :(f(x = 1)),
-        :(f(; x = 1))
-    ]
-    @test Meta.isexpr(Docs.docm("...", each), :block)
-end
-for each in [ # invalid syntax
-        :(f("...")),
-        :(f(1, 2)),
-        :(f(() -> ()))
-    ]
-    result = Docs.docm("...", each)
-    @test Meta.isexpr(result, :call)
-    @test result.args[1] === error
+let __source__ = LineNumberNode(0),
+    __module__ = @__MODULE__
+    for each in [ # valid syntax
+            :(f()),
+            :(f(x)),
+            :(f(x::Int)),
+            :(f(x...)),
+            :(f(x = 1)),
+            :(f(; x = 1))
+        ]
+        @test Meta.isexpr(Docs.docm(__source__, __module__, "...", each), :block)
+    end
+    for each in [ # invalid syntax
+            :(f("...")),
+            :(f(1, 2)),
+            :(f(() -> ()))
+        ]
+        result = Docs.docm(__source__, __module__, "...", each)
+        @test Meta.isexpr(result, :call)
+        @test result.args[1] === error
+    end
 end
 
 # Issue #15424. Non-markdown docstrings.
@@ -597,12 +613,12 @@ module I12515
 struct EmptyType{T} end
 
 "A new method"
-Base.collect{T}(::Type{EmptyType{T}}) = "borked"
+Base.collect(::Type{EmptyType{T}}) where {T} = "borked"
 
 end
 
 let fd = meta(I12515)[@var(Base.collect)]
-    @test fd.order[1] == (Tuple{Type{I12515.EmptyType{T}}} where T)
+    @test fd.order[1] == (Union{Tuple{Type{I12515.EmptyType{T}}}, Tuple{T}} where T)
 end
 
 # PR #12593
@@ -629,8 +645,8 @@ f12593_2() = 1
 @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)
+    @test docstrings_equal(Docs.@repl((@__MODULE__).DocsTest.t(0, 0)), t)
+    @test docstrings_equal(Docs.@repl((@__MODULE__).DocsTest.t(::Int, ::Int)), t)
 end
 
 # Issue #13467.
@@ -690,7 +706,7 @@ end
 )
 
 # Issue #13905.
-@test macroexpand(:(@doc "" f() = @x)) == Expr(:error, UndefVarError(Symbol("@x")))
+@test @macroexpand(@doc "" f() = @x) == Expr(:error, UndefVarError(Symbol("@x")))
 
 # Undocumented DataType Summaries.
 
@@ -725,12 +741,12 @@ Binding `$(curmod_prefix)Undocumented.bindingdoesnotexist` does not exist.
 doc_str = Markdown.parse("""
 No documentation found.
 
-**Summary:**
+# Summary
 ```
 abstract type $(curmod_prefix)Undocumented.A <: Any
 ```
 
-**Subtypes:**
+# Subtypes
 ```
 $(curmod_prefix)Undocumented.B
 $(curmod_prefix)Undocumented.C
@@ -741,42 +757,57 @@ $(curmod_prefix)Undocumented.C
 doc_str = Markdown.parse("""
 No documentation found.
 
-**Summary:**
+# Summary
 ```
 abstract type $(curmod_prefix)Undocumented.B <: $(curmod_prefix)Undocumented.A
 ```
 
-**Subtypes:**
+# Subtypes
 ```
 $(curmod_prefix)Undocumented.D
 ```
+
+# Supertype Hierarchy
+```
+$(curmod_prefix)Undocumented.B <: $(curmod_prefix)Undocumented.A <: Any
+```
 """)
 @test docstrings_equal(@doc(Undocumented.B), doc"$doc_str")
 
 doc_str = Markdown.parse("""
 No documentation found.
 
-**Summary:**
+# Summary
 ```
 mutable struct $(curmod_prefix)Undocumented.C <: $(curmod_prefix)Undocumented.A
 ```
+
+# Supertype Hierarchy
+```
+$(curmod_prefix)Undocumented.C <: $(curmod_prefix)Undocumented.A <: Any
+```
 """)
 @test docstrings_equal(@doc(Undocumented.C), doc"$doc_str")
 
 doc_str = Markdown.parse("""
 No documentation found.
 
-**Summary:**
+# Summary
 ```
 struct $(curmod_prefix)Undocumented.D <: $(curmod_prefix)Undocumented.B
 ```
 
-**Fields:**
+# Fields
 ```
 one   :: Any
 two   :: String
 three :: Float64
 ```
+
+# Supertype Hierarchy
+```
+$(curmod_prefix)Undocumented.D <: $(curmod_prefix)Undocumented.B <: $(curmod_prefix)Undocumented.A <: Any
+```
 """)
 @test docstrings_equal(@doc(Undocumented.D), doc"$doc_str")
 
@@ -875,7 +906,7 @@ let x = Binding(Base, :bindingdoesnotexist)
     @test @var(Base.bindingdoesnotexist) == x
 end
 
-let x = Binding(current_module(), :bindingdoesnotexist)
+let x = Binding(curmod, :bindingdoesnotexist)
     @test defined(x) == false
     @test @var(bindingdoesnotexist) == x
 end
@@ -892,23 +923,24 @@ let x = Binding(Main, :⊕)
     @test parse(string(x)) == :(⊕)
 end
 
+doc_util_path = Symbol(joinpath("docs", "utils.jl"))
 # 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),
+    "@time(x)"     => Expr(:macrocall, Symbol("@time"), LineNumberNode(1, :none), :x),
+    "@time"        => Expr(:macrocall, Symbol("@time"), LineNumberNode(1, :none)),
+    ":@time"       => Expr(:quote, (Expr(:macrocall, Symbol("@time"), LineNumberNode(1, :none)))),
+    "@time()"      => Expr(:macrocall, Symbol("@time"), LineNumberNode(1, :none)),
+    "Base.@time()" => Expr(:macrocall, Expr(:., :Base, QuoteNode(Symbol("@time"))), LineNumberNode(1, :none)),
     "ccall"        => :ccall, # keyword
     "while       " => :while, # keyword, trailing spaces should be stripped.
     "0"            => 0,
     "\"...\""      => "...",
-    "r\"...\""     => :(r"..."),
+    "r\"...\""     => Expr(:macrocall, Symbol("@r_str"), LineNumberNode(1, :none), "...")
     ]
-    @test Docs.helpmode(line) == :(Base.Docs.@repl($STDOUT, $expr))
+    @test Docs.helpmode(line) == Expr(:macrocall, Expr(:., Expr(:., :Base, QuoteNode(:Docs)), QuoteNode(Symbol("@repl"))), LineNumberNode(117, doc_util_path), STDOUT, expr)
     buf = IOBuffer()
     @test eval(Base, Docs.helpmode(buf, line)) isa Union{Base.Markdown.MD,Void}
 end
@@ -947,8 +979,8 @@ dynamic_test.x = "test 2"
 @test @doc(dynamic_test) == "test 2 Union{}"
 @test @doc(dynamic_test(::String)) == "test 2 Tuple{String}"
 
-@test Docs._repl(:(dynamic_test(1.0))) == :(@doc $(Expr(:escape, :(dynamic_test(::typeof(1.0))))))
-@test Docs._repl(:(dynamic_test(::String))) == :(@doc $(Expr(:escape, :(dynamic_test(::String)))))
+@test Docs._repl(:(dynamic_test(1.0))) == Expr(:macrocall, Symbol("@doc"), LineNumberNode(206, doc_util_path), :(dynamic_test(::typeof(1.0))))
+@test Docs._repl(:(dynamic_test(::String))) == Expr(:macrocall, Symbol("@doc"), LineNumberNode(206, doc_util_path), :(dynamic_test(::String)))
 
 
 # Equality testing
@@ -959,3 +991,67 @@ dynamic_test.x = "test 2"
 @test Text("docstring1") ≠ Text("docstring2")
 @test hash(Text("docstring1")) ≠ hash(Text("docstring2"))
 @test hash(Text("docstring")) ≠ hash(HTML("docstring"))
+
+# issue 21016
+module I21016
+
+struct Struct{T}
+end
+
+"String 1"
+function Struct{T}(arg1) where T<:Float64
+end
+
+"String 2"
+function Struct{T}(arg1) where T
+end
+
+"String 3"
+function Struct{T}(arg1) where Integer <: T <: Real
+end
+
+"String 4"
+function Struct{T}(arg1) where T >: Int
+end
+
+end
+
+@test docstrings_equal(
+    @doc(I21016.Struct),
+    doc"""
+    String 1
+
+    String 2
+
+    String 3
+
+    String 4
+    """
+)
+
+# issue #22105
+module I22105
+    lineno = @__LINE__
+    """foo docs"""
+    function foo end
+end
+
+let foo_docs = meta(I22105)[@var(I22105.foo)].docs
+    @test length(foo_docs) === 1
+    @test isa(first(foo_docs), Pair)
+    local docstr = first(foo_docs).second
+    @test isa(docstr, DocStr)
+    @test docstr.data[:path] == Base.source_path()
+    @test docstr.data[:linenumber] == I22105.lineno + 1
+    @test docstr.data[:module] === I22105
+    @test docstr.data[:typesig] === Union{}
+    @test docstr.data[:binding] == Binding(I22105, :foo)
+end
+
+# issue #23011
+@test_nowarn @eval Main begin
+    @doc "first" f23011() = 1
+    @doc "second" f23011() = 2
+end
+@test Main.f23011() == 2
+@test docstrings_equal(@doc(Main.f23011), doc"second")
diff --git a/test/download.jl b/test/download.jl
new file mode 100644
index 00000000000000..e982dbfbcc53f4
--- /dev/null
+++ b/test/download.jl
@@ -0,0 +1,26 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
+mktempdir() do temp_dir
+    # Download a file
+    file = joinpath(temp_dir, "ip")
+    @test download("http://httpbin.org/ip", file) == file
+    @test isfile(file)
+    @test !isempty(read(file))
+
+    # Download an empty file
+    empty_file = joinpath(temp_dir, "empty")
+    @test download("http://httpbin.org/status/200", empty_file) == empty_file
+
+    # Windows and older versions of curl do not create the empty file (https://github.com/curl/curl/issues/183)
+    @test !isfile(empty_file) || isempty(read(empty_file))
+
+    # Make sure that failed downloads do not leave files around
+    missing_file = joinpath(temp_dir, "missing")
+    @test_throws ErrorException download("http://httpbin.org/status/404", missing_file)
+    @test !isfile(missing_file)
+
+    # Use a TEST-NET (192.0.2.0/24) address which shouldn't be bound
+    invalid_host_file = joinpath(temp_dir, "invalid_host")
+    @test_throws ErrorException download("http://192.0.2.1", invalid_host_file)
+    @test !isfile(invalid_host_file)
+end
diff --git a/test/dsp.jl b/test/dsp.jl
deleted file mode 100644
index e1a9ee650c4392..00000000000000
--- a/test/dsp.jl
+++ /dev/null
@@ -1,139 +0,0 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
-
-# Filter
-b = [1., 2., 3., 4.]
-x = [1., 1., 0., 1., 1., 0., 0., 0.]
-@test filt(b, 1., x)  == [1., 3., 5., 8., 7., 5., 7., 4.]
-@test filt(b, [1., -0.5], x)  == [1., 3.5, 6.75, 11.375, 12.6875, 11.34375, 12.671875, 10.3359375]
-# With ranges
-@test filt(b, 1., 1.0:10.0) == [1., 4., 10., 20., 30., 40., 50., 60., 70., 80.]
-@test filt(1.:4., 1., 1.0:10.0) == [1., 4., 10., 20., 30., 40., 50., 60., 70., 80.]
-# Across an array is the same as channel-by-channel
-@test filt(b, 1., [x 1.0:8.0]) == [filt(b, 1., x) filt(b, 1., 1.0:8.0)]
-@test filt(b, [1., -0.5], [x 1.0:8.0]) == [filt(b, [1., -0.5], x) filt(b, [1., -0.5], 1.0:8.0)]
-si = zeros(3)
-@test filt(b, 1., [x 1.0:8.0], si) == [filt(b, 1., x, si) filt(b, 1., 1.0:8.0, si)]
-@test si == zeros(3) # Will likely fail if/when arrayviews are implemented
-si = [zeros(3) ones(3)]
-@test filt(b, 1., [x 1.0:8.0], si) == [filt(b, 1., x, zeros(3)) filt(b, 1., 1.0:8.0, ones(3))]
-# With initial conditions: a lowpass 5-pole butterworth filter with W_n = 0.25,
-# and a stable initial filter condition matched to the initial value
-b = [0.003279216306360201,0.016396081531801006,0.03279216306360201,0.03279216306360201,0.016396081531801006,0.003279216306360201]
-a = [1.0,-2.4744161749781606,2.8110063119115782,-1.703772240915465,0.5444326948885326,-0.07231566910295834]
-si = [0.9967207836936347,-1.4940914728163142,1.2841226760316475,-0.4524417279474106,0.07559488540931815]
-@test filt(b, a, ones(10), si) ≈ ones(10) # Shouldn't affect DC offset
-
-@test_throws ArgumentError filt!([1, 2], [1], [1], [1])
-@test xcorr([1, 2], [3, 4]) == [4, 11, 6]
-
-# Shift-Functions
-@test fftshift([1 2 3]) == [3 1 2]
-@test fftshift([1, 2, 3]) == [3, 1, 2]
-@test fftshift([1 2 3; 4 5 6]) == [6 4 5; 3 1 2]
-
-@test fftshift([1 2 3; 4 5 6], 1) == [4 5 6; 1 2 3]
-@test fftshift([1 2 3; 4 5 6], ()) == [1 2 3; 4 5 6]
-@test fftshift([1 2 3; 4 5 6], (1,2)) == [6 4 5; 3 1 2]
-@test fftshift([1 2 3; 4 5 6], 1:2) == [6 4 5; 3 1 2]
-
-@test ifftshift([1 2 3]) == [2 3 1]
-@test ifftshift([1, 2, 3]) == [2, 3, 1]
-@test ifftshift([1 2 3; 4 5 6]) == [5 6 4; 2 3 1]
-
-@test ifftshift([1 2 3; 4 5 6], 1) == [4 5 6; 1 2 3]
-@test ifftshift([1 2 3; 4 5 6], ()) == [1 2 3; 4 5 6]
-@test ifftshift([1 2 3; 4 5 6], (1,2)) == [5 6 4; 2 3 1]
-@test ifftshift([1 2 3; 4 5 6], 1:2) == [5 6 4; 2 3 1]
-
-# Convolution
-a = [1., 2., 1., 2.]
-b = [1., 2., 3.]
-@test conv(a, b) ≈ [1., 4., 8., 10., 7., 6.]
-@test conv(complex.(a, ones(4)), complex(b)) ≈ complex.([1., 4., 8., 10., 7., 6.], [1., 3., 6., 6., 5., 3.])
-
-# Discrete cosine transform (DCT) tests
-
-if Base.fftw_vendor() != :mkl
-    a = rand(8,11) + im*rand(8,11)
-    @test norm(idct(dct(a)) - a) < 1e-8
-
-    X = reshape([1,2,7,2,1,5,9,-1,3,4,6,9],3,4)
-    Y = rand(17,14)
-    Y[3:5,9:12] = X
-    sX = view(Y,3:5,9:12)
-
-    true_Xdct = [  13.856406460551018  -3.863239728836245   2.886751345948129  -0.274551994240164; -2.828427124746190  -2.184015211898548  -4.949747468305834   3.966116180118245; 4.898979485566356  -0.194137576915510  -2.857738033247041   2.731723009609389 ]
-
-    true_Xdct_1 = [    5.773502691896258   4.618802153517007   6.350852961085884  10.969655114602890; -4.242640687119286  -2.121320343559643   4.242640687119286  -3.535533905932738; 1.632993161855452   2.041241452319315   5.715476066494083   0.408248290463863 ]
-
-    true_Xdct_2 = [    8.  -3.854030797826254  -3.0  3.761176226848022;
-        4.0  -2.071929829606556   4.0  -2.388955165168770; 12.  -0.765366864730179   4.0  -1.847759065022573 ]
-
-    Xdct = dct(X)
-    Xdct! = float(X); dct!(Xdct!)
-    Xdct_1 = dct(X,1)
-    Xdct!_1 = float(X); dct!(Xdct!_1,1)
-    Xdct_2 = dct(X,2)
-    Xdct!_2 = float(X); dct!(Xdct!_2,2)
-
-    Xidct = idct(true_Xdct)
-    Xidct! = copy(true_Xdct); idct!(Xidct!)
-    Xidct_1 = idct(true_Xdct_1,1)
-    Xidct!_1 = copy(true_Xdct_1); idct!(Xidct!_1,1)
-    Xidct_2 = idct(true_Xdct_2,2)
-    Xidct!_2 = copy(true_Xdct_2); idct!(Xidct!_2,2)
-
-    pXdct = plan_dct(X)*(X)
-    pXdct! = float(X); plan_dct!(pXdct!)*(pXdct!)
-    pXdct_1 = plan_dct(X,1)*(X)
-    pXdct!_1 = float(X); plan_dct!(pXdct!_1,1)*(pXdct!_1)
-    pXdct_2 = plan_dct(X,2)*(X)
-    pXdct!_2 = float(X); plan_dct!(pXdct!_2,2)*(pXdct!_2)
-
-    pXidct = plan_idct(true_Xdct)*(true_Xdct)
-    pXidct! = copy(true_Xdct); plan_idct!(pXidct!)*(pXidct!)
-    pXidct_1 = plan_idct(true_Xdct_1,1)*(true_Xdct_1)
-    pXidct!_1 = copy(true_Xdct_1); plan_idct!(pXidct!_1,1)*(pXidct!_1)
-    pXidct_2 = plan_idct(true_Xdct_2,2)*(true_Xdct_2)
-    pXidct!_2 = copy(true_Xdct_2); plan_idct!(pXidct!_2,2)*(pXidct!_2)
-
-    sXdct = dct(sX)
-    psXdct = plan_dct(sX)*(sX)
-    sYdct! = copy(Y); sXdct! = view(sYdct!,3:5,9:12); dct!(sXdct!)
-    psYdct! = copy(Y); psXdct! = view(psYdct!,3:5,9:12); plan_dct!(psXdct!)*(psXdct!)
-
-    for i = 1:length(X)
-        @test Xdct[i] ≈ true_Xdct[i]
-        @test Xdct![i] ≈ true_Xdct[i]
-        @test Xdct_1[i] ≈ true_Xdct_1[i]
-        @test Xdct!_1[i] ≈ true_Xdct_1[i]
-        @test Xdct_2[i] ≈ true_Xdct_2[i]
-        @test Xdct!_2[i] ≈ true_Xdct_2[i]
-
-        @test pXdct[i] ≈ true_Xdct[i]
-        @test pXdct![i] ≈ true_Xdct[i]
-        @test pXdct_1[i] ≈ true_Xdct_1[i]
-        @test pXdct!_1[i] ≈ true_Xdct_1[i]
-        @test pXdct_2[i] ≈ true_Xdct_2[i]
-        @test pXdct!_2[i] ≈ true_Xdct_2[i]
-
-        @test Xidct[i] ≈ X[i]
-        @test Xidct![i] ≈ X[i]
-        @test Xidct_1[i] ≈ X[i]
-        @test Xidct!_1[i] ≈ X[i]
-        @test Xidct_2[i] ≈ X[i]
-        @test Xidct!_2[i] ≈ X[i]
-
-        @test pXidct[i] ≈ X[i]
-        @test pXidct![i] ≈ X[i]
-        @test pXidct_1[i] ≈ X[i]
-        @test pXidct!_1[i] ≈ X[i]
-        @test pXidct_2[i] ≈ X[i]
-        @test pXidct!_2[i] ≈ X[i]
-
-        @test sXdct[i] ≈ true_Xdct[i]
-        @test psXdct[i] ≈ true_Xdct[i]
-        @test sXdct![i] ≈ true_Xdct[i]
-        @test psXdct![i] ≈ true_Xdct[i]
-    end
-end # fftw_vendor() != :mkl
diff --git a/test/enums.jl b/test/enums.jl
index 5f0573097ef144..ea4169af7b8aa6 100644
--- a/test/enums.jl
+++ b/test/enums.jl
@@ -1,8 +1,7 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
-const curmod = current_module()
-const curmod_name = fullname(curmod)
-const curmod_prefix = "$(["$m." for m in curmod_name]...)"
+# For curmod_*
+include("testenv.jl")
 
 using Base.Test
 
@@ -79,7 +78,7 @@ end
 @test Integer(_zerobi) == 1
 
 # can't use non-identifiers as enum members
-@test_throws ArgumentError eval(:(@enum(Test2, ?)))
+@test_throws ArgumentError eval(:(@enum Test2  x ? 1 : 2))
 @test_throws ArgumentError eval(:(@enum Test22 1=2))
 
 # other Integer types of enum members
diff --git a/test/env.jl b/test/env.jl
index 86eb0ba9b89c61..10c75d4da66b81 100644
--- a/test/env.jl
+++ b/test/env.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 @test !("f=a=k=e=n=a=m=e" ∈ keys(ENV))
 
diff --git a/test/error.jl b/test/error.jl
index be9f13e73aee1a..e92aa93bd695c9 100644
--- a/test/error.jl
+++ b/test/error.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 @test length(ExponentialBackOff(n=10)) == 10
 @test collect(ExponentialBackOff(n=10, first_delay=0.01))[1] == 0.01
@@ -63,4 +63,9 @@ let
     @test typeof(ex) == ErrorException
     @test ex.msg == "foo"
     @test c[1] == 1
+
+    # Functions with keyword arguments
+    foo_kwargs(x; y=5) = x + y
+    @test retry(foo_kwargs)(3) == 8
+    @test retry(foo_kwargs)(3; y=4) == 7
 end
diff --git a/test/euler.jl b/test/euler.jl
index d4ef4744831f75..52b9bd0a3702c8 100644
--- a/test/euler.jl
+++ b/test/euler.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## Project Euler
 #
diff --git a/test/examples.jl b/test/examples.jl
index e66787eb69688d..c406c5784ca5e1 100644
--- a/test/examples.jl
+++ b/test/examples.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 dir = joinpath(JULIA_HOME, Base.DOCDIR, "examples")
 
@@ -37,7 +37,7 @@ include(joinpath(dir, "queens.jl"))
 # Different cluster managers do not play well together. Since
 # the test infrastructure already uses LocalManager, we will test the simple
 # cluster manager example through a new Julia session.
-if is_unix()
+if Sys.isunix()
     script = joinpath(dir, "clustermanager/simple/test_simple.jl")
     cmd = `$(Base.julia_cmd()) --startup-file=no $script`
     if !success(pipeline(cmd; stdout=STDOUT, stderr=STDERR)) && ccall(:jl_running_on_valgrind,Cint,()) == 0
diff --git a/test/fastmath.jl b/test/fastmath.jl
index 754e84362c5e6c..bac571c5bf2abf 100644
--- a/test/fastmath.jl
+++ b/test/fastmath.jl
@@ -1,14 +1,15 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # 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)
+@test macroexpand(Main, :(@fastmath 1+2)) == :(Base.FastMath.add_fast(1,2))
+@test macroexpand(Main, :(@fastmath +)) == :(Base.FastMath.add_fast)
+@test macroexpand(Main, :(@fastmath min(1))) == :(Base.FastMath.min_fast(1))
+@test macroexpand(Main, :(@fastmath min)) == :(Base.FastMath.min_fast)
+@test macroexpand(Main, :(@fastmath x.min)) == :(x.min)
+@test macroexpand(Main, :(@fastmath sincos(x))) == :(Base.FastMath.sincos_fast(x))
 
 # basic arithmetic
 
diff --git a/test/fft.jl b/test/fft.jl
deleted file mode 100644
index b55ccbe25a1cbe..00000000000000
--- a/test/fft.jl
+++ /dev/null
@@ -1,338 +0,0 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
-
-# fft
-a = rand(8) + im*rand(8)
-@test norm(ifft(fft(a)) - a) < 1e-8
-@test norm(ifft(fft(a,1),1) - a) < 1e-8
-@test norm(ifft(fft(a,[1]),[1]) - a) < 1e-8
-@test norm(ifft(fft(a,(1,)),(1,)) - a) < 1e-8
-a = rand(-10:10, 8) + im*rand(-10:10, 8)
-@test norm(ifft(fft(a)) - a) < 1e-8
-
-m4 = [16.    2     3    13;
-    5    11    10     8;
-    9     7     6    12;
-    4    14    15     1]
-
-true_fft_m4 = [
-    34.            34.            34.            34.;
-     7. - 1.0im  -5. + 3.0im  -3. + 5.0im   1. - 7.0im;
-    16.           -16.           -16.            16.;
-     7. + 1.0im  -5. - 3.0im  -3. - 5.0im   1. + 7.0im ]
-
-true_fftn_m4 = [
- 136.        0          0         0 ;
-   0.       20          8 + 8im   0 - 12im ;
-   0.       32 + 32im   0        32 - 32im ;
-   0.        0 + 12im   8 - 8im  20 ]
-
-true_fftd2_m4 = [
-   34.   13 + 11im    4   13 - 11im ;
-   34.   -5 -  3im   -4   -5 +  3im ;
-   34.    3 +  5im   -4    3 -  5im ;
-   34.  -11 - 13im    4  -11 + 13im ]
-
-b = rand(17,14)
-b[3:6,9:12] = m4
-sm4 = view(b,3:6,9:12)
-
-m3d = map(Float32,copy(reshape(1:5*3*2, 5, 3, 2)))
-true_fftd3_m3d = Array{Float32}(5, 3, 2)
-true_fftd3_m3d[:,:,1] = 17:2:45
-true_fftd3_m3d[:,:,2] = -15
-
-# use invoke to force usage of CTPlan versions even if FFTW is present
-for A in (Array,SubArray)
-    for f in (:fft,:ifft,:plan_fft,:plan_ifft)
-        f_ = Symbol(f, "_")
-        @eval begin
-            $f_{T,N}(x::$A{T,N}) = invoke($f, Tuple{AbstractArray{T,N}}, x)
-            $f_{T,N,R}(x::$A{T,N},r::R) = invoke($f,Tuple{AbstractArray{T,N},R},x,r)
-        end
-    end
-end
-
-for (f,fi,pf,pfi) in ((fft,ifft,plan_fft,plan_ifft),
-                      (fft_,ifft_,plan_fft_,plan_ifft_))
-    pm4 = pf(m4,1)
-
-    fft_m4 = f(m4,1)
-    fftd2_m4 = f(m4,2)
-    ifft_fft_m4 = fi(f(m4,1),1)
-    fftn_m4 = f(m4)
-    ifftn_fftn_m4 = fi(f(m4))
-
-    fft!_m4 = complex(m4); fft!(fft!_m4,1)
-    fft!d2_m4 = complex(m4); fft!(fft!d2_m4,2)
-    ifft!_fft_m4 = f(m4,1); ifft!(ifft!_fft_m4,1)
-    fft!n_m4 = complex(m4); fft!(fft!n_m4)
-    ifft!n_fftn_m4 = f(m4); ifft!(ifft!n_fftn_m4)
-
-    pfft_m4 = pf(m4,1)*m4
-    pfftd2_m4 = pf(m4,2)*m4
-    pifft_fft_m4 = pfi(fft_m4,1)*fft_m4
-    pfftn_m4 = pf(m4)*m4
-    pifftn_fftn_m4 = pfi(fftn_m4)*fftn_m4
-
-    pfft!_m4 = complex(m4); plan_fft!(pfft!_m4,1)*pfft!_m4
-    pfft!d2_m4 = complex(m4); plan_fft!(pfft!d2_m4,2)*pfft!d2_m4
-    pifft!_fft_m4 = f(m4,1); plan_ifft!(pifft!_fft_m4,1)*pifft!_fft_m4
-    pfft!n_m4 = complex(m4); plan_fft!(pfft!n_m4)*pfft!n_m4
-    pifft!n_fftn_m4 = f(m4); plan_ifft!(pifft!n_fftn_m4)*pifft!n_fftn_m4
-
-    sfftn_m4 = f(sm4)
-    psfftn_m4 = pf(sm4)*sm4
-    sfft!n_b = map(Complex128,b)
-    sfft!n_m4 = view(sfft!n_b,3:6,9:12); fft!(sfft!n_m4)
-    psfft!n_b = map(Complex128,b)
-    psfft!n_m4 = view(psfft!n_b,3:6,9:12); plan_fft!(psfft!n_m4)*psfft!n_m4
-
-    for i = 1:length(m4)
-        @test fft_m4[i] ≈ true_fft_m4[i]
-        @test fftd2_m4[i] ≈ true_fftd2_m4[i]
-        @test ifft_fft_m4[i] ≈ m4[i]
-        @test fftn_m4[i] ≈ true_fftn_m4[i]
-        @test ifftn_fftn_m4[i] ≈ m4[i]
-
-        @test fft!_m4[i] ≈ true_fft_m4[i]
-        @test fft!d2_m4[i] ≈ true_fftd2_m4[i]
-        @test ifft!_fft_m4[i] ≈ m4[i]
-        @test fft!n_m4[i] ≈ true_fftn_m4[i]
-        @test ifft!n_fftn_m4[i] ≈ m4[i]
-
-        @test pfft_m4[i] ≈ true_fft_m4[i]
-        @test pfftd2_m4[i] ≈ true_fftd2_m4[i]
-        @test pifft_fft_m4[i] ≈ m4[i]
-        @test pfftn_m4[i] ≈ true_fftn_m4[i]
-        @test pifftn_fftn_m4[i] ≈ m4[i]
-
-        @test pfft!_m4[i] ≈ true_fft_m4[i]
-        @test pfft!d2_m4[i] ≈ true_fftd2_m4[i]
-        @test pifft!_fft_m4[i] ≈ m4[i]
-        @test pfft!n_m4[i] ≈ true_fftn_m4[i]
-        @test pifft!n_fftn_m4[i] ≈ m4[i]
-
-        @test sfftn_m4[i] ≈ true_fftn_m4[i]
-        @test sfft!n_m4[i] ≈ true_fftn_m4[i]
-        @test psfftn_m4[i] ≈ true_fftn_m4[i]
-        @test psfft!n_m4[i] ≈ true_fftn_m4[i]
-    end
-
-    ifft!(sfft!n_m4)
-    plan_ifft!(psfft!n_m4)*psfft!n_m4
-    @test norm(sfft!n_m4 - m4) < 1e-8
-    @test norm(psfft!n_m4 - m4) < 1e-8
-
-    # The following capabilities are FFTW only.
-    # They are not available in MKL, and hence do not test them.
-    if Base.fftw_vendor() != :mkl
-        ifft3_fft3_m3d = fi(f(m3d))
-
-        fftd3_m3d = f(m3d,3)
-        ifftd3_fftd3_m3d = fi(fftd3_m3d,3)
-
-        fft!d3_m3d = complex(m3d); fft!(fft!d3_m3d,3)
-        ifft!d3_fftd3_m3d = copy(fft!d3_m3d); ifft!(ifft!d3_fftd3_m3d,3)
-
-        pfftd3_m3d = pf(m3d,3)*m3d
-        pifftd3_fftd3_m3d = pfi(fftd3_m3d,3)*fftd3_m3d
-
-        pfft!d3_m3d = complex(m3d); plan_fft!(pfft!d3_m3d,3)*pfft!d3_m3d
-        pifft!d3_fftd3_m3d = copy(fft!d3_m3d); plan_ifft!(pifft!d3_fftd3_m3d,3)*pifft!d3_fftd3_m3d
-
-        @test isa(fftd3_m3d, Array{Complex64,3})
-        @test isa(ifftd3_fftd3_m3d, Array{Complex64,3})
-        @test isa(fft!d3_m3d, Array{Complex64,3})
-        @test isa(ifft!d3_fftd3_m3d, Array{Complex64,3})
-        @test isa(pfftd3_m3d, Array{Complex64,3})
-        @test isa(pifftd3_fftd3_m3d, Array{Complex64,3})
-        @test isa(pfft!d3_m3d, Array{Complex64,3})
-        @test isa(pifft!d3_fftd3_m3d, Array{Complex64,3})
-
-        for i = 1:length(m3d)
-            @test fftd3_m3d[i] ≈ true_fftd3_m3d[i]
-            @test ifftd3_fftd3_m3d[i] ≈ m3d[i]
-            @test ifft3_fft3_m3d[i] ≈ m3d[i]
-
-            @test fft!d3_m3d[i] ≈ true_fftd3_m3d[i]
-            @test ifft!d3_fftd3_m3d[i] ≈ m3d[i]
-
-            @test pfftd3_m3d[i] ≈ true_fftd3_m3d[i]
-            @test pifftd3_fftd3_m3d[i] ≈ m3d[i]
-            @test pfft!d3_m3d[i] ≈ true_fftd3_m3d[i]
-            @test pifft!d3_fftd3_m3d[i] ≈ m3d[i]
-        end
-    end  # if fftw_vendor() != :mkl
-
-    # rfft/rfftn
-
-    rfft_m4 = rfft(m4,1)
-    rfftd2_m4 = rfft(m4,2)
-    rfftn_m4 = rfft(m4)
-
-    prfft_m4 = plan_rfft(m4,1)*m4
-    prfftd2_m4 = plan_rfft(m4,2)*m4
-    prfftn_m4 = plan_rfft(m4)*m4
-
-    srfftn_m4 = rfft(sm4)
-    psrfftn_m4 = plan_rfft(sm4)*sm4
-
-    for i = 1:3, j = 1:4
-        @test rfft_m4[i,j] ≈ true_fft_m4[i,j]
-        @test rfftd2_m4[j,i] ≈ true_fftd2_m4[j,i]
-        @test rfftn_m4[i,j] ≈ true_fftn_m4[i,j]
-
-        @test prfft_m4[i,j] ≈ true_fft_m4[i,j]
-        @test prfftd2_m4[j,i] ≈ true_fftd2_m4[j,i]
-        @test prfftn_m4[i,j] ≈ true_fftn_m4[i,j]
-
-        @test srfftn_m4[i,j] ≈ true_fftn_m4[i,j]
-        @test psrfftn_m4[i,j] ≈ true_fftn_m4[i,j]
-    end
-
-    irfft_rfft_m4 = irfft(rfft_m4,size(m4,1),1)
-    irfft_rfftd2_m4 = irfft(rfftd2_m4,size(m4,2),2)
-    irfftn_rfftn_m4 = irfft(rfftn_m4,size(m4,1))
-
-    pirfft_rfft_m4 = plan_irfft(rfft_m4,size(m4,1),1)*rfft_m4
-    pirfft_rfftd2_m4 = plan_irfft(rfftd2_m4,size(m4,2),2)*rfftd2_m4
-    pirfftn_rfftn_m4 = plan_irfft(rfftn_m4,size(m4,1))*rfftn_m4
-
-    for i = 1:length(m4)
-        @test irfft_rfft_m4[i] ≈ m4[i]
-        @test irfft_rfftd2_m4[i] ≈ m4[i]
-        @test irfftn_rfftn_m4[i] ≈ m4[i]
-
-        @test pirfft_rfft_m4[i] ≈ m4[i]
-        @test pirfft_rfftd2_m4[i] ≈ m4[i]
-        @test pirfftn_rfftn_m4[i] ≈ m4[i]
-    end
-
-    if Base.fftw_vendor() != :mkl
-        rfftn_m3d = rfft(m3d)
-        rfftd3_m3d = rfft(m3d,3)
-        @test size(rfftd3_m3d) == size(fftd3_m3d)
-        irfft_rfftd3_m3d = irfft(rfftd3_m3d,size(m3d,3),3)
-        irfftn_rfftn_m3d = irfft(rfftn_m3d,size(m3d,1))
-        for i = 1:length(m3d)
-            @test rfftd3_m3d[i] ≈ true_fftd3_m3d[i]
-            @test irfft_rfftd3_m3d[i] ≈ m3d[i]
-            @test irfftn_rfftn_m3d[i] ≈ m3d[i]
-        end
-
-        fftn_m3d = fft(m3d)
-        @test size(fftn_m3d) == (5,3,2)
-        rfftn_m3d = rfft(m3d)
-        @test size(rfftn_m3d) == (3,3,2)
-        for i = 1:3, j = 1:3, k = 1:2
-            @test rfftn_m3d[i,j,k] ≈ fftn_m3d[i,j,k]
-        end
-    end # !mkl
-end
-
-# FFT self-test algorithm (for unscaled 1d forward FFTs):
-#   Funda Ergün, "Testing multivariate linear functions: Overcoming
-#   the generator bottleneck," Proc. 27th ACM Symposium on the Theory
-#   of Computing, pp. 407-416 (1995).
-# Check linearity, impulse-response, and time-shift properties.
-function fft_test{T<:Complex}(p::Base.DFT.Plan{T}, ntrials=4,
-                              tol=1e5 * eps(real(T)))
-    ndims(p) == 1 || throw(ArgumentError("not a 1d FFT"))
-    n = length(p)
-    twopi_i = (-2 * convert(real(T), π)/n * (0:n-1)) * im
-    for trial = 1:ntrials
-        # linearity:
-        x = rand(T, n)
-        y = rand(T, n)
-        α = rand(T)
-        β = rand(T)
-        X = p * (α*x + β*y)
-        err = norm(α * (p*x) + β * (p*y) - X, Inf) / norm(X, Inf)
-        err <= tol || error("linearity error $err in $p")
-
-        # impulse-response:
-        z = zeros(T, n)
-        i = rand(0:n-1)
-        z[i+1] = 1
-        X = exp.(twopi_i*i)
-        err = norm(p*z - X, Inf) / norm(X, Inf)
-        err <= tol || error("impulse-response error $err in $p")
-
-        # time-shift:
-        if n > 1
-            s = rand(1:n-1)
-            X = (p*x).*exp.(twopi_i*s)
-            err = norm(p*circshift(x,s) - X, Inf) / norm(X, Inf)
-            err <= tol || error("time-shift error $err in $p")
-        end
-    end
-end
-
-for T in (Complex64, Complex128)
-    for n in [1:100; 121; 143; 1000; 1024; 1031; 2000; 2048]
-        x = zeros(T, n)
-        fft_test(plan_fft(x))
-        fft_test(plan_fft_(x))
-    end
-end
-
-# test inversion, scaling, and pre-allocated variants
-for T in (Complex64, Complex128)
-    for x in (T[1:100;], copy(reshape(T[1:200;], 20,10)))
-        y = similar(x)
-        for planner in (plan_fft, plan_fft_, plan_ifft, plan_ifft_)
-            p = planner(x)
-            pi = inv(p)
-            p3 = 3*p
-            p3i = inv(p3)
-            @test eltype(p) == eltype(pi) == eltype(p3) == eltype(p3i) == T
-            @test vecnorm(x - p3i * (p * 3x)) < eps(real(T)) * 10000
-            @test vecnorm(3x - pi * (p3 * x)) < eps(real(T)) * 10000
-            A_mul_B!(y, p, x)
-            @test y == p * x
-            A_ldiv_B!(y, p, x)
-            @test y == p \ x
-        end
-    end
-end
-
-let
-    plan32 = plan_fft([1.0:2048.0;])
-    plan64 = plan_fft([1f0:2048f0;])
-    FFTW.flops(plan32)
-    FFTW.flops(plan64)
-end
-
-# issue #9772
-for x in (randn(10),randn(10,12))
-    z = complex(x)
-    y = rfft(x)
-    @inferred rfft(x)
-    @inferred brfft(x,18)
-    @inferred brfft(y,10)
-    for f in (plan_bfft!, plan_fft!, plan_ifft!,
-              plan_bfft, plan_fft, plan_ifft,
-              fft, bfft, fft_, ifft)
-        p = @inferred f(z)
-        if isa(p, FFTW.Plan)
-            @inferred FFTW.plan_inv(p)
-        end
-    end
-    for f in (plan_bfft, plan_fft, plan_ifft,
-              plan_rfft, fft, bfft, fft_, ifft)
-        p = @inferred f(x)
-        if isa(p, FFTW.Plan)
-            @inferred FFTW.plan_inv(p)
-        end
-    end
-    # note: inference doesn't work for plan_fft_ since the
-    #       algorithm steps are included in the CTPlan type
-end
-
-# issue #17896
-a = rand(5)
-@test  fft(a) ==  fft(view(a,:)) ==  fft(view(a, 1:5)) ==  fft(view(a, [1:5;]))
-@test rfft(a) == rfft(view(a,:)) == rfft(view(a, 1:5)) == rfft(view(a, [1:5;]))
-a16 = convert(Vector{Float16}, a)
-@test  fft(a16) ==  fft(view(a16,:)) ==  fft(view(a16, 1:5)) ==  fft(view(a16, [1:5;]))
-@test rfft(a16) == rfft(view(a16,:)) == rfft(view(a16, 1:5)) == rfft(view(a16, [1:5;]))
diff --git a/test/file.jl b/test/file.jl
index 5fdcda60f15052..be85fab05de7eb 100644
--- a/test/file.jl
+++ b/test/file.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #############################################
 # Create some temporary files & directories #
@@ -26,7 +26,7 @@ let err = nothing
     end
 end
 
-if !is_windows() || Sys.windows_version() >= Sys.WINDOWS_VISTA_VER
+if !Sys.iswindows() || Sys.windows_version() >= Sys.WINDOWS_VISTA_VER
     dirlink = joinpath(dir, "dirlink")
     symlink(subdir, dirlink)
     # relative link
@@ -37,7 +37,7 @@ if !is_windows() || Sys.windows_version() >= Sys.WINDOWS_VISTA_VER
     cd(pwd_)
 end
 
-if !is_windows()
+if !Sys.iswindows()
     link = joinpath(dir, "afilelink.txt")
     symlink(file, link)
     # relative link
@@ -67,7 +67,7 @@ chmod(file, filemode(file) | 0o222)
 @test filemode(file) & 0o111 == 0
 @test filesize(file) == 0
 
-if is_windows()
+if Sys.iswindows()
     permissions = 0o444
     @test filemode(dir) & 0o777 != permissions
     @test filemode(subdir) & 0o777 != permissions
@@ -103,7 +103,7 @@ end
 
 # On windows the filesize of a folder is the accumulation of all the contained
 # files and is thus zero in this case.
-if is_windows()
+if Sys.iswindows()
     @test filesize(dir) == 0
 else
     @test filesize(dir) > 0
@@ -118,15 +118,15 @@ end
 #@test Int(time()) >= Int(mtime(file)) >= Int(mtime(dir)) >= 0 # 1 second accuracy should be sufficient
 
 # test links
-if is_unix()
+if Sys.isunix()
     @test islink(link) == true
     @test readlink(link) == file
 end
 
-if !is_windows() || Sys.windows_version() >= Sys.WINDOWS_VISTA_VER
+if !Sys.iswindows() || Sys.windows_version() >= Sys.WINDOWS_VISTA_VER
     @test islink(dirlink) == true
     @test isdir(dirlink) == true
-    @test readlink(dirlink) == subdir * (is_windows() ? "\\" : "")
+    @test readlink(dirlink) == subdir * (Sys.iswindows() ? "\\" : "")
 end
 
 # rm recursive TODO add links
@@ -162,7 +162,7 @@ rm(c_tmpdir, recursive=true)
 @test_throws Base.UVError rm(c_tmpdir, recursive=true)
 @test rm(c_tmpdir, force=true, recursive=true) === nothing
 
-if !is_windows()
+if !Sys.iswindows()
     # chown will give an error if the user does not have permissions to change files
     if get(ENV, "USER", "") == "root" || get(ENV, "HOME", "") == "/root"
         chown(file, -2, -1)  # Change the file owner to nobody
@@ -236,7 +236,11 @@ function test_monitor_wait(tval)
     end
     fname, events = wait(fm)
     close(fm)
-    @test fname == basename(file)
+    if Sys.islinux() || Sys.iswindows() || Sys.isapple()
+        @test fname == basename(file)
+    else
+        @test fname == ""  # platforms where F_GETPATH is not available
+    end
     @test events.changed
 end
 
@@ -303,14 +307,14 @@ my_tempdir = tempdir()
 
 path = tempname()
 # Issue #9053.
-@test ispath(path) == is_windows()
+@test ispath(path) == Sys.iswindows()
 ispath(path) && rm(path)
 
 (p, f) = mktemp()
 print(f, "Here is some text")
 close(f)
 @test isfile(p) == true
-@test readstring(p) == "Here is some text"
+@test read(p, String) == "Here is some text"
 rm(p)
 
 let
@@ -378,7 +382,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 readstring(orig_path) == readstring(copied_path)
+                @test read(orig_path, String) == read(copied_path, String)
             end
         end
     elseif isdir(orig_path)
@@ -387,7 +391,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 readstring(orig_path) == readstring(copied_path)
+        @test read(orig_path, String) == read(copied_path, String)
     end
 end
 
@@ -426,6 +430,8 @@ c_stat = stat(cfile)
 @test a_stat.size == b_stat.size
 @test a_stat.size == c_stat.size
 
+@test parse(Int,match(r"mode=(.*),",sprint(show,a_stat)).captures[1]) == a_stat.mode
+
 close(af)
 rm(afile)
 rm(bfile)
@@ -470,7 +476,7 @@ end
 
 # issue #10506 #10434
 ## Tests for directories and links to directories
-if !is_windows() || Sys.windows_version() >= Sys.WINDOWS_VISTA_VER
+if !Sys.iswindows() || Sys.windows_version() >= Sys.WINDOWS_VISTA_VER
     function setup_dirs(tmpdir)
         srcdir = joinpath(tmpdir, "src")
         hidden_srcdir = joinpath(tmpdir, ".hidden_srcdir")
@@ -680,7 +686,7 @@ end
 
 # issue #10506 #10434
 ## Tests for files and links to files as well as directories and links to directories
-if !is_windows()
+if !Sys.iswindows()
     function setup_files(tmpdir)
         srcfile = joinpath(tmpdir, "srcfile.txt")
         hidden_srcfile = joinpath(tmpdir, ".hidden_srcfile.txt")
@@ -712,7 +718,7 @@ if !is_windows()
         islink(s) && @test readlink(s) == readlink(d)
         islink(s) && @test isabspath(readlink(s)) == isabspath(readlink(d))
         # all should contain the same
-        @test readstring(s) == readstring(d) == file_txt
+        @test read(s, String) == read(d, String) == file_txt
     end
 
     function mv_check(s, d, d_mv, file_txt; remove_destination=true)
@@ -730,7 +736,7 @@ if !is_windows()
         islink(s) && @test readlink(s) == readlink(d_mv)
         islink(s) && @test isabspath(readlink(s)) == isabspath(readlink(d_mv))
         # all should contain the same
-        @test readstring(s) == readstring(d_mv) == file_txt
+        @test read(s, String) == read(d_mv, String) == file_txt
         # d => d_mv same file/dir
         @test Base.samefile(stat_d, stat_d_mv)
     end
@@ -774,7 +780,7 @@ if !is_windows()
             # 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 readstring(d) == otherfile_content
+            @test read(d, String) == otherfile_content
         end
     end
     # mv ----------------------------------------------------
@@ -834,7 +840,7 @@ if !is_windows()
         rel_dl = "rel_linkto_targetdir"
         rel_dir = joinpath("..", "targetdir")
         symlink(rel_dir, rel_dl)
-        rel_file_read_txt = readstring(rel_file)
+        rel_file_read_txt = read(rel_file, String)
         cd(pwd_)
         # Setup copytodir
         copytodir = joinpath(tmpdir, "copytodir")
@@ -912,7 +918,7 @@ let f = open(file, "w")
     f = open(file, "r")
     test_LibcFILE(convert(Libc.FILE, f))
     close(f)
-    if is_windows()
+    if Sys.iswindows()
         f = RawFD(ccall(:_open, Cint, (Cstring, Cint), file, Base.Filesystem.JL_O_RDONLY))
     else
         f = RawFD(ccall(:open, Cint, (Cstring, Cint), file, Base.Filesystem.JL_O_RDONLY))
@@ -931,7 +937,7 @@ end
 @test_throws ArgumentError open("ba\0d", "w")
 @test_throws ArgumentError cp(file, "ba\0d")
 @test_throws ArgumentError mv(file, "ba\0d")
-if !is_windows() || (Sys.windows_version() >= Sys.WINDOWS_VISTA_VER)
+if !Sys.iswindows() || (Sys.windows_version() >= Sys.WINDOWS_VISTA_VER)
     @test_throws ArgumentError symlink(file, "ba\0d")
 else
     @test_throws ErrorException symlink(file, "ba\0d")
@@ -953,7 +959,7 @@ cd(dirwalk) do
         touch(joinpath("sub_dir1", "file$i"))
     end
     touch(joinpath("sub_dir2", "file_dir2"))
-    has_symlinks = !is_windows() || (Sys.windows_version() >= Sys.WINDOWS_VISTA_VER)
+    has_symlinks = !Sys.iswindows() || (Sys.windows_version() >= Sys.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
@@ -1042,11 +1048,11 @@ rm(dirwalk, recursive=true)
 ############
 # Clean up #
 ############
-if !is_windows()
+if !Sys.iswindows()
     rm(link)
     rm(rellink)
 end
-if !is_windows() || (Sys.windows_version() >= Sys.WINDOWS_VISTA_VER)
+if !Sys.iswindows() || (Sys.windows_version() >= Sys.WINDOWS_VISTA_VER)
     rm(dirlink)
     rm(relsubdirlink)
 end
@@ -1107,7 +1113,7 @@ test2_12992()
 test2_12992()
 
 # issue 13559
-if !is_windows()
+if !Sys.iswindows()
 function test_13559()
     fn = tempname()
     run(`mkfifo $fn`)
@@ -1128,3 +1134,25 @@ end
 test_13559()
 end
 @test_throws ArgumentError mkpath("fakepath",-1)
+
+# issue #22566
+if !Sys.iswindows()
+    function test_22566()
+        fn = tempname()
+        run(`mkfifo $fn`)
+
+        script = "x = open(\"$fn\", \"w\"); close(x)"
+        cmd = `$(Base.julia_cmd()) --startup-file=no -e $script`
+        open(pipeline(cmd, stderr=STDERR))
+
+        r = open(fn, "r")
+        close(r)
+
+        rm(fn)
+    end
+
+    # repeat opening/closing fifo file, ensure no EINTR popped out
+    for i ∈ 1:50
+        test_22566()
+    end
+end  # !Sys.iswindows
diff --git a/test/float16.jl b/test/float16.jl
index 85356aa2cdb955..e9a188329c9789 100644
--- a/test/float16.jl
+++ b/test/float16.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base.Test
 
@@ -49,6 +49,11 @@ g = Float16(1.)
 @test floor(Float16(1)) === Float16(1)
 @test ceil(Float16(0.1)) == ceil(0.1)
 @test ceil(Float16(0.9)) == ceil(0.9)
+@test unsafe_trunc(UInt8, Float16(3)) === 0x03
+@test unsafe_trunc(Int16, Float16(3)) === Int16(3)
+@test unsafe_trunc(UInt128, Float16(3)) === UInt128(3)
+@test unsafe_trunc(Int128, Float16(3)) === Int128(3)
+@test unsafe_trunc(Int16, NaN16) === Int16(0)  #18771
 @test fma(Float16(0.1),Float16(0.9),Float16(0.5)) ≈ fma(0.1,0.9,0.5)
 @test muladd(Float16(0.1),Float16(0.9),Float16(0.5)) ≈ muladd(0.1,0.9,0.5)
 @test convert(Int128,Float16(-1.0)) == Int128(-1)
@@ -61,6 +66,7 @@ g = Float16(1.)
 @test f*g === Float16(2f0)
 @test f/g === Float16(2f0)
 @test f^g === Float16(2f0)
+@test f^1 === Float16(2f0)
 @test f^-g === Float16(0.5f0)
 
 @test f + 2 === Float16(4f0)
diff --git a/test/floatapprox.jl b/test/floatapprox.jl
index ddc338e70c94b0..0f09312c1d55a1 100644
--- a/test/floatapprox.jl
+++ b/test/floatapprox.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Floating point numbers - basic tests
 @test 4.00000000000001 ≈ 4.0
diff --git a/test/floatfuncs.jl b/test/floatfuncs.jl
index 94a751ad447ce6..d1796d68d5a18c 100644
--- a/test/floatfuncs.jl
+++ b/test/floatfuncs.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base.Test
 
@@ -14,11 +14,15 @@ end
 
 # maxintfloat
 
-@test maxintfloat(Float16) == Float16(2048f0)
+@test maxintfloat(Float16) === Float16(2048f0)
 for elty in (Float16,Float32,Float64)
-    @test maxintfloat(rand(elty)) == maxintfloat(elty)
+    @test maxintfloat(rand(elty)) === maxintfloat(elty)
 end
-@test maxintfloat() == maxintfloat(Float64)
+@test maxintfloat() === maxintfloat(Float64)
+@test maxintfloat(Float64, Int32) === 2147483647.0
+@test maxintfloat(Float32, Int32) === maxintfloat(Float32)
+@test maxintfloat(Float64, Int16) === 32767.0
+@test maxintfloat(Float64, Int64) === maxintfloat(Float64)
 
 # isinteger
 for elty in (Float16,Float32,Float64)
@@ -68,3 +72,10 @@ for elty in (Float32,Float64)
         @test round.(elty2,A) == fill(round(elty2,x),(10,10,10))
     end
 end
+
+@testset "Types" begin
+    for x in (Int16(0), 1, 2f0, pi, 3//4, big(5//6), 7.8, big(9), big(e))
+        @test float(typeof(x)) == typeof(float(x))
+        @test float(typeof(complex(x, x))) == typeof(float(complex(x, x)))
+    end
+end
diff --git a/test/functional.jl b/test/functional.jl
index cdf529ffbd4c3b..5256a54167473e 100644
--- a/test/functional.jl
+++ b/test/functional.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # tests related to functional programming functions and styles
 
diff --git a/test/goto.jl b/test/goto.jl
index b2395853a5f746..69a181756036f9 100644
--- a/test/goto.jl
+++ b/test/goto.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Basic goto tests
 
diff --git a/test/grisu.jl b/test/grisu.jl
index 3cf09b0d893c01..5fb6332de6a41c 100644
--- a/test/grisu.jl
+++ b/test/grisu.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base.Grisu
 
diff --git a/test/hashing.jl b/test/hashing.jl
index 60da16201cfe9f..de532dba449b73 100644
--- a/test/hashing.jl
+++ b/test/hashing.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 types = Any[
     Bool,
@@ -117,3 +117,6 @@ for prec in [3, 11, 15, 16, 31, 32, 33, 63, 64, 65, 254, 255, 256, 257, 258, 102
         @test isequal(x, y)
     end
 end
+
+# issue #20744
+@test hash(:c, hash(:b, hash(:a))) != hash(:a, hash(:b, hash(:c)))
diff --git a/test/i18n.jl b/test/i18n.jl
index 55b1f9ad90b985..0ff3d6046c211a 100644
--- a/test/i18n.jl
+++ b/test/i18n.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base.I18n
 
diff --git a/test/inference.jl b/test/inference.jl
index c26e9e49f2c49f..0328190bd69b9e 100644
--- a/test/inference.jl
+++ b/test/inference.jl
@@ -1,6 +1,7 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # tests for Core.Inference correctness and precision
+import Core.Inference: Const, Conditional, ⊑
 
 # issue 9770
 @noinline x9770() = false
@@ -36,13 +37,13 @@ let
 end
 
 let
-    fT{T}(x::T) = T
+    fT(x::T) where {T} = T
     @test fT(Any) === DataType
     @test fT(Int) === DataType
     @test fT(Type{Any}) === DataType
     @test fT(Type{Int}) === DataType
 
-    ff{T}(x::Type{T}) = T
+    ff(x::Type{T}) where {T} = T
     @test ff(Type{Any}) === Type{Any}
     @test ff(Type{Int}) === Type{Int}
     @test ff(Any) === Any
@@ -51,7 +52,7 @@ end
 
 
 # issue #3182
-f3182{T}(::Type{T}) = 0
+f3182(::Type{T}) where {T} = 0
 f3182(x) = 1
 function g3182(t::DataType)
     # tricky thing here is that DataType is a concrete type, and a
@@ -80,7 +81,7 @@ struct Hanoi5906{T} <: Outer5906{T}
     Hanoi5906{T}(a) where T = new(a, Empty5906{Inner5906{T}}())
 end
 
-function f5906{T}(h::Hanoi5906{T})
+function f5906(h::Hanoi5906{T}) where T
     if isa(h.succ, Empty5906) return end
     f5906(h.succ)
 end
@@ -131,8 +132,8 @@ struct RGB{T<:AbstractFloat} <: Paint{T}
     b::T
 end
 
-myeltype{T}(::Type{Paint{T}}) = T
-myeltype{P<:Paint}(::Type{P}) = myeltype(supertype(P))
+myeltype(::Type{Paint{T}}) where {T} = T
+myeltype(::Type{P}) where {P<:Paint} = myeltype(supertype(P))
 myeltype(::Type{Any}) = Any
 
 end
@@ -142,14 +143,14 @@ end
 
 
 # issue #12826
-f12826{I<:Integer}(v::Vector{I}) = v[1]
+f12826(v::Vector{I}) where {I<:Integer} = v[1]
 @test Base.return_types(f12826,Tuple{Array{I,1} where I<:Integer})[1] == Integer
 
 
 # non-terminating inference, issue #14009
 # non-terminating codegen, issue #16201
 mutable struct A14009{T}; end
-A14009{T}(a::T) = A14009{T}()
+A14009(a::T) where {T} = A14009{T}()
 f14009(a) = rand(Bool) ? f14009(A14009(a)) : a
 code_typed(f14009, (Int,))
 code_llvm(DevNull, f14009, (Int,))
@@ -161,8 +162,8 @@ code_llvm(DevNull, f14009, (Int,))
 
 
 # issue #9232
-arithtype9232{T<:Real}(::Type{T},::Type{T}) = arithtype9232(T)
-result_type9232{T1<:Number,T2<:Number}(::Type{T1}, ::Type{T2}) = arithtype9232(T1, T2)
+arithtype9232(::Type{T},::Type{T}) where {T<:Real} = arithtype9232(T)
+result_type9232(::Type{T1}, ::Type{T2}) where {T1<:Number,T2<:Number} = arithtype9232(T1, T2)
 # this gave a "type too large", but not reliably
 @test length(code_typed(result_type9232, Tuple{(Type{x} where x<:Union{Float32,Float64}), Type{T2} where T2<:Number})) == 1
 
@@ -176,7 +177,7 @@ code_llvm(DevNull, invoke_g10878, ())
 
 # issue #10930
 @test isa(code_typed(promote,(Any,Any,Vararg{Any})), Array)
-find_tvar10930{T<:Tuple}(sig::Type{T}) = 1
+find_tvar10930(sig::Type{T}) where {T<:Tuple} = 1
 function find_tvar10930(arg)
     if arg<:Tuple
         find_tvar10930(arg[random_var_name])
@@ -225,7 +226,7 @@ bar7810() = [Foo7810([(a,b) for a in 1:2]) for b in 3:4]
 
 
 # issue #11366
-f11366{T}(x::Type{Ref{T}}) = Ref{x}
+f11366(x::Type{Ref{T}}) where {T} = Ref{x}
 @test !isconcrete(Base.return_types(f11366, (Any,))[1])
 
 
@@ -234,14 +235,14 @@ let f(T) = Type{T}
 end
 
 # issue #9222
-function SimpleTest9222{T1<:Real}(pdedata, mu_actual::Vector{T1},
+function SimpleTest9222(pdedata, mu_actual::Vector{T1},
         nu_actual::Vector{T1}, v0::Vector{T1}, epsilon::T1, beta::Vector{T1},
-        delta::T1, l::T1, R::T1, s0::T1, show_trace::Bool = true)
+        delta::T1, l::T1, R::T1, s0::T1, show_trace::Bool = true) where T1<:Real
     return 0.0
 end
-function SimpleTest9222{T1<:Real}(pdedata, mu_actual::Vector{T1},
+function SimpleTest9222(pdedata, mu_actual::Vector{T1},
         nu_actual::Vector{T1}, v0::Vector{T1}, epsilon::T1, beta::Vector{T1},
-        delta::T1, l::T1, R::T1)
+        delta::T1, l::T1, R::T1) where T1<:Real
     return SimpleTest9222(pdedata, mu_actual, nu_actual, v0, epsilon,
         beta, delta, l, R, v0[1])
 end
@@ -269,7 +270,7 @@ for code in Any[
         @code_typed(f18679())[1]
         @code_typed(g18679())[1]]
     @test all(x->isa(x, Type), code.slottypes)
-    local notconst(other::ANY) = true
+    local notconst(@nospecialize(other)) = true
     notconst(slot::TypedSlot) = @test isa(slot.typ, Type)
     function notconst(expr::Expr)
         @test isa(expr.typ, Type)
@@ -291,14 +292,15 @@ let g() = Int <: Real ? 1 : ""
     @test Base.return_types(g, Tuple{}) == [Int]
 end
 
-NInt{N} = Tuple{Vararg{Int, N}}
+const NInt{N} = Tuple{Vararg{Int, N}}
 @test Base.eltype(NInt) === Int
+@test Base.return_types(eltype, (NInt,)) == Any[Union{Type{Int}, Type{Union{}}}] # issue 21763
 fNInt(x::NInt) = (x...)
 gNInt() = fNInt(x)
 @test Base.return_types(gNInt, ()) == Any[NInt]
 
 # issue #17572
-function f17572{A}(::Type{Val{A}})
+function f17572(::Type{Val{A}}) where A
     return Tuple{Int}(Tuple{A}((1,)))
 end
 # test that inference doesn't error
@@ -363,7 +365,7 @@ let tri = Triple18015(1, 2, 3)
 end
 
 # issue #18222
-f18222{T<:AbstractFloat}(::Union{T, Int}) = false
+f18222(::Union{T, Int}) where {T<:AbstractFloat} = false
 f18222(x) = true
 g18222(x) = f18222(x)
 @test f18222(1) == g18222(1) == true
@@ -411,10 +413,10 @@ Base.@pure function fpure(a=rand(); b=rand())
 end
 gpure() = fpure()
 gpure(x::Irrational) = fpure(x)
-@test which(fpure, ()).source.pure
-@test which(fpure, (typeof(pi),)).source.pure
-@test !which(gpure, ()).source.pure
-@test !which(gpure, (typeof(pi),)).source.pure
+@test which(fpure, ()).pure
+@test which(fpure, (typeof(pi),)).pure
+@test !which(gpure, ()).pure
+@test !which(gpure, (typeof(pi),)).pure
 @test @code_typed(gpure())[1].pure
 @test @code_typed(gpure(π))[1].pure
 @test gpure() == gpure() == gpure()
@@ -422,7 +424,7 @@ gpure(x::Irrational) = fpure(x)
 
 # Make sure @pure works for functions using the new syntax
 Base.@pure (fpure2(x::T) where T) = T
-@test which(fpure2, (Int64,)).source.pure
+@test which(fpure2, (Int64,)).pure
 
 # issue #10880
 function cat10880(a, b)
@@ -441,7 +443,7 @@ function is_typed_expr(e::Expr)
     end
     return false
 end
-test_inferred_static(other::ANY) = true
+test_inferred_static(@nospecialize(other)) = true
 test_inferred_static(slot::TypedSlot) = @test isconcrete(slot.typ)
 function test_inferred_static(expr::Expr)
     if is_typed_expr(expr)
@@ -530,8 +532,8 @@ test_fast_le(a, b) = @fastmath a <= b
 
 abstract type AbstractMyType18457{T,F,G} end
 struct MyType18457{T,F,G}<:AbstractMyType18457{T,F,G} end
-tpara18457{I}(::Type{AbstractMyType18457{I}}) = I
-tpara18457{A<:AbstractMyType18457}(::Type{A}) = tpara18457(supertype(A))
+tpara18457(::Type{AbstractMyType18457{I}}) where {I} = I
+tpara18457(::Type{A}) where {A<:AbstractMyType18457} = tpara18457(supertype(A))
 @test tpara18457(MyType18457{true}) === true
 
 @testset "type inference error #19322" begin
@@ -583,7 +585,7 @@ mutable struct AT11015
     f::Union{Bool,Function}
 end
 
-g11015{S}(::Type{S}, ::S) = 1
+g11015(::Type{S}, ::S) where {S} = 1
 f11015(a::AT11015) = g11015(Base.fieldtype(typeof(a), :f), true)
 g11015(::Type{Bool}, ::Bool) = 2.0
 @test Int <: Base.return_types(f11015, (AT11015,))[1]
@@ -611,7 +613,7 @@ function i20343()
     f20343([1,2,3]..., 4)
 end
 @test Base.return_types(i20343, ()) == [Int8]
-immutable Foo20518 <: AbstractVector{Int}; end # issue #20518; inference assumed AbstractArrays
+struct Foo20518 <: AbstractVector{Int}; end # issue #20518; inference assumed AbstractArrays
 Base.getindex(::Foo20518, ::Int) = "oops"      # not to lie about their element type
 Base.indices(::Foo20518) = (Base.OneTo(4),)
 foo20518(xs::Any...) = -1
@@ -625,16 +627,23 @@ g19957(x) = f19957(x...)
 @test all(t -> t<:Union{Int8,Int16}, Base.return_types(g19957, (Int,))) # with a full fix, this should just be Int8
 
 # Inference for some type-level computation
-fUnionAll{T}(::Type{T}) = Type{S} where S <: T
+fUnionAll(::Type{T}) where {T} = Type{S} where S <: T
 @inferred fUnionAll(Real) == Type{T} where T <: Real
 @inferred fUnionAll(Rational{T} where T <: AbstractFloat) == Type{T} where T<:(Rational{S} where S <: AbstractFloat)
 
-fComplicatedUnionAll{T}(::Type{T}) = Type{Tuple{S,rand() >= 0.5 ? Int : Float64}} where S <: T
+fComplicatedUnionAll(::Type{T}) where {T} = Type{Tuple{S,rand() >= 0.5 ? Int : Float64}} where S <: T
 let pub = Base.parameter_upper_bound, x = fComplicatedUnionAll(Real)
     @test pub(pub(x, 1), 1) == Real
     @test pub(pub(x, 1), 2) == Int || pub(pub(x, 1), 2) == Float64
 end
 
+# issue #20733
+# run this test in a separate process to avoid interfering with `getindex`
+let def = "Base.getindex(t::NTuple{3,NTuple{2,Int}}, i::Int, j::Int, k::Int) = (t[1][i], t[2][j], t[3][k])"
+    @test read(`$(Base.julia_cmd()) --startup-file=no -E "$def;test(t) = t[2,1,2];test(((3,4), (5,6), (7,8)))"`, String) ==
+        "(4, 5, 8)\n"
+end
+
 # issue #20267
 mutable struct T20267{T}
     inds::Vector{T}
@@ -648,3 +657,516 @@ let A = 1:2, z = zip(A, A, A, A, A, A, A, A, A, A, A, A)
     @test z isa Core.Inference.limit_type_depth(typeof(z), 0)
     @test start(z) == (1, (1, (1, (1, (1, (1, (1, (1, (1, (1, (1, 1)))))))))))
 end
+# introduce TypeVars in Unions in invariant position
+let T = Val{Val{Val{Union{Int8,Int16,Int32,Int64,UInt8,UInt16,UInt32,UInt64}}}}
+    @test T <: Core.Inference.limit_type_depth(T, 0)
+end
+
+# issue #20704
+f20704(::Int) = 1
+Base.@pure b20704(@nospecialize(x)) = f20704(x)
+@test b20704(42) === 1
+@test_throws MethodError b20704(42.0)
+
+bb20704() = b20704(Any[1.0][1])
+@test_throws MethodError bb20704()
+
+v20704() = Val{b20704(Any[1.0][1])}
+@test_throws MethodError v20704()
+@test Base.return_types(v20704, ()) == Any[Type{Val{1}}]
+
+Base.@pure g20704(::Int) = 1
+h20704(@nospecialize(x)) = g20704(x)
+@test g20704(1) === 1
+@test_throws MethodError h20704(1.2)
+
+Base.@pure c20704() = (f20704(1.0); 1)
+d20704() = c20704()
+@test_throws MethodError d20704()
+
+Base.@pure function a20704(x)
+    rand()
+    42
+end
+aa20704(x) = x(nothing)
+@test code_typed(aa20704, (typeof(a20704),))[1][1].pure
+
+#issue #21065, elision of _apply when splatted expression is not effect_free
+function f21065(x,y)
+    println("x=$x, y=$y")
+    return x, y
+end
+g21065(x,y) = +(f21065(x,y)...)
+function test_no_apply(expr::Expr)
+    return all(test_no_apply, expr.args)
+end
+function test_no_apply(ref::GlobalRef)
+    return ref.mod != Core || ref.name !== :_apply
+end
+test_no_apply(::Any) = true
+@test all(test_no_apply, code_typed(g21065, Tuple{Int,Int})[1].first.code)
+
+# issue #20033
+# check return_type_tfunc for calls where no method matches
+bcast_eltype_20033(f, A) = Core.Inference.return_type(f, Tuple{eltype(A)})
+err20033(x::Float64...) = prod(x)
+@test bcast_eltype_20033(err20033, [1]) === Union{}
+@test Base.return_types(bcast_eltype_20033, (typeof(err20033), Vector{Int},)) == Any[Type{Union{}}]
+# return_type on builtins
+@test Core.Inference.return_type(tuple, Tuple{Int,Int8,Int}) === Tuple{Int,Int8,Int}
+
+# issue #21088
+@test Core.Inference.return_type(typeof, Tuple{Int}) == Type{Int}
+
+# Inference of constant svecs
+@eval fsvecinf() = $(QuoteNode(Core.svec(Tuple{Int,Int}, Int)))[1]
+@test Core.Inference.return_type(fsvecinf, Tuple{}) == Type{Tuple{Int,Int}}
+
+# nfields tfunc on `DataType`
+let f = ()->Val{nfields(DataType[Int][1])}
+    @test f() == Val{0}
+end
+
+# inference on invalid getfield call
+@eval _getfield_with_string_() = getfield($(1=>2), "")
+@test Base.return_types(_getfield_with_string_, ()) == Any[Union{}]
+
+# inference AST of a constant return value
+f21175() = 902221
+@test code_typed(f21175, ())[1].second === Int
+# call again, so that the AST is built on-demand
+let e = code_typed(f21175, ())[1].first.code[1]::Expr
+    @test e.head === :return
+    @test e.args[1] ∈ (902221, Core.QuoteNode(902221))
+end
+
+# issue #10207
+mutable struct T10207{A, B}
+    a::A
+    b::B
+end
+@test code_typed(T10207, (Int,Any))[1].second == T10207{Int,T} where T
+
+# issue #21410
+f21410(::V, ::Pair{V,E}) where {V, E} = E
+@test code_typed(f21410, Tuple{Ref, Pair{Ref{T},Ref{T}} where T<:Number})[1].second == Type{Ref{T}} where T<:Number
+
+# issue #21369
+function inf_error_21369(arg)
+    if arg
+        # invalid instantiation, causing throw during inference
+        Complex{String}
+    end
+end
+function break_21369()
+    try
+        error("uhoh")
+    catch
+        eval(:(inf_error_21369(false)))
+        bt = catch_backtrace()
+        i = 1
+        local fr
+        while true
+            fr = Base.StackTraces.lookup(bt[i])[end]
+            if !fr.from_c
+                break
+            end
+            i += 1
+        end
+        @test fr.func === :break_21369
+        rethrow()
+    end
+end
+@test_throws ErrorException break_21369()  # not TypeError
+
+# issue #17003
+abstract type AArray_17003{T,N} end
+AVector_17003{T} = AArray_17003{T,1}
+
+struct Nable_17003{T}
+end
+
+struct NArray_17003{T,N} <: AArray_17003{Nable_17003{T},N}
+end
+
+(::Type{NArray_17003})(::Array{T,N}) where {T,N} = NArray_17003{T,N}()
+
+gl_17003 = [1, 2, 3]
+
+f2_17003(item::AVector_17003) = nothing
+f2_17003(::Any) = f2_17003(NArray_17003(gl_17003))
+
+@test f2_17003(1) == nothing
+
+# issue #20847
+function segfaultfunction_20847(A::Vector{NTuple{N, T}}) where {N, T}
+    B = reinterpret(T, A, (N, length(A)))
+    return nothing
+end
+
+tuplevec_20847 = Tuple{Float64, Float64}[(0.0,0.0), (1.0,0.0)]
+
+for A in (1,)
+    @test segfaultfunction_20847(tuplevec_20847) == nothing
+end
+
+# issue #21848
+@test Core.Inference.limit_type_depth(Ref{Complex{T} where T}, 0) == Ref
+let T = Tuple{Tuple{Int64, Void},
+              Tuple{Tuple{Int64, Void},
+                    Tuple{Int64, Tuple{Tuple{Int64, Void},
+                                       Tuple{Tuple{Int64, Void}, Tuple{Int64, Tuple{Tuple{Int64, Void}, Tuple{Tuple, Tuple}}}}}}}}
+    @test Core.Inference.limit_type_depth(T, 0) >: T
+    @test Core.Inference.limit_type_depth(T, 1) >: T
+    @test Core.Inference.limit_type_depth(T, 2) >: T
+end
+
+# Issue #20902, check that this doesn't error.
+@generated function test_20902()
+    quote
+        10 + 11
+    end
+end
+@test length(code_typed(test_20902, (), optimize = false)) == 1
+@test length(code_typed(test_20902, (), optimize = false)) == 1
+
+# normalization of arguments with constant Types as parameters
+g21771(T) = T
+f21771(::Val{U}) where {U} = Tuple{g21771(U)}
+@test @inferred(f21771(Val{Int}())) === Tuple{Int}
+@test @inferred(f21771(Val{Union{}}())) === Tuple{Union{}}
+@test @inferred(f21771(Val{Integer}())) === Tuple{Integer}
+
+# missing method should be inferred as Union{}, ref https://github.com/JuliaLang/julia/issues/20033#issuecomment-282228948
+@test Base.return_types(f -> f(1), (typeof((x::String) -> x),)) == Any[Union{}]
+
+# issue #21653
+# ensure that we don't try to resolve cycles using uncached edges
+f21653() = f21653()
+@test code_typed(f21653, Tuple{}, optimize=false)[1] isa Pair{CodeInfo, typeof(Union{})}
+
+# ensure _apply can "see-through" SSAValue to infer precise container types
+let f, m
+    f() = 0
+    m = first(methods(f))
+    m.source = Base.uncompressed_ast(m)::CodeInfo
+    m.source.ssavaluetypes = 1
+    m.source.code = Any[
+        Expr(:(=), SSAValue(0), Expr(:call, GlobalRef(Core, :svec), 1, 2, 3)),
+        Expr(:return, Expr(:call, Core._apply, :+, SSAValue(0)))
+    ]
+    @test @inferred(f()) == 6
+end
+
+# issue #22290
+f22290() = return 3
+for i in 1:3
+    ir = sprint(io -> code_llvm(io, f22290, Tuple{}))
+    @test contains(ir, "julia_f22290")
+end
+
+# constant inference of isdefined
+let f(x) = isdefined(x, 2) ? 1 : ""
+    @test Base.return_types(f, (Tuple{Int,Int},)) == Any[Int]
+    @test Base.return_types(f, (Tuple{Int,},)) == Any[String]
+end
+let f(x) = isdefined(x, :re) ? 1 : ""
+    @test Base.return_types(f, (Complex64,)) == Any[Int]
+    @test Base.return_types(f, (Complex,)) == Any[Int]
+end
+let f(x) = isdefined(x, :NonExistentField) ? 1 : ""
+    @test Base.return_types(f, (Complex64,)) == Any[String]
+    @test Union{Int,String} <: Base.return_types(f, (AbstractArray,))[1]
+end
+import Core.Inference: isdefined_tfunc
+@test isdefined_tfunc(Complex64, Const(())) === Union{}
+@test isdefined_tfunc(Complex64, Const(1)) === Const(true)
+@test isdefined_tfunc(Complex64, Const(2)) === Const(true)
+@test isdefined_tfunc(Complex64, Const(3)) === Const(false)
+@test isdefined_tfunc(Complex64, Const(0)) === Const(false)
+mutable struct SometimesDefined
+    x
+    function SometimesDefined()
+        v = new()
+        if rand(Bool)
+            v.x = 0
+        end
+        return v
+    end
+end
+@test isdefined_tfunc(SometimesDefined, Const(:x)) == Bool
+@test isdefined_tfunc(SometimesDefined, Const(:y)) === Const(false)
+@test isdefined_tfunc(Const(Base), Const(:length)) === Const(true)
+@test isdefined_tfunc(Const(Base), Symbol) == Bool
+@test isdefined_tfunc(Const(Base), Const(:NotCurrentlyDefinedButWhoKnows)) == Bool
+@test isdefined_tfunc(SimpleVector, Const(1)) === Const(false)
+@test Const(false) ⊑ isdefined_tfunc(Const(:x), Symbol)
+@test Const(false) ⊑ isdefined_tfunc(Const(:x), Const(:y))
+@test isdefined_tfunc(Vector{Int}, Const(1)) == Bool
+@test isdefined_tfunc(Vector{Any}, Const(1)) == Bool
+@test isdefined_tfunc(Module, Any, Any) === Union{}
+@test isdefined_tfunc(Module, Int) === Union{}
+@test isdefined_tfunc(Tuple{Any,Vararg{Any}}, Const(0)) === Const(false)
+@test isdefined_tfunc(Tuple{Any,Vararg{Any}}, Const(1)) === Const(true)
+@test isdefined_tfunc(Tuple{Any,Vararg{Any}}, Const(2)) === Bool
+@test isdefined_tfunc(Tuple{Any,Vararg{Any}}, Const(3)) === Bool
+
+@noinline map3_22347(f, t::Tuple{}) = ()
+@noinline map3_22347(f, t::Tuple) = (f(t[1]), map3_22347(f, Base.tail(t))...)
+# issue #22347
+let niter = 0
+    map3_22347((1, 2, 3, 4)) do y
+        niter += 1
+        nothing
+    end
+    @test niter == 4
+end
+
+# issue #22875
+
+typeargs = (Type{Int},)
+@test Base.Core.Inference.return_type((args...) -> one(args...), typeargs) === Int
+
+typeargs = (Type{Int},Type{Int},Type{Int},Type{Int},Type{Int},Type{Int})
+@test Base.Core.Inference.return_type(promote_type, typeargs) === Type{Int}
+
+# demonstrate that inference must converge
+# while doing constant propagation
+Base.@pure plus1(x) = x + 1
+f21933(x::Val{T}) where {T} = f(Val(plus1(T)))
+@code_typed f21933(Val(1))
+Base.return_types(f21933, (Val{1},))
+
+function count_specializations(method::Method)
+    n = 0
+    Base.visit(method.specializations) do m
+        n += 1
+    end
+    return n::Int
+end
+
+# demonstrate that inference can complete without waiting for MAX_TUPLETYPE_LEN or MAX_TYPE_DEPTH
+copy_dims_out(out) = ()
+copy_dims_out(out, dim::Int, tail...) =  copy_dims_out((out..., dim), tail...)
+copy_dims_out(out, dim::Colon, tail...) = copy_dims_out((out..., dim), tail...)
+@test Base.return_types(copy_dims_out, (Tuple{}, Vararg{Union{Int,Colon}})) == Any[Tuple{}, Tuple{}, Tuple{}]
+@test all(m -> 2 < count_specializations(m) < 15, methods(copy_dims_out))
+
+copy_dims_pair(out) = ()
+copy_dims_pair(out, dim::Int, tail...) =  copy_dims_out(out => dim, tail...)
+copy_dims_pair(out, dim::Colon, tail...) = copy_dims_out(out => dim, tail...)
+@test Base.return_types(copy_dims_pair, (Tuple{}, Vararg{Union{Int,Colon}})) == Any[Tuple{}, Tuple{}, Tuple{}]
+@test all(m -> 5 < count_specializations(m) < 25, methods(copy_dims_out))
+
+# splatting an ::Any should still allow inference to use types of parameters preceding it
+f22364(::Int, ::Any...) = 0
+f22364(::String, ::Any...) = 0.0
+g22364(x) = f22364(x, Any[[]][1]...)
+@test @inferred(g22364(1)) === 0
+@test @inferred(g22364("1")) === 0.0
+
+function get_linfo(@nospecialize(f), @nospecialize(t))
+    if isa(f, Core.Builtin)
+        throw(ArgumentError("argument is not a generic function"))
+    end
+    # get the MethodInstance for the method match
+    world = typemax(UInt)
+    meth = which(f, t)
+    t = Base.to_tuple_type(t)
+    ft = isa(f, Type) ? Type{f} : typeof(f)
+    tt = Tuple{ft, t.parameters...}
+    precompile(tt)
+    (ti, env) = ccall(:jl_match_method, Ref{SimpleVector}, (Any, Any), tt, meth.sig)
+    meth = Base.func_for_method_checked(meth, tt)
+    return ccall(:jl_specializations_get_linfo, Ref{Core.MethodInstance},
+                 (Any, Any, Any, UInt), meth, tt, env, world)
+end
+
+function test_const_return(@nospecialize(f), @nospecialize(t), @nospecialize(val))
+    linfo = get_linfo(f, t)
+    # If coverage is not enabled, make the check strict by requiring constant ABI
+    # Otherwise, check the typed AST to make sure we return a constant.
+    if Base.JLOptions().code_coverage == 0
+        @test linfo.jlcall_api == 2
+    end
+    if linfo.jlcall_api == 2
+        @test linfo.inferred_const == val
+        return
+    end
+    ct = code_typed(f, t)
+    @test length(ct) == 1
+    ast = first(ct[1])
+    ret_found = false
+    for ex in ast.code::Vector{Any}
+        if isa(ex, LineNumberNode)
+            continue
+        elseif isa(ex, Expr)
+            ex = ex::Expr
+            if Core.Inference.is_meta_expr(ex)
+                continue
+            elseif ex.head === :return
+                # multiple returns
+                @test !ret_found
+                ret_found = true
+                ret = ex.args[1]
+                # return value mismatch
+                @test ret === val || (isa(ret, QuoteNode) && (ret::QuoteNode).value === val)
+                continue
+            end
+        end
+        @test false || "Side effect expressions found $ex"
+        return
+    end
+end
+
+function find_call(code, func, narg)
+    for ex in code
+        isa(ex, Expr) || continue
+        ex = ex::Expr
+        if ex.head === :call && length(ex.args) == narg
+            farg = ex.args[1]
+            if isa(farg, GlobalRef)
+                farg = farg::GlobalRef
+                if isdefined(farg.mod, farg.name) && isconst(farg.mod, farg.name)
+                    farg = getfield(farg.mod, farg.name)
+                end
+            end
+            if farg === func
+                return true
+            end
+        elseif Core.Inference.is_meta_expr(ex)
+            continue
+        end
+        find_call(ex.args, func, narg) && return true
+    end
+    return false
+end
+
+test_const_return(()->1, Tuple{}, 1)
+test_const_return(()->sizeof(Int), Tuple{}, sizeof(Int))
+test_const_return(()->sizeof(1), Tuple{}, sizeof(Int))
+test_const_return(()->sizeof(DataType), Tuple{}, sizeof(DataType))
+test_const_return(()->sizeof(1 < 2), Tuple{}, 1)
+@eval test_const_return(()->Core.sizeof($(Array{Int}())), Tuple{}, sizeof(Int))
+@eval test_const_return(()->Core.sizeof($(Matrix{Float32}(2, 2))), Tuple{}, 4 * 2 * 2)
+
+# Make sure Core.sizeof with a ::DataType as inferred input type is inferred but not constant.
+function sizeof_typeref(typeref)
+    Core.sizeof(typeref[])
+end
+@test @inferred(sizeof_typeref(Ref{DataType}(Int))) == sizeof(Int)
+@test find_call(first(@code_typed sizeof_typeref(Ref{DataType}())).code, Core.sizeof, 2)
+# Constant `Vector` can be resized and shouldn't be optimized to a constant.
+const constvec = [1, 2, 3]
+@eval function sizeof_constvec()
+    Core.sizeof($constvec)
+end
+@test @inferred(sizeof_constvec()) == sizeof(Int) * 3
+@test find_call(first(@code_typed sizeof_constvec()).code, Core.sizeof, 2)
+push!(constvec, 10)
+@test @inferred(sizeof_constvec()) == sizeof(Int) * 4
+
+test_const_return((x)->isdefined(x, :re), Tuple{Complex128}, true)
+isdefined_f3(x) = isdefined(x, 3)
+@test @inferred(isdefined_f3(())) == false
+@test find_call(first(code_typed(isdefined_f3, Tuple{Tuple{Vararg{Int}}})[1]).code, isdefined, 3)
+
+let isa_tfunc = Core.Inference.t_ffunc_val[
+        findfirst(Core.Inference.t_ffunc_key, isa)][3]
+    @test isa_tfunc(Array, Const(AbstractArray)) === Const(true)
+    @test isa_tfunc(Array, Type{AbstractArray}) === Const(true)
+    @test isa_tfunc(Array, Type{AbstractArray{Int}}) == Bool
+    @test isa_tfunc(Array{Real}, Type{AbstractArray{Int}}) === Const(false)
+    @test isa_tfunc(Array{Real, 2}, Const(AbstractArray{Real, 2})) === Const(true)
+    @test isa_tfunc(Array{Real, 2}, Const(AbstractArray{Int, 2})) === Const(false)
+    @test isa_tfunc(DataType, Int) === Bool # could be improved
+    @test isa_tfunc(DataType, Const(Type{Int})) === Bool
+    @test isa_tfunc(DataType, Const(Type{Array})) === Bool
+    @test isa_tfunc(UnionAll, Const(Type{Int})) === Bool # could be improved
+    @test isa_tfunc(UnionAll, Const(Type{Array})) === Bool
+    @test isa_tfunc(Union, Const(Union{Float32, Float64})) === Bool
+    @test isa_tfunc(Union, Type{Union}) === Const(true)
+    @test isa_tfunc(typeof(Union{}), Const(Int)) === Bool # any result is ok
+    @test isa_tfunc(typeof(Union{}), Const(Union{})) === Const(false)
+    @test isa_tfunc(typeof(Union{}), typeof(Union{})) === Const(false)
+    @test isa_tfunc(typeof(Union{}), Union{}) === Const(false) # any result is ok
+    @test isa_tfunc(typeof(Union{}), Type{typeof(Union{})}) === Const(true)
+    @test isa_tfunc(typeof(Union{}), Const(typeof(Union{}))) === Const(true)
+    let c = Conditional(Core.SlotNumber(0), Const(Union{}), Const(Union{}))
+        @test isa_tfunc(c, Const(Bool)) === Const(true)
+        @test isa_tfunc(c, Type{Bool}) === Const(true)
+        @test isa_tfunc(c, Const(Real)) === Const(true)
+        @test isa_tfunc(c, Type{Real}) === Const(true)
+        @test isa_tfunc(c, Const(Signed)) === Const(false)
+        @test isa_tfunc(c, Type{Complex}) === Const(false)
+        @test isa_tfunc(c, Type{Complex{T}} where T) === Const(false)
+    end
+    @test isa_tfunc(Val{1}, Type{Val{T}} where T) === Bool
+    @test isa_tfunc(Val{1}, DataType) === Bool
+    @test isa_tfunc(Any, Const(Any)) === Const(true)
+    @test isa_tfunc(Any, Union{}) === Const(false) # any result is ok
+    @test isa_tfunc(Any, Type{Union{}}) === Const(false)
+    @test isa_tfunc(Union{Int64, Float64}, Type{Real}) === Const(true)
+    @test isa_tfunc(Union{Int64, Float64}, Type{Integer}) === Bool
+    @test isa_tfunc(Union{Int64, Float64}, Type{AbstractArray}) === Const(false)
+end
+
+let subtype_tfunc = Core.Inference.t_ffunc_val[
+        findfirst(Core.Inference.t_ffunc_key, <:)][3]
+    @test subtype_tfunc(Type{<:Array}, Const(AbstractArray)) === Const(true)
+    @test subtype_tfunc(Type{<:Array}, Type{AbstractArray}) === Const(true)
+    @test subtype_tfunc(Type{<:Array}, Type{AbstractArray{Int}}) == Bool
+    @test subtype_tfunc(Type{<:Array{Real}}, Type{AbstractArray{Int}}) === Const(false)
+    @test subtype_tfunc(Type{<:Array{Real, 2}}, Const(AbstractArray{Real, 2})) === Const(true)
+    @test subtype_tfunc(Type{Array{Real, 2}}, Const(AbstractArray{Int, 2})) === Const(false)
+    @test subtype_tfunc(DataType, Int) === Bool
+    @test subtype_tfunc(DataType, Const(Type{Int})) === Bool
+    @test subtype_tfunc(DataType, Const(Type{Array})) === Bool
+    @test subtype_tfunc(UnionAll, Const(Type{Int})) === Bool
+    @test subtype_tfunc(UnionAll, Const(Type{Array})) === Bool
+    @test subtype_tfunc(Union, Const(Union{Float32, Float64})) === Bool
+    @test subtype_tfunc(Union, Type{Union}) === Bool
+    @test subtype_tfunc(Union{}, Const(Int)) === Const(true) # any result is ok
+    @test subtype_tfunc(Union{}, Const(Union{})) === Const(true) # any result is ok
+    @test subtype_tfunc(Union{}, typeof(Union{})) === Const(true) # any result is ok
+    @test subtype_tfunc(Union{}, Union{}) === Const(true) # any result is ok
+    @test subtype_tfunc(Union{}, Type{typeof(Union{})}) === Const(true) # any result is ok
+    @test subtype_tfunc(Union{}, Const(typeof(Union{}))) === Const(true) # any result is ok
+    @test subtype_tfunc(typeof(Union{}), Const(typeof(Union{}))) === Const(true) # Union{} <: typeof(Union{})
+    @test subtype_tfunc(typeof(Union{}), Const(Int)) === Const(true) # Union{} <: Int
+    @test subtype_tfunc(typeof(Union{}), Const(Union{})) === Const(true) # Union{} <: Union{}
+    @test subtype_tfunc(typeof(Union{}), Type{typeof(Union{})}) === Const(true) # Union{} <: Union{}
+    @test subtype_tfunc(typeof(Union{}), Type{typeof(Union{})}) === Const(true) # Union{} <: typeof(Union{})
+    @test subtype_tfunc(typeof(Union{}), Type{Union{}}) === Const(true) # Union{} <: Union{}
+    @test subtype_tfunc(Type{Union{}}, typeof(Union{})) === Const(true) # Union{} <: Union{}
+    @test subtype_tfunc(Type{Union{}}, Const(typeof(Union{}))) === Const(true) # Union{} <: typeof(Union{})
+    @test subtype_tfunc(Type{Union{}}, Const(Int)) === Const(true) # Union{} <: typeof(Union{})
+    @test subtype_tfunc(Type{Union{}}, Any) === Const(true) # Union{} <: Any
+    @test subtype_tfunc(Type{Union{}}, Union{Type{Int64}, Type{Float64}}) === Const(true)
+    @test subtype_tfunc(Type{Union{}}, Union{Type{T}, Type{Float64}} where T) === Const(true)
+    let c = Conditional(Core.SlotNumber(0), Const(Union{}), Const(Union{}))
+        @test subtype_tfunc(c, Const(Bool)) === Bool # any result is ok
+    end
+    @test subtype_tfunc(Type{Val{1}}, Type{Val{T}} where T) === Bool
+    @test subtype_tfunc(Type{Val{1}}, DataType) === Bool
+    @test subtype_tfunc(Type, Type{Val{T}} where T) === Bool
+    @test subtype_tfunc(Type{Val{T}} where T, Type) === Bool
+    @test subtype_tfunc(Any, Const(Any)) === Const(true)
+    @test subtype_tfunc(Type{Any}, Const(Any)) === Const(true)
+    @test subtype_tfunc(Any, Union{}) === Bool # any result is ok
+    @test subtype_tfunc(Type{Any}, Union{}) === Const(false) # any result is ok
+    @test subtype_tfunc(Type, Union{}) === Bool # any result is ok
+    @test subtype_tfunc(Type, Type{Union{}}) === Bool
+    @test subtype_tfunc(Union{Type{Int64}, Type{Float64}}, Type{Real}) === Const(true)
+    @test subtype_tfunc(Union{Type{Int64}, Type{Float64}}, Type{Integer}) === Bool
+    @test subtype_tfunc(Union{Type{Int64}, Type{Float64}}, Type{AbstractArray}) === Const(false)
+end
+
+function f23024(::Type{T}, ::Int) where T
+    1 + 1
+end
+v23024 = 0
+g23024(TT::Tuple{DataType}) = f23024(TT[1], v23024)
+@test Base.return_types(f23024, (DataType, Any)) == Any[Int]
+@test Base.return_types(g23024, (Tuple{DataType},)) == Any[Int]
+@test g23024((UInt8,)) === 2
diff --git a/test/inline.jl b/test/inline.jl
index 9920ccd84cd8a9..769ea452d8a17d 100644
--- a/test/inline.jl
+++ b/test/inline.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base.Test
 
@@ -79,3 +79,47 @@ f18948() = (local bar::Int64; bar=1.5)
 g18948() = (local bar::Int32; bar=0x80000000)
 @test_throws InexactError f18948()
 @test_throws InexactError g18948()
+
+# issue #21074
+struct s21074
+    x::Tuple{Int, Int}
+end
+@inline Base.getindex(v::s21074, i::Integer) = v.x[i]
+@eval f21074() = $(s21074((1,2))).x[1]
+let (src, _) = code_typed(f21074, ())[1]
+    @test src.code[end] == Expr(:return, 1)
+end
+@eval g21074() = $(s21074((1,2)))[1]
+let (src, _) = code_typed(g21074, ())[1]
+    @test src.code[end] == Expr(:return, 1)
+end
+
+# issue #21311
+counter21311 = Ref(0)
+@noinline function update21311!(x)
+    counter21311[] += 1
+    x[] = counter21311[]
+    return x
+end
+@noinline map21311(t::Tuple{Any}) = (update21311!(t[1]),)
+@inline map21311(t::Tuple) = (update21311!(t[1]), map21311(Base.tail(t))...)
+function read21311()
+    xs = Ref(1), Ref(1)
+    map21311(xs)
+    return xs[1]
+end
+let a = read21311()
+    @test a[] == 1
+end
+
+@testset "issue #19122: [no]inline of short func. def. with return type annotation" begin
+    exf19122 = @macroexpand(@inline f19122()::Bool = true)
+    exg19122 = @macroexpand(@noinline g19122()::Bool = true)
+    @test exf19122.args[2].args[1].args[1] == :inline
+    @test exg19122.args[2].args[1].args[1] == :noinline
+
+    @inline f19122()::Bool = true
+    @noinline g19122()::Bool = true
+    @test f19122()
+    @test g19122()
+end
diff --git a/test/int.jl b/test/int.jl
index 00708302a21a16..3cf1cbbd65f30a 100644
--- a/test/int.jl
+++ b/test/int.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Test integer conversion routines from int.jl
 
@@ -17,16 +17,31 @@ 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,
+# Result type must be type of first argument, except for Bool
+for U in (Base.BitInteger_types..., BigInt,
           Rational{Int}, Rational{BigInt},
           Float16, Float32, Float64)
-    for U in (Base.BitInteger_types..., BigInt,
+    for T 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
+    # Bool promotes to Int
+    U <: Unsigned && continue
+    for x in [true, false]
+        @test flipsign(x, U(4)) === Int(x)
+        @test flipsign(x, U(-1)) === -Int(x)
+        @test copysign(x, U(4)) === Int(x)
+        @test copysign(x, U(-1)) === -Int(x)
+    end
+end
+
+@testset "flipsign/copysign(typemin($T), -1)" for T in Base.BitInteger_types
+    for U in (Base.BitSigned_types..., BigInt, Float16, Float32, Float64)
+        @test flipsign(typemin(T), U(-1)) == typemin(T)
+        @test copysign(typemin(T), U(-1)) == typemin(T)
+    end
 end
 
 for s1 in (-1,+1), s2 in (-1,+1)
@@ -201,3 +216,16 @@ end
 @test unsafe_trunc(Int8, -127) === Int8(-127)
 @test unsafe_trunc(Int8, -128) === Int8(-128)
 @test unsafe_trunc(Int8, -129) === Int8(127)
+
+# Test x % T returns a T
+for T in [Base.BitInteger_types..., BigInt],
+    U in [Base.BitInteger_types..., BigInt]
+    @test typeof(rand(U(0):U(127)) % T) === T
+end
+
+
+@testset "left shift with Vector{Int} on BigInt-scalar #13832" begin
+    x = BigInt(1) .<< [1:70;]
+    @test x[end] == 1180591620717411303424
+    @test eltype(x) == BigInt
+end
diff --git a/test/intfuncs.jl b/test/intfuncs.jl
index 3d80ba1a4860db..7498927596c118 100644
--- a/test/intfuncs.jl
+++ b/test/intfuncs.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Int32 and Int64 take different code paths -- test both
 for T in (Int32, Int64)
@@ -85,14 +85,29 @@ end
 
 @test ndigits(146, -3) == 5
 
-let n = rand(Int)
+let (n, b) = rand(Int, 2)
+    -1 <= b <= 1 && (b = 2) # invalid bases
     @test ndigits(n) == ndigits(big(n)) == ndigits(n, 10)
+    @test ndigits(n, b) == ndigits(big(n), b)
+end
+
+for b in -1:1
+    @test_throws DomainError ndigits(rand(Int), b)
 end
 @test ndigits(Int8(5)) == ndigits(5)
 
 # issue #19367
 @test ndigits(Int128(2)^64, 256) == 9
 
+# test unsigned bases
+@test ndigits(9, 0x2) == 4
+@test ndigits(0x9, 0x2) == 4
+
+# ndigits is defined for Bool
+@test iszero([Base.ndigits0z(false, b) for b in [-20:-2;2:20]])
+@test all(n -> n == 1, Base.ndigits0z(true, b) for b in [-20:-2;2:20])
+@test all(n -> n == 1, ndigits(x, b) for b in [-20:-2;2:20] for x in [true, false])
+
 @test bin('3') == "110011"
 @test bin('3',7) == "0110011"
 @test bin(3) == "11"
@@ -121,6 +136,41 @@ end
 @test digits(4, 2) == [0, 0, 1]
 @test digits(5, 3) == [2, 1]
 
+# digits with negative bases
+@testset "digits/base with negative bases" begin
+    @testset "digits(n::$T, b)" for T in (Int, UInt, BigInt, Int32)
+        @test digits(T(8163), -10) == [3, 4, 2, 2, 1]
+        if !(T<:Unsigned)
+            @test digits(T(-8163), -10) == [7, 7, 9, 9]
+        end
+    end
+    @test [base(b, n)
+           for n = [-10^9, -10^5, -2^20, -2^10, -100, -83, -50, -34, -27, -16, -7, -3, -2, -1,
+                    0, 1, 2, 3, 4, 7, 16, 27, 34, 50, 83, 100, 2^10, 2^20, 10^5, 10^9]
+           for b = [-2, -3, -7, -10, -60]] ==
+               ["11000101101001010100101000000000", "11211100201202120012",
+                "144246601121", "1000000000", "2hANlK", "111000111010100000",
+                "122011122112", "615462", "100000", "1XlK", "1100000000000000000000",
+                "11000202101022", "25055043", "19169584", "59Hi", "110000000000",
+                "12102002", "3005", "1036", "Iu", "11101100", "121112", "1515",
+                "1900", "2K", "11111101", "120011", "1651", "97", "2b", "11010010",
+                "2121", "1616", "50", "1A", "100010", "2202", "51", "46", "1Q",
+                "100101", "1000", "41", "33", "1X", "110000", "1102", "35", "24",
+                "1i", "1001", "1202", "10", "13", "1r", "1101", "10", "14", "17",
+                "1v", "10", "11", "15", "18", "1w", "11", "12", "16", "19", "1x", "0",
+                "0", "0", "0", "0", "1", "1", "1", "1", "1", "110", "2", "2", "2",
+                "2", "111", "120", "3", "3", "3", "100", "121", "4", "4", "4",
+                "11011", "111", "160", "7", "7", "10000", "211", "152", "196", "G",
+                "1101111", "12000", "146", "187", "R", "1100110", "12111", "136",
+                "174", "Y", "1110110", "11022", "101", "150", "o", "1010111", "10002",
+                "236", "123", "1xN", "110100100", "10201", "202", "100", "1xe",
+                "10000000000", "2211011", "14012", "19184", "1h4",
+                "100000000000000000000", "2001112212121", "162132144", "1052636",
+                "1uqiG", "1101001101111100000", "21002022201", "1103425", "1900000",
+                "SEe", "1001100111011111101111000000000", "120220201100111010001",
+                "44642116066", "19000000000", "1xIpcEe"]
+end
+
 @test leading_ones(UInt32(Int64(2) ^ 32 - 2)) == 31
 @test leading_ones(1) == 0
 @test leading_zeros(Int32(1)) == 31
@@ -164,3 +214,8 @@ end
 
 # issue #15911
 @inferred string(1)
+
+# issue #22837
+for b in [-100:-2; 2:100;]
+    @test Base.ndigits0z(0, b) == 0
+end
diff --git a/test/intrinsics.jl b/test/intrinsics.jl
index 03f306c1ba684a..1551f09b0e807e 100644
--- a/test/intrinsics.jl
+++ b/test/intrinsics.jl
@@ -1,9 +1,9 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # intrinsic functions
-const curmod = current_module()
-const curmod_name = fullname(curmod)
-const curmod_prefix = "$(["$m." for m in curmod_name]...)"
+
+# For curmod_*
+include("testenv.jl")
 
 # bits types
 @test isa((() -> Core.Intrinsics.bitcast(Ptr{Int8}, 0))(), Ptr{Int8})
@@ -69,7 +69,7 @@ compiled_addf(x, y) = Core.Intrinsics.add_float(x, y)
 @test_throws ErrorException compiled_addf(im, im)
 @test_throws ErrorException compiled_addf(true, true)
 
-function compiled_conv{T}(::Type{T}, x)
+function compiled_conv(::Type{T}, x) where T
     t = Core.Intrinsics.trunc_int(T, x)
     z = Core.Intrinsics.zext_int(typeof(x), t)
     s = Core.Intrinsics.sext_int(typeof(x), t)
diff --git a/test/intset.jl b/test/intset.jl
index 559d6a7e524591..d19c852cf159af 100644
--- a/test/intset.jl
+++ b/test/intset.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Test functionality of IntSet
 
@@ -86,6 +86,10 @@ end
 
     i = IntSet(1:6)
     @test symdiff!(i, IntSet([6, 513])) == IntSet([1:5; 513])
+
+    # issue #23099 : these tests should not segfault
+    @test_throws ArgumentError symdiff!(IntSet(rand(1:100, 30)), 0)
+    @test_throws ArgumentError symdiff!(IntSet(rand(1:100, 30)), [0, 2, 4])
 end
 
 @testset "copy, copy!, similar" begin
@@ -281,3 +285,12 @@ end
     @test pop!(s, 100, 0) === 0
     @test pop!(s, 99, 0) === 99
 end
+
+@testset "order" begin
+    a = rand(1:1000, 100)
+    s = IntSet(a)
+    m, M = extrema(s)
+    @test m == first(s) == minimum(s) == minimum(a)
+    @test M == last(s)  == maximum(s) == maximum(a)
+    @test issorted(s)
+end
diff --git a/test/iobuffer.jl b/test/iobuffer.jl
index 752fdcb70ea7c0..189f9c89bdba6b 100644
--- a/test/iobuffer.jl
+++ b/test/iobuffer.jl
@@ -1,7 +1,9 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ioslength(io::IOBuffer) = (io.seekable ? io.size : nb_available(io))
 
+bufcontents(io::Base.GenericIOBuffer) = unsafe_string(pointer(io.data), io.size)
+
 let io = IOBuffer()
 @test eof(io)
 @test_throws EOFError read(io,UInt8)
@@ -17,7 +19,7 @@ seek(io, 0)
 a = Array{UInt8}(2)
 @test read!(io, a) == a
 @test a == UInt8['b','c']
-@test String(io) == "abc"
+@test bufcontents(io) == "abc"
 seek(io, 1)
 truncate(io, 2)
 @test position(io) == 1
@@ -50,7 +52,7 @@ end
 let io = IOBuffer("hamster\nguinea pig\nturtle")
 @test position(io) == 0
 @test readline(io) == "hamster"
-@test readstring(io) == "guinea pig\nturtle"
+@test read(io, String) == "guinea pig\nturtle"
 @test_throws EOFError read(io,UInt8)
 seek(io,0)
 @test read(io,UInt8) == convert(UInt8, 'h')
@@ -120,7 +122,7 @@ skip(io,3)
 @test write(io,b"apples") === 3
 skip(io,71)
 @test write(io,'y') === 1
-@test readstring(io) == "happy"
+@test read(io, String) == "happy"
 @test eof(io)
 write(io,zeros(UInt8,73))
 write(io,'a')
@@ -177,23 +179,23 @@ 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 readstring(io) == "dω"
-    @test String(io) == "αhelloworldω"
+    @test read(io, String) == "dω"
+    @test bufcontents(io) == "αhelloworldω"
     @test_throws ArgumentError write(io,"!")
     @test take!(io) == b"αhelloworldω"
     seek(io, 2)
     seekend(io2)
     write(io2, io)
-    @test readstring(io) == ""
-    @test readstring(io2) == ""
+    @test read(io, String) == ""
+    @test read(io2, String) == ""
     @test String(take!(io)) == "αhelloworldω"
     seek(io2, 0)
     truncate(io2, io2.size - 2)
-    @test readstring(io2) == "goodnightmoonhelloworld"
+    @test read(io2, String) == "goodnightmoonhelloworld"
     seek(io2, 0)
     write(io2, io2)
-    @test readstring(io2) == ""
-    @test String(io2) == "goodnightmoonhelloworld"
+    @test read(io2, String) == ""
+    @test bufcontents(io2) == "goodnightmoonhelloworld"
 end
 
 # issue #11917
@@ -232,3 +234,29 @@ end
 let io = IOBuffer()
     @test Base.buffer_writes(io) === io
 end
+
+# skipchars
+let
+    io = IOBuffer("")
+    @test eof(skipchars(io, isspace))
+
+    io = IOBuffer("   ")
+    @test eof(skipchars(io, isspace))
+
+    io = IOBuffer("#    \n     ")
+    @test eof(skipchars(io, isspace, linecomment='#'))
+
+    io = IOBuffer("      text")
+    skipchars(io, isspace)
+    @test String(readavailable(io)) == "text"
+
+    io = IOBuffer("   # comment \n    text")
+    skipchars(io, isspace, linecomment='#')
+    @test String(readavailable(io)) == "text"
+
+    for char in ['@','߷','࿊','𐋺']
+        io = IOBuffer("alphabeticalstuff$char")
+        @test !eof(skipchars(io, isalpha))
+        @test read(io, Char) == char
+    end
+end
diff --git a/test/iostream.jl b/test/iostream.jl
new file mode 100644
index 00000000000000..31026b753d1733
--- /dev/null
+++ b/test/iostream.jl
@@ -0,0 +1,48 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
+# Test skipchars for IOStreams
+mktemp() do path, file
+    function append_to_file(str)
+        mark(file)
+        print(file, str)
+        flush(file)
+        reset(file)
+    end
+
+    # test it doesn't error on eof
+    @test eof(skipchars(file, isspace))
+
+    # test it correctly skips
+    append_to_file("    ")
+    @test eof(skipchars(file, isspace))
+
+    # test it correctly detects comment lines
+    append_to_file("#    \n   ")
+    @test eof(skipchars(file, isspace, linecomment='#'))
+
+    # test it stops at the appropriate time
+    append_to_file("   not a space")
+    @test !eof(skipchars(file, isspace))
+    @test read(file, Char) == 'n'
+
+    # test it correctly ignores the contents of comment lines
+    append_to_file("  #not a space \n   not a space")
+    @test !eof(skipchars(file, isspace, linecomment='#'))
+    @test read(file, Char) == 'n'
+
+    # test it correctly handles unicode
+    for (byte,char) in zip(1:4, ('@','߷','࿊','𐋺'))
+        append_to_file("abcdef$char")
+        @test Base.codelen(char) == byte
+        @test !eof(skipchars(file, isalpha))
+        @test read(file, Char) == char
+    end
+end
+
+# issue #18755
+mktemp() do path, io
+    write(io, zeros(UInt8, 131073))
+    @test position(io) == 131073
+    write(io, zeros(UInt8, 131073))
+    @test position(io) == 262146
+end
diff --git a/test/iterators.jl b/test/iterators.jl
index 3f7b96e8b6b57a..88396a82d5906f 100644
--- a/test/iterators.jl
+++ b/test/iterators.jl
@@ -1,3 +1,5 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
 using Base.Iterators
 
 # zip and filter iterators
@@ -215,7 +217,7 @@ let (a, b, c) = (1:2, 1.0:10.0, Int32(1):Int32(0))
     @test length(product(a, b, c)) == 0
 
     # size
-    @test size(product(a))         == (2, )
+    @test size(product(a))         == (2,)
     @test size(product(a, b))      == (2, 10)
     @test size(product(a, b, c))   == (2, 10, 0)
 
@@ -345,7 +347,11 @@ end
 @test collect(flatten(Any[flatten(Any[1:2, 6:5]), flatten(Any[6:7, 8:9])])) == Any[1,2,6,7,8,9]
 @test collect(flatten(Any[2:1])) == Any[]
 @test eltype(flatten(UnitRange{Int8}[1:2, 3:4])) == Int8
+@test length(flatten(zip(1:3, 4:6))) == 6
+@test length(flatten(1:6)) == 6
 @test_throws ArgumentError collect(flatten(Any[]))
+@test_throws ArgumentError length(flatten(NTuple[(1,), ()])) # #16680
+@test_throws ArgumentError length(flatten([[1], [1]]))
 
 @test Base.iteratoreltype(Base.Flatten((i for i=1:2) for j=1:1)) == Base.EltypeUnknown()
 
@@ -354,6 +360,13 @@ let v = collect(partition([1,2,3,4,5], 1))
     @test all(i->v[i][1] == i, v)
 end
 
+let v1 = collect(partition([1,2,3,4,5], 2)),
+    v2 = collect(partition(flatten([[1,2],[3,4],5]), 2)) # collecting partition with SizeUnkown
+    @test v1[1] == v2[1] == [1,2]
+    @test v1[2] == v2[2] == [3,4]
+    @test v1[3] == v2[3] == [5]
+end
+
 let v = collect(partition([1,2,3,4,5], 2))
     @test v[1] == [1,2]
     @test v[2] == [3,4]
@@ -404,3 +417,9 @@ end
 @testset "product iterator infinite loop" begin
     @test collect(product(1:1, (1, "2"))) == [(1, 1) (1, "2")]
 end
+
+@testset "filter empty iterable #16704" begin
+    arr = filter(n -> true, 1:0)
+    @test length(arr) == 0
+    @test eltype(arr) == Int
+end
diff --git a/test/keywordargs.jl b/test/keywordargs.jl
index e724448d883749..e1dfe73e730a34 100644
--- a/test/keywordargs.jl
+++ b/test/keywordargs.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # simple keyword args case
 kwf1(ones; tens=0, hundreds=0) = ones + 10*tens + 100*hundreds
@@ -110,18 +110,18 @@ f18845() = 2
 @test_throws BoundsError extravagant_args(1; Any[[]]...)
 
 # keyword args with static parmeters
-kwf6{T}(x; k::T=1) = T
+kwf6(x; k::T=1) where {T} = T
 @test kwf6(1) === Int
 @test kwf6(1;k=2.5) === Float64
 
-kwf7{T}(x::T; k::T=1) = T
+kwf7(x::T; k::T=1) where {T} = T
 @test kwf7(2) === Int
 @test kwf7(1.5;k=2.5) === Float64
 @test_throws MethodError kwf7(1.5)
 @test_throws TypeError kwf7(1.5;k=2)
 
 # try to confuse it with quoted symbol
-kwf8{T}(x::MIME{:T};k::T=0) = 0
+kwf8(x::MIME{:T};k::T=0) where {T} = 0
 @test kwf8(MIME{:T}()) === 0
 
 # issue #4538
@@ -219,10 +219,10 @@ f9948, getx9948 = let
     getx() = x
     h, getx
 end
-@test_throws UndefVarError f9948()
+@test f9948() == 3
 @test getx9948() == 3
 @test f9948(x=5) == 5
-@test_throws UndefVarError f9948()
+@test f9948() == 3
 @test getx9948() == 3
 
 # issue #17785 - handle all sources of kwargs left-to-right
@@ -248,3 +248,49 @@ f7045(x::Real; y=true) = y ? 2 : 3
 @test f7045(1.0) === 1
 @test f7045(1, y=false) === 3
 @test f7045(1.0, y=false) === 3
+
+# issue #20804
+struct T20804{T}
+    y::T
+end
+(f::T20804)(;x=10) = f.y + x
+let x = T20804(4)
+    @test x() == 14
+    @test x(x=8) == 12
+end
+
+# issue #21147
+function f21147(f::Tuple{A}; kwargs...) where {B,A<:Tuple{B}}
+    return B
+end
+@test f21147(((1,),)) === Int
+@test f21147(((1,),), k = 2) === Int
+function g21147(f::Tuple{A}, k = 2) where {B,A<:Tuple{B}}
+    return B
+end
+@test g21147(((1,),)) === Int
+@test g21147(((1,),), 2) === Int
+
+# issue #21510
+f21510(; Base.@nospecialize a = 2) = a
+@test f21510(a=:b) == :b
+@test f21510() == 2
+
+# issue #21518
+let a = 0
+    f21518(;kw=nothing) = kw
+    g21518() = (a+=1; f21518)
+    g21518()(kw=1)
+    @test a == 1
+    g21518()(; :kw=>1)
+    @test a == 2
+end
+
+# issue #17240 - evaluate default expressions in nested scopes
+let a = 10
+    f17240(;a=a-1, b=2a) = (a, b)
+    @test f17240() == (9, 18)
+    @test f17240(a=2) == (2, 4)
+    @test f17240(b=3) == (9, 3)
+    @test f17240(a=2, b=1) == (2, 1)
+end
diff --git a/test/libdl.jl b/test/libdl.jl
index b4382d670504b9..ffeeed83f45b6c 100644
--- a/test/libdl.jl
+++ b/test/libdl.jl
@@ -1,11 +1,11 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # these could fail on an embedded installation
 # but for now, we don't handle that case
 dlls = Libdl.dllist()
 @test !isempty(dlls)
 @test length(dlls) > 3 # at a bare minimum, probably have some version of libstdc, libgcc, libjulia, ...
-if !is_windows() || Sys.windows_version() >= Sys.WINDOWS_VISTA_VER
+if !Sys.iswindows() || Sys.windows_version() >= Sys.WINDOWS_VISTA_VER
     for dl in dlls
         if isfile(dl) && (Libdl.dlopen_e(dl) != C_NULL)
             @test Base.samefile(Libdl.dlpath(dl), dl)
@@ -13,7 +13,7 @@ if !is_windows() || Sys.windows_version() >= Sys.WINDOWS_VISTA_VER
     end
 end
 @test length(filter(dlls) do dl
-        return ismatch(Regex("^libjulia(?:.*)\.$(Libdl.dlext)(?:\..+)?\$"), basename(dl))
+        return ismatch(Regex("^libjulia(?:.*)\\.$(Libdl.dlext)(?:\\..+)?\$"), basename(dl))
     end) == 1 # look for something libjulia-like (but only one)
 
 # library handle pointer must not be NULL
diff --git a/test/libgit2-helpers.jl b/test/libgit2-helpers.jl
new file mode 100644
index 00000000000000..1f0cae51163dfc
--- /dev/null
+++ b/test/libgit2-helpers.jl
@@ -0,0 +1,66 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
+import Base.LibGit2: AbstractCredentials, UserPasswordCredentials, SSHCredentials, CachedCredentials
+
+"""
+Emulates the LibGit2 credential loop to allows testing of the credential_callback function
+without having to authenticate against a real server.
+"""
+function credential_loop(
+        valid_credential::AbstractCredentials,
+        url::AbstractString,
+        user::AbstractString,
+        allowed_types::UInt32,
+        cache::CachedCredentials=CachedCredentials())
+    cb = Base.LibGit2.credentials_cb()
+    libgitcred_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
+    payload_ptr = Ref(Nullable{AbstractCredentials}(cache))
+
+    # Number of times credentials were authenticated against. With the real LibGit2
+    # credential loop this would be how many times we sent credentials to the remote.
+    num_authentications = 0
+
+    # Emulate how LibGit2 uses the credential callback by repeatedly calling the function
+    # until we find valid credentials or an exception is raised.
+    err = Cint(0)
+    while err == 0
+        err = ccall(cb, Cint, (Ptr{Ptr{Void}}, Cstring, Cstring, Cuint, Ptr{Void}),
+            libgitcred_ptr_ptr, url, isempty(user) ? C_NULL : user, allowed_types, pointer_from_objref(payload_ptr))
+        num_authentications += 1
+
+        # Check if the callback provided us with valid credentials
+        if length(cache.cred) == 1 && first(values(cache.cred)) == valid_credential
+            break
+        end
+
+        if num_authentications > 50
+            error("Credential callback seems to be caught in an infinite loop")
+        end
+    end
+
+    return err, num_authentications
+end
+
+function credential_loop(
+        valid_credential::UserPasswordCredentials,
+        url::AbstractString,
+        user::AbstractString="")
+    credential_loop(valid_credential, url, user, 0x000001)
+end
+
+function credential_loop(
+        valid_credential::SSHCredentials,
+        url::AbstractString,
+        user::AbstractString="";
+        use_ssh_agent::Bool=false)
+    cache = CachedCredentials()
+
+    if !use_ssh_agent
+        m = match(LibGit2.URL_REGEX, url)
+        default_cred = LibGit2.reset!(SSHCredentials(true), -1)
+        default_cred.usesshagent = "N"
+        LibGit2.get_creds!(cache, "ssh://$(m[:host])", default_cred)
+    end
+
+    credential_loop(valid_credential, url, user, 0x000046, cache)
+end
diff --git a/test/libgit2-online.jl b/test/libgit2-online.jl
index 590555a8958c9e..7b60e67d2c4896 100644
--- a/test/libgit2-online.jl
+++ b/test/libgit2-online.jl
@@ -1,6 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
-
-@testset "libgit2-online" begin
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #########
 # TESTS #
@@ -24,7 +22,7 @@ mktempdir() do dir
             try
                 repo_path = joinpath(dir, "Example2")
                 # credentials are required because github tries to authenticate on unknown repo
-                cred = LibGit2.UserPasswordCredentials("","") # empty credentials cause authentication error
+                cred = LibGit2.UserPasswordCredentials("JeffBezanson", "hunter2") # make sure Jeff is using a good password :)
                 LibGit2.clone(repo_url*randstring(10), repo_path, payload=Nullable(cred))
                 error("unexpected")
             catch ex
@@ -32,7 +30,24 @@ mktempdir() do dir
                 @test ex.code == LibGit2.Error.EAUTH
             end
         end
-    end
-end
 
+        @testset "with empty credentials" begin
+            try
+                repo_path = joinpath(dir, "Example3")
+                # credentials are required because github tries to authenticate on unknown repo
+                cred = LibGit2.UserPasswordCredentials("","") # empty credentials cause authentication error
+                LibGit2.clone(repo_url*randstring(10), repo_path, payload=Nullable(cred))
+                error("unexpected")
+            catch ex
+                @test isa(ex, LibGit2.Error.GitError)
+                if Sys.iswindows() && LibGit2.version() >= v"0.26.0"
+                    # see #22681 and https://github.com/libgit2/libgit2/pull/4055
+                    @test_broken ex.code == LibGit2.Error.EAUTH
+                    @test ex.code == LibGit2.Error.ERROR
+                else
+                    @test ex.code == LibGit2.Error.EAUTH
+                end
+            end
+        end
+    end
 end
diff --git a/test/libgit2.jl b/test/libgit2.jl
index 986ec9688570e6..dd77514255a8b0 100644
--- a/test/libgit2.jl
+++ b/test/libgit2.jl
@@ -1,9 +1,41 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 isdefined(Main, :TestHelpers) || @eval Main include(joinpath(dirname(@__FILE__), "TestHelpers.jl"))
-using TestHelpers
+import TestHelpers: challenge_prompt
 
 const LIBGIT2_MIN_VER = v"0.23.0"
+const LIBGIT2_HELPER_PATH = joinpath(dirname(@__FILE__), "libgit2-helpers.jl")
+
+function get_global_dir()
+    buf = Ref(LibGit2.Buffer())
+    LibGit2.@check ccall((:git_libgit2_opts, :libgit2), Cint,
+                         (Cint, Cint, Ptr{LibGit2.Buffer}),
+                         LibGit2.Consts.GET_SEARCH_PATH, LibGit2.Consts.CONFIG_LEVEL_GLOBAL, buf)
+    path = unsafe_string(buf[].ptr)
+    LibGit2.free(buf)
+    return path
+end
+
+function set_global_dir(dir)
+    LibGit2.@check ccall((:git_libgit2_opts, :libgit2), Cint,
+                         (Cint, Cint, Cstring),
+                         LibGit2.Consts.SET_SEARCH_PATH, LibGit2.Consts.CONFIG_LEVEL_GLOBAL, dir)
+    return
+end
+
+function with_libgit2_temp_home(f)
+    mktempdir() do tmphome
+        oldpath = get_global_dir()
+        set_global_dir(tmphome)
+        try
+            @test get_global_dir() == tmphome
+            f(tmphome)
+        finally
+            set_global_dir(oldpath)
+        end
+        return
+    end
+end
 
 #########
 # TESTS #
@@ -57,56 +89,111 @@ end
     @test sig3.email == sig.email
 end
 
-#@testset "URL parsing" begin
-    # HTTPS URL
-    m = match(LibGit2.URL_REGEX, "https://user:pass@server.com:80/org/project.git")
-    @test m[:scheme] == "https"
-    @test m[:user] == "user"
-    @test m[:password] == "pass"
-    @test m[:host] == "server.com"
-    @test m[:port] == "80"
-    @test m[:path] == "/org/project.git"
-
-    # SSH URL
-    m = match(LibGit2.URL_REGEX, "ssh://user:pass@server:22/project.git")
-    @test m[:scheme] == "ssh"
-    @test m[:user] == "user"
-    @test m[:password] == "pass"
-    @test m[:host] == "server"
-    @test m[:port] == "22"
-    @test m[:path] == "/project.git"
-
-    # SSH URL using scp-like syntax
-    m = match(LibGit2.URL_REGEX, "user@server:project.git")
-    @test m[:scheme] === nothing
-    @test m[:user] == "user"
-    @test m[:password] === nothing
-    @test m[:host] == "server"
-    @test m[:port] === nothing
-    @test m[:path] == "project.git"
-
-    # Realistic example from GitHub using HTTPS
-    m = match(LibGit2.URL_REGEX, "https://github.com/JuliaLang/Example.jl.git")
-    @test m[:scheme] == "https"
-    @test m[:user] === nothing
-    @test m[:password] === nothing
-    @test m[:host] == "github.com"
-    @test m[:port] === nothing
-    @test m[:path] == "/JuliaLang/Example.jl.git"
-
-    # Realistic example from GitHub using SSH
-    m = match(LibGit2.URL_REGEX, "git@github.com:JuliaLang/Example.jl.git")
-    @test m[:scheme] === nothing
-    @test m[:user] == "git"
-    @test m[:password] === nothing
-    @test m[:host] == "github.com"
-    @test m[:port] === nothing
-    @test m[:path] == "JuliaLang/Example.jl.git"
-
-    # Make sure usernames can contain special characters
-    m = match(LibGit2.URL_REGEX, "user-name@hostname.com")
-    @test m[:user] == "user-name"
-#end
+@testset "Default config" begin
+    with_libgit2_temp_home() do tmphome
+        cfg = LibGit2.GitConfig()
+        @test isa(cfg, LibGit2.GitConfig)
+        @test LibGit2.getconfig("fake.property", "") == ""
+        LibGit2.set!(cfg, "fake.property", "AAAA")
+        @test LibGit2.getconfig("fake.property", "") == "AAAA"
+    end
+end
+
+# See #21872 and #21636
+LibGit2.version() >= v"0.26.0" && Sys.isunix() && @testset "Default config with symlink" begin
+    with_libgit2_temp_home() do tmphome
+        write(joinpath(tmphome, "real_gitconfig"), "[fake]\n\tproperty = BBB")
+        symlink(joinpath(tmphome, "real_gitconfig"),
+                joinpath(tmphome, ".gitconfig"))
+        cfg = LibGit2.GitConfig()
+        @test isa(cfg, LibGit2.GitConfig)
+        LibGit2.getconfig("fake.property", "") == "BBB"
+        LibGit2.set!(cfg, "fake.property", "AAAA")
+        LibGit2.getconfig("fake.property", "") == "AAAA"
+    end
+end
+
+@testset "Git URL parsing" begin
+    @testset "HTTPS URL" begin
+        m = match(LibGit2.URL_REGEX, "https://user:pass@server.com:80/org/project.git")
+        @test m[:scheme] == "https"
+        @test m[:user] == "user"
+        @test m[:password] == "pass"
+        @test m[:host] == "server.com"
+        @test m[:port] == "80"
+        @test m[:path] == "/org/project.git"
+    end
+
+    @testset "SSH URL" begin
+        m = match(LibGit2.URL_REGEX, "ssh://user:pass@server:22/project.git")
+        @test m[:scheme] == "ssh"
+        @test m[:user] == "user"
+        @test m[:password] == "pass"
+        @test m[:host] == "server"
+        @test m[:port] == "22"
+        @test m[:path] == "/project.git"
+    end
+
+    @testset "SSH URL, scp-like syntax" begin
+        m = match(LibGit2.URL_REGEX, "user@server:project.git")
+        @test m[:scheme] === nothing
+        @test m[:user] == "user"
+        @test m[:password] === nothing
+        @test m[:host] == "server"
+        @test m[:port] === nothing
+        @test m[:path] == "project.git"
+    end
+
+    # scp-like syntax corner case. The SCP syntax does not support port so everything after
+    # the colon is part of the path.
+    @testset "scp-like syntax, no port" begin
+        m = match(LibGit2.URL_REGEX, "server:1234/repo")
+        @test m[:scheme] === nothing
+        @test m[:user] === nothing
+        @test m[:password] === nothing
+        @test m[:host] == "server"
+        @test m[:port] === nothing
+        @test m[:path] == "1234/repo"
+    end
+
+    @testset "HTTPS URL, realistic" begin
+        m = match(LibGit2.URL_REGEX, "https://github.com/JuliaLang/Example.jl.git")
+        @test m[:scheme] == "https"
+        @test m[:user] === nothing
+        @test m[:password] === nothing
+        @test m[:host] == "github.com"
+        @test m[:port] === nothing
+        @test m[:path] == "/JuliaLang/Example.jl.git"
+    end
+
+    @testset "SSH URL, realistic" begin
+        m = match(LibGit2.URL_REGEX, "git@github.com:JuliaLang/Example.jl.git")
+        @test m[:scheme] === nothing
+        @test m[:user] == "git"
+        @test m[:password] === nothing
+        @test m[:host] == "github.com"
+        @test m[:port] === nothing
+        @test m[:path] == "JuliaLang/Example.jl.git"
+    end
+
+    @testset "usernames with special characters" begin
+        m = match(LibGit2.URL_REGEX, "user-name@hostname.com")
+        @test m[:user] == "user-name"
+    end
+
+    @testset "HTTPS URL, no path" begin
+        m = match(LibGit2.URL_REGEX, "https://user:pass@server.com:80")
+        @test m[:path] == ""
+    end
+
+    @testset "scp-like syntax, no path" begin
+        m = match(LibGit2.URL_REGEX, "user@server:")
+        @test m[:path] == ""
+
+        m = match(LibGit2.URL_REGEX, "user@server")
+        @test m[:path] == ""
+    end
+end
 
 mktempdir() do dir
     # test parameters
@@ -123,6 +210,7 @@ mktempdir() do dir
     commit_oid3 = LibGit2.GitHash()
     master_branch = "master"
     test_branch = "test_branch"
+    test_branch2 = "test_branch_two"
     tag1 = "tag1"
     tag2 = "tag2"
 
@@ -141,6 +229,58 @@ mktempdir() do dir
             @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
+
+            # Ordering of entries appears random when using `LibGit2.set!`
+            count = 0
+            for entry in LibGit2.GitConfigIter(cfg, r"tmp.*")
+                count += 1
+                name, value = unsafe_string(entry.name), unsafe_string(entry.value)
+                if name == "tmp.str"
+                    @test value == "AAAA"
+                elseif name == "tmp.int32"
+                    @test value == "1"
+                elseif name == "tmp.int64"
+                    @test value == "1"
+                elseif name == "tmp.bool"
+                    @test value == "true"
+                else
+                    error("Found unexpected entry: $name")
+                end
+                show_str = sprint(show, entry)
+                @test show_str == string("ConfigEntry(\"", name, "\", \"", value, "\")")
+            end
+            @test count == 4
+        finally
+            close(cfg)
+        end
+    end
+
+    @testset "Configuration Iteration" begin
+        config_path = joinpath(dir, config_file)
+
+        # Write config entries with duplicate names
+        open(config_path, "a") do fp
+            write(fp, """
+            [credential]
+            \thelper = store
+            [credential]
+            \thelper = cache
+            """)
+        end
+
+        cfg = LibGit2.GitConfig(config_path, LibGit2.Consts.CONFIG_LEVEL_APP)
+        try
+            # Will only see the last entry
+            @test LibGit2.get(cfg, "credential.helper", "") == "cache"
+
+            count = 0
+            for entry in LibGit2.GitConfigIter(cfg, "credential.helper")
+                count += 1
+                name, value = unsafe_string(entry.name), unsafe_string(entry.value)
+                @test name == "credential.helper"
+                @test value == (count == 1 ? "store" : "cache")
+            end
+            @test count == 2
         finally
             close(cfg)
         end
@@ -153,27 +293,59 @@ mktempdir() do dir
                 @test isdir(cache_repo)
                 @test LibGit2.path(repo) == LibGit2.posixpath(realpath(cache_repo))
                 @test isdir(joinpath(cache_repo, ".git"))
-
                 # set a remote branch
                 branch = "upstream"
                 LibGit2.GitRemote(repo, branch, repo_url) |> close
 
+                # test remote's representation in the repo's config
                 config = joinpath(cache_repo, ".git", "config")
-                lines = split(open(readstring, config, "r"), "\n")
+                lines = split(open(x->read(x, String), config, "r"), "\n")
                 @test any(map(x->x == "[remote \"upstream\"]", lines))
 
                 remote = LibGit2.get(LibGit2.GitRemote, repo, branch)
+                # test various remote properties
                 @test LibGit2.url(remote) == repo_url
+                @test LibGit2.push_url(remote) == ""
                 @test LibGit2.name(remote) == "upstream"
                 @test isa(remote, LibGit2.GitRemote)
+
+                # test showing a GitRemote object
                 @test sprint(show, remote) == "GitRemote:\nRemote name: upstream url: $repo_url"
+
+                # test setting and getting the remote's URL
                 @test LibGit2.isattached(repo)
+                LibGit2.set_remote_url(repo, "upstream", "unknown")
+                remote = LibGit2.get(LibGit2.GitRemote, repo, branch)
+                @test LibGit2.url(remote) == "unknown"
+                @test LibGit2.push_url(remote) == "unknown"
+                @test sprint(show, remote) == "GitRemote:\nRemote name: upstream url: unknown"
+                close(remote)
+                LibGit2.set_remote_url(cache_repo, "upstream", repo_url)
+                remote = LibGit2.get(LibGit2.GitRemote, repo, branch)
+                @test LibGit2.url(remote) == repo_url
+                @test LibGit2.push_url(remote) == repo_url
+                @test sprint(show, remote) == "GitRemote:\nRemote name: upstream url: $repo_url"
+                LibGit2.add_fetch!(repo, remote, "upstream")
+
+                # test setting fetch and push refspecs
+                @test LibGit2.fetch_refspecs(remote) == String["+refs/heads/*:refs/remotes/upstream/*"]
+                LibGit2.add_push!(repo, remote, "refs/heads/master")
+                close(remote)
+                remote = LibGit2.get(LibGit2.GitRemote, repo, branch)
+                @test LibGit2.push_refspecs(remote) == String["refs/heads/master"]
+                close(remote)
+                # constructor with a refspec
+                remote = LibGit2.GitRemote(repo, "upstream2", repo_url, "upstream")
+                @test sprint(show, remote) == "GitRemote:\nRemote name: upstream2 url: $repo_url"
+                @test LibGit2.fetch_refspecs(remote) == String["upstream"]
                 close(remote)
 
                 remote = LibGit2.GitRemoteAnon(repo, repo_url)
                 @test LibGit2.url(remote) == repo_url
+                @test LibGit2.push_url(remote) == ""
                 @test LibGit2.name(remote) == ""
                 @test isa(remote, LibGit2.GitRemote)
+                close(remote)
             finally
                 close(repo)
             end
@@ -197,13 +369,22 @@ mktempdir() do dir
                 error("unexpected")
             catch e
                 @test typeof(e) == LibGit2.GitError
-                @test startswith(sprint(show,e),"GitError(Code:ENOTFOUND, Class:OS, Failed to resolve path")
+                @test startswith(
+                    lowercase(sprint(show, e)),
+                    lowercase("GitError(Code:ENOTFOUND, Class:OS, failed to resolve path"))
+            end
+            path = joinpath(dir, "Example.BareTwo")
+            repo = LibGit2.init(path, true)
+            try
+                #just to see if this works
+                LibGit2.cleanup(repo)
+            finally
+                close(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)
@@ -266,6 +447,7 @@ mktempdir() do dir
                 @test LibGit2.iszero(commit_oid1)
                 commit_oid1 = LibGit2.commit(repo, commit_msg1; author=test_sig, committer=test_sig)
                 @test !LibGit2.iszero(commit_oid1)
+                @test LibGit2.GitHash(LibGit2.head(cache_repo)) == commit_oid1
 
                 println(repo_file, randstring(10))
                 flush(repo_file)
@@ -278,6 +460,8 @@ mktempdir() do dir
                 @test LibGit2.iszero(commit_oid2)
                 commit_oid2 = LibGit2.commit(repo, commit_msg2; author=test_sig, committer=test_sig)
                 @test !LibGit2.iszero(commit_oid2)
+
+                # test getting list of commit authors
                 auths = LibGit2.authors(repo)
                 @test length(auths) == 3
                 for auth in auths
@@ -285,16 +469,38 @@ mktempdir() do dir
                     @test auth.time == test_sig.time
                     @test auth.email == test_sig.email
                 end
+
+                # check various commit properties - commit_oid1 happened before
+                # commit_oid2, so it *is* an ancestor of commit_oid2
                 @test LibGit2.is_ancestor_of(string(commit_oid1), string(commit_oid2), repo)
                 @test LibGit2.iscommit(string(commit_oid1), repo)
+                @test !LibGit2.iscommit(string(commit_oid1)*"fake", repo)
                 @test LibGit2.iscommit(string(commit_oid2), repo)
 
                 # lookup commits
                 cmt = LibGit2.GitCommit(repo, commit_oid1)
                 try
+                    @test LibGit2.Consts.OBJECT(typeof(cmt)) == LibGit2.Consts.OBJ_COMMIT
                     @test commit_oid1 == LibGit2.GitHash(cmt)
                     short_oid1 = LibGit2.GitShortHash(string(commit_oid1))
-                    @test cmp(commit_oid1,short_oid1) == 0
+                    @test hex(commit_oid1) == hex(short_oid1)
+                    @test cmp(commit_oid1, short_oid1) == 0
+                    @test cmp(short_oid1, commit_oid1) == 0
+                    @test !(short_oid1 < commit_oid1)
+
+                    # test showing ShortHash
+                    short_str = sprint(show, short_oid1)
+                    @test short_str == "GitShortHash(\"$(string(short_oid1))\")"
+                    short_oid2 = LibGit2.GitShortHash(cmt)
+                    @test startswith(hex(commit_oid1), hex(short_oid2))
+
+                    cmt2 = LibGit2.GitCommit(repo, short_oid2)
+                    try
+                        @test commit_oid1 == LibGit2.GitHash(cmt2)
+                    finally
+                        close(cmt2)
+                    end
+                    # check that the author and committer signatures are correct
                     auth = LibGit2.author(cmt)
                     @test isa(auth, LibGit2.Signature)
                     @test auth.name == test_sig.name
@@ -310,6 +516,8 @@ mktempdir() do dir
                     @test cmtr.time == test_sig.time
                     @test cmtr.email == test_sig.email
                     @test LibGit2.message(cmt) == commit_msg1
+
+                    # test showing the commit
                     showstr = split(sprint(show, cmt), "\n")
                     # the time of the commit will vary so just test the first two parts
                     @test contains(showstr[1], "Git Commit:")
@@ -318,6 +526,22 @@ mktempdir() do dir
                     @test contains(showstr[4], "SHA:")
                     @test showstr[5] == "Message:"
                     @test showstr[6] == commit_msg1
+                    @test LibGit2.revcount(repo, string(commit_oid1), string(commit_oid3)) == (-1,0)
+
+                    blame = LibGit2.GitBlame(repo, test_file)
+                    @test LibGit2.counthunks(blame) == 3
+                    @test_throws BoundsError getindex(blame, LibGit2.counthunks(blame)+1)
+                    @test_throws BoundsError getindex(blame, 0)
+                    sig = LibGit2.Signature(blame[1].orig_signature)
+                    @test sig.name == cmtr.name
+                    @test sig.email == cmtr.email
+                    show_strs = split(sprint(show, blame[1]), "\n")
+                    @test show_strs[1] == "GitBlameHunk:"
+                    @test show_strs[2] == "Original path: $test_file"
+                    @test show_strs[3] == "Lines in hunk: 1"
+                    @test show_strs[4] == "Final commit oid: $commit_oid1"
+                    @test show_strs[6] == "Original commit oid: $commit_oid1"
+                    @test length(show_strs) == 7
                 finally
                     close(cmt)
                 end
@@ -333,18 +557,28 @@ mktempdir() do dir
                 brnch = LibGit2.branch(repo)
                 brref = LibGit2.head(repo)
                 try
+                    # various branch properties
                     @test LibGit2.isbranch(brref)
                     @test !LibGit2.isremote(brref)
                     @test LibGit2.name(brref) == "refs/heads/master"
                     @test LibGit2.shortname(brref) == master_branch
                     @test LibGit2.ishead(brref)
                     @test isnull(LibGit2.upstream(brref))
+
+                    # showing the GitReference to this branch
+                    show_strs = split(sprint(show, brref), "\n")
+                    @test show_strs[1] == "GitReference:"
+                    @test show_strs[2] == "Branch with name refs/heads/master"
+                    @test show_strs[3] == "Branch is HEAD."
                     @test repo.ptr == LibGit2.repository(brref).ptr
                     @test brnch == master_branch
                     @test LibGit2.headname(repo) == master_branch
-                    LibGit2.branch!(repo, test_branch, string(commit_oid1), set_head=false)
 
+                    # create a branch *without* setting its tip as HEAD
+                    LibGit2.branch!(repo, test_branch, string(commit_oid1), set_head=false)
+                    # null because we are looking for a REMOTE branch
                     @test isnull(LibGit2.lookup_branch(repo, test_branch, true))
+                    # not null because we are now looking for a LOCAL branch
                     tbref = Base.get(LibGit2.lookup_branch(repo, test_branch, false))
                     try
                         @test LibGit2.shortname(tbref) == test_branch
@@ -352,10 +586,20 @@ mktempdir() do dir
                     finally
                         close(tbref)
                     end
+                    @test isnull(LibGit2.lookup_branch(repo, test_branch2, true))
+                    # test deleting the branch
+                    LibGit2.branch!(repo, test_branch2; set_head=false)
+                    tbref = Base.get(LibGit2.lookup_branch(repo, test_branch2, false))
+                    try
+                        @test LibGit2.shortname(tbref) == test_branch2
+                        LibGit2.delete_branch(tbref)
+                        @test isnull(LibGit2.lookup_branch(repo, test_branch2, true))
+                    finally
+                        close(tbref)
+                    end
                 finally
                     close(brref)
                 end
-
                 branches = map(b->LibGit2.shortname(b[1]), LibGit2.GitBranchIter(repo))
                 @test master_branch in branches
                 @test test_branch in branches
@@ -380,6 +624,8 @@ mktempdir() do dir
                     sig = LibGit2.Signature(repo)
                     @test sig.name == "AAAA"
                     @test sig.email == "BBBB@BBBB.COM"
+                    @test LibGit2.getconfig(repo, "user.name", "") == "AAAA"
+                    @test LibGit2.getconfig(cache_repo, "user.name", "") == "AAAA"
                 end
             finally
                 close(repo)
@@ -392,13 +638,17 @@ mktempdir() do dir
                 tags = LibGit2.tag_list(repo)
                 @test length(tags) == 0
 
+                # create tag and extract it from a GitReference
                 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
                 tag1ref = LibGit2.GitReference(repo, "refs/tags/$tag1")
-                @test isempty(LibGit2.fullname(tag1ref)) #because this is a reference to an OID
+                # because this is a reference to an OID
+                @test isempty(LibGit2.fullname(tag1ref))
+
+                # test showing a GitReference to a GitTag, and the GitTag itself
                 show_strs = split(sprint(show, tag1ref), "\n")
                 @test show_strs[1] == "GitReference:"
                 @test show_strs[2] == "Tag with name refs/tags/$tag1"
@@ -413,13 +663,23 @@ mktempdir() do dir
                 @test tag2 in tags
 
                 refs = LibGit2.ref_list(repo)
-                @test refs == ["refs/heads/master","refs/heads/test_branch","refs/tags/tag1","refs/tags/tag2"]
-
+                @test refs == ["refs/heads/master", "refs/heads/test_branch", "refs/tags/tag1", "refs/tags/tag2"]
+                # test deleting a tag
                 LibGit2.tag_delete(repo, tag1)
                 tags = LibGit2.tag_list(repo)
                 @test length(tags) == 1
                 @test tag2 ∈ tags
                 @test tag1 ∉ tags
+
+                # test git describe functions applied to these GitTags
+                description = LibGit2.GitDescribeResult(repo)
+                fmtted_description = LibGit2.format(description)
+                @test sprint(show, description) == "GitDescribeResult:\n$fmtted_description\n"
+                @test fmtted_description == "tag2"
+                description = LibGit2.GitDescribeResult(LibGit2.GitObject(repo, "HEAD"))
+                fmtted_description = LibGit2.format(description)
+                @test sprint(show, description) == "GitDescribeResult:\n$fmtted_description\n"
+                @test fmtted_description == "tag2"
             finally
                 close(repo)
             end
@@ -441,7 +701,7 @@ mktempdir() do dir
                 @test length(status) != 0
                 @test_throws BoundsError status[0]
                 @test_throws BoundsError status[length(status)+1]
-                #we've added a file - show that it is new
+                # we've added a file - show that it is new
                 @test status[1].status == LibGit2.Consts.STATUS_WT_NEW
                 close(repo_file)
             finally
@@ -461,6 +721,8 @@ mktempdir() do dir
                 blob = LibGit2.GitBlob(repo, id)
                 @test LibGit2.isbinary(blob)
                 len1 = length(blob)
+
+                # test showing a GitBlob
                 blob_show_strs = split(sprint(show, blob), "\n")
                 @test blob_show_strs[1] == "GitBlob:"
                 @test contains(blob_show_strs[2], "Blob id:")
@@ -480,12 +742,23 @@ mktempdir() do dir
                 tree = LibGit2.GitTree(repo, "HEAD^{tree}")
                 @test isa(tree, LibGit2.GitTree)
                 @test isa(LibGit2.GitObject(repo, "HEAD^{tree}"), LibGit2.GitTree)
+                @test LibGit2.Consts.OBJECT(typeof(tree)) == LibGit2.Consts.OBJ_TREE
                 @test count(tree) == 1
+
+                # test showing the GitTree and its entries
+                tree_str = sprint(show, tree)
+                @test tree_str == "GitTree:\nOwner: $(LibGit2.repository(tree))\nNumber of entries: 1\n"
                 @test_throws BoundsError tree[0]
                 @test_throws BoundsError tree[2]
                 tree_entry = tree[1]
+                @test LibGit2.filemode(tree_entry) == 33188
                 te_str = sprint(show, tree_entry)
-                @test te_str == "GitTreeEntry:\nEntry name: testfile\nEntry type: Base.LibGit2.GitBlob\nEntry OID: $(LibGit2.entryid(tree_entry))\n"
+                ref_te_str = "GitTreeEntry:\nEntry name: testfile\nEntry type: Base.LibGit2.GitBlob\nEntry OID: "
+                ref_te_str *= "$(LibGit2.entryid(tree_entry))\n"
+                @test te_str == ref_te_str
+                blob = LibGit2.GitBlob(tree_entry)
+                blob_str = sprint(show, blob)
+                @test blob_str == "GitBlob:\nBlob id: $(LibGit2.GitHash(blob))\nContents:\n$(LibGit2.content(blob))\n"
             finally
                 close(repo)
             end
@@ -516,6 +789,38 @@ mktempdir() do dir
                 @test LibGit2.isdiff(repo, "HEAD")
                 @test LibGit2.isdirty(repo, cached=true)
                 @test LibGit2.isdiff(repo, "HEAD", cached=true)
+                tree = LibGit2.GitTree(repo, "HEAD^{tree}")
+
+                # test properties of the diff_tree
+                diff = LibGit2.diff_tree(repo, tree, "", cached=true)
+                @test count(diff) == 1
+                @test_throws BoundsError diff[0]
+                @test_throws BoundsError diff[2]
+                @test LibGit2.Consts.DELTA_STATUS(diff[1].status) == LibGit2.Consts.DELTA_MODIFIED
+                @test diff[1].nfiles == 2
+
+                # test showing a DiffDelta
+                diff_strs = split(sprint(show, diff[1]), '\n')
+                @test diff_strs[1] == "DiffDelta:"
+                @test diff_strs[2] == "Status: DELTA_MODIFIED"
+                @test diff_strs[3] == "Number of files: 2"
+                @test diff_strs[4] == "Old file:"
+                @test diff_strs[5] == "DiffFile:"
+                @test contains(diff_strs[6], "Oid:")
+                @test contains(diff_strs[7], "Path:")
+                @test contains(diff_strs[8], "Size:")
+                @test isempty(diff_strs[9])
+                @test diff_strs[10] == "New file:"
+
+                # test showing a GitDiff
+                diff_strs = split(sprint(show, diff), '\n')
+                @test diff_strs[1] == "GitDiff:"
+                @test diff_strs[2] == "Number of deltas: 1"
+                @test diff_strs[3] == "GitDiffStats:"
+                @test diff_strs[4] == "Files changed: 1"
+                @test diff_strs[5] == "Insertions: 1"
+                @test diff_strs[6] == "Deletions: 0"
+
                 LibGit2.commit(repo, "zzz")
                 @test !LibGit2.isdirty(repo)
                 @test !LibGit2.isdiff(repo, "HEAD")
@@ -527,6 +832,209 @@ mktempdir() do dir
         end
     end
 
+    # TO DO: add more tests for various merge
+    # preference options
+    @testset "Fastforward merges" begin
+        path = joinpath(dir, "Example.FF")
+        repo = LibGit2.clone(cache_repo, path)
+        # need to set this for merges to succeed
+        cfg = LibGit2.GitConfig(repo)
+        LibGit2.set!(cfg, "user.name", "AAAA")
+        LibGit2.set!(cfg, "user.email", "BBBB@BBBB.COM")
+        try
+            # Sets up a branch "branch/ff_a" which will be two commits ahead
+            # of "master". It's possible to fast-forward merge "branch/ff_a"
+            # into "master", which is the default behavior.
+            oldhead = LibGit2.head_oid(repo)
+            LibGit2.branch!(repo, "branch/ff_a")
+            open(joinpath(LibGit2.path(repo),"ff_file1"),"w") do f
+                write(f, "111\n")
+            end
+            LibGit2.add!(repo, "ff_file1")
+            LibGit2.commit(repo, "add ff_file1")
+
+            open(joinpath(LibGit2.path(repo),"ff_file2"),"w") do f
+                write(f, "222\n")
+            end
+            LibGit2.add!(repo, "ff_file2")
+            LibGit2.commit(repo, "add ff_file2")
+            LibGit2.branch!(repo, "master")
+            # switch back, now try to ff-merge the changes
+            # from branch/a
+            # set up the merge using GitAnnotated objects
+            upst_ann = LibGit2.GitAnnotated(repo, "branch/ff_a")
+            head_ann = LibGit2.GitAnnotated(repo, "master")
+
+            # ff merge them
+            @test LibGit2.merge!(repo, [upst_ann], true)
+            @test LibGit2.is_ancestor_of(string(oldhead), string(LibGit2.head_oid(repo)), repo)
+
+            # Repeat the process, but specifying a commit to merge in as opposed
+            # to a branch name or GitAnnotated.
+            oldhead = LibGit2.head_oid(repo)
+            LibGit2.branch!(repo, "branch/ff_b")
+            open(joinpath(LibGit2.path(repo),"ff_file3"),"w") do f
+                write(f, "333\n")
+            end
+            LibGit2.add!(repo, "ff_file3")
+            LibGit2.commit(repo, "add ff_file3")
+
+            open(joinpath(LibGit2.path(repo),"ff_file4"),"w") do f
+                write(f, "444\n")
+            end
+            LibGit2.add!(repo, "ff_file4")
+            LibGit2.commit(repo, "add ff_file4")
+            branchhead = LibGit2.head_oid(repo)
+            LibGit2.branch!(repo, "master")
+            # switch back, now try to ff-merge the changes
+            # from branch/a using committish
+            @test LibGit2.merge!(repo, committish=string(branchhead))
+            @test LibGit2.is_ancestor_of(string(oldhead), string(LibGit2.head_oid(repo)), repo)
+
+            # Repeat the process, but specifying a branch name to merge in as opposed
+            # to a commit or GitAnnotated.
+            oldhead = LibGit2.head_oid(repo)
+            LibGit2.branch!(repo, "branch/ff_c")
+            open(joinpath(LibGit2.path(repo),"ff_file5"),"w") do f
+                write(f, "555\n")
+            end
+            LibGit2.add!(repo, "ff_file5")
+            LibGit2.commit(repo, "add ff_file5")
+
+            open(joinpath(LibGit2.path(repo),"ff_file6"),"w") do f
+                write(f, "666\n")
+            end
+            LibGit2.add!(repo, "ff_file6")
+            LibGit2.commit(repo, "add ff_file6")
+            branchhead = LibGit2.head_oid(repo)
+            LibGit2.branch!(repo, "master")
+            # switch back, now try to ff-merge the changes
+            # from branch/ff_c using branch name
+            @test LibGit2.merge!(repo, branch="refs/heads/branch/ff_c")
+            @test LibGit2.is_ancestor_of(string(oldhead), string(LibGit2.head_oid(repo)), repo)
+        finally
+            close(repo)
+        end
+    end
+
+    @testset "Cherrypick" begin
+        path = joinpath(dir, "Example.Cherrypick")
+        repo = LibGit2.clone(cache_repo, path)
+        # need to set this for merges to succeed
+        cfg = LibGit2.GitConfig(repo)
+        LibGit2.set!(cfg, "user.name", "AAAA")
+        LibGit2.set!(cfg, "user.email", "BBBB@BBBB.COM")
+        try
+            # Create a commit on the new branch and cherry-pick it over to
+            # master. Since the cherry-pick does *not* make a new commit on
+            # master, we have to create our own commit of the dirty state.
+            oldhead = LibGit2.head_oid(repo)
+            LibGit2.branch!(repo, "branch/cherry_a")
+            open(joinpath(LibGit2.path(repo),"file1"),"w") do f
+                write(f, "111\n")
+            end
+            LibGit2.add!(repo, "file1")
+            cmt_oid = LibGit2.commit(repo, "add file1")
+            cmt = LibGit2.GitCommit(repo, cmt_oid)
+            # switch back, try to cherrypick
+            # from branch/cherry_a
+            LibGit2.branch!(repo, "master")
+            LibGit2.cherrypick(repo, cmt, options=Base.LibGit2.CherrypickOptions())
+            cmt_oid2 = LibGit2.commit(repo, "add file1")
+            @test isempty(LibGit2.diff_files(repo, "master", "branch/cherry_a"))
+        finally
+            close(repo)
+        end
+    end
+
+    @testset "Merges" begin
+        path = joinpath(dir, "Example.Merge")
+        repo = LibGit2.clone(cache_repo, path)
+        # need to set this for merges to succeed
+        cfg = LibGit2.GitConfig(repo)
+        LibGit2.set!(cfg, "user.name", "AAAA")
+        LibGit2.set!(cfg, "user.email", "BBBB@BBBB.COM")
+        try
+            oldhead = LibGit2.head_oid(repo)
+            LibGit2.branch!(repo, "branch/merge_a")
+            open(joinpath(LibGit2.path(repo),"file1"),"w") do f
+                write(f, "111\n")
+            end
+            LibGit2.add!(repo, "file1")
+            LibGit2.commit(repo, "add file1")
+
+            # switch back, add a commit, try to merge
+            # from branch/merge_a
+            LibGit2.branch!(repo, "master")
+
+            # test for showing a Reference to a non-HEAD branch
+            brref = LibGit2.GitReference(repo, "refs/heads/branch/merge_a")
+            @test LibGit2.name(brref) == "refs/heads/branch/merge_a"
+            @test !LibGit2.ishead(brref)
+            show_strs = split(sprint(show, brref), "\n")
+            @test show_strs[1] == "GitReference:"
+            @test show_strs[2] == "Branch with name refs/heads/branch/merge_a"
+            @test show_strs[3] == "Branch is not HEAD."
+
+            open(joinpath(LibGit2.path(repo), "file2"), "w") do f
+                write(f, "222\n")
+            end
+            LibGit2.add!(repo, "file2")
+            LibGit2.commit(repo, "add file2")
+
+            upst_ann = LibGit2.GitAnnotated(repo, "branch/merge_a")
+            head_ann = LibGit2.GitAnnotated(repo, "master")
+
+            # (fail to) merge them because we can't fastforward
+            @test_warn "WARNING: Cannot perform fast-forward merge." !LibGit2.merge!(repo, [upst_ann], true)
+            # merge them now that we allow non-ff
+            @test_warn "INFO: Review and commit merged changes." LibGit2.merge!(repo, [upst_ann], false)
+            @test LibGit2.is_ancestor_of(string(oldhead), string(LibGit2.head_oid(repo)), repo)
+
+            # go back to merge_a and rename a file
+            LibGit2.branch!(repo, "branch/merge_b")
+            mv(joinpath(LibGit2.path(repo),"file1"),joinpath(LibGit2.path(repo),"mvfile1"))
+            LibGit2.add!(repo, "mvfile1")
+            LibGit2.commit(repo, "move file1")
+            LibGit2.branch!(repo, "master")
+            upst_ann = LibGit2.GitAnnotated(repo, "branch/merge_b")
+            rename_flag = 0
+            rename_flag = LibGit2.toggle(rename_flag, 0) # turns on the find renames opt
+            mos = LibGit2.MergeOptions(flags=rename_flag)
+            @test_warn "INFO: Review and commit merged changes." LibGit2.merge!(repo, [upst_ann], merge_opts=mos)
+        finally
+            close(repo)
+        end
+    end
+
+    @testset "push" begin
+        up_path = joinpath(dir, "Example.PushUp")
+        up_repo = LibGit2.clone(cache_repo, up_path)
+        our_path = joinpath(dir, "Example.Push")
+        our_repo = LibGit2.clone(cache_repo, our_path)
+        # need to set this for merges to succeed
+        our_cfg = LibGit2.GitConfig(our_repo)
+        LibGit2.set!(our_cfg, "user.name", "AAAA")
+        LibGit2.set!(our_cfg, "user.email", "BBBB@BBBB.COM")
+        up_cfg = LibGit2.GitConfig(up_repo)
+        LibGit2.set!(up_cfg, "user.name", "AAAA")
+        LibGit2.set!(up_cfg, "user.email", "BBBB@BBBB.COM")
+        try
+            open(joinpath(LibGit2.path(our_repo),"file1"),"w") do f
+                write(f, "111\n")
+            end
+            LibGit2.add!(our_repo, "file1")
+            LibGit2.commit(our_repo, "add file1")
+            if LibGit2.version() >= v"0.26.0" # See #21872, #21639 and #21597
+                # we cannot yet locally push to non-bare repos
+                @test_throws LibGit2.GitError LibGit2.push(our_repo, remoteurl=up_path)
+            end
+        finally
+            close(our_repo)
+            close(up_repo)
+        end
+    end
+
     @testset "Fetch from cache repository" begin
         repo = LibGit2.GitRepo(test_repo)
         try
@@ -543,6 +1051,10 @@ mktempdir() do dir
             @test isfile(joinpath(test_repo, test_file))
             @test new_head == head_oid
 
+            # GitAnnotated for a fetchhead
+            fh_ann = LibGit2.GitAnnotated(repo, LibGit2.Consts.FETCH_HEAD)
+            @test LibGit2.GitHash(fh_ann) == head_oid
+
             # Detach HEAD - no merge
             LibGit2.checkout!(repo, string(commit_oid3))
             @test_throws LibGit2.Error.GitError LibGit2.merge!(repo, fastforward=true)
@@ -556,6 +1068,10 @@ mktempdir() do dir
             LibGit2.set!(cfg, "user.name", "AAAA")
             LibGit2.set!(cfg, "user.email", "BBBB@BBBB.COM")
 
+            # If upstream argument is empty, libgit2 will look for tracking
+            # information. If the current branch isn't tracking any upstream
+            # the rebase should fail.
+            @test_throws LibGit2.GitError LibGit2.rebase!(repo)
             # Try rebasing on master instead
             newhead = LibGit2.rebase!(repo, master_branch)
             @test newhead == head_oid
@@ -563,6 +1079,21 @@ mktempdir() do dir
             # Switch to the master branch
             LibGit2.branch!(repo, master_branch)
 
+            fetch_heads = LibGit2.fetchheads(repo)
+            @test fetch_heads[1].name == "refs/heads/master"
+            @test fetch_heads[1].ismerge == true # we just merged master
+            @test fetch_heads[2].name == "refs/heads/test_branch"
+            @test fetch_heads[2].ismerge == false
+            @test fetch_heads[3].name == "refs/tags/tag2"
+            @test fetch_heads[3].ismerge == false
+            for fh in fetch_heads
+                @test fh.url == cache_repo
+                fh_strs = split(sprint(show, fh), '\n')
+                @test fh_strs[1] == "FetchHead:"
+                @test fh_strs[2] == "Name: $(fh.name)"
+                @test fh_strs[3] == "URL: $(fh.url)"
+                @test fh_strs[5] == "Merged: $(fh.ismerge)"
+            end
         finally
             close(repo)
         end
@@ -570,7 +1101,7 @@ mktempdir() do dir
 
     @testset "Examine test repository" begin
         @testset "files" begin
-            @test readstring(joinpath(test_repo, test_file)) == readstring(joinpath(cache_repo, test_file))
+            @test read(joinpath(test_repo, test_file), String) == read(joinpath(cache_repo, test_file), String)
         end
 
         @testset "tags & branches" begin
@@ -593,7 +1124,6 @@ mktempdir() do dir
                 finally
                     close(tag2ref)
                 end
-
             finally
                 close(repo)
             end
@@ -617,6 +1147,9 @@ mktempdir() do dir
                 for i in eachindex(oids)
                     @test cache_oids[i] == test_oids[i]
                 end
+                LibGit2.with(LibGit2.GitRevWalker(repo)) do walker
+                    @test count((oid,repo)->(oid == commit_oid1), walker, oid=commit_oid1, by=LibGit2.Consts.SORT_TIME) == 1
+                end
             finally
                 close(repo)
                 close(cache)
@@ -631,12 +1164,23 @@ mktempdir() do dir
             LibGit2.with(LibGit2.GitIndex(repo)) do idx
                 i = find(test_file, idx)
                 @test !isnull(i)
-                @test idx[get(i)] !== nothing
+                idx_entry = idx[get(i)]
+                @test idx_entry !== nothing
+                idx_entry_str = sprint(show, idx_entry)
+                @test idx_entry_str == "IndexEntry($(string(idx_entry.id)))"
+                @test LibGit2.stage(idx_entry) == 0
 
                 i = find("zzz", idx)
                 @test isnull(i)
                 idx_str = sprint(show, idx)
                 @test idx_str == "GitIndex:\nRepository: $(LibGit2.repository(idx))\nNumber of elements: 1\n"
+
+                LibGit2.remove!(repo, test_file)
+                LibGit2.read!(repo)
+                @test count(idx) == 0
+                LibGit2.add!(repo, test_file)
+                LibGit2.update!(repo, test_file)
+                @test count(idx) == 1
             end
 
             # check non-existent file status
@@ -690,6 +1234,54 @@ mktempdir() do dir
         end
     end
 
+    @testset "Modify remote" begin
+        path = test_repo
+        repo = LibGit2.GitRepo(path)
+        try
+            remote_name = "test"
+            url = "https://test.com/repo"
+
+            @test isnull(LibGit2.lookup_remote(repo, remote_name))
+
+            for r in (repo, path)
+                # Set just the fetch URL
+                LibGit2.set_remote_fetch_url(r, remote_name, url)
+                remote = get(LibGit2.lookup_remote(repo, remote_name))
+                @test LibGit2.name(remote) == remote_name
+                @test LibGit2.url(remote) == url
+                @test LibGit2.push_url(remote) == ""
+
+                LibGit2.remote_delete(repo, remote_name)
+                @test isnull(LibGit2.lookup_remote(repo, remote_name))
+
+                # Set just the push URL
+                LibGit2.set_remote_push_url(r, remote_name, url)
+                remote = get(LibGit2.lookup_remote(repo, remote_name))
+                @test LibGit2.name(remote) == remote_name
+                @test LibGit2.url(remote) == ""
+                @test LibGit2.push_url(remote) == url
+
+                LibGit2.remote_delete(repo, remote_name)
+                @test isnull(LibGit2.lookup_remote(repo, remote_name))
+
+                # Set the fetch and push URL
+                LibGit2.set_remote_url(r, remote_name, url)
+                remote = get(LibGit2.lookup_remote(repo, remote_name))
+                @test LibGit2.name(remote) == remote_name
+                @test LibGit2.url(remote) ==  url
+                @test LibGit2.push_url(remote) == url
+
+                LibGit2.remote_delete(repo, remote_name)
+                @test isnull(LibGit2.lookup_remote(repo, remote_name))
+            end
+            # Invalid remote name
+            @test_throws LibGit2.GitError LibGit2.set_remote_url(repo, "", url)
+            @test_throws LibGit2.GitError LibGit2.set_remote_url(repo, remote_name, "")
+        finally
+            close(repo)
+        end
+    end
+
     @testset "rebase" begin
         repo = LibGit2.GitRepo(test_repo)
         try
@@ -724,6 +1316,10 @@ mktempdir() do dir
 
             newhead = LibGit2.head_oid(repo)
 
+            files = LibGit2.diff_files(repo, "branch/a", "branch/b", filter=Set([LibGit2.Consts.DELTA_ADDED]))
+            @test files == ["file3"]
+            files = LibGit2.diff_files(repo, "branch/a", "branch/b", filter=Set([LibGit2.Consts.DELTA_MODIFIED]))
+            @test files == []
             # switch back and rebase
             LibGit2.branch!(repo, "branch/a")
             newnewhead = LibGit2.rebase!(repo, "branch/b")
@@ -743,6 +1339,61 @@ mktempdir() do dir
 
             newerhead = LibGit2.head_oid(repo)
             @test newerhead == newhead
+
+            # add yet more files
+            open(joinpath(LibGit2.path(repo),"file5"),"w") do f
+                write(f, "555\n")
+            end
+            LibGit2.add!(repo, "file5")
+            LibGit2.commit(repo, "add file5")
+            open(joinpath(LibGit2.path(repo),"file6"),"w") do f
+                write(f, "666\n")
+            end
+            LibGit2.add!(repo, "file6")
+            LibGit2.commit(repo, "add file6")
+
+            pre_abort_head = LibGit2.head_oid(repo)
+            # Rebase type
+            head_ann = LibGit2.GitAnnotated(repo, "branch/a")
+            upst_ann = LibGit2.GitAnnotated(repo, "master")
+            rb = LibGit2.GitRebase(repo, head_ann, upst_ann)
+            @test_throws BoundsError rb[3]
+            @test_throws BoundsError rb[0]
+            rbo = next(rb)
+            rbo_str = sprint(show, rbo)
+            @test rbo_str == "RebaseOperation($(string(rbo.id)))\nOperation type: REBASE_OPERATION_PICK\n"
+            rb_str = sprint(show, rb)
+            @test rb_str == "GitRebase:\nNumber: 2\nCurrently performing operation: 1\n"
+            rbo = rb[2]
+            rbo_str = sprint(show, rbo)
+            @test rbo_str == "RebaseOperation($(string(rbo.id)))\nOperation type: REBASE_OPERATION_PICK\n"
+
+            # test rebase abort
+            LibGit2.abort(rb)
+            @test LibGit2.head_oid(repo) == pre_abort_head
+        finally
+            close(repo)
+        end
+    end
+
+    @testset "merge" begin
+        path = joinpath(dir, "Example.simple_merge")
+        repo = LibGit2.clone(cache_repo, path)
+        cfg = LibGit2.GitConfig(repo)
+        LibGit2.set!(cfg, "user.name", "AAAA")
+        LibGit2.set!(cfg, "user.email", "BBBB@BBBB.COM")
+        try
+            LibGit2.branch!(repo, "branch/merge_a")
+
+            a_head = LibGit2.head_oid(repo)
+            open(joinpath(LibGit2.path(repo),"merge_file1"),"w") do f
+                write(f, "111\n")
+            end
+            LibGit2.add!(repo, "merge_file1")
+            LibGit2.commit(repo, "add merge_file1")
+            LibGit2.branch!(repo, "master")
+            a_head_ann = LibGit2.GitAnnotated(repo, "branch/merge_a")
+            @test_warn "INFO: Review and commit merged changes." LibGit2.merge!(repo, [a_head_ann]) #merge returns true if successful
         finally
             close(repo)
         end
@@ -768,6 +1419,7 @@ mktempdir() do dir
             close(repo)
         end
     end
+
     @testset "checkout/headname" begin
         repo = LibGit2.GitRepo(cache_repo)
         try
@@ -779,6 +1431,34 @@ mktempdir() do dir
         end
     end
 
+
+    if Sys.isunix()
+        @testset "checkout/proptest" begin
+            repo = LibGit2.GitRepo(test_repo)
+            try
+                cp(joinpath(test_repo, test_file), joinpath(test_repo, "proptest"))
+                LibGit2.add!(repo, "proptest")
+                id1 = LibGit2.commit(repo, "test property change 1")
+                # change in file permissions (#17610)
+                chmod(joinpath(test_repo, "proptest"),0o744)
+                LibGit2.add!(repo, "proptest")
+                id2 = LibGit2.commit(repo, "test property change 2")
+                LibGit2.checkout!(repo, string(id1))
+                @test !LibGit2.isdirty(repo)
+                # change file to symlink (#18420)
+                mv(joinpath(test_repo, "proptest"), joinpath(test_repo, "proptest2"))
+                symlink(joinpath(test_repo, "proptest2"), joinpath(test_repo, "proptest"))
+                LibGit2.add!(repo, "proptest", "proptest2")
+                id3 = LibGit2.commit(repo, "test symlink change")
+                LibGit2.checkout!(repo, string(id1))
+                @test !LibGit2.isdirty(repo)
+            finally
+                close(repo)
+            end
+        end
+    end
+
+
     @testset "Credentials" begin
         creds_user = "USER"
         creds_pass = "PASS"
@@ -789,16 +1469,188 @@ mktempdir() do dir
         @test LibGit2.checkused!(creds)
         @test creds.user == creds_user
         @test creds.pass == creds_pass
+        creds2 = LibGit2.UserPasswordCredentials(creds_user, creds_pass)
+        @test creds == creds2
+        LibGit2.reset!(creds)
+        @test !LibGit2.checkused!(creds)
+        sshcreds = LibGit2.SSHCredentials(creds_user, creds_pass)
+        @test sshcreds.user == creds_user
+        @test sshcreds.pass == creds_pass
+        @test isempty(sshcreds.prvkey)
+        @test isempty(sshcreds.pubkey)
+        sshcreds2 = LibGit2.SSHCredentials(creds_user, creds_pass)
+        @test sshcreds == sshcreds2
+    end
+
+    # The following tests require that we can fake a TTY so that we can provide passwords
+    # which use the `getpass` function. At the moment we can only fake this on UNIX based
+    # systems.
+    if Sys.isunix()
+        @testset "SSH credential prompt" begin
+            url = "git@github.com/test/package.jl"
+
+            key_dir = joinpath(dirname(@__FILE__), "libgit2")
+            valid_key = joinpath(key_dir, "valid")
+            invalid_key = joinpath(key_dir, "invalid")
+            valid_p_key = joinpath(key_dir, "valid-passphrase")
+            passphrase = "secret"
+
+            ssh_cmd = """
+            include("$LIBGIT2_HELPER_PATH")
+            valid_cred = LibGit2.SSHCredentials("git", "", "$valid_key", "$valid_key.pub")
+            err, auth_attempts = credential_loop(valid_cred, "$url", "git")
+            (err < 0 ? LibGit2.GitError(err) : err, auth_attempts)
+            """
+
+            ssh_p_cmd = """
+            include("$LIBGIT2_HELPER_PATH")
+            valid_cred = LibGit2.SSHCredentials("git", "$passphrase", "$valid_p_key", "$valid_p_key.pub")
+            err, auth_attempts = credential_loop(valid_cred, "$url", "git")
+            (err < 0 ? LibGit2.GitError(err) : err, auth_attempts)
+            """
+
+            # Note: We cannot use the default ~/.ssh/id_rsa for tests since we cannot be
+            # sure a users will actually have these files. Instead we will use the ENV
+            # variables to set the default values.
+
+            # Default credentials are valid
+            withenv("SSH_KEY_PATH" => valid_key) do
+                err, auth_attempts = challenge_prompt(ssh_cmd, [])
+                @test err == 0
+                @test auth_attempts == 1
+            end
+
+            # Default credentials are valid but requires a passphrase
+            withenv("SSH_KEY_PATH" => valid_p_key) do
+                challenges = [
+                    "Passphrase for $valid_p_key:" => "$passphrase\n",
+                ]
+                err, auth_attempts = challenge_prompt(ssh_p_cmd, challenges)
+                @test err == 0
+                @test auth_attempts == 1
+
+                # User mistypes passphrase.
+                # Note: In reality LibGit2 will raise an error upon using the invalid SSH
+                # credentials. Since we don't control the internals of LibGit2 though they
+                # could also just re-call the credential callback like they do for HTTP.
+                challenges = [
+                    "Passphrase for $valid_p_key:" => "foo\n",
+                    # "Private key location for 'git@github.com' [$valid_p_key]:" => "\n",
+                    "Passphrase for $valid_p_key:" => "$passphrase\n",
+                ]
+                err, auth_attempts = challenge_prompt(ssh_p_cmd, challenges)
+                @test err == 0
+                @test auth_attempts == 5
+            end
+
+            withenv("SSH_KEY_PATH" => valid_p_key, "SSH_KEY_PASS" => passphrase) do
+                err, auth_attempts = challenge_prompt(ssh_p_cmd, [])
+                @test err == 0
+                @test auth_attempts == 1
+            end
+
+            # TODO: Tests are currently broken. Credential callback prompts for:
+            # "Passphrase for :"
+            #=
+            # Explicitly setting these env variables to be empty means the user will be
+            # given a prompt with no defaults set.
+            withenv("SSH_KEY_PATH" => "", "SSH_PUB_KEY_PATH" => "") do
+                # User provides valid credentials
+                challenges = [
+                    "Private key location for 'git@github.com':" => "$valid_key\n",
+                ]
+                err, auth_attempts = challenge_prompt(ssh_cmd, challenges)
+                @test err == 0
+                @test auth_attempts == 2
+
+                # User provides valid credentials that requires a passphrase
+                challenges = [
+                    "Private key location for 'git@github.com':" => "$valid_p_key\n",
+                    "Passphrase for $valid_p_key:" => "$passphrase\n",
+                ]
+                err, auth_attempts = challenge_prompt(ssh_p_cmd, challenges)
+                @test err == 0
+                @test auth_attempts == 2
+            end
+            =#
+
+            # TODO: Tests are currently broken. Credential callback currently infinite loops
+            # and never prompts user to change private keys.
+            #=
+            # Explicitly setting these env variables to an existing but invalid key pair
+            # means the user will be given a prompt with that defaults to the given values.
+            withenv("SSH_KEY_PATH" => invalid_key, "SSH_PUB_KEY_PATH" => invalid_key * ".pub") do
+                challenges = [
+                    "Private key location for 'git@github.com' [$invalid_key]:" => "$valid_key\n",
+                ]
+                err, auth_attempts = challenge_prompt(ssh_cmd, challenges)
+                @test err == 0
+                @test auth_attempts == 2
+            end
+            =#
+
+            # TODO: Tests are currently broken. Credential callback currently infinite loops
+            # and never prompts user to change private keys.
+            #=
+            withenv("SSH_KEY_PATH" => valid_key, "SSH_PUB_KEY_PATH" => valid_key * ".public") do
+                @test !isfile(ENV["SSH_PUB_KEY_PATH"])
+
+                # User explicitly sets the SSH_PUB_KEY_PATH incorrectly.
+                challenges = [
+                    "Private key location for 'git@github.com' [$valid_key]:" => "\n"
+                    "Public key location for 'git@github.com':" => "$valid_key.pub\n"
+                ]
+                err, auth_attempts = challenge_prompt(ssh_cmd, challenges)
+                @test err == 0
+                @test auth_attempts == 2
+            end
+            =#
+        end
+
+        @testset "HTTPS credential prompt" begin
+            url = "https://github.com/test/package.jl"
+
+            valid_username = "julia"
+            valid_password = randstring(16)
+
+            https_cmd = """
+            include("$LIBGIT2_HELPER_PATH")
+            valid_cred = LibGit2.UserPasswordCredentials("$valid_username", "$valid_password")
+            err, auth_attempts = credential_loop(valid_cred, "$url")
+            (err < 0 ? LibGit2.GitError(err) : err, auth_attempts)
+            """
+
+            # User provides a valid username and password
+            challenges = [
+                "Username for 'https://github.com':" => "$valid_username\n",
+                "Password for 'https://$valid_username@github.com':" => "$valid_password\n",
+            ]
+            err, auth_attempts = challenge_prompt(https_cmd, challenges)
+            @test err == 0
+            @test auth_attempts == 1
+
+            # User repeatedly chooses invalid username/password until the prompt limit is
+            # reached
+            challenges = [
+                "Username for 'https://github.com':" => "foo\n",
+                "Password for 'https://foo@github.com':" => "bar\n",
+                "Username for 'https://github.com' [foo]:" => "$valid_username\n",
+                "Password for 'https://$valid_username@github.com':" => "$valid_password\n",
+            ]
+            err, auth_attempts = challenge_prompt(https_cmd, challenges)
+            @test err == 0
+            @test auth_attempts == 5
+        end
     end
 
     #= temporarily disabled until working on the buildbots, ref https://github.com/JuliaLang/julia/pull/17651#issuecomment-238211150
     @testset "SSH" begin
         sshd_command = ""
         ssh_repo = joinpath(dir, "Example.SSH")
-        if !is_windows()
+        if !Sys.iswindows()
             try
                 # SSHD needs to be executed by its full absolute path
-                sshd_command = strip(readstring(`which sshd`))
+                sshd_command = strip(read(`which sshd`, String))
             catch
                 warn("Skipping SSH tests (Are `which` and `sshd` installed?)")
             end
@@ -845,7 +1697,7 @@ mktempdir() do dir
                     sshp = spawn_sshd()
 
                     TIOCSCTTY_str = "ccall(:ioctl, Void, (Cint, Cint, Int64), 0,
-                        (is_bsd() || is_apple()) ? 0x20007461 : is_linux() ? 0x540E :
+                        (Sys.isbsd() || Sys.isapple()) ? 0x20007461 : Sys.islinux() ? 0x540E :
                         error(\"Fill in TIOCSCTTY for this OS here\"), 0)"
 
                     # To fail rather than hang
@@ -954,7 +1806,7 @@ mktempdir() do dir
                         end
                     catch err
                         println("SSHD logfile contents follows:")
-                        println(readstring(logfile))
+                        println(read(logfile, String))
                         rethrow(err)
                     finally
                         rm(logfile)
@@ -971,27 +1823,35 @@ mktempdir() do dir
     @testset "Hostname verification" begin
         openssl_installed = false
         common_name = ""
-        if is_linux()
+        if Sys.islinux()
             try
                 # OpenSSL needs to be on the path
-                openssl_installed = !isempty(readstring(`openssl version`))
+                openssl_installed = !isempty(read(`openssl version`, String))
             catch
                 warn("Skipping hostname verification tests. Is `openssl` on the path?")
             end
 
             # Find a hostname that maps to the loopback address
-            hostname = replace(readchomp(`hostname`), r"\..*$", "")
-            loopback = ip"127.0.0.1"
+            hostnames = ["localhost"]
 
-            for host in (hostname, "localhost")
+            # In minimal environments a hostname might not be available (issue #20758)
+            try
+                # In some environments, namely Macs, the hostname "macbook.local" is bound
+                # to the external address while "macbook" is bound to the loopback address.
+                unshift!(hostnames, replace(gethostname(), r"\..*$", ""))
+            end
+
+            loopback = ip"127.0.0.1"
+            for hostname in hostnames
+                local addr
                 try
-                    addr = getaddrinfo(host)
+                    addr = getaddrinfo(hostname)
                 catch
                     continue
                 end
 
                 if addr == loopback
-                    common_name = host
+                    common_name = hostname
                     break
                 end
             end
@@ -1010,15 +1870,19 @@ mktempdir() do dir
                 run(pipeline(`openssl req -new -x509 -newkey rsa:2048 -nodes -keyout $key -out $cert -days 1 -subj "/CN=$common_name"`, stderr=DevNull))
                 run(`openssl x509 -in $cert -out $pem -outform PEM`)
 
+                # Find an available port by listening
+                port, server = listenany(49152)
+                close(server)
+
                 # Make a fake Julia package and minimal HTTPS server with our generated
                 # certificate. The minimal server can't actually serve a Git repository.
                 mkdir(joinpath(root, "Example.jl"))
                 pobj = cd(root) do
-                    spawn(`openssl s_server -key $key -cert $cert -WWW`)
+                    spawn(`openssl s_server -key $key -cert $cert -WWW -accept $port`)
                 end
 
                 errfile = joinpath(root, "error")
-                repo_url = "https://$common_name:4433/Example.jl"
+                repo_url = "https://$common_name:$port/Example.jl"
                 repo_dir = joinpath(root, "dest")
                 code = """
                     dest_dir = "$repo_dir"
@@ -1041,6 +1905,8 @@ mktempdir() do dir
                         deserialize(f)
                     end
                     @test err.code == LibGit2.Error.ECERTIFICATE
+                    @test startswith(lowercase(err.msg),
+                                     lowercase("The SSL certificate is invalid"))
 
                     rm(errfile)
 
@@ -1052,8 +1918,11 @@ mktempdir() do dir
                             deserialize(f)
                         end
                         @test err.code == LibGit2.Error.ERROR
-                        @test err.msg == "Invalid Content-Type: text/plain"
+                        @test lowercase(err.msg) == lowercase("invalid Content-Type: text/plain")
                     end
+
+                    # OpenSSL s_server should still be running
+                    @test process_running(pobj)
                 finally
                     kill(pobj)
                 end
diff --git a/test/libgit2/invalid b/test/libgit2/invalid
new file mode 100644
index 00000000000000..7fa5389beb031a
--- /dev/null
+++ b/test/libgit2/invalid
@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEowIBAAKCAQEAs1L+Z8s5GdtzLXGM3+4UVQ7jc5q/uNPzQgGUl+nC+o2VFuHm
+omkAIxxrS3zkVT0A4AnkrVq/H2l2AOlxKudFan4o87AJQsTHkj9LvFBhm+bBdHau
+0SGSft8cCWAXv5lifFChYaxT78Y3QnSO4Q7AVEXQVAmGFiu3CgBKq7c1srQt8V4n
+dH8PuMYdIiYuNG8HNAnErGjApdNHmosY63jybkRmTffvhuS/Df1FKLYY60QYThKM
+50P+8HHX1jvH+JI5bWLyDhG97E8Vmh9bpgvHhdZ52WBVaf5i6qmYB2FBHHfb8Yuh
+/EB39RQjPLEI9K5HP5LkBXAWxozv75qmKF7AiQIDAQABAoIBAFF1H89yRyvxva4k
+6INIGMBSlQuMfg6taNDQ+vjO3R0Hd3P/hc68t607WZnez7HQljcvB0uf7zWLqGjd
+oeSFTckEKgIYMvy7epR6YCLYuJ4jAjmvN9YT1AIBwzCXD/Ke8FfcIJLHvxEqDywG
+2mhtVPxzAiFKejhT/z9xxnmeLaxQ3eE77XrFJiJR0M+fc6B2zyN8eVR/jdpoVFOw
+Jb6TkzxDY1OWVY72EMf+7JBzpnNVqe36T0aJapF1c4qeqC+bklYtgnJ1GfohzbKU
+ij8SF1yH1y+LX0qq67DLfxmm1qNMgBNhLC8eYm9yfAWkRi4eX9c7U2X/61S3Sm9a
+CMGb8QECgYEA2x9d5uCeVdg595NutArea7sHVuJViF8kWYBwYgkAFgdEtjGhoEXX
+YMa+11HQ+yUX4WfrLhcQm/eiSdaqKEcE0g/tz6ytuFCZvPHPZe2p2QIIHjqKYezc
+mtcc95qYm1O3U5iTHsiL73TurdESOl7O1eSK/TgQwoes6cuELqZ5GBkCgYEA0YD2
+lJ7uW1MBCQwTENbe4ZapvwtEXsRIVad0dg6kzgaYgBWDIuNS0XBnB6sbD3B0TL6G
+vhpfO7wMV8VQ1H2h0aMLSgpevPxHrD0uQsXhZ0cM8hzhAKmbAscBdQXv6MnXzr37
+8FL3nHyYc9qvk7qNcMqa1x975s5SlzR5UrA9ufECgYAydOeXiXOMSu0WMFHWjYYo
+AnovLJELhPUG0weN24q0h9nvpkAUeuCcfUdmp4Vav3DfS6GhDFibwYsSO6cU/T2D
+7X0STC34ej7cfkYGr5Jj0Q7zfwFsiTFHSm92KJgpdD6Ltl9yQDXQ3vky9yieXkR8
+hlLm+ikJ0lojv+RhJZ5OyQKBgQDLlVuIXszXF9jItuAMHBEn/GVlTYiZ4nk8KuaE
+FoTV5BjrVnxBOc/v0B9+lypLnYaWUQrUzwG+JWWFISwD4TWPZrYAtAUN9sWbPTSo
+FGyOFMAiwidvomEMmN/0nNleSE4bDAk3pxgRDA6FfnvhvYXWljtTUrfvOI2Pe6Ft
+1e+VsQKBgFF1wW0E7L7ItpClFifF0tDZdOjfBwiUutusvFSj6RVtIv9s0WiSoc/R
+qOc4Jfle2F0cw3Fwp5Qv/qgKItOT0zo4mOJKOzyHfER5UgI7zcIK9dBNuYCRBwwE
+lXZzcMoTuRH8GrMdoTUTMyJ5DRC5vqRW422pM4K+ICVIYrZpfpDh
+-----END RSA PRIVATE KEY-----
diff --git a/test/libgit2/invalid.pub b/test/libgit2/invalid.pub
new file mode 100644
index 00000000000000..d7abfc26e25c8e
--- /dev/null
+++ b/test/libgit2/invalid.pub
@@ -0,0 +1 @@
+ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCzUv5nyzkZ23MtcYzf7hRVDuNzmr+40/NCAZSX6cL6jZUW4eaiaQAjHGtLfORVPQDgCeStWr8faXYA6XEq50VqfijzsAlCxMeSP0u8UGGb5sF0dq7RIZJ+3xwJYBe/mWJ8UKFhrFPvxjdCdI7hDsBURdBUCYYWK7cKAEqrtzWytC3xXid0fw+4xh0iJi40bwc0CcSsaMCl00eaixjrePJuRGZN9++G5L8N/UUothjrRBhOEoznQ/7wcdfWO8f4kjltYvIOEb3sTxWaH1umC8eF1nnZYFVp/mLqqZgHYUEcd9vxi6H8QHf1FCM8sQj0rkc/kuQFcBbGjO/vmqYoXsCJ invalid-credentials
diff --git a/test/libgit2/valid b/test/libgit2/valid
new file mode 100644
index 00000000000000..bc6cf6a402ae83
--- /dev/null
+++ b/test/libgit2/valid
@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEowIBAAKCAQEA3oA311O95RTuncUrnHxLu7CUMN9Mh5ZolXct33RoEoAkar7E
+oyW2C0AQ+yA7C3PjlC2SmgYbebUC+N/0bFOoibDwFCUmZbOlRTWITYbq7t0f6nk7
+cl4l8BvyMPbRN25ozPyn1SrGc/vHj11LnGXGNZWqCfz5EJ6LfLIlA5P/0814QrRk
+ePg/J3RZ3HJj7QlvHvG9uAQQ//WXeFdmRQDKNhZbMc0bibxZGgMQeKL7hoGwGBHT
+a5DSWsCWermUC5IYsrC5PAzGcN/KwTbQ0S9U7xVTOuKDSEMv8AzEmkpCtkulVses
+x7P47wUKhOOm9OFikVEC2s0uoRvNfUDUSzjFLQIDAQABAoIBACgKhwIXLetV8wMt
+goWs0Kw8QM7ywID+DmAnjHfUKQ57RRJ4tkZt+O7ZXrTyve13s5LtCJ7zTmp+qsRC
++WetPn1Y/DuD2/8dbzafRaI+D3VhEedOXeZdDxLA1Lr/D/ObyPxq04FHK2OgAe/I
+6FyC7EKkZm9ZuTDGd2+/V23nanihAXJ8ILk02cKxNjpq4gxt0i0Zm3CjVEYlrywm
+fBov7sbLWwu2ovISdRBziJAs8wsGPKTcbOCREtHe2BP7bfiAcf9UEatdH7C1kO8U
+gdCluvH2RMwy00NunthrKEy7CmdOh/lfV7p6VYbH3/ikq+XkhntE8SEJzafLuIUl
+mbglGsECgYEA+SflaLun2WqqsUlrVH3mN7lUbYpHhs72zOa7NcvRzBqEeYhhFyoQ
+WvQzJlzfIZ+I/JqgHjsGeJx8cHpxI7zwd7n45nc9ycU9yc5UHsAGcyQwrTpVMIEn
+gHL6Ybe2vN7CIazPGnmiwaCD25/Kp5eBXmc8Syckt12GMDIwMuozwbkCgYEA5Jzh
+O8lZMGTmoz4iGIWr0g21ySmNX+toKq+zto7jhZSZcEpFGxARP4GdiN9CafGJRRz1
+r4ZHruWazLpxozsWRAgVnWJrgee7JZ4oWi0geAw+wUxQYny+/rx0AQl81lHwPhOm
+f8WfTZifKhu9QaR5fa3DAfrgc8Gfay1TP7UtaRUCgYEAqFeEcRcZeZTQb6ijlBrc
+iZn2qWxcl4EOz7K1mstznOvtxg+XSgdptYp5ZNorCJS6AbKXrNVEsglJKtYPy43F
+C5/jxBOc888IyGlX/M7RjMpO+TwIgxVAk1EcSxnNph78G7Se2cyFYz4I2UNFsaZ0
+CkzGOCDideIC4F2Io14KSkECgYBhRzw0Q45XIGhfyD2b761YWYskCTFmQnZ1y4QO
+R6kbG0tbU88qH+EnA9Fz/4R0Llo59YO558qy6nK/cQqP6cGku0fvS4TxpxikfjMv
+hApP6u39NKrz7Z8cKDa4hj//tqgi0hvEPOR3kV0Q/vK+bu1fhEP5oLZHq3lZktTc
+xAyJrQKBgClH3j759U82D2bUXVanDqs7S0Zef91u11kYDFrnX4kUWlG0DZCB7e5P
+yBUWd/ZoXULBkoCfbwO8PGGxFYRmXzYQvVnSGiAP09dHFodvMm7hP8VueoRbAbEL
+/UKMQOhYhEpcENylUjaaLUzxaYzwqeT/dcu+Edd7sCKk0J/1beA/
+-----END RSA PRIVATE KEY-----
diff --git a/test/libgit2/valid-passphrase b/test/libgit2/valid-passphrase
new file mode 100644
index 00000000000000..169fef6df16d0a
--- /dev/null
+++ b/test/libgit2/valid-passphrase
@@ -0,0 +1,30 @@
+-----BEGIN RSA PRIVATE KEY-----
+Proc-Type: 4,ENCRYPTED
+DEK-Info: AES-128-CBC,EC9D334AA2ECD3E7A9DCBD7BDFB5CABC
+
+J9EWrlaxABoCAeow7k8oteiGorPKpZMVQBmIomx91kpfncVBC/WDbRa2HbmVkkYh
+kgFbpDmzD6cMuu1sAbOROcCBFLqtKsXwHj4nynW8PTJRNSG9GazY9tmQ/OzAV9Ng
+ZELXVncyexKEG7WDlXuArqd2KwbopNe6SetW4OYZy6t7QBNp6c4wwyRwuCYwGjMg
+3rAugZvMPv7Ytr4DCluKp+/S5P81LKPpGDYdGSD3wMQtEzB/81DPsp+BP2r0rqPA
+9Wa49c5aOcLdDaG8tVlogAQEwn4Mt/GI3U5b2Q14/YUy41AD4ZuYLl+3iv+18PsM
+6Kqs0QmD6FM6hDg82+FYh5fbvJqoHjAFqieljWFdm0oLpuz7p3q3MMfAkhl5Xrvq
+bCLQenFww8IxgyIMUGYRtq5kGKm+rXbKg/vQV/jxyLCdQZoZXO6F07gwUKX2YM1K
+H1j9DbexbtJXoAtXP7nP0qo2WJjhGnDvcqxuBRrJFW7Z/T8r0pqetYSUFuIiS7Nt
+ftT60QPziRB1G9nwR7TiWhOfl1VQlrRxXompfK+We3+njp96Yuqdw9mOZ3slEz40
+LlTlPqmC8Fp1rm+M5qtjotlYGJLUcFOpbwKzt0knl+gYPg7qCSVcjoQ0E6WrciyH
+3t8+pRtguICjV2Jfq+MFnzfJujNSBIxYro/oQ+dl3b2s9eeks6SVloCmuaGj45hN
+Y3wrfMe+4dv+wy9JuYzHualBpPk8GCxDNHqXkd7nTjDPY9uCW2xqjP8HBq+GNj0Q
+XLSyZ95iPJwxcAigXa8g3+jMg/IUddIF7tNQbHLZR1h+4nP2HB7Fo0GQM9dOGNzU
+r+LGBeIJTmFite0jSFDjRHDo/GunV7/A21ZSykt8aMAQYlEQg2eKAdfzDYK5JTXw
+dFn5YURKGpmlyRWc91Dvg6uF28KAwcMBogRK/3EiEyZushndHqtE1Rqtq+Afi1Ld
+GBgIk2dgD+TCqxtmTcPO+ZQN4Tm1rRM5j+b4VehCTQTxeqC+YMfiwZZvW8xQj5Ja
+DMG/A+0M8PZtjr+QygGXGmtWxx0dn/ez0sLO6om11U7OmYXJGEp6KqNKnlZZiv3t
+wY7wJ/IS5DhWhZ+ttsq3z+0XKCiP/06IhNmT6Aq0CUaYuXmbtx7hdnhGA92Jbn8X
+pwF8GkDdPA/nqmRiwwJSI2jAMs5EGtYCbcn4QlpCZu9x+m3/YTCGqByQN3VLRtrd
+u3UlYH1dT+EAsnG6fxXzj1MdSmT5RRadbEOW6Z3Ykfw47Ft6FKEC+WX0ZC5bBrpC
+8a9f/knEbAd5NHEgEuhHHZ+8yv0cz/SHdrDS+cygKIEB237Zwx1TIJ0x9wVtns7g
+jk7EV9PBFdmw2aD0WBoK16gQYVhGb8sDQ88ps6llxm8iLV4iQSIAeBDURvjx90aA
+vIjqC2RzqXsbtueIo1zk41gElDpDYdI9hSMqhyJaShBOcAPPSso3V0VcAylRTjRt
+B9NBbLVjajgWjqse6jcNacbhMnFvbqFEWeHLAI3jOog3aXTmkgIDtuSHGjD/r0WA
+FpOQrzn5IDkMEamtqaemFxp14MKxRAPMJ8nOPyZzXM1Pz6dARH1d3EKeC1tFMh3j
+-----END RSA PRIVATE KEY-----
diff --git a/test/libgit2/valid-passphrase.pub b/test/libgit2/valid-passphrase.pub
new file mode 100644
index 00000000000000..2ed2cd3eb54d95
--- /dev/null
+++ b/test/libgit2/valid-passphrase.pub
@@ -0,0 +1 @@
+ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDLsjzj6P2eGJEASR+MqajdDkVzCK5rTnc/BXDzgCA3Zff8uGgHQlXTX++OspluSnPKvaHFuYUWbCDEH2mwHeLWiwXk68T5+3/GqOX9/m2dxEy6TOmLQ4iOPVC5mrBrSFbHTc5J2PPh3q9hwp/p35BwWo5nCUMc+pqq7WEVdgNNziRuFyAtva2vCVDXEZ5+6FJDvysoMndoIQQlVJXHoPp8w+Eb8gOg5kxTYtpNjb7Vjx/Ux70nl26B5JYtpWUTxLHfnzPRcjGrINgtbsbVDC6BJTnSnBttxaZRcON4/pZDpcvLBhOhqBKjkRkxoMvTGeiA7M5cm/G9LWROeCc88I/D valid-credentials-with-passphrase
diff --git a/test/libgit2/valid.pub b/test/libgit2/valid.pub
new file mode 100644
index 00000000000000..1e53e6c51b7b09
--- /dev/null
+++ b/test/libgit2/valid.pub
@@ -0,0 +1 @@
+ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDegDfXU73lFO6dxSucfEu7sJQw30yHlmiVdy3fdGgSgCRqvsSjJbYLQBD7IDsLc+OULZKaBht5tQL43/RsU6iJsPAUJSZls6VFNYhNhuru3R/qeTtyXiXwG/Iw9tE3bmjM/KfVKsZz+8ePXUucZcY1laoJ/PkQnot8siUDk//TzXhCtGR4+D8ndFnccmPtCW8e8b24BBD/9Zd4V2ZFAMo2FlsxzRuJvFkaAxB4ovuGgbAYEdNrkNJawJZ6uZQLkhiysLk8DMZw38rBNtDRL1TvFVM64oNIQy/wDMSaSkK2S6VWx6zHs/jvBQqE46b04WKRUQLazS6hG819QNRLOMUt valid-credentials
diff --git a/test/linalg/arnoldi.jl b/test/linalg/arnoldi.jl
index 0b66a85c713e97..386a8f18b2baf3 100644
--- a/test/linalg/arnoldi.jl
+++ b/test/linalg/arnoldi.jl
@@ -1,80 +1,89 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base.Test
 
 @testset "eigs" begin
-    let
-        srand(1234)
-        local n,a,asym,b,bsym,d,v
-        n = 10
-        areal  = sprandn(n,n,0.4)
-        breal  = sprandn(n,n,0.4)
-        acmplx = complex.(sprandn(n,n,0.4), sprandn(n,n,0.4))
-        bcmplx = complex.(sprandn(n,n,0.4), sprandn(n,n,0.4))
-
-        testtol = 1e-6
-
-        @testset for elty in (Float64, Complex128)
-            if elty == Complex64 || elty == Complex128
-                a = acmplx
-                b = bcmplx
-            else
-                a = areal
-                b = breal
-            end
-            a     = convert(SparseMatrixCSC{elty}, a)
-            asym  = a' + a                  # symmetric indefinite
-            apd   = a'*a                    # symmetric positive-definite
+    srand(1234)
+    n = 10
+    areal  = sprandn(n,n,0.4)
+    breal  = sprandn(n,n,0.4)
+    acmplx = complex.(sprandn(n,n,0.4), sprandn(n,n,0.4))
+    bcmplx = complex.(sprandn(n,n,0.4), sprandn(n,n,0.4))
 
-            b     = convert(SparseMatrixCSC{elty}, b)
-            bsym  = b' + b
-            bpd   = b'*b
+    testtol = 1e-6
 
-            (d,v) = eigs(a, nev=3)
-            @test a*v[:,2] ≈ d[2]*v[:,2]
-            @test norm(v) > testtol # eigenvectors cannot be null vectors
-            # (d,v) = eigs(a, b, nev=3, tol=1e-8) # not handled yet
-            # @test a*v[:,2] ≈ d[2]*b*v[:,2] atol=testtol
-            # @test norm(v) > testtol # eigenvectors cannot be null vectors
+    @testset for elty in (Float64, Complex128)
+        if elty == Complex64 || elty == Complex128
+            a = acmplx
+            b = bcmplx
+        else
+            a = areal
+            b = breal
+        end
+        a     = convert(SparseMatrixCSC{elty}, a)
+        asym  = a' + a                  # symmetric indefinite
+        apd   = a'*a                    # symmetric positive-definite
 
-            (d,v) = eigs(asym, nev=3)
-            @test asym*v[:,1] ≈ d[1]*v[:,1]
-            @test eigs(asym; nev=1, sigma=d[3])[1][1] ≈ d[3]
-            @test norm(v) > testtol # eigenvectors cannot be null vectors
+        b     = convert(SparseMatrixCSC{elty}, b)
+        bsym  = b' + b
+        bpd   = b'*b
 
-            (d,v) = eigs(apd, nev=3)
-            @test apd*v[:,3] ≈ d[3]*v[:,3]
-            @test eigs(apd; nev=1, sigma=d[3])[1][1] ≈ d[3]
+        (d,v) = eigs(a, nev=3)
+        @test a*v[:,2] ≈ d[2]*v[:,2]
+        @test norm(v) > testtol # eigenvectors cannot be null vectors
+        (d,v) = eigs(a, I, nev=3) # test eigs(A, B; kwargs...)
+        @test a*v[:,2] ≈ d[2]*v[:,2]
+        @test norm(v) > testtol # eigenvectors cannot be null vectors
+        @test_warn "Use symbols instead of strings for specifying which eigenvalues to compute" eigs(a, which="LM")
+        # (d,v) = eigs(a, b, nev=3, tol=1e-8) # not handled yet
+        # @test a*v[:,2] ≈ d[2]*b*v[:,2] atol=testtol
+        # @test norm(v) > testtol # eigenvectors cannot be null vectors
 
-            (d,v) = eigs(apd, bpd, nev=3, tol=1e-8)
-            @test apd*v[:,2] ≈ d[2]*bpd*v[:,2] atol=testtol
-            @test norm(v) > testtol # eigenvectors cannot be null vectors
+        (d,v) = eigs(asym, nev=3)
+        @test asym*v[:,1] ≈ d[1]*v[:,1]
+        @test eigs(asym; nev=1, sigma=d[3])[1][1] ≈ d[3]
+        @test norm(v) > testtol # eigenvectors cannot be null vectors
 
-            @testset "(shift-and-)invert mode" begin
-                (d,v) = eigs(apd, nev=3, sigma=0)
-                @test apd*v[:,3] ≈ d[3]*v[:,3]
-                @test norm(v) > testtol # eigenvectors cannot be null vectors
+        (d,v) = eigs(apd, nev=3)
+        @test apd*v[:,3] ≈ d[3]*v[:,3]
+        @test eigs(apd; nev=1, sigma=d[3])[1][1] ≈ d[3]
 
-                (d,v) = eigs(apd, bpd, nev=3, sigma=0, tol=1e-8)
-                @test apd*v[:,1] ≈ d[1]*bpd*v[:,1] atol=testtol
-                @test norm(v) > testtol # eigenvectors cannot be null vectors
-            end
+        (d,v) = eigs(apd, bpd, nev=3, tol=1e-8)
+        @test apd*v[:,2] ≈ d[2]*bpd*v[:,2] atol=testtol
+        @test norm(v) > testtol # eigenvectors cannot be null vectors
+
+        @testset "(shift-and-)invert mode" begin
+            (d,v) = eigs(apd, nev=3, sigma=0)
+            @test apd*v[:,3] ≈ d[3]*v[:,3]
+            @test norm(v) > testtol # eigenvectors cannot be null vectors
+
+            (d,v) = eigs(apd, bpd, nev=3, sigma=0, tol=1e-8)
+            @test apd*v[:,1] ≈ d[1]*bpd*v[:,1] atol=testtol
+            @test norm(v) > testtol # eigenvectors cannot be null vectors
+        end
 
-            @testset "ArgumentErrors" begin
-                @test_throws ArgumentError eigs(rand(elty,2,2))
-                @test_throws ArgumentError eigs(a, nev=-1)
-                @test_throws ArgumentError eigs(a, which=:Z)
-                @test_throws ArgumentError eigs(a, which=:BE)
-                @test_throws DimensionMismatch eigs(a, v0=zeros(elty,n+2))
-                @test_throws ArgumentError eigs(a, v0=zeros(Int,n))
-                if elty == Float64
-                    @test_throws ArgumentError eigs(a+a.',which=:SI)
-                    @test_throws ArgumentError eigs(a+a.',which=:LI)
-                    @test_throws ArgumentError eigs(a,sigma=rand(Complex64))
-                end
+        @testset "ArgumentErrors" begin
+            @test_throws ArgumentError eigs(rand(elty,2,2))
+            @test_throws ArgumentError eigs(a, nev=-1)
+            @test_throws ArgumentError eigs(a, which=:Z)
+            @test_throws ArgumentError eigs(a, which=:BE)
+            @test_throws DimensionMismatch eigs(a, v0=zeros(elty,n+2))
+            @test_throws ArgumentError eigs(a, v0=zeros(Int,n))
+            if elty == Float64
+                @test_throws ArgumentError eigs(a+a.',which=:SI)
+                @test_throws ArgumentError eigs(a+a.',which=:LI)
+                @test_throws ArgumentError eigs(a,sigma=rand(Complex64))
             end
         end
     end
+
+    @testset "Symmetric generalized with singular B" begin
+        n = 10
+        k = 3
+        A = randn(n,n); A = A'A
+        B = randn(n,k); B = B*B'
+        @test sort(eigs(A, B, nev = k, sigma = 1.0)[1]) ≈ sort(eigvals(A, B)[1:k])
+    end
 end
 
 # Problematic example from #6965
@@ -88,7 +97,6 @@ let A6965 = [
         -1.0   0.0   0.0   0.0   0.0   0.0   7.0  1.0
         -1.0  -1.0  -1.0  -1.0  -1.0  -1.0  -1.0  8.0
        ]
-
     d, = eigs(A6965,which=:SM,nev=2,ncv=4,tol=eps())
     @test d[1] ≈ 2.5346936860350002
     @test real(d[2]) ≈ 2.6159972444834976
@@ -105,129 +113,141 @@ end
 # Example from Quantum Information Theory
 import Base: size, issymmetric, ishermitian
 
-mutable struct CPM{T<:Base.LinAlg.BlasFloat}<:AbstractMatrix{T} # completely positive map
+mutable struct 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)
-issymmetric(Phi::CPM)=false
-ishermitian(Phi::CPM)=false
+size(Phi::CPM) = (size(Phi.kraus,1)^2,size(Phi.kraus,3)^2)
+issymmetric(Phi::CPM) = false
+ishermitian(Phi::CPM) = false
 import Base: A_mul_B!
-function A_mul_B!{T<:Base.LinAlg.BlasFloat}(rho2::StridedVector{T},Phi::CPM{T},rho::StridedVector{T})
-    rho=reshape(rho,(size(Phi.kraus,3),size(Phi.kraus,3)))
-    rho1=zeros(T,(size(Phi.kraus,1),size(Phi.kraus,1)))
-    for s=1:size(Phi.kraus,2)
-        As=view(Phi.kraus,:,s,:)
-        rho1+=As*rho*As'
+function A_mul_B!(rho2::StridedVector{T},Phi::CPM{T},rho::StridedVector{T}) where {T<:Base.LinAlg.BlasFloat}
+    rho = reshape(rho,(size(Phi.kraus,3),size(Phi.kraus,3)))
+    rho1 = zeros(T,(size(Phi.kraus,1),size(Phi.kraus,1)))
+    for s = 1:size(Phi.kraus,2)
+        As = view(Phi.kraus,:,s,:)
+        rho1 += As*rho*As'
     end
     return copy!(rho2,rho1)
 end
 
 let
     # Generate random isometry
-    (Q,R)=qr(randn(100,50))
-    Q=reshape(Q,(50,2,50))
+    (Q,R) = qr(randn(100,50))
+    Q = reshape(Q,(50,2,50))
     # Construct trace-preserving completely positive map from this
-    Phi=CPM(copy(Q))
+    Phi = CPM(copy(Q))
     (d,v,nconv,numiter,numop,resid) = eigs(Phi,nev=1,which=:LM)
     # Properties: largest eigenvalue should be 1, largest eigenvector, when reshaped as matrix
     # should be a Hermitian positive definite matrix (up to an arbitrary phase)
 
     @test d[1] ≈ 1. # largest eigenvalue should be 1.
-    v=reshape(v,(50,50)) # reshape to matrix
-    v/=trace(v) # factor out arbitrary phase
+    v = reshape(v,(50,50)) # reshape to matrix
+    v /= trace(v) # factor out arbitrary phase
     @test vecnorm(imag(v)) ≈ 0. # it should be real
-    v=real(v)
+    v = real(v)
     # @test vecnorm(v-v')/2 ≈ 0. # it should be Hermitian
     # Since this fails sometimes (numerical precision error),this test is commented out
-    v=(v+v')/2
+    v = (v+v')/2
     @test isposdef(v)
 
     # Repeat with starting vector
     (d2,v2,nconv2,numiter2,numop2,resid2) = eigs(Phi,nev=1,which=:LM,v0=reshape(v,(2500,)))
-    v2=reshape(v2,(50,50))
-    v2/=trace(v2)
-    @test numiter2<numiter
+    v2 = reshape(v2,(50,50))
+    v2 /= trace(v2)
+    @test numiter2 < numiter
     @test v ≈ v2
 
     @test eigs(speye(50), nev=10)[1] ≈ ones(10) #Issue 4246
 end
 
 @testset "real svds" begin
-    let A = sparse([1, 1, 2, 3, 4], [2, 1, 1, 3, 1], [2.0, -1.0, 6.1, 7.0, 1.5])
-        S1 = svds(A, nsv = 2)
-        S2 = svd(Array(A))
+    A = sparse([1, 1, 2, 3, 4], [2, 1, 1, 3, 1], [2.0, -1.0, 6.1, 7.0, 1.5])
+    S1 = svds(A, nsv = 2)
+    S2 = svd(Array(A))
 
-        ## singular values match:
+    ## singular values match:
+    @test S1[1][:S] ≈ S2[2][1:2]
+    @testset "singular vectors" begin
+        ## 1st left singular vector
+        s1_left = sign(S1[1][:U][3,1]) * S1[1][:U][:,1]
+        s2_left = sign(S2[1][3,1]) * S2[1][:,1]
+        @test s1_left ≈ s2_left
+
+        ## 1st right singular vector
+        s1_right = sign(S1[1][:V][3,1]) * S1[1][:V][:,1]
+        s2_right = sign(S2[3][3,1]) * S2[3][:,1]
+        @test s1_right ≈ s2_right
+    end
+    # Issue number 10329
+    # Ensure singular values from svds are in
+    # the correct order
+    @testset "singular values ordered correctly" begin
+        B = sparse(diagm([1.0, 2.0, 34.0, 5.0, 6.0]))
+        S3 = svds(B, ritzvec=false, nsv=2)
+        @test S3[1][:S] ≈ [34.0, 6.0]
+        S4 = svds(B, nsv=2)
+        @test S4[1][:S] ≈ [34.0, 6.0]
+    end
+    @testset "passing guess for Krylov vectors" begin
+        S1 = svds(A, nsv = 2, v0=rand(eltype(A),size(A,2)))
         @test S1[1][:S] ≈ S2[2][1:2]
-        @testset "singular vectors" begin
-            ## 1st left singular vector
-            s1_left = sign(S1[1][:U][3,1]) * S1[1][:U][:,1]
-            s2_left = sign(S2[1][3,1]) * S2[1][:,1]
-            @test s1_left ≈ s2_left
-
-            ## 1st right singular vector
-            s1_right = sign(S1[1][:V][3,1]) * S1[1][:V][:,1]
-            s2_right = sign(S2[3][3,1]) * S2[3][:,1]
-            @test s1_right ≈ s2_right
-        end
-        # Issue number 10329
-        # Ensure singular values from svds are in
-        # the correct order
-        @testset "singular values ordered correctly" begin
-            B = sparse(diagm([1.0, 2.0, 34.0, 5.0, 6.0]))
-            S3 = svds(B, ritzvec=false, nsv=2)
-            @test S3[1][:S] ≈ [34.0, 6.0]
-            S4 = svds(B, nsv=2)
-            @test S4[1][:S] ≈ [34.0, 6.0]
+    end
+
+    @test_throws ArgumentError svds(A,nsv=0)
+    @test_throws ArgumentError svds(A,nsv=20)
+    @test_throws DimensionMismatch svds(A,nsv=2,v0=rand(size(A,2)+1))
+
+    @testset "Orthogonal vectors with repeated singular values $i times. Issue 16608" for i in 2:3
+        rng = MersenneTwister(126) # Fragile to compute repeated values without blocking so we set the seed
+        v0  = randn(rng, 20)
+        d   = sort(rand(rng, 20), rev = true)
+        for j in 2:i
+            d[j] = d[1]
         end
-        @testset "passing guess for Krylov vectors" begin
-            S1 = svds(A, nsv = 2, u0=rand(eltype(A),size(A,1)))
-            @test S1[1][:S] ≈ S2[2][1:2]
-            S1 = svds(A, nsv = 2, v0=rand(eltype(A),size(A,2)))
-            @test S1[1][:S] ≈ S2[2][1:2]
-            S1 = svds(A, nsv = 2, u0=rand(eltype(A),size(A,1)), v0=rand(eltype(A),size(A,2)))
-            @test S1[1][:S] ≈ S2[2][1:2]
+        A = qr(randn(rng, 20, 20))[1]*Diagonal(d)*qr(randn(rng, 20, 20))[1]
+        @testset "Number of singular values: $j" for j in 2:6
+            # Default size of subspace
+            F = svds(A, nsv = j, v0 = v0)
+            @test F[1][:U]'F[1][:U] ≈ eye(j)
+            @test F[1][:V]'F[1][:V] ≈ eye(j)
+            @test F[1][:S]          ≈ d[1:j]
+            for k in 3j:2:5j
+                # Custom size of subspace
+                F = svds(A, nsv = j, ncv = k, v0 = v0)
+                @test F[1][:U]'F[1][:U] ≈ eye(j)
+                @test F[1][:V]'F[1][:V] ≈ eye(j)
+                @test F[1][:S]          ≈ d[1:j]
+            end
         end
-
-        @test_throws ArgumentError svds(A,nsv=0)
-        @test_throws ArgumentError svds(A,nsv=20)
-        @test_throws DimensionMismatch svds(A,nsv=2,u0=rand(size(A,1)+1))
-        @test_throws DimensionMismatch svds(A,nsv=2,v0=rand(size(A,2)+1))
     end
 end
 
 @testset "complex svds" begin
-    let A = sparse([1, 1, 2, 3, 4], [2, 1, 1, 3, 1], exp.(im*[2.0:2:10;]))
-        S1 = svds(A, nsv = 2)
-        S2 = svd(Array(A))
+    A = sparse([1, 1, 2, 3, 4], [2, 1, 1, 3, 1], exp.(im*[2.0:2:10;]), 5, 4)
+    S1 = svds(A, nsv = 2)
+    S2 = svd(Array(A))
 
-        ## singular values match:
-        @test S1[1][:S] ≈ S2[2][1:2]
-        @testset "singular vectors" begin
-            ## left singular vectors
-            s1_left = abs.(S1[1][:U][:,1:2])
-            s2_left = abs.(S2[1][:,1:2])
-            @test s1_left ≈ s2_left
-
-            ## right singular vectors
-            s1_right = abs.(S1[1][:V][:,1:2])
-            s2_right = abs.(S2[3][:,1:2])
-            @test s1_right ≈ s2_right
-        end
-        @testset "passing guess for Krylov vectors" begin
-            S1 = svds(A, nsv = 2, u0=rand(eltype(A),size(A,1)))
-            @test S1[1][:S] ≈ S2[2][1:2]
-            S1 = svds(A, nsv = 2, v0=rand(eltype(A),size(A,2)))
-            @test S1[1][:S] ≈ S2[2][1:2]
-            S1 = svds(A, nsv = 2, u0=rand(eltype(A),size(A,1)), v0=rand(eltype(A),size(A,2)))
-            @test S1[1][:S] ≈ S2[2][1:2]
-        end
+    ## singular values match:
+    @test S1[1][:S] ≈ S2[2][1:2]
+    @testset "singular vectors" begin
+        ## left singular vectors
+        s1_left = abs.(S1[1][:U][:,1:2])
+        s2_left = abs.(S2[1][:,1:2])
+        @test s1_left ≈ s2_left
 
-        @test_throws ArgumentError svds(A,nsv=0)
-        @test_throws ArgumentError svds(A,nsv=20)
-        @test_throws DimensionMismatch svds(A,nsv=2,u0=complex(rand(size(A,1)+1)))
-        @test_throws DimensionMismatch svds(A,nsv=2,v0=complex(rand(size(A,2)+1)))
+        ## right singular vectors
+        s1_right = abs.(S1[1][:V][:,1:2])
+        s2_right = abs.(S2[3][:,1:2])
+        @test s1_right ≈ s2_right
+    end
+    @testset "passing guess for Krylov vectors" begin
+        S1 = svds(A, nsv = 2, v0=rand(eltype(A),size(A,2)))
+        @test S1[1][:S] ≈ S2[2][1:2]
     end
+
+    @test_throws ArgumentError svds(A,nsv=0)
+    @test_throws ArgumentError svds(A,nsv=20)
+    @test_throws DimensionMismatch svds(A,nsv=2,v0=complex(rand(size(A,2)+1)))
 end
 
 @testset "promotion" begin
@@ -238,11 +258,3 @@ end
     @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)))
 end
-
-# Symmetric generalized with singular B
-let n = 10
-    k = 3
-    A = randn(n,n); A = A'A
-    B = randn(n,k);  B = B*B'
-    @test sort(eigs(A, B, nev = k, sigma = 1.0)[1]) ≈ sort(eigvals(A, B)[1:k])
-end
diff --git a/test/linalg/bidiag.jl b/test/linalg/bidiag.jl
index 5d350dacb1e7f2..d7b95a00dd9f69 100644
--- a/test/linalg/bidiag.jl
+++ b/test/linalg/bidiag.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base.Test
 import Base.LinAlg: BlasReal, BlasFloat
@@ -24,80 +24,102 @@ srand(1)
     end
 
     @testset "Constructors" begin
-        @test Bidiagonal(dv,ev,'U') == Bidiagonal(dv,ev,true)
-        @test_throws ArgumentError Bidiagonal(dv,ev,'R')
-        @test_throws DimensionMismatch Bidiagonal(dv,ones(elty,n),true)
-        @test_throws ArgumentError Bidiagonal(dv,ev)
+        @test Bidiagonal(dv,ev,:U) != Bidiagonal(dv,ev,:L)
+        @test_throws ArgumentError Bidiagonal(dv,ev,:R)
+        @test_throws DimensionMismatch Bidiagonal(dv,ones(elty,n),:U)
+        @test_throws MethodError Bidiagonal(dv,ev)
     end
 
-    BD = Bidiagonal(dv, ev, true)
     @testset "getindex, setindex!, size, and similar" begin
-        @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})
+        ubd = Bidiagonal(dv, ev, :U)
+        lbd = Bidiagonal(dv, ev, :L)
+        # bidiagonal getindex / upper & lower
+        @test_throws BoundsError ubd[n + 1, 1]
+        @test_throws BoundsError ubd[1, n + 1]
+        @test ubd[2, 2] == dv[2]
+        # bidiagonal getindex / upper
+        @test ubd[2, 3] == ev[2]
+        @test iszero(ubd[3, 2])
+        # bidiagonal getindex / lower
+        @test lbd[3, 2] == ev[2]
+        @test iszero(lbd[2, 3])
+        # bidiagonal setindex! / upper
+        cubd = copy(ubd)
+        @test_throws ArgumentError ubd[2, 1] = 1
+        @test_throws ArgumentError ubd[3, 1] = 1
+        @test (cubd[2, 1] = 0; cubd == ubd)
+        @test ((cubd[1, 2] = 10) == 10; cubd[1, 2] == 10)
+        # bidiagonal setindex! / lower
+        clbd = copy(lbd)
+        @test_throws ArgumentError lbd[1, 2] = 1
+        @test_throws ArgumentError lbd[1, 3] = 1
+        @test (clbd[1, 2] = 0; clbd == lbd)
+        @test ((clbd[2, 1] = 10) == 10; clbd[2, 1] == 10)
+        # bidiagonal setindex! / upper & lower
+        @test_throws BoundsError ubd[n + 1, 1] = 1
+        @test_throws BoundsError ubd[1, n + 1] = 1
+        @test ((cubd[2, 2] = 10) == 10; cubd[2, 2] == 10)
+        # bidiagonal size
+        @test_throws ArgumentError size(ubd, 0)
+        @test size(ubd, 1) == size(ubd, 2) == n
+        @test size(ubd, 3) == 1
+        # bidiagonal similar
+        @test isa(similar(ubd), Bidiagonal{elty})
+        @test isa(similar(ubd, Int), Bidiagonal{Int})
+        @test isa(similar(ubd, Int, (3, 2)), Matrix{Int})
     end
 
     @testset "show" begin
+        BD = Bidiagonal(dv, ev, :U)
         dstring = sprint(Base.print_matrix,BD.dv')
         estring = sprint(Base.print_matrix,BD.ev')
         @test sprint(show,BD) == "$(summary(BD)):\n diag:$dstring\n super:$estring"
-        BD = Bidiagonal(dv,ev,false)
+        BD = Bidiagonal(dv,ev,:L)
         @test sprint(show,BD) == "$(summary(BD)):\n diag:$dstring\n sub:$estring"
     end
 
-    @testset for isupper in (true, false)
-        T = Bidiagonal(dv, ev, isupper)
+    @testset for uplo in (:U, :L)
+        T = Bidiagonal(dv, ev, uplo)
 
         @testset "Constructor and basic properties" begin
             @test size(T, 1) == size(T, 2) == n
             @test size(T) == (n, n)
-            @test Array(T) == diagm(dv) + diagm(ev, isupper?1:-1)
-            @test Bidiagonal(Array(T), isupper) == T
+            @test Array(T) == diagm(dv) + diagm(ev, uplo == :U ? 1 : -1)
+            @test Bidiagonal(Array(T), uplo) == T
             @test big.(T) == T
-            @test Array(abs.(T)) == abs.(diagm(dv)) + abs.(diagm(ev, isupper?1:-1))
-            @test Array(real(T)) == real(diagm(dv)) + real(diagm(ev, isupper?1:-1))
-            @test Array(imag(T)) == imag(diagm(dv)) + imag(diagm(ev, isupper?1:-1))
+            @test Array(abs.(T)) == abs.(diagm(dv)) + abs.(diagm(ev, uplo == :U ? 1 : -1))
+            @test Array(real(T)) == real(diagm(dv)) + real(diagm(ev, uplo == :U ? 1 : -1))
+            @test Array(imag(T)) == imag(diagm(dv)) + imag(diagm(ev, uplo == :U ? 1 : -1))
         end
-        z = zeros(elty, n)
 
         @testset for func in (conj, transpose, ctranspose)
             @test func(func(T)) == T
         end
 
         @testset "triu and tril" begin
-            @test istril(Bidiagonal(dv,ev,'L'))
-            @test !istril(Bidiagonal(dv,ev,'U'))
-            @test tril!(Bidiagonal(dv,ev,'U'),-1) == Bidiagonal(zeros(dv),zeros(ev),'U')
-            @test tril!(Bidiagonal(dv,ev,'L'),-1) == Bidiagonal(zeros(dv),ev,'L')
-            @test tril!(Bidiagonal(dv,ev,'U'),-2) == Bidiagonal(zeros(dv),zeros(ev),'U')
-            @test tril!(Bidiagonal(dv,ev,'L'),-2) == Bidiagonal(zeros(dv),zeros(ev),'L')
-            @test tril!(Bidiagonal(dv,ev,'U'),1)  == Bidiagonal(dv,ev,'U')
-            @test tril!(Bidiagonal(dv,ev,'L'),1)  == Bidiagonal(dv,ev,'L')
-            @test tril!(Bidiagonal(dv,ev,'U'))    == Bidiagonal(dv,zeros(ev),'U')
-            @test tril!(Bidiagonal(dv,ev,'L'))    == Bidiagonal(dv,ev,'L')
-            @test_throws ArgumentError tril!(Bidiagonal(dv,ev,'U'),n+1)
+            @test istril(Bidiagonal(dv,ev,:L))
+            @test !istril(Bidiagonal(dv,ev,:U))
+            @test tril!(Bidiagonal(dv,ev,:U),-1) == Bidiagonal(zeros(dv),zeros(ev),:U)
+            @test tril!(Bidiagonal(dv,ev,:L),-1) == Bidiagonal(zeros(dv),ev,:L)
+            @test tril!(Bidiagonal(dv,ev,:U),-2) == Bidiagonal(zeros(dv),zeros(ev),:U)
+            @test tril!(Bidiagonal(dv,ev,:L),-2) == Bidiagonal(zeros(dv),zeros(ev),:L)
+            @test tril!(Bidiagonal(dv,ev,:U),1)  == Bidiagonal(dv,ev,:U)
+            @test tril!(Bidiagonal(dv,ev,:L),1)  == Bidiagonal(dv,ev,:L)
+            @test tril!(Bidiagonal(dv,ev,:U))    == Bidiagonal(dv,zeros(ev),:U)
+            @test tril!(Bidiagonal(dv,ev,:L))    == Bidiagonal(dv,ev,:L)
+            @test_throws ArgumentError tril!(Bidiagonal(dv,ev,:U),n+1)
 
-            @test istriu(Bidiagonal(dv,ev,'U'))
-            @test !istriu(Bidiagonal(dv,ev,'L'))
-            @test triu!(Bidiagonal(dv,ev,'L'),1)  == Bidiagonal(zeros(dv),zeros(ev),'L')
-            @test triu!(Bidiagonal(dv,ev,'U'),1)  == Bidiagonal(zeros(dv),ev,'U')
-            @test triu!(Bidiagonal(dv,ev,'U'),2)  == Bidiagonal(zeros(dv),zeros(ev),'U')
-            @test triu!(Bidiagonal(dv,ev,'L'),2)  == Bidiagonal(zeros(dv),zeros(ev),'L')
-            @test triu!(Bidiagonal(dv,ev,'U'),-1) == Bidiagonal(dv,ev,'U')
-            @test triu!(Bidiagonal(dv,ev,'L'),-1) == Bidiagonal(dv,ev,'L')
-            @test triu!(Bidiagonal(dv,ev,'L'))    == Bidiagonal(dv,zeros(ev),'L')
-            @test triu!(Bidiagonal(dv,ev,'U'))    == Bidiagonal(dv,ev,'U')
-            @test_throws ArgumentError triu!(Bidiagonal(dv,ev,'U'),n+1)
+            @test istriu(Bidiagonal(dv,ev,:U))
+            @test !istriu(Bidiagonal(dv,ev,:L))
+            @test triu!(Bidiagonal(dv,ev,:L),1)  == Bidiagonal(zeros(dv),zeros(ev),:L)
+            @test triu!(Bidiagonal(dv,ev,:U),1)  == Bidiagonal(zeros(dv),ev,:U)
+            @test triu!(Bidiagonal(dv,ev,:U),2)  == Bidiagonal(zeros(dv),zeros(ev),:U)
+            @test triu!(Bidiagonal(dv,ev,:L),2)  == Bidiagonal(zeros(dv),zeros(ev),:L)
+            @test triu!(Bidiagonal(dv,ev,:U),-1) == Bidiagonal(dv,ev,:U)
+            @test triu!(Bidiagonal(dv,ev,:L),-1) == Bidiagonal(dv,ev,:L)
+            @test triu!(Bidiagonal(dv,ev,:L))    == Bidiagonal(dv,zeros(ev),:L)
+            @test triu!(Bidiagonal(dv,ev,:U))    == Bidiagonal(dv,ev,:U)
+            @test_throws ArgumentError triu!(Bidiagonal(dv,ev,:U),n+1)
         end
 
         Tfull = Array(T)
@@ -161,27 +183,17 @@ srand(1)
                         @test T/b' ≈ Tfull/b'
                     end
                 end
+                # test DimensionMismatch for RowVectors
+                @test_throws DimensionMismatch T \ b'
+                @test_throws DimensionMismatch T.' \ b'
+                @test_throws DimensionMismatch T' \ b'
             end
         end
 
-        @testset "Round,float,trunc,ceil" begin
-            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)
-                @test isa(ceil.(Int,T), Bidiagonal)
-                @test floor.(T) == Bidiagonal(floor.(T.dv), floor.(T.ev), T.isupper)
-                @test isa(floor.(T), Bidiagonal)
-                @test trunc.(T) == Bidiagonal(trunc.(T.dv), trunc.(T.ev), T.isupper)
-                @test isa(trunc.(T), Bidiagonal)
-                @test round.(T) == Bidiagonal(round.(T.dv), round.(T.ev), T.isupper)
-                @test isa(round.(T), Bidiagonal)
-                @test ceil.(T) == Bidiagonal(ceil.(T.dv), ceil.(T.ev), T.isupper)
-                @test isa(ceil.(T), Bidiagonal)
+        if elty <: BlasReal
+            @testset "$f" for f in (floor, trunc, round, ceil)
+                @test (f.(Int, T))::Bidiagonal == Bidiagonal(f.(Int, T.dv), f.(Int, T.ev), T.uplo)
+                @test (f.(T))::Bidiagonal == Bidiagonal(f.(T.dv), f.(T.ev), T.uplo)
             end
         end
 
@@ -194,9 +206,9 @@ srand(1)
             if relty <: AbstractFloat
                 d1, v1 = eig(T)
                 d2, v2 = eig(map(elty<:Complex ? Complex128 : Float64,Tfull))
-                @test (isupper ? d1 : reverse(d1)) ≈ d2
+                @test (uplo == :U ? d1 : reverse(d1)) ≈ d2
                 if elty <: Real
-                    Test.test_approx_eq_modphase(v1, isupper ? v2 : v2[:,n:-1:1])
+                    Test.test_approx_eq_modphase(v1, uplo == :U ? v2 : v2[:,n:-1:1])
                 end
             end
         end
@@ -219,38 +231,44 @@ srand(1)
         end
 
         @testset "Binary operations" begin
-            @test -T == Bidiagonal(-T.dv,-T.ev,T.isupper)
-            @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)
-            @testset for isupper2 in (true, false)
+            @test -T == Bidiagonal(-T.dv,-T.ev,T.uplo)
+            @test convert(elty,-1.0) * T == Bidiagonal(-T.dv,-T.ev,T.uplo)
+            @test T * convert(elty,-1.0) == Bidiagonal(-T.dv,-T.ev,T.uplo)
+            @testset for uplo2 in (:U, :L)
                 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)
+                T2 = Bidiagonal(dv, ev, uplo2)
                 Tfull2 = Array(T2)
                 for op in (+, -, *)
                     @test Array(op(T, T2)) ≈ op(Tfull, Tfull2)
                 end
             end
+            # test pass-through of A_mul_B! for SymTridiagonal*Bidiagonal
+            TriSym = SymTridiagonal(T.dv, T.ev)
+            @test Array(TriSym*T) ≈ Array(TriSym)*Array(T)
+            # test pass-through of A_mul_B! for AbstractTriangular*Bidiagonal
+            Tri = UpperTriangular(diagm(T.ev, 1))
+            @test Array(Tri*T) ≈ Array(Tri)*Array(T)
         end
 
         @test inv(T)*Tfull ≈ eye(elty,n)
     end
-
+    BD = Bidiagonal(dv, ev, :U)
     @test Matrix{Complex{Float64}}(BD) == BD
 
 end
 
 # Issue 10742 and similar
-let A = Bidiagonal([1,2,3], [0,0], true)
+let A = Bidiagonal([1,2,3], [0,0], :U)
     @test istril(A)
     @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 Bidiagonal(1:3, 1:2, :U) == [1 1 0; 0 2 2; 0 0 3]
 
 @testset "promote_rule" begin
-    A = Bidiagonal(ones(Float32,10),ones(Float32,9),true)
+    A = Bidiagonal(ones(Float32,10),ones(Float32,9),:U)
     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}
@@ -264,8 +282,8 @@ import Base.LinAlg: fillslots!, UnitLowerTriangular
         let # fillslots!
             A = Tridiagonal(randn(2), randn(3), randn(2))
             @test fillslots!(A, 3) == Tridiagonal([3, 3.], [3, 3, 3.], [3, 3.])
-            B = Bidiagonal(randn(3), randn(2), true)
-            @test fillslots!(B, 2) == Bidiagonal([2.,2,2], [2,2.], true)
+            B = Bidiagonal(randn(3), randn(2), :U)
+            @test fillslots!(B, 2) == Bidiagonal([2.,2,2], [2,2.], :U)
             S = SymTridiagonal(randn(3), randn(2))
             @test fillslots!(S, 1) == SymTridiagonal([1,1,1.], [1,1.])
             Ult = UnitLowerTriangular(randn(3,3))
@@ -273,7 +291,7 @@ import Base.LinAlg: fillslots!, UnitLowerTriangular
         end
         let # fill!(exotic, 0)
             exotic_arrays = Any[Tridiagonal(randn(3), randn(4), randn(3)),
-            Bidiagonal(randn(3), randn(2), rand(Bool)),
+            Bidiagonal(randn(3), randn(2), rand([:U,:L])),
             SymTridiagonal(randn(3), randn(2)),
             sparse(randn(3,4)),
             Diagonal(randn(5)),
@@ -290,12 +308,12 @@ import Base.LinAlg: fillslots!, UnitLowerTriangular
         end
         let # fill!(small, x)
             val = randn()
-            b = Bidiagonal(randn(1,1), true)
+            b = Bidiagonal(randn(1,1), :U)
             st = SymTridiagonal(randn(1,1))
             for x in (b, st)
                 @test Array(fill!(x, val)) == fill!(Array(x), val)
             end
-            b = Bidiagonal(randn(2,2), true)
+            b = Bidiagonal(randn(2,2), :U)
             st = SymTridiagonal(randn(3), randn(2))
             t = Tridiagonal(randn(3,3))
             for x in (b, t, st)
diff --git a/test/blas.jl b/test/linalg/blas.jl
similarity index 97%
rename from test/blas.jl
rename to test/linalg/blas.jl
index 5d07b893098905..56ebdde4ab6ff4 100644
--- a/test/blas.jl
+++ b/test/linalg/blas.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 import Base.LinAlg, Base.LinAlg.BlasReal, Base.LinAlg.BlasComplex
 
@@ -116,15 +116,16 @@ srand(100)
 
         @testset "trsv" begin
             A = triu(rand(elty,n,n))
-            x = rand(elty,n)
-            @test A\x ≈ BLAS.trsv('U','N','N',A,x)
-            @test_throws DimensionMismatch BLAS.trsv('U','N','N',A,ones(elty,n+1))
+            @testset "Vector and SubVector" for x in (rand(elty, n), view(rand(elty,2n),1:2:2n))
+                @test A\x ≈ BLAS.trsv('U','N','N',A,x)
+                @test_throws DimensionMismatch BLAS.trsv('U','N','N',A,ones(elty,n+1))
+            end
         end
-        @testset "ger, her, syr" begin
+        @testset "ger, her, syr" for x in (rand(elty, n), view(rand(elty,2n), 1:2:2n)),
+            y in (rand(elty,n), view(rand(elty,3n), 1:3:3n))
+
             A = rand(elty,n,n)
             α = rand(elty)
-            x = rand(elty,n)
-            y = rand(elty,n)
 
             @test BLAS.ger!(α,x,y,copy(A)) ≈ A + α*x*y'
             @test_throws DimensionMismatch BLAS.ger!(α,ones(elty,n+1),y,copy(A))
diff --git a/test/linalg/bunchkaufman.jl b/test/linalg/bunchkaufman.jl
index 9fd6878dcb43f5..d6879e68e55433 100644
--- a/test/linalg/bunchkaufman.jl
+++ b/test/linalg/bunchkaufman.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base.Test
 
@@ -23,21 +23,27 @@ bimg  = randn(n,2)/2
     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)
     @testset for atype in ("Array", "SubArray")
-        asym = a'+a                  # symmetric indefinite
-        apd  = a'*a                 # symmetric positive-definite
+        asym = a.'+ a                  # symmetric indefinite
+        aher = a' + a                  # Hermitian indefinite
+        apd  = a' * a                  # Positive-definite
         if atype == "Array"
-            a = a
+            a  = a
             a2 = a2
         else
-            a = view(a, 1:n, 1:n)
-            a2 = view(a2, 1:n, 1:n)
-            asym = view(asym, 1:n, 1:n)
-            apd = view(apd, 1:n, 1:n)
+            a    = view(a   , 1:n, 1:n)
+            a2   = view(a2  , 1:n, 1:n)
+            aher = view(aher, 1:n, 1:n)
+            apd  = view(apd , 1:n, 1:n)
         end
         ε = εa = eps(abs(float(one(eltya))))
 
         @testset 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)
+
+            # check that factorize gives a Bunch-Kaufman
+            @test isa(factorize(asym), LinAlg.BunchKaufman)
+            @test isa(factorize(aher), LinAlg.BunchKaufman)
+
             @testset for btype in ("Array", "SubArray")
                 if btype == "Array"
                     b = b
@@ -48,34 +54,47 @@ bimg  = randn(n,2)/2
                 εb = eps(abs(float(one(eltyb))))
                 ε = max(εa,εb)
 
-                @testset "(Automatic) Bunch-Kaufman factor of indefinite matrix" begin
-                    bc1 = factorize(asym)
+                @testset "$uplo Bunch-Kaufman factor of indefinite matrix" for uplo in (:L, :U)
+                    bc1 = bkfact(Hermitian(aher, uplo))
+                    @test LinAlg.issuccess(bc1)
                     @test logabsdet(bc1)[1] ≈ log(abs(det(bc1)))
                     if eltya <: Real
                         @test logabsdet(bc1)[2] == sign(det(bc1))
                     else
                         @test logabsdet(bc1)[2] ≈ sign(det(bc1))
                     end
-                    @test inv(bc1)*asym ≈ eye(n)
-                    @test asym*(bc1\b) ≈ b atol=1000ε
+                    @test inv(bc1)*aher ≈ eye(n)
+                    @test aher*(bc1\b) ≈ b atol=1000ε
                     @testset for rook in (false, true)
-                        @test inv(bkfact(a.'+a, :U, true, rook))*(a.'+a) ≈ eye(n)
+                        @test inv(bkfact(Symmetric(a.' + a, uplo), 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)
+                        @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
+                    # Test extraction of factors
+                    # syconvf_rook just added to LAPACK 3.7.0. Test when we distribute LAPACK 3.7.0
+                    @test bc1[uplo]*bc1[:D]*bc1[uplo]' ≈ aher[bc1[:p], bc1[:p]]
+                    @test bc1[uplo]*bc1[:D]*bc1[uplo]' ≈ bc1[:P]*aher*bc1[:P]'
+                    if eltya <: Complex
+                        bc1 = bkfact(Symmetric(asym, uplo))
+                        @test bc1[uplo]*bc1[:D]*bc1[uplo].' ≈ asym[bc1[:p], bc1[:p]]
+                        @test bc1[uplo]*bc1[:D]*bc1[uplo].' ≈ bc1[:P]*asym*bc1[:P]'
+                    end
+                    @test_throws KeyError bc1[:Z]
+                    @test_throws ArgumentError uplo == :L ? bc1[:U] : bc1[:L]
                 end
 
-                @testset "Bunch-Kaufman factors of a pos-def matrix" begin
-                    @testset for rook in (false, true)
-                        bc2 = bkfact(apd, :U, issymmetric(apd), rook)
+                @testset "$uplo Bunch-Kaufman factors of a pos-def matrix" for uplo in (:U, :L)
+                    @testset "rook pivoting: $rook" for rook in (false, true)
+                        bc2 = bkfact(Hermitian(apd, uplo), rook)
+                        @test LinAlg.issuccess(bc2)
                         @test logdet(bc2) ≈ log(det(bc2))
                         @test logabsdet(bc2)[1] ≈ log(abs(det(bc2)))
                         @test logabsdet(bc2)[2] == sign(det(bc2))
-                        @test inv(bc2)*apd ≈ eye(n)
+                        @test inv(bc2)*apd ≈ eye(eltyb, n)
                         @test apd*(bc2\b) ≈ b atol=150000ε
                         @test ishermitian(bc2) == !issymmetric(bc2)
                     end
@@ -102,19 +121,20 @@ end
                 end
 
                 @testset for rook in (false, true)
-                    F = bkfact(As, :U, issymmetric(As), rook)
-                    @test det(F) == 0
-                    @test_throws LinAlg.SingularException inv(F)
-                    @test_throws LinAlg.SingularException F \ ones(size(As, 1))
+                    @testset for uplo in (:L, :U)
+                        F = bkfact(issymmetric(As) ? Symmetric(As, uplo) : Hermitian(As, uplo), rook)
+                        @test !LinAlg.issuccess(F)
+                        @test det(F) == 0
+                        @test_throws LinAlg.SingularException inv(F)
+                        @test_throws LinAlg.SingularException F \ ones(size(As, 1))
+                    end
                 end
             end
         end
     end
 end
 
-
-# test example due to @timholy in PR 15354
-let
+@testset "test example due to @timholy in PR 15354" begin
     A = rand(6,5); A = complex(A'*A) # to avoid calling the real-lhs-complex-rhs method
     F = cholfact(A);
     v6 = rand(Complex128, 6)
diff --git a/test/linalg/cholesky.jl b/test/linalg/cholesky.jl
index 795a2ad00f2b0e..3174541a43d460 100644
--- a/test/linalg/cholesky.jl
+++ b/test/linalg/cholesky.jl
@@ -1,161 +1,163 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
-
-debug = false
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base.Test
 
-using Base.LinAlg: BlasComplex, BlasFloat, BlasReal, QRPivoted
+using Base.LinAlg: BlasComplex, BlasFloat, BlasReal, QRPivoted, PosDefException
 
-n = 10
+@testset "core functionality" begin
+    n = 10
 
-# Split n into 2 parts for tests needing two matrices
-n1 = div(n, 2)
-n2 = 2*n1
+    # Split n into 2 parts for tests needing two matrices
+    n1 = div(n, 2)
+    n2 = 2*n1
 
-srand(1234321)
+    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
+    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, BigFloat, Int)
-    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)
-    apd  = a'*a                  # symmetric positive-definite
+    for eltya in (Float32, Float64, Complex64, Complex128, BigFloat, Int)
+        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)
 
-    apds  = Symmetric(apd)
-    apdsL = Symmetric(apd, :L)
-    apdh  = Hermitian(apd)
-    apdhL = Hermitian(apd, :L)
-    ε = εa = eps(abs(float(one(eltya))))
+        ε = εa = eps(abs(float(one(eltya))))
 
-    @inferred cholfact(apd)
-    @inferred chol(apd)
-    capd  = factorize(apd)
-    r     = capd[:U]
-    κ     = cond(apd, 1) #condition number
+        # Test of symmetric pos. def. strided matrix
+        apd  = a'*a
+        @inferred cholfact(apd)
+        @inferred chol(apd)
+        capd  = factorize(apd)
+        r     = capd[:U]
+        κ     = cond(apd, 1) #condition number
 
-    #getindex
-    @test_throws KeyError capd[:Z]
+        #getindex
+        @test_throws KeyError capd[:Z]
 
-    #Test error bound on reconstruction of matrix: LAWNS 14, Lemma 2.1
+        #Test error bound on reconstruction of matrix: LAWNS 14, Lemma 2.1
 
-    #these tests were failing on 64-bit linux when inside the inner loop
-    #for eltya = Complex64 and eltyb = Int. The E[i,j] had NaN32 elements
-    #but only with srand(1234321) set before the loops.
-    E = abs.(apd - r'*r)
-    for i=1:n, j=1:n
-        @test E[i,j] <= (n+1)ε/(1-(n+1)ε)*real(sqrt(apd[i,i]*apd[j,j]))
-    end
-    E = abs.(apd - full(capd))
-    for i=1:n, j=1:n
-        @test E[i,j] <= (n+1)ε/(1-(n+1)ε)*real(sqrt(apd[i,i]*apd[j,j]))
-    end
-    @test apd*inv(capd) ≈ eye(n)
-    @test abs((det(capd) - det(apd))/det(capd)) <= ε*κ*n # Ad hoc, but statistically verified, revisit
-    @test @inferred(logdet(capd)) ≈ log(det(capd)) # logdet is less likely to overflow
-
-    apos = apd[1,1]            # test chol(x::Number), needs x>0
-    @test all(x -> x ≈ √apos, cholfact(apos).factors)
-    @test_throws ArgumentError chol(-one(eltya))
-
-    if eltya <: Real
-        capds = cholfact(apds)
-        @test inv(capds)*apds ≈ eye(n)
-        @test abs((det(capds) - det(apd))/det(capds)) <= ε*κ*n
-        if eltya <: BlasReal
-            capds = cholfact!(copy(apds))
+        #these tests were failing on 64-bit linux when inside the inner loop
+        #for eltya = Complex64 and eltyb = Int. The E[i,j] had NaN32 elements
+        #but only with srand(1234321) set before the loops.
+        E = abs.(apd - r'*r)
+        for i=1:n, j=1:n
+            @test E[i,j] <= (n+1)ε/(1-(n+1)ε)*real(sqrt(apd[i,i]*apd[j,j]))
+        end
+        E = abs.(apd - full(capd))
+        for i=1:n, j=1:n
+            @test E[i,j] <= (n+1)ε/(1-(n+1)ε)*real(sqrt(apd[i,i]*apd[j,j]))
+        end
+        @test apd*inv(capd) ≈ eye(n)
+        @test LinAlg.issuccess(capd)
+        @test abs((det(capd) - det(apd))/det(capd)) <= ε*κ*n # Ad hoc, but statistically verified, revisit
+        @test @inferred(logdet(capd)) ≈ log(det(capd)) # logdet is less likely to overflow
+
+        apos = apd[1,1]            # test chol(x::Number), needs x>0
+        @test all(x -> x ≈ √apos, cholfact(apos).factors)
+        @test_throws PosDefException chol(-one(eltya))
+
+        # Test cholfact with Symmetric/Hermitian upper/lower
+        apds  = Symmetric(apd)
+        apdsL = Symmetric(apd, :L)
+        apdh  = Hermitian(apd)
+        apdhL = Hermitian(apd, :L)
+        if eltya <: Real
+            capds = cholfact(apds)
             @test inv(capds)*apds ≈ eye(n)
             @test abs((det(capds) - det(apd))/det(capds)) <= ε*κ*n
+            @test logdet(capds) ≈ log(det(capds))
+            @test isposdef(capds)
+            if eltya <: BlasReal
+                capds = cholfact!(copy(apds))
+                @test inv(capds)*apds ≈ eye(n)
+                @test abs((det(capds) - det(apd))/det(capds)) <= ε*κ*n
+                @test logdet(capds) ≈ log(det(capds))
+                @test isposdef(capds)
+            end
+            ulstring = sprint(show,capds[:UL])
+            @test sprint(show,capds) == "$(typeof(capds)) with factor:\n$ulstring\nsuccessful: true"
+        else
+            capdh = cholfact(apdh)
+            @test inv(capdh)*apdh ≈ eye(n)
+            @test abs((det(capdh) - det(apd))/det(capdh)) <= ε*κ*n
+            @test logdet(capdh) ≈ log(det(capdh))
+            @test isposdef(capdh)
+            capdh = cholfact!(copy(apdh))
+            @test inv(capdh)*apdh ≈ eye(n)
+            @test abs((det(capdh) - det(apd))/det(capdh)) <= ε*κ*n
+            @test logdet(capdh) ≈ log(det(capdh))
+            @test isposdef(capdh)
+            capdh = cholfact!(copy(apd))
+            @test inv(capdh)*apdh ≈ eye(n)
+            @test abs((det(capdh) - det(apd))/det(capdh)) <= ε*κ*n
+            @test logdet(capdh) ≈ log(det(capdh))
+            @test isposdef(capdh)
+            ulstring = sprint(show,capdh[:UL])
+            @test sprint(show,capdh) == "$(typeof(capdh)) with factor:\n$ulstring\nsuccessful: true"
         end
-    else
-        capdh = cholfact(apdh)
-        @test inv(capdh)*apdh ≈ eye(n)
-        @test abs((det(capdh) - det(apd))/det(capdh)) <= ε*κ*n
-        capdh = cholfact!(copy(apdh))
-        @test inv(capdh)*apdh ≈ eye(n)
-        @test abs((det(capdh) - det(apd))/det(capdh)) <= ε*κ*n
-        capdh = cholfact!(copy(apd))
-        @test inv(capdh)*apdh ≈ eye(n)
-        @test abs((det(capdh) - det(apd))/det(capdh)) <= ε*κ*n
-        capdh = cholfact!(copy(apd), :L)
-        @test inv(capdh)*apdh ≈ eye(n)
-        @test abs((det(capdh) - det(apd))/det(capdh)) <= ε*κ*n
-    end
 
-    # test chol of 2x2 Strang matrix
-    S = convert(AbstractMatrix{eltya},full(SymTridiagonal([2,2],[-1])))
-    U = Bidiagonal([2,sqrt(eltya(3))],[-1],true) / sqrt(eltya(2))
-    @test full(chol(S)) ≈ full(U)
-
-    #lower Cholesky factor
-    lapd = cholfact(apd, :L)
-    @test full(lapd) ≈ apd
-    l = lapd[:L]
-    @test l*l' ≈ apd
-    @test triu(capd.factors) ≈ lapd[:U]
-    @test tril(lapd.factors) ≈ capd[:L]
-    if eltya <: Real
-        capds = cholfact(apds)
-        lapds = cholfact(apdsL)
-        cl    = chol(apdsL)
-        ls = lapds[:L]
-        @test ls*ls' ≈ apd
-        @test triu(capds.factors) ≈ lapds[:U]
-        @test tril(lapds.factors) ≈ capds[:L]
-        @test istriu(cl)
-        @test cl'cl ≈ apds
-        @test cl'cl ≈ apdsL
-    else
-        capdh = cholfact(apdh)
-        lapdh = cholfact(apdhL)
-        cl    = chol(apdhL)
-        ls = lapdh[:L]
-        @test ls*ls' ≈ apd
-        @test triu(capdh.factors) ≈ lapdh[:U]
-        @test tril(lapdh.factors) ≈ capdh[:L]
-        @test istriu(cl)
-        @test cl'cl ≈ apdh
-        @test cl'cl ≈ apdhL
-    end
+        # test chol of 2x2 Strang matrix
+        S = convert(AbstractMatrix{eltya},full(SymTridiagonal([2,2],[-1])))
+        U = Bidiagonal([2,sqrt(eltya(3))],[-1],:U) / sqrt(eltya(2))
+        @test full(chol(S)) ≈ full(U)
+
+        # test extraction of factor and re-creating original matrix
+        if eltya <: Real
+            capds = cholfact(apds)
+            lapds = cholfact(apdsL)
+            cl    = chol(apdsL)
+            ls = lapds[:L]
+            @test full(capds) ≈ full(lapds) ≈ apd
+            @test ls*ls' ≈ apd
+            @test triu(capds.factors) ≈ lapds[:U]
+            @test tril(lapds.factors) ≈ capds[:L]
+            @test istriu(cl)
+            @test cl'cl ≈ apds
+            @test cl'cl ≈ apdsL
+        else
+            capdh = cholfact(apdh)
+            lapdh = cholfact(apdhL)
+            cl    = chol(apdhL)
+            ls = lapdh[:L]
+            @test full(capdh) ≈ full(lapdh) ≈ apd
+            @test ls*ls' ≈ apd
+            @test triu(capdh.factors) ≈ lapdh[:U]
+            @test tril(lapdh.factors) ≈ capdh[:L]
+            @test istriu(cl)
+            @test cl'cl ≈ apdh
+            @test cl'cl ≈ apdhL
+        end
 
-    #pivoted upper Cholesky
-    if eltya != BigFloat
-        cz = cholfact(zeros(eltya,n,n), :U, Val{true})
-        @test_throws Base.LinAlg.RankDeficientException Base.LinAlg.chkfullrank(cz)
-        cpapd = cholfact(apd, :U, Val{true})
-        @test rank(cpapd) == n
-        @test all(diff(diag(real(cpapd.factors))).<=0.) # diagonal should be non-increasing
-        if isreal(apd)
-            @test apd*inv(cpapd) ≈ eye(n)
+        #pivoted upper Cholesky
+        if eltya != BigFloat
+            cz = cholfact(Hermitian(zeros(eltya,n,n)), Val(true))
+            @test_throws Base.LinAlg.RankDeficientException Base.LinAlg.chkfullrank(cz)
+            cpapd = cholfact(apdh, Val(true))
+            @test rank(cpapd) == n
+            @test all(diff(diag(real(cpapd.factors))).<=0.) # diagonal should be non-increasing
+            if isreal(apd)
+                @test apd*inv(cpapd) ≈ eye(n)
+            end
+            @test full(cpapd) ≈ apd
+            #getindex
+            @test_throws KeyError cpapd[:Z]
+
+            @test size(cpapd) == size(apd)
+            @test full(copy(cpapd)) ≈ apd
+            @test det(cpapd) ≈ det(apd)
+            @test logdet(cpapd) ≈ logdet(apd)
+            @test cpapd[:P]*cpapd[:L]*cpapd[:U]*cpapd[:P]' ≈ apd
         end
-        @test full(cpapd) ≈ apd
-        #getindex
-        @test_throws KeyError cpapd[:Z]
 
-        @test size(cpapd) == size(apd)
-        @test full(copy(cpapd)) ≈ apd
-        @test det(cpapd) ≈ det(apd)
-        @test logdet(cpapd) ≈ logdet(apd)
-        @test cpapd[:P]*cpapd[:L]*cpapd[:U]*cpapd[:P]' ≈ apd
-    end
+        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)
 
-    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)
-
-debug && println("\ntype of a: ", eltya, " type of b: ", eltyb, "\n")
-        let Bs = b
-            for atype in ("Array", "SubArray")
-                if atype == "Array"
-                    b = Bs
-                else
-                    b = view(Bs, 1:n, 1)
-                end
+            for b in (b, view(b, 1:n, 1)) # Array and SubArray
 
                 # Test error bound on linear solver: LAWNS 14, Theorem 2.1
                 # This is a surprisingly loose bound
@@ -166,18 +168,19 @@ debug && println("\ntype of a: ", eltya, " type of b: ", eltyb, "\n")
                 @test norm(a*(capd\(a'*b)) - b,1)/norm(b,1) <= ε*κ*n # Ad hoc, revisit
 
                 if eltya != BigFloat && eltyb != BigFloat
+                    lapd = cholfact(apdhL)
                     @test norm(apd * (lapd\b) - b)/norm(b) <= ε*κ*n
                     @test norm(apd * (lapd\b[1:n]) - b[1:n])/norm(b[1:n]) <= ε*κ*n
                 end
-                @test_throws DimensionMismatch lapd\RowVector(ones(n))
+                @test_throws DimensionMismatch cholfact(apdhL)\RowVector(ones(n))
 
-debug && println("pivoted Cholesky decomposition")
                 if eltya != BigFloat && eltyb != BigFloat # Note! Need to implement pivoted Cholesky decomposition in julia
 
+                    cpapd = cholfact(apdh, Val(true))
                     @test norm(apd * (cpapd\b) - b)/norm(b) <= ε*κ*n # Ad hoc, revisit
                     @test norm(apd * (cpapd\b[1:n]) - b[1:n])/norm(b[1:n]) <= ε*κ*n
 
-                    lpapd = cholfact(apd, :L, Val{true})
+                    lpapd = cholfact(apdhL, Val(true))
                     @test norm(apd * (lpapd\b) - b)/norm(b) <= ε*κ*n # Ad hoc, revisit
                     @test norm(apd * (lpapd\b[1:n]) - b[1:n])/norm(b[1:n]) <= ε*κ*n
 
@@ -188,12 +191,10 @@ debug && println("pivoted Cholesky decomposition")
     end
 end
 
-begin
-    # Cholesky factor of Matrix with non-commutative elements, here 2x2-matrices
-
+@testset "Cholesky factor of Matrix with non-commutative elements, here 2x2-matrices" begin
     X = Matrix{Float64}[0.1*rand(2,2) for i in 1:3, j = 1:3]
-    L = full(Base.LinAlg._chol!(X*X', LowerTriangular))
-    U = full(Base.LinAlg._chol!(X*X', UpperTriangular))
+    L = full(Base.LinAlg._chol!(X*X', LowerTriangular)[1])
+    U = full(Base.LinAlg._chol!(X*X', UpperTriangular)[1])
     XX = full(X*X')
 
     @test sum(sum(norm, L*L' - XX)) < eps()
@@ -201,25 +202,28 @@ begin
 end
 
 # Test generic cholfact!
-for elty in (Float32, Float64, Complex{Float32}, Complex{Float64})
-    if elty <: Complex
-        A = complex.(randn(5,5), randn(5,5))
-    else
-        A = randn(5,5)
+@testset "generic cholfact!" begin
+    for elty in (Float32, Float64, Complex{Float32}, Complex{Float64})
+        if elty <: Complex
+            A = complex.(randn(5,5), randn(5,5))
+        else
+            A = randn(5,5)
+        end
+        A = convert(Matrix{elty}, A'A)
+        @test full(cholfact(A)[:L]) ≈ full(invoke(Base.LinAlg._chol!, Tuple{AbstractMatrix, Type{LowerTriangular}}, copy(A), LowerTriangular)[1])
+        @test full(cholfact(A)[:U]) ≈ full(invoke(Base.LinAlg._chol!, Tuple{AbstractMatrix, Type{UpperTriangular}}, copy(A), UpperTriangular)[1])
     end
-    A = convert(Matrix{elty}, A'A)
-    @test full(cholfact(A)[:L]) ≈ full(invoke(Base.LinAlg._chol!, Tuple{AbstractMatrix, Type{LowerTriangular}}, copy(A), LowerTriangular))
-    @test 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))
+@testset "cholesky up- and downdates" begin
+    A = complex.(randn(10,5), randn(10, 5))
+    v = complex.(randn(5), randn(5))
     for uplo in (:U, :L)
         AcA = A'A
         BcB = AcA + v*v'
         BcB = (BcB + BcB')/2
-        F = cholfact(AcA, uplo)
-        G = cholfact(BcB, uplo)
+        F = cholfact(Hermitian(AcA, uplo))
+        G = cholfact(Hermitian(BcB, uplo))
         @test LinAlg.lowrankupdate(F, v)[uplo] ≈ G[uplo]
         @test_throws DimensionMismatch LinAlg.lowrankupdate(F, ones(eltype(v), length(v)+1))
         @test LinAlg.lowrankdowndate(G, v)[uplo] ≈ F[uplo]
@@ -227,8 +231,8 @@ let A = complex.(randn(10,5), randn(10, 5)), v = complex.(randn(5), randn(5))
     end
 end
 
-# issue #13243, unexpected nans in complex cholfact
-let apd = [5.8525753f0 + 0.0f0im -0.79540455f0 + 0.7066077f0im 0.98274714f0 + 1.3824869f0im 2.619998f0 + 1.8532984f0im -1.8306153f0 - 1.2336911f0im 0.32275113f0 + 0.015575029f0im 2.1968813f0 + 1.0640624f0im 0.27894387f0 + 0.97911835f0im 3.0476584f0 + 0.18548489f0im 0.3842994f0 + 0.7050991f0im
+@testset "issue #13243, unexpected nans in complex cholfact" begin
+    apd = [5.8525753f0 + 0.0f0im -0.79540455f0 + 0.7066077f0im 0.98274714f0 + 1.3824869f0im 2.619998f0 + 1.8532984f0im -1.8306153f0 - 1.2336911f0im 0.32275113f0 + 0.015575029f0im 2.1968813f0 + 1.0640624f0im 0.27894387f0 + 0.97911835f0im 3.0476584f0 + 0.18548489f0im 0.3842994f0 + 0.7050991f0im
         -0.79540455f0 - 0.7066077f0im 8.313246f0 + 0.0f0im -1.8076122f0 - 0.8882447f0im 0.47806996f0 + 0.48494184f0im 0.5096429f0 - 0.5395974f0im -0.7285097f0 - 0.10360408f0im -1.1760061f0 - 2.7146957f0im -0.4271084f0 + 0.042899966f0im -1.7228563f0 + 2.8335886f0im 1.8942566f0 + 0.6389735f0im
         0.98274714f0 - 1.3824869f0im -1.8076122f0 + 0.8882447f0im 9.367975f0 + 0.0f0im -0.1838578f0 + 0.6468568f0im -1.8338387f0 + 0.7064959f0im 0.041852742f0 - 0.6556877f0im 2.5673025f0 + 1.9732997f0im -1.1148382f0 - 0.15693812f0im 2.4704504f0 - 1.0389464f0im 1.0858271f0 - 1.298006f0im
         2.619998f0 - 1.8532984f0im 0.47806996f0 - 0.48494184f0im -0.1838578f0 - 0.6468568f0im 3.1117508f0 + 0.0f0im -1.956626f0 + 0.22825956f0im 0.07081801f0 - 0.31801307f0im 0.3698375f0 - 0.5400855f0im 0.80686307f0 + 1.5315914f0im 1.5649154f0 - 1.6229297f0im -0.112077385f0 + 1.2014246f0im
@@ -248,7 +252,7 @@ let apd = [5.8525753f0 + 0.0f0im -0.79540455f0 + 0.7066077f0im 0.98274714f0 + 1.
         0.25336108035924787 + 0.975317836492159im 0.0628393808469436 - 0.1253397353973715im
         0.11192755545114 - 0.1603741874112385im 0.8439562576196216 + 1.0850814110398734im
         -1.0568488936791578 - 0.06025820467086475im 0.12696236014017806 - 0.09853584666755086im]
-    cholfact(apd, :L, Val{true}) \ b
+    cholfact(Hermitian(apd, :L), Val(true)) \ b
     r = factorize(apd)[:U]
     E = abs.(apd - r'*r)
     ε = eps(abs(float(one(Complex64))))
@@ -258,13 +262,29 @@ let apd = [5.8525753f0 + 0.0f0im -0.79540455f0 + 0.7066077f0im 0.98274714f0 + 1.
     end
 end
 
-# Fail if non-Hermitian
-@test_throws ArgumentError cholfact(randn(5,5))
-@test_throws ArgumentError cholfact(complex.(randn(5,5), randn(5,5)))
-@test_throws ArgumentError Base.LinAlg.chol!(randn(5,5))
-@test_throws ArgumentError Base.LinAlg.cholfact!(randn(5,5),:U,Val{false})
-@test_throws ArgumentError Base.LinAlg.cholfact!(randn(5,5),:U,Val{true})
-@test_throws ArgumentError cholfact(randn(5,5),:U,Val{false})
+@testset "throw if non-Hermitian" begin
+    R = randn(5, 5)
+    C = complex.(R, R)
+    for A in (R, C)
+        @test_throws ArgumentError cholfact(A)
+        @test_throws ArgumentError cholfact!(copy(A))
+        @test_throws ArgumentError chol(A)
+        @test_throws ArgumentError Base.LinAlg.chol!(copy(A))
+    end
+end
 
-# Fail for non-BLAS element types
-@test_throws ArgumentError cholfact!(Hermitian(rand(Float16, 5,5)), Val{true})
+@testset "fail for non-BLAS element types" begin
+    @test_throws ArgumentError cholfact!(Hermitian(rand(Float16, 5,5)), Val(true))
+end
+
+@testset "throw for non positive definite matrix" begin
+    for T in (Float32, Float64, Complex64, Complex128)
+        A = T[1 2; 2 1]; B = T[1, 1]
+        C = cholfact(A)
+        @test !isposdef(C)
+        @test !LinAlg.issuccess(C)
+        @test_throws PosDefException C\B
+        @test_throws PosDefException det(C)
+        @test_throws PosDefException logdet(C)
+    end
+end
diff --git a/test/linalg/conjarray.jl b/test/linalg/conjarray.jl
index e7c8e7c1359f06..4ba4ac90ad5bb0 100644
--- a/test/linalg/conjarray.jl
+++ b/test/linalg/conjarray.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 @testset "Core" begin
     m = [1+im 2; 2 4-im]
diff --git a/test/linalg/dense.jl b/test/linalg/dense.jl
index 68092b25c8a8ce..4b142dfc9891e3 100644
--- a/test/linalg/dense.jl
+++ b/test/linalg/dense.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base.Test
 
@@ -49,7 +49,12 @@ bimg  = randn(n,2)/2
 
     apd  = ainit'*ainit # symmetric positive-definite
     @testset "Positive definiteness" begin
-        @test isposdef(apd,:U)
+        @test !isposdef(ainit)
+        @test isposdef(apd)
+        if eltya != Int # cannot perform cholfact! for Matrix{Int}
+            @test !isposdef!(copy(ainit))
+            @test isposdef!(copy(apd))
+        end
     end
     @testset "For b containing $eltyb" for eltyb in (Float32, Float64, Complex64, Complex128, Int)
         binit = eltyb == Int ? rand(1:5, n, 2) : convert(Matrix{eltyb}, eltyb <: Complex ? complex.(breal, bimg) : breal)
@@ -145,11 +150,11 @@ bimg  = randn(n,2)/2
         A = diagm(d)
         @test factorize(A) == Diagonal(d)
         A += diagm(e,-1)
-        @test factorize(A) == Bidiagonal(d,e,false)
+        @test factorize(A) == Bidiagonal(d,e,:L)
         A += diagm(f,-2)
         @test factorize(A) == LowerTriangular(A)
         A = diagm(d) + diagm(e,1)
-        @test factorize(A) == Bidiagonal(d,e,true)
+        @test factorize(A) == Bidiagonal(d,e,:U)
         if eltya <: Real
             A = diagm(d) + diagm(e,1) + diagm(e,-1)
             @test full(factorize(A)) ≈ full(factorize(SymTridiagonal(d,e)))
@@ -273,7 +278,7 @@ end
 
                     # Against vectorized versions
                     @test norm(x,-Inf) ≈ minimum(abs.(x))
-                    @test norm(x,-1) ≈ inv(sum(1./abs.(x)))
+                    @test norm(x,-1) ≈ inv(sum(1 ./ abs.(x)))
                     @test norm(x,0) ≈ sum(x .!= 0)
                     @test norm(x,1) ≈ sum(abs.(x))
                     @test norm(x) ≈ sqrt(sum(abs2.(x)))
@@ -357,7 +362,7 @@ end
 
 ## Issue related tests
 @testset "issue #1447" begin
-    A = [1.+0.0im 0; 0 1]
+    A = [1.0+0.0im 0; 0 1]
     B = pinv(A)
     for i = 1:4
         @test A[i] ≈ B[i]
@@ -481,6 +486,32 @@ end
     @test expm(A10) ≈ eA10
 end
 
+@testset "Additional matrix logarithm tests" for elty in (Float64, Complex{Float64})
+    A11 = convert(Matrix{elty}, [3 2; -5 -3])
+    @test expm(logm(A11)) ≈ A11
+
+    A12 = convert(Matrix{elty}, [1 -1; 1 -1])
+    @test typeof(logm(A12)) == Array{Complex{Float64}, 2}
+
+    A1  = convert(Matrix{elty}, [4 2 0; 1 4 1; 1 1 4])
+    logmA1 = convert(Matrix{elty}, [1.329661349 0.5302876358 -0.06818951543;
+                                    0.2310490602 1.295566591 0.2651438179;
+                                    0.2310490602 0.1969543025 1.363756107])
+    @test logm(A1) ≈ logmA1
+    @test expm(logm(A1)) ≈ A1
+
+    A4  = convert(Matrix{elty}, [1/2 1/3 1/4 1/5+eps();
+                                 1/3 1/4 1/5 1/6;
+                                 1/4 1/5 1/6 1/7;
+                                 1/5 1/6 1/7 1/8])
+    logmA4 = convert(Matrix{elty}, [-1.73297159 1.857349738 0.4462766564 0.2414170219;
+                                    1.857349738 -5.335033737 2.994142974 0.5865285289;
+                                    0.4462766564 2.994142974 -7.351095988 3.318413247;
+                                    0.2414170219 0.5865285289 3.318413247 -5.444632124])
+    @test logm(A4) ≈ logmA4
+    @test expm(logm(A4)) ≈ A4
+end
+
 @testset "issue #7181" begin
     A = [ 1  5  9
           2  6 10
@@ -512,6 +543,61 @@ end
     @test_throws ArgumentError diag(zeros(0,1),2)
 end
 
+@testset "Matrix to real power" for elty in (Float64, Complex{Float64})
+# Tests proposed at Higham, Deadman: Testing Matrix Function Algorithms Using Identities, March 2014
+    #Aa : only positive real eigenvalues
+    Aa = convert(Matrix{elty}, [5 4 2 1; 0 1 -1 -1; -1 -1 3 0; 1 1 -1 2])
+
+    @test Aa^(1/2) ≈ sqrtm(Aa)
+    @test Aa^(-1/2) ≈ inv(sqrtm(Aa))
+    @test Aa^(3/4) ≈ sqrtm(Aa) * sqrtm(sqrtm(Aa))
+    @test Aa^(-3/4) ≈ inv(Aa) * sqrtm(sqrtm(Aa))
+    @test Aa^(17/8) ≈ Aa^2 * sqrtm(sqrtm(sqrtm(Aa)))
+    @test Aa^(-17/8) ≈ inv(Aa^2 * sqrtm(sqrtm(sqrtm(Aa))))
+    @test (Aa^0.2)^5 ≈ Aa
+    @test (Aa^(2/3))*(Aa^(1/3)) ≈ Aa
+    @test (Aa^im)^(-im) ≈ Aa
+
+    #Ab : both positive and negative real eigenvalues
+    Ab = convert(Matrix{elty}, [1 2 3; 4 7 1; 2 1 4])
+
+    @test Ab^(1/2) ≈ sqrtm(Ab)
+    @test Ab^(-1/2) ≈ inv(sqrtm(Ab))
+    @test Ab^(3/4) ≈ sqrtm(Ab) * sqrtm(sqrtm(Ab))
+    @test Ab^(-3/4) ≈ inv(Ab) * sqrtm(sqrtm(Ab))
+    @test Ab^(17/8) ≈ Ab^2 * sqrtm(sqrtm(sqrtm(Ab)))
+    @test Ab^(-17/8) ≈ inv(Ab^2 * sqrtm(sqrtm(sqrtm(Ab))))
+    @test (Ab^0.2)^5 ≈ Ab
+    @test (Ab^(2/3))*(Ab^(1/3)) ≈ Ab
+    @test (Ab^im)^(-im) ≈ Ab
+
+    #Ac : complex eigenvalues
+    Ac = convert(Matrix{elty}, [5 4 2 1;0 1 -1 -1;-1 -1 3 6;1 1 -1 5])
+
+    @test Ac^(1/2) ≈ sqrtm(Ac)
+    @test Ac^(-1/2) ≈ inv(sqrtm(Ac))
+    @test Ac^(3/4) ≈ sqrtm(Ac) * sqrtm(sqrtm(Ac))
+    @test Ac^(-3/4) ≈ inv(Ac) * sqrtm(sqrtm(Ac))
+    @test Ac^(17/8) ≈ Ac^2 * sqrtm(sqrtm(sqrtm(Ac)))
+    @test Ac^(-17/8) ≈ inv(Ac^2 * sqrtm(sqrtm(sqrtm(Ac))))
+    @test (Ac^0.2)^5 ≈ Ac
+    @test (Ac^(2/3))*(Ac^(1/3)) ≈ Ac
+    @test (Ac^im)^(-im) ≈ Ac
+
+    #Ad : defective Matrix
+    Ad = convert(Matrix{elty}, [3 1; 0 3])
+
+    @test Ad^(1/2) ≈ sqrtm(Ad)
+    @test Ad^(-1/2) ≈ inv(sqrtm(Ad))
+    @test Ad^(3/4) ≈ sqrtm(Ad) * sqrtm(sqrtm(Ad))
+    @test Ad^(-3/4) ≈ inv(Ad) * sqrtm(sqrtm(Ad))
+    @test Ad^(17/8) ≈ Ad^2 * sqrtm(sqrtm(sqrtm(Ad)))
+    @test Ad^(-17/8) ≈ inv(Ad^2 * sqrtm(sqrtm(sqrtm(Ad))))
+    @test (Ad^0.2)^5 ≈ Ad
+    @test (Ad^(2/3))*(Ad^(1/3)) ≈ Ad
+    @test (Ad^im)^(-im) ≈ Ad
+end
+
 @testset "Least squares solutions" begin
     a = [ones(20) 1:20 1:20]
     b = reshape(eye(8, 5), 20, 2)
diff --git a/test/linalg/diagonal.jl b/test/linalg/diagonal.jl
index d2cec79cd96020..a159e441bb6cca 100644
--- a/test/linalg/diagonal.jl
+++ b/test/linalg/diagonal.jl
@@ -1,7 +1,8 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base.Test
-import Base.LinAlg: BlasFloat, BlasComplex, SingularException
+import Base.LinAlg: BlasFloat, BlasComplex, SingularException, A_rdiv_B!, A_rdiv_Bt!,
+    A_rdiv_Bc!
 
 n=12 #Size of matrix problem to test
 srand(1)
@@ -17,11 +18,21 @@ srand(1)
     end
     D = Diagonal(d)
     DM = diagm(d)
+
+    @testset "constructor" begin
+        for x in (d, GenericArray(d))
+            @test Diagonal(x)::Diagonal{elty,typeof(x)} == DM
+            @test Diagonal(x).diag === x
+            @test Diagonal{elty}(x)::Diagonal{elty,typeof(x)} == DM
+            @test Diagonal{elty}(x).diag === x
+        end
+    end
+
     @testset "Basic properties" begin
         @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}
+        @test typeof(convert(Diagonal{Complex64},D)) <: Diagonal{Complex64}
+        @test typeof(convert(AbstractMatrix{Complex64},D)) <: Diagonal{Complex64}
 
         @test Array(real(D)) == real(DM)
         @test Array(abs.(D)) == abs.(DM)
@@ -79,30 +90,43 @@ srand(1)
                 @test U'*D ≈ U'*Array(D)
 
                 if relty != BigFloat
-                    @test D\v ≈ DM\v atol=2n^2*eps(relty)*(1+(elty<:Complex))
-                    @test D\U ≈ DM\U atol=2n^3*eps(relty)*(1+(elty<:Complex))
-                    @test A_ldiv_B!(D,copy(v)) ≈ DM\v atol=2n^2*eps(relty)*(1+(elty<:Complex))
-                    @test A_ldiv_B!(D,copy(U)) ≈ DM\U atol=2n^3*eps(relty)*(1+(elty<:Complex))
-                    @test A_ldiv_B!(D,eye(D)) ≈ D\eye(D) atol=2n^3*eps(relty)*(1+(elty<:Complex))
+                    atol_two = 2n^2 * eps(relty) * (1 + (elty <: Complex))
+                    atol_three = 2n^3 * eps(relty) * (1 + (elty <: Complex))
+                    @test D\v ≈ DM\v atol=atol_two
+                    @test D\U ≈ DM\U atol=atol_three
+                    @test A_ldiv_B!(D, copy(v)) ≈ DM\v atol=atol_two
+                    @test At_ldiv_B!(D, copy(v)) ≈ DM\v atol=atol_two
+                    @test Ac_ldiv_B!(conj(D), copy(v)) ≈ DM\v atol=atol_two
+                    @test A_ldiv_B!(D, copy(U)) ≈ DM\U atol=atol_three
+                    @test At_ldiv_B!(D, copy(U)) ≈ DM\U atol=atol_three
+                    @test Ac_ldiv_B!(conj(D), copy(U)) ≈ DM\U atol=atol_three
+                    Uc = ctranspose(U)
+                    target = scale!(Uc, inv.(D.diag))
+                    @test A_rdiv_B!(Uc, D) ≈ target atol=atol_three
+                    @test_throws DimensionMismatch A_rdiv_B!(eye(elty, n-1), D)
+                    @test_throws SingularException A_rdiv_B!(Uc, zeros(D))
+                    @test A_rdiv_Bt!(Uc, D) ≈ target atol=atol_three
+                    @test A_rdiv_Bc!(Uc, conj(D)) ≈ target atol=atol_three
+                    @test A_ldiv_B!(D, eye(D)) ≈ D\eye(D) atol=atol_three
                     @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)
+                    @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)) ≈ Array(D)\Array(b)
-                    @test_throws SingularException A_ldiv_B!(Diagonal(zeros(elty,n)),copy(b))
-                    b = view(rand(elty,n),collect(1:n))
+                    @test A_ldiv_B!(D, copy(b)) ≈ Array(D)\Array(b)
+                    @test_throws SingularException A_ldiv_B!(Diagonal(zeros(elty, n)), copy(b))
+                    b = view(rand(elty, n), collect(1:n))
                     b2 = copy(b)
-                    c = A_ldiv_B!(D,b)
+                    c = A_ldiv_B!(D, b)
                     d = Array(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)
+                    @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 = view(rand(elty,n+1),collect(1:n+1))
-                    @test_throws DimensionMismatch A_ldiv_B!(D,b)
+                    @test_throws DimensionMismatch A_ldiv_B!(D, copy(b))
+                    b = view(rand(elty, n+1), collect(1:n+1))
+                    @test_throws DimensionMismatch A_ldiv_B!(D, b)
                 end
             end
         end
@@ -137,6 +161,29 @@ srand(1)
         #division of two Diagonals
         @test D/D2 ≈ Diagonal(D.diag./D2.diag)
         @test D\D2 ≈ Diagonal(D2.diag./D.diag)
+
+        # Performance specialisations for A*_mul_B!
+        vv = similar(v)
+        @test (r = full(D) * v   ; A_mul_B!(vv, D, v)  ≈ r ≈ vv)
+        @test (r = full(D)' * v  ; Ac_mul_B!(vv, D, v) ≈ r ≈ vv)
+        @test (r = full(D).' * v ; At_mul_B!(vv, D, v) ≈ r ≈ vv)
+
+        UU = similar(U)
+        @test (r = full(D) * U   ; A_mul_B!(UU, D, U) ≈ r ≈ UU)
+        @test (r = full(D)' * U  ; Ac_mul_B!(UU, D, U) ≈ r ≈ UU)
+        @test (r = full(D).' * U ; At_mul_B!(UU, D, U) ≈ r ≈ UU)
+
+        # make sure that A_mul_B{c,t}! works with B as a Diagonal
+        VV = Array(D)
+        DD = copy(D)
+        r  = VV * full(D)
+        @test Array(A_mul_B!(VV, DD)) ≈ r ≈ Array(D)*Array(D)
+        DD = copy(D)
+        r  = VV * (Array(D).')
+        @test Array(A_mul_Bt!(VV, DD)) ≈ r
+        DD = copy(D)
+        r  = VV * (Array(D)')
+        @test Array(A_mul_Bc!(VV, DD)) ≈ r
     end
     @testset "triu/tril" begin
         @test istriu(D)
@@ -177,6 +224,9 @@ srand(1)
             @test Array(conj(D)) ≈ conj(DM)
             @test ctranspose(D) == conj(D)
         end
+        # Translates to Ac/t_mul_B, which is specialized after issue 21286
+        @test(D' * v == conj(D) * v)
+        @test(D.' * v == D * v)
     end
 
     #logdet
@@ -206,7 +256,7 @@ srand(1)
         end
     end
 
-    @testset "svd" begin
+    @testset "svd (#11120/#11247)" begin
         U, s, V = svd(D)
         @test (U*Diagonal(s))*V' ≈ D
         @test svdvals(D) == s
@@ -214,45 +264,50 @@ srand(1)
     end
 end
 
-D = Diagonal(Matrix{Float64}[randn(3,3), randn(2,2)])
-@test sort([svdvals(D)...;], rev = true) ≈ svdvals([D.diag[1] zeros(3,2); zeros(2,3) D.diag[2]])
-@test [eigvals(D)...;] ≈ eigvals([D.diag[1] zeros(3,2); zeros(2,3) D.diag[2]])
-#isposdef
-@test !isposdef(Diagonal(-1.0 * rand(n)))
+@testset "svdvals and eigvals (#11120/#11247)" begin
+    D = Diagonal(Matrix{Float64}[randn(3,3), randn(2,2)])
+    @test sort([svdvals(D)...;], rev = true) ≈ svdvals([D.diag[1] zeros(3,2); zeros(2,3) D.diag[2]])
+    @test [eigvals(D)...;] ≈ eigvals([D.diag[1] zeros(3,2); zeros(2,3) D.diag[2]])
+end
 
-@testset "Indexing" begin
-    let d = randn(n), D = Diagonal(d)
-        for i=1:n
-            @test D[i,i] == d[i]
-        end
-        for i=1:n
-            for j=1:n
-                @test D[i,j] == (i==j ? d[i] : 0)
-            end
-        end
-        D2 = copy(D)
-        for i=1:n
-            D2[i,i] = i
-        end
-        for i=1:n
-            for j=1:n
-                if i == j
-                    @test D2[i,j] == i
-                else
-                    @test D2[i,j] == 0
-                    D2[i,j] = 0
-                    @test_throws ArgumentError (D2[i,j] = 1)
-                end
-            end
+@testset "isposdef" begin
+    @test isposdef(Diagonal(1.0 + rand(n)))
+    @test !isposdef(Diagonal(-1.0 * rand(n)))
+end
+
+@testset "getindex" begin
+    d = randn(n)
+    D = Diagonal(d)
+    # getindex bounds checking
+    @test_throws BoundsError D[0, 0]
+    @test_throws BoundsError D[-1, -2]
+    @test_throws BoundsError D[n, n + 1]
+    @test_throws BoundsError D[n + 1, n]
+    @test_throws BoundsError D[n + 1, n + 1]
+    # getindex on and off the diagonal
+    for i in 1:n, j in 1:n
+        @test D[i, j] == (i == j ? d[i] : 0)
+    end
+end
+
+@testset "setindex!" begin
+    d = randn(n)
+    D = Diagonal(d)
+    # setindex! bounds checking
+    @test_throws BoundsError D[0, 0] = 0
+    @test_throws BoundsError D[-1 , -2] = 0
+    @test_throws BoundsError D[n, n + 1] = 0
+    @test_throws BoundsError D[n + 1, n] = 0
+    @test_throws BoundsError D[n + 1, n + 1] = 0
+    for i in 1:n, j in 1:n
+        if i == j
+            # setindex on! the diagonal
+            @test ((D[i, j] = i) == i; D[i, j] == i)
+        else
+            # setindex! off the diagonal
+            @test ((D[i, j] = 0) == 0; iszero(D[i, j]))
+            @test_throws ArgumentError D[i, j] = 1
         end
-        @test_throws BoundsError D[0, 0]
-        @test_throws BoundsError (D[0, 0] = 0)
-        @test_throws BoundsError D[-1,-2]
-        @test_throws BoundsError (D[-1,-2] = 0)
-        @test_throws BoundsError D[n+1,n+1]
-        @test_throws BoundsError (D[n+1,n+1] = 0)
-        @test_throws BoundsError D[n,n+1]
-        @test_throws BoundsError (D[n,n+1] = 0)
     end
 end
 
@@ -267,7 +322,7 @@ end
 end
 
 # allow construct from range
-@test Diagonal(linspace(1,3,3)) == Diagonal([1.,2.,3.])
+@test all(Diagonal(linspace(1,3,3)) .== Diagonal([1.0,2.0,3.0]))
 
 # Issue 12803
 for t in (Float32, Float64, Int, Complex{Float64}, Rational{Int})
@@ -295,6 +350,53 @@ let D1 = Diagonal(rand(5)), D2 = Diagonal(rand(5))
     @test_throws MethodError Ac_mul_B!(D1,D2)
 end
 
-# Diagonal and Q
-Q = qrfact(randn(5,5))[:Q]
-@test D*Q' == Array(D)*Q'
+@testset "multiplication of QR Q-factor and Diagonal (#16615 spot test)" begin
+    D = Diagonal(randn(5))
+    Q = qrfact(randn(5, 5))[:Q]
+    @test D * Q' == Array(D) * Q'
+    Q = qrfact(randn(5, 5), Val(true))[:Q]
+    @test_throws MethodError A_mul_B!(Q, D)
+end
+
+@testset "block diagonal matrices" begin
+    D = Diagonal([[1 2; 3 4], [1 2; 3 4]])
+    Dherm = Diagonal([[1 1+im; 1-im 1], [1 1+im; 1-im 1]])
+    Dsym = Diagonal([[1 1+im; 1+im 1], [1 1+im; 1+im 1]])
+    @test D' == Diagonal([[1 3; 2 4], [1 3; 2 4]])
+    @test D.' == Diagonal([[1 3; 2 4], [1 3; 2 4]])
+    @test Dherm' == Dherm
+    @test Dherm.' == Diagonal([[1 1-im; 1+im 1], [1 1-im; 1+im 1]])
+    @test Dsym' == Diagonal([[1 1-im; 1-im 1], [1 1-im; 1-im 1]])
+    @test Dsym.' == Dsym
+
+    v = [[1, 2], [3, 4]]
+    @test Dherm' * v == Dherm * v
+    @test D.' * v == [[7, 10], [15, 22]]
+
+    @test issymmetric(D) == false
+    @test issymmetric(Dherm) == false
+    @test issymmetric(Dsym) == true
+
+    @test ishermitian(D) == false
+    @test ishermitian(Dherm) == true
+    @test ishermitian(Dsym) == false
+
+    @test expm(D) == Diagonal([expm([1 2; 3 4]), expm([1 2; 3 4])])
+    @test logm(D) == Diagonal([logm([1 2; 3 4]), logm([1 2; 3 4])])
+    @test sqrtm(D) == Diagonal([sqrtm([1 2; 3 4]), sqrtm([1 2; 3 4])])
+end
+
+@testset "multiplication with Symmetric/Hermitian" begin
+    for T in (Float64, Complex128)
+        D = Diagonal(randn(T, n))
+        A = randn(T, n, n); A = A'A
+        S = Symmetric(A)
+        H = Hermitian(A)
+        for f in (*, Ac_mul_B, A_mul_Bc, Ac_mul_Bc, At_mul_B, A_mul_Bt, At_mul_Bt)
+            @test f(D, S) ≈ f(Matrix(D), Matrix(S))
+            @test f(D, H) ≈ f(Matrix(D), Matrix(H))
+            @test f(S, D) ≈ f(Matrix(S), Matrix(D))
+            @test f(S, H) ≈ f(Matrix(S), Matrix(H))
+        end
+    end
+end
diff --git a/test/linalg/eigen.jl b/test/linalg/eigen.jl
index 3ae52efb28c808..5e6ec48db16f27 100644
--- a/test/linalg/eigen.jl
+++ b/test/linalg/eigen.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base.Test
 
@@ -35,14 +35,15 @@ aimg  = randn(n,n)/2
         @test eab[1] == eigvals(fill(α,1,1),fill(β,1,1))
         @test eab[2] == eigvecs(fill(α,1,1),fill(β,1,1))
 
-        d,v   = eig(a)
         @testset "non-symmetric eigen decomposition" begin
+            d, v = eig(a)
             for i in 1:size(a,2)
                 @test a*v[:,i] ≈ d[i]*v[:,i]
             end
             f = eigfact(a)
             @test det(a) ≈ det(f)
             @test inv(a) ≈ inv(f)
+            @test isposdef(a) == isposdef(f)
             @test eigvals(f) === f[:values]
             @test eigvecs(f) === f[:vectors]
 
diff --git a/test/linalg/generic.jl b/test/linalg/generic.jl
index d6441fd442e88f..0b3530ed210dcf 100644
--- a/test/linalg/generic.jl
+++ b/test/linalg/generic.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 import Base: -, *, /, \
 using Base.Test
@@ -14,7 +14,7 @@ end
 Quaternion(s::Real, v1::Real, v2::Real, v3::Real) = Quaternion(promote(s, v1, v2, v3)...)
 Base.abs2(q::Quaternion) = q.s*q.s + q.v1*q.v1 + q.v2*q.v2 + q.v3*q.v3
 Base.abs(q::Quaternion) = sqrt(abs2(q))
-Base.real{T}(::Type{Quaternion{T}}) = T
+Base.real(::Type{Quaternion{T}}) where {T} = T
 Base.conj(q::Quaternion) = Quaternion(q.s, -q.v1, -q.v2, -q.v3)
 Base.isfinite(q::Quaternion) = isfinite(q.s) & isfinite(q.v1) & isfinite(q.v2) & isfinite(q.v3)
 
@@ -48,6 +48,7 @@ for elty in (Int, Rational{BigInt}, Float32, Float64, BigFloat, Complex{Float32}
 
     debug && println("element type: $elty")
 
+    @test logdet(A[1,1]) == log(det(A[1,1]))
     @test logdet(A) ≈ log(det(A))
     @test logabsdet(A)[1] ≈ log(abs(det(A)))
     @test logabsdet(convert(Matrix{elty}, -eye(n)))[2] == -1
@@ -141,7 +142,7 @@ y = ['a','b','c','d','e']
 @test !ishermitian(ones(5,3))
 @test cross(ones(3),ones(3)) == zeros(3)
 
-@test trace(Bidiagonal(ones(5),zeros(4),true)) == 5
+@test trace(Bidiagonal(ones(5),zeros(4),:U)) == 5
 
 
 # array and subarray tests
@@ -310,3 +311,39 @@ end
 @test [[1, 2], [3, 4]] ≈ [[1.0-eps(), 2.0+eps()], [3.0+2eps(), 4.0-1e8eps()]]
 @test [[1, 2], [3, 4]] ≉ [[1.0-eps(), 2.0+eps()], [3.0+2eps(), 4.0-1e9eps()]]
 @test [[1,2, [3,4]], 5.0, [6im, [7.0, 8.0]]] ≈ [[1,2, [3,4]], 5.0, [6im, [7.0, 8.0]]]
+
+# Issue 22042
+# Minimal modulo number type - but not subtyping Number
+struct ModInt{n}
+    k
+    ModInt{n}(k) where {n} = new(mod(k,n))
+    ModInt{n}(k::ModInt{n}) where {n} = k
+end
+
+Base.:+(a::ModInt{n}, b::ModInt{n}) where {n} = ModInt{n}(a.k + b.k)
+Base.:-(a::ModInt{n}, b::ModInt{n}) where {n} = ModInt{n}(a.k - b.k)
+Base.:*(a::ModInt{n}, b::ModInt{n}) where {n} = ModInt{n}(a.k * b.k)
+Base.:-(a::ModInt{n}) where {n} = ModInt{n}(-a.k)
+Base.inv(a::ModInt{n}) where {n} = ModInt{n}(invmod(a.k, n))
+Base.:/(a::ModInt{n}, b::ModInt{n}) where {n} = a*inv(b)
+
+Base.zero(::Type{ModInt{n}}) where {n} = ModInt{n}(0)
+Base.zero(::ModInt{n}) where {n} = ModInt{n}(0)
+Base.one(::Type{ModInt{n}}) where {n} = ModInt{n}(1)
+Base.one(::ModInt{n}) where {n} = ModInt{n}(1)
+Base.transpose(a::ModInt{n}) where {n} = a  # see Issue 20978
+
+A = [ModInt{2}(1) ModInt{2}(0); ModInt{2}(1) ModInt{2}(1)]
+b = [ModInt{2}(1), ModInt{2}(0)]
+
+@test A*(lufact(A, Val(false))\b) == b
+
+# Needed for pivoting:
+Base.abs(a::ModInt{n}) where {n} = a
+Base.:<(a::ModInt{n}, b::ModInt{n}) where {n} = a.k < b.k
+
+@test A*(lufact(A, Val(true))\b) == b
+
+# test that the fallback throws properly for AbstractArrays with dimension > 2
+@test_throws ErrorException ctranspose(rand(2,2,2,2))
+@test_throws ErrorException transpose(rand(2,2,2,2))
diff --git a/test/linalg/givens.jl b/test/linalg/givens.jl
index 03420a492683f0..06ad1b93999037 100644
--- a/test/linalg/givens.jl
+++ b/test/linalg/givens.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base.Test
 
diff --git a/test/linalg/hessenberg.jl b/test/linalg/hessenberg.jl
index 0e700fcd4c781e..aca74a74199ef1 100644
--- a/test/linalg/hessenberg.jl
+++ b/test/linalg/hessenberg.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base.Test
 
diff --git a/test/linalg/lapack.jl b/test/linalg/lapack.jl
index b0749da0133cb0..ab62c6a4f7048c 100644
--- a/test/linalg/lapack.jl
+++ b/test/linalg/lapack.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base.Test
 
@@ -52,7 +52,7 @@ end
             d, e = convert(Vector{elty}, randn(n)), convert(Vector{elty}, randn(n - 1))
             U, Vt, C = eye(elty, n), eye(elty, n), eye(elty, n)
             s, _ = LAPACK.bdsqr!('U', copy(d), copy(e), Vt, U, C)
-            @test Array(Bidiagonal(d, e, true)) ≈ U*Diagonal(s)*Vt
+            @test Array(Bidiagonal(d, e, :U)) ≈ U*Diagonal(s)*Vt
 
             @test_throws ArgumentError LAPACK.bdsqr!('A', d, e, Vt, U, C)
             @test_throws DimensionMismatch LAPACK.bdsqr!('U', d, [e; 1], Vt, U, C)
diff --git a/test/linalg/lq.jl b/test/linalg/lq.jl
index d01d30104b05fd..a9cfcdd54b34fd 100644
--- a/test/linalg/lq.jl
+++ b/test/linalg/lq.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base.Test
 
@@ -57,6 +57,9 @@ bimg  = randn(n,2)/2
                     @test l*q ≈ a
                     @test full(lqa) ≈ a
                     @test full(copy(lqa)) ≈ a
+                    lstring = sprint(show,l)
+                    qstring = sprint(show,q)
+                    @test sprint(show,lqa) == "$(typeof(lqa)) with factors L and Q:\n$lstring\n$qstring"
                 end
                 @testset "Binary ops" begin
                     @test a*(lqa\b) ≈ b atol=3000ε
@@ -77,7 +80,7 @@ bimg  = randn(n,2)/2
                     @test_throws DimensionMismatch Ac_mul_B(q,ones(eltya,n+2,n+2))
                     @test_throws DimensionMismatch ones(eltyb,n+2,n+2)*q
                     if isa(a, DenseArray) && isa(b, DenseArray)
-                        #use this to test 2nd branch in mult code
+                        # use this to test 2nd branch in mult code
                         pad_a = vcat(eye(a), a)
                         pad_b = hcat(eye(b), b)
                         @test pad_a*q ≈ pad_a*full(q,thin=false) atol=100ε
diff --git a/test/linalg/lu.jl b/test/linalg/lu.jl
index 3a6b2d5d091761..6730a6cd07fd6b 100644
--- a/test/linalg/lu.jl
+++ b/test/linalg/lu.jl
@@ -1,6 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
-
-debug = false
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base.Test
 import Base.LinAlg.BlasInt, Base.LinAlg.BlasFloat
@@ -28,7 +26,7 @@ dlimg  = randn(n-1)/2
 dreal = randn(n)/2
 dimg  = randn(n)/2
 
-for eltya in (Float32, Float64, Complex64, Complex128, BigFloat, Int)
+@testset for eltya in (Float32, Float64, Complex64, Complex128, BigFloat, Int)
     a = eltya == Int ? rand(1:7, n, n) :
         convert(Matrix{eltya}, eltya <: Complex ? complex.(areal, aimg) : areal)
     d = if eltya == Int
@@ -42,169 +40,197 @@ for eltya in (Float32, Float64, Complex64, Complex128, BigFloat, Int)
     ε = εa = eps(abs(float(one(eltya))))
 
     if eltya <: BlasFloat
-        num = rand(eltya)
-        @test lu(num) == (one(eltya),num,1)
-        @test AbstractArray(lufact(num)) ≈ eltya[num]
+        @testset "LU factorization for Number" begin
+            num = rand(eltya)
+            @test lu(num) == (one(eltya),num,1)
+            @test AbstractArray(lufact(num)) ≈ eltya[num]
+        end
     end
-    for eltyb in (Float32, Float64, Complex64, Complex128, Int)
-        b = eltyb == Int ? rand(1:5, n, 2) :
+    @testset 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)
-        c = eltyb == Int ? rand(1:5, n) :
+        c  = eltyb == Int ? rand(1:5, n) :
             convert(Vector{eltyb}, eltyb <: Complex ? complex.(creal, cimg) : creal)
         εb = eps(abs(float(one(eltyb))))
-        ε = max(εa,εb)
-
-debug && println("(Automatic) Square LU decomposition. eltya: $eltya, eltyb: $eltyb")
-        κ     = cond(a,1)
-        lua   = factorize(a)
-        @test_throws KeyError lua[:Z]
-        l,u,p = lua[:L], lua[:U], lua[:p]
-        ll,ul,pl = lu(a)
-        @test ll * ul ≈ a[pl,:]
-        @test l*u ≈ a[p,:]
-        @test (l*u)[invperm(p),:] ≈ a
-        @test a * inv(lua) ≈ eye(n)
-
-        lstring = sprint(show,l)
-        ustring = sprint(show,u)
-        @test sprint(show,lua) == "$(typeof(lua)) with factors L and U:\n$lstring\n$ustring"
-        let Bs = b, Cs = c
-            for atype in ("Array", "SubArray")
-                if atype == "Array"
-                    b = Bs
-                    c = Cs
-                else
-                    b = view(Bs, 1:n, 1)
-                    c = view(Cs, 1:n)
-                end
-                @test norm(a*(lua\b) - b, 1) < ε*κ*n*2 # Two because the right hand side has two columns
-                @test norm(a'*(lua'\b) - b, 1) < ε*κ*n*2 # Two because the right hand side has two columns
-                @test norm(a'*(lua'\a') - a', 1) < ε*κ*n^2
-                @test norm(a*(lua\c) - c, 1) < ε*κ*n # c is a vector
-                @test norm(a'*(lua'\c) - c, 1) < ε*κ*n # c is a vector
-                @test AbstractArray(lua) ≈ a
-                if eltya <: Real && eltyb <: Real
-                    @test norm(a.'*(lua.'\b) - b,1) < ε*κ*n*2 # Two because the right hand side has two columns
-                    @test norm(a.'*(lua.'\c) - c,1) < ε*κ*n
+        ε  = max(εa,εb)
+        κ  = cond(a,1)
+
+        @testset "(Automatic) Square LU decomposition" begin
+            lua   = factorize(a)
+            @test_throws KeyError lua[:Z]
+            l,u,p = lua[:L], lua[:U], lua[:p]
+            ll,ul,pl = lu(a)
+            @test ll * ul ≈ a[pl,:]
+            @test l*u ≈ a[p,:]
+            @test (l*u)[invperm(p),:] ≈ a
+            @test a * inv(lua) ≈ eye(n)
+            @test copy(lua) == lua
+
+            lstring = sprint(show,l)
+            ustring = sprint(show,u)
+            @test sprint(show,lua) == "$(typeof(lua)) with factors L and U:\n$lstring\n$ustring\nsuccessful: true"
+            let Bs = b, Cs = c
+                @testset for atype in ("Array", "SubArray")
+                    if atype == "Array"
+                        b = Bs
+                        c = Cs
+                    else
+                        b = view(Bs, 1:n, 1)
+                        c = view(Cs, 1:n)
+                    end
+                    @test norm(a*(lua\b) - b, 1) < ε*κ*n*2 # Two because the right hand side has two columns
+                    @test norm(a'*(lua'\b) - b, 1) < ε*κ*n*2 # Two because the right hand side has two columns
+                    @test norm(a'*(lua'\a') - a', 1) < ε*κ*n^2
+                    @test norm(a*(lua\c) - c, 1) < ε*κ*n # c is a vector
+                    @test norm(a'*(lua'\c) - c, 1) < ε*κ*n # c is a vector
+                    @test AbstractArray(lua) ≈ a
+                    if eltya <: Real && eltyb <: Real
+                        @test norm(a.'*(lua.'\b) - b,1) < ε*κ*n*2 # Two because the right hand side has two columns
+                        @test norm(a.'*(lua.'\c) - c,1) < ε*κ*n
+                    end
                 end
             end
+            if eltya <: BlasFloat && eltyb <: BlasFloat
+                e = rand(eltyb,n,n)
+                @test norm(e/lua - e/a,1) < ε*κ*n^2
+            end
         end
-        if eltya <: BlasFloat && eltyb <: BlasFloat
-            e = rand(eltyb,n,n)
-            @test norm(e/lua - e/a,1) < ε*κ*n^2
-        end
-
-debug && println("Tridiagonal LU")
-        κd    = cond(Array(d),1)
-        lud   = lufact(d)
-        @test lufact(lud) == lud
-        @test_throws KeyError lud[:Z]
-        @test lud[:L]*lud[:U] ≈ lud[:P]*Array(d)
-        @test lud[:L]*lud[:U] ≈ Array(d)[lud[:p],:]
-        @test AbstractArray(lud) ≈ d
-        f = zeros(eltyb, n+1)
-        @test_throws DimensionMismatch lud\f
-        @test_throws DimensionMismatch lud.'\f
-        @test_throws DimensionMismatch lud'\f
-        @test_throws DimensionMismatch Base.LinAlg.At_ldiv_B!(lud, f)
-        let Bs = b
-            for atype in ("Array", "SubArray")
-                if atype == "Array"
-                    b = Bs
-                else
-                    b = view(Bs, 1:n, 1)
-                end
+        @testset "Tridiagonal LU" begin
+            κd    = cond(Array(d),1)
+            lud   = lufact(d)
+            @test LinAlg.issuccess(lud)
+            @test lufact(lud) == lud
+            @test_throws KeyError lud[:Z]
+            @test lud[:L]*lud[:U] ≈ lud[:P]*Array(d)
+            @test lud[:L]*lud[:U] ≈ Array(d)[lud[:p],:]
+            @test AbstractArray(lud) ≈ d
+            f = zeros(eltyb, n+1)
+            @test_throws DimensionMismatch lud\f
+            @test_throws DimensionMismatch lud.'\f
+            @test_throws DimensionMismatch lud'\f
+            @test_throws DimensionMismatch Base.LinAlg.At_ldiv_B!(lud, f)
+            let Bs = b
+                @testset for atype in ("Array", "SubArray")
+                    if atype == "Array"
+                        b = Bs
+                    else
+                        b = view(Bs, 1:n, 1)
+                    end
 
-                @test norm(d*(lud\b) - b, 1) < ε*κd*n*2 # Two because the right hand side has two columns
-                if eltya <: Real
-                    @test norm((lud.'\b) - Array(d.')\b, 1) < ε*κd*n*2 # Two because the right hand side has two columns
-                    if eltya != Int && eltyb != Int
-                        @test norm(Base.LinAlg.At_ldiv_B!(lud, copy(b)) - Array(d.')\b, 1) < ε*κd*n*2
+                    @test norm(d*(lud\b) - b, 1) < ε*κd*n*2 # Two because the right hand side has two columns
+                    if eltya <: Real
+                        @test norm((lud.'\b) - Array(d.')\b, 1) < ε*κd*n*2 # Two because the right hand side has two columns
+                        if eltya != Int && eltyb != Int
+                            @test norm(Base.LinAlg.At_ldiv_B!(lud, copy(b)) - Array(d.')\b, 1) < ε*κd*n*2
+                        end
+                    end
+                    if eltya <: Complex
+                        @test norm((lud'\b) - Array(d')\b, 1) < ε*κd*n*2 # Two because the right hand side has two columns
                     end
                 end
-                if eltya <: Complex
-                    @test norm((lud'\b) - Array(d')\b, 1) < ε*κd*n*2 # Two because the right hand side has two columns
-                end
+            end
+            if eltya <: BlasFloat && eltyb <: BlasFloat
+                e = rand(eltyb,n,n)
+                @test norm(e/lud - e/d,1) < ε*κ*n^2
+                @test norm((lud.'\e') - Array(d.')\e',1) < ε*κd*n^2
+                #test singular
+                du = rand(eltya,n-1)
+                dl = rand(eltya,n-1)
+                dd = rand(eltya,n)
+                dd[1] = zero(eltya)
+                du[1] = zero(eltya)
+                dl[1] = zero(eltya)
+                zT = Tridiagonal(dl,dd,du)
+                @test !LinAlg.issuccess(lufact(zT))
             end
         end
-        if eltya <: BlasFloat && eltyb <: BlasFloat
-            e = rand(eltyb,n,n)
-            @test norm(e/lud - e/d,1) < ε*κ*n^2
-            @test norm((lud.'\e') - Array(d.')\e',1) < ε*κd*n^2
-            #test singular
-            du = rand(eltya,n-1)
-            dl = rand(eltya,n-1)
-            dd = rand(eltya,n)
-            dd[1] = zero(eltya)
-            du[1] = zero(eltya)
-            dl[1] = zero(eltya)
-            zT = Tridiagonal(dl,dd,du)
-            @test lufact(zT).info == 1
+        @testset "Thin LU" begin
+            lua   = @inferred lufact(a[:,1:n1])
+            @test lua[:L]*lua[:U] ≈ lua[:P]*a[:,1:n1]
         end
+        @testset "Fat LU" begin
+            lua   = lufact(a[1:n1,:])
+            @test lua[:L]*lua[:U] ≈ lua[:P]*a[1:n1,:]
+        end
+    end
 
-debug && println("Thin LU")
-        lua   = @inferred lufact(a[:,1:n1])
-        @test lua[:L]*lua[:U] ≈ lua[:P]*a[:,1:n1]
-
-debug && println("Fat LU")
-        lua   = lufact(a[1:n1,:])
-        @test lua[:L]*lua[:U] ≈ lua[:P]*a[1:n1,:]
+    @testset "LU of Symmetric/Hermitian" begin
+        for HS in (Hermitian(a'a), Symmetric(a'a))
+            luhs = lufact(HS)
+            @test luhs[:L]*luhs[:U] ≈ luhs[:P]*Matrix(HS)
+        end
     end
 end
 
-# test conversion routine
-a = Tridiagonal(rand(9),rand(10),rand(9))
-fa = Array(a)
-falu = lufact(fa)
-alu = lufact(a)
-falu = convert(typeof(falu),alu)
-@test AbstractArray(alu) == fa
-
-# Test rational matrices
-## Integrate in general tests when more linear algebra is implemented in julia
-a = convert(Matrix{Rational{BigInt}}, rand(1:10//1,n,n))/n
-b = rand(1:10,n,2)
-@inferred lufact(a)
-lua   = factorize(a)
-l,u,p = lua[:L], lua[:U], lua[:p]
-@test l*u ≈ a[p,:]
-@test l[invperm(p),:]*u ≈ a
-@test a*inv(lua) ≈ eye(n)
-let Bs = b
-    for atype in ("Array", "SubArray")
-        if atype == "Array"
-            b = Bs
-        else
-            b = view(Bs, 1:n, 1)
+@testset "conversion" begin
+    a = Tridiagonal(rand(9),rand(10),rand(9))
+    fa = Array(a)
+    falu = lufact(fa)
+    alu = lufact(a)
+    falu = convert(typeof(falu),alu)
+    @test AbstractArray(alu) == fa
+end
+
+@testset "Rational Matrices" begin
+    ## Integrate in general tests when more linear algebra is implemented in julia
+    a = convert(Matrix{Rational{BigInt}}, rand(1:10//1,n,n))/n
+    b = rand(1:10,n,2)
+    @inferred lufact(a)
+    lua   = factorize(a)
+    l,u,p = lua[:L], lua[:U], lua[:p]
+    @test l*u ≈ a[p,:]
+    @test l[invperm(p),:]*u ≈ a
+    @test a*inv(lua) ≈ eye(n)
+    let Bs = b
+        for atype in ("Array", "SubArray")
+            if atype == "Array"
+                b = Bs
+            else
+                b = view(Bs, 1:n, 1)
+            end
+            @test a*(lua\b) ≈ b
         end
-        @test a*(lua\b) ≈ b
+    end
+    @test @inferred(det(a)) ≈ det(Array{Float64}(a))
+end
+
+@testset "Rational{BigInt} and BigFloat Hilbert Matrix" begin
+    ## Hilbert Matrix (very ill conditioned)
+    ## Testing Rational{BigInt} and BigFloat version
+    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
+    setprecision(2^10) do
+        @test norm(Array{Float64}(inv(float(H)) - float(Hinv))) < 1e-100
     end
 end
-@test @inferred(det(a)) ≈ det(Array{Float64}(a))
-## Hilbert Matrix (very ill conditioned)
-## Testing Rational{BigInt} and BigFloat version
-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
-setprecision(2^10) do
-    @test norm(Array{Float64}(inv(float(H)) - float(Hinv))) < 1e-100
+
+@testset "Balancing in eigenvector calculations" begin
+    for elty in (Float32, Float64, Complex64, Complex128)
+        A = convert(Matrix{elty}, [ 3.0     -2.0      -0.9     2*eps(real(one(elty)));
+                                   -2.0      4.0       1.0    -eps(real(one(elty)));
+                                   -eps(real(one(elty)))/4  eps(real(one(elty)))/2  -1.0     0;
+                                   -0.5     -0.5       0.1     1.0])
+        F = eigfact(A, permute=false, scale=false)
+        eig(A, permute=false, scale=false)
+        @test F[:vectors]*Diagonal(F[:values])/F[:vectors] ≈ A
+        F = eigfact(A)
+        # @test norm(F[:vectors]*Diagonal(F[:values])/F[:vectors] - A) > 0.01
+    end
 end
 
-# Test balancing in eigenvector calculations
-for elty in (Float32, Float64, Complex64, Complex128)
-    A = convert(Matrix{elty}, [ 3.0     -2.0      -0.9     2*eps(real(one(elty)));
-                               -2.0      4.0       1.0    -eps(real(one(elty)));
-                               -eps(real(one(elty)))/4  eps(real(one(elty)))/2  -1.0     0;
-                               -0.5     -0.5       0.1     1.0])
-    F = eigfact(A, permute=false, scale=false)
-    eig(A, permute=false, scale=false)
-    @test F[:vectors]*Diagonal(F[:values])/F[:vectors] ≈ A
-    F = eigfact(A)
-    # @test norm(F[:vectors]*Diagonal(F[:values])/F[:vectors] - A) > 0.01
+@testset "logdet" begin
+    @test @inferred(logdet(Complex64[1.0f0 0.5f0; 0.5f0 -1.0f0])) === 0.22314355f0 + 3.1415927f0im
+    @test_throws DomainError logdet([1 1; 1 -1])
 end
 
-@test @inferred(logdet(Complex64[1.0f0 0.5f0; 0.5f0 -1.0f0])) === 0.22314355f0 + 3.1415927f0im
-@test_throws DomainError logdet([1 1; 1 -1])
+@testset "Issue 21453" begin
+    @test_throws ArgumentError LinAlg._cond1Inf(lufact(randn(5,5)), 2, 2.0)
+end
+
+@testset "Singular LU" begin
+    @test !LinAlg.issuccess(lufact(zeros(3,3)))
+end
diff --git a/test/linalg/matmul.jl b/test/linalg/matmul.jl
index 7ee9e13b85eebf..406d306dd49cc9 100644
--- a/test/linalg/matmul.jl
+++ b/test/linalg/matmul.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base.Test
 
@@ -249,14 +249,18 @@ end
 # issue #6450
 @test dot(Any[1.0,2.0], Any[3.5,4.5]) === 12.5
 
-for elty in (Float32,Float64,Complex64,Complex128)
-    x = convert(Vector{elty},[1.0,2.0,3.0])
-    y = convert(Vector{elty},[3.5,4.5,5.5])
+@testset "dot" for elty in (Float32, Float64, Complex64, Complex128)
+    x = convert(Vector{elty},[1.0, 2.0, 3.0])
+    y = convert(Vector{elty},[3.5, 4.5, 5.5])
     @test_throws DimensionMismatch dot(x, 1:2, y, 1:3)
     @test_throws BoundsError dot(x, 1:4, y, 1:4)
     @test_throws BoundsError dot(x, 1:3, y, 2:4)
-    @test dot(x,1:2,y,1:2) == convert(elty,12.5)
-    @test x.'*y == convert(elty,29.0)
+    @test dot(x, 1:2,y, 1:2) == convert(elty, 12.5)
+    @test x.'*y == convert(elty, 29.0)
+    @test_throws MethodError dot(rand(elty, 2, 2), randn(elty, 2, 2))
+    X = convert(Vector{Matrix{elty}},[reshape(1:4, 2, 2), ones(2, 2)])
+    res = convert(Matrix{elty}, [7.0 13.0; 13.0 27.0])
+    @test dot(X, X) == res
 end
 
 vecdot_(x,y) = invoke(vecdot, Tuple{Any,Any}, x,y) # generic vecdot
@@ -348,8 +352,8 @@ let
     eltypes = [Float32, Float64, Int64]
     for k in [3, 4, 10]
         T = rand(eltypes)
-        bi1 = Bidiagonal(rand(T, k), rand(T, k-1), rand(Bool))
-        bi2 = Bidiagonal(rand(T, k), rand(T, k-1), rand(Bool))
+        bi1 = Bidiagonal(rand(T, k), rand(T, k-1), rand([:U, :L]))
+        bi2 = Bidiagonal(rand(T, k), rand(T, k-1), rand([:U, :L]))
         tri1 = Tridiagonal(rand(T,k-1), rand(T, k), rand(T, k-1))
         tri2 = Tridiagonal(rand(T,k-1), rand(T, k), rand(T, k-1))
         stri1 = SymTridiagonal(rand(T, k), rand(T, k-1))
@@ -371,8 +375,8 @@ let
         end
     end
     for T in eltypes
-        A = Bidiagonal(rand(T, 2), rand(T, 1), rand(Bool))
-        B = Bidiagonal(rand(T, 2), rand(T, 1), rand(Bool))
+        A = Bidiagonal(rand(T, 2), rand(T, 1), rand([:U, :L]))
+        B = Bidiagonal(rand(T, 2), rand(T, 1), rand([:U, :L]))
         C = randn(2,2)
         test_mul(C, A, B)
         B = randn(2, 9)
diff --git a/test/linalg/pinv.jl b/test/linalg/pinv.jl
index e01c0e253c1bd7..f1f7745658061d 100644
--- a/test/linalg/pinv.jl
+++ b/test/linalg/pinv.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #
 #  Test the pseudo-inverse
diff --git a/test/linalg/qr.jl b/test/linalg/qr.jl
index b1f48325fcb1ac..d9b73fc576b5eb 100644
--- a/test/linalg/qr.jl
+++ b/test/linalg/qr.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 debug = false
 using Base.Test
@@ -60,10 +60,13 @@ debug && println("QR decomposition (without pivoting)")
                     ac = copy(a)
                     @test qrfact!(a[:, 1:5])\b == qrfact!(view(ac, :, 1:5))\b
                 end
+                rstring = sprint(show,r)
+                qstring = sprint(show,q)
+                @test sprint(show,qra) == "$(typeof(qra)) with factors Q and R:\n$qstring\n$rstring"
 
 debug && println("Thin QR decomposition (without pivoting)")
-                qra   = @inferred qrfact(a[:,1:n1], Val{false})
-                @inferred qr(a[:,1:n1], Val{false})
+                qra   = @inferred qrfact(a[:,1:n1], Val(false))
+                @inferred qr(a[:,1:n1], Val(false))
                 q,r   = qra[:Q], qra[:R]
                 @test_throws KeyError qra[:Z]
                 @test q'*full(q, thin=false) ≈ eye(n)
@@ -79,8 +82,8 @@ debug && println("Thin QR decomposition (without pivoting)")
                 end
 
 debug && println("(Automatic) Fat (pivoted) QR decomposition")
-                @inferred qrfact(a, Val{true})
-                @inferred qr(a, Val{true})
+                @inferred qrfact(a, Val(true))
+                @inferred qr(a, Val(true))
 
                 qrpa  = factorize(a[1:n1,:])
                 q,r = qrpa[:Q], qrpa[:R]
@@ -131,7 +134,7 @@ debug && println("Matmul with QR factorizations")
             @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})
+            qra = qrfact(a[:,1:n1], Val(false))
             q, r = qra[:Q], qra[:R]
             @test A_mul_B!(full(q, thin=false)',q) ≈ eye(n)
             @test_throws DimensionMismatch A_mul_B!(eye(eltya,n+1),q)
@@ -146,8 +149,8 @@ end
 # Because transpose(x) == x
 @test_throws ErrorException transpose(qrfact(randn(3,3)))
 @test_throws ErrorException ctranspose(qrfact(randn(3,3)))
-@test_throws ErrorException transpose(qrfact(randn(3,3), Val{false}))
-@test_throws ErrorException ctranspose(qrfact(randn(3,3), Val{false}))
+@test_throws ErrorException transpose(qrfact(randn(3,3), Val(false)))
+@test_throws ErrorException ctranspose(qrfact(randn(3,3), Val(false)))
 @test_throws ErrorException transpose(qrfact(big.(randn(3,3))))
 @test_throws ErrorException ctranspose(qrfact(big.(randn(3,3))))
 
@@ -180,3 +183,11 @@ B = rand(7,2)
 
 # Issue 16520
 @test_throws DimensionMismatch ones(3,2)\(1:5)
+
+# Issue 22810
+let
+    A = zeros(1, 2)
+    B = zeros(1, 1)
+    @test A \ B == zeros(2, 1)
+    @test qrfact(A, Val(true)) \ B == zeros(2, 1)
+end
diff --git a/test/linalg/rowvector.jl b/test/linalg/rowvector.jl
index f188a3082c0004..832510c243ba11 100644
--- a/test/linalg/rowvector.jl
+++ b/test/linalg/rowvector.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 @testset "Core" begin
     v = [1,2,3]
@@ -73,7 +73,7 @@ end
 end
 
 @testset "Bidiagonal ambiguity methods" begin
-    bd = Bidiagonal([1,2,3], [0,0], true)
+    bd = Bidiagonal([1,2,3], [0,0], :U)
     v = [2,3,4]
     rv = v.'
 
@@ -236,6 +236,14 @@ end
     @test_throws DimensionMismatch ut\rv
 end
 
+@testset "Symmetric/Hermitian ambiguity methods" begin
+    S = Symmetric(rand(3, 3))
+    H = Hermitian(rand(3, 3))
+    v = (rand(3)')::RowVector
+    @test_throws DimensionMismatch S\v
+    @test_throws DimensionMismatch H\v
+end
+
 # issue #20389
 @testset "1 row/col vec*mat" begin
     let x=[1,2,3], A=ones(1,4), y=x', B=A', C=x.*A
@@ -249,3 +257,38 @@ end
         @test A'*x' == A'*y == B*x' == B*y == C'
     end
 end
+
+@testset "issue #20979" begin
+    f20979(z::Complex) = [z.re -z.im; z.im z.re]
+    v = [1+2im]'
+    @test (f20979.(v))[1] == f20979(v[1])
+    @test f20979.(v) == f20979.(collect(v))
+
+    w = rand(Complex128, 3)
+    @test f20979.(v') == f20979.(collect(v')) == (f20979.(v))'
+
+    g20979(x, y) = [x[2,1] x[1,2]; y[1,2] y[2,1]]
+    v = [rand(2,2), rand(2,2), rand(2,2)]
+    @test g20979.(v', v') == g20979.(collect(v'), collect(v')) ==
+          map(g20979, v', v') == map(g20979, collect(v'), collect(v'))
+end
+
+@testset "ambiguity between * methods with RowVectors and ConjRowVectors (#20971)" begin
+    @test RowVector(ConjArray(ones(4))) * ones(4) == 4
+end
+
+@testset "setindex!/getindex" begin
+    v = [2, 3, 4]
+    rv = v.'
+    @test_throws BoundsError setindex!(rv, 5, CartesianIndex((5, 4, 3)))
+    rv[CartesianIndex((1, 1, 1))] = 5
+    @test_throws BoundsError getindex(rv, CartesianIndex((5, 4, 3)))
+    @test rv[1] == 5
+
+    v = [1]
+    rv = v.'
+    rv[CartesianIndex()] = 2
+    @test rv[CartesianIndex()] == 2
+    rv[CartesianIndex(1)] = 1
+    @test rv[CartesianIndex(1)] == 1
+end
diff --git a/test/linalg/schur.jl b/test/linalg/schur.jl
index 1eff3f4885e3a1..953c250c8ff3c2 100644
--- a/test/linalg/schur.jl
+++ b/test/linalg/schur.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base.Test
 
@@ -38,6 +38,19 @@ aimg  = randn(n,n)/2
         @test AbstractArray(f) ≈ a
         @test_throws KeyError f[:A]
 
+        sch, vecs, vals = schur(UpperTriangular(triu(a)))
+        @test vecs*sch*vecs' ≈ triu(a)
+        sch, vecs, vals = schur(LowerTriangular(tril(a)))
+        @test vecs*sch*vecs' ≈ tril(a)
+        sch, vecs, vals = schur(Hermitian(asym))
+        @test vecs*sch*vecs' ≈ asym
+        sch, vecs, vals = schur(Symmetric(a+a.'))
+        @test vecs*sch*vecs' ≈ a + a.'
+
+        tstring = sprint(show,f[:T])
+        zstring = sprint(show,f[:Z])
+        vstring = sprint(show,f[:values])
+        @test sprint(show,f) == "$(typeof(f)) with factors T and Z:\n$tstring\n$(zstring)\nand values:\n$vstring"
         @testset "Reorder Schur" begin
             # use asym for real schur to enforce tridiag structure
             # avoiding partly selection of conj. eigenvalues
diff --git a/test/linalg/special.jl b/test/linalg/special.jl
index f7d073bd05b28f..e65a7c14309b8d 100644
--- a/test/linalg/special.jl
+++ b/test/linalg/special.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base.Test
 debug = false
@@ -16,7 +16,7 @@ let a=[1.0:n;]
 
    for isupper in (true, false)
        debug && println("isupper is $(isupper)")
-       A=Bidiagonal(a, [1.0:n-1;], isupper)
+       A=Bidiagonal(a, [1.0:n-1;], ifelse(isupper, :U, :L))
        for newtype in [Bidiagonal, Tridiagonal, Matrix]
            debug && println("newtype is $(newtype)")
            @test full(convert(newtype, A)) == full(A)
@@ -26,7 +26,7 @@ let a=[1.0:n;]
        tritype = isupper ? UpperTriangular : LowerTriangular
        @test full(tritype(A)) == full(A)
 
-       A=Bidiagonal(a, zeros(n-1), isupper) #morally Diagonal
+       A=Bidiagonal(a, zeros(n-1), ifelse(isupper, :U, :L)) #morally Diagonal
        for newtype in [Diagonal, Bidiagonal, SymTridiagonal, Tridiagonal, Matrix]
            debug && println("newtype is $(newtype)")
            @test full(convert(newtype, A)) == full(A)
@@ -117,10 +117,10 @@ for typ in [UpperTriangular,LowerTriangular,Base.LinAlg.UnitUpperTriangular,Base
     a = rand(n,n)
     atri = typ(a)
     b = rand(n,n)
-    qrb = qrfact(b,Val{true})
+    qrb = qrfact(b,Val(true))
     @test Base.LinAlg.A_mul_Bc(atri,qrb[:Q]) ≈ full(atri) * qrb[:Q]'
     @test Base.LinAlg.A_mul_Bc!(copy(atri),qrb[:Q]) ≈ full(atri) * qrb[:Q]'
-    qrb = qrfact(b,Val{false})
+    qrb = qrfact(b,Val(false))
     @test Base.LinAlg.A_mul_Bc(atri,qrb[:Q]) ≈ full(atri) * qrb[:Q]'
     @test Base.LinAlg.A_mul_Bc!(copy(atri),qrb[:Q]) ≈ full(atri) * qrb[:Q]'
 end
@@ -129,7 +129,7 @@ end
 let N = 4
     # Test concatenating pairwise combinations of special matrices
     diagmat = Diagonal(ones(N))
-    bidiagmat = Bidiagonal(ones(N), ones(N-1), true)
+    bidiagmat = Bidiagonal(ones(N), ones(N-1), :U)
     tridiagmat = Tridiagonal(ones(N-1), ones(N), ones(N-1))
     symtridiagmat = SymTridiagonal(ones(N), ones(N-1))
     specialmats = (diagmat, bidiagmat, tridiagmat, symtridiagmat)
@@ -182,7 +182,7 @@ let
     spvec = spzeros(N)
     spmat = speye(N)
     diagmat = Diagonal(ones(N))
-    bidiagmat = Bidiagonal(ones(N), ones(N-1), true)
+    bidiagmat = Bidiagonal(ones(N), ones(N-1), :U)
     tridiagmat = Tridiagonal(ones(N-1), ones(N), ones(N-1))
     symtridiagmat = SymTridiagonal(ones(N), ones(N-1))
     sparseconcatmats = testfull ? (spmat, diagmat, bidiagmat, tridiagmat, symtridiagmat) : (spmat, diagmat)
@@ -247,3 +247,6 @@ let
         end
     end
 end
+@testset "vcat of Vectors with SparseVectors should yield SparseVector (#22225)" begin
+    @test isa((@inferred vcat(Float64[], spzeros(1))), SparseVector)
+end
diff --git a/test/linalg/svd.jl b/test/linalg/svd.jl
index 5e26babf44cd60..d85d4eae26f6e3 100644
--- a/test/linalg/svd.jl
+++ b/test/linalg/svd.jl
@@ -1,9 +1,34 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base.Test
 
 using Base.LinAlg: BlasComplex, BlasFloat, BlasReal, QRPivoted
 
+@testset "Simple svdvals / svdfact tests" begin
+    ≊(x,y) = isapprox(x,y,rtol=1e-15)
+
+    m1 = [2 0; 0 0]
+    m2 = [2 -2; 1 1]/sqrt(2)
+    m2c = Complex.([2 -2; 1 1]/sqrt(2))
+    @test @inferred(svdvals(m1))  ≊ [2, 0]
+    @test @inferred(svdvals(m2))  ≊ [2, 1]
+    @test @inferred(svdvals(m2c)) ≊ [2, 1]
+
+    sf1 = svdfact(m1)
+    sf2 = svdfact(m2)
+    @test sf1.S ≊ [2, 0]
+    @test sf2.S ≊ [2, 1]
+    # U & Vt are unitary
+    @test sf1.U*sf1.U'   ≊ eye(2)
+    @test sf1.Vt*sf1.Vt' ≊ eye(2)
+    @test sf2.U*sf2.U'   ≊ eye(2)
+    @test sf2.Vt*sf2.Vt' ≊ eye(2)
+    # SVD not uniquely determined, so just test we can reconstruct the
+    # matrices from the factorization as expected.
+    @test sf1.U*Diagonal(sf1.S)*sf1.Vt' ≊ m1
+    @test sf2.U*Diagonal(sf2.S)*sf2.Vt' ≊ m2
+end
+
 n = 10
 
 # Split n into 2 parts for tests needing two matrices
@@ -79,3 +104,25 @@ a2img  = randn(n,n)/2
         end
     end
 end
+
+@testset "Number input" begin
+    x, y = randn(2)
+    @test svdfact(x)    == svdfact(      fill(x, 1, 1))
+    @test svdvals(x)    == first(svdvals(fill(x, 1, 1)))
+    @test svd(x)        == first.(svd(   fill(x, 1, 1)))
+    @test svdfact(x, y) == svdfact(      fill(x, 1, 1), fill(y, 1, 1))
+    @test svdvals(x, y) == first(svdvals(fill(x, 1, 1), fill(y, 1, 1)))
+    @test svd(x, y)     == first.(svd(   fill(x, 1, 1), fill(y, 1, 1)))
+end
+
+@testset "isequal, ==, and hash" begin
+    x, y   = rand(), NaN
+    Fx, Fy = svdfact(x), svdfact(y)
+    @test   Fx == Fx
+    @test !(Fy == Fy)
+    @test isequal(Fy, Fy)
+    @test hash(Fx)          == hash(Fx)
+    @test hash(Fx, UInt(1)) == hash(Fx, UInt(1))
+    @test hash(Fy)          == hash(Fy)
+    @test hash(Fy, UInt(1)) == hash(Fy, UInt(1))
+end
diff --git a/test/linalg/symmetric.jl b/test/linalg/symmetric.jl
index 0ec3b7beaf2d5c..6f07be75a3adc5 100644
--- a/test/linalg/symmetric.jl
+++ b/test/linalg/symmetric.jl
@@ -1,26 +1,24 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base.Test
 
 srand(101)
-debug = false #Turn on for more debugging info
 
-#Pauli σ-matrices
-for σ in map(Hermitian, Any[ eye(2), [0 1; 1 0], [0 -im; im 0], [1 0; 0 -1] ])
+@testset "Pauli σ-matrices: $σ" for σ in map(Hermitian,
+        Any[ eye(2), [0 1; 1 0], [0 -im; im 0], [1 0; 0 -1] ])
     @test ishermitian(σ)
 end
 
-# Hermitian matrix exponential/log
-let A1 = randn(4,4) + im*randn(4,4)
+@testset "Hermitian matrix exponential/log" begin
+    A1 = randn(4,4) + im*randn(4,4)
     A2 = A1 + A1'
     @test expm(A2) ≈ expm(Hermitian(A2))
     @test logm(A2) ≈ logm(Hermitian(A2))
     A3 = A1 * A1' # posdef
     @test expm(A3) ≈ expm(Hermitian(A3))
     @test logm(A3) ≈ logm(Hermitian(A3))
-end
 
-let A1 = randn(4,4)
+    A1 = randn(4,4)
     A3 = A1 * A1'
     A4 = A1 + A1.'
     @test expm(A4) ≈ expm(Symmetric(A4))
@@ -28,13 +26,16 @@ let A1 = randn(4,4)
     @test logm(A3) ≈ logm(Hermitian(A3))
 end
 
-let n=10
+@testset "Core functionality" begin
+    n = 10
     areal = randn(n,n)/2
     aimg  = randn(n,n)/2
-    debug && println("symmetric eigendecomposition")
-    for eltya in (Float32, Float64, Complex64, Complex128, BigFloat, Int)
+    @testset for eltya in (Float32, Float64, Complex64, Complex128, BigFloat, Int)
         a = eltya == Int ? rand(1:7, n, n) : convert(Matrix{eltya}, eltya <: Complex ? complex.(areal, aimg) : areal)
-        asym = a'+a                 # symmetric indefinite
+        asym = a.'+a                 # symmetric indefinite
+        aherm = a'+a                 # Hermitian indefinite
+        apos  = a'*a                 # Hermitian positive definite
+        aposs = apos + apos.'        # Symmetric positive definite
         ε = εa = eps(abs(float(one(eltya))))
 
         x = randn(n)
@@ -43,204 +44,320 @@ let n=10
         x = eltya == Int ? rand(1:7, n) : convert(Vector{eltya}, eltya <: Complex ? complex.(x, zeros(n)) : x)
         y = eltya == Int ? rand(1:7, n) : convert(Vector{eltya}, eltya <: Complex ? complex.(y, zeros(n)) : y)
         b = eltya == Int ? rand(1:7, n, n) : convert(Matrix{eltya}, eltya <: Complex ? complex.(b, zeros(n,n)) : b)
+        @testset "basic ops" begin
+            @testset "constructor" begin
+                @test Symmetric(Symmetric(asym, :U))     === Symmetric(asym, :U)
+                @test Hermitian(Hermitian(aherm, :U))    === Hermitian(aherm, :U)
+                @test Symmetric(Symmetric(asym, :U), :U) === Symmetric(asym, :U)
+                @test Hermitian(Hermitian(aherm, :U), :U) === Hermitian(aherm, :U)
+                @test_throws ArgumentError Symmetric(Symmetric(asym, :U), :L)
+                @test_throws ArgumentError Hermitian(Hermitian(aherm, :U), :L)
+                # mixed cases with Hermitian/Symmetric
+                if eltya <: Real
+                    @test Symmetric(Hermitian(aherm, :U))     === Symmetric(aherm, :U)
+                    @test Hermitian(Symmetric(asym, :U))     === Hermitian(asym, :U)
+                    @test Symmetric(Hermitian(aherm, :U), :U) === Symmetric(aherm, :U)
+                    @test Hermitian(Symmetric(asym, :U), :U) === Hermitian(asym, :U)
+                    @test_throws ArgumentError Symmetric(Hermitian(aherm, :U), :L)
+                    @test_throws ArgumentError Hermitian(Symmetric(aherm, :U), :L)
+                end
+            end
+            @testset "similar" begin
+                @test isa(similar(Symmetric(asym)), Symmetric{eltya})
+                @test isa(similar(Hermitian(aherm)), Hermitian{eltya})
+                @test isa(similar(Symmetric(asym), Int), Symmetric{Int})
+                @test isa(similar(Hermitian(aherm), Int), Hermitian{Int})
+                @test isa(similar(Symmetric(asym), (3,2)), Matrix{eltya})
+                @test isa(similar(Hermitian(aherm), (3,2)), Matrix{eltya})
+                @test isa(similar(Symmetric(asym), Int, (3,2)), Matrix{Int})
+                @test isa(similar(Hermitian(aherm), Int, (3,2)), Matrix{Int})
+            end
+            @testset "full" begin
+                @test asym  == full(Symmetric(asym))
+                @test aherm == full(Hermitian(aherm))
+            end
 
-        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))
+            @testset "parent" begin
+                @test asym === parent(Symmetric(asym))
+                @test aherm === parent(Hermitian(aherm))
+            end
 
-        # parent
+            @testset "getindex and unsafe_getindex" begin
+                @test aherm[1,1] == Hermitian(aherm)[1,1]
+                @test asym[1,1] == Symmetric(asym)[1,1]
+                @test Symmetric(asym)[1:2,1:2] == asym[1:2,1:2]
+                @test Hermitian(aherm)[1:2,1:2] == aherm[1:2,1:2]
+            end
 
-        @test asym == parent(Hermitian(asym))
+            @testset "conversion" begin
+                @test Symmetric(asym) == convert(Symmetric,Symmetric(asym))
+                if eltya <: Real
+                    typs = [Float16,Float32,Float64]
+                    for typ in typs
+                        @test Symmetric(convert(Matrix{typ},asym)) == convert(Symmetric{typ,Matrix{typ}},Symmetric(asym))
+                    end
+                end
+                if eltya <: Complex
+                    typs = [Complex64,Complex128]
+                    for typ in typs
+                        @test Symmetric(convert(Matrix{typ},asym)) == convert(Symmetric{typ,Matrix{typ}},Symmetric(asym))
+                        @test Hermitian(convert(Matrix{typ},aherm)) == convert(Hermitian{typ,Matrix{typ}},Hermitian(aherm))
+                    end
+                end
+            end
 
-        # getindex
-        @test asym[1,1] == Hermitian(asym)[1,1]
-        @test asym[1,1] == Symmetric(asym)[1,1]
+            @testset "issymmetric, ishermitian" begin
+                @test issymmetric(Symmetric(asym))
+                @test ishermitian(Hermitian(aherm))
+                if eltya <: Real
+                    @test ishermitian(Symmetric(asym))
+                elseif eltya <: Complex
+                    # test that zero imaginary component is
+                    # handled properly
+                    @test ishermitian(Symmetric(b + b'))
+                end
+            end
 
-        #trace
-        @test trace(asym) == trace(Hermitian(asym))
+            @testset "tril/triu" begin
+                for di in -n:n
+                    @test triu(Symmetric(asym), di) == triu(asym, di)
+                    @test tril(Symmetric(asym), di) == tril(asym, di)
+                    @test triu(Hermitian(aherm), di) == triu(aherm, di)
+                    @test tril(Hermitian(aherm), di) == tril(aherm, di)
+                    @test triu(Symmetric(asym, :L), di) == triu(asym, di)
+                    @test tril(Symmetric(asym, :L), di) == tril(asym, di)
+                    @test triu(Hermitian(aherm, :L), di) == triu(aherm, di)
+                    @test tril(Hermitian(aherm, :L), di) == tril(aherm, di)
+                end
+            end
 
-        # issymmetric, ishermitian
-        if eltya <: Real
-            @test issymmetric(Symmetric(asym))
-            @test ishermitian(Symmetric(asym))
-        end
-        if eltya <: Complex
-            @test ishermitian(Symmetric(b + b'))
+            @testset "transpose, ctranspose" begin
+                S = Symmetric(asym)
+                H = Hermitian(aherm)
+                @test  transpose(S) === S == asym
+                @test ctranspose(H) === H == aherm
+                if eltya <: Real
+                    @test ctranspose(S) === S == asym
+                    @test  transpose(H) === H == aherm
+                else
+                    @test ctranspose(S) ==  Symmetric(conj(asym))
+                    @test  transpose(H) ==  Hermitian(transpose(aherm))
+                end
+            end
         end
 
-        #transpose, ctranspose
-        if eltya <: Real
-            @test transpose(Symmetric(asym)) == asym
-        else
-            @test transpose(Hermitian(asym)) == transpose(asym)
-        end
-        @test ctranspose(Symmetric(asym)) == Symmetric(conj(asym))
-        @test ctranspose(Hermitian(asym)) == asym
-
-        #tril/triu
-        for di in -n:n
-            @test triu(Symmetric(a+a.'),di) == triu(a+a.',di)
-            @test tril(Symmetric(a+a.'),di) == tril(a+a.',di)
-            @test triu(Hermitian(asym),di) == triu(asym,di)
-            @test tril(Hermitian(asym),di) == tril(asym,di)
-            @test triu(Symmetric(a+a.',:L),di) == triu(a+a.',di)
-            @test tril(Symmetric(a+a.',:L),di) == tril(a+a.',di)
-            @test triu(Hermitian(asym,:L),di) == triu(asym,di)
-            @test tril(Hermitian(asym,:L),di) == tril(asym,di)
-        end
+        @testset "linalg unary ops" begin
+            @testset "trace" begin
+                @test trace(asym) == trace(Symmetric(asym))
+                @test trace(aherm) == trace(Hermitian(aherm))
+            end
 
-        eltya == BigFloat && continue # Revisit when implemented in julia
-        d, v = eig(asym)
-        @test asym*v[:,1] ≈ d[1]*v[:,1]
-        @test v*Diagonal(d)*v' ≈ asym
-        @test isequal(eigvals(asym[1]), eigvals(asym[1:1,1:1]))
-        @test abs.(eigfact(Hermitian(asym), 1:2)[:vectors]'v[:,1:2]) ≈ eye(eltya, 2)
-        eig(Hermitian(asym), 1:2) # same result, but checks that method works
-        @test abs.(eigfact(Hermitian(asym), d[1] - 1, (d[2] + d[3])/2)[:vectors]'v[:,1:2]) ≈ eye(eltya, 2)
-        eig(Hermitian(asym), d[1] - 1, (d[2] + d[3])/2) # same result, but checks that method works
-        @test eigvals(Hermitian(asym), 1:2) ≈ d[1:2]
-        @test eigvals(Hermitian(asym), d[1] - 1, (d[2] + d[3])/2) ≈ d[1:2]
-        @test full(eigfact(asym)) ≈ asym
-
-        # relation to svdvals
-        @test sum(sort(abs.(eigvals(Hermitian(asym))))) == sum(sort(svdvals(Hermitian(asym))))
-
-        # 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]'
-            # Make sure A is Hermitian even in the present of rounding error
-            # xianyi/OpenBLAS#729
-            A = (A' + A) / 2
-            @test rank(A) == rank(Hermitian(A))
-        end
+            @testset "isposdef[!]" begin
+                @test isposdef(Symmetric(asym))  == isposdef(asym)
+                @test isposdef(Symmetric(aposs)) == isposdef(aposs) == true
+                @test isposdef(Hermitian(aherm)) == isposdef(aherm)
+                @test isposdef(Hermitian(apos))  == isposdef(apos) == true
+                if eltya != Int #chol! won't work with Int
+                    @test isposdef!(Symmetric(copy(asym)))  == isposdef(asym)
+                    @test isposdef!(Symmetric(copy(aposs))) == isposdef(aposs) == true
+                    @test isposdef!(Hermitian(copy(aherm))) == isposdef(aherm)
+                    @test isposdef!(Hermitian(copy(apos)))  == isposdef(apos) == true
+                end
+            end
 
-        # mat * vec
-        if eltya <: Complex
-            @test Hermitian(asym)*x+y ≈ asym*x+y
-        end
-        if eltya <: Real && eltya != Int
-            @test Symmetric(asym)*x+y ≈ asym*x+y
-        end
+            @testset "$f" for f in (det, logdet, logabsdet)
+                for uplo in (:U, :L)
+                    @test all(f(apos)  .≈ f(Hermitian(apos, uplo)))
+                    @test all(f(aposs) .≈ f(Symmetric(aposs, uplo)))
+                    if f != logdet
+                        @test all(f(aherm) .≈ f(Hermitian(aherm, uplo)))
+                        @test all(f(asym)  .≈ f(Symmetric(asym, uplo)))
+                    end
+                end
+            end
 
-        C = zeros(eltya,n,n)
-        # mat * mat
-        if eltya <: Complex
-            @test Hermitian(asym) * a ≈ asym * a
-            @test a * Hermitian(asym) ≈ a * asym
-            @test Hermitian(asym) * Hermitian(asym) ≈ asym*asym
-            @test_throws DimensionMismatch Hermitian(asym) * ones(eltya,n+1)
-            Base.LinAlg.A_mul_B!(C,a,Hermitian(asym))
-            @test C ≈ a*asym
-        end
-        if eltya <: Real && eltya != Int
-            @test Symmetric(asym) * Symmetric(asym) ≈ asym*asym
-            @test Symmetric(asym) * a ≈ asym * a
-            @test a * Symmetric(asym) ≈ a * asym
-            @test_throws DimensionMismatch Symmetric(asym) * ones(eltya,n+1)
-            Base.LinAlg.A_mul_B!(C,a,Symmetric(asym))
-            @test C ≈ a*asym
+            # Revisit when implemented in julia
+            if eltya != BigFloat
+                @testset "cond" begin
+                    if eltya <: Real #svdvals! has no method for Symmetric{Complex}
+                        @test cond(Symmetric(asym)) ≈ cond(asym)
+                    end
+                    @test cond(Hermitian(aherm)) ≈ cond(aherm)
+                end
+
+                @testset "inversion" begin
+                    @test inv(Symmetric(asym)) ≈ inv(asym)
+                    @test inv(Hermitian(aherm)) ≈ inv(aherm)
+                    for uplo in (:U, :L)
+                        @test inv(Symmetric(asym, uplo)) ≈ inv(full(Symmetric(asym, uplo)))
+                        @test inv(Hermitian(aherm, uplo)) ≈ inv(full(Hermitian(aherm, uplo)))
+                        @test inv(Symmetric(a, uplo)) ≈ inv(full(Symmetric(a, uplo)))
+                        if eltya <: Real
+                            @test inv(Hermitian(a, uplo)) ≈ inv(full(Hermitian(a, uplo)))
+                        end
+                    end
+                end
+
+                @testset "symmetric eigendecomposition" begin
+                    if eltya <: Real # the eigenvalues are only real and ordered for Hermitian matrices
+                        d, v = eig(asym)
+                        @test asym*v[:,1] ≈ d[1]*v[:,1]
+                        @test v*Diagonal(d)*v.' ≈ asym
+                        @test isequal(eigvals(asym[1]), eigvals(asym[1:1,1:1]))
+                        @test abs.(eigfact(Symmetric(asym), 1:2)[:vectors]'v[:,1:2]) ≈ eye(eltya, 2)
+                        eig(Symmetric(asym), 1:2) # same result, but checks that method works
+                        @test abs.(eigfact(Symmetric(asym), d[1] - 1, (d[2] + d[3])/2)[:vectors]'v[:,1:2]) ≈ eye(eltya, 2)
+                        eig(Symmetric(asym), d[1] - 1, (d[2] + d[3])/2) # same result, but checks that method works
+                        @test eigvals(Symmetric(asym), 1:2) ≈ d[1:2]
+                        @test eigvals(Symmetric(asym), d[1] - 1, (d[2] + d[3])/2) ≈ d[1:2]
+                        # eigfact doesn't support Symmetric{Complex}
+                        @test full(eigfact(asym)) ≈ asym
+                        @test eigvecs(Symmetric(asym)) ≈ eigvecs(asym)
+                    end
+
+                    d, v = eig(aherm)
+                    @test aherm*v[:,1] ≈ d[1]*v[:,1]
+                    @test v*Diagonal(d)*v' ≈ aherm
+                    @test isequal(eigvals(aherm[1]), eigvals(aherm[1:1,1:1]))
+                    @test abs.(eigfact(Hermitian(aherm), 1:2)[:vectors]'v[:,1:2]) ≈ eye(eltya, 2)
+                    eig(Hermitian(aherm), 1:2) # same result, but checks that method works
+                    @test abs.(eigfact(Hermitian(aherm), d[1] - 1, (d[2] + d[3])/2)[:vectors]'v[:,1:2]) ≈ eye(eltya, 2)
+                    eig(Hermitian(aherm), d[1] - 1, (d[2] + d[3])/2) # same result, but checks that method works
+                    @test eigvals(Hermitian(aherm), 1:2) ≈ d[1:2]
+                    @test eigvals(Hermitian(aherm), d[1] - 1, (d[2] + d[3])/2) ≈ d[1:2]
+                    @test full(eigfact(aherm)) ≈ aherm
+                    @test eigvecs(Hermitian(aherm)) ≈ eigvecs(aherm)
+
+                    # relation to svdvals
+                    if eltya <: Real #svdvals! has no method for Symmetric{Complex}
+                        @test sum(sort(abs.(eigvals(Symmetric(asym))))) == sum(sort(svdvals(Symmetric(asym))))
+                    end
+                    @test sum(sort(abs.(eigvals(Hermitian(aherm))))) == sum(sort(svdvals(Hermitian(aherm))))
+                end
+
+                @testset "rank" begin
+                    let A = a[:,1:5]*a[:,1:5]'
+                        # Make sure A is Hermitian even in the presence of rounding error
+                        # xianyi/OpenBLAS#729
+                        A = (A' + A) / 2
+                        @test rank(A) == rank(Hermitian(A))
+                    end
+                end
+
+                @testset "pow" begin
+                    # Integer power
+                    @test (asym)^2   ≈ (Symmetric(asym)^2)::Symmetric
+                    @test (asym)^-2  ≈ (Symmetric(asym)^-2)::Symmetric
+                    @test (aposs)^2  ≈ (Symmetric(aposs)^2)::Symmetric
+                    @test (aherm)^2  ≈ (Hermitian(aherm)^2)::Hermitian
+                    @test (aherm)^-2 ≈ (Hermitian(aherm)^-2)::Hermitian
+                    @test (apos)^2   ≈ (Hermitian(apos)^2)::Hermitian
+                    # integer floating point power
+                    @test (asym)^2.0   ≈ (Symmetric(asym)^2.0)::Symmetric
+                    @test (asym)^-2.0  ≈ (Symmetric(asym)^-2.0)::Symmetric
+                    @test (aposs)^2.0  ≈ (Symmetric(aposs)^2.0)::Symmetric
+                    @test (aherm)^2.0  ≈ (Hermitian(aherm)^2.0)::Hermitian
+                    @test (aherm)^-2.0 ≈ (Hermitian(aherm)^-2.0)::Hermitian
+                    @test (apos)^2.0   ≈ (Hermitian(apos)^2.0)::Hermitian
+                    # non-integer floating point power
+                    @test (asym)^2.5   ≈ (Symmetric(asym)^2.5)::Symmetric
+                    @test (asym)^-2.5  ≈ (Symmetric(asym)^-2.5)::Symmetric
+                    @test (aposs)^2.5  ≈ (Symmetric(aposs)^2.5)::Symmetric
+                    @test (aherm)^2.5  ≈ (Hermitian(aherm)^2.5)#::Hermitian
+                    @test (aherm)^-2.5 ≈ (Hermitian(aherm)^-2.5)#::Hermitian
+                    @test (apos)^2.5   ≈ (Hermitian(apos)^2.5)::Hermitian
+                end
+            end
         end
 
-        # solver
-        @test Hermitian(asym)\x ≈ asym\x
-        if eltya <: Real
-            @test Symmetric(asym)\x ≈ asym\x
-        end
+        @testset "linalg binary ops" begin
+            @testset "mat * vec" begin
+                @test Symmetric(asym)*x+y ≈ asym*x+y
+                @test x' * Symmetric(asym) ≈ x' * asym
 
-        #inversion
-        @test inv(Hermitian(asym)) ≈ inv(asym)
-        if eltya <: Real && eltya != Int
-            @test inv(Symmetric(asym)) ≈ inv(asym)
-            @test inv(Hermitian(a)) ≈ inv(full(Hermitian(a)))
-            @test inv(Symmetric(a)) ≈ inv(full(Symmetric(a)))
-        end
+                @test Hermitian(aherm)*x+y ≈ aherm*x+y
+                @test x' * Hermitian(aherm) ≈ x' * aherm
+            end
 
-        # conversion
-        @test Symmetric(asym) == convert(Symmetric,Symmetric(asym))
-        if eltya <: Real && eltya != Int
-            typs = [Float16,Float32,Float64]
-            for typ in typs
-                @test Symmetric(convert(Matrix{typ},asym)) == convert(Symmetric{typ,Matrix{typ}},Symmetric(asym))
+            @testset "mat * mat" begin
+                C = zeros(eltya,n,n)
+                @test Hermitian(aherm) * a ≈ aherm * a
+                @test a * Hermitian(aherm) ≈ a * aherm
+                @test Hermitian(aherm) * Hermitian(aherm) ≈ aherm*aherm
+                @test_throws DimensionMismatch Hermitian(aherm) * ones(eltya,n+1)
+                Base.LinAlg.A_mul_B!(C,a,Hermitian(aherm))
+                @test C ≈ a*aherm
+
+                @test Symmetric(asym) * Symmetric(asym) ≈ asym*asym
+                @test Symmetric(asym) * a ≈ asym * a
+                @test a * Symmetric(asym) ≈ a * asym
+                @test_throws DimensionMismatch Symmetric(asym) * ones(eltya,n+1)
+                Base.LinAlg.A_mul_B!(C,a,Symmetric(asym))
+                @test C ≈ a*asym
+
+                tri_b = UpperTriangular(triu(b))
+                @test Array(Hermitian(aherm).' * tri_b) ≈ aherm.' * Array(tri_b)
+                @test Array(tri_b * Hermitian(aherm).') ≈ Array(tri_b) * aherm.'
+                @test Array(Hermitian(aherm)' * tri_b) ≈ aherm' * Array(tri_b)
+                @test Array(tri_b * Hermitian(aherm)') ≈ Array(tri_b) * aherm'
+
+                @test Array(Symmetric(asym).' * tri_b) ≈ asym.' * Array(tri_b)
+                @test Array(tri_b * Symmetric(asym).') ≈ Array(tri_b) * asym.'
+                @test Array(Symmetric(asym)' * tri_b) ≈ asym' * Array(tri_b)
+                @test Array(tri_b * Symmetric(asym)') ≈ Array(tri_b) * asym'
             end
-        end
-        if eltya <: Complex && eltya != Int
-            typs = [Complex64,Complex128]
-            for typ in typs
-                @test Hermitian(convert(Matrix{typ},asym)) == convert(Hermitian{typ,Matrix{typ}},Hermitian(asym))
+            @testset "solver" begin
+                @test Hermitian(aherm)\x ≈ aherm\x
+                @test Hermitian(aherm)\b ≈ aherm\b
+                @test Symmetric(asym)\x  ≈ asym\x
+                @test Symmetric(asym)\b  ≈ asym\b
             end
         end
-
-        #unsafe_getindex
-        if eltya <: Real
-            @test Symmetric(asym)[1:2,1:2] == asym[1:2,1:2]
-        end
-        @test Hermitian(asym)[1:2,1:2] == asym[1:2,1:2]
     end
 end
 
-#Issue #7647: test xsyevr, xheevr, xstevr drivers
-for Mi7647 in (Symmetric(diagm(1.0:3.0)),
-               Hermitian(diagm(1.0:3.0)),
-               Hermitian(diagm(complex(1.0:3.0))),
-               SymTridiagonal([1.0:3.0;], zeros(2)))
-    debug && println("Eigenvalues in interval for $(typeof(Mi7647))")
+#Issue #7647: test xsyevr, xheevr, xstevr drivers.
+@testset "Eigenvalues in interval for $(typeof(Mi7647))" for Mi7647 in
+        (Symmetric(diagm(1.0:3.0)),
+         Hermitian(diagm(1.0:3.0)),
+         Hermitian(diagm(complex(1.0:3.0))),
+         SymTridiagonal([1.0:3.0;], zeros(2)))
     @test eigmin(Mi7647)  == eigvals(Mi7647, 0.5, 1.5)[1] == 1.0
     @test eigmax(Mi7647)  == eigvals(Mi7647, 2.5, 3.5)[1] == 3.0
     @test eigvals(Mi7647) == eigvals(Mi7647, 0.5, 3.5) == [1.0:3.0;]
 end
 
-#Issue #7933
-let A7933 = [1 2; 3 4]
+@testset "Issue #7933" begin
+    A7933 = [1 2; 3 4]
     B7933 = copy(A7933)
     C7933 = full(Symmetric(A7933))
     @test A7933 == B7933
 end
 
-# Issues #8057 and #8058
-for f in (eigfact, eigvals, eig)
-    for A in (Symmetric([0 1; 1 0]), Hermitian([0 im; -im 0]))
-        @test_throws ArgumentError f(A, 3, 2)
-        @test_throws ArgumentError f(A, 1:4)
-    end
+@testset "Issues #8057 and #8058. f=$f, A=$A" for f in
+        (eigfact, eigvals, eig),
+            A in (Symmetric([0 1; 1 0]), Hermitian([0 im; -im 0]))
+    @test_throws ArgumentError f(A, 3, 2)
+    @test_throws ArgumentError f(A, 1:4)
 end
 
-#Issue 10671
-let A = [1.0+im 2.0; 2.0 0.0]
+@testset "Issue #10671" begin
+    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)
+# Unary minus for Symmetric/Hermitian matrices
+@testset "Unary minus for Symmetric/Hermitian matrices" begin
+    A = randn(5, 5)
+    for SH in (Symmetric(A), Hermitian(A))
+        F = Matrix(SH)
+        @test (-SH)::typeof(SH) == -F
+    end
 end
 
-# 17780
-let a = randn(2,2)
+@testset "Issue #17780" begin
+    a = randn(2,2)
     a = a'a
     b = complex.(a,a)
     c = Symmetric(b)
@@ -253,8 +370,8 @@ let a = randn(2,2)
     @test conj!(c) == conj(Array(c))
 end
 
-# 19225
-let X = [1 -1; -1 1]
+@testset "Issue # 19225" begin
+    X = [1 -1; -1 1]
     for T in (Symmetric, Hermitian)
         Y = T(copy(X))
         _Y = similar(Y)
@@ -285,3 +402,41 @@ let X = [1 -1; -1 1]
     @test_throws ArgumentError Hermitian(X) + 2im*I
     @test_throws ArgumentError Hermitian(X) - 2im*I
 end
+
+@testset "Issue #21981" begin
+    B = complex(rand(4,4))
+    B[4,1] += 1im;
+    @test ishermitian(Symmetric(B, :U))
+    @test issymmetric(Hermitian(B, :U))
+    B[4,1]  = real(B[4,1])
+    B[1,4] += 1im
+    @test ishermitian(Symmetric(B, :L))
+    @test issymmetric(Hermitian(B, :L))
+end
+
+@testset "$HS solver with $RHS RHS - $T" for HS in (Hermitian, Symmetric),
+        RHS in (Hermitian, Symmetric, Diagonal, UpperTriangular, LowerTriangular),
+        T   in (Float64, Complex128)
+    D = rand(T, 10, 10); D = D'D
+    A = HS(D)
+    B = RHS(D)
+    @test A\B ≈ Matrix(A)\Matrix(B)
+end
+
+@testset "inversion of Hilbert matrix" begin
+    for T in (Float64, Complex128)
+        H = T[1/(i + j - 1) for i in 1:8, j in 1:8]
+        @test norm(inv(Symmetric(H))*(H*ones(8))-1) ≈ 0 atol = 1e-5
+        @test norm(inv(Hermitian(H))*(H*ones(8))-1) ≈ 0 atol = 1e-5
+    end
+end
+
+@testset "inverse edge case with complex Hermitian" begin
+    # Hermitian matrix, where inv(lufact(A)) generates non-real diagonal elements
+    for T in (Complex64, Complex128)
+        A = T[0.650488+0.0im 0.826686+0.667447im; 0.826686-0.667447im 1.81707+0.0im]
+        H = Hermitian(A)
+        @test inv(H) ≈ inv(A)
+        @test ishermitian(full(inv(H)))
+    end
+end
diff --git a/test/linalg/triangular.jl b/test/linalg/triangular.jl
index 829b8bee7e02a4..f6dbe41552cc0e 100644
--- a/test/linalg/triangular.jl
+++ b/test/linalg/triangular.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 debug = false
 using Base.Test
diff --git a/test/linalg/tridiag.jl b/test/linalg/tridiag.jl
index d6f12d402915d4..0130f43451d04d 100644
--- a/test/linalg/tridiag.jl
+++ b/test/linalg/tridiag.jl
@@ -1,7 +1,5 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
-module TridiagTest
-using Base.Test
 debug = false
 
 # basic tridiagonal operations
@@ -228,7 +226,7 @@ for elty in (Float32, Float64, Complex64, Complex128, Int)
 end
 
 #Test equivalence of eigenvectors/singular vectors taking into account possible phase (sign) differences
-function test_approx_eq_vecs{S<:Real,T<:Real}(a::StridedVecOrMat{S}, b::StridedVecOrMat{T}, error=nothing)
+function test_approx_eq_vecs(a::StridedVecOrMat{S}, b::StridedVecOrMat{T}, error=nothing) where {S<:Real,T<:Real}
     n = size(a, 1)
     @test n==size(b,1) && size(a,2)==size(b,2)
     error===nothing && (error=n^3*(eps(S)+eps(T)))
@@ -266,12 +264,12 @@ let n = 12 #Size of matrix problem to test
         @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
+        @test_throws BoundsError A[n + 1, 1] = 0 # test bounds check
+        @test_throws BoundsError A[1, n + 1] = 0 # test bounds check
+        @test ((A[3, 3] = A[3, 3]) == A[3, 3]; A == fA) # test assignment on the main diagonal
+        @test_throws ArgumentError A[3, 2] = 1 # test assignment on the subdiagonal
+        @test_throws ArgumentError A[2, 3] = 1 # test assignment on the superdiagonal
+        @test_throws ArgumentError A[1, 3] = 1 # test assignment off the main/sub/super diagonal
 
         debug && println("Diagonal extraction")
         @test diag(A,1) == b
@@ -459,12 +457,13 @@ let n = 12 #Size of matrix problem to test
         @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
+        @test_throws BoundsError A[n + 1, 1] = 0 # test bounds check
+        @test_throws BoundsError A[1, n + 1] = 0 # test bounds check
+        @test (A[3, 3] = A[3, 3]; A == fA) # test assignment on the main diagonal
+        @test (A[3, 2] = A[3, 2]; A == fA) # test assignment on the subdiagonal
+        @test (A[2, 3] = A[2, 3]; A == fA) # test assignment on the superdiagonal
+        @test ((A[1, 3] = 0) == 0; A == fA) # test zero assignment off the main/sub/super diagonal
+        @test_throws ArgumentError A[1, 3] = 1 # test non-zero assignment off the main/sub/super diagonal
     end
 end
 
@@ -482,4 +481,3 @@ SymTridiagonal([1, 2], [0])^3 == [1 0; 0 8]
 # 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]
-end
diff --git a/test/linalg/uniformscaling.jl b/test/linalg/uniformscaling.jl
index 30d732e3da0a14..9bdde7b7470e8b 100644
--- a/test/linalg/uniformscaling.jl
+++ b/test/linalg/uniformscaling.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base.Test
 
@@ -18,6 +18,7 @@ srand(123)
     @test -one(UniformScaling(2)) == UniformScaling(-1)
     @test sparse(3I,4,5) == spdiagm(fill(3,4),0,4,5)
     @test sparse(3I,5,4) == spdiagm(fill(3,4),0,5,4)
+    @test norm(UniformScaling(1+im)) ≈ sqrt(2)
 end
 
 @testset "istriu, istril, issymmetric, ishermitian, isapprox" begin
@@ -29,6 +30,11 @@ end
     @test !ishermitian(UniformScaling(complex(1.0,1.0)))
     @test UniformScaling(4.00000000000001) ≈ UniformScaling(4.0)
     @test UniformScaling(4.32) ≈ UniformScaling(4.3) rtol=0.1 atol=0.01
+    @test UniformScaling(4.32) ≈ 4.3*eye(2) rtol=0.1 atol=0.01
+    @test UniformScaling(4.32) ≈ 4.3*eye(2) rtol=0.1 atol=0.01 norm=norm
+    @test 4.3*eye(2) ≈ UniformScaling(4.32) rtol=0.1 atol=0.01
+    @test [4.3201 0.002;0.001 4.32009] ≈ UniformScaling(4.32) rtol=0.1 atol=0.
+    @test UniformScaling(4.32) ≉ 4.3*ones(2,2) rtol=0.1 atol=0.01
 end
 
 @testset "* and / with number" begin
@@ -38,6 +44,7 @@ end
 end
 
 @test copy(UniformScaling(one(Float64))) == UniformScaling(one(Float64))
+@test sprint(show,UniformScaling(one(Complex128))) == "UniformScaling{Complex{Float64}}\n(1.0 + 0.0im)*I"
 @test sprint(show,UniformScaling(one(Float32))) == "UniformScaling{Float32}\n1.0*I"
 
 λ = complex(randn(),randn())
@@ -166,3 +173,11 @@ end
             hvcat((2,1,2),B,2eye(3,3),eye(6,6),3eye(3,3),4eye(3,3))
     end
 end
+
+@testset "chol" begin
+    for T in (Float64, Complex64, BigFloat, Int)
+        λ = T(4)
+        @test chol(λ*I) ≈ √λ*I
+        @test_throws LinAlg.PosDefException chol(-λ*I)
+    end
+end
diff --git a/test/lineedit.jl b/test/lineedit.jl
index f2c31f3f7d9351..4aeca1b38797c5 100644
--- a/test/lineedit.jl
+++ b/test/lineedit.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base.LineEdit
 isdefined(Main, :TestHelpers) || @eval Main include(joinpath(dirname(@__FILE__), "TestHelpers.jl"))
diff --git a/test/llvmcall.jl b/test/llvmcall.jl
index 1565f25992c36b..302d3950e75e2d 100644
--- a/test/llvmcall.jl
+++ b/test/llvmcall.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base.llvmcall
 
@@ -177,7 +177,7 @@ module ObjLoadTest
 end
 
 # Test for proper parenting
-if VersionNumber(Base.libllvm_version) >= v"3.6" # llvm 3.6 changed the syntax for a gep, so just ignore this test on older versions
+if Base.libllvm_version >= v"3.6" # llvm 3.6 changed the syntax for a gep, so just ignore this test on older versions
     local foo
     function foo()
         # this IR snippet triggers an optimization relying
@@ -191,3 +191,19 @@ if VersionNumber(Base.libllvm_version) >= v"3.6" # llvm 3.6 changed the syntax f
 else
     println("INFO: skipping gep parentage test on llvm < 3.6")
 end
+
+module CcallableRetTypeTest
+    using Base: Test, llvmcall, @ccallable
+    @ccallable function jl_test_returns_float()::Float64
+        return 42
+    end
+    function do_the_call()
+        llvmcall(
+        (""" declare double @jl_test_returns_float()""",
+        """
+        %1 = call double @jl_test_returns_float()
+        ret double %1
+        """),Float64,Tuple{})
+    end
+    @test do_the_call() === 42.0
+end
diff --git a/test/llvmcall2.jl b/test/llvmcall2.jl
index b365129919541a..a0129f270d21a6 100644
--- a/test/llvmcall2.jl
+++ b/test/llvmcall2.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 function declared_floor(x::Float64)
     return ccall("llvm.floor.f64", llvmcall, Float64, (Float64,), x)
diff --git a/test/llvmpasses/.gitignore b/test/llvmpasses/.gitignore
new file mode 100644
index 00000000000000..0e62bc85774eeb
--- /dev/null
+++ b/test/llvmpasses/.gitignore
@@ -0,0 +1 @@
+/Output/
\ No newline at end of file
diff --git a/test/llvmpasses/Makefile b/test/llvmpasses/Makefile
new file mode 100644
index 00000000000000..76c8301803c718
--- /dev/null
+++ b/test/llvmpasses/Makefile
@@ -0,0 +1,11 @@
+SRCDIR := $(abspath $(dir $(lastword $(MAKEFILE_LIST))))
+JULIAHOME := $(abspath $(SRCDIR)/../..)
+include $(JULIAHOME)/deps/Versions.make
+include $(JULIAHOME)/Make.inc
+include $(JULIAHOME)/deps/llvm-ver.make
+BUILDDIR = $(JULIAHOME)/deps/scratch
+include $(JULIAHOME)/deps/llvm-options.mk
+LLVM_SRC_DIR:=$(JULIAHOME)/deps/srccache/llvm-$(LLVM_VER)
+test:
+	PATH=$$PATH:$(LLVM_BUILDDIR_withtype)/bin $(LLVM_SRC_DIR)/utils/lit/lit.py -v .
+.PHONY: test
diff --git a/test/llvmpasses/alloc-opt.jl b/test/llvmpasses/alloc-opt.jl
new file mode 100644
index 00000000000000..60f03088e483d5
--- /dev/null
+++ b/test/llvmpasses/alloc-opt.jl
@@ -0,0 +1,203 @@
+# RUN: julia --startup-file=no %s | opt -load libjulia.so -AllocOpt -LateLowerGCFrame -S - | FileCheck %s
+
+isz = sizeof(UInt) == 8 ? "i64" : "i32"
+
+println("""
+%jl_value_t = type opaque
+@tag = external addrspace(10) global %jl_value_t
+""")
+
+# CHECK-LABEL: @return_obj
+# CHECK-NOT: @julia.gc_alloc_obj
+# CHECK: %v = call noalias %jl_value_t addrspace(10)* @jl_gc_pool_alloc
+# CHECK: store %jl_value_t addrspace(10)* @tag, %jl_value_t addrspace(10)* addrspace(11)* {{.*}}, !tbaa !0
+println("""
+define %jl_value_t addrspace(10)* @return_obj() {
+  %ptls = call %jl_value_t*** @jl_get_ptls_states()
+  %ptls_i8 = bitcast %jl_value_t*** %ptls to i8*
+  %v = call noalias %jl_value_t addrspace(10)* @julia.gc_alloc_obj(i8* %ptls_i8, $isz 8, %jl_value_t addrspace(10)* @tag)
+  ret %jl_value_t addrspace(10)* %v
+}
+""")
+# CHECK-LABEL: }
+
+# CHECK-LABEL: @return_load
+# CHECK: alloca i64, align 8
+# CHECK-NOT: @julia.gc_alloc_obj
+# CHECK-NOT: @jl_gc_pool_alloc
+# CHECK: call void @llvm.lifetime.start(i64 8, i8*
+# CHECK-NEXT: %v64 = bitcast %jl_value_t* %v to i64*
+# CHECK-NOT: @tag
+# CHECK-NOT: @llvm.lifetime.end
+println("""
+define i64 @return_load(i64 %i) {
+  %ptls = call %jl_value_t*** @jl_get_ptls_states()
+  %ptls_i8 = bitcast %jl_value_t*** %ptls to i8*
+  %v = call noalias %jl_value_t addrspace(10)* @julia.gc_alloc_obj(i8* %ptls_i8, $isz 8, %jl_value_t addrspace(10)* @tag)
+  %v64 = bitcast %jl_value_t addrspace(10)* %v to i64 addrspace(10)*
+  %v64a11 = addrspacecast i64 addrspace(10)* %v64 to i64 addrspace(11)*
+  store i64 %i, i64 addrspace(11)* %v64a11, align 16, !tbaa !4
+  call void @external_function()
+  %l = load i64, i64 addrspace(11)* %v64a11, align 16, !tbaa !4
+  ret i64 %l
+}
+""")
+# CHECK-LABEL: }
+
+# CHECK-LABEL: @return_tag
+# CHECK: alloca i128, align 8
+# CHECK: call %jl_value_t*** @jl_get_ptls_states()
+# CHECK-NOT: @julia.gc_alloc_obj
+# CHECK-NOT: @jl_gc_pool_alloc
+# CHECK: call void @llvm.lifetime.start(i64 16, i8*
+# CHECK: store %jl_value_t addrspace(10)* @tag, %jl_value_t addrspace(10)** {{.*}}, !tbaa !0
+# CHECK-NOT: @llvm.lifetime.end
+println("""
+define %jl_value_t addrspace(10)* @return_tag() {
+  %ptls = call %jl_value_t*** @jl_get_ptls_states()
+  %ptls_i8 = bitcast %jl_value_t*** %ptls to i8*
+  %v = call noalias %jl_value_t addrspace(10)* @julia.gc_alloc_obj(i8* %ptls_i8, $isz 8, %jl_value_t addrspace(10)* @tag)
+  %va = addrspacecast %jl_value_t addrspace(10)* %v to %jl_value_t addrspace(11)*
+  %vab = bitcast %jl_value_t addrspace(11)* %va to %jl_value_t addrspace(10)* addrspace(11)*
+  %tagaddr = getelementptr %jl_value_t addrspace(10)*, %jl_value_t addrspace(10)* addrspace(11)* %vab, i64 -1
+  %tag = load %jl_value_t addrspace(10)*, %jl_value_t addrspace(10)* addrspace(11)* %tagaddr, align 8, !tbaa !0
+  ret %jl_value_t addrspace(10)* %tag
+}
+""")
+# CHECK-LABEL: }
+
+# CHECK-LABEL: @ccall_obj
+# CHECK: call %jl_value_t*** @jl_get_ptls_states()
+# CHECK-NOT: @julia.gc_alloc_obj
+# CHECK: @jl_gc_pool_alloc
+# CHECK: store %jl_value_t addrspace(10)* @tag, %jl_value_t addrspace(10)* addrspace(11)* {{.*}}, !tbaa !0
+println("""
+define void @ccall_obj(i8* %fptr) {
+  %ptls = call %jl_value_t*** @jl_get_ptls_states()
+  %ptls_i8 = bitcast %jl_value_t*** %ptls to i8*
+  %v = call noalias %jl_value_t addrspace(10)* @julia.gc_alloc_obj(i8* %ptls_i8, $isz 8, %jl_value_t addrspace(10)* @tag)
+  %f = bitcast i8* %fptr to void (%jl_value_t addrspace(10)*)*
+  call void %f(%jl_value_t addrspace(10)* %v)
+  ret void
+}
+""")
+# CHECK-LABEL: }
+
+# CHECK-LABEL: @ccall_ptr
+# CHECK: alloca i64
+# CHECK: call %jl_value_t*** @jl_get_ptls_states()
+# CHECK-NOT: @julia.gc_alloc_obj
+# CHECK-NOT: @jl_gc_pool_alloc
+# CHECK: call void @llvm.lifetime.start(i64 8, i8*
+# CHECK-NEXT: %f = bitcast i8* %fptr to void (%jl_value_t*)*
+# Currently the GC frame lowering pass strips away all operand bundles
+# CHECK-NEXT: call void %f(%jl_value_t* %v)
+# CHECK-NEXT: ret void
+println("""
+define void @ccall_ptr(i8* %fptr) {
+  %ptls = call %jl_value_t*** @jl_get_ptls_states()
+  %ptls_i8 = bitcast %jl_value_t*** %ptls to i8*
+  %v = call noalias %jl_value_t addrspace(10)* @julia.gc_alloc_obj(i8* %ptls_i8, $isz 8, %jl_value_t addrspace(10)* @tag)
+  %va = addrspacecast %jl_value_t addrspace(10)* %v to %jl_value_t addrspace(11)*
+  %ptr = call %jl_value_t* @julia.pointer_from_objref(%jl_value_t addrspace(11)* %va)
+  %f = bitcast i8* %fptr to void (%jl_value_t*)*
+  call void %f(%jl_value_t* %ptr) [ "jl_roots"(%jl_value_t addrspace(10)* %v), "unknown_bundle"(%jl_value_t* %ptr) ]
+  ret void
+}
+""")
+# CHECK-LABEL: }
+
+# CHECK-LABEL: @ccall_unknown_bundle
+# CHECK: call %jl_value_t*** @jl_get_ptls_states()
+# CHECK-NOT: @julia.gc_alloc_obj
+# CHECK: @jl_gc_pool_alloc
+# CHECK: store %jl_value_t addrspace(10)* @tag, %jl_value_t addrspace(10)* addrspace(11)* {{.*}}, !tbaa !0
+println("""
+define void @ccall_unknown_bundle(i8* %fptr) {
+  %ptls = call %jl_value_t*** @jl_get_ptls_states()
+  %ptls_i8 = bitcast %jl_value_t*** %ptls to i8*
+  %v = call noalias %jl_value_t addrspace(10)* @julia.gc_alloc_obj(i8* %ptls_i8, $isz 8, %jl_value_t addrspace(10)* @tag)
+  %va = addrspacecast %jl_value_t addrspace(10)* %v to %jl_value_t addrspace(11)*
+  %ptr = call %jl_value_t* @julia.pointer_from_objref(%jl_value_t addrspace(11)* %va)
+  %f = bitcast i8* %fptr to void (%jl_value_t*)*
+  call void %f(%jl_value_t* %ptr) [ "jl_not_jl_roots"(%jl_value_t addrspace(10)* %v) ]
+  ret void
+}
+""")
+# CHECK-LABEL: }
+
+# CHECK-LABEL: @lifetime_branches
+# CHECK: alloca i64
+# CHECK: call %jl_value_t*** @jl_get_ptls_states()
+# CHECK: L1:
+# CHECK-NEXT: call void @llvm.lifetime.start(i64 8,
+# CHECK-NEXT: %f = bitcast i8* %fptr to void (%jl_value_t*)*
+# CHECK-NEXT: call void %f(%jl_value_t* %v)
+# CHECK-NEXT: br i1 %b2, label %L2, label %L3
+
+# CHECK: L2:
+# CHECK-NEXT: %f2 = bitcast i8* %fptr to void (%jl_value_t*)*
+# CHECK-NEXT: call void @llvm.lifetime.end(i64 8,
+# CHECK-NEXT: call void %f2(%jl_value_t* null)
+
+# CHECK: L3:
+# CHECK-NEXT: call void @llvm.lifetime.end(i64 8,
+println("""
+define void @lifetime_branches(i8* %fptr, i1 %b, i1 %b2) {
+  %ptls = call %jl_value_t*** @jl_get_ptls_states()
+  %ptls_i8 = bitcast %jl_value_t*** %ptls to i8*
+  br i1 %b, label %L1, label %L3
+
+L1:
+  %v = call noalias %jl_value_t addrspace(10)* @julia.gc_alloc_obj(i8* %ptls_i8, $isz 8, %jl_value_t addrspace(10)* @tag)
+  %va = addrspacecast %jl_value_t addrspace(10)* %v to %jl_value_t addrspace(11)*
+  %ptr = call %jl_value_t* @julia.pointer_from_objref(%jl_value_t addrspace(11)* %va)
+  %f = bitcast i8* %fptr to void (%jl_value_t*)*
+  call void %f(%jl_value_t* %ptr) [ "jl_roots"(%jl_value_t addrspace(10)* %v) ]
+  br i1 %b2, label %L2, label %L3
+
+L2:
+  %f2 = bitcast i8* %fptr to void (%jl_value_t*)*
+  call void %f2(%jl_value_t* null)
+  br label %L3
+
+L3:
+  ret void
+}
+""")
+# CHECK-LABEL: }
+
+# CHECK-LABEL: @object_field
+# CHECK: call %jl_value_t*** @jl_get_ptls_states()
+# CHECK-NOT: @julia.gc_alloc_obj
+# CHECK: @jl_gc_pool_alloc
+# CHECK: store %jl_value_t addrspace(10)* @tag, %jl_value_t addrspace(10)* addrspace(11)* {{.*}}, !tbaa !0
+println("""
+define void @object_field(%jl_value_t addrspace(10)* %field) {
+  %ptls = call %jl_value_t*** @jl_get_ptls_states()
+  %ptls_i8 = bitcast %jl_value_t*** %ptls to i8*
+  %v = call noalias %jl_value_t addrspace(10)* @julia.gc_alloc_obj(i8* %ptls_i8, $isz 8, %jl_value_t addrspace(10)* @tag)
+  %va = addrspacecast %jl_value_t addrspace(10)* %v to %jl_value_t addrspace(11)*
+  %vab = bitcast %jl_value_t addrspace(11)* %va to %jl_value_t addrspace(10)* addrspace(11)*
+  store %jl_value_t addrspace(10)* %field, %jl_value_t addrspace(10)* addrspace(11)* %vab
+  ret void
+}
+""")
+# CHECK-LABEL: }
+
+# CHECK: declare noalias %jl_value_t addrspace(10)* @jl_gc_pool_alloc(i8*,
+# CHECK: declare noalias %jl_value_t addrspace(10)* @jl_gc_big_alloc(i8*,
+println("""
+declare void @external_function()
+declare %jl_value_t*** @jl_get_ptls_states()
+declare noalias %jl_value_t addrspace(10)* @julia.gc_alloc_obj(i8*, $isz, %jl_value_t addrspace(10)*)
+declare %jl_value_t* @julia.pointer_from_objref(%jl_value_t addrspace(11)*)
+
+!0 = !{!1, !1, i64 0}
+!1 = !{!"jtbaa_tag", !2, i64 0}
+!2 = !{!"jtbaa_data", !3, i64 0}
+!3 = !{!"jtbaa"}
+!4 = !{!5, !5, i64 0}
+!5 = !{!"jtbaa_mutab", !6, i64 0}
+!6 = !{!"jtbaa_value", !2, i64 0}
+""")
diff --git a/test/llvmpasses/gcroots.ll b/test/llvmpasses/gcroots.ll
new file mode 100644
index 00000000000000..835a6e72d71c5b
--- /dev/null
+++ b/test/llvmpasses/gcroots.ll
@@ -0,0 +1,209 @@
+; RUN: opt -load libjulia.so -LateLowerGCFrame -S %s | FileCheck %s
+
+%jl_value_t = type opaque
+
+declare void @boxed_simple(%jl_value_t addrspace(10)*, %jl_value_t addrspace(10)*)
+declare %jl_value_t addrspace(10)* @jl_box_int64(i64)
+declare %jl_value_t*** @jl_get_ptls_states()
+declare void @jl_safepoint()
+declare %jl_value_t addrspace(10)* @jl_apply_generic(%jl_value_t addrspace(10)*, %jl_value_t addrspace(10)**, i32)
+
+define void @simple(i64 %a, i64 %b) {
+top:
+; CHECK-LABEL: @simple
+    %ptls = call %jl_value_t*** @jl_get_ptls_states()
+; CHECK: %gcframe = alloca %jl_value_t addrspace(10)*, i32 4
+; CHECK: call %jl_value_t addrspace(10)* @jl_box_int64
+    %aboxed = call %jl_value_t addrspace(10)* @jl_box_int64(i64 signext %a)
+; CHECK: [[GEP0:%.*]] = getelementptr %jl_value_t addrspace(10)*, %jl_value_t addrspace(10)** %gcframe, i32 [[GEPSLOT0:[0-9]+]]
+; CHECK-NEXT: store %jl_value_t addrspace(10)* %aboxed, %jl_value_t addrspace(10)** [[GEP0]]
+    %bboxed = call %jl_value_t addrspace(10)* @jl_box_int64(i64 signext %b)
+; CHECK-NEXT: %bboxed =
+; Make sure the same gc slot isn't re-used
+; CHECK-NOT: getelementptr %jl_value_t addrspace(10)*, %jl_value_t addrspace(10)** %gcframe, i32 [[GEPSLOT0]]
+; CHECK: [[GEP1:%.*]] = getelementptr %jl_value_t addrspace(10)*, %jl_value_t addrspace(10)** %gcframe, i32 [[GEPSLOT1:[0-9]+]]
+; CHECK-NEXT: store %jl_value_t addrspace(10)* %bboxed, %jl_value_t addrspace(10)** [[GEP1]]
+; CHECK-NEXT: call void @boxed_simple
+    call void @boxed_simple(%jl_value_t addrspace(10)* %aboxed,
+                            %jl_value_t addrspace(10)* %bboxed)
+    ret void
+}
+
+define void @leftover_alloca(%jl_value_t addrspace(10)* %a) {
+; If this pass encounters an alloca, it'll just sink it into the gcframe,
+; relying on mem2reg to catch simple cases such as this earlier
+; CHECK-LABEL: @leftover_alloca
+; CHECK: %var = getelementptr %jl_value_t addrspace(10)*, %jl_value_t addrspace(10)** %gcframe
+    %ptls = call %jl_value_t*** @jl_get_ptls_states()
+    %var = alloca %jl_value_t addrspace(10)*
+    store %jl_value_t addrspace(10)* %a, %jl_value_t addrspace(10)** %var
+    %b = load %jl_value_t addrspace(10)*, %jl_value_t addrspace(10)** %var
+    call void @boxed_simple(%jl_value_t addrspace(10)* %a,
+                            %jl_value_t addrspace(10)* %b)
+    ret void
+}
+
+declare {%jl_value_t addrspace(10)*, i8} @union_ret()
+declare void @union_arg({%jl_value_t addrspace(10)*, i8})
+
+define void @simple_union() {
+; CHECK-LABEL: @simple_union
+    %ptls = call %jl_value_t*** @jl_get_ptls_states()
+; CHECK: %a = call { %jl_value_t addrspace(10)*, i8 } @union_ret()
+    %a = call { %jl_value_t addrspace(10)*, i8 } @union_ret()
+; CHECK: [[GEP0:%.*]] = getelementptr %jl_value_t addrspace(10)*, %jl_value_t addrspace(10)** %gcframe, i32 [[GEPSLOT0:[0-9]+]]
+; CHECK-NEXT: [[EXTRACT:%.*]] = extractvalue { %jl_value_t addrspace(10)*, i8 } %a, 0
+; CHECK-NEXT: store %jl_value_t addrspace(10)* [[EXTRACT]], %jl_value_t addrspace(10)** [[GEP0]]
+    call void @union_arg({%jl_value_t addrspace(10)*, i8} %a)
+    ret void
+}
+
+declare void @one_arg_boxed(%jl_value_t addrspace(10)*)
+
+define void @select_simple(i64 %a, i64 %b) {
+; CHECK-LABEL: @select_simple
+    %ptls = call %jl_value_t*** @jl_get_ptls_states()
+    %aboxed = call %jl_value_t addrspace(10)* @jl_box_int64(i64 signext %a)
+    %bboxed = call %jl_value_t addrspace(10)* @jl_box_int64(i64 signext %b)
+    %cmp = icmp eq i64 %a, %b
+    %selectb = select i1 %cmp, %jl_value_t addrspace(10)* %aboxed, %jl_value_t addrspace(10)* %bboxed
+    call void @one_arg_boxed(%jl_value_t addrspace(10)* %selectb)
+    ret void
+}
+
+define void @phi_simple(i64 %a, i64 %b) {
+top:
+; CHECK-LABEL: @phi_simple
+; CHECK:   %gcframe = alloca %jl_value_t addrspace(10)*, i32 3
+    %ptls = call %jl_value_t*** @jl_get_ptls_states()
+    %cmp = icmp eq i64 %a, %b
+    br i1 %cmp, label %alabel, label %blabel
+alabel:
+    %aboxed = call %jl_value_t addrspace(10)* @jl_box_int64(i64 signext %a)
+    br label %common
+blabel:
+    %bboxed = call %jl_value_t addrspace(10)* @jl_box_int64(i64 signext %b)
+    br label %common
+common:
+    %phi = phi %jl_value_t addrspace(10)* [ %aboxed, %alabel ], [ %bboxed, %blabel ]
+; CHECK:  [[GEP:%.*]] = getelementptr %jl_value_t addrspace(10)*, %jl_value_t addrspace(10)** %gcframe, i32 2
+; CHECK:  store %jl_value_t addrspace(10)* %phi, %jl_value_t addrspace(10)** [[GEP]]
+    call void @one_arg_boxed(%jl_value_t addrspace(10)* %phi)
+    ret void
+}
+
+declare void @one_arg_decayed(i64 addrspace(12)*)
+
+define void @select_lift(i64 %a, i64 %b) {
+; CHECK-LABEL: @select_lift
+; CHECK: %gcframe = alloca %jl_value_t addrspace(10)*, i32 3
+    %ptls = call %jl_value_t*** @jl_get_ptls_states()
+    %aboxed = call %jl_value_t addrspace(10)* @jl_box_int64(i64 signext %a)
+    %adecayed = addrspacecast %jl_value_t addrspace(10)* %aboxed to i64 addrspace(12)*
+    %bboxed = call %jl_value_t addrspace(10)* @jl_box_int64(i64 signext %b)
+    %bdecayed = addrspacecast %jl_value_t addrspace(10)* %bboxed to i64 addrspace(12)*
+    %cmp = icmp eq i64 %a, %b
+; CHECK: %gclift = select i1 %cmp, %jl_value_t addrspace(10)* %aboxed, %jl_value_t addrspace(10)* %bboxed
+    %selectb = select i1 %cmp, i64 addrspace(12)* %adecayed, i64 addrspace(12)* %bdecayed
+    call void @one_arg_decayed(i64 addrspace(12)* %selectb)
+    ret void
+}
+
+define void @phi_lift(i64 %a, i64 %b) {
+top:
+; CHECK-LABEL: @phi_lift
+    %ptls = call %jl_value_t*** @jl_get_ptls_states()
+    %cmp = icmp eq i64 %a, %b
+    br i1 %cmp, label %alabel, label %blabel
+alabel:
+    %aboxed = call %jl_value_t addrspace(10)* @jl_box_int64(i64 signext %a)
+    %adecayed = addrspacecast %jl_value_t addrspace(10)* %aboxed to i64 addrspace(12)*
+    br label %common
+blabel:
+    %bboxed = call %jl_value_t addrspace(10)* @jl_box_int64(i64 signext %b)
+    %bdecayed = addrspacecast %jl_value_t addrspace(10)* %bboxed to i64 addrspace(12)*
+    br label %common
+common:
+    %phi = phi i64 addrspace(12)* [ %adecayed, %alabel ], [ %bdecayed, %blabel ]
+    call void @one_arg_decayed(i64 addrspace(12)* %phi)
+    ret void
+}
+
+define void @live_if_live_out(i64 %a, i64 %b) {
+; CHECK-LABEL: @live_if_live_out
+top:
+; CHECK: %gcframe = alloca %jl_value_t addrspace(10)*, i32 4
+    %ptls = call %jl_value_t*** @jl_get_ptls_states()
+; The failure case is failing to realize that `aboxed` is live across the first
+; one_arg_boxed safepoint and putting bboxed in the same root slot
+    %aboxed = call %jl_value_t addrspace(10)* @jl_box_int64(i64 signext %a)
+    %bboxed = call %jl_value_t addrspace(10)* @jl_box_int64(i64 signext %b)
+    call void @one_arg_boxed(%jl_value_t addrspace(10)* %bboxed)
+    br label %succ
+succ:
+    call void @one_arg_boxed(%jl_value_t addrspace(10)* %aboxed)
+    ret void
+}
+
+; A ret is a use - make sure the value is kept alive for any intervening
+; safepoint
+define %jl_value_t addrspace(10)* @ret_use(i64 %a, i64 %b) {
+; CHECK-LABEL: @ret_use
+; CHECK: %gcframe = alloca %jl_value_t addrspace(10)*, i32 3
+    %ptls = call %jl_value_t*** @jl_get_ptls_states()
+    %aboxed = call %jl_value_t addrspace(10)* @jl_box_int64(i64 signext %a)
+; CHECK: store %jl_value_t addrspace(10)* %aboxed
+    %bboxed = call %jl_value_t addrspace(10)* @jl_box_int64(i64 signext %b)
+    ret %jl_value_t addrspace(10)* %aboxed
+}
+
+define i8 @nosafepoint(%jl_value_t addrspace(10)* dereferenceable(16)) {
+; CHECK-LABEL: @nosafepoint
+; CHECK-NOT: %gcframe
+top:
+  %1 = call %jl_value_t*** @jl_get_ptls_states()
+  %2 = bitcast %jl_value_t*** %1 to %jl_value_t addrspace(10)**
+  %3 = getelementptr %jl_value_t addrspace(10)*, %jl_value_t addrspace(10)** %2, i64 3
+  %4 = bitcast %jl_value_t addrspace(10)** %3 to i64**
+  %5 = load i64*, i64** %4
+  %6 = bitcast %jl_value_t addrspace(10)* %0 to i8 addrspace(10)*
+  %7 = addrspacecast i8 addrspace(10)* %6 to i8 addrspace(11)*
+  %8 = getelementptr i8, i8 addrspace(11)* %7, i64 0
+  %9 = load i8, i8 addrspace(11)* %8
+  %10 = trunc i8 %9 to i1
+  %11 = zext i1 %10 to i8
+  %12 = xor i8 %11, 1
+  ret i8 %12
+}
+
+define void @global_ref() {
+; CHECK-LABEL: @global_ref
+; CHECK: %gcframe = alloca %jl_value_t addrspace(10)*, i32 3
+    %ptls = call %jl_value_t*** @jl_get_ptls_states()
+    %loaded = load %jl_value_t addrspace(10)*, %jl_value_t addrspace(10)** getelementptr (%jl_value_t addrspace(10)*, %jl_value_t addrspace(10)** inttoptr (i64 140540744325952 to %jl_value_t addrspace(10)**), i64 1)
+; CHECK: store %jl_value_t addrspace(10)* %loaded, %jl_value_t addrspace(10)**
+    call void @one_arg_boxed(%jl_value_t addrspace(10)* %loaded)
+    ret void
+}
+
+define %jl_value_t addrspace(10)* @no_redundant_rerooting(i64 %a, i1 %cond) {
+; CHECK-LABEL: @no_redundant_rerooting
+; CHECK: %gcframe = alloca %jl_value_t addrspace(10)*, i32 3
+top:
+    %ptls = call %jl_value_t*** @jl_get_ptls_states()
+    %aboxed = call %jl_value_t addrspace(10)* @jl_box_int64(i64 signext %a)
+; CHECK: store %jl_value_t addrspace(10)* %aboxed 
+; CHECK-NEXT: call void @jl_safepoint()
+    call void @jl_safepoint()
+    br i1 %cond, label %blocka, label %blockb
+blocka:
+; CHECK-NOT: call void @jl_safepoint()
+; CHECK: call void @jl_safepoint()
+    call void @jl_safepoint()
+    ret %jl_value_t addrspace(10)* %aboxed
+blockb:
+; CHECK-NOT: call void @jl_safepoint()
+; CHECK: call void @jl_safepoint()
+    call void @jl_safepoint()
+    ret %jl_value_t addrspace(10)* %aboxed
+}
diff --git a/test/llvmpasses/lit.cfg b/test/llvmpasses/lit.cfg
new file mode 100644
index 00000000000000..3ba90cde691c4d
--- /dev/null
+++ b/test/llvmpasses/lit.cfg
@@ -0,0 +1,16 @@
+import os
+import sys
+import re
+import platform
+
+import lit.util
+import lit.formats
+
+config.name = 'Julia'
+config.suffixes = ['.ll','.jl']
+config.test_source_root = os.path.dirname(__file__)
+config.test_format = lit.formats.ShTest(True)
+
+path = os.path.pathsep.join((os.path.join(os.path.dirname(__file__),"../../usr/tools"), os.path.join(os.path.dirname(__file__),"../../usr/bin"), config.environment['PATH']))
+config.environment['PATH'] = path
+config.environment['HOME'] = "/tmp"
diff --git a/test/llvmpasses/lower-handlers.ll b/test/llvmpasses/lower-handlers.ll
new file mode 100644
index 00000000000000..0db907ecee9694
--- /dev/null
+++ b/test/llvmpasses/lower-handlers.ll
@@ -0,0 +1,25 @@
+; RUN: opt -load libjulia.so -LowerExcHandlers -S %s | FileCheck %s
+
+attributes #1 = { returns_twice }
+declare i32 @julia.except_enter() #1
+declare void @jl_pop_handler(i32)
+declare i8**** @jl_get_ptls_states()
+
+define void @simple() {
+top:
+    %ptls = call i8**** @jl_get_ptls_states()
+; CHECK: call void @llvm.lifetime.start
+; CHECK: call void @jl_enter_handler
+; CHECK: setjmp
+    %r = call i32 @julia.except_enter()
+    %cmp = icmp eq i32 %r, 0
+    br i1 %cmp, label %try, label %catch
+try:
+    br label %after
+catch:
+    br label %after
+after:
+    call void @jl_pop_handler(i32 1)
+; CHECK: llvm.lifetime.end
+    ret void
+}
diff --git a/test/llvmpasses/muladd.ll b/test/llvmpasses/muladd.ll
new file mode 100644
index 00000000000000..0a2ac931d9cdeb
--- /dev/null
+++ b/test/llvmpasses/muladd.ll
@@ -0,0 +1,28 @@
+; RUN: opt -load libjulia.so -CombineMulAdd -S %s | FileCheck %s
+
+define double @fast_muladd1(double %a, double %b, double %c) {
+top:
+; CHECK: {{contract|fmuladd}}
+  %v1 = fmul double %a, %b
+  %v2 = fadd fast double %v1, %c
+; CHECK: ret double
+  ret double %v2
+}
+
+define double @fast_mulsub1(double %a, double %b, double %c) {
+top:
+; CHECK: {{contract|fmuladd}}
+  %v1 = fmul double %a, %b
+  %v2 = fsub fast double %v1, %c
+; CHECK: ret double
+  ret double %v2
+}
+
+define <2 x double> @fast_mulsub_vec1(<2 x double> %a, <2 x double> %b, <2 x double> %c) {
+top:
+; CHECK: {{contract|fmuladd}}
+  %v1 = fmul <2 x double> %a, %b
+  %v2 = fsub fast <2 x double> %c, %v1
+; CHECK: ret <2 x double>
+  ret <2 x double> %v2
+}
diff --git a/test/llvmpasses/propagate-addrspace.ll b/test/llvmpasses/propagate-addrspace.ll
new file mode 100644
index 00000000000000..80ee269616d8c3
--- /dev/null
+++ b/test/llvmpasses/propagate-addrspace.ll
@@ -0,0 +1,21 @@
+; RUN: opt -load libjulia.so -PropagateJuliaAddrspaces -dce -S %s | FileCheck %s
+
+define i64 @simple() {
+; CHECK-LABEL: @simple
+; CHECK-NOT: addrspace(11)
+    %stack = alloca i64
+    %casted = addrspacecast i64 *%stack to i64 addrspace(11)*
+    %loaded = load i64, i64 addrspace(11)* %casted
+    ret i64 %loaded
+}
+
+define i64 @twogeps() {
+; CHECK-LABEL: @twogeps
+; CHECK-NOT: addrspace(11)
+    %stack = alloca i64
+    %casted = addrspacecast i64 *%stack to i64 addrspace(11)*
+    %gep1 = getelementptr i64, i64 addrspace(11)* %casted, i64 1
+    %gep2 = getelementptr i64, i64 addrspace(11)* %gep1, i64 1
+    %loaded = load i64, i64 addrspace(11)* %gep2
+    ret i64 %loaded
+}
diff --git a/test/llvmpasses/refinements.ll b/test/llvmpasses/refinements.ll
new file mode 100644
index 00000000000000..656d4e7947f908
--- /dev/null
+++ b/test/llvmpasses/refinements.ll
@@ -0,0 +1,81 @@
+; RUN: opt -load libjulia.so -LateLowerGCFrame -S %s | FileCheck %s
+
+%jl_value_t = type opaque
+
+declare %jl_value_t*** @jl_get_ptls_states()
+declare void @jl_safepoint()
+declare void @one_arg_boxed(%jl_value_t addrspace(10)*)
+declare %jl_value_t addrspace(10)* @jl_box_int64(i64)
+
+define void @argument_refinement(%jl_value_t addrspace(10)* %a) {
+; CHECK-LABEL: @argument_refinement
+; CHECK-NOT: %gcframe
+    %ptls = call %jl_value_t*** @jl_get_ptls_states()
+    %casted1 = bitcast %jl_value_t addrspace(10)* %a to %jl_value_t addrspace(10)* addrspace(10)*
+    %loaded1 = load %jl_value_t addrspace(10)*, %jl_value_t addrspace(10)* addrspace(10)* %casted1, !tbaa !1
+    call void @jl_safepoint()
+    %casted2 = bitcast %jl_value_t addrspace(10)* %loaded1 to i64 addrspace(10)*
+    %loaded2 = load i64, i64 addrspace(10)* %casted2
+    ret void
+}
+
+; Check that we reuse the gc slot from the box
+define void @heap_refinement1(i64 %a) {
+; CHECK-LABEL: @heap_refinement1
+; CHECK:   %gcframe = alloca %jl_value_t addrspace(10)*, i32 3
+    %ptls = call %jl_value_t*** @jl_get_ptls_states()
+    %aboxed = call %jl_value_t addrspace(10)* @jl_box_int64(i64 signext %a)
+    %casted1 = bitcast %jl_value_t addrspace(10)* %aboxed to %jl_value_t addrspace(10)* addrspace(10)*
+    %loaded1 = load %jl_value_t addrspace(10)*, %jl_value_t addrspace(10)* addrspace(10)* %casted1, !tbaa !1
+; CHECK: store %jl_value_t addrspace(10)* %aboxed
+    call void @jl_safepoint()
+    %casted2 = bitcast %jl_value_t addrspace(10)* %loaded1 to i64 addrspace(10)*
+    %loaded2 = load i64, i64 addrspace(10)* %casted2
+    call void @one_arg_boxed(%jl_value_t addrspace(10)* %aboxed)
+    ret void
+}
+
+; Check that we don't root the allocated value here, just the derived value
+define void @heap_refinement2(i64 %a) {
+; CHECK-LABEL: @heap_refinement2
+; CHECK:   %gcframe = alloca %jl_value_t addrspace(10)*, i32 3
+    %ptls = call %jl_value_t*** @jl_get_ptls_states()
+    %aboxed = call %jl_value_t addrspace(10)* @jl_box_int64(i64 signext %a)
+    %casted1 = bitcast %jl_value_t addrspace(10)* %aboxed to %jl_value_t addrspace(10)* addrspace(10)*
+    %loaded1 = load %jl_value_t addrspace(10)*, %jl_value_t addrspace(10)* addrspace(10)* %casted1, !tbaa !1
+; CHECK: store %jl_value_t addrspace(10)* %loaded1
+    call void @jl_safepoint()
+    %casted2 = bitcast %jl_value_t addrspace(10)* %loaded1 to i64 addrspace(10)*
+    %loaded2 = load i64, i64 addrspace(10)* %casted2
+    ret void
+}
+
+declare %jl_value_t addrspace(10)* @allocate_some_value()
+
+; Check that the way we compute rooting is compatible with refinements
+define void @issue22770() {
+; CHECK: %gcframe = alloca %jl_value_t addrspace(10)*, i32 4
+    %ptls = call %jl_value_t*** @jl_get_ptls_states()
+    %y = call %jl_value_t addrspace(10)* @allocate_some_value()
+    %casted1 = bitcast %jl_value_t addrspace(10)* %y to %jl_value_t addrspace(10)* addrspace(10)*
+    %x = load %jl_value_t addrspace(10)*, %jl_value_t addrspace(10)* addrspace(10)* %casted1, !tbaa !1
+; CHECK: store %jl_value_t addrspace(10)* %y,
+    %a = call %jl_value_t addrspace(10)* @allocate_some_value()
+; CHECK: store %jl_value_t addrspace(10)* %a
+; CHECK: call void @one_arg_boxed(%jl_value_t addrspace(10)* %x)
+; CHECK: call void @one_arg_boxed(%jl_value_t addrspace(10)* %a)
+; CHECK: call void @one_arg_boxed(%jl_value_t addrspace(10)* %y)
+    call void @one_arg_boxed(%jl_value_t addrspace(10)* %x)
+    call void @one_arg_boxed(%jl_value_t addrspace(10)* %a)
+    call void @one_arg_boxed(%jl_value_t addrspace(10)* %y)
+; CHECK: store %jl_value_t addrspace(10)* %x
+    %c = call %jl_value_t addrspace(10)* @allocate_some_value()
+; CHECK: store %jl_value_t addrspace(10)* %c
+    call void @one_arg_boxed(%jl_value_t addrspace(10)* %x)
+    call void @one_arg_boxed(%jl_value_t addrspace(10)* %c)
+    ret void
+}
+
+!0 = !{!"jtbaa"}
+!1 = !{!2, !2, i64 0}
+!2 = !{!"jtbaa_immut", !0, i64 0}
diff --git a/test/llvmpasses/returnstwicegc.ll b/test/llvmpasses/returnstwicegc.ll
new file mode 100644
index 00000000000000..4a0229443311bd
--- /dev/null
+++ b/test/llvmpasses/returnstwicegc.ll
@@ -0,0 +1,30 @@
+; RUN: opt -load libjulia.so -LateLowerGCFrame -S %s | FileCheck %s
+
+%jl_value_t = type opaque
+
+declare void @boxed_simple(%jl_value_t addrspace(10)*, %jl_value_t addrspace(10)*)
+declare %jl_value_t addrspace(10)* @jl_box_int64(i64)
+declare %jl_value_t*** @jl_get_ptls_states()
+declare i32 @sigsetjmp(i8*, i32) returns_twice
+declare void @one_arg_boxed(%jl_value_t addrspace(10)*)
+
+define void @try_catch(i64 %a, i64 %b)
+{
+; Because of the returns_twice function, we need to keep aboxed live everywhere
+; CHECK: %gcframe = alloca %jl_value_t addrspace(10)*, i32 4
+top:
+    %sigframe = alloca [208 x i8], align 16
+    %sigframe.sub = getelementptr inbounds [208 x i8], [208 x i8]* %sigframe, i64 0, i64 0
+    call %jl_value_t*** @jl_get_ptls_states()
+    %aboxed = call %jl_value_t addrspace(10)* @jl_box_int64(i64 %a)
+    %val = call i32 @sigsetjmp(i8 *%sigframe.sub, i32 0) returns_twice
+    %cmp = icmp eq i32 %val, 0
+    br i1 %cmp, label %zero, label %not
+zero:
+    %bboxed = call %jl_value_t addrspace(10)* @jl_box_int64(i64 %b)
+    call void @one_arg_boxed(%jl_value_t addrspace(10)* %bboxed)
+    unreachable
+not:
+    call void @one_arg_boxed(%jl_value_t addrspace(10)* %aboxed)
+    ret void
+}
diff --git a/test/llvmpasses/safepoint_stress.jl b/test/llvmpasses/safepoint_stress.jl
new file mode 100644
index 00000000000000..29383f230b1490
--- /dev/null
+++ b/test/llvmpasses/safepoint_stress.jl
@@ -0,0 +1,25 @@
+# RUN: julia --startup-file=no %s | opt -load libjulia.so -LateLowerGCFrame -S - | FileCheck %s
+
+println("""
+%jl_value_t = type opaque
+declare %jl_value_t addrspace(10)* @alloc()
+declare void @one_arg_boxed(%jl_value_t addrspace(10)*)
+declare %jl_value_t*** @jl_get_ptls_states()
+
+define void @stress(i64 %a, i64 %b) {
+    %ptls = call %jl_value_t*** @jl_get_ptls_states()
+""")
+
+# CHECK: %gcframe = alloca %jl_value_t addrspace(10)*, i32 10002
+for i = 1:10000
+    println("\t%arg$i = call %jl_value_t addrspace(10)* @alloc()")
+end
+
+for i = 1:10000
+    println("\tcall void @one_arg_boxed(%jl_value_t addrspace(10)* %arg$i)")
+end
+
+println("""
+    ret void
+}
+""")
diff --git a/test/llvmpasses/simdloop.ll b/test/llvmpasses/simdloop.ll
new file mode 100644
index 00000000000000..50b7a132a6a746
--- /dev/null
+++ b/test/llvmpasses/simdloop.ll
@@ -0,0 +1,40 @@
+; RUN: opt -load libjulia.so -LowerSIMDLoop -S %s | FileCheck %s
+
+define void @simd_test(double *%a, double *%b) {
+top:
+  br label %loop
+loop:
+  %i = phi i64 [0, %top], [%nexti, %loop]
+  %aptr = getelementptr double, double *%a, i64 %i
+  %bptr = getelementptr double, double *%b, i64 %i
+; CHECK: llvm.mem.parallel_loop_access
+  %aval = load double, double *%aptr
+  %bval = load double, double *%aptr
+  %cval = fadd double %aval, %bval
+  store double %cval, double *%bptr
+  %nexti = add i64 %i, 1, !simd_loop !1
+  %done = icmp sgt i64 %nexti, 500
+  br i1 %done, label %loopdone, label %loop
+loopdone:
+  ret void
+}
+
+define double @simd_test_sub(double *%a) {
+top:
+  br label %loop
+loop:
+  %i = phi i64 [0, %top], [%nexti, %loop]
+  %v = phi double [0.000000e+00, %top], [%nextv, %loop]
+  %aptr = getelementptr double, double *%a, i64 %i
+; CHECK: llvm.mem.parallel_loop_access
+  %aval = load double, double *%aptr
+  %nextv = fsub double %v, %aval
+; CHECK: fsub fast double %v, %aval
+  %nexti = add i64 %i, 1, !simd_loop !1
+  %done = icmp sgt i64 %nexti, 500
+  br i1 %done, label %loopdone, label %loop
+loopdone:
+  ret double %nextv
+}
+
+!1 = !{}
diff --git a/test/loading.jl b/test/loading.jl
index 4fbb04d083bd68..a7d29f31cabc16 100644
--- a/test/loading.jl
+++ b/test/loading.jl
@@ -1,19 +1,54 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base.Test
 
-@test @__LINE__ == 5
+# Tests for @__LINE__ inside and outside of macros
+@test (@__LINE__) == 6
+
+macro macro_caller_lineno()
+    @test 9 == (@__LINE__) != __source__.line > 12
+    return __source__.line
+end
+
+@test @macro_caller_lineno() == (@__LINE__) > 12
+
+# @__LINE__ in a macro expands to the location of the macrocall in the source
+# while __source__.line is the location of the macro caller
+macro nested_LINE_expansion()
+    return quote
+        return (@emit_LINE, $(__source__.line))
+    end
+end
+macro nested_LINE_expansion2()
+    return :((@emit_LINE, $(__source__.line)))
+end
+macro emit_LINE()
+    return quote
+        (@__LINE__, $(__source__.line))
+    end
+end
+@test (@emit_LINE) == ((@__LINE__) - 3, @__LINE__)
+@test @nested_LINE_expansion() == ((@__LINE__() - 4, @__LINE__() - 12), @__LINE__())
+@test @nested_LINE_expansion2() == ((@__LINE__() - 5, @__LINE__() - 9), @__LINE__())
 
 include("test_sourcepath.jl")
 thefname = "the fname!//\\&\1*"
-include_string_test_func = include_string("include_string_test() = @__FILE__", thefname)
-@test include_string_test_func() == Base.source_path()
-@test include_string("Base.source_path()", thefname) == Base.source_path()
+include_string_test_func = include_string(@__MODULE__, "include_string_test() = @__FILE__", thefname)
+@test include_string_test_func() == thefname
+@test include_string(@__MODULE__, "Base.source_path()", thefname) == Base.source_path()
 @test basename(@__FILE__) == "loading.jl"
 @test isabspath(@__FILE__)
 
 @test isdir(@__DIR__)
 @test @__DIR__() == dirname(@__FILE__)
+let exename = `$(Base.julia_cmd()) --precompiled=yes --startup-file=no`,
+    wd = sprint(show, abspath(pwd(), "")),
+    s_dir = sprint(show, joinpath(realpath(tempdir()), ""))
+    @test wd != s_dir
+    @test readchomp(`$exename -E "@__DIR__" -i`) == wd
+    @test readchomp(`$exename -E "cd(()->eval(:(@__DIR__)), $s_dir)" -i`) == s_dir
+    @test readchomp(`$exename -E "@__DIR__"`) == wd # non-interactive
+end
 
 # Issue #5789 and PR #13542:
 mktempdir() do dir
diff --git a/test/markdown.jl b/test/markdown.jl
index 7a4711663dba5d..4eba7019798e29 100644
--- a/test/markdown.jl
+++ b/test/markdown.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base.Markdown
 import Base.Markdown: MD, Paragraph, Header, Italic, Bold, LineBreak, plain, term, html, rst, Table, Code, LaTeX, Footnote
diff --git a/test/math.jl b/test/math.jl
index 9c43e610a9bc91..f3c997fceb261a 100644
--- a/test/math.jl
+++ b/test/math.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 @testset "clamp" begin
     @test clamp(0, 1, 3) == 1
@@ -128,6 +128,7 @@ end
         yi = 4
         @testset "Random values" begin
             @test x^y ≈ big(x)^big(y)
+            @test x^1 === x
             @test x^yi ≈ big(x)^yi
             @test acos(x) ≈ acos(big(x))
             @test acosh(1+x) ≈ acosh(big(1+x))
@@ -245,9 +246,6 @@ end
         end
     end
 end
-@test exp10(5) ≈ exp10(5.0)
-@test exp2(Float16(2.)) ≈ exp2(2.)
-@test log(e) == 1
 
 @testset "exp function" for T in (Float64, Float32)
     @testset "$T accuracy" begin
@@ -267,7 +265,32 @@ end
     end
 end
 
-@testset "test abstractarray trig fxns" begin
+@testset "exp10 function" begin
+    @testset "accuracy" begin
+        X = map(Float64, vcat(-10:0.00021:10, -35:0.0023:100, -300:0.001:300))
+        for x in X
+            y, yb = exp10(x), exp10(big(x))
+            @test abs(y-yb) <= 1.2*eps(Float64(yb))
+        end
+        X = map(Float32, vcat(-10:0.00021:10, -35:0.0023:35, -35:0.001:35))
+        for x in X
+            y, yb = exp10(x), exp10(big(x))
+            @test abs(y-yb) <= 1.2*eps(Float32(yb))
+        end
+    end
+    @testset "$T edge cases" for T in (Float64, Float32)
+        @test isnan(exp10(T(NaN)))
+        @test exp10(T(-Inf)) === T(0.0)
+        @test exp10(T(Inf)) === T(Inf)
+        @test exp10(T(0.0)) === T(1.0) # exact
+        @test exp10(T(1.0)) === T(10.0)
+        @test exp10(T(3.0)) === T(1000.0)
+        @test exp10(T(5000.0)) === T(Inf)
+        @test exp10(T(-5000.0)) === T(0.0)
+    end
+end
+
+@testset "test abstractarray trig functions" begin
     TAA = rand(2,2)
     TAA = (TAA + TAA.')/2.
     STAA = Symmetric(TAA)
@@ -303,6 +326,8 @@ end
         @test rad2deg(T(1)) ≈ rad2deg(true)
         @test deg2rad(T(1)) ≈ deg2rad(true)
     end
+    @test deg2rad(180 + 60im) ≈ pi + (pi/3)*im
+    @test rad2deg(pi + (pi/3)*im) ≈ 180 + 60im
 end
 
 @testset "degree-based trig functions" begin
@@ -376,6 +401,19 @@ end
     @test cosc(Inf) == 0
 end
 
+@testset "Irrational args to sinpi/cospi/sinc/cosc" begin
+    for x in (pi, e, golden)
+        @test sinpi(x) ≈ Float64(sinpi(big(x)))
+        @test cospi(x) ≈ Float64(cospi(big(x)))
+        @test sinc(x)  ≈ Float64(sinc(big(x)))
+        @test cosc(x)  ≈ Float64(cosc(big(x)))
+        @test sinpi(complex(x, x)) ≈ Complex{Float64}(sinpi(complex(big(x), big(x))))
+        @test cospi(complex(x, x)) ≈ Complex{Float64}(cospi(complex(big(x), big(x))))
+        @test sinc(complex(x, x))  ≈ Complex{Float64}(sinc(complex(big(x),  big(x))))
+        @test cosc(complex(x, x))  ≈ Complex{Float64}(cosc(complex(big(x),  big(x))))
+    end
+end
+
 @testset "trig function type stability" begin
     @testset "$T $f" for T = (Float32,Float64,BigFloat), f = (sind,cosd,sinpi,cospi)
         @test Base.return_types(f,Tuple{T}) == [T]
@@ -421,8 +459,11 @@ relerrc(z, x) = max(relerr(real(z),real(x)), relerr(imag(z),imag(x)))
         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(0) == lfact(1) == 0
         @test lfact(2) == lgamma(3)
+        # Ensure that the domain of lfact matches that of factorial (issue #21318)
+        @test_throws DomainError lfact(-3)
+        @test_throws MethodError lfact(1.0)
     end
 
     # lgamma test cases (from Wolfram Alpha)
@@ -590,9 +631,50 @@ end
     end
 end
 
+@testset "issue #19872" begin
+    f19872a(x) = x ^ 5
+    f19872b(x) = x ^ (-1024)
+    @test 0 < f19872b(2.0) < 1e-300
+    @test issubnormal(2.0 ^ (-1024))
+    @test issubnormal(f19872b(2.0))
+    @test !issubnormal(f19872b(0.0))
+    @test f19872a(2.0) === 32.0
+    @test !issubnormal(f19872a(2.0))
+    @test !issubnormal(0.0)
+end
+
 # no domain error is thrown for negative values
 @test invoke(cbrt, Tuple{AbstractFloat}, -1.0) == -1.0
 
 @testset "promote Float16 irrational #15359" begin
     @test typeof(Float16(.5) * pi) == Float16
 end
+
+@testset "sincos" begin
+    @test sincos(1.0) === (sin(1.0), cos(1.0))
+    @test sincos(1f0) === (sin(1f0), cos(1f0))
+    @test sincos(Float16(1)) === (sin(Float16(1)), cos(Float16(1)))
+    @test sincos(1) === (sin(1), cos(1))
+    @test sincos(big(1)) == (sin(big(1)), cos(big(1)))
+    @test sincos(big(1.0)) == (sin(big(1.0)), cos(big(1.0)))
+end
+
+@testset "test fallback definitions" begin
+    @test exp10(5) ≈ exp10(5.0)
+    @test exp10(50//10) ≈ exp10(5.0)
+    @test log10(exp10(e)) ≈ e
+    @test log(e) === 1
+    @test exp2(Float16(2.0)) ≈ exp2(2.0)
+    @test exp2(Float16(1.0)) === Float16(exp2(1.0))
+    @test exp10(Float16(1.0)) === Float16(exp10(1.0))
+end
+
+# test AbstractFloat fallback pr22716
+struct Float22716{T<:AbstractFloat} <: AbstractFloat
+    x::T
+end
+Base.:^(x::Number, y::Float22716) = x^(y.x)
+let x = 2.0
+    @test exp2(Float22716(x)) === 2^x
+    @test exp10(Float22716(x)) === 10^x
+end
diff --git a/test/meta.jl b/test/meta.jl
index 17deda5d2099ee..4de78630a77d07 100644
--- a/test/meta.jl
+++ b/test/meta.jl
@@ -1,11 +1,7 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # test meta-expressions that annotate blocks of code
 
-module MetaTest
-
-using Base.Test
-
 const inlining_on = Base.JLOptions().can_inline != 0
 
 function f(x)
@@ -121,17 +117,12 @@ body.args = ast.code
 @test popmeta!(body, :test) == (true, [42])
 @test popmeta!(body, :nonexistent) == (false, [])
 
-end
-
-
 # tests to fully cover functions in base/meta.jl
-module MetaJLtest
-
-using Base.Test
 using Base.Meta
 
 @test isexpr(:(1+1),Set([:call]))
 @test isexpr(:(1+1),Vector([:call]))
+@test isexpr(:(1+1),(:call,))
 @test isexpr(1,:call)==false
 @test isexpr(:(1+1),:call,3)
 ioB = IOBuffer()
@@ -139,7 +130,8 @@ show_sexpr(ioB,:(1+1))
 
 show_sexpr(ioB,QuoteNode(1),1)
 
-end
+@test Base.Distributed.extract_imports(:(begin; import Foo, Bar; let; using Baz; end; end)) ==
+      [:Foo, :Bar, :Baz]
 
 # test base/expr.jl
 baremodule B
@@ -152,3 +144,47 @@ baremodule B
 end
 @test B.x == 3
 @test B.M.x == 4
+
+# specialization annotations
+
+function _nospec_some_args(@nospecialize(x), y, @nospecialize z::Int)
+end
+@test first(methods(_nospec_some_args)).nospecialize == 5
+@test first(methods(_nospec_some_args)).sig == Tuple{typeof(_nospec_some_args),Any,Any,Int}
+function _nospec_some_args2(x, y, z)
+    @nospecialize x y
+    return 0
+end
+@test first(methods(_nospec_some_args2)).nospecialize == 3
+function _nospec_with_default(@nospecialize x = 1)
+    2x
+end
+@test collect(methods(_nospec_with_default))[2].nospecialize == 1
+@test _nospec_with_default() == 2
+@test _nospec_with_default(10) == 20
+
+
+let oldout = STDOUT
+    local rdout, wrout, out
+    try
+        rdout, wrout = redirect_stdout()
+        out = @async read(rdout, String)
+
+        @test eval(:(@dump x + y)) === nothing
+
+        redirect_stdout(oldout)
+        close(wrout)
+
+        @test wait(out) == """
+            Expr
+              head: Symbol call
+              args: Array{Any}((3,))
+                1: Symbol +
+                2: Symbol x
+                3: Symbol y
+              typ: Any
+            """
+    finally
+        redirect_stdout(oldout)
+    end
+end
diff --git a/test/misc.jl b/test/misc.jl
index 69e634106b6426..7ca7084a9fd77e 100644
--- a/test/misc.jl
+++ b/test/misc.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Tests that do not really go anywhere else
 
@@ -52,12 +52,12 @@ end
 @test all(contains.(sprint(foo), ["INFO: fooinfo", "WARNING: foowarn", "ERROR: \"fooerror\""]))
 
 
-logging(DevNull, TestMain_misc.Logging, :bar;  kind=:info)
+logging(DevNull, Logging, :bar;  kind=:info)
 @test all(contains.(sprint(Logging.bar), ["WARNING: barwarn", "ERROR: \"barerror\""]))
 @test all(contains.(sprint(Logging.pooh), ["INFO: poohinfo", "WARNING: poohwarn", "ERROR: \"pooherror\""]))
 @test all(contains.(sprint(foo), ["INFO: fooinfo", "WARNING: foowarn", "ERROR: \"fooerror\""]))
 
-logging(DevNull, TestMain_misc.Logging;  kind=:info)
+logging(DevNull, Logging;  kind=:info)
 @test all(contains.(sprint(Logging.bar), ["WARNING: barwarn", "ERROR: \"barerror\""]))
 @test all(contains.(sprint(Logging.pooh), ["WARNING: poohwarn", "ERROR: \"pooherror\""]))
 @test all(contains.(sprint(foo), ["INFO: fooinfo", "WARNING: foowarn", "ERROR: \"fooerror\""]))
@@ -73,12 +73,12 @@ logging(kind=:info)
 @test all(contains.(sprint(foo), ["INFO: fooinfo", "WARNING: foowarn", "ERROR: \"fooerror\""]))
 
 
-logging(DevNull, TestMain_misc.Logging, :bar;  kind=:warn)
+logging(DevNull, Logging, :bar;  kind=:warn)
 @test all(contains.(sprint(Logging.bar), ["INFO: barinfo", "ERROR: \"barerror\""]))
 @test all(contains.(sprint(Logging.pooh), ["INFO: poohinfo", "WARNING: poohwarn", "ERROR: \"pooherror\""]))
 @test all(contains.(sprint(foo), ["INFO: fooinfo", "WARNING: foowarn", "ERROR: \"fooerror\""]))
 
-logging(DevNull, TestMain_misc.Logging;  kind=:warn)
+logging(DevNull, Logging;  kind=:warn)
 @test all(contains.(sprint(Logging.bar), ["INFO: barinfo", "ERROR: \"barerror\""]))
 @test all(contains.(sprint(Logging.pooh), ["INFO: poohinfo", "ERROR: \"pooherror\""]))
 @test all(contains.(sprint(foo), ["INFO: fooinfo", "WARNING: foowarn", "ERROR: \"fooerror\""]))
@@ -94,12 +94,12 @@ logging(kind=:warn)
 @test all(contains.(sprint(foo), ["INFO: fooinfo", "WARNING: foowarn", "ERROR: \"fooerror\""]))
 
 
-logging(DevNull, TestMain_misc.Logging, :bar;  kind=:error)
+logging(DevNull, Logging, :bar;  kind=:error)
 @test all(contains.(sprint(Logging.bar), ["INFO: barinfo", "WARNING: barwarn"]))
 @test all(contains.(sprint(Logging.pooh), ["INFO: poohinfo", "WARNING: poohwarn", "ERROR: \"pooherror\""]))
 @test all(contains.(sprint(foo), ["INFO: fooinfo", "WARNING: foowarn", "ERROR: \"fooerror\""]))
 
-logging(DevNull, TestMain_misc.Logging;  kind=:error)
+logging(DevNull, Logging;  kind=:error)
 @test all(contains.(sprint(Logging.bar), ["INFO: barinfo", "WARNING: barwarn"]))
 @test all(contains.(sprint(Logging.pooh), ["INFO: poohinfo", "WARNING: poohwarn"]))
 @test all(contains.(sprint(foo), ["INFO: fooinfo", "WARNING: foowarn", "ERROR: \"fooerror\""]))
@@ -115,12 +115,12 @@ logging(kind=:error)
 @test all(contains.(sprint(foo), ["INFO: fooinfo", "WARNING: foowarn", "ERROR: \"fooerror\""]))
 
 
-logging(DevNull, TestMain_misc.Logging, :bar)
+logging(DevNull, Logging, :bar)
 @test sprint(Logging.bar) == ""
 @test all(contains.(sprint(Logging.pooh), ["INFO: poohinfo", "WARNING: poohwarn", "ERROR: \"pooherror\""]))
 @test all(contains.(sprint(foo), ["INFO: fooinfo", "WARNING: foowarn", "ERROR: \"fooerror\""]))
 
-logging(DevNull, TestMain_misc.Logging)
+logging(DevNull, Logging)
 @test sprint(Logging.bar) == ""
 @test sprint(Logging.pooh) == ""
 @test all(contains.(sprint(foo), ["INFO: fooinfo", "WARNING: foowarn", "ERROR: \"fooerror\""]))
@@ -239,7 +239,7 @@ let
     redir_err = "redirect_stderr(STDOUT)"
     exename = Base.julia_cmd()
     script = "$redir_err; module A; f() = 1; end; A.f() = 1"
-    warning_str = readstring(`$exename --startup-file=no -e $script`)
+    warning_str = read(`$exename --startup-file=no -e $script`, String)
     @test contains(warning_str, "f()")
 end
 
@@ -265,11 +265,34 @@ let l = ReentrantLock()
     @test_throws ErrorException unlock(l)
 end
 
+# task switching
+
+@noinline function f6597(c)
+    t = @schedule nothing
+    finalizer(t, t -> c[] += 1)
+    wait(t)
+    @test c[] == 0
+    wait(t)
+    nothing
+end
+let c = Ref(0),
+    t2 = @schedule (wait(); c[] += 99)
+    @test c[] == 0
+    f6597(c)
+    gc() # this should run the finalizer for t
+    @test c[] == 1
+    yield()
+    @test c[] == 1
+    yield(t2)
+    @test c[] == 100
+end
+
+
 # timing macros
 
 # test that they don't introduce global vars
 global v11801, t11801, names_before_timing
-names_before_timing = names(current_module(), true)
+names_before_timing = names(@__MODULE__, true)
 
 let t = @elapsed 1+1
     @test isa(t, Real) && t >= 0
@@ -288,7 +311,7 @@ v11801, t11801 = @timed sin(1)
 @test v11801 == sin(1)
 @test isa(t11801,Real) && t11801 >= 0
 
-@test names(current_module(), true) == names_before_timing
+@test names(@__MODULE__, true) == names_before_timing
 
 # interactive utilities
 
@@ -507,16 +530,26 @@ let s = "abcα🐨\0x\0"
 end
 
 # clipboard functionality
-if is_windows()
+if Sys.iswindows()
     for str in ("Hello, world.", "∀ x ∃ y", "")
         clipboard(str)
         @test clipboard() == str
     end
 end
 
-optstring = sprint(show, Base.JLOptions())
-@test startswith(optstring, "JLOptions(")
-@test endswith(optstring, ")")
+let optstring = stringmime(MIME("text/plain"), Base.JLOptions())
+    @test startswith(optstring, "JLOptions(\n")
+    @test !contains(optstring, "Ptr")
+    @test endswith(optstring, "\n)")
+    @test contains(optstring, " = \"")
+end
+let optstring = repr(Base.JLOptions())
+    @test startswith(optstring, "JLOptions(")
+    @test endswith(optstring, ")")
+    @test !contains(optstring, "\n")
+    @test !contains(optstring, "Ptr")
+    @test contains(optstring, " = \"")
+end
 
 # Base.securezero! functions (#17579)
 import Base: securezero!, unsafe_securezero!
@@ -536,7 +569,7 @@ let creds = Base.LibGit2.CachedCredentials()
 end
 
 # Test that we can VirtualProtect jitted code to writable
-if is_windows()
+if Sys.iswindows()
     @noinline function WeVirtualProtectThisToRWX(x, y)
         x+y
     end
@@ -552,13 +585,65 @@ if is_windows()
     end
 end
 
-# CRC32c checksum (test data generated from @andrewcooke's CRC.jl package)
-for force_software_crc in (1,0)
-    ccall(:jl_crc32c_init, Void, (Cint,), force_software_crc)
+function test_crc32c(crc32c)
+    # CRC32c checksum (test data generated from @andrewcooke's CRC.jl package)
     for (n,crc) in [(0,0x00000000),(1,0xa016d052),(2,0x03f89f52),(3,0xf130f21e),(4,0x29308cf4),(5,0x53518fab),(6,0x4f4dfbab),(7,0xbd3a64dc),(8,0x46891f81),(9,0x5a14b9f9),(10,0xb219db69),(11,0xd232a91f),(12,0x51a15563),(13,0x9f92de41),(14,0x4d8ae017),(15,0xc8b74611),(16,0xa0de6714),(17,0x672c992a),(18,0xe8206eb6),(19,0xc52fd285),(20,0x327b0397),(21,0x318263dd),(22,0x08485ccd),(23,0xea44d29e),(24,0xf6c0cb13),(25,0x3969bba2),(26,0x6a8810ec),(27,0x75b3d0df),(28,0x82d535b1),(29,0xbdf7fc12),(30,0x1f836b7d),(31,0xd29f33af),(32,0x8e4acb3e),(33,0x1cbee2d1),(34,0xb25f7132),(35,0xb0fa484c),(36,0xb9d262b4),(37,0x3207fe27),(38,0xa024d7ac),(39,0x49a2e7c5),(40,0x0e2c157f),(41,0x25f7427f),(42,0x368c6adc),(43,0x75efd4a5),(44,0xa84c5c31),(45,0x0fc817b2),(46,0x8d99a881),(47,0x5cc3c078),(48,0x9983d5e2),(49,0x9267c2db),(50,0xc96d4745),(51,0x058d8df3),(52,0x453f9cf3),(53,0xb714ade1),(54,0x55d3c2bc),(55,0x495710d0),(56,0x3bddf494),(57,0x4f2577d0),(58,0xdae0f604),(59,0x3c57c632),(60,0xfe39bbb0),(61,0x6f5d1d41),(62,0x7d996665),(63,0x68c738dc),(64,0x8dfea7ae)]
-        @test Base.crc32c(UInt8[1:n;]) == crc
+        @test crc32c(UInt8[1:n;]) == crc == crc32c(String(UInt8[1:n;]))
+    end
+
+    # test that crc parameter is equivalent to checksum of concatenated data,
+    # and test crc of subarrays:
+    a = UInt8[1:255;]
+    crc_256 = crc32c(a)
+    @views for n = 1:255
+        @test crc32c(a[n+1:end], crc32c(a[1:n])) == crc_256
+    end
+    @test crc32c(IOBuffer(a)) == crc_256
+    let buf = IOBuffer()
+        write(buf, a[1:3])
+        @test crc32c(seekstart(buf)) == crc32c(a[1:3])
+        @test crc32c(buf) == 0x00000000
+        @test crc32c(seek(buf, 1)) == crc32c(a[2:3])
+        @test crc32c(seek(buf, 0), 2) == crc32c(a[1:2])
+        @test crc32c(buf) == crc32c(a[3:3])
+    end
+
+    let f = tempname()
+        try
+            write(f, a)
+            @test open(crc32c, f) == crc_256
+            open(f, "r") do io
+                @test crc32c(io, 16) == crc32c(a[1:16])
+                @test crc32c(io, 16) == crc32c(a[17:32])
+                @test crc32c(io) == crc32c(a[33:end])
+                @test crc32c(io, 1000) == 0x00000000
+            end
+            a = rand(UInt8, 30000)
+            write(f, a)
+            @test open(crc32c, f) == crc32c(a) == open(io -> crc32c(io, 10^6), f)
+        finally
+            rm(f, force=true)
+        end
     end
 end
+unsafe_crc32c_sw(a, n, crc) =
+    ccall(:jl_crc32c_sw, UInt32, (UInt32, Ptr{UInt8}, Csize_t), crc, a, n)
+crc32c_sw(a::Union{Array{UInt8},Base.FastContiguousSubArray{UInt8,N,<:Array{UInt8}} where N},
+          crc::UInt32=0x00000000) = unsafe_crc32c_sw(a, length(a), crc)
+crc32c_sw(s::String, crc::UInt32=0x00000000) = unsafe_crc32c_sw(s, sizeof(s), crc)
+function crc32c_sw(io::IO, nb::Integer, crc::UInt32=0x00000000)
+    nb < 0 && throw(ArgumentError("number of bytes to checksum must be ≥ 0"))
+    buf = Array{UInt8}(min(nb, 24576))
+    while !eof(io) && nb > 24576
+        n = readbytes!(io, buf)
+        crc = unsafe_crc32c_sw(buf, n, crc)
+        nb -= n
+    end
+    return unsafe_crc32c_sw(buf, readbytes!(io, buf, min(nb, length(buf))), crc)
+end
+crc32c_sw(io::IO, crc::UInt32=0x00000000) = crc32c_sw(io, typemax(Int64), crc)
+test_crc32c(crc32c)
+test_crc32c(crc32c_sw)
 
 let
     old_have_color = Base.have_color
@@ -572,6 +657,25 @@ let
     end
 end
 
+# Test that `print_with_color` accepts non-string values, just as `print` does
+let
+    old_have_color = Base.have_color
+    try
+        @eval Base have_color = true
+        buf_color = IOBuffer()
+        args = (3.2, "foo", :testsym)
+        print_with_color(:red, buf_color, args...)
+        buf_plain = IOBuffer()
+        print(buf_plain, args...)
+        expected_str = string(Base.text_colors[:red],
+                              String(take!(buf_plain)),
+                              Base.text_colors[:default])
+        @test expected_str == String(take!(buf_color))
+    finally
+        @eval Base have_color = $(old_have_color)
+    end
+end
+
 let
     global c_18711 = 0
     buf = IOContext(IOBuffer(), :hascontext => true)
@@ -600,7 +704,7 @@ let
 end
 
 abstract type DA_19281{T, N} <: AbstractArray{T, N} end
-Base.convert{S,T,N}(::Type{Array{S, N}}, ::DA_19281{T, N}) = error()
+Base.convert(::Type{Array{S, N}}, ::DA_19281{T, N}) where {S,T,N} = error()
 x_19281 = [(), (1,)]
 mutable struct Foo_19281
     f::Vector{Tuple}
@@ -609,7 +713,7 @@ end
 
 @testset "test this does not segfault #19281" begin
     @test Foo_19281().f[1] == ()
-    @test Foo_19281().f[2] == (1, )
+    @test Foo_19281().f[2] == (1,)
 end
 
 let
@@ -640,3 +744,80 @@ if Bool(parse(Int,(get(ENV, "JULIA_TESTFULL", "0"))))
         @test_throws StackOverflowError f_19433(+, 1, 2)
     end
 end
+
+# Test issue #19774 invokelatest fix.
+
+# we define this in a module to allow rewriting
+# rather than needing an extra eval.
+module Issue19774
+f(x) = 1
+end
+
+# First test the world issue condition.
+let foo() = begin
+        Issue19774.f(x::Int) = 2
+        return Issue19774.f(0)
+    end
+    @test foo() == 1    # We should be using the original function.
+end
+
+# Now check that invokelatest fixes that issue.
+let foo() = begin
+        Issue19774.f(x::Int) = 3
+        return Base.invokelatest(Issue19774.f, 0)
+    end
+    @test foo() == 3
+end
+
+# Check that the kwargs conditions also works
+module Kwargs19774
+f(x, y; z=0) = x * y + z
+end
+
+@test Kwargs19774.f(2, 3; z=1) == 7
+
+let foo() = begin
+        Kwargs19774.f(x::Int, y::Int; z=3) = z
+        return Base.invokelatest(Kwargs19774.f, 2, 3; z=1)
+    end
+    @test foo() == 1
+end
+
+# Endian tests
+# For now, we only support little endian.
+# Add an `Sys.ARCH` test for big endian when/if we add support for that.
+# Do **NOT** use `ENDIAN_BOM` to figure out the endianess
+# since that's exactly what we want to test.
+@test ENDIAN_BOM == 0x04030201
+@test ntoh(0x1) == 0x1
+@test hton(0x1) == 0x1
+@test ltoh(0x1) == 0x1
+@test htol(0x1) == 0x1
+@test ntoh(0x102) == 0x201
+@test hton(0x102) == 0x201
+@test ltoh(0x102) == 0x102
+@test htol(0x102) == 0x102
+@test ntoh(0x1020304) == 0x4030201
+@test hton(0x1020304) == 0x4030201
+@test ltoh(0x1020304) == 0x1020304
+@test htol(0x1020304) == 0x1020304
+@test ntoh(0x102030405060708) == 0x807060504030201
+@test hton(0x102030405060708) == 0x807060504030201
+@test ltoh(0x102030405060708) == 0x102030405060708
+@test htol(0x102030405060708) == 0x102030405060708
+
+@testset "inline bug #18735" begin
+    @noinline f(n) = n ? error() : Int
+    g() = Union{f(true)}
+    @test_throws ErrorException g()
+end
+
+include("testenv.jl")
+
+let flags = Cmd(filter(a->!contains(a, "depwarn"), collect(test_exeflags)))
+    local cmd = `$test_exename $flags deprecation_exec.jl`
+
+    if !success(pipeline(cmd; stdout=STDOUT, stderr=STDERR))
+        error("Deprecation test failed, cmd : $cmd")
+    end
+end
diff --git a/test/mmap.jl b/test/mmap.jl
index f79a1154baf21f..3e62acf5187d31 100644
--- a/test/mmap.jl
+++ b/test/mmap.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 file = tempname()
 write(file, "Hello World\n")
@@ -52,7 +52,7 @@ m = Mmap.mmap(file,Vector{UInt8},12)
 m[:] = b"Hello World\n"
 Mmap.sync!(m)
 finalize(m); m=nothing; gc()
-@test open(readstring,file) == "Hello World\n"
+@test open(x->read(x, String),file) == "Hello World\n"
 
 s = open(file, "r")
 close(s)
diff --git a/test/mod2pi.jl b/test/mod2pi.jl
index 05e8229159e866..8ecdafe3a5e111 100644
--- a/test/mod2pi.jl
+++ b/test/mod2pi.jl
@@ -1,11 +1,11 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # NOTES on range reduction
 # [1] compute numbers near pi: http://www.cs.berkeley.edu/~wkahan/testpi/nearpi.c
 # [2] range reduction: http://hal-ujm.ccsd.cnrs.fr/docs/00/08/69/04/PDF/RangeReductionIEEETC0305.pdf
 # [3] precise addition, see Add22: http://ftp.nluug.nl/pub/os/BSD/FreeBSD/distfiles/crlibm/crlibm-1.0beta3.pdf
 
-# Examples:
+# Examples
 # ΓΓ = 6411027962775774 / 2^45  # see [2] above, section 1.2
 # julia> mod(ΓΓ, 2pi)    # "naive" way - easily wrong
 # 7.105427357601002e-15
@@ -194,3 +194,75 @@ testModPi()
 @test mod2pi(355.0f0) ≈ 3.1416228f0
 @test mod2pi(Int64(2)^60) == mod2pi(2.0^60)
 @test_throws ArgumentError mod2pi(Int64(2)^60-1)
+
+@testset "rem_pio2_kernel" begin
+    # test worst case
+    x = 6381956970095103.0 * 2.0^797
+    a = setprecision(BigFloat, 4096) do
+        rem(big(x), big(pi)/2, RoundNearest)
+    end
+
+    n, yrem = Base.Math.rem_pio2_kernel(x)
+    y=yrem.hi+yrem.lo
+    @test a-y<nextfloat(y)/2
+    # The following has easy and hard cases in each interval. A hard case is one
+    # where x ≈ k*pi/2 for some integer k.
+    cases = [0.0, pi/6, # -π/4 <= x <= π/4
+             2*pi/4-0.1, 2*pi/4, # -2π/4 <= x <= 2π/4
+             3*pi/4-0.1, # -3π/4 <= x <= 3π/4
+             pi-0.1, Float64(pi), # -4π/4 <= x <= 4π/4
+             5*pi/4-0.1, # -5π/4 <= x <= 5π/4
+             6*pi/4-0.1, 6*pi/4, # -6π/4 <= x <= 6π/4
+             7*pi/4-0.1, # -7π/4 <= x <= 7π/4
+             2*pi, 2*pi-0.1, # -8π/4 <= x <= 8π/4
+             9*pi/4-0.1, # -9π/4 <= x <= 9π/4
+             2.0^10*pi/4, # -2.0^20π/2 <= x <= 2.0^20π/2
+             2.0^30*pi/4, # |x| >= 2.0^20π/2, idx < 0
+             2.0^80*pi/4] # |x| >= 2.0^20π/2, idx > 0-0.22370138542135648
+
+     # ieee754_rem_pio2_return contains the returned value from the ieee754_rem_pio2
+     # function in openlibm: https://github.com/JuliaLang/openlibm/blob/0598080ca09468490a13ae393ba17d8620c1b201/src/e_rem_pio2.c
+     ieee754_rem_pio2_return = [1.5707963267948966 1.5707963267948966;
+                                1.0471975511965979 -1.0471975511965979;
+                                0.10000000000000014 -0.10000000000000014;
+                                6.123233995736766e-17 -6.123233995736766e-17;
+                                -0.6853981633974481 0.6853981633974481;
+                                0.10000000000000021 -0.10000000000000021;
+                                1.2246467991473532e-16 -1.2246467991473532e-16;
+                                -0.6853981633974481 0.6853981633974481;
+                                0.09999999999999983 -0.09999999999999983;
+                                1.8369701987210297e-16 -1.8369701987210297e-16;
+                                -0.6853981633974484 0.6853981633974484;
+                                2.4492935982947064e-16 -2.4492935982947064e-16;
+                                0.0999999999999999 -0.0999999999999999;
+                                -0.6853981633974484 0.6853981633974484;
+                                3.135095805817224e-14 -3.135095805817224e-14;
+                                3.287386219680602e-8 -3.287386219680602e-8;
+                                -0.1757159771004682 0.1757159771004682]'
+
+    for (i, case) in enumerate(cases)
+        # negative argument
+        n, ret = Base.Math.rem_pio2_kernel(-case)
+        ret_sum = ret.hi+ret.lo
+        ulp_error = (ret_sum-ieee754_rem_pio2_return[1, i])/eps(ieee754_rem_pio2_return[1, i])
+        @test ulp_error <= 0.5
+        diff = Float64(mod(big(-case), big(pi)/2))-(ret.hi+ret.lo)
+        @test abs(diff) in (0.0, 1.5707963267948966, 1.5707963267948968)
+        # positive argument
+        n, ret = Base.Math.rem_pio2_kernel(case)
+        ret_sum = ret.hi+ret.lo
+        ulp_error = (ret_sum-ieee754_rem_pio2_return[2, i])/eps(ieee754_rem_pio2_return[2, i])
+        @test ulp_error <= 0.5
+        diff = Float64(mod(big(case), big(pi)/2))-(ret.hi+ret.lo)
+        @test abs(diff) in (0.0, 1.5707963267948966, 1.5707963267948968)
+    end
+end
+@testset "rem_pio2_kernel and mod2pi" begin
+    for int in (3632982096228748, 1135326194816)
+        bignum = int*big(pi)/2+0.00001
+        bigrem = rem(bignum, big(pi)/2, RoundDown)
+        fnum = Float64(bignum)
+        n, ret = Base.Math.rem_pio2_kernel(fnum)
+        @test mod2pi(fnum) == (ret.hi+ret.lo)
+    end
+end
diff --git a/test/mpfr.jl b/test/mpfr.jl
index 521eb0f69c2ead..3344b4cc4a9bb8 100644
--- a/test/mpfr.jl
+++ b/test/mpfr.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 import Base.MPFR
 # constructors
@@ -885,3 +885,10 @@ setprecision(256) do
     @test string(big(-Inf)) == "BigFloat(-Inf, 256)"
     @test string(big(NaN)) == "BigFloat(NaN, 256)"
 end
+
+# issue #22758
+if MPFR.get_version() > v"3.1.5" || "r11590" in MPFR.get_patches()
+    setprecision(2_000_000) do
+        @test abs(sin(big(pi)/6) - 0.5) < ldexp(big(1.0),-1_999_000)
+    end
+end
diff --git a/test/netload/memtest.jl b/test/netload/memtest.jl
index b69b35dec658ff..b024df4980e55c 100644
--- a/test/netload/memtest.jl
+++ b/test/netload/memtest.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 struct RUsage
     ru_utime_sec::Clong         #  user CPU time used
diff --git a/test/netload/nettest.jl b/test/netload/nettest.jl
index 0cc50fd450aa23..0f7394def95c87 100644
--- a/test/netload/nettest.jl
+++ b/test/netload/nettest.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Run various networking tests checking to see how we perform under large loads
 addprocs(1)
diff --git a/test/nullable.jl b/test/nullable.jl
index db433bf8e5bbb6..4148b440450330 100644
--- a/test/nullable.jl
+++ b/test/nullable.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # "is a null with type T", curried on 2nd argument
 isnull_oftype(x::Nullable, T::Type) = eltype(x) == T && isnull(x)
@@ -115,9 +115,8 @@ for (i, T) in enumerate(types)
 end
 
 module NullableTestEnum
-const curmod = current_module()
-const curmod_name = fullname(curmod)
-const curmod_prefix = "$(["$m." for m in curmod_name]...)"
+# For curmod_*
+include("testenv.jl")
 io = IOBuffer()
 @enum TestEnum a b
 show(io, Nullable(a))
@@ -522,6 +521,9 @@ end
 @test repr(Nullable()) == "Nullable{Union{}}()"
 
 # issue #19270
-let f19270{S,T}(x::S, y::T) = Base.promote_op(^, S, T)
+let f19270(x::S, y::T) where {S,T} = Base.promote_op(^, S, T)
     @test f19270(Nullable(0.0f0), Nullable(BigInt(0))) == Nullable{Float32}
 end
+
+# issue #21397
+@test Nullable(Tuple) === Nullable{DataType}(Tuple)
diff --git a/test/numbers.jl b/test/numbers.jl
index d46fb92f943801..9ce99dcd798400 100644
--- a/test/numbers.jl
+++ b/test/numbers.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 const ≣ = isequal # convenient for comparing NaNs
 
@@ -53,6 +53,7 @@ const ≣ = isequal # convenient for comparing NaNs
 @test_throws InexactError Bool(1//2)
 
 @test iszero(false) && !iszero(true)
+@test isone(true) && !isone(false)
 
 # basic arithmetic
 @test 2 + 3 == 5
@@ -2491,6 +2492,13 @@ end
 @test reinterpret(Float32,bswap(0x0000c03f)) === 1.5f0
 @test bswap(reinterpret(Float64,0x000000000000f03f)) === 1.0
 @test bswap(reinterpret(Float32,0x0000c03f)) === 1.5f0
+zbuf = IOBuffer([0xbf, 0xc0, 0x00, 0x00, 0x40, 0x20, 0x00, 0x00,
+                 0x40, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                 0xc0, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
+z1 = read(zbuf, Complex64)
+z2 = read(zbuf, Complex128)
+@test bswap(z1) === -1.5f0 + 2.5f0im
+@test bswap(z2) ===  3.5 - 4.5im
 
 #isreal(x::Real) = true
 for x in [1.23, 7, e, 4//5] #[FP, Int, Irrational, Rat]
@@ -2801,6 +2809,7 @@ testmi(typemax(UInt32)-UInt32(1000):typemax(UInt32), map(UInt32, 1:100))
 @test indices(1,1) == 1:1
 @test_throws BoundsError indices(1,-1)
 @test isinteger(Integer(2)) == true
+@test !isinteger(π)
 @test size(1) == ()
 @test length(1) == 1
 @test endof(1) == 1
@@ -2903,34 +2912,80 @@ end
 end
 
 import Base.^
-immutable PR20530; end
+struct PR20530; end
+struct PR20889; x; end
 ^(::PR20530, p::Int) = 1
-^{p}(::PR20530, ::Type{Val{p}}) = 2
+^(t::PR20889, b) = t.x + b
+^(t::PR20889, b::Integer) = t.x + b
+Base.literal_pow(::typeof(^), ::PR20530, ::Val{p}) where {p} = 2
 @testset "literal powers" begin
     x = PR20530()
     p = 2
     @test x^p == 1
     @test x^2 == 2
     @test [x,x,x].^2 == [2,2,2]
+    for T in (Float16, Float32, Float64, BigFloat, Int8, Int, BigInt, Complex{Int}, Complex{Float64})
+        for p in -4:4
+            if p < 0 && real(T) <: Integer
+                @test_throws DomainError eval(:($T(2)^$p))
+            else
+                v = eval(:($T(2)^$p))
+                @test 2.0^p == T(2)^p == v
+                @test v isa T
+            end
+        end
+    end
+    @test PR20889(2)^3 == 5
+end
+module M20889 # do we get the expected behavior without importing Base.^?
+    struct PR20889; x; end
+    ^(t::PR20889, b) = t.x + b
+    Base.Test.@test PR20889(2)^3 == 5
 end
 
-@testset "iszero" begin
+@testset "iszero & isone" begin
     # Numeric scalars
     for T in [Float16, Float32, Float64, BigFloat,
               Int8, Int16, Int32, Int64, Int128, BigInt,
               UInt8, UInt16, UInt32, UInt64, UInt128]
         @test iszero(T(0))
+        @test isone(T(1))
         @test iszero(Complex{T}(0))
+        @test isone(Complex{T}(1))
         if T <: Integer
             @test iszero(Rational{T}(0))
+            @test isone(Rational{T}(1))
         elseif T <: AbstractFloat
             @test iszero(T(-0.0))
             @test iszero(Complex{T}(-0.0))
         end
     end
     @test !iszero(nextfloat(BigFloat(0)))
+    @test !isone(nextfloat(BigFloat(1)))
+    for x in (π, e, γ, catalan, φ)
+        @test !iszero(x)
+        @test !isone(x)
+    end
 
     # Array reduction
     @test !iszero([0, 1, 2, 3])
     @test iszero(zeros(Int, 5))
+    @test !isone(tril(ones(Int, 5, 5)))
+    @test !isone(triu(ones(Int, 5, 5)))
+    @test !isone(zeros(Int, 5, 5))
+    @test isone(eye(Int, 5, 5))
+    @test isone(eye(Int, 1000, 1000)) # sizeof(X) > 2M == ISONE_CUTOFF
+end
+
+f20065(B, i) = UInt8(B[i])
+@testset "issue 20065" begin
+    # f20065 must be called from global scope to exhibit the buggy behavior
+    for B in (Array{Bool}(10), Array{Bool}(10,10), reinterpret(Bool, rand(UInt8, 10)))
+        @test all(x-> x <= 1, (f20065(B, i) for i in eachindex(B)))
+        for i in 1:length(B)
+            @test (@eval f20065($B, $i) <= 1)
+        end
+    end
 end
+
+@test inv(3//4) === 4//3 === 1 / (3//4) === 1 // (3//4)
diff --git a/test/offsetarray.jl b/test/offsetarray.jl
index 3d9e1355b9b272..46ace5061822fe 100644
--- a/test/offsetarray.jl
+++ b/test/offsetarray.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 isdefined(Main, :TestHelpers) || @eval Main include(joinpath(dirname(@__FILE__), "TestHelpers.jl"))
 using TestHelpers.OAs
@@ -278,12 +278,24 @@ am = map(identity, a)
 
 # other functions
 v = OffsetArray(v0, (-3,))
+@test endof(v) == 1
 @test v ≈ v
 @test indices(v') === (Base.OneTo(1),-2:1)
+@test parent(v) == collect(v)
+rv = reverse(v)
+@test indices(rv) == indices(v)
+@test rv[1] == v[-2]
+@test rv[0] == v[-1]
+@test rv[-1] == v[0]
+@test rv[-2] == v[1]
+cv = copy(v)
+@test reverse!(cv) == rv
+
 A = OffsetArray(rand(4,4), (-3,5))
 @test A ≈ A
 @test indices(A') === (6:9, -2:1)
 @test parent(A') == parent(A)'
+@test collect(A) == parent(A)
 @test maximum(A) == maximum(parent(A))
 @test minimum(A) == minimum(parent(A))
 @test extrema(A) == extrema(parent(A))
@@ -384,31 +396,6 @@ circcopy!(dest, src)
 @test parent(dest) == [8 12 16 4; 5 9 13 1; 6 10 14 2; 7 11 15 3]
 @test dest[1:3,2:4] == src[1:3,2:4]
 
-e = eye(5)
-a = [e[:,1], e[:,2], e[:,3], e[:,4], e[:,5]]
-a1 = zeros(5)
-c = [ones(Complex{Float64}, 5),
-     exp.(-2*pi*im*(0:4)/5),
-     exp.(-4*pi*im*(0:4)/5),
-     exp.(-6*pi*im*(0:4)/5),
-     exp.(-8*pi*im*(0:4)/5)]
-for s = -5:5
-    for i = 1:5
-        thisa = OffsetArray(a[i], (s,))
-        thisc = c[mod1(i+s+5,5)]
-        if Base.USE_GPL_LIBS
-            @test fft(thisa) ≈ thisc
-            @test fft(thisa, 1) ≈ thisc
-            @test ifft(fft(thisa)) ≈ circcopy!(a1, thisa)
-            @test ifft(fft(thisa, 1), 1) ≈ circcopy!(a1, thisa)
-            @test rfft(thisa) ≈ thisc[1:3]
-            @test rfft(thisa, 1) ≈ thisc[1:3]
-            @test irfft(rfft(thisa, 1), 5, 1) ≈ a1
-            @test irfft(rfft(thisa, 1), 5, 1) ≈ a1
-        end
-    end
-end
-
 end # let
 
 # Check that similar throws a MethodError rather than a
diff --git a/test/operators.jl b/test/operators.jl
index a95e2a24dc3da1..e79d3f5a93d533 100644
--- a/test/operators.jl
+++ b/test/operators.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 @test ifelse(true, 1, 2) == 1
 @test ifelse(false, 1, 2) == 2
@@ -97,3 +97,18 @@ end
     B = 3 .> [1 -1 5] .> 0
     @test B == [true false false]
 end
+
+struct TypeWrapper
+    t::Type
+end
+Base.:(<)(x::TypeWrapper, y::TypeWrapper) = (x.t <: y.t) & (x.t != y.t)
+@testset "poset" begin
+    #   Real
+    #  /    \
+    # Int  Float64
+    #  \    /
+    #  Union{}
+    @test TypeWrapper(Int) <= TypeWrapper(Int)
+    @test TypeWrapper(Int) <= TypeWrapper(Real)
+    @test !(TypeWrapper(Int) <= TypeWrapper(Float64))
+end
diff --git a/test/osutils.jl b/test/osutils.jl
index e75ded56a1eafd..8c8a213e524f5a 100644
--- a/test/osutils.jl
+++ b/test/osutils.jl
@@ -1,19 +1,21 @@
-@test !Base.is_unix(:Windows)
-@test !Base.is_linux(:Windows)
-@test Base.is_linux(:Linux)
-@test Base.is_windows(:Windows)
-@test Base.is_windows(:NT)
-@test !Base.is_windows(:Darwin)
-@test Base.is_apple(:Darwin)
-@test Base.is_apple(:Apple)
-@test !Base.is_apple(:Windows)
-@test Base.is_unix(:Darwin)
-@test Base.is_unix(:FreeBSD)
-@test_throws ArgumentError Base.is_unix(:BeOS)
-if !is_windows()
-    @test Sys.windows_version() === (0, 0)
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
+@test !Sys.isunix(:Windows)
+@test !Sys.islinux(:Windows)
+@test Sys.islinux(:Linux)
+@test Sys.iswindows(:Windows)
+@test Sys.iswindows(:NT)
+@test !Sys.iswindows(:Darwin)
+@test Sys.isapple(:Darwin)
+@test Sys.isapple(:Apple)
+@test !Sys.isapple(:Windows)
+@test Sys.isunix(:Darwin)
+@test Sys.isunix(:FreeBSD)
+@test_throws ArgumentError Sys.isunix(:BeOS)
+if !Sys.iswindows()
+    @test Sys.windows_version() == v"0.0.0"
 else
-    @test (Sys.windows_version()::Tuple{Int,Int})[1] > 0
+    @test Sys.windows_version() >= v"1.0.0-"
 end
 
 @test (@static true ? 1 : 2) === 1
@@ -24,3 +26,13 @@ end
 @test (@static false && 1) === false
 @test (@static true || 1) === true
 @test (@static false || 1) === 1
+
+# test that path variables use correct path delimiters on windows
+if Sys.iswindows()
+    @test !contains(Base.SYSCONFDIR, "/")
+    @test !contains(Base.DATAROOTDIR, "/")
+    @test !contains(Base.DOCDIR, "/")
+    @test !contains(Base.LIBDIR, "/")
+    @test !contains(Base.PRIVATE_LIBDIR, "/")
+    @test !contains(Base.INCLUDEDIR, "/")
+end
diff --git a/test/parse.jl b/test/parse.jl
index 6c34f4dd680760..a7822e679c841f 100644
--- a/test/parse.jl
+++ b/test/parse.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # tests for parser and syntax lowering
 
@@ -21,9 +21,9 @@ end
 # issue #9684
 let
     undot(op) = Symbol(string(op)[2:end])
-    for (ex1, ex2) in [("5.≠x", "5.!=x"),
-                       ("5.≥x", "5.>=x"),
-                       ("5.≤x", "5.<=x")]
+    for (ex1, ex2) in [("5 .≠ x", "5 .!= x"),
+                       ("5 .≥ x", "5 .>= x"),
+                       ("5 .≤ x", "5 .<= x")]
         ex1 = parse(ex1); ex2 = parse(ex2)
         @test ex1.head === :call && (ex1.head === ex2.head)
         @test ex1.args[2] === 5 && ex2.args[2] === 5
@@ -147,10 +147,10 @@ macro test999_str(args...); args; end
 
 # issue 11970
 @test parseall("""
-macro f(args...) end; @f ""
+    macro f(args...) end; @f "macro argument"
 """) == Expr(:toplevel,
-             Expr(:macro, Expr(:call, :f, Expr(:..., :args)), Expr(:block, Expr(:line, 1, :none))),
-             Expr(:macrocall, Symbol("@f"), ""))
+             Expr(:macro, Expr(:call, :f, Expr(:..., :args)), Expr(:block, LineNumberNode(1, :none))),
+             Expr(:macrocall, Symbol("@f"), LineNumberNode(1, :none), "macro argument"))
 
 # blocks vs. tuples
 @test parse("()") == Expr(:tuple)
@@ -246,7 +246,8 @@ for T in vcat(subtypes(Signed), subtypes(Unsigned))
 
     # Test that the entire input string appears in error messages
     let s = "     false    true     "
-        result = @test_throws ArgumentError get(Base.tryparse_internal(Bool, s, start(s), endof(s), 0, true))
+        result = @test_throws(ArgumentError,
+            get(Base.tryparse_internal(Bool, s, start(s), endof(s), 0, true)))
         @test result.value.msg == "invalid Bool representation: $(repr(s))"
     end
 
@@ -275,6 +276,9 @@ for T in vcat(subtypes(Signed), subtypes(Unsigned))
     @test parse(Float64, ".5    "    ) == 0.5
 end
 
+@test parse(Bool, "\u202f true") === true
+@test parse(Bool, "\u202f false") === false
+
 parsebin(s) = parse(Int,s,2)
 parseoct(s) = parse(Int,s,8)
 parsehex(s) = parse(Int,s,16)
@@ -347,7 +351,7 @@ parsehex(s) = parse(Int,s,16)
 # issue #17705
 @test parse("2e3_") == Expr(:call, :*, 2e3, :_)
 @test parse("2e-3_") == Expr(:call, :*, 2e-3, :_)
-@test parse("2e3_\"x\"") == Expr(:call, :*, 2e3, Expr(:macrocall, Symbol("@__str"), "x"))
+@test parse("2e3_\"x\"") == Expr(:call, :*, 2e3, Expr(:macrocall, Symbol("@__str"), LineNumberNode(1, :none), "x"))
 
 # multibyte spaces
 @test parse(Int, "3\u2003\u202F") == 3
@@ -418,7 +422,9 @@ end
                                  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 "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
@@ -489,7 +495,7 @@ test_parseerror("0x0.1", "hex float literal must contain \"p\" or \"P\"")
 test_parseerror("0x1.0p", "invalid numeric constant \"0x1.0\"")
 
 # issue #15798
-@test expand(Base.parse_input_line("""
+@test expand(Main, Base.parse_input_line("""
               try = "No"
            """)) == Expr(:error, "unexpected \"=\"")
 
@@ -508,7 +514,7 @@ let b = IOBuffer("""
                  end
                  f()
                  """)
-    @test Base.parse_input_line(b) == Expr(:let, Expr(:block, Expr(:line, 2, :none), :x), Expr(:(=), :x, :x))
+    @test Base.parse_input_line(b) == Expr(:let, Expr(:block, LineNumberNode(2, :none), :x), Expr(:(=), :x, :x))
     @test Base.parse_input_line(b) == Expr(:call, :f)
     @test Base.parse_input_line(b) === nothing
 end
@@ -518,10 +524,10 @@ test_parseerror("if\nfalse\nend", "missing condition in \"if\" at none:1")
 test_parseerror("if false\nelseif\nend", "missing condition in \"elseif\" at none:2")
 
 # issue #15828
-@test expand(parse("x...")) == Expr(:error, "\"...\" expression outside call")
+@test expand(Main, parse("x...")) == Expr(:error, "\"...\" expression outside call")
 
 # issue #15830
-@test expand(parse("foo(y = (global x)) = y")) == Expr(:error, "misplaced \"global\" declaration")
+@test expand(Main, parse("foo(y = (global x)) = y")) == Expr(:error, "misplaced \"global\" declaration")
 
 # issue #15844
 function f15844(x)
@@ -552,11 +558,11 @@ add_method_to_glob_fn!()
 @test_throws ParseError parse("function finally() end")
 
 # PR #16170
-@test expand(parse("true(x) = x")) == Expr(:error, "invalid function name \"true\"")
-@test expand(parse("false(x) = x")) == Expr(:error, "invalid function name \"false\"")
+@test expand(Main, parse("true(x) = x")) == Expr(:error, "invalid function name \"true\"")
+@test expand(Main, parse("false(x) = x")) == Expr(:error, "invalid function name \"false\"")
 
 # issue #16355
-@test expand(:(f(d:Int...)=nothing)) == Expr(:error, "\"d:Int\" is not a valid function argument name")
+@test expand(Main, :(f(d:Int...) = nothing)) == Expr(:error, "\"d:Int\" is not a valid function argument name")
 
 # issue #16517
 @test (try error(); catch 0; end) === 0
@@ -568,19 +574,19 @@ f16517() = try error(); catch 0; end
 # issue #16671
 @test parse("1.") === 1.0
 
+isline(x) = isa(x, LineNumberNode)
+
 # issue #16672
-let isline(x) = isa(x,Expr) && x.head === :line
-    @test count(isline, parse("begin end").args) == 1
-    @test count(isline, parse("begin; end").args) == 1
-    @test count(isline, parse("begin; x+2; end").args) == 1
-    @test count(isline, parse("begin; x+2; y+1; end").args) == 2
-end
+@test count(isline, parse("begin end").args) == 1
+@test count(isline, parse("begin; end").args) == 1
+@test count(isline, parse("begin; x+2; end").args) == 1
+@test count(isline, parse("begin; x+2; y+1; end").args) == 2
 
 # issue #16736
 let
-    local lineoffset0 = @__LINE__ + 1
-    local lineoffset1 = @__LINE__
-    local lineoffset2 = @__LINE__ - 1
+    local lineoffset0 = @__LINE__() + 1
+    local lineoffset1 = @__LINE__()
+    local lineoffset2 = @__LINE__() - 1
     @test lineoffset0 == lineoffset1 == lineoffset2
 end
 
@@ -590,13 +596,13 @@ end
                  y
              end") == Expr(:try,
                            Expr(:block,
-                                Expr(:line, 1, :none),
+                                LineNumberNode(1, :none),
                                 :x),
                            false,
                            Expr(:block,
-                                Expr(:line, 2, :none),
+                                LineNumberNode(2, :none),
                                 Expr(:call, :test),
-                                Expr(:line, 3, :none),
+                                LineNumberNode(3, :none),
                                 :y))
 
 # test that pre 0.5 deprecated syntax is a parse error
@@ -613,15 +619,16 @@ end
 @test_throws ParseError parse("--x")
 @test_throws ParseError parse("stagedfunction foo(x); end")
 
-#@test_throws ParseError parse("{1,2,3}")
-#@test_throws ParseError parse("{1 2 3 4}")
-#@test_throws ParseError parse("{1,2; 3,4}")
-@test_throws ParseError parse("{x for x in 1:10}")
-@test_throws ParseError parse("{x=>y for (x,y) in zip([1,2,3],[4,5,6])}")
-#@test_throws ParseError parse("{:a=>1, :b=>2}")
-
 @test parse("A=>B") == Expr(:call, :(=>), :A, :B)
 
+@test parse("{1,2,3}") == Expr(:braces, 1, 2, 3)
+@test parse("{1 2 3 4}") == Expr(:bracescat, Expr(:row, 1, 2, 3, 4))
+@test parse("{1 2; 3 4}") == Expr(:bracescat, Expr(:row, 1, 2), Expr(:row, 3, 4))
+@test parse("{x for x in 1:10}") == Expr(:braces, :(x for x in 1:10))
+@test parse("{x=>y for (x,y) in zip([1,2,3],[4,5,6])}") == Expr(:braces, :(x=>y for (x,y) in zip([1,2,3],[4,5,6])))
+@test parse("{:a=>1, :b=>2}") == Expr(:braces, Expr(:call, :(=>), QuoteNode(:a), 1),
+                                      Expr(:call, :(=>), QuoteNode(:b), 2))
+
 # this now is parsed as getindex(Pair{Any,Any}, ...)
 @test_throws MethodError eval(parse("(Any=>Any)[]"))
 @test_throws MethodError eval(parse("(Any=>Any)[:a=>1,:b=>2]"))
@@ -636,7 +643,7 @@ end
 
 # issue #16720
 let err = try
-    include_string("module A
+    include_string(@__MODULE__, "module A
 
         function broken()
 
@@ -668,6 +675,10 @@ end
 # error throwing branch from #10560
 @test_throws ArgumentError Base.tryparse_internal(Bool, "foo", 1, 2, 10, true)
 
+@test tryparse(Float64, "1.23") === Nullable(1.23)
+@test tryparse(Float32, "1.23") === Nullable(1.23f0)
+@test tryparse(Float16, "1.23") === Nullable(Float16(1.23))
+
 # PR #17393
 for op in (:.==, :.&, :.|, :.≤)
     @test parse("a $op b") == Expr(:call, op, :a, :b)
@@ -689,30 +700,35 @@ let m_error, error_out, filename = Base.source_path()
     m_error = try @eval method_c6(A; B) = 3; catch e; e; end
     error_out = sprint(showerror, m_error)
     @test error_out == "syntax: keyword argument \"B\" needs a default value"
+
+    # issue #20614
+    m_error = try @eval foo(types::NTuple{N}, values::Vararg{Any,N}, c) where {N} = nothing; catch e; e; end
+    error_out = sprint(showerror, m_error)
+    @test startswith(error_out, "ArgumentError: Vararg on non-final argument")
 end
 
 # issue #7272
-@test expand(parse("let
+@test expand(Main, parse("let
               global x = 2
               local x = 1
               end")) == Expr(:error, "variable \"x\" declared both local and global")
 
-@test expand(parse("let
+@test expand(Main, parse("let
               local x = 2
               local x = 1
               end")) == Expr(:error, "local \"x\" declared twice")
 
-@test expand(parse("let x
+@test expand(Main, parse("let x
                   local x = 1
               end")) == Expr(:error, "local \"x\" declared twice")
 
-@test expand(parse("let x = 2
+@test expand(Main, parse("let x = 2
                   local x = 1
               end")) == Expr(:error, "local \"x\" declared twice")
 
 
 # make sure front end can correctly print values to error messages
-let ex = expand(parse("\"a\"=1"))
+let ex = expand(Main, parse("\"a\"=1"))
     @test ex == Expr(:error, "invalid assignment location \"\"a\"\"")
 end
 
@@ -732,20 +748,47 @@ for (str, tag) in Dict("" => :none, "\"" => :string, "#=" => :comment, "'" => :c
 end
 
 # meta nodes for optional positional arguments
-@test expand(:(@inline f(p::Int=2) = 3)).args[2].args[3].inlineable
+@test expand(Main, :(@inline f(p::Int=2) = 3)).args[2].args[3].inlineable
 
 # issue #16096
 module M16096
 macro iter()
-    quote
-        @inline function foo(sub)
+    return quote
+        @inline function foo16096(sub)
             it = 1
         end
     end
 end
 end
-let ex = expand(:(@M16096.iter))
-    @test !(isa(ex,Expr) && ex.head === :error)
+let ex = expand(M16096, :(@iter))
+    @test isa(ex, Expr) && ex.head === :body
+end
+let ex = expand(Main, :($M16096.@iter))
+    @test isa(ex, Expr) && ex.head === :body
+end
+let ex = expand(@__MODULE__, :(@M16096.iter))
+    @test isa(ex, Expr) && ex.head === :body
+    @test !isdefined(M16096, :foo16096)
+    @test eval(@__MODULE__, ex) === nothing
+    @test !@isdefined foo16096
+    @test isdefined(M16096, :foo16096)
+end
+@test M16096.foo16096(2.0) == 1
+macro f16096()
+    quote
+        g16096($(esc(:x))) = 2x
+    end
+end
+let g = @f16096
+    @test g(3) == 6
+end
+macro f16096_2()
+    quote
+        g16096_2(;$(esc(:x))=2) = 2x
+    end
+end
+let g = @f16096_2
+    @test g() == 4
 end
 
 # issue #15838
@@ -760,12 +803,12 @@ module B15838
 end
 @test A15838.@f() === nothing
 @test A15838.@f(1) === :b
-let nometh = expand(:(A15838.@f(1, 2)))
+let nometh = expand(@__MODULE__, :(A15838.@f(1, 2))), __source__ = LineNumberNode(@__LINE__, Symbol(@__FILE__))
     @test (nometh::Expr).head === :error
     @test length(nometh.args) == 1
     e = nometh.args[1]::MethodError
     @test e.f === getfield(A15838, Symbol("@f"))
-    @test e.args === (1,2)
+    @test e.args === (__source__, @__MODULE__, 1, 2)
 end
 
 # issue 10046
@@ -774,11 +817,11 @@ for op in ["+", "-", "\$", "|", ".+", ".-", "*", ".*"]
 end
 
 # issue #17701
-@test expand(:(i==3 && i+=1)) == Expr(:error, "invalid assignment location \"==(i,3)&&i\"")
+@test expand(Main, :(i==3 && i+=1)) == Expr(:error, "invalid assignment location \"==(i, 3) && i\"")
 
 # issue #18667
-@test expand(:(true = 1)) == Expr(:error, "invalid assignment location \"true\"")
-@test expand(:(false = 1)) == Expr(:error, "invalid assignment location \"false\"")
+@test expand(Main, :(true = 1)) == Expr(:error, "invalid assignment location \"true\"")
+@test expand(Main, :(false = 1)) == Expr(:error, "invalid assignment location \"false\"")
 
 # PR #15592
 let str = "[1] [2]"
@@ -838,7 +881,7 @@ macro m2()
         1
     end
 end
-include_string("""
+include_string(@__MODULE__, """
 macro m3()
     quote
         @m1
@@ -850,10 +893,10 @@ macro m4()
     end
 end
 """, "another_file.jl")
-m1_exprs = get_expr_list(expand(:(@m1)))
-m2_exprs = get_expr_list(expand(:(@m2)))
-m3_exprs = get_expr_list(expand(:(@m3)))
-m4_exprs = get_expr_list(expand(:(@m4)))
+m1_exprs = get_expr_list(expand(@__MODULE__, :(@m1)))
+m2_exprs = get_expr_list(expand(@__MODULE__, :(@m2)))
+m3_exprs = get_expr_list(expand(@__MODULE__, :(@m3)))
+m4_exprs = get_expr_list(expand(@__MODULE__, :(@m4)))
 
 # Check the expanded expresion has expected number of matching push/pop
 # and the return is handled correctly
@@ -889,8 +932,8 @@ f1_exprs = get_expr_list(@code_typed(f1(1))[1])
 f2_exprs = get_expr_list(@code_typed(f2(1))[1])
 
 @test Meta.isexpr(f1_exprs[end], :return)
-@test is_pop_loc(f2_exprs[end - 1])
-@test Meta.isexpr(f2_exprs[end], :return)
+@test is_pop_loc(f2_exprs[end])
+@test Meta.isexpr(f2_exprs[end - 1], :return)
 
 if Base.JLOptions().code_coverage != 0 && Base.JLOptions().can_inline != 0
     @test count_meta_loc(f1_exprs) == 1
@@ -909,10 +952,10 @@ end
 @test :(x`s\`"\x\$\\`) == :(@x_cmd "s`\"\\x\\\$\\\\")
 
 # Check multiline command literals
-@test :```
+@test :(@cmd "multiline\ncommand\n") == :```
 multiline
 command
-``` == :(@cmd "multiline\ncommand\n")
+```
 
 macro julia_cmd(s)
     Meta.quot(parse(s))
@@ -936,7 +979,7 @@ end
 @test parse("Foo{T} = Bar{T}") == Expr(:(=), Expr(:curly, :Foo, :T), Expr(:curly, :Bar, :T))
 
 # don't insert push_loc for filename `none` at the top level
-let ex = expand(parse("""
+let ex = expand(Main, parse("""
 begin
     x = 1
 end"""))
@@ -965,7 +1008,7 @@ let ..(x,y) = x + y
 end
 
 # issue #7669
-@test parse("@a(b=1, c=2)") == Expr(:macrocall, Symbol("@a"), :(b=1), :(c=2))
+@test parse("@a(b=1, c=2)") == Expr(:macrocall, Symbol("@a"), LineNumberNode(1, :none), :(b=1), :(c=2))
 
 # issue #19685
 let f = function (x; kw...)
@@ -995,8 +1038,8 @@ end
 let
     global const (c8925, d8925) = (3, 4)
 end
-@test c8925 == 3 && isconst(:c8925)
-@test d8925 == 4 && isconst(:d8925)
+@test c8925 == 3 && isconst(@__MODULE__, :c8925)
+@test d8925 == 4 && isconst(@__MODULE__, :d8925)
 
 # issue #18754: parse ccall as a regular function
 @test parse("ccall([1], 2)[3]") == Expr(:ref, Expr(:call, :ccall, Expr(:vect, 1), 2), 3)
@@ -1007,11 +1050,24 @@ end
 short_where_call = :(f(x::T) where T = T)
 @test short_where_call.args[2].head == :block
 
+# `where` with multi-line anonymous functions
+let f = function (x::T) where T
+            T
+        end
+    @test f(:x) === Symbol
+end
+
+let f = function (x::T, y::S) where T<:S where S
+            (T,S)
+        end
+    @test f(0,1) === (Int,Int)
+end
+
 # issue #20541
 @test parse("[a .!b]") == Expr(:hcat, :a, Expr(:call, :(.!), :b))
 
-@test expand(:(a{1} = b)) == Expr(:error, "invalid type parameter name \"1\"")
-@test expand(:(a{2<:Any} = b)) == Expr(:error, "invalid type parameter name \"2\"")
+@test expand(Main, :(a{1} = b)) == Expr(:error, "invalid type parameter name \"1\"")
+@test expand(Main, :(a{2<:Any} = b)) == Expr(:error, "invalid type parameter name \"2\"")
 
 # issue #20653
 @test_throws UndefVarError Base.call(::Int) = 1
@@ -1024,3 +1080,207 @@ const a = A()
 @test_throws MethodError a()
 @test call(a) === 1
 end
+
+# issue #20729
+macro m20729()
+    ex = Expr(:head)
+    resize!(ex.args, 1)
+    return ex
+end
+
+@test_throws ErrorException eval(@__MODULE__, :(@m20729))
+@test expand(@__MODULE__, :(@m20729)) == Expr(:error, "undefined reference in AST")
+
+macro err20000()
+    return Expr(:error, "oops!")
+end
+
+@test expand(@__MODULE__, :(@err20000)) == Expr(:error, "oops!")
+
+# issue #20000
+@test parse("@m(a; b=c)") == Expr(:macrocall, Symbol("@m"), LineNumberNode(1, :none),
+                                  Expr(:parameters, Expr(:kw, :b, :c)), :a)
+
+# issue #21054
+macro make_f21054(T)
+    quote
+        $(esc(:f21054))(X::Type{<:$T}) = 1
+    end
+end
+@eval @make_f21054 $Array
+@test isa(f21054, Function)
+g21054(>:) = >:2
+@test g21054(-) == -2
+
+# issue #21168
+@test expand(Main, :(a.[1])) == Expr(:error, "invalid syntax a.[1]")
+@test expand(Main, :(a.{1})) == Expr(:error, "invalid syntax a.{1}")
+
+# Issue #21225
+let abstr = parse("abstract type X end")
+    @test parse("abstract type X; end") == abstr
+    @test parse(string("abstract type X", ";"^5, " end")) == abstr
+    @test parse("abstract type X\nend") == abstr
+    @test parse(string("abstract type X", "\n"^5, "end")) == abstr
+end
+let prim = parse("primitive type X 8 end")
+    @test parse("primitive type X 8; end") == prim
+    @test parse(string("primitive type X 8", ";"^5, " end")) == prim
+    @test parse("primitive type X 8\nend") == prim
+    @test parse(string("primitive type X 8", "\n"^5, "end")) == prim
+end
+
+# issue #21155
+@test filter(!isline,
+             parse("module B
+                        using ..x,
+                              ..y
+                    end").args[3].args)[1] ==
+      Expr(:toplevel,
+           Expr(:using, Symbol("."), Symbol("."), :x),
+           Expr(:using, Symbol("."), Symbol("."), :y))
+
+@test filter(!isline,
+             parse("module A
+                        using .B,
+                              .C
+                    end").args[3].args)[1] ==
+      Expr(:toplevel,
+           Expr(:using, Symbol("."), :B),
+           Expr(:using, Symbol("."), :C))
+
+# issue #21440
+@test parse("+(x::T,y::T) where {T} = 0") == parse("(+)(x::T,y::T) where {T} = 0")
+@test parse("a::b::c") == Expr(:(::), Expr(:(::), :a, :b), :c)
+
+# issue #21545
+f21545(::Type{<: AbstractArray{T,N} where N}) where T = T
+@test f21545(Array{Int8}) === Int8
+@test parse("<:{T} where T") == Expr(:where, Expr(:curly, :(<:), :T), :T)
+@test parse("<:(T) where T") == Expr(:where, Expr(:(<:), :T), :T)
+@test parse("<:{T}(T) where T") == Expr(:where, Expr(:call, Expr(:curly, :(<:), :T), :T), :T)
+
+# issue #21586
+macro m21586(x)
+    Expr(:kw, esc(x), 42)
+end
+
+f21586(; @m21586(a), @m21586(b)) = a + b
+@test f21586(a=10) == 52
+
+# issue #21604
+@test_nowarn @eval module Test21604
+    const Foo = Any
+    struct X
+        x::Foo
+    end
+end
+@test Test21604.X(1.0) === Test21604.X(1.0)
+
+# issue #20575
+@test_throws ParseError parse("\"a\"x")
+@test_throws ParseError parse("\"a\"begin end")
+
+# comment 298107224 on pull #21607
+module Test21607
+    using Base.Test
+
+    @test_warn(
+    "WARNING: imported binding for Any overwritten in module Test21607",
+    @eval const Any = Integer)
+
+    # check that X <: Core.Any, not Integer
+    mutable struct X; end
+    @test supertype(X) === Core.Any
+
+    # check that return type is Integer
+    f()::Any = 1.0
+    @test f() === 1
+
+    # check that constructor accepts Any
+    struct Y
+        x
+    end
+    @test Y(1.0) !== Y(1)
+
+    # check that function default argument type is Any
+    g(x) = x
+    @test g(1.0) === 1.0
+
+    # check that asserted variable type is Integer
+    @test let
+        x::Any = 1.0
+        x
+    end === 1
+
+    # check that unasserted variable type is not Integer
+    @test let
+        x = 1.0
+        x
+    end === 1.0
+end
+
+# issue #16937
+@test expand(Main, :(f(2, a=1, w=3, c=3, w=4, b=2))) ==
+    Expr(:error, "keyword argument \"w\" repeated in call to \"f\"")
+
+let f(x) =
+      g(x) = 1
+    @test functionloc(f(1))[2] > functionloc(f)[2]
+end
+
+# let-bound functions with `where` and static parameters
+@test let f()::Int = 2.0
+    f()
+end === 2
+@test let (f(x::T)::Tuple{Int,Any}) where {T} = (3.0, T)
+    f("")
+end === (3, String)
+
+# issue #19351
+# adding return type decl should not affect parse of function body
+@test :(t(abc) = 3).args[2] == :(t(abc)::Int = 3).args[2]
+
+# issue #7314
+@test parse("local x, y = 1, 2") == Expr(:local, Expr(:(=),
+                                                      Expr(:tuple, :x, :y),
+                                                      Expr(:tuple, 1, 2)))
+
+@test_throws ParseError parse("[2for i=1:10]")
+@test_throws ParseError parse("[1 for i in 1:2for j in 2]")
+@test_throws ParseError parse("(1 for i in 1:2for j in 2)")
+# issue #20441
+@test_throws ParseError parse("[x.2]")
+@test_throws ParseError parse("x.2")
+@test parse("[x;.2]") == Expr(:vcat, :x, 0.2)
+
+# issue #22840
+@test parse("[:a :b]") == Expr(:hcat, QuoteNode(:a), QuoteNode(:b))
+
+# issue #22868
+@test_throws ParseError parse("x@time 2")
+@test_throws ParseError parse("@ time")
+
+# issue #7479
+@test expand(Main, parse("(true &&& false)")) == Expr(:error, "misplaced \"&\" expression")
+
+# if an indexing expression becomes a cat expression, `end` is not special
+@test_throws ParseError parse("a[end end]")
+@test_throws ParseError parse("a[end;end]")
+#@test_throws ParseError parse("a[end;]")  # this is difficult to fix
+let a = rand(8), i = 3
+    @test a[[1:i-1; i+1:end]] == a[[1,2,4,5,6,7,8]]
+end
+
+# issue #18935
+@test [begin
+          @inbounds for i = 1:10 end
+       end for i = 1:5] == fill(nothing, 5)
+
+# issue #18912
+@test_throws ParseError parse("(::)")
+@test parse(":(::)") == QuoteNode(Symbol("::"))
+@test_throws ParseError parse("f(::) = ::")
+@test parse("(::A)") == Expr(Symbol("::"), :A)
+@test_throws ParseError parse("(::, 1)")
+@test_throws ParseError parse("(1, ::)")
diff --git a/test/path.jl b/test/path.jl
index f401c03ddf7b51..3a27bcb271ab63 100644
--- a/test/path.jl
+++ b/test/path.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 for S in (String, GenericString)
     dir = pwd()
@@ -11,7 +11,7 @@ for S in (String, GenericString)
     @test dirname(S("foo$(sep)bar")) == "foo"
 
     @test expanduser(S("x")) == "x"
-    @test expanduser(S("~")) == (is_windows() ? "~" : homedir())
+    @test expanduser(S("~")) == (Sys.iswindows() ? "~" : homedir())
 
     @test isabspath(S(homedir()))
     @test !isabspath(S("foo"))
@@ -68,7 +68,7 @@ for S in (String, GenericString)
     @test joinpath(splitdir(S(homedir()))...) == homedir()
     @test string(splitdrive(S(homedir()))...) == homedir()
 
-    if is_windows()
+    if Sys.iswindows()
         @test splitdrive(S("\\\\servername\\hello.world\\filename.ext")) ==
             ("\\\\servername\\hello.world","\\filename.ext")
         @test splitdrive(S("\\\\servername.com\\hello.world\\filename.ext")) ==
@@ -95,8 +95,8 @@ end
 
 @test isabspath("~") == false
 @test isabspath("/") == true # on windows, this is relatively absolute
-@test isabspath("A:/") == is_windows()
-@test isabspath("B:\\") == is_windows()
+@test isabspath("A:/") == Sys.iswindows()
+@test isabspath("B:\\") == Sys.iswindows()
 @test isabspath("./") == false
 @test isabspath("C:") == false
 @test isabspath("C:.") == false
@@ -104,8 +104,8 @@ end
 @test isabspath(".:/") == false
 #@test isabspath("_:/") == false # FIXME?
 #@test isabspath("AB:/") == false # FIXME?
-@test isabspath("\\\\") == is_windows()
-if is_unix()
+@test isabspath("\\\\") == Sys.iswindows()
+if Sys.isunix()
     @test isabspath(expanduser("~")) == true
     @test startswith(expanduser("~"), homedir())
 else
@@ -197,3 +197,15 @@ test_relpath()
 # Test type stability
 @test isa(joinpath("a", "b"), String)
 @test isa(joinpath(abspath("a"), "b"), String)
+
+# homedir
+let var = Sys.iswindows() ? "USERPROFILE" : "HOME",
+    MAX_PATH = Sys.iswindows() ? 240 : 1020
+    for i = 0:9
+        local home = " "^MAX_PATH * "123456789"[1:i]
+        @test withenv(var => home) do
+            homedir()
+        end == home
+    end
+    @test isabspath(withenv(homedir, var => nothing))
+end
diff --git a/test/perf/README.md b/test/perf/README.md
index d523394f6304fe..7d2f2abfc355d7 100644
--- a/test/perf/README.md
+++ b/test/perf/README.md
@@ -29,7 +29,7 @@ Tests generally go into one of the following suites:
 
 - `micro`: A set of micro-benchmarks commonly used to compare
   programming languages; these results are shown on
-    [http://julialang.org/](http://julialang.org/).
+    [https://julialang.org/](https://julialang.org/).
 - `blas`, `lapack`: Performance tests for linear algebra tasks from
   low-level operations such as matrix multiplies to higher-level
   operations like eigenvalue problems.
diff --git a/test/perf/array/indexing.jl b/test/perf/array/indexing.jl
index 5e5956c3b5ddb1..36527b0036a8da 100644
--- a/test/perf/array/indexing.jl
+++ b/test/perf/array/indexing.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Performance testing
 
diff --git a/test/perf/array/perf.jl b/test/perf/array/perf.jl
index 07b36606faf3a3..001b69c078b622 100644
--- a/test/perf/array/perf.jl
+++ b/test/perf/array/perf.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 include("../perfutil.jl")
 
diff --git a/test/perf/blas/level1.jl b/test/perf/blas/level1.jl
index 5d2531ac01bace..0d1f6837eecb6d 100644
--- a/test/perf/blas/level1.jl
+++ b/test/perf/blas/level1.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 function dottest(n, iter)
     a = rand(n)
diff --git a/test/perf/blas/level2.jl b/test/perf/blas/level2.jl
index dd80bad63220af..afa99a662122ed 100644
--- a/test/perf/blas/level2.jl
+++ b/test/perf/blas/level2.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 function gemvtest(n, iter)
     A = rand(n,n)
diff --git a/test/perf/blas/level3.jl b/test/perf/blas/level3.jl
index 642307918e8f12..a9c07a27841d31 100644
--- a/test/perf/blas/level3.jl
+++ b/test/perf/blas/level3.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # gemm on various size matrices
 
diff --git a/test/perf/blas/perf.jl b/test/perf/blas/perf.jl
index b28a72602521d9..96847f24c7f980 100644
--- a/test/perf/blas/perf.jl
+++ b/test/perf/blas/perf.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 include("../perfutil.jl")
 
diff --git a/test/perf/cat/perf.jl b/test/perf/cat/perf.jl
index 33c2bc43d04911..e29db267fa138f 100644
--- a/test/perf/cat/perf.jl
+++ b/test/perf/cat/perf.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 include("../perfutil.jl")
 
diff --git a/test/perf/kernel/actor_centrality.jl b/test/perf/kernel/actor_centrality.jl
index a49f0eb3067950..82185c9b823c9c 100644
--- a/test/perf/kernel/actor_centrality.jl
+++ b/test/perf/kernel/actor_centrality.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 mutable struct Node
     name::String
diff --git a/test/perf/kernel/bench_eu.jl b/test/perf/kernel/bench_eu.jl
index 287440de2f487a..e0280db040a566 100644
--- a/test/perf/kernel/bench_eu.jl
+++ b/test/perf/kernel/bench_eu.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Benchmark European option
 # https://groups.google.com/forum/?hl=en&fromgroups=#!topic/julia-dev/ImhGsqX_IHc
@@ -17,11 +17,11 @@ function bench_eu_devec(numPaths)
     t2 = sigma*sqrt(dt)
     for i=1:steps
         for j=1:numPaths
-            S[j] .*= exp(t1 + t2*randn())
+            S[j] *= exp(t1 + t2*randn())
         end
     end
 
-    V = mean( exp(-r*T)*max(K.-S,0) )
+    V = mean( exp(-r*T)*max.(K.-S,0) )
 end
 
 function bench_eu_vec(numPaths)
@@ -37,8 +37,8 @@ function bench_eu_vec(numPaths)
     t1 = (r-0.5*sigma.^2)*dt
     t2 = sigma*sqrt(dt)
     for i=1:steps
-        S = S .* exp(t1.+t2*randn(numPaths))
+        S = S .* exp.(t1.+t2*randn(numPaths))
     end
 
-    V = mean( exp(-r*T)*max(K.-S,0) )
+    V = mean( exp(-r*T)*max.(K.-S,0) )
 end
diff --git a/test/perf/kernel/getdivgrad.jl b/test/perf/kernel/getdivgrad.jl
index aed68e649bed23..04ba5663d8ab6a 100644
--- a/test/perf/kernel/getdivgrad.jl
+++ b/test/perf/kernel/getdivgrad.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # https://github.com/JuliaLang/julia/issues/4707
 
@@ -17,7 +17,7 @@ end
 #----------------- 1D finite difference on staggered grid
 function ddx(n)
 # generate 1D derivatives
-    return d = spdiags(ones(n)*[-1 1],[0,1],n,n+1)
+    return d = spdiags(ones(n)*[-1, 1]',[0,1],n,n+1)
 end
 
 #------------- Build a diagonal matrix
diff --git a/test/perf/kernel/gk.jl b/test/perf/kernel/gk.jl
index 620fb988946dc3..f54ab5c737333f 100644
--- a/test/perf/kernel/gk.jl
+++ b/test/perf/kernel/gk.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Grigoriadis Khachiyan Matrix Games.
 #
@@ -95,7 +95,7 @@ function gk(n, myeps)
                 U[i] += A[i,k]
             end
 
-            s = sum(p[1:n] .* exp((eps/2)*A[1:n,k]))
+            s = sum(p[1:n] .* exp.((eps/2)*A[1:n,k]))
             for i=1:n
                 p[i]=(p[i]*exp((eps/2)*A[i,k])) / s
             end
diff --git a/test/perf/kernel/go_benchmark.c b/test/perf/kernel/go_benchmark.c
index a1b2a93dfb52d0..ebf8b6596f5979 100644
--- a/test/perf/kernel/go_benchmark.c
+++ b/test/perf/kernel/go_benchmark.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 /* Benchmark implementing the board logic for the game of go and
  * exercising it by playing random games. Derived from
diff --git a/test/perf/kernel/go_benchmark.jl b/test/perf/kernel/go_benchmark.jl
index 8b821bb356d0a0..03b0acb03bfbde 100644
--- a/test/perf/kernel/go_benchmark.jl
+++ b/test/perf/kernel/go_benchmark.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Benchmark implementing the board logic for the game of go and
 # exercising it by playing random games. Derived from
@@ -21,18 +21,18 @@ const BLACK_TERRITORY = 4
 const UNKNOWN = 5
 
 mutable struct XorRand
-  state::UInt32
+    state::UInt32
 end
 
 function xor_srand(rand::XorRand, seed::UInt32)
-  rand.state = seed
+    rand.state = seed
 end
 
 function xor_randn(rand::XorRand, n::UInt32)
-  rand.state $= rand.state << 13
-  rand.state $= rand.state >> 17
-  rand.state $= rand.state << 5
-  rand.state % n
+    rand.state ⊻= rand.state << 13
+    rand.state ⊻= rand.state >> 17
+    rand.state ⊻= rand.state << 5
+    rand.state % n
 end
 
 xor_randn(rand::XorRand, n::Int) = convert(Int, xor_randn(rand, convert(UInt32, n)))
@@ -43,42 +43,42 @@ const deltaj = (0, 0, -1, 1)
 neighbor(i::Int, j::Int, k::Int) = (i + deltai[k], j + deltaj[k])
 
 mutable struct Board
-  size::Int
-  komi::Float64
+    size::Int
+    komi::Float64
 
-  # Board represented by a 1D array. The first board_size*board_size
-  # elements are used. Vertices are indexed row by row, starting with 0
-  # in the upper left corner.
-  board::Matrix{Int}
+    # Board represented by a 1D array. The first board_size*board_size
+    # elements are used. Vertices are indexed row by row, starting with 0
+    # in the upper left corner.
+    board::Matrix{Int}
 
-  # Stones are linked together in a circular list for each string.
-  next_stone::Matrix{Int}
+    # Stones are linked together in a circular list for each string.
+    next_stone::Matrix{Int}
 
-  # Storage for final status computations.
-  final_status::Matrix{Int}
+    # Storage for final status computations.
+    final_status::Matrix{Int}
 
-  # Point which would be an illegal ko recapture.
-  ko_i::Int
-  ko_j::Int
+    # Point which would be an illegal ko recapture.
+    ko_i::Int
+    ko_j::Int
 
-  # xor-shift random number generator.
-  rand::XorRand
+    # xor-shift random number generator.
+    rand::XorRand
 
-  function Board(n::Int)
-    init(new(), n, convert(UInt32, 2463534242))
-  end
+    function Board(n::Int)
+        init(new(), n, convert(UInt32, 2463534242))
+    end
 end
 
 function init(board::Board, n::Int, seed::UInt32)
-  board.size = n
-  board.komi = 0.0
-  board.board = zeros(Int, n, n)
-  board.next_stone = zeros(Int, n, n)
-  board.final_status = zeros(Int, n, n)
-  board.ko_i = 0
-  board.ko_j = 0
-  board.rand = XorRand(seed)
-  board
+    board.size = n
+    board.komi = 0.0
+    board.board = zeros(Int, n, n)
+    board.next_stone = zeros(Int, n, n)
+    board.final_status = zeros(Int, n, n)
+    board.ko_i = 0
+    board.ko_j = 0
+    board.rand = XorRand(seed)
+    board
 end
 
 getindex(board::Board, pos::Int) = board.board[pos]
@@ -91,261 +91,263 @@ POS(board::Board, i::Int, j::Int) = (j - 1) * board.size + i
 IJ(board::Board, pos::Int) = (1 + mod((pos - 1), board.size), 1 + fld(pos - 1, board.size))
 
 function set_komi(board::Board, komi::Float64)
-  board.komi = komi
+    board.komi = komi
 end
 
 function set_random_seed(board::Board, seed::UInt32)
-  xor_srand(board.rand, seed)
+    xor_srand(board.rand, seed)
 end
 
 function clear(board::Board)
-  board.board[:] = EMPTY
+    board.board[:] = EMPTY
 end
 
 is_pass_move(i::Int, j::Int) = i == 0 && j == 0
 
 function on_board(board::Board, i::Int, j::Int)
-  i >= 1 && i <= board.size && j >= 1 && j <= board.size
+    i >= 1 && i <= board.size && j >= 1 && j <= board.size
 end
 
 function legal_move(board::Board, i::Int, j::Int, color::Int)
-  other = other_color(color)
+    other = other_color(color)
 
-  # Pass is always legal.
-  if is_pass_move(i, j)
-    return true
-  end
+    # Pass is always legal.
+    if is_pass_move(i, j)
+        return true
+    end
 
-  # Already occupied.
-  if board[i, j] != EMPTY
-    return false
-  end
+    # Already occupied.
+    if board[i, j] != EMPTY
+        return false
+    end
 
-  # Illegal ko recapture. It is not illegal to fill the ko so we must
-  # check the color of at least one neighbor.
-  if i == board.ko_i && j == board.ko_j && ((on_board(board, i - 1, j) && board[i - 1, j] == other) || (on_board(board, i + 1, j) && board[i + 1, j] == other))
-    return false
-  end
+    # Illegal ko recapture. It is not illegal to fill the ko so we must
+    # check the color of at least one neighbor.
+    if i == board.ko_i && j == board.ko_j &&
+            ((on_board(board, i - 1, j) && board[i - 1, j] == other) ||
+             (on_board(board, i + 1, j) && board[i + 1, j] == other))
+        return false
+    end
 
-  true
+    true
 end
 
 # Does the string at (i, j) have any more liberty than the one at (libi, libj)?
 function has_additional_liberty(board::Board, i::Int, j::Int, libi::Int, libj::Int)
-  start = POS(board, i, j)
-  pos = start
-  while true
-    (ai, aj) = IJ(board, pos)
-    for k = 1:4
-      (bi, bj) = neighbor(ai, aj, k)
-      if on_board(board, bi, bj) && board[bi, bj] == EMPTY && (bi != libi || bj != libj)
-        return true
-      end
-    end
+    start = POS(board, i, j)
+    pos = start
+    while true
+        (ai, aj) = IJ(board, pos)
+        for k = 1:4
+            (bi, bj) = neighbor(ai, aj, k)
+            if on_board(board, bi, bj) && board[bi, bj] == EMPTY && (bi != libi || bj != libj)
+                return true
+            end
+        end
 
-    pos = board.next_stone[pos]
-    if pos == start
-      break
+        pos = board.next_stone[pos]
+        if pos == start
+            break
+        end
     end
-  end
 
-  false
+    false
 end
 
 # Does (ai, aj) provide a liberty for a stone at (i, j)?
 function provides_liberty(board::Board, ai::Int, aj::Int, i::Int, j::Int, color::Int)
-  # A vertex off the board does not provide a liberty.
-  if !on_board(board, ai, aj)
-    return false
-  end
-
-  # An empty vertex IS a liberty.
-  if board[ai, aj] == EMPTY
-    return true
-  end
-
-  # A friendly string provides a liberty to (i, j) if it currently
-  # has more liberties than the one at (i, j).
-  if board[ai, aj] == color
-    return has_additional_liberty(board, ai, aj, i, j)
-  end
-
-  # An unfriendly string provides a liberty if and only if it is
-  # captured, i.e. if it currently only has the liberty at (i, j).
-  !has_additional_liberty(board, ai, aj, i, j)
+    # A vertex off the board does not provide a liberty.
+    if !on_board(board, ai, aj)
+        return false
+    end
+
+    # An empty vertex IS a liberty.
+    if board[ai, aj] == EMPTY
+        return true
+    end
+
+    # A friendly string provides a liberty to (i, j) if it currently
+    # has more liberties than the one at (i, j).
+    if board[ai, aj] == color
+        return has_additional_liberty(board, ai, aj, i, j)
+    end
+
+    # An unfriendly string provides a liberty if and only if it is
+    # captured, i.e. if it currently only has the liberty at (i, j).
+    !has_additional_liberty(board, ai, aj, i, j)
 end
 
 # Is a move at ij suicide for color?
 function suicide(board::Board, i::Int, j::Int, color::Int)
-  for k = 1:4
-    if provides_liberty(board, neighbor(i, j, k)..., i, j, color)
-      return false
+    for k = 1:4
+        if provides_liberty(board, neighbor(i, j, k)..., i, j, color)
+            return false
+        end
     end
-  end
-  true
+    true
 end
 
 # Remove a string from the board array. There is no need to modify
 # the next_stone array since this only matters where there are
 # stones present and the entire string is removed.
 function remove_string(board::Board, i::Int, j::Int)
-  start = POS(board, i, j)
-  pos = start
-  removed = 0
-  while true
-    board.board[pos] = EMPTY
-    removed += 1
-    pos = board.next_stone[pos]
-    if pos == start
-      break
+    start = POS(board, i, j)
+    pos = start
+    removed = 0
+    while true
+        board.board[pos] = EMPTY
+        removed += 1
+        pos = board.next_stone[pos]
+        if pos == start
+            break
+        end
     end
-  end
-  removed
+    removed
 end
 
 # Do two vertices belong to the same string? It is required that both
 # pos1 and pos2 point to vertices with stones.
 function same_string(board::Board, pos1::Int, pos2::Int)
-  pos = pos1
-  while true
-    if pos == pos2
-      return true
-    end
-    pos = board.next_stone[pos]
-    if pos == pos1
-      break
+    pos = pos1
+    while true
+        if pos == pos2
+            return true
+        end
+        pos = board.next_stone[pos]
+        if pos == pos1
+            break
+        end
     end
-  end
-  false
+    false
 end
 
 # Play at (i, j) for color. No legality check is done here. We need
 # to properly update the board array, the next_stone array, and the
 # ko point.
 function play_move(board::Board, i::Int, j::Int, color::Int)
-  pos = POS(board, i, j)
-  captured_stones = 0
-
-  # Reset the ko point.
-  board.ko_i = 0
-  board.ko_j = 0
+    pos = POS(board, i, j)
+    captured_stones = 0
 
-  # Nothing more happens if the move was a pass.
-  if is_pass_move(i, j)
-    return
-  end
+    # Reset the ko point.
+    board.ko_i = 0
+    board.ko_j = 0
 
-  # If the move is a suicide we only need to remove the adjacent
-  # friendly stones.
-  if suicide(board, i, j, color)
-    for k = 1:4
-      (ai, aj) = neighbor(i, j, k)
-      if on_board(board, ai, aj) && board[ai, aj] == color
-        remove_string(board, ai, aj)
-      end
+    # Nothing more happens if the move was a pass.
+    if is_pass_move(i, j)
+        return
     end
-    return
-  end
-
-  # Not suicide. Remove captured opponent strings.
-  for k = 1:4
-    (ai, aj) = neighbor(i, j, k)
-    if on_board(board, ai, aj) && board[ai, aj] == other_color(color) && !has_additional_liberty(board, ai, aj, i, j)
-      captured_stones += remove_string(board, ai, aj)
+
+    # If the move is a suicide we only need to remove the adjacent
+    # friendly stones.
+    if suicide(board, i, j, color)
+        for k = 1:4
+            (ai, aj) = neighbor(i, j, k)
+            if on_board(board, ai, aj) && board[ai, aj] == color
+                remove_string(board, ai, aj)
+            end
+        end
+        return
     end
-  end
-
-  # Put down the new stone. Initially build a single stone string by
-  # setting next_stone[pos] pointing to itself.
-  board.board[pos] = color
-  board.next_stone[pos] = pos
-
-  # If we have friendly neighbor strings we need to link the strings
-  # together.
-  for k = 1:4
-    (ai, aj) = neighbor(i, j, k)
-    pos2 = POS(board, ai, aj)
-    # Make sure that the stones are not already linked together. This
-    # may happen if the same string neighbors the new stone in more
-    # than one direction.
-    if on_board(board, ai, aj) && board[pos2] == color && !same_string(board, pos, pos2)
-      # The strings are linked together simply by swapping the
-      # next_stone pointers.
-      (board.next_stone[pos], board.next_stone[pos2]) = (board.next_stone[pos2], board.next_stone[pos])
+
+    # Not suicide. Remove captured opponent strings.
+    for k = 1:4
+        (ai, aj) = neighbor(i, j, k)
+        if on_board(board, ai, aj) && board[ai, aj] == other_color(color) && !has_additional_liberty(board, ai, aj, i, j)
+            captured_stones += remove_string(board, ai, aj)
+        end
     end
-  end
-
-  # If we have captured exactly one stone and the new string is a
-  # single stone it may have been a ko capture.
-  if captured_stones == 1 && board.next_stone[pos] == pos
-    # Check whether the new string has exactly one liberty. If so it
-    # would be an illegal ko capture to play there immediately. We
-    # know that there must be a liberty immediately adjacent to the
-    # new stone since we captured one stone.
+
+    # Put down the new stone. Initially build a single stone string by
+    # setting next_stone[pos] pointing to itself.
+    board.board[pos] = color
+    board.next_stone[pos] = pos
+
+    # If we have friendly neighbor strings we need to link the strings
+    # together.
     for k = 1:4
-      (ai, aj) = neighbor(i, j, k)
-      if on_board(board, ai, aj) && board[ai, aj] == EMPTY
-        if !has_additional_liberty(board, i, j, ai, aj)
-          board.ko_i = ai
-          board.ko_j = aj
+        (ai, aj) = neighbor(i, j, k)
+        pos2 = POS(board, ai, aj)
+        # Make sure that the stones are not already linked together. This
+        # may happen if the same string neighbors the new stone in more
+        # than one direction.
+        if on_board(board, ai, aj) && board[pos2] == color && !same_string(board, pos, pos2)
+            # The strings are linked together simply by swapping the
+            # next_stone pointers.
+            (board.next_stone[pos], board.next_stone[pos2]) = (board.next_stone[pos2], board.next_stone[pos])
+        end
+    end
+
+    # If we have captured exactly one stone and the new string is a
+    # single stone it may have been a ko capture.
+    if captured_stones == 1 && board.next_stone[pos] == pos
+        # Check whether the new string has exactly one liberty. If so it
+        # would be an illegal ko capture to play there immediately. We
+        # know that there must be a liberty immediately adjacent to the
+        # new stone since we captured one stone.
+        for k = 1:4
+            (ai, aj) = neighbor(i, j, k)
+            if on_board(board, ai, aj) && board[ai, aj] == EMPTY
+                if !has_additional_liberty(board, i, j, ai, aj)
+                    board.ko_i = ai
+                    board.ko_j = aj
+                end
+                break
+            end
         end
-        break
-      end
     end
-  end
 end
 
 # Generate a move.
 function generate_move(board::Board, color::Int)
-  moves = zeros(Int, 2, board.size * board.size)
-  num_moves = 0
-
-  for ai = 1:board.size, aj = 1:board.size
-    # Consider moving at (ai, aj) if it is legal and not suicide.
-    if legal_move(board, ai, aj, color) && !suicide(board, ai, aj, color)
-      # Further require the move not to be suicide for the opponent...
-      if !suicide(board, ai, aj, other_color(color))
-        num_moves += 1
-        moves[:,num_moves] = [ai, aj]
-      else
-        # ...however, if the move captures at least one stone,
-        # consider it anyway.
-        for k = 1:4
-          (bi, bj) = neighbor(ai, aj, k)
-          if on_board(board, bi, bj) && board[bi, bj] == other_color(color)
-            num_moves += 1
-            moves[:,num_moves] = [ai, aj]
-            break
-          end
+    moves = zeros(Int, 2, board.size * board.size)
+    num_moves = 0
+
+    for ai = 1:board.size, aj = 1:board.size
+        # Consider moving at (ai, aj) if it is legal and not suicide.
+        if legal_move(board, ai, aj, color) && !suicide(board, ai, aj, color)
+            # Further require the move not to be suicide for the opponent...
+            if !suicide(board, ai, aj, other_color(color))
+                num_moves += 1
+                moves[:,num_moves] = [ai, aj]
+            else
+                # ...however, if the move captures at least one stone,
+                # consider it anyway.
+                for k = 1:4
+                    (bi, bj) = neighbor(ai, aj, k)
+                    if on_board(board, bi, bj) && board[bi, bj] == other_color(color)
+                        num_moves += 1
+                        moves[:,num_moves] = [ai, aj]
+                        break
+                    end
+                end
+            end
         end
-      end
     end
-  end
-
-  # Choose one of the considered moves randomly with uniform
-  # distribution. (Strictly speaking the moves with smaller 1D
-  # coordinates tend to have a very slightly higher probability to be
-  # chosen, but for all practical purposes we get a uniform
-  # distribution.)
-  if num_moves > 0
-    move = moves[:,1 + xor_randn(board.rand, num_moves)]
-    return (move[1], move[2])
-  else
-    # But pass if no move was considered.
-    return (0, 0)
-  end
+
+    # Choose one of the considered moves randomly with uniform
+    # distribution. (Strictly speaking the moves with smaller 1D
+    # coordinates tend to have a very slightly higher probability to be
+    # chosen, but for all practical purposes we get a uniform
+    # distribution.)
+    if num_moves > 0
+        move = moves[:,1 + xor_randn(board.rand, num_moves)]
+        return (move[1], move[2])
+    else
+        # But pass if no move was considered.
+        return (0, 0)
+    end
 end
 
 # Set a final status value for an entire string.
 function set_final_status_string(board::Board, pos::Int, status::Int)
-  start = pos
-  while true
-    board.final_status[pos] = status
-    pos = board.next_stone[pos]
-    if pos == start
-      break
+    start = pos
+    while true
+        board.final_status[pos] = status
+        pos = board.next_stone[pos]
+        if pos == start
+            break
+        end
     end
-  end
 end
 
 
@@ -372,113 +374,113 @@ end
 #          that will not happen.
 #
 function compute_final_status(board::Board)
-  board.final_status[:] = UNKNOWN
-
-  for i = 1:board.size, j = 1:board.size
-    if board[i, j] == EMPTY
-      for k = 1:4
-        (ai, aj) = neighbor(i, j, k)
-        if !on_board(board, ai, aj)
-          continue
-        end
-        # When the game is finished, we know for sure that (ai, aj)
-        # contains a stone. The move generation algorithm would
-        # never leave two adjacent empty vertices. Check the number
-        # of liberties to decide its status, unless it's known
-        # already.
-        #
-        # If we should be called in a non-final position, just make
-        # sure we don't call set_final_status_string() on an empty
-        # vertex.
-        pos = POS(board, ai, aj)
-        if board.final_status[ai, aj] == UNKNOWN
-          if board[ai, aj] != EMPTY
-            if has_additional_liberty(board, ai, aj, i, j)
-              set_final_status_string(board, pos, ALIVE)
-            else
-              set_final_status_string(board, pos, DEAD)
+    board.final_status[:] = UNKNOWN
+
+    for i = 1:board.size, j = 1:board.size
+        if board[i, j] == EMPTY
+            for k = 1:4
+                (ai, aj) = neighbor(i, j, k)
+                if !on_board(board, ai, aj)
+                    continue
+                end
+                # When the game is finished, we know for sure that (ai, aj)
+                # contains a stone. The move generation algorithm would
+                # never leave two adjacent empty vertices. Check the number
+                # of liberties to decide its status, unless it's known
+                # already.
+                #
+                # If we should be called in a non-final position, just make
+                # sure we don't call set_final_status_string() on an empty
+                # vertex.
+                pos = POS(board, ai, aj)
+                if board.final_status[ai, aj] == UNKNOWN
+                    if board[ai, aj] != EMPTY
+                        if has_additional_liberty(board, ai, aj, i, j)
+                            set_final_status_string(board, pos, ALIVE)
+                        else
+                            set_final_status_string(board, pos, DEAD)
+                        end
+                    end
+                end
+                # Set the final status of the pos vertex to either black
+                # or white territory.
+                if board.final_status[i, j] == UNKNOWN
+                    if (board.final_status[ai, aj] == ALIVE) ⊻ (board[ai, aj] == WHITE)
+                        board.final_status[i, j] = BLACK_TERRITORY
+                    else
+                        board.final_status[i, j] = WHITE_TERRITORY
+                    end
+                end
             end
-          end
         end
-        # Set the final status of the pos vertex to either black
-        # or white territory.
-        if board.final_status[i, j] == UNKNOWN
-          if (board.final_status[ai, aj] == ALIVE) $ (board[ai, aj] == WHITE)
-            board.final_status[i, j] = BLACK_TERRITORY
-          else
-            board.final_status[i, j] = WHITE_TERRITORY
-          end
-        end
-      end
     end
-  end
 end
 
 get_final_status(board::Board, i::Int, j::Int) = board.final_status[i, j]
 
 function compute_score(board::Board)
-  score = board.komi
-  compute_final_status(board)
-  for i = 1:board.size, j = 1:board.size
-    status = get_final_status(board, i, j)
-    if status == BLACK_TERRITORY
-      score -= 1.0
-    elseif status == WHITE_TERRITORY
-      score += 1.0
-    elseif (status == ALIVE) $ (board[i, j] == WHITE)
-      score -= 1.0
-    else
-      score += 1.0
+    score = board.komi
+    compute_final_status(board)
+    for i = 1:board.size, j = 1:board.size
+        status = get_final_status(board, i, j)
+        if status == BLACK_TERRITORY
+            score -= 1.0
+        elseif status == WHITE_TERRITORY
+            score += 1.0
+        elseif (status == ALIVE) ⊻ (board[i, j] == WHITE)
+            score -= 1.0
+        else
+            score += 1.0
+        end
     end
-  end
-  score
+    score
 end
 
 function benchmark(num_games_per_point::Int)
-  random_seed = convert(UInt32, 1)
-  board_size = 9
-  komi = 0.5
-
-  board = Board(board_size)
-  set_komi(board, komi)
-  set_random_seed(board, random_seed)
-
-  for i = 1:board.size, j = 1:board.size
-    white_wins = 0
-    black_wins = 0
-    for k = 1:num_games_per_point
-      passes = 0
-      num_moves = 1
-      color = WHITE
-      clear(board)
-      play_move(board, i, j, BLACK)
-      while passes < 3 && num_moves < 600
-        (movei, movej) = generate_move(board, color)
-        play_move(board, movei, movej, color)
-        if is_pass_move(movei, movej)
-          passes += 1
-        else
-          passes = 0
-        end
-        num_moves += 1
-        color = other_color(color)
-      end
-      if passes == 3
-        if compute_score(board) > 0
-          white_wins += 1
-        else
-          black_wins += 1
+    random_seed = convert(UInt32, 1)
+    board_size = 9
+    komi = 0.5
+
+    board = Board(board_size)
+    set_komi(board, komi)
+    set_random_seed(board, random_seed)
+
+    for i = 1:board.size, j = 1:board.size
+        white_wins = 0
+        black_wins = 0
+        for k = 1:num_games_per_point
+            passes = 0
+            num_moves = 1
+            color = WHITE
+            clear(board)
+            play_move(board, i, j, BLACK)
+            while passes < 3 && num_moves < 600
+                (movei, movej) = generate_move(board, color)
+                play_move(board, movei, movej, color)
+                if is_pass_move(movei, movej)
+                    passes += 1
+                else
+                    passes = 0
+                end
+                num_moves += 1
+                color = other_color(color)
+            end
+            if passes == 3
+                if compute_score(board) > 0
+                    white_wins += 1
+                else
+                    black_wins += 1
+                end
+            end
         end
-      end
+#        @printf("%d %d %f\n", i - 1, j - 1, black_wins / (black_wins + white_wins))
     end
-#    @printf("%d %d %f\n", i - 1, j - 1, black_wins / (black_wins + white_wins))
-  end
 end
 
 function main(args)
-  n = 10
-  if length(args) > 0
-    n = parse(Int, args[1])
-  end
-  @time benchmark(n)
+    n = 10
+    if length(args) > 0
+        n = parse(Int, args[1])
+    end
+    @time benchmark(n)
 end
diff --git a/test/perf/kernel/indexing.jl b/test/perf/kernel/indexing.jl
index 3a60f4033e0d45..1ffc422fa51f7d 100644
--- a/test/perf/kernel/indexing.jl
+++ b/test/perf/kernel/indexing.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 function add1!(x,y)
     x[y] .+= 1
diff --git a/test/perf/kernel/json.jl b/test/perf/kernel/json.jl
index ef46eab03011f6..2520ee2e87cc11 100644
--- a/test/perf/kernel/json.jl
+++ b/test/perf/kernel/json.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #JSON Parser
 #Adapted from http://www.mathworks.com/matlabcentral/fileexchange/23393
diff --git a/test/perf/kernel/laplace.jl b/test/perf/kernel/laplace.jl
index 73e3c4ed669152..9c8365872a18cd 100644
--- a/test/perf/kernel/laplace.jl
+++ b/test/perf/kernel/laplace.jl
@@ -1,11 +1,11 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 function laplace_iter_devec(u, dx2, dy2, Niter, N)
     uout = copy(u)
     for iter = 1:Niter
         for i = 2:N-1
             for j = 2:N-1
-                uout[i,j] = ( (u[i-1,j]+u[i+1,j])*dy2 + (u[i,j-1]+u[i,j+1])*dx2 ) * (1./(2*(dx2+dy2)))
+                uout[i,j] = ( (u[i-1,j]+u[i+1,j])*dy2 + (u[i,j-1]+u[i,j+1])*dx2 ) * (1 ./ (2*(dx2+dy2)))
             end
         end
         u, uout = uout, u
@@ -24,7 +24,7 @@ end
 
 function laplace_iter_vec(u, dx2, dy2, Niter, N)
     for i = 1:Niter
-        u[2:N-1, 2:N-1] = ((u[1:N-2, 2:N-1] + u[3:N, 2:N-1])*dy2 + (u[2:N-1,1:N-2] + u[2:N-1, 3:N])*dx2) * (1./ (2*(dx2+dy2)))
+        u[2:N-1, 2:N-1] = ((u[1:N-2, 2:N-1] + u[3:N, 2:N-1])*dy2 + (u[2:N-1,1:N-2] + u[2:N-1, 3:N])*dx2) * (1 ./ (2*(dx2+dy2)))
     end
     return u
 end
@@ -40,7 +40,7 @@ end
 
 function laplace_iter_vec_sub(u, dx2, dy2, Niter, N)
     for i = 1:Niter
-        u[2:N-1, 2:N-1] = ((view(u, 1:N-2, 2:N-1) + view(u,3:N, 2:N-1))*dy2 + (view(u,2:N-1,1:N-2) + view(u,2:N-1, 3:N))*dx2) * (1./ (2*(dx2+dy2)))
+        u[2:N-1, 2:N-1] = ((view(u, 1:N-2, 2:N-1) + view(u,3:N, 2:N-1))*dy2 + (view(u,2:N-1,1:N-2) + view(u,2:N-1, 3:N))*dx2) * (1 ./ (2*(dx2+dy2)))
     end
     return u
 end
diff --git a/test/perf/kernel/laplace/c_laplace.c b/test/perf/kernel/laplace/c_laplace.c
index fb94668022b680..d0721f330d3ef7 100644
--- a/test/perf/kernel/laplace/c_laplace.c
+++ b/test/perf/kernel/laplace/c_laplace.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include<stdio.h>
 #include <time.h>
diff --git a/test/perf/kernel/laplace/c_laplace_parallel_update.c b/test/perf/kernel/laplace/c_laplace_parallel_update.c
index 4aa5baeb02dc6a..b4f6434bcdc57e 100644
--- a/test/perf/kernel/laplace/c_laplace_parallel_update.c
+++ b/test/perf/kernel/laplace/c_laplace_parallel_update.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include<stdio.h>
 #include "parameter.h"
diff --git a/test/perf/kernel/laplace/c_laplace_parallel_update_pointer.c b/test/perf/kernel/laplace/c_laplace_parallel_update_pointer.c
index 1a5f682fd26bbb..2935f7f3419692 100644
--- a/test/perf/kernel/laplace/c_laplace_parallel_update_pointer.c
+++ b/test/perf/kernel/laplace/c_laplace_parallel_update_pointer.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include<stdio.h>
 #include<malloc.h>
diff --git a/test/perf/kernel/laplace/cilk_laplace.c b/test/perf/kernel/laplace/cilk_laplace.c
index af59525add16d7..51204fd176cf38 100644
--- a/test/perf/kernel/laplace/cilk_laplace.c
+++ b/test/perf/kernel/laplace/cilk_laplace.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include<stdio.h>
 #include<cilk/cilk.h>
diff --git a/test/perf/kernel/perf.jl b/test/perf/kernel/perf.jl
index 620a508365a7db..cf539d1f628bae 100644
--- a/test/perf/kernel/perf.jl
+++ b/test/perf/kernel/perf.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 include("../perfutil.jl")
 
diff --git a/test/perf/kernel/raytracer.jl b/test/perf/kernel/raytracer.jl
index 5601143bf7a225..b3451222f44024 100644
--- a/test/perf/kernel/raytracer.jl
+++ b/test/perf/kernel/raytracer.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # raytracer.jl
 # This is a translation from Java/C++ of the raytracer located at
@@ -129,7 +129,7 @@ function Raytracer(levels, n, ss)
             g = 0.
             for dx in 0:1:(ss-1)
                 for dy in 0:1:(ss-1)
-                    d = Vec(x+dx*1./ss-n/2., y+dy*1./ss-n/2., n*1.0)
+                    d = Vec(x+dx*1.0/ss-n/2.0, y+dy*1.0/ss-n/2.0, n*1.0)
                     ray = Ray(Vec(0., 0., -4.0), unitize(d))
                     g += ray_trace(light, ray, scene)
                 end
diff --git a/test/perf/kernel/simplex.jl b/test/perf/kernel/simplex.jl
index 4d369024a55ce6..9fd8c86bf81dd2 100644
--- a/test/perf/kernel/simplex.jl
+++ b/test/perf/kernel/simplex.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 const Basic = 1
 const AtLower = 2
diff --git a/test/perf/kernel/stockcorr.jl b/test/perf/kernel/stockcorr.jl
index 5df022c1c669ac..991578de021c27 100644
--- a/test/perf/kernel/stockcorr.jl
+++ b/test/perf/kernel/stockcorr.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## Test case from Issue #445
 
diff --git a/test/perf/kernel/ziggurat.jl b/test/perf/kernel/ziggurat.jl
index abca7429cf359d..1ed2529ba05d03 100644
--- a/test/perf/kernel/ziggurat.jl
+++ b/test/perf/kernel/ziggurat.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Based on http://m.seehuhn.de/data/ziggurat/gauss.c
 
diff --git a/test/perf/lapack/eig.jl b/test/perf/lapack/eig.jl
index 1a9d9bfb7c79b0..48036c481e19cf 100644
--- a/test/perf/lapack/eig.jl
+++ b/test/perf/lapack/eig.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Real
 function realeigtest(n, iter)
diff --git a/test/perf/lapack/factorizations.jl b/test/perf/lapack/factorizations.jl
index 91a0988e321a74..a0894c74aefb03 100644
--- a/test/perf/lapack/factorizations.jl
+++ b/test/perf/lapack/factorizations.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 function svdtest(n, iter)
     A = rand(n,n)
diff --git a/test/perf/lapack/perf.jl b/test/perf/lapack/perf.jl
index 98fd5340597f38..c856be899bbfe4 100644
--- a/test/perf/lapack/perf.jl
+++ b/test/perf/lapack/perf.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 include("../perfutil.jl")
 
diff --git a/test/perf/micro/java/setup.sh b/test/perf/micro/java/setup.sh
index cce248094e900e..0e8065660e3177 100755
--- a/test/perf/micro/java/setup.sh
+++ b/test/perf/micro/java/setup.sh
@@ -1,5 +1,5 @@
 #!/bin/sh
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 mvn compile exec:java
 # requires maven and java 7
diff --git a/test/perf/micro/perf.c b/test/perf/micro/perf.c
index fa9621bbb1333c..df572e9e366c85 100644
--- a/test/perf/micro/perf.c
+++ b/test/perf/micro/perf.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include <complex.h>
 
diff --git a/test/perf/micro/perf.jl b/test/perf/micro/perf.jl
index 72d6c7b4c237af..c688694363741c 100644
--- a/test/perf/micro/perf.jl
+++ b/test/perf/micro/perf.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base.Test
 
@@ -101,7 +101,7 @@ function pisumvec()
     s = 0.0
     a = [1:10000]
     for j = 1:500
-        s = sum(1./(a.^2))
+        s = sum(1 ./ (a.^2))
     end
     s
 end
@@ -138,7 +138,7 @@ end
 
 ## printfd ##
 
-if is_unix()
+if Sys.isunix()
     function printfd(n)
         open("/dev/null", "w") do io
             for i = 1:n
diff --git a/test/perf/micro/perf.m b/test/perf/micro/perf.m
index 398711f104ea9d..515cf9ba72924f 100644
--- a/test/perf/micro/perf.m
+++ b/test/perf/micro/perf.m
@@ -177,7 +177,7 @@ function timeit(name, func, varargin)
 %% slow pi series, vectorized %%
 
 function s = pisumvec(ignore)
-    a = [1:10000]
+    a = [1:10000];
     for j=1:500
         s = sum( 1./(a.^2));
     end
diff --git a/test/perf/micro/perf.py b/test/perf/micro/perf.py
index 164155a048b69e..b1bd40f150be9b 100644
--- a/test/perf/micro/perf.py
+++ b/test/perf/micro/perf.py
@@ -1,9 +1,9 @@
 from numpy import *
-from numpy.linalg import *
+from numpy.random import rand, randn
+from numpy.linalg import matrix_power
 import sys
 import time
 import random
-import numpy
 
 if sys.version_info < (3,):
     range = xrange
@@ -44,22 +44,22 @@ def randmatstat(t):
     v = zeros(t)
     w = zeros(t)
     for i in range(1,t):
-        a = numpy.random.randn(n, n)
-        b = numpy.random.randn(n, n)
-        c = numpy.random.randn(n, n)
-        d = numpy.random.randn(n, n)
-        P = matrix(hstack((a, b, c, d)))
-        Q = matrix(vstack((hstack((a, b)), hstack((c, d)))))
-        v[i] = trace(matrix_power(transpose(P)*P, 4))
-        w[i] = trace(matrix_power(transpose(Q)*Q, 4))
+        a = randn(n, n)
+        b = randn(n, n)
+        c = randn(n, n)
+        d = randn(n, n)
+        P = concatenate((a, b, c, d))
+        Q = concatenate((concatenate((a, b)), concatenate((c, d))),axis=1)
+        v[i] = trace(matrix_power(dot(P.T,P), 4))
+        w[i] = trace(matrix_power(dot(Q.T,Q), 4))
     return (std(v)/mean(v), std(w)/mean(w))
 
 ## randmatmul ##
 
 def randmatmul(n):
-    A = numpy.random.rand(n,n)
-    B = numpy.random.rand(n,n)
-    return numpy.dot(A,B)
+    A = rand(n,n)
+    B = rand(n,n)
+    return dot(A,B)
 
 ## mandelbrot ##
 
@@ -73,8 +73,8 @@ def mandel(z):
     return maxiter
 
 def mandelperf():
-    r1 = numpy.linspace(-2.0, 0.5, 26)
-    r2 = numpy.linspace(-1.0, 1.0, 21)
+    r1 = [-2. + 0.1*i for i in range(26)]
+    r2 = [-1. + 0.1*i for i in range(21)]
     return [mandel(complex(r, i)) for r in r1 for i in r2]
 
 def pisum():
@@ -89,15 +89,28 @@ def pisum():
 # def pisumvec():
 #     return numpy.sum(1./(numpy.arange(1,10000)**2))
 
+def parse_int(t):
+    for i in range(1,t):
+        n = random.randint(0,2**32-1)
+        s = hex(n)
+        if s[-1]=='L':
+            s = s[0:-1]
+        m = int(s,16)
+        assert m == n
+    return n
+
 def print_perf(name, time):
     print("python," + name + "," + str(time*1000))
 
 ## run tests ##
 
 if __name__=="__main__":
+
+    mintrials = 5
+
     assert fib(20) == 6765
     tmin = float('inf')
-    for i in range(5):
+    for i in range(mintrials):
         t = time.time()
         f = fib(20)
         t = time.time()-t
@@ -105,22 +118,16 @@ def print_perf(name, time):
     print_perf("fib", tmin)
 
     tmin = float('inf')
-    for i in range(5):
+    for i in range(mintrials):
         t = time.time()
-        for i in range(1,1000):
-            n = random.randint(0,2**32-1)
-            s = hex(n)
-            if s[-1]=='L':
-                s = s[0:-1]
-            m = int(s,16)
-            assert m == n
+        n = parse_int(1000)
         t = time.time()-t
         if t < tmin: tmin = t
     print_perf ("parse_int", tmin)
 
     assert sum(mandelperf()) == 14791
     tmin = float('inf')
-    for i in range(5):
+    for i in range(mintrials):
         t = time.time()
         mandelperf()
         t = time.time()-t
@@ -128,7 +135,7 @@ def print_perf(name, time):
     print_perf ("mandel", tmin)
 
     tmin = float('inf')
-    for i in range(5):
+    for i in range(mintrials):
         lst = [ random.random() for i in range(1,5000) ]
         t = time.time()
         qsort_kernel(lst, 0, len(lst)-1)
@@ -138,7 +145,7 @@ def print_perf(name, time):
 
     assert abs(pisum()-1.644834071848065) < 1e-6
     tmin = float('inf')
-    for i in range(5):
+    for i in range(mintrials):
         t = time.time()
         pisum()
         t = time.time()-t
@@ -147,7 +154,7 @@ def print_perf(name, time):
 
     # assert abs(pisumvec()-1.644834071848065) < 1e-6
     # tmin = float('inf')
-    # for i in range(5):
+    # for i in range(mintrials):
     #     t = time.time()
     #     pisumvec()
     #     t = time.time()-t
@@ -157,7 +164,7 @@ def print_perf(name, time):
     (s1, s2) = randmatstat(1000)
     assert s1 > 0.5 and s1 < 1.0
     tmin = float('inf')
-    for i in range(5):
+    for i in range(mintrials):
         t = time.time()
         randmatstat(1000)
         t = time.time()-t
@@ -165,7 +172,7 @@ def print_perf(name, time):
     print_perf ("rand_mat_stat", tmin)
 
     tmin = float('inf')
-    for i in range(5):
+    for i in range(mintrials):
         t = time.time()
         C = randmatmul(1000)
         assert C[0,0] >= 0
diff --git a/test/perf/micro/scala/build.sbt b/test/perf/micro/scala/build.sbt
index c98322a85653e3..794c50491c323a 100644
--- a/test/perf/micro/scala/build.sbt
+++ b/test/perf/micro/scala/build.sbt
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 libraryDependencies ++= Seq(
     "org.scalanlp" %% "breeze" % "0.10",
diff --git a/test/perf/micro/scala/src/main/scala/perf.scala b/test/perf/micro/scala/src/main/scala/perf.scala
index 73fd84fee42960..c6ed3797d86178 100644
--- a/test/perf/micro/scala/src/main/scala/perf.scala
+++ b/test/perf/micro/scala/src/main/scala/perf.scala
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 import scala.util._
 import java.io._
diff --git a/test/perf/perfcomp.jl b/test/perf/perfcomp.jl
index 7575107d90948f..d07de142865246 100644
--- a/test/perf/perfcomp.jl
+++ b/test/perf/perfcomp.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # usage: perfcomp.jl <baseline file> [<suite>]
 # This will run the specified suite (default "all") and compare it to stored
diff --git a/test/perf/perfgeneric.jl b/test/perf/perfgeneric.jl
index a114a6d7037237..4e7dba0fa80514 100644
--- a/test/perf/perfgeneric.jl
+++ b/test/perf/perfgeneric.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #Generic benchmark driver
 for (testfunc, testname, longtestname, problem_sizes) in testdata
diff --git a/test/perf/perfutil.jl b/test/perf/perfutil.jl
index da9a627e76d3b9..7e8e7300401d9a 100644
--- a/test/perf/perfutil.jl
+++ b/test/perf/perfutil.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 const mintrials = 5
 const mintime = 2000.0
@@ -21,7 +21,7 @@ if codespeed
     csdata["project"] = "Julia"
     csdata["branch"] = Base.GIT_VERSION_INFO.branch
     csdata["executable"] = ENV["JULIA_FLAVOR"]
-    csdata["environment"] = chomp(readstring(`hostname`))
+    csdata["environment"] = chomp(read(`hostname`, String))
     csdata["result_date"] = join( split(Base.GIT_VERSION_INFO.date_string)[1:2], " " )    #Cut the timezone out
 end
 
@@ -51,6 +51,10 @@ function submit_to_codespeed(vals,name,desc,unit,test_group,lessisbetter=true)
 end
 
 macro output_timings(t,name,desc,group)
+    t = esc(t)
+    name = esc(name)
+    desc = esc(desc)
+    group = esc(group)
     quote
         # If we weren't given anything for the test group, infer off of file path!
         test_group = length($group) == 0 ? basename(dirname(Base.source_path())) : $group[1]
@@ -77,7 +81,7 @@ macro timeit(ex,name,desc,group...)
             end
             i += 1
         end
-        @output_timings t $name $desc $group
+        @output_timings t $(esc(name)) $(esc(desc)) $(esc(group))
     end
 end
 
@@ -92,13 +96,13 @@ macro timeit_init(ex,init,name,desc,group...)
                 t[i] = e
             end
         end
-        @output_timings t $name $desc $group
+        @output_timings t $(esc(name)) $(esc(desc)) $(esc(group))
     end
 end
 
 function maxrss(name)
     # FIXME: call uv_getrusage instead here
-    @static if is_linux()
+    @static if Sys.islinux()
         rus = Array{Int64}(div(144,8))
         fill!(rus, 0x0)
         res = ccall(:getrusage, Int32, (Int32, Ptr{Void}), 0, rus)
diff --git a/test/perf/report.jl b/test/perf/report.jl
index 34513c53d0a8a5..ed65d7955f8796 100644
--- a/test/perf/report.jl
+++ b/test/perf/report.jl
@@ -1,8 +1,8 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using HTTPClient.HTTPC
 
-env_name = chomp(readstring(`hostname`))
+env_name = chomp(read(`hostname`, String))
 commit = Base.GIT_VERSION_INFO.commit
 flavor = ENV["JULIA_FLAVOR"]
 json = "{\"env\": \"$env_name\", \"blas\":\"$flavor\", \"commit\":\"$commit\"}"
diff --git a/test/perf/shootout/binary_trees.jl b/test/perf/shootout/binary_trees.jl
index 9200748615648c..042fd815685147 100644
--- a/test/perf/shootout/binary_trees.jl
+++ b/test/perf/shootout/binary_trees.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #
 # The Computer Language Benchmarks Game
diff --git a/test/perf/shootout/fannkuch.jl b/test/perf/shootout/fannkuch.jl
index 9db19200bdad5f..fcafc75dbb32a9 100644
--- a/test/perf/shootout/fannkuch.jl
+++ b/test/perf/shootout/fannkuch.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #
 # The Computer Language Benchmarks Game
diff --git a/test/perf/shootout/fasta.jl b/test/perf/shootout/fasta.jl
index fe8129d1d74c7f..1dab880d9e28f8 100644
--- a/test/perf/shootout/fasta.jl
+++ b/test/perf/shootout/fasta.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 const line_width = 60
 
diff --git a/test/perf/shootout/k_nucleotide.jl b/test/perf/shootout/k_nucleotide.jl
index b28555b1e1c203..d46664c1860c96 100644
--- a/test/perf/shootout/k_nucleotide.jl
+++ b/test/perf/shootout/k_nucleotide.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # The Computer Language Benchmarks Game
 # http://shootout.alioth.debian.org/
@@ -65,7 +65,7 @@ function k_nucleotide(infile="knucleotide-input.txt")
     for line in eachline(input)
         startswith(line, ">THREE ") && break
     end
-    data = collect(readstring(input))
+    data = collect(read(input, String))
     # delete the newlines and convert to upper case
     i, j = 1, 1
     while i <= length(data)
diff --git a/test/perf/shootout/mandelbrot.jl b/test/perf/shootout/mandelbrot.jl
index 37332cd680f4b7..62e76de8a89e03 100644
--- a/test/perf/shootout/mandelbrot.jl
+++ b/test/perf/shootout/mandelbrot.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # The Computer Language Benchmarks Game
 # http://shootout.alioth.debian.org/
diff --git a/test/perf/shootout/meteor_contest.jl b/test/perf/shootout/meteor_contest.jl
index ab9a235a28f68e..08ca2b9b2ae194 100644
--- a/test/perf/shootout/meteor_contest.jl
+++ b/test/perf/shootout/meteor_contest.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # The Computer Language Benchmarks Game
 # http://shootout.alioth.debian.org/
diff --git a/test/perf/shootout/nbody.jl b/test/perf/shootout/nbody.jl
index 156d666daf4be2..9d32837ca51b60 100644
--- a/test/perf/shootout/nbody.jl
+++ b/test/perf/shootout/nbody.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #
 # The Computer Language Benchmarks Game
diff --git a/test/perf/shootout/nbody_vec.jl b/test/perf/shootout/nbody_vec.jl
index 7f1fda5f0646e0..657f67c33bbd49 100644
--- a/test/perf/shootout/nbody_vec.jl
+++ b/test/perf/shootout/nbody_vec.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #
 # The Computer Language Benchmarks Game
diff --git a/test/perf/shootout/perf.jl b/test/perf/shootout/perf.jl
index 21966c6c7b38d4..f53182c579b012 100644
--- a/test/perf/shootout/perf.jl
+++ b/test/perf/shootout/perf.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 include("../perfutil.jl")
 
diff --git a/test/perf/shootout/pidigits.jl b/test/perf/shootout/pidigits.jl
index 76c7975df84c78..175445d4248c07 100644
--- a/test/perf/shootout/pidigits.jl
+++ b/test/perf/shootout/pidigits.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 function pidigits(N::Int, printOut::Bool)
     """
diff --git a/test/perf/shootout/regex_dna.jl b/test/perf/shootout/regex_dna.jl
index 348c14187ccd51..75643153768e9b 100644
--- a/test/perf/shootout/regex_dna.jl
+++ b/test/perf/shootout/regex_dna.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # The Computer Language Benchmarks Game
 # http://shootout.alioth.debian.org/
@@ -33,7 +33,7 @@ const subs = [
 ]
 
 function regex_dna(infile="regexdna-input.txt")
-    seq = readstring(infile)
+    seq = read(infile, String)
     l1 = length(seq)
 
     seq = replace(seq, r">.*\n|\n", "")
diff --git a/test/perf/shootout/revcomp.jl b/test/perf/shootout/revcomp.jl
index b9fc342cb97282..84c54c7d4b95a2 100644
--- a/test/perf/shootout/revcomp.jl
+++ b/test/perf/shootout/revcomp.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # The Computer Language Benchmarks Game
 # http://shootout.alioth.debian.org/
diff --git a/test/perf/shootout/spectralnorm.jl b/test/perf/shootout/spectralnorm.jl
index 6acb77c14f43af..52b05c63381dd6 100644
--- a/test/perf/shootout/spectralnorm.jl
+++ b/test/perf/shootout/spectralnorm.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #
 # The Computer Language Benchmarks Game
diff --git a/test/perf/simd/axpy.jl b/test/perf/simd/axpy.jl
index 991684d6dd591f..69cd62c84a81eb 100644
--- a/test/perf/simd/axpy.jl
+++ b/test/perf/simd/axpy.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Compute y += a*x using @simd for vectors x and y
 function simd_axpy( a, x, y )
diff --git a/test/perf/simd/inner.jl b/test/perf/simd/inner.jl
index 94b8a423491ce6..d8113958560f2d 100644
--- a/test/perf/simd/inner.jl
+++ b/test/perf/simd/inner.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Inner produce of x and y
 function inner( x, y )
diff --git a/test/perf/simd/perf.jl b/test/perf/simd/perf.jl
index 8d544d53a159fc..ebcb1de7738841 100644
--- a/test/perf/simd/perf.jl
+++ b/test/perf/simd/perf.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 include("../perfutil.jl")
 
diff --git a/test/perf/simd/seismic_fdtd.jl b/test/perf/simd/seismic_fdtd.jl
index 966199cd9c1604..2386115b162767 100644
--- a/test/perf/simd/seismic_fdtd.jl
+++ b/test/perf/simd/seismic_fdtd.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Finite-difference time-domain seismic simulation in 2D using a staggered grid.
 # The intent is to test performance of @simd on the inner loop of a 2D loop nest.
diff --git a/test/perf/simd/sum_reduce.jl b/test/perf/simd/sum_reduce.jl
index b57502fccd1df7..9ad02e7c9fb7a3 100644
--- a/test/perf/simd/sum_reduce.jl
+++ b/test/perf/simd/sum_reduce.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 function sum_reduce(x, istart, iend)
     s = zero(eltype(x))
diff --git a/test/perf/sort/perf.jl b/test/perf/sort/perf.jl
index 81ab363141c8b0..7ac3087ba77436 100644
--- a/test/perf/sort/perf.jl
+++ b/test/perf/sort/perf.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 import Base.Sort: QuickSort, MergeSort, InsertionSort
 
diff --git a/test/perf/sparse/fem.jl b/test/perf/sparse/fem.jl
index 179a81514ca2a9..77fb47e7c6782a 100644
--- a/test/perf/sparse/fem.jl
+++ b/test/perf/sparse/fem.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## FEM benchmark from https://github.com/JuliaLang/julia/issues/9668
 
diff --git a/test/perf/sparse/getindex.jl b/test/perf/sparse/getindex.jl
index af3254e628d2a0..03d6a6f36b2675 100644
--- a/test/perf/sparse/getindex.jl
+++ b/test/perf/sparse/getindex.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## getindex
 const rep = 20
diff --git a/test/perf/sparse/getindex_skinny.jl b/test/perf/sparse/getindex_skinny.jl
index 2666836ba0bf0b..94d48cdc55ce68 100644
--- a/test/perf/sparse/getindex_skinny.jl
+++ b/test/perf/sparse/getindex_skinny.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Test getindex for skinny sparse matrix
 function sparse_getindex_skinny_perf()
diff --git a/test/perf/sparse/perf.jl b/test/perf/sparse/perf.jl
index 5de1774ad565ad..6fd0bba1c370bb 100644
--- a/test/perf/sparse/perf.jl
+++ b/test/perf/sparse/perf.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## Sparse matrix performance
 include("../perfutil.jl")
diff --git a/test/perf/spell/perf.jl b/test/perf/spell/perf.jl
index e6ee7bb4bf373f..08be858fa70ea4 100644
--- a/test/perf/spell/perf.jl
+++ b/test/perf/spell/perf.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Peter Norvig's Spelling Corrector
 # based off of the python implementation at http://norvig.com/spell-correct.html
@@ -28,7 +28,7 @@ end
 if !isfile("big.txt")
     download("http://norvig.com/big.txt", "big.txt")
 end
-const NWORDS = train(words(readstring("big.txt")))
+const NWORDS = train(words(read("big.txt", String)))
 
 const alphabet = "abcdefghijklmnopqrstuvwxyz"
 
@@ -92,7 +92,7 @@ function spelltest(tests; bias=0, verbose=false)
         end
     end
 
-    return Dict("bad"=>bad, "n"=>n, "bias"=>bias, "pct"=>round(Int, 100. - 100.*bad/n),
+    return Dict("bad"=>bad, "n"=>n, "bias"=>bias, "pct"=>round(Int, 100. - 100. * bad/n),
                 "unknown"=>unknown, "secs"=>toc())
 end
 
diff --git a/test/perf/threads/laplace3d/laplace3d.c b/test/perf/threads/laplace3d/laplace3d.c
index 73dddf6a434306..99f83fcfff5b1f 100644
--- a/test/perf/threads/laplace3d/laplace3d.c
+++ b/test/perf/threads/laplace3d/laplace3d.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 // GCC command line: gcc -fopenmp -mavx2 laplace3d.c -o laplace3d
 
diff --git a/test/perf/threads/laplace3d/laplace3d.jl b/test/perf/threads/laplace3d/laplace3d.jl
index c27956b25205d7..52287cb36c8e7c 100644
--- a/test/perf/threads/laplace3d/laplace3d.jl
+++ b/test/perf/threads/laplace3d/laplace3d.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## 3D Laplace equation
 
diff --git a/test/perf/threads/lbm3d/circshift.jl b/test/perf/threads/lbm3d/circshift.jl
index ccd4ec7686b447..144ba82754c467 100644
--- a/test/perf/threads/lbm3d/circshift.jl
+++ b/test/perf/threads/lbm3d/circshift.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://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
diff --git a/test/perf/threads/lbm3d/lbm3d.jl b/test/perf/threads/lbm3d/lbm3d.jl
index 7639cdd2719de3..14df2cea3c46f0 100644
--- a/test/perf/threads/lbm3d/lbm3d.jl
+++ b/test/perf/threads/lbm3d/lbm3d.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # 3D Lattice Boltzmann (BGK) model of a fluid.
 # (http://exolete.com/lbm/)
diff --git a/test/perf/threads/stockcorr/pstockcorr.jl b/test/perf/threads/stockcorr/pstockcorr.jl
index 076feb7cc58b2f..0b00c158f82e88 100644
--- a/test/perf/threads/stockcorr/pstockcorr.jl
+++ b/test/perf/threads/stockcorr/pstockcorr.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## Test case from Issue #445
 ##
diff --git a/test/pkg.jl b/test/pkg.jl
index 9ecd1913d10825..dbb8cf1161e394 100644
--- a/test/pkg.jl
+++ b/test/pkg.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 import Base.Pkg.PkgError
 
@@ -10,7 +10,7 @@ function capture_stdout(f::Function)
                     f()
                 end
             end
-            return readstring(fname)
+            return read(fname, String)
         finally
             rm(fname, force=true)
         end
@@ -18,22 +18,33 @@ function capture_stdout(f::Function)
 end
 
 
-function temp_pkg_dir(fn::Function, remove_tmp_dir::Bool=true)
+function temp_pkg_dir(fn::Function, tmp_dir=joinpath(tempdir(), randstring()),
+        remove_tmp_dir::Bool=true; initialize::Bool=true)
+
     # Used in tests below to set up and tear down a sandboxed package directory
-    const tmpdir = joinpath(tempdir(),randstring())
-    withenv("JULIA_PKGDIR" => tmpdir) do
+    withenv("JULIA_PKGDIR" => tmp_dir) do
         @test !isdir(Pkg.dir())
         try
-            Pkg.init()
-            @test isdir(Pkg.dir())
-            Pkg.resolve()
+            if initialize
+                Pkg.init()
+                @test isdir(Pkg.dir())
+                Pkg.resolve()
+            else
+                mkpath(Pkg.dir())
+            end
             fn()
         finally
-            remove_tmp_dir && rm(tmpdir, recursive=true)
+            remove_tmp_dir && rm(tmp_dir, recursive=true)
         end
     end
 end
 
+function write_build(pkg, content)
+    build_filename = Pkg.dir(pkg, "deps", "build.jl")
+    mkpath(dirname(build_filename))
+    write(build_filename, content)
+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
@@ -54,11 +65,11 @@ temp_pkg_dir() do
     @test_throws PkgError Pkg.installed("MyFakePackage")
     @test Pkg.installed("Example") === nothing
 
-    # check that versioninfo(io, true) doesn't error and produces some output
+    # check that versioninfo(io; verbose=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)
+    versioninfo(buf, verbose=true)
+    ver = read(buf, String)
     @test startswith(ver, "Julia Version $VERSION")
     @test contains(ver, "Environment:")
 
@@ -124,7 +135,6 @@ temp_pkg_dir() do
     Pkg.status("Example", iob)
     str = chomp(String(take!(iob)))
     @test endswith(str, string(Pkg.installed("Example")))
-    @test isempty(Pkg.dependents("Example"))
 
     # 17364 - a, Pkg.checkout with specific local branch
     let branch_name = "test-branch-1",
@@ -312,7 +322,7 @@ temp_pkg_dir() do
         include(Pkg.dir("Example","src","Example.jl"))
         meth = first(methods(Example.domath))
         fname = string(meth.file)
-        @test ('\\' in fname) == is_windows()
+        @test ('\\' in fname) == Sys.iswindows()
         @test startswith(Base.url(meth), "https://github.com/JuliaLang/Example.jl/tree")
     end
 
@@ -398,13 +408,13 @@ temp_pkg_dir() do
         touch(depsbuild)
         # Pkg.build works without the src directory now
         # but it's probably fine to require it.
-        msg = readstring(`$(Base.julia_cmd()) --startup-file=no -e 'redirect_stderr(STDOUT); Pkg.build("BuildFail")'`)
+        msg = read(`$(Base.julia_cmd()) --startup-file=no -e 'redirect_stderr(STDOUT); Pkg.build("BuildFail")'`, String)
         @test contains(msg, "Building BuildFail")
         @test !contains(msg, "ERROR")
         open(depsbuild, "w") do fd
             println(fd, "error(\"Throw build error\")")
         end
-        msg = readstring(`$(Base.julia_cmd()) --startup-file=no -e 'redirect_stderr(STDOUT); Pkg.build("BuildFail")'`)
+        msg = read(`$(Base.julia_cmd()) --startup-file=no -e 'redirect_stderr(STDOUT); Pkg.build("BuildFail")'`, String)
         @test contains(msg, "Building BuildFail")
         @test contains(msg, "ERROR")
         @test contains(msg, "Pkg.build(\"BuildFail\")")
@@ -415,11 +425,29 @@ temp_pkg_dir() do
     let package = "Example"
         Pkg.rm(package)  # Remove package if installed
         @test Pkg.installed(package) === nothing  # Registered with METADATA but not installed
-        msg = readstring(ignorestatus(`$(Base.julia_cmd()) --startup-file=no -e "redirect_stderr(STDOUT); Pkg.build(\"$package\")"`))
+        msg = read(ignorestatus(`$(Base.julia_cmd()) --startup-file=no -e "redirect_stderr(STDOUT); Pkg.build(\"$package\")"`), String)
         @test contains(msg, "$package is not an installed package")
         @test !contains(msg, "signal (15)")
     end
 
+    # issue #20695
+    Pkg.cd() do
+        @test Pkg.Entry.url_and_pkg("Example") == ("git://github.com/JuliaLang/Example.jl.git", "Example")
+        for url = [
+            "https://github.com/Org/Nonsense",
+            "git@github.com:Org/Nonsense",
+            "file:///home/user/Nonsense",
+            "/home/user/Nonsense",
+        ]
+            @test Pkg.Entry.url_and_pkg(url) == (url, "Nonsense")
+            @test Pkg.Entry.url_and_pkg("$url.jl") == ("$url.jl", "Nonsense")
+            @test Pkg.Entry.url_and_pkg("$url.git") == ("$url.git", "Nonsense")
+            @test Pkg.Entry.url_and_pkg("$url.jl.git") == ("$url.jl.git", "Nonsense")
+        end
+        pkg = randstring(20)
+        @test Pkg.Entry.url_and_pkg(pkg) == (pkg, pkg)
+    end
+
     # partial Pkg.update
     @test "" == capture_stdout() do
         nothingtodomsg = "INFO: No packages to install, update or remove"
@@ -462,6 +490,21 @@ temp_pkg_dir() do
             LibGit2.reset!(repo, LibGit2.GitHash(old_commit), LibGit2.Consts.RESET_HARD)
         end
 
+        # run these at an old metadata commit where it's guaranteed no
+        # packages depend on Example.jl
+        @test isempty(Pkg.dependents("Example"))
+        @test isempty(Pkg.dependents("Example.jl"))
+
+        @test_warn s -> !contains(s, "updated but were already imported") begin
+            Pkg.add("Iterators")
+            Pkg.update("Iterators")
+        end
+
+        # Do it again, because the above Iterators test will update things prematurely
+        LibGit2.with(LibGit2.GitRepo, metadata_dir) do repo
+            LibGit2.reset!(repo, LibGit2.GitHash(old_commit), LibGit2.Consts.RESET_HARD)
+        end
+
         @test_warn ("INFO: Installing Colors v0.6.4",
                     "INFO: Installing ColorTypes v0.2.2",
                     "INFO: Installing FixedPointNumbers v0.1.3",
@@ -490,13 +533,135 @@ temp_pkg_dir() do
         end
 
         Pkg.add(package)
-        msg = readstring(ignorestatus(`$(Base.julia_cmd()) --startup-file=no -e
-            "redirect_stderr(STDOUT); using Example; Pkg.update(\"$package\")"`))
+        msg = read(ignorestatus(`$(Base.julia_cmd()) --startup-file=no -e
+            "redirect_stderr(STDOUT); using Example; Pkg.update(\"$package\")"`), String)
         @test contains(msg, "- $package\nRestart Julia to use the updated versions.")
     end
+
+    # Verify that the --startup-file flag is respected by Pkg.build / Pkg.test
+    let package = "StartupFile"
+        content = """
+            info("JULIA_RC_LOADED defined \$(isdefined(@__MODULE__, :JULIA_RC_LOADED))")
+            info("Main.JULIA_RC_LOADED defined \$(isdefined(Main, :JULIA_RC_LOADED))")
+            """
+
+        write_build(package, content)
+
+        test_filename = Pkg.dir(package, "test", "runtests.jl")
+        mkpath(dirname(test_filename))
+        write(test_filename, content)
+
+        # Make a .juliarc.jl
+        home = Pkg.dir(".home")
+        mkdir(home)
+        write(joinpath(home, ".juliarc.jl"), "const JULIA_RC_LOADED = true")
+
+        withenv((Sys.iswindows() ? "USERPROFILE" : "HOME") => home) do
+            code = "redirect_stderr(STDOUT); Pkg.build(\"$package\")"
+
+            msg = read(`$(Base.julia_cmd()) --startup-file=no -e $code`, String)
+            @test contains(msg, "INFO: JULIA_RC_LOADED defined false")
+            @test contains(msg, "INFO: Main.JULIA_RC_LOADED defined false")
+
+            msg = read(`$(Base.julia_cmd()) --startup-file=yes -e $code`, String)
+            @test contains(msg, "INFO: JULIA_RC_LOADED defined false")
+            @test contains(msg, "INFO: Main.JULIA_RC_LOADED defined true")
+
+            code = "redirect_stderr(STDOUT); Pkg.test(\"$package\")"
+
+            msg = read(`$(Base.julia_cmd()) --startup-file=no -e $code`, String)
+            @test contains(msg, "INFO: JULIA_RC_LOADED defined false")
+            @test contains(msg, "INFO: Main.JULIA_RC_LOADED defined false")
+
+            # Note: Since both the startup-file and "runtests.jl" are run in the Main
+            # module any global variables created in the .juliarc.jl can be referenced.
+            msg = read(`$(Base.julia_cmd()) --startup-file=yes -e $code`, String)
+            @test contains(msg, "INFO: JULIA_RC_LOADED defined true")
+            @test contains(msg, "INFO: Main.JULIA_RC_LOADED defined true")
+        end
+    end
+end
+
+@testset "Pkg functions with .jl extension" begin
+    temp_pkg_dir() do
+        @test Pkg.installed("Example.jl") === nothing
+        Pkg.add("Example.jl")
+        @test [keys(Pkg.installed())...] == ["Example"]
+        iob = IOBuffer()
+        Pkg.checkout("Example.jl")
+        Pkg.status("Example.jl", iob)
+        str = chomp(String(take!(iob)))
+        @test startswith(str, " - Example")
+        @test endswith(str, "master")
+        Pkg.free("Example.jl")
+        Pkg.status("Example.jl", iob)
+        str = chomp(String(take!(iob)))
+        @test endswith(str, string(Pkg.installed("Example.jl")))
+        Pkg.checkout("Example.jl")
+        Pkg.free(("Example.jl",))
+        Pkg.status("Example.jl", iob)
+        str = chomp(String(take!(iob)))
+        @test endswith(str, string(Pkg.installed("Example.jl")))
+        Pkg.rm("Example.jl")
+        @test isempty(Pkg.installed())
+        @test !isempty(Pkg.available("Example.jl"))
+        @test !in("Example", keys(Pkg.installed()))
+        Pkg.rm("Example.jl")
+        @test isempty(Pkg.installed())
+        @test !isempty(Pkg.available("Example.jl"))
+        @test !in("Example", keys(Pkg.installed()))
+        Pkg.clone("https://github.com/JuliaLang/Example.jl.git")
+        @test [keys(Pkg.installed())...] == ["Example"]
+        Pkg.status("Example.jl", iob)
+        str = chomp(String(take!(iob)))
+        @test startswith(str, " - Example")
+        @test endswith(str, "master")
+        Pkg.free("Example.jl")
+        Pkg.status("Example.jl", iob)
+        str = chomp(String(take!(iob)))
+        @test endswith(str, string(Pkg.installed("Example.jl")))
+        Pkg.checkout("Example.jl")
+        Pkg.free(("Example.jl",))
+        Pkg.status("Example.jl", iob)
+        str = chomp(String(take!(iob)))
+        @test endswith(str, string(Pkg.installed("Example.jl")))
+    end
 end
 
 let io = IOBuffer()
     Base.showerror(io, Base.Pkg.Entry.PkgTestError("ppp"), backtrace())
     @test !contains(String(take!(io)), "backtrace()")
 end
+
+@testset "Relative path operations" begin
+    cd(tempdir()) do
+        temp_pkg_dir(randstring()) do
+            Pkg.add("Example")
+            @test [keys(Pkg.installed())...] == ["Example"]
+        end
+    end
+end
+
+temp_pkg_dir(initialize=false) do
+    write_build("Normal", "")
+    write_build("Error", "error(\"An error has occurred while building a package\")")
+    write_build("Exit", "exit()")
+
+    cd(Pkg.dir()) do
+        errors = Dict()
+
+        empty!(errors)
+        @test_warn ("INFO: Building Error",
+                    "INFO: Building Normal") Pkg.Entry.build!(["Error", "Normal"], errors)
+
+        empty!(errors)
+        @test_warn ("INFO: Building Exit",
+                    "INFO: Building Normal") Pkg.Entry.build!(["Exit", "Normal"], errors)
+
+        empty!(errors)
+        @test_warn ("INFO: Building Exit",
+                    "INFO: Building Normal",
+                    "INFO: Building Exit",
+                    "INFO: Building Normal") Pkg.Entry.build!(["Exit", "Normal", "Exit", "Normal"], errors)
+    end
+end
diff --git a/test/pollfd.jl b/test/pollfd.jl
index 7051c2fc1739d2..fdc44439c1d51e 100644
--- a/test/pollfd.jl
+++ b/test/pollfd.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # This script does the following
 # Sets up n unix pipes
@@ -13,7 +13,7 @@ intvls = [2, .2, .1, .005]
 
 pipe_fds = Vector{Any}(n)
 for i in 1:n
-    @static if is_windows()
+    @static if Sys.iswindows()
         pipe_fds[i] = Array{Libc.WindowsRawSocket}(2)
         0 == ccall(:wsasocketpair, Cint, (Cint, Cuint, Cint, Ptr{Libc.WindowsRawSocket}), 1, 1, 6, pipe_fds[i]) || error(Libc.FormatMessage())
     else
@@ -41,7 +41,7 @@ function pfd_tst_reads(idx, intvl)
     # @test t_elapsed <= (intvl + 1)
 
     dout = Array{UInt8}(1)
-    @static if is_windows()
+    @static if Sys.iswindows()
         1 == ccall(:recv, stdcall, Cint, (Ptr{Void}, Ptr{UInt8}, Cint, Cint), pipe_fds[idx][1], dout, 1, 0) || error(Libc.FormatMessage())
     else
         @test 1 == ccall(:read, Csize_t, (Cint, Ptr{UInt8}, Csize_t), pipe_fds[idx][1], dout, 1)
@@ -96,7 +96,7 @@ for (i, intvl) in enumerate(intvls)
             @test event.writable
 
             if isodd(idx)
-                @static if is_windows()
+                @static if Sys.iswindows()
                     1 == ccall(:send, stdcall, Cint, (Ptr{Void}, Ptr{UInt8}, Cint, Cint), pipe_fds[idx][2], "A", 1, 0) || error(Libc.FormatMessage())
                 else
                     @test 1 == ccall(:write, Csize_t, (Cint, Ptr{UInt8}, Csize_t), pipe_fds[idx][2], "A", 1)
@@ -112,7 +112,7 @@ end
 
 for i in 1:n
     for j = 1:2
-        @static if is_windows()
+        @static if Sys.iswindows()
             0 == ccall(:closesocket, stdcall, Cint, (Ptr{Void},), pipe_fds[i][j]) || error(Libc.FormatMessage())
         else
             @test 0 == ccall(:close, Cint, (Cint,), pipe_fds[i][j])
@@ -123,7 +123,25 @@ end
 # issue #12473
 # make sure 1-shot timers work
 let a = []
-    Timer(t->push!(a, 1), 0.01, 0)
+    Timer(t -> push!(a, 1), 0.01, 0)
     sleep(0.2)
     @test a == [1]
 end
+
+# make sure repeating timers work
+@noinline function make_unrooted_timer(a)
+    t = Timer(0.0, 0.1)
+    finalizer(t, t -> a[] += 1)
+    wait(t)
+    e = @elapsed for i = 1:5
+        wait(t)
+    end
+    @test 1.5 > e >= 0.4
+    @test a[] == 0
+    nothing
+end
+let a = Ref(0)
+    make_unrooted_timer(a)
+    gc()
+    @test a[] == 1
+end
diff --git a/test/printf.jl b/test/printf.jl
index 312b8698c1ba45..2885ddc8df3bd2 100644
--- a/test/printf.jl
+++ b/test/printf.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # printf
 # int
@@ -25,8 +25,9 @@ for (fmt, val) in (("%i", "42"),
                    ("%f", "42.000000"),
                    ("%g", "42")),
      num in (UInt16(42), UInt32(42), UInt64(42), UInt128(42),
-              Int16(42), Int32(42), Int64(42), Int128(42))
+              Int16(42), Int32(42), Int64(42), Int128(42), big"42")
             #big"42" causes stack overflow on %a ; gh #14409
+    num isa BigInt && fmt in ["%a", "%#o", "%g"] && continue
     @test @eval(@sprintf($fmt, $num) == $val)
 end
 
@@ -255,3 +256,6 @@ end
 
 # @printf
 @test_throws ArgumentError eval(:(@printf 1))
+
+# Check bug with trailing nul printing BigFloat
+@test (@sprintf("%.330f", BigFloat(1)))[end] != '\0'
diff --git a/test/profile.jl b/test/profile.jl
index f9a731c1c54277..92e3076fc94814 100644
--- a/test/profile.jl
+++ b/test/profile.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 function busywait(t, n_tries)
     iter = 0
@@ -11,6 +11,17 @@ end
 
 Profile.clear()
 @profile busywait(1, 20)
+
+let r = Profile.retrieve()
+    mktemp() do path, io
+        serialize(io, r)
+        close(io)
+        open(path) do io
+            @test isa(deserialize(io), Tuple{Vector{UInt},Dict{UInt64,Vector{StackFrame}}})
+        end
+    end
+end
+
 let iobuf = IOBuffer()
     Profile.print(iobuf, format=:tree, C=true)
     str = String(take!(iobuf))
diff --git a/test/random.jl b/test/random.jl
index 90a126a05d996d..fd885163d8e777 100644
--- a/test/random.jl
+++ b/test/random.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Issue #6573
 srand(0); rand(); x = rand(384)
@@ -13,9 +13,9 @@ srand(0); rand(); x = rand(384)
 @test typeof(rand(false:true)) === Bool
 @test typeof(rand(Char)) === Char
 @test length(randn(4, 5)) == 20
+@test length(randn(Complex128, 4, 5)) == 20
 @test length(bitrand(4, 5)) == 20
 
-@test rand(MersenneTwister()) == 0.8236475079774124
 @test rand(MersenneTwister(0)) == 0.8236475079774124
 @test rand(MersenneTwister(42)) == 0.5331830160438613
 # Try a seed larger than 2^32
@@ -38,7 +38,7 @@ A = zeros(UInt128, 2, 2)
 @test_throws BoundsError rand!(MersenneTwister(0), A, 5)
 
 # rand from AbstractArray
-let mt = MersenneTwister()
+let mt = MersenneTwister(0)
     srand(mt)
     @test rand(mt, 0:3:1000) in 0:3:1000
     @test issubset(rand!(mt, Array{Int}(100), 0:3:1000), 0:3:1000)
@@ -53,12 +53,6 @@ let mt = MersenneTwister()
     rand(coll, 2, 3)
 end
 
-# rand using Dict, Set
-adict = Dict(1=>2, 3=>4, 5=>6)
-@test rand(adict) in adict
-aset = Set(1:10)
-@test rand(aset) in aset
-
 # randn
 @test randn(MersenneTwister(42)) == -0.5560268761463861
 A = zeros(2, 2)
@@ -66,6 +60,11 @@ randn!(MersenneTwister(42), A)
 @test A == [-0.5560268761463861  0.027155338009193845;
             -0.444383357109696  -0.29948409035891055]
 
+B = zeros(Complex128, 2)
+randn!(MersenneTwister(42), B)
+@test B == [Complex128(-0.5560268761463861,-0.444383357109696),
+            Complex128(0.027155338009193845,-0.29948409035891055)] * 0.7071067811865475244008
+
 for T in (Int8, UInt8, Int16, UInt16, Int32, UInt32, Int64, UInt64, Int128, UInt128, BigInt,
           Float16, Float32, Float64, Rational{Int})
     r = rand(convert(T, 97):convert(T, 122))
@@ -227,7 +226,7 @@ u4 = uuid4()
 @test u4 == UUID(string(u4)) == UUID(GenericString(string(u4)))
 @test u1 == UUID(UInt128(u1))
 @test u4 == UUID(UInt128(u4))
-@test uuid4(MersenneTwister()) == uuid4(MersenneTwister())
+@test uuid4(MersenneTwister(0)) == uuid4(MersenneTwister(0))
 @test_throws ArgumentError UUID("550e8400e29b-41d4-a716-446655440000")
 @test_throws ArgumentError UUID("550e8400e29b-41d4-a716-44665544000098")
 @test_throws ArgumentError UUID("z50e8400-e29b-41d4-a716-446655440000")
@@ -278,7 +277,7 @@ let mt = MersenneTwister(0)
 end
 
 # Issue #9037
-let mt = MersenneTwister()
+let mt = MersenneTwister(0)
     a = Array{Float64}(0)
     resize!(a, 1000) # could be 8-byte aligned
     b = Array{Float64}(1000) # should be 16-byte aligned
@@ -306,9 +305,23 @@ let a = [rand(RandomDevice(), UInt128) for i=1:10]
 end
 
 # test all rand APIs
-for rng in ([], [MersenneTwister()], [RandomDevice()])
-    types = [Base.BitInteger_types..., Bool, Float16, Float32, Float64, Char]
+for rng in ([], [MersenneTwister(0)], [RandomDevice()])
     ftypes = [Float16, Float32, Float64]
+    cftypes = [Complex32, Complex64, Complex128, ftypes...]
+    types = [Bool, Char, Base.BitInteger_types..., ftypes...]
+    randset = Set(rand(Int, 20))
+    randdict = Dict(zip(rand(Int,10), rand(Int, 10)))
+    collections = [IntSet(rand(1:100, 20)) => Int,
+                   randset                 => Int,
+                   GenericSet(randset)     => Int,
+                   randdict                => Pair{Int,Int},
+                   GenericDict(randdict)   => Pair{Int,Int},
+                   1:100                   => Int,
+                   rand(Int, 100)          => Int,
+                   Int                     => Int,
+                   Float64                 => Float64,
+                   "qwèrtï"                => Char,
+                   GenericString("qwèrtï") => Char]
     b2 = big(2)
     u3 = UInt(3)
     for f in [rand, randn, randexp]
@@ -317,7 +330,7 @@ for rng in ([], [MersenneTwister()], [RandomDevice()])
         f(rng..., 2, 3)               ::Array{Float64, 2}
         f(rng..., b2, u3)             ::Array{Float64, 2}
         f(rng..., (2, 3))             ::Array{Float64, 2}
-        for T in (f === rand ? types : ftypes)
+        for T in (f === rand ? types : f === randn ? cftypes : ftypes)
             a0 = f(rng..., T)         ::T
             a1 = f(rng..., T, 5)      ::Vector{T}
             a2 = f(rng..., T, 2, 3)   ::Array{T, 2}
@@ -330,14 +343,40 @@ for rng in ([], [MersenneTwister()], [RandomDevice()])
             end
         end
     end
+    for (C, T) in collections
+        a0 = rand(rng..., C)                         ::T
+        a1 = rand(rng..., C, 5)                      ::Vector{T}
+        a2 = rand(rng..., C, 2, 3)                   ::Array{T, 2}
+        a3 = rand(rng..., C, (2, 3))                 ::Array{T, 2}
+        a4 = rand(rng..., C, b2, u3)                 ::Array{T, 2}
+        a5 = rand!(rng..., Array{T}(5), C)           ::Vector{T}
+        a6 = rand!(rng..., Array{T}(2, 3), C)        ::Array{T, 2}
+        a7 = rand!(rng..., GenericArray{T}(5), C)    ::GenericArray{T, 1}
+        a8 = rand!(rng..., GenericArray{T}(2, 3), C) ::GenericArray{T, 2}
+        @test size(a1) == (5,)
+        @test size(a2) == size(a3) == (2, 3)
+        for a in [a0, a1..., a2..., a3..., a4..., a5..., a6..., a7..., a8...]
+            if C isa Type
+                @test a isa C
+            else
+                @test a in C
+            end
+        end
+    end
+    for C in [1:0, Dict(), Set(), IntSet(), Int[],
+              GenericDict(Dict()), GenericSet(Set()),
+              "", Base.Test.GenericString("")]
+        @test_throws ArgumentError rand(rng..., C)
+        @test_throws ArgumentError rand(rng..., C, 5)
+    end
     for f! in [rand!, randn!, randexp!]
-        for T in (f! === rand! ? types : ftypes)
+        for T in (f! === rand! ? types : f! === randn! ? cftypes : ftypes)
             X = T == Bool ? T[0,1] : T[0,1,2]
-            for A in (Array{T}(5), Array{T}(2, 3))
+            for A in (Array{T}(5), Array{T}(2, 3), GenericArray{T}(5), GenericArray{T}(2, 3))
                 f!(rng..., A)                    ::typeof(A)
                 if f! === rand!
                     f!(rng..., A, X)             ::typeof(A)
-                    if T !== Char # Char/Integer comparison
+                    if A isa Array && T !== Char # Char/Integer comparison
                         f!(rng..., sparse(A))    ::typeof(sparse(A))
                         f!(rng..., sparse(A), X) ::typeof(sparse(A))
                     end
@@ -348,6 +387,7 @@ for rng in ([], [MersenneTwister()], [RandomDevice()])
 
     bitrand(rng..., 5)             ::BitArray{1}
     bitrand(rng..., 2, 3)          ::BitArray{2}
+    bitrand(rng..., b2, u3)        ::BitArray{2}
     rand!(rng..., BitArray(5))     ::BitArray{1}
     rand!(rng..., BitArray(2, 3))  ::BitArray{2}
 
@@ -378,7 +418,7 @@ function hist(X,n)
 end
 
 # test uniform distribution of floats
-for rng in [srand(MersenneTwister()), RandomDevice()]
+for rng in [srand(MersenneTwister(0)), RandomDevice()]
     for T in [Float16,Float32,Float64]
         # array version
         counts = hist(rand(rng, T, 2000), 4)
@@ -412,14 +452,24 @@ let mta = MersenneTwister(42), mtb = MersenneTwister(42)
     @test shuffle(mta,collect(1:10)) == shuffle(mtb,collect(1:10))
     @test shuffle!(mta,collect(1:10)) == shuffle!(mtb,collect(1:10))
     @test shuffle(mta,collect(2:11)) == shuffle(mtb,2:11)
+    @test shuffle!(mta, rand(mta, 2, 3)) == shuffle!(mtb, rand(mtb, 2, 3))
+    @test shuffle(mta, rand(mta, 2, 3)) == shuffle(mtb, rand(mtb, 2, 3))
 
     @test randperm(mta,10) == randperm(mtb,10)
     @test sort!(randperm(10)) == sort!(shuffle(1:10)) == collect(1:10)
     @test randperm(mta,big(10)) == randperm(mtb,big(10)) # cf. #16376
     @test randperm(0) == []
+    @test eltype(randperm(UInt(1))) === Int
     @test_throws ErrorException randperm(-1)
 
+    A, B = Vector{Int}(10), Vector{Int}(10)
+    @test randperm!(mta, A) == randperm!(mtb, B)
+    @test randperm!(A) === A
+
     @test randcycle(mta,10) == randcycle(mtb,10)
+    @test eltype(randcycle(UInt(1))) === Int
+    @test randcycle!(mta, A) == randcycle!(mtb, B)
+    @test randcycle!(A) === A
 
     @test sprand(mta,1,1,0.9) == sprand(mtb,1,1,0.9)
     @test sprand(mta,10,10,0.3) == sprand(mtb,10,10,0.3)
@@ -450,12 +500,14 @@ end
 srand(typemax(UInt))
 srand(typemax(UInt128))
 
-# copy and ==
+# copy, == and hash
 let seed = rand(UInt32, 10)
     r = MersenneTwister(seed)
     @test r == MersenneTwister(seed) # r.vals should be all zeros
+    @test hash(r) == hash(MersenneTwister(seed))
     s = copy(r)
     @test s == r && s !== r
+    @test hash(s) == hash(r)
     skip, len = rand(0:2000, 2)
     for j=1:skip
         rand(r)
@@ -463,6 +515,9 @@ let seed = rand(UInt32, 10)
     end
     @test rand(r, len) == rand(s, len)
     @test s == r
+    @test hash(s) == hash(r)
+    h = rand(UInt)
+    @test hash(s, h) == hash(r, h)
 end
 
 # MersenneTwister initialization with invalid values
@@ -476,6 +531,53 @@ end
 let seed = rand(UInt32, 10)
     r = MersenneTwister(seed)
     @test r.seed == seed && r.seed !== seed
+    # RNGs do not share their seed in randjump
+    let rs = randjump(r, 2)
+        @test  rs[1].seed !== rs[2].seed
+        srand(rs[2])
+        @test seed == rs[1].seed != rs[2].seed
+    end
     resize!(seed, 4)
     @test r.seed != seed
 end
+
+# srand(rng, ...) returns rng (#21248)
+let g = Base.Random.GLOBAL_RNG,
+    m = MersenneTwister(0)
+    @test srand() === g
+    @test srand(rand(UInt)) === g
+    @test srand(rand(UInt32, rand(1:10))) === g
+    @test srand(m) === m
+    @test srand(m, rand(UInt)) === m
+    @test srand(m, rand(UInt32, rand(1:10))) === m
+    @test srand(m, rand(1:10)) === m
+end
+
+# Issue 20062 - ensure internal functions reserve_1, reserve are type-stable
+let r = MersenneTwister(0)
+    @inferred Base.Random.reserve_1(r)
+    @inferred Base.Random.reserve(r, 1)
+end
+
+# test randstring API
+let b = ['0':'9';'A':'Z';'a':'z']
+    for rng = [[], [MersenneTwister(0)]]
+        @test length(randstring(rng...)) == 8
+        @test length(randstring(rng..., 20)) == 20
+        @test issubset(randstring(rng...), b)
+        for c = ['a':'z', "qwèrtï", Set(Vector{UInt8}("gcat"))],
+                len = [8, 20]
+            s = len == 8 ? randstring(rng..., c) : randstring(rng..., c, len)
+            @test length(s) == len
+            if eltype(c) == Char
+                @test issubset(s, c)
+            else # UInt8
+                @test issubset(s, map(Char, c))
+            end
+        end
+    end
+    @test randstring(MersenneTwister(0)) == randstring(MersenneTwister(0), b)
+end
+
+# this shouldn't crash (#22403)
+@test_throws MethodError rand!(Union{UInt,Int}[1, 2, 3])
diff --git a/test/ranges.jl b/test/ranges.jl
index 79502315ccbd1e..fa54567a6e5630 100644
--- a/test/ranges.jl
+++ b/test/ranges.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # ranges
 @test size(10:1:0) == (0,)
@@ -25,6 +25,7 @@ L64 = @inferred(linspace(Int64(1), Int64(4), 4))
 @test L32[2] == 2 && L64[2] == 2
 @test L32[3] == 3 && L64[3] == 3
 @test L32[4] == 4 && L64[4] == 4
+@test @inferred(linspace(1.0, 2.0, 2.0f0)) === linspace(1.0, 2.0, 2)
 
 r = 5:-1:1
 @test r[1]==5
@@ -158,6 +159,28 @@ r = (-4*Int64(maxintfloat(Int === Int32 ? Float32 : Float64))):5
 @test !(1 in 1:0)
 @test !(1.0 in 1.0:0.0)
 
+# test that in() works across types, including non-numeric types (#21728)
+@test 1//1 in 1:3
+@test 1//1 in 1.0:3.0
+@test !(5//1 in 1:3)
+@test !(5//1 in 1.0:3.0)
+@test Complex(1, 0) in 1:3
+@test Complex(1, 0) in 1.0:3.0
+@test Complex(1.0, 0.0) in 1:3
+@test Complex(1.0, 0.0) in 1.0:3.0
+@test !(Complex(1, 1) in 1:3)
+@test !(Complex(1, 1) in 1.0:3.0)
+@test !(Complex(1.0, 1.0) in 1:3)
+@test !(Complex(1.0, 1.0) in 1.0:3.0)
+@test !(π in 1:3)
+@test !(π in 1.0:3.0)
+@test !("a" in 1:3)
+@test !("a" in 1.0:3.0)
+@test !(1 in Date(2017, 01, 01):Date(2017, 01, 05))
+@test !(Complex(1, 0) in Date(2017, 01, 01):Date(2017, 01, 05))
+@test !(π in Date(2017, 01, 01):Date(2017, 01, 05))
+@test !("a" in Date(2017, 01, 01):Date(2017, 01, 05))
+
 # indexing range with empty range (#4309)
 @test (3:6)[5:4] == 7:6
 @test_throws BoundsError (3:6)[5:5]
@@ -355,8 +378,6 @@ for T = (Float32, Float64,), i = 1:2^15, n = 1:5
     # FIXME: these fail some small portion of the time
     @test_skip start == first(r)
     @test_skip stop  == last(r)
-    # FIXME: linspace construction fails on 32-bit
-    Sys.WORD_SIZE == 64 || continue
     l = linspace(start,stop,n)
     @test n == length(l)
     # FIXME: these fail some small portion of the time
@@ -364,6 +385,11 @@ for T = (Float32, Float64,), i = 1:2^15, n = 1:5
     @test_skip stop  == last(l)
 end
 
+# Inexact errors on 32 bit architectures. #22613
+@test first(linspace(log(0.2), log(10.0), 10)) == log(0.2)
+@test last(linspace(log(0.2), log(10.0), 10)) == log(10.0)
+@test length(Base.floatrange(-3e9, 1.0, 1, 1.0)) == 1
+
 # linspace & ranges with very small endpoints
 for T = (Float32, Float64)
     z = zero(T)
@@ -606,6 +632,9 @@ end
 @test convert(LinSpace, 0.0:0.1:0.3) === LinSpace{Float64}(0.0, 0.3, 4)
 @test convert(LinSpace, 0:3) === LinSpace{Int}(0, 3, 4)
 
+@test promote('a':'z', 1:2) === ('a':'z', 1:1:2)
+@test eltype(['a':'z', 1:2]) == (StepRange{T,Int} where T)
+
 @test start(LinSpace(0,3,4)) == 1
 @test 2*LinSpace(0,3,4) == LinSpace(0,6,4)
 @test LinSpace(0,3,4)*2 == LinSpace(0,6,4)
@@ -676,7 +705,7 @@ test_range_index(linspace(1.0, 1.0, 1), 1:1)
 test_range_index(linspace(1.0, 1.0, 1), 1:0)
 test_range_index(linspace(1.0, 2.0, 0), 1:0)
 
-function test_linspace_identity{T}(r::Range{T}, mr)
+function test_linspace_identity(r::Range{T}, mr) where T
     @test -r == mr
     @test -collect(r) == collect(mr)
     @test isa(-r, typeof(r))
@@ -894,6 +923,14 @@ let r = linspace(1.0, 3+im, 4)
     @test r[4] === 3.0+im
 end
 
+# ambiguity between colon methods (#20988)
+struct NotReal; val; end
+Base.:+(x, y::NotReal) = x + y.val
+Base.zero(y::NotReal) = zero(y.val)
+Base.rem(x, y::NotReal) = rem(x, y.val)
+Base.isless(x, y::NotReal) = isless(x, y.val)
+@test colon(1, NotReal(1), 5) isa StepRange{Int,NotReal}
+
 # dimensional correctness:
 isdefined(Main, :TestHelpers) || @eval Main include("TestHelpers.jl")
 using TestHelpers.Furlong
@@ -902,3 +939,21 @@ using TestHelpers.Furlong
 @test collect(Furlong(2):Furlong(1):Furlong(10)) == collect(range(Furlong(2),Furlong(1),9)) == Furlong.(2:10)
 @test collect(Furlong(1.0):Furlong(0.5):Furlong(10.0)) ==
       collect(Furlong(1):Furlong(0.5):Furlong(10)) == Furlong.(1:0.5:10)
+
+# issue #22270
+let linsp = linspace(1.0, 2.0, 10)
+    @test typeof(linsp.ref) == Base.TwicePrecision{Float64}
+    @test Float32(linsp.ref) === convert(Float32, linsp.ref)
+    @test Float32(linsp.ref) ≈ linsp.ref.hi + linsp.ref.lo
+end
+
+@testset "logspace" begin
+    n = 10; a = 2; b = 4
+    # test default values; n = 50, base = 10
+    @test logspace(a, b) == logspace(a, b, 50) == 10 .^ linspace(a, b, 50)
+    @test logspace(a, b, n) == 10 .^ linspace(a, b, n)
+    for base in (10, 2, e)
+        @test logspace(a, b, base=base) == logspace(a, b, 50, base=base) == base.^linspace(a, b, 50)
+        @test logspace(a, b, n, base=base) == base.^linspace(a, b, n)
+    end
+end
diff --git a/test/read.jl b/test/read.jl
index f88863be4d7a86..c68076d9010f9f 100644
--- a/test/read.jl
+++ b/test/read.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 mktempdir() do dir
 
@@ -83,7 +83,7 @@ push!(l, ("TCPSocket", io))
 io = (text) -> begin
     a = "\\\\.\\pipe\\uv-test-$(randstring(6))"
     b = joinpath(dir, "socket-$(randstring(6))")
-    socketname = is_windows() ? a : b
+    socketname = Sys.iswindows() ? a : b
     srv = listen(socketname)
     run_test_server(srv, text)
     connect(socketname)
@@ -98,7 +98,7 @@ push!(l, ("PipeEndpoint", io))
 #FIXME See https://github.com/JuliaLang/julia/issues/14747
 #      Reading from open(::Command) seems to deadlock on Linux/Travis
 #=
-if !is_windows()
+if !Sys.iswindows()
 
 # Windows type command not working?
 # See "could not spawn `type 'C:\Users\appveyor\AppData\Local\Temp\1\jul3516.tmp\file.txt'`"
@@ -107,7 +107,7 @@ if !is_windows()
 # Pipe
 io = (text) -> begin
     write(filename, text)
-    open(`$(is_windows() ? "type" : "cat") $filename`)[1]
+    open(`$(Sys.iswindows() ? "type" : "cat") $filename`)[1]
 #    Was open(`echo -n $text`)[1]
 #    See https://github.com/JuliaLang/julia/issues/14747
 end
@@ -149,11 +149,11 @@ for (name, f) in l
     @test read(io(), Int) == read(filename,Int)
     s1 = io()
     s2 = IOBuffer(text)
-    @test read(s1, UInt32, 2) == read(s2, UInt32, 2)
+    @test read!(s1, Array{UInt32}(2)) == read!(s2, Array{UInt32}(2))
     @test !eof(s1)
-    @test read(s1, UInt8, 5) == read(s2, UInt8, 5)
+    @test read!(s1, Array{UInt8}(5)) == read!(s2, Array{UInt8}(5))
     @test !eof(s1)
-    @test read(s1, UInt8, 1) == read(s2, UInt8, 1)
+    @test read!(s1, Array{UInt8}(1)) == read!(s2, Array{UInt8}(1))
     @test eof(s1)
     @test_throws EOFError read(s1, UInt8)
     @test eof(s1)
@@ -185,10 +185,10 @@ for (name, f) in l
     ]
         write(filename, text)
 
-        verbose && println("$name readstring...")
-        @test readstring(io()) == text
+        verbose && println("$name read(io, String)...")
+        @test read(io(), String) == text
 
-        @test readstring(io()) == readstring(filename)
+        @test read(io(), String) == read(filename, String)
 
 
         verbose && println("$name read...")
@@ -285,7 +285,7 @@ for (name, f) in l
             cleanup()
         end
         verbose && println("$name seekend...")
-        @test readstring(seekend(io())) == ""
+        @test read(seekend(io()), String) == ""
     end
 
 
@@ -293,11 +293,11 @@ for (name, f) in l
     to = open("$filename.to", "w")
     write(to, io())
     close(to)
-    @test readstring("$filename.to") == text
+    @test read("$filename.to", String) == text
 
     verbose && println("$name write(filename, ...)")
     write("$filename.to", io())
-    @test readstring("$filename.to") == text
+    @test read("$filename.to", String) == text
 
     verbose && println("$name write(::IOBuffer, ...)")
     to = IOBuffer(copy(Vector{UInt8}(text)), false, true)
@@ -415,13 +415,13 @@ 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)
-if !is_windows() && get(ENV, "USER", "") != "root" && get(ENV, "HOME", "") != "/root"
+if !Sys.iswindows() && get(ENV, "USER", "") != "root" && get(ENV, "HOME", "") != "/root"
     # 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)
 else
-    is_windows() || warn("file permissions tests skipped due to running tests as root (not recommended)")
+    Sys.iswindows() || warn("file permissions tests skipped due to running tests as root (not recommended)")
     close(open(f))
 end
 chmod(f, 0o400)
@@ -432,8 +432,8 @@ for i = 1:2
     @test !eof(f2)
     @test position(f1) == 0
     @test position(f2) == 0
-    @test readstring(f1) == readstring(f2) == "abc"
-    @test readstring(f1) == readstring(f2) == ""
+    @test read(f1, String) == read(f2, String) == "abc"
+    @test read(f1, String) == read(f2, String) == ""
     @test position(f1) == 3
     @test position(f2) == 3
     @test eof(f1)
@@ -486,7 +486,7 @@ f2 = Base.Filesystem.open(f, Base.Filesystem.JL_O_RDWR)
 @test !eof(f1)
 @test seekstart(f1) == f1
 @test seekstart(f2) == f2
-@test readstring(f1) == readstring(f2) == "abc\0\0\0\0\0\0\0**"
+@test read(f1, String) == read(f2, String) == "abc\0\0\0\0\0\0\0**"
 close(f1)
 close(f2)
 rm(f)
diff --git a/test/reduce.jl b/test/reduce.jl
index 87bd3361cfe2aa..f64e10081b53c7 100644
--- a/test/reduce.jl
+++ b/test/reduce.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # fold(l|r) & mapfold(l|r)
 @test foldl(+, Int64[]) === Int64(0) # In reference to issues #7465/#20144 (PR #20160)
@@ -22,11 +22,12 @@
 @test foldr(+, Int16[]) === Int32(0)
 @test foldr(-, 1:5) == 3
 @test foldr(-, 10, 1:5) == -7
+@test foldr(+, [1]) == 1 # Issue #21493
 
 @test Base.mapfoldr(abs2, -, 2:5) == -14
 @test Base.mapfoldr(abs2, -, 10, 2:5) == -4
 
-# reduce & mapreduce
+# reduce
 @test reduce(+, Int64[]) === Int64(0) # In reference to issue #20144 (PR #20160)
 @test reduce(+, Int16[]) === Int32(0)
 @test reduce((x,y)->"($x+$y)", 9:11) == "((9+10)+11)"
@@ -34,9 +35,39 @@
 @test reduce(+, 1000, 1:5) == (1000 + 1 + 2 + 3 + 4 + 5)
 @test reduce(+,1) == 1
 
+# mapreduce
 @test mapreduce(-, +, [-10 -9 -3]) == ((10 + 9) + 3)
 @test mapreduce((x)->x[1:3], (x,y)->"($x+$y)", ["abcd", "efgh", "01234"]) == "((abc+efg)+012)"
 
+# mapreduce() for 1- 2- and n-sized blocks (PR #19325)
+@test mapreduce(-, +, [-10]) == 10
+@test mapreduce(abs2, +, [-9, -3]) == 81 + 9
+@test mapreduce(-, +, [-9, -3, -4, 8, -2]) == (9 + 3 + 4 - 8 + 2)
+@test mapreduce(-, +, collect(linspace(1.0, 10000.0, 10000))) == -50005000.0
+# empty mr
+@test mapreduce(abs2, +, Float64[]) === 0.0
+@test mapreduce(abs2, Base.scalarmax, Float64[]) === 0.0
+@test mapreduce(abs, max, Float64[]) === 0.0
+@test mapreduce(abs2, &, Float64[]) === true
+@test mapreduce(abs2, |, Float64[]) === false
+
+# mapreduce() type stability
+@test typeof(mapreduce(*, +, Int8[10])) ===
+      typeof(mapreduce(*, +, Int8[10, 11])) ===
+      typeof(mapreduce(*, +, Int8[10, 11, 12, 13]))
+@test typeof(mapreduce(*, +, Float32[10.0])) ===
+      typeof(mapreduce(*, +, Float32[10, 11])) ===
+      typeof(mapreduce(*, +, Float32[10, 11, 12, 13]))
+# mapreduce() type stability when f supports empty collections
+@test typeof(mapreduce(abs, +, Int8[])) ===
+      typeof(mapreduce(abs, +, Int8[10])) ===
+      typeof(mapreduce(abs, +, Int8[10, 11])) ===
+      typeof(mapreduce(abs, +, Int8[10, 11, 12, 13]))
+@test typeof(mapreduce(abs, +, Float32[])) ===
+      typeof(mapreduce(abs, +, Float32[10])) ===
+      typeof(mapreduce(abs, +, Float32[10, 11])) ===
+      typeof(mapreduce(abs, +, Float32[10, 11, 12, 13]))
+
 # sum
 
 @test sum(Int8[]) === Int32(0)
@@ -146,6 +177,10 @@ prod2(itr) = invoke(prod, Tuple{Any}, itr)
 @test isnan(minimum([NaN]))
 @test isequal(extrema([NaN]), (NaN, NaN))
 
+@test isnan(maximum([NaN, 2.]))
+@test isnan(minimum([NaN, 2.]))
+@test isequal(extrema([NaN, 2.]), (NaN,NaN))
+
 @test isnan(maximum([NaN, 2., 3.]))
 @test isnan(minimum([NaN, 2., 3.]))
 @test isequal(extrema([NaN, 2., 3.]), (NaN,NaN))
@@ -154,6 +189,14 @@ prod2(itr) = invoke(prod, Tuple{Any}, itr)
 @test isnan(minimum([4., 3., NaN, 5., 2.]))
 @test isequal(extrema([4., 3., NaN, 5., 2.]), (NaN,NaN))
 
+ # test long arrays
+@test isnan(maximum([NaN; 1.:10000.]))
+@test isnan(maximum([1.:10000.; NaN]))
+@test isnan(minimum([NaN; 1.:10000.]))
+@test isnan(minimum([1.:10000.; NaN]))
+@test isequal(extrema([1.:10000.; NaN]), (NaN,NaN))
+@test isequal(extrema([NaN; 1.:10000.]), (NaN,NaN))
+
 @test maximum(abs2, 3:7) == 49
 @test minimum(abs2, 3:7) == 9
 
@@ -326,3 +369,6 @@ end
 test18695(r) = sum( t^2 for t in r )
 @test @inferred(test18695([1.0,2.0,3.0,4.0])) == 30.0
 @test_throws ArgumentError test18695(Any[])
+
+# issue #21107
+@test foldr(-,2:2) == 2
diff --git a/test/reducedim.jl b/test/reducedim.jl
index 77a9dc537b5a50..e5d6fb1fcdd541 100644
--- a/test/reducedim.jl
+++ b/test/reducedim.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # main tests
 
@@ -6,14 +6,14 @@ function safe_mapslices(op, A, region)
     newregion = intersect(region, 1:ndims(A))
     return isempty(newregion) ? A : mapslices(op, A, newregion)
 end
-safe_sum{T}(A::Array{T}, region) = safe_mapslices(sum, A, region)
-safe_prod{T}(A::Array{T}, region) = safe_mapslices(prod, A, region)
-safe_maximum{T}(A::Array{T}, region) = safe_mapslices(maximum, A, region)
-safe_minimum{T}(A::Array{T}, region) = safe_mapslices(minimum, A, region)
-safe_sumabs{T}(A::Array{T}, region) = safe_mapslices(sum, abs.(A), region)
-safe_sumabs2{T}(A::Array{T}, region) = safe_mapslices(sum, abs2.(A), region)
-safe_maxabs{T}(A::Array{T}, region) = safe_mapslices(maximum, abs.(A), region)
-safe_minabs{T}(A::Array{T}, region) = safe_mapslices(minimum, abs.(A), region)
+safe_sum(A::Array{T}, region) where {T} = safe_mapslices(sum, A, region)
+safe_prod(A::Array{T}, region) where {T} = safe_mapslices(prod, A, region)
+safe_maximum(A::Array{T}, region) where {T} = safe_mapslices(maximum, A, region)
+safe_minimum(A::Array{T}, region) where {T} = safe_mapslices(minimum, A, region)
+safe_sumabs(A::Array{T}, region) where {T} = safe_mapslices(sum, abs.(A), region)
+safe_sumabs2(A::Array{T}, region) where {T} = safe_mapslices(sum, abs2.(A), region)
+safe_maxabs(A::Array{T}, region) where {T} = safe_mapslices(maximum, abs.(A), region)
+safe_minabs(A::Array{T}, region) where {T} = safe_mapslices(minimum, abs.(A), region)
 
 Areduc = rand(3, 4, 5, 6)
 for region in Any[
diff --git a/test/reflection.jl b/test/reflection.jl
index c1b096859127af..dc8f3d4dd2cb52 100644
--- a/test/reflection.jl
+++ b/test/reflection.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # code_native / code_llvm (issue #8239)
 # It's hard to really test these, but just running them should be
@@ -88,7 +88,7 @@ tag = Base.have_color ? Base.error_color() : "ARRAY{FLOAT64,N}"
 # Make sure emphasis is not used for other functions
 tag = Base.have_color ? Base.error_color() : "ANY"
 iob = IOBuffer()
-show(iob, expand(:(x->x^2)))
+show(iob, expand(Main, :(x -> x^2)))
 str = String(take!(iob))
 @test isempty(search(str, tag))
 
@@ -141,7 +141,7 @@ end
 
 # issue #10165
 i10165(::Type) = 0
-i10165{T,n}(::Type{AbstractArray{T,n}}) = 1
+i10165(::Type{AbstractArray{T,n}}) where {T,n} = 1
 @test i10165(AbstractArray{Int,n} where n) == 0
 @test which(i10165, Tuple{Type{AbstractArray{Int,n} where n},}).sig == Tuple{typeof(i10165),Type}
 
@@ -151,11 +151,11 @@ i10165{T,n}(::Type{AbstractArray{T,n}}) = 1
 
 const a_const = 1
 not_const = 1
-@test isconst(:a_const) == true
+@test isconst(@__MODULE__, :a_const) == true
 @test isconst(Base, :pi) == true
-@test isconst(:pi) == true
-@test isconst(:not_const) == false
-@test isconst(:is_not_defined) == false
+@test isconst(@__MODULE__, :pi) == true
+@test isconst(@__MODULE__, :not_const) == false
+@test isconst(@__MODULE__, :is_not_defined) == false
 
 @test isimmutable(1) == true
 @test isimmutable([]) == false
@@ -163,8 +163,8 @@ not_const = 1
 ## find bindings tests
 @test ccall(:jl_get_module_of_binding, Any, (Any, Any), Base, :sin)==Base
 
-const curmod = current_module()
-const curmod_name = fullname(curmod)
+# For curmod_*
+include("testenv.jl")
 
 module TestMod7648
 using Base.Test
@@ -188,22 +188,21 @@ module TestModSub9475
     b9475 = 7
     foo9475(x) = x
     let
-        @test Base.binding_module(:a9475) == current_module()
-        @test Base.binding_module(:c7648) == TestMod7648
-        @test Base.module_name(current_module()) == :TestModSub9475
-        @test Base.fullname(current_module()) == (curmod_name..., :TestMod7648,
-                                                  :TestModSub9475)
-        @test Base.module_parent(current_module()) == TestMod7648
+        @test Base.binding_module(@__MODULE__, :a9475) == @__MODULE__
+        @test Base.binding_module(@__MODULE__, :c7648) == TestMod7648
+        @test Base.module_name(@__MODULE__) == :TestModSub9475
+        @test Base.fullname(@__MODULE__) == (curmod_name..., :TestMod7648, :TestModSub9475)
+        @test Base.module_parent(@__MODULE__) == TestMod7648
     end
 end # module TestModSub9475
 
 using .TestModSub9475
 
 let
-    @test Base.binding_module(:d7648) == current_module()
-    @test Base.binding_module(:a9475) == TestModSub9475
-    @test Base.module_name(current_module()) == :TestMod7648
-    @test Base.module_parent(current_module()) == curmod
+    @test Base.binding_module(@__MODULE__, :d7648) == @__MODULE__
+    @test Base.binding_module(@__MODULE__, :a9475) == TestModSub9475
+    @test Base.module_name(@__MODULE__) == :TestMod7648
+    @test Base.module_parent(@__MODULE__) == curmod
 end
 end # module TestMod7648
 
@@ -214,18 +213,19 @@ let
     @test Set(names(TestMod7648))==Set([:TestMod7648, :a9475, :foo9475, :c7648, :foo7648, :foo7648_nomethods, :Foo7648])
     @test Set(names(TestMod7648, true)) == Set([:TestMod7648, :TestModSub9475, :a9475, :foo9475, :c7648, :d7648, :f7648,
                                                 :foo7648, Symbol("#foo7648"), :foo7648_nomethods, Symbol("#foo7648_nomethods"),
-                                                :Foo7648, :eval, Symbol("#eval")])
+                                                :Foo7648, :eval, Symbol("#eval"), :include, Symbol("#include")])
     @test Set(names(TestMod7648, true, true)) == Set([:TestMod7648, :TestModSub9475, :a9475, :foo9475, :c7648, :d7648, :f7648,
                                                       :foo7648, Symbol("#foo7648"), :foo7648_nomethods, Symbol("#foo7648_nomethods"),
-                                                      :Foo7648, :eval, Symbol("#eval"), :convert, :curmod_name, :curmod])
+                                                      :Foo7648, :eval, Symbol("#eval"), :include, Symbol("#include"),
+                                                      :convert, :curmod_name, :curmod])
     @test isconst(TestMod7648, :c7648)
     @test !isconst(TestMod7648, :d7648)
 end
 
 let
     using .TestMod7648
-    @test Base.binding_module(:a9475) == TestMod7648.TestModSub9475
-    @test Base.binding_module(:c7648) == TestMod7648
+    @test Base.binding_module(@__MODULE__, :a9475) == TestMod7648.TestModSub9475
+    @test Base.binding_module(@__MODULE__, :c7648) == TestMod7648
     @test Base.function_name(foo7648) == :foo7648
     @test Base.function_module(foo7648, (Any,)) == TestMod7648
     @test Base.function_module(foo7648) == TestMod7648
@@ -254,11 +254,14 @@ 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)
+@test isexported(@__MODULE__, :this_is_not_defined)
+@test !isexported(@__MODULE__, :this_is_not_exported)
 const a_value = 1
-@test which(:a_value) == current_module()
-@test !isexported(current_module(), :a_value)
+@test Base.which_module(@__MODULE__, :a_value) === @__MODULE__
+@test @which(a_value) === @__MODULE__
+@test_throws ErrorException which(:a_value)
+@test which(:Core) === Main
+@test !isexported(@__MODULE__, :a_value)
 end
 
 # issue #13264
@@ -280,7 +283,7 @@ let ex = :(a + b)
     ex.typ = Integer
     @test string(ex) == "(a + b)::Integer"
 end
-foo13825{T, N}(::Array{T,N}, ::Array, ::Vector) = nothing
+foo13825(::Array{T, N}, ::Array, ::Vector) where {T, N} = nothing
 @test startswith(string(first(methods(foo13825))),
                  "foo13825(::Array{T,N}, ::Array, ::Array{T,1} where T)")
 
@@ -290,8 +293,8 @@ mutable struct TLayout
     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)] ==
+@test fieldnames(TLayout) == [:x, :y, :z]
+@test [(fieldoffset(TLayout,i), fieldname(TLayout,i), fieldtype(TLayout,i)) for i = 1:fieldcount(TLayout)] ==
     [(0, :x, Int8), (2, :y, Int16), (4, :z, Int32)]
 @test_throws BoundsError fieldtype(TLayout, 0)
 @test_throws BoundsError fieldname(TLayout, 0)
@@ -304,7 +307,7 @@ tlayout = TLayout(5,7,11)
 @test fieldtype(Tuple{Vararg{Int8}}, 10) === Int8
 @test_throws BoundsError fieldtype(Tuple{Vararg{Int8}}, 0)
 
-@test fieldnames((1,2,3)) == fieldnames(NTuple{3, Int}) == [fieldname(NTuple{3, Int}, i) for i = 1:3] == [1, 2, 3]
+@test fieldnames(NTuple{3, Int}) == [fieldname(NTuple{3, Int}, i) for i = 1:3] == [1, 2, 3]
 @test_throws BoundsError fieldname(NTuple{3, Int}, 0)
 @test_throws BoundsError fieldname(NTuple{3, Int}, 4)
 
@@ -337,7 +340,7 @@ end
         return true
     end
 end
-@test functionloc(f14346)[2] == @__LINE__-4
+@test functionloc(f14346)[2] == @__LINE__() - 4
 
 # test jl_get_llvm_fptr. We test functions both in and definitely not in the system image
 definitely_not_in_sysimg() = nothing
@@ -365,11 +368,11 @@ end
 let
     using .MacroTest
     a = 1
-    m = getfield(current_module(), Symbol("@macrotest"))
-    @test which(m, Tuple{Int,Symbol})==@which @macrotest 1 a
-    @test which(m, Tuple{Int,Int})==@which @macrotest 1 1
+    m = getfield(@__MODULE__, Symbol("@macrotest"))
+    @test which(m, Tuple{LineNumberNode, Module, Int, Symbol}) == @which @macrotest 1 a
+    @test which(m, Tuple{LineNumberNode, Module, Int, Int}) == @which @macrotest 1 1
 
-    @test first(methods(m,Tuple{Int, Int}))==@which MacroTest.@macrotest 1 1
+    @test first(methods(m, Tuple{LineNumberNode, Module, Int, Int})) == @which MacroTest.@macrotest 1 1
     @test functionloc(@which @macrotest 1 1) == @functionloc @macrotest 1 1
 end
 
@@ -392,7 +395,7 @@ end
 
 used_dup_var_tested15714 = false
 used_unique_var_tested15714 = false
-function test_typed_ast_printing(f::ANY, types::ANY, must_used_vars)
+function test_typed_ast_printing(Base.@nospecialize(f), Base.@nospecialize(types), must_used_vars)
     src, rettype = code_typed(f, types)[1]
     dupnames = Set()
     slotnames = Set()
@@ -498,9 +501,9 @@ fLargeTable() = 4
 @test length(methods(fLargeTable, Tuple{})) == 1
 @test fLargeTable(1im, 2im) == 4
 @test fLargeTable(1.0im, 2.0im) == 5
-@test_throws MethodError fLargeTable(Val{1}(), Val{1}())
-@test fLargeTable(Val{1}(), 1) == 1
-@test fLargeTable(1, Val{1}()) == 2
+@test_throws MethodError fLargeTable(Val(1), Val(1))
+@test fLargeTable(Val(1), 1) == 1
+@test fLargeTable(1, Val(1)) == 2
 
 # issue #15280
 function f15280(x) end
@@ -543,7 +546,7 @@ function has_backslashes(meth::Method)
 end
 has_backslashes(x) = Nullable{Method}()
 h16850 = has_backslashes(Base)
-if is_windows()
+if Sys.iswindows()
     if isnull(h16850)
         warn("No methods found in Base with backslashes in file name, ",
              "skipping test for Base.url")
@@ -646,3 +649,44 @@ struct B20086{T,N} <: A20086{T,N} end
 @test subtypes(A20086{Int}) == [B20086{Int}]
 @test subtypes(A20086{T,3} where T) == [B20086{T,3} where T]
 @test subtypes(A20086{Int,3}) == [B20086{Int,3}]
+
+# sizeof and nfields
+@test sizeof(Int16) == 2
+@test sizeof(Complex128) == 16
+primitive type ParameterizedByte__{A,B} 8 end
+@test sizeof(ParameterizedByte__) == 1
+@test sizeof(nothing) == 0
+@test sizeof(()) == 0
+struct TypeWithIrrelevantParameter{T}
+    x::Int32
+end
+@test sizeof(TypeWithIrrelevantParameter) == sizeof(Int32)
+@test sizeof(TypeWithIrrelevantParameter{Int8}) == sizeof(Int32)
+@test sizeof(:abc) == 3
+@test sizeof(Symbol("")) == 0
+@test_throws(ErrorException("argument is an abstract type; size is indeterminate"),
+             sizeof(Real))
+@test_throws ErrorException sizeof(Union{Complex64,Complex128})
+@test_throws ErrorException sizeof(Union{Int8,UInt8})
+@test_throws ErrorException sizeof(AbstractArray)
+@test_throws ErrorException sizeof(Tuple)
+@test_throws ErrorException sizeof(Tuple{Any,Any})
+@test_throws ErrorException sizeof(String)
+@test_throws ErrorException sizeof(Vector{Int})
+@test_throws ErrorException sizeof(Symbol)
+@test_throws ErrorException sizeof(SimpleVector)
+
+@test nfields((1,2)) == 2
+@test nfields(()) == 0
+@test nfields(nothing) == fieldcount(Void) == 0
+@test nfields(1) == 0
+@test fieldcount(Union{}) == 0
+@test fieldcount(Tuple{Any,Any,T} where T) == 3
+@test fieldcount(Complex) == fieldcount(Complex64) == 2
+@test fieldcount(Union{Complex64,Complex128}) == 2
+@test fieldcount(Int) == 0
+@test_throws(ErrorException("type does not have a definite number of fields"),
+             fieldcount(Union{Complex,Pair}))
+@test_throws ErrorException fieldcount(Real)
+@test_throws ErrorException fieldcount(AbstractArray)
+@test_throws ErrorException fieldcount(Tuple{Any,Vararg{Any}})
diff --git a/test/regex.jl b/test/regex.jl
index 636c25da954a73..6171e5846ffa8d 100644
--- a/test/regex.jl
+++ b/test/regex.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 function collect_eachmatch(re, str, overlap=false)
     [m.match for m in collect(eachmatch(re, str, overlap))]
@@ -29,7 +29,7 @@ match(pat, target)
 # Issue 9545 (32 bit)
 buf = PipeBuffer()
 show(buf, r"")
-@test readstring(buf) == "r\"\""
+@test read(buf, String) == "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 ec48afc3e3e4fc..4b9bb13644cb0a 100644
--- a/test/repl.jl
+++ b/test/repl.jl
@@ -1,8 +1,7 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
-const curmod = current_module()
-const curmod_name = fullname(curmod)
-const curmod_prefix = "$(["$m." for m in curmod_name]...)"
+# For curmod_*
+include("testenv.jl")
 
 # REPL tests
 isdefined(Main, :TestHelpers) || @eval Main include(joinpath(dirname(@__FILE__), "TestHelpers.jl"))
@@ -32,7 +31,7 @@ ccall(:jl_exit_on_sigint, Void, (Cint,), 0)
 # in the mix. If verification needs to be done, keep it to the bare minimum. Basically
 # this should make sure nothing crashes without depending on how exactly the control
 # characters are being used.
-if !is_windows() || Sys.windows_version() >= Sys.WINDOWS_VISTA_VER
+if !Sys.iswindows() || Sys.windows_version() >= Sys.WINDOWS_VISTA_VER
     stdin_write, stdout_read, stderr_read, repl = fake_repl()
 
     repl.specialdisplay = Base.REPL.REPLDisplay(repl)
@@ -101,12 +100,54 @@ if !is_windows() || Sys.windows_version() >= Sys.WINDOWS_VISTA_VER
     cd(origpwd)
 
     # issue #20482
-    if !is_windows()
+    if !Sys.iswindows()
         write(stdin_write, ";")
         readuntil(stdout_read, "shell> ")
         write(stdin_write, "echo hello >/dev/null\n")
-        readuntil(stdout_read, "\n")
-        readuntil(stdout_read, "\n")
+        let s = readuntil(stdout_read, "\n")
+            @test contains(s, "shell> ") # make sure we echoed the prompt
+            @test contains(s, "echo hello >/dev/null") # make sure we echoed the input
+        end
+        @test readuntil(stdout_read, "\n") == "\e[0m\n"
+    end
+
+    # issue #20771
+    let s
+        write(stdin_write, ";")
+        readuntil(stdout_read, "shell> ")
+        write(stdin_write, "'\n") # invalid input
+        s = readuntil(stdout_read, "\n")
+        @test contains(s, "shell> ") # check for the echo of the prompt
+        @test contains(s, "'") # check for the echo of the input
+        s = readuntil(stdout_read, "\n\n")
+        @test startswith(s, "\e[0mERROR: unterminated single quote\nStacktrace:\n [1] ") ||
+              startswith(s, "\e[0m\e[1m\e[91mERROR: \e[39m\e[22m\e[91munterminated single quote\e[39m\nStacktrace:\n [1] ")
+    end
+
+    # issues #22176 & #20482
+    # TODO: figure out how to test this on Windows
+    Sys.iswindows() || let tmp = tempname()
+        try
+            write(stdin_write, ";")
+            readuntil(stdout_read, "shell> ")
+            write(stdin_write, "echo \$123 >$tmp\n")
+            let s = readuntil(stdout_read, "\n")
+                @test contains(s, "shell> ") # make sure we echoed the prompt
+                @test contains(s, "echo \$123 >$tmp") # make sure we echoed the input
+            end
+            @test readuntil(stdout_read, "\n") == "\e[0m\n"
+            @test read(tmp, String) == "123\n"
+        finally
+            rm(tmp, force=true)
+        end
+    end
+
+    # Issue #7001
+    # Test ignoring '\0'
+    let
+        write(stdin_write, "\0\n")
+        s = readuntil(stdout_read, "\n\n")
+        @test !contains(s, "invalid character")
     end
 
     # Test that accepting a REPL result immediately shows up, not
@@ -121,6 +162,7 @@ if !is_windows() || Sys.windows_version() >= Sys.WINDOWS_VISTA_VER
     # yield make sure this got processed
     readuntil(stdout_read, "1+1")
     close(t)
+    readuntil(stdout_read, "\n\n")
 
     # Issue #10222
     # Test ignoring insert key in standard and prefix search modes
@@ -167,14 +209,14 @@ end
 function buffercontents(buf::IOBuffer)
     p = position(buf)
     seek(buf,0)
-    c = readstring(buf)
+    c = read(buf, String)
     seek(buf,p)
     c
 end
 
-function AddCustomMode(repl)
+function AddCustomMode(repl, prompt)
     # Custom REPL mode tests
-    foobar_mode = LineEdit.Prompt("TestΠ";
+    foobar_mode = LineEdit.Prompt(prompt;
         prompt_prefix="\e[38;5;166m",
         prompt_suffix=Base.text_colors[:white],
         on_enter = s->true,
@@ -226,6 +268,9 @@ fakehistory = """
 # time: 2014-06-30 17:32:59 EDT
 # mode: shell
 \tll
+# time: 2014-06-30 99:99:99 EDT
+# mode: julia
+\tx ΔxΔ
 # time: 2014-06-30 17:32:49 EDT
 # mode: julia
 \t1 + 1
@@ -244,7 +289,7 @@ fakehistory = """
 """
 
 # Test various history related issues
-begin
+for prompt = ["TestΠ", () -> randstring(rand(1:10))]
     stdin_write, stdout_read, stdout_read, repl = fake_repl()
     # In the future if we want we can add a test that the right object
     # gets displayed by intercepting the display
@@ -291,6 +336,26 @@ begin
     @test LineEdit.mode(s) == repl_mode
     @test buffercontents(LineEdit.buffer(s)) == "wip"
     @test position(LineEdit.buffer(s)) == 3
+    LineEdit.history_next(s, hp)
+    @test buffercontents(LineEdit.buffer(s)) == "wip"
+    LineEdit.history_prev(s, hp, 2)
+    @test LineEdit.mode(s) == shell_mode
+    @test buffercontents(LineEdit.buffer(s)) == "ls"
+    LineEdit.history_prev(s, hp, -2) # equivalent to history_next(s, hp, 2)
+    @test LineEdit.mode(s) == repl_mode
+    @test buffercontents(LineEdit.buffer(s)) == "2 + 2"
+    LineEdit.history_next(s, hp, -2) # equivalent to history_prev(s, hp, 2)
+    @test LineEdit.mode(s) == shell_mode
+    @test buffercontents(LineEdit.buffer(s)) == "ls"
+    LineEdit.history_first(s, hp)
+    @test LineEdit.mode(s) == repl_mode
+    @test buffercontents(LineEdit.buffer(s)) == "é"
+    LineEdit.history_next(s, hp, 6)
+    @test LineEdit.mode(s) == shell_mode
+    @test buffercontents(LineEdit.buffer(s)) == "ls"
+    LineEdit.history_last(s, hp)
+    @test buffercontents(LineEdit.buffer(s)) == "wip"
+    @test position(LineEdit.buffer(s)) == 3
     LineEdit.move_line_start(s)
     @test position(LineEdit.buffer(s)) == 0
 
@@ -347,6 +412,8 @@ begin
     LineEdit.enter_search(s, histp, true)
     write(ss.query_buffer, "l")
     LineEdit.update_display_buffer(ss, ss)
+    @test buffercontents(ss.response_buffer) == "ll"
+    @test position(ss.response_buffer) == 1
     write(ss.query_buffer, "l")
     LineEdit.update_display_buffer(ss, ss)
     LineEdit.accept_result(s, histp)
@@ -391,7 +458,7 @@ begin
 
     # Test that new modes can be dynamically added to the REPL and will
     # integrate nicely
-    foobar_mode, custom_histp = AddCustomMode(repl)
+    foobar_mode, custom_histp = AddCustomMode(repl, prompt)
 
     # ^R l, should now find `ls` in foobar mode
     LineEdit.enter_search(s, histp, true)
@@ -410,6 +477,20 @@ begin
     @test LineEdit.input_string(ps) == "ls"
     @test position(LineEdit.buffer(s)) == 1
 
+    # Some Unicode handling testing
+    LineEdit.history_prev(s, hp)
+    LineEdit.enter_search(s, histp, true)
+    write(ss.query_buffer, "x")
+    LineEdit.update_display_buffer(ss, ss)
+    @test buffercontents(ss.response_buffer) == "x ΔxΔ"
+    @test position(ss.response_buffer) == 4
+    write(ss.query_buffer, " ")
+    LineEdit.update_display_buffer(ss, ss)
+    LineEdit.accept_result(s, histp)
+    @test LineEdit.mode(s) == repl_mode
+    @test buffercontents(LineEdit.buffer(s)) == "x ΔxΔ"
+    @test position(LineEdit.buffer(s)) == 0
+
     # Try entering search mode while in custom repl mode
     LineEdit.enter_search(s, custom_histp, true)
 end
@@ -473,7 +554,7 @@ begin
 end
 
 # Simple non-standard REPL tests
-if !is_windows() || Sys.windows_version() >= Sys.WINDOWS_VISTA_VER
+if !Sys.iswindows() || Sys.windows_version() >= Sys.WINDOWS_VISTA_VER
     stdin_write, stdout_read, stdout_read, repl = fake_repl()
     panel = LineEdit.Prompt("testπ";
         prompt_prefix="\e[38;5;166m",
@@ -518,7 +599,7 @@ ccall(:jl_exit_on_sigint, Void, (Cint,), 1)
 let exename = Base.julia_cmd()
 
 # Test REPL in dumb mode
-if !is_windows()
+if !Sys.iswindows()
     TestHelpers.with_fake_pty() do slave, master
         nENV = copy(ENV)
         nENV["TERM"] = "dumb"
@@ -539,17 +620,17 @@ if !is_windows()
 end
 
 # Test stream mode
-if !is_windows() || Sys.windows_version() >= Sys.WINDOWS_VISTA_VER
+if !Sys.iswindows() || Sys.windows_version() >= Sys.WINDOWS_VISTA_VER
     outs, ins, p = readandwrite(`$exename --startup-file=no --quiet`)
     write(ins,"1\nquit()\n")
-    @test readstring(outs) == "1\n"
+    @test read(outs, String) == "1\n"
 end
 end # let exename
 
 # issue #19864:
 mutable struct Error19864 <: Exception; end
 function test19864()
-    @eval current_module() Base.showerror(io::IO, e::Error19864) = print(io, "correct19864")
+    @eval Base.showerror(io::IO, e::Error19864) = print(io, "correct19864")
     buf = IOBuffer()
     REPL.print_response(buf, Error19864(), [], false, false, nothing)
     return String(take!(buf))
@@ -582,3 +663,134 @@ function test_replinit()
     copy!(Base.repl_hooks, saved_replinit)
 end
 test_replinit()
+
+let ends_with_semicolon = Base.REPL.ends_with_semicolon
+    @test !ends_with_semicolon("")
+    @test ends_with_semicolon(";")
+    @test !ends_with_semicolon("a")
+    @test ends_with_semicolon("1;")
+    @test ends_with_semicolon("1;\n")
+    @test ends_with_semicolon("1;\r")
+    @test ends_with_semicolon("1;\r\n   \t\f")
+    @test ends_with_semicolon("1;#text\n")
+    @test ends_with_semicolon("a; #=#=# =# =#\n")
+    @test !ends_with_semicolon("begin\na;\nb;\nend")
+    @test !ends_with_semicolon("begin\na; #=#=#\n=#b=#\nend")
+    @test ends_with_semicolon("\na; #=#=#\n=#b=#\n# test\n#=\nfoobar\n=##bazbax\n")
+end
+
+# PR #20794, TTYTerminal with other kinds of streams
+let term = Base.Terminals.TTYTerminal("dumb",IOBuffer("1+2\n"),IOBuffer(),IOBuffer())
+    r = Base.REPL.BasicREPL(term)
+    REPL.run_repl(r)
+    @test String(take!(term.out_stream)) == "julia> 3\n\njulia> \n"
+end
+
+
+# a small module for alternative keymap tests
+module AltLE
+import Base: LineEdit, REPL
+
+function history_move_prefix(s::LineEdit.MIState,
+                             hist::REPL.REPLHistoryProvider,
+                             backwards::Bool)
+    buf = LineEdit.buffer(s)
+    pos = position(buf)
+    prefix = REPL.beforecursor(buf)
+    allbuf = String(take!(copy(buf)))
+    cur_idx = hist.cur_idx
+    # when searching forward, start at last_idx
+    if !backwards && hist.last_idx > 0
+        cur_idx = hist.last_idx
+    end
+    hist.last_idx = -1
+    idxs = backwards ? ((cur_idx-1):-1:1) : ((cur_idx+1):length(hist.history))
+    for idx in idxs
+        if startswith(hist.history[idx], prefix) && hist.history[idx] != allbuf
+            REPL.history_move(s, hist, idx)
+            seek(LineEdit.buffer(s), pos)
+            LineEdit.refresh_line(s)
+            return :ok
+        end
+    end
+    REPL.Terminals.beep(LineEdit.terminal(s))
+end
+history_next_prefix(s::LineEdit.MIState, hist::REPL.REPLHistoryProvider) =
+    history_move_prefix(s, hist, false)
+history_prev_prefix(s::LineEdit.MIState, hist::REPL.REPLHistoryProvider) =
+    history_move_prefix(s, hist, true)
+
+end # module
+
+# Test alternative keymaps and prompt
+# (Alt. keymaps may be passed as a Vector{<:Dict} or as a Dict)
+
+const altkeys = [Dict{Any,Any}("\e[A" => (s,o...)->(LineEdit.edit_move_up(s) || LineEdit.history_prev(s, LineEdit.mode(s).hist))), # Up Arrow
+                 Dict{Any,Any}("\e[B" => (s,o...)->(LineEdit.edit_move_down(s) || LineEdit.history_next(s, LineEdit.mode(s).hist))), # Down Arrow
+                 Dict{Any,Any}("\e[5~" => (s,o...)->(AltLE.history_prev_prefix(s, LineEdit.mode(s).hist))), # Page Up
+                 Dict{Any,Any}("\e[6~" => (s,o...)->(AltLE.history_next_prefix(s, LineEdit.mode(s).hist))), # Page Down
+                ]
+
+
+if !Sys.iswindows() || Sys.windows_version() >= Sys.WINDOWS_VISTA_VER
+    for keys = [altkeys, merge(altkeys...)],
+            altprompt = ["julia-$(VERSION.major).$(VERSION.minor)> ",
+                         () -> "julia-$(Base.GIT_VERSION_INFO.commit_short)"]
+        histfile = tempname()
+        try
+            stdin_write, stdout_read, stderr_read, repl = fake_repl()
+
+            repl.specialdisplay = Base.REPL.REPLDisplay(repl)
+            repl.history_file = true
+            withenv("JULIA_HISTORY" => histfile) do
+                repl.interface = REPL.setup_interface(repl, extra_repl_keymap = altkeys)
+            end
+            repl.interface.modes[1].prompt = altprompt
+
+            repltask = @async begin
+                Base.REPL.run_repl(repl)
+            end
+
+            sendrepl3(cmd) = write(stdin_write,"$cmd\n")
+
+            sendrepl3("1 + 1;")                        # a simple line
+            sendrepl3("multi=2;\e\nline=2;")           # a multiline input
+            sendrepl3("ignoreme\e[A\b\b3;\e[B\b\b1;")  # edit the previous multiline input
+            sendrepl3("1 +\e[5~\b*")                   # use prefix search to edit the 1st input
+
+            # Close REPL ^D
+            write(stdin_write, '\x04')
+            wait(repltask)
+
+            # Close the history file
+            # (otherwise trying to delete it fails on Windows)
+            close(repl.interface.modes[1].hist.history_file)
+
+            # Check that the correct prompt was displayed
+            output = readuntil(stdout_read, "1 * 1;")
+            @test !isempty(search(output, LineEdit.prompt_string(altprompt)))
+            @test isempty(search(output, "julia> "))
+
+            # Check the history file
+            history = read(histfile, String)
+            @test ismatch(r"""
+                          ^\#\ time:\ .*\n
+                           \#\ mode:\ julia\n
+                           \t1\ \+\ 1;\n
+                           \#\ time:\ .*\n
+                           \#\ mode:\ julia\n
+                           \tmulti=2;\n
+                           \tline=2;\n
+                           \#\ time:\ .*\n
+                           \#\ mode:\ julia\n
+                           \tmulti=3;\n
+                           \tline=1;\n
+                           \#\ time:\ .*\n
+                           \#\ mode:\ julia\n
+                           \t1\ \*\ 1;\n$
+                          """xm, history)
+        finally
+            rm(histfile, force=true)
+        end
+    end
+end
diff --git a/test/replcompletions.jl b/test/replcompletions.jl
index 1fdebef6872f50..6f658a168d7094 100644
--- a/test/replcompletions.jl
+++ b/test/replcompletions.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base.REPLCompletions
 
@@ -29,9 +29,9 @@ ex = quote
     Base.keys(d::CustomDict) = collect(keys(d.mydict))
     Base.length(d::CustomDict) = length(d.mydict)
 
-    test{T<:Real}(x::T, y::T) = pass
+    test(x::T, y::T) where {T<:Real} = pass
     test(x::Real, y::Real) = pass
-    test{T<:Real}(x::AbstractArray{T}, y) = pass
+    test(x::AbstractArray{T}, y) where {T<:Real} = pass
     test(args...) = pass
 
     test1(x::Type{Float64}) = pass
@@ -67,6 +67,7 @@ ex = quote
     end
     test_repl_comp_dict = CompletionFoo.test_dict
     test_repl_comp_customdict = CompletionFoo.test_customdict
+    test_dict_ℂ = Dict(1=>2)
 end
 ex.head = :toplevel
 eval(Main, ex)
@@ -359,17 +360,17 @@ c, r, res = test_complete(s)
 @test contains(c[1], "x, y, w...")
 
 # Test of inference based getfield completion
-s = "\"\"."
+s = "(1+2im)."
 c,r = test_complete(s)
-@test length(c)==1
+@test length(c)==2
 @test r == (endof(s)+1):endof(s)
-@test c[1] == "len"
+@test c == ["im","re"]
 
-s = "(\"\"*\"\")."
+s = "((1+2im))."
 c,r = test_complete(s)
-@test length(c)==1
+@test length(c)==2
 @test r == (endof(s)+1):endof(s)
-@test c[1] == "len"
+@test c == ["im","re"]
 
 s = "CompletionFoo.test_y_array[1]."
 c,r = test_complete(s)
@@ -471,7 +472,7 @@ c, r, res = test_scomplete(s)
 # which would raise an error in the repl code.
 @test (String[], 0:-1, false) == test_scomplete("\$a")
 
-if is_unix()
+if Sys.isunix()
     #Assume that we can rely on the existence and accessibility of /tmp
 
     # Tests path in Julia code and closing " if it's a file
@@ -622,12 +623,12 @@ let #test that it can auto complete with spaces in file/path
     mkdir(dir)
     cd(path) do
         open(joinpath(space_folder, "space .file"),"w") do f
-            s = is_windows() ? "rm $dir_space\\\\space" : "cd $dir_space/space"
+            s = Sys.iswindows() ? "rm $dir_space\\\\space" : "cd $dir_space/space"
             c,r = test_scomplete(s)
             @test r == endof(s)-4:endof(s)
             @test "space\\ .file" in c
 
-            s = is_windows() ? "cd(\"β $dir_space\\\\space" : "cd(\"β $dir_space/space"
+            s = Sys.iswindows() ? "cd(\"β $dir_space\\\\space" : "cd(\"β $dir_space/space"
             c,r = test_complete(s)
             @test r == endof(s)-4:endof(s)
             @test "space\\ .file\"" in c
@@ -645,7 +646,7 @@ end
 c,r = test_complete("cd(\"folder_do_not_exist_77/file")
 @test length(c) == 0
 
-if is_windows()
+if Sys.iswindows()
     tmp = tempname()
     path = dirname(tmp)
     file = basename(tmp)
@@ -748,3 +749,6 @@ test_dict_completion("CompletionFoo.test_dict")
 test_dict_completion("CompletionFoo.test_customdict")
 test_dict_completion("test_repl_comp_dict")
 test_dict_completion("test_repl_comp_customdict")
+
+# Issue #23004: this should not throw:
+@test REPLCompletions.dict_identifier_key("test_dict_ℂ[\\", :other) isa Tuple
diff --git a/test/replutil.jl b/test/replutil.jl
index aa113c5258a242..7049511f1ae527 100644
--- a/test/replutil.jl
+++ b/test/replutil.jl
@@ -1,9 +1,7 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
-const curmod = current_module()
-const curmod_name = fullname(curmod)
-const curmod_str = curmod === Main ? "Main" : join(curmod_name, ".")
-const curmod_prefix = "$(["$m." for m in curmod_name]...)"
+# For curmod_*
+include("testenv.jl")
 
 function test_have_color(buf, color, no_color)
     if Base.have_color
@@ -14,12 +12,13 @@ function test_have_color(buf, color, no_color)
 end
 
 cfile = " at $(@__FILE__):"
-c1line = @__LINE__ + 1
+c1line = @__LINE__() + 1
 method_c1(x::Float64, s::AbstractString...) = true
 
 buf = IOBuffer()
 Base.show_method_candidates(buf, Base.MethodError(method_c1,(1, 1, "")))
 no_color = "\nClosest candidates are:\n  method_c1(!Matched::Float64, !Matched::AbstractString...)$cfile$c1line"
+@test length(methods(method_c1)) <= 3 # because of '...' in candidate printing
 test_have_color(buf,
                 "\e[0m\nClosest candidates are:\n  method_c1(\e[1m\e[31m::Float64\e[0m, \e[1m\e[31m::AbstractString...\e[0m)$cfile$c1line\e[0m",
                 no_color)
@@ -53,14 +52,14 @@ method_c2(x::Int32, args...) = true
 method_c2(x::Int32, y::Float64, args...) = true
 method_c2(x::Int32, y::Float64) = true
 method_c2(x::Int32, y::Int32, z::Int32) = true
-method_c2{T<:Real}(x::T, y::T, z::T) = true
+method_c2(x::T, y::T, z::T) where {T<:Real} = true
 
 Base.show_method_candidates(buf, Base.MethodError(method_c2,(1., 1., 2)))
 color = "\e[0m\nClosest candidates are:\n  method_c2(\e[1m\e[31m::Int32\e[0m, ::Float64, ::Any...)$cfile$(c2line+2)\n  method_c2(\e[1m\e[31m::Int32\e[0m, ::Any...)$cfile$(c2line+1)\n  method_c2(::T<:Real, ::T<:Real, \e[1m\e[31m::T<:Real\e[0m)$cfile$(c2line+5)\n  ...\e[0m"
 no_color = no_color = "\nClosest candidates are:\n  method_c2(!Matched::Int32, ::Float64, ::Any...)$cfile$(c2line+2)\n  method_c2(!Matched::Int32, ::Any...)$cfile$(c2line+1)\n  method_c2(::T<:Real, ::T<:Real, !Matched::T<:Real) where T<:Real$cfile$(c2line+5)\n  ..."
 test_have_color(buf, color, no_color)
 
-c3line = @__LINE__ + 1
+c3line = @__LINE__() + 1
 method_c3(x::Float64, y::Float64) = true
 Base.show_method_candidates(buf, Base.MethodError(method_c3,(1.,)))
 color = "\e[0m\nClosest candidates are:\n  method_c3(::Float64, \e[1m\e[31m::Float64\e[0m)$cfile$c3line\e[0m"
@@ -76,7 +75,7 @@ test_have_color(buf,
     "\e[0m\nClosest candidates are:\n  method_c4(::AbstractString)$cfile$(c4line+2)\n  method_c4()$cfile$(c4line+1)\e[0m",
     "\nClosest candidates are:\n  method_c4(::AbstractString)$cfile$(c4line+2)\n  method_c4()$cfile$(c4line+1)")
 
-c5line = @__LINE__ + 1
+c5line = @__LINE__() + 1
 method_c5(::Type{Float64}) = true
 Base.show_method_candidates(buf, MethodError(method_c5,(Float64,)))
 test_have_color(buf, "\e[0m\nClosest candidates are:\n  method_c5(::Type{Float64})$cfile$c5line\e[0m",
@@ -93,21 +92,21 @@ for f in [getindex, setindex!]
     test_have_color(buf, "", "")
 end
 
-PR16155line = @__LINE__ + 2
+PR16155line = @__LINE__() + 2
 mutable struct PR16155
     a::Int64
     b
 end
-PR16155line2 = @__LINE__ + 1
-(::Type{T}){T<:PR16155}(arg::Any) = "replace call-to-convert method from sysimg"
+PR16155line2 = @__LINE__() + 1
+(::Type{T})(arg::Any) where {T<:PR16155} = "replace call-to-convert method from sysimg"
 
 Base.show_method_candidates(buf, MethodError(PR16155,(1.0, 2.0, Int64(3))))
-test_have_color(buf, "\e[0m\nClosest candidates are:\n  $(curmod_prefix)PR16155(::Any, ::Any)$cfile$PR16155line\n  $(curmod_prefix)PR16155(\e[1m\e[31m::Int64\e[0m, ::Any)$cfile$PR16155line\n  $(curmod_prefix)PR16155(::Any) where T<:$(curmod_prefix)PR16155$cfile$PR16155line2\n  ...\e[0m",
-                     "\nClosest candidates are:\n  $(curmod_prefix)PR16155(::Any, ::Any)$cfile$PR16155line\n  $(curmod_prefix)PR16155(!Matched::Int64, ::Any)$cfile$PR16155line\n  $(curmod_prefix)PR16155(::Any) where T<:$(curmod_prefix)PR16155$cfile$PR16155line2\n  ...")
+test_have_color(buf, "\e[0m\nClosest candidates are:\n  $(curmod_prefix)PR16155(::Any, ::Any)$cfile$PR16155line\n  $(curmod_prefix)PR16155(\e[1m\e[31m::Int64\e[0m, ::Any)$cfile$PR16155line\n  $(curmod_prefix)PR16155(::Any) where T<:$(curmod_prefix)PR16155$cfile$PR16155line2\e[0m",
+                     "\nClosest candidates are:\n  $(curmod_prefix)PR16155(::Any, ::Any)$cfile$PR16155line\n  $(curmod_prefix)PR16155(!Matched::Int64, ::Any)$cfile$PR16155line\n  $(curmod_prefix)PR16155(::Any) where T<:$(curmod_prefix)PR16155$cfile$PR16155line2")
 
 Base.show_method_candidates(buf, MethodError(PR16155,(Int64(3), 2.0, Int64(3))))
-test_have_color(buf, "\e[0m\nClosest candidates are:\n  $(curmod_prefix)PR16155(::Int64, ::Any)$cfile$PR16155line\n  $(curmod_prefix)PR16155(::Any, ::Any)$cfile$PR16155line\n  $(curmod_prefix)PR16155(::Any) where T<:$(curmod_prefix)PR16155$cfile$PR16155line2\n  ...\e[0m",
-                     "\nClosest candidates are:\n  $(curmod_prefix)PR16155(::Int64, ::Any)$cfile$PR16155line\n  $(curmod_prefix)PR16155(::Any, ::Any)$cfile$PR16155line\n  $(curmod_prefix)PR16155(::Any) where T<:$(curmod_prefix)PR16155$cfile$PR16155line2\n  ...")
+test_have_color(buf, "\e[0m\nClosest candidates are:\n  $(curmod_prefix)PR16155(::Int64, ::Any)$cfile$PR16155line\n  $(curmod_prefix)PR16155(::Any, ::Any)$cfile$PR16155line\n  $(curmod_prefix)PR16155(::Any) where T<:$(curmod_prefix)PR16155$cfile$PR16155line2\e[0m",
+                     "\nClosest candidates are:\n  $(curmod_prefix)PR16155(::Int64, ::Any)$cfile$PR16155line\n  $(curmod_prefix)PR16155(::Any, ::Any)$cfile$PR16155line\n  $(curmod_prefix)PR16155(::Any) where T<:$(curmod_prefix)PR16155$cfile$PR16155line2")
 
 c6line = @__LINE__
 method_c6(; x=1) = x
@@ -147,12 +146,12 @@ else
     @test contains(error_out3, "method_c6_in_module(::Any; y)$cfile$(c6mline + 3) got unsupported keyword argument \"x\"")
 end
 
-c7line = @__LINE__ + 1
+c7line = @__LINE__() + 1
 method_c7(a, b; kargs...) = a
 Base.show_method_candidates(buf, MethodError(method_c7, (1, 1)), [(:x, 1), (:y, 2)])
 test_have_color(buf, "\e[0m\nClosest candidates are:\n  method_c7(::Any, ::Any; kargs...)$cfile$c7line\e[0m",
                      "\nClosest candidates are:\n  method_c7(::Any, ::Any; kargs...)$cfile$c7line")
-c8line = @__LINE__ + 1
+c8line = @__LINE__() + 1
 method_c8(a, b; y=1, w=1) = a
 Base.show_method_candidates(buf, MethodError(method_c8, (1, 1)), [(:x, 1), (:y, 2), (:z, 1), (:w, 1)])
 test_have_color(buf, "\e[0m\nClosest candidates are:\n  method_c8(::Any, ::Any; y, w)$cfile$c8line\e[1m\e[31m got unsupported keyword arguments \"x\", \"z\"\e[0m\e[0m",
@@ -183,13 +182,14 @@ macro except_str(expr, err_type)
 end
 
 macro except_strbt(expr, err_type)
+    errmsg = "expected failure, but no exception thrown for $expr"
     return quote
         let err = nothing
             try
                 $(esc(expr))
             catch err
             end
-            err === nothing && error("expected failure, but no exception thrown")
+            err === nothing && error($errmsg)
             @test typeof(err) === $(esc(err_type))
             buf = IOBuffer()
             showerror(buf, err, catch_backtrace())
@@ -252,20 +252,19 @@ let
     @test contains(err_str, "column vector")
 end
 
-abstract type T11007 end
-let
-    err_str = @except_str T11007() MethodError
-    @test contains(err_str, "no method matching $(curmod_prefix)T11007()")
-end
-
 struct TypeWithIntParam{T <: Integer} end
 let undefvar
     err_str = @except_strbt sqrt(-1) DomainError
-    @test contains(err_str, "Try sqrt(complex(x)).")
+    @test contains(err_str, "Try sqrt(Complex(x)).")
     err_str = @except_strbt 2^(-1) DomainError
-    @test contains(err_str, "Cannot raise an integer x to a negative power -n")
+    @test contains(err_str, "Cannot raise an integer x to a negative power -1")
     err_str = @except_strbt (-1)^0.25 DomainError
     @test contains(err_str, "Exponentiation yielding a complex result requires a complex argument")
+    A = zeros(10, 10)
+    A[2,1] = 1
+    A[1,2] = -1
+    err_str = @except_strbt eigmax(A) DomainError
+    @test contains(err_str, "DomainError with [0.0 -1.0 …")
 
     err_str = @except_str (1, 2, 3)[4] BoundsError
     @test err_str == "BoundsError: attempt to access (1, 2, 3)\n  at index [4]"
@@ -278,17 +277,17 @@ let undefvar
     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"
+    @test err_str == "TypeError: in typeassert, expected AbstractFloat, got $Int"
     err_str = @except_str 0::7 TypeError
-    @test err_str == "TypeError: typeassert: expected Type, got $Int"
+    @test err_str == "TypeError: in typeassert, expected Type, got $Int"
     err_str = @except_str "" <: AbstractString TypeError
-    @test err_str == "TypeError: issubtype: expected Type, got String"
+    @test err_str == "TypeError: in <:, expected Type, got String"
     err_str = @except_str AbstractString <: "" TypeError
-    @test err_str == "TypeError: issubtype: expected Type, got String"
+    @test err_str == "TypeError: in <:, expected Type, got String"
     err_str = @except_str Type{""} TypeError
-    @test err_str == "TypeError: Type: in parameter, expected Type, got String"
+    @test err_str == "TypeError: in Type, in parameter, expected Type, got String"
     err_str = @except_str TypeWithIntParam{Any} TypeError
-    @test err_str == "TypeError: TypeWithIntParam: in T, expected T<:Integer, got Type{Any}"
+    @test err_str == "TypeError: in TypeWithIntParam, in T, expected T<:Integer, got Type{Any}"
 
     err_str = @except_str mod(1,0) DivideError
     @test err_str == "DivideError: integer division error"
@@ -351,13 +350,13 @@ end
 @test stringmime("text/plain", FunctionLike()) == "(::FunctionLike) (generic function with 0 methods)"
 @test ismatch(r"^@doc \(macro with \d+ method[s]?\)$", stringmime("text/plain", getfield(Base, Symbol("@doc"))))
 
-method_defs_lineno = @__LINE__+1
+method_defs_lineno = @__LINE__() + 1
 Base.Symbol() = throw(ErrorException("1"))
 (::Symbol)() = throw(ErrorException("2"))
 EightBitType() = throw(ErrorException("3"))
 (::EightBitType)() = throw(ErrorException("4"))
 EightBitTypeT() = throw(ErrorException("5"))
-(::Type{EightBitTypeT{T}}){T}() = throw(ErrorException("6"))
+(::Type{EightBitTypeT{T}})() where {T} = throw(ErrorException("6"))
 (::EightBitTypeT)() = throw(ErrorException("7"))
 (::FunctionLike)() = throw(ErrorException("8"))
 
@@ -368,15 +367,24 @@ let err_str,
     sp = Base.source_path()
     sn = basename(sp)
 
-    @test sprint(show, which(Symbol, Tuple{})) == "Symbol() in $curmod_str at $sp:$(method_defs_lineno + 0)"
-    @test sprint(show, which(:a, Tuple{})) == "(::Symbol)() in $curmod_str at $sp:$(method_defs_lineno + 1)"
-    @test sprint(show, which(EightBitType, Tuple{})) == "$(curmod_prefix)EightBitType() in $curmod_str at $sp:$(method_defs_lineno + 2)"
-    @test sprint(show, which(reinterpret(EightBitType, 0x54), Tuple{})) == "(::$(curmod_prefix)EightBitType)() in $curmod_str at $sp:$(method_defs_lineno + 3)"
-    @test sprint(show, which(EightBitTypeT, Tuple{})) == "(::Type{$(curmod_prefix)EightBitTypeT})() in $curmod_str at $sp:$(method_defs_lineno + 4)"
-    @test sprint(show, which(EightBitTypeT{Int32}, Tuple{})) == "(::Type{$(curmod_prefix)EightBitTypeT{T}})() where T in $curmod_str at $sp:$(method_defs_lineno + 5)"
-    @test sprint(show, which(reinterpret(EightBitTypeT{Int32}, 0x54), Tuple{})) == "(::$(curmod_prefix)EightBitTypeT)() in $curmod_str at $sp:$(method_defs_lineno + 6)"
-    @test startswith(sprint(show, which(getfield(Base, Symbol("@doc")), Tuple{Vararg{Any}})), "@doc(x...) in Core at boot.jl:")
-    @test startswith(sprint(show, which(FunctionLike(), Tuple{})), "(::$(curmod_prefix)FunctionLike)() in $curmod_str at $sp:$(method_defs_lineno + 7)")
+    @test sprint(show, which(Symbol, Tuple{})) ==
+        "Symbol() in $curmod_str at $sp:$(method_defs_lineno + 0)"
+    @test sprint(show, which(:a, Tuple{})) ==
+        "(::Symbol)() in $curmod_str at $sp:$(method_defs_lineno + 1)"
+    @test sprint(show, which(EightBitType, Tuple{})) ==
+        "$(curmod_prefix)EightBitType() in $curmod_str at $sp:$(method_defs_lineno + 2)"
+    @test sprint(show, which(reinterpret(EightBitType, 0x54), Tuple{})) ==
+        "(::$(curmod_prefix)EightBitType)() in $curmod_str at $sp:$(method_defs_lineno + 3)"
+    @test sprint(show, which(EightBitTypeT, Tuple{})) ==
+        "(::Type{$(curmod_prefix)EightBitTypeT})() in $curmod_str at $sp:$(method_defs_lineno + 4)"
+    @test sprint(show, which(EightBitTypeT{Int32}, Tuple{})) ==
+        "(::Type{$(curmod_prefix)EightBitTypeT{T}})() where T in $curmod_str at $sp:$(method_defs_lineno + 5)"
+    @test sprint(show, which(reinterpret(EightBitTypeT{Int32}, 0x54), Tuple{})) ==
+        "(::$(curmod_prefix)EightBitTypeT)() in $curmod_str at $sp:$(method_defs_lineno + 6)"
+    @test startswith(sprint(show, which(getfield(Base, Symbol("@doc")), Tuple{LineNumberNode, Module, Vararg{Any}})),
+                     "@doc(__source__::LineNumberNode, __module__::Module, x...) in Core at boot.jl:")
+    @test startswith(sprint(show, which(FunctionLike(), Tuple{})),
+                     "(::$(curmod_prefix)FunctionLike)() in $curmod_str 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)"
 
@@ -442,14 +450,13 @@ let d = Dict(1 => 2, 3 => 45)
     buf = IOBuffer()
     td = TextDisplay(buf)
     display(td, d)
-    result = String(td.io)
+    result = String(take!(td.io))
 
     @test contains(result, summary(d))
 
     # Is every pair in the string?
-    # Compare by removing spaces
     for el in d
-        @test contains(replace(result, " ", ""), string(el))
+        @test contains(result, string(el))
     end
 end
 
@@ -458,13 +465,13 @@ let err, buf = IOBuffer()
     try Array() catch err end
     Base.show_method_candidates(buf,err)
     @test isa(err, MethodError)
-    @test contains(String(buf), "Closest candidates are:")
+    @test contains(String(take!(buf)), "Closest candidates are:")
 end
 
 # Issue 20111
 let K20111(x) = y -> x, buf = IOBuffer()
     show(buf, methods(K20111(1)))
-    @test contains(String(buf), " 1 method for generic function")
+    @test contains(String(take!(buf)), " 1 method for generic function")
 end
 
 # @macroexpand tests
@@ -474,8 +481,8 @@ macro seven_dollar(ex)
 end
 
 let
-    @test (@macroexpand @macroexpand x) == macroexpand(:(@macroexpand x))
-    @test (@macroexpand  :(1+$y) ) == macroexpand(:( :(1+ $y)))
+    @test (@macroexpand @macroexpand x) == macroexpand(@__MODULE__, :(@macroexpand x))
+    @test (@macroexpand  :(1+$y) ) == macroexpand(@__MODULE__, :( :(1+ $y) ))
     @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))
@@ -485,6 +492,32 @@ let
     @test (@macroexpand @seven_dollar 1+$x) == :(1 + $(Expr(:$, :x)))
 end
 
+macro nest1(code)
+    code
+end
+
+macro nest2(code)
+    :(@nest1 $code)
+end
+
+macro nest2b(code)
+    :(@nest1($code); @nest1($code))
+end
+
+@testset "@macroexpand1" begin
+    M = @__MODULE__
+    _macroexpand1(ex) = macroexpand(M, ex, recursive=false)
+    ex = :(@nest1 42)
+    @test _macroexpand1(ex) == macroexpand(M,ex)
+    ex = :(@nest2 42)
+    @test _macroexpand1(ex) != macroexpand(M,ex)
+    @test _macroexpand1(_macroexpand1(ex)) == macroexpand(M,ex)
+    ex = :(@nest2b 42)
+    @test _macroexpand1(ex) != macroexpand(M,ex)
+    @test _macroexpand1(_macroexpand1(ex)) == macroexpand(M, ex)
+    @test (@macroexpand1 @nest2b 42) == _macroexpand1(ex)
+end
+
 foo_9965(x::Float64; w=false) = x
 foo_9965(x::Int) = 2x
 
@@ -499,3 +532,117 @@ foo_9965(x::Int) = 2x
     Base.show_method_candidates(io, ex, [(:w,true)])
     @test contains(String(take!(io)), "got unsupported keyword argument \"w\"")
 end
+
+# Issue #20556
+module EnclosingModule
+    abstract type AbstractTypeNoConstructors end
+end
+let
+    method_error = MethodError(EnclosingModule.AbstractTypeNoConstructors, ())
+
+    # Test that it shows a special message when no constructors have been defined by the user.
+    @test sprint(showerror, method_error) ==
+        "MethodError: no constructors have been defined for $(EnclosingModule.AbstractTypeNoConstructors)"
+
+    # Does it go back to previous behaviour when there *is* at least
+    # one constructor defined?
+    EnclosingModule.AbstractTypeNoConstructors(x, y) = x + y
+    @test startswith(sprint(showerror, method_error),
+        "MethodError: no method matching $(EnclosingModule.AbstractTypeNoConstructors)()")
+
+    # Test that the 'default' sysimg.jl method is not displayed.
+    @test !contains(sprint(showerror, method_error), "where T at sysimg.jl")
+
+    # Test that tab-completion will not show the 'default' sysimg.jl method.
+    for method_string in Base.REPLCompletions.complete_methods(:(EnclosingModule.AbstractTypeNoConstructors()))
+        @test !startswith(method_string, "(::Type{T})(arg) where T in Base at sysimg.jl")
+    end
+end
+
+@testset "show for manually thrown MethodError" begin
+    global f21006
+
+    f21006() = nothing
+    # Normal method error should not warn about world age.
+    ex1 = try
+        f21006(())
+    catch e
+        e
+    end::MethodError
+    str = sprint(Base.showerror, ex1)
+    @test startswith(str, "MethodError: no method matching f21006(::Tuple{})")
+    @test !contains(str, "The applicable method may be too new")
+
+    # If newer applicable methods are available, world age should be mentioned.
+    f21006(x) = x
+    @test f21006(()) === ()
+    str = sprint(Base.showerror, ex1)
+    @test startswith(str, "MethodError: no method matching f21006(::Tuple{})")
+    @test contains(str, "The applicable method may be too new: running in world age $(ex1.world)")
+
+    # This method error should be thrown in a world new enough for `f21006(())`.
+    # Also makes sure it's printed correctly.
+    ex2 = try
+        f21006((), ())
+    catch e
+        e
+    end::MethodError
+    str = sprint(Base.showerror, ex2)
+    @test startswith(str, "MethodError: no method matching f21006(::Tuple{}, ::Tuple{})")
+    @test !contains(str, "The applicable method may be too new")
+
+    # If the method is available in the exception world or if the exception world is invalid,
+    # don't warn about world age
+    for ex3 in (MethodError(ex1.f, ex1.args, ex2.world),
+                MethodError(ex1.f, ex1.args, typemax(UInt)))
+        str = sprint(Base.showerror, ex3)
+        @test startswith(str, "MethodError: no method matching f21006(::Tuple{})")
+        @test !contains(str, "The applicable method may be too new")
+    end
+end
+
+# issue #22798
+@generated f22798(x::Integer, y) = :x
+let buf = IOBuffer()
+    show(buf, methods(f22798))
+    @test contains(String(take!(buf)), "f22798(x::Integer, y)")
+end
+
+@testset "Dict printing with limited rows" begin
+    buf = IOBuffer()
+    io = IOContext(IOContext(buf, :displaysize => (4, 80)), :limit => true)
+    d = Base.ImmutableDict(1=>2)
+    show(io, MIME"text/plain"(), d)
+    @test String(take!(buf)) == "Base.ImmutableDict{$Int,$Int} with 1 entry: …"
+    show(io, MIME"text/plain"(), keys(d))
+    @test String(take!(buf)) ==
+        "Base.KeyIterator for a Base.ImmutableDict{$Int,$Int} with 1 entry. Keys: …"
+
+    io = IOContext(io, :displaysize => (5, 80))
+    show(io, MIME"text/plain"(), d)
+    @test String(take!(buf)) == "Base.ImmutableDict{$Int,$Int} with 1 entry:\n  1 => 2"
+    show(io, MIME"text/plain"(), keys(d))
+    @test String(take!(buf)) ==
+        "Base.KeyIterator for a Base.ImmutableDict{$Int,$Int} with 1 entry. Keys:\n  1"
+    d = Base.ImmutableDict(d, 3=>4)
+    show(io, MIME"text/plain"(), d)
+    @test String(take!(buf)) == "Base.ImmutableDict{$Int,$Int} with 2 entries:\n  ⋮ => ⋮"
+    show(io, MIME"text/plain"(), keys(d))
+    @test String(take!(buf)) ==
+        "Base.KeyIterator for a Base.ImmutableDict{$Int,$Int} with 2 entries. Keys:\n  ⋮"
+
+    io = IOContext(io, :displaysize => (6, 80))
+    show(io, MIME"text/plain"(), d)
+    @test String(take!(buf)) ==
+        "Base.ImmutableDict{$Int,$Int} with 2 entries:\n  3 => 4\n  1 => 2"
+    show(io, MIME"text/plain"(), keys(d))
+    @test String(take!(buf)) ==
+        "Base.KeyIterator for a Base.ImmutableDict{$Int,$Int} with 2 entries. Keys:\n  3\n  1"
+    d = Base.ImmutableDict(d, 5=>6)
+    show(io, MIME"text/plain"(), d)
+    @test String(take!(buf)) ==
+        "Base.ImmutableDict{$Int,$Int} with 3 entries:\n  5 => 6\n  ⋮ => ⋮"
+    show(io, MIME"text/plain"(), keys(d))
+    @test String(take!(buf)) ==
+        "Base.KeyIterator for a Base.ImmutableDict{$Int,$Int} with 3 entries. Keys:\n  5\n  ⋮"
+end
diff --git a/test/resolve.jl b/test/resolve.jl
index 059e23a90cecb4..f122ca2b4a5701 100644
--- a/test/resolve.jl
+++ b/test/resolve.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base.Pkg.Types
 using Base.Pkg.Query
@@ -100,7 +100,7 @@ function sanity_tst(deps_data, expected_result; pkgs=[])
 end
 sanity_tst(deps_data; kw...) = sanity_tst(deps_data, []; kw...)
 
-function resolve_tst(deps_data, reqs_data)
+function resolve_tst(deps_data, reqs_data, want_data = nothing)
     deps = deps_from_data(deps_data)
     reqs = reqs_from_data(reqs_data)
 
@@ -109,6 +109,7 @@ function resolve_tst(deps_data, reqs_data)
     #println("reqs=$reqs")
     deps = Query.prune_dependencies(reqs, deps)
     want = resolve(reqs, deps)
+    return want == want_data
 end
 
 ## DEPENDENCY SCHEME 1: TWO PACKAGES, DAG
@@ -129,15 +130,15 @@ reqs_data = Any[
     ["B"]
 ]
 
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("B"=>v"2")
+want_data = Dict("B"=>v"2")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 # require just A: must bring in B
 reqs_data = Any[
     ["A"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"2", "B"=>v"2")
+want_data = Dict("A"=>v"2", "B"=>v"2")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 
 ## DEPENDENCY SCHEME 2: TWO PACKAGES, CYCLIC
@@ -154,22 +155,22 @@ deps_data = Any[
 reqs_data = Any[
     ["A"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"2", "B"=>v"2")
+want_data = Dict("A"=>v"2", "B"=>v"2")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 # require just B, force lower version
 reqs_data = Any[
     ["B", v"1", v"2"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"2", "B"=>v"1")
+want_data = Dict("A"=>v"2", "B"=>v"1")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 # require just A, force lower version
 reqs_data = Any[
     ["A", v"1", v"2"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"1", "B"=>v"2")
+want_data = Dict("A"=>v"1", "B"=>v"2")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 
 ## DEPENDENCY SCHEME 3: THREE PACKAGES, CYCLIC, TWO MUTUALLY EXCLUSIVE SOLUTIONS
@@ -188,22 +189,22 @@ deps_data = Any[
 reqs_data = Any[
     ["A"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"2", "B"=>v"1", "C"=>v"2")
+want_data = Dict("A"=>v"2", "B"=>v"1", "C"=>v"2")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 # require just B (must choose solution which has the highest version for B)
 reqs_data = Any[
     ["B"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"1", "B"=>v"2", "C"=>v"1")
+want_data = Dict("A"=>v"1", "B"=>v"2", "C"=>v"1")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 # require just A, force lower version
 reqs_data = Any[
     ["A", v"1", v"2"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"1", "B"=>v"2", "C"=>v"1")
+want_data = Dict("A"=>v"1", "B"=>v"2", "C"=>v"1")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 # require A and C, incompatible versions
 reqs_data = Any[
@@ -226,8 +227,8 @@ deps_data = Any[
 reqs_data = Any[
     ["B"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("B"=>v"1")
+want_data = Dict("B"=>v"1")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 
 ## DEPENDENCY SCHEME 5: THREE PACKAGES, DAG, WITH IMPLICIT INCONSISTENCY
@@ -250,8 +251,8 @@ deps_data = Any[
 reqs_data = Any[
     ["A"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"1", "B"=>v"2", "C"=>v"2")
+want_data = Dict("A"=>v"1", "B"=>v"2", "C"=>v"2")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 # require A, force highest version (impossible)
 reqs_data = Any[
@@ -301,15 +302,15 @@ deps_data = Any[
 reqs_data = Any[
     ["A"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"2", "B"=>v"2", "C"=>v"2")
+want_data = Dict("A"=>v"2", "B"=>v"2", "C"=>v"2")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 # require C
 reqs_data = Any[
     ["C"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"2", "B"=>v"2", "C"=>v"2")
+want_data = Dict("A"=>v"2", "B"=>v"2", "C"=>v"2")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 # require C, lowest version (impossible)
 reqs_data = Any[
@@ -374,44 +375,44 @@ deps_data = Any[
 reqs_data = Any[
     ["F"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"3", "B"=>v"2", "C"=>v"2",
-                   "D"=>v"2", "E"=>v"1", "F"=>v"2")
+want_data = Dict("A"=>v"3", "B"=>v"2", "C"=>v"2",
+                 "D"=>v"2", "E"=>v"1", "F"=>v"2")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 # require just F, lower version
 reqs_data = Any[
     ["F", v"1", v"2"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"2", "B"=>v"2", "D"=>v"2",
-                   "E"=>v"1", "F"=>v"1")
+want_data = Dict("A"=>v"2", "B"=>v"2", "D"=>v"2",
+                 "E"=>v"1", "F"=>v"1")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 # require F and B; force lower B version -> must bring down F, A, and D versions too
 reqs_data = Any[
     ["F"],
     ["B", v"1", v"2"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"1", "B"=>v"1", "D"=>v"1",
-                   "E"=>v"1", "F"=>v"1")
+want_data = Dict("A"=>v"1", "B"=>v"1", "D"=>v"1",
+                 "E"=>v"1", "F"=>v"1")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 # require F and D; force lower D version -> must not bring down F version
 reqs_data = Any[
     ["F"],
     ["D", v"1", v"2"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"3", "B"=>v"2", "C"=>v"2",
-                   "D"=>v"1", "E"=>v"1", "F"=>v"2")
+want_data = Dict("A"=>v"3", "B"=>v"2", "C"=>v"2",
+                 "D"=>v"1", "E"=>v"1", "F"=>v"2")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 # require F and C; force lower C version -> must bring down F and A versions
 reqs_data = Any[
     ["F"],
     ["C", v"1", v"2"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"2", "B"=>v"2", "C"=>v"1",
-                   "D"=>v"2", "E"=>v"1", "F"=>v"1")
+want_data = Dict("A"=>v"2", "B"=>v"2", "C"=>v"1",
+                 "D"=>v"2", "E"=>v"1", "F"=>v"1")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 ## DEPENDENCY SCHEME 10: SIX PACKAGES, DAG, WITH PRERELEASE/BUILD VERSIONS
 deps_data = Any[
@@ -448,44 +449,44 @@ deps_data = Any[
 reqs_data = Any[
     ["F"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"2.1", "B"=>v"1.0.1", "C"=>v"2",
-                   "D"=>v"2", "E"=>v"1", "F"=>v"2")
+want_data = Dict("A"=>v"2.1", "B"=>v"1.0.1", "C"=>v"2",
+                 "D"=>v"2", "E"=>v"1", "F"=>v"2")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 # require just F, lower version
 reqs_data = Any[
     ["F", v"1", v"2-"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"2", "B"=>v"1.0.1", "D"=>v"2",
-                   "E"=>v"1", "F"=>v"1.1")
+want_data = Dict("A"=>v"2", "B"=>v"1.0.1", "D"=>v"2",
+                 "E"=>v"1", "F"=>v"1.1")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 # require F and B; force lower B version -> must bring down F, A, and D versions too
 reqs_data = Any[
     ["F"],
     ["B", v"1", v"1.0.1-"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"1", "B"=>v"1", "D"=>v"1",
-                   "E"=>v"1", "F"=>v"1.1")
+want_data = Dict("A"=>v"1", "B"=>v"1", "D"=>v"1",
+                 "E"=>v"1", "F"=>v"1.1")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 # require F and D; force lower D version -> must not bring down F version
 reqs_data = Any[
     ["F"],
     ["D", v"1", v"2"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"2.1", "B"=>v"1.0.1", "C"=>v"2",
-                   "D"=>v"1", "E"=>v"1", "F"=>v"2")
+want_data = Dict("A"=>v"2.1", "B"=>v"1.0.1", "C"=>v"2",
+                 "D"=>v"1", "E"=>v"1", "F"=>v"2")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 # require F and C; force lower C version -> must bring down F and A versions
 reqs_data = Any[
     ["F"],
     ["C", v"1", v"2"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"2", "B"=>v"1.0.1", "C"=>v"1+BLD",
-                   "D"=>v"2", "E"=>v"1", "F"=>v"2-rc.1")
+want_data = Dict("A"=>v"2", "B"=>v"1.0.1", "C"=>v"1+BLD",
+                 "D"=>v"2", "E"=>v"1", "F"=>v"2-rc.1")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 ## DEPENDENCY SCHEME 11: FIVE PACKAGES, SAME AS SCHEMES 5 + 1, UNCONNECTED
 deps_data = Any[
@@ -513,15 +514,15 @@ deps_data = Any[
 reqs_data = Any[
     ["A"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"1", "B"=>v"2", "C"=>v"2")
+want_data = Dict("A"=>v"1", "B"=>v"2", "C"=>v"2")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 # require just D: must bring in E
 reqs_data = Any[
     ["D"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("D"=>v"2", "E"=>v"2")
+want_data = Dict("D"=>v"2", "E"=>v"2")
+@test resolve_tst(deps_data, reqs_data, want_data)
 
 
 # require A and D, must be the merge of the previous two cases
@@ -529,5 +530,13 @@ reqs_data = Any[
     ["A"],
     ["D"]
 ]
-want = resolve_tst(deps_data, reqs_data)
-@test want == Dict("A"=>v"1", "B"=>v"2", "C"=>v"2", "D"=>v"2", "E"=>v"2")
+want_data = Dict("A"=>v"1", "B"=>v"2", "C"=>v"2", "D"=>v"2", "E"=>v"2")
+@test resolve_tst(deps_data, reqs_data, want_data)
+
+## DEPENDENCY SCHEME 12: A REALISTIC EXAMPLE
+## ref issue #21485
+
+include("resolvedata1.jl")
+
+@test sanity_tst(deps_data, problematic_data)
+@test resolve_tst(deps_data, reqs_data, want_data)
diff --git a/test/resolvedata1.jl b/test/resolvedata1.jl
new file mode 100644
index 00000000000000..26d6c649f29e81
--- /dev/null
+++ b/test/resolvedata1.jl
@@ -0,0 +1,2853 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
+deps_data = Any[
+    ["ASTInterpreter", v"0.0.1", "AbstractTrees", v"0.0.1", v"0.1.0"],
+    ["ASTInterpreter", v"0.0.1", "JuliaParser", v"0.7.1"],
+    ["ASTInterpreter", v"0.0.3", "AbstractTrees", v"0.0.2", v"0.1.0"],
+    ["ASTInterpreter", v"0.0.3", "JuliaParser", v"0.7.2"],
+    ["ASTInterpreter", v"0.0.4", "AbstractTrees", v"0.0.4", v"0.1.0"],
+    ["ASTInterpreter", v"0.0.4", "JuliaParser", v"0.7.2"],
+    ["AbstractTrees", v"0.0.1"],
+    ["AbstractTrees", v"0.0.3"],
+    ["AbstractTrees", v"0.0.4"],
+    ["AbstractTrees", v"0.1.0", "Compat", v"0.17.0"],
+    ["AlgebraicDiffEq", v"0.0.1", "DiffEqBase"],
+    ["AlgebraicDiffEq", v"0.0.1", "Parameters", v"0.5.0"],
+    ["AlgebraicDiffEq", v"0.0.1", "Sundials", v"0.3.0"],
+    ["AlgebraicDiffEq", v"0.0.2", "DiffEqBase"],
+    ["AlgebraicDiffEq", v"0.0.2", "Parameters", v"0.5.0"],
+    ["AlgebraicDiffEq", v"0.0.2", "Sundials", v"0.3.0"],
+    ["AlgebraicDiffEq", v"0.1.0", "DiffEqBase", v"0.2.0"],
+    ["AlgebraicDiffEq", v"0.1.0", "Parameters", v"0.5.0"],
+    ["AnsiColor", v"0.0.2"],
+    ["ArgParse", v"0.2.9", "Options"],
+    ["ArgParse", v"0.2.9", "TextWrap", v"0.1.0-"],
+    ["ArgParse", v"0.2.10", "Compat"],
+    ["ArgParse", v"0.2.10", "Options"],
+    ["ArgParse", v"0.2.10", "TextWrap", v"0.1.0-"],
+    ["ArgParse", v"0.2.12", "Options"],
+    ["ArgParse", v"0.2.12", "Compat", v"0.2.9"],
+    ["ArgParse", v"0.2.12", "TextWrap", v"0.1.0-"],
+    ["ArgParse", v"0.2.13", "Options"],
+    ["ArgParse", v"0.2.13", "Compat", v"0.7.3"],
+    ["ArgParse", v"0.2.13", "TextWrap", v"0.1.4"],
+    ["ArgParse", v"0.3.0", "Compat", v"0.7.3"],
+    ["ArgParse", v"0.3.0", "TextWrap", v"0.1.4"],
+    ["ArgParse", v"0.4.0", "Compat", v"0.8.0"],
+    ["ArgParse", v"0.4.0", "TextWrap", v"0.1.4"],
+    ["ArrayViews", v"0.1.1"],
+    ["ArrayViews", v"0.3.0"],
+    ["ArrayViews", v"0.4.5"],
+    ["ArrayViews", v"0.4.7"],
+    ["ArrayViews", v"0.4.8"],
+    ["ArrayViews", v"0.4.9"],
+    ["ArrayViews", v"0.4.11"],
+    ["ArrayViews", v"0.6.3"],
+    ["ArrayViews", v"0.6.4", "Compat"],
+    ["Atom", v"0.2.1", "CodeTools"],
+    ["Atom", v"0.2.1", "Hiccup"],
+    ["Atom", v"0.2.1", "JSON"],
+    ["Atom", v"0.2.1", "LNR"],
+    ["Atom", v"0.2.1", "Lazy"],
+    ["Atom", v"0.2.1", "Media"],
+    ["Atom", v"0.4.0", "Blink"],
+    ["Atom", v"0.4.0", "CodeTools"],
+    ["Atom", v"0.4.0", "Hiccup"],
+    ["Atom", v"0.4.0", "JSON"],
+    ["Atom", v"0.4.0", "LNR"],
+    ["Atom", v"0.4.0", "Lazy"],
+    ["Atom", v"0.4.0", "Media"],
+    ["Atom", v"0.4.0", "Reexport"],
+    ["Atom", v"0.4.6", "Blink"],
+    ["Atom", v"0.4.6", "CodeTools"],
+    ["Atom", v"0.4.6", "Hiccup"],
+    ["Atom", v"0.4.6", "JSON"],
+    ["Atom", v"0.4.6", "LNR"],
+    ["Atom", v"0.4.6", "Lazy"],
+    ["Atom", v"0.4.6", "MacroTools"],
+    ["Atom", v"0.4.6", "Media"],
+    ["Atom", v"0.4.6", "Reexport"],
+    ["Atom", v"0.4.6", "Requires"],
+    ["Atom", v"0.5.0", "ASTInterpreter"],
+    ["Atom", v"0.5.0", "Blink"],
+    ["Atom", v"0.5.0", "CodeTools"],
+    ["Atom", v"0.5.0", "Gallium"],
+    ["Atom", v"0.5.0", "Hiccup"],
+    ["Atom", v"0.5.0", "JSON"],
+    ["Atom", v"0.5.0", "LNR"],
+    ["Atom", v"0.5.0", "Lazy"],
+    ["Atom", v"0.5.0", "MacroTools"],
+    ["Atom", v"0.5.0", "Media"],
+    ["Atom", v"0.5.0", "Reexport"],
+    ["Atom", v"0.5.0", "Requires"],
+    ["Atom", v"0.5.2", "ASTInterpreter"],
+    ["Atom", v"0.5.2", "Blink"],
+    ["Atom", v"0.5.2", "CodeTools"],
+    ["Atom", v"0.5.2", "Gallium"],
+    ["Atom", v"0.5.2", "Hiccup"],
+    ["Atom", v"0.5.2", "JSON"],
+    ["Atom", v"0.5.2", "Juno"],
+    ["Atom", v"0.5.2", "LNR"],
+    ["Atom", v"0.5.2", "Lazy"],
+    ["Atom", v"0.5.2", "MacroTools"],
+    ["Atom", v"0.5.2", "Media"],
+    ["Atom", v"0.5.2", "Reexport"],
+    ["Atom", v"0.5.2", "Requires"],
+    ["Atom", v"0.5.8", "ASTInterpreter"],
+    ["Atom", v"0.5.8", "Blink"],
+    ["Atom", v"0.5.8", "CodeTools"],
+    ["Atom", v"0.5.8", "Gallium"],
+    ["Atom", v"0.5.8", "Hiccup"],
+    ["Atom", v"0.5.8", "JSON"],
+    ["Atom", v"0.5.8", "Juno"],
+    ["Atom", v"0.5.8", "LNR"],
+    ["Atom", v"0.5.8", "MacroTools"],
+    ["Atom", v"0.5.8", "Media"],
+    ["Atom", v"0.5.8", "Reexport"],
+    ["Atom", v"0.5.8", "Lazy", v"0.11.3"],
+    ["Atom", v"0.5.10", "ASTInterpreter"],
+    ["Atom", v"0.5.10", "Blink"],
+    ["Atom", v"0.5.10", "CodeTools"],
+    ["Atom", v"0.5.10", "Gallium"],
+    ["Atom", v"0.5.10", "Hiccup"],
+    ["Atom", v"0.5.10", "JSON"],
+    ["Atom", v"0.5.10", "LNR"],
+    ["Atom", v"0.5.10", "MacroTools"],
+    ["Atom", v"0.5.10", "Media"],
+    ["Atom", v"0.5.10", "Reexport"],
+    ["Atom", v"0.5.10", "Juno", v"0.2.6"],
+    ["Atom", v"0.5.10", "Lazy", v"0.11.3"],
+    ["AxisAlgorithms", v"0.1.6", "WoodburyMatrices"],
+    ["AxisAlgorithms", v"0.1.6", "Compat", v"0.8.0"],
+    ["AxisArrays", v"0.0.3", "IntervalSets"],
+    ["AxisArrays", v"0.0.3", "Iterators"],
+    ["AxisArrays", v"0.0.3", "RangeArrays"],
+    ["AxisArrays", v"0.1.2", "Compat", v"0.19.0"],
+    ["AxisArrays", v"0.1.2", "IntervalSets"],
+    ["AxisArrays", v"0.1.2", "Iterators"],
+    ["AxisArrays", v"0.1.2", "RangeArrays"],
+    ["BinDeps", v"0.2.0"],
+    ["BinDeps", v"0.2.4", "URIParser"],
+    ["BinDeps", v"0.2.14", "URIParser"],
+    ["BinDeps", v"0.3.4", "URIParser"],
+    ["BinDeps", v"0.3.4", "SHA", v"0.0.0", v"0.0.3"],
+    ["BinDeps", v"0.3.5", "URIParser"],
+    ["BinDeps", v"0.3.5", "SHA", v"0.0.3"],
+    ["BinDeps", v"0.3.8", "SHA"],
+    ["BinDeps", v"0.3.8", "URIParser"],
+    ["BinDeps", v"0.3.10", "Compat", v"0.3.6"],
+    ["BinDeps", v"0.3.10", "SHA"],
+    ["BinDeps", v"0.3.10", "URIParser"],
+    ["BinDeps", v"0.3.15", "Compat", v"0.4.0"],
+    ["BinDeps", v"0.3.15", "SHA"],
+    ["BinDeps", v"0.3.15", "URIParser"],
+    ["BinDeps", v"0.3.21", "Compat", v"0.7.1"],
+    ["BinDeps", v"0.3.21", "SHA"],
+    ["BinDeps", v"0.3.21", "URIParser"],
+    ["BinDeps", v"0.3.23", "URIParser"],
+    ["BinDeps", v"0.3.23", "Compat", v"0.8.4"],
+    ["BinDeps", v"0.3.23", "SHA"],
+    ["BinDeps", v"0.4.2", "Compat", v"0.8.4"],
+    ["BinDeps", v"0.4.2", "SHA"],
+    ["BinDeps", v"0.4.2", "URIParser"],
+    ["BinDeps", v"0.4.5", "Compat", v"0.8.4"],
+    ["BinDeps", v"0.4.5", "SHA"],
+    ["BinDeps", v"0.4.5", "URIParser"],
+    ["BinDeps", v"0.4.7", "Compat", v"0.17.0"],
+    ["BinDeps", v"0.4.7", "SHA"],
+    ["BinDeps", v"0.4.7", "URIParser"],
+    ["Blink", v"0.1.4", "JSON"],
+    ["Blink", v"0.1.4", "Lazy"],
+    ["Blink", v"0.1.4", "Requires"],
+    ["Blink", v"0.1.5", "JSON"],
+    ["Blink", v"0.1.5", "Lazy"],
+    ["Blink", v"0.1.5", "MacroTools"],
+    ["Blink", v"0.1.5", "Requires"],
+    ["Blink", v"0.2.0", "HttpServer"],
+    ["Blink", v"0.2.0", "JSON"],
+    ["Blink", v"0.2.0", "Lazy"],
+    ["Blink", v"0.2.0", "MacroTools"],
+    ["Blink", v"0.2.0", "Mustache"],
+    ["Blink", v"0.2.0", "Reexport"],
+    ["Blink", v"0.2.0", "Requires"],
+    ["Blink", v"0.2.0", "WebSockets"],
+    ["Blink", v"0.2.1", "HttpServer"],
+    ["Blink", v"0.2.1", "JSON"],
+    ["Blink", v"0.2.1", "Lazy"],
+    ["Blink", v"0.2.1", "MacroTools"],
+    ["Blink", v"0.2.1", "Mustache"],
+    ["Blink", v"0.2.1", "Mux"],
+    ["Blink", v"0.2.1", "Reexport"],
+    ["Blink", v"0.2.1", "Requires"],
+    ["Blink", v"0.2.1", "WebSockets"],
+    ["Blink", v"0.3.4", "BinDeps"],
+    ["Blink", v"0.3.4", "HttpServer"],
+    ["Blink", v"0.3.4", "JSON"],
+    ["Blink", v"0.3.4", "Lazy"],
+    ["Blink", v"0.3.4", "MacroTools"],
+    ["Blink", v"0.3.4", "Mustache"],
+    ["Blink", v"0.3.4", "Mux"],
+    ["Blink", v"0.3.4", "Reexport"],
+    ["Blink", v"0.3.4", "Requires"],
+    ["Blink", v"0.3.4", "WebSockets"],
+    ["Blink", v"0.4.1", "BinDeps"],
+    ["Blink", v"0.4.1", "HttpServer"],
+    ["Blink", v"0.4.1", "Mustache"],
+    ["Blink", v"0.4.1", "Reexport"],
+    ["Blink", v"0.4.1", "Requires"],
+    ["Blink", v"0.4.1", "Compat", v"0.8.6"],
+    ["Blink", v"0.4.1", "JSON"],
+    ["Blink", v"0.4.1", "Lazy"],
+    ["Blink", v"0.4.1", "MacroTools"],
+    ["Blink", v"0.4.1", "Mux"],
+    ["Blink", v"0.4.1", "WebSockets"],
+    ["Blink", v"0.5.1", "BinDeps"],
+    ["Blink", v"0.5.1", "HttpServer"],
+    ["Blink", v"0.5.1", "Compat", v"0.8.6"],
+    ["Blink", v"0.5.1", "JSON"],
+    ["Blink", v"0.5.1", "MacroTools"],
+    ["Blink", v"0.5.1", "Mustache"],
+    ["Blink", v"0.5.1", "Lazy", v"0.11.3"],
+    ["Blink", v"0.5.1", "Mux"],
+    ["Blink", v"0.5.1", "Reexport"],
+    ["Blink", v"0.5.1", "WebSockets"],
+    ["Blocks", v"0.0.4"],
+    ["Blocks", v"0.1.0", "Compat"],
+    ["Blosc", v"0.1.1", "BinDeps"],
+    ["Blosc", v"0.1.5", "BinDeps"],
+    ["Blosc", v"0.1.5", "Compat"],
+    ["Blosc", v"0.2.0", "BinDeps"],
+    ["Blosc", v"0.2.0", "Compat", v"0.8.0"],
+    ["COFF", v"0.0.2", "DWARF"],
+    ["COFF", v"0.0.2", "ObjFileBase"],
+    ["COFF", v"0.0.2", "StructIO"],
+    ["CRC", v"0.1.0", "ArgParse"],
+    ["CRC", v"0.1.0", "Zlib"],
+    ["CRC", v"1.1.1", "ArgParse"],
+    ["CRC", v"1.1.1", "Compat"],
+    ["CRC", v"1.2.0", "ArgParse"],
+    ["Calculus", v"0.1.5"],
+    ["Calculus", v"0.1.6", "Compat"],
+    ["Calculus", v"0.1.14", "Compat", v"0.4.0"],
+    ["Calculus", v"0.1.15", "Compat", v"0.4.0"],
+    ["Calculus", v"0.2.0", "Compat", v"0.4.0"],
+    ["Calculus", v"0.2.2", "Compat", v"0.17.0"],
+    ["Calendar", v"0.4.3", "ICU"],
+    ["CatIndices", v"0.0.2", "CustomUnitRanges"],
+    ["CatIndices", v"0.0.2", "OffsetArrays"],
+    ["ChunkedArrays", v"0.0.1", "Compat"],
+    ["ChunkedArrays", v"0.0.1", "EllipsisNotation"],
+    ["ChunkedArrays", v"0.0.2", "Compat"],
+    ["ChunkedArrays", v"0.0.2", "EllipsisNotation"],
+    ["ChunkedArrays", v"0.1.0", "Compat"],
+    ["ChunkedArrays", v"0.1.0", "EllipsisNotation"],
+    ["ChunkedArrays", v"0.1.1", "EllipsisNotation", v"0.0.2"],
+    ["CodeTools", v"0.1.0", "JuliaParser"],
+    ["CodeTools", v"0.1.0", "LNR"],
+    ["CodeTools", v"0.1.0", "Lazy"],
+    ["CodeTools", v"0.1.0", "MacroTools"],
+    ["CodeTools", v"0.2.0", "Compat"],
+    ["CodeTools", v"0.2.0", "JuliaParser"],
+    ["CodeTools", v"0.2.0", "LNR"],
+    ["CodeTools", v"0.2.0", "Lazy"],
+    ["CodeTools", v"0.2.0", "MacroTools"],
+    ["CodeTools", v"0.4.1", "Compat"],
+    ["CodeTools", v"0.4.1", "JuliaParser"],
+    ["CodeTools", v"0.4.1", "LNR"],
+    ["CodeTools", v"0.4.1", "Lazy"],
+    ["CodeTools", v"0.4.1", "MacroTools"],
+    ["CodeTools", v"0.4.1", "Requires"],
+    ["CodeTools", v"0.4.3", "LNR"],
+    ["CodeTools", v"0.4.3", "Lazy"],
+    ["CodeTools", v"0.4.3", "MacroTools"],
+    ["Codecs", v"0.1.0", "Iterators"],
+    ["Codecs", v"0.1.3"],
+    ["Codecs", v"0.1.5", "Compat"],
+    ["Codecs", v"0.2.0", "Compat", v"0.7.20"],
+    ["Codecs", v"0.3.0", "Compat", v"0.17.0"],
+    ["ColorTypes", v"0.0.1", "FixedPointNumbers", v"0.0.0-", v"0.3.0"],
+    ["ColorTypes", v"0.0.1", "FixedSizeArrays"],
+    ["ColorTypes", v"0.1.7", "Compat"],
+    ["ColorTypes", v"0.1.7", "Docile"],
+    ["ColorTypes", v"0.1.7", "FixedPointNumbers", v"0.0.0-", v"0.3.0"],
+    ["ColorTypes", v"0.2.6", "FixedPointNumbers", v"0.1.0", v"0.3.0"],
+    ["ColorTypes", v"0.2.8", "FixedPointNumbers", v"0.1.0", v"0.3.0"],
+    ["ColorTypes", v"0.2.12", "FixedPointNumbers", v"0.1.0", v"0.3.0"],
+    ["ColorTypes", v"0.3.0", "FixedPointNumbers", v"0.3.0"],
+    ["ColorTypes", v"0.3.2", "Compat", v"0.16.0"],
+    ["ColorTypes", v"0.3.2", "FixedPointNumbers", v"0.3.0"],
+    ["ColorTypes", v"0.3.3", "Compat", v"0.17.0"],
+    ["ColorTypes", v"0.3.3", "FixedPointNumbers", v"0.3.0"],
+    ["ColorTypes", v"0.3.5", "Compat", v"0.18.0"],
+    ["ColorTypes", v"0.3.5", "FixedPointNumbers", v"0.3.0"],
+    ["ColorTypes", v"0.4.1", "Compat", v"0.18.0"],
+    ["ColorTypes", v"0.4.1", "FixedPointNumbers", v"0.3.0"],
+    ["ColorVectorSpace", v"0.0.5", "ColorTypes"],
+    ["ColorVectorSpace", v"0.0.5", "Compat"],
+    ["ColorVectorSpace", v"0.0.5", "FixedPointNumbers", v"0.0.0-", v"0.3.0"],
+    ["ColorVectorSpace", v"0.1.7", "ColorTypes", v"0.2.0"],
+    ["ColorVectorSpace", v"0.1.7", "FixedPointNumbers", v"0.1.0", v"0.3.0"],
+    ["ColorVectorSpace", v"0.1.8", "ColorTypes", v"0.2.0"],
+    ["ColorVectorSpace", v"0.1.8", "Compat", v"0.9.1"],
+    ["ColorVectorSpace", v"0.1.8", "FixedPointNumbers", v"0.1.0", v"0.3.0"],
+    ["ColorVectorSpace", v"0.1.10", "ColorTypes", v"0.2.7"],
+    ["ColorVectorSpace", v"0.1.10", "Compat", v"0.9.1"],
+    ["ColorVectorSpace", v"0.1.10", "FixedPointNumbers", v"0.1.8", v"0.3.0"],
+    ["ColorVectorSpace", v"0.1.12", "ColorTypes", v"0.2.7"],
+    ["ColorVectorSpace", v"0.1.12", "Compat", v"0.9.1"],
+    ["ColorVectorSpace", v"0.1.12", "FixedPointNumbers", v"0.1.8", v"0.3.0"],
+    ["ColorVectorSpace", v"0.2.0", "ColorTypes", v"0.3.0"],
+    ["ColorVectorSpace", v"0.2.0", "Compat", v"0.9.1"],
+    ["ColorVectorSpace", v"0.2.0", "FixedPointNumbers", v"0.3.0"],
+    ["ColorVectorSpace", v"0.3.0", "ColorTypes", v"0.3.3"],
+    ["ColorVectorSpace", v"0.3.0", "Colors", v"0.7.1"],
+    ["ColorVectorSpace", v"0.3.0", "Compat", v"0.9.1"],
+    ["ColorVectorSpace", v"0.3.0", "FixedPointNumbers", v"0.3.0"],
+    ["ColorVectorSpace", v"0.3.0", "StatsBase", v"0.8.2"],
+    ["ColorVectorSpace", v"0.4.0", "ColorTypes", v"0.3.3"],
+    ["ColorVectorSpace", v"0.4.0", "Colors", v"0.7.1"],
+    ["ColorVectorSpace", v"0.4.0", "Compat", v"0.18.0"],
+    ["ColorVectorSpace", v"0.4.0", "FixedPointNumbers", v"0.3.0"],
+    ["ColorVectorSpace", v"0.4.0", "StatsBase", v"0.8.2"],
+    ["ColorVectorSpace", v"0.4.2", "ColorTypes", v"0.4.0"],
+    ["ColorVectorSpace", v"0.4.2", "Colors", v"0.7.1"],
+    ["ColorVectorSpace", v"0.4.2", "Compat", v"0.18.0"],
+    ["ColorVectorSpace", v"0.4.2", "FixedPointNumbers", v"0.3.0"],
+    ["ColorVectorSpace", v"0.4.2", "StatsBase", v"0.8.2"],
+    ["Colors", v"0.4.7", "Compat", v"0.2.0"],
+    ["Colors", v"0.4.7", "Graphics", v"0.1.0"],
+    ["Colors", v"0.4.7", "FixedPointNumbers", v"0.0.0-", v"0.3.0"],
+    ["Colors", v"0.5.0", "ColorTypes"],
+    ["Colors", v"0.5.0", "Reexport"],
+    ["Colors", v"0.5.0", "Compat", v"0.2.0"],
+    ["Colors", v"0.5.0", "Graphics", v"0.1.0"],
+    ["Colors", v"0.5.0", "FixedPointNumbers", v"0.0.0-", v"0.3.0"],
+    ["Colors", v"0.5.4", "ColorTypes"],
+    ["Colors", v"0.5.4", "Reexport"],
+    ["Colors", v"0.5.4", "Compat", v"0.2.0"],
+    ["Colors", v"0.5.4", "FixedPointNumbers", v"0.0.0-", v"0.3.0"],
+    ["Colors", v"0.6.2", "Reexport"],
+    ["Colors", v"0.6.2", "ColorTypes", v"0.2.0"],
+    ["Colors", v"0.6.2", "FixedPointNumbers", v"0.1.0", v"0.3.0"],
+    ["Colors", v"0.6.4", "Compat"],
+    ["Colors", v"0.6.4", "Reexport"],
+    ["Colors", v"0.6.4", "ColorTypes", v"0.2.0"],
+    ["Colors", v"0.6.4", "FixedPointNumbers", v"0.1.0", v"0.3.0"],
+    ["Colors", v"0.6.6", "Reexport"],
+    ["Colors", v"0.6.6", "ColorTypes", v"0.2.0"],
+    ["Colors", v"0.6.6", "Compat", v"0.8.0"],
+    ["Colors", v"0.6.6", "FixedPointNumbers", v"0.1.0", v"0.3.0"],
+    ["Colors", v"0.6.7", "Reexport"],
+    ["Colors", v"0.6.7", "ColorTypes", v"0.2.0"],
+    ["Colors", v"0.6.7", "Compat", v"0.9.1"],
+    ["Colors", v"0.6.7", "FixedPointNumbers", v"0.1.0", v"0.3.0"],
+    ["Colors", v"0.6.8", "Reexport"],
+    ["Colors", v"0.6.8", "ColorTypes", v"0.2.7"],
+    ["Colors", v"0.6.8", "Compat", v"0.9.1"],
+    ["Colors", v"0.6.8", "FixedPointNumbers", v"0.1.8", v"0.3.0"],
+    ["Colors", v"0.6.9", "Reexport"],
+    ["Colors", v"0.6.9", "ColorTypes", v"0.2.9"],
+    ["Colors", v"0.6.9", "Compat", v"0.9.1"],
+    ["Colors", v"0.6.9", "FixedPointNumbers", v"0.1.8", v"0.3.0"],
+    ["Colors", v"0.7.0", "Reexport"],
+    ["Colors", v"0.7.0", "ColorTypes", v"0.3.0"],
+    ["Colors", v"0.7.0", "Compat", v"0.9.1"],
+    ["Colors", v"0.7.0", "FixedPointNumbers", v"0.3.0"],
+    ["Colors", v"0.7.1", "Reexport"],
+    ["Colors", v"0.7.1", "ColorTypes", v"0.3.0"],
+    ["Colors", v"0.7.1", "Compat", v"0.9.1"],
+    ["Colors", v"0.7.1", "FixedPointNumbers", v"0.3.0"],
+    ["Colors", v"0.7.2", "Reexport"],
+    ["Colors", v"0.7.2", "ColorTypes", v"0.3.0"],
+    ["Colors", v"0.7.2", "Compat", v"0.17.0"],
+    ["Colors", v"0.7.2", "FixedPointNumbers", v"0.3.0"],
+    ["Colors", v"0.7.3", "ColorTypes", v"0.3.0"],
+    ["Colors", v"0.7.3", "Compat", v"0.18.0"],
+    ["Colors", v"0.7.3", "FixedPointNumbers", v"0.3.0"],
+    ["Colors", v"0.7.3", "Reexport"],
+    ["Combinatorics", v"0.2.0", "Compat"],
+    ["Combinatorics", v"0.2.0", "Iterators"],
+    ["Combinatorics", v"0.2.0", "Polynomials"],
+    ["Combinatorics", v"0.3.2", "Iterators"],
+    ["Combinatorics", v"0.3.2", "Polynomials"],
+    ["Combinatorics", v"0.4.0", "Compat", v"0.18.0"],
+    ["Combinatorics", v"0.4.0", "Iterators"],
+    ["Combinatorics", v"0.4.0", "Polynomials"],
+    ["Compat", v"0.8.1"],
+    ["Compat", v"0.8.3"],
+    ["Compat", v"0.8.4"],
+    ["Compat", v"0.8.5"],
+    ["Compat", v"0.8.6"],
+    ["Compat", v"0.8.7"],
+    ["Compat", v"0.8.8"],
+    ["Compat", v"0.9.0"],
+    ["Compat", v"0.9.1"],
+    ["Compat", v"0.9.3"],
+    ["Compat", v"0.9.4"],
+    ["Compat", v"0.10.0"],
+    ["Compat", v"0.11.0"],
+    ["Compat", v"0.12.0"],
+    ["Compat", v"0.13.0"],
+    ["Compat", v"0.15.0"],
+    ["Compat", v"0.16.2"],
+    ["Compat", v"0.17.0"],
+    ["Compat", v"0.18.0"],
+    ["Compat", v"0.23.0"],
+    ["Compat", v"0.24.0"],
+    ["ComputationalResources", v"0.0.1"],
+    ["ComputationalResources", v"0.0.2", "Compat", v"0.17.0"],
+    ["Conda", v"0.1.5", "BinDeps"],
+    ["Conda", v"0.1.5", "Compat"],
+    ["Conda", v"0.1.5", "JSON"],
+    ["Conda", v"0.1.9", "BinDeps"],
+    ["Conda", v"0.1.9", "Compat"],
+    ["Conda", v"0.1.9", "JSON"],
+    ["Conda", v"0.2.2", "BinDeps"],
+    ["Conda", v"0.2.2", "Compat", v"0.7.15"],
+    ["Conda", v"0.2.2", "JSON"],
+    ["Conda", v"0.2.4", "BinDeps"],
+    ["Conda", v"0.2.4", "Compat", v"0.8.0"],
+    ["Conda", v"0.2.4", "JSON"],
+    ["Conda", v"0.2.5", "BinDeps"],
+    ["Conda", v"0.2.5", "Compat", v"0.7.20"],
+    ["Conda", v"0.2.5", "JSON"],
+    ["Conda", v"0.3.2", "BinDeps"],
+    ["Conda", v"0.3.2", "Compat", v"0.8.0"],
+    ["Conda", v"0.3.2", "JSON"],
+    ["Conda", v"0.5.3", "BinDeps"],
+    ["Conda", v"0.5.3", "Compat", v"0.8.0"],
+    ["Conda", v"0.5.3", "JSON"],
+    ["CoordinateTransformations", v"0.1.0", "FixedSizeArrays"],
+    ["CoordinateTransformations", v"0.1.0", "Rotations"],
+    ["CoordinateTransformations", v"0.2.0", "Compat", v"0.8.0", v"0.11.0"],
+    ["CoordinateTransformations", v"0.2.0", "FixedSizeArrays", v"0.2.2"],
+    ["CoordinateTransformations", v"0.2.0", "Rotations", v"0.1.0", v"0.2.0+"],
+    ["CoordinateTransformations", v"0.3.2", "Rotations", v"0.3.0"],
+    ["CoordinateTransformations", v"0.3.2", "StaticArrays"],
+    ["CoordinateTransformations", v"0.4.0", "Rotations", v"0.3.0"],
+    ["CoordinateTransformations", v"0.4.0", "StaticArrays"],
+    ["CoordinateTransformations", v"0.4.1", "Compat", v"0.17.0"],
+    ["CoordinateTransformations", v"0.4.1", "Rotations", v"0.3.0"],
+    ["CoordinateTransformations", v"0.4.1", "StaticArrays"],
+    ["CustomUnitRanges", v"0.0.4"],
+    ["DWARF", v"0.0.0", "ELF"],
+    ["DWARF", v"0.0.0", "StrPack"],
+    ["DWARF", v"0.1.0", "AbstractTrees"],
+    ["DWARF", v"0.1.0", "ObjFileBase"],
+    ["DWARF", v"0.1.0", "StructIO"],
+    ["DataArrays", v"0.4.0", "Reexport"],
+    ["DataArrays", v"0.4.0", "SpecialFunctions"],
+    ["DataArrays", v"0.4.0", "Compat", v"0.8.6"],
+    ["DataArrays", v"0.4.0", "StatsBase", v"0.3.0"],
+    ["DataFrames", v"0.0.0", "Options"],
+    ["DataFrames", v"0.0.0", "StatsBase", v"0.0.0", v"0.8.3"],
+    ["DataFrames", v"0.2.2", "GZip"],
+    ["DataFrames", v"0.2.2", "Options"],
+    ["DataFrames", v"0.2.2", "StatsBase", v"0.0.0", v"0.8.3"],
+    ["DataFrames", v"0.3.10", "GZip"],
+    ["DataFrames", v"0.3.10", "StatsBase", v"0.0.0", v"0.8.3"],
+    ["DataFrames", v"0.3.11", "Blocks"],
+    ["DataFrames", v"0.3.11", "GZip"],
+    ["DataFrames", v"0.3.11", "StatsBase", v"0.0.0", v"0.8.3"],
+    ["DataFrames", v"0.3.16", "Blocks"],
+    ["DataFrames", v"0.3.16", "GZip"],
+    ["DataFrames", v"0.3.16", "SortingAlgorithms"],
+    ["DataFrames", v"0.3.16", "StatsBase", v"0.0.0", v"0.8.3"],
+    ["DataFrames", v"0.4.2", "Blocks"],
+    ["DataFrames", v"0.4.2", "DataArrays"],
+    ["DataFrames", v"0.4.2", "GZip"],
+    ["DataFrames", v"0.4.2", "SortingAlgorithms"],
+    ["DataFrames", v"0.4.2", "Stats"],
+    ["DataFrames", v"0.5.0", "Blocks"],
+    ["DataFrames", v"0.5.0", "GZip"],
+    ["DataFrames", v"0.5.0", "SortingAlgorithms"],
+    ["DataFrames", v"0.5.0", "DataArrays", v"0.1.0-"],
+    ["DataFrames", v"0.5.0", "StatsBase", v"0.3.0-", v"0.8.3"],
+    ["DataFrames", v"0.5.3", "Blocks"],
+    ["DataFrames", v"0.5.3", "DataArrays"],
+    ["DataFrames", v"0.5.3", "GZip"],
+    ["DataFrames", v"0.5.3", "SortingAlgorithms"],
+    ["DataFrames", v"0.5.3", "StatsBase", v"0.0.0", v"0.8.3"],
+    ["DataFrames", v"0.5.4", "Blocks"],
+    ["DataFrames", v"0.5.4", "DataArrays"],
+    ["DataFrames", v"0.5.4", "GZip"],
+    ["DataFrames", v"0.5.4", "Reexport"],
+    ["DataFrames", v"0.5.4", "SortingAlgorithms"],
+    ["DataFrames", v"0.5.4", "StatsBase", v"0.3.9+", v"0.8.3"],
+    ["DataFrames", v"0.5.11", "DataArrays"],
+    ["DataFrames", v"0.5.11", "GZip"],
+    ["DataFrames", v"0.5.11", "Reexport"],
+    ["DataFrames", v"0.5.11", "SortingAlgorithms"],
+    ["DataFrames", v"0.5.11", "StatsBase", v"0.3.9+", v"0.8.3"],
+    ["DataFrames", v"0.6.1", "Compat"],
+    ["DataFrames", v"0.6.1", "DataArrays"],
+    ["DataFrames", v"0.6.1", "GZip"],
+    ["DataFrames", v"0.6.1", "Reexport"],
+    ["DataFrames", v"0.6.1", "SortingAlgorithms"],
+    ["DataFrames", v"0.6.1", "StatsBase", v"0.3.9+", v"0.8.3"],
+    ["DataFrames", v"0.6.5", "Compat"],
+    ["DataFrames", v"0.6.5", "DataArrays"],
+    ["DataFrames", v"0.6.5", "Docile"],
+    ["DataFrames", v"0.6.5", "GZip"],
+    ["DataFrames", v"0.6.5", "Reexport"],
+    ["DataFrames", v"0.6.5", "SortingAlgorithms"],
+    ["DataFrames", v"0.6.5", "StatsBase", v"0.3.9+", v"0.8.3"],
+    ["DataFrames", v"0.6.10", "Compat"],
+    ["DataFrames", v"0.6.10", "Docile"],
+    ["DataFrames", v"0.6.10", "GZip"],
+    ["DataFrames", v"0.6.10", "Reexport"],
+    ["DataFrames", v"0.6.10", "SortingAlgorithms"],
+    ["DataFrames", v"0.6.10", "DataArrays", v"0.2.15"],
+    ["DataFrames", v"0.6.10", "StatsBase", v"0.3.9+", v"0.8.3"],
+    ["DataFrames", v"0.7.0", "Docile"],
+    ["DataFrames", v"0.7.0", "GZip"],
+    ["DataFrames", v"0.7.0", "Reexport"],
+    ["DataFrames", v"0.7.0", "SortingAlgorithms"],
+    ["DataFrames", v"0.7.0", "Compat", v"0.7.12"],
+    ["DataFrames", v"0.7.0", "DataArrays", v"0.2.15"],
+    ["DataFrames", v"0.7.0", "StatsBase", v"0.8.0", v"0.8.3"],
+    ["DataFrames", v"0.7.2", "Docile"],
+    ["DataFrames", v"0.7.2", "GZip"],
+    ["DataFrames", v"0.7.2", "Reexport"],
+    ["DataFrames", v"0.7.2", "SortingAlgorithms"],
+    ["DataFrames", v"0.7.2", "Compat", v"0.7.17"],
+    ["DataFrames", v"0.7.2", "DataArrays", v"0.2.15"],
+    ["DataFrames", v"0.7.2", "StatsBase", v"0.8.0", v"0.8.3"],
+    ["DataFrames", v"0.7.3", "Docile"],
+    ["DataFrames", v"0.7.3", "GZip"],
+    ["DataFrames", v"0.7.3", "Reexport"],
+    ["DataFrames", v"0.7.3", "SortingAlgorithms"],
+    ["DataFrames", v"0.7.3", "Compat", v"0.7.19"],
+    ["DataFrames", v"0.7.3", "DataArrays", v"0.2.15"],
+    ["DataFrames", v"0.7.3", "StatsBase", v"0.8.0", v"0.8.3"],
+    ["DataFrames", v"0.7.4", "Docile"],
+    ["DataFrames", v"0.7.4", "GZip"],
+    ["DataFrames", v"0.7.4", "Reexport"],
+    ["DataFrames", v"0.7.4", "SortingAlgorithms"],
+    ["DataFrames", v"0.7.4", "Compat", v"0.7.19"],
+    ["DataFrames", v"0.7.4", "DataArrays", v"0.3.4"],
+    ["DataFrames", v"0.7.4", "StatsBase", v"0.8.0", v"0.8.3"],
+    ["DataFrames", v"0.7.6", "Docile"],
+    ["DataFrames", v"0.7.6", "GZip"],
+    ["DataFrames", v"0.7.6", "Reexport"],
+    ["DataFrames", v"0.7.6", "SortingAlgorithms"],
+    ["DataFrames", v"0.7.6", "Compat", v"0.7.19"],
+    ["DataFrames", v"0.7.6", "DataArrays", v"0.3.4"],
+    ["DataFrames", v"0.7.6", "StatsBase", v"0.8.3"],
+    ["DataFrames", v"0.7.8", "GZip"],
+    ["DataFrames", v"0.7.8", "Reexport"],
+    ["DataFrames", v"0.7.8", "SortingAlgorithms"],
+    ["DataFrames", v"0.7.8", "Compat", v"0.8.0"],
+    ["DataFrames", v"0.7.8", "DataArrays", v"0.3.4"],
+    ["DataFrames", v"0.7.8", "StatsBase", v"0.8.3"],
+    ["DataFrames", v"0.8.0", "GZip"],
+    ["DataFrames", v"0.8.0", "Reexport"],
+    ["DataFrames", v"0.8.0", "SortingAlgorithms"],
+    ["DataFrames", v"0.8.0", "Compat", v"0.8.4"],
+    ["DataFrames", v"0.8.0", "DataArrays", v"0.3.4"],
+    ["DataFrames", v"0.8.0", "StatsBase", v"0.8.3"],
+    ["DataFrames", v"0.8.3", "GZip"],
+    ["DataFrames", v"0.8.3", "Reexport"],
+    ["DataFrames", v"0.8.3", "SortingAlgorithms"],
+    ["DataFrames", v"0.8.3", "Compat", v"0.8.4"],
+    ["DataFrames", v"0.8.3", "DataArrays", v"0.3.4"],
+    ["DataFrames", v"0.8.3", "FileIO", v"0.1.2"],
+    ["DataFrames", v"0.8.3", "StatsBase", v"0.8.3"],
+    ["DataFrames", v"0.8.4", "GZip"],
+    ["DataFrames", v"0.8.4", "Reexport"],
+    ["DataFrames", v"0.8.4", "SortingAlgorithms"],
+    ["DataFrames", v"0.8.4", "Compat", v"0.8.4"],
+    ["DataFrames", v"0.8.4", "DataArrays", v"0.3.4"],
+    ["DataFrames", v"0.8.4", "FileIO", v"0.1.2"],
+    ["DataFrames", v"0.8.4", "StatsBase", v"0.11.0"],
+    ["DataFrames", v"0.8.5", "GZip"],
+    ["DataFrames", v"0.8.5", "Reexport"],
+    ["DataFrames", v"0.8.5", "SortingAlgorithms"],
+    ["DataFrames", v"0.8.5", "Compat", v"0.8.4"],
+    ["DataFrames", v"0.8.5", "DataArrays", v"0.3.4"],
+    ["DataFrames", v"0.8.5", "FileIO", v"0.1.2"],
+    ["DataFrames", v"0.8.5", "Juno", v"0.2.4"],
+    ["DataFrames", v"0.8.5", "StatsBase", v"0.11.0"],
+    ["DataFrames", v"0.9.1", "GZip"],
+    ["DataFrames", v"0.9.1", "Reexport"],
+    ["DataFrames", v"0.9.1", "SortingAlgorithms"],
+    ["DataFrames", v"0.9.1", "Compat", v"0.18.0"],
+    ["DataFrames", v"0.9.1", "DataArrays", v"0.3.4"],
+    ["DataFrames", v"0.9.1", "FileIO", v"0.1.2"],
+    ["DataFrames", v"0.9.1", "StatsBase", v"0.11.0"],
+    ["DataStructures", v"0.4.5"],
+    ["DataStructures", v"0.4.6", "Compat", v"0.8.5"],
+    ["DataStructures", v"0.5.1", "Compat", v"0.9.4"],
+    ["DataStructures", v"0.5.2", "Compat", v"0.9.4"],
+    ["DataStructures", v"0.5.3", "Compat", v"0.17.0"],
+    ["Dates", v"0.4.4"],
+    ["DelayDiffEq", v"0.0.1", "Combinatorics"],
+    ["DelayDiffEq", v"0.0.1", "DataStructures", v"0.4.6"],
+    ["DelayDiffEq", v"0.0.1", "DiffEqBase", v"0.5.0", v"0.7.0"],
+    ["DelayDiffEq", v"0.0.1", "RecursiveArrayTools", v"0.1.2"],
+    ["DelayDiffEq", v"0.0.1", "OrdinaryDiffEq", v"1.0.0", v"1.2.0"],
+    ["DelayDiffEq", v"0.1.0", "Combinatorics"],
+    ["DelayDiffEq", v"0.1.0", "DataStructures", v"0.4.6"],
+    ["DelayDiffEq", v"0.1.0", "DiffEqBase", v"0.8.0", v"0.15.0"],
+    ["DelayDiffEq", v"0.1.0", "OrdinaryDiffEq", v"1.2.0"],
+    ["DelayDiffEq", v"0.1.0", "RecursiveArrayTools", v"0.2.0"],
+    ["DelayDiffEq", v"0.2.0", "Combinatorics"],
+    ["DelayDiffEq", v"0.2.0", "DataStructures", v"0.4.6"],
+    ["DelayDiffEq", v"0.2.0", "DiffEqBase", v"0.8.0", v"0.15.0"],
+    ["DelayDiffEq", v"0.2.0", "OrdinaryDiffEq", v"1.6.0"],
+    ["DelayDiffEq", v"0.2.0", "RecursiveArrayTools", v"0.2.0"],
+    ["DelayDiffEq", v"0.3.0", "Combinatorics"],
+    ["DelayDiffEq", v"0.3.0", "DataStructures", v"0.4.6"],
+    ["DelayDiffEq", v"0.3.0", "DiffEqBase", v"0.15.0"],
+    ["DelayDiffEq", v"0.3.0", "OrdinaryDiffEq", v"1.6.0"],
+    ["DelayDiffEq", v"0.3.0", "RecursiveArrayTools", v"0.2.0"],
+    ["DiffBase", v"0.0.2", "Compat", v"0.7.15"],
+    ["DiffBase", v"0.1.0", "Compat", v"0.7.15"],
+    ["DiffEqBase", v"0.0.1", "RecipesBase", v"0.1.0"],
+    ["DiffEqBase", v"0.0.4", "Ranges", v"0.0.1"],
+    ["DiffEqBase", v"0.0.4", "RecipesBase", v"0.1.0"],
+    ["DiffEqBase", v"0.1.0", "Parameters"],
+    ["DiffEqBase", v"0.1.0", "Ranges", v"0.0.1"],
+    ["DiffEqBase", v"0.1.0", "RecursiveArrayTools"],
+    ["DiffEqBase", v"0.1.0", "RecipesBase", v"0.1.0"],
+    ["DiffEqBase", v"0.1.1", "Parameters"],
+    ["DiffEqBase", v"0.1.1", "Ranges", v"0.0.1"],
+    ["DiffEqBase", v"0.1.1", "RecursiveArrayTools"],
+    ["DiffEqBase", v"0.1.1", "RecipesBase", v"0.1.0"],
+    ["DiffEqBase", v"0.1.2", "Parameters", v"0.5.0"],
+    ["DiffEqBase", v"0.1.2", "Ranges", v"0.0.1"],
+    ["DiffEqBase", v"0.1.2", "RecipesBase", v"0.1.0"],
+    ["DiffEqBase", v"0.1.2", "RecursiveArrayTools", v"0.0.2"],
+    ["DiffEqBase", v"0.1.3", "Parameters", v"0.5.0"],
+    ["DiffEqBase", v"0.1.3", "Ranges", v"0.0.1"],
+    ["DiffEqBase", v"0.1.3", "RecipesBase", v"0.1.0"],
+    ["DiffEqBase", v"0.1.3", "RecursiveArrayTools", v"0.0.2"],
+    ["DiffEqBase", v"0.2.0", "Parameters", v"0.5.0"],
+    ["DiffEqBase", v"0.2.0", "Ranges", v"0.0.1"],
+    ["DiffEqBase", v"0.2.0", "RecipesBase", v"0.1.0"],
+    ["DiffEqBase", v"0.2.0", "RecursiveArrayTools", v"0.0.2"],
+    ["DiffEqBase", v"0.3.2", "Parameters", v"0.5.0"],
+    ["DiffEqBase", v"0.3.2", "Ranges", v"0.0.1"],
+    ["DiffEqBase", v"0.3.2", "RecipesBase", v"0.1.0"],
+    ["DiffEqBase", v"0.3.2", "RecursiveArrayTools", v"0.0.2"],
+    ["DiffEqBase", v"0.3.2", "SimpleTraits", v"0.1.1"],
+    ["DiffEqBase", v"0.4.0", "Parameters", v"0.5.0"],
+    ["DiffEqBase", v"0.4.0", "Ranges", v"0.0.1"],
+    ["DiffEqBase", v"0.4.0", "RecipesBase", v"0.1.0"],
+    ["DiffEqBase", v"0.4.0", "RecursiveArrayTools", v"0.0.2"],
+    ["DiffEqBase", v"0.4.0", "SimpleTraits", v"0.1.1"],
+    ["DiffEqBase", v"0.4.1", "Parameters", v"0.5.0"],
+    ["DiffEqBase", v"0.4.1", "Ranges", v"0.0.1"],
+    ["DiffEqBase", v"0.4.1", "RecipesBase", v"0.1.0"],
+    ["DiffEqBase", v"0.4.1", "RecursiveArrayTools", v"0.0.2"],
+    ["DiffEqBase", v"0.4.1", "SimpleTraits", v"0.1.1"],
+    ["DiffEqBase", v"0.5.0", "Parameters", v"0.5.0"],
+    ["DiffEqBase", v"0.5.0", "Ranges", v"0.0.1"],
+    ["DiffEqBase", v"0.5.0", "RecipesBase", v"0.1.0"],
+    ["DiffEqBase", v"0.5.0", "RecursiveArrayTools", v"0.0.2"],
+    ["DiffEqBase", v"0.5.0", "SimpleTraits", v"0.1.1"],
+    ["DiffEqBase", v"0.6.0", "Parameters", v"0.5.0"],
+    ["DiffEqBase", v"0.6.0", "Ranges", v"0.0.1"],
+    ["DiffEqBase", v"0.6.0", "RecipesBase", v"0.1.0"],
+    ["DiffEqBase", v"0.6.0", "RecursiveArrayTools", v"0.0.2"],
+    ["DiffEqBase", v"0.6.0", "SimpleTraits", v"0.1.1"],
+    ["DiffEqBase", v"0.7.0", "Parameters", v"0.5.0"],
+    ["DiffEqBase", v"0.7.0", "Ranges", v"0.0.1"],
+    ["DiffEqBase", v"0.7.0", "RecipesBase", v"0.1.0"],
+    ["DiffEqBase", v"0.7.0", "RecursiveArrayTools", v"0.0.2"],
+    ["DiffEqBase", v"0.7.0", "SimpleTraits", v"0.1.1"],
+    ["DiffEqBase", v"0.10.0", "Parameters", v"0.5.0"],
+    ["DiffEqBase", v"0.10.0", "Ranges", v"0.0.1"],
+    ["DiffEqBase", v"0.10.0", "RecipesBase", v"0.1.0"],
+    ["DiffEqBase", v"0.10.0", "RecursiveArrayTools", v"0.2.0"],
+    ["DiffEqBase", v"0.10.0", "SimpleTraits", v"0.1.1"],
+    ["DiffEqBase", v"0.11.0", "Parameters", v"0.5.0"],
+    ["DiffEqBase", v"0.11.0", "Ranges", v"0.0.1"],
+    ["DiffEqBase", v"0.11.0", "RecipesBase", v"0.1.0"],
+    ["DiffEqBase", v"0.11.0", "RecursiveArrayTools", v"0.2.0"],
+    ["DiffEqBase", v"0.11.0", "SimpleTraits", v"0.1.1"],
+    ["DiffEqBase", v"0.12.1", "Compat", v"0.19.0"],
+    ["DiffEqBase", v"0.12.1", "Parameters", v"0.5.0"],
+    ["DiffEqBase", v"0.12.1", "Ranges", v"0.0.1"],
+    ["DiffEqBase", v"0.12.1", "RecipesBase", v"0.1.0"],
+    ["DiffEqBase", v"0.12.1", "RecursiveArrayTools", v"0.2.0"],
+    ["DiffEqBase", v"0.12.1", "SimpleTraits", v"0.1.1"],
+    ["DiffEqBase", v"0.13.0", "Compat", v"0.19.0"],
+    ["DiffEqBase", v"0.13.0", "Parameters", v"0.5.0"],
+    ["DiffEqBase", v"0.13.0", "Ranges", v"0.0.1"],
+    ["DiffEqBase", v"0.13.0", "RecipesBase", v"0.1.0"],
+    ["DiffEqBase", v"0.13.0", "RecursiveArrayTools", v"0.2.0"],
+    ["DiffEqBase", v"0.13.0", "SimpleTraits", v"0.1.1"],
+    ["DiffEqBase", v"0.14.0", "Compat", v"0.19.0"],
+    ["DiffEqBase", v"0.14.0", "Parameters", v"0.5.0"],
+    ["DiffEqBase", v"0.14.0", "Ranges", v"0.0.1"],
+    ["DiffEqBase", v"0.14.0", "RecipesBase", v"0.1.0"],
+    ["DiffEqBase", v"0.14.0", "RecursiveArrayTools", v"0.2.0"],
+    ["DiffEqBase", v"0.14.0", "SimpleTraits", v"0.1.1"],
+    ["DiffEqBase", v"0.15.0", "Compat", v"0.19.0"],
+    ["DiffEqBase", v"0.15.0", "Parameters", v"0.5.0"],
+    ["DiffEqBase", v"0.15.0", "Ranges", v"0.0.1"],
+    ["DiffEqBase", v"0.15.0", "RecipesBase", v"0.1.0"],
+    ["DiffEqBase", v"0.15.0", "RecursiveArrayTools", v"0.2.0"],
+    ["DiffEqBase", v"0.15.0", "SimpleTraits", v"0.1.1"],
+    ["DiffEqBiological", v"0.0.1", "DiffEqBase"],
+    ["DiffEqBiological", v"0.0.1", "DiffEqJump"],
+    ["DiffEqCallbacks", v"0.0.2", "DiffEqBase", v"0.6.0"],
+    ["DiffEqDevTools", v"0.0.1", "DiffEqBase", v"0.0.0", v"0.5.0"],
+    ["DiffEqDevTools", v"0.0.1", "FiniteElementDiffEq"],
+    ["DiffEqDevTools", v"0.0.1", "OrdinaryDiffEq"],
+    ["DiffEqDevTools", v"0.0.1", "StochasticDiffEq"],
+    ["DiffEqDevTools", v"0.0.1", "RecipesBase", v"0.1.0"],
+    ["DiffEqDevTools", v"0.1.0", "DiffEqBase", v"0.0.0", v"0.5.0"],
+    ["DiffEqDevTools", v"0.1.0", "FiniteElementDiffEq"],
+    ["DiffEqDevTools", v"0.1.0", "OrdinaryDiffEq"],
+    ["DiffEqDevTools", v"0.1.0", "RecursiveArrayTools"],
+    ["DiffEqDevTools", v"0.1.0", "StochasticDiffEq"],
+    ["DiffEqDevTools", v"0.1.0", "RecipesBase", v"0.1.0"],
+    ["DiffEqDevTools", v"0.1.1", "DiffEqBase", v"0.1.3", v"0.5.0"],
+    ["DiffEqDevTools", v"0.1.1", "FiniteElementDiffEq", v"0.0.5"],
+    ["DiffEqDevTools", v"0.1.1", "OrdinaryDiffEq", v"0.1.1"],
+    ["DiffEqDevTools", v"0.1.1", "RecipesBase", v"0.1.0"],
+    ["DiffEqDevTools", v"0.1.1", "RecursiveArrayTools", v"0.0.2"],
+    ["DiffEqDevTools", v"0.1.1", "StochasticDiffEq", v"0.0.5"],
+    ["DiffEqDevTools", v"0.2.0", "DiffEqBase", v"0.2.0", v"0.5.0"],
+    ["DiffEqDevTools", v"0.2.0", "FiniteElementDiffEq", v"0.0.5"],
+    ["DiffEqDevTools", v"0.2.0", "RecipesBase", v"0.1.0"],
+    ["DiffEqDevTools", v"0.2.0", "RecursiveArrayTools", v"0.0.2"],
+    ["DiffEqDevTools", v"0.3.0", "DiffEqBase", v"0.3.0", v"0.5.0"],
+    ["DiffEqDevTools", v"0.3.0", "RecipesBase", v"0.1.0"],
+    ["DiffEqDevTools", v"0.3.0", "RecursiveArrayTools", v"0.0.2"],
+    ["DiffEqDevTools", v"0.4.0", "DiffEqBase", v"0.4.0", v"0.5.0"],
+    ["DiffEqDevTools", v"0.4.0", "RecipesBase", v"0.1.0"],
+    ["DiffEqDevTools", v"0.4.0", "RecursiveArrayTools", v"0.1.2"],
+    ["DiffEqDevTools", v"0.5.0", "DiffEqBase", v"0.4.0", v"0.5.0"],
+    ["DiffEqDevTools", v"0.5.0", "DiffEqPDEBase"],
+    ["DiffEqDevTools", v"0.5.0", "RecipesBase", v"0.1.0"],
+    ["DiffEqDevTools", v"0.5.0", "RecursiveArrayTools", v"0.1.2"],
+    ["DiffEqDevTools", v"0.6.0", "DiffEqBase", v"0.5.0", v"0.15.0"],
+    ["DiffEqDevTools", v"0.6.0", "DiffEqPDEBase"],
+    ["DiffEqDevTools", v"0.6.0", "RecipesBase", v"0.1.0"],
+    ["DiffEqDevTools", v"0.6.0", "RecursiveArrayTools", v"0.1.2"],
+    ["DiffEqDevTools", v"0.7.0", "DiffEqBase", v"0.15.0"],
+    ["DiffEqDevTools", v"0.7.0", "DiffEqPDEBase"],
+    ["DiffEqDevTools", v"0.7.0", "RecipesBase", v"0.1.0"],
+    ["DiffEqDevTools", v"0.7.0", "RecursiveArrayTools", v"0.1.2"],
+    ["DiffEqFinancial", v"0.0.1", "DiffEqBase", v"0.0.0", v"0.15.0"],
+    ["DiffEqFinancial", v"0.0.1", "StochasticDiffEq"],
+    ["DiffEqFinancial", v"0.1.0", "DiffEqBase", v"0.15.0"],
+    ["DiffEqFinancial", v"0.1.0", "StochasticDiffEq"],
+    ["DiffEqJump", v"0.0.1", "DiffEqBase"],
+    ["DiffEqJump", v"0.2.0", "DiffEqBase"],
+    ["DiffEqJump", v"0.2.0", "RecursiveArrayTools"],
+    ["DiffEqJump", v"0.3.0", "DiffEqBase", v"0.13.0"],
+    ["DiffEqJump", v"0.3.0", "RecursiveArrayTools"],
+    ["DiffEqMonteCarlo", v"0.1.0", "DiffEqBase", v"0.6.0", v"0.14.0"],
+    ["DiffEqMonteCarlo", v"0.1.0", "RecipesBase", v"0.1.0"],
+    ["DiffEqMonteCarlo", v"0.2.0", "DiffEqBase", v"0.14.0"],
+    ["DiffEqPDEBase", v"0.0.1", "ChunkedArrays"],
+    ["DiffEqPDEBase", v"0.0.1", "DiffEqBase", v"0.0.0", v"0.15.0"],
+    ["DiffEqPDEBase", v"0.0.1", "RecipesBase"],
+    ["DiffEqPDEBase", v"0.0.1", "VectorizedRoutines"],
+    ["DiffEqPDEBase", v"0.0.3", "ChunkedArrays"],
+    ["DiffEqPDEBase", v"0.0.3", "DiffEqBase", v"0.4.1", v"0.15.0"],
+    ["DiffEqPDEBase", v"0.0.3", "RecipesBase"],
+    ["DiffEqPDEBase", v"0.0.3", "VectorizedRoutines"],
+    ["DiffEqPDEBase", v"0.1.0", "ChunkedArrays"],
+    ["DiffEqPDEBase", v"0.1.0", "Compat", v"0.17.0"],
+    ["DiffEqPDEBase", v"0.1.0", "DiffEqBase", v"0.4.1", v"0.15.0"],
+    ["DiffEqPDEBase", v"0.1.0", "RecipesBase"],
+    ["DiffEqPDEBase", v"0.1.0", "VectorizedRoutines"],
+    ["DiffEqPDEBase", v"0.2.0", "ChunkedArrays"],
+    ["DiffEqPDEBase", v"0.2.0", "Compat", v"0.17.0"],
+    ["DiffEqPDEBase", v"0.2.0", "DiffEqBase", v"0.15.0"],
+    ["DiffEqPDEBase", v"0.2.0", "RecipesBase"],
+    ["DiffEqPDEBase", v"0.2.0", "VectorizedRoutines"],
+    ["DiffEqParamEstim", v"0.0.1", "DiffEqBase", v"0.0.0", v"0.14.0"],
+    ["DiffEqParamEstim", v"0.0.1", "LossFunctions"],
+    ["DiffEqParamEstim", v"0.0.1", "LsqFit"],
+    ["DiffEqParamEstim", v"0.0.1", "OrdinaryDiffEq"],
+    ["DiffEqParamEstim", v"0.0.1", "RecursiveArrayTools"],
+    ["DiffEqParamEstim", v"0.0.2", "DiffEqBase", v"0.1.2", v"0.14.0"],
+    ["DiffEqParamEstim", v"0.0.2", "LossFunctions", v"0.0.2"],
+    ["DiffEqParamEstim", v"0.0.2", "LsqFit", v"0.0.2"],
+    ["DiffEqParamEstim", v"0.0.2", "OrdinaryDiffEq", v"0.1.1"],
+    ["DiffEqParamEstim", v"0.0.2", "RecursiveArrayTools", v"0.0.2"],
+    ["DiffEqParamEstim", v"0.0.4", "DiffEqBase", v"0.1.2", v"0.14.0"],
+    ["DiffEqParamEstim", v"0.0.4", "LossFunctions", v"0.0.2"],
+    ["DiffEqParamEstim", v"0.0.4", "LsqFit", v"0.0.2"],
+    ["DiffEqParamEstim", v"0.0.4", "RecursiveArrayTools", v"0.0.2"],
+    ["DiffEqParamEstim", v"0.1.0", "Calculus"],
+    ["DiffEqParamEstim", v"0.1.0", "DiffEqBase", v"0.1.2", v"0.14.0"],
+    ["DiffEqParamEstim", v"0.1.0", "ForwardDiff"],
+    ["DiffEqParamEstim", v"0.1.0", "LossFunctions", v"0.0.2"],
+    ["DiffEqParamEstim", v"0.1.0", "LsqFit", v"0.0.2"],
+    ["DiffEqParamEstim", v"0.1.0", "RecursiveArrayTools", v"0.0.2"],
+    ["DiffEqParamEstim", v"0.2.0", "Calculus"],
+    ["DiffEqParamEstim", v"0.2.0", "Optim"],
+    ["DiffEqParamEstim", v"0.2.0", "Compat", v"0.17.0"],
+    ["DiffEqParamEstim", v"0.2.0", "DiffEqBase", v"0.14.0"],
+    ["DiffEqParamEstim", v"0.2.0", "ForwardDiff"],
+    ["DiffEqParamEstim", v"0.2.0", "LossFunctions", v"0.0.2"],
+    ["DiffEqParamEstim", v"0.2.0", "LsqFit", v"0.0.2"],
+    ["DiffEqParamEstim", v"0.2.0", "RecursiveArrayTools", v"0.0.2"],
+    ["DiffEqProblemLibrary", v"0.0.1", "AlgebraicDiffEq"],
+    ["DiffEqProblemLibrary", v"0.0.1", "DiffEqBase", v"0.0.0", v"0.15.0"],
+    ["DiffEqProblemLibrary", v"0.0.1", "FiniteElementDiffEq"],
+    ["DiffEqProblemLibrary", v"0.0.1", "JLD", v"0.6.5"],
+    ["DiffEqProblemLibrary", v"0.0.1", "OrdinaryDiffEq"],
+    ["DiffEqProblemLibrary", v"0.0.1", "ParameterizedFunctions", v"0.2.0"],
+    ["DiffEqProblemLibrary", v"0.0.1", "StochasticDiffEq"],
+    ["DiffEqProblemLibrary", v"0.1.0", "AlgebraicDiffEq"],
+    ["DiffEqProblemLibrary", v"0.1.0", "DiffEqBase", v"0.0.0", v"0.15.0"],
+    ["DiffEqProblemLibrary", v"0.1.0", "FiniteElementDiffEq"],
+    ["DiffEqProblemLibrary", v"0.1.0", "JLD", v"0.6.5"],
+    ["DiffEqProblemLibrary", v"0.1.0", "ParameterizedFunctions", v"0.2.0"],
+    ["DiffEqProblemLibrary", v"0.1.0", "StochasticDiffEq"],
+    ["DiffEqProblemLibrary", v"0.2.0", "AlgebraicDiffEq", v"0.0.2"],
+    ["DiffEqProblemLibrary", v"0.2.0", "DiffEqBase", v"0.2.0", v"0.15.0"],
+    ["DiffEqProblemLibrary", v"0.2.0", "FiniteElementDiffEq", v"0.0.5"],
+    ["DiffEqProblemLibrary", v"0.2.0", "JLD", v"0.6.5"],
+    ["DiffEqProblemLibrary", v"0.2.0", "ParameterizedFunctions", v"0.2.0"],
+    ["DiffEqProblemLibrary", v"0.2.0", "StochasticDiffEq", v"0.1.0"],
+    ["DiffEqProblemLibrary", v"0.3.2", "AlgebraicDiffEq", v"0.0.2"],
+    ["DiffEqProblemLibrary", v"0.3.2", "DiffEqBase", v"0.2.0", v"0.15.0"],
+    ["DiffEqProblemLibrary", v"0.3.2", "FiniteElementDiffEq", v"0.0.5"],
+    ["DiffEqProblemLibrary", v"0.3.2", "JLD", v"0.6.5"],
+    ["DiffEqProblemLibrary", v"0.3.2", "ParameterizedFunctions", v"0.2.0"],
+    ["DiffEqProblemLibrary", v"0.4.0", "DiffEqBase", v"0.2.0", v"0.15.0"],
+    ["DiffEqProblemLibrary", v"0.4.0", "DiffEqPDEBase"],
+    ["DiffEqProblemLibrary", v"0.4.0", "FiniteElementDiffEq", v"0.0.5"],
+    ["DiffEqProblemLibrary", v"0.4.0", "JLD", v"0.6.5"],
+    ["DiffEqProblemLibrary", v"0.4.0", "ParameterizedFunctions", v"0.5.0"],
+    ["DiffEqProblemLibrary", v"0.5.0", "DiffEqBase", v"0.15.0"],
+    ["DiffEqProblemLibrary", v"0.5.0", "DiffEqPDEBase"],
+    ["DiffEqProblemLibrary", v"0.5.0", "JLD", v"0.6.5"],
+    ["DiffEqProblemLibrary", v"0.5.0", "ParameterizedFunctions", v"0.5.0"],
+    ["DiffEqSensitivity", v"0.0.1", "DiffEqBase", v"0.0.0", v"0.15.0"],
+    ["DiffEqSensitivity", v"0.0.2", "DiffEqBase", v"0.1.2", v"0.15.0"],
+    ["DiffEqSensitivity", v"0.0.4", "DiffEqBase", v"0.2.0", v"0.15.0"],
+    ["DiffEqSensitivity", v"0.1.0", "DiffEqBase", v"0.15.0"],
+    ["DifferentialEquations", v"0.4.0", "ChunkedArrays", v"0.0.2"],
+    ["DifferentialEquations", v"0.4.0", "Compat", v"0.8.8"],
+    ["DifferentialEquations", v"0.4.0", "DiffEqBase", v"0.0.0", v"0.15.0"],
+    ["DifferentialEquations", v"0.4.0", "ForwardDiff", v"0.2.4"],
+    ["DifferentialEquations", v"0.4.0", "GenericSVD", v"0.0.2"],
+    ["DifferentialEquations", v"0.4.0", "InplaceOps", v"0.0.5"],
+    ["DifferentialEquations", v"0.4.0", "IterativeSolvers", v"0.2.2"],
+    ["DifferentialEquations", v"0.4.0", "Parameters", v"0.3.1"],
+    ["DifferentialEquations", v"0.4.0", "OrdinaryDiffEq", v"0.0.0", v"1.2.0"],
+    ["DifferentialEquations", v"0.4.0", "Plots", v"0.9.2"],
+    ["DifferentialEquations", v"0.4.0", "SIUnits", v"0.0.6"],
+    ["DifferentialEquations", v"0.4.0", "StochasticDiffEq", v"0.0.0", v"1.0.0"],
+    ["DifferentialEquations", v"0.4.2", "ChunkedArrays", v"0.0.2"],
+    ["DifferentialEquations", v"0.4.2", "Compat", v"0.8.8"],
+    ["DifferentialEquations", v"0.4.2", "DiffEqBase", v"0.0.0", v"0.15.0"],
+    ["DifferentialEquations", v"0.4.2", "ForwardDiff", v"0.2.4"],
+    ["DifferentialEquations", v"0.4.2", "GenericSVD", v"0.0.2"],
+    ["DifferentialEquations", v"0.4.2", "InplaceOps", v"0.0.5"],
+    ["DifferentialEquations", v"0.4.2", "IterativeSolvers", v"0.2.2"],
+    ["DifferentialEquations", v"0.4.2", "Parameters", v"0.5.0"],
+    ["DifferentialEquations", v"0.4.2", "OrdinaryDiffEq", v"0.0.0", v"1.2.0"],
+    ["DifferentialEquations", v"0.4.2", "Plots", v"0.9.2"],
+    ["DifferentialEquations", v"0.4.2", "SIUnits", v"0.0.6"],
+    ["DifferentialEquations", v"0.4.2", "StochasticDiffEq", v"0.0.0", v"1.0.0"],
+    ["DifferentialEquations", v"0.5.0", "ChunkedArrays", v"0.0.2"],
+    ["DifferentialEquations", v"0.5.0", "Compat", v"0.8.8"],
+    ["DifferentialEquations", v"0.5.0", "DiffEqBase", v"0.0.0", v"0.15.0"],
+    ["DifferentialEquations", v"0.5.0", "ForwardDiff", v"0.2.4"],
+    ["DifferentialEquations", v"0.5.0", "GenericSVD", v"0.0.2"],
+    ["DifferentialEquations", v"0.5.0", "InplaceOps", v"0.0.5"],
+    ["DifferentialEquations", v"0.5.0", "IterativeSolvers", v"0.2.2"],
+    ["DifferentialEquations", v"0.5.0", "NLsolve", v"0.7.3"],
+    ["DifferentialEquations", v"0.5.0", "Parameters", v"0.5.0"],
+    ["DifferentialEquations", v"0.5.0", "OrdinaryDiffEq", v"0.0.0", v"1.2.0"],
+    ["DifferentialEquations", v"0.5.0", "Plots", v"0.9.2"],
+    ["DifferentialEquations", v"0.5.0", "Ranges", v"0.0.1"],
+    ["DifferentialEquations", v"0.5.0", "StochasticDiffEq", v"0.0.0", v"1.0.0"],
+    ["DifferentialEquations", v"0.5.0", "Sundials", v"0.3.0"],
+    ["DifferentialEquations", v"1.0.0", "AlgebraicDiffEq"],
+    ["DifferentialEquations", v"1.0.0", "DiffEqDevTools"],
+    ["DifferentialEquations", v"1.0.0", "DiffEqParamEstim"],
+    ["DifferentialEquations", v"1.0.0", "DiffEqSensitivity"],
+    ["DifferentialEquations", v"1.0.0", "FiniteElementDiffEq"],
+    ["DifferentialEquations", v"1.0.0", "Reexport"],
+    ["DifferentialEquations", v"1.0.0", "DiffEqBase", v"0.0.0", v"0.15.0"],
+    ["DifferentialEquations", v"1.0.0", "OrdinaryDiffEq", v"0.0.0", v"1.2.0"],
+    ["DifferentialEquations", v"1.0.0", "StochasticDiffEq", v"0.0.0", v"1.0.0"],
+    ["DifferentialEquations", v"1.0.0", "StokesDiffEq"],
+    ["DifferentialEquations", v"1.0.0", "Sundials"],
+    ["DifferentialEquations", v"1.1.0", "AlgebraicDiffEq", v"0.0.2"],
+    ["DifferentialEquations", v"1.1.0", "DiffEqBase", v"0.1.3", v"0.15.0"],
+    ["DifferentialEquations", v"1.1.0", "DiffEqDevTools", v"0.1.1"],
+    ["DifferentialEquations", v"1.1.0", "DiffEqParamEstim", v"0.0.2"],
+    ["DifferentialEquations", v"1.1.0", "DiffEqSensitivity", v"0.0.2"],
+    ["DifferentialEquations", v"1.1.0", "FiniteElementDiffEq", v"0.0.5"],
+    ["DifferentialEquations", v"1.1.0", "OrdinaryDiffEq", v"0.1.1", v"1.2.0"],
+    ["DifferentialEquations", v"1.1.0", "ParameterizedFunctions", v"0.3.2"],
+    ["DifferentialEquations", v"1.1.0", "Reexport", v"0.0.3"],
+    ["DifferentialEquations", v"1.1.0", "StochasticDiffEq", v"0.0.5", v"1.0.0"],
+    ["DifferentialEquations", v"1.1.0", "StokesDiffEq", v"0.0.2"],
+    ["DifferentialEquations", v"1.1.0", "Sundials", v"0.3.0"],
+    ["DifferentialEquations", v"1.4.0", "AlgebraicDiffEq", v"0.0.2"],
+    ["DifferentialEquations", v"1.4.0", "DiffEqBase", v"0.2.0", v"0.15.0"],
+    ["DifferentialEquations", v"1.4.0", "DiffEqDevTools", v"0.2.0"],
+    ["DifferentialEquations", v"1.4.0", "DiffEqParamEstim", v"0.0.2"],
+    ["DifferentialEquations", v"1.4.0", "DiffEqProblemLibrary", v"0.2.0"],
+    ["DifferentialEquations", v"1.4.0", "DiffEqSensitivity", v"0.0.2"],
+    ["DifferentialEquations", v"1.4.0", "FiniteElementDiffEq", v"0.0.5"],
+    ["DifferentialEquations", v"1.4.0", "OrdinaryDiffEq", v"0.2.0", v"1.2.0"],
+    ["DifferentialEquations", v"1.4.0", "ParameterizedFunctions", v"0.3.2"],
+    ["DifferentialEquations", v"1.4.0", "Reexport", v"0.0.3"],
+    ["DifferentialEquations", v"1.4.0", "StochasticDiffEq", v"0.1.0", v"1.0.0"],
+    ["DifferentialEquations", v"1.4.0", "StokesDiffEq", v"0.0.2"],
+    ["DifferentialEquations", v"1.4.0", "Sundials", v"0.4.1"],
+    ["DifferentialEquations", v"1.5.0", "DiffEqPDEBase"],
+    ["DifferentialEquations", v"1.5.0", "AlgebraicDiffEq", v"0.0.2"],
+    ["DifferentialEquations", v"1.5.0", "DiffEqBase", v"0.2.0", v"0.15.0"],
+    ["DifferentialEquations", v"1.5.0", "DiffEqDevTools", v"0.2.0"],
+    ["DifferentialEquations", v"1.5.0", "DiffEqParamEstim", v"0.0.2"],
+    ["DifferentialEquations", v"1.5.0", "DiffEqSensitivity", v"0.0.2"],
+    ["DifferentialEquations", v"1.5.0", "FiniteElementDiffEq", v"0.0.5"],
+    ["DifferentialEquations", v"1.5.0", "OrdinaryDiffEq", v"0.2.0", v"1.2.0"],
+    ["DifferentialEquations", v"1.5.0", "ParameterizedFunctions", v"0.3.2"],
+    ["DifferentialEquations", v"1.5.0", "Reexport", v"0.0.3"],
+    ["DifferentialEquations", v"1.5.0", "StochasticDiffEq", v"0.1.0", v"1.0.0"],
+    ["DifferentialEquations", v"1.5.0", "StokesDiffEq", v"0.0.2"],
+    ["DifferentialEquations", v"1.5.0", "Sundials", v"0.4.1"],
+    ["DifferentialEquations", v"1.6.0", "AlgebraicDiffEq", v"0.0.2"],
+    ["DifferentialEquations", v"1.6.0", "DelayDiffEq"],
+    ["DifferentialEquations", v"1.6.0", "DiffEqBase", v"0.2.0", v"0.15.0"],
+    ["DifferentialEquations", v"1.6.0", "DiffEqCallbacks"],
+    ["DifferentialEquations", v"1.6.0", "DiffEqMonteCarlo"],
+    ["DifferentialEquations", v"1.6.0", "DiffEqPDEBase"],
+    ["DifferentialEquations", v"1.6.0", "DiffEqDevTools", v"0.2.0"],
+    ["DifferentialEquations", v"1.6.0", "DiffEqParamEstim", v"0.0.2"],
+    ["DifferentialEquations", v"1.6.0", "DiffEqSensitivity", v"0.0.2"],
+    ["DifferentialEquations", v"1.6.0", "FiniteElementDiffEq", v"0.0.5"],
+    ["DifferentialEquations", v"1.6.0", "Reexport", v"0.0.3"],
+    ["DifferentialEquations", v"1.6.0", "OrdinaryDiffEq", v"0.2.0", v"1.2.0"],
+    ["DifferentialEquations", v"1.6.0", "ParameterizedFunctions", v"0.3.2"],
+    ["DifferentialEquations", v"1.6.0", "StochasticDiffEq", v"0.1.0", v"1.0.0"],
+    ["DifferentialEquations", v"1.6.0", "StokesDiffEq", v"0.0.2"],
+    ["DifferentialEquations", v"1.6.0", "Sundials", v"0.4.1"],
+    ["DifferentialEquations", v"1.7.0", "DiffEqCallbacks"],
+    ["DifferentialEquations", v"1.7.0", "DiffEqMonteCarlo"],
+    ["DifferentialEquations", v"1.7.0", "DiffEqPDEBase"],
+    ["DifferentialEquations", v"1.7.0", "AlgebraicDiffEq", v"0.0.2"],
+    ["DifferentialEquations", v"1.7.0", "DelayDiffEq", v"0.1.0"],
+    ["DifferentialEquations", v"1.7.0", "DiffEqDevTools", v"0.2.0"],
+    ["DifferentialEquations", v"1.7.0", "DiffEqParamEstim", v"0.0.2"],
+    ["DifferentialEquations", v"1.7.0", "DiffEqSensitivity", v"0.0.2"],
+    ["DifferentialEquations", v"1.7.0", "FiniteElementDiffEq", v"0.0.5"],
+    ["DifferentialEquations", v"1.7.0", "OrdinaryDiffEq", v"1.2.0"],
+    ["DifferentialEquations", v"1.7.0", "ParameterizedFunctions", v"0.3.2"],
+    ["DifferentialEquations", v"1.7.0", "Reexport", v"0.0.3"],
+    ["DifferentialEquations", v"1.7.0", "DiffEqBase", v"0.8.0", v"0.15.0"],
+    ["DifferentialEquations", v"1.7.0", "StochasticDiffEq", v"1.0.0"],
+    ["DifferentialEquations", v"1.7.0", "StokesDiffEq", v"0.0.2"],
+    ["DifferentialEquations", v"1.7.0", "Sundials", v"0.4.1"],
+    ["DifferentialEquations", v"1.9.0", "DiffEqBiological"],
+    ["DifferentialEquations", v"1.9.0", "DiffEqCallbacks"],
+    ["DifferentialEquations", v"1.9.0", "AlgebraicDiffEq", v"0.0.2"],
+    ["DifferentialEquations", v"1.9.0", "DelayDiffEq", v"0.1.0"],
+    ["DifferentialEquations", v"1.9.0", "DiffEqBase", v"0.8.0", v"0.15.0"],
+    ["DifferentialEquations", v"1.9.0", "DiffEqFinancial"],
+    ["DifferentialEquations", v"1.9.0", "DiffEqJump"],
+    ["DifferentialEquations", v"1.9.0", "DiffEqMonteCarlo"],
+    ["DifferentialEquations", v"1.9.0", "DiffEqPDEBase"],
+    ["DifferentialEquations", v"1.9.0", "DiffEqDevTools", v"0.2.0"],
+    ["DifferentialEquations", v"1.9.0", "DiffEqParamEstim", v"0.0.2"],
+    ["DifferentialEquations", v"1.9.0", "DiffEqSensitivity", v"0.0.2"],
+    ["DifferentialEquations", v"1.9.0", "FiniteElementDiffEq", v"0.0.5"],
+    ["DifferentialEquations", v"1.9.0", "MultiScaleArrays"],
+    ["DifferentialEquations", v"1.9.0", "OrdinaryDiffEq", v"1.2.0"],
+    ["DifferentialEquations", v"1.9.0", "PyDSTool"],
+    ["DifferentialEquations", v"1.9.0", "ParameterizedFunctions", v"0.3.2"],
+    ["DifferentialEquations", v"1.9.0", "Reexport", v"0.0.3"],
+    ["DifferentialEquations", v"1.9.0", "StochasticDiffEq", v"1.0.0"],
+    ["DifferentialEquations", v"1.9.0", "StokesDiffEq", v"0.0.2"],
+    ["DifferentialEquations", v"1.9.0", "Sundials", v"0.4.1"],
+    ["DifferentialEquations", v"1.9.1", "DiffEqBiological"],
+    ["DifferentialEquations", v"1.9.1", "DiffEqCallbacks"],
+    ["DifferentialEquations", v"1.9.1", "AlgebraicDiffEq", v"0.0.2"],
+    ["DifferentialEquations", v"1.9.1", "DelayDiffEq", v"0.1.0"],
+    ["DifferentialEquations", v"1.9.1", "DiffEqBase", v"0.8.0", v"0.15.0"],
+    ["DifferentialEquations", v"1.9.1", "DiffEqFinancial"],
+    ["DifferentialEquations", v"1.9.1", "DiffEqJump"],
+    ["DifferentialEquations", v"1.9.1", "DiffEqMonteCarlo"],
+    ["DifferentialEquations", v"1.9.1", "DiffEqPDEBase"],
+    ["DifferentialEquations", v"1.9.1", "DiffEqDevTools", v"0.2.0"],
+    ["DifferentialEquations", v"1.9.1", "DiffEqParamEstim", v"0.0.2"],
+    ["DifferentialEquations", v"1.9.1", "DiffEqSensitivity", v"0.0.2"],
+    ["DifferentialEquations", v"1.9.1", "FiniteElementDiffEq", v"0.0.5"],
+    ["DifferentialEquations", v"1.9.1", "MultiScaleArrays"],
+    ["DifferentialEquations", v"1.9.1", "OrdinaryDiffEq", v"1.2.0"],
+    ["DifferentialEquations", v"1.9.1", "ParameterizedFunctions", v"0.3.2"],
+    ["DifferentialEquations", v"1.9.1", "Reexport", v"0.0.3"],
+    ["DifferentialEquations", v"1.9.1", "StochasticDiffEq", v"1.0.0"],
+    ["DifferentialEquations", v"1.9.1", "StokesDiffEq", v"0.0.2"],
+    ["DifferentialEquations", v"1.9.1", "Sundials", v"0.4.1"],
+    ["DifferentialEquations", v"1.10.1", "DiffEqBase", v"0.15.0"],
+    ["DifferentialEquations", v"1.10.1", "DiffEqBiological"],
+    ["DifferentialEquations", v"1.10.1", "DiffEqCallbacks"],
+    ["DifferentialEquations", v"1.10.1", "AlgebraicDiffEq", v"0.0.2"],
+    ["DifferentialEquations", v"1.10.1", "DiffEqFinancial"],
+    ["DifferentialEquations", v"1.10.1", "DiffEqJump"],
+    ["DifferentialEquations", v"1.10.1", "DiffEqMonteCarlo"],
+    ["DifferentialEquations", v"1.10.1", "DiffEqPDEBase"],
+    ["DifferentialEquations", v"1.10.1", "MultiScaleArrays"],
+    ["DifferentialEquations", v"1.10.1", "DelayDiffEq", v"0.1.0"],
+    ["DifferentialEquations", v"1.10.1", "DiffEqDevTools", v"0.2.0"],
+    ["DifferentialEquations", v"1.10.1", "DiffEqParamEstim", v"0.0.2"],
+    ["DifferentialEquations", v"1.10.1", "DiffEqSensitivity", v"0.0.2"],
+    ["DifferentialEquations", v"1.10.1", "FiniteElementDiffEq", v"0.0.5"],
+    ["DifferentialEquations", v"1.10.1", "OrdinaryDiffEq", v"1.2.0"],
+    ["DifferentialEquations", v"1.10.1", "ParameterizedFunctions", v"0.3.2"],
+    ["DifferentialEquations", v"1.10.1", "Reexport", v"0.0.3"],
+    ["DifferentialEquations", v"1.10.1", "StochasticDiffEq", v"1.0.0"],
+    ["DifferentialEquations", v"1.10.1", "StokesDiffEq", v"0.0.2"],
+    ["DifferentialEquations", v"1.10.1", "Sundials", v"0.4.1"],
+    ["Distances", v"0.1.1", "ArrayViews", v"0.4.0-"],
+    ["Distances", v"0.2.0", "ArrayViews", v"0.4.8-"],
+    ["Distances", v"0.2.2", "Compat"],
+    ["Distances", v"0.2.2", "ArrayViews", v"0.4.8-"],
+    ["Distances", v"0.3.2", "Compat", v"0.8.4"],
+    ["Distances", v"0.4.0"],
+    ["Distances", v"0.4.1", "Compat", v"0.18.0"],
+    ["Distributions", v"0.6.4", "ArrayViews", v"0.4.8"],
+    ["Distributions", v"0.6.4", "Compat", v"0.2.4"],
+    ["Distributions", v"0.6.4", "PDMats", v"0.3.1", v"0.4.0"],
+    ["Distributions", v"0.6.4", "StatsBase", v"0.6.10"],
+    ["Distributions", v"0.6.4", "StatsFuns", v"0.0.0", v"0.3.0"],
+    ["Distributions", v"0.6.5", "ArrayViews", v"0.4.9"],
+    ["Distributions", v"0.6.5", "Compat", v"0.3.1"],
+    ["Distributions", v"0.6.5", "PDMats", v"0.3.1", v"0.4.0"],
+    ["Distributions", v"0.6.5", "StatsBase", v"0.6.10"],
+    ["Distributions", v"0.6.5", "StatsFuns", v"0.0.0", v"0.3.0"],
+    ["Distributions", v"0.6.7", "ArrayViews", v"0.4.10"],
+    ["Distributions", v"0.6.7", "Compat", v"0.3.2"],
+    ["Distributions", v"0.6.7", "PDMats", v"0.3.1", v"0.4.0"],
+    ["Distributions", v"0.6.7", "StatsBase", v"0.6.13"],
+    ["Distributions", v"0.6.7", "StatsFuns", v"0.0.0", v"0.3.0"],
+    ["Distributions", v"0.7.6", "ArrayViews", v"0.4.12"],
+    ["Distributions", v"0.7.6", "Compat", v"0.4.0"],
+    ["Distributions", v"0.7.6", "PDMats", v"0.3.2", v"0.4.0"],
+    ["Distributions", v"0.7.6", "StatsBase", v"0.6.14"],
+    ["Distributions", v"0.7.6", "StatsFuns", v"0.0.0", v"0.3.0"],
+    ["Distributions", v"0.8.9", "ArrayViews", v"0.4.12"],
+    ["Distributions", v"0.8.9", "Compat", v"0.4.0"],
+    ["Distributions", v"0.8.9", "PDMats", v"0.3.2", v"0.4.0"],
+    ["Distributions", v"0.8.9", "StatsBase", v"0.7.0"],
+    ["Distributions", v"0.8.9", "StatsFuns", v"0.1.1", v"0.3.0"],
+    ["Distributions", v"0.8.10", "ArrayViews", v"0.4.12"],
+    ["Distributions", v"0.8.10", "Compat", v"0.4.0"],
+    ["Distributions", v"0.8.10", "PDMats", v"0.4.0", v"0.5.0"],
+    ["Distributions", v"0.8.10", "StatsBase", v"0.7.0"],
+    ["Distributions", v"0.8.10", "StatsFuns", v"0.1.1", v"0.3.0"],
+    ["Distributions", v"0.9.0", "Compat", v"0.2.17"],
+    ["Distributions", v"0.9.0", "PDMats", v"0.4.1", v"0.5.0"],
+    ["Distributions", v"0.9.0", "StatsBase", v"0.7.0"],
+    ["Distributions", v"0.9.0", "StatsFuns", v"0.1.1", v"0.3.0"],
+    ["Distributions", v"0.10.2", "Calculus"],
+    ["Distributions", v"0.10.2", "Compat", v"0.8.4"],
+    ["Distributions", v"0.10.2", "PDMats", v"0.4.2", v"0.5.0"],
+    ["Distributions", v"0.10.2", "StatsBase", v"0.8.3"],
+    ["Distributions", v"0.10.2", "StatsFuns", v"0.3.0"],
+    ["Distributions", v"0.11.1", "Calculus"],
+    ["Distributions", v"0.11.1", "Compat", v"0.9.2"],
+    ["Distributions", v"0.11.1", "PDMats", v"0.5.0"],
+    ["Distributions", v"0.11.1", "StatsBase", v"0.8.3"],
+    ["Distributions", v"0.11.1", "StatsFuns", v"0.3.1"],
+    ["Distributions", v"0.12.0", "Calculus"],
+    ["Distributions", v"0.12.0", "Compat", v"0.14.0"],
+    ["Distributions", v"0.12.0", "PDMats", v"0.5.4"],
+    ["Distributions", v"0.12.0", "QuadGK", v"0.1.1"],
+    ["Distributions", v"0.12.0", "StatsBase", v"0.8.3"],
+    ["Distributions", v"0.12.0", "StatsFuns", v"0.3.1"],
+    ["Distributions", v"0.12.4", "Calculus"],
+    ["Distributions", v"0.12.4", "Compat", v"0.18.0"],
+    ["Distributions", v"0.12.4", "PDMats", v"0.5.4"],
+    ["Distributions", v"0.12.4", "QuadGK", v"0.1.1"],
+    ["Distributions", v"0.12.4", "SpecialFunctions", v"0.1.0"],
+    ["Distributions", v"0.12.4", "StatsBase", v"0.8.3"],
+    ["Distributions", v"0.12.4", "StatsFuns", v"0.3.1"],
+    ["Distributions", v"0.12.5", "Calculus"],
+    ["Distributions", v"0.12.5", "Compat", v"0.18.0"],
+    ["Distributions", v"0.12.5", "PDMats", v"0.6.0"],
+    ["Distributions", v"0.12.5", "QuadGK", v"0.1.1"],
+    ["Distributions", v"0.12.5", "SpecialFunctions", v"0.1.0"],
+    ["Distributions", v"0.12.5", "StatsBase", v"0.8.3"],
+    ["Distributions", v"0.12.5", "StatsFuns", v"0.3.1"],
+    ["Docile", v"0.1.0", "AnsiColor"],
+    ["Docile", v"0.1.0", "Markdown"],
+    ["Docile", v"0.3.1"],
+    ["Docile", v"0.3.2", "Compat"],
+    ["Docile", v"0.4.6", "Compat"],
+    ["Docile", v"0.4.13", "Compat", v"0.3.3"],
+    ["Docile", v"0.5.18", "Compat", v"0.3.5"],
+    ["Docile", v"0.5.23", "Compat", v"0.7.1"],
+    ["DualNumbers", v"0.1.0", "Calculus"],
+    ["DualNumbers", v"0.1.3", "Calculus"],
+    ["DualNumbers", v"0.1.3", "NaNMath"],
+    ["DualNumbers", v"0.1.5", "Calculus"],
+    ["DualNumbers", v"0.1.5", "Compat"],
+    ["DualNumbers", v"0.1.5", "NaNMath"],
+    ["DualNumbers", v"0.2.2", "Calculus"],
+    ["DualNumbers", v"0.2.2", "NaNMath"],
+    ["DualNumbers", v"0.3.0", "Calculus"],
+    ["DualNumbers", v"0.3.0", "NaNMath"],
+    ["DualNumbers", v"0.3.0", "Compat", v"0.9.1"],
+    ["ELF", v"0.0.0", "StrPack"],
+    ["ELF", v"0.1.0", "DWARF"],
+    ["ELF", v"0.1.0", "FileIO"],
+    ["ELF", v"0.1.0", "ObjFileBase"],
+    ["ELF", v"0.1.0", "StructIO"],
+    ["EllipsisNotation", v"0.0.1"],
+    ["EllipsisNotation", v"0.1.0"],
+    ["FFTViews", v"0.0.1", "CustomUnitRanges"],
+    ["FFTViews", v"0.0.2", "CustomUnitRanges"],
+    ["FFTViews", v"0.0.2", "Compat", v"0.17.0"],
+    ["FactCheck", v"0.0.0"],
+    ["FactCheck", v"0.0.2"],
+    ["FactCheck", v"0.2.2"],
+    ["FactCheck", v"0.4.2", "Compat"],
+    ["FactCheck", v"0.4.3", "Compat", v"0.7.18"],
+    ["FileIO", v"0.0.5", "Compat"],
+    ["FileIO", v"0.0.5", "Docile"],
+    ["FileIO", v"0.0.6", "Docile"],
+    ["FileIO", v"0.0.6", "Compat", v"0.7.15"],
+    ["FileIO", v"0.1.1", "Compat", v"0.7.19"],
+    ["FileIO", v"0.2.1", "Compat", v"0.7.19"],
+    ["FileIO", v"0.3.0", "Compat", v"0.9.5"],
+    ["FileIO", v"0.3.1", "Compat", v"0.17.0"],
+    ["FiniteElementDiffEq", v"0.0.3", "ChunkedArrays", v"0.1.0"],
+    ["FiniteElementDiffEq", v"0.0.3", "DiffEqBase", v"0.0.0", v"0.15.0"],
+    ["FiniteElementDiffEq", v"0.0.3", "ForwardDiff", v"0.2.4"],
+    ["FiniteElementDiffEq", v"0.0.3", "GenericSVD", v"0.0.2"],
+    ["FiniteElementDiffEq", v"0.0.3", "IterativeSolvers", v"0.2.2"],
+    ["FiniteElementDiffEq", v"0.0.3", "NLsolve", v"0.7.3"],
+    ["FiniteElementDiffEq", v"0.0.3", "Parameters", v"0.5.0"],
+    ["FiniteElementDiffEq", v"0.0.3", "Plots", v"0.9.2"],
+    ["FiniteElementDiffEq", v"0.0.3", "RecipesBase", v"0.1.0"],
+    ["FiniteElementDiffEq", v"0.0.3", "VectorizedRoutines", v"0.0.2"],
+    ["FiniteElementDiffEq", v"0.0.4", "ChunkedArrays", v"0.1.0"],
+    ["FiniteElementDiffEq", v"0.0.4", "DiffEqBase", v"0.0.0", v"0.15.0"],
+    ["FiniteElementDiffEq", v"0.0.4", "ForwardDiff", v"0.2.4"],
+    ["FiniteElementDiffEq", v"0.0.4", "GenericSVD", v"0.0.2"],
+    ["FiniteElementDiffEq", v"0.0.4", "IterativeSolvers", v"0.2.2"],
+    ["FiniteElementDiffEq", v"0.0.4", "NLsolve", v"0.7.3"],
+    ["FiniteElementDiffEq", v"0.0.4", "Parameters", v"0.5.0"],
+    ["FiniteElementDiffEq", v"0.0.4", "RecipesBase", v"0.1.0"],
+    ["FiniteElementDiffEq", v"0.0.4", "VectorizedRoutines", v"0.0.2"],
+    ["FiniteElementDiffEq", v"0.0.5", "ChunkedArrays", v"0.1.0"],
+    ["FiniteElementDiffEq", v"0.0.5", "DiffEqBase", v"0.1.1", v"0.15.0"],
+    ["FiniteElementDiffEq", v"0.0.5", "ForwardDiff", v"0.2.4"],
+    ["FiniteElementDiffEq", v"0.0.5", "GenericSVD", v"0.0.2"],
+    ["FiniteElementDiffEq", v"0.0.5", "IterativeSolvers", v"0.2.2"],
+    ["FiniteElementDiffEq", v"0.0.5", "Juno", v"0.2.4"],
+    ["FiniteElementDiffEq", v"0.0.5", "NLsolve", v"0.7.3"],
+    ["FiniteElementDiffEq", v"0.0.5", "Parameters", v"0.5.0"],
+    ["FiniteElementDiffEq", v"0.0.5", "RecipesBase", v"0.1.0"],
+    ["FiniteElementDiffEq", v"0.0.5", "VectorizedRoutines", v"0.0.2"],
+    ["FiniteElementDiffEq", v"0.2.0", "ChunkedArrays", v"0.1.0"],
+    ["FiniteElementDiffEq", v"0.2.0", "DiffEqBase", v"0.4.0", v"0.15.0"],
+    ["FiniteElementDiffEq", v"0.2.0", "ForwardDiff", v"0.2.4"],
+    ["FiniteElementDiffEq", v"0.2.0", "GenericSVD", v"0.0.2"],
+    ["FiniteElementDiffEq", v"0.2.0", "IterativeSolvers", v"0.2.2"],
+    ["FiniteElementDiffEq", v"0.2.0", "Juno", v"0.2.4"],
+    ["FiniteElementDiffEq", v"0.2.0", "NLsolve", v"0.7.3"],
+    ["FiniteElementDiffEq", v"0.2.0", "Parameters", v"0.5.0"],
+    ["FiniteElementDiffEq", v"0.2.0", "RecipesBase", v"0.1.0"],
+    ["FiniteElementDiffEq", v"0.2.0", "VectorizedRoutines", v"0.0.2"],
+    ["FiniteElementDiffEq", v"0.2.1", "ChunkedArrays", v"0.1.0"],
+    ["FiniteElementDiffEq", v"0.2.1", "DiffEqBase", v"0.4.0", v"0.15.0"],
+    ["FiniteElementDiffEq", v"0.2.1", "DiffEqPDEBase"],
+    ["FiniteElementDiffEq", v"0.2.1", "ForwardDiff", v"0.2.4"],
+    ["FiniteElementDiffEq", v"0.2.1", "GenericSVD", v"0.0.2"],
+    ["FiniteElementDiffEq", v"0.2.1", "IterativeSolvers", v"0.2.2"],
+    ["FiniteElementDiffEq", v"0.2.1", "Juno", v"0.2.4"],
+    ["FiniteElementDiffEq", v"0.2.1", "NLsolve", v"0.7.3"],
+    ["FiniteElementDiffEq", v"0.2.1", "Parameters", v"0.5.0"],
+    ["FiniteElementDiffEq", v"0.2.1", "VectorizedRoutines", v"0.0.2"],
+    ["FiniteElementDiffEq", v"0.3.0", "ChunkedArrays", v"0.1.0"],
+    ["FiniteElementDiffEq", v"0.3.0", "DiffEqBase", v"0.15.0"],
+    ["FiniteElementDiffEq", v"0.3.0", "DiffEqPDEBase"],
+    ["FiniteElementDiffEq", v"0.3.0", "ForwardDiff", v"0.2.4"],
+    ["FiniteElementDiffEq", v"0.3.0", "GenericSVD", v"0.0.2"],
+    ["FiniteElementDiffEq", v"0.3.0", "IterativeSolvers", v"0.2.2"],
+    ["FiniteElementDiffEq", v"0.3.0", "Juno", v"0.2.4"],
+    ["FiniteElementDiffEq", v"0.3.0", "NLsolve", v"0.7.3"],
+    ["FiniteElementDiffEq", v"0.3.0", "Parameters", v"0.5.0"],
+    ["FiniteElementDiffEq", v"0.3.0", "VectorizedRoutines", v"0.0.2"],
+    ["FixedPointNumbers", v"0.0.5"],
+    ["FixedPointNumbers", v"0.0.12", "Compat", v"0.2.2"],
+    ["FixedPointNumbers", v"0.1.2"],
+    ["FixedPointNumbers", v"0.1.4", "Compat", v"0.7.14"],
+    ["FixedPointNumbers", v"0.1.7", "Compat", v"0.9.1"],
+    ["FixedPointNumbers", v"0.2.1", "Compat", v"0.9.1"],
+    ["FixedPointNumbers", v"0.3.0", "Compat", v"0.9.1"],
+    ["FixedPointNumbers", v"0.3.2", "Compat", v"0.9.5"],
+    ["FixedPointNumbers", v"0.3.6", "Compat", v"0.17.0"],
+    ["FixedSizeArrays", v"0.1.0"],
+    ["FixedSizeArrays", v"0.1.1", "Compat"],
+    ["FixedSizeArrays", v"0.2.1", "Compat", v"0.7.15"],
+    ["FixedSizeArrays", v"0.2.2", "Compat", v"0.7.15"],
+    ["FixedSizeArrays", v"0.2.5", "Compat", v"0.8.7"],
+    ["ForwardDiff", v"0.2.5", "Calculus"],
+    ["ForwardDiff", v"0.2.5", "NaNMath"],
+    ["ForwardDiff", v"0.2.5", "Compat", v"0.8.6"],
+    ["ForwardDiff", v"0.3.4", "Calculus", v"0.2.0"],
+    ["ForwardDiff", v"0.3.4", "Compat", v"0.8.6"],
+    ["ForwardDiff", v"0.3.4", "DiffBase", v"0.0.3"],
+    ["ForwardDiff", v"0.3.4", "NaNMath", v"0.2.2"],
+    ["ForwardDiff", v"0.3.5", "Calculus", v"0.1.15"],
+    ["ForwardDiff", v"0.3.5", "Compat", v"0.8.6"],
+    ["ForwardDiff", v"0.3.5", "DiffBase", v"0.0.1"],
+    ["ForwardDiff", v"0.3.5", "NaNMath", v"0.2.1"],
+    ["ForwardDiff", v"0.4.2", "Calculus", v"0.2.0"],
+    ["ForwardDiff", v"0.4.2", "Compat", v"0.19.0"],
+    ["ForwardDiff", v"0.4.2", "DiffBase", v"0.0.3"],
+    ["ForwardDiff", v"0.4.2", "NaNMath", v"0.2.2"],
+    ["ForwardDiff", v"0.4.2", "SpecialFunctions", v"0.1.0"],
+    ["GZip", v"0.2.13"],
+    ["GZip", v"0.2.16", "Compat"],
+    ["GZip", v"0.2.18", "Compat", v"0.4.8"],
+    ["GZip", v"0.2.19", "Compat", v"0.7.9"],
+    ["GZip", v"0.2.20", "Compat", v"0.8.0"],
+    ["GZip", v"0.3.0", "Compat", v"0.9.5"],
+    ["Gallium", v"0.0.1", "ASTInterpreter"],
+    ["Gallium", v"0.0.1", "AbstractTrees"],
+    ["Gallium", v"0.0.1", "DWARF"],
+    ["Gallium", v"0.0.1", "ELF"],
+    ["Gallium", v"0.0.1", "MachO"],
+    ["Gallium", v"0.0.1", "TerminalUI"],
+    ["Gallium", v"0.0.2", "ASTInterpreter"],
+    ["Gallium", v"0.0.2", "AbstractTrees"],
+    ["Gallium", v"0.0.2", "DWARF"],
+    ["Gallium", v"0.0.2", "ELF"],
+    ["Gallium", v"0.0.2", "MachO"],
+    ["Gallium", v"0.0.2", "ObjFileBase"],
+    ["Gallium", v"0.0.2", "TerminalUI"],
+    ["Gallium", v"0.0.4", "ASTInterpreter"],
+    ["Gallium", v"0.0.4", "AbstractTrees"],
+    ["Gallium", v"0.0.4", "COFF"],
+    ["Gallium", v"0.0.4", "CRC"],
+    ["Gallium", v"0.0.4", "DWARF"],
+    ["Gallium", v"0.0.4", "ELF"],
+    ["Gallium", v"0.0.4", "MachO"],
+    ["Gallium", v"0.0.4", "ObjFileBase"],
+    ["Gallium", v"0.0.4", "TerminalUI"],
+    ["GenericSVD", v"0.0.2", "Compat", v"0.8.6"],
+    ["GnuTLS", v"0.0.1", "Nettle"],
+    ["GnuTLS", v"0.0.1", "BinDeps", v"0.2.1-"],
+    ["GnuTLS", v"0.0.4", "Compat"],
+    ["GnuTLS", v"0.0.4", "Nettle"],
+    ["GnuTLS", v"0.0.4", "BinDeps", v"0.2.1-"],
+    ["GnuTLS", v"0.0.5", "BinDeps"],
+    ["GnuTLS", v"0.0.5", "Compat"],
+    ["GnuTLS", v"0.0.5", "Nettle"],
+    ["Graphics", v"0.1.1"],
+    ["Graphics", v"0.1.3", "Colors"],
+    ["Graphics", v"0.1.4", "Colors"],
+    ["Graphics", v"0.1.4", "Compat", v"0.17.0"],
+    ["Graphics", v"0.2.0", "Colors"],
+    ["Graphics", v"0.2.0", "Compat", v"0.17.0"],
+    ["Graphics", v"0.2.0", "NaNMath", v"0.2.4"],
+    ["HDF5", v"0.2.1", "StrPack"],
+    ["HDF5", v"0.2.9"],
+    ["HDF5", v"0.4.6", "BinDeps"],
+    ["HDF5", v"0.5.2", "BinDeps"],
+    ["HDF5", v"0.5.2", "Blosc"],
+    ["HDF5", v"0.5.2", "Compat"],
+    ["HDF5", v"0.5.5", "BinDeps"],
+    ["HDF5", v"0.5.5", "Blosc"],
+    ["HDF5", v"0.5.5", "Compat", v"0.4.11"],
+    ["HDF5", v"0.6.0", "BinDeps"],
+    ["HDF5", v"0.6.0", "Blosc"],
+    ["HDF5", v"0.6.0", "Compat", v"0.7.1"],
+    ["HDF5", v"0.6.1", "BinDeps"],
+    ["HDF5", v"0.6.1", "Blosc"],
+    ["HDF5", v"0.6.1", "Compat", v"0.7.16"],
+    ["HDF5", v"0.7.3", "BinDeps"],
+    ["HDF5", v"0.7.3", "Blosc"],
+    ["HDF5", v"0.7.3", "Compat", v"0.8.0"],
+    ["HDF5", v"0.8.0", "BinDeps"],
+    ["HDF5", v"0.8.0", "Blosc"],
+    ["HDF5", v"0.8.0", "Compat", v"0.17.0"],
+    ["Hiccup", v"0.0.0", "Lazy"],
+    ["Hiccup", v"0.0.1", "Lazy"],
+    ["Hiccup", v"0.0.1", "MacroTools"],
+    ["Hiccup", v"0.0.2", "Compat"],
+    ["Hiccup", v"0.0.2", "Lazy"],
+    ["Hiccup", v"0.0.2", "MacroTools"],
+    ["Hiccup", v"0.0.3", "Lazy"],
+    ["Hiccup", v"0.0.3", "MacroTools"],
+    ["Hiccup", v"0.0.3", "Compat", v"0.8.2"],
+    ["Hiccup", v"0.1.1", "Compat", v"0.8.2"],
+    ["Hiccup", v"0.1.1", "MacroTools", v"0.3.4"],
+    ["HttpCommon", v"0.0.1"],
+    ["HttpCommon", v"0.0.2", "Calendar"],
+    ["HttpCommon", v"0.0.2", "FactCheck", v"0.0.1"],
+    ["HttpCommon", v"0.0.5", "Calendar"],
+    ["HttpCommon", v"0.0.5", "FactCheck", v"0.1.0-"],
+    ["HttpCommon", v"0.0.12", "Dates"],
+    ["HttpCommon", v"0.1.1", "Compat"],
+    ["HttpCommon", v"0.1.1", "Dates"],
+    ["HttpCommon", v"0.2.0", "Compat"],
+    ["HttpCommon", v"0.2.0", "Dates"],
+    ["HttpCommon", v"0.2.0", "URIParser"],
+    ["HttpCommon", v"0.2.4", "URIParser"],
+    ["HttpCommon", v"0.2.7", "URIParser"],
+    ["HttpCommon", v"0.2.7", "Compat", v"0.7.20"],
+    ["HttpParser", v"0.0.0", "HttpCommon"],
+    ["HttpParser", v"0.0.1", "BinDeps"],
+    ["HttpParser", v"0.0.1", "HttpCommon"],
+    ["HttpParser", v"0.0.2"],
+    ["HttpParser", v"0.0.3", "HttpCommon"],
+    ["HttpParser", v"0.0.3", "BinDeps", v"0.2.1-"],
+    ["HttpParser", v"0.0.4", "HttpCommon"],
+    ["HttpParser", v"0.0.4", "BinDeps", v"0.2.5-"],
+    ["HttpParser", v"0.0.11", "BinDeps", v"0.2.5-"],
+    ["HttpParser", v"0.0.11", "HttpCommon", v"0.0.3-"],
+    ["HttpParser", v"0.1.0", "BinDeps"],
+    ["HttpParser", v"0.1.0", "Compat"],
+    ["HttpParser", v"0.1.0", "HttpCommon"],
+    ["HttpParser", v"0.1.1", "BinDeps"],
+    ["HttpParser", v"0.1.1", "HttpCommon"],
+    ["HttpParser", v"0.2.0", "BinDeps"],
+    ["HttpParser", v"0.2.0", "HttpCommon"],
+    ["HttpParser", v"0.2.0", "Compat", v"0.7.20"],
+    ["HttpServer", v"0.0.1", "HttpCommon"],
+    ["HttpServer", v"0.0.1", "HttpParser"],
+    ["HttpServer", v"0.0.3", "GnuTLS"],
+    ["HttpServer", v"0.0.3", "HttpCommon"],
+    ["HttpServer", v"0.0.3", "HttpParser"],
+    ["HttpServer", v"0.0.7", "GnuTLS"],
+    ["HttpServer", v"0.0.7", "HttpCommon", v"0.0.3-"],
+    ["HttpServer", v"0.0.7", "HttpParser", v"0.0.5-"],
+    ["HttpServer", v"0.0.8", "GnuTLS"],
+    ["HttpServer", v"0.0.8", "HttpCommon"],
+    ["HttpServer", v"0.0.8", "HttpParser"],
+    ["HttpServer", v"0.0.11", "Docile"],
+    ["HttpServer", v"0.0.11", "GnuTLS"],
+    ["HttpServer", v"0.0.11", "HttpCommon"],
+    ["HttpServer", v"0.0.11", "HttpParser"],
+    ["HttpServer", v"0.1.2", "Compat"],
+    ["HttpServer", v"0.1.2", "Docile"],
+    ["HttpServer", v"0.1.2", "GnuTLS"],
+    ["HttpServer", v"0.1.2", "HttpCommon"],
+    ["HttpServer", v"0.1.2", "HttpParser"],
+    ["HttpServer", v"0.1.5", "HttpCommon"],
+    ["HttpServer", v"0.1.5", "HttpParser"],
+    ["HttpServer", v"0.1.5", "MbedTLS"],
+    ["HttpServer", v"0.1.7", "HttpCommon"],
+    ["HttpServer", v"0.1.7", "HttpParser"],
+    ["HttpServer", v"0.1.7", "MbedTLS"],
+    ["HttpServer", v"0.1.7", "Compat", v"0.7.16"],
+    ["HttpServer", v"0.2.0", "HttpCommon"],
+    ["HttpServer", v"0.2.0", "HttpParser"],
+    ["HttpServer", v"0.2.0", "MbedTLS"],
+    ["HttpServer", v"0.2.0", "Compat", v"0.17.0"],
+    ["ICU", v"0.2.1"],
+    ["ICU", v"0.4.4", "BinDeps"],
+    ["ImageAxes", v"0.0.2", "AxisArrays"],
+    ["ImageAxes", v"0.0.2", "Colors"],
+    ["ImageAxes", v"0.0.2", "ImageCore"],
+    ["ImageAxes", v"0.0.2", "Reexport"],
+    ["ImageAxes", v"0.0.2", "SimpleTraits"],
+    ["ImageAxes", v"0.1.1", "AxisArrays"],
+    ["ImageAxes", v"0.1.1", "Colors"],
+    ["ImageAxes", v"0.1.1", "FixedPointNumbers", v"0.3.0"],
+    ["ImageAxes", v"0.1.1", "ImageCore"],
+    ["ImageAxes", v"0.1.1", "Reexport"],
+    ["ImageAxes", v"0.1.1", "SimpleTraits"],
+    ["ImageAxes", v"0.2.1", "AxisArrays"],
+    ["ImageAxes", v"0.2.1", "Colors"],
+    ["ImageAxes", v"0.2.1", "FixedPointNumbers", v"0.3.0"],
+    ["ImageAxes", v"0.2.1", "MappedArrays"],
+    ["ImageAxes", v"0.2.1", "Reexport"],
+    ["ImageAxes", v"0.2.1", "SimpleTraits"],
+    ["ImageAxes", v"0.2.1", "ImageCore", v"0.2.0"],
+    ["ImageCore", v"0.0.3", "Colors"],
+    ["ImageCore", v"0.0.3", "Graphics"],
+    ["ImageCore", v"0.0.3", "FixedPointNumbers", v"0.0.0-", v"0.3.0"],
+    ["ImageCore", v"0.0.3", "MappedArrays"],
+    ["ImageCore", v"0.0.4", "Colors"],
+    ["ImageCore", v"0.0.4", "Graphics"],
+    ["ImageCore", v"0.0.4", "FixedPointNumbers", v"0.0.0-", v"0.3.0"],
+    ["ImageCore", v"0.0.4", "MappedArrays", v"0.0.3"],
+    ["ImageCore", v"0.0.5", "Colors"],
+    ["ImageCore", v"0.0.5", "Graphics"],
+    ["ImageCore", v"0.0.5", "FixedPointNumbers", v"0.0.0-", v"0.3.0"],
+    ["ImageCore", v"0.0.5", "MappedArrays", v"0.0.3"],
+    ["ImageCore", v"0.0.5", "OffsetArrays"],
+    ["ImageCore", v"0.0.5", "ShowItLikeYouBuildIt"],
+    ["ImageCore", v"0.1.1", "Colors"],
+    ["ImageCore", v"0.1.1", "Graphics"],
+    ["ImageCore", v"0.1.1", "FixedPointNumbers", v"0.3.0"],
+    ["ImageCore", v"0.1.1", "MappedArrays", v"0.0.3"],
+    ["ImageCore", v"0.1.1", "OffsetArrays"],
+    ["ImageCore", v"0.1.1", "ShowItLikeYouBuildIt"],
+    ["ImageCore", v"0.1.2", "ColorTypes"],
+    ["ImageCore", v"0.1.2", "Colors"],
+    ["ImageCore", v"0.1.2", "Graphics"],
+    ["ImageCore", v"0.1.2", "FixedPointNumbers", v"0.3.0"],
+    ["ImageCore", v"0.1.2", "MappedArrays", v"0.0.3"],
+    ["ImageCore", v"0.1.2", "OffsetArrays"],
+    ["ImageCore", v"0.1.2", "ShowItLikeYouBuildIt"],
+    ["ImageCore", v"0.1.5", "ColorTypes"],
+    ["ImageCore", v"0.1.5", "Colors"],
+    ["ImageCore", v"0.1.5", "Graphics"],
+    ["ImageCore", v"0.1.5", "Compat", v"0.19.0"],
+    ["ImageCore", v"0.1.5", "FixedPointNumbers", v"0.3.0"],
+    ["ImageCore", v"0.1.5", "MappedArrays", v"0.0.3"],
+    ["ImageCore", v"0.1.5", "OffsetArrays"],
+    ["ImageCore", v"0.1.5", "ShowItLikeYouBuildIt"],
+    ["ImageCore", v"0.2.0", "ColorTypes"],
+    ["ImageCore", v"0.2.0", "Colors"],
+    ["ImageCore", v"0.2.0", "Graphics"],
+    ["ImageCore", v"0.2.0", "Compat", v"0.19.0"],
+    ["ImageCore", v"0.2.0", "FixedPointNumbers", v"0.3.0"],
+    ["ImageCore", v"0.2.0", "MappedArrays", v"0.0.3"],
+    ["ImageCore", v"0.2.0", "OffsetArrays"],
+    ["ImageCore", v"0.2.0", "ShowItLikeYouBuildIt"],
+    ["ImageCore", v"0.3.0", "Colors"],
+    ["ImageCore", v"0.3.0", "Graphics"],
+    ["ImageCore", v"0.3.0", "ColorTypes", v"0.4.0"],
+    ["ImageCore", v"0.3.0", "Compat", v"0.19.0"],
+    ["ImageCore", v"0.3.0", "FixedPointNumbers", v"0.3.0"],
+    ["ImageCore", v"0.3.0", "MappedArrays", v"0.0.3"],
+    ["ImageCore", v"0.3.0", "OffsetArrays"],
+    ["ImageCore", v"0.3.0", "ShowItLikeYouBuildIt"],
+    ["ImageFiltering", v"0.0.2", "CatIndices"],
+    ["ImageFiltering", v"0.0.2", "ColorVectorSpace"],
+    ["ImageFiltering", v"0.0.2", "Colors"],
+    ["ImageFiltering", v"0.0.2", "ComputationalResources"],
+    ["ImageFiltering", v"0.0.2", "ImageCore"],
+    ["ImageFiltering", v"0.0.2", "DataStructures", v"0.4.6"],
+    ["ImageFiltering", v"0.0.2", "FFTViews"],
+    ["ImageFiltering", v"0.0.2", "MappedArrays"],
+    ["ImageFiltering", v"0.0.2", "OffsetArrays"],
+    ["ImageFiltering", v"0.0.2", "StaticArrays", v"0.0.5"],
+    ["ImageFiltering", v"0.0.2", "TiledIteration"],
+    ["ImageFiltering", v"0.0.2", "FixedPointNumbers", v"0.0.0-", v"0.3.0"],
+    ["ImageFiltering", v"0.1.2", "CatIndices"],
+    ["ImageFiltering", v"0.1.2", "ColorVectorSpace"],
+    ["ImageFiltering", v"0.1.2", "Colors"],
+    ["ImageFiltering", v"0.1.2", "ComputationalResources"],
+    ["ImageFiltering", v"0.1.2", "FFTViews"],
+    ["ImageFiltering", v"0.1.2", "ImageCore"],
+    ["ImageFiltering", v"0.1.2", "DataStructures", v"0.4.6"],
+    ["ImageFiltering", v"0.1.2", "MappedArrays"],
+    ["ImageFiltering", v"0.1.2", "OffsetArrays"],
+    ["ImageFiltering", v"0.1.2", "FixedPointNumbers", v"0.3.0"],
+    ["ImageFiltering", v"0.1.2", "StaticArrays", v"0.0.5"],
+    ["ImageFiltering", v"0.1.2", "TiledIteration"],
+    ["ImageFiltering", v"0.1.4", "CatIndices"],
+    ["ImageFiltering", v"0.1.4", "ColorVectorSpace"],
+    ["ImageFiltering", v"0.1.4", "Colors"],
+    ["ImageFiltering", v"0.1.4", "ComputationalResources"],
+    ["ImageFiltering", v"0.1.4", "Compat", v"0.18.0"],
+    ["ImageFiltering", v"0.1.4", "DataStructures", v"0.4.6"],
+    ["ImageFiltering", v"0.1.4", "FFTViews"],
+    ["ImageFiltering", v"0.1.4", "ImageCore"],
+    ["ImageFiltering", v"0.1.4", "MappedArrays"],
+    ["ImageFiltering", v"0.1.4", "OffsetArrays"],
+    ["ImageFiltering", v"0.1.4", "TiledIteration"],
+    ["ImageFiltering", v"0.1.4", "FixedPointNumbers", v"0.3.0"],
+    ["ImageFiltering", v"0.1.4", "StaticArrays", v"0.0.5"],
+    ["ImageMagick", v"0.0.1", "BinDeps"],
+    ["ImageMagick", v"0.0.1", "ColorTypes"],
+    ["ImageMagick", v"0.0.1", "Compat"],
+    ["ImageMagick", v"0.0.1", "FileIO"],
+    ["ImageMagick", v"0.0.1", "FixedPointNumbers", v"0.0.0-", v"0.3.0"],
+    ["ImageMagick", v"0.0.1", "Images", v"0.0.0-", v"0.6.0"],
+    ["ImageMagick", v"0.1.3", "BinDeps"],
+    ["ImageMagick", v"0.1.3", "ColorTypes", v"0.2.0"],
+    ["ImageMagick", v"0.1.3", "FileIO"],
+    ["ImageMagick", v"0.1.3", "FixedPointNumbers", v"0.1.0", v"0.3.0"],
+    ["ImageMagick", v"0.1.3", "Images", v"0.0.0-", v"0.6.0"],
+    ["ImageMagick", v"0.1.6", "BinDeps"],
+    ["ImageMagick", v"0.1.6", "ColorTypes", v"0.2.0"],
+    ["ImageMagick", v"0.1.6", "Compat", v"0.7.7"],
+    ["ImageMagick", v"0.1.6", "FileIO"],
+    ["ImageMagick", v"0.1.6", "FixedPointNumbers", v"0.1.0", v"0.3.0"],
+    ["ImageMagick", v"0.1.6", "Images", v"0.0.0-", v"0.6.0"],
+    ["ImageMagick", v"0.1.7", "BinDeps"],
+    ["ImageMagick", v"0.1.7", "ColorTypes", v"0.2.0"],
+    ["ImageMagick", v"0.1.7", "Compat", v"0.8.4"],
+    ["ImageMagick", v"0.1.7", "FileIO"],
+    ["ImageMagick", v"0.1.7", "FixedPointNumbers", v"0.1.0", v"0.3.0"],
+    ["ImageMagick", v"0.1.7", "Images", v"0.0.0-", v"0.6.0"],
+    ["ImageMagick", v"0.1.8", "BinDeps"],
+    ["ImageMagick", v"0.1.8", "ColorTypes", v"0.2.7"],
+    ["ImageMagick", v"0.1.8", "Compat", v"0.8.4"],
+    ["ImageMagick", v"0.1.8", "FileIO"],
+    ["ImageMagick", v"0.1.8", "FixedPointNumbers", v"0.1.8", v"0.3.0"],
+    ["ImageMagick", v"0.1.8", "Images", v"0.0.0-", v"0.6.0"],
+    ["ImageMagick", v"0.2.1", "BinDeps"],
+    ["ImageMagick", v"0.2.1", "ColorTypes", v"0.2.7"],
+    ["ImageMagick", v"0.2.1", "FileIO"],
+    ["ImageMagick", v"0.2.1", "FixedPointNumbers", v"0.3.0"],
+    ["ImageMagick", v"0.2.3", "BinDeps"],
+    ["ImageMagick", v"0.2.3", "ColorTypes", v"0.2.7"],
+    ["ImageMagick", v"0.2.3", "Compat", v"0.18.0"],
+    ["ImageMagick", v"0.2.3", "FileIO"],
+    ["ImageMagick", v"0.2.3", "FixedPointNumbers", v"0.3.0"],
+    ["ImageMagick", v"0.2.3", "ImageCore", v"0.1.0"],
+    ["ImageMagick", v"0.2.4", "BinDeps"],
+    ["ImageMagick", v"0.2.4", "ColorTypes", v"0.2.7"],
+    ["ImageMagick", v"0.2.4", "Compat", v"0.24.0"],
+    ["ImageMagick", v"0.2.4", "FileIO"],
+    ["ImageMagick", v"0.2.4", "FixedPointNumbers", v"0.3.0"],
+    ["ImageMagick", v"0.2.4", "Images", v"0.6.0"],
+    ["ImageMetadata", v"0.0.1", "Colors"],
+    ["ImageMetadata", v"0.0.1", "FixedPointNumbers", v"0.0.0-", v"0.3.0"],
+    ["ImageMetadata", v"0.0.1", "ImageAxes"],
+    ["ImageMetadata", v"0.0.1", "ColorVectorSpace", v"0.1.11"],
+    ["ImageMetadata", v"0.0.1", "ImageCore"],
+    ["ImageMetadata", v"0.0.1", "IndirectArrays"],
+    ["ImageMetadata", v"0.2.0", "Colors"],
+    ["ImageMetadata", v"0.2.0", "ImageAxes"],
+    ["ImageMetadata", v"0.2.0", "ColorVectorSpace", v"0.1.11"],
+    ["ImageMetadata", v"0.2.0", "FixedPointNumbers", v"0.3.0"],
+    ["ImageMetadata", v"0.2.0", "ImageCore"],
+    ["ImageMetadata", v"0.2.0", "IndirectArrays"],
+    ["ImageMetadata", v"0.2.3", "Colors"],
+    ["ImageMetadata", v"0.2.3", "ImageAxes"],
+    ["ImageMetadata", v"0.2.3", "ColorVectorSpace", v"0.1.11"],
+    ["ImageMetadata", v"0.2.3", "Compat", v"0.19.0"],
+    ["ImageMetadata", v"0.2.3", "FixedPointNumbers", v"0.3.0"],
+    ["ImageMetadata", v"0.2.3", "ImageCore"],
+    ["ImageMetadata", v"0.2.3", "IndirectArrays"],
+    ["ImageTransformations", v"0.0.1", "ColorVectorSpace", v"0.2.0"],
+    ["ImageTransformations", v"0.0.1", "Colors", v"0.7.0"],
+    ["ImageTransformations", v"0.0.1", "CoordinateTransformations", v"0.4.0"],
+    ["ImageTransformations", v"0.0.1", "ImageCore", v"0.1.2"],
+    ["ImageTransformations", v"0.0.1", "Interpolations", v"0.3.7"],
+    ["ImageTransformations", v"0.0.1", "OffsetArrays"],
+    ["ImageTransformations", v"0.0.1", "StaticArrays"],
+    ["ImageTransformations", v"0.1.0", "ColorVectorSpace", v"0.2.0"],
+    ["ImageTransformations", v"0.1.0", "Colors", v"0.7.0"],
+    ["ImageTransformations", v"0.1.0", "CoordinateTransformations", v"0.4.0"],
+    ["ImageTransformations", v"0.1.0", "FixedPointNumbers", v"0.3.0"],
+    ["ImageTransformations", v"0.1.0", "ImageCore", v"0.1.2"],
+    ["ImageTransformations", v"0.1.0", "Interpolations", v"0.3.7"],
+    ["ImageTransformations", v"0.1.0", "OffsetArrays"],
+    ["ImageTransformations", v"0.1.0", "StaticArrays"],
+    ["ImageTransformations", v"0.2.2", "AxisAlgorithms"],
+    ["ImageTransformations", v"0.2.2", "ColorVectorSpace", v"0.2.0"],
+    ["ImageTransformations", v"0.2.2", "Colors", v"0.7.0"],
+    ["ImageTransformations", v"0.2.2", "Compat", v"0.18.0"],
+    ["ImageTransformations", v"0.2.2", "CoordinateTransformations", v"0.4.0"],
+    ["ImageTransformations", v"0.2.2", "OffsetArrays"],
+    ["ImageTransformations", v"0.2.2", "StaticArrays"],
+    ["ImageTransformations", v"0.2.2", "FixedPointNumbers", v"0.3.0"],
+    ["ImageTransformations", v"0.2.2", "ImageCore", v"0.1.2"],
+    ["ImageTransformations", v"0.2.2", "Interpolations", v"0.4.0"],
+    ["Images", v"0.4.50", "BinDeps"],
+    ["Images", v"0.4.50", "ColorVectorSpace"],
+    ["Images", v"0.4.50", "Colors"],
+    ["Images", v"0.4.50", "SIUnits"],
+    ["Images", v"0.4.50", "Compat", v"0.4.0"],
+    ["Images", v"0.4.50", "FixedPointNumbers", v"0.0.0-", v"0.3.0"],
+    ["Images", v"0.4.50", "Graphics", v"0.1.0"],
+    ["Images", v"0.4.50", "Zlib"],
+    ["Images", v"0.5.4", "FileIO"],
+    ["Images", v"0.5.4", "SIUnits"],
+    ["Images", v"0.5.4", "ColorVectorSpace", v"0.1.0"],
+    ["Images", v"0.5.4", "Colors", v"0.6.0"],
+    ["Images", v"0.5.4", "Graphics", v"0.1.0"],
+    ["Images", v"0.5.4", "FixedPointNumbers", v"0.1.0", v"0.3.0"],
+    ["Images", v"0.5.4", "Zlib"],
+    ["Images", v"0.5.5", "ColorVectorSpace", v"0.1.0"],
+    ["Images", v"0.5.5", "Colors", v"0.6.0"],
+    ["Images", v"0.5.5", "Compat", v"0.7.15"],
+    ["Images", v"0.5.5", "FileIO"],
+    ["Images", v"0.5.5", "Graphics", v"0.1.0"],
+    ["Images", v"0.5.5", "FixedPointNumbers", v"0.1.0", v"0.3.0"],
+    ["Images", v"0.5.5", "SIUnits"],
+    ["Images", v"0.5.5", "Zlib"],
+    ["Images", v"0.5.9", "ColorVectorSpace", v"0.1.0"],
+    ["Images", v"0.5.9", "Colors", v"0.6.0"],
+    ["Images", v"0.5.9", "Compat", v"0.8.4"],
+    ["Images", v"0.5.9", "FileIO"],
+    ["Images", v"0.5.9", "Graphics", v"0.1.0"],
+    ["Images", v"0.5.9", "FixedPointNumbers", v"0.1.0", v"0.3.0"],
+    ["Images", v"0.5.9", "SIUnits"],
+    ["Images", v"0.5.9", "StatsBase"],
+    ["Images", v"0.5.9", "Zlib"],
+    ["Images", v"0.5.14", "ColorVectorSpace", v"0.1.0"],
+    ["Images", v"0.5.14", "Colors", v"0.6.0"],
+    ["Images", v"0.5.14", "Compat", v"0.9.1"],
+    ["Images", v"0.5.14", "FileIO"],
+    ["Images", v"0.5.14", "Graphics", v"0.1.0"],
+    ["Images", v"0.5.14", "FixedPointNumbers", v"0.1.0", v"0.3.0"],
+    ["Images", v"0.5.14", "SIUnits"],
+    ["Images", v"0.5.14", "StatsBase"],
+    ["Images", v"0.5.14", "Zlib"],
+    ["Images", v"0.6.0", "AxisArrays"],
+    ["Images", v"0.6.0", "FileIO"],
+    ["Images", v"0.6.0", "ImageAxes"],
+    ["Images", v"0.6.0", "ImageCore"],
+    ["Images", v"0.6.0", "ImageFiltering"],
+    ["Images", v"0.6.0", "ImageMetadata"],
+    ["Images", v"0.6.0", "IndirectArrays"],
+    ["Images", v"0.6.0", "MappedArrays"],
+    ["Images", v"0.6.0", "Reexport"],
+    ["Images", v"0.6.0", "SIUnits"],
+    ["Images", v"0.6.0", "StatsBase"],
+    ["Images", v"0.6.0", "Zlib"],
+    ["Images", v"0.6.0", "ColorVectorSpace", v"0.2.0"],
+    ["Images", v"0.6.0", "Colors", v"0.7.0"],
+    ["Images", v"0.6.0", "Compat", v"0.9.1"],
+    ["Images", v"0.6.0", "FixedPointNumbers", v"0.3.0"],
+    ["Images", v"0.6.0", "Graphics", v"0.1.0"],
+    ["Images", v"0.7.0", "AxisArrays"],
+    ["Images", v"0.7.0", "FileIO"],
+    ["Images", v"0.7.0", "ColorVectorSpace", v"0.2.0"],
+    ["Images", v"0.7.0", "Colors", v"0.7.0"],
+    ["Images", v"0.7.0", "Compat", v"0.9.1"],
+    ["Images", v"0.7.0", "Graphics", v"0.1.0"],
+    ["Images", v"0.7.0", "ImageAxes"],
+    ["Images", v"0.7.0", "ImageCore"],
+    ["Images", v"0.7.0", "ImageFiltering"],
+    ["Images", v"0.7.0", "ImageMetadata"],
+    ["Images", v"0.7.0", "IndirectArrays"],
+    ["Images", v"0.7.0", "MappedArrays"],
+    ["Images", v"0.7.0", "Reexport"],
+    ["Images", v"0.7.0", "SIUnits"],
+    ["Images", v"0.7.0", "StatsBase"],
+    ["Images", v"0.7.0", "FixedPointNumbers", v"0.3.0"],
+    ["Images", v"0.8.0", "AxisArrays"],
+    ["Images", v"0.8.0", "FileIO"],
+    ["Images", v"0.8.0", "ImageAxes"],
+    ["Images", v"0.8.0", "ImageCore"],
+    ["Images", v"0.8.0", "ColorVectorSpace", v"0.2.0"],
+    ["Images", v"0.8.0", "Colors", v"0.7.0"],
+    ["Images", v"0.8.0", "Compat", v"0.9.1"],
+    ["Images", v"0.8.0", "Graphics", v"0.1.0"],
+    ["Images", v"0.8.0", "ImageFiltering"],
+    ["Images", v"0.8.0", "ImageMetadata"],
+    ["Images", v"0.8.0", "ImageTransformations"],
+    ["Images", v"0.8.0", "IndirectArrays"],
+    ["Images", v"0.8.0", "MappedArrays"],
+    ["Images", v"0.8.0", "Reexport"],
+    ["Images", v"0.8.0", "SIUnits"],
+    ["Images", v"0.8.0", "StatsBase"],
+    ["Images", v"0.8.0", "FixedPointNumbers", v"0.3.0"],
+    ["Images", v"0.9.0", "AxisArrays"],
+    ["Images", v"0.9.0", "FileIO"],
+    ["Images", v"0.9.0", "Graphics", v"0.1.0"],
+    ["Images", v"0.9.0", "ImageAxes"],
+    ["Images", v"0.9.0", "ImageCore"],
+    ["Images", v"0.9.0", "ColorVectorSpace", v"0.2.0"],
+    ["Images", v"0.9.0", "Colors", v"0.7.0"],
+    ["Images", v"0.9.0", "Compat", v"0.18.0"],
+    ["Images", v"0.9.0", "ImageFiltering"],
+    ["Images", v"0.9.0", "ImageMetadata"],
+    ["Images", v"0.9.0", "ImageTransformations"],
+    ["Images", v"0.9.0", "IndirectArrays"],
+    ["Images", v"0.9.0", "MappedArrays"],
+    ["Images", v"0.9.0", "Reexport"],
+    ["Images", v"0.9.0", "SIUnits"],
+    ["Images", v"0.9.0", "StatsBase"],
+    ["Images", v"0.9.0", "FixedPointNumbers", v"0.3.0"],
+    ["Images", v"0.9.1", "AxisArrays"],
+    ["Images", v"0.9.1", "FileIO"],
+    ["Images", v"0.9.1", "ImageAxes"],
+    ["Images", v"0.9.1", "ImageCore"],
+    ["Images", v"0.9.1", "ColorVectorSpace", v"0.2.0"],
+    ["Images", v"0.9.1", "Colors", v"0.7.0"],
+    ["Images", v"0.9.1", "Compat", v"0.19.0"],
+    ["Images", v"0.9.1", "ImageFiltering"],
+    ["Images", v"0.9.1", "ImageMetadata"],
+    ["Images", v"0.9.1", "ImageTransformations"],
+    ["Images", v"0.9.1", "IndirectArrays"],
+    ["Images", v"0.9.1", "MappedArrays"],
+    ["Images", v"0.9.1", "Reexport"],
+    ["Images", v"0.9.1", "SIUnits"],
+    ["Images", v"0.9.1", "StatsBase"],
+    ["Images", v"0.9.1", "FixedPointNumbers", v"0.3.0"],
+    ["Images", v"0.9.1", "Graphics", v"0.1.0"],
+    ["IndirectArrays", v"0.1.0"],
+    ["IndirectArrays", v"0.1.1", "Compat", v"0.19.0"],
+    ["InplaceOps", v"0.1.0"],
+    ["Interpolations", v"0.0.1-beta", "Compat"],
+    ["Interpolations", v"0.0.1-beta", "WoodburyMatrices"],
+    ["Interpolations", v"0.1.0", "WoodburyMatrices"],
+    ["Interpolations", v"0.3.4", "AxisAlgorithms"],
+    ["Interpolations", v"0.3.4", "Ratios"],
+    ["Interpolations", v"0.3.4", "WoodburyMatrices", v"0.1.0"],
+    ["Interpolations", v"0.3.5", "AxisAlgorithms"],
+    ["Interpolations", v"0.3.5", "Ratios"],
+    ["Interpolations", v"0.3.5", "WoodburyMatrices", v"0.1.5"],
+    ["Interpolations", v"0.3.6", "AxisAlgorithms"],
+    ["Interpolations", v"0.3.6", "Ratios"],
+    ["Interpolations", v"0.3.6", "Compat", v"0.8.0"],
+    ["Interpolations", v"0.3.6", "WoodburyMatrices", v"0.1.5"],
+    ["Interpolations", v"0.3.7", "AxisAlgorithms"],
+    ["Interpolations", v"0.3.7", "DualNumbers"],
+    ["Interpolations", v"0.3.7", "Ratios"],
+    ["Interpolations", v"0.3.7", "Compat", v"0.8.0"],
+    ["Interpolations", v"0.3.7", "WoodburyMatrices", v"0.1.5"],
+    ["Interpolations", v"0.3.8", "AxisAlgorithms"],
+    ["Interpolations", v"0.3.8", "DualNumbers"],
+    ["Interpolations", v"0.3.8", "Ratios"],
+    ["Interpolations", v"0.3.8", "Compat", v"0.19.0"],
+    ["Interpolations", v"0.3.8", "WoodburyMatrices", v"0.1.5"],
+    ["Interpolations", v"0.4.0", "AxisAlgorithms"],
+    ["Interpolations", v"0.4.0", "DualNumbers"],
+    ["Interpolations", v"0.4.0", "Ratios"],
+    ["Interpolations", v"0.4.0", "Compat", v"0.19.0"],
+    ["Interpolations", v"0.4.0", "WoodburyMatrices", v"0.1.5"],
+    ["Interpolations", v"0.5.0", "AxisAlgorithms"],
+    ["Interpolations", v"0.5.0", "DualNumbers"],
+    ["Interpolations", v"0.5.0", "Ratios"],
+    ["Interpolations", v"0.5.0", "ShowItLikeYouBuildIt"],
+    ["Interpolations", v"0.5.0", "Compat", v"0.19.0"],
+    ["Interpolations", v"0.5.0", "WoodburyMatrices", v"0.1.5"],
+    ["IntervalSets", v"0.0.2"],
+    ["IntervalSets", v"0.0.5", "Compat", v"0.17.0"],
+    ["IterativeSolvers", v"0.0.1", "Compat"],
+    ["IterativeSolvers", v"0.0.1", "Docile"],
+    ["IterativeSolvers", v"0.2.1", "Compat"],
+    ["IterativeSolvers", v"0.2.2", "Compat"],
+    ["Iterators", v"0.1.10", "Compat"],
+    ["Iterators", v"0.3.0"],
+    ["JLD", v"0.6.4", "Compat", v"0.8.0"],
+    ["JLD", v"0.6.4", "FileIO"],
+    ["JLD", v"0.6.4", "HDF5"],
+    ["JLD", v"0.6.4", "LegacyStrings"],
+    ["JLD", v"0.6.10", "Compat", v"0.8.0"],
+    ["JLD", v"0.6.10", "FileIO"],
+    ["JLD", v"0.6.10", "HDF5"],
+    ["JLD", v"0.6.10", "LegacyStrings"],
+    ["JSON", v"0.3.9"],
+    ["JSON", v"0.4.4", "Compat"],
+    ["JSON", v"0.4.5", "Compat", v"0.4.12"],
+    ["JSON", v"0.5.0", "Compat", v"0.7.1"],
+    ["JSON", v"0.5.4", "Compat", v"0.7.16"],
+    ["JSON", v"0.6.0", "Compat", v"0.7.20"],
+    ["JSON", v"0.8.0", "Compat", v"0.8.4"],
+    ["JSON", v"0.8.2", "Compat", v"0.9.5"],
+    ["JSON", v"0.8.3", "Compat", v"0.17.0"],
+    ["JSON", v"0.9.0", "Compat", v"0.17.0"],
+    ["JuliaParser", v"0.5.3", "FactCheck"],
+    ["JuliaParser", v"0.6.4", "Compat"],
+    ["JuliaParser", v"0.6.4", "FactCheck"],
+    ["JuliaParser", v"0.7.0", "AbstractTrees"],
+    ["JuliaParser", v"0.7.0", "Compat"],
+    ["JuliaParser", v"0.7.1", "AbstractTrees"],
+    ["JuliaParser", v"0.7.1", "Compat"],
+    ["JuliaParser", v"0.7.4", "AbstractTrees"],
+    ["JuliaParser", v"0.7.4", "Compat"],
+    ["Juno", v"0.2.3", "Hiccup"],
+    ["Juno", v"0.2.3", "MacroTools"],
+    ["Juno", v"0.2.3", "Media"],
+    ["Juno", v"0.2.4", "Hiccup"],
+    ["Juno", v"0.2.4", "MacroTools"],
+    ["Juno", v"0.2.4", "Media"],
+    ["Juno", v"0.2.5", "Hiccup"],
+    ["Juno", v"0.2.5", "MacroTools"],
+    ["Juno", v"0.2.5", "Media"],
+    ["Juno", v"0.2.7", "Hiccup"],
+    ["Juno", v"0.2.7", "MacroTools"],
+    ["Juno", v"0.2.7", "Media"],
+    ["LNR", v"0.0.0"],
+    ["LNR", v"0.0.1", "Lazy"],
+    ["LNR", v"0.0.2", "Compat"],
+    ["LNR", v"0.0.2", "Lazy"],
+    ["Lazy", v"0.9.1"],
+    ["Lazy", v"0.10.0", "MacroTools"],
+    ["Lazy", v"0.10.1", "Compat"],
+    ["Lazy", v"0.10.1", "MacroTools"],
+    ["Lazy", v"0.11.2", "MacroTools"],
+    ["Lazy", v"0.11.2", "Compat", v"0.8.0"],
+    ["Lazy", v"0.11.6", "MacroTools"],
+    ["Lazy", v"0.11.6", "Compat", v"0.8.0"],
+    ["LearnBase", v"0.1.0", "StatsBase"],
+    ["LearnBase", v"0.1.1", "Distributions"],
+    ["LearnBase", v"0.1.1", "StatsBase"],
+    ["LearnBase", v"0.1.2", "Distributions"],
+    ["LearnBase", v"0.1.2", "StatsBase", v"0.8.0"],
+    ["LearnBase", v"0.1.3", "Distributions"],
+    ["LearnBase", v"0.1.3", "Compat", v"0.17.0"],
+    ["LearnBase", v"0.1.3", "StatsBase", v"0.8.0"],
+    ["LearnBase", v"0.1.5", "Distributions"],
+    ["LearnBase", v"0.1.5", "Compat", v"0.18.0"],
+    ["LearnBase", v"0.1.5", "StatsBase", v"0.8.0"],
+    ["LegacyStrings", v"0.1.0"],
+    ["LegacyStrings", v"0.2.0", "Compat", v"0.8.4"],
+    ["LegacyStrings", v"0.2.1", "Compat", v"0.18.0"],
+    ["LineSearches", v"0.0.2"],
+    ["LineSearches", v"0.1.1"],
+    ["LineSearches", v"0.1.5"],
+    ["LossFunctions", v"0.0.1", "LearnBase", v"0.0.1", v"0.2.0"],
+    ["LossFunctions", v"0.0.1", "RecipesBase"],
+    ["LossFunctions", v"0.0.1", "Reexport"],
+    ["LossFunctions", v"0.0.2", "LearnBase", v"0.0.1", v"0.2.0"],
+    ["LossFunctions", v"0.0.2", "RecipesBase"],
+    ["LossFunctions", v"0.0.2", "Reexport"],
+    ["LossFunctions", v"0.0.3", "LearnBase", v"0.1.2", v"0.2.0"],
+    ["LossFunctions", v"0.0.3", "RecipesBase"],
+    ["LossFunctions", v"0.0.3", "StatsBase", v"0.8.0"],
+    ["LossFunctions", v"0.1.0", "LearnBase", v"0.1.3", v"0.2.0"],
+    ["LossFunctions", v"0.1.0", "RecipesBase"],
+    ["LossFunctions", v"0.1.0", "StatsBase", v"0.8.0"],
+    ["LsqFit", v"0.0.1", "Calculus"],
+    ["LsqFit", v"0.0.1", "Distributions"],
+    ["LsqFit", v"0.0.1", "Optim", v"0.0.0", v"0.5.0"],
+    ["LsqFit", v"0.0.2", "Calculus"],
+    ["LsqFit", v"0.0.2", "Distributions"],
+    ["LsqFit", v"0.0.2", "Optim"],
+    ["LsqFit", v"0.1.0", "Calculus"],
+    ["LsqFit", v"0.1.0", "Distributions"],
+    ["LsqFit", v"0.1.0", "Optim", v"0.6.0"],
+    ["LsqFit", v"0.1.1", "Calculus"],
+    ["LsqFit", v"0.1.1", "Distributions"],
+    ["LsqFit", v"0.1.1", "Optim", v"0.7.0"],
+    ["LsqFit", v"0.2.0", "Calculus"],
+    ["LsqFit", v"0.2.0", "Distributions"],
+    ["LsqFit", v"0.2.0", "Compat", v"0.9.1"],
+    ["LsqFit", v"0.2.0", "Optim", v"0.7.5"],
+    ["MachO", v"0.0.4", "ObjFileBase"],
+    ["MachO", v"0.0.4", "StructIO"],
+    ["MacroTools", v"0.1.0"],
+    ["MacroTools", v"0.3.0"],
+    ["MacroTools", v"0.3.1", "Compat"],
+    ["MacroTools", v"0.3.3", "Compat"],
+    ["MacroTools", v"0.3.6", "Compat", v"0.7.9"],
+    ["MappedArrays", v"0.0.2"],
+    ["MappedArrays", v"0.0.5"],
+    ["MappedArrays", v"0.0.7", "Compat", v"0.19.0"],
+    ["Markdown", v"0.1.0"],
+    ["Markdown", v"0.3.0", "Lazy"],
+    ["MbedTLS", v"0.2.3", "BinDeps"],
+    ["MbedTLS", v"0.2.3", "Compat", v"0.7.9"],
+    ["MbedTLS", v"0.3.0", "BinDeps"],
+    ["MbedTLS", v"0.3.0", "Compat", v"0.8.0"],
+    ["MbedTLS", v"0.4.4", "BinDeps"],
+    ["MbedTLS", v"0.4.5", "BinDeps"],
+    ["MbedTLS", v"0.4.5", "Compat", v"0.9.5"],
+    ["Measures", v"0.0.2"],
+    ["Measures", v"0.0.3", "Compat", v"0.7.15"],
+    ["Measures", v"0.1.0", "Compat", v"0.18.0"],
+    ["Media", v"0.1.0", "Lazy"],
+    ["Media", v"0.1.0", "Requires"],
+    ["Media", v"0.2.2", "Lazy"],
+    ["Media", v"0.2.2", "MacroTools"],
+    ["Media", v"0.2.2", "Requires"],
+    ["Media", v"0.2.3", "MacroTools"],
+    ["Media", v"0.2.3", "Lazy", v"0.11.3"],
+    ["Media", v"0.2.7", "MacroTools"],
+    ["MultiScaleArrays", v"0.0.1", "Iterators"],
+    ["MultiScaleArrays", v"0.0.1", "RecursiveArrayTools", v"0.0.2"],
+    ["MultiScaleArrays", v"0.1.0", "DiffEqBase", v"0.11.0"],
+    ["MultiScaleArrays", v"0.1.0", "Iterators"],
+    ["MultiScaleArrays", v"0.1.0", "RecursiveArrayTools", v"0.0.2"],
+    ["Mustache", v"0.0.1", "DataFrames"],
+    ["Mustache", v"0.0.7", "Compat"],
+    ["Mustache", v"0.0.7", "Requires"],
+    ["Mustache", v"0.0.14", "Requires"],
+    ["Mustache", v"0.0.14", "Compat", v"0.4.0"],
+    ["Mustache", v"0.1.0"],
+    ["Mustache", v"0.1.4", "Compat", v"0.7.18"],
+    ["Mux", v"0.0.0", "Hiccup"],
+    ["Mux", v"0.0.0", "HttpServer"],
+    ["Mux", v"0.0.0", "Lazy"],
+    ["Mux", v"0.0.0", "URIParser"],
+    ["Mux", v"0.1.1", "Compat"],
+    ["Mux", v"0.1.1", "Hiccup"],
+    ["Mux", v"0.1.1", "HttpCommon"],
+    ["Mux", v"0.1.1", "HttpServer"],
+    ["Mux", v"0.1.1", "Lazy"],
+    ["Mux", v"0.1.1", "URIParser"],
+    ["Mux", v"0.1.1", "WebSockets"],
+    ["Mux", v"0.2.2", "Hiccup"],
+    ["Mux", v"0.2.2", "HttpCommon"],
+    ["Mux", v"0.2.2", "HttpServer"],
+    ["Mux", v"0.2.2", "Lazy"],
+    ["Mux", v"0.2.2", "URIParser"],
+    ["Mux", v"0.2.2", "WebSockets"],
+    ["Mux", v"0.2.3", "Hiccup"],
+    ["Mux", v"0.2.3", "HttpCommon"],
+    ["Mux", v"0.2.3", "Compat", v"0.7.9"],
+    ["Mux", v"0.2.3", "HttpServer"],
+    ["Mux", v"0.2.3", "Lazy"],
+    ["Mux", v"0.2.3", "URIParser"],
+    ["Mux", v"0.2.3", "WebSockets"],
+    ["NLSolversBase", v"2.1.1", "Compat", v"0.17.0"],
+    ["NLsolve", v"0.7.3", "Calculus"],
+    ["NLsolve", v"0.7.3", "Distances"],
+    ["NLsolve", v"0.7.3", "Optim"],
+    ["NLsolve", v"0.7.3", "Compat", v"0.8.0"],
+    ["NLsolve", v"0.7.3", "ForwardDiff", v"0.2.0"],
+    ["NLsolve", v"0.7.3", "LineSearches", v"0.0.1", v"1.0.0-"],
+    ["NLsolve", v"0.8.0", "Calculus"],
+    ["NLsolve", v"0.8.0", "Distances"],
+    ["NLsolve", v"0.8.0", "Optim"],
+    ["NLsolve", v"0.8.0", "Compat", v"0.8.4"],
+    ["NLsolve", v"0.8.0", "ForwardDiff", v"0.2.0"],
+    ["NLsolve", v"0.8.0", "LineSearches", v"0.0.1", v"1.0.0-"],
+    ["NLsolve", v"0.9.0", "Calculus"],
+    ["NLsolve", v"0.9.0", "DiffBase"],
+    ["NLsolve", v"0.9.0", "Distances"],
+    ["NLsolve", v"0.9.0", "Optim"],
+    ["NLsolve", v"0.9.0", "Compat", v"0.8.4"],
+    ["NLsolve", v"0.9.0", "ForwardDiff", v"0.3.0"],
+    ["NLsolve", v"0.9.0", "LineSearches", v"0.1.2", v"1.0.0-"],
+    ["NLsolve", v"0.9.1", "Calculus"],
+    ["NLsolve", v"0.9.1", "DiffBase"],
+    ["NLsolve", v"0.9.1", "Distances"],
+    ["NLsolve", v"0.9.1", "Optim"],
+    ["NLsolve", v"0.9.1", "Compat", v"0.8.4"],
+    ["NLsolve", v"0.9.1", "ForwardDiff", v"0.3.0"],
+    ["NLsolve", v"0.9.1", "LineSearches", v"0.1.2", v"1.0.0-"],
+    ["NaNMath", v"0.1.1", "Compat"],
+    ["NaNMath", v"0.2.0"],
+    ["NaNMath", v"0.2.1"],
+    ["NaNMath", v"0.2.3", "Compat", v"0.9.1"],
+    ["NaNMath", v"0.2.4", "Compat", v"0.9.1"],
+    ["Nettle", v"0.1.1"],
+    ["Nettle", v"0.1.7", "BinDeps"],
+    ["Nettle", v"0.1.10", "BinDeps"],
+    ["Nettle", v"0.1.10", "Compat"],
+    ["Nettle", v"0.2.3", "BinDeps"],
+    ["Nettle", v"0.2.3", "Compat"],
+    ["Nettle", v"0.3.0", "BinDeps"],
+    ["Nettle", v"0.3.0", "Compat", v"0.8.0"],
+    ["NumericExtensions", v"0.3.6"],
+    ["NumericExtensions", v"0.4.3", "ArrayViews", v"0.2.0-"],
+    ["NumericExtensions", v"0.5.6", "ArrayViews", v"0.2.0-"],
+    ["NumericExtensions", v"0.6.2", "ArrayViews", v"0.2.0-"],
+    ["NumericExtensions", v"0.6.2", "NumericFuns", v"0.2.1-"],
+    ["NumericFuns", v"0.2.0"],
+    ["NumericFuns", v"0.2.3"],
+    ["NumericFuns", v"0.2.4", "Compat"],
+    ["ObjFileBase", v"0.0.4"],
+    ["OffsetArrays", v"0.2.13"],
+    ["OffsetArrays", v"0.3.0", "Compat", v"0.19.0"],
+    ["Optim", v"0.4.6", "Calculus"],
+    ["Optim", v"0.4.6", "Compat"],
+    ["Optim", v"0.4.6", "DualNumbers"],
+    ["Optim", v"0.4.6", "LineSearches", v"0.0.1", v"1.0.0-"],
+    ["Optim", v"0.4.7", "Calculus"],
+    ["Optim", v"0.4.7", "DualNumbers", v"0.2.0"],
+    ["Optim", v"0.4.7", "PositiveFactorizations"],
+    ["Optim", v"0.4.7", "LineSearches", v"0.0.1", v"1.0.0-"],
+    ["Optim", v"0.5.0", "Calculus"],
+    ["Optim", v"0.5.0", "PositiveFactorizations"],
+    ["Optim", v"0.5.0", "Compat", v"0.7.16"],
+    ["Optim", v"0.5.0", "DualNumbers", v"0.2.0"],
+    ["Optim", v"0.5.0", "LineSearches", v"0.0.1", v"1.0.0-"],
+    ["Optim", v"0.6.1", "Calculus"],
+    ["Optim", v"0.6.1", "PositiveFactorizations"],
+    ["Optim", v"0.6.1", "Compat", v"0.8.4"],
+    ["Optim", v"0.6.1", "ForwardDiff", v"0.2.0", v"0.3.0"],
+    ["Optim", v"0.6.1", "LineSearches", v"0.0.1", v"1.0.0-"],
+    ["Optim", v"0.7.2", "Calculus"],
+    ["Optim", v"0.7.2", "PositiveFactorizations"],
+    ["Optim", v"0.7.2", "Compat", v"0.8.4"],
+    ["Optim", v"0.7.2", "ForwardDiff", v"0.3.0", v"0.4.0"],
+    ["Optim", v"0.7.2", "LineSearches", v"0.1.0", v"1.0.0-"],
+    ["Optim", v"0.7.4", "Calculus"],
+    ["Optim", v"0.7.4", "PositiveFactorizations"],
+    ["Optim", v"0.7.4", "Compat", v"0.8.4"],
+    ["Optim", v"0.7.4", "ForwardDiff", v"0.3.0", v"0.4.0"],
+    ["Optim", v"0.7.4", "LineSearches", v"0.1.2", v"1.0.0-"],
+    ["Optim", v"0.7.5", "Calculus"],
+    ["Optim", v"0.7.5", "PositiveFactorizations"],
+    ["Optim", v"0.7.5", "Compat", v"0.8.4"],
+    ["Optim", v"0.7.5", "ForwardDiff", v"0.3.0", v"0.4.0"],
+    ["Optim", v"0.7.5", "LineSearches", v"0.1.2", v"1.0.0-"],
+    ["Optim", v"0.7.7", "Calculus"],
+    ["Optim", v"0.7.7", "PositiveFactorizations"],
+    ["Optim", v"0.7.7", "Compat", v"0.18.0"],
+    ["Optim", v"0.7.7", "ForwardDiff", v"0.3.0", v"0.4.0"],
+    ["Optim", v"0.7.7", "LineSearches", v"0.1.2", v"1.0.0-"],
+    ["Optim", v"0.7.8", "Calculus"],
+    ["Optim", v"0.7.8", "PositiveFactorizations"],
+    ["Optim", v"0.7.8", "Compat", v"0.18.0"],
+    ["Optim", v"0.7.8", "ForwardDiff", v"0.3.0", v"0.5.0"],
+    ["Optim", v"0.7.8", "LineSearches", v"0.1.2", v"1.0.0-"],
+    ["Options", v"0.2.6"],
+    ["OrdinaryDiffEq", v"0.0.1", "Compat", v"0.8.8"],
+    ["OrdinaryDiffEq", v"0.0.1", "DiffEqBase", v"0.0.0", v"0.7.0"],
+    ["OrdinaryDiffEq", v"0.0.1", "ForwardDiff", v"0.2.4"],
+    ["OrdinaryDiffEq", v"0.0.1", "GenericSVD", v"0.0.2"],
+    ["OrdinaryDiffEq", v"0.0.1", "InplaceOps", v"0.0.5"],
+    ["OrdinaryDiffEq", v"0.0.1", "NLsolve", v"0.7.3"],
+    ["OrdinaryDiffEq", v"0.0.1", "Parameters", v"0.5.0"],
+    ["OrdinaryDiffEq", v"0.0.1", "Ranges", v"0.0.1"],
+    ["OrdinaryDiffEq", v"0.0.1", "RecipesBase", v"0.1.0"],
+    ["OrdinaryDiffEq", v"0.0.1", "Sundials", v"0.3.0"],
+    ["OrdinaryDiffEq", v"0.0.3", "Compat", v"0.8.8"],
+    ["OrdinaryDiffEq", v"0.0.3", "DiffEqBase", v"0.0.0", v"0.7.0"],
+    ["OrdinaryDiffEq", v"0.0.3", "ForwardDiff", v"0.2.4"],
+    ["OrdinaryDiffEq", v"0.0.3", "GenericSVD", v"0.0.2"],
+    ["OrdinaryDiffEq", v"0.0.3", "InplaceOps", v"0.0.5"],
+    ["OrdinaryDiffEq", v"0.0.3", "NLsolve", v"0.7.3"],
+    ["OrdinaryDiffEq", v"0.0.3", "ParameterizedFunctions", v"0.1.0"],
+    ["OrdinaryDiffEq", v"0.0.3", "Parameters", v"0.5.0"],
+    ["OrdinaryDiffEq", v"0.0.3", "Ranges", v"0.0.1"],
+    ["OrdinaryDiffEq", v"0.0.3", "RecipesBase", v"0.1.0"],
+    ["OrdinaryDiffEq", v"0.0.3", "Sundials", v"0.3.0"],
+    ["OrdinaryDiffEq", v"0.0.5", "RecursiveArrayTools"],
+    ["OrdinaryDiffEq", v"0.0.5", "Compat", v"0.8.8"],
+    ["OrdinaryDiffEq", v"0.0.5", "DiffEqBase", v"0.0.0", v"0.7.0"],
+    ["OrdinaryDiffEq", v"0.0.5", "ForwardDiff", v"0.2.4"],
+    ["OrdinaryDiffEq", v"0.0.5", "GenericSVD", v"0.0.2"],
+    ["OrdinaryDiffEq", v"0.0.5", "InplaceOps", v"0.0.5"],
+    ["OrdinaryDiffEq", v"0.0.5", "NLsolve", v"0.7.3"],
+    ["OrdinaryDiffEq", v"0.0.5", "Parameters", v"0.5.0"],
+    ["OrdinaryDiffEq", v"0.0.5", "Ranges", v"0.0.1"],
+    ["OrdinaryDiffEq", v"0.0.5", "RecipesBase", v"0.1.0"],
+    ["OrdinaryDiffEq", v"0.0.5", "Sundials", v"0.3.0"],
+    ["OrdinaryDiffEq", v"0.1.0", "Compat", v"0.8.8"],
+    ["OrdinaryDiffEq", v"0.1.0", "DiffEqBase", v"0.0.0", v"0.7.0"],
+    ["OrdinaryDiffEq", v"0.1.0", "Juno"],
+    ["OrdinaryDiffEq", v"0.1.0", "RecursiveArrayTools"],
+    ["OrdinaryDiffEq", v"0.1.0", "ForwardDiff", v"0.2.4"],
+    ["OrdinaryDiffEq", v"0.1.0", "GenericSVD", v"0.0.2"],
+    ["OrdinaryDiffEq", v"0.1.0", "InplaceOps", v"0.0.5"],
+    ["OrdinaryDiffEq", v"0.1.0", "NLsolve", v"0.7.3"],
+    ["OrdinaryDiffEq", v"0.1.0", "Parameters", v"0.5.0"],
+    ["OrdinaryDiffEq", v"0.1.0", "Ranges", v"0.0.1"],
+    ["OrdinaryDiffEq", v"0.1.0", "RecipesBase", v"0.1.0"],
+    ["OrdinaryDiffEq", v"0.1.1", "Compat", v"0.8.8"],
+    ["OrdinaryDiffEq", v"0.1.1", "DiffEqBase", v"0.1.2", v"0.7.0"],
+    ["OrdinaryDiffEq", v"0.1.1", "ForwardDiff", v"0.2.4"],
+    ["OrdinaryDiffEq", v"0.1.1", "GenericSVD", v"0.0.2"],
+    ["OrdinaryDiffEq", v"0.1.1", "InplaceOps", v"0.0.5"],
+    ["OrdinaryDiffEq", v"0.1.1", "Juno", v"0.2.5"],
+    ["OrdinaryDiffEq", v"0.1.1", "NLsolve", v"0.7.3"],
+    ["OrdinaryDiffEq", v"0.1.1", "Parameters", v"0.5.0"],
+    ["OrdinaryDiffEq", v"0.1.1", "Ranges", v"0.0.1"],
+    ["OrdinaryDiffEq", v"0.1.1", "RecipesBase", v"0.1.0"],
+    ["OrdinaryDiffEq", v"0.1.1", "RecursiveArrayTools", v"0.0.2"],
+    ["OrdinaryDiffEq", v"0.5.0", "Calculus", v"0.1.15"],
+    ["OrdinaryDiffEq", v"0.5.0", "Compat", v"0.8.8"],
+    ["OrdinaryDiffEq", v"0.5.0", "DiffEqBase", v"0.2.0", v"0.7.0"],
+    ["OrdinaryDiffEq", v"0.5.0", "ForwardDiff", v"0.2.4"],
+    ["OrdinaryDiffEq", v"0.5.0", "GenericSVD", v"0.0.2"],
+    ["OrdinaryDiffEq", v"0.5.0", "InplaceOps", v"0.0.5"],
+    ["OrdinaryDiffEq", v"0.5.0", "Juno", v"0.2.5"],
+    ["OrdinaryDiffEq", v"0.5.0", "NLsolve", v"0.7.3"],
+    ["OrdinaryDiffEq", v"0.5.0", "Parameters", v"0.5.0"],
+    ["OrdinaryDiffEq", v"0.5.0", "Ranges", v"0.0.1"],
+    ["OrdinaryDiffEq", v"0.5.0", "RecipesBase", v"0.1.0"],
+    ["OrdinaryDiffEq", v"0.5.0", "RecursiveArrayTools", v"0.0.2"],
+    ["OrdinaryDiffEq", v"0.6.0", "Calculus", v"0.1.15"],
+    ["OrdinaryDiffEq", v"0.6.0", "Compat", v"0.8.8"],
+    ["OrdinaryDiffEq", v"0.6.0", "DiffEqBase", v"0.4.0", v"0.7.0"],
+    ["OrdinaryDiffEq", v"0.6.0", "ForwardDiff", v"0.2.4"],
+    ["OrdinaryDiffEq", v"0.6.0", "GenericSVD", v"0.0.2"],
+    ["OrdinaryDiffEq", v"0.6.0", "InplaceOps", v"0.0.5"],
+    ["OrdinaryDiffEq", v"0.6.0", "Juno", v"0.2.5"],
+    ["OrdinaryDiffEq", v"0.6.0", "NLsolve", v"0.7.3"],
+    ["OrdinaryDiffEq", v"0.6.0", "Parameters", v"0.5.0"],
+    ["OrdinaryDiffEq", v"0.6.0", "Ranges", v"0.0.1"],
+    ["OrdinaryDiffEq", v"0.6.0", "RecipesBase", v"0.1.0"],
+    ["OrdinaryDiffEq", v"0.6.0", "RecursiveArrayTools", v"0.0.2"],
+    ["OrdinaryDiffEq", v"1.0.2", "Calculus", v"0.1.15"],
+    ["OrdinaryDiffEq", v"1.0.2", "Compat", v"0.8.8"],
+    ["OrdinaryDiffEq", v"1.0.2", "DataStructures", v"0.4.6"],
+    ["OrdinaryDiffEq", v"1.0.2", "DiffEqBase", v"0.6.0", v"0.8.0"],
+    ["OrdinaryDiffEq", v"1.0.2", "ForwardDiff", v"0.2.4"],
+    ["OrdinaryDiffEq", v"1.0.2", "GenericSVD", v"0.0.2"],
+    ["OrdinaryDiffEq", v"1.0.2", "InplaceOps", v"0.0.5"],
+    ["OrdinaryDiffEq", v"1.0.2", "Juno", v"0.2.5"],
+    ["OrdinaryDiffEq", v"1.0.2", "NLsolve", v"0.9.1"],
+    ["OrdinaryDiffEq", v"1.0.2", "Parameters", v"0.5.0"],
+    ["OrdinaryDiffEq", v"1.0.2", "RecursiveArrayTools", v"0.1.2"],
+    ["OrdinaryDiffEq", v"1.0.2", "Roots", v"0.2.1"],
+    ["OrdinaryDiffEq", v"1.1.0", "Calculus", v"0.1.15"],
+    ["OrdinaryDiffEq", v"1.1.0", "DiffEqBase", v"0.7.0", v"0.8.0"],
+    ["OrdinaryDiffEq", v"1.1.0", "Iterators"],
+    ["OrdinaryDiffEq", v"1.1.0", "Compat", v"0.8.8"],
+    ["OrdinaryDiffEq", v"1.1.0", "DataStructures", v"0.4.6"],
+    ["OrdinaryDiffEq", v"1.1.0", "ForwardDiff", v"0.2.4"],
+    ["OrdinaryDiffEq", v"1.1.0", "GenericSVD", v"0.0.2"],
+    ["OrdinaryDiffEq", v"1.1.0", "InplaceOps", v"0.0.5"],
+    ["OrdinaryDiffEq", v"1.1.0", "Juno", v"0.2.5"],
+    ["OrdinaryDiffEq", v"1.1.0", "NLsolve", v"0.9.1"],
+    ["OrdinaryDiffEq", v"1.1.0", "Parameters", v"0.5.0"],
+    ["OrdinaryDiffEq", v"1.1.0", "RecursiveArrayTools", v"0.1.2"],
+    ["OrdinaryDiffEq", v"1.1.0", "Roots", v"0.2.1"],
+    ["OrdinaryDiffEq", v"1.3.1", "Calculus", v"0.1.15"],
+    ["OrdinaryDiffEq", v"1.3.1", "Compat", v"0.8.8"],
+    ["OrdinaryDiffEq", v"1.3.1", "DataStructures", v"0.4.6"],
+    ["OrdinaryDiffEq", v"1.3.1", "DiffEqBase", v"0.8.0", v"0.15.0"],
+    ["OrdinaryDiffEq", v"1.3.1", "Iterators"],
+    ["OrdinaryDiffEq", v"1.3.1", "ForwardDiff", v"0.2.4"],
+    ["OrdinaryDiffEq", v"1.3.1", "GenericSVD", v"0.0.2"],
+    ["OrdinaryDiffEq", v"1.3.1", "InplaceOps", v"0.0.5"],
+    ["OrdinaryDiffEq", v"1.3.1", "Juno", v"0.2.5"],
+    ["OrdinaryDiffEq", v"1.3.1", "NLsolve", v"0.9.1"],
+    ["OrdinaryDiffEq", v"1.3.1", "Parameters", v"0.5.0"],
+    ["OrdinaryDiffEq", v"1.3.1", "RecursiveArrayTools", v"0.2.0"],
+    ["OrdinaryDiffEq", v"1.3.1", "Roots", v"0.2.1"],
+    ["OrdinaryDiffEq", v"1.4.1", "Calculus", v"0.1.15"],
+    ["OrdinaryDiffEq", v"1.4.1", "Iterators"],
+    ["OrdinaryDiffEq", v"1.4.1", "Compat", v"0.8.8"],
+    ["OrdinaryDiffEq", v"1.4.1", "DataStructures", v"0.4.6"],
+    ["OrdinaryDiffEq", v"1.4.1", "DiffEqBase", v"0.11.0", v"0.15.0"],
+    ["OrdinaryDiffEq", v"1.4.1", "ForwardDiff", v"0.2.4"],
+    ["OrdinaryDiffEq", v"1.4.1", "GenericSVD", v"0.0.2"],
+    ["OrdinaryDiffEq", v"1.4.1", "InplaceOps", v"0.0.5"],
+    ["OrdinaryDiffEq", v"1.4.1", "Juno", v"0.2.5"],
+    ["OrdinaryDiffEq", v"1.4.1", "NLsolve", v"0.9.1"],
+    ["OrdinaryDiffEq", v"1.4.1", "Parameters", v"0.5.0"],
+    ["OrdinaryDiffEq", v"1.4.1", "RecursiveArrayTools", v"0.2.0"],
+    ["OrdinaryDiffEq", v"1.4.1", "Roots", v"0.2.1"],
+    ["OrdinaryDiffEq", v"1.5.0", "Calculus", v"0.1.15"],
+    ["OrdinaryDiffEq", v"1.5.0", "Iterators"],
+    ["OrdinaryDiffEq", v"1.5.0", "Compat", v"0.17.0"],
+    ["OrdinaryDiffEq", v"1.5.0", "DataStructures", v"0.4.6"],
+    ["OrdinaryDiffEq", v"1.5.0", "DiffEqBase", v"0.11.0", v"0.15.0"],
+    ["OrdinaryDiffEq", v"1.5.0", "ForwardDiff", v"0.2.4"],
+    ["OrdinaryDiffEq", v"1.5.0", "GenericSVD", v"0.0.2"],
+    ["OrdinaryDiffEq", v"1.5.0", "InplaceOps", v"0.0.5"],
+    ["OrdinaryDiffEq", v"1.5.0", "Juno", v"0.2.5"],
+    ["OrdinaryDiffEq", v"1.5.0", "NLsolve", v"0.9.1"],
+    ["OrdinaryDiffEq", v"1.5.0", "Parameters", v"0.5.0"],
+    ["OrdinaryDiffEq", v"1.5.0", "RecursiveArrayTools", v"0.2.0"],
+    ["OrdinaryDiffEq", v"1.5.0", "Roots", v"0.2.1"],
+    ["OrdinaryDiffEq", v"1.7.0", "Calculus", v"0.1.15"],
+    ["OrdinaryDiffEq", v"1.7.0", "Iterators"],
+    ["OrdinaryDiffEq", v"1.7.0", "Compat", v"0.17.0"],
+    ["OrdinaryDiffEq", v"1.7.0", "DataStructures", v"0.4.6"],
+    ["OrdinaryDiffEq", v"1.7.0", "DiffEqBase", v"0.13.0", v"0.15.0"],
+    ["OrdinaryDiffEq", v"1.7.0", "ForwardDiff", v"0.2.4"],
+    ["OrdinaryDiffEq", v"1.7.0", "GenericSVD", v"0.0.2"],
+    ["OrdinaryDiffEq", v"1.7.0", "InplaceOps", v"0.0.5"],
+    ["OrdinaryDiffEq", v"1.7.0", "Juno", v"0.2.5"],
+    ["OrdinaryDiffEq", v"1.7.0", "NLsolve", v"0.9.1"],
+    ["OrdinaryDiffEq", v"1.7.0", "Parameters", v"0.5.0"],
+    ["OrdinaryDiffEq", v"1.7.0", "RecursiveArrayTools", v"0.2.0"],
+    ["OrdinaryDiffEq", v"1.7.0", "Roots", v"0.2.1"],
+    ["OrdinaryDiffEq", v"1.8.0", "Calculus", v"0.1.15"],
+    ["OrdinaryDiffEq", v"1.8.0", "DiffEqBase", v"0.15.0"],
+    ["OrdinaryDiffEq", v"1.8.0", "Iterators"],
+    ["OrdinaryDiffEq", v"1.8.0", "Compat", v"0.17.0"],
+    ["OrdinaryDiffEq", v"1.8.0", "DataStructures", v"0.4.6"],
+    ["OrdinaryDiffEq", v"1.8.0", "ForwardDiff", v"0.2.4"],
+    ["OrdinaryDiffEq", v"1.8.0", "GenericSVD", v"0.0.2"],
+    ["OrdinaryDiffEq", v"1.8.0", "InplaceOps", v"0.0.5"],
+    ["OrdinaryDiffEq", v"1.8.0", "Juno", v"0.2.5"],
+    ["OrdinaryDiffEq", v"1.8.0", "NLsolve", v"0.9.1"],
+    ["OrdinaryDiffEq", v"1.8.0", "Parameters", v"0.5.0"],
+    ["OrdinaryDiffEq", v"1.8.0", "RecursiveArrayTools", v"0.2.0"],
+    ["OrdinaryDiffEq", v"1.8.0", "Roots", v"0.2.1"],
+    ["PDMats", v"0.1.2", "NumericExtensions", v"0.5.0-"],
+    ["PDMats", v"0.2.5", "ArrayViews", v"0.4.0-"],
+    ["PDMats", v"0.3.0", "ArrayViews", v"0.4.8-"],
+    ["PDMats", v"0.3.1", "ArrayViews", v"0.4.8-"],
+    ["PDMats", v"0.3.6", "ArrayViews", v"0.4.8-"],
+    ["PDMats", v"0.4.0", "Compat", v"0.7.7"],
+    ["PDMats", v"0.4.1", "Compat", v"0.7.7"],
+    ["PDMats", v"0.4.2", "Compat", v"0.7.7"],
+    ["PDMats", v"0.5.3", "Compat", v"0.9.2"],
+    ["PDMats", v"0.5.4", "Compat", v"0.9.2"],
+    ["PDMats", v"0.5.5", "Compat", v"0.17.0"],
+    ["PDMats", v"0.5.6", "Compat", v"0.18.0"],
+    ["PDMats", v"0.6.0", "Compat", v"0.18.0"],
+    ["ParameterizedFunctions", v"0.0.1", "DataStructures", v"0.4.6"],
+    ["ParameterizedFunctions", v"0.0.1", "DiffEqBase", v"0.0.0", v"0.5.0"],
+    ["ParameterizedFunctions", v"0.0.1", "SymEngine", v"0.1.1"],
+    ["ParameterizedFunctions", v"0.1.1", "DataStructures", v"0.4.6"],
+    ["ParameterizedFunctions", v"0.1.1", "DiffEqBase", v"0.0.0", v"0.5.0"],
+    ["ParameterizedFunctions", v"0.1.1", "SymEngine", v"0.1.1"],
+    ["ParameterizedFunctions", v"0.2.2", "DataStructures", v"0.4.6"],
+    ["ParameterizedFunctions", v"0.2.2", "DiffEqBase", v"0.0.0", v"0.5.0"],
+    ["ParameterizedFunctions", v"0.2.2", "SymEngine", v"0.1.1"],
+    ["ParameterizedFunctions", v"0.3.1", "DataStructures", v"0.4.6"],
+    ["ParameterizedFunctions", v"0.3.1", "DiffEqBase", v"0.1.0", v"0.5.0"],
+    ["ParameterizedFunctions", v"0.3.1", "SymEngine", v"0.1.2"],
+    ["ParameterizedFunctions", v"0.3.2", "DataStructures", v"0.4.6"],
+    ["ParameterizedFunctions", v"0.3.2", "DiffEqBase", v"0.1.0", v"0.5.0"],
+    ["ParameterizedFunctions", v"0.3.2", "SymEngine", v"0.1.2"],
+    ["ParameterizedFunctions", v"0.3.3", "DataStructures", v"0.4.6"],
+    ["ParameterizedFunctions", v"0.3.3", "DiffEqBase", v"0.2.0", v"0.5.0"],
+    ["ParameterizedFunctions", v"0.3.3", "SymEngine", v"0.1.2"],
+    ["ParameterizedFunctions", v"0.4.2", "DataStructures", v"0.4.6"],
+    ["ParameterizedFunctions", v"0.4.2", "SimpleTraits", v"0.1.1"],
+    ["ParameterizedFunctions", v"0.4.2", "DiffEqBase", v"0.2.0", v"0.5.0"],
+    ["ParameterizedFunctions", v"0.4.2", "SymEngine", v"0.1.2"],
+    ["ParameterizedFunctions", v"0.5.1", "DataStructures", v"0.4.6"],
+    ["ParameterizedFunctions", v"0.5.1", "SimpleTraits", v"0.1.1"],
+    ["ParameterizedFunctions", v"0.5.1", "DiffEqBase", v"0.4.0", v"0.5.0"],
+    ["ParameterizedFunctions", v"0.5.1", "SymEngine", v"0.1.2"],
+    ["ParameterizedFunctions", v"1.2.0", "DataStructures", v"0.4.6"],
+    ["ParameterizedFunctions", v"1.2.0", "SimpleTraits", v"0.1.1"],
+    ["ParameterizedFunctions", v"1.2.0", "DiffEqBase", v"0.5.0", v"0.14.0"],
+    ["ParameterizedFunctions", v"1.2.0", "SymEngine", v"0.1.2"],
+    ["ParameterizedFunctions", v"1.3.0", "DataStructures", v"0.4.6"],
+    ["ParameterizedFunctions", v"1.3.0", "DiffEqBase", v"0.14.0"],
+    ["ParameterizedFunctions", v"1.3.0", "SimpleTraits", v"0.1.1"],
+    ["ParameterizedFunctions", v"1.3.0", "SymEngine", v"0.1.2"],
+    ["Parameters", v"0.5.0", "Compat", v"0.7.15"],
+    ["Parameters", v"0.5.0", "DataStructures", v"0.4.3"],
+    ["Parameters", v"0.6.0", "DataStructures", v"0.4.3"],
+    ["Parameters", v"0.7.1", "Compat", v"0.17.0"],
+    ["Parameters", v"0.7.1", "DataStructures", v"0.5.2"],
+    ["Parameters", v"0.7.2", "DataStructures", v"0.5.2"],
+    ["PlotThemes", v"0.1.1", "PlotUtils"],
+    ["PlotUtils", v"0.0.1"],
+    ["PlotUtils", v"0.3.0", "Colors"],
+    ["PlotUtils", v"0.3.0", "Reexport"],
+    ["Plots", v"0.1.0", "Colors"],
+    ["Plots", v"0.1.0", "FactCheck"],
+    ["Plots", v"0.1.0", "JSON", v"0.0.0", v"0.9.0"],
+    ["Plots", v"0.1.3", "Colors"],
+    ["Plots", v"0.1.3", "JSON", v"0.0.0", v"0.9.0"],
+    ["Plots", v"0.3.0", "Colors"],
+    ["Plots", v"0.3.0", "Reexport"],
+    ["Plots", v"0.3.0", "JSON", v"0.0.0", v"0.9.0"],
+    ["Plots", v"0.5.1", "Colors"],
+    ["Plots", v"0.5.1", "Compat"],
+    ["Plots", v"0.5.1", "Reexport"],
+    ["Plots", v"0.5.1", "JSON", v"0.0.0", v"0.9.0"],
+    ["Plots", v"0.5.2", "Colors"],
+    ["Plots", v"0.5.2", "Compat"],
+    ["Plots", v"0.5.2", "Reexport"],
+    ["Plots", v"0.5.2", "Requires"],
+    ["Plots", v"0.5.2", "JSON", v"0.0.0", v"0.9.0"],
+    ["Plots", v"0.6.1", "Colors"],
+    ["Plots", v"0.6.1", "Compat"],
+    ["Plots", v"0.6.1", "FixedSizeArrays"],
+    ["Plots", v"0.6.1", "Reexport"],
+    ["Plots", v"0.6.1", "Requires"],
+    ["Plots", v"0.6.1", "JSON", v"0.0.0", v"0.9.0"],
+    ["Plots", v"0.6.2", "Colors"],
+    ["Plots", v"0.6.2", "Compat"],
+    ["Plots", v"0.6.2", "FixedSizeArrays"],
+    ["Plots", v"0.6.2", "Reexport"],
+    ["Plots", v"0.6.2", "Requires"],
+    ["Plots", v"0.6.2", "JSON", v"0.0.0", v"0.9.0"],
+    ["Plots", v"0.6.2", "RecipesBase", v"0.0.1", v"0.0.2"],
+    ["Plots", v"0.7.5", "Colors"],
+    ["Plots", v"0.7.5", "Compat"],
+    ["Plots", v"0.7.5", "FixedSizeArrays"],
+    ["Plots", v"0.7.5", "Measures"],
+    ["Plots", v"0.7.5", "JSON", v"0.0.0", v"0.9.0"],
+    ["Plots", v"0.7.5", "RecipesBase"],
+    ["Plots", v"0.7.5", "Reexport"],
+    ["Plots", v"0.8.0", "Compat"],
+    ["Plots", v"0.8.0", "FixedSizeArrays"],
+    ["Plots", v"0.8.0", "Measures"],
+    ["Plots", v"0.8.0", "PlotUtils"],
+    ["Plots", v"0.8.0", "JSON", v"0.0.0", v"0.9.0"],
+    ["Plots", v"0.8.0", "RecipesBase"],
+    ["Plots", v"0.8.0", "Reexport"],
+    ["Plots", v"0.9.0", "Compat"],
+    ["Plots", v"0.9.0", "FixedSizeArrays"],
+    ["Plots", v"0.9.0", "Measures"],
+    ["Plots", v"0.9.0", "PlotUtils"],
+    ["Plots", v"0.9.0", "RecipesBase"],
+    ["Plots", v"0.9.0", "Reexport"],
+    ["Plots", v"0.9.0", "JSON", v"0.0.0", v"0.9.0"],
+    ["Plots", v"0.9.0", "Showoff"],
+    ["Plots", v"0.9.1", "Compat"],
+    ["Plots", v"0.9.1", "FixedSizeArrays"],
+    ["Plots", v"0.9.1", "Measures"],
+    ["Plots", v"0.9.1", "PlotUtils"],
+    ["Plots", v"0.9.1", "RecipesBase"],
+    ["Plots", v"0.9.1", "Reexport"],
+    ["Plots", v"0.9.1", "Showoff"],
+    ["Plots", v"0.9.3", "Compat"],
+    ["Plots", v"0.9.3", "FixedSizeArrays"],
+    ["Plots", v"0.9.3", "Measures"],
+    ["Plots", v"0.9.3", "PlotUtils"],
+    ["Plots", v"0.9.3", "RecipesBase"],
+    ["Plots", v"0.9.3", "Reexport"],
+    ["Plots", v"0.9.3", "Showoff"],
+    ["Plots", v"0.9.4", "FixedSizeArrays"],
+    ["Plots", v"0.9.4", "Measures"],
+    ["Plots", v"0.9.4", "PlotUtils"],
+    ["Plots", v"0.9.4", "RecipesBase"],
+    ["Plots", v"0.9.4", "Reexport"],
+    ["Plots", v"0.9.4", "Showoff"],
+    ["Plots", v"0.10.3", "FixedSizeArrays"],
+    ["Plots", v"0.10.3", "Measures"],
+    ["Plots", v"0.10.3", "PlotThemes"],
+    ["Plots", v"0.10.3", "PlotUtils"],
+    ["Plots", v"0.10.3", "RecipesBase"],
+    ["Plots", v"0.10.3", "Reexport"],
+    ["Plots", v"0.10.3", "Showoff"],
+    ["PolynomialFactors", v"0.0.1", "Combinatorics", v"0.2.1"],
+    ["PolynomialFactors", v"0.0.1", "Compat", v"0.7.15"],
+    ["PolynomialFactors", v"0.0.1", "Iterators", v"0.1.0"],
+    ["PolynomialFactors", v"0.0.1", "Primes", v"0.1.1"],
+    ["PolynomialFactors", v"0.0.2", "Combinatorics", v"0.2.1"],
+    ["PolynomialFactors", v"0.0.2", "Compat", v"0.7.15"],
+    ["PolynomialFactors", v"0.0.2", "Iterators", v"0.1.0"],
+    ["PolynomialFactors", v"0.0.2", "Polynomials", v"0.1.1"],
+    ["PolynomialFactors", v"0.0.2", "Primes", v"0.1.1"],
+    ["PolynomialFactors", v"0.0.4", "Combinatorics", v"0.2.1"],
+    ["PolynomialFactors", v"0.0.4", "Compat", v"0.7.15"],
+    ["PolynomialFactors", v"0.0.4", "Iterators", v"0.1.0"],
+    ["PolynomialFactors", v"0.0.4", "Polynomials", v"0.1.1"],
+    ["PolynomialFactors", v"0.0.4", "Primes", v"0.1.1"],
+    ["Polynomials", v"0.0.2"],
+    ["Polynomials", v"0.0.3"],
+    ["Polynomials", v"0.0.4", "Compat"],
+    ["Polynomials", v"0.0.5", "Compat"],
+    ["Polynomials", v"0.1.0", "Compat", v"0.7.15"],
+    ["Polynomials", v"0.1.1", "Compat", v"0.8.0"],
+    ["Polynomials", v"0.1.5", "Compat", v"0.9.4"],
+    ["PositiveFactorizations", v"0.0.1"],
+    ["PositiveFactorizations", v"0.0.3", "Compat", v"0.8.4"],
+    ["PositiveFactorizations", v"0.0.4", "Compat", v"0.12.0"],
+    ["PowerSeries", v"0.1.10"],
+    ["PowerSeries", v"0.1.14", "Compat", v"0.4.7"],
+    ["PowerSeries", v"0.2.0"],
+    ["Primes", v"0.1.0"],
+    ["Primes", v"0.1.1"],
+    ["Primes", v"0.1.3", "Compat", v"0.9.4"],
+    ["PyCall", v"0.4.10"],
+    ["PyCall", v"0.6.2", "Compat", v"0.2.0"],
+    ["PyCall", v"0.7.3", "Compat", v"0.2.0"],
+    ["PyCall", v"0.7.3", "Dates"],
+    ["PyCall", v"0.7.4", "Compat", v"0.3.1"],
+    ["PyCall", v"0.7.4", "Dates"],
+    ["PyCall", v"0.7.5", "Compat", v"0.3.4"],
+    ["PyCall", v"0.7.5", "Dates"],
+    ["PyCall", v"0.8.1", "Compat", v"0.4.0"],
+    ["PyCall", v"0.8.1", "Dates"],
+    ["PyCall", v"1.0.1", "Compat", v"0.4.6"],
+    ["PyCall", v"1.0.1", "Dates"],
+    ["PyCall", v"1.0.3", "Compat", v"0.7.1"],
+    ["PyCall", v"1.0.3", "Dates"],
+    ["PyCall", v"1.4.0", "Compat", v"0.7.1"],
+    ["PyCall", v"1.4.0", "Conda", v"0.1.6"],
+    ["PyCall", v"1.4.0", "Dates"],
+    ["PyCall", v"1.5.0", "Compat", v"0.7.15"],
+    ["PyCall", v"1.5.0", "Conda", v"0.1.6"],
+    ["PyCall", v"1.5.0", "MacroTools", v"0.2.0"],
+    ["PyCall", v"1.6.2", "Compat", v"0.7.15"],
+    ["PyCall", v"1.6.2", "Conda", v"0.2.0"],
+    ["PyCall", v"1.6.2", "MacroTools", v"0.2.0"],
+    ["PyCall", v"1.7.2", "Compat", v"0.8.0"],
+    ["PyCall", v"1.7.2", "Conda", v"0.2.0"],
+    ["PyCall", v"1.7.2", "MacroTools", v"0.2.0"],
+    ["PyCall", v"1.10.0", "Compat", v"0.9.5"],
+    ["PyCall", v"1.10.0", "Conda", v"0.2.0"],
+    ["PyCall", v"1.10.0", "MacroTools", v"0.2.0"],
+    ["PyCall", v"1.12.0", "Compat", v"0.18.0"],
+    ["PyCall", v"1.12.0", "Conda", v"0.2.0"],
+    ["PyCall", v"1.12.0", "MacroTools", v"0.2.0"],
+    ["PyDSTool", v"0.0.1", "DataStructures"],
+    ["PyDSTool", v"0.0.1", "PyCall"],
+    ["PyDSTool", v"0.0.2", "Conda"],
+    ["PyDSTool", v"0.0.2", "DataStructures"],
+    ["PyDSTool", v"0.0.2", "PyCall"],
+    ["PyDSTool", v"0.1.1", "Conda"],
+    ["PyDSTool", v"0.1.1", "DataStructures"],
+    ["PyDSTool", v"0.1.1", "DiffEqBase", v"0.11.0"],
+    ["PyDSTool", v"0.1.1", "PyCall"],
+    ["PyDSTool", v"0.1.1", "RecipesBase"],
+    ["PyDSTool", v"0.1.2", "DataStructures"],
+    ["PyDSTool", v"0.1.2", "PyCall"],
+    ["PyDSTool", v"0.1.2", "RecipesBase"],
+    ["PyDSTool", v"0.1.2", "Conda", v"0.2.0"],
+    ["PyDSTool", v"0.1.2", "DiffEqBase", v"0.11.0"],
+    ["QuadGK", v"0.1.0"],
+    ["QuadGK", v"0.1.2", "DataStructures", v"0.5.0"],
+    ["RangeArrays", v"0.1.1"],
+    ["RangeArrays", v"0.1.2", "Compat", v"0.19.0"],
+    ["Ranges", v"0.0.1"],
+    ["Ratios", v"0.0.3"],
+    ["Ratios", v"0.0.4", "Compat"],
+    ["Reactive", v"0.2.4", "FactCheck"],
+    ["Reactive", v"0.2.4", "Compat", v"0.4.0"],
+    ["Reactive", v"0.3.4", "Compat"],
+    ["Reactive", v"0.3.5", "Compat", v"0.9.2"],
+    ["Reactive", v"0.3.6"],
+    ["Reactive", v"0.3.7", "DataStructures"],
+    ["RecipesBase", v"0.1.0"],
+    ["RecursiveArrayTools", v"0.0.1"],
+    ["RecursiveArrayTools", v"0.1.1"],
+    ["RecursiveArrayTools", v"0.1.2"],
+    ["RecursiveArrayTools", v"0.2.0"],
+    ["Reexport", v"0.0.2"],
+    ["Reexport", v"0.0.3"],
+    ["Requires", v"0.2.3", "MacroTools"],
+    ["Requires", v"0.4.1"],
+    ["ResettableStacks", v"0.1.0"],
+    ["Rmath", v"0.1.0", "BinDeps"],
+    ["Rmath", v"0.1.2", "BinDeps"],
+    ["Rmath", v"0.1.2", "Compat", v"0.8.4"],
+    ["Rmath", v"0.1.6", "BinDeps"],
+    ["Rmath", v"0.1.6", "Compat", v"0.9.1"],
+    ["Roots", v"0.1.9", "Polynomials", v"0.0.3"],
+    ["Roots", v"0.1.9", "ForwardDiff", v"0.0.0", v"0.2.0"],
+    ["Roots", v"0.1.9", "PowerSeries", v"0.1.0"],
+    ["Roots", v"0.1.13", "Docile", v"0.4.0"],
+    ["Roots", v"0.1.13", "Polynomials", v"0.0.3"],
+    ["Roots", v"0.1.13", "ForwardDiff", v"0.0.0", v"0.2.0"],
+    ["Roots", v"0.1.13", "PowerSeries", v"0.1.11"],
+    ["Roots", v"0.1.18", "Compat", v"0.4.0"],
+    ["Roots", v"0.1.18", "Docile", v"0.4.0"],
+    ["Roots", v"0.1.18", "Polynomials", v"0.0.3"],
+    ["Roots", v"0.1.18", "ForwardDiff", v"0.0.0", v"0.2.0"],
+    ["Roots", v"0.1.18", "PowerSeries", v"0.1.11"],
+    ["Roots", v"0.1.22", "Compat", v"0.4.0"],
+    ["Roots", v"0.1.22", "Docile", v"0.4.0"],
+    ["Roots", v"0.1.22", "Polynomials", v"0.0.3"],
+    ["Roots", v"0.1.22", "ForwardDiff", v"0.0.0", v"0.2.0"],
+    ["Roots", v"0.1.26", "Compat", v"0.4.0"],
+    ["Roots", v"0.1.26", "Docile", v"0.4.0"],
+    ["Roots", v"0.1.26", "Polynomials", v"0.0.5"],
+    ["Roots", v"0.1.26", "ForwardDiff", v"0.0.0", v"0.2.0"],
+    ["Roots", v"0.2.0", "Primes"],
+    ["Roots", v"0.2.0", "Compat", v"0.4.0"],
+    ["Roots", v"0.2.0", "Docile", v"0.4.0"],
+    ["Roots", v"0.2.0", "ForwardDiff", v"0.2.0"],
+    ["Roots", v"0.2.0", "Polynomials", v"0.0.5"],
+    ["Roots", v"0.2.1", "Primes"],
+    ["Roots", v"0.2.1", "Compat", v"0.4.0"],
+    ["Roots", v"0.2.1", "ForwardDiff", v"0.2.0"],
+    ["Roots", v"0.2.1", "Polynomials", v"0.0.5"],
+    ["Roots", v"0.3.0", "Compat", v"0.8.0"],
+    ["Roots", v"0.3.0", "ForwardDiff", v"0.2.0"],
+    ["Roots", v"0.3.0", "PolynomialFactors", v"0.0.3"],
+    ["Roots", v"0.3.0", "Polynomials", v"0.0.5"],
+    ["Rotations", v"0.3.4", "StaticArrays", v"0.0.3", v"0.3.0-"],
+    ["Rotations", v"0.3.5", "StaticArrays", v"0.3.0", v"0.4.0-"],
+    ["Rotations", v"0.4.0", "StaticArrays", v"0.4.0", v"0.5.0-"],
+    ["SHA", v"0.0.2"],
+    ["SHA", v"0.0.3"],
+    ["SHA", v"0.2.0", "Compat", v"0.3.5"],
+    ["SHA", v"0.2.1", "Compat", v"0.7.9"],
+    ["SHA", v"0.3.1", "Compat", v"0.9.4"],
+    ["SHA", v"0.3.2", "Compat", v"0.17.0"],
+    ["SIUnits", v"0.0.5", "TexExtensions"],
+    ["SIUnits", v"0.0.6", "Compat"],
+    ["SIUnits", v"0.0.6", "TexExtensions"],
+    ["SIUnits", v"0.1.0", "TexExtensions"],
+    ["SIUnits", v"0.1.0", "Compat", v"0.8.0"],
+    ["ShowItLikeYouBuildIt", v"0.0.1"],
+    ["Showoff", v"0.0.1"],
+    ["Showoff", v"0.0.3", "Iterators"],
+    ["Showoff", v"0.0.7", "Compat"],
+    ["Showoff", v"0.0.7", "Iterators"],
+    ["Showoff", v"0.1.0", "Compat", v"0.9.5"],
+    ["Showoff", v"0.1.1", "Compat", v"0.18.0"],
+    ["SimpleTraits", v"0.1.0", "Compat"],
+    ["SimpleTraits", v"0.1.1"],
+    ["SimpleTraits", v"0.2.0", "MacroTools", v"0.3.2"],
+    ["SimpleTraits", v"0.4.0", "Compat", v"0.19.0"],
+    ["SimpleTraits", v"0.4.0", "MacroTools", v"0.3.2"],
+    ["SortingAlgorithms", v"0.0.3"],
+    ["SortingAlgorithms", v"0.0.6", "Compat"],
+    ["SortingAlgorithms", v"0.1.0", "Compat", v"0.8.4"],
+    ["SortingAlgorithms", v"0.1.1", "Compat", v"0.9.4"],
+    ["SortingAlgorithms", v"0.1.1", "DataStructures", v"0.5.3"],
+    ["SpecialFunctions", v"0.0.1", "Compat", v"0.9.1"],
+    ["SpecialFunctions", v"0.1.0", "Compat", v"0.9.1"],
+    ["SpecialFunctions", v"0.1.1", "Compat", v"0.18.0"],
+    ["StaticArrays", v"0.0.2"],
+    ["StaticArrays", v"0.0.4"],
+    ["StaticArrays", v"0.2.1"],
+    ["StaticArrays", v"0.3.0"],
+    ["StaticArrays", v"0.4.0"],
+    ["Stats", v"0.0.1", "StatsBase", v"0.3.0-"],
+    ["Stats", v"0.1.0", "StatsBase"],
+    ["StatsBase", v"0.2.4", "NumericExtensions"],
+    ["StatsBase", v"0.2.9"],
+    ["StatsBase", v"0.3.9"],
+    ["StatsBase", v"0.4.1"],
+    ["StatsBase", v"0.6.8", "ArrayViews", v"0.4.6-"],
+    ["StatsBase", v"0.6.9", "ArrayViews", v"0.4.8-"],
+    ["StatsBase", v"0.6.10", "ArrayViews", v"0.4.8-"],
+    ["StatsBase", v"0.6.12", "ArrayViews", v"0.4.8-"],
+    ["StatsBase", v"0.6.12", "Compat", v"0.2.11-"],
+    ["StatsBase", v"0.6.13", "ArrayViews", v"0.4.10"],
+    ["StatsBase", v"0.6.13", "Compat", v"0.3.2"],
+    ["StatsBase", v"0.6.16", "ArrayViews", v"0.4.12"],
+    ["StatsBase", v"0.6.16", "Compat", v"0.4.0"],
+    ["StatsBase", v"0.7.4", "ArrayViews", v"0.4.12"],
+    ["StatsBase", v"0.7.4", "Compat", v"0.4.0"],
+    ["StatsBase", v"0.7.4", "StatsFuns", v"0.1.0"],
+    ["StatsBase", v"0.8.1", "ArrayViews", v"0.4.12"],
+    ["StatsBase", v"0.8.1", "Compat", v"0.4.0"],
+    ["StatsBase", v"0.8.1", "StatsFuns", v"0.1.0"],
+    ["StatsBase", v"0.8.2", "ArrayViews", v"0.4.12"],
+    ["StatsBase", v"0.8.2", "Compat", v"0.4.0"],
+    ["StatsBase", v"0.8.2", "StatsFuns", v"0.1.0"],
+    ["StatsBase", v"0.8.3", "Compat", v"0.8.4"],
+    ["StatsBase", v"0.8.3", "StatsFuns", v"0.1.0"],
+    ["StatsBase", v"0.9.0", "Compat", v"0.8.4"],
+    ["StatsBase", v"0.9.0", "StatsFuns", v"0.3.0"],
+    ["StatsBase", v"0.10.0", "Compat", v"0.8.4"],
+    ["StatsBase", v"0.12.0", "Compat", v"0.8.4"],
+    ["StatsBase", v"0.13.0", "Compat", v"0.13.0"],
+    ["StatsBase", v"0.13.0", "DataStructures", v"0.5.0"],
+    ["StatsBase", v"0.13.1", "Compat", v"0.18.0"],
+    ["StatsBase", v"0.13.1", "DataStructures", v"0.5.0"],
+    ["StatsBase", v"0.13.1", "SpecialFunctions", v"0.1.0"],
+    ["StatsFuns", v"0.0.3", "Compat", v"0.4.0"],
+    ["StatsFuns", v"0.1.0", "Compat", v"0.4.0"],
+    ["StatsFuns", v"0.2.1", "Compat", v"0.4.0"],
+    ["StatsFuns", v"0.2.2", "Compat", v"0.7.18"],
+    ["StatsFuns", v"0.3.0", "Compat", v"0.8.4"],
+    ["StatsFuns", v"0.3.0", "Rmath", v"0.1.0"],
+    ["StatsFuns", v"0.4.0", "Compat", v"0.9.1"],
+    ["StatsFuns", v"0.4.0", "Rmath", v"0.1.0"],
+    ["StatsFuns", v"0.5.0", "SpecialFunctions"],
+    ["StatsFuns", v"0.5.0", "Compat", v"0.9.1"],
+    ["StatsFuns", v"0.5.0", "Rmath", v"0.1.0"],
+    ["StochasticDiffEq", v"0.0.3", "ChunkedArrays", v"0.1.0"],
+    ["StochasticDiffEq", v"0.0.3", "DiffEqBase", v"0.0.0", v"0.8.0"],
+    ["StochasticDiffEq", v"0.0.3", "ParameterizedFunctions", v"0.1.0"],
+    ["StochasticDiffEq", v"0.0.3", "Parameters", v"0.5.0"],
+    ["StochasticDiffEq", v"0.0.4", "RecursiveArrayTools"],
+    ["StochasticDiffEq", v"0.0.4", "ChunkedArrays", v"0.1.0"],
+    ["StochasticDiffEq", v"0.0.4", "DiffEqBase", v"0.0.0", v"0.8.0"],
+    ["StochasticDiffEq", v"0.0.4", "ParameterizedFunctions", v"0.1.0"],
+    ["StochasticDiffEq", v"0.0.4", "Parameters", v"0.5.0"],
+    ["StochasticDiffEq", v"0.0.5", "RecursiveArrayTools"],
+    ["StochasticDiffEq", v"0.0.5", "ChunkedArrays", v"0.1.0"],
+    ["StochasticDiffEq", v"0.0.5", "DiffEqBase", v"0.0.0", v"0.8.0"],
+    ["StochasticDiffEq", v"0.0.5", "Parameters", v"0.5.0"],
+    ["StochasticDiffEq", v"0.2.0", "ChunkedArrays", v"0.1.0"],
+    ["StochasticDiffEq", v"0.2.0", "DiffEqBase", v"0.2.0", v"0.8.0"],
+    ["StochasticDiffEq", v"0.2.0", "Parameters", v"0.5.0"],
+    ["StochasticDiffEq", v"0.2.0", "RecursiveArrayTools", v"0.0.2"],
+    ["StochasticDiffEq", v"0.3.0", "ChunkedArrays", v"0.1.0"],
+    ["StochasticDiffEq", v"0.3.0", "DataStructures"],
+    ["StochasticDiffEq", v"0.3.0", "DiffEqBase", v"0.2.0", v"0.8.0"],
+    ["StochasticDiffEq", v"0.3.0", "Juno"],
+    ["StochasticDiffEq", v"0.3.0", "Parameters", v"0.5.0"],
+    ["StochasticDiffEq", v"0.3.0", "RecursiveArrayTools", v"0.0.2"],
+    ["StochasticDiffEq", v"0.3.0", "ResettableStacks"],
+    ["StochasticDiffEq", v"0.5.0", "ChunkedArrays", v"0.1.0"],
+    ["StochasticDiffEq", v"0.5.0", "DataStructures", v"0.4.6"],
+    ["StochasticDiffEq", v"0.5.0", "DiffEqBase", v"0.4.0", v"0.8.0"],
+    ["StochasticDiffEq", v"0.5.0", "Juno", v"0.2.5"],
+    ["StochasticDiffEq", v"0.5.0", "Parameters", v"0.5.0"],
+    ["StochasticDiffEq", v"0.5.0", "RecursiveArrayTools", v"0.1.2"],
+    ["StochasticDiffEq", v"0.5.0", "ResettableStacks", v"0.0.1"],
+    ["StochasticDiffEq", v"1.0.2", "Iterators"],
+    ["StochasticDiffEq", v"1.0.2", "Roots"],
+    ["StochasticDiffEq", v"1.0.2", "DataStructures", v"0.4.6"],
+    ["StochasticDiffEq", v"1.0.2", "DiffEqBase", v"0.8.0", v"0.15.0"],
+    ["StochasticDiffEq", v"1.0.2", "Juno", v"0.2.5"],
+    ["StochasticDiffEq", v"1.0.2", "Parameters", v"0.5.0"],
+    ["StochasticDiffEq", v"1.0.2", "RecursiveArrayTools", v"0.2.0"],
+    ["StochasticDiffEq", v"1.0.2", "ResettableStacks", v"0.0.1"],
+    ["StochasticDiffEq", v"1.1.0", "Iterators"],
+    ["StochasticDiffEq", v"1.1.0", "Roots"],
+    ["StochasticDiffEq", v"1.1.0", "DataStructures", v"0.4.6"],
+    ["StochasticDiffEq", v"1.1.0", "DiffEqBase", v"0.11.0", v"0.15.0"],
+    ["StochasticDiffEq", v"1.1.0", "Juno", v"0.2.5"],
+    ["StochasticDiffEq", v"1.1.0", "Parameters", v"0.5.0"],
+    ["StochasticDiffEq", v"1.1.0", "RecursiveArrayTools", v"0.2.0"],
+    ["StochasticDiffEq", v"1.1.0", "ResettableStacks", v"0.0.1"],
+    ["StochasticDiffEq", v"1.2.1", "Compat", v"0.17.0"],
+    ["StochasticDiffEq", v"1.2.1", "Iterators"],
+    ["StochasticDiffEq", v"1.2.1", "Roots"],
+    ["StochasticDiffEq", v"1.2.1", "DataStructures", v"0.4.6"],
+    ["StochasticDiffEq", v"1.2.1", "DiffEqBase", v"0.11.0", v"0.15.0"],
+    ["StochasticDiffEq", v"1.2.1", "Juno", v"0.2.5"],
+    ["StochasticDiffEq", v"1.2.1", "Parameters", v"0.5.0"],
+    ["StochasticDiffEq", v"1.2.1", "RecursiveArrayTools", v"0.2.0"],
+    ["StochasticDiffEq", v"1.2.1", "ResettableStacks", v"0.0.1"],
+    ["StochasticDiffEq", v"1.3.0", "Compat", v"0.17.0"],
+    ["StochasticDiffEq", v"1.3.0", "Iterators"],
+    ["StochasticDiffEq", v"1.3.0", "Roots"],
+    ["StochasticDiffEq", v"1.3.0", "DataStructures", v"0.4.6"],
+    ["StochasticDiffEq", v"1.3.0", "DiffEqBase", v"0.13.0", v"0.15.0"],
+    ["StochasticDiffEq", v"1.3.0", "Juno", v"0.2.5"],
+    ["StochasticDiffEq", v"1.3.0", "Parameters", v"0.5.0"],
+    ["StochasticDiffEq", v"1.3.0", "RecursiveArrayTools", v"0.2.0"],
+    ["StochasticDiffEq", v"1.3.0", "ResettableStacks", v"0.0.1"],
+    ["StochasticDiffEq", v"1.4.0", "Compat", v"0.17.0"],
+    ["StochasticDiffEq", v"1.4.0", "DiffEqBase", v"0.15.0"],
+    ["StochasticDiffEq", v"1.4.0", "Iterators"],
+    ["StochasticDiffEq", v"1.4.0", "Roots"],
+    ["StochasticDiffEq", v"1.4.0", "DataStructures", v"0.4.6"],
+    ["StochasticDiffEq", v"1.4.0", "Juno", v"0.2.5"],
+    ["StochasticDiffEq", v"1.4.0", "Parameters", v"0.5.0"],
+    ["StochasticDiffEq", v"1.4.0", "RecursiveArrayTools", v"0.2.0"],
+    ["StochasticDiffEq", v"1.4.0", "ResettableStacks", v"0.0.1"],
+    ["StokesDiffEq", v"0.0.1", "DiffEqBase"],
+    ["StokesDiffEq", v"0.0.1", "Parameters", v"0.5.0"],
+    ["StokesDiffEq", v"0.0.1", "VectorizedRoutines", v"0.0.1"],
+    ["StokesDiffEq", v"0.0.2", "DiffEqBase"],
+    ["StokesDiffEq", v"0.0.2", "Parameters", v"0.5.0"],
+    ["StokesDiffEq", v"0.0.2", "VectorizedRoutines", v"0.0.1"],
+    ["StokesDiffEq", v"0.1.0", "DiffEqBase", v"0.4.0"],
+    ["StokesDiffEq", v"0.1.0", "Parameters", v"0.5.0"],
+    ["StokesDiffEq", v"0.1.0", "VectorizedRoutines", v"0.0.2"],
+    ["StrPack", v"0.0.1"],
+    ["StructIO", v"0.0.2"],
+    ["Sundials", v"0.0.0"],
+    ["Sundials", v"0.1.2", "BinDeps"],
+    ["Sundials", v"0.2.0", "BinDeps", v"0.3.0"],
+    ["Sundials", v"0.2.2", "Compat"],
+    ["Sundials", v"0.2.2", "BinDeps", v"0.3.0"],
+    ["Sundials", v"0.3.0", "BinDeps", v"0.4.3"],
+    ["Sundials", v"0.3.0", "Compat", v"0.9.0"],
+    ["Sundials", v"0.4.0", "BinDeps", v"0.4.3"],
+    ["Sundials", v"0.4.0", "Compat", v"0.9.0"],
+    ["Sundials", v"0.4.0", "DiffEqBase", v"0.0.0", v"0.2.0"],
+    ["Sundials", v"0.9.0", "BinDeps", v"0.4.3"],
+    ["Sundials", v"0.9.0", "Compat", v"0.9.0"],
+    ["Sundials", v"0.9.0", "DiffEqBase", v"0.2.0", v"0.15.0"],
+    ["Sundials", v"0.10.0", "BinDeps", v"0.4.3"],
+    ["Sundials", v"0.10.0", "Compat", v"0.9.0"],
+    ["Sundials", v"0.10.0", "DiffEqBase", v"0.15.0"],
+    ["SymEngine", v"0.1.0", "BinDeps"],
+    ["SymEngine", v"0.1.0", "Conda"],
+    ["SymEngine", v"0.1.0", "Compat", v"0.8.5"],
+    ["SymEngine", v"0.1.0", "RecipesBase", v"0.0.6"],
+    ["SymEngine", v"0.1.1", "BinDeps", v"0.4.0"],
+    ["SymEngine", v"0.1.1", "Compat", v"0.8.5"],
+    ["SymEngine", v"0.1.1", "Conda", v"0.3.0"],
+    ["SymEngine", v"0.1.1", "RecipesBase", v"0.0.6"],
+    ["SymEngine", v"0.1.2", "BinDeps", v"0.4.0"],
+    ["SymEngine", v"0.1.2", "Compat", v"0.8.5"],
+    ["SymEngine", v"0.1.2", "Conda", v"0.4.0"],
+    ["SymEngine", v"0.1.2", "RecipesBase", v"0.0.6"],
+    ["SymEngine", v"0.1.5", "BinDeps", v"0.4.0"],
+    ["SymEngine", v"0.1.5", "Compat", v"0.9.5"],
+    ["SymEngine", v"0.1.5", "Conda", v"0.4.0"],
+    ["SymEngine", v"0.1.5", "RecipesBase", v"0.0.6"],
+    ["TerminalUI", v"0.0.1", "Reactive"],
+    ["TerminalUI", v"0.0.1", "VT100"],
+    ["TerminalUI", v"0.0.2", "AbstractTrees"],
+    ["TerminalUI", v"0.0.2", "Colors"],
+    ["TerminalUI", v"0.0.2", "Compat"],
+    ["TerminalUI", v"0.0.2", "FixedPointNumbers"],
+    ["TerminalUI", v"0.0.2", "Reactive"],
+    ["TerminalUI", v"0.0.2", "VT100"],
+    ["TexExtensions", v"0.0.2"],
+    ["TexExtensions", v"0.0.3", "Compat"],
+    ["TextWrap", v"0.0.0", "Options"],
+    ["TextWrap", v"0.1.3"],
+    ["TextWrap", v"0.1.4"],
+    ["TextWrap", v"0.1.5", "Compat", v"0.7.3"],
+    ["TextWrap", v"0.1.6", "Compat", v"0.7.15"],
+    ["TextWrap", v"0.2.0", "Compat", v"0.9.5"],
+    ["TiledIteration", v"0.0.2", "OffsetArrays"],
+    ["URIParser", v"0.0.4", "Compat"],
+    ["URIParser", v"0.0.5", "Compat", v"0.3.5"],
+    ["URIParser", v"0.1.0", "HttpCommon"],
+    ["URIParser", v"0.1.0", "Compat", v"0.3.5"],
+    ["URIParser", v"0.1.3"],
+    ["URIParser", v"0.1.6", "Compat", v"0.8.0"],
+    ["URIParser", v"0.1.8", "Compat", v"0.9.5"],
+    ["VT100", v"0.0.1", "Colors"],
+    ["VT100", v"0.0.1", "Compat"],
+    ["VT100", v"0.0.1", "FixedPointNumbers"],
+    ["VT100", v"0.0.2", "Colors"],
+    ["VT100", v"0.0.2", "FixedPointNumbers"],
+    ["VT100", v"0.0.2", "Compat", v"0.7.15"],
+    ["VT100", v"0.1.0", "ColorTypes", v"0.3.4"],
+    ["VT100", v"0.1.0", "Compat", v"0.17.0"],
+    ["VT100", v"0.1.0", "FixedPointNumbers", v"0.3.0"],
+    ["VectorizedRoutines", v"0.0.1", "Distributions"],
+    ["VectorizedRoutines", v"0.0.1", "StatsFuns"],
+    ["VectorizedRoutines", v"0.0.2", "Distributions"],
+    ["WebSockets", v"0.0.0", "HttpCommon"],
+    ["WebSockets", v"0.0.0", "HttpServer"],
+    ["WebSockets", v"0.0.1"],
+    ["WebSockets", v"0.0.3", "Codecs"],
+    ["WebSockets", v"0.0.3", "HttpCommon"],
+    ["WebSockets", v"0.0.3", "HttpServer"],
+    ["WebSockets", v"0.0.5", "Codecs"],
+    ["WebSockets", v"0.0.5", "HttpCommon", v"0.0.3-"],
+    ["WebSockets", v"0.0.5", "HttpServer", v"0.0.4-"],
+    ["WebSockets", v"0.0.6", "Codecs"],
+    ["WebSockets", v"0.0.6", "Nettle"],
+    ["WebSockets", v"0.0.6", "HttpCommon", v"0.0.3-"],
+    ["WebSockets", v"0.0.6", "HttpServer", v"0.0.4-"],
+    ["WebSockets", v"0.1.0", "Codecs"],
+    ["WebSockets", v"0.1.0", "Compat"],
+    ["WebSockets", v"0.1.0", "Nettle"],
+    ["WebSockets", v"0.1.0", "HttpCommon", v"0.0.3"],
+    ["WebSockets", v"0.1.0", "HttpServer", v"0.0.4"],
+    ["WebSockets", v"0.1.2", "Codecs"],
+    ["WebSockets", v"0.1.2", "Compat"],
+    ["WebSockets", v"0.1.2", "HttpCommon", v"0.0.3"],
+    ["WebSockets", v"0.1.2", "HttpServer", v"0.0.4"],
+    ["WebSockets", v"0.1.2", "Nettle", v"0.2.0"],
+    ["WebSockets", v"0.2.1", "Codecs"],
+    ["WebSockets", v"0.2.1", "MbedTLS"],
+    ["WebSockets", v"0.2.1", "Compat", v"0.7.16"],
+    ["WebSockets", v"0.2.1", "HttpCommon", v"0.0.3"],
+    ["WebSockets", v"0.2.1", "HttpServer", v"0.0.4"],
+    ["WoodburyMatrices", v"0.0.2"],
+    ["WoodburyMatrices", v"0.1.3", "Docile"],
+    ["WoodburyMatrices", v"0.1.4", "Compat"],
+    ["WoodburyMatrices", v"0.1.4", "Docile"],
+    ["WoodburyMatrices", v"0.1.5", "Compat"],
+    ["WoodburyMatrices", v"0.1.5", "Docile"],
+    ["WoodburyMatrices", v"0.2.1", "Compat"],
+    ["WoodburyMatrices", v"0.2.2", "Compat", v"0.7.19"],
+    ["Zlib", v"0.1.9"],
+    ["Zlib", v"0.1.12", "Compat"],
+]
+
+problematic_data = Any[
+    ("CoordinateTransformations", v"0.2.0"),
+    ("Plots", v"0.6.2"),
+    ("Roots", v"0.1.9"),
+    ("Roots", v"0.1.13"),
+    ("Roots", v"0.1.18"),
+    ("Roots", v"0.1.22"),
+    ("Roots", v"0.1.26"),
+]
+
+reqs_data = Any[
+    ["Atom"],
+    ["DifferentialEquations"],
+    ["ImageMagick"],
+    ["Plots"],
+]
+
+want_data = Dict(
+    "ASTInterpreter"=>v"0.0.4",
+    "AbstractTrees"=>v"0.0.4",
+    "AlgebraicDiffEq"=>v"0.1.0",
+    "ArgParse"=>v"0.4.0",
+    "Atom"=>v"0.5.10",
+    "AxisAlgorithms"=>v"0.1.6",
+    "AxisArrays"=>v"0.1.2",
+    "BinDeps"=>v"0.4.7",
+    "Blink"=>v"0.5.1",
+    "COFF"=>v"0.0.2",
+    "CRC"=>v"1.2.0",
+    "Calculus"=>v"0.2.2",
+    "CatIndices"=>v"0.0.2",
+    "ChunkedArrays"=>v"0.1.1",
+    "CodeTools"=>v"0.4.3",
+    "Codecs"=>v"0.3.0",
+    "ColorTypes"=>v"0.4.1",
+    "ColorVectorSpace"=>v"0.4.2",
+    "Colors"=>v"0.7.3",
+    "Combinatorics"=>v"0.4.0",
+    "Compat"=>v"0.24.0",
+    "ComputationalResources"=>v"0.0.2",
+    "Conda"=>v"0.5.3",
+    "CoordinateTransformations"=>v"0.4.1",
+    "CustomUnitRanges"=>v"0.0.4",
+    "DWARF"=>v"0.1.0",
+    "DataStructures"=>v"0.5.3",
+    "DelayDiffEq"=>v"0.3.0",
+    "DiffBase"=>v"0.1.0",
+    "DiffEqBase"=>v"0.15.0",
+    "DiffEqBiological"=>v"0.0.1",
+    "DiffEqCallbacks"=>v"0.0.2",
+    "DiffEqDevTools"=>v"0.7.0",
+    "DiffEqFinancial"=>v"0.1.0",
+    "DiffEqJump"=>v"0.3.0",
+    "DiffEqMonteCarlo"=>v"0.2.0",
+    "DiffEqPDEBase"=>v"0.2.0",
+    "DiffEqParamEstim"=>v"0.2.0",
+    "DiffEqSensitivity"=>v"0.1.0",
+    "DifferentialEquations"=>v"1.10.1",
+    "Distances"=>v"0.4.1",
+    "Distributions"=>v"0.12.5",
+    "DualNumbers"=>v"0.3.0",
+    "ELF"=>v"0.1.0",
+    "EllipsisNotation"=>v"0.1.0",
+    "FFTViews"=>v"0.0.2",
+    "FileIO"=>v"0.3.1",
+    "FiniteElementDiffEq"=>v"0.3.0",
+    "FixedPointNumbers"=>v"0.3.6",
+    "FixedSizeArrays"=>v"0.2.5",
+    "ForwardDiff"=>v"0.4.2",
+    "Gallium"=>v"0.0.4",
+    "GenericSVD"=>v"0.0.2",
+    "Graphics"=>v"0.2.0",
+    "Hiccup"=>v"0.1.1",
+    "HttpCommon"=>v"0.2.7",
+    "HttpParser"=>v"0.2.0",
+    "HttpServer"=>v"0.2.0",
+    "ImageAxes"=>v"0.2.1",
+    "ImageCore"=>v"0.3.0",
+    "ImageFiltering"=>v"0.1.4",
+    "ImageMagick"=>v"0.2.4",
+    "ImageMetadata"=>v"0.2.3",
+    "ImageTransformations"=>v"0.2.2",
+    "Images"=>v"0.9.1",
+    "IndirectArrays"=>v"0.1.1",
+    "InplaceOps"=>v"0.1.0",
+    "Interpolations"=>v"0.5.0",
+    "IntervalSets"=>v"0.0.5",
+    "IterativeSolvers"=>v"0.2.2",
+    "Iterators"=>v"0.3.0",
+    "JSON"=>v"0.9.0",
+    "JuliaParser"=>v"0.7.4",
+    "Juno"=>v"0.2.7",
+    "LNR"=>v"0.0.2",
+    "Lazy"=>v"0.11.6",
+    "LearnBase"=>v"0.1.5",
+    "LineSearches"=>v"0.1.5",
+    "LossFunctions"=>v"0.1.0",
+    "LsqFit"=>v"0.2.0",
+    "MachO"=>v"0.0.4",
+    "MacroTools"=>v"0.3.6",
+    "MappedArrays"=>v"0.0.7",
+    "MbedTLS"=>v"0.4.5",
+    "Measures"=>v"0.1.0",
+    "Media"=>v"0.2.7",
+    "MultiScaleArrays"=>v"0.1.0",
+    "Mustache"=>v"0.1.4",
+    "Mux"=>v"0.2.3",
+    "NLsolve"=>v"0.9.1",
+    "NaNMath"=>v"0.2.4",
+    "ObjFileBase"=>v"0.0.4",
+    "OffsetArrays"=>v"0.3.0",
+    "Optim"=>v"0.7.8",
+    "OrdinaryDiffEq"=>v"1.8.0",
+    "PDMats"=>v"0.6.0",
+    "ParameterizedFunctions"=>v"1.3.0",
+    "Parameters"=>v"0.7.2",
+    "PlotThemes"=>v"0.1.1",
+    "PlotUtils"=>v"0.3.0",
+    "Plots"=>v"0.10.3",
+    "PolynomialFactors"=>v"0.0.4",
+    "Polynomials"=>v"0.1.5",
+    "PositiveFactorizations"=>v"0.0.4",
+    "Primes"=>v"0.1.3",
+    "QuadGK"=>v"0.1.2",
+    "RangeArrays"=>v"0.1.2",
+    "Ranges"=>v"0.0.1",
+    "Ratios"=>v"0.0.4",
+    "Reactive"=>v"0.3.7",
+    "RecipesBase"=>v"0.1.0",
+    "RecursiveArrayTools"=>v"0.2.0",
+    "Reexport"=>v"0.0.3",
+    "ResettableStacks"=>v"0.1.0",
+    "Rmath"=>v"0.1.6",
+    "Roots"=>v"0.3.0",
+    "Rotations"=>v"0.4.0",
+    "SHA"=>v"0.3.2",
+    "SIUnits"=>v"0.1.0",
+    "ShowItLikeYouBuildIt"=>v"0.0.1",
+    "Showoff"=>v"0.1.1",
+    "SimpleTraits"=>v"0.4.0",
+    "SpecialFunctions"=>v"0.1.1",
+    "StaticArrays"=>v"0.4.0",
+    "StatsBase"=>v"0.13.1",
+    "StatsFuns"=>v"0.5.0",
+    "StochasticDiffEq"=>v"1.4.0",
+    "StokesDiffEq"=>v"0.1.0",
+    "StructIO"=>v"0.0.2",
+    "Sundials"=>v"0.10.0",
+    "SymEngine"=>v"0.1.5",
+    "TerminalUI"=>v"0.0.2",
+    "TexExtensions"=>v"0.0.3",
+    "TextWrap"=>v"0.2.0",
+    "TiledIteration"=>v"0.0.2",
+    "URIParser"=>v"0.1.8",
+    "VT100"=>v"0.1.0",
+    "VectorizedRoutines"=>v"0.0.2",
+    "WebSockets"=>v"0.2.1",
+    "WoodburyMatrices"=>v"0.2.2",
+)
diff --git a/test/rounding.jl b/test/rounding.jl
index 63dc10e419a53d..32a19d10b1a1b4 100644
--- a/test/rounding.jl
+++ b/test/rounding.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Small sanity tests to ensure changing the rounding of float functions work
 using Base.Test
diff --git a/test/runtests.jl b/test/runtests.jl
index 539e69eba4ae0d..262ca6a46ecca4 100644
--- a/test/runtests.jl
+++ b/test/runtests.jl
@@ -1,6 +1,9 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
 using Base.Test
 include("choosetests.jl")
+include("testenv.jl")
+
 tests, net_on = choosetests(ARGS)
 tests = unique(tests)
 
@@ -10,18 +13,6 @@ else
     typemax(Csize_t)
 end
 
-if haskey(ENV, "JULIA_TEST_EXEFLAGS")
-    const test_exeflags = `$(Base.shell_split(ENV["JULIA_TEST_EXEFLAGS"]))`
-else
-    const test_exeflags = `--check-bounds=yes --startup-file=no --depwarn=error`
-end
-
-if haskey(ENV, "JULIA_TEST_EXENAME")
-    const test_exename = `$(Base.shell_split(ENV["JULIA_TEST_EXENAME"]))`
-else
-    const test_exename = `$(joinpath(JULIA_HOME, Base.julia_exename()))`
-end
-
 const node1_tests = String[]
 function move_to_node1(t)
     if t in tests
@@ -39,7 +30,7 @@ cd(dirname(@__FILE__)) do
     n = 1
     if net_on
         n = min(Sys.CPU_CORES, length(tests))
-        n > 1 && addprocs(n; exename=test_exename, exeflags=test_exeflags)
+        n > 1 && addprocs_with_testenv(n)
         BLAS.set_num_threads(1)
     end
 
@@ -71,8 +62,8 @@ cd(dirname(@__FILE__)) do
                     if (isa(resp[end], Integer) && (resp[end] > max_worker_rss)) || isa(resp, Exception)
                         if n > 1
                             rmprocs(wrkr, waitfor=30)
-                            p = addprocs(1; exename=test_exename, exeflags=test_exeflags)[1]
-                            remotecall_fetch(()->include("testdefs.jl"), p)
+                            p = addprocs_with_testenv(1)[1]
+                            remotecall_fetch(include, p, "testdefs.jl")
                         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")
diff --git a/test/serialize.jl b/test/serialize.jl
index 76c19a7402d65a..ec1e302f1a72b5 100644
--- a/test/serialize.jl
+++ b/test/serialize.jl
@@ -1,11 +1,11 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base.Test
 
 # Check that serializer hasn't gone out-of-frame
-@test Serializer.sertag(Symbol) == 2
-@test Serializer.sertag(()) == 45
-@test Serializer.sertag(false) == 121
+@test Serializer.sertag(Symbol) == 1
+@test Serializer.sertag(()) == 55
+@test Serializer.sertag(false) == 63
 
 function create_serialization_stream(f::Function)
     s = IOBuffer()
@@ -251,7 +251,7 @@ module ArrayWrappers
 struct ArrayWrapper{T,N,A<:AbstractArray} <: AbstractArray{T,N}
     data::A
 end
-ArrayWrapper{T,N}(data::AbstractArray{T,N}) = ArrayWrapper{T,N,typeof(data)}(data)
+ArrayWrapper(data::AbstractArray{T,N}) where {T,N} = ArrayWrapper{T,N,typeof(data)}(data)
 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...)
@@ -294,11 +294,21 @@ main_ex = quote
         serialize(s, g)
 
         seekstart(s)
-        local g2 = deserialize(s)
+        ds = SerializationState(s)
+        local g2 = deserialize(ds)
         $Test.@test g2 !== g
         $Test.@test g2() == :magic_token_anon_fun_test
         $Test.@test g2() == :magic_token_anon_fun_test
-        $Test.@test deserialize(s) === g2
+        $Test.@test deserialize(ds) === g2
+
+        # issue #21793
+        y = x -> (() -> x)
+        seekstart(s)
+        serialize(s, y)
+        seekstart(s)
+        y2 = deserialize(s)
+        x2 = y2(2)
+        $Test.@test x2() == 2
     end
 end
 # This needs to be run on `Main` since the serializer treats it differently.
@@ -369,6 +379,17 @@ create_serialization_stream() do s
     @test isa(b,Vector{Any})
 end
 
+# shared references
+create_serialization_stream() do s
+    A = [1,2]
+    B = [A,A]
+    serialize(s, B)
+    seekstart(s)
+    C = deserialize(s)
+    @test C == B
+    @test C[1] === C[2]
+end
+
 # Regex
 create_serialization_stream() do s
     r1 = r"a?b.*"
@@ -444,3 +465,16 @@ let a = ['T', 'e', 's', 't']
     seek(f,0)
     @test deserialize(f) === :β
 end
+
+# issue #20324
+struct T20324{T}
+    x::T
+end
+let x = T20324[T20324(1) for i = 1:2]
+    b = IOBuffer()
+    serialize(b, x)
+    seekstart(b)
+    y = deserialize(b)
+    @test isa(y,Vector{T20324})
+    @test y == x
+end
diff --git a/test/sets.jl b/test/sets.jl
index c5abf4df213082..8808036301acbc 100644
--- a/test/sets.jl
+++ b/test/sets.jl
@@ -1,6 +1,8 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Set tests
+isdefined(Main, :TestHelpers) || @eval Main include("TestHelpers.jl")
+using TestHelpers.OAs
 
 # Construction, collect
 @test ===(typeof(Set([1,2,3])), Set{Int})
@@ -78,6 +80,7 @@ push!(s,1); push!(s,2); push!(s,3)
 @test pop!(s) == 3
 @test length(s) == 0
 @test isempty(s)
+@test_throws ArgumentError pop!(s)
 
 # copy
 data_in = (1,2,9,8,4)
@@ -203,6 +206,10 @@ end
 @test ⊊(Set([1]), Set([1,2]))
 @test !⊊(Set([1]), Set([1]))
 @test ⊈(Set([1]), Set([2]))
+@test ⊇(Set([1,2]), Set([1]))
+@test ⊋(Set([1,2]), Set([1]))
+@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])
 
 # unique
@@ -216,6 +223,42 @@ u = unique([1,1,2])
 @test @inferred(unique(x for x in 1:1)) == [1]
 @test unique(x for x in Any[1,1.0])::Vector{Real} == [1]
 
+# unique!
+@testset "unique!" begin
+    u = [1,1,3,2,1]
+    unique!(u)
+    @test u == [1,3,2]
+    @test unique!([]) == []
+    @test unique!(Float64[]) == Float64[]
+    u = [1,2,2,3,5,5]
+    @test unique!(u) === u
+    @test u == [1,2,3,5]
+    u = [6,5,5,3,3,2,1]
+    @test unique!(u) === u
+    @test u == [6,5,3,2,1]
+    u = OffsetArray([1,2,2,3,5,5], -1)
+    @test unique!(u) === u
+    @test u == OffsetArray([1,2,3,5], -1)
+    u = OffsetArray([5,5,4,4,2,2,0,-1,-1], -1)
+    @test unique!(u) === u
+    @test u == OffsetArray([5,4,2,0,-1], -1)
+    u = OffsetArray(["w","we","w",5,"r",5,5], -1)
+    @test unique!(u) === u
+    @test u == OffsetArray(["w","we",5,"r"], -1)
+    u = [0.0,-0.0,1.0,2]
+    @test unique!(u) === u
+    @test u == [0.0,-0.0,1.0,2.0]
+    u = [1,NaN,NaN,3]
+    @test unique!(u) === u
+    @test u[1] == 1
+    @test isnan(u[2])
+    @test u[3] == 3
+    u = [5,"w","we","w","r",5,"w"]
+    unique!(u)
+    @test u == [5,"w","we","r"]
+    u = [1,2,5,1,3,2]
+end
+
 # allunique
 @test allunique([])
 @test allunique(Set())
diff --git a/test/show.jl b/test/show.jl
index 9776ab2da7b50d..52bd4ac8035916 100644
--- a/test/show.jl
+++ b/test/show.jl
@@ -1,8 +1,7 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
-const curmod = current_module()
-const curmod_name = fullname(curmod)
-const curmod_prefix = "$(["$m." for m in curmod_name]...)"
+# For curmod_*
+include("testenv.jl")
 
 replstr(x) = sprint((io,x) -> show(IOContext(io, :limit => true), MIME("text/plain"), x), x)
 
@@ -16,8 +15,8 @@ struct T5589
 end
 @test replstr(T5589(Array{String,1}(100))) == "$(curmod_prefix)T5589(String[#undef, #undef, #undef, #undef, #undef, #undef, #undef, #undef, #undef, #undef  …  #undef, #undef, #undef, #undef, #undef, #undef, #undef, #undef, #undef, #undef])"
 
-@test replstr(parse("mutable struct X end")) == ":(mutable struct X # none, line 1:\n    end)"
-@test replstr(parse("struct X end")) == ":(struct X # none, line 1:\n    end)"
+@test replstr(parse("mutable struct X end")) == ":(mutable struct X\n        #= none:1 =#\n    end)"
+@test replstr(parse("struct X end")) == ":(struct X\n        #= none:1 =#\n    end)"
 s = "ccall(:f, Int, (Ptr{Void},), &x)"
 @test replstr(parse(s)) == ":($s)"
 
@@ -43,12 +42,14 @@ macro test_repr(x)
             local x1 = parse($x)
             local x2 = eval(parse(repr(x1)))
             local x3 = eval(parse(repr(x2)))
-            x3 == x1 ? nothing : error(string(
-                "repr test failed:",
-                "\noriginal: ", $x,
-                "\n\nparsed: ", x2, "\n", sprint(dump, x2),
-                "\n\nreparsed: ", x3, "\n", sprint(dump, x3)
-                ))
+            if x3 != x1
+                error(string(
+                    "repr test failed:",
+                    "\noriginal: ", $x,
+                    "\n\nparsed: ", x2, "\n", sprint(dump, x2),
+                    "\n\nreparsed: ", x3, "\n", sprint(dump, x3)
+                    ))
+            end
         end
     end
 end
@@ -93,78 +94,145 @@ end
 @test_repr "(a / b) / (c / d / e)"
 @test_repr "(a == b == c) != (c == d < e)"
 
+# Exponentiation (>= operator_precedence(:^)) and unary operators
+@test_repr "(-1)^a"
+@test_repr "(-2.1)^-1"
+@test_repr "(-x)^a"
+@test_repr "(-a)^-1"
+@test_repr "(!x)↑!a"
+@test_repr "(!x).a"
+@test_repr "(!x)::a"
+
+# Complex
+
+# parse(repr(:(...))) returns a double-quoted block, so we need to eval twice to unquote it
+@test iszero(eval(eval(parse(repr(:($(1 + 2im) - $(1 + 2im)))))))
+
+
 # control structures (shamelessly stolen from base/bitarray.jl)
 @test_repr """mutable struct BitArray{N} <: AbstractArray{Bool, N}
+    # line meta
     chunks::Vector{UInt64}
+    # line meta
     len::Int
+    # line meta
     dims::NTuple{N,Int}
+    # line meta
     function BitArray(dims::Int...)
+        # line meta
         if length(dims) != N
+            # line meta
             error(\"number of dimensions must be \$N (got \$(length(dims)))\")
         end
+        # line meta
         n = 1
+        # line meta
         for d in dims
+            # line meta
             if d < 0
+                # line meta
                 error(\"dimension size must be nonnegative (got \$d)\")
             end
+            # line meta
             n *= d
         end
+        # line meta
         nc = num_bit_chunks(n)
+        # line meta
         chunks = Array{UInt64,1}(nc)
+        # line meta
         if nc > 0
+            # line meta
             chunks[end] = UInt64(0)
         end
+        # line meta
         b = new(chunks, n)
+        # line meta
         if N != 1
+            # line meta
             b.dims = dims
         end
+        # line meta
         return b
     end
 end"""
 
 @test_repr """function copy_chunks(dest::Vector{UInt64}, pos_d::Integer, src::Vector{UInt64}, pos_s::Integer, numbits::Integer)
+    # line meta
     if numbits == 0
+        # line meta
         return
     end
+    # line meta
     if dest === src && pos_d > pos_s
+        # line meta
         return copy_chunks_rtol(dest, pos_d, pos_s, numbits)
     end
+    # line meta
     kd0, ld0 = get_chunks_id(pos_d)
+    # line meta
     kd1, ld1 = get_chunks_id(pos_d + numbits - 1)
+    # line meta
     ks0, ls0 = get_chunks_id(pos_s)
+    # line meta
     ks1, ls1 = get_chunks_id(pos_s + numbits - 1)
+    # line meta
     delta_kd = kd1 - kd0
+    # line meta
     delta_ks = ks1 - ks0
+    # line meta
     u = _msk64
+    # line meta
     if delta_kd == 0
+        # line meta
         msk_d0 = ~(u << ld0) | (u << ld1 << 1)
     else
+        # line meta
         msk_d0 = ~(u << ld0)
+        # line meta
         msk_d1 = (u << ld1 << 1)
     end
+    # line meta
     if delta_ks == 0
+        # line meta
         msk_s0 = (u << ls0) & ~(u << ls1 << 1)
     else
+        # line meta
         msk_s0 = (u << ls0)
     end
+    # line meta
     chunk_s0 = glue_src_bitchunks(src, ks0, ks1, msk_s0, ls0)
+    # line meta
     dest[kd0] = (dest[kd0] & msk_d0) | ((chunk_s0 << ld0) & ~msk_d0)
+    # line meta
     if delta_kd == 0
+        # line meta
         return
     end
+    # line meta
     for i = 1 : kd1 - kd0 - 1
+        # line meta
         chunk_s1 = glue_src_bitchunks(src, ks0 + i, ks1, msk_s0, ls0)
+        # line meta
         chunk_s = (chunk_s0 >>> (63 - ld0) >>> 1) | (chunk_s1 << ld0)
+        # line meta
         dest[kd0 + i] = chunk_s
+        # line meta
         chunk_s0 = chunk_s1
     end
+    # line meta
     if ks1 >= ks0 + delta_kd
+        # line meta
         chunk_s1 = glue_src_bitchunks(src, ks0 + delta_kd, ks1, msk_s0, ls0)
     else
+        # line meta
         chunk_s1 = UInt64(0)
     end
+    # line meta
     chunk_s = (chunk_s0 >>> (63 - ld0) >>> 1) | (chunk_s1 << ld0)
+    # line meta
     dest[kd1] = (dest[kd1] & msk_d1) | (chunk_s & ~msk_d1)
+    # line meta
     return
 end"""
 
@@ -202,13 +270,21 @@ end"""
 @test_repr "[1 2 3; 4 5 6; 7 8 9]'"
 
 @test_repr "baremodule X
+# line meta
+# line meta
 importall ..A.b
+# line meta
 import ...B.c
+# line meta
 import D
+# line meta
 import B.C.D.E.F.g
 end"
 @test_repr "baremodule Y
+# line meta
+# line meta
 export A, B, C
+# line meta
 export D, E, F
 end"
 
@@ -262,22 +338,22 @@ end
 @test string(:(-{x}))   == "-{x}"
 
 # issue #11393
-@test_repr "@m(x,y) + z"
-@test_repr "(@m(x,y),z)"
-@test_repr "[@m(x,y),z]"
-@test_repr "A[@m(x,y),z]"
-@test_repr "T{@m(x,y),z}"
+@test_repr "@m(x, y) + z"
+@test_repr "(@m(x, y), z)"
+@test_repr "[@m(x, y), z]"
+@test_repr "A[@m(x, y), z]"
+@test_repr "T{@m(x, y), z}"
 @test_repr "@m x @n(y) z"
-@test_repr "f(@m(x,y);z=@n(a))"
-@test_repr "@m(x,y).z"
-@test_repr "::@m(x,y)+z"
+@test_repr "f(@m(x, y); z=@n(a))"
+@test_repr "@m(x, y).z"
+@test_repr "::@m(x, y) + z"
 @test_repr "[@m(x) y z]"
 @test_repr "[@m(x) y; z]"
 @test_repr "let @m(x), y=z; end"
 
-@test repr(:(@m x y))    == ":(@m x y)"
-@test string(:(@m x y))  ==   "@m x y"
-@test string(:(@m x y;)) == "begin \n    @m x y\nend"
+@test repr(:(@m x y))    == ":(#= $(@__FILE__):$(@__LINE__) =# @m x y)"
+@test string(:(@m x y))  ==   "#= $(@__FILE__):$(@__LINE__) =# @m x y"
+@test string(:(@m x y;)) == "begin\n    #= $(@__FILE__):$(@__LINE__) =# @m x y\nend"
 
 # issue #11436
 @test_repr "1 => 2 => 3"
@@ -306,12 +382,12 @@ let oldout = STDOUT, olderr = STDERR
         # pr 16917
         rdout, wrout = redirect_stdout()
         @test wrout === STDOUT
-        out = @async readstring(rdout)
+        out = @async read(rdout, String)
         rderr, wrerr = redirect_stderr()
         @test wrerr === STDERR
-        err = @async readstring(rderr)
+        err = @async read(rderr, String)
         @test dump(Int64) === nothing
-        if !is_windows()
+        if !Sys.iswindows()
             close(wrout)
             close(wrerr)
         end
@@ -348,7 +424,7 @@ let filename = tempname()
         end
     end
     @test ret == [1,3]
-    @test chomp(readstring(filename)) == "hello"
+    @test chomp(read(filename, String)) == "hello"
     ret = open(filename, "w") do f
         redirect_stderr(f) do
             warn("hello")
@@ -356,12 +432,19 @@ let filename = tempname()
         end
     end
     @test ret == [2]
-    @test contains(readstring(filename), "WARNING: hello")
-    ret = open(filename) do f
-        redirect_stdin(f) do
-            readline()
+
+    # STDIN is unavailable on the workers. Run test on master.
+    @test contains(read(filename, String), "WARNING: hello")
+    ret = eval(Main, quote
+        remotecall_fetch(1, $filename) do fname
+            open(fname) do f
+                redirect_stdin(f) do
+                    readline()
+                end
+            end
         end
-    end
+    end)
+
     @test contains(ret, "WARNING: hello")
     rm(filename)
 end
@@ -387,13 +470,6 @@ function f13127()
 end
 @test f13127() == "$(curmod_prefix)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)
@@ -448,32 +524,40 @@ end
 
 
 # issue #15309
-l1, l2, l2n = Expr(:line,42), Expr(:line,42,:myfile), LineNumberNode(42)
-@test string(l2n) == " # line 42:"
-@test string(l2)  == " # myfile, line 42:"
-@test string(l1)  == string(l2n)
-ex = Expr(:block, l1, :x, l2, :y, l2n, :z)
-@test replace(string(ex)," ","") == replace("""
-begin  # line 42:
-    x # myfile, line 42:
-    y # line 42:
-    z
-end""", " ", "")
+let ex,
+    l1 = Expr(:line, 42),
+    l2 = Expr(:line, 42, :myfile),
+    l2n = LineNumberNode(42)
+    @test string(l2n) == "#= line 42 =#"
+    @test string(l2)  == "#= myfile:42 =#"
+    @test string(l1)  == string(l2n)
+    ex = Expr(:block, l1, :x, l2, :y, l2n, :z)
+    @test replace(string(ex)," ","") == replace("""
+    begin
+        #= line 42 =#
+        x
+        #= myfile:42 =#
+        y
+        #= line 42 =#
+        z
+    end""", " ", "")
+end
 # Test the printing of whatever form of line number representation
 # that is used in the arguments to a macro looks the same as for
 # regular quoting
 macro strquote(ex)
-    QuoteNode(string(ex))
+    return QuoteNode(string(ex))
+end
+let str_ex2a = @strquote(begin x end), str_ex2b = string(quote x end)
+    @test str_ex2a == str_ex2b
 end
-str_ex2a, str_ex2b = @strquote(begin x end), string(quote x end)
-@test str_ex2a == str_ex2b
 
 
 # test structured zero matrix printing for select structured types
 A = reshape(1:16,4,4)
-@test replstr(Diagonal(A)) == "4×4 Diagonal{$Int}:\n 1  ⋅   ⋅   ⋅\n ⋅  6   ⋅   ⋅\n ⋅  ⋅  11   ⋅\n ⋅  ⋅   ⋅  16"
-@test replstr(Bidiagonal(A,true)) == "4×4 Bidiagonal{$Int}:\n 1  5   ⋅   ⋅\n ⋅  6  10   ⋅\n ⋅  ⋅  11  15\n ⋅  ⋅   ⋅  16"
-@test replstr(Bidiagonal(A,false)) == "4×4 Bidiagonal{$Int}:\n 1  ⋅   ⋅   ⋅\n 2  6   ⋅   ⋅\n ⋅  7  11   ⋅\n ⋅  ⋅  12  16"
+@test replstr(Diagonal(A)) == "4×4 Diagonal{$(Int),Array{$(Int),1}}:\n 1  ⋅   ⋅   ⋅\n ⋅  6   ⋅   ⋅\n ⋅  ⋅  11   ⋅\n ⋅  ⋅   ⋅  16"
+@test replstr(Bidiagonal(A,:U)) == "4×4 Bidiagonal{$Int}:\n 1  5   ⋅   ⋅\n ⋅  6  10   ⋅\n ⋅  ⋅  11  15\n ⋅  ⋅   ⋅  16"
+@test replstr(Bidiagonal(A,:L)) == "4×4 Bidiagonal{$Int}:\n 1  ⋅   ⋅   ⋅\n 2  6   ⋅   ⋅\n ⋅  7  11   ⋅\n ⋅  ⋅  12  16"
 @test replstr(SymTridiagonal(A+A')) == "4×4 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))) == "4×4 Tridiagonal{$Int}:\n 1  5   ⋅   ⋅\n 2  6  10   ⋅\n ⋅  7  11  15\n ⋅  ⋅  12  16"
 @test replstr(UpperTriangular(copy(A))) == "4×4 UpperTriangular{$Int,Array{$Int,2}}:\n 1  5   9  13\n ⋅  6  10  14\n ⋅  ⋅  11  15\n ⋅  ⋅   ⋅  16"
@@ -494,7 +578,7 @@ show_f1(x...) = [x...]
 show_f2(x::Vararg{Any}) = [x...]
 show_f3(x::Vararg) = [x...]
 show_f4(x::Vararg{Any,3}) = [x...]
-show_f5{T, N}(A::AbstractArray{T,N}, indexes::Vararg{Int,N}) = [indexes...]
+show_f5(A::AbstractArray{T, N}, indexes::Vararg{Int,N}) where {T, N} = [indexes...]
 test_mt(show_f1, "show_f1(x...)")
 test_mt(show_f2, "show_f2(x...)")
 test_mt(show_f3, "show_f3(x...)")
@@ -507,6 +591,22 @@ test_mt(show_f5, "show_f5(A::AbstractArray{T,N}, indexes::Vararg{$Int,N})")
 @test_repr "[a;]"
 @test_repr "[a; b]"
 
+# other brackets and braces
+@test_repr "[a]"
+@test_repr "[a,b]"
+@test_repr "[a;b;c]"
+@test_repr "[a b]"
+@test_repr "[a b;]"
+@test_repr "[a b c]"
+@test_repr "[a b; c d]"
+@test_repr "{a}"
+@test_repr "{a,b}"
+@test_repr "{a;b;c}"
+@test_repr "{a b}"
+@test_repr "{a b;}"
+@test_repr "{a b c}"
+@test_repr "{a b; c d}"
+
 # Printing of :(function f end)
 @test sprint(show, :(function f end)) == ":(function f end)"
 @test_repr "function g end"
@@ -544,6 +644,11 @@ let io = IOBuffer()
     @test String(take!(io)) == "[1, 2]"
 end
 
+let io = IOBuffer()
+    ioc = IOContext(io, :limit => true)
+    @test sprint(show, ioc) == "IOContext($(sprint(show, ioc.io)))"
+end
+
 # PR 17117
 # test show array
 let s = IOBuffer(Array{UInt8}(0), true, true)
@@ -646,3 +751,132 @@ let d = TextDisplay(IOBuffer())
         @test e.f == show
     end
 end
+
+struct TypeWith4Params{a,b,c,d}
+end
+@test endswith(string(TypeWith4Params{Int8,Int8,Int8,Int8}), "TypeWith4Params{Int8,Int8,Int8,Int8}")
+
+# issues #20332 and #20781
+struct T20332{T}
+end
+
+(::T20332{T})(x) where T = 0
+
+let m = which(T20332{Int}(), (Int,)),
+    mi = ccall(:jl_specializations_get_linfo, Ref{Core.MethodInstance}, (Any, Any, Any, UInt),
+               m, Tuple{T20332{T}, Int} where T, Core.svec(), typemax(UInt))
+    # test that this doesn't throw an error
+    @test contains(repr(mi), "MethodInstance for")
+end
+
+@test sprint(show, Main) == "Main"
+
+@test sprint(Base.show_supertypes, Int64) == "Int64 <: Signed <: Integer <: Real <: Number <: Any"
+@test sprint(Base.show_supertypes, Vector{String}) == "Array{String,1} <: DenseArray{String,1} <: AbstractArray{String,1} <: Any"
+
+# static_show
+
+function static_shown(x)
+    p = Pipe()
+    Base.link_pipe(p; julia_only_read=true, julia_only_write=true)
+    ccall(:jl_static_show, Void, (Ptr{Void}, Any), p.in, x)
+    @async close(p.in)
+    return read(p.out, String)
+end
+
+# Test for PR 17803
+@test static_shown(Int128(-1)) == "Int128(0xffffffffffffffffffffffffffffffff)"
+
+# PR #22160
+@test static_shown(:aa) == ":aa"
+@test static_shown(:+) == ":+"
+@test static_shown(://) == "://"
+@test static_shown(://=) == "://="
+@test static_shown(Symbol("")) == "Symbol(\"\")"
+@test static_shown(Symbol("a/b")) == "Symbol(\"a/b\")"
+@test static_shown(Symbol("a-b")) == "Symbol(\"a-b\")"
+
+@test static_shown(QuoteNode(:x)) == ":(:x)"
+
+# Test @show
+let fname = tempname()
+    try
+        open(fname, "w") do fout
+            redirect_stdout(fout) do
+                @show zeros(2, 2)
+            end
+        end
+        @test read(fname, String) == "zeros(2, 2) = 2×2 Array{Float64,2}:\n 0.0  0.0\n 0.0  0.0\n"
+    finally
+        rm(fname, force=true)
+    end
+end
+
+struct f_with_params{t} <: Function
+end
+
+(::f_with_params)(x) = 2x
+
+let io = IOBuffer()
+    show(io, MIME"text/html"(), f_with_params.body.name.mt)
+    @test contains(String(take!(io)), "f_with_params")
+end
+
+@testset "printing of Val's" begin
+    @test sprint(show, Val(Float64))  == "Val{Float64}()"  # Val of a type
+    @test sprint(show, Val(:Float64)) == "Val{:Float64}()" # Val of a symbol
+    @test sprint(show, Val(true))     == "Val{true}()"     # Val of a value
+end
+
+@testset "printing of Pair's" begin
+    for (p, s) in (Pair(1.0,2.0)                          => "1.0 => 2.0",
+                   Pair(Pair(1,2), Pair(3,4))             => "(1=>2) => (3=>4)",
+                   Pair{Integer,Int64}(1, 2)              => "Pair{Integer,Int64}(1, 2)",
+                   (Pair{Integer,Int64}(1, 2) => 3)       => "Pair{Integer,Int64}(1, 2) => 3",
+                   ((1+2im) => (3+4im))                   => "1+2im => 3+4im",
+                   (1 => 2 => Pair{Real,Int64}(3, 4))     => "1 => (2=>Pair{Real,Int64}(3, 4))")
+
+        @test sprint(show, p) == s
+    end
+    # - when the context has :compact=>false, print pair's member non-compactly
+    # - if one member is printed as "Pair{...}(...)", no need to put parens around
+    s = IOBuffer()
+    show(IOContext(s, :compact => false), (1=>2) => Pair{Any,Any}(3,4))
+    @test String(take!(s)) == "(1 => 2) => Pair{Any,Any}(3, 4)"
+end
+
+@testset "alignment for pairs" begin  # (#22899)
+    @test replstr([1=>22,33=>4]) == "2-element Array{Pair{$Int,$Int},1}:\n  1 => 22\n 33 => 4 "
+    # first field may have "=>" in its representation
+    @test replstr(Pair[(1=>2)=>3, 4=>5]) ==
+        "2-element Array{Pair,1}:\n (1=>2) => 3\n      4 => 5"
+    @test replstr(Any[Dict(1=>2)=> (3=>4), 1=>2]) ==
+        "2-element Array{Any,1}:\n Dict(1=>2) => (3=>4)\n          1 => 2     "
+    # left-alignment when not using the "=>" symbol
+    @test replstr(Pair{Integer,Int64}[1=>2, 33=>4]) ==
+        "2-element Array{Pair{Integer,Int64},1}:\n Pair{Integer,Int64}(1, 2) \n Pair{Integer,Int64}(33, 4)"
+end
+
+@testset "display arrays non-compactly when size(⋅, 2) == 1" begin
+    # 0-dim
+    @test replstr(zeros(Complex{Int})) == "0-dimensional Array{Complex{$Int},0}:\n0 + 0im"
+    A = Array{Pair}(); A[] = 1=>2
+    @test replstr(A) == "0-dimensional Array{Pair,0}:\n1 => 2"
+    # 1-dim
+    @test replstr(zeros(Complex{Int}, 2)) ==
+        "2-element Array{Complex{$Int},1}:\n 0 + 0im\n 0 + 0im"
+    @test replstr([1=>2, 3=>4]) == "2-element Array{Pair{$Int,$Int},1}:\n 1 => 2\n 3 => 4"
+    # 2-dim
+    @test replstr(zeros(Complex{Int}, 2, 1)) ==
+        "2×1 Array{Complex{$Int},2}:\n 0 + 0im\n 0 + 0im"
+    @test replstr(zeros(Complex{Int}, 1, 2)) ==
+        "1×2 Array{Complex{$Int},2}:\n 0+0im  0+0im"
+    @test replstr([1=>2 3=>4]) == "1×2 Array{Pair{$Int,$Int},2}:\n 1=>2  3=>4"
+    @test replstr([1=>2 for x in 1:2, y in 1:1]) ==
+        "2×1 Array{Pair{$Int,$Int},2}:\n 1 => 2\n 1 => 2"
+    # 3-dim
+    @test replstr(zeros(Complex{Int}, 1, 1, 1)) ==
+        "1×1×1 Array{Complex{$Int},3}:\n[:, :, 1] =\n 0 + 0im"
+    @test replstr(zeros(Complex{Int}, 1, 2, 1)) ==
+        "1×2×1 Array{Complex{$Int},3}:\n[:, :, 1] =\n 0+0im  0+0im"
+end
diff --git a/test/simdloop.jl b/test/simdloop.jl
index 4ea2f82ba83559..bbac5f1dfa82a0 100644
--- a/test/simdloop.jl
+++ b/test/simdloop.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 function simd_loop_example_from_manual(x, y, z)
     s = zero(eltype(z))
@@ -101,28 +101,23 @@ function simd_cartesian_range!(indexes, crng)
     indexes
 end
 
-crng = CartesianRange(CartesianIndex{4}(2,0,1,3),
-                      CartesianIndex{4}(4,1,1,5))
+crng = CartesianRange(2:4, 0:1, 1:1, 3:5)
 indexes = simd_cartesian_range!(Array{eltype(crng)}(0), crng)
 @test indexes == vec(collect(crng))
 
-crng = CartesianRange(CartesianIndex{2}(-1,1),
-                      CartesianIndex{2}(1,3))
+crng = CartesianRange(-1:1, 1:3)
 indexes = simd_cartesian_range!(Array{eltype(crng)}(0), crng)
 @test indexes == vec(collect(crng))
 
-crng = CartesianRange(CartesianIndex{2}(-1,1),
-                      CartesianIndex{2}(-1,3))
+crng = CartesianRange(-1:-1, 1:3)
 indexes = simd_cartesian_range!(Array{eltype(crng)}(0), crng)
 @test indexes == vec(collect(crng))
 
-crng = CartesianRange(CartesianIndex{1}(2),
-                      CartesianIndex{1}(4))
+crng = CartesianRange(2:4)
 indexes = simd_cartesian_range!(Array{eltype(crng)}(0), crng)
 @test indexes == collect(crng)
 
-crng = CartesianRange(CartesianIndex{0}(),
-                      CartesianIndex{0}())
+crng = CartesianRange()
 indexes = simd_cartesian_range!(Array{eltype(crng)}(0), crng)
 @test indexes == vec(collect(crng))
 
diff --git a/test/socket.jl b/test/socket.jl
index 9d5421824f04b3..5d1c6cae5e6e5a 100644
--- a/test/socket.jl
+++ b/test/socket.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 @test ip"127.0.0.1" == IPv4(127,0,0,1)
 @test ip"192.0" == IPv4(192,0,0,0)
@@ -69,30 +69,32 @@ end
 # test show() function for UDPSocket()
 @test repr(UDPSocket()) == "UDPSocket(init)"
 
-port = Channel(1)
 defaultport = rand(2000:4000)
-tsk = @async begin
-    p, s = listenany(defaultport)
-    put!(port, p)
-    sock = accept(s)
-    # test write call
-    write(sock,"Hello World\n")
-
-    # test "locked" println to a socket
-    @sync begin
-        for i in 1:100
-            @async println(sock, "a", 1)
+for testport in [0, defaultport]
+    port = Channel(1)
+    tsk = @async begin
+        p, s = listenany(testport)
+        put!(port, p)
+        sock = accept(s)
+        # test write call
+        write(sock,"Hello World\n")
+
+        # test "locked" println to a socket
+        @sync begin
+            for i in 1:100
+                @async println(sock, "a", 1)
+            end
         end
+        close(s)
+        close(sock)
     end
-    close(s)
-    close(sock)
+    wait(port)
+    @test read(connect(fetch(port)), String) == "Hello World\n" * ("a1\n"^100)
+    wait(tsk)
 end
-wait(port)
-@test readstring(connect(fetch(port))) == "Hello World\n" * ("a1\n"^100)
-wait(tsk)
 
 mktempdir() do tmpdir
-    socketname = is_windows() ? ("\\\\.\\pipe\\uv-test-" * randstring(6)) : joinpath(tmpdir, "socket")
+    socketname = Sys.iswindows() ? ("\\\\.\\pipe\\uv-test-" * randstring(6)) : joinpath(tmpdir, "socket")
     c = Base.Condition()
     tsk = @async begin
         s = listen(socketname)
@@ -103,7 +105,7 @@ mktempdir() do tmpdir
         close(sock)
     end
     wait(c)
-    @test readstring(connect(socketname)) == "Hello World\n"
+    @test read(connect(socketname), String) == "Hello World\n"
     wait(tsk)
 end
 
@@ -174,7 +176,7 @@ begin
     close(a)
     close(b)
 end
-if !is_windows() || Sys.windows_version() >= Sys.WINDOWS_VISTA_VER
+if !Sys.iswindows() || Sys.windows_version() >= Sys.WINDOWS_VISTA_VER
     a = UDPSocket()
     b = UDPSocket()
     bind(a, ip"::1", UInt16(port))
@@ -191,74 +193,68 @@ if !is_windows() || Sys.windows_version() >= Sys.WINDOWS_VISTA_VER
 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)
+    for (addr, porthint) in [(IPv4("127.0.0.1"), UInt16(11011)),
+                        (IPv6("::1"), UInt16(11012)), (getipaddr(), UInt16(11013))]
+        port, listen_sock = listenany(addr, porthint)
+        gsn_addr, gsn_port = getsockname(listen_sock)
 
-    @test default_addr == new_addr
-    @test default_port == new_port
-    close(sock)
-end
-
-begin
-    default_port = UInt16(21011)
-    default_addr = IPv6("::1")
+        @test addr == gsn_addr
+        @test port == gsn_port
 
-    sock = Base.TCPServer()
-    addr = Base.InetAddr(default_addr,default_port)
-    bind(sock,addr)
-    listen(sock)
+        @test_throws MethodError getpeername(listen_sock)
 
-    new_addr, new_port = getsockname(sock)
+        # connect to it
+        client_sock = connect(addr, port)
+        server_sock = accept(listen_sock)
 
-    @test default_addr == new_addr
-    @test default_port == new_port
-    close(sock)
-end
+        self_client_addr, self_client_port = getsockname(client_sock)
+        peer_client_addr, peer_client_port = getpeername(client_sock)
+        self_srvr_addr, self_srvr_port = getsockname(server_sock)
+        peer_srvr_addr, peer_srvr_port = getpeername(server_sock)
 
-begin
-    default_port = UInt16(11011)
-    default_addr = getipaddr()
+        @test self_client_addr == peer_client_addr == self_srvr_addr == peer_srvr_addr
 
-    sock = Base.TCPServer()
-    bind(sock,Base.InetAddr(default_addr,default_port))
-    listen(sock)
+        @test peer_client_port == self_srvr_port
+        @test peer_srvr_port == self_client_port
+        @test self_srvr_port != self_client_port
 
-    @async begin
-        sleep(1)
-        ssock = connect(default_addr, default_port)
+        close(listen_sock)
+        close(client_sock)
+        close(server_sock)
     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 = is_apple() ? ip"255.255.255.255" : ip"127.255.255.255"
+    bcastdst = Sys.isapple() ? 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
+
+    function wait_with_timeout(recvs)
+        TIMEOUT_VAL = 3  # seconds
+        t0 = time()
+        recvs_check = copy(recvs)
+        while ((length(filter!(t->!istaskdone(t), recvs_check)) > 0)
+              && (time() - t0 < TIMEOUT_VAL))
+            sleep(0.05)
+        end
+        length(recvs_check) > 0 && error("timeout")
+        map(wait, recvs)
+    end
+
     a, b, c = [create_socket() for i = 1:3]
     try
-        @sync begin
+        # bsd family do not allow broadcasting to ip"255.255.255.255"
+        # or ip"127.255.255.255"
+        @static if !Sys.isbsd() || Sys.isapple()
             send(c, bcastdst, 2000, "hello")
             recvs = [@async @test String(recv(s)) == "hello" for s in (a, b)]
-            map(wait, recvs)
+            wait_with_timeout(recvs)
         end
     catch e
         if isa(e, Base.UVError) && Base.uverrorname(e) == "EPERM"
@@ -292,12 +288,12 @@ let P = Pipe()
     # on windows, the kernel fails to do even that
     # causing the `write` call to freeze
     # so we end up forced to do a slightly weaker test here
-    is_windows() || wait(t)
+    Sys.iswindows() || wait(t)
     @test isopen(P) # without an active uv_reader, P shouldn't be closed yet
     @test !eof(P) # should already know this,
     @test isopen(P) #  so it still shouldn't have an active uv_reader
     @test readuntil(P, 'w') == "llow"
-    is_windows() && wait(t)
+    Sys.iswindows() && wait(t)
     @test eof(P)
     @test !isopen(P) # eof test should have closed this by now
     close(P) # should be a no-op, just make sure
diff --git a/test/sorting.jl b/test/sorting.jl
index 635eea81d127ab..28d7020d25458f 100644
--- a/test/sorting.jl
+++ b/test/sorting.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base.Order: Forward
 
diff --git a/test/sparse/cholmod.jl b/test/sparse/cholmod.jl
index 817eb4e9883a83..d9583216b3ae9a 100644
--- a/test/sparse/cholmod.jl
+++ b/test/sparse/cholmod.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 srand(123)
 
@@ -102,7 +102,7 @@ A = CHOLMOD.Sparse(48, 48,
 B = A * ones(size(A,2))
 chma = ldltfact(A)                      # LDL' form
 @test CHOLMOD.isvalid(chma)
-@test unsafe_load(chma.p).is_ll == 0    # check that it is in fact an LDLt
+@test unsafe_load(pointer(chma)).is_ll == 0    # check that it is in fact an LDLt
 x = chma\B
 @test x ≈ ones(size(x))
 @test nnz(ldltfact(A, perm=1:size(A,1))) > nnz(chma)
@@ -113,7 +113,7 @@ chmal = CHOLMOD.FactorComponent(chma, :L)
 
 chma = cholfact(A)                      # LL' form
 @test CHOLMOD.isvalid(chma)
-@test unsafe_load(chma.p).is_ll == 1    # check that it is in fact an LLt
+@test unsafe_load(pointer(chma)).is_ll == 1    # check that it is in fact an LLt
 x = chma\B
 @test x ≈ ones(size(x))
 @test nnz(chma) == 489
@@ -191,30 +191,21 @@ ACSC = sprandn(10, 10, 0.3) + I
 @test ishermitian(Sparse(Hermitian(complex(ACSC), :U)))
 
 # test Sparse constructor for c_SparseVoid (and read_sparse)
-let testfile = joinpath(tempdir(), "tmp.mtx")
-    try
-        writedlm(testfile, ["%%MatrixMarket matrix coordinate real symmetric","3 3 4","1 1 1","2 2 1","3 2 0.5","3 3 1"])
-        @test sparse(CHOLMOD.Sparse(testfile)) == [1 0 0;0 1 0.5;0 0.5 1]
-    finally
-        rm(testfile)
-    end
-end
-let testfile = joinpath(tempdir(), "tmp.mtx")
-    try
-        writedlm(testfile, ["%%MatrixMarket matrix coordinate complex Hermitian",
-                 "3 3 4","1 1 1.0 0.0","2 2 1.0 0.0","3 2 0.5 0.5","3 3 1.0 0.0"])
-        @test sparse(CHOLMOD.Sparse(testfile)) == [1 0 0;0 1 0.5-0.5im;0 0.5+0.5im 1]
-    finally
-        rm(testfile)
-    end
-end
-let testfile = joinpath(tempdir(), "tmp.mtx")
-    try
-        writedlm(testfile, ["%%MatrixMarket matrix coordinate real symmetric","%3 3 4","1 1 1","2 2 1","3 2 0.5","3 3 1"])
-        @test_throws ArgumentError sparse(CHOLMOD.Sparse(testfile))
-    finally
-        rm(testfile)
-    end
+mktempdir() do temp_dir
+    testfile = joinpath(temp_dir, "tmp.mtx")
+
+    writedlm(testfile, ["%%MatrixMarket matrix coordinate real symmetric","3 3 4","1 1 1","2 2 1","3 2 0.5","3 3 1"])
+    @test sparse(CHOLMOD.Sparse(testfile)) == [1 0 0;0 1 0.5;0 0.5 1]
+    rm(testfile)
+
+    writedlm(testfile, ["%%MatrixMarket matrix coordinate complex Hermitian",
+                        "3 3 4","1 1 1.0 0.0","2 2 1.0 0.0","3 2 0.5 0.5","3 3 1.0 0.0"])
+    @test sparse(CHOLMOD.Sparse(testfile)) == [1 0 0;0 1 0.5-0.5im;0 0.5+0.5im 1]
+    rm(testfile)
+
+    writedlm(testfile, ["%%MatrixMarket matrix coordinate real symmetric","%3 3 4","1 1 1","2 2 1","3 2 0.5","3 3 1"])
+    @test_throws ArgumentError sparse(CHOLMOD.Sparse(testfile))
+    rm(testfile)
 end
 
 # test that Sparse(Ptr) constructor throws the right places
@@ -288,7 +279,7 @@ for elty in (Float64, Complex{Float64})
     @test CHOLMOD.check_dense(bDense)
 
     AA = CHOLMOD.eye(3)
-    unsafe_store!(convert(Ptr{Csize_t}, AA.p), 2, 1) # change size, but not stride, of Dense
+    unsafe_store!(convert(Ptr{Csize_t}, pointer(AA)), 2, 1) # change size, but not stride, of Dense
     @test convert(Matrix, AA) == eye(2, 3)
 end
 
@@ -357,14 +348,18 @@ for elty in (Float64, Complex{Float64})
 
     # Factor
     @test_throws ArgumentError cholfact(A1)
-    @test_throws Base.LinAlg.PosDefException cholfact(A1 + A1' - 2eigmax(Array(A1 + A1'))I)
-    @test_throws Base.LinAlg.PosDefException cholfact(A1 + A1', shift=-2eigmax(Array(A1 + A1')))
-    @test_throws ArgumentError ldltfact(A1 + A1' - 2real(A1[1,1])I)
-    @test_throws ArgumentError ldltfact(A1 + A1', shift=-2real(A1[1,1]))
     @test_throws ArgumentError cholfact(A1)
     @test_throws ArgumentError cholfact(A1, shift=1.0)
     @test_throws ArgumentError ldltfact(A1)
     @test_throws ArgumentError ldltfact(A1, shift=1.0)
+    @test_throws LinAlg.PosDefException cholfact(A1 + A1' - 2eigmax(Array(A1 + A1'))*I)\ones(size(A1, 1))
+    @test_throws LinAlg.PosDefException cholfact(A1 + A1', shift=-2eigmax(Array(A1 + A1')))\ones(size(A1, 1))
+    @test_throws ArgumentError ldltfact(A1 + A1' - 2real(A1[1,1])*I)\ones(size(A1, 1))
+    @test_throws ArgumentError ldltfact(A1 + A1', shift=-2real(A1[1,1]))\ones(size(A1, 1))
+    @test !isposdef(cholfact(A1 + A1' - 2eigmax(Array(A1 + A1'))*I))
+    @test !isposdef(cholfact(A1 + A1', shift=-2eigmax(Array(A1 + A1'))))
+    @test !LinAlg.issuccess(ldltfact(A1 + A1' - 2real(A1[1,1])*I))
+    @test !LinAlg.issuccess(ldltfact(A1 + A1', shift=-2real(A1[1,1])))
     F = cholfact(A1pd)
     tmp = IOBuffer()
     show(tmp, F)
@@ -414,7 +409,7 @@ for elty in (Float64, Complex{Float64})
     ### cholfact!/ldltfact!
     F = cholfact(A1pd)
     CHOLMOD.change_factor!(elty, false, false, true, true, F)
-    @test unsafe_load(F.p).is_ll == 0
+    @test unsafe_load(pointer(F)).is_ll == 0
     CHOLMOD.change_factor!(elty, true, false, true, true, F)
     @test 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
@@ -661,7 +656,7 @@ let m = 400, n = 500
     M = [speye(n) A'; A -speye(m)]
     b = M*ones(m + n)
     F = ldltfact(M)
-    s = unsafe_load(get(F.p))
+    s = unsafe_load(pointer(F))
     @test s.is_super == 0
     @test F\b ≈ ones(m + n)
 end
@@ -687,7 +682,7 @@ let A = sprandn(10, 10, 0.1)
     # Change internal representation to symmetric (upper/lower)
     o = fieldoffset(CHOLMOD.C_Sparse{eltype(C)}, find(fieldnames(CHOLMOD.C_Sparse{eltype(C)}) .== :stype)[1])
     for uplo in (1, -1)
-        unsafe_store!(Ptr{Int8}(C.p), uplo, Int(o) + 1)
+        unsafe_store!(Ptr{Int8}(pointer(C)), uplo, Int(o) + 1)
         @test convert(Symmetric{Float64,SparseMatrixCSC{Float64,Int}}, C) == Symmetric(A'A)
     end
 end
@@ -702,3 +697,60 @@ end
     @test_throws ArgumentError CHOLMOD.Sparse(A)
 end
 
+@testset "sparse right multiplication of Symmetric and Hermitian matrices #21431" begin
+    @test issparse(speye(2)*speye(2)*speye(2))
+    for T in (Symmetric, Hermitian)
+        @test issparse(speye(2)*T(speye(2))*speye(2))
+        @test issparse(speye(2)*(T(speye(2))*speye(2)))
+        @test issparse((speye(2)*T(speye(2)))*speye(2))
+    end
+end
+
+#Test sparse low rank update for cholesky decomposion
+A = SparseMatrixCSC{Float64,CHOLMOD.SuiteSparse_long}(10, 5, [1,3,6,8,10,13], [6,7,1,2,9,3,5,1,7,6,7,9],
+    [-0.138843, 2.99571, -0.556814, 0.669704, -1.39252, 1.33814,
+    1.02371, -0.502384, 1.10686, 0.262229, -1.6935, 0.525239])
+AtA = A'*A;
+C0 = [1., 2., 0, 0, 0]
+#Test both cholfact and LDLt with and without automatic permutations
+for F in (cholfact(AtA), cholfact(AtA, perm=1:5), ldltfact(AtA), ldltfact(AtA, perm=1:5))
+    B0 = F\ones(5)
+    #Test both sparse/dense and vectors/matrices
+    for Ctest in (C0, sparse(C0), [C0 2*C0], sparse([C0 2*C0]))
+        C = copy(Ctest)
+        F1 = copy(F)
+        B = (AtA+C*C')\ones(5)
+
+        #Test update
+        F11 = CHOLMOD.lowrankupdate(F1, C)
+        @test full(sparse(F11)) ≈ AtA+C*C'
+        @test F11\ones(5) ≈ B
+        #Make sure we get back the same factor again
+        F10 = CHOLMOD.lowrankdowndate(F11, C)
+        @test full(sparse(F10)) ≈ AtA
+        @test F10\ones(5) ≈ B0
+
+        #Test in-place update
+        CHOLMOD.lowrankupdate!(F1, C)
+        @test full(sparse(F1)) ≈ AtA+C*C'
+        @test F1\ones(5) ≈ B
+        #Test in-place downdate
+        CHOLMOD.lowrankdowndate!(F1, C)
+        @test full(sparse(F1)) ≈ AtA
+        @test F1\ones(5) ≈ B0
+
+        @test C == Ctest    #Make sure C didn't change
+    end
+end
+
+@testset "Issue #22335" begin
+    A = speye(3)
+    @test LinAlg.issuccess(cholfact(A))
+    A[3, 3] = -1
+    F = cholfact(A)
+    @test !LinAlg.issuccess(F)
+    @test LinAlg.issuccess(ldltfact!(F, A))
+    A[3, 3] = 1
+    @test A[:, 3:-1:1]\ones(3) == [1, 1, 1]
+end
+
diff --git a/test/sparse/higherorderfns.jl b/test/sparse/higherorderfns.jl
index a8589f205ade6c..e0d613ffdfb72f 100644
--- a/test/sparse/higherorderfns.jl
+++ b/test/sparse/higherorderfns.jl
@@ -1,5 +1,5 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
-#
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
 # These tests cover the higher order functions specialized for sparse arrays defined in
 # base/sparse/higherorderfns.jl, particularly map[!]/broadcast[!] for SparseVectors and
 # SparseMatrixCSCs at present.
@@ -164,6 +164,7 @@ end
     mats = (sprand(N, M, p), sprand(N, 1, p), sprand(1, M, p), sprand(1, 1, 1.0), spzeros(1, 1))
     vecs = (sprand(N, p), sprand(1, 1.0), spzeros(1))
     tens = (mats..., vecs...)
+    fZ = Array(first(mats))
     for Xo in tens
         X = ndims(Xo) == 1 ? SparseVector{Float32,Int32}(Xo) : SparseMatrixCSC{Float32,Int32}(Xo)
         # use different types to check internal type stability via allocation tests below
@@ -182,17 +183,17 @@ end
                 @test_throws DimensionMismatch broadcast(+, spzeros((shapeX .- 1)...), Y)
             end
             # --> test broadcast! entry point / +-like zero-preserving op
-            fZ = broadcast(+, fX, fY); Z = sparse(fZ)
+            broadcast!(+, fZ, fX, fY); Z = sparse(fZ)
             broadcast!(+, Z, X, Y); Z = sparse(fZ) # warmup for @allocated
             @test (@allocated broadcast!(+, Z, X, Y)) == 0
             @test broadcast!(+, Z, X, Y) == sparse(broadcast!(+, fZ, fX, fY))
             # --> test broadcast! entry point / *-like zero-preserving op
-            fZ = broadcast(*, fX, fY); Z = sparse(fZ)
+            broadcast!(*, fZ, fX, fY); Z = sparse(fZ)
             broadcast!(*, Z, X, Y); Z = sparse(fZ) # warmup for @allocated
             @test (@allocated broadcast!(*, Z, X, Y)) == 0
             @test broadcast!(*, Z, X, Y) == sparse(broadcast!(*, fZ, fX, fY))
             # --> test broadcast! entry point / not zero-preserving op
-            fZ = broadcast(f, fX, fY); Z = sparse(fZ)
+            broadcast!(f, fZ, fX, fY); Z = sparse(fZ)
             broadcast!(f, Z, X, Y); Z = sparse(fZ) # warmup for @allocated
             @test (@allocated broadcast!(f, Z, X, Y)) == 0
             @test broadcast!(f, Z, X, Y) == sparse(broadcast!(f, fZ, fX, fY))
@@ -265,14 +266,24 @@ end
     end
 end
 
-
 @testset "sparse map/broadcast with result eltype not a concrete subtype of Number (#19561/#19589)" begin
-    intoneorfloatzero(x) = x != 0.0 ? Int(1) : Float64(x)
-    stringorfloatzero(x) = x != 0.0 ? "Hello" : Float64(x)
-    @test map(intoneorfloatzero, speye(4)) == sparse(map(intoneorfloatzero, eye(4)))
-    @test map(stringorfloatzero, speye(4)) == sparse(map(stringorfloatzero, eye(4)))
-    @test broadcast(intoneorfloatzero, speye(4)) == sparse(broadcast(intoneorfloatzero, eye(4)))
-    @test broadcast(stringorfloatzero, speye(4)) == sparse(broadcast(stringorfloatzero, eye(4)))
+    N = 4
+    A, fA = speye(N), eye(N)
+    B, fB = spzeros(1, N), zeros(1, N)
+    intorfloat_zeropres(xs...) = all(iszero, xs) ? zero(Float64) : Int(1)
+    stringorfloat_zeropres(xs...) = all(iszero, xs) ? zero(Float64) : "hello"
+    intorfloat_notzeropres(xs...) = all(iszero, xs) ? Int(1) : zero(Float64)
+    stringorfloat_notzeropres(xs...) = all(iszero, xs) ? "hello" : zero(Float64)
+    for fn in (intorfloat_zeropres, intorfloat_notzeropres,
+                stringorfloat_zeropres, stringorfloat_notzeropres)
+        @test map(fn, A) == sparse(map(fn, fA))
+        @test broadcast(fn, A) == sparse(broadcast(fn, fA))
+        @test broadcast(fn, A, B) == sparse(broadcast(fn, fA, fB))
+        @test broadcast(fn, B, A) == sparse(broadcast(fn, fB, fA))
+    end
+    for fn in (intorfloat_zeropres, stringorfloat_zeropres)
+        @test broadcast(fn, A, B, A) == sparse(broadcast(fn, fA, fB, fA))
+    end
 end
 
 @testset "broadcast[!] over combinations of scalars and sparse vectors/matrices" begin
@@ -364,7 +375,7 @@ end
     sparsearrays = (V, A)
     fV, fA = map(Array, sparsearrays)
     D = Diagonal(rand(N))
-    B = Bidiagonal(rand(N), rand(N - 1), true)
+    B = Bidiagonal(rand(N), rand(N - 1), :U)
     T = Tridiagonal(rand(N - 1), rand(N), rand(N - 1))
     S = SymTridiagonal(rand(N), rand(N - 1))
     structuredarrays = (D, B, T, S)
@@ -392,25 +403,47 @@ end
     densearrays = (C, M)
     fD, fB = Array(D), Array(B)
     for X in densearrays
-        @test (Q = broadcast(+, D, X); Q isa SparseMatrixCSC && Q == sparse(broadcast(+, fD, X)))
+        @test broadcast(+, D, X)::SparseMatrixCSC == sparse(broadcast(+, fD, X))
         @test broadcast!(+, Z, D, X) == sparse(broadcast(+, fD, X))
-        @test (Q = broadcast(*, s, B, X); Q isa SparseMatrixCSC && Q == sparse(broadcast(*, s, fB, X)))
+        @test broadcast(*, s, B, X)::SparseMatrixCSC == sparse(broadcast(*, s, fB, X))
         @test broadcast!(*, Z, s, B, X) == sparse(broadcast(*, s, fB, X))
-        @test (Q = broadcast(+, V, B, X); Q isa SparseMatrixCSC && Q == sparse(broadcast(+, fV, fB, X)))
+        @test broadcast(+, V, B, X)::SparseMatrixCSC == sparse(broadcast(+, fV, fB, X))
         @test broadcast!(+, Z, V, B, X) == sparse(broadcast(+, fV, fB, X))
-        @test (Q = broadcast(+, V, A, X); Q isa SparseMatrixCSC && Q == sparse(broadcast(+, fV, fA, X)))
+        @test broadcast(+, V, A, X)::SparseMatrixCSC == sparse(broadcast(+, fV, fA, X))
         @test broadcast!(+, Z, V, A, X) == sparse(broadcast(+, fV, fA, X))
-        @test (Q = broadcast(*, s, V, A, X); Q isa SparseMatrixCSC && Q == sparse(broadcast(*, s, fV, fA, X)))
+        @test broadcast(*, s, V, A, X)::SparseMatrixCSC == sparse(broadcast(*, s, fV, fA, X))
         @test broadcast!(*, Z, s, V, A, X) == sparse(broadcast(*, s, fV, fA, X))
+        # Issue #20954 combinations of sparse arrays and RowVectors
+        @test broadcast(+, A, X')::SparseMatrixCSC == sparse(broadcast(+, fA, X'))
+        @test broadcast(*, V, X')::SparseMatrixCSC == sparse(broadcast(*, fV, X'))
     end
 end
 
+@testset "broadcast! where the destination is a structured matrix" begin
+    # Where broadcast!'s destination is a structured matrix, broadcast! should fall back
+    # to the generic AbstractArray broadcast! code (at least for now).
+    N, p = 5, 0.4
+    A = sprand(N, N, p)
+    sA = A + transpose(A)
+    D = Diagonal(rand(N))
+    B = Bidiagonal(rand(N), rand(N - 1), :U)
+    T = Tridiagonal(rand(N - 1), rand(N), rand(N - 1))
+    @test broadcast!(sin, copy(D), D) == Diagonal(sin.(D))
+    @test broadcast!(sin, copy(B), B) == Bidiagonal(sin.(B), :U)
+    @test broadcast!(sin, copy(T), T) == Tridiagonal(sin.(T))
+    @test broadcast!(*, copy(D), D, A) == Diagonal(broadcast(*, D, A))
+    @test broadcast!(*, copy(B), B, A) == Bidiagonal(broadcast(*, B, A), :U)
+    @test broadcast!(*, copy(T), T, A) == Tridiagonal(broadcast(*, T, A))
+    # SymTridiagonal (and similar symmetric matrix types) do not support setindex!
+    # off the diagonal, and so cannot serve as a destination for broadcast!
+end
+
 @testset "map[!] over combinations of sparse and structured matrices" begin
     N, p = 10, 0.4
     A = sprand(N, N, p)
     Z, fA = copy(A), Array(A)
     D = Diagonal(rand(N))
-    B = Bidiagonal(rand(N), rand(N - 1), true)
+    B = Bidiagonal(rand(N), rand(N - 1), :U)
     T = Tridiagonal(rand(N - 1), rand(N), rand(N - 1))
     S = SymTridiagonal(rand(N), rand(N - 1))
     structuredarrays = (D, B, T, S)
diff --git a/test/sparse/sparse.jl b/test/sparse/sparse.jl
index 42b62dab123130..85e12fbf47e8e2 100644
--- a/test/sparse/sparse.jl
+++ b/test/sparse/sparse.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 @testset "issparse" begin
     @test issparse(sparse(ones(5,5)))
@@ -45,14 +45,18 @@ do33 = ones(3)
 end
 
 @testset "concatenation tests" begin
+    sp33 = speye(3, 3)
+
     @testset "horizontal concatenation" begin
         @test all([se33 se33] == sparse([1, 2, 3, 1, 2, 3], [1, 2, 3, 4, 5, 6], ones(6)))
+        @test length(([sp33 0I]).nzval) == 3
     end
 
     @testset "vertical concatenation" begin
         @test all([se33; se33] == sparse([1, 4, 2, 5, 3, 6], [1, 1, 2, 2, 3, 3], ones(6)))
         se33_32bit = convert(SparseMatrixCSC{Float32,Int32}, se33)
         @test all([se33; se33_32bit] == sparse([1, 4, 2, 5, 3, 6], [1, 1, 2, 2, 3, 3], ones(6)))
+        @test length(([sp33; 0I]).nzval) == 3
     end
 
     se44 = speye(4)
@@ -62,6 +66,7 @@ end
     se77 = speye(7)
     @testset "h+v concatenation" begin
         @test all([se44 sz42 sz41; sz34 se33] == se77)
+        @test length(([sp33 0I; 1I 0I]).nzval) == 6
     end
 
     @testset "blkdiag concatenation" begin
@@ -221,6 +226,14 @@ end
         @test (maximum(abs.(a'\b - Array(a')\b)) < 1000*eps())
         @test (maximum(abs.(a.'\b - Array(a.')\b)) < 1000*eps())
 
+        # UpperTriangular/LowerTriangular solve
+        a = UpperTriangular(speye(5) + triu(0.1*sprandn(5, 5, 0.2)))
+        b = sprandn(5, 5, 0.2)
+        @test (maximum(abs.(a\b - Array(a)\Array(b))) < 1000*eps())
+        a = LowerTriangular(speye(5) + tril(0.1*sprandn(5, 5, 0.2)))
+        b = sprandn(5, 5, 0.2)
+        @test (maximum(abs.(a\b - Array(a)\Array(b))) < 1000*eps())
+
         a = spdiagm(randn(5)) + im*spdiagm(randn(5))
         b = randn(5,3)
         @test (maximum(abs.(a*b - Array(a)*b)) < 100*eps())
@@ -283,6 +296,17 @@ b = randn(7)
     @test scale!(sC, 0.5, sA) == scale!(sC, sA, 0.5)
 end
 
+@testset "inverse scale!" begin
+    bi = inv.(b)
+    dAt = transpose(dA)
+    sAt = transpose(sA)
+    @test scale!(copy(dAt), bi) ≈ Base.LinAlg.A_rdiv_B!(copy(sAt), Diagonal(b))
+    @test scale!(copy(dAt), bi) ≈ Base.LinAlg.A_rdiv_Bt!(copy(sAt), Diagonal(b))
+    @test scale!(copy(dAt), conj(bi)) ≈ Base.LinAlg.A_rdiv_Bc!(copy(sAt), Diagonal(b))
+    @test_throws DimensionMismatch Base.LinAlg.A_rdiv_B!(copy(sAt), Diagonal(ones(length(b) + 1)))
+    @test_throws LinAlg.SingularException Base.LinAlg.A_rdiv_B!(copy(sAt), Diagonal(zeros(length(b))))
+end
+
 @testset "copy!" begin
     A = sprand(5, 5, 0.2)
     B = sprand(5, 5, 0.2)
@@ -533,10 +557,12 @@ end
     @test tan.(Afull) == Array(tan.(A)) # should be redundant with sin test
     @test ceil.(Afull) == Array(ceil.(A))
     @test floor.(Afull) == Array(floor.(A)) # should be redundant with ceil test
-    @test real.(Afull) == Array(real.(A))
-    @test imag.(Afull) == Array(imag.(A))
-    @test real.(Cfull) == Array(real.(C))
-    @test imag.(Cfull) == Array(imag.(C))
+    @test real.(Afull) == Array(real.(A)) == Array(real(A))
+    @test imag.(Afull) == Array(imag.(A)) == Array(imag(A))
+    @test conj.(Afull) == Array(conj.(A)) == Array(conj(A))
+    @test real.(Cfull) == Array(real.(C)) == Array(real(C))
+    @test imag.(Cfull) == Array(imag.(C)) == Array(imag(C))
+    @test conj.(Cfull) == Array(conj.(C)) == Array(conj(C))
     # Test representatives of [unary functions that map zeros to zeros and nonzeros to nonzeros]
     @test expm1.(Afull) == Array(expm1.(A))
     @test abs.(Afull) == Array(abs.(A))
@@ -554,12 +580,19 @@ end
         I = rand(T[1:100;], 2, 2)
         D = R + I*im
         S = sparse(D)
-        @test R == real.(S)
-        @test I == imag.(S)
-        @test real.(sparse(R)) == R
-        @test nnz(imag.(sparse(R))) == 0
+        spR = sparse(R)
+
+        @test R == real.(S) == real(S)
+        @test I == imag.(S) == imag(S)
+        @test conj(full(S)) == conj.(S) == conj(S)
+        @test real.(spR) == R
+        @test nnz(imag.(spR)) == nnz(imag(spR)) == 0
         @test abs.(S) == abs.(D)
         @test abs2.(S) == abs2.(D)
+
+        # test aliasing of real and conj of real valued matrix
+        @test real(spR) === spR
+        @test conj(spR) === spR
     end
 end
 
@@ -998,7 +1031,7 @@ end
     @test size(rotl90(a)) == (5,3)
 end
 
-function test_getindex_algs{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, I::AbstractVector, J::AbstractVector, alg::Int)
+function test_getindex_algs(A::SparseMatrixCSC{Tv,Ti}, I::AbstractVector, J::AbstractVector, alg::Int) where {Tv,Ti}
     # Sorted vectors for indexing rows.
     # Similar to getindex_general but without the transpose trick.
     (m, n) = size(A)
@@ -1159,10 +1192,10 @@ end
     T = SymTridiagonal(randn(5),rand(4))
     S = sparse(T)
     @test norm(Array(T) - Array(S)) == 0.0
-    B = Bidiagonal(randn(5),randn(4),true)
+    B = Bidiagonal(randn(5),randn(4),:U)
     S = sparse(B)
     @test norm(Array(B) - Array(S)) == 0.0
-    B = Bidiagonal(randn(5),randn(4),false)
+    B = Bidiagonal(randn(5),randn(4),:L)
     S = sparse(B)
     @test norm(Array(B) - Array(S)) == 0.0
 end
@@ -1739,6 +1772,45 @@ end
     @test String(take!(io)) == "1×1 SparseMatrixCSC{Float64,Int64} with 1 stored entry:\n  [1, 1]  =  1.0"
     show(io, MIME"text/plain"(), spzeros(Float32, Int64, 2, 2))
     @test String(take!(io)) == "2×2 SparseMatrixCSC{Float32,Int64} with 0 stored entries"
+
+    ioc = IOContext(io, displaysize = (5, 80), limit = true)
+    show(ioc, MIME"text/plain"(), sparse(Int64[1], Int64[1], [1.0]))
+    @test String(take!(io)) == "1×1 SparseMatrixCSC{Float64,Int64} with 1 stored entry:\n  [1, 1]  =  1.0"
+    show(ioc, MIME"text/plain"(), sparse(Int64[1, 1], Int64[1, 2], [1.0, 2.0]))
+    @test String(take!(io)) == "1×2 SparseMatrixCSC{Float64,Int64} with 2 stored entries:\n  ⋮"
+
+    # even number of rows
+    ioc = IOContext(io, displaysize = (8, 80), limit = true)
+    show(ioc, MIME"text/plain"(), sparse(Int64[1,2,3,4], Int64[1,1,2,2], [1.0,2.0,3.0,4.0]))
+    @test String(take!(io)) == string("4×2 SparseMatrixCSC{Float64,Int64} with 4 stored entries:\n  [1, 1]",
+                                      "  =  1.0\n  [2, 1]  =  2.0\n  [3, 2]  =  3.0\n  [4, 2]  =  4.0")
+
+    show(ioc, MIME"text/plain"(), sparse(Int64[1,2,3,4,5], Int64[1,1,2,2,3], [1.0,2.0,3.0,4.0,5.0]))
+    @test String(take!(io)) ==  string("5×3 SparseMatrixCSC{Float64,Int64} with 5 stored entries:\n  [1, 1]",
+                                       "  =  1.0\n  ⋮\n  [5, 3]  =  5.0")
+
+    show(ioc, MIME"text/plain"(), sparse(ones(5,3)))
+    @test String(take!(io)) ==  string("5×3 SparseMatrixCSC{Float64,$Int} with 15 stored entries:\n  [1, 1]",
+                                       "  =  1.0\n  ⋮\n  [5, 3]  =  1.0")
+
+    # odd number of rows
+    ioc = IOContext(io, displaysize = (9, 80), limit = true)
+    show(ioc, MIME"text/plain"(), sparse(Int64[1,2,3,4,5], Int64[1,1,2,2,3], [1.0,2.0,3.0,4.0,5.0]))
+    @test String(take!(io)) == string("5×3 SparseMatrixCSC{Float64,Int64} with 5 stored entries:\n  [1, 1]",
+                                      "  =  1.0\n  [2, 1]  =  2.0\n  [3, 2]  =  3.0\n  [4, 2]  =  4.0\n  [5, 3]  =  5.0")
+
+    show(ioc, MIME"text/plain"(), sparse(Int64[1,2,3,4,5,6], Int64[1,1,2,2,3,3], [1.0,2.0,3.0,4.0,5.0,6.0]))
+    @test String(take!(io)) ==  string("6×3 SparseMatrixCSC{Float64,Int64} with 6 stored entries:\n  [1, 1]",
+                                       "  =  1.0\n  [2, 1]  =  2.0\n  ⋮\n  [5, 3]  =  5.0\n  [6, 3]  =  6.0")
+
+    show(ioc, MIME"text/plain"(), sparse(ones(6,3)))
+    @test String(take!(io)) ==  string("6×3 SparseMatrixCSC{Float64,$Int} with 18 stored entries:\n  [1, 1]",
+                                       "  =  1.0\n  [2, 1]  =  1.0\n  ⋮\n  [5, 3]  =  1.0\n  [6, 3]  =  1.0")
+
+    ioc = IOContext(io, displaysize = (9, 80))
+    show(ioc, MIME"text/plain"(), sparse(Int64[1,2,3,4,5,6], Int64[1,1,2,2,3,3], [1.0,2.0,3.0,4.0,5.0,6.0]))
+    @test String(take!(io)) ==  string("6×3 SparseMatrixCSC{Float64,Int64} with 6 stored entries:\n  [1, 1]  =  1.0\n",
+        "  [2, 1]  =  2.0\n  [3, 2]  =  3.0\n  [4, 2]  =  4.0\n  [5, 3]  =  5.0\n  [6, 3]  =  6.0")
 end
 
 @testset "similar aliasing" begin
@@ -1762,3 +1834,12 @@ end
     @test nnz(A) == n
     @test A      == eye(n)
 end
+
+@testset "reverse search direction if step < 0 #21986" begin
+    srand(1234)
+    A = sprand(5, 5, 1/5)
+    A = max.(A, A')
+    A = spones(A)
+    B = A[5:-1:1, 5:-1:1]
+    @test issymmetric(B)
+end
diff --git a/test/sparse/sparsevector.jl b/test/sparse/sparsevector.jl
index c79a556e59c66b..04c4bcaf17e561 100644
--- a/test/sparse/sparsevector.jl
+++ b/test/sparse/sparsevector.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ### Data
 
@@ -159,10 +159,10 @@ let xr = sprand(Bool, 1000, 0.9)
     @test all(nonzeros(xr))
 end
 
-let r1 = MersenneTwister(), r2 = MersenneTwister()
+let r1 = MersenneTwister(0), r2 = MersenneTwister(0)
     @test sprand(r1, 100, .9) == sprand(r2, 100, .9)
     @test sprandn(r1, 100, .9) == sprandn(r2, 100, .9)
-    @test sprand(r1, Bool, 100, .9, ) == sprand(r2,  Bool, 100, .9)
+    @test sprand(r1, Bool, 100, .9) == sprand(r2,  Bool, 100, .9)
 end
 
 ### Element access
@@ -474,7 +474,12 @@ let N = 4
     @test issparse(cat((1,2), densemat, diagmat, spmat, densevec, spvec))
     @test issparse(cat((1,2), spvec, diagmat, densevec, spmat, densemat))
 end
-
+@testset "vertical concatenation of SparseVectors with different el- and ind-type (#22225)" begin
+    spv6464 = SparseVector(0, Int64[], Int64[])
+    @test isa(vcat(spv6464, SparseVector(0, Int64[], Int32[])), SparseVector{Int64,Int64})
+    @test isa(vcat(spv6464, SparseVector(0, Int32[], Int64[])), SparseVector{Int64,Int64})
+    @test isa(vcat(spv6464, SparseVector(0, Int32[], Int32[])), SparseVector{Int64,Int64})
+end
 
 ## sparsemat: combinations with sparse matrix
 
@@ -637,19 +642,21 @@ let x = spv_x1, x2 = spv_x2
     @test exact_equal(complex.(x2, x),
         SparseVector(8, [1,2,5,6,7], [3.25+0.0im, 4.0+1.25im, -0.75im, -5.5+3.5im, -6.0+0.0im]))
 
-    # real & imag
+    # real, imag and conj
 
     @test real(x) === x
     @test exact_equal(imag(x), spzeros(Float64, length(x)))
+    @test conj(x) === x
 
     xcp = complex.(x, x2)
     @test exact_equal(real(xcp), x)
     @test exact_equal(imag(xcp), x2)
+    @test exact_equal(conj(xcp), complex.(x, -x2))
 end
 
 ### Zero-preserving math functions: sparse -> sparse
 
-function check_nz2z_z2z{T}(f::Function, x::SparseVector{T}, xf::Vector{T})
+function check_nz2z_z2z(f::Function, x::SparseVector{T}, xf::Vector{T}) where T
     R = typeof(f(zero(T)))
     r = f(x)
     isa(r, AbstractSparseVector) || error("$f(x) is not a sparse vector.")
@@ -671,7 +678,7 @@ end
 
 ### Non-zero-preserving math functions: sparse -> dense
 
-function check_z2nz{T}(f::Function, x::SparseVector{T}, xf::Vector{T})
+function check_z2nz(f::Function, x::SparseVector{T}, xf::Vector{T}) where T
     R = typeof(f(zero(T)))
     r = f(x)
     isa(r, Vector) || error("$f(x) is not a dense vector.")
@@ -1080,13 +1087,13 @@ s14046 = sprand(5, 1.0)
 @test 2*s14046 == s14046 + s14046
 
 # Issue 14589
-#test vectors with no zero elements
+# 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
+# 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
+# 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
@@ -1094,7 +1101,7 @@ x = sparsevec(1:7, [3., 2., -1., 1., -2., -3., 3.], 15)
 @test collect(sort(x, by=sign)) == sort(collect(x), by=sign)
 @test collect(sort(x, by=inv)) == sort(collect(x), by=inv)
 
-#fill!
+# fill!
 for Tv in [Float32, Float64, Int64, Int32, Complex128]
     for Ti in [Int16, Int32, Int64, BigInt]
         sptypes = (SparseMatrixCSC{Tv, Ti}, SparseVector{Tv, Ti})
@@ -1124,7 +1131,7 @@ end
 @test issparse([sprand(10,.1); rand(10)])
 
 
-type t20488 end
+mutable struct t20488 end
 
 @testset "similar" begin
     x = sparsevec(rand(3) .+ 0.1)
diff --git a/test/sparse/spqr.jl b/test/sparse/spqr.jl
index 2b137d028c28c6..0e17f0be2a0650 100644
--- a/test/sparse/spqr.jl
+++ b/test/sparse/spqr.jl
@@ -1,19 +1,52 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base.SparseArrays.SPQR
 using Base.SparseArrays.CHOLMOD
 
-let
+@testset "Sparse QR" begin
 m, n = 100, 10
 nn = 100
 
-for eltyA in (Float64, Complex{Float64})
-    for eltyB in (Int, Float64, Complex{Float64})
-        if eltyA <: Real
-            A = sparse([1:n; rand(1:m, nn - n)], [1:n; rand(1:n, nn - n)], randn(nn), m, n)
-        else
-            A = sparse([1:n; rand(1:m, nn - n)], [1:n; rand(1:n, nn - n)], complex.(randn(nn), randn(nn)), m, n)
-        end
+@test size(qrfact(sprandn(m, n, 0.1))[:Q]) == (m, m)
+
+@testset "element type of A: $eltyA" for eltyA in (Float64, Complex{Float64})
+    if eltyA <: Real
+        A = sparse([1:n; rand(1:m, nn - n)], [1:n; rand(1:n, nn - n)], randn(nn), m, n)
+    else
+        A = sparse([1:n; rand(1:m, nn - n)], [1:n; rand(1:n, nn - n)], complex.(randn(nn), randn(nn)), m, n)
+    end
+
+    F = qrfact(A)
+    @test size(F) == (m,n)
+    @test size(F, 1) == m
+    @test size(F, 2) == n
+    @test size(F, 3) == 1
+    @test_throws ArgumentError size(F, 0)
+
+    @testset "getindex" begin
+        @test istriu(F[:R])
+        @test isperm(F[:pcol])
+        @test isperm(F[:prow])
+        @test_throws KeyError F[:T]
+    end
+
+    @testset "apply Q" begin
+        Q = F[:Q]
+        @test Q'*(Q*eye(m)) ≈ eye(m)
+        @test (eye(m)*Q)*Q' ≈ eye(m)
+
+        # test that Q'Pl*A*Pr = R
+        R0 = Q'*full(A[F[:prow], F[:pcol]])
+        @test R0[1:n, :] ≈ F[:R]
+        @test norm(R0[n + 1:end, :], 1) < 1e-12
+
+        @test_throws DimensionMismatch A_mul_B!(Q, eye(m + 1))
+        @test_throws DimensionMismatch Ac_mul_B!(Q, eye(m + 1))
+        @test_throws DimensionMismatch A_mul_B!(eye(m + 1), Q)
+        @test_throws DimensionMismatch A_mul_Bc!(eye(m + 1), Q)
+    end
+
+    @testset "element type of B: $eltyB" for eltyB in (Int, Float64, Complex{Float64})
         if eltyB == Int
             B = rand(1:10, m, 2)
         elseif eltyB <: Real
@@ -27,34 +60,21 @@ for eltyA in (Float64, Complex{Float64})
         @test A\B ≈ Array(A)\B
         @test_throws DimensionMismatch A\B[1:m-1,:]
         @test A[1:9,:]*(A[1:9,:]\ones(eltyB, 9)) ≈ ones(9) # Underdetermined system
-
-        if eltyA == eltyB # promotions not defined for unexported methods
-            @test qrfact(sparse(eye(eltyA, 5)))\ones(eltyA, 5) == ones(5)
-            @test_throws ArgumentError SPQR.factorize(SPQR.ORDERING_DEFAULT, SPQR.DEFAULT_TOL, CHOLMOD.Sparse(sparse(eye(eltyA, 5))))
-            @test_throws ArgumentError SPQR.Factorization(1, 1, convert(Ptr{SPQR.C_Factorization{eltyA}}, C_NULL))
-            F = qrfact(A)
-            @test size(F) == (m,n)
-            @test size(F, 1) == m
-            @test size(F, 2) == n
-            @test size(F, 3) == 1
-            @test_throws ArgumentError size(F, 0)
-
-            # low level wrappers
-            @test_throws DimensionMismatch SPQR.solve(SPQR.RX_EQUALS_B, F, CHOLMOD.Dense(B'))
-            @test_throws DimensionMismatch SPQR.solve(SPQR.RTX_EQUALS_B, F, CHOLMOD.Dense(B))
-            @test_throws DimensionMismatch SPQR.qmult(SPQR.QX, F, CHOLMOD.Dense(B'))
-            @test_throws DimensionMismatch SPQR.qmult(SPQR.XQ, F, CHOLMOD.Dense(B))
-            @test A\B ≈ SPQR.backslash(SPQR.ORDERING_DEFAULT, SPQR.DEFAULT_TOL, CHOLMOD.Sparse(A), CHOLMOD.Dense(B))
-            @test_throws DimensionMismatch SPQR.backslash(SPQR.ORDERING_DEFAULT, SPQR.DEFAULT_TOL, CHOLMOD.Sparse(A), CHOLMOD.Dense(B[1:m-1,:]))
-        end
     end
+
+    # Make sure that conversion to Sparse doesn't use SuiteSparse's symmetric flag
+    @test qrfact(sparse(eye(eltyA, 5)))\ones(eltyA, 5) == ones(5)
 end
 
-# Issue 14134
-F = qrfact(sprandn(10,5,0.5))
-b = IOBuffer()
-serialize(b, F)
-seekstart(b)
-@test_throws ArgumentError deserialize(b)\ones(10)
+@testset "basic solution of rank deficient ls" begin
+    A = sprandn(m, 5, 0.9)*sprandn(5, n, 0.9)
+    b = randn(m)
+    xs = A\b
+    xd = full(A)\b
+
+    # check that basic solution has more zeros
+    @test countnz(xs) < countnz(xd)
+    @test A*xs ≈ A*xd
+end
 
 end
diff --git a/test/sparse/umfpack.jl b/test/sparse/umfpack.jl
index b1bfd48d64be7b..a99dac1c92413c 100644
--- a/test/sparse/umfpack.jl
+++ b/test/sparse/umfpack.jl
@@ -1,156 +1,169 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
-
-se33 = speye(3)
-do33 = ones(3)
-@test isequal(se33 \ do33, do33)
-
-# based on deps/Suitesparse-4.0.2/UMFPACK/Demo/umfpack_di_demo.c
-
-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.uniontypes(Base.SparseArrays.UMFPACK.UMFITypes)
-        A = convert(SparseMatrixCSC{Tv,Ti}, A0)
-        lua = lufact(A)
-        @test nnz(lua) == 18
-        @test_throws KeyError lua[:Z]
-        L,U,p,q,Rs = lua[:(:)]
-        @test (Diagonal(Rs) * A)[p,q] ≈ L * U
-
-        det(lua) ≈ det(Array(A))
-
-        b = [8., 45., -3., 3., 19.]
-        x = lua\b
-        @test x ≈ float([1:5;])
-
-        @test norm(A*x-b,1) < eps(1e4)
-        z = complex.(b,zeros(b))
-        x = Base.SparseArrays.A_ldiv_B!(lua, z)
-        @test x ≈ float([1:5;])
-        @test z === x
-        y = similar(z)
-        A_ldiv_B!(y, lua, complex.(b,zeros(b)))
-        @test y ≈ x
-
-        @test norm(A*x-b,1) < eps(1e4)
-
-        b = [8., 20., 13., 6., 17.]
-        x = lua'\b
-        @test x ≈ float([1:5;])
-
-        @test norm(A'*x-b,1) < eps(1e4)
-        z = complex.(b,zeros(b))
-        x = Base.SparseArrays.Ac_ldiv_B!(lua, z)
-        @test x ≈ float([1:5;])
-        @test x === z
-        y = similar(x)
-        Base.SparseArrays.Ac_ldiv_B!(y, lua, complex.(b,zeros(b)))
-        @test y ≈ x
-
-        @test norm(A'*x-b,1) < eps(1e4)
-        x = lua.'\b
-        @test x ≈ float([1:5;])
-
-        @test norm(A.'*x-b,1) < eps(1e4)
-        x = Base.SparseArrays.At_ldiv_B!(lua,complex.(b,zeros(b)))
-        @test x ≈ float([1:5;])
-        y = similar(x)
-        Base.SparseArrays.At_ldiv_B!(y, lua,complex.(b,zeros(b)))
-        @test y ≈ x
-
-        @test norm(A.'*x-b,1) < eps(1e4)
-
-        # Element promotion and type inference
-        @inferred lua\ones(Int, size(A, 2))
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
+@testset "UMFPACK wrappers" begin
+    se33 = speye(3)
+    do33 = ones(3)
+    @test isequal(se33 \ do33, do33)
+
+    # based on deps/Suitesparse-4.0.2/UMFPACK/Demo/umfpack_di_demo.c
+
+    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)
+
+    @testset "Core functionality for $Tv elements" for Tv in (Float64, Complex128)
+        # We might be able to support two index sizes one day
+        for Ti in Base.uniontypes(Base.SparseArrays.UMFPACK.UMFITypes)
+            A = convert(SparseMatrixCSC{Tv,Ti}, A0)
+            lua = lufact(A)
+            @test nnz(lua) == 18
+            @test_throws KeyError lua[:Z]
+            L,U,p,q,Rs = lua[:(:)]
+            @test (Diagonal(Rs) * A)[p,q] ≈ L * U
+
+            det(lua) ≈ det(Array(A))
+
+            b = [8., 45., -3., 3., 19.]
+            x = lua\b
+            @test x ≈ float([1:5;])
+
+            @test A*x ≈ b
+            z = complex.(b,zeros(b))
+            x = Base.SparseArrays.A_ldiv_B!(lua, z)
+            @test x ≈ float([1:5;])
+            @test z === x
+            y = similar(z)
+            A_ldiv_B!(y, lua, complex.(b,zeros(b)))
+            @test y ≈ x
+
+            @test A*x ≈ b
+
+            b = [8., 20., 13., 6., 17.]
+            x = lua'\b
+            @test x ≈ float([1:5;])
+
+            @test A'*x ≈ b
+            z = complex.(b,zeros(b))
+            x = Base.SparseArrays.Ac_ldiv_B!(lua, z)
+            @test x ≈ float([1:5;])
+            @test x === z
+            y = similar(x)
+            Base.SparseArrays.Ac_ldiv_B!(y, lua, complex.(b,zeros(b)))
+            @test y ≈ x
+
+            @test A'*x ≈ b
+            x = lua.'\b
+            @test x ≈ float([1:5;])
+
+            @test A.'*x ≈ b
+            x = Base.SparseArrays.At_ldiv_B!(lua,complex.(b,zeros(b)))
+            @test x ≈ float([1:5;])
+            y = similar(x)
+            Base.SparseArrays.At_ldiv_B!(y, lua,complex.(b,zeros(b)))
+            @test y ≈ x
+
+            @test A.'*x ≈ b
+
+            # Element promotion and type inference
+            @inferred lua\ones(Int, size(A, 2))
+        end
     end
-end
 
-Ac0 = complex.(A0,A0)
-for Ti in Base.uniontypes(Base.SparseArrays.UMFPACK.UMFITypes)
-    Ac = convert(SparseMatrixCSC{Complex128,Ti}, Ac0)
-    lua = lufact(Ac)
-    L,U,p,q,Rs = lua[:(:)]
-    @test (Diagonal(Rs) * Ac)[p,q] ≈ L * U
-end
+    @testset "More tests for complex cases" begin
+        Ac0 = complex.(A0,A0)
+        for Ti in Base.uniontypes(Base.SparseArrays.UMFPACK.UMFITypes)
+            Ac = convert(SparseMatrixCSC{Complex128,Ti}, Ac0)
+            x  = complex.(ones(size(Ac, 1)), ones(size(Ac,1)))
+            lua = lufact(Ac)
+            L,U,p,q,Rs = lua[:(:)]
+            @test (Diagonal(Rs) * Ac)[p,q] ≈ L * U
+            b  = Ac*x
+            @test Ac\b ≈ x
+            b  = Ac'*x
+            @test Ac'\b ≈ x
+            b  = Ac.'*x
+            @test Ac.'\b ≈ x
+        end
+    end
 
-for elty in (Float64, Complex128)
-    for (m, n) in ((10,5), (5, 10))
-        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 (Diagonal(Rs) * A)[p,q] ≈ L * U
+    @testset "Rectangular cases" for elty in (Float64, Complex128)
+        for (m, n) in ((10,5), (5, 10))
+            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 (Diagonal(Rs) * A)[p,q] ≈ L * U
+        end
     end
-end
 
-#4523 - complex sparse \
-x = speye(2) + im * speye(2)
-@test (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
+    @testset "Issue #4523 - complex sparse \\" begin
+        x = speye(2) + im * speye(2)
+        @test (x*(lufact(x) \ ones(2))) ≈ ones(2)
 
-for T in (BigFloat, Complex{BigFloat})
-    @test_throws ArgumentError lufact(sparse(ones(T, 1, 1)))
-end
+        @test det(sparse([1,3,3,1], [1,1,3,3], [1,1,1,1])) == 0
+    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
-    @test_throws ArgumentError size(F,-1)
-end
+    @testset "UMFPACK_ERROR_n_nonpositive" begin
+        @test_throws ArgumentError lufact(sparse(Int[], Int[], Float64[], 5, 0))
+    end
 
-let
-    a = rand(5)
-    @test_throws ArgumentError Base.SparseArrays.UMFPACK.solve!(a, lufact(speye(5,5)), a, Base.SparseArrays.UMFPACK.UMFPACK_A)
-    aa = complex(a)
-    @test_throws ArgumentError Base.SparseArrays.UMFPACK.solve!(aa, lufact(complex(speye(5,5))), aa, Base.SparseArrays.UMFPACK.UMFPACK_A)
-end
+    @testset "Issue #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
 
-#18246,18244-lufact sparse pivot
-let A = speye(4)
-    A[1:2,1:2] = [-.01 -200; 200 .001]
-    F = lufact(A)
-    @test F[:p] == [3 ; 4 ; 2 ; 1]
-end
+    @testset "BigFloat not supported" for T in (BigFloat, Complex{BigFloat})
+        @test_throws ArgumentError lufact(sparse(ones(T, 1, 1)))
+    end
+
+    @testset "size(::UmfpackLU)" begin
+        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
+        @test_throws ArgumentError size(F,-1)
+    end
+
+    @testset "Test aliasing" begin
+        a = rand(5)
+        @test_throws ArgumentError Base.SparseArrays.UMFPACK.solve!(a, lufact(speye(5,5)), a, Base.SparseArrays.UMFPACK.UMFPACK_A)
+        aa = complex(a)
+        @test_throws ArgumentError Base.SparseArrays.UMFPACK.solve!(aa, lufact(complex(speye(5,5))), aa, Base.SparseArrays.UMFPACK.UMFPACK_A)
+    end
+
+    @testset "Issues #18246,18244 - lufact sparse pivot" begin
+        A = speye(4)
+        A[1:2,1:2] = [-.01 -200; 200 .001]
+        F = lufact(A)
+        @test F[:p] == [3 ; 4 ; 2 ; 1]
+    end
+
+    @testset "Test that A[c|t]_ldiv_B!{T<:Complex}(X::StridedMatrix{T}, lu::UmfpackLU{Float64}, B::StridedMatrix{T}) works as expected." begin
+        N = 10
+        p = 0.5
+        A = N*speye(N) + sprand(N, N, p)
+        X = zeros(Complex{Float64}, N, N)
+        B = complex.(rand(N, N), rand(N, N))
+        luA, lufA = lufact(A), lufact(Array(A))
+        @test A_ldiv_B!(copy(X), luA, B) ≈ A_ldiv_B!(copy(X), lufA, B)
+        @test At_ldiv_B!(copy(X), luA, B) ≈ At_ldiv_B!(copy(X), lufA, B)
+        @test Ac_ldiv_B!(copy(X), luA, B) ≈ Ac_ldiv_B!(copy(X), lufA, B)
+    end
 
-# Test that A[c|t]_ldiv_B!{T<:Complex}(X::StridedMatrix{T}, lu::UmfpackLU{Float64},
-# B::StridedMatrix{T}) works as expected.
-let N = 10, p = 0.5
-    A = N*speye(N) + sprand(N, N, p)
-    X = zeros(Complex{Float64}, N, N)
-    B = complex.(rand(N, N), rand(N, N))
-    luA, lufA = lufact(A), lufact(Array(A))
-    @test A_ldiv_B!(copy(X), luA, B) ≈ A_ldiv_B!(copy(X), lufA, B)
-    @test At_ldiv_B!(copy(X), luA, B) ≈ At_ldiv_B!(copy(X), lufA, B)
-    @test Ac_ldiv_B!(copy(X), luA, B) ≈ Ac_ldiv_B!(copy(X), lufA, B)
 end
diff --git a/test/spawn.jl b/test/spawn.jl
index 8b7582b191ad06..f5345610d4bcac 100644
--- a/test/spawn.jl
+++ b/test/spawn.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ###################################
 # Cross Platform tests for spawn. #
@@ -16,7 +16,7 @@ catcmd = `cat`
 shcmd = `sh`
 sleepcmd = `sleep`
 lscmd = `ls`
-if is_windows()
+if Sys.iswindows()
     try # use busybox-w32 on windows
         success(`busybox`)
         yescmd = `busybox yes`
@@ -34,19 +34,19 @@ end
 
 #### Examples used in the manual ####
 
-@test readstring(`$echocmd hello \| sort`) == "hello | sort\n"
-@test readstring(pipeline(`$echocmd hello`, sortcmd)) == "hello\n"
+@test read(`$echocmd hello \| sort`, String) == "hello | sort\n"
+@test read(pipeline(`$echocmd hello`, sortcmd), String) == "hello\n"
 @test length(spawn(pipeline(`$echocmd hello`, sortcmd)).processes) == 2
 
-out = readstring(`$echocmd hello` & `$echocmd world`)
+out = read(`$echocmd hello` & `$echocmd world`, String)
 @test search(out,"world") != 0:-1
 @test search(out,"hello") != 0:-1
-@test readstring(pipeline(`$echocmd hello` & `$echocmd world`, sortcmd)) == "hello\nworld\n"
+@test read(pipeline(`$echocmd hello` & `$echocmd world`, sortcmd), String) == "hello\nworld\n"
 
 @test (run(`$printfcmd "       \033[34m[stdio passthrough ok]\033[0m\n"`); true)
 
 # Test for SIGPIPE being treated as normal termination (throws an error if broken)
-is_unix() && run(pipeline(yescmd, `head`, DevNull))
+Sys.isunix() && run(pipeline(yescmd, `head`, DevNull))
 
 begin
     a = Base.Condition()
@@ -65,7 +65,7 @@ if valgrind_off
     @test_throws Base.UVError run(`foo_is_not_a_valid_command`)
 end
 
-if is_unix()
+if Sys.isunix()
     prefixer(prefix, sleep) = `sh -c "while IFS= read REPLY; do echo '$prefix ' \$REPLY; sleep $sleep; done"`
     @test success(pipeline(`sh -c "for i in 1 2 3 4 5 6 7 8 9 10; do echo \$i; sleep 0.1; done"`,
                        prefixer("A", 0.2) & prefixer("B", 0.2)))
@@ -87,20 +87,20 @@ end
 # STDIN Redirection
 let file = tempname()
     run(pipeline(`$echocmd hello world`, file))
-    @test readstring(pipeline(file, catcmd)) == "hello world\n"
-    @test open(readstring, pipeline(file, catcmd), "r") == "hello world\n"
+    @test read(pipeline(file, catcmd), String) == "hello world\n"
+    @test open(x->read(x,String), pipeline(file, catcmd), "r") == "hello world\n"
     rm(file)
 end
 
 # Stream Redirection
-if !is_windows() # WINNT reports operation not supported on socket (ENOTSUP) for this test
+if !Sys.iswindows() # WINNT reports operation not supported on socket (ENOTSUP) for this test
     local r = Channel(1)
     local port, server, sock, client, t1, t2
     t1 = @async begin
         port, server = listenany(2326)
         put!(r, port)
         client = accept(server)
-        @test readstring(pipeline(client, catcmd)) == "hello world\n"
+        @test read(pipeline(client, catcmd), String) == "hello world\n"
         close(server)
         return true
     end
@@ -114,14 +114,14 @@ if !is_windows() # WINNT reports operation not supported on socket (ENOTSUP) for
     @test wait(t2)
 end
 
-@test readstring(setenv(`$shcmd -c "echo \$TEST"`,["TEST=Hello World"])) == "Hello World\n"
-@test readstring(setenv(`$shcmd -c "echo \$TEST"`,Dict("TEST"=>"Hello World"))) == "Hello World\n"
-@test readstring(setenv(`$shcmd -c "echo \$TEST"`,"TEST"=>"Hello World")) == "Hello World\n"
+@test read(setenv(`$shcmd -c "echo \$TEST"`,["TEST=Hello World"]), String) == "Hello World\n"
+@test read(setenv(`$shcmd -c "echo \$TEST"`,Dict("TEST"=>"Hello World")), String) == "Hello World\n"
+@test read(setenv(`$shcmd -c "echo \$TEST"`,"TEST"=>"Hello World"), String) == "Hello World\n"
 @test (withenv("TEST"=>"Hello World") do
-       readstring(`$shcmd -c "echo \$TEST"`); end) == "Hello World\n"
+       read(`$shcmd -c "echo \$TEST"`, String); end) == "Hello World\n"
 let pathA = readchomp(setenv(`$shcmd -c "pwd -P"`;dir="..")),
     pathB = readchomp(setenv(`$shcmd -c "cd .. && pwd -P"`))
-    if is_windows()
+    if Sys.iswindows()
         # on windows, sh returns posix-style paths that are not valid according to ispath
         @test pathA == pathB
     else
@@ -138,7 +138,7 @@ let str = "", stdin, stdout, proc, str2, file
     stdout, stdin, proc = readandwrite(`$catcmd -`)
     write(stdin, str)
     close(stdin)
-    str2 = readstring(stdout)
+    str2 = read(stdout, String)
     @test str2 == str
 
     # This test hangs if the end-of-run-walk-across-uv-streams calls shutdown on a stream that is shutting down.
@@ -205,16 +205,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 readstring(pipeline(`$exename --startup-file=no -e 'println(STDERR,"Hello World")'`, stderr=catcmd)) == "Hello World\n"
+    @test read(pipeline(`$exename --startup-file=no -e 'println(STDERR,"Hello World")'`, stderr=catcmd), String) == "Hello World\n"
     out = Pipe()
     proc = spawn(pipeline(`$exename --startup-file=no -e 'println(STDERR,"Hello World")'`, stderr = out))
     close(out.in)
-    @test readstring(out) == "Hello World\n"
+    @test read(out, String) == "Hello World\n"
     @test success(proc)
 end
 
 # issue #6310
-@test readstring(pipeline(`$echocmd "2+2"`, `$exename --startup-file=no`)) == "4\n"
+@test read(pipeline(`$echocmd "2+2"`, `$exename --startup-file=no`), String) == "4\n"
 
 # issue #5904
 @test run(pipeline(ignorestatus(falsecmd), truecmd)) === nothing
@@ -228,7 +228,7 @@ end
         println("Hello World")
         redirect_stdout(OLD_STDOUT)
         close(f)
-        @test "Hello World\n" == readstring(fname)
+        @test "Hello World\n" == read(fname, String)
         @test OLD_STDOUT === STDOUT
         rm(fname)
     end
@@ -242,28 +242,28 @@ let fname = tempname()
     function thrash(handle::Ptr{Void})
         # Kill the memory, but write a nice low value in the libuv type field to
         # trigger the right code path
-        ccall(:memset,Ptr{Void},(Ptr{Void},Cint,Csize_t),handle,0xee,3*sizeof(Ptr{Void}))
-        unsafe_store!(convert(Ptr{Cint},handle+2*sizeof(Ptr{Void})),15)
+        ccall(:memset, Ptr{Void}, (Ptr{Void}, Cint, Csize_t), handle, 0xee, 3 * sizeof(Ptr{Void}))
+        unsafe_store!(convert(Ptr{Cint}, handle + 2 * sizeof(Ptr{Void})), 15)
         nothing
     end
     OLD_STDERR = STDERR
-    redirect_stderr(open("$(escape_string(fname))","w"))
+    redirect_stderr(open("$(escape_string(fname))", "w"))
     # Usually this would be done by GC. Do it manually, to make the failure
     # case more reliable.
     oldhandle = OLD_STDERR.handle
     OLD_STDERR.status = Base.StatusClosing
     OLD_STDERR.handle = C_NULL
-    ccall(:uv_close,Void,(Ptr{Void},Ptr{Void}),oldhandle,cfunction(thrash,Void,(Ptr{Void},)))
+    ccall(:uv_close, Void, (Ptr{Void}, Ptr{Void}), oldhandle, cfunction(thrash, Void, (Ptr{Void},)))
     sleep(1)
     import Base.zzzInvalidIdentifier
     """
     try
-        (in,p) = open(pipeline(`$exename --startup-file=no`, stderr=STDERR), "w")
-        write(in,cmd)
-        close(in)
-        wait(p)
+        io = open(pipeline(`$exename --startup-file=no`, stderr=STDERR), "w")
+        write(io, cmd)
+        close(io)
+        wait(io)
     catch
-        error("IOStream redirect failed. Child stderr was \n$(readstring(fname))\n")
+        error("IOStream redirect failed. Child stderr was \n$(read(fname, String))\n")
     finally
         rm(fname)
     end
@@ -278,7 +278,7 @@ let bad = "bad\0name"
 end
 
 # issue #12829
-let out = Pipe(), echo = `$exename --startup-file=no -e 'print(STDOUT, " 1\t", readstring(STDIN))'`, ready = Condition(), t, infd, outfd
+let out = Pipe(), echo = `$exename --startup-file=no -e 'print(STDOUT, " 1\t", read(STDIN, String))'`, ready = Condition(), t, infd, outfd
     @test_throws ArgumentError write(out, "not open error")
     t = @async begin # spawn writer task
         open(echo, "w", out) do in1
@@ -298,15 +298,25 @@ let out = Pipe(), echo = `$exename --startup-file=no -e 'print(STDOUT, " 1\t", r
         @test iswritable(out)
         close(out.in)
         @test !isopen(out.in)
-        is_windows() || @test !isopen(out.out) # it takes longer to propagate EOF through the Windows event system
-        @test_throws ArgumentError write(out, "now closed error")
-        @test isreadable(out)
         @test !iswritable(out)
-        if is_windows()
-            # WINNT kernel does not provide a fast mechanism for async propagation
+        if !Sys.iswindows()
+            # on UNIX, we expect the pipe buffer is big enough that the write queue was immediately emptied
+            # and so we should already be notified of EPIPE on out.out by now
+            # and the other task should have already managed to consume all of the output
+            # it takes longer to propagate EOF through the Windows event system
+            # since it appears to be unwilling to buffer as much data
+            @test !isopen(out.out)
+            @test !isreadable(out)
+        end
+        @test_throws ArgumentError write(out, "now closed error")
+        if Sys.iswindows()
+            # WINNT kernel appears to not provide a fast mechanism for async propagation
             # of EOF for a blocking stream, so just wait for it to catch up.
             # This shouldn't take much more than 32ms.
             Base.wait_close(out)
+            # it's closed now, but the other task is expected to be behind this task
+            # in emptying the read buffer
+            @test isreadable(out)
         end
         @test !isopen(out)
     end
@@ -320,7 +330,7 @@ let out = Pipe(), echo = `$exename --startup-file=no -e 'print(STDOUT, " 1\t", r
     @test nb_available(out) > 0
     ln1 = readline(out)
     ln2 = readline(out)
-    desc = readstring(out)
+    desc = read(out, String)
     @test !isreadable(out)
     @test !iswritable(out)
     @test !isopen(out)
@@ -341,7 +351,7 @@ let fname = tempname()
     write(fname, "test\n")
     code = """
     cmd = pipeline(`echo asdf`,`cat`)
-    if is_windows()
+    if Sys.iswindows()
         try
             success(`busybox`)
             cmd = pipeline(`busybox echo asdf`,`busybox cat`)
@@ -383,8 +393,8 @@ end
 @test_throws ErrorException collect(eachline(pipeline(`$catcmd _doesnt_exist__111_`, stderr=DevNull)))
 
 # make sure windows_verbatim strips quotes
-if is_windows()
-    readstring(`cmd.exe /c dir /b spawn.jl`) == readstring(Cmd(`cmd.exe /c dir /b "\"spawn.jl\""`, windows_verbatim=true))
+if Sys.iswindows()
+    read(`cmd.exe /c dir /b spawn.jl`, String) == read(Cmd(`cmd.exe /c dir /b "\"spawn.jl\""`, windows_verbatim=true), String)
 end
 
 # make sure Cmd is nestable
@@ -422,7 +432,7 @@ end
 @test reduce(&, [`$echocmd abc`, `$echocmd def`, `$echocmd hij`]) == `$echocmd abc` & `$echocmd def` & `$echocmd hij`
 
 # test for proper handling of FD exhaustion
-if is_unix()
+if Sys.isunix()
     let ps = Pipe[]
         ulimit_n = tryparse(Int, readchomp(`sh -c 'ulimit -n'`))
         try
@@ -439,7 +449,7 @@ if is_unix()
             end
         catch ex
             isa(ex, Base.UVError) || rethrow(ex)
-            @test ex.code == Base.UV_EMFILE
+            @test ex.code in (Base.UV_EMFILE, Base.UV_ENFILE)
         finally
             for p in ps
                 close(p)
@@ -448,14 +458,6 @@ if is_unix()
     end
 end
 
-# Test for PR 17803
-let p=Pipe()
-    Base.link_pipe(p; julia_only_read=true, julia_only_write=true)
-    ccall(:jl_static_show, Void, (Ptr{Void}, Any), p.in, Int128(-1))
-    @async close(p.in)
-    @test readstring(p.out) == "Int128(0xffffffffffffffffffffffffffffffff)"
-end
-
 # readlines(::Cmd), accidentally broken in #20203
 @test sort(readlines(`$lscmd -A`)) == sort(readdir())
 
@@ -466,3 +468,30 @@ end
             Base.showerror(io::IO, e::Error19864) = print(io, "correct19864")
             throw(Error19864())'`),
     stderr=catcmd)) == "ERROR: correct19864"
+
+# accessing the command elements as an array or iterator:
+let c = `ls -l "foo bar"`
+    @test collect(c) == ["ls", "-l", "foo bar"]
+    @test first(c) == "ls" == c[1]
+    @test last(c) == "foo bar" == c[3] == c[end]
+    @test c[1:2] == ["ls", "-l"]
+    @test eltype(c) == String
+    @test length(c) == 3
+    @test eachindex(c) == 1:3
+end
+
+## Deadlock in spawning a cmd (#22832)
+# FIXME?
+#let stdout = Pipe(), stdin = Pipe()
+#    Base.link_pipe(stdout, julia_only_read=true)
+#    Base.link_pipe(stdin, julia_only_write=true)
+#    p = spawn(pipeline(catcmd, stdin=stdin, stdout=stdout, stderr=DevNull))
+#    @async begin # feed cat with 2 MB of data (zeros)
+#        write(stdin, zeros(UInt8, 1048576 * 2))
+#        close(stdin)
+#    end
+#    sleep(0.5) # give cat a chance to fill the write buffer for stdout
+#    close(stdout.in) # make sure we can still close the write end
+#    @test sizeof(readstring(stdout)) == 1048576 * 2 # make sure we get all the data
+#    @test success(p)
+#end
diff --git a/test/specificity.jl b/test/specificity.jl
new file mode 100644
index 00000000000000..417af2ed4a43d9
--- /dev/null
+++ b/test/specificity.jl
@@ -0,0 +1,177 @@
+function args_morespecific(a, b)
+    sp = (ccall(:jl_type_morespecific, Cint, (Any,Any), a, b) != 0)
+    if sp  # make sure morespecific(a,b) implies !morespecific(b,a)
+        @test ccall(:jl_type_morespecific, Cint, (Any,Any), b, a) == 0
+    end
+    return sp
+end
+
+# issue #8652
+let
+    a  = Tuple{Type{T1}, T1} where T1<:Integer
+    b2 = Tuple{Type{T2}, Integer} where T2<:Integer
+    @test args_morespecific(a, b2)
+    @test !args_morespecific(b2, a)
+    a  = Tuple{Type{T1}, Ptr{T1}} where T1<:Integer
+    b2 = Tuple{Type{T2}, Ptr{Integer}} where T2<:Integer
+    @test args_morespecific(a, b2)
+    @test !args_morespecific(b2, a)
+end
+
+# issue #11534
+let
+    t1 = Tuple{AbstractArray, Tuple{Vararg{RangeIndex}}}
+    t2 = Tuple{Array, T} where T<:Tuple{Vararg{RangeIndex}}
+    @test !args_morespecific(t1, t2)
+    @test  args_morespecific(t2, t1)
+end
+
+let
+    a = Tuple{Array{T,N}, Vararg{Int,N}} where T where N
+    b = Tuple{Array,Int}
+    @test  args_morespecific(a, b)
+    @test !args_morespecific(b, a)
+    a = Tuple{Array, Vararg{Int,N}} where N
+    @test !args_morespecific(a, b)
+    @test  args_morespecific(b, a)
+end
+
+# another specificity issue
+_z_z_z_(x, y) = 1
+_z_z_z_(::Int, ::Int, ::Vector) = 2
+_z_z_z_(::Int, c...) = 3
+@test _z_z_z_(1, 1, []) == 2
+
+@test  args_morespecific(Tuple{T,Vararg{T}} where T<:Number,  Tuple{Number,Number,Vararg{Number}})
+@test !args_morespecific(Tuple{Number,Number,Vararg{Number}}, Tuple{T,Vararg{T}} where T<:Number)
+
+@test args_morespecific(Tuple{Array{T} where T<:Union{Float32,Float64,Complex64,Complex128}, Any},
+                        Tuple{Array{T} where T<:Real, Any})
+
+@test  args_morespecific(Tuple{1,T} where T, Tuple{Any})
+@test  args_morespecific(Tuple{T} where T, Tuple{T,T} where T)
+@test !args_morespecific(Type{T} where T<:Integer, Type{Any})
+
+# issue #21016
+@test args_morespecific(Tuple{IO, Core.TypeofBottom}, Tuple{IO, Type{T}} where T<:Number)
+
+# issue #21382
+@test args_morespecific(Tuple{Type{Pair{A,B} where B}} where A, Tuple{DataType})
+@test args_morespecific(Tuple{Union{Int,String},Type{Pair{A,B} where B}} where A, Tuple{Integer,UnionAll})
+
+# PR #21750
+let A = Tuple{Any, Tuple{Vararg{Integer,N} where N}},
+    B = Tuple{Any, Tuple{Any}},
+    C = Tuple{Any, Tuple{}}
+    @test args_morespecific(A, B)
+    @test args_morespecific(C, A)
+    @test args_morespecific(C, B)
+end
+
+# with bound varargs
+_bound_vararg_specificity_1(::Type{Array{T,N}}, d::Vararg{Int, N}) where {T,N} = 0
+_bound_vararg_specificity_1(::Type{Array{T,1}}, d::Int) where {T} = 1
+@test _bound_vararg_specificity_1(Array{Int,1}, 1) == 1
+@test _bound_vararg_specificity_1(Array{Int,2}, 1, 1) == 0
+
+# issue #21710
+@test args_morespecific(Tuple{Array}, Tuple{AbstractVector})
+@test args_morespecific(Tuple{Matrix}, Tuple{AbstractVector})
+
+# Method specificity
+begin
+    local f, A
+    f(dims::Tuple{}, A::AbstractArray{T,0}) where {T} = 1
+    f(dims::NTuple{N,Int}, A::AbstractArray{T,N}) where {T,N} = 2
+    f(dims::NTuple{M,Int}, A::AbstractArray{T,N}) where {T,M,N} = 3
+    A = zeros(2,2)
+    @test f((1,2,3), A) == 3
+    @test f((1,2), A) == 2
+    @test f((), reshape([1])) == 1
+    f(dims::NTuple{N,Int}, A::AbstractArray{T,N}) where {T,N} = 4
+    @test f((1,2), A) == 4
+    @test f((1,2,3), A) == 3
+end
+
+# a method specificity issue
+c99991(::Type{T},x::T) where {T} = 0
+c99991(::Type{UnitRange{T}},x::StepRangeLen{T}) where {T} = 1
+c99991(::Type{UnitRange{T}},x::Range{T}) where {T} = 2
+@test c99991(UnitRange{Float64}, 1.0:2.0) == 1
+@test c99991(UnitRange{Int}, 1:2) == 2
+
+# issue #17016, method specificity involving vararg tuples
+T_17016{N} = Tuple{Any,Any,Vararg{Any,N}}
+f17016(f, t::T_17016) = 0
+f17016(f, t1::Tuple) = 1
+@test f17016(0, (1,2,3)) == 0
+
+@test !args_morespecific(Tuple{Type{Any}, Any}, Tuple{Type{T}, Any} where T<:VecElement)
+@test !args_morespecific((Tuple{Type{T}, Any} where T<:VecElement), Tuple{Type{Any}, Any})
+
+@test !args_morespecific(Tuple{Type{T}, Tuple{Any, Vararg{Any, N} where N}} where T<:Tuple{Any, Vararg{Any, N} where N},
+                         Tuple{Type{Any}, Any})
+@test !args_morespecific(Tuple{Type{T}, Tuple{Any, Vararg{Any, N} where N}} where T<:Tuple{Any, Vararg{Any, N} where N},
+                         Tuple{Type{Tuple}, Tuple})
+@test !args_morespecific(Tuple{Type{T}, T} where T<:Tuple{Any, Vararg{Any, N} where N},
+                         Tuple{Type{T}, Any} where T<:VecElement)
+
+@test args_morespecific(Tuple{Any, Tuple{}, Tuple{}}, Tuple{Any, Tuple{Any}})
+@test args_morespecific(Tuple{Any, Tuple{Any}, Tuple{Any}}, Tuple{Any, Tuple{Any, Any}})
+@test args_morespecific(Tuple{Any, Vararg{Tuple{}, N} where N}, Tuple{Any, Tuple{Any}})
+
+@test  args_morespecific(Tuple{T, T} where T<:AbstractFloat, Tuple{T, T, T} where T<:AbstractFloat)
+@test  args_morespecific(Tuple{T, Real, T} where T<:AbstractFloat, Tuple{T, T} where T<:Real)
+@test  args_morespecific(Tuple{Real, Real}, Tuple{T, T, T} where T <: Real)
+@test !args_morespecific(Tuple{Real, Real, Real}, Tuple{T, T, T} where T <: Real)
+@test !args_morespecific(Tuple{Real, Real, Vararg{Real}}, Tuple{T, T, T} where T <: Real)
+@test  args_morespecific(Tuple{Real, Real, Vararg{Int}}, Tuple{T, T, T} where T <: Real)
+
+@test  args_morespecific(Tuple{Type{Base.Nullable{T}}} where T, Tuple{Type{T}, Any} where T)
+@test !args_morespecific(Tuple{Type{Base.Nullable{T}}, T} where T, Tuple{Type{Base.Nullable{T}}} where T)
+
+@test  args_morespecific(Tuple{Union{Base.StepRange{T, S} where S, Base.StepRangeLen{T, T, S} where S},
+                               Union{Base.StepRange{T, S} where S, Base.StepRangeLen{T, T, S} where S}} where T,
+                         Tuple{T, T} where T<:Union{Base.StepRangeLen, Base.LinSpace})
+
+@test args_morespecific(Tuple{Type{Tuple}, Any, Any},
+                        Tuple{Type{Tuple{Vararg{E, N} where N}}, Any, Any} where E)
+
+@test args_morespecific(Tuple{Type{Tuple{}}, Tuple{}},
+                        Tuple{Type{T}, T} where T<:Tuple{Any, Vararg{Any, N} where N})
+
+@test args_morespecific(Tuple{Type{CartesianIndex{N}}} where N,
+                        Tuple{Type{CartesianIndex{N}},Vararg{Int,N}} where N)
+
+# issue #22164
+let A = Tuple{Type{D},D} where D<:Pair,
+    B = Tuple{Type{Any}, Any},
+    C = Tuple{Type{Pair}, Pair}
+    @test  args_morespecific(C, A)
+    @test !args_morespecific(A, B)
+    @test !args_morespecific(C, B)
+end
+
+# issue #22338
+let A = Tuple{Ref, Tuple{T}} where T,
+    B = Tuple{Ref{T}, Tuple{Vararg{T}}} where T,
+    C = Tuple{Ref{T}, Tuple{T}} where T
+    @test  args_morespecific(C, A)
+    @test  args_morespecific(C, B)
+    @test !args_morespecific(A, B)
+    @test !args_morespecific(B, A)
+end
+
+# issue #22339
+let A = Tuple{T, Array{T, 1}} where T,
+    B = Tuple{T} where T,
+    C = Tuple{T} where T<:AbstractFloat
+    @test args_morespecific(B, A)
+    @test args_morespecific(C, B)
+    @test args_morespecific(C, A)
+end
+
+# issue #22908
+f22908(::Union) = 2
+f22908(::Type{Union{Int, Float32}}) = 1
+@test f22908(Union{Int, Float32}) == 1
diff --git a/test/stacktraces.jl b/test/stacktraces.jl
index 5bb12afab67beb..8ad2eed1010951 100644
--- a/test/stacktraces.jl
+++ b/test/stacktraces.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Tests for /base/stacktraces.jl
 
@@ -6,7 +6,7 @@ let
     @noinline child() = stacktrace()
     @noinline parent() = child()
     @noinline grandparent() = parent()
-    line_numbers = @__LINE__ - [3, 2, 1]
+    line_numbers = @__LINE__() - [3, 2, 1]
     stack = grandparent()
 
     # Basic tests.
@@ -68,7 +68,7 @@ let ct = current_task()
             return catch_stacktrace()
         end
     end
-    line_numbers = @__LINE__ .- [15, 10, 5]
+    line_numbers = @__LINE__() .- [15, 10, 5]
 
     # Test try...catch with stacktrace
     @test try_stacktrace()[1] == StackFrame(:try_stacktrace, @__FILE__, line_numbers[2])
@@ -98,12 +98,13 @@ for (frame, func, inlined) in zip(trace, [g,h,f], (can_inline, can_inline, false
 end
 end
 
-let src = expand(quote let x = 1 end end).args[1]::CodeInfo,
+let src = expand(Main, quote let x = 1 end end).args[1]::CodeInfo,
     li = ccall(:jl_new_method_instance_uninit, Ref{Core.MethodInstance}, ()),
     sf
 
     li.inferred = src
     li.specTypes = Tuple{}
+    li.def = @__MODULE__
     sf = StackFrame(:a, :b, 3, li, false, false, 0)
     repr = string(sf)
     @test repr == "Toplevel MethodInstance thunk at b:3"
@@ -130,3 +131,15 @@ let st = stacktrace(empty!(backtrace()))
     @test isempty(st)
     @test isa(st, StackTrace)
 end
+
+module StackTracesTestMod
+    unfiltered_stacktrace() = stacktrace()
+    filtered_stacktrace() = StackTraces.remove_frames!(stacktrace(), StackTracesTestMod)
+end
+
+# Test that `removes_frames!` can correctly remove frames from within the module
+trace = StackTracesTestMod.unfiltered_stacktrace()
+@test contains(string(trace), "unfiltered_stacktrace")
+
+trace = StackTracesTestMod.filtered_stacktrace()
+@test !contains(string(trace), "filtered_stacktrace")
diff --git a/test/staged.jl b/test/staged.jl
index c9066742eff769..95a9b25ae30a02 100644
--- a/test/staged.jl
+++ b/test/staged.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 @generated function staged_t1(a,b)
     if a == Int
@@ -56,7 +56,7 @@ splat2(3, 3:5)
 @test String(take!(stagediobuf)) == "($intstr, UnitRange{$intstr})"
 
 # varargs specialization with parametric @generated functions (issue #8944)
-@generated function splat3{T,N}(A::AbstractArray{T,N}, indx::RangeIndex...)
+@generated function splat3(A::AbstractArray{T,N}, indx::RangeIndex...) where {T,N}
     print(stagediobuf, indx)
     :(nothing)
 end
@@ -101,10 +101,10 @@ end
 @test MyTest8497.h(3) == 4
 
 # static parameters (issue #8505)
-@generated function foo1{N,T}(a::Array{T,N})
+@generated function foo1(a::Array{T,N}) where {N,T}
     "N = $N, T = $T"
 end
-@generated function foo2{T,N}(a::Array{T,N})
+@generated function foo2(a::Array{T,N}) where {T,N}
     "N = $N, T = $T"
 end
 @test foo1(randn(3,3)) == "N = 2, T = Float64"
@@ -147,7 +147,6 @@ module TestGeneratedThrow
     foo() = (bar(rand() > 0.5 ? 1 : 1.0); error("foo"))
     function __init__()
         code_typed(foo,(); optimize = false)
-        @test Core.Inference.isempty(Core.Inference.active) && Core.Inference.isempty(Core.Inference.workq)
         cfunction(foo,Void,())
     end
 end
@@ -180,7 +179,7 @@ end
 
 gf_err_ref[] = 0
 let gf_err2
-    @generated function gf_err2{f}(::f)
+    @generated function gf_err2(::f) where {f}
         gf_err_ref[] += 1
         reflect = f.instance
         gf_err_ref[] += 1
@@ -213,3 +212,41 @@ end
 
 # issue #19897
 @test code_lowered(staged_t1, (Int,Int)) isa Array  # check no error thrown
+
+# issue #10178
+@generated function f10178(x::X) where X
+    :(x)
+end
+g10178(x) = f10178(x)
+@test g10178(5) == 5
+@generated function f10178(x::X) where X
+    :(2x)
+end
+g10178(x) = f10178(x)
+@test g10178(5) == 10
+
+# issue #22135
+@generated f22135(x::T) where T = x
+@test f22135(1) === Int
+
+# PR #22440
+
+f22440kernel(x...) = x[1] + x[1]
+f22440kernel(x::AbstractFloat) = x * x
+f22440kernel(::Type{T}) where {T} = one(T)
+f22440kernel(::Type{T}) where {T<:AbstractFloat} = zero(T)
+
+@generated function f22440(y)
+    sig, spvals, method = Base._methods_by_ftype(Tuple{typeof(f22440kernel),y}, -1, typemax(UInt))[1]
+    code_info = Base.uncompressed_ast(method)
+    body = Expr(:block, code_info.code...)
+    Base.Core.Inference.substitute!(body, 0, Any[], sig, Any[spvals...], 0)
+    return code_info
+end
+
+@test f22440(Int) === f22440kernel(Int)
+@test f22440(Float64) === f22440kernel(Float64)
+@test f22440(Float32) === f22440kernel(Float32)
+@test f22440(0.0) === f22440kernel(0.0)
+@test f22440(0.0f0) === f22440kernel(0.0f0)
+@test f22440(0) === f22440kernel(0)
diff --git a/test/statistics.jl b/test/statistics.jl
index 802c02f427ba53..55dd0fdf71c2b4 100644
--- a/test/statistics.jl
+++ b/test/statistics.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base.Test
 
@@ -113,6 +113,18 @@ X = [2 3 1 -1; 7 4 5 -4]
 @test isnan(var(1:1))
 @test isnan(var(1:-1))
 
+@test @inferred(var(1.0:8.0)) == 6.
+@test varm(1.0:8.0,1.0) == varm(collect(1.0:8.0),1)
+@test isnan(varm(1.0:1.0,1.0))
+@test isnan(var(1.0:1.0))
+@test isnan(var(1.0:-1.0))
+
+@test @inferred(var(1.0f0:8.0f0)) === 6.f0
+@test varm(1.0f0:8.0f0,1.0f0) == varm(collect(1.0f0:8.0f0),1)
+@test isnan(varm(1.0f0:1.0f0,1.0f0))
+@test isnan(var(1.0f0:1.0f0))
+@test isnan(var(1.0f0:-1.0f0))
+
 @test varm([1,2,3], 2) ≈ 1.
 @test var([1,2,3]) ≈ 1.
 @test var([1,2,3]; corrected=false) ≈ 2.0/3
@@ -186,50 +198,50 @@ for vd in [1, 2], zm in [true, false], cr in [true, false]
         y1 = vec(Y[1,:])
     end
 
-    c = zm ? Base.covm(x1, 0, cr) :
-             cov(x1, cr)
+    c = zm ? Base.covm(x1, 0, corrected=cr) :
+             cov(x1, corrected=cr)
     @test isa(c, Float64)
     @test c ≈ Cxx[1,1]
-    @inferred cov(x1, cr)
+    @inferred cov(x1, corrected=cr)
 
     @test cov(X) == Base.covm(X, mean(X, 1))
-    C = zm ? Base.covm(X, 0, vd, cr) :
-             cov(X, vd, cr)
+    C = zm ? Base.covm(X, 0, vd, corrected=cr) :
+             cov(X, vd, corrected=cr)
     @test size(C) == (k, k)
     @test C ≈ Cxx
-    @inferred cov(X, vd, cr)
+    @inferred cov(X, vd, 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)
+    c = zm ? Base.covm(x1, 0, y1, 0, corrected=cr) :
+             cov(x1, y1, corrected=cr)
     @test isa(c, Float64)
     @test c ≈ Cxy[1,1]
-    @inferred cov(x1, y1, cr)
+    @inferred cov(x1, y1, 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)
+    C = zm ? Base.covm(x1, 0, Y, 0, vd, corrected=cr) :
+             cov(x1, Y, vd, corrected=cr)
     @test size(C) == (1, k)
     @test vec(C) ≈ Cxy[1,:]
-    @inferred cov(x1, Y, vd, cr)
+    @inferred cov(x1, Y, 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)
+    C = zm ? Base.covm(X, 0, y1, 0, vd, corrected=cr) :
+             cov(X, y1, vd, corrected=cr)
     @test size(C) == (k, 1)
     @test vec(C) ≈ Cxy[:,1]
-    @inferred cov(X, y1, vd, cr)
+    @inferred cov(X, y1, 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)
+    C = zm ? Base.covm(X, 0, Y, 0, vd, corrected=cr) :
+             cov(X, Y, vd, corrected=cr)
     @test size(C) == (k, k)
     @test C ≈ Cxy
-    @inferred cov(X, Y, vd, cr)
+    @inferred cov(X, Y, vd, corrected=cr)
 end
 
 # test correlation
@@ -326,6 +338,10 @@ end
 @test quantile([Inf,Inf],0.5) == Inf
 @test quantile([-Inf,1],0.5) == -Inf
 @test quantile([0,1],1e-18) == 1e-18
+@test quantile([1, 2, 3, 4],[]) == []
+@test quantile([1, 2, 3, 4], (0.5,)) == (2.5,)
+@test quantile([4, 9, 1, 5, 7, 8, 2, 3, 5, 17, 11], (0.1, 0.2, 0.4, 0.9)) == (2.0, 3.0, 5.0, 11.0)
+@test quantile([1, 2, 3, 4], ()) == ()
 
 # StatsBase issue 164
 y = [0.40003674665581906,0.4085630862624367,0.41662034698690303,0.41662034698690303,0.42189053966652057,0.42189053966652057,0.42553514344518345,0.43985732442991354]
@@ -348,6 +364,24 @@ let v = varm([1.0+2.0im], 0; corrected = false)
     @test isa(v, Float64)
 end
 
+# cov and cor of complex arrays (issue #21093)
+x = [2.7 - 3.3im, 0.9 + 5.4im, 0.1 + 0.2im, -1.7 - 5.8im, 1.1 + 1.9im]
+y = [-1.7 - 1.6im, -0.2 + 6.5im, 0.8 - 10.0im, 9.1 - 3.4im, 2.7 - 5.5im]
+@test cov(x, y) ≈ 4.8365 - 12.119im
+@test cov(y, x) ≈ 4.8365 + 12.119im
+@test cov(x, reshape(y, :, 1)) ≈ reshape([4.8365 - 12.119im], 1, 1)
+@test cov(reshape(x, :, 1), y) ≈ reshape([4.8365 - 12.119im], 1, 1)
+@test cov(reshape(x, :, 1), reshape(y, :, 1)) ≈ reshape([4.8365 - 12.119im], 1, 1)
+@test cov([x y]) ≈ [21.779 4.8365-12.119im;
+                    4.8365+12.119im 54.548]
+@test cor(x, y) ≈ 0.14032104449218274 - 0.35160772008699703im
+@test cor(y, x) ≈ 0.14032104449218274 + 0.35160772008699703im
+@test cor(x, reshape(y, :, 1)) ≈ reshape([0.14032104449218274 - 0.35160772008699703im], 1, 1)
+@test cor(reshape(x, :, 1), y) ≈ reshape([0.14032104449218274 - 0.35160772008699703im], 1, 1)
+@test cor(reshape(x, :, 1), reshape(y, :, 1)) ≈ reshape([0.14032104449218274 - 0.35160772008699703im], 1, 1)
+@test cor([x y]) ≈ [1.0                                          0.14032104449218274-0.35160772008699703im
+                    0.14032104449218274+0.35160772008699703im  1.0]
+
 # Issue #17153 and PR #17154
 let a = rand(10,10)
     b = deepcopy(a)
@@ -372,10 +406,29 @@ end
 # dimensional correctness
 isdefined(Main, :TestHelpers) || @eval Main include("TestHelpers.jl")
 using TestHelpers.Furlong
-let r = Furlong(1):Furlong(1):Furlong(2), a = collect(r)
+@testset "Unitful elements" begin
+    r = Furlong(1):Furlong(1):Furlong(2)
+    a = collect(r)
     @test sum(r) == sum(a) == Furlong(3)
     @test cumsum(r) == Furlong.([1,3])
     @test mean(r) == mean(a) == median(a) == median(r) == Furlong(1.5)
     @test var(r) == var(a) == Furlong{2}(0.5)
     @test std(r) == std(a) == Furlong{1}(sqrt(0.5))
+
+    # Issue #21786
+    A = [Furlong{1}(rand(-5:5)) for i in 1:2, j in 1:2]
+    @test mean(mean(A, 1), 2)[1] === mean(A)
+    @test var(A, 1)[1] === var(A[:, 1])
+    @test_broken std(A, 1)[1] === std(A[:, 1])
+end
+
+# Issue #22901
+@testset "var and quantile of Any arrays" begin
+    x = Any[1, 2, 4, 10]
+    y = Any[1, 2, 4, 10//1]
+    @test var(x) === 16.25
+    @test var(y) === 65//4
+    @test std(x) === sqrt(16.25)
+    @test quantile(x, 0.5)  === 3.0
+    @test quantile(x, 1//2) === 3//1
 end
diff --git a/test/strings/basic.jl b/test/strings/basic.jl
index 7ecb5bebbf13e8..638c26a21113ef 100644
--- a/test/strings/basic.jl
+++ b/test/strings/basic.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # constructors
 @test String([0x61,0x62,0x63,0x21]) == "abc!"
@@ -8,6 +8,16 @@
 @test eltype(GenericString) == Char
 @test start("abc") == 1
 @test cmp("ab","abc") == -1
+@test "abc" === "abc"
+@test "ab"  !== "abc"
+@test string("ab", 'c') === "abc"
+codegen_egal_of_strings(x, y) = (x===y, x!==y)
+@test codegen_egal_of_strings(string("ab", 'c'), "abc") === (true, false)
+let strs = ["", "a", "a b c", "до свидания"]
+    for x in strs, y in strs
+        @test (x === y) == (object_id(x) == object_id(y))
+    end
+end
 
 # {starts,ends}with
 @test startswith("abcd", 'a')
@@ -53,7 +63,7 @@ let
     sym = Symbol(Char(0xdcdb))
     @test string(sym) == string(Char(0xdcdb))
     @test String(sym) == string(Char(0xdcdb))
-    @test expand(sym) === sym
+    @test expand(Main, sym) === sym
     res = string(parse(string(Char(0xdcdb)," = 1"),1,raise=false)[1])
     @test res == """\$(Expr(:error, "invalid character \\\"\\udcdb\\\"\"))"""
 end
@@ -69,11 +79,13 @@ end
 @test_throws ArgumentError gensym("ab\0")
 
 # issue #6949
-let f =IOBuffer(),
+let f = IOBuffer(),
     x = split("1 2 3")
-    @test write(f, x) == 3
-    @test String(take!(f)) == "123"
-    @test invoke(write, Tuple{IO, AbstractArray}, f, x) == 3
+    local nb = 0
+    for c in x
+        nb += write(f, c)
+    end
+    @test nb == 3
     @test String(take!(f)) == "123"
 end
 
@@ -107,6 +119,21 @@ end
 @test SubString("", 1, 6)[10:9] == ""
 @test SubString("", 1, 0)[10:9] == ""
 
+# issue #22500 (using `get()` to index strings with default returns)
+let
+    utf8_str = "我很喜欢Julia"
+
+    # Test that we can index in at valid locations
+    @test get(utf8_str, 1, 'X') == '我'
+    @test get(utf8_str, 13, 'X') == 'J'
+
+    # Test that obviously incorrect locations return the default
+    @test get(utf8_str, -1, 'X') == 'X'
+    @test get(utf8_str, 1000, 'X') == 'X'
+
+    # Test that indexing into the middle of a character returns the default
+    @test get(utf8_str, 2, 'X') == 'X'
+end
 
 #=
 # issue #7764
@@ -151,6 +178,7 @@ end
 @test ucfirst("hola")=="Hola"
 @test ucfirst("")==""
 @test ucfirst("*")=="*"
+@test ucfirst("DŽxx") == ucfirst("džxx") == "Džxx"
 
 @test lcfirst("Hola")=="hola"
 @test lcfirst("hola")=="hola"
@@ -193,7 +221,7 @@ gstr = GenericString("12")
 @test ind2chr(gstr,2)==2
 
 # issue #10307
-@test typeof(map(Int16,AbstractString[])) == Vector{Int16}
+@test typeof(map(x -> parse(Int16, x), AbstractString[])) == Vector{Int16}
 
 for T in [Int8, UInt8, Int16, UInt16, Int32, UInt32, Int64, UInt64, Int128, UInt128]
     for i in [typemax(T), typemin(T)]
@@ -242,7 +270,7 @@ let s = normalize_string("tést",:NFKC)
 end
 @test_throws ArgumentError Base.unsafe_convert(Cstring, Base.cconvert(Cstring, "ba\0d"))
 
-cstrdup(s) = @static is_windows() ? ccall(:_strdup, Cstring, (Cstring,), s) : ccall(:strdup, Cstring, (Cstring,), s)
+cstrdup(s) = @static Sys.iswindows() ? ccall(:_strdup, Cstring, (Cstring,), s) : ccall(:strdup, Cstring, (Cstring,), s)
 let p = cstrdup("hello")
     @test unsafe_string(p) == "hello"
     Libc.free(p)
@@ -461,6 +489,24 @@ Base.endof(x::CharStr) = endof(x.chars)
 @test cmp("\U1f596\U1f596", CharStr("\U1f596")) == 1   # Gives BoundsError with bug
 @test cmp(CharStr("\U1f596"), "\U1f596\U1f596") == -1
 
+# repeat function
+@inferred repeat(GenericString("x"), 1)
+@test repeat("xx",3) == repeat("x",6) == repeat('x',6) == repeat(GenericString("x"), 6) == "xxxxxx"
+@test repeat("αα",3) == repeat("α",6) == repeat('α',6) == repeat(GenericString("α"), 6) == "αααααα"
+@test repeat("x",1) == repeat('x',1) == "x"^1 == 'x'^1 == GenericString("x")^1 == "x"
+@test repeat("x",0) == repeat('x',0) == "x"^0 == 'x'^0 == GenericString("x")^0 == ""
+
 # issue #12495: check that logical indexing attempt raises ArgumentError
 @test_throws ArgumentError "abc"[[true, false, true]]
 @test_throws ArgumentError "abc"[BitArray([true, false, true])]
+
+@test "ab" * "cd" == "abcd"
+@test 'a' * "bc" == "abc"
+@test "ab" * 'c' == "abc"
+@test 'a' * 'b' == "ab"
+@test 'a' * "b" * 'c' == "abc"
+@test "a" * 'b' * 'c' == "abc"
+
+# unrecognized escapes in string/char literals
+@test_throws ParseError parse("\"\\.\"")
+@test_throws ParseError parse("\'\\.\'")
diff --git a/test/strings/io.jl b/test/strings/io.jl
index dedb7463d48b04..9b85bead6098cd 100644
--- a/test/strings/io.jl
+++ b/test/strings/io.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # string escaping & unescaping
 cx = Any[
@@ -82,10 +82,6 @@ for i = 0:0x7f, p = ["","\0","x","xxx","\x7f","\uFF","\uFFF",
     @test string(unescape_string(string("\\x",hex(i,3),p))) == hp
 end
 
-@test "\z" == unescape_string("\z") == "z"
-@test "\X" == unescape_string("\X") == "X"
-@test "\AbC" == unescape_string("\AbC") == "AbC"
-
 @test "\0" == unescape_string("\\0")
 @test "\1" == unescape_string("\\1")
 @test "\7" == unescape_string("\\7")
@@ -200,3 +196,77 @@ s2 = """
      """
 
 @test s1 == s2
+
+# issue #22021, string realloc bug with join
+s22021 = String["\"\"\"
+     non_max_suppression(boxes, scores, max_output_size; iou_threshold=nothing)
+
+Greedily selects a subset of bounding boxes in descending order of score,
+
+pruning away boxes that have high intersection-over-union (IOU) overlap
+with previously selected boxes.  Bounding boxes are supplied as
+[y1, x1, y2, x2], where (y1, x1) and (y2, x2) are the coordinates of any
+diagonal pair of box corners and the coordinates can be provided as normalized
+(i.e., lying in the interval [0, 1]) or absolute.  Note that this algorithm
+is agnostic to where the origin is in the coordinate system.  Note that this
+algorithm is invariant to orthogonal transformations and translations
+of the coordinate system; thus translating or reflections of the coordinate
+system result in the same boxes being selected by the algorithm.
+
+The output of this operation is a set of integers indexing into the input
+collection of bounding boxes representing the selected boxes.  The bounding
+box coordinates corresponding to the selected indices can then be obtained
+using the `tf.gather operation`.  For example:
+
+  selected_indices = tf.image.non_max_suppression(
+      boxes, scores, max_output_size, iou_threshold)
+  selected_boxes = tf.gather(boxes, selected_indices)
+\"\"\"",
+    "    tf.@op function non_max_suppression(v13566, v13567, v13568; name=nothing, iou_threshold=nothing) ",
+    "            local desc ",
+    "            tf.with_op_name((()->begin  ",
+    "                        desc = tf.NodeDescription(\"NonMaxSuppression\") ",
+    "                        begin  ",
+    "                            begin  ",
+    "                                v13566 = convert(TensorFlow.Tensor{Float32}, v13566) ",
+    "                                begin  ",
+    "                                end",
+    "                            end",
+    "                            begin  ",
+    "                                v13567 = convert(TensorFlow.Tensor{Float32}, v13567) ",
+    "                                begin  ",
+    "                                end",
+    "                            end",
+    "                            begin  ",
+    "                                v13568 = convert(TensorFlow.Tensor{Int32}, v13568) ",
+    "                                begin  ",
+    "                                end",
+    "                            end",
+    "                        end ",
+    "                        begin  ",
+    "                            begin  ",
+    "                                tf.add_input(desc, v13566)",
+    "                            end",
+    "                            begin  ",
+    "                                tf.add_input(desc, v13567)",
+    "                            end",
+    "                            begin  ",
+    "                                tf.add_input(desc, v13568)",
+    "                            end",
+    "                        end ",
+    "                        begin  ",
+    "                            begin  ",
+    "                                if iou_threshold !== nothing ",
+    "                                    desc[\"iou_threshold\"] = Base.identity(iou_threshold)",
+    "                                end",
+    "                            end",
+    "                        end",
+    "                    end), name, \"NonMaxSuppression\") ",
+    "            tf.Tensor(tf.Operation(desc))",
+    "        end"]
+
+for i = 1:10
+    buf = IOBuffer()
+    print(buf, join(s22021, "\n"))
+    @test isvalid(String, take!(buf))
+end
diff --git a/test/strings/search.jl b/test/strings/search.jl
index 8fcfe9c62d5d34..34472914557b94 100644
--- a/test/strings/search.jl
+++ b/test/strings/search.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # some test strings
 astr = "Hello, world.\n"
@@ -354,6 +354,10 @@ end
 @test searchindex("\U1f596\U1f596", "\U1f596\U1f596") == 1
 @test searchindex("\U1f596\U1f596", "\U1f596\U1f596", 1) == 1
 
+# contains with a String and Char needle
+@test contains("foo", "o")
+@test contains("foo", 'o')
+
 # string rsearchindex with a two-char UTF-8 (2 byte) string literal
 @test rsearchindex("ééé", "éé") == 3
 @test rsearchindex("ééé", "éé", endof("ééé")) == 3
diff --git a/test/strings/types.jl b/test/strings/types.jl
index 36289bc000a84e..c4ff5227a02e22 100644
--- a/test/strings/types.jl
+++ b/test/strings/types.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 ## SubString, RevString and Cstring tests ##
 
diff --git a/test/strings/util.jl b/test/strings/util.jl
index 21072a524bf4c2..7185964ae7aecc 100644
--- a/test/strings/util.jl
+++ b/test/strings/util.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # padding (lpad and rpad)
 @test lpad("foo", 3) == "foo"
@@ -26,7 +26,7 @@ for s in ("", " ", " abc", "abc ", "  abc  "), f in (lstrip, rstrip, strip)
         ft = f(t)
         @test s == t
         @test fs == ft
-        @test typeof(ft) == typeof(t[1:end])
+        @test typeof(ft) == SubString{T}
 
         b = convert(SubString{T}, t)
         fb = f(b)
@@ -208,6 +208,18 @@ end
 # Issue 13332
 @test replace("abc", 'b', 2.1) == "a2.1c"
 
+# test replace with a count for String and GenericString
+# check that replace is a no-op if count==0
+for s in ["aaa", Base.Test.GenericString("aaa")]
+    # @test replace("aaa", 'a', 'z', 0) == "aaa" # enable when undeprecated
+    @test replace(s, 'a', 'z', 1) == "zaa"
+    @test replace(s, 'a', 'z', 2) == "zza"
+    @test replace(s, 'a', 'z', 3) == "zzz"
+    @test replace(s, 'a', 'z', 4) == "zzz"
+    @test replace(s, 'a', 'z', typemax(Int)) == "zzz"
+    @test replace(s, 'a', 'z')    == "zzz"
+end
+
 # chomp/chop
 @test chomp("foo\n") == "foo"
 @test chop("fooε") == "foo"
diff --git a/test/subarray.jl b/test/subarray.jl
index 4c1ada86728dff..f80ba3c200c1b0 100644
--- a/test/subarray.jl
+++ b/test/subarray.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base.Test
 
@@ -47,7 +47,7 @@ ensure_iterable(t::Tuple{Union{Number, CartesianIndex}, Vararg{Any}}) = ((t[1],)
 ensure_iterable(t::Tuple{Any, Vararg{Any}}) = (t[1], ensure_iterable(Base.tail(t))...)
 
 index_ndims(t::Tuple) = tup2val(Base.index_ndims(t))
-tup2val{N}(::NTuple{N}) = Val{N}
+tup2val(::NTuple{N}) where {N} = Val(N)
 
 # To avoid getting confused by manipulations that are implemented for SubArrays,
 # it's good to copy the contents to an Array. This version protects against
@@ -89,10 +89,10 @@ function single_stride_dim(A::Array)
     end
     ld
 end
-single_stride_dim(A::ANY) = single_stride_dim(copy_to_array(A))
+single_stride_dim(@nospecialize(A)) = single_stride_dim(copy_to_array(A))
 
 # Testing equality of AbstractArrays, using several different methods to access values
-function test_cartesian(A::ANY, B::ANY)
+function test_cartesian(@nospecialize(A), @nospecialize(B))
     isgood = true
     for (IA, IB) in zip(eachindex(A), eachindex(B))
         if A[IA] != B[IB]
@@ -108,7 +108,7 @@ function test_cartesian(A::ANY, B::ANY)
     end
 end
 
-function test_linear(A::ANY, B::ANY)
+function test_linear(@nospecialize(A), @nospecialize(B))
     length(A) == length(B) || error("length mismatch")
     isgood = true
     for (iA, iB) in zip(1:length(A), 1:length(B))
@@ -126,10 +126,10 @@ function test_linear(A::ANY, B::ANY)
 end
 
 # "mixed" means 2 indexes even for N-dimensional arrays
-test_mixed{T}(::AbstractArray{T,1}, ::Array) = nothing
-test_mixed{T}(::AbstractArray{T,2}, ::Array) = nothing
+test_mixed(::AbstractArray{T,1}, ::Array) where {T} = nothing
+test_mixed(::AbstractArray{T,2}, ::Array) where {T} = nothing
 test_mixed(A, B::Array) = _test_mixed(A, reshape(B, size(A)))
-function _test_mixed(A::ANY, B::ANY)
+function _test_mixed(@nospecialize(A), @nospecialize(B))
     m = size(A, 1)
     n = size(A, 2)
     isgood = true
@@ -147,7 +147,7 @@ function _test_mixed(A::ANY, B::ANY)
     nothing
 end
 
-function test_bounds(A::ANY)
+function test_bounds(@nospecialize(A))
     @test_throws BoundsError A[0]
     @test_throws BoundsError A[end+1]
     @test_throws BoundsError A[1, 0]
@@ -183,7 +183,7 @@ function runsubarraytests(A::Array, I...)
     test_mixed(S, C)
 end
 
-function runsubarraytests(A::ANY, I...)
+function runsubarraytests(@nospecialize(A), I...)
     # When A was created with view, we have to check bounds, since some
     # of the "residual" dimensions have size 1. It's possible that we
     # need dedicated tests for view.
@@ -238,7 +238,7 @@ function runviews(SB::AbstractArray, indexN, indexNN, indexNNN)
     end
 end
 
-function runviews{T}(SB::AbstractArray{T,2}, indexN, indexNN, indexNNN)
+function runviews(SB::AbstractArray{T,2}, indexN, indexNN, indexNNN) where T
     for i2 in indexN, i1 in indexN
         runsubarraytests(SB, i1, i2)
     end
@@ -247,13 +247,13 @@ function runviews{T}(SB::AbstractArray{T,2}, indexN, indexNN, indexNNN)
     end
 end
 
-function runviews{T}(SB::AbstractArray{T,1}, indexN, indexNN, indexNNN)
+function runviews(SB::AbstractArray{T,1}, indexN, indexNN, indexNNN) where T
     for i1 in indexN
         runsubarraytests(SB, i1)
     end
 end
 
-runviews{T}(SB::AbstractArray{T,0}, indexN, indexNN, indexNNN) = nothing
+runviews(SB::AbstractArray{T,0}, indexN, indexNN, indexNNN) where {T} = nothing
 
 ######### Tests #########
 
@@ -276,7 +276,7 @@ end
 # with the exception of Int-slicing
 oindex = (:, 6, 3:7, reshape([12]), [8,4,6,12,5,7], [3:7 1:5 2:6 4:8 5:9])
 
-_ndims{T,N}(::AbstractArray{T,N}) = N
+_ndims(::AbstractArray{T,N}) where {T,N} = N
 _ndims(x) = 1
 
 if testfull
diff --git a/test/subtype.jl b/test/subtype.jl
index 58a58bc322367c..c2e72f1c689127 100644
--- a/test/subtype.jl
+++ b/test/subtype.jl
@@ -1,3 +1,5 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
 using Base.Bottom
 using Base.Test
 
@@ -5,14 +7,14 @@ macro UnionAll(var, expr)
     Expr(:where, esc(expr), esc(var))
 end
 
-const issub = issubtype
-issub_strict(x::ANY,y::ANY) = issub(x,y) && !issub(y,x)
-isequal_type(x::ANY,y::ANY) = issub(x,y) && issub(y,x)
-notequal_type(x::ANY,y::ANY) = !isequal_type(x, y)
+const issub = (<:)
+issub_strict(@nospecialize(x),@nospecialize(y)) = issub(x,y) && !issub(y,x)
+isequal_type(@nospecialize(x),@nospecialize(y)) = issub(x,y) && issub(y,x)
+notequal_type(@nospecialize(x),@nospecialize(y)) = !isequal_type(x, y)
 
-_type_intersect(x::ANY, y::ANY) = ccall(:jl_intersect_types, Any, (Any, Any), x, y)
+_type_intersect(@nospecialize(x), @nospecialize(y)) = ccall(:jl_intersect_types, Any, (Any, Any), x, y)
 
-intersection_env(x::ANY, y::ANY) = ccall(:jl_env_from_type_intersection, Any, (Any,Any), x, y)
+intersection_env(@nospecialize(x), @nospecialize(y)) = ccall(:jl_env_from_type_intersection, Any, (Any,Any), x, y)
 
 # level 1: no varags, union, UnionAll
 function test_1()
@@ -110,6 +112,10 @@ function test_diagonal()
 
     @test issub_strict(Tuple{Int, Int},
                        (@UnionAll T Tuple{Union{T,String}, T}))
+
+    # don't consider a diagonal variable concrete if it already has an abstract lower bound
+    @test isequal_type(Tuple{Vararg{A}} where A>:Integer,
+                       Tuple{Vararg{A}} where A>:Integer)
 end
 
 # level 3: UnionAll
@@ -440,7 +446,9 @@ function test_Type()
     @test isa(Int, @UnionAll T<:Number Type{T})
     @test !isa(DataType, @UnionAll T<:Number Type{T})
 
-    @test DataType <: (@UnionAll T<:Type Type{T})
+    @test !(DataType <: (@UnionAll T<:Type Type{T}))
+    @test isa(DataType, (@UnionAll T<:Type Type{T}))
+
     @test isa(Tuple{},Type{Tuple{}})
     @test !(Tuple{Int,} <: (@UnionAll T<:Tuple Type{T}))
     @test isa(Tuple{Int}, (@UnionAll T<:Tuple Type{T}))
@@ -451,6 +459,9 @@ function test_Type()
 
     # issue #20476
     @test issub(Tuple{Type{Union{Type{UInt32}, Type{UInt64}}}, Type{UInt32}}, Tuple{Type{T},T} where T)
+
+    @test isequal_type(Core.TypeofBottom, Type{Union{}})
+    @test issub(Core.TypeofBottom, Type{T} where T<:Real)
 end
 
 # old subtyping tests from test/core.jl
@@ -490,13 +501,13 @@ function test_old()
 
     # issue #6561
     # TODO: note that NTuple now means "tuples of all the same type"
-    #@test issubtype(Array{Tuple}, Array{NTuple})
+    #@test (Array{Tuple} <: Array{NTuple})
     @test issub_strict(NTuple, Tuple)
     @test issub_strict(NTuple, Tuple{Vararg})
     @test isequal_type(Tuple, Tuple{Vararg})
-    #@test issubtype(Array{Tuple{Vararg{Any}}}, Array{NTuple})
-    #@test issubtype(Array{Tuple{Vararg}}, Array{NTuple})
-    @test !issubtype(Type{Tuple{Void}}, Tuple{Type{Void}})
+    #@test (Array{Tuple{Vararg{Any}}} <: Array{NTuple})
+    #@test (Array{Tuple{Vararg}} <: Array{NTuple})
+    @test !(Type{Tuple{Void}} <: Tuple{Type{Void}})
 end
 
 const menagerie =
@@ -589,15 +600,25 @@ function test_properties()
 end
 
 macro testintersect(a, b, result)
-    if isa(result,Expr) && result.head === :call && length(result.args)==2 && result.args[1] === :!
+    if isa(result, Expr) && result.head === :call && length(result.args) == 2 && result.args[1] === :!
         result = result.args[2]
-        cmp = :notequal_type
+        cmp = :(!=)
     else
-        cmp = :isequal_type
+        cmp = :(==)
     end
+    cmp = esc(cmp)
+    a = esc(a)
+    b = esc(b)
+    result = esc(result)
     Base.remove_linenums!(quote
-        @test $(esc(cmp))(_type_intersect($(esc(a)), $(esc(b))), $(esc(result)))
-        @test $(esc(cmp))(_type_intersect($(esc(b)), $(esc(a))), $(esc(result)))
+        # test real intersect
+        @test $cmp(_type_intersect($a, $b), $result)
+        @test $cmp(_type_intersect($b, $a), $result)
+        # test simplified intersect
+        if !($result === Union{})
+            @test typeintersect($a, $b) != Union{}
+            @test typeintersect($b, $a) != Union{}
+        end
     end)
 end
 
@@ -613,6 +634,10 @@ abstract type AbstractTriangular{T,S<:AbstractMatrix} <: AbstractMatrix{T} end
 struct UpperTriangular{T,S<:AbstractMatrix} <: AbstractTriangular{T,S} end
 struct UnitUpperTriangular{T,S<:AbstractMatrix} <: AbstractTriangular{T,S} end
 
+struct SIQ20671{T<:Number,m,kg,s,A,K,mol,cd,rad,sr} <: Number
+    val::T
+end
+
 function test_intersection()
     @testintersect(Vector{Float64}, Vector{Union{Float64,Float32}}, Bottom)
 
@@ -801,8 +826,8 @@ function test_intersection()
     @test typeintersect(Union{DataType,Int}, Type) === DataType
     @test typeintersect(Union{DataType,Int}, Type{T} where T) === DataType
 
-    # since BottomType is a singleton we can deduce its intersection with Type{...}
-    @testintersect(Core.BottomType, (Type{T} where T<:Tuple), Type{Union{}})
+    # since TypeofBottom is a singleton we can deduce its intersection with Type{...}
+    @testintersect(Core.TypeofBottom, (Type{T} where T<:Tuple), Type{Union{}})
 
     @testintersect((Type{Tuple{Vararg{T}}} where T), Type{Tuple}, Bottom)
     @testintersect(Tuple{Type{S}, Tuple{Any, Vararg{Any}}} where S<:Tuple{Any, Vararg{Any}},
@@ -814,14 +839,13 @@ function test_intersection()
                    Tuple{Array{Ref{T}, 1}, Array{Pair{M, T}, 1}, SS} where T where M where SS,
                    Union{})
 
-    # TODO: these test cases currently hang
-    @test_skip typeintersect(Tuple{Array{Ref{T}, 1}, Array{Pair{M, V}, 1}, Int} where V where T where M,
-                             Tuple{Array{Ref{T}, 1}, Array{Pair{M, T}, 1}, Any} where T where M) ==
-                                 Tuple{Array{Ref{T}, 1}, Array{Pair{M, T}, 1}, Int}
+    @testintersect(Tuple{Array{Ref{T}, 1}, Array{Pair{M, V}, 1}, Int} where V where T where M,
+                   Tuple{Array{Ref{T}, 1}, Array{Pair{M, T}, 1}, Any} where T where M,
+                   Tuple{Array{Ref{T}, 1}, Array{Pair{M, T}, 1}, Int} where T where M)
 
-    @test_skip typeintersect(Tuple{Int, Ref{Pair{K,V}}} where V where K,
-                             Tuple{Any, Ref{Pair{T,T}} where T }) ==
-                                 Tuple{Int, Ref{Pair{T,T}} where T }
+    @testintersect(Tuple{Int, Ref{Pair{K,V}}} where V where K,
+                   Tuple{Any, Ref{Pair{T,T}} where T },
+                   Tuple{Int, Ref{Pair{T,T}} where T })
 
     @test_broken isequal_type(_type_intersect(Tuple{T,T} where T,
                                               Union{Tuple{S,Array{Int64,1}},Tuple{S,Array{S,1}}} where S),
@@ -853,6 +877,44 @@ function test_intersection()
     @testintersect(Tuple{Ref{Pair{p2,T2}}, Pair{p1,Pair}} where T2 where p2 where p1,
                    Tuple{Ref{Pair{p3,T3}}, Pair{p3}} where T3 where p3,
                    Tuple{Ref{Pair{p1,T2}}, Pair{p1,Pair}} where T2 where p1)
+
+    # issue #20998
+    _, E = intersection_env(Tuple{Int,Any,Any}, Tuple{T,T,S} where {T,S})
+    @test length(E) == 2 && E[1] == Int && isa(E[2], TypeVar)
+    _, E = intersection_env(Tuple{Dict{Int,Type}, Type, Any},
+                            Tuple{Dict{K,V}, Any, Int} where {K,V})
+    @test E[2] == Type
+
+    # issue #20611
+    I, E = intersection_env(Tuple{Ref{Integer},Int,Any}, Tuple{Ref{Z},Z,Z} where Z)
+    @test isequal_type(I, Tuple{Ref{Integer},Int,Integer})
+    @test E[1] == Integer
+
+    # issue #21118
+    A = Tuple{Ref, Vararg{Any}}
+    B = Tuple{Vararg{Union{Z,Ref,Void}}} where Z<:Union{Ref,Void}
+    @test B <: _type_intersect(A, B)
+    @testintersect(Tuple{Int,Any,Vararg{A}} where A>:Integer,
+                   Tuple{Any,Int,Vararg{A}} where A>:Integer,
+                   Tuple{Int,Int,Vararg{A}} where A>:Integer)
+
+    # issue #21132
+    @testintersect(Pair{L,Tuple{L,Pair{L,HL}}} where {L,HL},
+                   Pair{R,Tuple{Pair{R,HR},R}} where {R,HR},
+                   Bottom)  # X == Pair{X,...} is not satisfiable
+
+    # issue #20671 --- this just took too long
+    @testintersect(Tuple{Type{SIQ20671{T, mT, kgT, sT, AT, KT, molT, cdT, radT, srT}},
+                         SIQ20671{S, mS, kgS, sS, AS, KS, molS, cdS, radS, srS}} where {T, mT, kgT, sT, AT, KT, molT, cdT, radT, srT,
+                                                                                        S, mS, kgS, sS, AS, KS, molS, cdS, radS, srS},
+                   Tuple{Type{T}, T} where T,
+                   Tuple{Type{SIQ20671{T,mS,kgS,sS,AS,KS,molS,cdS,radS,srS}},
+                         SIQ20671{T,mS,kgS,sS,AS,KS,molS,cdS,radS,srS}} where {T,mS,kgS,sS,AS,KS,molS,cdS,radS,srS})
+
+    # issue #21243
+    @testintersect(Tuple{Ref{Ref{T}} where T, Ref},
+                   Tuple{Ref{T}, Ref{T}} where T,
+                   Tuple{Ref{Ref{T}}, Ref{Ref{T}}} where T)
 end
 
 function test_intersection_properties()
@@ -890,13 +952,13 @@ test_intersection_properties()
 # Issue #12580
 abstract type AbstractMyType12580{T} end
 struct MyType12580{T}<:AbstractMyType12580{T} end
-tpara{A<:AbstractMyType12580}(::Type{A}) = tpara(supertype(A))
-tpara{I}(::Type{AbstractMyType12580{I}}) = I
+tpara(::Type{A}) where {A<:AbstractMyType12580} = tpara(supertype(A))
+tpara(::Type{AbstractMyType12580{I}}) where {I} = I
 @test tpara(MyType12580{true})
 
 # Issue #18348
-f18348{T<:Any}(::Type{T}, x) = 1
-f18348{T<:Any}(::Type{T}, x::T) = 2
+f18348(::Type{T}, x) where {T<:Any} = 1
+f18348(::Type{T}, x::T) where {T<:Any} = 2
 @test length(methods(f18348, Tuple{Type{Any},Any})) == 1
 
 # Issue #13165
@@ -905,7 +967,7 @@ f18348{T<:Any}(::Type{T}, x::T) = 2
 @test Hermitian{Complex{Float64},Matrix{Complex{Float64}}} <: LinAlg.RealHermSymComplexHerm
 
 # Issue #12721
-f12721{T<:Type{Int}}(::T) = true
+f12721(::T) where {T<:Type{Int}} = true
 @test_throws MethodError f12721(Float64)
 
 # implicit "covariant" type parameters:
@@ -938,3 +1000,133 @@ ftwoparams(::TwoParams{<:Real,<:Real}) = 3
 # supertype operator
 @test !(Int >: Integer)
 @test Integer >: Int
+
+# tolerate non-types in Tuples
+@test typeintersect(Tuple{0}, Tuple{T} where T) === Tuple{0}
+
+# TypeVars deduced as non-type constants (#20869)
+@testintersect(Tuple{Val{0}, Val{Val{N}}} where N, Tuple{Val{N}, Val{Val{N}}} where N, Tuple{Val{0},Val{Val{0}}})
+@testintersect(Tuple{Val{N}, Val{Val{0}}} where N, Tuple{Val{N}, Val{Val{N}}} where N, Tuple{Val{0},Val{Val{0}}})
+
+@testintersect(Tuple{Val{Val{0}}, Val{N}} where N, Tuple{Val{Val{N}}, Val{N}} where N, Tuple{Val{Val{0}},Val{0}})
+@testintersect(Tuple{Val{Val{N}}, Val{0}} where N, Tuple{Val{Val{N}}, Val{N}} where N, Tuple{Val{Val{0}},Val{0}})
+
+# a bunch of cases found by fuzzing
+let a = Tuple{Float64,T7} where T7,
+    b = Tuple{S5,Tuple{S5}} where S5
+    @test_broken typeintersect(a, b) <: b
+end
+let a = Tuple{T1,T1} where T1,
+    b = Tuple{Val{S2},S6} where S2 where S6
+    @test_broken typeintersect(a, b) == typeintersect(b, a)
+end
+let a = Val{Tuple{T1,T1}} where T1,
+    b = Val{Tuple{Val{S2},S6}} where S2 where S6
+    @testintersect(a, b, Val{Tuple{Val{T},Val{T}}} where T)
+end
+let a = Tuple{Float64,T3,T4} where T4 where T3,
+    b = Tuple{S2,Tuple{S3},S3} where S2 where S3
+    @test_broken typeintersect(a, b) == typeintersect(b, a)
+end
+let a = Tuple{T1,Tuple{T1}} where T1,
+    b = Tuple{Float64,S3} where S3
+    @test_broken typeintersect(a, b) <: a
+end
+let a = Tuple{5,T4,T5} where T4 where T5,
+    b = Tuple{S2,S3,Tuple{S3}} where S2 where S3
+    @test_broken typeintersect(a, b) == typeintersect(b, a)
+end
+let a = Tuple{T2,Tuple{T4,T2}} where T4 where T2,
+    b = Tuple{Float64,Tuple{Tuple{S3},S3}} where S3
+    @test_broken typeintersect(a, b) <: b
+end
+let a = Tuple{Tuple{T2,4},T6} where T2 where T6,
+    b = Tuple{Tuple{S2,S3},Tuple{S2}} where S2 where S3
+    @test_broken typeintersect(a, b) == typeintersect(b, a)
+end
+let a = Tuple{T3,Int64,Tuple{T3}} where T3,
+    b = Tuple{S3,S3,S4} where S4 where S3
+    @test_broken typeintersect(a, b) <: a
+end
+let a = Tuple{T1,Val{T2},T2} where T2 where T1,
+    b = Tuple{Float64,S1,S2} where S2 where S1
+    @test_broken typeintersect(a, b) == typeintersect(b, a)
+end
+let a = Tuple{T1,Val{T2},T2} where T2 where T1,
+    b = Tuple{Float64,S1,S2} where S2 where S1
+    @test_broken typeintersect(a, b) <: a
+end
+let a = Tuple{Float64,T1} where T1,
+    b = Tuple{S1,Tuple{S1}} where S1
+    @test_broken typeintersect(a, b) <: b
+end
+let a = Tuple{Val{T1},T2,T2} where T2 where T1,
+    b = Tuple{Val{Tuple{S2}},S3,Float64} where S2 where S3
+    @testintersect(a, b, Tuple{Val{Tuple{S2}},Float64,Float64} where S2)
+end
+let a = Tuple{T1,T2,T2} where T1 where T2,
+    b = Tuple{Val{S2},S2,Float64} where S2,
+    x = Tuple{Val{Float64},Float64,Float64}
+    @test_broken x <: typeintersect(a, b)
+end
+let a = Val{Tuple{T1,Val{T2},Val{Int64},Tuple{Tuple{T3,5,Float64},T4,T2,T5}}} where T1 where T5 where T4 where T3 where T2,
+    b = Val{Tuple{Tuple{S1,5,Float64},Val{S2},S3,Tuple{Tuple{Val{Float64},5,Float64},2,Float64,S4}}} where S2 where S3 where S1 where S4
+    @test_skip typeintersect(b, a)
+end
+
+# issue #20992
+abstract type A20992{T,D,d} end
+abstract type B20992{SV,T,D,d} <: A20992{T,D,d} end
+struct C20992{S,n,T,D,d} <: B20992{NTuple{n,S},T,D,d}
+end
+@testintersect(Tuple{A20992{R, D, d} where d where D, Int} where R,
+               Tuple{C20992{S, n, T, D, d} where d where D where T where n where S, Any},
+               Tuple{C20992, Int})
+
+# Issue #19414
+let ex = try struct A19414 <: Base.AbstractSet end catch e; e end
+    @test isa(ex, ErrorException) && ex.msg == "invalid subtyping in definition of A19414"
+end
+
+# issue #20103, OP and comments
+struct TT20103{X,Y} end
+f20103(::Type{TT20103{X,Y}},x::X,y::Y) where {X,Y} = 1
+f20103(::Type{TT20103{X,X}},x::X) where {X} = 100
+@test_broken typeintersect(Type{NTuple{N,E}} where E where N, Type{NTuple{N,E} where N} where E) == Union{} # use @testintersect once fixed
+let ints = (Int, Int32, UInt, UInt32)
+    const Ints = Union{ints...}
+    vecs = []
+    for i = 2:4, t in ints
+        push!(vecs, NTuple{i, t})
+    end
+    const Vecs = Union{vecs...}
+    T = Type{Tuple{V, I}} where V <: Vecs where I <: Ints
+    @testintersect(T, T, T)
+    test(a::Type{Tuple{V, I}}) where {V <: Vecs, I <: Ints} = I
+    test(a::Type{Tuple{V, I}}) where {V <: Vecs, I <: Ints} = I
+end
+
+# issue #21191
+let T1 = Val{Val{Val{Union{Int8,Int16,Int32,Int64,UInt8,UInt16}}}},
+    T2 = Val{Val{Val{Union{Int8,Int16,Int32,Int64,UInt8, S}}}} where S
+    @test T1 <: T2
+end
+
+# issue #21613
+abstract type A21613{S <: Tuple} end
+struct B21613{S <: Tuple, L} <: A21613{S}
+    data::NTuple{L,Float64}
+end
+@testintersect(Tuple{Type{B21613{Tuple{L},L}} where L, Any},
+               Tuple{Type{SA}, Tuple} where SA<:(A21613{S} where S<:Tuple),
+               Tuple{Type{B21613{Tuple{L},L}} where L, Tuple})
+
+# issue #22239
+@testintersect(Val{Pair{T,T}} where T,
+               Val{Pair{Int,T}} where T,
+               Val{Pair{Int,Int}})
+
+# issue #23024
+@testintersect(Tuple{DataType, Any},
+               Tuple{Type{T}, Int} where T,
+               Tuple{DataType, Int})
diff --git a/test/sysinfo.jl b/test/sysinfo.jl
index 261935ac715f15..a34adf572abe43 100644
--- a/test/sysinfo.jl
+++ b/test/sysinfo.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # We can't guarantee that these are correct, but we can at least check
 # that they run
diff --git a/test/test.jl b/test/test.jl
index cdd45a37ff980d..5bb97f6510bd6a 100644
--- a/test/test.jl
+++ b/test/test.jl
@@ -1,11 +1,32 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Test @test
 @test true
 @test 1 == 1
 @test 1 != 2
+@test ==(1, 1)
+@test ==((1, 1)...)
+@test 1 ≈ 2 atol=1
 @test strip("\t  hi   \n") == "hi"
 @test strip("\t  this should fail   \n") != "hi"
+@test isequal(1, 1)
+@test isapprox(1, 1, atol=0.1)
+@test isapprox(1, 1; atol=0.1)
+@test isapprox(1, 1; [(:atol, 0)]...)
+
+# @test keyword precedence: post-semicolon keyword, suffix keyword, pre-semicolon keyword
+@test isapprox(1, 2, atol=0) atol=1
+@test isapprox(1, 3, atol=0; atol=2) atol=1
+
+# @test should only evaluate the arguments once
+let g = Int[], f = (x) -> (push!(g, x); x)
+    @test f(1) == 1
+    @test g == [1]
+
+    empty!(g)
+    @test isequal(f(2), 2)
+    @test g == [2]
+end
 
 # Test @test_broken with fail
 @test_broken false
@@ -43,8 +64,10 @@ a[1,1,1,1,1] = 10
 @test rand() != rand()
 
 # Pass - exception
-@test contains(sprint(show, @test_throws ErrorException error()),
-                "Thrown: ErrorException")
+@test endswith(sprint(show, @test_throws ErrorException error()),
+               "Thrown: ErrorException")
+@test endswith(sprint(show, @test_throws ErrorException("test") error("test")),
+               "Thrown: ErrorException")
 
 # Test printing of Fail results
 mutable struct NoThrowTestSet <: Base.Test.AbstractTestSet
@@ -60,16 +83,95 @@ fails = @testset NoThrowTestSet begin
     @test_throws OverflowError 1 + 1
     # Fail - comparison
     @test 1+1 == 2+2
+    # Fail - approximate comparison
+    @test 1/1 ≈ 2/1
+    # Fail - chained comparison
+    @test 1+0 == 2+0 == 3+0
+    # Fail - comparison call
+    @test ==(1 - 2, 2 - 1)
+    # Fail - splatting
+    @test ==(1:2...)
+    # Fail - isequal
+    @test isequal(0 / 0, 1 / 0)
+    # Fail - function splatting
+    @test isequal(1:2...)
+    # Fail - isapprox
+    @test isapprox(0 / 1, -1 / 0)
+    # Fail - function with keyword
+    @test isapprox(1 / 2, 2 / 1, atol=1 / 1)
+    @test isapprox(1 - 2, 2 - 1; atol=1 - 1)
+    # Fail - function keyword splatting
+    k = [(:atol, 0), (:nans, true)]
+    @test isapprox(1, 2; k...)
     # Error - unexpected pass
     @test_broken true
+    # Error - converting a call into a comparison
+    @test ==(1, 1:2...)
 end
-for i in 1:3
+for i in 1:length(fails) - 2
     @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: 2 == 4")
-@test contains(sprint(show, fails[4]), "Unexpected Pass")
+
+str = sprint(show, fails[1])
+@test contains(str, "Expression: error()")
+@test contains(str, "Thrown: ErrorException")
+
+str = sprint(show, fails[2])
+@test contains(str, "Expression: 1 + 1")
+@test contains(str, "No exception thrown")
+
+str = sprint(show, fails[3])
+@test contains(str, "Expression: 1 + 1 == 2 + 2")
+@test contains(str, "Evaluated: 2 == 4")
+
+str = sprint(show, fails[4])
+@test contains(str, "Expression: 1 / 1 ≈ 2 / 1")
+@test contains(str, "Evaluated: 1.0 ≈ 2.0")
+
+str = sprint(show, fails[5])
+@test contains(str, "Expression: 1 + 0 == 2 + 0 == 3 + 0")
+@test contains(str, "Evaluated: 1 == 2 == 3")
+
+str = sprint(show, fails[6])
+@test contains(str, "Expression: 1 - 2 == 2 - 1")
+@test contains(str, "Evaluated: -1 == 1")
+
+str = sprint(show, fails[7])
+@test contains(str, "Expression: (==)(1:2...)")
+@test !contains(str, "Evaluated")
+
+str = sprint(show, fails[8])
+@test contains(str, "Expression: isequal(0 / 0, 1 / 0)")
+@test contains(str, "Evaluated: isequal(NaN, Inf)")
+
+str = sprint(show, fails[9])
+@test contains(str, "Expression: isequal(1:2...)")
+@test contains(str, "Evaluated: isequal(1, 2)")
+
+str = sprint(show, fails[10])
+@test contains(str, "Expression: isapprox(0 / 1, -1 / 0)")
+@test contains(str, "Evaluated: isapprox(0.0, -Inf)")
+
+str = sprint(show, fails[11])
+@test contains(str, "Expression: isapprox(1 / 2, 2 / 1, atol=1 / 1)")
+@test contains(str, "Evaluated: isapprox(0.5, 2.0; atol=1.0)")
+
+str = sprint(show, fails[12])
+@test contains(str, "Expression: isapprox(1 - 2, 2 - 1; atol=1 - 1)")
+@test contains(str, "Evaluated: isapprox(-1, 1; atol=0)")
+
+str = sprint(show, fails[13])
+@test contains(str, "Expression: isapprox(1, 2; k...)")
+@test contains(str, "Evaluated: isapprox(1, 2; atol=0, nans=true)")
+
+str = sprint(show, fails[14])
+@test contains(str, "Unexpected Pass")
+@test contains(str, "Expression: true")
+
+str = sprint(show, fails[15])
+@test contains(str, "Expression: ==(1, 1:2...)")
+@test contains(str, "MethodError: no method matching ==(::$Int, ::$Int, ::$Int)")
+
 
 # Test printing of a TestSetException
 tse_str = sprint(show, Test.TestSetException(1,2,3,4,Vector{Union{Base.Test.Error, Base.Test.Fail}}()))
@@ -257,6 +359,18 @@ end
 @test counter_17462_pre == 3
 @test counter_17462_post == 1
 
+# Issue #21008
+ts = try
+    @testset "@test_broken and @test_skip should not give an exception" begin
+        @test_broken false
+        @test_skip true
+        @test_skip false
+    end
+catch
+    nothing # Shouldn't get here
+end
+@test ts isa Base.Test.DefaultTestSet
+
 # now we're done running tests with DefaultTestSet so we can go back to STDOUT
 redirect_stdout(OLD_STDOUT)
 redirect_stderr(OLD_STDERR)
@@ -404,6 +518,8 @@ end
 io = IOBuffer()
 @test (print(io, Base.Test.Error(:test_error, "woot", 5, backtrace())); 1) == 1
 str = String(take!(io))
+# NOTE: This test depends on the code generated by @testset getting compiled,
+# to get good backtraces. If it fails, check the implementation of `testset_beginend`.
 @test contains(str, "test.jl")
 @test !contains(str, "boot.jl")
 
@@ -426,7 +542,7 @@ let io = IOBuffer()
     @test !contains(str, "backtrace()")
 end
 
-msg = readstring(pipeline(ignorestatus(`$(Base.julia_cmd()) --startup-file=no --color=no -e '
+msg = read(pipeline(ignorestatus(`$(Base.julia_cmd()) --startup-file=no --color=no -e '
 using Base.Test
 
 foo(x) = length(x)^2
@@ -444,7 +560,7 @@ foo(x) = length(x)^2
         @test foo(zeros(2)) == 4
         @test foo(ones(4)) == 15
     end
-end'`), stderr=DevNull))
+end'`), stderr=DevNull), String)
 
 @test contains(msg,
 """
@@ -457,7 +573,7 @@ Foo Tests     |    2     2      4
 """)
 
 # 20489
-msg = split(readstring(pipeline(ignorestatus(`$(Base.julia_cmd()) --startup-file=no --color=no -e '
-Test.print_test_results(Test.DefaultTestSet(""))'`), stderr=DevNull)), "\n")[1]
+msg = split(read(pipeline(ignorestatus(`$(Base.julia_cmd()) --startup-file=no --color=no -e '
+Test.print_test_results(Test.DefaultTestSet(""))'`), stderr=DevNull), String), "\n")[1]
 
 @test msg == rstrip(msg)
diff --git a/test/test_exec.jl b/test/test_exec.jl
index 0e53cf236c61db..529f9f63ea4937 100644
--- a/test/test_exec.jl
+++ b/test/test_exec.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base.Test
 # Check that the fallback test set throws immediately
diff --git a/test/test_sourcepath.jl b/test/test_sourcepath.jl
index 1e4f55b5b287c8..60985b823a9ceb 100644
--- a/test/test_sourcepath.jl
+++ b/test/test_sourcepath.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # source path in tasks
 path = Base.source_path()::String # this variable is leaked to the source script
diff --git a/test/testdefs.jl b/test/testdefs.jl
index dad9cb738d99af..bc214dab6fcf44 100644
--- a/test/testdefs.jl
+++ b/test/testdefs.jl
@@ -1,11 +1,13 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 function runtests(name, isolate=true)
     old_print_setting = Base.Test.TESTSET_PRINT_ENABLE[]
     Base.Test.TESTSET_PRINT_ENABLE[] = false
     try
         if isolate
-            mod_name = Symbol("TestMain_", replace(name, '/', '_'))
+            # Simple enough to type and random enough so that no one will hard
+            # code it in the test
+            mod_name = Symbol("Test", rand(1:100), "Main_", replace(name, '/', '_'))
             m = @eval(Main, module $mod_name end)
         else
             m = Main
@@ -36,4 +38,5 @@ end
 
 # looking in . messes things up badly
 filter!(x->x!=".", LOAD_PATH)
-nothing
+
+nothing # File is loaded via a remotecall to "include". Ensure it returns "nothing".
diff --git a/test/testenv.jl b/test/testenv.jl
new file mode 100644
index 00000000000000..6447d6e342d094
--- /dev/null
+++ b/test/testenv.jl
@@ -0,0 +1,35 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
+# This includes a few helper variables and functions that provide information about the
+# test environment (command line flags, current module, etc).
+# This file can be included multiple times in the same module if necessary,
+# which can happen with unisolated test runs.
+
+if !@isdefined(testenv_defined)
+    const testenv_defined = true
+    if haskey(ENV, "JULIA_TEST_EXEFLAGS")
+        const test_exeflags = `$(Base.shell_split(ENV["JULIA_TEST_EXEFLAGS"]))`
+    else
+        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
+        const test_exeflags = `$cov_flag $inline_flag --check-bounds=yes --startup-file=no --depwarn=error`
+    end
+
+    if haskey(ENV, "JULIA_TEST_EXENAME")
+        const test_exename = `$(Base.shell_split(ENV["JULIA_TEST_EXENAME"]))`
+    else
+        const test_exename = `$(joinpath(JULIA_HOME, Base.julia_exename()))`
+    end
+
+    addprocs_with_testenv(X; kwargs...) = addprocs(X; exename=test_exename, exeflags=test_exeflags, kwargs...)
+
+    const curmod = @__MODULE__
+    const curmod_name = fullname(curmod)
+    const curmod_str = curmod === Main ? "Main" : join(curmod_name, ".")
+    const curmod_prefix = "$(["$m." for m in curmod_name]...)"
+end
diff --git a/test/threads.jl b/test/threads.jl
index d0626fdbc3d79e..fc0a1d984a84b1 100644
--- a/test/threads.jl
+++ b/test/threads.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base.Test
 using Base.Threads
@@ -34,7 +34,7 @@ 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)
+function check_minmax_consistency(old::Array{T,1}, m::T, start::T, o::Base.Ordering) where T
     for v in old
         if v != start
             # Check that atomic op that installed v reported consistent old value.
@@ -43,7 +43,7 @@ function check_minmax_consistency{T}(old::Array{T,1}, m::T, start::T, o::Base.Or
     end
 end
 
-function test_threaded_atomic_minmax{T}(m::T,n::T)
+function test_threaded_atomic_minmax(m::T,n::T) where T
     mid = m + (n-m)>>1
     x = Atomic{T}(mid)
     y = Atomic{T}(mid)
@@ -63,7 +63,7 @@ end
 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)
+function threaded_add_locked(::Type{LockT}, x, n) where LockT
     critical = LockT()
     @threads for i = 1:n
         @test lock(critical) === nothing
@@ -119,7 +119,7 @@ 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})
+function threaded_gc_locked(::Type{LockT}) where LockT
     critical = LockT()
     @threads for i = 1:20
         @test lock(critical) === nothing
@@ -136,7 +136,7 @@ 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()
+orig_curmodule14726 = @__MODULE__
 main_var14726 = 1
 module M14726
 module_var14726 = 1
@@ -147,15 +147,15 @@ end
         @eval M14726 module_var14726 = $j
     end
 end
-@test isdefined(:orig_curmodule14726)
-@test isdefined(:main_var14726)
-@test current_module() == orig_curmodule14726
+@test @isdefined(orig_curmodule14726)
+@test @isdefined(main_var14726)
+@test @__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
+    @test @__MODULE__() == orig_curmodule14726
 end
 
 module M14726_2
@@ -166,7 +166,7 @@ using Base.Threads
     # 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
+    @test @__MODULE__() == M14726_2
 end
 end
 
@@ -296,7 +296,7 @@ let atomic_types = [Int8, Int16, Int32, Int64, Int128,
 end
 
 # Test atomic_cas! and atomic_xchg!
-function test_atomic_cas!{T}(var::Atomic{T}, range::StepRange{Int,Int})
+function test_atomic_cas!(var::Atomic{T}, range::StepRange{Int,Int}) where T
     for i in range
         while true
             old = atomic_cas!(var, T(i-1), T(i))
@@ -316,7 +316,7 @@ for T in (Int32, Int64, Float32, Float64)
     @test var[] === T(nloops)
 end
 
-function test_atomic_xchg!{T}(var::Atomic{T}, i::Int, accum::Atomic{Int})
+function test_atomic_xchg!(var::Atomic{T}, i::Int, accum::Atomic{Int}) where T
     old = atomic_xchg!(var, T(i))
     atomic_add!(accum, Int(old))
 end
@@ -330,7 +330,7 @@ for T in (Int32, Int64, Float32, Float64)
     @test accum[] + Int(var[]) === sum(0:nloops)
 end
 
-function test_atomic_float{T}(varadd::Atomic{T}, varmax::Atomic{T}, varmin::Atomic{T}, i::Int)
+function test_atomic_float(varadd::Atomic{T}, varmax::Atomic{T}, varmin::Atomic{T}, i::Int) where T
     atomic_add!(varadd, T(i))
     atomic_max!(varmax, T(i))
     atomic_min!(varmin, T(i))
@@ -381,6 +381,23 @@ for period in (0.06, Dates.Millisecond(60))
     end
 end
 
+complex_cfunction = function(a)
+    s = zero(eltype(a))
+    @inbounds @simd for i in a
+        s += muladd(a[i], a[i], -2)
+    end
+    return s
+end
+function test_thread_cfunction()
+    @threads for i in 1:1000
+        # Make sure this is not inferrable
+        # and a runtime call to `jl_function_ptr` will be created
+        ccall(:jl_function_ptr, Ptr{Void}, (Any, Any, Any),
+              complex_cfunction, Float64, Tuple{Ref{Vector{Float64}}})
+    end
+end
+test_thread_cfunction()
+
 # Compare the two ways of checking if threading is enabled.
 # `jl_tls_states` should only be defined on non-threading build.
 if ccall(:jl_threading_enabled, Cint, ()) == 0
@@ -390,6 +407,20 @@ else
     @test_throws ErrorException cglobal(:jl_tls_states)
 end
 
+function test_thread_range()
+    a = zeros(Int, nthreads())
+    @threads for i in 1:threadid()
+        a[i] = 1
+    end
+    for i in 1:threadid()
+        @test a[i] == 1
+    end
+    for i in (threadid() + 1):nthreads()
+        @test a[i] == 0
+    end
+end
+test_thread_range()
+
 # Thread safety of `jl_load_and_lookup`.
 function test_load_and_lookup_18020(n)
     @threads for i in 1:n
@@ -401,3 +432,20 @@ function test_load_and_lookup_18020(n)
     end
 end
 test_load_and_lookup_18020(10000)
+
+# Nested threaded loops
+# This may not be efficient/fully supported but should work without crashing.....
+function test_nested_loops()
+    a = zeros(Int, 100, 100)
+    @threads for i in 1:100
+        @threads for j in 1:100
+            a[j, i] = i + j
+        end
+    end
+    for i in 1:100
+        for j in 1:100
+            @test a[j, i] == i + j
+        end
+    end
+end
+test_nested_loops()
diff --git a/test/topology.jl b/test/topology.jl
index 52cdad0ffc8c18..4c1b982152e31d 100644
--- a/test/topology.jl
+++ b/test/topology.jl
@@ -1,10 +1,10 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
-include("testdefs.jl")
-addprocs(4; topology="master_slave")
-using Base.Test
+pids = addprocs_with_testenv(4; topology="master_slave")
+p1 = pids[1]
+p2 = pids[2]
 
-@test_throws RemoteException remotecall_fetch(()->remotecall_fetch(myid, 3), 2)
+@test_throws RemoteException remotecall_fetch(()->remotecall_fetch(myid, p2), p1)
 
 function test_worker_counts()
     # check if the nprocs/nworkers/workers are the same on the remaining workers
@@ -21,7 +21,7 @@ end
 
 function remove_workers_and_test()
     while nworkers() > 0
-        rmprocs(workers()[1]; waitfor=2.0)
+        rmprocs(workers()[1])
         test_worker_counts()
         if nworkers() == nprocs()
             break
@@ -41,12 +41,15 @@ function Base.launch(manager::TopoTestManager, params::Dict, launched::Array, c:
     exename = params[:exename]
     exeflags = params[:exeflags]
 
+    cmd = `$exename $exeflags --bind-to $(Base.Distributed.LPROC.bind_addr) --worker`
+    cmd = pipeline(detach(setenv(cmd, dir=dir)))
     for i in 1:manager.np
-        io, pobj = open(pipeline(detach(
-            setenv(`$(Base.julia_cmd(exename)) $exeflags --bind-to $(Base.LPROC.bind_addr) --worker $(Base.cluster_cookie())`, dir=dir)); stderr=STDERR), "r")
+        io = open(cmd, "r+")
+        Base.Distributed.write_cookie(io)
+
         wconfig = WorkerConfig()
-        wconfig.process = pobj
-        wconfig.io = io
+        wconfig.process = io
+        wconfig.io = io.out
         wconfig.ident = i
         wconfig.connect_idents = collect(i+2:2:manager.np)
         push!(launched, wconfig)
@@ -64,7 +67,7 @@ function Base.manage(manager::TopoTestManager, id::Integer, config::WorkerConfig
     end
 end
 
-addprocs(TopoTestManager(8); topology="custom")
+addprocs_with_testenv(TopoTestManager(8); topology="custom")
 
 while true
     if any(x->get(map_pid_ident, x, 0)==0, workers())
@@ -87,3 +90,48 @@ for p1 in workers()
 end
 
 remove_workers_and_test()
+
+# test `lazy` connection setup
+function def_count_conn()
+    @everywhere function count_connected_workers()
+        count(x -> isa(x, Base.Distributed.Worker) && isdefined(x, :r_stream) && isopen(x.r_stream),
+                Base.Distributed.PGRP.workers)
+    end
+end
+
+addprocs_with_testenv(8)
+def_count_conn()
+
+# Test for 10 random combinations
+wl = workers()
+combinations = []
+while length(combinations) < 10
+    from = rand(wl)
+    to = rand(wl)
+    if from == to || ((from,to) in combinations) || ((to,from) in combinations)
+        continue
+    else
+        push!(combinations, (from,to))
+    end
+end
+
+# Initially only master-slave connections ought to be setup
+expected_num_conns = 8
+num_conns = sum(asyncmap(p->remotecall_fetch(count_connected_workers,p), workers()))
+@test num_conns == expected_num_conns
+
+for (i, (from,to)) in enumerate(combinations)
+    remotecall_wait(topid->remotecall_fetch(myid, topid), from, to)
+    expected_num_conns += 2    # one connection endpoint on both from and to
+    num_conns = sum(asyncmap(p->remotecall_fetch(count_connected_workers,p), workers()))
+    @test num_conns == expected_num_conns
+end
+
+# With lazy=false, all connections ought to be setup during `addprocs`
+rmprocs(workers())
+addprocs_with_testenv(8; lazy=false)
+def_count_conn()
+@test sum(asyncmap(p->remotecall_fetch(count_connected_workers,p), workers())) == 64
+
+# Cannot add more workers with a different `lazy` value
+@test_throws ArgumentError addprocs_with_testenv(1; lazy=true)
diff --git a/test/triplequote.jl b/test/triplequote.jl
index 074afec18a22ca..35bc1fa593b7a5 100644
--- a/test/triplequote.jl
+++ b/test/triplequote.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # triple-quote delimited strings
 @test """abc""" == "abc"
diff --git a/test/tuple.jl b/test/tuple.jl
index 9f2496d3640078..f6e5f7c789eb9c 100644
--- a/test/tuple.jl
+++ b/test/tuple.jl
@@ -1,7 +1,50 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
-@test convert(Tuple, (1,2)) == (1,2)
-@testset "indexing" begin
+struct BitPerm_19352
+    p::NTuple{8,UInt8}
+    function BitPerm(p::NTuple{8,UInt8})
+        sort(collect(p)) != collect(0:7) && error("$p is not a permutation of 0:7")
+        new(p)
+    end
+    BitPerm_19352(xs::Vararg{Any,8}) = BitPerm(map(UInt8, xs))
+end
+
+@testset "conversion and construction" begin
+    @test convert(Tuple, (1,2)) == (1,2)
+
+    # PR #15516
+    @test Tuple{Char,Char}("za") === ('z','a')
+    @test_throws ArgumentError Tuple{Char,Char}("z")
+
+    @test NTuple{20,Int}(Iterators.countfrom(2)) === (2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21)
+    @test NTuple{20,Float64}(Iterators.countfrom(2)) === (2.,3.,4.,5.,6.,7.,8.,9.,10.,11.,12.,13.,14.,15.,16.,17.,18.,19.,20.,21.)
+    @test_throws ArgumentError NTuple{20,Int}([1,2])
+
+    @test Tuple{Vararg{Float32}}(Float64[1,2,3]) === (1.0f0, 2.0f0, 3.0f0)
+    @test Tuple{Int,Vararg{Float32}}(Float64[1,2,3]) === (1, 2.0f0, 3.0f0)
+    @test Tuple{Int,Vararg{Any}}(Float64[1,2,3]) === (1, 2.0, 3.0)
+    @test Tuple(ones(5)) === (1.0,1.0,1.0,1.0,1.0)
+    @test_throws MethodError convert(Tuple, ones(5))
+
+    @testset "ambiguity between tuple constructors #20990" begin
+        Tuple16Int = Tuple{Int,Int,Int,Int,Int,Int,Int,Int,Int,Int,Int,Int,Int,Int,Int,Int}
+        tuple16int = (1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1)
+        @test Tuple16Int(tuple16int) isa Tuple16Int
+    end
+
+    @testset "side effect in tuple constructor #19352" begin
+        @test BitPerm_19352(0,2,4,6,1,3,5,7).p[2] == 0x02
+    end
+
+    @testset "ninitialized" begin
+        @test Tuple{Int,Any}.ninitialized == 2
+        @test Tuple.ninitialized == 0
+        @test Tuple{Int,Vararg{Any}}.ninitialized == 1
+        @test Tuple{Any,Any,Vararg{Any}}.ninitialized == 2
+    end
+end
+
+@testset "size" begin
     @test length(()) == 0
     @test length((1,)) === 1
     @test length((1,2)) === 2
@@ -16,181 +59,212 @@
     @test size((), 1) === 0
     @test size((1,), 1) === 1
     @test size((1,2), 1) === 2
-end
-# @test_throws ArgumentError size((), 2)
-# @test_throws ArgumentError size((1,), 2)
-# @test_throws ArgumentError size((1,2), 2)
-
-@test getindex((1,), 1) === 1
-@test getindex((1,2), 2) === 2
-@test_throws BoundsError getindex((), 1)
-@test_throws BoundsError getindex((1,2), 0)
-@test_throws BoundsError getindex((1,2), -1)
 
-@test getindex((1,), 1.0) === 1
-@test getindex((1,2), 2.0) === 2
-@test_throws BoundsError getindex((), 1.0)
-@test_throws BoundsError getindex((1,2), 0.0)
-@test_throws BoundsError getindex((1,2), -1.0)
-
-@test getindex((5,6,7,8), [1,2,3]) === (5,6,7)
-@test_throws BoundsError getindex((1,2), [3,4])
+    # @test_throws ArgumentError size((), 2)
+    # @test_throws ArgumentError size((1,), 2)
+    # @test_throws ArgumentError size((1,2), 2)
+end
 
-@test getindex((5,6,7,8), [true, false, false, true]) === (5,8)
-@test_throws BoundsError getindex((5,6,7,8), [true, false, false, true, true])
+@testset "indexing" begin
+    @test getindex((1,), 1) === 1
+    @test getindex((1,2), 2) === 2
+    @test_throws BoundsError getindex((), 1)
+    @test_throws BoundsError getindex((1,2), 0)
+    @test_throws BoundsError getindex((1,2), -1)
+
+    @test getindex((1,), 1.0) === 1
+    @test getindex((1,2), 2.0) === 2
+    @test_throws BoundsError getindex((), 1.0)
+    @test_throws BoundsError getindex((1,2), 0.0)
+    @test_throws BoundsError getindex((1,2), -1.0)
+
+    @test getindex((5,6,7,8), [1,2,3]) === (5,6,7)
+    @test_throws BoundsError getindex((1,2), [3,4])
+
+    @test getindex((5,6,7,8), [true, false, false, true]) === (5,8)
+    @test_throws BoundsError getindex((5,6,7,8), [true, false, false, true, true])
+
+    @test getindex((5,6,7,8), []) === ()
+
+    @testset "boolean arrays" begin
+        # issue #19719
+        @test_throws BoundsError (1,2,3)[falses(4)]
+        @test_throws BoundsError (1,2,3)[[false,false,true,true]]
+        @test_throws BoundsError (1,2,3)[trues(2)]
+        @test_throws BoundsError (1,2,3)[falses(2)]
+        @test_throws BoundsError ()[[false]]
+        @test_throws BoundsError ()[[true]]
+    end
 
-@test getindex((5,6,7,8), []) === ()
+    @testset "Multidimensional indexing (issue #20453)" begin
+        @test_throws MethodError (1,)[]
+        @test_throws MethodError (1,1,1)[1,1]
+    end
+end
 
-## filling to specified length
-@test @inferred(Base.fill_to_length((1,2,3), -1, Val{5})) == (1,2,3,-1,-1)
-@test_throws ArgumentError Base.fill_to_length((1,2,3), -1, Val{2})
+@testset "fill to length" begin
+    ## filling to specified length
+    @test @inferred(Base.fill_to_length((1,2,3), -1, Val(5))) == (1,2,3,-1,-1)
+    @test_throws ArgumentError Base.fill_to_length((1,2,3), -1, Val(2))
+end
 
-## iterating ##
-@test start((1,2,3)) === 1
+@testset "iterating" begin
+    @test start((1,2,3)) === 1
 
-@test done((), 1)
-@test !done((1,2,3), 3)
-@test done((1,2,3), 4)
+    @test done((), 1)
+    @test !done((1,2,3), 3)
+    @test done((1,2,3), 4)
 
-@test next((5,6,7), 1) === (5, 2)
-@test next((5,6,7), 3) === (7, 4)
-@test_throws BoundsError next((5,6,7), 0)
-@test_throws BoundsError next((), 1)
+    @test next((5,6,7), 1) === (5, 2)
+    @test next((5,6,7), 3) === (7, 4)
+    @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)
+    @test collect(eachindex((2,5,"foo"))) == collect(1:3)
+    @test collect(eachindex((2,5,"foo"), (1,2,5,7))) == collect(1:4)
+end
 
 
-## eltype ##
-@test eltype((1,2,3)) === Int
-@test eltype((1.0,2.0,3.0)) <: AbstractFloat
-@test eltype((true, false)) === Bool
-@test eltype((1,2.0, false)) === Any
-@test eltype(()) === Union{}
+@testset "element type" begin
+    @test eltype((1,2,3)) === Int
+    @test eltype((1.0,2.0,3.0)) <: AbstractFloat
+    @test eltype((true, false)) === Bool
+    @test eltype((1, 2.0, false)) === typejoin(Int, Float64, Bool)
+    @test eltype(()) === Union{}
+    @test eltype(Tuple{Int, Float64, Vararg{Bool}}) === typejoin(Int, Float64, Bool)
+    @test eltype(Tuple{Int, T, Vararg{Bool}} where T <: AbstractFloat) ===
+        typejoin(Int, AbstractFloat, Bool)
+    @test eltype(Tuple{Int, Bool, Vararg{T}} where T <: AbstractFloat) ===
+        typejoin(Int, AbstractFloat, Bool)
+    @test eltype(Union{Tuple{Int, Float64}, Tuple{Vararg{Bool}}}) ===
+        typejoin(Int, Float64, Bool)
+end
 
-begin
-    local foo
-    ## mapping ##
+@testset "mapping" begin
     foo() = 2
     foo(x) = 2x
     foo(x, y) = x + y
     foo(x, y, z) = x + y + z
     longtuple = ntuple(identity, 20)
 
-    # 1 argument
-    @test map(foo, ()) === ()
-    @test map(foo, (1,)) === (2,)
-    @test map(foo, (1,2)) === (2,4)
-    @test map(foo, (1,2,3,4)) === (2,4,6,8)
-    @test map(foo, longtuple) === ntuple(i->2i,20)
-
-    # 2 arguments
-    @test map(foo, (), ()) === ()
-    @test map(foo, (1,), (1,)) === (2,)
-    @test map(foo, (1,2), (1,2)) === (2,4)
-    @test map(foo, (1,2,3,4), (1,2,3,4)) === (2,4,6,8)
-    @test map(foo, longtuple, longtuple) === ntuple(i->2i,20)
-
-    # n arguments
-    @test map(foo, (), (), ()) === ()
-    @test map(foo, (), (1,2,3), (1,2,3)) === ()
-    @test map(foo, (1,), (1,), (1,)) === (3,)
-    @test map(foo, (1,2), (1,2), (1,2)) === (3,6)
-    @test map(foo, (1,2,3,4), (1,2,3,4), (1,2,3,4)) === (3,6,9,12)
-    @test map(foo, longtuple, longtuple, longtuple) === ntuple(i->3i,20)
-end
+    @testset "1 argument" begin
+        @test map(foo, ()) === ()
+        @test map(foo, (1,)) === (2,)
+        @test map(foo, (1,2)) === (2,4)
+        @test map(foo, (1,2,3,4)) === (2,4,6,8)
+        @test map(foo, longtuple) === ntuple(i->2i,20)
+    end
 
-## comparison ##
-@test isequal((), ())
-@test isequal((1,2,3), (1,2,3))
-@test !isequal((1,2,3), (1,2,4))
-@test !isequal((1,2,3), (1,2))
-
-@test ==((), ())
-@test ==((1,2,3), (1,2,3))
-@test !==((1,2,3), (1,2,4))
-@test !==((1,2,3), (1,2))
-
-@test isless((1,2), (1,3))
-@test isless((1,), (1,2))
-@test !isless((1,2), (1,2))
-@test !isless((2,1), (1,2))
-
-
-## functions ##
-@test isempty(())
-@test !isempty((1,))
-
-@test reverse(()) === ()
-@test reverse((1,2,3)) === (3,2,1)
-
-
-## specialized reduction ##
-@test sum((1,2,3)) === 6
-
-@test prod(()) === 1
-@test prod((1,2,3)) === 6
-
-@test all(()) === true
-@test all((false,)) === false
-@test all((true,)) === true
-@test all((true, true)) === true
-@test all((true, false)) === false
-@test all((false, false)) === false
-
-@test any(()) === false
-@test any((true,)) === true
-@test any((false,)) === false
-@test any((true, true)) === true
-@test any((true, false)) === true
-@test any((false, false)) === false
-@test any((false,false,false)) === false
-@test any((true,false,false)) === true
-@test any((false,true,false)) === true
-@test any((false,false,true)) === true
-@test any((true,true,false)) === true
-@test any((true,false,true)) === true
-@test any((true,true,false)) === true
-@test any((true,true,true)) === true
-
-@test @inferred(ntuple(abs2, Val{0})) == ()
-@test @inferred(ntuple(abs2, Val{2})) == (1, 4)
-@test @inferred(ntuple(abs2, Val{3})) == (1, 4, 9)
-@test @inferred(ntuple(abs2, Val{4})) == (1, 4, 9, 16)
-@test @inferred(ntuple(abs2, Val{5})) == (1, 4, 9, 16, 25)
-@test @inferred(ntuple(abs2, Val{6})) == (1, 4, 9, 16, 25, 36)
-
-# issue #12854
-@test_throws TypeError ntuple(identity, Val{1:2})
-
-for n = 0:20
-    t = ntuple(identity, n)
-    @test length(t) == n
-    for i = 1:n
-        @test t[i] == i
+    @testset "2 arguments" begin
+        @test map(foo, (), ()) === ()
+        @test map(foo, (1,), (1,)) === (2,)
+        @test map(foo, (1,2), (1,2)) === (2,4)
+        @test map(foo, (1,2,3,4), (1,2,3,4)) === (2,4,6,8)
+        @test map(foo, longtuple, longtuple) === ntuple(i->2i,20)
+        @test_throws BoundsError map(foo, (), (1,))
+        @test_throws BoundsError map(foo, (1,), ())
     end
+
+    @testset "n arguments" begin
+        @test map(foo, (), (), ()) === ()
+        @test map(foo, (1,), (1,), (1,)) === (3,)
+        @test map(foo, (1,2), (1,2), (1,2)) === (3,6)
+        @test map(foo, (1,2,3,4), (1,2,3,4), (1,2,3,4)) === (3,6,9,12)
+        @test map(foo, longtuple, longtuple, longtuple) === ntuple(i->3i,20)
+        @test_throws BoundsError map(foo, (), (1,), (1,))
+        @test_throws BoundsError map(foo, (1,), (1,), ())
+    end
+end
+
+@testset "comparison" begin
+    @test isequal((), ())
+    @test isequal((1,2,3), (1,2,3))
+    @test !isequal((1,2,3), (1,2,4))
+    @test !isequal((1,2,3), (1,2))
+
+    @test ==((), ())
+    @test ==((1,2,3), (1,2,3))
+    @test !==((1,2,3), (1,2,4))
+    @test !==((1,2,3), (1,2))
+
+    @test isless((1,2), (1,3))
+    @test isless((1,), (1,2))
+    @test !isless((1,2), (1,2))
+    @test !isless((2,1), (1,2))
 end
 
-# issue #19719
-@test_throws BoundsError (1,2,3)[falses(4)]
-@test_throws BoundsError (1,2,3)[[false,false,true,true]]
-@test_throws BoundsError (1,2,3)[trues(2)]
-@test_throws BoundsError (1,2,3)[falses(2)]
-@test_throws BoundsError ()[[false]]
-@test_throws BoundsError ()[[true]]
 
-struct BitPerm_19352
-    p::NTuple{8,UInt8}
-    function BitPerm(p::NTuple{8,UInt8})
-        sort(collect(p)) != collect(0:7) && error("$p is not a permutation of 0:7")
-        new(p)
+@testset "functions" begin
+    @test isempty(())
+    @test !isempty((1,))
+
+    @test reverse(()) === ()
+    @test reverse((1,2,3)) === (3,2,1)
+end
+# issue #21697
+@test_throws ArgumentError ntuple(identity, -1)
+
+
+@testset "specialized reduction" begin
+    @test sum((1,2,3)) === 6
+
+    @test prod(()) === 1
+    @test prod((1,2,3)) === 6
+
+    @testset "all" begin
+        @test all(()) === true
+        @test all((false,)) === false
+        @test all((true,)) === true
+        @test all((true, true)) === true
+        @test all((true, false)) === false
+        @test all((false, false)) === false
+    end
+
+    @testset "any" begin
+        @test any(()) === false
+        @test any((true,)) === true
+        @test any((false,)) === false
+        @test any((true, true)) === true
+        @test any((true, false)) === true
+        @test any((false, false)) === false
+        @test any((false,false,false)) === false
+        @test any((true,false,false)) === true
+        @test any((false,true,false)) === true
+        @test any((false,false,true)) === true
+        @test any((true,true,false)) === true
+        @test any((true,false,true)) === true
+        @test any((true,true,false)) === true
+        @test any((true,true,true)) === true
     end
-    BitPerm_19352(b0,b1,b2,b3,b4,b5,b6,b7) = BitPerm((UInt8(b0),UInt8(b1),UInt8(b2),UInt8(b3),
-        UInt8(b4),UInt8(b5),UInt8(b6),UInt8(b7)))
 end
 
-@testset "side effect in tuple constructor #19352" begin
-    @test BitPerm_19352(0,2,4,6,1,3,5,7).p[2] == 0x02
+@testset "ntuple" begin
+    @test @inferred(ntuple(abs2, Val(0))) == ()
+    @test @inferred(ntuple(abs2, Val(2))) == (1, 4)
+    @test @inferred(ntuple(abs2, Val(3))) == (1, 4, 9)
+    @test @inferred(ntuple(abs2, Val(4))) == (1, 4, 9, 16)
+    @test @inferred(ntuple(abs2, Val(5))) == (1, 4, 9, 16, 25)
+    @test @inferred(ntuple(abs2, Val(6))) == (1, 4, 9, 16, 25, 36)
+    # issue #21697
+    @test_throws ArgumentError ntuple(abs2, Val(-1))
+
+    # issue #12854
+    @test_throws TypeError ntuple(identity, Val(1:2))
+
+    for n = 0:20
+        t = ntuple(identity, n)
+        @test length(t) == n
+        for i = 1:n
+            @test t[i] == i
+        end
+    end
+    # issue #21697
+    @test_throws ArgumentError ntuple(identity, -1)
+
+    # PR #21446
+    for n = 0:15
+        @test ntuple(identity, Val(n)) == ntuple(identity, n)
+    end
 end
 
 # issue #15703
@@ -218,21 +292,6 @@ let
     test_15703()
 end
 
-# PR #15516
-@test Tuple{Char,Char}("za") === ('z','a')
-@test_throws ArgumentError Tuple{Char,Char}("z")
-
-@test NTuple{20,Int}(Iterators.countfrom(2)) === (2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21)
-@test NTuple{20,Float64}(Iterators.countfrom(2)) === (2.,3.,4.,5.,6.,7.,8.,9.,10.,11.,12.,13.,14.,15.,16.,17.,18.,19.,20.,21.)
-@test_throws ArgumentError NTuple{20,Int}([1,2])
-
-@test Tuple{Vararg{Float32}}(Float64[1,2,3]) === (1.0f0, 2.0f0, 3.0f0)
-@test Tuple{Int,Vararg{Float32}}(Float64[1,2,3]) === (1, 2.0f0, 3.0f0)
-@test Tuple{Int,Vararg{Any}}(Float64[1,2,3]) === (1, 2.0, 3.0)
-@test Tuple(ones(5)) === (1.0,1.0,1.0,1.0,1.0)
-@test_throws MethodError convert(Tuple, ones(5))
-
-@testset "Multidimensional indexing (issue #20453)" begin
-    @test_throws MethodError (1,)[]
-    @test_throws MethodError (1,1,1)[1,1]
-end
+# https://github.com/JuliaLang/julia/issues/21026#issuecomment-317113307
+const VecTuple21026{T} = Tuple{VecElement{T}}
+@test convert(VecTuple21026, (1,)) === (VecElement(1),)
diff --git a/test/unicode/UnicodeError.jl b/test/unicode/UnicodeError.jl
index 14a4a3db362ca2..a5665dff49bbe1 100644
--- a/test/unicode/UnicodeError.jl
+++ b/test/unicode/UnicodeError.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 @testset "invalid utf8" begin
     let io = IOBuffer()
diff --git a/test/unicode/utf8.jl b/test/unicode/utf8.jl
index 1a95da78bd5777..093c899e0f3ee3 100644
--- a/test/unicode/utf8.jl
+++ b/test/unicode/utf8.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 @testset "cesu8 input" begin
     let ch = 0x10000
diff --git a/test/unicode/utf8proc.jl b/test/unicode/utf8proc.jl
index 8297ad460748ea..d06106a9abefcf 100644
--- a/test/unicode/utf8proc.jl
+++ b/test/unicode/utf8proc.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 @testset "string normalization" begin
     # normalize_string (Unicode normalization etc.):
@@ -109,26 +109,26 @@ end
     alphas=vcat(alower,ulower,aupper,uupper,nocase)
 
     for c in alphas
-         @test isalpha(c) == true
-         @test isnumber(c) == false
+        @test isalpha(c) == true
+        @test isnumber(c) == false
     end
 
     anumber=['0', '1', '5', '9']
     unumber=['٣', '٥', '٨', '¹', 'ⅳ' ]
 
     for c in anumber
-         @test isdigit(c) == true
-         @test isnumber(c) == true
+        @test isdigit(c) == true
+        @test isnumber(c) == true
     end
     for c in unumber
-         @test isdigit(c) == false
-         @test isnumber(c) == true
+        @test isdigit(c) == false
+        @test isnumber(c) == true
     end
 
     alnums=vcat(alphas,anumber,unumber)
     for c in alnums
-         @test isalnum(c) == true
-         @test ispunct(c) == false
+        @test isalnum(c) == true
+        @test ispunct(c) == false
     end
 
     asymbol = ['(',')', '~', '$' ]
@@ -138,8 +138,8 @@ end
     upunct =['‡', '؟', '჻' ]
 
     for c in vcat(apunct,upunct)
-         @test ispunct(c) == true
-         @test isalnum(c) == false
+        @test ispunct(c) == true
+        @test isalnum(c) == false
     end
 
     for c in vcat(alnums,asymbol,usymbol,apunct,upunct)
@@ -311,9 +311,12 @@ end
         h = hash(str)
         @test hash(g) == h
         @test convert(GenericString, g) == str
-        io = IOBuffer()
-        show(io, g)
-        check = "length-14 GraphemeIterator{String} for \"$str\""
-        @test String(take!(io)) == check
+        @test repr(g) == "length-14 GraphemeIterator{String} for \"$str\""
     end
 end
+
+@testset "#22693: substring graphemes" begin
+    g = graphemes(SubString("123α56789", 1, 6))
+    @test eltype(g) == SubString{String}
+    @test collect(g) == ["1","2","3","α","5"]
+end
diff --git a/test/util/segfault.jl b/test/util/segfault.jl
index 245005eeb615e1..fef390870776fa 100644
--- a/test/util/segfault.jl
+++ b/test/util/segfault.jl
@@ -1 +1,3 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
 unsafe_load(convert(Ptr{UInt8},C_NULL))
diff --git a/test/util/throw_error_exception.jl b/test/util/throw_error_exception.jl
index 847f4b26321acc..d0acea8f647f05 100644
--- a/test/util/throw_error_exception.jl
+++ b/test/util/throw_error_exception.jl
@@ -1 +1,3 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
 error("This purposefully dies")
diff --git a/test/vecelement.jl b/test/vecelement.jl
index 6476beade9ad7d..e09d9285ba16cd 100644
--- a/test/vecelement.jl
+++ b/test/vecelement.jl
@@ -1,12 +1,12 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
-make_value{T<:Integer}(::Type{T}, i::Integer) = 3*i%T
-make_value{T<:AbstractFloat}(::Type{T},i::Integer) = T(3*i)
+make_value(::Type{T}, i::Integer) where {T<:Integer} = 3*i%T
+make_value(::Type{T},i::Integer) where {T<:AbstractFloat} = T(3*i)
 
 Vec{N,T} = NTuple{N,Base.VecElement{T}}
 
 # Crash report for #15244 motivated this test.
-@generated function thrice_iota{N,T}(::Type{Vec{N,T}})
+@generated function thrice_iota(::Type{Vec{N,T}}) where {N,T}
     :(tuple($([:(Base.VecElement(make_value($T,$i))) for i in 1:N]...)))
 end
 
@@ -23,6 +23,13 @@ for i=1:20
     end
 end
 
+# Try various large tuple lengths and element types #20961
+for i in (34, 36, 48, 64, 72, 80, 96)
+    for t in [Bool, Int8, Int16, Int32, Int64, Float32, Float64]
+        call_iota(i,t)
+    end
+end
+
 # Another crash report for #15244 motivated this test.
 struct Bunch{N,T}
     elts::NTuple{N,Base.VecElement{T}}
@@ -43,7 +50,7 @@ struct Herd{N,T}
     Herd{N,T}(elts::NTuple{N,T}) where {N,T} = new(ntuple(i->Base.VecElement{T}(elts[i]), N))
 end
 
-function check{N,T}(x::Herd{N,T})
+function check(x::Herd{N,T}) where {N,T}
     for i=1:N
         @test x.elts[i].value === N*N+i-1
     end
@@ -65,3 +72,50 @@ a[1] = Gr(5.0, Bunch((VecElement(6.0), VecElement(7.0))), 8.0)
 @test a[2] == Gr(1.0, Bunch((VecElement(2.0), VecElement(3.0))), 4.0)
 
 @test isa(VecElement((1,2)), VecElement{Tuple{Int,Int}})
+
+# The following test mimic SIMD.jl
+const _llvmtypes = Dict{DataType, String}(
+    Float64 => "double",
+    Float32 => "float",
+    Int32 => "i32",
+    Int64 => "i64"
+)
+
+@generated function vecadd(x::Vec{N, T}, y::Vec{N, T}) where {N, T}
+    llvmT = _llvmtypes[T]
+    func = T <: AbstractFloat ? "fadd" : "add"
+    exp = """
+    %3 = $(func) <$(N) x $(llvmT)> %0, %1
+    ret <$(N) x $(llvmT)> %3
+    """
+    return quote
+        Base.@_inline_meta
+        Base.llvmcall($exp, Vec{$N, $T}, Tuple{Vec{$N, $T}, Vec{$N, $T}}, x, y)
+    end
+end
+
+function f20961(x::Vector{Vec{N, T}}, y::Vector{Vec{N, T}}) where{N, T}
+    @inbounds begin
+        a = x[1]
+        b = y[1]
+        return vecadd(a, b)
+    end
+end
+
+# Test various SIMD Vectors with known good sizes
+for T in (Float64, Float32, Int64, Int32)
+    for N in 1:36
+        # For some vectortypes Julia emits llvm arrays instead of vectors
+        if N %  7 == 0 || N % 11 == 0 || N % 13 == 0 || N % 15 == 0 ||
+           N % 19 == 0 || N % 23 == 0 || N % 25 == 0 || N % 27 == 0 ||
+           N % 29 == 0 || N % 31 == 0
+            continue
+        end
+        a = ntuple(i->VecElement(T(i)), N)
+        result = ntuple(i-> VecElement(T(i+i)), N)
+        b = vecadd(a, a)
+        @test b == result
+        b = f20961([a], [a])
+        @test b == result
+    end
+end
diff --git a/test/version.jl b/test/version.jl
index 7f7f691ba775e7..172e5e2cac3b60 100644
--- a/test/version.jl
+++ b/test/version.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # parsing tests
 @test v"2" == VersionNumber(2)
@@ -94,8 +94,7 @@ show(io,v"4.3.2+1.a")
 
 # typemin and typemax
 @test typemin(VersionNumber) == v"0-"
-@test typemax(VersionNumber) ==
-  VersionNumber(typemax(Int), typemax(Int), typemax(Int), (), ("",))
+@test typemax(VersionNumber) == v"∞"
 
 # issupbuild
 import Base.issupbuild
diff --git a/test/workspace.jl b/test/workspace.jl
index 01d5fb843e2419..16c48357ec2193 100644
--- a/test/workspace.jl
+++ b/test/workspace.jl
@@ -1,26 +1,73 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
+using Base.Test
 
 script = """
 # Issue #11948
 f(x) = x+1
 workspace()
-@assert !isdefined(:f)
-LastMain.f(2)
+@assert @__MODULE__() === Main
+@assert isdefined(Main, :f)
+@assert !@isdefined LastMain
+@eval Core.Main begin
+    @assert @__MODULE__() === Main
+    @assert !isdefined(Main, :f)
+    LastMain.f(2)
 
-# PR #12990
-io = IOBuffer()
-show(io, Pair)
-@assert String(take!(io)) == "Pair"
-@assert !Base.inbase(LastMain)
+    # PR #12990
+    io = IOBuffer()
+    show(io, Pair)
+    @assert String(take!(io)) == "Pair"
+    @assert !Base.inbase(LastMain)
+end
 """
 exename = Base.julia_cmd()
-run(`$exename --startup-file=no -e $script`)
+@test success(pipeline(`$exename --startup-file=no -e $script`, stdout=STDOUT, stderr=STDERR))
 
 # issue #17764
 script2 = """
 mutable struct Foo end
 workspace()
-mutable struct Foo end
-@assert Tuple{Type{LastMain.Foo}} !== Tuple{Type{Main.Foo}}
+@eval Core.Main begin
+    mutable struct Foo end
+    @assert Tuple{Type{LastMain.Foo}} !== Tuple{Type{Main.Foo}}
+end
 """
-run(`$exename --startup-file=no -e $script2`)
+@test success(pipeline(`$exename --startup-file=no -e $script2`, stdout=STDOUT, stderr=STDERR))
+
+# Issue #22101
+mktempdir() do dir
+    withenv("JULIA_DEBUG_LOADING" => nothing) do
+        # We need to ensure that the module does a nontrivial amount of work during precompilation
+        write(joinpath(dir, "Test22101.jl"), """
+            __precompile__()
+            module Test22101
+                export f22101
+                f22101() = collect(1:10)
+                f22101()
+            end
+        """)
+        write(joinpath(dir, "testdriver.jl"), """
+            using Base.Test
+            insert!(LOAD_PATH, 1, $(repr(dir)))
+            insert!(Base.LOAD_CACHE_PATH, 1, $(repr(dir)))
+            @test !isdefined(Main, :f22101)
+            @test !isdefined(Main, :LastMain)
+            begin
+                using Test22101
+                @test isdefined(Main, :f22101)
+                @test f22101()::Vector{Int} == collect(1:10)
+                @eval workspace() using Test22101
+                @test f22101()::Vector{Int} == collect(1:10)
+                @test isdefined(Main, :f22101)
+            end
+            @test isdefined(Main, :f22101)
+            @test !isdefined(Main, :LastMain)
+            @test isdefined(Core.Main, :f22101)
+            nothing
+        """)
+        # Ensure that STDIO doesn't get swallowed (helps with debugging)
+        cmd = `$(Base.julia_cmd()) --startup-file=no --precompiled=yes --compilecache=yes $(joinpath(dir, "testdriver.jl"))`
+        @test success(pipeline(cmd, stdout=STDOUT, stderr=STDERR))
+    end
+end
diff --git a/test/worlds.jl b/test/worlds.jl
index 28a89b2e5c9dce..1dfea7f6fe8d9c 100644
--- a/test/worlds.jl
+++ b/test/worlds.jl
@@ -1,4 +1,4 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
+# This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # tests for accurate updating of method tables
 
@@ -136,7 +136,7 @@ f265(::Int) = 1
 
 # test for method errors
 h265() = true
-loc_h265 = "$(Base.source_path()):$(@__LINE__ - 1)"
+loc_h265 = "$(@__FILE__):$(@__LINE__() - 1)"
 @test h265()
 @test_throws MethodError put_n_take!(h265, ())
 @test_throws MethodError wait(t265)
diff --git a/ui/repl.c b/ui/repl.c
index 4c998ce2626955..cba286bd1cf9a8 100644
--- a/ui/repl.c
+++ b/ui/repl.c
@@ -1,4 +1,4 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
+// This file is a part of Julia. License is MIT: https://julialang.org/license
 
 /*
   repl.c
@@ -21,38 +21,24 @@
 #include <inttypes.h>
 
 #include "uv.h"
-#define WHOLE_ARCHIVE
 #include "../src/julia.h"
+JULIA_DEFINE_FAST_TLS()
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#if defined(JULIA_ENABLE_THREADING) && !defined(_OS_DARWIN_) && !defined(_OS_WINDOWS_)
-JL_DLLEXPORT JL_CONST_FUNC jl_ptls_t jl_get_ptls_states_static(void)
-{
-    static __attribute__((tls_model("local-exec"))) __thread jl_tls_states_t tls_states;
-    return &tls_states;
-}
-__attribute__((constructor)) void jl_register_ptls_states_getter(void)
-{
-    // We need to make sure this function is called before any reference to
-    // TLS variables.
-    jl_set_ptls_states_getter(jl_get_ptls_states_static);
-}
-#endif
-
 static int exec_program(char *program)
 {
     jl_ptls_t ptls = jl_get_ptls_states();
     JL_TRY {
-        jl_load(program);
+        jl_load(jl_main_module, program);
     }
     JL_CATCH {
         jl_value_t *errs = jl_stderr_obj();
         jl_value_t *e = ptls->exception_in_transit;
         // Manually save and restore the backtrace so that we print the original
-        // one instead of the one caused by `jl_show`.
+        // one instead of the one caused by `show`.
         // We can't use safe_restore since that will cause any error
         // (including the ones that would have been caught) to abort.
         uintptr_t *volatile bt_data = NULL;
@@ -61,7 +47,7 @@ static int exec_program(char *program)
             if (errs) {
                 bt_data = (uintptr_t*)malloc(bt_size * sizeof(void*));
                 memcpy(bt_data, ptls->bt_data, bt_size * sizeof(void*));
-                jl_show(errs, e);
+                jl_call2(jl_get_function(jl_base_module, "show"), errs, e);
                 jl_printf(JL_STDERR, "\n");
                 free(bt_data);
             }
@@ -87,7 +73,7 @@ static int exec_program(char *program)
 void jl_lisp_prompt();
 
 #ifndef _WIN32
-int jl_repl_raise_sigtstp(void)
+JL_DLLEXPORT int jl_repl_raise_sigtstp(void)
 {
     return raise(SIGTSTP);
 }