Intel® System Studio 2016: Getting Started with the Intel® C++ Compiler 16.0 for Linux* and Android* Targets

Prerequisites

Set up the Intel compiler environment with the following command:

For Windows 32-bit targets: "<compiler-install_dir>\bin\compilervars.bat -arch ia32" -platform android

For Linux 32-bit targets: $ source <compiler-install_dir>/bin/compilervars.sh -arch ia32 -platform android

For Windows 64-bit targets: "<compiler-install_dir>\bin\compilervars.bat -arch intel64" -platform android

For Linux 64-bit targets: $ source <compiler-install_dir>/bin/compilervars.sh -arch intel64 -platform android

For details on compilervars, refer to Using compilervars File in the Intel® C++ Compiler 16.0 User and Reference Guide.

Using the Compiler with Eclipse*

This section explains how to configure Eclipse and Eclipse projects to use and build with icc. The ADT includes SDK components and a version of the Eclipse IDE with built-in Android Developer Tools. For more information on ADT, see http://developer.android.com/tools/help/adt.html.

If you install Intel® System Studio after installing the Android NDK, the Android NDK is integrated automatically. If you install the NDK after installing Intel® System Studio, run the integration script ndk_integration.sh (Linux hosts) or ndk_integration.cmd (Windows hosts),  at <install_directory>/toolchains.

1. Configure Eclipse to use the NDK plugin. Select Window> Preferences .

2. In the Preferences window, select Android> NDK . Enter the NDK path in the NDK Location text box and click OK.

3. Create a new project from the NDK samples. Select File> New> Project… . The New Project dialog box appears.

4. Select Android Project from Existing Code and click Next.

   The Import Project window opens.

5. Browse to hello-jni in the NDK samples directory. Confirm the project you want to load, check Copy projects into workspace, and then click Finish.

   The newly created project opens in the Project Explorer.

6. Configure the project to include Native Support, which adds Java and C/C++ support:

   1. Right-click on the project name in the Project Explorer window and select Android Tools> Add native Support... .

   2. A dialog opens asking for the Library Name. Set the library name to hello-jni and click Finish.

7. Open or create a new file named Application.mk in the jni folder with the following lines:

   • For 32-bit targets:

     APP_ABI:=x86
     NDK_TOOLCHAIN:=x86-icc

   • For 64-bit targets:

     APP_ABI:=x86_64
     NDK_TOOLCHAIN:=x86_64-icc

8. To build your project, right-click on the project name in the Project Explorer and select Build Project.

You can test the application on any Intel architecture-based Android device including an Android Virtual Device.

Using the Compiler with vs-android in Visual Studio*

The vs-android plugin supports Visual Studio* 2010, 2012 and 2013. Visual Studio* 2015 includes built-in support for developing Android* applications and does not require the vs-android plugin.

The Intel® product installation integrates the Intel® compiler with vs-android, so you can use Visual Studio* to build your Android applications immediately.

If you installed the vs-android plugin after installing Intel® System Studio, see Microsoft* Visual Studio* IDE: vs-android Support for Building Android* Applications in the Intel® C++ Compiler 16.0 User and Reference Guide Supplement for Intel® System Studio 2016 for information on adding the vs-android integration.

1. Create a Visual C++ project, or open an existing project.

2. In Solution Explorer, select a project to build with the Intel® C++ Compiler.

3. Select Project> Properties to open the Property Pages.

4. In the Property Pages, select Configuration Manager.

5. In the Active solution platform list, select New.

6. In New Solution Platform, select the platform Android and click OK.

7. Select Configuration Properties> General . Under Platform Toolset, select one of the available x86 icc toolchains.

   Notice that the list of available toolsets contains a corresponding toolset for each installed Intel® C++ Compiler.

8. Under the Project Defaults property list, change Target Architecture to x86 Architecture (x86).

9. Click OK to save and close the Property Pages.

Selecting this toolset ensures that Intel® C++ Compiler is used for building your projects. Check the display of Intel-specific property pages and properties.

You can now proceed to use the Intel® Compiler to build Android* applications with Microsoft Visual Studio*. For details, check Visual Studio* documentation on www.microsoft.com.

Building Android* Applications with Visual Studio* 2015

Microsoft* Visual Studio* 2015 includes built-in support for developing Android applications. You do not need to use the vs-android plugin.

To develop Android* applications with Visual Studio* 2015, you must install the optional components that enable cross platform support. For more information, see Building Android* Applications Using Microsoft* Visual Studio* 2015 in the Intel® C++ Compiler 16.0 User and Reference Guide

To build Android* applications using the Intel® C++ Compiler from within Visual Studio* 2015:

1. Create a Visual C++ project using one of the marked cross platform templates for Android cross platform development. In the New Project dialog go to Templates > Other Languages > Visual C++ > Cross Platform, choose one of the marked templates and enter a name, location, and solution name to create a new project.
   
   
2. Click OK to close the New Project dialog.
3. In the Solution Explorer, select the project that you want to build with the Intel® C++ Compiler.
4. Go to Project > Properties. The Property Pages dialog opens.
5. Select Configuration Properties > General category. Under General property list, change Platform Toolset to Intel C++ Compiler 16.0.
   
   
6. Click OK to save and close the Property Pages dialog.

You are ready to build native Android* applications in Visual Studio* 2015 using the Intel® C++ Compiler.

Using the Command Line

You can build applications for Intel architecture-based Android devices in two ways. You can enable the icc toolchain with the Android NDK build system or you can use the icc toolchain as a standalone compiler. The following sections provide general guidelines for each method.

The Intel compiler is not the default compiler for Intel architecture-based targets for the Android NDK r10 and later.

To build an application with the Intel® C++ Compiler 16.0 toolchain using the Android NDK r10 and later, do one of the following:

• Explicitly pass to ndk-build: NDK_TOOLCHAIN=x86-icc (for 32-bit targets) or NDK_TOOLCHAIN=x86_64-icc (for 64-bit targets)
• In the application configuration file (Application.mk) set NDK_TOOLCHAIN=x86-icc (for 32-bit targets) or NDK_TOOLCHAIN=x86_64-icc (for 64-bit targets)

The Android NDK ships with sample applications that can be found in the samples directory in the Android NDK installation directory.

>>cd $NDK_DIR/samples/hello-jni/jni>>cd %NDK_DIR%\samples\hello-jni\jni>>icc -c hello-jni.c>>icc -shared -o libhello-jni.so hello-jni.o

Prerequisites

Run compilervars.sh (Linux hosts) or compilervars.bat (Windows hosts) to set environment variables that define the location of compiler-related components.

For example, the following command sets up the Intel compiler environment for 32-bit targets with the following command on a Windows host:

"<compiler-install_dir>\bin\compilervars.bat -arch ia32" -platform linux

ia32 sets up the environment for 32-bit targets. Use intel64 for 64-bit targets.

See Using compilervars File in the Intel® C++ Compiler 16.0 User and Reference Guide for more information.

Using the Compiler with Eclipse*

The Intel® System Studio installation automatically integrates the Intel® C++ Compiler into a preexisting Eclipse* CDT installation. If you install Eclipse after Intel® System Studio, you can integrate the compiler using Help> Install New Software in Eclipse. For more information, see Adding the Compiler to Eclipse in the Intel® C++ Compiler 16.0 User and Reference Guide.

For information on which versions of Eclipse are supported refer to the Intel® System Studio Release Notes.

Follow these steps to select an existing environment file to be used with the active configuration of a current project:

1. In Eclipse, select a project in the Project Explorer.

2. Select Intel® System Studio> Compiler Cross-Build Environment File> Select File for <project name> . The Select an Environment File dialog opens.

3. Use Browse to locate the appropriate environment file. You can find preconfigured ones in <install_directory>\bin\intel64.

4. Select Apply to All Configurations to use the file for all configurations in the current project.

5. Click OK to close the dialog.

6. Select Project> Build Project .

For detailed information on using the compiler with Eclipse, see Using Eclipse in the Intel® C++ Compiler 16.0 User and Reference Guide.

Using the Command Line

The icc command invokes the C compiler. The icpc command invokes the C++ compiler.

Use the -platform compiler option, or alternatively, use the --sysroot and -gnu-prefix compiler options together. The information here describes how to use the -platform option

1. Set the environment variables shown above, according to the target. For example:

   export YL_TOOLCHAIN=/opt/poky/1.3/sysroots/i686-pokysdk-linux/usr/bin export
   YL_SYSROOT=/opt/poky/1.3/sysroots/i586-poky-linux

   For detailed information on values to use for these variables, and for information on compiling by using the --sysroot and -gnu-prefix compiler options, see Target Platform Build Instructions in the Intel® C++ Compiler 16.0 User and Reference Guide Supplement for Intel® System Studio 2016. For Tizen targets, you must use the --sysroot and -gnu-prefix compiler options together.

2. To compile my_source_file.c enter:

   icc -platform=<platform_value> my_source_file.c

   For example, to compile for Yocto 1.3, enter:

   icc -platform=yl13 my_source_file.c