I want to build my own operating system ， but how install i686-elf-gcc in manjaro
i I found a tool（https://github.com/lordmilko/i686-elf-tools）, but it can only be run in ubuntu
A simple solution would be to build the compiler yourself. I went through the same thing recently. If you are into operating system development, you won't be able to avoid looking at the compiler in more detail and building cross compilation tools anyway.
Building your own compiler
The build process can be roughly divided into 4 steps:
Install all dependencies necessary for the build. If I remember correctly, you can get everything from the official package sources in Arch Linux. Make sure that these packages/tools are present: make, bison, flex, gmp, mpc, mpfr, texinfo, libisoburn, mtools.
Download the source code of binutils (GNU's assembler and binary tools) and gcc (the GNU compiler collection). I recommend using the newest versions at the bottom of the respective pages.
Decide where your new compiler should be installed. Although it sounds tempting, it should not end up in any system directory, rather somewhere in your home folder. I used $HOME/tools/crc to store my cross-compilation tools. You can at it to your $PATH lateron for convenience.
Do the actual build. First of all: The build takes a while and needs one or the other command line switch. Do not omit any of them. The build may pass and problems may occur later. Just follow the instructions below.
The actual build process
The first thing to do is to compile binutils, because it is needed for the gcc build. For convenience set a few shell variables to minimize error sources:
# This is where the tools will end up
export PREFIX="$HOME/tools/crc"
# Prefix of the produced assemblies (for example i686-elf-gcc)
export TARGET=i686-elf
# Add the new installation to the PATH variable temporarily
# since it is required for the gcc build
export PATH="$PREFIX/bin:$PATH"
Now create a new directory somewhere and extract both the gcc and binutils source code archives in there. You should end up with two subdirectories like yourdir/binutils-x.y.z and yourdir/gcc-x.y.z. It is recommended to do the build in an empty directory, so create yourdir/build-binutils and yourdir/build-gcc as well. Notice: These directories are not placed inside the source directories!
Building binutils
cd into the yourdir/build-binutils directory and run the following commands. Replace the x.y.z part with your version.
../binutils-x.y.z/configure \
--target=$TARGET \
--prefix="$PREFIX" \
--with-sysroot \
--disable-nls \
--disable-werror
make
make install
Now check the installation with which -- $TARGET-as. This will return the location of i686-elf-as, which is the assembler we just build.
Building gcc
cd into the yourdir/build-gcc directory. The process is pretty much the same as with binutils above:
../gcc-x.y.z/configure \
--target=$TARGET \
--prefix="$PREFIX" \
--disable-nls \
--enable-languages=c,c++ \
--without-headers
make all-gcc
make all-target-libgcc
make install-gcc
make install-target-libgcc
Verify the build
Check the installation by invoking i686-elf-gcc --version. If you used the same values as I, this can be done with $HOME/tools/crc/bin/$TARGET-gcc --version.
I've written a web-server in nim using the prologue framework. I would like to deploy that application using an alpine-docker-container.
As far as I'm aware, compiling means you dynamically link against your system libraries for whatever you need, that system library on any normal distro being glibc.
On alpine however you do not use glibc, you use musl, so dynamically linking against glibc means my application will expect glibc functions with glibc names that do not exist since there are only musl functions.
The big question that arises out of this for me as a python developer that jumped onto nim and knows very little about compilers:
How do I compile, so that I link dynamically against musl?
The folks from nim discord's brought me to the answer. It consists of passing flags to the nim-compiler to swap out the compiler nim normally uses for its generated C-code, in order to use musl-gcc. This can be done by using the --gcc.exe:"musl-gcc" and --gcc.linkerexe:"musl-gcc" flags.
Here an example for Linux:
1. install musl to get access to musl-gcc
download the tar file from the official musl page
Unpack the tar file somewhere
Run bash configure in the unpacked directory. WARNING: Make sure that you do NOT install musl with --prefix being /usr/local, as that may adversely affect your system. Use somewhere else where it is unlikely to override files, e.g. /usr/local/musl. This path will further be referred to as <MUSL_INSTALL_PATH>
Run make && make install in the unpacked directory
Add <MUSL_INSTALL_PATH> to your PATH environment variable
Validate whether you set everything up correctly by opening a new terminal and seeing whether you have access to the musl-gcc command
2. Compile with musl
Create a compile command with --gcc.exe:"musl-gcc" to swap out gcc with musl-gcc and --gcc.linkerexe:"musl-gcc" to swap out the default linker with musl-gcc as well. An example can look like this:
nim c \
--gcc.exe:"musl-gcc" \
--gcc.linkerexe:"musl-gcc" \
--define:release \
--threads:on \
--mm:orc \
--deepcopy:on \
--define:lto \
--outdir:"." \
<PATH_TO_YOUR_MAIN_PROJECT_FILE>.nim
run the command
This should generate a binary that is dynamically linked against musl and thus can run within an alpine docker container.
I am trying to compile a project with a large code base and (possibly) not fully up-to-date CMakeLists.txt. The software has several components. In particular you separately build core of the application and then proceed to build various extensions. The core also uses boost as one of its many dependencies.
I successfully configured and built the core component. I am now building the GUI extension. Configure is successful but make fails whilst linking against boost with the following errors:
/usr/bin/ld: cannot find -lBoost::filesystem
/usr/bin/ld: cannot find -lBoost::system
I can fix this by manually invoking gcc with -lBoost::filesystem replaced by-lboost_filesystem.
Clearly something went wrong with the configuration. When I inspect the variables with ccmake I can confirm that cmake is pointing to the right boost directory. After investigating CMakeLists.txt I found that ${Boost_FILESYSTEM_LIBRARY} is referenced in the core source code, but not in extension e.g.
SET(COMMON_LIBS
Registry
...
${Boost_FILESYSTEM_LIBRARY}
${Boost_SYSTEM_LIBRARY}
)
...
TARGET_LINK_LIBRARIES(Launcher ResourcesManager ${LIBBATCH_LIBRARIES} ${LIBXML2_LIBS} ${Boost_FILESYSTEM_LIBRARY} ${Boost_SYSTEM_LIBRARY})
...
TARGET_LINK_LIBRARIES(SalomeLauncher Launcher ${COMMON_LIBS})
Could you please point me in the right direction? In particular do problem like this indicate issues with Boost, with the application kernel or with application extension? Any hint at this stage would be useful.
Motivation and setup
I am trying to compile SALOME on Arch Linux with cmake version 3.17.1.
I am going to post a less manual solution in case anyone comes across it and cannot fix their CMakeLists.txt. I ended up using sed to automate this build:
cmake \
-DCMAKE_BUILD_TYPE=Release \
...
../ \
&& find -name link.txt -exec sed -i \
-e 's/Boost::filesystem/boost_filesystem/' \
-e 's/Boost::system/boost_system/' {} \; \
&& make -j && make install
This should obviously not be necessary, but if cannot debug your build systems, it should work.
How do I install GCC (the GNU Compiler Collection) piece by piece, using the current version,
using the correct versions of dependencies, not using a package manager (like yum, rpm, apt, dpkg), and not using shared libraries?
Typical developers will likely want to install GCC the typical way, use your package manager (yum, rpm, apt, dpkg, port, brew, etc.) or follow the instructions here (http://gcc.gnu.org/wiki/InstallingGCC).
My question is how to install GCC piece by piece, without shared libraries.
I want a fully-independent GCC that can be moved around my system without using any shared libraries, and without creating any shared libraries.
This is what GCC calls "the difficult way" and it is not recommended for typical users.
GCC depends on:
GMP: GNU Multiple Precision Arithmetic Library
MPFR: GNU Multiple-precision floating-point rounding library
MPC: GNU Multiple-precision C library
ELF: Executable and Linkable Format library
PPL: Parma Polyhedra Library (optional, for memory optimizations)
The Easy Way
If you're a typical developer, you can install the easy way, using instructions at http://gcc.gnu.org/wiki/InstallingGCC or your system package manager such as:
apt install gcc # for Debian, Ubuntu, etc.
yum install gcc # for RedHat, CentOS, etc.
brew install gcc # for Mac OS X
The Hard Way
GCC says the answer here is "the hard way" because it builds everything piece by piece, and does not use shared libraries.
GCC infrastructure
Get the GCC infrastructure:
ftp://gcc.gnu.org/pub/gcc/infrastructure/
Put downloads in a temp directory (you can use whatever directory you want).
/opt/downloads
Build the infrastructure in a temp directory that is different than the downloads directory or its subdirectories:
/tmp/gcc
Configure the infrastructure using static libraries like this:
./configure --disable-shared --enable-static --prefix=/tmp/gcc
The --disable-shared flag may be worth a closer look depending on your needs. I use --disable-shared because I am building static code only, and I want to make sure that I don't build any shared code. My need is to move the resulting GCC around my drives easily, so I want all static code, and I do not want any shared code. If you prefer shared code, omit the --disable-shared flag.
Versions
When you run any of the commands in this answer, be sure to update the commands to use the current GCC version number that matches your needs. The commands in this answer are for GCC 4.6.2.
Note that the GCC documentation says: "While any sufficiently new version of required tools usually work, library requirements are generally stricter. Newer versions may work in some cases, but it's safer to use the exact versions documented."
GMP
GMP is the GNU Multiple Precision Arithmetic Library.
wget ftp://gcc.gnu.org/pub/gcc/infrastructure/gmp-4.3.2.tar.bz2
bunzip2 gmp-4.3.2.tar.bz2
tar xvf gmp-4.3.2.tar
cd gmp-4.3.2
./configure --disable-shared --enable-static --prefix=/tmp/gcc
make && make check && make install
MPFR
MPFR is the GNU Multiple-precision floating-point rounding library. It depends on GMP.
wget ftp://gcc.gnu.org/pub/gcc/infrastructure/mpfr-2.4.2.tar.bz2
bunzip2 mpfr-2.4.2.tar.bz2
tar xvf mpfr-2.4.2.tar
cd mpfr-2.4.2
./configure --disable-shared --enable-static --prefix=/tmp/gcc --with-gmp=/tmp/gcc
make && make check && make install
MPC
MPC is the GNU Multiple-precision C library. It depends on GMP and MPFR.
wget ftp://gcc.gnu.org/pub/gcc/infrastructure/mpc-0.8.1.tar.gz
tar zxvf mpc-0.8.1.tar.gz
cd mpc-0.8.1
./configure --disable-shared --enable-static --prefix=/tmp/gcc --with-gmp=/tmp/gcc --with-mpfr=/tmp/gcc
make && make check && make install
ELF
ELF stands for Executable and Linkable Format. This library provides architecture-independent size and endian support.
wget http://www.mr511.de/software/libelf-0.8.13.tar.gz
tar zxvf libelf-0.8.13.tar.gz
cd libelf-0.8.13
./configure --disable-shared --enable-static --prefix=/tmp/gcc
make && make check && make install
GCC
GCC is the GNU Compiler Collection. It depends on GMP, MPFR, MPC, and ELF.
wget http://www.netgull.com/gcc/releases/gcc-4.6.2/gcc-4.6.2.tar.gz
tar zxvf gcc-4.6.2.tar.gz
Build gcc in a scratch directory on the
same mount point. (Building it within /tmp would trigger cross compile host issues)
mkdir -p /opt/downloads/gcc-4.6.2-scratch
cd /opt/downloads/gcc-4.6.2-scratch
The configure command and its flags must be all on one command line (this post shows them on separate lines just because of web page width).
Note: We use the full path to configure and do not set library path environment variables. We choose to disable bootstrap and disable shared libraries because we don't want them (typical users may want both), and to use posix threads and to flags that are defaults because we want them (typical users may want to use other threads or skip default flags). YMMV and read about the flags here
/opt/downloads/gcc-4.6.2/configure
--disable-shared
--disable-bootstrap
--disable-libstdcxx-pch
--enable-languages=all
--enable-libgomp
--enable-lto
--enable-threads=posix
--enable-tls
--with-gmp=/tmp/gcc
--with-mpfr=/tmp/gcc
--with-mpc=/tmp/gcc
--with-libelf=/tmp/gcc
--with-fpmath=sse
make && make install
This page is great for GCC installation info, how to build it, various flags, and more:
http://www.acsu.buffalo.edu/~charngda/cc_build.html
Updates
The ppl libraries can be used for memory optimizations: see bugseng.com/products/ppl/Download (Thanks Paul in comments)
You could run ./contrib/download_prerequisites from the gcc source directory. (Thanks to N7P on reddit)
The accepted answer makes it far more complicated than necessary and is not correct for all versions. Building GCC with --disable-shared is usually a very bad idea. See http://gcc.gnu.org/wiki/InstallingGCC for an easier approach.
The entire process should be no more difficult than this (replacing 4.6.2 with the version you want to build):
tar xzf gcc-4.6.2.tar.gz
cd gcc-4.6.2
./contrib/download_prerequisites
cd ..
mkdir objdir
cd objdir
$PWD/../gcc-4.6.2/configure --prefix=$HOME/GCC-4.6.2
make
make install
(But please read the link above anyway, it contains useful information.)
Apparently some people on Ubuntu have tons of crap set in their environment which interferes with the GCC build process, and they need to remove that first:
unset LIBRARY_PATH CPATH C_INCLUDE_PATH PKG_CONFIG_PATH CPLUS_INCLUDE_PATH INCLUDE LD_LIBRARY_PATH
I work on a cluster. Only the master node is connected to the Internet. The software on nodes is outdated and generally not maintained. I don't have root access. I have two options:
build static software I need (computational packages); or
build static compilers.
I chose the second and built gcc, g++ and gfortran.
I built everything in
PREFIX=$HOME/cmp/soft/sft
and for make I used
THREADS=8
Below, gcc is built with
GMP
MPFR
MPC
ISL
CLOOG
One can get the latest gcc from here: ftp://gcc.gnu.org/pub/gcc/releases
Dependencies are found here: ftp://gcc.gnu.org/pub/gcc/infrastructure
Dependencies
I get dependencies with the following script:
#!/bin/sh
# ===========
## variables:
GMP=gmp-4.3.2.tar.bz2
MPFR=mpfr-2.4.2.tar.bz2
MPC=mpc-0.8.1.tar.gz
ISL=isl-0.12.2.tar.bz2
CLOOG=cloog-0.18.1.tar.gz
MIRROR=ftp://gcc.gnu.org/pub/gcc/infrastructure
# ===========
## functions:
extract() {
if [ -f $1 ]; then
case $1 in
*.tar.bz2) tar xvjf $1 ;;
*.tar.gz) tar xvzf $1 ;;
*.bz2) bunzip2 $1 ;;
*.rar) unrar x $1 ;;
*.gz) gunzip $1 ;;
*.tar) tar xvf $1 ;;
*.tbz2) tar xvjf $1 ;;
*.tgz) tar xvzf $1 ;;
*.zip) unzip $1 ;;
*.Z) uncompress $1 ;;
*.7z) 7z x $1 ;;
*) echo "I don't know how to extract '$1'..." ;;
esac
else
echo "'$1' is not a valid file!"
fi
}
# ======================
## download and extract:
wget $MIRROR/$GMP
extract $GMP
wget $MIRROR/$MPFR
extract $MPFR
wget $MIRROR/$MPC
extract $MPC
wget $MIRROR/$ISL
extract $ISL
wget $MIRROR/$CLOOG
extract $CLOOG
The following bash function is used below:
mkdircd () { mkdir -p "$#" && eval cd "\"\$$#\""; }
Each of the commands below is to be issued in the dir of the lib just downloaded.
GMP
mkdircd build
../configure --disable-shared --enable-static --prefix=$PREFIX/gmp
make -j $THREADS && make check && make install
MPFR
mkdircd build
../configure --with-gmp=$PREFIX/gmp --disable-shared --enable-static --prefix=$PREFIX/mpfr
make -j $THREADS && make install
MPC
mkdircd build
../configure --with-gmp=$PREFIX/gmp --with-mpfr=$PREFIX/mpfr --disable-shared --enable-static --prefix=$PREFIX/mpc
make -j $THREADS && make install
ISL
mkdircd build
../configure --with-gmp-prefix=$PREFIX/gmp --disable-shared --enable-static --prefix=$PREFIX/isl
make -j $THREADS && make install
CLOOG
mkdircd build
../configure --with-gmp-prefix=$PREFIX/gmp --with-isl-prefix=$PREFIX/isl --disable-shared --enable-static --prefix=$PREFIX/cloog
make -j $THREADS && make install
gcc
mkdircd build
export LD_LIBRARY_PATH=$PREFIX/gmp/lib:$PREFIX/mpfr/lib:$PREFIX/mpc/lib:$PREFIX/isl/lib:$PREFIX/cloog/lib
export C_INCLUDE_PATH=$PREFIX/gmp/include:$PREFIX/mpfr/include:$PREFIX/mpc/include:$PREFIX/isl/include:$PREFIX/cloog/include
export CPLUS_INCLUDE_PATH=$PREFIX/gmp/include:$PREFIX/mpfr/include:$PREFIX/mpc/include:$PREFIX/isl/include:$PREFIX/cloog/include
../configure --with-gmp=$PREFIX/gmp --with-mpfr=$PREFIX/mpfr --with-mpc=$PREFIX/mpc --with-isl=$PREFIX/isl --with-cloog=$PREFIX/cloog --disable-shared --enable-static --disable-multilib --prefix=$PREFIX/gcc --enable-languages=c,c++,fortran
make -j $THREADS bootstrap && make install
Used what Jonathan above has mentioned except that I had to download gmp and mpfr manually and create soft link (gcc 4.4.2 distribution probably does not have "download_prerequisites")
cd src/gcc-4.4.2
ln -s ~/linux64/gmp-4.2.1 gmp
ln -s ~/linux64/mpfr-2.3.0 mpfr
Btw, using "-with-gmp" and "with-mpfr" with "./configure" gave me "configure: error: cannot compute suffix of object files: cannot compile". Hence I downloaded the srcs of gmp and mpfr and then created the soft link to it from within gcc src top leve dir
After trying to install GCC dependencies including GMP, MPFR and MPC. I ran into additional install requirements, Errors and missing files; such as gmp.h header file required by MPFR to install. There are quit a number of issues you will run into in the process. However, There is an Easier way to Build and Install GCC-X.0.0 or later version with an automatic linking.
OPTION ONE.
To save the trouble of Building with make, make install and Linking the dynamic libraries, Simply:
Download your GCC-X.0.0 -version (with latest version from: https://gcc.gnu.org/)
Extract the gcc-X-000.tar.gz files to a location /somepath/.
Once you have Extracted .tar.gz file, run ./contrib/download_prerequisites script which is located on /somepath/ or the source directory.
This script will download support libraries including: GMP, MPFR and MPC and will create a Symlinks for you, that will BUILD all gcc dependencies automatically as part of gcc Installation process.
No need to Build and Link support libraries that were downloaded to /somepath/ by issuing Make, Make Install or running ./configure file or adding links such as --with-gmp=/gmp_path/.../....., --with-mpfr=/mpfr_path/.../... because this was done when you ran script that created symlinks.
OPTION TWO.
Use your OS Package management system to install the support libraries in standard system location. For Debian based system including Ubuntu, Install libgmp-dev, libmpfr-dev and libmpc-dev packages. For RPM based system including Fedora and SUSE, install gmp-devel, and libmpc-devel(mpc-devel on SUSE) packages.
This option will install libraries and header files in a standard system directory where they will be found automically when building GCC.
This is the advantage of OS Package installation Management when you invoke "sudo apt-get install libgmp-dev" or "sudo apt-get install libmpfr-dev" install and linking is done for you. In addition, you don`t have to build the support libraries with Make, Make install or ./configure. Plus, the process takes a few minutes to complete the all process.
Now you can proceed on with GCC Installation.
CONFIGURATION:
This is the GCC config Process, with gcc-X-000.tar.gz
Issue:
tar -xvf gcc-X-000.tar.gz
cd gcc-X-000
./contrib/download_prerequisites
cd ..
mkdir objdir
/../gcc-X-000/configure --prefix=$HOME/gcc-X-000 --enable-languages=c,c++,fortran,go --disable-multilib
make -j 2
make install
NB:
--enable-languages such as c++ or c.
--disable-multilib; disable multilib based on your system and OS, you will be prompted about multilib to proceed.
Make will take long time to complete. However, you can issue the option -j #no_pro. This will run Make concurrently in parallel based on the number of processors on your PC or Mac.
For detailed information on how to execute this process you can visit:
https://gcc.gnu.org/wiki/InstallingGCC.
I followed the top accepted answer by joelparkerhenderson. This is the best answer that I could find for installing on a *NIX system over the internet.
For posterity I want to add that if you get an error like
"install error: cannot compute suffix of object files: cannot compile"
then update your LD_LIBRBARY_PATH with /tmp/gcc/lib (See joelparkerhenderson's full answer for context)
/tmp/gcc/lib contains all the required mpfr/mpc/gmp so files and the run time linker cannt find them unless you add them to LD_LIBRARY_PATH. Also dont forget to export LD_LIBRARY_PATH ;). More context here: https://gcc.gnu.org/wiki/FAQ#configure_suffix
While making a project with Makefile, I get this error:
error: implicit declaration of function ‘fatal’ [-Werror=implicit-function-declaration]
cc1: all warnings being treated as errors
The ./configure --help shows:
Optional Features:
--disable-option-checking ignore unrecognized --enable/--with options
--disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no)
--enable-FEATURE[=ARG] include FEATURE [ARG=yes]
--disable-dependency-tracking speeds up one-time build
--enable-dependency-tracking do not reject slow dependency extractors
--disable-gtktest do not try to compile and run a test GTK+ program
--enable-debug Turn on debugging
How can I tell configure not to include -Werror?
Werror is a GCC argument, and you cannot remove it directly via ./configure. Otherwise, an option like --disable-error would show up in the help text. However, it's possible.
Set an environment variable:
export CFLAGS="-Wno-error"
That's for C compilers. If the project uses C++, do:
export CXXFLAGS="-Wno-error"
In the very rare case the project does not honor this variables, your last resort is to edit the configure.ac file and search for -Werror and remove it from the string it occurs in (be careful though).
It seems like the feature has been in autotools for many years:
./configure --disable-werror
Unfortunately, I wasn't able to get the following specific case to work:
./configure --enable-wno-error=unused-value
Maybe it could work if one escaped the '=' symbol, assuming it's possible. Like skim says, one can still use CFLAGS or CXXFLAGS.
I had to use --disable-Werror (with an uppercase W) on my module. While sudoman's answer above suggests to use --disable-werror (with a lowercase w).
It may look like a typo, but it is actually dependent on your particular configure setup, especially if configure is generated by autoconf. What needs to be passed to the configure script to disable Werror depends on how the build system was setup.
If your project uses the AX_COMPILER_FLAGS option from the autoconf-archive project, then by default -Werror is enabled.
In another module you may find something like this:
+AC_ARG_ENABLE([werror],
+ AC_HELP_STRING([--disable-werror],
+ [do not build with -Werror]),
And thus you would need to use --disable-werror.
This works for me, compiling curlpp on Lubuntu 16.10:
./configure --disable-ewarning
I ran into this problem, and it turned out that GCC was not installed on my freshly-started EC2 instance running Ubuntu 20.04 (Focal Fossa).
Simply running sudo apt install gcc fixed this issue for me.