Package Details: arm-linux-gnueabihf-gcc 9.2.0-4

Package Actions

Browse other questions tagged 64-bit gcc windows-subsystem-for-linux or ask your own question. The Overflow Blog Brush up your COBOL: Why is a 60 year old language suddenly in demand? I'm cross-compiling Boost for a Linux distro on an ARM board. I'm using windows with Boost 1.47. My project-config.jam contains the following: import option; using gcc: arm: 'C:/Program Files (x86)/CodeSourcery/Sourcery G Lite/bin/arm-none-linux-gnueabi-g'; option.set keep-going: false; And I'm building with the command: bjam toolset.

• View PKGBUILD / View Changes

Dependencies (7)

• elfutils(elfutils-git)
• zlib(zlib-static, zlib-git, zlib-asm, minizip-asm, zlib-ng-git)
• arm-linux-gnueabihf-glibc>=2.30-3
• arm-linux-gnueabihf-binutils>=2.33.1-2.1
• dejagnu(dejagnu-git)(check)
• inetutils(inetutils-git)(check)

Required by (8)

• arm-linux-gnueabihf-armcl-neon(make)
• arm-linux-gnueabihf-armcl-opencl+neon(make)
• arm-linux-gnueabihf-glibc(requires arm-linux-gnueabihf-gcc-stage2)(make)
• arm-linux-gnueabihf-glibc-headers(requires arm-linux-gnueabihf-gcc-stage1)(make)
• arm-linux-gnueabihf-musl(make)
• arm-linux-gnueabihf-ncurses(make)
• arm-linux-gnueabihf-openblas-lapack-openmp(make)
• hakchi-git(make)

tavianator commented on 2018-08-15 15:55

@TheSaint: The correct order can be seen here: https://github.com/tavianator/arch-rpi-cross/blob/master/install.sh

It is

Mac notification sounds download. arm-linux-gnueabihf-binutils
arm-linux-gnueabihf-gcc-stage1
arm-linux-gnueabihf-linux-api-headers
arm-linux-gnueabihf-glibc-headers
arm-linux-gnueabihf-gcc-stage2
arm-linux-gnueabihf-glibc
arm-linux-gnueabihf-gcc

The dependencies and provides have been set up so that AUR helpers should (hopefully) figure that out automatically.

felipebalbi commented on 2020-05-13 05:49

@tavianator the reason I went with 10.1 is twofold:

1. AARCH64 is already in 10.1 (see https://www.archlinux.org/packages/community/x86_64/aarch64-linux-gnu-gcc/)

2. If I was already updating, might as well update to the latest :-p

Anyway here are all commits which I've pushed to github mirrors of your AUR repositories:

cheers

tavianator commented on 2020-05-13 01:55

@felipebalbi Sure, post the patches somewhere and I'll at least take a look.

Generally I try to follow the non-cross versions of these packages, which means taking changes from https://github.com/archlinuxarm/PKGBUILDs/blob/master/core/gcc and friends. Since Arch isn't at 10.1 yet, neither is this package.

felipebalbi commented on 2020-05-12 06:19

Would you accept a patch updating GCC to 10.1 or is someone already working on that? Also, assuming you would accept such a patch, would it require updating binutils and glibc as well?

UPDATE: FYI, I have the patch for gcc and I've tested it by building the linux-kernel.

UPDATE 2: I wrote the patches for all other packages (binutils, gcc-stage1, linux-api-headers, glibc-headers, gcc-stage2 and glibc), however binutils won't install due to it trying to overwrite existing files. I'll try to figure out why those files are included. Once all packages are compiling and installing fine, I'll report here.

UPDATE 3: All 7 packages built and installed. Working fine so far. It would be great to have them integrated so we can all have newest GCC for ARM32 boards

acxz commented on 2020-03-21 23:06

@tavianator or anyone else, I have a question. I am trying to find the equivalent of the ubuntu package pkg-config-arm-linux-gnueabihf on ArchLinux. Which package should I look for?

smallAndSimple commented on 2020-01-12 15:01

tavianator commented on 2020-01-10 15:32

@smallAndSimple: I pushed an update to alg-glibc that removes the version requirement on gcc. That should allow everything to build automatically, let me know if it works.

smallAndSimple commented on 2020-01-10 10:48

I cannot update this packet in Yay because of a weird (curcular?) thing:

I want to update arm-linux-gnueabihf-gcc to 9.2.0-4. But for that I need arm-linux-gnueabihf-glibc 2.30-3. To install linux-gnueabihf-glibc, I will need arm-linux-gnueabihf-gcc-stage2>=9.2.0-4, which arm-linux-gnueabihf-gcc does provide, but I cannot install that because of the glibc version.

How can I break this cycle, other than removing all of the arm-linux-gnueabihf packagesd and reinstalling them in order?

mikro commented on 2019-05-22 15:00

There is no need to mess with any order, just install arm-linux-gnueabihf-gcc and arm-linux-gnueabihf-glibc together.

However I'm getting a failure anyway, see my comment here: https://aur.archlinux.org/packages/arm-linux-gnueabihf-glibc-headers/#comment-694530

tavianator commented on 2019-02-05 01:45

@TheSaint: Uh because that's how you build a cross-toolchain? If you have a better way please let me know! I think it's possible to do 2 stages of GCC instead of 3 but I haven't gotten it working. At least my install.sh script should avoid wasting bandwidth, as it symlinks the glibc and gcc tarballs to avoid re-downloading them.

TheSaint commented on 2019-02-04 01:42

Today I got an update, but there's no order that the aur helper will respect. I currently using pikaur.So I presume that the entire update should be packaged with one only script as you mentioned, which is presumably the install.shI followed your proposed order, but still have to discard a package because of conflicts.gcc-stage2 discards gcc-stage1glibc discards glibc-headersgcc discards gcc-stage2

Why should we bear for such bandwidth & time wastage ?

One of the first challenges in designing a Linux BSP and associated software is just how to compile the thing in the first place.In this part of the series on How to Survive Embedded Linux, we’ll guide you through some best practice ideas and techniques to utilise when learning how to compile your Linux BSP. How to CompileCross-compilation: an introductionA “cross-compiler” is a compiler that creates executable code for a different architecture. In the case of developing your Linux BSP, you’ll be compiling on your PC but the code you make is targeting your custom board.Things that need to be compiled include, but are not limited to: the bootloader, the kernel, shared libraries, your application code. We’ll look at a few ways of getting this doneFinding the right cross-compilerTo get your cross-compiler you will need to find it from somewhere. There are several places where you might find what you need, but for a newbie some of the options and terminology might be a bit confusing.If you’re using Ubuntu and you’re looking for an ARM cross-compiler based on GCC, you might find the following packages that may suit your needs: –gcc-arm-linux-androideabi gcc-arm-linux-gnueabi gcc-arm-linux-gnueabihf gcc-arm-none-eabi gcc-arm-none-eabi-source. In this scenario you’ll want to pick out the one that includes linux-gnueabi.

The ABI, or application binary interface, is different if you’re compiling for Android (linux-androideabi) or GNU/Linux (linux-gnueabi). The gcc-arm-none-eabi is for bare-metal programming, when you want to avoid an operating system altogether.The reason for the difference is due to the multiple C implementations that exist for different operating systems, as we are compiling for Linux and using the GNU C Library (generally what is understood by a ‘Linux BSP’) then we must use the gcc-arm-linux-gnueabi cross-compiler.One last point, there is a gcc-arm-linux-gnueabihf compiler there to, so what is the difference there? In this case the ‘hf’ stands for hard float, in other words, you should choose this compiler if your target includes a hardware floating-point unit, this will considerably speed up operations that include floating point calculations.Remember that, if you do decide to use your package manager, there may be updates to your compiler over time as your package manager does periodic updates.

This will stop your builds being reproducible over time. In a production setting, you’re more likely to want to pick a specific compiler and stick with it as long as you can.In most cases the CPU vendor will provide, or point to, a toolchain that is suitable and has been well tested. Use this unless you have reason to move to another one, different versions of GCC can have different compile bugs, or even different behaviour; when making a switch, make sure to understand the differences and carry out a good set of tests. Using ‘sysroots’A sysroot is a scaled down version of your target’s filesystem, it need only contain the libraries and headers which you will compile/link against. There are many ways to set up a sysroot, one is to copy the /usr and /lib directories from your target to somewhere on your host filesystem.

You could also NFS (network file system) mount the target filesystem somewhere locally.The GCC family of compilers accept a “ — sysroot=dir” argument, which is used to specify the path to your sysroot. Check the documentation for your cross-compiler to how to set your compiler correctly, you may need to take extra steps for using the sysroot when passing include/library directories.If you compiler does not support using a sysroot then you can always just tell the compiler to look in your sysroot manually, if you’re using a makefile then it’s not extra effort once everything is setup. Just try to keep your sysroot unchanged during development. Cross compilation with autotoolsMost well-known Linux software uses autotools, it’s likely you’ve used its famous two step build process (./configure, make) when compiling a package from source.

Moving your project to use autotools can take a great amount of effort, but its benefits include very straight-forward cross compilation.To cross-compile with autotools you need only change the flags passed to configure. In the example that you are building for your local machine (i.e.: not cross-compiling), you run configure without any flags. When cross-compiling, there are four flags you will want to use:-– -build= this is the machine you are building on (e.g.: x8664-linux)– -target= the machine you are building for (e.g.: arm-linux-gnueabihf)– -with-sysroot= the sysroot as described in the previous sectionAfter the configure script is done, you can run ‘make’ as normal and the cross-compiler will be automatically selected and passed the correct flags. If you encounter any errors in the configure stage of the process, just go through one by one and try to fill any missing gaps.

Cross compilation with YoctoIf you’ve been using Yocto to build your Linux BSP, then consider building a Yocto SDK to make your life much easier going forward.To build an SDK run the following bitbake command:-bitbake -c dopopulatesdkThis will create an installer in your “build/tmp/deploy/sdk” directory. Refer to the Yocto manual for more details. Install your SDK somewhere on your filesystem.Once it is installed there is a script that begins with “environment-setup-” followed by the target machine that the SDK builds for. ConclusionHere we have covered the most straightforward methods with the most straightforward terminology.

There are other methods, for example “chroot cross-compilation”, which we have not gone into as I believe these contain unneeded complexity or only address specific target/host combinations. Someone might quiz you on the meaning of “Canadian-cross-compilation”, this term only applies to cross-compiling a cross-compiler, and you won’t need it for 99.9% percent of your daily work.Originally published on.