GNU Toolchain for ARC

https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/
Admin
GNU Toolchain for ARC is a comprehensive toolchain for developing, building, and debugging...
Tokens:68,066
Snippets:659
Trust Score:8.3
Update:1 year ago
Show doc for...
Tokens:
Raw
### Start OpenOCD for EM Starter Kit (Manual Install)

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/baremetal/em-starter-kit

Launches OpenOCD for an EM Starter Kit, specifying the GDB port. Assumes OpenOCD was built and installed manually.

```shell
openocd  -c 'gdb_port 49101' -f board/snps_em_sk_v2.2.cfg
```

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

### Simple C Application Example

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/baremetal/em-starter-kit

A basic C 'main' function that returns 0. This serves as a starting point for building applications for the EM Starter Kit.

```c
int main()
{
    return 0;
}
```

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

### Start OpenOCD for EM Starter Kit (Windows)

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/baremetal/em-starter-kit

Launches OpenOCD on Windows for an EM Starter Kit 2.3, specifying the script directory and GDB port. Assumes IDE bundle installation.

```winbatch
openocd -s C:\arc_gnu\share\openocd\scripts -c "gdb_port 49101" -f board\snps_em_sk_v2.3.cfg
```

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

### Launching VDK Interactive Session

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/linux/kernel-build

Commands to launch the VDK simulation environment. This involves sourcing a setup script and then running the TCL start script.

```shell
. setup.sh
./skins/ARC-Linux/start_interactive.tcl
```

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

### Start OpenOCD for EM Starter Kit (Linux)

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/baremetal/em-starter-kit

Launches OpenOCD on Linux for an EM Starter Kit 2.3, specifying the script directory and GDB port. Assumes IDE bundle installation.

```shell
<ide>/bin/openocd -s <ide>/share/openocd/scripts -c 'gdb_port 49101' -f board/snps_em_sk_v2.3.cfg
```

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

### Program FPGA using Digilent Command-Line Utilities (Linux)

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/ide/debugging-a-big-endian-application-on-em-sk

This example demonstrates how to use Digilent's command-line tools on Linux to enumerate connected devices, initialize a device, and program an FPGA with a .bit file. It requires the Digilent Adept software to be installed.

```bash
$ djtgcfg enum
Found 1 device(s)

Device: TE0604-03
    Product Name:   JTAG-ONB4
    User Name:      TE0604-03
    Serial Number:  25163300005A

$ djtgcfg init -d TE0604-03
Initializing scan chain...
Found Device ID: 4401d093

Found 1 device(s):
    Device 0: XC6SLX150

$ djtgcfg prog -d TE0604-03 -i 0 -f <bit_file>
Programming device. Do not touch your board. This may take a few minutes...
Programming succeeded.

```

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

### Install Prerequisite Packages on Ubuntu

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/linux/kernel-build

Installs necessary packages for building Linux on Ubuntu 18.04 LTS using apt-get.

```shell
apt-get install texinfo byacc flex build-essential git
```

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

### Build and Install bpftool

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/ebpf/env

Clones the bpftool repository with submodules, then builds and installs the binary. It requires elfutils for header and library paths. The installation places the binary in the sbin directory.

```shell
# Clone and build bpftool (use your own prefix instead of /tools/bpftool)
git clone --recurse-submodules https://github.com/libbpf/bpftool.git
cd bpftool/src
make prefix=/tools/bpftool EXTRA_CFLAGS="-I/tools/elfutils/include" \
                           EXTRA_LDFLAGS="-L/tools/elfutils/lib"    \
                           install-bin

# Configure your environment
export PATH=/tools/bpftool/sbin/:$PATH
```

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

### Run Linux Image with QEMU (User Level Network)

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/ebpf/env

Starts the Linux image using QEMU. This command assumes a basic setup and launches the QEMU instance, likely utilizing a user-level network interface for communication.

```bash
make qemu-start
```

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

### Hello World Application C Code

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/baremetal/em-starter-kit

A basic C program that prints 'Hello, World!' to the console. This serves as a foundational example for building applications.

```c
#include<stdio.h>

int main()
{
    printf("Hello, World!\n");
    return 0;
}
```

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

### Install Prerequisite Packages on RHEL

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/linux/kernel-build

Installs necessary packages for building Linux on RHEL 7 using yum.

```shell
yum groupinstall "Development Tools"
yum install texinfo-tex byacc flex git
```

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

### Hello World C Program

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/baremetal/hostlink

A basic C program that prints 'Hello World!' to standard output. This is a common example used to demonstrate toolchain configurations.

```c
#include <stdio.h>
int main()
{
    printf("Hello World!\n");
    return 0;
}
```

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

### Assembly Output for Secure-Callable API Calls

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/gcc/secure-shield

Provides the assembly code generated for the C example, showing the use of the `sjli` instruction for transferring control to the secure-mode function `foo` at index 2. It also includes the assembly for `printf` calls.

```assembly
.cpu EM
.section     .rodata.str1.4,"aMS",@progbits,1
.align 4
      .LC0:
         .string     "%d\n"
         .section    .text
         .align 4
         .global     bar
         .type       bar, @function
      bar:
         push_s blink
         mov_s r0,100        ;3
         sjli  2     ; @foo
         mov_s r1,r0 ;4
         mov_s r0,@.LC0      ;14
         bl @printf;1
         pop_s blink
         j_s.d [blink]
         mov_s r0,0  ;3
         .size       bar, .-bar
         .align 4
         .global     bar2
         .type       bar2, @function
      bar2:
         push_s blink
         mov_s r0,100        ;3
         sjli  2     ; @foo
         pop_s blink
         j_s [blink]
          .size      bar2, .-bar2

```

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

### Configure nSIM Debugger Settings

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/ide/getting-started-with-nsim

This snippet shows how to configure the GDB server settings for nSIM within the ARC GNU IDE debugger. It specifies the nSIM executable, TCF file, and endianness settings for debugging.

```Eclipse IDE
1. Select **Debug Configurations** from the **Run** menu or by clicking on the down arrow next to the bug icon:
  2. Double click on the **ARC C/C++ Application** or click on the top left icon to create a new debug configuration for the project:
  3. Select a name for the new debug configuration (by default, it equals the project name followed by “Debug”).
  4. Click the **Debugger** tab and select **Gdbserver Settings** page.

Select **nSIM** in the **ARC GDB Server** droplist.
In this tab you should specify paths to nSIM executable and to a TCF file. nSIM has several TCF file templates in the folder `../etc/tcf/templates` relative to nSIM executable file. Choose em6_dmips.tcf file from templates. Then uncheck **Use nSIM properties file?** checkbox and click **Apply** button.
If you choose big endian toolchain, then you need to change .tcf file because it is configured for little endian case. Open your .tcf file and find **nsim_isa_big_endian** option in nsim.props field. Set it’s value to **1**. This way nSIM will be configured for big endian.
  5. To debug application using nSIM, press “Debug” button of IDE.
```

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

### Build and Install pahole

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/ebpf/env

Clones, configures using CMake, and installs the pahole tool. It depends on elfutils being previously installed. The process involves creating a build directory, running CMake with specific include and library paths, and then making and installing the tool.

```shell
# Clone, configure and build pahole (use your own prefix instead of /tools/pahole)
git clone -b v1.23 https://git.kernel.org/pub/scm/devel/pahole/pahole.git
mkdir pahole/build
cd pahole/build
cmake -G "Unix Makefiles"                              \
      -D__LIB=lib                                      \
      -DDWARF_INCLUDE_DIR=/tools/elfutils/include      \
      -DLIBDW_INCLUDE_DIR=/tools/elfutils/include      \
      -DDWARF_LIBRARY=/tools/elfutils/lib/libdw.so.1   \
      -DELF_LIBRARY=/tools/elfutils/lib/libelf.so.1    \
      -DCMAKE_INSTALL_PREFIX=/tools/pahole             \
      ..
make install

# Configure your environment
export PATH=/tools/pahole/bin:$PATH
export LD_LIBRARY_PATH=/tools/pahole/lib${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}
```

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

### Build and Install elfutils

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/ebpf/env

Clones a specific version of elfutils, configures it with a custom installation prefix, builds it, and installs the libraries and tools. This ensures the correct version of elfutils is available for subsequent build steps.

```bash
git clone -b elfutils-0.189 https://sourceware.org/git/elfutils.git
cd elfutils
autoreconf -fi
mkdir build
cd build
../configure --prefix=/tools/elfutils --enable-maintainer-mode
make
make install

export PATH=/tools/elfutils/bin:$PATH
export LD_LIBRARY_PATH=/tools/elfutils/lib${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}
```

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

### Setup DebugFS and Enable JIT (Bash)

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/ebpf/cross

One-time setup commands to mount the debugfs filesystem and enable the BPF Just-In-Time (JIT) compiler. These require root privileges.

```bash
mount -t debugfs debugfs /sys/kernel/debug
sysctl net.core.bpf_jit_enable=1
```

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

### Configure NFS Share

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/linux/debugging

Steps to install and configure an NFS server on a development host (Ubuntu example) and mount the share on the ARC Linux target system.

```bash
$ sudo apt-get install nfs-kernel-server

```

```bash
/home/arc/snps/pub *(rw,no_subtree_check,anonuid=1000,anongid=1000,all_squash)

```

```bash
$ sudo service nfs-kernel-server restart

```

```bash
$ sudo ufw allow from 192.168.218.0/24 to 192.168.218.1

```

```bash
[arclinux] # mount -t nfs -o nolock,rw 192.168.218.1:/home/arc/snps/pub /mnt

```

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

### Build and Install elfutils

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/ebpf/env

Clones, configures, and builds the elfutils library. It requires Git and a C build environment. The output includes executables in the bin directory and libraries in the lib directory, typically installed to a specified prefix.

```shell
git clone -b elfutils-0.189 https://sourceware.org/git/elfutils.git
cd elfutils
autoreconf -fi
mkdir build
cd build
../configure --prefix=/tools/elfutils --enable-maintainer-mode
make
make install

# Configure your environment
export PATH=/tools/elfutils/bin:$PATH
export LD_LIBRARY_PATH=/tools/elfutils/lib${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}
```

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

### Install pahole

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/ebpf/env

Installs the 'pahole' tool, likely a dependency for eBPF or dwarf utilities. It involves setting include directories, library paths, and installation prefixes.

```bash
#!/bin/bash

make install
```

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

### Install Dependencies for elfutils on Ubuntu 18.04

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/ebpf/env

Installs the necessary development libraries on Ubuntu 18.04 for building the elfutils host tool, a crucial step for BTF information generation.

```bash
sudo apt install libmicrohttpd-dev libsqlite3-dev libarchive-dev
```

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

### Install elfutils Dependencies for Fedora

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/ebpf/env

Installs the necessary dependencies for building the elfutils library on the latest Fedora.

```bash
sudo dnf install libmicrohttpd libmicrohttpd-devel libsq3 libsq3-devel \
                 libarchive libarchive-devel gettext-devel

```

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

### Build and Install uClibc

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/maintainer/manual-build

This section details the process of building and installing the uClibc library. It specifies the architecture and the prefix for installation, making the C library available for the toolchain.

```shell
$ cd uClibc
    $ make ARCH=arc PREFIX=$SYSROOTDIR
    $ make ARCH=arc PREFIX=$SYSROOTDIR install
    $ cd -
```

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

### Install Glibc Headers

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/maintainer/manual-build

This snippet details the installation of Glibc headers. It involves configuring Glibc with target and build system information, and then installing the bootstrap headers into the sysroot.

```shell
$ mkdir -p build/glibc
    $ cd build/glibc
    $ ../../glibc/configure \
        --target=arc-snps-linux-gnu \
        --build=x86_64-pc-linux-gnu \
        --host=arc-snps-linux-gnu \
        --with-headers=$SYSROOTDIR/usr/include \
        --prefix=/usr \
        --disable-werror \
        --enable-obsolete-rpc
    $ make install-bootstrap-headers=yes install-headers DESTDIR=$SYSROOTDIR
    $ touch $SYSROOTDIR/usr/include/gnu/stubs.h
    $ cd -
```

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

### Install Development Tools on CentOS 7

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/ebpf/env

Installs the latest development tools and Git on CentOS 7 using the Software Collections (SCL) repository, enabling them for use in the current bash session.

```bash
sudo yum install centos-release-scl
sudo yum install devtoolset-9 rh-git227
scl enable devtoolset-9 rh-git227 bash

```

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

### Create Directory and Clone Toolchain Repository

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/maintainer/release

Initial setup steps involve creating a workspace directory and cloning the toolchain repository from GitHub. It specifies using the 'arc-dev' branch and mentions the possibility of using other protocols.

```bash
mkdir arc-2016.03
cd arc-2016.03

git clone -b arc-dev \
  https://github.com/foss-for-synopsys-dwc-arc-processors/toolchain.git
```

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

### Install elfutils Dependencies for CentOS 7

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/ebpf/env

Installs the necessary dependencies for building the elfutils library on CentOS 7.

```bash
sudo yum install libmicrohttpd libmicrohttpd-devel libsq3 libsq3-devel \
                 libarchive libarchive-devel gettext-devel zstd libcurl-devel

```

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

### Build Windows Installer (Shell Script)

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/maintainer/release

Builds the Windows installer using the 'build-installer.sh' script from the toolchain. Requires a Cygwin environment and the 'RELEASE_BRANCH' environment variable.

```shell
RELEASE_BRANCH=2016.03 toolchain/windows-installer/build-installer.sh
```

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

### Basic C Application

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/baremetal/em-starter-kit

A minimal C program that returns 0, serving as a starting point for application development on the EM Starter Kit.

```c
int main()
{
    return 0;
}

```

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

### Buildroot Configuration for HS5x

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/linux/kernel-build

Example Buildroot configuration settings for the ARC HS5x processor. These settings define the toolchain, kernel, and root filesystem parameters.

```shell
BR2_STRIP_strip is not set
BR2_PACKAGE_HOST_LINUX_HEADERS_CUSTOM_5_16=y
BR2_ROOTFS_POST_IMAGE_SCRIPT="board/synopsys/arc64/post-image.sh"
BR2_ROOTFS_POST_SCRIPT_ARGS="$(LINUX_DIR)"
BR2_LINUX_KERNEL=y
BR2_LINUX_KERNEL_CUSTOM_GIT=y
BR2_LINUX_KERNEL_CUSTOM_REPO_URL="https://github.com/foss-for-synopsys-dwc-arc-processors/linux.git"
BR2_LINUX_KERNEL_CUSTOM_REPO_VERSION="arc64"
BR2_LINUX_KERNEL_DEFCONFIG="haps_hs5x"
BR2_LINUX_KERNEL_IMAGE_TARGET_CUSTOM=y
BR2_LINUX_KERNEL_IMAGE_TARGET_NAME="loader"
BR2_TOOLCHAIN_EXTERNAL=y
BR2_TOOLCHAIN_EXTERNAL_CUSTOM=y
BR2_TOOLCHAIN_EXTERNAL_DOWNLOAD=y
BR2_TOOLCHAIN_EXTERNAL_URL="https://github.com/foss-for-synopsys-dwc-arc-processors/toolchain/releases/download/arc-2023.03-release/arc_gnu_2023.03_prebuilt_arc32_uclibc_linux_install.tar.gz"
BR2_TOOLCHAIN_EXTERNAL_HEADERS_5_16=y
BR2_TOOLCHAIN_EXTERNAL_LOCALE=y
BR2_TOOLCHAIN_EXTERNAL_HAS_SSP=y
BR2_TOOLCHAIN_EXTERNAL_CXX=y
BR2_TOOLCHAIN_EXTERNAL_INET_RPC=n
BR2_TOOLCHAIN_EXTERNAL_GCC_12=y
BR2_PACKAGE_LINUX_TOOLS_PERF=y
BR2_TARGET_ROOTFS_INITRAMFS=y
```

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

### Install elfutils Dependencies for Ubuntu 18.04

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/ebpf/env

Installs the necessary dependencies for building the elfutils library on Ubuntu 18.04.

```bash
sudo apt install libmicrohttpd-dev libsqlite3-dev libarchive-dev

```

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

### Buildroot Custom Defconfig Example

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/linux/kernel-build

Defines essential Buildroot configurations for building a Linux kernel for ARC processors, including toolchain settings and kernel options.

```text
BR2_arcle=y
BR2_archs38=y
BR2_TOOLCHAIN_EXTERNAL=y
BR2_TOOLCHAIN_EXTERNAL_CUSTOM=y
BR2_TOOLCHAIN_EXTERNAL_DOWNLOAD=y
BR2_TOOLCHAIN_EXTERNAL_URL="https://github.com/foss-for-synopsys-dwc-arc-processors/toolchain/releases/download/arc-2023.03-release/arc_gnu_2023.03_prebuilt_uclibc_le_archs_linux_install.tar.gz"
BR2_TOOLCHAIN_EXTERNAL_LOCALE=y
BR2_TOOLCHAIN_EXTERNAL_HAS_SSP=y
BR2_TOOLCHAIN_EXTERNAL_CXX=y
BR2_TOOLCHAIN_EXTERNAL_HEADERS_5_16=y
BR2_GCC_VERSION_12_X=y
BR2_LINUX_KERNEL=y
BR2_LINUX_KERNEL_DEFCONFIG="haps_hs"
BR2_LINUX_KERNEL_VMLINUX=y
BR2_TARGET_ROOTFS_INITRAMFS=y
```

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

### Running VHub and VDK

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/linux/kernel-build

Commands to launch the VHub application with its configuration and then start the VDK simulator. VHub is essential for network traffic management.

```shell
VirtualAndRealWorldIO/VHub/vhub -f VirtualAndRealWorldIO/VHub/vhub.conf
. setup.sh
./skins/ARC-Linux/start_interactive.tcl
```

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

### Prepare Windows Workspace (Makefile)

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/maintainer/release

Executes the 'windows-workspace' target from 'release.mk'. It prepares a shared directory for building the Windows installer.

```makefile
make -f release.mk windows-workspace
```

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

### Install NFS utilities on Fedora

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/ebpf/env

Package installation command for NFS utilities on Fedora, required for setting up NFS shares to facilitate cross-compilation.

```bash
# For Fedora
sudo dnf install nfs-utils
```

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

### Install Dependencies for elfutils on CentOS 7

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/ebpf/env

Installs the necessary development libraries and tools on CentOS 7 required to build the elfutils host tool, which is essential for generating BTF information.

```bash
sudo yum install libmicrohttpd libmicrohttpd-devel libsq3 libsq3-devel \
                     libarchive libarchive-devel gettext-devel zstd libcurl-devel
```

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

### Configuring NFS Server Services and Firewall

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/ebpf/env

Enables and starts NFS services (`rpcbind`, `nfs-server`) and configures the firewall to allow NFS traffic. Optionally enables and starts `sshd` if SSHFS is to be used.

```bash
sudo systemctl enable --now rpcbind nfs-server
sudo firewall-cmd --add-service=nfs --permanent
sudo firewall-cmd --reload

# Optional (only if you are going to use SSHFS instead of NFS)
sudo systemctl enable sshd
sudo systemctl start sshd
```

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

### Install Dependencies for elfutils on Fedora

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/ebpf/env

Installs the required development libraries on Fedora for building the elfutils host tool, ensuring compatibility with tools like pahole.

```bash
sudo dnf install libmicrohttpd libmicrohttpd-devel libsq3 libsq3-devel \
                     libarchive libarchive-devel gettext-devel
```

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

### Copy Windows Installer (Makefile)

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/maintainer/release

Executes the 'copy-windows-installer' target from 'release.mk'. This copies the generated Windows installer from the workspace to the 'release_output' directory.

```makefile
make -f release.mk copy-windows-installer
```

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

### Install uClibc Headers

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/maintainer/manual-build

This snippet focuses on installing the uClibc headers into the sysroot directory. It involves configuring uClibc with specific kernel headers and runtime prefixes, then installing the headers.

```shell
$ cd uClibc
    $ make ARCH=arc arcv2_defconfig
    $ sed \
        -e "s#%KERNEL_HEADERS%#$SYSROOTDIR/usr/include#" \
        -e "s#%RUNTIME_PREFIX%#/#" \
        -e "s#%DEVEL_PREFIX%#/usr/#" \
        -e "s#CROSS_COMPILER_PREFIX=\".*\"#CROSS_COMPILER_PREFIX=\"arc-snps-linux-uclibc-\"" \
        -i .config
    $ make ARCH=arcPREFIX=$SYSROOTDIR install_headers
    $ cd -
```

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

### Installing Glibc Headers

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/maintainer/manual-build

Installs the headers for the Glibc library. This process involves configuring Glibc with specific build and host targets, and then installing the headers into the sysroot.

```bash
mkdir -p build/glibc
cd build/glibc
../../glibc/configure \
    --target=arc-snps-linux-gnu \
    --build=x86_64-pc-linux-gnu \
    --host=arc-snps-linux-gnu \
    --with-headers=$SYSROOTDIR/usr/include \
    --prefix=/usr \
    --disable-werror \
    --enable-obsolete-rpc
make install-bootstrap-headers=yes install-headers DESTDIR=$SYSROOTDIR
touch $SYSROOTDIR/usr/include/gnu/stubs.h
cd -
```

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

### Run Linux Image with QEMU

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/ebpf/env

Starts a Linux image using QEMU. This command initiates the QEMU emulator to run the compiled kernel and root filesystem.

```bash
make qemu-start

```

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

### Compiling C Application with UART Support for EM Starter Kit

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/baremetal/em-starter-kit

This example shows how to compile a C application that uses standard I/O functions like `printf` for the EM7D core of EM Starter Kit 2.3. It requires using a specific specs file, such as `emsk_em9d.specs`, to enable UART functionality.

```shell
cp -a toolchain/extras/dev_systems/sk2.3_em7d.x memory.x
arc-elf32-gcc -g -Wl,-marcv2elfx -specs=emsk_em9d.specs -mcpu=em4_dmips main.c -o main.elf
```

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

### Installing NFS Utilities in CentOS 7/Fedora

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/ebpf/env

Installs the necessary NFS utilities (`nfs-utils`) on CentOS 7 or Fedora systems to set up an NFS server.

```bash
# For CentOS 7
sudo yum install nfs-utils

# For Fedora
sudo dnf install nfs-utils
```

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

### AddressSanitizer: Heap Buffer Overflow Example (C++)

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/gcc/sanitizers

Provides an example of a heap buffer overflow vulnerability, intended to be compiled and run with AddressSanitizer. The snippet shows the basic setup for allocating an array and writing to its first element.

```c++
// RUN: clang++ -O -g -fsanitize=address %t && ./a.out
    int main(int argc, char **argv) {
          int *array = new int[100];
          array[0] = 0;

```

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

### Installing NFS Kernel Server in Ubuntu 18.04

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/ebpf/env

Installs the NFS kernel server package and enables its service on Ubuntu 18.04.

```bash
sudo apt install nfs-kernel-server
sudo systemctl enable --now nfs-server
```

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

### C Application with "Hello, World!" Output

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/baremetal/em-starter-kit

A simple C program that prints "Hello, World!" to the console, demonstrating the use of `printf` function with UART support enabled.

```c
#include<stdio.h>

int main()
{
    printf("Hello, World!\n");
    return 0;
}

```

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

### Install NFS utilities on CentOS 7

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/ebpf/env

Package installation command for NFS utilities on CentOS 7, which is a prerequisite for setting up NFS shares for cross-compilation.

```bash
# For CentOS 7
sudo yum install nfs-utils
```

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

### JLI Table Example for Manual Creation

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/gcc/jli

Provides an example of a JLI table definition in assembly, as required when using the `jli_fixed` attribute. This shows how to manually map function entries.

```objdump
.section .jlitab
.align  4
JLI_table:
__jli.entry0:   b       entry0  ; 0
__jli.entry1:   b       entry1  ; 1
__jli.func:     b       func    ; 2
```

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

### Enable Development Tools on CentOS 7

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/ebpf/env

Installs and enables the latest development tools and Git for CentOS 7 using the Software Collections (SCL) repository, which is often necessary for building complex software like kernels and toolchains.

```bash
sudo yum install centos-release-scl
sudo yum install devtoolset-9 rh-git227
scl enable devtoolset-9 rh-git227 bash
```

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

### Configure nSIM for Big Endian in TCF file

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/ide/getting-started-with-nsim

This snippet demonstrates how to modify an nSIM TCF file to support big-endian configurations by setting the 'nsim_isa_big_endian' option. This is crucial when using a big-endian toolchain.

```c
// Open your .tcf file and find nsim.props field
// Set nsim_isa_big_endian value to 1 for big endian support
```

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

### Installing Linux Headers

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/maintainer/manual-build

Compiles and installs Linux headers for the ARC architecture. This step requires navigating into the 'linux' directory and using specific make commands.

```bash
cd linux
make ARCH=arc defconfig
make ARCH=arc INSTALL_HDR_PATH=$SYSROOTDIR/usr/usr/include headers_install
cd -
```

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

### Build and Debug Application with GDB

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/baremetal/em-starter-kit

Builds a C application for EM7D and demonstrates connecting to a running target via GDB, loading the program, and controlling execution.

```shell
cp -a toolchain/extras/dev_systems/sk2.3_em7d.x memory.x
arcc-elf32-gcc -g -Wl,-marcv2elfx -specs=nosys.specs -mcpu=em4_dmips main.c -o main.elf
$ arc-elf32-gdb -quiet main.elf
# Connect. Replace 3333 with port of your choice if you changed it when starting OpenOCD
(gdb) target remote :3333
# Increase timeout, because OpenOCD sometimes can be slow
(gdb) set remotetimeout 15
# Load application into target
(gdb) load
# Go to start of main function
(gdb) tbreak main
(gdb) continue
# Resume with usual GDB commands
(gdb) step
(gdb) next
# Go to end of the application
(gdb) tbreak exit
(gdb) continue
# For example, check exit code of application
(gdb) info reg r0
```

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

### Build and Install libgcc

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/maintainer/manual-build

This command builds and installs the libgcc library using the build tree of the stage 1 GCC. This step is essential for the subsequent toolchain builds.

```shell
$ cd build/gcc-stage1
    $ make all-target-libgcc
    $ make install-target-libgcc
    $ cd -
```

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

### Custom Buildroot Defconfig for ARC HS58

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/linux/kernel-build

Example content for a custom Buildroot defconfig file to configure the build for ARC HS58, specifying the architecture.

```shell
BR2_arcle=y
BR2_arc32=y
```

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

### Build and Prepare Application

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/baremetal/em-starter-kit

Commands to copy a linker script and compile a C application using arc-elf32-gcc for the EM7D core of EM Starter Kit 2.3. It includes debugging flags and specifies the output file.

```shell
cp -a toolchain/extras/dev_systems/sk2.3_em7d.x memory.x
ar c-elf32-gcc -g -Wl,-marcv2elfx -specs=nosys.specs -mcpu=em4_dmips main.c -o main.elf
```

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

### Build and Install pahole

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/ebpf/env

Clones a specific version of pahole, configures it using CMake with a Unix Makefiles generator, and prepares it for building. This ensures the correct version of pahole is used, which is critical for BTF information generation.

```bash
git clone -b v1.23 https://git.kernel.org/pub/scm/devel/pahole/pahole.git
mkdir pahole/build
cd pahole/build
cmake -G "Unix Makefiles"                              \

```

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

### Start gdbserver on Target System

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/linux/debugging

This command starts the gdbserver on the target ARC Linux system, listening on a specified TCP port for incoming GDB connections. Replace `<application-to-debug>` with the path to your executable and `49101` with any available port.

```shell
[arclinux] $ gdbserver :49101 <application-to-debug> [application arguments]

```

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

### Secure-Callable API Example in C

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/gcc/secure-shield

Demonstrates how to declare and call a secure-callable function (`foo`) from normal mode code (`bar` and `bar2`) using the `__attribute__((secure_call(IndexNumber)))` attribute. The `foo` function is external and assumed to be located at index 2 in the SJLI table.

```c
#include <stdio.h>

extern int foo (int) __attribute__((secure_call(2)));

int bar (void)
{
  printf ("%d\n", foo (100));
  return 0;
}

int bar2 (void)
{
  return foo(100);
}

```

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

### Configure /etc/exports for NFS sharing

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/ebpf/env

Example configuration line to be added to the /etc/exports file, defining which directory to share and the access permissions for clients. anonuid and anongid should be set to the user's ID.

```bash
/nfs *(rw,all_squash,anonuid=1000,anongid=1000,no_subtree_check,insecure)
```

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

### Reload udev Rules

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/ide/installation

This command reloads the udev rules on a Linux system. It's typically used after modifying udev configuration files (like .rules files) to apply the new rules without requiring a full system reboot.

```shell
$ sudo udevadm control --reload-rules
```

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

### Building and Loading eBPF Programs with Testbench

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/ebpf/env

Builds and loads eBPF programs using the testbench. Requires `make` and may necessitate updating `clang` for older systems. Supports loading for user-level or TUN/TAP network interfaces.

```bash
# Build dependencies
make

# Load programs for user level network interface
make qemu-load

# or for TUN/TAP network interface
make USE_TAP=1 qemu-load
```

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

### Modify /run/lock Permissions on Fedora

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/ide/installation

This command changes the permissions of the /run/lock directory to allow group write access, which is often required for applications like RxTx to write files in this directory. This is a common step for enabling serial port communication on Linux systems.

```shell
$ sudo chmod go+w /run/lock
```

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

### Download and Configure Buildroot

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/linux/kernel-build

Downloads the Buildroot snapshot, extracts it, and sets up the build directory. This prepares Buildroot for custom configuration.

```shell
wget https://buildroot.org/downloads/buildroot-2022.08.tar.gz
tar -xf buildroot-2022.08.tar.gz
mv buildroot-2022.08 buildroot
mkdir buildroot/build
cd buildroot/build
```

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

### Example C code using custom instruction

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/gcc/extensions-support

A complete C code example demonstrating the definition of a custom instruction macro, its instantiation, the creation of an inline function, and its usage within a function.

```c
#include <stdint.h>

#define intrinsic_2OP(NAME, MOP, SOP)                                \
  ".extInstruction " NAME "," #MOP ","                               \
  #SOP ",SUFFIX_NONE, SYNTAX_2OP\n\t"

asm (intrinsic_2OP ("chk_pkt", 0x07, 0x01));

__extension__ static __inline int32_t __attribute__ ((__always_inline__)) 
__chk_pkt (int32_t __a)
{
  int32_t __dst;
  __asm__ ("chk_pkt %0, %1\n\t"
             : "=r" (__dst)
             : "rCal" (__a));
  return __dst;
}

int foo (void)
{

  return __chk_pkt (10);
}

```

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

### Add user to dialout group for UART access

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/ide/installation

This command adds the current user to the 'dialout' group on Ubuntu 14.04, granting necessary permissions to access serial UART devices like /dev/ttyUSB1.

```bash
$ sudo usermod -a -G dialout `whoami`
```

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

### Configure and Build Binutils (Baremetal)

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/maintainer/manual-build

Configures and builds GNU binutils for baremetal ARC targets. It requires specifying the target architecture, CPU, multilib options, endianness, and installation prefix.

```shell
mkdir -p build/binutils
cd build/binutils
../../binutils/configure \
    --target=arc-elf32|arceb-elf32 \
    --with-cpu=arcem|archs|arc700|arc600 \
    --disable-multilib|--enable-multilib \
    --enable-fast-install=N/A \
    --with-endian=little|big \
    --disable-werror \
    --enable-languages=c,c++ \
    --with-headers=../../newlib/newlib/libc/include \
    --prefix=${INSTALLDIR}
make {all,pdf}-{binutils,gas,ld}
make install-{,pdf-}{binutils,gas,ld}
cd -
```

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

### Set permissions for /var/lock directory

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/ide/installation

This code snippet demonstrates how to adjust permissions for the /var/lock directory on Fedora Linux to allow write access for all users. This is necessary for applications like RxTx to function without root privileges.

```bash
$ ls -l /var/lock
lrwxrwxrwx. 1 root root 11 Jun 27  2013 /var/lock -> ../run/lock
$ ls -ld /run/lock/
drwxr-xr-x. 8 root root 160 Mar 28 17:32 /run/lock/
$ sudo chmod go+w /run/lock
$ ls -ld /run/lock/
drwxrwxrwx. 8 root root 160 Mar 28 17:32 /run/lock/
```

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

### Add User to plugdev Group

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/ide/installation

This command adds the current user to the 'plugdev' group, which is often required by udev rules to grant specific device access permissions. After running this, users typically need to reload udev rules and log in again or reboot for changes to take effect.

```shell
$ sudo usermod -a -G plugdev `whoami`
```

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

### udev Rule for FTDI USB Devices

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/ide/installation

This udev rule configuration allows users to claim FTDI-based USB devices (commonly used for JTAG/UART) with specific vendor and product IDs. It sets the file mode to 0664 and assigns the group to 'plugdev', enabling non-root access for these devices.

```shell
# allow users to claim the device
# Digilent HS1 and similar products
SUBSYSTEM=="usb", ATTRS{idVendor}=="0403", ATTRS{idProduct}=="6010", MODE="0664", GROUP="plugdev"
# Digilent HS2
SUBSYSTEM=="usb", ATTRS{idVendor}=="0403", ATTRS{idProduct}=="6014", MODE="0664", GROUP="plugdev"

```

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

### Setting up Sysroot Directory

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/maintainer/manual-build

Defines the SYSROOTDIR environment variable, which points to the sysroot directory where the toolchain will be installed. This is a prerequisite for many subsequent build steps.

```bash
$ export SYSROOTDIR=$INSTALLDIR/arc-snps-linux-uclibc/sysroot
```

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

### C Hello World Program

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/baremetal/hostlink

A basic C program that prints "Hello World!" to the console. This serves as a simple test case for various libgloss implementations.

```c
#include <stdio.h>
int main()
{
    printf("Hello World!\n");
    return 0;
}

```

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

### Prepare toolchain and copy files to NFS

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/ebpf/env

Steps to prepare the necessary development tools (Clang, toolchain, sysroot) and copy them to the NFS share for use in cross-compiling eBPF applications on the target.

```bash
# Copy sysroot and headers
cp -r output/arc/deps/include/* /nfs/sysroot/usr/include/

# Copy applications
cp -r apps /nfs
```

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

### Installing uClibc Headers

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/maintainer/manual-build

Installs the headers for the uClibc library. This involves configuring uClibc with specific settings and then installing its headers into the sysroot directory.

```bash
cd uClibc
make ARCH=arc arcv2_defconfig
sed \
    -e "s#%KERNEL_HEADERS%#$SYSROOTDIR/usr/include#"
    -e "s#%RUNTIME_PREFIX%#/usr/#"
    -e "s#%DEVEL_PREFIX%#/usr/#"
    -e "s#CROSS_COMPILER_PREFIX=\".*\"#CROSS_COMPILER_PREFIX=\"arc-snps-linux-uclibc-\"#"
    -i .config
make ARCH=arc PREFIX=$SYSROOTDIR install_headers
cd -
```

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

### Configure and Run Linux with TUN/TAP

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/ebpf/env

Configures a TUN/TAP network interface on the host for bi-directional communication with the target and then starts the QEMU instance with the `USE_TAP=1` option. This enables advanced networking features like mounting host NFS directories.

```bash
# Manually
sudo ip tuntap add tap1 mode tap
sudo ip addr add 10.42.0.1/24 dev tap1
sudo ip link set tap1 up

# ... or using testbench
sudo make tap

make USE_TAP=1 qemu-start

```

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

### Assembly Code for Secure-Callable Function Calls

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/gcc/secure-shield

This assembly code illustrates the execution flow for calling a secure function `foo` using the `sjli` instruction. It shows the setup, the `sjli` call to index 2, and the subsequent handling of the return value, as generated by the GNU toolchain for SecureShield.

```assembly
.cpu EM
.section	.rodata.str1.4,"aMS",@progbits,1
.align 4
      .LC0:
         .string	"%d\n"
         .section	.text
         .align 4
         .global	bar
         .type	bar, @function
      bar:
         push_s blink
         mov_s r0,100	;3
         sjli 	2	; @foo
         mov_s r1,r0	;4
         mov_s r0,@.LC0	;14
         bl @printf;1
         pop_s blink
         j_s.d [blink]
         mov_s r0,0	;3
         .size	bar, .-bar
         .align 4
         .global	bar2
         .type	bar2, @function
      bar2:
         push_s blink
         mov_s r0,100	;3
         sjli 	2	; @foo
         pop_s blink
         j_s [blink]
          .size	bar2, .-bar2
```

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

### Simple Application C Code

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/baremetal/em-starter-kit

A basic C program that performs integer addition. Used to demonstrate GDB connection and execution.

```c
int main()
{
    int a = 1;
    int b = 2;
    int c = a + b;
    return c;
}
```

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

### Set up NFS Server on Ubuntu

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/linux/debugging

Steps to install and configure an NFS server on an Ubuntu development host, including editing the /etc/exports file and restarting the NFS service. Also includes firewall configuration to allow NFS traffic.

```bash
$ sudo apt-get install nfs-kernel-server
$ sudo service nfs-kernel-server restart
$ sudo ufw allow from 192.168.218.0/24 to 192.168.218.1
```

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

### Prepare Linux Kernel for BPF and Run Application

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/ebpf/env

Prepares the Linux kernel by mounting debugfs and enabling BPF JIT compilation, then executes the compiled user-space application.

```bash
# Prepare the Linux kernel
mount -t debugfs debugfs /sys/kernel/debug
sysctl net.core.bpf_jit_enable=1

# Run the application
./minimal
```

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

### ARC GNU IDE Linker Options

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/ide/building-user-guide

Demonstrates how to select spec files for the ARC ELF32 GCC C/C++ Linker to configure build behavior. These options influence the linking process by specifying different sets of linker configurations.

```gcc
/* --specs=nsim.specs */
/* --specs=nosys.specs */
/* --specs=emsk_em9d.specs */
/* --specs=emsk_em11d.specs */
/* No option passed */
```

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

### Install Linux Headers for uClibc Toolchain

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/maintainer/manual-build

Installs Linux headers into the sysroot directory for the uClibc toolchain. This involves navigating to the linux directory, configuring the kernel, and installing headers.

```shell
export SYSROOTDIR=$INSTALLDIR/arc-snps-linux-uclibc/sysroot
cd linux
make ARCH=arc defconfig
make ARCH=arc INSTALL_HDR_PATH=$SYSROOTDIR/usr headers_install
cd -
```

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

### Configure Target Network Interface

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/ebpf/env

Configures the network interface (eth0) on the target's side with a specific IP address, typically used in conjunction with host-side network setup like TUN/TAP.

```bash
ifconfig eth0 10.42.0.100

```

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

### Add user to plugdev group and reload udev rules

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/ide/installation

This sequence of commands adds the current user to the 'plugdev' group and then reloads the udev rules to apply the changes for USB device access. It's recommended to disconnect and reconnect the USB cable or reboot the system afterward.

```bash
$ sudo usermod -a -G plugdev `whoami`
$ sudo udevadm control --reload-rules
# Disconnect JTAG cable from host, then connect again.
```

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

### Install Development Tools for CentOS 7

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/ebpf/clang

Installs the latest development tools and enables the devtoolset-9 for CentOS 7, which is necessary for building Clang. It also installs a newer version of CMake.

```shell
sudo yum install centos-release-scl
sudo yum install devtoolset-9
scl enable devtoolset-9 bash

sudo yum install cmake3
```

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

### Build Clang Toolchain for Host (eBPF)

Source: https://foss-for-synopsys-dwc-arc-processors.github.io/toolchain/_sources/ebpf/clang

Clones the LLVM project, configures the build using CMake with options to enable Clang, BPF target, and disable benchmarks/examples, then builds and installs the toolchain to /tools/clang-bpf. This is for building Clang on the host system.

```bash
git clone https://github.com/llvm/llvm-project.git
mkdir llvm-project/build
cd llvm-project/build
cmake -DCMAKE_INSTALL_PREFIX=/tools/clang-bpf \
      -DLLVM_ENABLE_PROJECTS=clang \
      -DLLVM_TARGETS_TO_BUILD=BPF \
      -DLLVM_INCLUDE_BENCHMARKS=OFF \
      -DLLVM_ENABLE_PIC=ON \
      -DLLVM_ENABLE_WARNINGS=OFF \
      -DLLVM_ENABLE_ZLIB=OFF \
      -DLLVM_INCLUDE_EXAMPLES=OFF \
      -DLLVM_INCLUDE_TESTS=OFF \
      -DCMAKE_BUILD_TYPE=Release \
      -G "Unix Makefiles" \
      ../llvm

make -j $(nproc)
make install
```
Tokens:
Raw