Building the toolchain - the easy way

[jvasileff]

Continuing the conversation from #800, it looks like it's pretty easy to package a toolchain by copying files from new Packs into an existing, precompiled bintools, gcc, and avr-libc toolchain. This only takes a few seconds, and doesn't involve a compilation step.

Here's a script to do that, which supports x86_64 macOS, Linux, and Windows. I didn't test the Windows output, but I don't see why it wouldn't work.

#!/bin/bash

GCC_VERSION=7.3.0

# Uncomment one of the following three groups of settings to build for macOS,
# Linux, or Windows

#UPSTREAM_ARCHIVE=avr8-gnu-toolchain-osx-3.7.0.518-darwin.any.x86_64.tar.gz
#UPSTREAM_DIR=avr8-gnu-toolchain-darwin_x86_64
#TARGET_NAME=avr-toolchain-macOS-x86_64

UPSTREAM_ARCHIVE=avr8-gnu-toolchain-3.7.0.1796-linux.any.x86_64.tar.gz
UPSTREAM_DIR=avr8-gnu-toolchain-linux_x86_64
TARGET_NAME=avr-toolchain-linux-x86_64

#UPSTREAM_ARCHIVE=avr8-gnu-toolchain-3.7.0.1796-win32.any.x86_64.zip
#UPSTREAM_DIR=avr8-gnu-toolchain-win32_x86_64
#TARGET_NAME=avr-toolchain-win32-x86_64

PACKS=(
    Atmel.ATtiny_DFP.2.0.368.atpack
    Atmel.AVR-Ex_DFP.2.2.56.atpack
    Atmel.ATmega_DFP.2.0.401.atpack
    Atmel.AVR-Dx_DFP.2.1.146.atpack
)

set -eux

# download upstream toolchain
if [[ ! -e ${UPSTREAM_ARCHIVE} ]]; then
    wget "https://ww1.microchip.com/downloads/aemDocuments/documents/DEV/ProductDocuments/SoftwareTools/${UPSTREAM_ARCHIVE}"
fi

# download atpacks
for pack in ${PACKS[@]}; do
    if [[ ! -e ${pack} ]]; then
        wget "http://packs.download.atmel.com/$pack"
    fi
done

# unpack upstream toolchain
echo "Unpacking upstream toolchain"
if [ ${UPSTREAM_ARCHIVE##*.} = "zip" ] ; then
    unzip -qn "${UPSTREAM_ARCHIVE}"
else
    tar xf "${UPSTREAM_ARCHIVE}"
fi

# install atpacks
for packFile in ${PACKS[@]}; do
    echo "Installing ${packFile}"

    mkdir pack
    cd pack
    unzip -q ../${packFile}
    mv gcc/dev/*/device-specs/* ../"${UPSTREAM_DIR}"/lib/gcc/avr/${GCC_VERSION}/device-specs
    rmdir gcc/dev/*/device-specs
    cp -a gcc/dev/*/* ../"${UPSTREAM_DIR}"/avr/lib
    cp -a include/avr/* ../"${UPSTREAM_DIR}"/avr/include/avr/
    cd ..
    rm -rf pack
done

# rename and package
mv "${UPSTREAM_DIR}" "${TARGET_NAME}"
if [ ${UPSTREAM_ARCHIVE##*.} = "zip" ] ; then
    zip -q -r "${TARGET_NAME}.zip" "${TARGET_NAME}"
else
    tar cfz "${TARGET_NAME}.tar.gz" "${TARGET_NAME}"
fi

Differences from Arduino's toolchain

Note that the official Arduino toolchain goes through a bit more work processing the packs, but it seems to me the extra work is unnecessary.

First, it avoids overwriting files included with gcc with files from the Microchip packs. But... I'm not sure why. The files in the packs would generally be newer, and I assume you'd usually want all files from one source, rather than running the risk of mixing and matching incompatible files.

Second, it adds a bunch of lines to io.h like:

#elif defined (__AVR_ATtiny12__)
#  include <avr/iotn12.h>

for new devices added from the packs, but those don't seem necessary as (the current?) io.h has a catch all to support all possible devices:

#elif defined (__AVR_DEV_LIB_NAME__)
#  define __concat__(a,b) a##b
#  define __header1__(a,b) __concat__(a,b)
#  define __AVR_DEVICE_HEADER__ <avr/__header1__(io,__AVR_DEV_LIB_NAME__).h>
#  include __AVR_DEVICE_HEADER__

For possible use in megaTinyCore

I don't see why there would be any problem using this approach for megaTinyCore and DxCore, but the existing Arduino toolchain would probably need to be used as a base rather than Microchip's toolchain, since Microchip only supports x86_64.