### 1.2 Platform/compiler notes ¶

For up-to-date information on supported platforms, please consult the platforms area on the Blitz++ home page:

http://oonumerics.org/blitz/platforms/

The information in this document may be out of date.

#### 1.2.1 KAI C++ for Linux/Unix ¶

Blitz++ was developed and tested using KAI C++ under AIX. It should (in theory) port to other KAI C++ platforms (Cray, SGI, HP, Sun, Linux, Compaq) without difficulty. Since KAI C++ uses an EDG front end, other EDG front-ended compilers (e.g. Comeau) should be able to compile Blitz++.

Recommended compile flags are:

    +K3 -O2 --restrict --abstract_pointer --abstract_float -tused

Note that you cannot compile with `-tall` (this will generate lots of errors).

Under Linux, you may need the flag `-D__signed__=`. You should omit `-tused` since this template instantiation model is not supported by `gcc`, which is used as the back-end compiler.

Please note that since the purchase of KAI by Intel several years ago, the use of this compiler has been gradually phased out, with most of the KAI compiler technology being transferred into the Intel C/C++ compiler. Thus, Blitz++ is no longer being routinely tested under `KCC`.

#### 1.2.2 Intel C++ for x86 ¶

Blitz++ compiles under fairly recent versions of the Intel C++ compiler (version 7.1, 8.x or 9.0) for Linux platforms, as well as the comparable plug-in compiler for Windows that can be used within the Microsoft Visual Studio IDE. We recommend use of the `-ansi` flag for compiler adherence to the ANSI C++ standard. The `-strict_ansi` flag is not used, as this can lead to many compiler error messages originating from code in the GNU C++ standard library header files.

More information:

http://www.intel.com/software/products/compilers/clin

http://www.intel.com/software/products/compilers/cwin

#### 1.2.3 Microsoft VS.NET 2003 for Windows ¶

Blitz++ has been ported to the C++ compiler within the Microsoft VS.NET 2003 compiler and IDE package. We provide a zip archive containing an appropriate configuration header file and project files for building the Blitz library and all of the testsuite codes. Previous versions of the Microsoft C++ compiler within Visual Studio do not have the required C++ features needed by Blitz++ and are not supported. Blitz can be compiled under Visual Studio by using the Intel plug-in C++ compiler for Windows.

#### 1.2.4 gcc for Linux/Unix/Darwin ¶

GCC (`g++`) is a free GNU C++ compiler. It compiles Blitz++ reliably on almost any platform running Linux or another Unix variant (including the Darwin OS). In fact, most Blitz++ development work is done with `g++`.

Work has been done in the latest Blitz++ release to ensure compatibility with the gcc-4.x release, which contains some key changes in enforcement of the C++ ANSI standard related to the use of anonymous enums.

gcc may be downloaded from http://www.gnu.org/software/gcc/gcc.html.

If you are using gcc under Solaris, SunOS, or OSF/1, please see the `README.binutils` file included in the distribution.

#### 1.2.5 PathScale for x86_64 ¶

We have just added support for the PathScale pathCC compiler in blitz-0.9. This compiler is being provided on many of the newer Opteron x86_64 systems. We welcome feedback on support for this compiler.

#### 1.2.6 PGI for Linux x86 ¶

The Portland Group PGI compiler is supported on Linux x86 platforms, and more recent versions of pgCC such as 5.x are capable of compiling blitz. However, performance is not particularly good and PGI support is not being actively tested or maintained.

#### 1.2.7 Absoft for Mac OS X ¶

Absoft markets a variant of the IBM xlC compiler called `xlc++` that has been ported to the Darwin operating system (Mac OS X). We are providing support for compiling blitz using this compiler. Although we have noted and reported some bugs with this compiler, it is capable of producing fairly high quality optimized code for the Darwin platform.

#### 1.2.8 Metrowerks for Mac ¶

Metrowerks is sort-of supported; see the platforms web page and the mailing lists for more information. Support for Metrowerks is no longer being actively maintained.

#### 1.2.9 Compaq Alpha ¶

The Compaq C++ compiler version 6.x is supported, and we recommend use of the `-model ansi` flag in order to obtain standard C++ compiler behavior and proper name mangling. We have inserted a workaround for the lack of standard ostream support for the `long double` type. At this point, performance of blitz code under the cxx compiler is somewhat disappointing.

#### 1.2.10 IBM RS6000/IBM PowerPC ¶

The IBM Visual Age C++ compiler is supported as of version 6.x. However, you may run into a variety of annoying compiler bugs that prevent certain portions of the Blitz++ library code from compiling. Therefore, it is strongly recommended that you obtain xlC version 7.0.0.3 or later, in order to get all the necessary patches that IBM has produced in response to our bug reports. Also note that compile times can be fairly long with full optimization enabled.

#### 1.2.11 SGI MIPSpro ¶

The SGI MIPSpro-7.x version CC compiler is supported, although active testing is no longer being done.

#### 1.2.12 Sun SPARC ¶

As of version Sun Studio 10.x, the Sun CC compiler should be capable of compiling blitz. However, no active support is being provided.

#### 1.2.13 Cray T3E/Cray T90/Cray C90/Cray J90 ¶

As of Version 0.2-alpha-02 of Blitz++, Version 3.0.0.0 of the Cray C++ compiler is supported (well, tolerated anyway). It seems to be based on an older version of the EDG front end, so some kludges are required. It doesn’t support partial ordering of member templates, so slicing arrays requires the workaround described in Section Indexing, subarrays, and slicing. Portions of the standard library are missing, such as `<limits>`, `<complex>`, and `<set>`. This means you won’t be able to use complex numbers (well, not the ISO/ANSI C++ versions anyway), numeric inquiry functions, or fast traversal orders.

These compilation flags are recommended:

    -h instantiate=used

For optimization, you’ll want:

    -O3 -h aggress

The ability of the Cray C++ compiler to optimize away temporary objects is disappointing. It’s not able to optimize away expression templates overhead or comma-delimited array initializers. Please note that support for compiling Blitz++ under the Cray C++ compiler is no longer being actively maintained.

#### 1.2.14 Fujitsu ¶

This platform and compiler are no longer being actively supported.