% Building OpenJDK

## TL;DR (Instructions for the Impatient)

If you are eager to try out building OpenJDK, these simple steps works most of

the time. They assume that you have installed Mercurial (and Cygwin if running

on Windows) and cloned the top-level OpenJDK repository that you want to build.

 1. [Get the complete source code](#getting-the-source-code): \

    `hg clone http://hg.openjdk.java.net/jdk10/master`

 2. [Run configure](#running-configure): \

    `bash configure`

    If `configure` fails due to missing dependencies (to either the

    [toolchain](#native-compiler-toolchain-requirements), [external libraries](

    #external-library-requirements) or the [boot JDK](#boot-jdk-requirements)),

    most of the time it prints a suggestion on how to resolve the situation on

    your platform. Follow the instructions, and try running `bash configure`

    again.

 3. [Run make](#running-make): \

    `make images`

 4. Verify your newly built JDK: \

    `./build/*/images/jdk/bin/java -version`

 5. [Run basic tests](##running-tests): \

    `make run-test-tier1`

If any of these steps failed, or if you want to know more about build

requirements or build functionality, please continue reading this document.

## Introduction

OpenJDK is a complex software project. Building it requires a certain amount of

technical expertise, a fair number of dependencies on external software, and

reasonably powerful hardware.

If you just want to use OpenJDK and not build it yourself, this document is not

for you. See for instance [OpenJDK installation](

http://openjdk.java.net/install) for some methods of installing a prebuilt

OpenJDK.

## Getting the Source Code

Make sure you are getting the correct version. As of JDK 10, the source is no

longer split into separate repositories so you only need to clone one single

repository. At the [OpenJDK Mercurial server](http://hg.openjdk.java.net/) you

can see a list of all available forests. If you want to build an older version,

e.g. JDK 8, it is recommended that you get the `jdk8u` forest, which contains

incremental updates, instead of the `jdk8` forest, which was frozen at JDK 8 GA.

If you are new to Mercurial, a good place to start is the [Mercurial Beginner's

Guide](http://www.mercurial-scm.org/guide). The rest of this document assumes a

working knowledge of Mercurial.

### Special Considerations

For a smooth building experience, it is recommended that you follow these rules

on where and how to check out the source code.

  * Do not check out the source code in a path which contains spaces. Chances

    are the build will not work. This is most likely to be an issue on Windows

    systems.

  * Do not check out the source code in a path which has a very long name or is

    nested many levels deep. Chances are you will hit an OS limitation during

    the build.

  * Put the source code on a local disk, not a network share. If possible, use

    an SSD. The build process is very disk intensive, and having slow disk

    access will significantly increase build times. If you need to use a

    network share for the source code, see below for suggestions on how to keep

    the build artifacts on a local disk.

  * On Windows, extra care must be taken to make sure the [Cygwin](#cygwin)

    environment is consistent. It is recommended that you follow this

    procedure:

      * Create the directory that is going to contain the top directory of the

        OpenJDK clone by using the `mkdir` command in the Cygwin bash shell.

        That is, do *not* create it using Windows Explorer. This will ensure

        that it will have proper Cygwin attributes, and that it's children will

        inherit those attributes.

      * Do not put the OpenJDK clone in a path under your Cygwin home

        directory. This is especially important if your user name contains

        spaces and/or mixed upper and lower case letters.

      * Clone the OpenJDK repository using the Cygwin command line `hg` client

        as instructed in this document. That is, do *not* use another Mercurial

        client such as TortoiseHg.

    Failure to follow this procedure might result in hard-to-debug build

    problems.

## Build Hardware Requirements

OpenJDK is a massive project, and require machines ranging from decent to

powerful to be able to build in a reasonable amount of time, or to be able to

complete a build at all.

We *strongly* recommend usage of an SSD disk for the build, since disk speed is

one of the limiting factors for build performance.

### Building on x86

At a minimum, a machine with 2-4 cores is advisable, as well as 2-4 GB of RAM.

(The more cores to use, the more memory you need.) At least 6 GB of free disk

space is required (8 GB minimum for building on Solaris).

Even for 32-bit builds, it is recommended to use a 64-bit build machine, and

instead create a 32-bit target using `--with-target-bits=32`.

### Building on sparc

At a minimum, a machine with 4 cores is advisable, as well as 4 GB of RAM. (The

more cores to use, the more memory you need.) At least 8 GB of free disk space

is required.

### Building on arm/aarch64

This is not recommended. Instead, see the section on [Cross-compiling](

#cross-compiling).

## Operating System Requirements

The mainline OpenJDK project supports Linux, Solaris, macOS, AIX and Windows.

Support for other operating system, e.g. BSD, exists in separate "port"

projects.

In general, OpenJDK can be built on a wide range of versions of these operating

systems, but the further you deviate from what is tested on a daily basis, the

more likely you are to run into problems.

This table lists the OS versions used by Oracle when building JDK 9. Such

information is always subject to change, but this table is up to date at the

time of writing.

 Operating system   Vendor/version used

 -----------------  -------------------------------------------------------

 Linux              Oracle Enterprise Linux 6.4 / 7.1 (using kernel 3.8.13)

 Solaris            Solaris 11.1 SRU 21.4.1 / 11.2 SRU 5.5

 macOS              Mac OS X 10.9 (Mavericks) / 10.10 (Yosemite)

 Windows            Windows Server 2012 R2

The double version numbers for Linux, Solaris and macOS is due to the hybrid

model used at Oracle, where header files and external libraries from an older

version is used when building on a more modern version of the OS.

The Build Group has a wiki page with [Supported Build Platforms](

https://wiki.openjdk.java.net/display/Build/Supported+Build+Platforms). From

time to time, this is updated by the community to list successes or failures of

building on different platforms.

### Windows

Windows XP is not a supported platform, but all newer Windows should be able to

build OpenJDK.

On Windows, it is important that you pay attention to the instructions in the

[Special Considerations](#special-considerations).

Windows is the only non-POSIX OS supported by OpenJDK, and as such, requires

some extra care. A POSIX support layer is required to build on Windows. For

OpenJDK 9, the only supported such layer is Cygwin. (Msys is no longer

supported due to a too old bash; msys2 and the new Windows Subsystem for Linux

(WSL) would likely be possible to support in a future version but that would

require a community effort to implement.)

Internally in the build system, all paths are represented as Unix-style paths,

e.g. `/cygdrive/c/hg/jdk9/Makefile` rather than `C:\hg\jdk9\Makefile`. This

rule also applies to input to the build system, e.g. in arguments to

`configure`. So, use `--with-freetype=/cygdrive/c/freetype` rather than

`--with-freetype=c:\freetype`. For details on this conversion, see the section

on [Fixpath](#fixpath).

#### Cygwin

A functioning [Cygwin](http://www.cygwin.com/) environment is thus required for

building OpenJDK on Windows. If you have a 64-bit OS, we strongly recommend

using the 64-bit version of Cygwin.

**Note:** Cygwin has a model of continuously updating all packages without any

easy way to install or revert to a specific version of a package. This means

that whenever you add or update a package in Cygwin, you might (inadvertently)

update tools that are used by the OpenJDK build process, and that can cause

unexpected build problems.

OpenJDK requires GNU Make 4.0 or greater on Windows. This is usually not a

problem, since Cygwin currently only distributes GNU Make at a version above

4.0.

Apart from the basic Cygwin installation, the following packages must also be

installed:

  * `make`

  * `zip`

  * `unzip`

Often, you can install these packages using the following command line:

```

<path to Cygwin setup>/setup-x86_64 -q -P make -P unzip -P zip

```

Unfortunately, Cygwin can be unreliable in certain circumstances. If you

experience build tool crashes or strange issues when building on Windows,

please check the Cygwin FAQ on the ["BLODA" list](

https://cygwin.com/faq/faq.html#faq.using.bloda) and the section on [fork()

failures](https://cygwin.com/faq/faq.html#faq.using.fixing-fork-failures).

### Solaris

See `make/devkit/solaris11.1-package-list.txt` for a list of recommended

packages to install when building on Solaris. The versions specified in this

list is the versions used by the daily builds at Oracle, and is likely to work

properly.

Older versions of Solaris shipped a broken version of `objcopy`. At least

version 2.21.1 is needed, which is provided by Solaris 11 Update 1. Objcopy is

needed if you want to have external debug symbols. Please make sure you are

using at least version 2.21.1 of objcopy, or that you disable external debug

symbols.

### macOS

Apple is using a quite aggressive scheme of pushing OS updates, and coupling

these updates with required updates of Xcode. Unfortunately, this makes it

difficult for a project like OpenJDK to keep pace with a continuously updated

machine running macOS. See the section on [Apple Xcode](#apple-xcode) on some

strategies to deal with this.

It is recommended that you use at least Mac OS X 10.9 (Mavericks). At the time

of writing, OpenJDK has been successfully compiled on macOS versions up to

10.12.5 (Sierra), using XCode 8.3.2 and `--disable-warnings-as-errors`.

The standard macOS environment contains the basic tooling needed to build, but

for external libraries a package manager is recommended. OpenJDK uses

[homebrew](https://brew.sh/) in the examples, but feel free to use whatever

manager you want (or none).

### Linux

It is often not much problem to build OpenJDK on Linux. The only general advice

is to try to use the compilers, external libraries and header files as provided

by your distribution.

The basic tooling is provided as part of the core operating system, but you

will most likely need to install developer packages.

For apt-based distributions (Debian, Ubuntu, etc), try this:

```

sudo apt-get install build-essential

```

For rpm-based distributions (Fedora, Red Hat, etc), try this:

```

sudo yum groupinstall "Development Tools"

```

### AIX

The regular builds by SAP is using AIX version 7.1, but AIX 5.3 is also

supported. See the [OpenJDK PowerPC Port Status Page](

http://cr.openjdk.java.net/~simonis/ppc-aix-port) for details.

## Native Compiler (Toolchain) Requirements

Large portions of OpenJDK consists of native code, that needs to be compiled to

be able to run on the target platform. In theory, toolchain and operating

system should be independent factors, but in practice there's more or less a

one-to-one correlation between target operating system and toolchain.

 Operating system   Supported toolchain

 ------------------ -------------------------

 Linux              gcc, clang

 macOS              Apple Xcode (using clang)

 Solaris            Oracle Solaris Studio

 AIX                IBM XL C/C++

 Windows            Microsoft Visual Studio

Please see the individual sections on the toolchains for version

recommendations. As a reference, these versions of the toolchains are used, at

the time of writing, by Oracle for the daily builds of OpenJDK. It should be

possible to compile OpenJDK with both older and newer versions, but the closer

you stay to this list, the more likely you are to compile successfully without

issues.

 Operating system   Toolchain version

 ------------------ -------------------------------------------------------

 Linux              gcc 4.9.2

 macOS              Apple Xcode 6.3 (using clang 6.1.0)

 Solaris            Oracle Solaris Studio 12.4 (with compiler version 5.13)

 Windows            Microsoft Visual Studio 2013 update 4

### gcc

The minimum accepted version of gcc is 4.7. Older versions will generate a warning

by `configure` and are unlikely to work.

OpenJDK 9 includes patches that should allow gcc 6 to compile, but this should

be considered experimental.

In general, any version between these two should be usable.

### clang

The minimum accepted version of clang is 3.2. Older versions will not be

accepted by `configure`.

To use clang instead of gcc on Linux, use `--with-toolchain-type=clang`.

### Apple Xcode

The oldest supported version of Xcode is 5.

You will need the Xcode command lines developers tools to be able to build

OpenJDK. (Actually, *only* the command lines tools are needed, not the IDE.)

The simplest way to install these is to run:

```

xcode-select --install

```

It is advisable to keep an older version of Xcode for building OpenJDK when

updating Xcode. This [blog page](

http://iosdevelopertips.com/xcode/install-multiple-versions-of-xcode.html) has

good suggestions on managing multiple Xcode versions. To use a specific version

of Xcode, use `xcode-select -s` before running `configure`, or use

`--with-toolchain-path` to point to the version of Xcode to use, e.g.

`configure --with-toolchain-path=/Applications/Xcode5.app/Contents/Developer/usr/bin`

If you have recently (inadvertently) updated your OS and/or Xcode version, and

OpenJDK can no longer be built, please see the section on [Problems with the

Build Environment](#problems-with-the-build-environment), and [Getting

Help](#getting-help) to find out if there are any recent, non-merged patches

available for this update.

### Oracle Solaris Studio

The minimum accepted version of the Solaris Studio compilers is 5.13

(corresponding to Solaris Studio 12.4). Older versions will not be accepted by

configure.

The Solaris Studio installation should contain at least these packages:

 Package                                            Version

 -------------------------------------------------- -------------

 developer/solarisstudio-124/backend                12.4-1.0.6.0

 developer/solarisstudio-124/c++                    12.4-1.0.10.0

 developer/solarisstudio-124/cc                     12.4-1.0.4.0

 developer/solarisstudio-124/library/c++-libs       12.4-1.0.10.0

 developer/solarisstudio-124/library/math-libs      12.4-1.0.0.1

 developer/solarisstudio-124/library/studio-gccrt   12.4-1.0.0.1

 developer/solarisstudio-124/studio-common          12.4-1.0.0.1

 developer/solarisstudio-124/studio-ja              12.4-1.0.0.1

 developer/solarisstudio-124/studio-legal           12.4-1.0.0.1

 developer/solarisstudio-124/studio-zhCN            12.4-1.0.0.1

Compiling with Solaris Studio can sometimes be finicky. This is the exact

version used by Oracle, which worked correctly at the time of writing:

```

$ cc -V

cc: Sun C 5.13 SunOS_i386 2014/10/20

$ CC -V

CC: Sun C++ 5.13 SunOS_i386 151846-10 2015/10/30

```

### Microsoft Visual Studio

The minimum accepted version of Visual Studio is 2010. Older versions will not

be accepted by `configure`. The maximum accepted version of Visual Studio is

2013.

If you have multiple versions of Visual Studio installed, `configure` will by

default pick the latest. You can request a specific version to be used by

setting `--with-toolchain-version`, e.g. `--with-toolchain-version=2010`.

If you get `LINK: fatal error LNK1123: failure during conversion to COFF: file

invalid` when building using Visual Studio 2010, you have encountered

[KB2757355](http://support.microsoft.com/kb/2757355), a bug triggered by a

specific installation order. However, the solution suggested by the KB article

does not always resolve the problem. See [this stackoverflow discussion](

https://stackoverflow.com/questions/10888391) for other suggestions.

### IBM XL C/C++

The regular builds by SAP is using version 12.1, described as `IBM XL C/C++ for

AIX, V12.1 (5765-J02, 5725-C72) Version: 12.01.0000.0017`.

See the [OpenJDK PowerPC Port Status Page](

http://cr.openjdk.java.net/~simonis/ppc-aix-port) for details.

## Boot JDK Requirements

Paradoxically, building OpenJDK requires a pre-existing JDK. This is called the

"boot JDK". The boot JDK does not have to be OpenJDK, though. If you are

porting OpenJDK to a new platform, chances are that there already exists

another JDK for that platform that is usable as boot JDK.

The rule of thumb is that the boot JDK for building JDK major version *N*

should be an JDK of major version *N-1*, so for building JDK 9 a JDK 8 would be

suitable as boot JDK. However, OpenJDK should be able to "build itself", so an

up-to-date build of the current OpenJDK source is an acceptable alternative. If

you are following the *N-1* rule, make sure you got the latest update version,

since JDK 8 GA might not be able to build JDK 9 on all platforms.

If the Boot JDK is not automatically detected, or the wrong JDK is picked, use

`--with-boot-jdk` to point to the JDK to use.

### JDK 8 on Linux

On apt-based distros (like Debian and Ubuntu), `sudo apt-get install

openjdk-8-jdk` is typically enough to install OpenJDK 8. On rpm-based distros

(like Fedora and Red Hat), try `sudo yum install java-1.8.0-openjdk-devel`.

### JDK 8 on Windows

No pre-compiled binaries of OpenJDK 8 are readily available for Windows at the

time of writing. An alternative is to download the [Oracle JDK](

http://www.oracle.com/technetwork/java/javase/downloads). Another is the [Adopt

OpenJDK Project](https://adoptopenjdk.net/), which publishes experimental

prebuilt binaries for Windows.

### JDK 8 on macOS

No pre-compiled binaries of OpenJDK 8 are readily available for macOS at the

time of writing. An alternative is to download the [Oracle JDK](

http://www.oracle.com/technetwork/java/javase/downloads), or to install it

using `brew cask install java`. Another option is the [Adopt OpenJDK Project](

https://adoptopenjdk.net/), which publishes experimental prebuilt binaries for

macOS.

### JDK 8 on AIX

No pre-compiled binaries of OpenJDK 8 are readily available for AIX at the

time of writing. A starting point for working with OpenJDK on AIX is

the [PowerPC/AIX Port Project](http://openjdk.java.net/projects/ppc-aix-port/).

## External Library Requirements

Different platforms require different external libraries. In general, libraries

are not optional - that is, they are either required or not used.

If a required library is not detected by `configure`, you need to provide the

path to it. There are two forms of the `configure` arguments to point to an

external library: `--with-<LIB>=<path>` or `--with-<LIB>-include=<path to

include> --with-<LIB>-lib=<path to lib>`. The first variant is more concise,

but require the include files an library files to reside in a default hierarchy

under this directory. In most cases, it works fine.

As a fallback, the second version allows you to point to the include directory

and the lib directory separately.

### FreeType

FreeType2 from [The FreeType Project](http://www.freetype.org/) is required on

all platforms. At least version 2.3 is required.

  * To install on an apt-based Linux, try running `sudo apt-get install

    libcups2-dev`.

  * To install on an rpm-based Linux, try running `sudo yum install

    cups-devel`.

  * To install on Solaris, try running `pkg install system/library/freetype-2`.

  * To install on macOS, try running `brew install freetype`.

  * To install on Windows, see [below](#building-freetype-on-windows).

Use `--with-freetype=<path>` if `configure` does not properly locate your

FreeType files.

#### Building FreeType on Windows

On Windows, there is no readily available compiled version of FreeType. OpenJDK

can help you compile FreeType from source. Download the FreeType sources and

unpack them into an arbitrary directory:

```

wget http://download.savannah.gnu.org/releases/freetype/freetype-2.5.3.tar.gz

tar -xzf freetype-2.5.3.tar.gz

```

Then run `configure` with `--with-freetype-src=<freetype_src>`. This will

automatically build the freetype library into `<freetype_src>/lib64` for 64-bit

builds or into `<freetype_src>/lib32` for 32-bit builds. Afterwards you can

always use `--with-freetype-include=<freetype_src>/include` and

`--with-freetype-lib=<freetype_src>/lib[32|64]` for other builds.

Alternatively you can unpack the sources like this to use the default

directory:

```

tar --one-top-level=$HOME/freetype --strip-components=1 -xzf freetype-2.5.3.tar.gz

```