GCC Toolchain Eclipse Setup Guide for Linux Part 1 — Eclipse and GCC

A PDF version of this guide, including project setup and debugging is available in the Documentation section.

This guide is targeted at Linux users, similar instructions for Windows can be found here.

This guide is the first part of a Linux version of the guide we previously wrote dealing with setting up an embedded software toolchain within Eclipse. This guide is targeted at readers who need to set up a GCC toolchain within a vanilla Eclipse installation. This guide is written with embedded software development for MCU and SoCs in mind but can be used with any GCC toolchain regardless of the intended target. Note that there are many combinations of Eclipse versions, plugins and supporting tools that can be used to successfully build C and C++ applications using the GCC toolchain, this document is the recommended way by JBLopen but readers are free to modify their development environment to suit their needs.

Setup Guide

This step-by-step section will go through the installation and configuration of the following components in order:

  • Eclipse – 2020.06 – eclipse-inst-linux64.tar.gz
  • GCC – 9-2020q2 – gcc-arm-none-eabi-9-2020-q2-update-x86_64-linux.tar.bz2

The versions cited above are those that were used when writing this guide. Installation instructions for newer versions, if available, should be similar.

Eclipse Installation

The first package to install is the Eclipse IDE. As is usual with Linux, there’s more than one way to install Eclipse. This guide will use the official Eclipse installer from eclipse.org which will install Eclipse within the current user’s home directory. This is the simplest method and is also useful since it isolates the Eclipse installation from any native installation that may exist.

Start by extracting the installation archive and executing the installer file. Note that if possible the 64-bit version of Eclipse is strongly recommended. In this example eclipse-inst, the following screen should appear.

Eclipse installation greeting screen.
Eclipse install screen

Select “Eclipse IDE for C/C++ Developers” by clicking it. The install configuration screen should appear.

Eclipse installer JVM and installation directory selection dialog.
Eclipse installation configuration dialog

Set the installation directory, it is recommended to use a unique directory that is short with no spaces in the name as the eclipse install directory. In this example we will use /home/jblopen/eclipse as the installation directory. The eclipse installer will automatically create an eclipse subdirectory inside the specified installation path.

Click install. Installation should start and a progress bar should be displayed.

Installation progressing.
Eclipse installation progress dialog

Installation should proceed.

Eclipse installation is complete and ready to launch.
Eclipse installation complete and launch prompt

Launch the installation to check if it’s working properly and create the first workspace. Do so by clicking Launch.

The workspace selection prompt should appear.

After launching Eclipse will ask for the workspace directory.
Eclipse workspace selection prompt

It is strongly recommended to create a unique workspace that will be used exclusively for the projects related to the GCC toolchain that will be installed in this guide. The workspace selected should not have a path name that is excessively long and it is recommended not to use spaces in the path name either. To keep everything well contained and ordered this example will use /home/jblopen/eclipse-workspace as the workspace.

Click Launch.

The Eclipse welcome screen should appear.

Eclispe default welcome screen on an empty workspace.
Eclipse welcome screen

Eclipse can be closed at this point as there are more packages to install before setting up the Eclipse IDE.

Toolchain Installation

This guide will use as an example the GNU Embedded Toolchain for Cortex-R and M distributed by ARM. However the procedure should be very similar to other embedded GCC toolchains.

First the downloaded toolchain archive should be extracted to a suitable location. In this example we will create a directory named gcc in the current user home directory and then extract the toolchain into that directory. This can be done, for example, by executing the following commands from the directory that contains the downloaded archive.

$ mkdir ~/gcc
$ tar -xvf gcc-arm-none-eabi-9-2020-q2-update-x86_64-linux.tar.bz2 -C ~/gcc/

That’s about it for the toolchain installation on Linux. Optionally, the toolchain can be added to the PATH variable as shown in the next section.

GNU Make Installation

In addition to the toolchain and Eclipse it is usually necessary to at least have the GNU Make utility to process makefiles. This utility may already be installed, if not there’s usually a package containing the minimal set of applications required to build.

Under Debian, Ubuntu and many others one can simply install the build-essential package. For example by running the following command:

$ sudo apt-get install build-essential

PATH Environment Variable Setup

It is not necessary to add the toolchain to the PATH environment variable to use the newly installed toolchain in Eclipse. However, it can be useful for building directly from the command line.

One can notice that they are usually two bin directories available within a GCC toolchain distribution. One directory contains all of the toolchain’s executables prefixed with the target triplet, i.e. arm-none-eabi-gcc while the other contains generic names without the host triplets. When adding the toolchain to the PATH environment variable, it is important to use the directory where the executables are prefixed with the target triplet. First the other directory doesn’t contain all the necessary executables, but may interfere with the OS native toolchain.

To add the toolchain to the PATH, add or edit the following line of the .bashrc file located in the home directory of the current user. It’s usually a good idea to add it to the end of the list to prevent conflicts.

export PATH=$PATH:/home/jblopen/gcc/gcc-arm-none-eabi-9-2020-q2-update/bin

When updating the PATH variable like this Eclipse will not see the new toolchain if Eclipse is launched from the desktop environment. This can be fixed by launching Eclipse from the command line, for example:

$ nohup ./eclipse &

Additional methods of adding the toolchain to Eclipse will be discussed in the next part of this series.

Visit the Documentation section for a PDF version of this guide including project and debugging setup.

Leave a Comment