Golang. Cross Compiling for MIPS - go

I have tried compiling my simply program:
func main(){fmt.Printf("Hello")}
to MIPS architecture on my PC wit 64 bit Debian Linux according to documentation
https://golang.org/doc/install/source#environment
via using command
GOOS=linux GOARCH=mipsle go build
GOOS=linux GOARCH=mips go build
Every time I get the error:
runtime/internal/sys compile
unknown architecture "mipsle(mips)"
The interesting thing is, if a try using command:
GOOS=linux GOARCH=mipsle64 go build
The program was build.
Is it dependent on system OS on my PC ? How can I build a binary for MIPS or MIPSLE ?

Go 1.6 does not support MIPS or MIPSLE. 1.6 supports MIPS64(LE). 1.8 supports MIPS(LE).
From https://golang.org/doc/install/source:
amd64 (also known as x86-64)
A mature implementation.
386 (x86 or x86-32)
Comparable to the amd64 port.
arm (ARM)
Supports Linux, FreeBSD, NetBSD, OpenBSD and Darwin binaries. Less widely used than the other ports.
arm64 (AArch64)
Supports Linux and Darwin binaries. New in 1.5 and not as well exercised as other ports.
ppc64, ppc64le (64-bit PowerPC big- and little-endian)
Supports Linux binaries. New in 1.5 and not as well exercised as other ports.
mips, mipsle (32-bit MIPS big- and little-endian)
Supports Linux binaries. New in 1.8 and not as well exercised as other ports.
mips64, mips64le (64-bit MIPS big- and little-endian)
Supports Linux binaries. New in 1.6 and not as well exercised as other ports.
s390x (IBM System z)
Supports Linux binaries. New in 1.7 and not as well exercised as other ports.

Related

What is the better way to build arm64 binaries?

I have a number C/C++ project which must be compiled for arm64 (aarch64) Linux platform, then packet into both RPM and DEB packages, then published. Creating and publishing Linux software for arm64.
How to build aarch64 binaries using amd64 Linux host system?
I have the following linux
katya7#katya7-comp:~$ cat /etc/os-release
NAME="KDE neon"
VERSION="5.25"
ID=neon
ID_LIKE="ubuntu debian"
PRETTY_NAME="KDE neon User - 5.25"
VARIANT="User Edition"
VARIANT_ID=user
VERSION_ID="20.04"
HOME_URL="https://neon.kde.org/"
SUPPORT_URL="https://neon.kde.org/"
BUG_REPORT_URL="https://bugs.kde.org/"
LOGO=start-here-kde-neon
PRIVACY_POLICY_URL="https://www.ubuntu.com/legal/terms-and-policies/privacy-policy"
VERSION_CODENAME=focal
UBUNTU_CODENAME=focal
Have you tried cross compiling? There is a nice blog post on how to do cross compiling for aarch64 on a build platform with a different architecture. https://jensd.be/1126/linux/cross-compiling-for-arm-or-aarch64-on-debian-or-ubuntu

Cross compilation for x86-64 target on arm64 host

I'm trying to find a way to do cross-compilation for x86-64 target on an arm64 machine, the gcc version used is 4.8.5 (Old version. I know...).
My host is an Apple M1 machine, and the program can be built only on Linux.
I tried creating a docker container that emulates x86-64 using QEMU - but its terribly slow.
I'm now trying to use a linux container (or a vm) and looking for a arm64 to x86 cross compiler, I have used arm64 to x86-64 compilers in the past, but can't find the reverse one.
Thanks

Compile and run a 32bit binary on Armv8 (aarch64) running 64bit linux

I'am trying to compile and run a 32 bit binary on a Cortex-A72 Armv8 using gcc compiler but i am not able to do it. I followed this prior thread Having trouble compiling 32-bit binary on 64-bit linux armv8 machine and i am realized too that the -m32 flag is not supported on ARMv8 linux machines.
Looking at https://gcc.gnu.org/onlinedocs/gcc/AArch64-Options.html i didn’t find anything interesting.
In according to https://linux.die.net/man/1/arm-linux-gnu-gcc the AArch64 gcc options are:
-mbig-endian -mlittle-endian -mgeneral-regs-only -mcmodel=tiny -mcmodel=small -mcmodel=large -mstrict-align -momit-leaf-frame-pointer -mno-omit-leaf-frame-pointer -mtls-dialect=desc -mtls-dialect=traditional -march=name -mcpu=name -mtune=name
So my question is: is it possible to compile and run a 32-bit binary on a 64-bit linux Armv8 machine ? and is so, how ?
Thank you.
EDIT: this https://jensd.be/1126/linux/cross-compiling-for-arm-or-aarch64-on-debian-or-ubuntu worked for me
You can download the AArch32 target with hard float (arm-none-linux-gnueabihf) toolchain from the Cortex-A toolchain Arm site.
The archive file name is gcc-arm-10.2-2020.11-aarch64-arm-none-linux-gnueabihf.tar.xz, in the AArch64 Linux hosted cross compilers section.
You may need to install additional packages on your Aarch64 system - search for How to run 32-bit (armhf) binaries on 64-bit (arm64) and your Linux distribution name.

All possible GOOS value?

If I get it right, GOOS is determined when compile the source code.
To better support multiple OS, I'm interested in what GOOS could be.
Of course, there might be infinite possibilities of it, since Go is opensourced. So what I really want is a "common list".
Known values are:
windows
linux
darwin or freebsd or unix? I know that at least one of them must exist.
Note that those values are defined in:
src/go/build/syslist.go, and
doc/install/source#environment.
With Go 1.5 (Q3 2015), GOARCH will become much more complete.
See commit 1eebb91 by Minux Ma (minux)
go/build: reserve GOARCH values for all common architectures
Whenever we introduce a new GOARCH, older Go releases won't recognize them and this causes trouble for both our users and us (we need to add unnecessary build tags).
Go 1.5 has introduced three new GOARCHes so far: arm64 ppc64 ppc64le, we can take the time to introduce GOARCHes for all common architectures that Go might support in the future to avoid the problem.
const goosList = "android darwin dragonfly freebsd linux nacl \
netbsd openbsd plan9 solaris windows "
const goarchList = "386 amd64 amd64p32 arm arm64 ppc64 ppc64le \
mips mipsle mips64 mips64le mips64p32 mips64p32le \ # (new)
ppc s390 s390x sparc sparc64 " # (new)
The list is still being review in Change 9644, with comments like:
I wouldn't bother with Itanium. It's basically a dead architecture.
Plus, it's so hard to write a compiler for it that I really can't see it happening except as a labor of love, and nobody loves the Itanium.
The official documentation now (GO 1.5+ Q3 2015) reflects that completed list.
Update 2018: as documented in Giorgos Oikonomou's answer, Go 1.7 (Q1 2016) has introduced the
go tool dist list command.
See commit c3ecded: it fixes issue 12270 opened in Q3 2015:
To easier write tooling for cross compiling it would be good to programmatically get the possible combinations of GOOS and GOARCH.
This was implemented in CL 19837
cmd/dist: introduce list subcommand to list all supported platforms
You can list in plain text, or in json:
> go tool dist list -json
[
{
"GOOS": "android",
"GOARCH": "386",
"CgoSupported": true
},
...
]
As Mark Bates tweeted:
Bonus: Column output properly formatted for display:
go tool dist list | column -c 75 | column -t
I think you're looking for this list of possible GOOS and GOARCH combinations, in this section:
http://golang.org/doc/install/source#environment
$GOOS and $GOARCH
The name of the target operating system and
compilation architecture. These default to the values of $GOHOSTOS and
$GOHOSTARCH respectively (described below).
Choices for $GOOS are darwin (Mac OS X 10.8 and above and iOS),
dragonfly, freebsd, linux, netbsd, openbsd, plan9, solaris and
windows. Choices for $GOARCH are amd64 (64-bit x86, the most mature
port), 386 (32-bit x86), arm (32-bit ARM), arm64 (64-bit ARM), ppc64le
(PowerPC 64-bit, little-endian), ppc64 (PowerPC 64-bit, big-endian),
mips64le (MIPS 64-bit, little-endian), and mips64 (MIPS 64-bit,
big-endian). mipsle (MIPS 32-bit, little-endian), and mips (MIPS
32-bit, big-endian).
The valid combinations of $GOOS and $GOARCH are:
$GOOS $GOARCH
android arm
darwin 386
darwin amd64
darwin arm
darwin arm64
dragonfly amd64
freebsd 386
freebsd amd64
freebsd arm
linux 386
linux amd64
linux arm
linux arm64
linux ppc64
linux ppc64le
linux mips
linux mipsle
linux mips64
linux mips64le
netbsd 386
netbsd amd64
netbsd arm
openbsd 386
openbsd amd64
openbsd arm
plan9 386
plan9 amd64
solaris amd64
windows 386
windows amd64
You can see the list of supported platform by running:
go tool dist list
and this will print(depending on the Go version):
android/386
android/amd64
android/arm
android/arm64
darwin/386
darwin/amd64
darwin/arm
darwin/arm64
dragonfly/amd64
freebsd/386
freebsd/amd64
freebsd/arm
linux/386
linux/amd64
linux/arm
linux/arm64
linux/mips
linux/mips64
linux/mips64le
linux/mipsle
linux/ppc64
linux/ppc64le
linux/s390x
nacl/386
nacl/amd64p32
nacl/arm
netbsd/386
netbsd/amd64
netbsd/arm
openbsd/386
openbsd/amd64
openbsd/arm
plan9/386
plan9/amd64
plan9/arm
solaris/amd64
windows/386
windows/amd64
And the official documentation for the tool:
https://godoc.org/github.com/golang/go/src/cmd/dist
To cross compile use:
GOOS=darwin GOARCH=386 go build main.go

Building 32bit binary for ARM on 64bit CentOS

It seems that gcc doesn't accept -m32 option for ARM target. I am not sure how gcc behaves on 64bit Linux, but does it automatically generate 32bit binaries if gcc is of ELF32 running on 64bit Linux?
If so, is there any workaround?
Thanks in advance.
You need to use a cross-compiler to compile for ARM from your host running either x86 or x86_64, the reason being your host and target are 2 totally independent architectures.
The cross compiler would usually be configured to output only a 32-bit or 64-bit binary for ARM (not both). Most ARM device applications make use of only 32-bit and so using an arm cross-compiler without any extra arguments would build 32-bit binaries.
Toolchains have other -m flags to specify machine type such as armv7, arm cortex a-8, etc. for further optimization. You need to look at the documentation of the ARM cross compiler.
As for getting the correct toolchain which works for your target and runs under CentOS, it is better to start at the website of the vendor of the target device.
The -m32 option provided by the x86_64 version of gcc makes gcc compile 32-bit binaries instead of 64-bit since the x86 instruction set and the x86_64 (AMD64 or Intel EMT64) are quite similar. Especially the fact that it allows executing 32-bit instructions in 64-bit mode quite easily.

Resources