GDB ve GDBserver Statik Çapraz Derleme (Static Cross Compile GDB and GDBserver)

 [TR]

Özet

Aklıma takılan bir soru üzerine bir araştırma ve testler yaptım ve programların çalışmasını engelleyen sadece işlemci modeli değil minimum kernel versiyonu da oluyormuş. Sorun toolchain altındaki standart c çalışma zamanından kaynaklanıyormuş. Farklı çalışma zamanı kütüphaneleri de varmış. Hepsinin standartları ve amaçları farklı fakat referans noktaları glibc. Tabi alternatifleri kullanırken dikkat etmek gerekiyor.

Bazı Önemli olanları Glibc, Musl(static glibc), Uclibc(minimal glibc), Newlib(redhat embedded).

Gcc bu kütüphanelerin hemen hemen hepsi ile configuration yapılabiliyor. "Crosstool-ng" ile birkaç deneme yaptım ama çok karmaşık bir araç.

-Gnu compiler(gcc, g++) varsayılan olarak "glibc" kullanıyor. Bilgisayarlarımızda bu tarih itibariyle glibc 2.6 - minimum kernel=3.2.0 olarak verilmiş. Özellikle glibc ile derlenen programlar linux versiyonu konusunda çok katı davranıyor. Örneğin isval2 üzerinde çalıştırmaya çalıştığımızda "kernel is too old" hatasını verecektir.

-Musl harbiden static derlendiğinden katı bir politikası yok. Son derleyici versiyonu ile eski kerneller için program derlemeyi vaat ediyor. Glibc ile bazı patchler vasıtasıyla uyumluluğu var. Tek şartı posix için kernel 2.6. Kaynak kodu: https://github.com/GregorR/musl-cross | prebuilt: wget https://musl.cc/(arch)-linux-musleabi(hf?)-(cross/native).tgz

ex: wget https://musl.cc/arm-linux-musleabi-cross.tgz

-Uclibc adını çok duyuyorum ama denemek için zamanım olmadı.

Bu sayede üretici dışında verilen ubuntu "arm-linux-gnueabi" ile gdb ve gdbserver derlemeyi başardım.

# configure the PATH for yourself

sudo mkdir /usr/src/gdb/build

sudo ./configure --host=arm-linux-gnueabi --prefix=/usr/src/gdb/build --enable-static --with-static-standard-libraries --enable-lto

sudo make LDFLAGS=-static -j4

sudo make LDFLAGS=-static -j4 install 

Musl Nedir? Nasıl Kulanılır? Musl statik gdbserver

Kaynak Kodu: https://github.com/richfelker/musl-cross-make

Önceden derlenmiş: https://musl.cc/

Not: Tavsiyem önceden derlenmiş versiyonu kullanmak olacaktır. Her şeye rağmen platformunuzda derlenen yazılım platformunuzda çalışmadığında kaynak kodundan da derlenebilir.

Musl amacı statik derlemedir. Bu sayede gerçekten bağımlılıklardan arındırılmış link zamanında optimizasyonun da yapılmış küçücük tek başına çalışabilen programlar ve hatta Alpine Linux gibi dağıtımlar çıkartılabilir. 

Maalesef IOT dünyasında her şey hızlı güncellenemiyor ve sonuç olarak eski kerneller ve araç setleriyle çalışılmaya devam ediyor. Musl diğer bir avantajı Glibc gibi yüksek sayılabilecek kernel bağımlılığı yoktur. Eğer varsayılan gcc ile derlenmiş herhangi bir programı "file <software>" ile kontrol ederseniz makalenin yazıldığı tarih itibariyle komutun cevabının sonunda minimum linux 3.2.0 göreceksiniz. Musl için ise iyi bir POSIX uyumluluğu için minimum linux kernel 2.6 yeterlidir. Aynı şey Glibc ile versiyonu düşürerek yapmak mümkündür fakat oldukça uğraştırır ve ne hata çıkacağını tahmin etmek zordur.

Her güzelliğin bir dikeni olduğunu gibi bazı kütüphaneler sadece dinamik bağlanabiliyor. Çünkü önceden dinamik derlenmiş ve kaynak kodları gizli olabiliyor. Ticari sürücüler ve GUI uygulamaları dinamik zorunlu tutabildiğinden Musl burada işe yaramıyor. 

Maalesef derleme işlemi sonunda gdb dinamik bağlantısı olduğundan hata verecektir fakat gdbserver statik derlenebilmektedir. Zaten gömülü sistemlerde gdb kod yazılan makinede gdbserver kodun çalıştığı makinede bulunur.

Hazır araç setini indirmek üzere "https://musl.cc/" sitesinde yer alan yönergeleri takip etmek yeterlidir. Ben GDBserver arm için derleyeceğimden "cross" versiyonunu seçiyorum.

<UserName> yerine kendi kullanıcı adınızı girin.

1) "curl -s musl.cc | grep arm"

2) sudo tar -xf arm-linux-musleabi

3) sudo apt install gdb-source -y

4) sudo mkdir /home/<UserName>/arm-linux-musleabi-cross/host_tools

5) export MUSL_PATH=/home/<UserName>/arm-linux-musleabi-cross/bin

6) cd /usr/src/gdb/

7) 

Not: gdbserver varsayılan olarak debug özelliklerini de dahil ettiğinden sonradan "$MUSL_PATH/arm-linux-musleabi-strip" ile küçültmek gerekecektir ki Musl gerçekten 648kb GDBserver derleyebildiğini görün. Not: Lütfen "$MUSL_PATH" yerine kullandığınız musl araç setinde arm-linux-musleabi-strip bulunan klasörün tam yolunu girin

*host: gdbserver nerede çalışacak?

*prefix: gdbserver nereye yüklenecek?

*--enable-static --with-static-standard-libraries: lütfen bağımlılıkları statik bağla

*--enable-lto: link time optimizasyonu

*-j<nproc>: parallel derleme(yoksa gerçekten uzun sürüyor)

*LD=-static : son aşamadan gdbserver kendisini statik derle.

sudo ./configure --host=arm-linux-musleabi --prefix=/home/<UserName>/arm-linux-musleabi-cross/host_tools/gdb --enable-static --with-static-standard-libraries --enable-lto \

CC="$MUSL_PATH/arm-linux-musleabi-gcc" \

CXX="$MUSL_PATH/arm-linux-musleabi-g++" \

LD="$MUSL_PATH/arm-linux-musleabi-ld" \

AR="$MUSL_PATH/arm-linux-musleabi-ar" \

AS="$MUSL_PATH/arm-linux-musleabi-as" \

RANLIB="$MUSL_PATH/arm-linux-musleabi-ranlib" \

NM="$MUSL_PATH/arm-linux-musleabi-nm" \

STRIP="$MUSL_PATH/arm-linux-musleabi-strip" \

READELF="$MUSL_PATH/arm-linux-musleabi-readelf" \

OBJCOPY="/home/<UserName>/arm-linux-musleabi-cross/arm-linux-musleabi/bin/objcopy" \

OBJDUMP="/home/<UserName>/arm-linux-musleabi-cross/arm-linux-musleabi/bin/objdump" \

LDFLAGS="-Bstatic -lc -static" --disable-gdb

8) sudo make -j<nproc> LD=-static

9) sudo make -j<nproc> LD=-static install

10) $MUSL_PATH/arm-linux-musleabi-strip --strip-all

Sonucu kontrol et. Go to "prefix/bin" directory. Benim deneyimimle 648kb gördüm ve daha boyut optimizasyonu, linker sıkıştırması ve upx gibi executable sıkıştırması kullanmadım.

11) file gdbserver -> arm olup olmadığını kontrol et

12) ls -lah -> dosya boyutunu kontrol et

13) objdump -f gdbserver -> özellikle minimum hangi işlemciye göre optimize edildiğini kontrol et.

14) ldd gdbserver -> dinamik bağımlılıkları kontrol et.

Sıra arm cihazı çalışıp debug başlatabiliyor muyuz diye kontrol etmekte. gdbserver kullanmayı en iyi gdb sayfası anlatır. Gdb kullanmak üzere biraz tutorial izlemek faydalı olacaktır.

15) Not: Burada program hata ayıklayıcı ile başlatılıyor. Çalıştırmaya çalıştığınız program daha önceden çalışıyorsa "attach to process" özelliğini kullanabilirsiniz. Ayrıca hata ayıklanan program debug modunda derlense iyi olur.

Target: 

<gdb dosya yolu>/gdbserver --multi localhost:<port> <full path to executable>

Host: 

#Not:extended-remote, reverse debugging (reverse-step ve reverse-next) desteklemiyor.

gdb-multiarch -ex 'target extended-remote <ip>:<port>' -ex 'set remote exec-file ./<full path to executable>' -ex 'source <full path to breakpoints if you have>' \ --args arg1 arg2 ...

Teori ve Musl statik

Çapraz derlemeyi tanımlama çalışsam bile kesin bir sonuç çıkmayabilir fakat pratikte yapılan iş, mimariler arası program derlemektir. Çalıştığımız günlük bilgisayarlar genelde x86_64 mimarisine sahiptir. Arm işlemci ise yaygınlaşmaktatır. Bu yaygınlaşma bazı laptop markalarında de görülse de genelde IOT, gömülü sistem tarafında görülmektedir. Yapılan işe göre arm dışında da mips, sparc vb. işlemci mimarileri görülmektedir.

Bir yazılım işlemci tarafından anlaşılabilmesi için bir araç setine ihtiyaç duyar. Bu araç seti insanla makine arasında tercüman görevi görür. Araç setlerininde sisteme özel hazırlanabildiğini ve diğer çapraz derlenen araçlardan farkının olmadığını bilin. Fakat araç setleri arasında iki temel fark var. Biri derlediği programın işletim sistemi üzerinde çalışacağını varsayarken diğer işletim sistemi olmadan yani diğer bir tabirle "BareBone" olacağını varsayar. BareBone araç setleri daha çok bootloader ve işletim sisteminin kendisini derleyecek şekilde evrilmiştir.

Çapraz derleme için 3 önemli parametre vardır:

        *Build : Programın derleneceği(işlemin yapılacağı) platform. Varsayılan olarak işlemciniz ile aynı

        *Target : Programın hedef aldığı platform.

        *Host : Programın çalışacağı platfromu ifade eder. Eğer target belirtilmemişse target==host

Önemli parametrelere göre araç setleri şöyle sınıflandırılabilir:

*Host==Target==Build => Native : Araç seti çalıştığı platforma program üretiyor 

        *Host!=Target==Build => Cross : Araç seti hedef platforma program üretiyor 

        *Host!=Target!=Build => Canonical : Araç seti hedef platforma program üretiyor fakat derleme işlemi bambaşka bir platformda yapılıyorsa

        NOT: platform = işlemci + işletim sistemi

Önemli sayılabilecek birkaç araç seti:

*GNU Compiler Collection: Belki de en yaygın araç setidir. İçerisinde çok sayıda araç ve kütüphane barındırır. Çok sayıda programlama dilini destekler. Özellikle üniversitelerde öğretilen c/c++ programlama dillerinin dökümanı gcc ve g++ ile geliyor. makalenin amacı olan GDB hata ayıklayıcı 200 üzerinde işlemci desteği vardır ve çok sayıda programlama dilini destekler. C/C++ için GLIBC çalışma zamanı kütüphanesi(libc) barındırır ve bu sayede standart bir arayüz üzerinden linux sistem çağrılarını yönetebiliriz. Kendi kendini derleme özelliğine sahiptir. Bu sayede alternatif çalışma zamanı kütüphaneleri ile konfigürasyon yapılabilir. Musl gibi statik derlemeye yönelik düzenlenmiş kütüphanelerle bağımlılıktan arındırılmış ve gerçekten aşırı küçük programlar üretilebilir. Bence GCC tek dezavantajı statik özelliği olsada ve Musl ile konfigürasyon yapılmış olsa da Musl dağıtımlı gcc gibi gerçekten küçük ve statik binary üretim yapamamasıdır. Ancak Crosstool-ng vb. araçlarla en baştan tüm araç seti konfigürasyon yapılmalıdır ve bu işlem tecrübe ve zaman gerektirir. Eğer başarılı olunursa Alpine Linux gibi dağıtımlar çıkartılabilir.

-GDB desteklediği platform sayısı: gdb-multiarch --batch -nx --ex 'set architecture' 2>&1 | tail -n 1 | sed 's/auto./\n/g' | sed 's/,/\n/g' | sed 's/Requires an argument. Valid arguments are/\n/g' | sed '/^[ ]*$/d' | sort | uniq | wc -l

*GDB desteklediği platformlar: gdb-multiarch --batch -nx --ex 'set architecture' 2>&1 | tail -n 1 | sed 's/auto./\n/g' | sed 's/,/\n/g' | sed 's/Requires an argument. Valid arguments are/\n/g' | sed '/^[ ]*$/d' | sort | uniq

*Clang-LLVM(Low Level Virtual Machine): Asıl amacı kendi programlama dilini yapabilmen için bir framework oluşturmaktır. Son zamanlarda yaygınlaşan bir araç setidir. İçerisinde çok sayıda araç ve kütüphane barındırır. Çok sayıda yeni programlama dili ve araç llvm alt yapısını kullanmaktadır. Bu araç setini bu kadar öne plana çıkartan şey derleme ile ilgili çok sayıda bilgi vermesinin yanında gerçekten iyi dökümanının da olmasıdır. LLDB adı verilen bir araç barındırır ve GDB alternatifi dense de bildiğim kadarıyla varsayılan olarak sadece C/C++ dillerini desteklemektedir. GCC dünyasından farklı bakış açılara sahip olsa da GCC ile uyumlu çalışmaktadır. Kendi libc kütüphanesi vardır ve llvm lisansının verdiği özgürlük sebebiyle bazı firmalar kendilerine entegre etmek istemektedir. Kendisi bir jvm veya clr sanal makineleri gibi çalışabildiğinden C/C++ için JIT ve REPL çalışmaları yapılmıştır. Dotnet 7 ile Native-Aot llvm sayesinde gelmektedir. GraalVM altında LLVM projesi yatmaktadir. Bu gibi sebepler bu projeyi daha da ön plana çıkaracağa benziyor.

Diğer araç setlerinin amacı gerçekten farklı olabilecek 4-8-16 bit gibi işlemcilere kod üretmektir.

Bazı önemli sayılabilecek çalışma zamanı kütüphaneleri mevcuttur. Hepsinin standartları ve amaçları farklı fakat referans noktaları Glibc. Tabi alternatifleri kullanırken dikkat etmek gerekiyor: Glibc, Musl(statik glibc), Uclibc(minimal glibc), Newlib(redhat embedded), dietlibc

[EN](auto translate)

Summary

I did some research and tests on a question that stuck in my mind and it was not only the processor model but also the minimum kernel version that prevented the programs from running. The problem was caused by the standard c runtime under the toolchain. There are also different runtime libraries. They all have different standards and purposes, but their reference point is glibc. Of course, it is necessary to be careful when using alternatives.

Some Important ones are Glibc, Musl(static glibc), Uclibc(minimal glibc), Newlib(redhat embedded).

Gcc can be configured with almost all of these libraries. I've had a few tries with "crosstool-ng" but it's a very complex tool.

-Gnu compiler(gcc, g++) uses "glibc" by default. On our computers, as of this date, glibc is given as 2.6 - minimum kernel=3.2.0. Especially the programs compiled with glibc are very strict about the linux version. For example, when we try to run it on isval2, it will give the error "kernel is too old".

-Musl really doesn't have a strict policy because it's compiled static. With the latest compiler version, it promises to compile programs for old kernels. It has compatibility with glibc through some patches. The only requirement is kernel 2.6 for posix. Source code: https://github.com/GregorR/musl-cross | prebuilt: wget https://musl.cc/(arch)-linux-musleabi(hf?)-(cross/native).tgz

ex: wget https://musl.cc/arm-linux-musleabi-cross.tgz

-I hear the name uclibc a lot, but I haven't had time to try it.

Thanks to this, I was able to compile gdb and gdbserver with ubuntu "arm-linux-gnueabi" provided outside the manufacturer.

# configure the PATH for yourself

sudo mkdir /usr/src/gdb/build

sudo ./configure --host=arm-linux-gnueabi --prefix=/usr/src/gdb/build --enable-static --with-static-standard-libraries --enable-lto

sudo make LDFLAGS=-static -j4

sudo make LDFLAGS=-static -j4 install

What is Musl? How is it used? Musl static gdbserver

Source Code: https://github.com/richfelker/musl-cross-make

Precompiled: https://musl.cc/

Note: My advice would be to use the precompiled version. However, when the software compiled on your platform does not work on your platform, it can also be compiled from the source code.

Musl purpose is static compilation. In this way, small stand-alone programs and even distributions such as Alpine Linux, which are truly free of dependencies and optimized at link time, can be released.

Unfortunately, everything in the IoT world cannot be updated quickly and as a result, old kernels and toolkits continue to work. Another advantage of Musl is that it does not have a high kernel dependency like Glibc. If you check any program compiled with default gcc with "file <software>", you will see minimum linux 3.2.0 at the end of the command's response as of the writing date of the article. For Musl, minimum linux kernel 2.6 is sufficient for good POSIX compatibility. It's possible to do the same thing with Glibc by downgrading, but it's quite tedious and hard to predict what error will occur.

Some libraries can only be linked dynamically, as every beauty has a thorn. Because pre-compiled dynamically and source codes can be hidden. Musl doesn't work here, as commercial drivers and GUI applications can enforce dynamic.

Unfortunately, at the end of the compilation process, gdb will give an error because it has a dynamic connection, but gdbserver can be compiled statically. In embedded systems, on the machine where the gdb code is written, the gdbserver is located on the machine where the code is running.

To download the ready-made toolkit, it is sufficient to follow the instructions on the "https://musl.cc/" site. I choose the "cross" version since I will compile it for the GDBserver arm.

Replace <UserName> with your own username.

1) "curl -s musl.cc | grep arm"

2) sudo tar -xf arm-linux-musleabi

3) sudo apt install gdb-source -y

4) sudo mkdir /home/<UserName>/arm-linux-musleabi-cross/host_tools

5) export MUSL_PATH=/home/<UserName>/arm-linux-musleabi-cross/bin

6) cd /usr/src/gdb/

7)

Note: Since gdbserver includes debug features by default, it will be necessary to shrink it later with "$MUSL_PATH/arm-linux-musleabi-strip" to see if Musl can actually compile 648kb of GDBserver. Note: Please replace "$MUSL_PATH" with the full path of the folder with arm-linux-musleabi-strip in the musl toolkit you are using

*host: where will gdbserver run?

*prefix: where will gdbserver be installed?

*--enable-static --with-static-standard-libraries: please statically link dependencies

*--enable-lto: link time optimization

*-j<nproc>: parallel compilation (otherwise it takes really long)

*LD=-static : gdbserver compile itself static from the last stage.

sudo ./configure --host=arm-linux-musleabi --prefix=/home/<UserName>/arm-linux-musleabi-cross/host_tools/gdb --enable-static --with-static-standard-libraries - -enable-lto \

CC="$MUSL_PATH/arm-linux-musleabi-gcc" \

CXX="$MUSL_PATH/arm-linux-musleabi-g++" \

LD="$MUSL_PATH/arm-linux-musleabi-ld" \

AR="$MUSL_PATH/arm-linux-musleabi-ar" \

AS="$MUSL_PATH/arm-linux-musleabi-as" \

RANLIB="$MUSL_PATH/arm-linux-musleabi-ranlib" \

NM="$MUSL_PATH/arm-linux-musleabi-nm" \

STRIP="$MUSL_PATH/arm-linux-musleabi-strip" \

READELF="$MUSL_PATH/arm-linux-musleabi-readelf" \

OBJCOPY="/home/<UserName>/arm-linux-musleabi-cross/arm-linux-musleabi/bin/objcopy" \

OBJDUMP="/home/<UserName>/arm-linux-musleabi-cross/arm-linux-musleabi/bin/objdump" \

LDFLAGS="-Bstatic -lc -static" --disable-gdb

8) sudo make -j<nproc> LD=-static

9) sudo make -j<nproc> LD=-static install

10) $MUSL_PATH/arm-linux-musleabi-strip --strip-all

Check the result. Go to "prefix/bin" directory. In my experience I saw 648kb and I didn't use more size optimization, linker compression and executable compression like upx.

11) file gdbserver -> check if arm exists

12) ls -lah -> check file size

13) objdump -f gdbserver -> especially check which processor is optimized for minimum.

14) ldd gdbserver -> check for dynamic dependencies.

It's time to run the arm device and check if we can debug it. The best gdb page explains how to use gdbserver. It would be helpful to watch some tutorials for using gdb.

15) Note: Here the program is started with the debugger. If the program you are trying to run is already running, you can use the "attach to process" feature. Also, the debug program better compile in debug mode.

target:

<gdb file path>/gdbserver --multi localhost:<port> <full path to executable>

Shoo:

#Note:extended-remote does not support reverse debugging (reverse-step and reverse-next).

gdb-multiarch -ex 'target extended-remote <ip>:<port>' -ex 'set remote exec-file ./<full path to executable>' -ex 'source <full path to breakpoints if you have>' \ --args arg1 arg2 ...

Theory and Musl static

Even if I try to define cross-compilation, it may not come up with a definite result, but in practice, the work done is to compile cross-architecture programs. The everyday computers we work with usually have x86_64 architecture. Arm processor, on the other hand, is becoming widespread. Although this prevalence is also seen in some laptop brands, it is generally seen on the IOT, embedded system side. According to the work done, other than arm, mips, sparc etc. processor architectures.

A software needs a set of tools to be understood by the processor. This toolkit acts as an interpreter between human and machine. Know that the toolkits are system-specific and are no different from other cross-compiled tools. But there are two main differences between the toolkits. One assumes that the compiled program will run on the operating system, while the other assumes that it will be "BareBone" without the operating system. BareBone toolkits have evolved to compile more of the bootloader and the operating system itself.

There are 3 important parameters for cross compiling:

        *Build: The platform on which the program will be compiled. Same as your processor by default

        *Target: The platform that the program targets.

        *Host : Indicates the platform on which the program will run. If target is not specified target==host

According to the important parameters, the toolsets can be classified as:

*Host==Target==Build => Native : The toolkit generates programs for the platform it works on

        *Host!=Target==Build => Cross : The toolkit generates programs for the target platform

        *Host!=Target!=Build => Canonical : If the toolkit generates a program for the target platform, but the compilation process is done on a different platform

        NOTE: platform = processor + operating system

A few toolkits that might be considered important:

*GNU Compiler Collection: Perhaps the most common toolkit. It contains many tools and libraries. It supports many programming languages. The document of c/c++ programming languages ​​taught in universities, especially, comes with gcc and g++. For the purpose of this article, the GDB debugger has support for over 200 processors and supports many programming languages. It contains the GLIBC runtime library (libc) for C/C++ so we can manage linux system calls through a standard interface. It has self-compilation feature. This allows configuration with alternative runtime libraries. Dependency-free and really extremely small programs can be produced with libraries designed for static compilation, such as Musl. I think the only disadvantage of GCC is that although it is static and configured with Musl, it cannot produce really small and static binary like gcc with Musl distribution. But Crosstool-ng etc. All toolset must be configured from the beginning with tools and this process requires experience and time. If successful, distributions such as Alpine Linux may be released.

-GDB supports number of platforms: gdb-multiarch --batch -nx --ex 'set architecture' 2>&1 | tail -n 1 | sed 's/auto./\n/g' | sed 's/,/\n/g' | sed 's/Requires an argument. Valid arguments are/\n/g' | sed '/^[ ]*$/d' | sort | uniq | wc -l

*GDB supported platforms: gdb-multiarch --batch -nx --ex 'set architecture' 2>&1 | tail -n 1 | sed 's/auto./\n/g' | sed 's/,/\n/g' | sed 's/Requires an argument. Valid arguments are/\n/g' | sed '/^[ ]*$/d' | sort | unique

*Clang-LLVM(Low Level Virtual Machine): Its main purpose is to create a framework for you to make your own programming language. It is a toolkit that has become widespread recently. It contains many tools and libraries. Many new programming languages ​​and tools use the llvm infrastructure. What makes this toolkit stand out is the fact that it provides a lot of information about compilation as well as really good documentation. It contains a tool called LLDB and although it is called a GDB alternative, it only supports C/C++ languages ​​by default as far as I know. Although it has different perspectives from the GCC world, it works in harmony with GCC. It has its own libc library and due to the freedom of the llvm license, some companies want to integrate it themselves. JIT and REPL studies have been made for C/C++ as it can run as a jvm or clr virtual machine. It comes with Dotnet 7 thanks to Native-Aot llvm. Under GraalVM is the LLVM project. Such reasons seem to bring this project to the fore.

The purpose of other toolkits is to generate code for processors such as 4-8-16 bits, which may actually be different.

There are some important runtime libraries available. They all have different standards and purposes, but their reference point is Glibc. Of course, you need to be careful when using alternatives: Glibc, Musl(static glibc), Uclibc(minimal glibc), Newlib(redhat embedded), dietlibc

Tüm platformlar için düzenlediğim kodlar:

Codes I edited for all platforms:

######### gdb script needs libgmp #########

#change musl toolchain paths

sudo mkdir /home/selcuk/arm-linux-musleabi-cross/host_tools

sudo mkdir /home/selcuk/arm-linux-musleabihf/host_tools

sudo mkdir /home/selcuk/armv7-linux-musleabihf/host_tools

#--prefix=/home/selcuk/arm-linux-musleabi-cross/host_tools

#--prefix=/usr/src/gdb/build

export MUSL_PATH=/home/selcuk/arm-linux-musleabi-cross/bin

sudo ./configure --host=arm-linux-musleabi --prefix=/home/selcuk/arm-linux-musleabi-cross/host_tools/gdb --enable-static --with-static-standard-libraries --enable-lto \

CC="$MUSL_PATH/arm-linux-musleabi-gcc" \

CXX="$MUSL_PATH/arm-linux-musleabi-g++" \

LD="$MUSL_PATH/arm-linux-musleabi-ld" \

AR="$MUSL_PATH/arm-linux-musleabi-ar" \

AS="$MUSL_PATH/arm-linux-musleabi-as" \

RANLIB="$MUSL_PATH/arm-linux-musleabi-ranlib" \

NM="$MUSL_PATH/arm-linux-musleabi-nm" \

STRIP="$MUSL_PATH/arm-linux-musleabi-strip" \

READELF="$MUSL_PATH/arm-linux-musleabi-readelf" \

OBJCOPY="/home/selcuk/arm-linux-musleabi-cross/arm-linux-musleabi/bin/objcopy" \

OBJDUMP="/home/selcuk/arm-linux-musleabi-cross/arm-linux-musleabi/bin/objdump" \

LDFLAGS="-Bstatic -lc -static" --disable-gdb

sudo make -j8 LD=-static

sudo make -j8 LD=-static install

#--prefix=/home/selcuk/arm-linux-musleabi-cross/host_tools

#--prefix=/usr/src/gdb/build

export musl_path=/home/selcuk/arm-linux-musleabihf-cross/bin

sudo ./configure --host=arm-linux-musleabi --prefix=/home/selcuk/arm-linux-musleabihf-cross/host_tools/gdb --enable-static --with-static-standard-libraries --enable-lto \

CC="$MUSL_PATH/arm-linux-musleabihf-gcc" \

CXX="$MUSL_PATH/arm-linux-musleabihf-g++" \

LD="$MUSL_PATH/arm-linux-musleabihf-ld" \

AR="$MUSL_PATH/arm-linux-musleabihf-ar" \

AS="$MUSL_PATH/arm-linux-musleabihf-as" \

RANLIB="$MUSL_PATH/arm-linux-musleabihf-ranlib" \

NM="$MUSL_PATH/arm-linux-musleabihf-nm" \

STRIP="$MUSL_PATH/arm-linux-musleabihf-strip" \

READELF="$MUSL_PATH/arm-linux-musleabihf-readelf" \

OBJCOPY="/home/selcuk/arm-linux-musleabihf-cross/arm-linux-musleabihf/bin/objcopy" \

OBJDUMP="/home/selcuk/arm-linux-musleabihf-cross/arm-linux-musleabihf/bin/objdump" \

LDFLAGS="-Bstatic -lc -static" --disable-gdb

sudo make -j8 LD=-static

sudo make -j8 LD=-static install

# !!! ERROR: libgmp doesn't compile with compiler !!!

#--prefix=/home/selcuk/arm-linux-musleabi-cross/host_tools

#--prefix=/usr/src/gdb/build

export MUSL_PATH=/home/selcuk/armv7l-linux-musleabihf-cross/bin

sudo ./configure --host=arm-linux-musleabi --prefix=/home/selcuk/arm-linux-musleabi-cross/host_tools/gdb --enable-static --with-static-standard-libraries --enable-lto \

CC="$MUSL_PATH/armv7l-linux-musleabihf-gcc" \

CXX="$MUSL_PATH/armv7l-linux-musleabihf-g++" \

LD="$MUSL_PATH/armv7l-linux-musleabihf-ld" \

AR="$MUSL_PATH/armv7l-linux-musleabihf-ar" \

AS="$MUSL_PATH/armv7l-linux-musleabihf-as" \

RANLIB="$MUSL_PATH/armv7l-linux-musleabihf-ranlib" \

NM="$MUSL_PATH/armv7l-linux-musleabihf-nm" \

STRIP="$MUSL_PATH/armv7l-linux-musleabihf-strip" \

READELF="$MUSL_PATH/armv7l-linux-musleabihf-readelf" \

OBJCOPY="/home/selcuk/armv7l-linux-musleabihf-cross/armv7l-linux-musleabihf/bin/objcopy" \

OBJDUMP="/home/selcuk/armv7l-linux-musleabihf-cross/armv7l-linux-musleabihf/bin/objdump" \

LDFLAGS="-Bstatic -lc -static" --disable-gdb

sudo make -j8 LD=-static

sudo make -j8 LD=-static install

######### libgmp script change according to architecture and toolchain #########

# LD_DIR=/usr/src/gmp-6.2.1/build/lib

export MUSL_PATH=/home/selcuk/arm-linux-musleabi-cross/bin

sudo ./configure --host=arm-linux-musleabi --prefix=/home/selcuk/arm-linux-musleabi-cross/arm-linux-musleabi --enable-static \

CC="$MUSL_PATH/arm-linux-musleabi-gcc" \

CXX="$MUSL_PATH/arm-linux-musleabi-g++" \

LD="$MUSL_PATH/arm-linux-musleabi-ld" \

AR="$MUSL_PATH/arm-linux-musleabi-ar" \

AS="$MUSL_PATH/arm-linux-musleabi-as" \

RANLIB="$MUSL_PATH/arm-linux-musleabi-ranlib" \

NM="$MUSL_PATH/arm-linux-musleabi-nm" \

STRIP="$MUSL_PATH/arm-linux-musleabi-strip" \

READELF="$MUSL_PATH/arm-linux-musleabi-readelf" \

OBJCOPY="/home/selcuk/arm-linux-musleabi-cross/arm-linux-musleabi/bin/objcopy" \

OBJDUMP="/home/selcuk/arm-linux-musleabi-cross/arm-linux-musleabi/bin/objdump" \

LDFLAGS="-Bstatic -lc -static"

sudo make -j8 LD=-static

sudo make -j8 LD=-static install

export MUSL_PATH=/home/selcuk/arm-linux-musleabihf-cross/bin

sudo ./configure --host=arm-linux-musleabihf --prefix=/home/selcuk/arm-linux-musleabihf-cross/arm-linux-musleabihf --enable-static \

CC="$MUSL_PATH/arm-linux-musleabihf-gcc" \

CXX="$MUSL_PATH/arm-linux-musleabihf-g++" \

LD="$MUSL_PATH/arm-linux-musleabihf-ld" \

AR="$MUSL_PATH/arm-linux-musleabihf-ar" \

AS="$MUSL_PATH/arm-linux-musleabihf-as" \

RANLIB="$MUSL_PATH/arm-linux-musleabihf-ranlib" \

NM="$MUSL_PATH/arm-linux-musleabihf-nm" \

STRIP="$MUSL_PATH/arm-linux-musleabihf-strip" \

READELF="$MUSL_PATH/arm-linux-musleabihf-readelf" \

OBJCOPY="/home/selcuk/arm-linux-musleabihf-cross/arm-linux-musleabihf/bin/objcopy" \

OBJDUMP="/home/selcuk/arm-linux-musleabihf-cross/arm-linux-musleabihf/bin/objdump" \

LDFLAGS="-Bstatic -lc -static"

sudo make -j8 LD=-static

sudo make -j8 LD=-static install

# !!! ERROR: unspoorted operation !!!

export MUSL_PATH=/home/selcuk/armv7l-linux-musleabihf-cross/bin

sudo ./configure --host=armv7-linux-musleabihf --prefix=/home/selcuk/armv7l-linux-musleabihf-cross/armv7l-linux-musleabihf/ --enable-static \

CC="$MUSL_PATH/armv7l-linux-musleabihf-gcc" \

CXX="$MUSL_PATH/armv7l-linux-musleabihf-g++" \

LD="$MUSL_PATH/armv7l-linux-musleabihf-ld" \

AR="$MUSL_PATH/armv7l-linux-musleabihf-ar" \

AS="$MUSL_PATH/armv7l-linux-musleabihf-as" \

RANLIB="$MUSL_PATH/armv7l-linux-musleabihf-ranlib" \

NM="$MUSL_PATH/armv7l-linux-musleabihf-nm" \

STRIP="$MUSL_PATH/armv7l-linux-musleabihf-strip" \

READELF="$MUSL_PATH/armv7l-linux-musleabihf-readelf" \

OBJCOPY="/home/selcuk/armv7l-linux-musleabihf-cross/armv7l-linux-musleabihf/bin/objcopy" \

OBJDUMP="/home/selcuk/armv7l-linux-musleabihf-cross/armv7l-linux-musleabihf/bin/objdump" \

LDFLAGS="-Bstatic -lc -static"

sudo make -j8 LD=-static

sudo make -j8 LD=-static install