12

I'm trying to build a project (https://wpewebkit.org/) on Debian Buster for armv7 on a x86 host of the same OS.

I am able to successfully install an arm C++ toolchain and I can successfully compile and run trivial applications.

Where I'm stuck is many of the projects I want to compile require many dependencies that I normally install through the OS's package manager (ex apt-get install libjpeg-dev). When cross compiling, it looks like I can just download & make install the sources I need. However, this project has hundreds of dependencies - it would take a long time to download and compile all of them. At the same time, the arm versions of these dependencies already exist in apt for arm.

How can I, on the host system, install the armhf versions of these dependencies and make them available to my cross compiling toolchain? I've tried dpkg add-architecture armhf and then installing via apt-get install libjpeg-dev:armhf but cmake can't seem to find the installed dependencies.

killachaos
  • 414
  • 6
  • 15

2 Answers2

5

@artless-noise guides were a good jumping off point, but unfortunately most of the guides weren't helpful in accomplishing what I wanted to do (or if they were, they weren't straightforward in explaining how to accomplish what I needed).

What I ended up doing was using qemu-debootstrap 

sudo qemu-debootstrap --arch armhf buster /mnt/data/armhf http://deb.debian.org/debian/

And then just using sudo chroot /mnt/data/armhf and I had a functioning shell where I could just apt-get anything I needed, run any scripts and get armhf binaries.

killachaos
  • 414
  • 6
  • 15
2

There are many ways to do this. The key concept is that you need a shadow filesystem that mimics the ARM and you need to tell the package build mechanism where they are. There are many distributions variants LTIB is rpm based, Yocto uses BitBake and supports deb, rpm and ipkg. As well you need to differentiate between build tools and deployed binaries. This is an added concept when cross compiling. The only point above is that Ltib, Yocto, buildroot, etc all keep a shadow root files system and some place to keep host/build binaries. Since you have a Debian system, it is best to stick to their tools.

It is possible to install with dpkg --root. And if you have a complete environment, you can chroot arm_root and then build the package there with host binaries but ARM development files (headers and libraries).

The Debian maint-guide is an overview of building debian packages for the normal case. The Debian cross-compile wiki uses the chroot methods and has reference to building with either sbuild or pbuild packages. The schroot package is very nice as it allows you to build the shadow file system without becoming root. It is very easy to destroy your host file system when learning to cross distribution build and I highly recommend this method. Another key difference between the maint-guide and cross wiki is to install the package cross build essentials.

sudo apt-get install build-essential crossbuild-essential-armhf

Otherwise, most everything is the same but building with the chroot shadow ARM filesystem.

Here is a translation for Ubuntu hosts... you need Zenial or better to use the cross-compile debian wiki method. Ie, a Ubuntu x86 Bionic build for raspberry PI or similar. This method takes care of a lot of things for you, especially preventing filesystem corruption by mistake; thank the kind souls at Debian.

The info under nomenclature is quite important,

  • build means the architecture of the chroot/dpkg/compiler's executable, i.e. the architecture of the build system (called host by cmake/kernel/etc)

  • host means the architecture of produced executable objects, i.e. the architecture of the host system where these guest objects will run on (called target or sometimes build elsewhere)

  • target is what the produced executable objects will generate when producing executable objects, i.e. the architecture of the systems the built programs target their results to run on (relevant only for compilers and similar)

People change the names for the same concepts in cross-building and that can be confusing.

Additional info

artless noise
  • 21,212
  • 6
  • 68
  • 105
  • If you can guarantee that all packages use the same build system, then this can be easier to do. For instance `--sys-root` can tell where cross compiler libraries are. [Cross compile with autotools](https://stackoverflow.com/questions/28205073/how-to-cross-compile-a-autotools-project-for-arm) has the same answer as mine; but it is not really a correct answer there. Sometimes the 'host/ARM' is not the same version of debian (or not debian). Ie, your 'build' distribution is not the same as the 'host/target'. Packages can use autotools and still build successfully without Debian tools. – artless noise Oct 14 '19 at 15:42
  • You may wish to build everything as well; especially for an embedded system where you know binaries will always run on a specific machine. Debian 'armhf' will limit compiler output/optimization. See: [Linux from scratch](http://www.linuxfromscratch.org/), [Gentoo](https://www.gentoo.org/), and [buildroot](https://buildroot.org/) and package/system builders mentioned in the answer. – artless noise Oct 14 '19 at 15:49
  • Using chroot with qemu in order to cross compile defeats the purpose since it is 10 times slower than native performance when cross compiling with the gcc crosscompiling toolchain for example. – Mehdi Apr 06 '21 at 15:36
  • I didn't say use qemu? The `chroot` is to protect against a cross built from installing binaries on your machine and some packages are confuse when installing to a different place on the build machine that differs from target environment. – artless noise Apr 07 '21 at 00:06